typebox 1.2.14 → 1.2.16

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

@@ -3,6 +3,7 @@ export interface TSettings {
      * Determines whether types should be instantiated as immutable using `Object.freeze(...)`.
      * This helps prevent unintended schema mutation. Enabling this option introduces a slight
      * performance overhead during instantiation.
+     *
      * @default false
      */
     immutableTypes: boolean;
@@ -11,6 +12,7 @@ export interface TSettings {
      * performs exhaustive checks to gather diagnostics for invalid values, which can result in
      * excessive buffering for large or complex types. This setting limits the number of buffered
      * errors and acts as a safeguard against potential denial-of-service (DoS) attacks.
+     *
      * @default 8
      */
     maxErrors: number;
@@ -20,6 +22,7 @@ export interface TSettings {
      * generated code. If evaluation is not permitted, it falls back to dynamic checking. Setting
      * this to `false` disables evaluation entirely, which may be desirable in applications that
      * restrict runtime code evaluation, regardless of Content Security Policy (CSP).
+     *
      * @default true
      */
     useAcceleration: boolean;
@@ -30,11 +33,13 @@ export interface TSettings {
      * TypeScript semantics to remain consistent with the language. This option is provided to align
      * runtime check semantics with projects that configure 'exactOptionalPropertyTypes: true' in
      * tsconfig.json.
+     *
      * @default false
      */
     exactOptionalPropertyTypes: boolean;
     /**
      * Controls whether internal compositor properties (`~kind`, `~readonly`, `~optional`) are enumerable.
+     *
      * @default false
      */
     enumerableKind: boolean;
@@ -44,9 +49,19 @@ export interface TSettings {
      * the value, followed by a subsequent `Assert`. Enabling this option may incur significant performance
      * overhead for invalid values. It is recommended to keep this disabled in performance-sensitive
      * applications.
+     *
      * @default false
      */
     correctiveParse: boolean;
+    /**
+     * Controls whether TypeBox sorts Union variants by specificity (narrowest first) for operations
+     * that require deterministic value matching, such as Clean, Decode, and Encode. When enabled,
+     * more specific types (e.g. Literal) always take precedence over broader types (e.g. String),
+     * regardless of the order variants are declared.
+     *
+     * @default true
+     */
+    unionPrioritySort: boolean;
 }
 /** Resets system settings to defaults */
 export declare function Reset(): void;

package/build/system/settings/settings.mjs

@@ -6,7 +6,8 @@ const settings = {
     useAcceleration: true,
     exactOptionalPropertyTypes: false,
     enumerableKind: false,
-    correctiveParse: false
+    correctiveParse: false,
+    unionPrioritySort: true
 };
 /** Resets system settings to defaults */
 export function Reset() {
@@ -16,6 +17,7 @@ export function Reset() {
     settings.exactOptionalPropertyTypes = false;
     settings.enumerableKind = false;
     settings.correctiveParse = false;
+    settings.unionPrioritySort = true;
 }
 /** Sets system settings */
 export function Set(options) {

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

@@ -2,7 +2,6 @@ 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 TUnion } from '../../types/union.mjs';
 import { type TCompare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare.mjs';
 import { type TFlatten } from './flatten.mjs';
 import { type TEvaluateType } from './evaluate.mjs';
@@ -10,7 +9,7 @@ type TBroadFilter<Type extends TSchema, Types extends TSchema[], Result extends
 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);
-export type TBroaden<Types extends TSchema[], Broadened extends TSchema[] = TBroadenTypes<Types>, Flattened extends TSchema[] = TFlatten<Broadened>, Result extends TSchema = (Flattened extends [] ? TNever : Flattened extends [infer Type extends TSchema] ? Type : TUnion<Flattened>)> = 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>;
 export {};

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

@@ -1,9 +1,8 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { IsAny } from '../../types/any.mjs';
-import { Never, IsNever } from '../../types/never.mjs';
+import { IsNever } from '../../types/never.mjs';
 import { IsObject } from '../../types/object.mjs';
-import { Union } from '../../types/union.mjs';
 import { Compare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare.mjs';
 import { Flatten } from './flatten.mjs';
 import { EvaluateType } from './evaluate.mjs';
@@ -40,8 +39,5 @@ function BroadenTypes(types) {
 export function Broaden(types) {
     const broadened = BroadenTypes(types);
     const flattened = Flatten(broadened);
-    const result = (flattened.length === 0 ? Never() :
-        flattened.length === 1 ? flattened[0] :
-            Union(flattened));
-    return result;
+    return flattened;
 }

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

@@ -14,11 +14,11 @@ export type TEvaluateDependent<If extends TSchema, Then extends TSchema, Else ex
 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>, Result extends TSchema = TBroaden<Distribution>> = Result;
+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 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>;
-export type TEvaluateUnion<Types extends TSchema[], Result extends TSchema = TBroaden<Types>> = Result;
+export type TEvaluateUnion<Types extends TSchema[], Broadend extends TSchema[] = TBroaden<Types>, Result extends TSchema = TEvaluateUnionFast<Broadend>> = Result;
 export declare function EvaluateUnion<Types extends TSchema[]>(types: [...Types]): TEvaluateUnion<Types>;
 export type TEvaluateType<Type extends TSchema, Result extends TSchema = (Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TEvaluateDependent<If, Then, Else> : Type extends TEnum<infer Values extends TEnumValue[]> ? TEvaluateEnum<Values> : Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type extends TTemplateLiteral<infer Pattern extends string> ? TEvaluateTemplateLiteral<Pattern> : Type extends TUnion<infer Types extends TSchema[]> ? TEvaluateUnion<Types> : Type)> = Result;
 export declare function EvaluateType<Type extends TSchema>(type: Type): TEvaluateType<Type>;

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

@@ -23,7 +23,8 @@ export function EvaluateEnum(values) {
 }
 export function EvaluateIntersect(types) {
     const distribution = Distribute(types);
-    const result = Broaden(distribution);
+    const broadend = Broaden(distribution);
+    const result = EvaluateUnionFast(broadend);
     return result;
 }
 export function EvaluateTemplateLiteral(pattern) {
@@ -32,7 +33,8 @@ export function EvaluateTemplateLiteral(pattern) {
     return result;
 }
 export function EvaluateUnion(types) {
-    const result = Broaden(types);
+    const broadend = Broaden(types);
+    const result = EvaluateUnionFast(broadend);
     return result;
 }
 export function EvaluateType(type) {

package/build/type/engine/index.d.mts

@@ -22,6 +22,7 @@ export * from './parameters/index.mjs';
 export * from './patterns/index.mjs';
 export * from './partial/index.mjs';
 export * from './pick/index.mjs';
+export * from './priority/index.mjs';
 export * from './readonly_object/index.mjs';
 export * from './record/index.mjs';
 export * from './ref/index.mjs';

package/build/type/engine/index.mjs

@@ -28,6 +28,7 @@ export * from './parameters/index.mjs';
 export * from './patterns/index.mjs';
 export * from './partial/index.mjs';
 export * from './pick/index.mjs';
+export * from './priority/index.mjs';
 export * from './readonly_object/index.mjs';
 export * from './record/index.mjs';
 export * from './ref/index.mjs';

package/build/type/engine/priority/index.d.mts

@@ -0,0 +1 @@
+export * from './priority.mjs';

package/build/type/engine/priority/index.mjs

@@ -0,0 +1 @@
+export * from './priority.mjs';

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

@@ -0,0 +1,20 @@
+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;
+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);
+/**
+ * Priority sorts types in sequence of narrowest to broadest using a Drop Sort algorithm.
+ * This function is typically used to sequence types for union variant checks to ensure
+ * that values are checked against the most narrow types before the broadest, which in
+ * turn helps ensure order-independent checking.
+ */
+export type TPriority<Types extends TSchema[], Result extends TSchema[] = TSort<Types>> = Result;
+/**
+ * Priority sorts types in sequence of narrowest to broadest using a Drop Sort algorithm.
+ * This function is typically used to sequence types for union variant checks to ensure
+ * that values are checked against the most narrow types before the broadest, which in
+ * turn helps ensure order-independent checking.
+ */
+export declare function Priority<Types extends TSchema[]>(types: [...Types]): TPriority<Types>;
+export {};

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

@@ -0,0 +1,28 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { Compare } 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 :
+            0);
+    return result;
+}
+function Insert(type, types, result = []) {
+    return Guard.ShiftLeft(types, (left, right) => Guard.IsEqual(Comparer(type, left), 1)
+        ? Insert(type, right, [...result, left])
+        : [...result, type, ...types], () => [...result, type]);
+}
+function Sort(types, result = []) {
+    return Guard.ShiftLeft(types, (left, right) => Sort(right, Insert(left, result)), () => result);
+}
+/**
+ * Priority sorts types in sequence of narrowest to broadest using a Drop Sort algorithm.
+ * This function is typically used to sequence types for union variant checks to ensure
+ * that values are checked against the most narrow types before the broadest, which in
+ * turn helps ensure order-independent checking.
+ */
+export function Priority(types) {
+    const result = Sort(types);
+    return result;
+}

package/build/type/types/record.d.mts

@@ -30,7 +30,7 @@ export declare function RecordDeferred<Key extends TSchema, Value extends TSchem
 /** Creates a Record type. */
 export declare function Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordAction<Key, Value>;
 /** Creates a Record type from regular expression pattern. */
-export declare function RecordFromPattern<Pattern extends string, Value extends TSchema>(key: Pattern, value: Value): TRecord<Pattern, Value>;
+export declare function RecordFromPattern<Pattern extends string, Value extends TSchema>(pattern: Pattern, value: Value): TRecord<Pattern, Value>;
 /** Transforms a Record Pattern to a Type */
 export type TRecordPatternToType<Pattern extends string, Result extends TSchema = (Pattern extends typeof StringKey ? TString : Pattern extends typeof IntegerKey ? TInteger : Pattern extends typeof NumberKey ? TNumber : TTemplateLiteralDecodeUnsafe<Pattern>)> = Result;
 /** Transforms a Record Pattern to a Type */

package/build/type/types/record.mjs

@@ -24,11 +24,11 @@ export function Record(key, value, options = {}) {
     return RecordAction(key, value, options);
 }
 // -------------------------------------------------------------------
-// FromPattern
+// RecordFromPattern
 // -------------------------------------------------------------------
 /** Creates a Record type from regular expression pattern. */
-export function RecordFromPattern(key, value) {
-    return CreateRecord(key, value);
+export function RecordFromPattern(pattern, value) {
+    return CreateRecord(pattern, value);
 }
 /** Transforms a Record Pattern to a Type */
 export function RecordPatternToType(pattern) {

package/build/value/clean/clean.mjs

@@ -1,5 +1,6 @@
-import { Arguments } from '../../system/arguments/index.mjs';
+import { Arguments, Settings } from '../../system/index.mjs';
 import { FromType } from './from_type.mjs';
+import { UnionPrioritySort } from '../shared/union_priority_sort.mjs';
 /**
  * Cleans a value by removing non-evaluated properties and elements as derived from the provided type.
  * This function returns unknown so callers should Check the return value before use. This function
@@ -11,5 +12,6 @@ export function Clean(...args) {
         3: (context, type, value) => [context, type, value],
         2: (type, value) => [{}, type, value]
     });
-    return FromType(context, type, value);
+    const sorted = Settings.Get().unionPrioritySort ? UnionPrioritySort(type) : type;
+    return FromType(context, sorted, value);
 }

package/build/value/clean/from_union.d.mts

@@ -1,2 +1,2 @@
-import type { TProperties, TUnion } from '../../type/index.mjs';
+import { type TProperties, type TUnion } from '../../type/index.mjs';
 export declare function FromUnion(context: TProperties, type: TUnion, value: unknown): unknown;

package/build/value/clean/from_union.mjs

@@ -2,9 +2,8 @@
 import { Check } from '../check/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { FromType } from './from_type.mjs';
-import { UnionPrioritySort } from '../shared/union_priority_sort.mjs';
 export function FromUnion(context, type, value) {
-    for (const schema of UnionPrioritySort(type.anyOf)) {
+    for (const schema of type.anyOf) {
         const clean = FromType(context, schema, Clone(value));
         if (Check(context, schema, clean))
             return clean;

package/build/value/codec/decode.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { Arguments } from '../../system/arguments/index.mjs';
+import { Arguments, Settings } from '../../system/index.mjs';
 import { AssertError } from '../assert/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Errors } from '../errors/index.mjs';
@@ -9,6 +9,7 @@ import { Convert } from '../convert/index.mjs';
 import { Default } from '../default/index.mjs';
 import { Pipeline } from '../pipeline/index.mjs';
 import { FromType } from './from_type.mjs';
+import { UnionPrioritySort } from '../shared/union_priority_sort.mjs';
 // ------------------------------------------------------------------
 // Assert
 // ------------------------------------------------------------------
@@ -27,7 +28,8 @@ function Assert(context, type, value) {
 // ------------------------------------------------------------------
 /** Executes Decode callbacks only */
 export function DecodeUnsafe(context, type, value) {
-    return FromType('Decode', context, type, value);
+    const sorted = Settings.Get().unionPrioritySort ? UnionPrioritySort(type) : type;
+    return FromType('Decode', context, sorted, value);
 }
 // ------------------------------------------------------------------
 // Decoder

package/build/value/codec/encode.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { Arguments } from '../../system/arguments/index.mjs';
+import { Arguments, Settings } from '../../system/index.mjs';
 import { AssertError } from '../assert/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Errors } from '../errors/index.mjs';
@@ -9,6 +9,7 @@ import { Convert } from '../convert/index.mjs';
 import { Default } from '../default/index.mjs';
 import { Pipeline } from '../pipeline/index.mjs';
 import { FromType } from './from_type.mjs';
+import { UnionPrioritySort } from '../shared/union_priority_sort.mjs';
 // ------------------------------------------------------------------
 // Assert
 // ------------------------------------------------------------------
@@ -27,7 +28,8 @@ function Assert(context, type, value) {
 // ------------------------------------------------------------------
 /** Executes Encode callbacks only */
 export function EncodeUnsafe(context, type, value) {
-    return FromType('Encode', context, type, value);
+    const sorted = Settings.Get().unionPrioritySort ? UnionPrioritySort(type) : type;
+    return FromType('Encode', context, sorted, value);
 }
 // ------------------------------------------------------------------
 // Encoder

package/build/value/codec/from_array.mjs

@@ -1,5 +1,4 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { FromType } from './from_type.mjs';
 import { Callback } from './callback.mjs';
@@ -7,10 +6,8 @@ import { Callback } from './callback.mjs';
 // Decode
 // ------------------------------------------------------------------
 function Decode(direction, context, type, value) {
-    // deno-coverage-ignore-start - unreachable | checked
     if (!Guard.IsArray(value))
-        return Unreachable();
-    // deno-coverage-ignore-stop
+        return value;
     for (let i = 0; i < value.length; i++) {
         value[i] = FromType(direction, context, type.items, value[i]);
     }

package/build/value/codec/from_object.mjs

@@ -1,5 +1,4 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { FromType } from './from_type.mjs';
 import { Callback } from './callback.mjs';
@@ -8,10 +7,8 @@ import { IsOptionalUndefined } from '../shared/optional_undefined.mjs';
 // Decode
 // ------------------------------------------------------------------
 function Decode(direction, context, type, value) {
-    // deno-coverage-ignore-start - unreachable | checked
     if (!Guard.IsObjectNotArray(value))
-        return Unreachable();
-    // deno-coverage-ignore-stop
+        return value;
     for (const key of Guard.Keys(type.properties)) {
         // Ignore for non-present or optional-undefined
         if (!Guard.HasPropertyKey(value, key) || IsOptionalUndefined(type.properties[key], key, value))

package/build/value/codec/from_record.mjs

@@ -1,5 +1,4 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { RecordPattern, RecordValue } from '../../type/index.mjs';
 import { FromType } from './from_type.mjs';
@@ -8,16 +7,12 @@ import { Callback } from './callback.mjs';
 // Decode
 // ------------------------------------------------------------------
 function Decode(direction, context, type, value) {
-    // deno-coverage-ignore-start - unreachable | checked
     if (!Guard.IsObjectNotArray(value))
-        return Unreachable();
-    // deno-coverage-ignore-stop
+        return value;
     const regexp = new RegExp(RecordPattern(type));
     for (const key of Guard.Keys(value)) {
-        // deno-coverage-ignore-start - unreachable | checked
         if (!regexp.test(key))
-            Unreachable();
-        // deno-coverage-ignore-stop
+            continue;
         value[key] = FromType(direction, context, RecordValue(type), value[key]);
     }
     return Callback(direction, context, type, value);

package/build/value/codec/from_tuple.mjs

@@ -1,5 +1,4 @@
 // deno-fmt-ignore-file
-import { Unreachable } from '../../system/unreachable/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { FromType } from './from_type.mjs';
 import { Callback } from './callback.mjs';
@@ -7,10 +6,8 @@ import { Callback } from './callback.mjs';
 // Decode
 // ------------------------------------------------------------------
 function Decode(direction, context, type, value) {
-    // deno-coverage-ignore-start - unreachable | checked
     if (!Guard.IsArray(value))
-        return Unreachable();
-    // deno-coverage-ignore-stop
+        return value;
     for (let i = 0; i < Math.min(type.items.length, value.length); i++) {
         value[i] = FromType(direction, context, type.items[i], value[i]);
     }

package/build/value/codec/from_union.mjs

@@ -4,12 +4,11 @@ import { Callback } from './callback.mjs';
 import { FromType } from './from_type.mjs';
 import { Clone } from '../clone/index.mjs';
 import { Check } from '../check/index.mjs';
-import { UnionPrioritySort } from '../shared/union_priority_sort.mjs';
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
 function Decode(direction, context, type, value) {
-    for (const schema of UnionPrioritySort(type.anyOf, 1)) {
+    for (const schema of type.anyOf) {
         if (!Check(context, schema, value))
             continue;
         const variant = FromType(direction, context, schema, value);
@@ -22,7 +21,7 @@ function Decode(direction, context, type, value) {
 // ------------------------------------------------------------------
 function Encode(direction, context, type, value) {
     const exterior = Callback(direction, context, type, value);
-    for (const schema of UnionPrioritySort(type.anyOf, -1)) {
+    for (const schema of type.anyOf) {
         const variant = FromType(direction, context, schema, Clone(exterior));
         if (!Check(context, schema, variant))
             continue;

package/build/value/shared/union_priority_sort.d.mts

@@ -1,3 +1,7 @@
 import { type TSchema } from '../../type/index.mjs';
-/** Deterministically sorts schemas by structural relationship (narrow to broad) */
-export declare function UnionPrioritySort(types: TSchema[], order?: number): TSchema[];
+/**
+ * (Type-Preprocessor) Recursively reorders Union variants from narrowest to broadest, ensuring
+ * more specific types (e.g. Literal) are evaluated before broader types (e.g. String). Used
+ * prior to Clean, Decode, and Encode operations.
+ */
+export declare function UnionPrioritySort(type: TSchema): TSchema;

package/build/value/shared/union_priority_sort.mjs

@@ -1,36 +1,72 @@
 // deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Compare } from '../../type/index.mjs';
+import Guard from '../../guard/index.mjs';
+import { IsArray, Array as _Array_, ArrayOptions } from '../../type/index.mjs';
+import { IsUnion, Union } from '../../type/index.mjs';
+import { IsObject, Object as _Object_ } from '../../type/index.mjs';
+import { IsRecord, Record, RecordKey, RecordValue } from '../../type/index.mjs';
+import { IsTuple, Tuple } from '../../type/index.mjs';
+import { IsIntersect, Intersect } from '../../type/index.mjs';
+import { Priority } from '../../type/index.mjs';
 // ------------------------------------------------------------------
-// DeterministicCompare
+// Modifiers (Mutable)
 //
-// Provides a deterministic tie-break for schemas. This is used when
-// schemas are structurally disjoint or mutually inclusive. While
-// JSON serialization incurs a performance overhead, it serves as a
-// reliable mechanism to ensure stable ordering and preserves the
-// alphabetical alignment of named constants.
+// Prioritized types lose `~modifier` properties and additional constraints
+// (e.g. additionalProperties) during the mapping phase and need to be
+// reassigned afterward. This is a fast mutable assignment to handle that,
+// but we should consider a more general solution. (review)
 //
 // ------------------------------------------------------------------
-function DeterministicCompare(left, right) {
-    return JSON.stringify(left).localeCompare(JSON.stringify(right));
+function Modifiers(type, next) {
+    for (const key of Guard.Keys(type)) {
+        if (Guard.HasPropertyKey(next, key))
+            continue;
+        next[key] = type[key];
+    }
+    return next;
+}
+// ------------------------------------------------------------------
+// Properties
+// ------------------------------------------------------------------
+function FromProperties(properties) {
+    const result = {};
+    for (const key of Guard.Keys(properties))
+        result[key] = FromType(properties[key]);
+    return result;
+}
+// ------------------------------------------------------------------
+// PriorityTypes
+// ------------------------------------------------------------------
+function FromPriorityTypes(types) {
+    return FromTypes(Priority(types));
+}
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+function FromTypes(types) {
+    return types.map(type => FromType(type));
+}
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+function FromType(type) {
+    const next = (IsArray(type) ? _Array_(FromType(type.items), ArrayOptions(type)) :
+        IsIntersect(type) ? Intersect(FromTypes(type.allOf)) :
+            IsUnion(type) ? Union(FromPriorityTypes(type.anyOf)) :
+                IsObject(type) ? _Object_(FromProperties(type.properties)) :
+                    IsRecord(type) ? Record(RecordKey(type), FromType(RecordValue(type))) :
+                        IsTuple(type) ? Tuple(FromTypes(type.items)) :
+                            type);
+    return Modifiers(type, next);
 }
 // ------------------------------------------------------------------
 // UnionPrioritySort
-//
-// Performs a deterministic sort on Union members. By default, this
-// function ensures that narrow (more specific) types precede broader
-// types in the resulting array. The order can be reversed by setting
-// the order property to -1 which will reverse unions from broader
-// to more narrow.
-//
 // ------------------------------------------------------------------
-/** Deterministically sorts schemas by structural relationship (narrow to broad) */
-export function UnionPrioritySort(types, order = 1) {
-    return [...types].sort((left, right) => {
-        const result = Compare(left, right);
-        return (Guard.IsEqual(result, 'disjoint') ? DeterministicCompare(left, right) :
-            Guard.IsEqual(result, 'right-inside') ? 1 :
-                Guard.IsEqual(result, 'left-inside') ? -1 :
-                    DeterministicCompare(left, right)) * order;
-    });
+/**
+ * (Type-Preprocessor) Recursively reorders Union variants from narrowest to broadest, ensuring
+ * more specific types (e.g. Literal) are evaluated before broader types (e.g. String). Used
+ * prior to Clean, Decode, and Encode operations.
+ */
+export function UnionPrioritySort(type) {
+    const result = FromType(type);
+    return result;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.2.14",
+  "version": "1.2.16",
   "keywords": [
     "typescript",
     "jsonschema"