@openclaw/imessage 2026.10.10 → 2026.11.5-beta.1

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

@@ -0,0 +1,30 @@
+// deno-lint-ignore-file no-explicit-any
+import { Guard } from '../../guard/index.mjs';
+import { Settings } from '../settings/index.mjs';
+import { Keys } from './keys.mjs';
+// ------------------------------------------------------------------
+// Freeze
+// ------------------------------------------------------------------
+function Freeze(value, seen) {
+    if (seen.has(value))
+        return;
+    seen.add(value);
+    for (const key of Keys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !('value' in descriptor))
+            continue;
+        if (Guard.IsObject(descriptor.value))
+            Freeze(descriptor.value, seen);
+    }
+    Object.freeze(value);
+}
+// ------------------------------------------------------------------
+// Finalize
+// ------------------------------------------------------------------
+/** Finalizes a type. Will recursively freeze if `immutableTypes` is true, otherwise no action. */
+export function Finalize(value) {
+    if (!Settings.Get().immutableTypes)
+        return value;
+    Freeze(value, new WeakSet());
+    return value;
+}

package/node_modules/typebox/build/system/memory/keys.d.mts

@@ -0,0 +1,2 @@
+/** Returns the own string and symbol keys of the given object. */
+export declare function Keys(value: Record<PropertyKey, unknown>): PropertyKey[];

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

@@ -0,0 +1,8 @@
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Keys (alternatively, Reflect.ownKeys(...))
+// ------------------------------------------------------------------
+/** Returns the own string and symbol keys of the given object. */
+export function Keys(value) {
+    return [...Guard.Keys(value), ...Guard.Symbols(value)];
+}

package/node_modules/typebox/build/system/memory/update.d.mts

@@ -1,7 +1,4 @@
 type ObjectLike = Record<PropertyKey, any>;
-/**
- * Updates a value with new properties while preserving property enumerability. Use this function to modify
- * existing types without altering their configuration.
- */
+/** Updates an existing type with additional hidden and enumerable properties while preserving property configuration. */
 export declare function Update(current: ObjectLike, hidden: ObjectLike, enumerable: ObjectLike): ObjectLike;
 export {};

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

@@ -1,27 +1,43 @@
 // deno-lint-ignore-file no-explicit-any
+import { Guard } from '../../guard/index.mjs';
 import { Settings } from '../settings/index.mjs';
 import { Metrics } from './metrics.mjs';
-import { Freeze } from './freeze.mjs';
-import { Clone } from './clone.mjs';
-/**
- * Updates a value with new properties while preserving property enumerability. Use this function to modify
- * existing types without altering their configuration.
- */
-export function Update(current, hidden, enumerable) {
-    Metrics.update += 1;
-    const settings = Settings.Get();
-    const result = Clone(current);
-    // hidden
-    for (const key of Object.keys(hidden)) {
+import { Finalize } from './finalize.mjs';
+import { Keys } from './keys.mjs';
+// ------------------------------------------------------------------
+// WithCurrent
+// ------------------------------------------------------------------
+function WithCurrent(current, hiddenKeys, enumerableKeys, result) {
+    for (const key of Keys(current)) {
+        if (Guard.IsUnsafePropertyKey(key) || hiddenKeys.includes(key) || enumerableKeys.includes(key))
+            continue; // (ignore: prototype-pollution)
+        const descriptor = Object.getOwnPropertyDescriptor(current, key); // safe-name!
+        Object.defineProperty(result, key, descriptor);
+    }
+}
+// ------------------------------------------------------------------
+// WithHidden
+// ------------------------------------------------------------------
+function WithHidden(hidden, keys, result) {
+    const enumerableKind = Settings.Get().enumerableKind;
+    for (const key of keys) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
         Object.defineProperty(result, key, {
             configurable: true,
             writable: true,
-            enumerable: settings.enumerableKind,
+            enumerable: enumerableKind,
             value: hidden[key]
         });
     }
-    // enumerable
-    for (const key of Object.keys(enumerable)) {
+}
+// ------------------------------------------------------------------
+// WithEnumerable
+// ------------------------------------------------------------------
+function WithEnumerable(enumerable, keys, result) {
+    for (const key of keys) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
         Object.defineProperty(result, key, {
             configurable: true,
             enumerable: true,
@@ -29,5 +45,16 @@ export function Update(current, hidden, enumerable) {
             value: enumerable[key]
         });
     }
-    return Freeze(result);
+}
+// ------------------------------------------------------------------
+// Update
+// ------------------------------------------------------------------
+/** Updates an existing type with additional hidden and enumerable properties while preserving property configuration. */
+export function Update(current, hidden, enumerable) {
+    Metrics.update += 1;
+    const result = {}, hiddenKeys = Keys(hidden), enumerableKeys = Keys(enumerable);
+    WithCurrent(current, hiddenKeys, enumerableKeys, result);
+    WithHidden(hidden, hiddenKeys, result);
+    WithEnumerable(enumerable, enumerableKeys, result);
+    return Finalize(result);
 }

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

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

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

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

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

@@ -1,33 +1,11 @@
-import { type TReadonly } from '../../types/_readonly.mjs';
-import { type TOptional } from '../../types/_optional.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TNever } from '../../types/never.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
-import { type TAddReadonly } from '../../action/_add_readonly.mjs';
-import { type TAddOptional } from '../../action/_add_optional.mjs';
-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>>> = ([
-    IsReadonly,
-    IsOptional
-] extends [true, true] ? TAddReadonly<TAddOptional<Property>> : [
-    IsReadonly,
-    IsOptional
-] extends [true, false] ? TAddReadonly<Property> : [
-    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;
+import { type TEvaluatePropertyIntersect } from './property.mjs';
+type TCompositePropertyKey<Left extends TProperties, Right extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Left ? Key extends keyof Right ? TEvaluatePropertyIntersect<Left[Key], Right[Key]> : Left[Key] : Key extends keyof Right ? Right[Key] : TNever)> = Result;
 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;

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

@@ -1,41 +1,14 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { IsReadonly } from '../../types/_readonly.mjs';
-import { IsOptional } from '../../types/_optional.mjs';
 import { Object, IsObject } from '../../types/object.mjs';
 import { Never } from '../../types/never.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
-import { AddReadonly } from '../../action/_add_readonly.mjs';
-import { AddOptional } from '../../action/_add_optional.mjs';
-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);
-}
-function IsOptionalProperty(left, right) {
-    return (IsOptional(left) ? IsOptional(right) ? true : false : false);
-}
-function CompositeProperty(left, right) {
-    const isReadonly = IsReadonlyProperty(left, right);
-    const isOptional = IsOptionalProperty(left, right);
-    const evaluated = EvaluateIntersect([left, right]);
-    // Modifiers need to be discarded and re-applied
-    const property = RemoveReadonly(RemoveOptional(evaluated));
-    return (isReadonly && isOptional ? AddReadonly(AddOptional(property)) :
-        isReadonly && !isOptional ? AddReadonly(property) :
-            !isReadonly && isOptional ? AddOptional(property) :
-                property);
-}
+import { EvaluatePropertyIntersect } from './property.mjs';
 function CompositePropertyKey(left, right, key) {
     return (key in left
-        ? key in right ? CompositeProperty(left[key], right[key]) : left[key]
+        ? key in right ? EvaluatePropertyIntersect(left[key], right[key]) : left[key]
         : key in right ? right[key] : Never());
 }
 function CompositeProperties(left, right) {

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

@@ -6,3 +6,4 @@ export * from './evaluate.mjs';
 export * from './flatten.mjs';
 export * from './instantiate.mjs';
 export * from './narrow.mjs';
+export * from './property.mjs';

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

@@ -6,3 +6,4 @@ export * from './evaluate.mjs';
 export * from './flatten.mjs';
 export * from './instantiate.mjs';
 export * from './narrow.mjs';
+export * from './property.mjs';

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

@@ -1,10 +1,14 @@
 import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
 import { type TAny } from '../../types/any.mjs';
 import { type TNever } from '../../types/never.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
 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';
+import { type TComposite } 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 TCanComposite<Type extends TSchema> = (Type extends TObject<infer _ extends TProperties> ? true : Type extends TTuple<infer _ extends TSchema[]> ? true : false);
 type TNarrowCompositeRule<Left extends TSchema, Right extends TSchema, CanCompositeLeft extends boolean = TCanComposite<Left>, CanCompositeRight extends boolean = TCanComposite<Right>> = ([
     CanCompositeLeft,
     CanCompositeRight

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

@@ -1,10 +1,12 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
+import { IsObject } from '../../types/object.mjs';
 import { IsAny } from '../../types/any.mjs';
 import { Never, IsNever } from '../../types/never.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
 import { IsUnknown } from '../../types/unknown.mjs';
 import { Compare, CompareResultLeftInside, CompareResultRightInside, CompareResultEqual } from './compare.mjs';
-import { Composite, CanComposite } from './composite.mjs';
+import { Composite } from './composite.mjs';
 function NarrowCompareRule(left, right) {
     const result = Compare(left, right);
     return (Guard.IsEqual(result, CompareResultLeftInside) ? left :
@@ -12,6 +14,9 @@ function NarrowCompareRule(left, right) {
             Guard.IsEqual(result, CompareResultEqual) ? right :
                 Never());
 }
+function CanComposite(type) {
+    return (IsObject(type) || IsTuple(type));
+}
 function NarrowCompositeRule(left, right) {
     const canCompositeLeft = CanComposite(left);
     const canCompositeRight = CanComposite(right);

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

@@ -0,0 +1,30 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TOptional } from '../../types/_optional.mjs';
+import { type TReadonly } from '../../types/_readonly.mjs';
+import { type TAddOptionalAction } from '../optional/instantiate_add.mjs';
+import { type TAddReadonlyAction } from '../readonly/instantiate_add.mjs';
+import { type TRemoveOptionalAction } from '../optional/instantiate_remove.mjs';
+import { type TRemoveReadonlyAction } from '../readonly/instantiate_remove.mjs';
+import { type TEvaluateIntersect, type TEvaluateUnion } from './evaluate.mjs';
+export type TEvaluatePropertyIntersect<Left extends TSchema, Right extends TSchema, IsReadonly extends boolean = Left extends TReadonly ? Right extends TReadonly ? true : false : false, IsOptional extends boolean = Left extends TOptional ? Right extends TOptional ? true : false : false, Evaluated extends TSchema = TEvaluateIntersect<[Left, Right]>, Property extends TSchema = TRemoveReadonlyAction<TRemoveOptionalAction<Evaluated>>> = ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? TAddReadonlyAction<TAddOptionalAction<Property>> : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? TAddReadonlyAction<Property> : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? TAddOptionalAction<Property> : Property);
+export declare function EvaluatePropertyIntersect<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TEvaluatePropertyIntersect<Left, Right>;
+export type TEvaluatePropertyUnion<Left extends TSchema, Right extends TSchema, IsReadonly extends boolean = Left extends TReadonly ? true : Right extends TReadonly ? true : false, IsOptional extends boolean = Left extends TOptional ? true : Right extends TOptional ? true : false, LeftProperty extends TSchema = TRemoveReadonlyAction<TRemoveOptionalAction<Left>>, RightProperty extends TSchema = TRemoveReadonlyAction<TRemoveOptionalAction<Right>>, Property extends TSchema = TEvaluateUnion<[LeftProperty, RightProperty]>> = ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? TAddReadonlyAction<TAddOptionalAction<Property>> : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? TAddReadonlyAction<Property> : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? TAddOptionalAction<Property> : Property);
+export declare function EvaluatePropertyUnion<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TEvaluatePropertyUnion<Left, Right>;

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

@@ -0,0 +1,29 @@
+// deno-fmt-ignore-file
+import { IsOptional } from '../../types/_optional.mjs';
+import { IsReadonly } from '../../types/_readonly.mjs';
+import { AddOptionalAction } from '../optional/instantiate_add.mjs';
+import { AddReadonlyAction } from '../readonly/instantiate_add.mjs';
+import { RemoveOptionalAction } from '../optional/instantiate_remove.mjs';
+import { RemoveReadonlyAction } from '../readonly/instantiate_remove.mjs';
+import { EvaluateIntersect, EvaluateUnion } from './evaluate.mjs';
+export function EvaluatePropertyIntersect(left, right) {
+    const isReadonly = IsReadonly(left) && IsReadonly(right);
+    const isOptional = IsOptional(left) && IsOptional(right);
+    const evaluated = EvaluateIntersect([left, right]);
+    const property = RemoveReadonlyAction(RemoveOptionalAction(evaluated, {}), {});
+    return (isReadonly && isOptional ? AddReadonlyAction(AddOptionalAction(property, {}), {}) :
+        isReadonly ? AddReadonlyAction(property, {}) :
+            isOptional ? AddOptionalAction(property, {}) :
+                property);
+}
+export function EvaluatePropertyUnion(left, right) {
+    const isReadonly = IsReadonly(left) || IsReadonly(right);
+    const isOptional = IsOptional(left) || IsOptional(right);
+    const leftProperty = RemoveReadonlyAction(RemoveOptionalAction(left, {}), {});
+    const rightProperty = RemoveReadonlyAction(RemoveOptionalAction(right, {}), {});
+    const property = EvaluateUnion([leftProperty, rightProperty]);
+    return (isReadonly && isOptional ? AddReadonlyAction(AddOptionalAction(property, {}), {}) :
+        isReadonly ? AddReadonlyAction(property, {}) :
+            isOptional ? AddOptionalAction(property, {}) :
+                property);
+}

package/node_modules/typebox/build/type/engine/immutable/instantiate_add.d.mts

@@ -2,9 +2,7 @@ import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TImmutable } from '../../types/_immutable.mjs';
 import { type TState, type TInstantiateType } from '../instantiate.mjs';
-type TAddImmutableOperation<Type extends TSchema, Result extends TSchema = '~immutable' extends keyof Type ? Type : TImmutable<Type>> = Result;
-export type TAddImmutableAction<Type extends TSchema, Result extends TSchema = TAddImmutableOperation<Type>> = Result;
+export type TAddImmutableAction<Type extends TSchema, Result extends TSchema = '~immutable' extends keyof Type ? Type : TImmutable<Type>> = Result;
 export declare function AddImmutableAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddImmutableAction<Type>;
 export type TAddImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddImmutableAction<InstantiateType>;
 export declare function AddImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddImmutableInstantiate<Context, State, Type>;
-export {};

package/node_modules/typebox/build/type/engine/immutable/instantiate_add.mjs

@@ -1,11 +1,8 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { InstantiateType } from '../instantiate.mjs';
-function AddImmutableOperation(type) {
-    return Memory.Update(type, { '~immutable': true }, {});
-}
 export function AddImmutableAction(type, options) {
-    const result = Memory.Update(AddImmutableOperation(type), {}, options);
+    const result = Memory.Update(type, { '~immutable': true }, options);
     return result;
 }
 export function AddImmutableInstantiate(context, state, type, options) {

package/node_modules/typebox/build/type/engine/object/from_intersect.d.mts

@@ -2,13 +2,13 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TFromType } from './from_type.mjs';
-import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { type TEvaluatePropertyIntersect } from '../evaluate/property.mjs';
 type TCollapseIntersectProperties<Left extends TProperties, Right extends TProperties, LeftKeys extends keyof Left = Exclude<keyof Left, keyof Right>, RightKeys extends keyof Right = Exclude<keyof Right, keyof Left>, SharedKeys extends keyof Left & keyof Right = Extract<keyof Left, keyof Right>, LeftProperties extends TProperties = {
     [Key in LeftKeys]: Left[Key];
 }, RightProperties extends TProperties = {
     [Key in RightKeys]: Right[Key];
 }, SharedProperties extends TProperties = {
-    [Key in SharedKeys]: TEvaluateIntersect<[Left[Key], Right[Key]]>;
+    [Key in SharedKeys]: TEvaluatePropertyIntersect<Left[Key], Right[Key]>;
 }, Unique extends TProperties = Memory.TAssign<LeftProperties, RightProperties>, Shared extends TProperties = Memory.TAssign<Unique, SharedProperties>> = Shared;
 export type TFromIntersect<Types extends TSchema[], Result extends TProperties = {}> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromIntersect<Right, TCollapseIntersectProperties<Result, TFromType<Left>>> : {
     [Key in keyof Result]: Result[Key];

package/node_modules/typebox/build/type/engine/object/from_intersect.mjs

@@ -3,14 +3,14 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
 import { FromType } from './from_type.mjs';
-import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
+import { EvaluatePropertyIntersect } from '../evaluate/property.mjs';
 function CollapseIntersectProperties(left, right) {
     const leftKeys = Guard.Keys(left).filter((key) => !Guard.HasPropertyKey(right, key));
     const rightKeys = Guard.Keys(right).filter((key) => !Guard.HasPropertyKey(left, key));
     const sharedKeys = Guard.Keys(left).filter((key) => Guard.HasPropertyKey(right, key));
     const leftProperties = leftKeys.reduce((result, key) => ({ ...result, [key]: left[key] }), {});
     const rightProperties = rightKeys.reduce((result, key) => ({ ...result, [key]: right[key] }), {});
-    const sharedProperties = sharedKeys.reduce((result, key) => ({ ...result, [key]: EvaluateIntersect([left[key], right[key]]) }), {});
+    const sharedProperties = sharedKeys.reduce((result, key) => ({ ...result, [key]: EvaluatePropertyIntersect(left[key], right[key]) }), {});
     const unique = Memory.Assign(leftProperties, rightProperties);
     const shared = Memory.Assign(unique, sharedProperties);
     return shared;

package/node_modules/typebox/build/type/engine/object/from_union.d.mts

@@ -1,10 +1,10 @@
 import { type TUnreachable } from '../../../system/unreachable/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+import { type TEvaluatePropertyUnion } from '../evaluate/property.mjs';
 import { type TFromType } from './from_type.mjs';
 type TCollapseUnionProperties<Left extends TProperties, Right extends TProperties, SharedKeys extends PropertyKey = keyof Left & keyof Right, Result extends TProperties = {
-    [Key in SharedKeys]: TEvaluateUnion<[Left[Key], Right[Key]]>;
+    [Key in SharedKeys]: TEvaluatePropertyUnion<Left[Key], Right[Key]>;
 }> = Result;
 type TReduceVariants<Types extends TSchema[], Result extends TProperties> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReduceVariants<Right, TCollapseUnionProperties<Result, TFromType<Left>>> : Result);
 export type TFromUnion<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReduceVariants<Right, TFromType<Left>> : TUnreachable);

package/node_modules/typebox/build/type/engine/object/from_union.mjs

@@ -1,12 +1,12 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Unreachable } from '../../../system/unreachable/index.mjs';
-import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+import { EvaluatePropertyUnion } from '../evaluate/property.mjs';
 import { FromType } from './from_type.mjs';
 function CollapseUnionProperties(left, right) {
     const sharedKeys = Guard.Keys(left).filter((key) => key in right);
     const result = sharedKeys.reduce((result, key) => {
-        return { ...result, [key]: EvaluateUnion([left[key], right[key]]) };
+        return { ...result, [key]: EvaluatePropertyUnion(left[key], right[key]) };
     }, {});
     return result;
 }

package/node_modules/typebox/build/type/engine/optional/instantiate_add.d.mts

@@ -2,9 +2,7 @@ import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TOptional } from '../../types/_optional.mjs';
 import { type TState, type TInstantiateType } from '../instantiate.mjs';
-type TAddOptionalOperation<Type extends TSchema, Result extends TSchema = `~optional` extends keyof Type ? Type : TOptional<Type>> = Result;
-export type TAddOptionalAction<Type extends TSchema, Result extends TSchema = TAddOptionalOperation<Type>> = Result;
+export type TAddOptionalAction<Type extends TSchema, Result extends TSchema = '~optional' extends keyof Type ? Type : TOptional<Type>> = Result;
 export declare function AddOptionalAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddOptionalAction<Type>;
 export type TAddOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddOptionalAction<InstantiateType>;
 export declare function AddOptionalInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddOptionalInstantiate<Context, State, Type>;
-export {};

package/node_modules/typebox/build/type/engine/optional/instantiate_add.mjs

@@ -1,11 +1,8 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { InstantiateType } from '../instantiate.mjs';
-function AddOptionalOperation(type) {
-    return Memory.Update(type, { '~optional': true }, {});
-}
 export function AddOptionalAction(type, options) {
-    const result = Memory.Update(AddOptionalOperation(type), {}, options);
+    const result = Memory.Update(type, { '~optional': true }, options);
     return result;
 }
 export function AddOptionalInstantiate(context, state, type, options) {

package/node_modules/typebox/build/type/engine/readonly/instantiate_add.d.mts

@@ -2,9 +2,7 @@ import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TReadonly } from '../../types/_readonly.mjs';
 import { type TState, type TInstantiateType } from '../instantiate.mjs';
-type TAddReadonlyOperation<Type extends TSchema, Result extends TSchema = `~readonly` extends keyof Type ? Type : TReadonly<Type>> = Result;
-export type TAddReadonlyAction<Type extends TSchema, Result extends TSchema = TAddReadonlyOperation<Type>> = Result;
+export type TAddReadonlyAction<Type extends TSchema, Result extends TSchema = '~readonly' extends keyof Type ? Type : TReadonly<Type>> = Result;
 export declare function AddReadonlyAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddReadonlyAction<Type>;
 export type TAddReadonlyInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddReadonlyAction<InstantiateType>;
 export declare function AddReadonlyInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddReadonlyInstantiate<Context, State, Type>;
-export {};

package/node_modules/typebox/build/type/engine/readonly/instantiate_add.mjs

@@ -1,11 +1,8 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { InstantiateType } from '../instantiate.mjs';
-function AddReadonlyOperation(type) {
-    return Memory.Update(type, { '~readonly': true }, {});
-}
 export function AddReadonlyAction(type, options) {
-    const result = Memory.Update(AddReadonlyOperation(type), {}, options);
+    const result = Memory.Update(type, { '~readonly': true }, options);
     return result;
 }
 export function AddReadonlyInstantiate(context, state, type, options) {

package/node_modules/typebox/build/type/engine/this/index.d.mts

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

package/node_modules/typebox/build/type/engine/this/index.mjs

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

package/node_modules/typebox/build/value/clone/clone.d.mts

@@ -1,5 +1,6 @@
 /**
- * Returns a Clone of the given value. This function is similar to structuredClone()
- * but also supports deep cloning instances of Map, Set and TypeArray.
+ * Returns a deep Clone of the given value. This function is similar to `structuredClone()`,
+ * but also supports deep cloning `Map`, `Set`, and `TypeArray` instances. This function can also be used
+ * to clone TypeBox types while retaining their enumerable and non-enumerable properties.
  */
-export declare function Clone<Value extends unknown>(value: Value): Value;
+export declare function Clone<Value extends unknown = unknown>(value: Value): Value;

package/node_modules/typebox/build/value/clone/clone.mjs

@@ -1,12 +1,10 @@
 // deno-fmt-ignore-file
-import { Clone as SystemClone } from '../../system/memory/clone.mjs';
-// ------------------------------------------------------------------
-// Clone
-// ------------------------------------------------------------------
+import { Deep } from '../../system/memory/deep.mjs';
 /**
- * Returns a Clone of the given value. This function is similar to structuredClone()
- * but also supports deep cloning instances of Map, Set and TypeArray.
+ * Returns a deep Clone of the given value. This function is similar to `structuredClone()`,
+ * but also supports deep cloning `Map`, `Set`, and `TypeArray` instances. This function can also be used
+ * to clone TypeBox types while retaining their enumerable and non-enumerable properties.
  */
 export function Clone(value) {
-    return SystemClone(value);
+    return Deep(value);
 }

package/node_modules/typebox/build/value/repair/from_cyclic.d.mts

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

package/node_modules/typebox/build/value/repair/from_cyclic.mjs

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

package/node_modules/typebox/build/value/shared/union_priority_sort.mjs

@@ -1,28 +1,27 @@
 // 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 { Memory } from '../../system/memory/index.mjs';
+import { Array as _Array_, ArrayOptions, IsArray } from '../../type/index.mjs';
+import { Intersect, IsIntersect } from '../../type/index.mjs';
 import { IsObject, Object as _Object_ } from '../../type/index.mjs';
-import { IsRecord, Record, RecordKey, RecordValue } from '../../type/index.mjs';
+import { IsRecord, Record, RecordPattern, RecordValue } from '../../type/index.mjs';
+import { String } from '../../type/index.mjs';
 import { IsTuple, Tuple } from '../../type/index.mjs';
-import { IsIntersect, Intersect } from '../../type/index.mjs';
+import { IsUnion, Union } 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)
+// reassigned afterward. We previously used a mutable assignment on this
+// function, however `immutableTypes: true` caused errors. We use the 
+// Memory.Assign to ensure modifiers are retained and we preserve type
+// configurations (review)
 //
 // ------------------------------------------------------------------
 function Modifiers(type, next) {
-    for (const key of Guard.Keys(type)) {
-        if (Guard.HasPropertyKey(next, key))
-            continue;
-        next[key] = type[key];
-    }
-    return next;
+    return Memory.Assign(type, next);
 }
 // ------------------------------------------------------------------
 // Properties
@@ -34,6 +33,18 @@ function FromProperties(properties) {
     return result;
 }
 // ------------------------------------------------------------------
+// FromRecordKey
+//
+// This is required because RecordKey(...) returns a canonical
+// decoded type derived from the pattern. When the pattern is an
+// unrecognized user-defined one, the result falls through to
+// TString (^.*$) and the user-defined pattern is lost. This
+// function ensures the exact pattern is retained.
+// ------------------------------------------------------------------
+function FromRecordKey(type) {
+    return String({ pattern: RecordPattern(type) });
+}
+// ------------------------------------------------------------------
 // PriorityTypes
 // ------------------------------------------------------------------
 function FromPriorityTypes(types) {
@@ -43,7 +54,7 @@ function FromPriorityTypes(types) {
 // Types
 // ------------------------------------------------------------------
 function FromTypes(types) {
-    return types.map(type => FromType(type));
+    return types.map((type) => FromType(type));
 }
 // ------------------------------------------------------------------
 // Type
@@ -53,7 +64,7 @@ function FromType(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))) :
+                    IsRecord(type) ? Record(FromRecordKey(type), FromType(RecordValue(type))) :
                         IsTuple(type) ? Tuple(FromTypes(type.items)) :
                             type);
     return Modifiers(type, next);