pi-proactive 0.2.0-beta.2 → 0.2.0-beta.3

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

@@ -1,14 +1,41 @@
 // 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 { EvaluatePropertyIntersect } from './property.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);
+}
 function CompositePropertyKey(left, right, key) {
     return (key in left
-        ? key in right ? EvaluatePropertyIntersect(left[key], right[key]) : left[key]
+        ? key in right ? CompositeProperty(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,4 +6,3 @@ 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,4 +6,3 @@ 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,14 +1,10 @@
 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 } from './composite.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 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,12 +1,10 @@
 // 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 } from './composite.mjs';
+import { Composite, CanComposite } from './composite.mjs';
 function NarrowCompareRule(left, right) {
     const result = Compare(left, right);
     return (Guard.IsEqual(result, CompareResultLeftInside) ? left :
@@ -14,9 +12,6 @@ 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/immutable/instantiate_add.d.mts

@@ -2,7 +2,9 @@ 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';
-export type TAddImmutableAction<Type extends TSchema, Result extends TSchema = '~immutable' extends keyof Type ? Type : TImmutable<Type>> = Result;
+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 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,8 +1,11 @@
 // 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(type, { '~immutable': true }, options);
+    const result = Memory.Update(AddImmutableOperation(type), {}, 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 TEvaluatePropertyIntersect } from '../evaluate/property.mjs';
+import { type TEvaluateIntersect } from '../evaluate/evaluate.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]: TEvaluatePropertyIntersect<Left[Key], Right[Key]>;
+    [Key in SharedKeys]: TEvaluateIntersect<[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 { EvaluatePropertyIntersect } from '../evaluate/property.mjs';
+import { EvaluateIntersect } from '../evaluate/evaluate.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]: EvaluatePropertyIntersect(left[key], right[key]) }), {});
+    const sharedProperties = sharedKeys.reduce((result, key) => ({ ...result, [key]: EvaluateIntersect([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 TEvaluatePropertyUnion } from '../evaluate/property.mjs';
+import { type TEvaluateUnion } from '../evaluate/evaluate.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]: TEvaluatePropertyUnion<Left[Key], Right[Key]>;
+    [Key in SharedKeys]: TEvaluateUnion<[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 { EvaluatePropertyUnion } from '../evaluate/property.mjs';
+import { EvaluateUnion } from '../evaluate/evaluate.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]: EvaluatePropertyUnion(left[key], right[key]) };
+        return { ...result, [key]: EvaluateUnion([left[key], right[key]]) };
     }, {});
     return result;
 }

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

@@ -2,7 +2,9 @@ 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';
-export type TAddOptionalAction<Type extends TSchema, Result extends TSchema = '~optional' extends keyof Type ? Type : TOptional<Type>> = Result;
+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 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,8 +1,11 @@
 // 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(type, { '~optional': true }, options);
+    const result = Memory.Update(AddOptionalOperation(type), {}, options);
     return result;
 }
 export function AddOptionalInstantiate(context, state, type, options) {

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

@@ -2,7 +2,9 @@ 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';
-export type TAddReadonlyAction<Type extends TSchema, Result extends TSchema = '~readonly' extends keyof Type ? Type : TReadonly<Type>> = Result;
+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 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,8 +1,11 @@
 // 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(type, { '~readonly': true }, options);
+    const result = Memory.Update(AddReadonlyOperation(type), {}, options);
     return result;
 }
 export function AddReadonlyInstantiate(context, state, type, options) {

package/node_modules/typebox/build/type/extends/inference.d.mts

@@ -22,7 +22,7 @@ export declare function TryRestInferable<Type extends TSchema>(type: Type): TTry
 export type TTryInferable<Type extends TSchema, Result extends TInferable | undefined = (Type extends TInfer<infer Name extends string, infer Type extends TSchema> ? TInferable<Name, Type> : undefined)> = Result;
 export declare function TryInferable<Type extends TSchema>(type: Type): TTryInferable<Type>;
 type TryInferResults<Rest extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Rest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<{}, Head, Right> extends Result.TExtendsTrueLike ? TryInferResults<Tail, Right, [...Result, Head]> : undefined : Result);
-declare function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right): TryInferResults<Rest, Right>;
+declare function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right, result?: TSchema[]): TryInferResults<Rest, Right>;
 export type TInferTupleResult<Inferred extends TProperties, Name extends string, Left extends TSchema[], Right extends TSchema, Results extends TSchema[] | undefined = TryInferResults<Left, Right>> = (Results extends [...infer Results extends TSchema[]] ? Result.TExtendsTrue<Memory.TAssign<Inferred, {
     [_ in Name]: TTuple<Results>;
 }>> : Result.TExtendsFalse);

package/node_modules/typebox/build/type/extends/inference.mjs

@@ -45,21 +45,8 @@ export function TryInferable(type) {
     return (IsInfer(type) ? Inferrable(type.name, type.extends) :
         undefined);
 }
-// function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right, result: TSchema[] = []): TryInferResults<Rest, Right> {
-//   return Guard.ShiftLeft(rest, (head, tail) =>
-//     Result.Match(ExtendsLeft({}, head, right),
-//       () => TryInferResults(tail, right, [...result, head]), // Stack Overflow Here (Large Rest)
-//       () => undefined),
-//     () => result) as never
-// }
-function TryInferResults(rest, right) {
-    const result = [];
-    for (const head of rest) {
-        if (!Result.IsExtendsTrueLike(ExtendsLeft({}, head, right)))
-            return undefined;
-        result.push(head);
-    }
-    return result;
+function TryInferResults(rest, right, result = []) {
+    return Guard.ShiftLeft(rest, (head, tail) => Result.Match(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => undefined), () => result);
 }
 export function InferTupleResult(inferred, name, left, right) {
     const results = TryInferResults(left, right);

package/node_modules/typebox/build/type/extends/tuple.d.mts

@@ -16,8 +16,7 @@ type TElementsLeft<Inferred extends TProperties, Reversed extends boolean, LeftR
 type TElementsRight<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = (RightRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TElementsLeft<Inferred, Reversed, LeftRest, Head, Tail> : LeftRest['length'] extends 0 ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
 type TElements<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = TElementsRight<Inferred, Reversed, LeftRest, RightRest>;
 type TExtendsTupleToTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[], InstantiatedRight extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Right>, Reversed extends boolean = TReversed<InstantiatedRight>> = TElements<Inferred, Reversed, TApplyReverse<Left, Reversed>, TApplyReverse<InstantiatedRight, Reversed>>;
-type TExtendsTupleToArrayReduce<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema> = (Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Head, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsTupleToArrayReduce<Inferred, Tail, Right> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
-type TExtendsTupleToArray<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Inferrable extends TInferable | undefined = TTryInferable<Right>> = (Inferrable extends TInferable ? TInferUnionResult<Inferred, Inferrable['name'], Left, Inferrable['type']> : TExtendsTupleToArrayReduce<Inferred, Left, Right>);
+type TExtendsTupleToArray<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Inferrable extends TInferable | undefined = TTryInferable<Right>> = (Inferrable extends TInferable ? TInferUnionResult<Inferred, Inferrable['name'], Left, Inferrable['type']> : Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Head, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsTupleToArray<Inferred, Tail, Right> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
 export type TExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, InstantiatedLeft extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Left>> = (Right extends TTuple<infer Types extends TSchema[]> ? TExtendsTupleToTuple<Inferred, InstantiatedLeft, Types> : Right extends TArray<infer Type extends TSchema> ? TExtendsTupleToArray<Inferred, InstantiatedLeft, Type> : TExtendsRight<Inferred, TTuple<InstantiatedLeft>, Right>);
 export declare function ExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsTuple<Inferred, Left, Right>;
 export {};

package/node_modules/typebox/build/type/extends/tuple.mjs

@@ -47,31 +47,11 @@ function ExtendsTupleToTuple(inferred, left, right) {
     const reversed = Reversed(instantiatedRight);
     return Elements(inferred, reversed, ApplyReverse(left, reversed), ApplyReverse(instantiatedRight, reversed));
 }
-// function ExtendsTupleToArrayReduce<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>
-//   (inferred: Inferred, left: [...Left], right: Right):
-//     TExtendsTupleToArrayReduce<Inferred, Left, Right> {
-//   return (
-//     Guard.ShiftLeft(left, (head, tail) =>
-//       Result.Match(ExtendsLeft(inferred, head, right), inferred =>
-//         ExtendsTupleToArrayReduce(inferred, tail, right), // Stack Overflow Here (Large Left)
-//         () => Result.ExtendsFalse()),
-//       () => Result.ExtendsTrue(inferred))
-//   ) as never
-// }
-function ExtendsTupleToArrayReduce(inferred, left, right) {
-    for (const head of left) {
-        const result = ExtendsLeft(inferred, head, right);
-        if (!Result.IsExtendsTrueLike(result))
-            return result;
-        inferred = result.inferred; // (review-assign-to-argument)
-    }
-    return Result.ExtendsTrue(inferred);
-}
 function ExtendsTupleToArray(inferred, left, right) {
     const inferrable = TryInferable(right);
     return (IsInferable(inferrable)
         ? InferUnionResult(inferred, inferrable['name'], left, inferrable['type'])
-        : ExtendsTupleToArrayReduce(inferred, left, right));
+        : Guard.ShiftLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
 }
 export function ExtendsTuple(inferred, left, right) {
     const instantiatedLeft = InstantiateElements(inferred, State([], []), left);

package/node_modules/typebox/build/value/clean/from_object.mjs

@@ -12,7 +12,7 @@ export function FromObject(context, type, value) {
         return value;
     const additionalProperties = GetAdditionalProperties(type);
     for (const key of Guard.Keys(value)) {
-        if (Guard.HasPropertyKey(type.properties, key) && IsSchema(type.properties[key])) {
+        if (Guard.HasPropertyKey(type.properties, key)) {
             value[key] = FromType(context, type.properties[key], value[key]);
             continue;
         }

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

@@ -1,6 +1,5 @@
 /**
- * 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.
+ * Returns a Clone of the given value. This function is similar to structuredClone()
+ * but also supports deep cloning instances of Map, Set and TypeArray.
  */
-export declare function Clone<Value extends unknown = unknown>(value: Value): Value;
+export declare function Clone<Value extends unknown>(value: Value): Value;

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

@@ -1,10 +1,12 @@
 // deno-fmt-ignore-file
-import { Deep } from '../../system/memory/deep.mjs';
+import { Clone as SystemClone } from '../../system/memory/clone.mjs';
+// ------------------------------------------------------------------
+// Clone
+// ------------------------------------------------------------------
 /**
- * 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.
+ * Returns a Clone of the given value. This function is similar to structuredClone()
+ * but also supports deep cloning instances of Map, Set and TypeArray.
  */
 export function Clone(value) {
-    return Deep(value);
+    return SystemClone(value);
 }

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
-import { EnableParseErrors, DisableParseErrors } from '../../system/settings/internal.mjs';
-import { Arguments, Settings } from '../../system/index.mjs';
+import { Settings } from '../../system/system.mjs';
+import { Arguments } from '../../system/arguments/index.mjs';
 import { AssertError } from '../assert/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Errors } from '../errors/index.mjs';
@@ -18,11 +18,8 @@ export class ParseError extends AssertError {
     }
 }
 function Assert(context, type, value) {
-    EnableParseErrors();
-    const errors = Errors(context, type, value);
-    DisableParseErrors();
     if (!Check(context, type, value))
-        throw new ParseError(value, errors);
+        throw new ParseError(value, Errors(context, type, value));
     return value;
 }
 // ------------------------------------------------------------------
@@ -46,8 +43,5 @@ export function Parse(...args) {
         return value;
     if (Settings.Get().correctiveParse)
         return Parser(context, type, value);
-    EnableParseErrors();
-    const errors = Errors(context, type, value);
-    DisableParseErrors();
-    throw new ParseError(value, errors);
+    throw new ParseError(value, Errors(context, type, value));
 }

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

@@ -1,27 +1,28 @@
 // deno-fmt-ignore-file
 import Guard from '../../guard/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 { 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, RecordPattern, RecordValue } from '../../type/index.mjs';
-import { String } from '../../type/index.mjs';
+import { IsRecord, Record, RecordKey, RecordValue } from '../../type/index.mjs';
 import { IsTuple, Tuple } from '../../type/index.mjs';
-import { IsUnion, Union } 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. 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)
+// reassigned afterward. This is a fast mutable assignment to handle that,
+// but we should consider a more general solution. (review)
 //
 // ------------------------------------------------------------------
 function Modifiers(type, next) {
-    return Memory.Assign(type, next);
+    for (const key of Guard.Keys(type)) {
+        if (Guard.HasPropertyKey(next, key))
+            continue;
+        next[key] = type[key];
+    }
+    return next;
 }
 // ------------------------------------------------------------------
 // Properties
@@ -33,18 +34,6 @@ 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) {
@@ -54,7 +43,7 @@ function FromPriorityTypes(types) {
 // Types
 // ------------------------------------------------------------------
 function FromTypes(types) {
-    return types.map((type) => FromType(type));
+    return types.map(type => FromType(type));
 }
 // ------------------------------------------------------------------
 // Type
@@ -64,7 +53,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(FromRecordKey(type), FromType(RecordValue(type))) :
+                    IsRecord(type) ? Record(RecordKey(type), FromType(RecordValue(type))) :
                         IsTuple(type) ? Tuple(FromTypes(type.items)) :
                             type);
     return Modifiers(type, next);

package/node_modules/typebox/package.json

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