@depup/typebox 1.1.23-depup.0 → 1.3.9-depup.0

package/build/value/delta/diff.mjs

@@ -37,6 +37,8 @@ function* FromObject(path, left, right) {
     for (const key of rightKeys) {
         if (Guard.HasPropertyKey(left, key))
             continue;
+        if (Guard.IsUnsafePropertyKey(key))
+            continue;
         yield CreateInsert(`${path}/${key}`, right[key]);
     }
     // ----------------------------------------------------------------
@@ -45,6 +47,8 @@ function* FromObject(path, left, right) {
     for (const key of leftKeys) {
         if (!Guard.HasPropertyKey(right, key))
             continue;
+        if (Guard.IsUnsafePropertyKey(key))
+            continue;
         if (Equal(left, right))
             continue;
         yield* FromValue(`${path}/${key}`, left[key], right[key]);
@@ -55,6 +59,8 @@ function* FromObject(path, left, right) {
     for (const key of leftKeys) {
         if (Guard.HasPropertyKey(right, key))
             continue;
+        if (Guard.IsUnsafePropertyKey(key))
+            continue;
         yield CreateDelete(`${path}/${key}`);
     }
 }

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

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

package/build/value/errors/errors.mjs

@@ -4,7 +4,7 @@ import { Errors as SchemaErrors, } from '../../schema/index.mjs';
 /**
  * Performs an exhaustive Check on the specified value and reports any errors found.
  * If no errors are found, an empty array is returned. Unlike Check, this function
- * does not terminate at the first occurance of an error. For best performance, call
+ * does not terminate at the first occurrence of an error. For best performance, call
  * Check first and call Errors only if Check returns false.
  */
 export function Errors(...args) {

package/build/value/index.d.mts

@@ -9,7 +9,6 @@ export * from './errors/index.mjs';
 export * from './default/index.mjs';
 export * from './equal/index.mjs';
 export * from './hash/index.mjs';
-export * from './mutate/index.mjs';
 export * from './parse/index.mjs';
 export * from './delta/index.mjs';
 export * from './pipeline/index.mjs';

package/build/value/index.mjs

@@ -12,7 +12,6 @@ export * from './errors/index.mjs';
 export * from './default/index.mjs';
 export * from './equal/index.mjs';
 export * from './hash/index.mjs';
-export * from './mutate/index.mjs';
 export * from './parse/index.mjs';
 export * from './delta/index.mjs';
 export * from './pipeline/index.mjs';

package/build/value/repair/{from-array.mjs → from_array.mjs}

@@ -4,7 +4,7 @@ import { Guard } from '../../guard/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Create } from '../create/index.mjs';
 import { Hash } from '../hash/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { RepairError } from './error.mjs';
 // ------------------------------------------------------------------
 // MakeUnique

package/build/value/repair/from_enum.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { Evaluate } from '../../type/index.mjs';
+import { FromType } from './from_type.mjs';
+export function FromEnum(context, type, value) {
+    return FromType(context, Evaluate(type), value);
+}

package/build/value/repair/from_intersect.d.mts

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

package/build/value/repair/{from-intersect.mjs → from_intersect.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Instantiate, Evaluate } from '../../type/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromIntersect(context, type, value) {
     const instantiated = Instantiate(context, type);
     const evaluated = Evaluate(instantiated);

package/build/value/repair/{from-object.mjs → from_object.mjs}

@@ -3,7 +3,7 @@ import { Guard } from '../../guard/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Create } from '../create/index.mjs';
 import { IsAdditionalProperties } from '../../schema/types/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromObject(context, type, value) {
     if (Check(context, type, value))
         return value;

package/build/value/repair/{from-record.mjs → from_record.mjs}

@@ -4,7 +4,7 @@ import { RecordValue, RecordPattern } from '../../type/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { Create } from '../create/index.mjs';
 import { Check } from '../check/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromRecord(context, type, value) {
     if (Check(context, type, value))
         return value;

package/build/value/repair/{from-ref.mjs → from_ref.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { RepairError } from './error.mjs';
 export function FromRef(context, type, value) {
     return Guard.HasPropertyKey(context, type.$ref)

package/build/value/{convert/from-template-literal.mjs → repair/from_template_literal.mjs}

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
-import { TemplateLiteralDecode } from '../../type/engine/template-literal/index.mjs';
-import { FromType } from './from-type.mjs';
+import { TemplateLiteralDecode } from '../../type/engine/template_literal/index.mjs';
+import { FromType } from './from_type.mjs';
 export function FromTemplateLiteral(context, type, value) {
     const decoded = TemplateLiteralDecode(type.pattern);
     return FromType(context, decoded, value);

package/build/value/repair/{from-tuple.mjs → from_tuple.mjs}

@@ -2,7 +2,7 @@
 import { Guard } from '../../guard/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Create } from '../create/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 export function FromTuple(context, schema, value) {
     if (Check(context, schema, value))
         return value;

package/build/value/repair/{from-type.mjs → from_type.mjs}

@@ -3,17 +3,16 @@ import { Guard, GlobalsGuard } from '../../guard/index.mjs';
 import * as T from '../../type/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Create } from '../create/index.mjs';
-import { FromArray } from './from-array.mjs';
-import { FromBase } from './from-base.mjs';
-import { FromEnum } from './from-enum.mjs';
-import { FromIntersect } from './from-intersect.mjs';
-import { FromObject } from './from-object.mjs';
-import { FromRecord } from './from-record.mjs';
-import { FromRef } from './from-ref.mjs';
-import { FromTemplateLiteral } from './from-template-literal.mjs';
-import { FromTuple } from './from-tuple.mjs';
-import { FromUnion } from './from-union.mjs';
-import { FromUnknown } from './from-unknown.mjs';
+import { FromArray } from './from_array.mjs';
+import { FromEnum } from './from_enum.mjs';
+import { FromIntersect } from './from_intersect.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromRecord } from './from_record.mjs';
+import { FromRef } from './from_ref.mjs';
+import { FromTemplateLiteral } from './from_template_literal.mjs';
+import { FromTuple } from './from_tuple.mjs';
+import { FromUnion } from './from_union.mjs';
+import { FromUnknown } from './from_unknown.mjs';
 import { RepairError } from './error.mjs';
 // ------------------------------------------------------------------
 // AssertRepairableValue
@@ -33,17 +32,25 @@ function AssertRepairableValue(context, type, value) {
 // AssertRepairableType
 // ------------------------------------------------------------------
 function AssertRepairableType(context, type, value) {
-    const unsupported = T.IsAsyncIterator(type)
-        || T.IsIterator(type)
-        || T.IsConstructor(type)
+    const unsupported = T.IsConstructor(type)
         || T.IsFunction(type)
-        || T.IsNever(type)
-        || T.IsPromise(type);
+        || T.IsNever(type);
     if (unsupported) {
         throw new RepairError(context, type, value, 'Type is not repairable');
     }
 }
 // ------------------------------------------------------------------
+// CreateWhenUndefined
+//
+// If the value is 'undefined' AND the type is not TUndefined, then 
+// we know the value must be created. We handle this case for undefined 
+// only as it enables 'default' annotation to be initialized via Create 
+// before we applying subsequent Repair logic.
+// ------------------------------------------------------------------
+function CreateWhenUndefined(context, type, value) {
+    return (Guard.IsUndefined(value) && !T.IsUndefined(type)) ? Create(context, type) : value;
+}
+// ------------------------------------------------------------------
 // FinalizeRepair
 //
 // When a type includes the ~refine modifier, a post-repair validation
@@ -64,23 +71,18 @@ function FinalizeRepair(context, type, repaired) {
 // FromType
 // ------------------------------------------------------------------
 export function FromType(context, type, value) {
-    // Base Repair
-    if (T.IsBase(type)) {
-        const repaired = FromBase(context, type, value);
-        return FinalizeRepair(context, type, repaired);
-    }
-    // Schema Repair
     AssertRepairableValue(context, type, value);
     AssertRepairableType(context, type, value);
-    const repaired = (T.IsArray(type) ? FromArray(context, type, value) :
-        T.IsEnum(type) ? FromEnum(context, type, value) :
-            T.IsIntersect(type) ? FromIntersect(context, type, value) :
-                T.IsObject(type) ? FromObject(context, type, value) :
-                    T.IsRecord(type) ? FromRecord(context, type, value) :
-                        T.IsRef(type) ? FromRef(context, type, value) :
-                            T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, value) :
-                                T.IsTuple(type) ? FromTuple(context, type, value) :
-                                    T.IsUnion(type) ? FromUnion(context, type, value) :
-                                        FromUnknown(context, type, value));
+    const candidate = CreateWhenUndefined(context, type, value);
+    const repaired = (T.IsArray(type) ? FromArray(context, type, candidate) :
+        T.IsEnum(type) ? FromEnum(context, type, candidate) :
+            T.IsIntersect(type) ? FromIntersect(context, type, candidate) :
+                T.IsObject(type) ? FromObject(context, type, candidate) :
+                    T.IsRecord(type) ? FromRecord(context, type, candidate) :
+                        T.IsRef(type) ? FromRef(context, type, candidate) :
+                            T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, candidate) :
+                                T.IsTuple(type) ? FromTuple(context, type, candidate) :
+                                    T.IsUnion(type) ? FromUnion(context, type, candidate) :
+                                        FromUnknown(context, type, candidate));
     return FinalizeRepair(context, type, repaired);
 }

package/build/value/{clean/from-union.d.mts → repair/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/repair/{from-union.mjs → from_union.mjs}

@@ -5,8 +5,8 @@ import { Flatten } from '../../type/engine/evaluate/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { Create } from '../create/index.mjs';
-import { FromType } from './from-type.mjs';
-import { UnionScoreSelect } from '../shared/union-score-select.mjs';
+import { FromType } from './from_type.mjs';
+import { UnionScoreSelect } from '../shared/union_score_select.mjs';
 // ------------------------------------------------------------------
 // RepairUnion
 // ------------------------------------------------------------------

package/build/value/repair/repair.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Arguments } from '../../system/arguments/index.mjs';
-import { FromType } from './from-type.mjs';
+import { FromType } from './from_type.mjs';
 import { Assert } from '../assert/index.mjs';
 /**
  * Repairs a value to match the provided type. This function is intended for data migration

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

@@ -1,3 +1,3 @@
-export * from './optional-undefined.mjs';
-export * from './union-priority-sort.mjs';
-export * from './union-score-select.mjs';
+export * from './optional_undefined.mjs';
+export * from './union_priority_sort.mjs';
+export * from './union_score_select.mjs';

package/build/value/shared/index.mjs

@@ -1,4 +1,4 @@
 // deno-fmt-ignore-file
-export * from './optional-undefined.mjs';
-export * from './union-priority-sort.mjs';
-export * from './union-score-select.mjs';
+export * from './optional_undefined.mjs';
+export * from './union_priority_sort.mjs';
+export * from './union_score_select.mjs';

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

@@ -0,0 +1,7 @@
+import { type TSchema } from '../../type/index.mjs';
+/**
+ * (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

@@ -0,0 +1,72 @@
+// deno-fmt-ignore-file
+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';
+// ------------------------------------------------------------------
+// Modifiers (Mutable)
+//
+// 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 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
+// ------------------------------------------------------------------
+/**
+ * (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/build/value/value.d.mts

@@ -9,7 +9,6 @@ export { Default } from './default/index.mjs';
 export { Equal } from './equal/index.mjs';
 export { Errors } from './errors/index.mjs';
 export { Hash } from './hash/index.mjs';
-export { Mutate, type TMutable } from './mutate/index.mjs';
 export { Parse } from './parse/index.mjs';
 export { Diff, Patch } from './delta/index.mjs';
 export { Pointer } from './pointer/index.mjs';

package/build/value/value.mjs

@@ -9,7 +9,6 @@ export { Default } from './default/index.mjs';
 export { Equal } from './equal/index.mjs';
 export { Errors } from './errors/index.mjs';
 export { Hash } from './hash/index.mjs';
-export { Mutate } from './mutate/index.mjs';
 export { Parse } from './parse/index.mjs';
 export { Diff, Patch } from './delta/index.mjs';
 export { Pointer } from './pointer/index.mjs';

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-04-09T16:37:16.569Z",
+  "timestamp": "2026-08-02T00:59:01.706Z",
   "totalUpdated": 0
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@depup/typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript (with updated dependencies)",
-  "version": "1.1.23-depup.0",
+  "version": "1.3.9-depup.0",
   "keywords": [
     "typebox",
     "depup",
@@ -22,22 +22,18 @@
   "types": "./build/index.d.mts",
   "module": "./build/index.mjs",
   "exports": {
-    "./system": {
-      "import": "./build/system/index.mjs",
-      "default": "./build/system/index.mjs"
-    },
     "./compile": {
       "import": "./build/compile/index.mjs",
       "default": "./build/compile/index.mjs"
     },
-    "./value": {
-      "import": "./build/value/index.mjs",
-      "default": "./build/value/index.mjs"
-    },
     "./error": {
       "import": "./build/error/index.mjs",
       "default": "./build/error/index.mjs"
     },
+    "./format": {
+      "import": "./build/format/index.mjs",
+      "default": "./build/format/index.mjs"
+    },
     "./guard": {
       "import": "./build/guard/index.mjs",
       "default": "./build/guard/index.mjs"
@@ -46,14 +42,18 @@
       "import": "./build/schema/index.mjs",
       "default": "./build/schema/index.mjs"
     },
-    "./format": {
-      "import": "./build/format/index.mjs",
-      "default": "./build/format/index.mjs"
+    "./system": {
+      "import": "./build/system/index.mjs",
+      "default": "./build/system/index.mjs"
     },
     "./type": {
       "import": "./build/type/index.mjs",
       "default": "./build/type/index.mjs"
     },
+    "./value": {
+      "import": "./build/value/index.mjs",
+      "default": "./build/value/index.mjs"
+    },
     ".": {
       "import": "./build/index.mjs",
       "default": "./build/index.mjs"
@@ -61,30 +61,30 @@
   },
   "typesVersions": {
     "*": {
-      "system": [
-        "./build/system/index.d.mts"
-      ],
       "compile": [
         "./build/compile/index.d.mts"
       ],
-      "value": [
-        "./build/value/index.d.mts"
-      ],
       "error": [
         "./build/error/index.d.mts"
       ],
+      "format": [
+        "./build/format/index.d.mts"
+      ],
       "guard": [
         "./build/guard/index.d.mts"
       ],
       "schema": [
         "./build/schema/index.d.mts"
       ],
-      "format": [
-        "./build/format/index.d.mts"
+      "system": [
+        "./build/system/index.d.mts"
       ],
       "type": [
         "./build/type/index.d.mts"
       ],
+      "value": [
+        "./build/value/index.d.mts"
+      ],
       ".": [
         "./build/index.d.mts"
       ]
@@ -94,8 +94,8 @@
     "changes": {},
     "depsUpdated": 0,
     "originalPackage": "typebox",
-    "originalVersion": "1.1.23",
-    "processedAt": "2026-04-09T16:37:17.382Z",
+    "originalVersion": "1.3.9",
+    "processedAt": "2026-08-02T00:59:02.398Z",
     "smokeTest": "passed"
   }
 }