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

package/node_modules/typebox/build/system/hashing/hash.mjs

@@ -1,16 +1,16 @@
 // deno-fmt-ignore-file
 import { Unreachable } from '../unreachable/index.mjs';
-import { GlobalsGuard, Guard } from '../../guard/index.mjs';
+import { Guard, GlobalsGuard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // InstanceKeys
 //
-// Retrieves all enumerable and non-enumerable own property keys
-// and inherited prototype keys (excluding symbols and the 'constructor')
+// Retrieves all enumerable and non-enumerable own property keys 
+// and inherited prototype keys (excluding symbols and the 'constructor') 
 // from an object instance.
 //
-// This function is useful for differentiating between class instances
-// based on their structural keys rather than relying on the
-// constructor name. It provides a more reliable structural comparison
+// This function is useful for differentiating between class instances 
+// based on their structural keys rather than relying on the 
+// constructor name. It provides a more reliable structural comparison 
 // by capturing both own and prototype properties.
 //
 // ------------------------------------------------------------------
@@ -40,57 +40,38 @@ function IsIEEE754(value) {
 // ------------------------------------------------------------------
 // ByteMarker
 // ------------------------------------------------------------------
-const ByteMarker = {
-    Array: 0x0,
-    BigInt: 0x1,
-    Boolean: 0x2,
-    Date: 0x3,
-    Constructor: 0x4,
-    Function: 0x5,
-    Null: 0x6,
-    Number: 0x7,
-    Object: 0x8,
-    RegExp: 0x9,
-    String: 0xA,
-    Symbol: 0xB,
-    TypeArray: 0xC,
-    Undefined: 0xD
-};
+var ByteMarker;
+(function (ByteMarker) {
+    ByteMarker[ByteMarker["Array"] = 0] = "Array";
+    ByteMarker[ByteMarker["BigInt"] = 1] = "BigInt";
+    ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
+    ByteMarker[ByteMarker["Date"] = 3] = "Date";
+    ByteMarker[ByteMarker["Constructor"] = 4] = "Constructor";
+    ByteMarker[ByteMarker["Function"] = 5] = "Function";
+    ByteMarker[ByteMarker["Null"] = 6] = "Null";
+    ByteMarker[ByteMarker["Number"] = 7] = "Number";
+    ByteMarker[ByteMarker["Object"] = 8] = "Object";
+    ByteMarker[ByteMarker["RegExp"] = 9] = "RegExp";
+    ByteMarker[ByteMarker["String"] = 10] = "String";
+    ByteMarker[ByteMarker["Symbol"] = 11] = "Symbol";
+    ByteMarker[ByteMarker["TypeArray"] = 12] = "TypeArray";
+    ByteMarker[ByteMarker["Undefined"] = 13] = "Undefined";
+})(ByteMarker || (ByteMarker = {}));
 // ------------------------------------------------------------------
 // State
 // ------------------------------------------------------------------
-//
-// The 64-bit accumulator is held as four 16-bit limbs (A0 is the least
-// significant) so the FNV1A64 operation can be computed with number
-// arithmetic, avoiding a BigInt multiply and modulo for every byte.
-//
-// Offset: 14695981039346656037 (0xCBF29CE484222325)
-//
-// ------------------------------------------------------------------
-let A0 = 0x2325, A1 = 0x8422, A2 = 0x9CE4, A3 = 0xCBF2;
+let Accumulator = BigInt('14695981039346656037');
+const [Prime, Size] = [BigInt('1099511628211'), BigInt('18446744073709551616' /* 2 ^ 64 */)];
+const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
 const F64 = new Float64Array(1);
 const F64In = new DataView(F64.buffer);
 const F64Out = new Uint8Array(F64.buffer);
 // ------------------------------------------------------------------
 // Operation
-//
-// Prime: 1099511628211 (0x100000001B3 = 2^40 + 0x1B3)
-//
-// The multiply is computed as (A * 0x1B3) + (A << 40) modulo 2^64, 
-// where (A << 40) adds (A0 << 8) to the third limb and (A1 << 8) 
-// to the fourth.
-//
 // ------------------------------------------------------------------
 function FNV1A64_OP(byte) {
-    const L0 = A0 ^ byte;
-    const T0 = L0 * 0x1B3;
-    const T1 = A1 * 0x1B3 + (T0 >>> 16);
-    const T2 = A2 * 0x1B3 + (T1 >>> 16) + (L0 << 8);
-    const T3 = A3 * 0x1B3 + (T2 >>> 16) + (A1 << 8);
-    A0 = T0 & 0xFFFF;
-    A1 = T1 & 0xFFFF;
-    A2 = T2 & 0xFFFF;
-    A3 = T3 & 0xFFFF;
+    Accumulator = Accumulator ^ Bytes[byte];
+    Accumulator = (Accumulator * Prime) % Size;
 }
 // ------------------------------------------------------------------
 // Array
@@ -178,15 +159,8 @@ function FromRegExp(value) {
 const encoder = new TextEncoder();
 function FromString(value) {
     FNV1A64_OP(ByteMarker.String);
-    for (let i = 0; i < value.length; i++) {
-        const code = value.charCodeAt(i);
-        if (code > 0x7F) {
-            for (const byte of encoder.encode(value.slice(i))) {
-                FNV1A64_OP(byte);
-            }
-            return;
-        }
-        FNV1A64_OP(code);
+    for (const byte of encoder.encode(value)) {
+        FNV1A64_OP(byte);
     }
 }
 // ------------------------------------------------------------------
@@ -246,16 +220,13 @@ function FromValue(value) {
 // ------------------------------------------------------------------
 // Hash
 // ------------------------------------------------------------------
-function Hex(limb) {
-    return limb.toString(16).padStart(4, '0');
-}
 /** Generates a FNV1A-64 non cryptographic hash of the given value */
 export function HashCode(value) {
-    return BigInt(`0x${Hash(value)}`);
+    Accumulator = BigInt('14695981039346656037');
+    FromValue(value);
+    return Accumulator;
 }
 /** Generates a FNV1A-64 non cryptographic hash of the given value */
 export function Hash(value) {
-    A0 = 0x2325, A1 = 0x8422, A2 = 0x9CE4, A3 = 0xCBF2;
-    FromValue(value);
-    return `${Hex(A3)}${Hex(A2)}${Hex(A1)}${Hex(A0)}`;
+    return HashCode(value).toString(16).padStart(16, '0');
 }

package/node_modules/typebox/build/system/locale/en_US.mjs

@@ -33,8 +33,7 @@ export function en_US(error) {
         case 'unevaluatedProperties': return 'must not have unevaluated properties';
         case 'uniqueItems': return `must not have duplicate items`;
         case '~refine': return error.params.message;
-        // deno-coverage-ignore-start - unreachable
+        // deno-coverage-ignore - unreachable
         default: return 'an unknown validation error occurred';
-        // deno-coverage-ignore-stop
     }
 }

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

@@ -1,8 +1,14 @@
 type ObjectLike = Record<PropertyKey, any>;
-/** Performs an Object assign using the Left and Right object types. */
+/**
+ * Performs an Object assign using the Left and Right object types. We track this operation as it
+ * creates a new GC handle per assignment.
+ */
 export type TAssign<Left extends ObjectLike, Right extends ObjectLike, Assigned extends ObjectLike = Omit<Left, keyof Right> & Right> = {
     [Key in keyof Assigned]: Assigned[Key];
 } & {};
-/** Performs an Object assign using the Left and Right object types. */
+/**
+ * Performs an Object assign using the Left and Right object types. We track this operation as it
+ * creates a new GC handle per assignment.
+ */
 export declare function Assign<Left extends ObjectLike, Right extends ObjectLike>(left: Left, right: Right): TAssign<Left, Right>;
 export {};

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

@@ -1,19 +1,12 @@
 // deno-lint-ignore-file ban-types no-explicit-any
 // deno-fmt-ignore-file
 import { Metrics } from './metrics.mjs';
-import { Finalize } from './finalize.mjs';
-import { Keys } from './keys.mjs';
-/** Performs an Object assign using the Left and Right object types. */
+import { Freeze } from './freeze.mjs';
+/**
+ * Performs an Object assign using the Left and Right object types. We track this operation as it
+ * creates a new GC handle per assignment.
+ */
 export function Assign(left, right) {
     Metrics.assign += 1;
-    const result = {}, rightKeys = Keys(right), leftKeys = Keys(left);
-    for (const key of leftKeys) {
-        if (rightKeys.includes(key))
-            continue;
-        Object.defineProperty(result, key, Object.getOwnPropertyDescriptor(left, key));
-    }
-    for (const key of rightKeys) {
-        Object.defineProperty(result, key, Object.getOwnPropertyDescriptor(right, key));
-    }
-    return Finalize(result);
+    return Freeze({ ...left, ...right });
 }

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

@@ -1,4 +1,5 @@
-type ObjectLike = Record<PropertyKey, any>;
-/** Returns a shallow clone of the given object. */
-export declare function Clone<Value extends ObjectLike = ObjectLike>(value: Value): Value;
-export {};
+/**
+ * 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;

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

@@ -1,19 +1,34 @@
-// deno-lint-ignore-file no-explicit-any
 // deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
+import { Guard, GlobalsGuard } from '../../guard/index.mjs';
 import { Metrics } from './metrics.mjs';
-import { Keys } from './keys.mjs';
 // ------------------------------------------------------------------
-// Clone
+// ClassInstance
+//
+// TypeBox does not clone arbitrary class instances. Class instances
+// cannot be safely cloned without potentially breaking private
+// members of the instance.
+//
 // ------------------------------------------------------------------
-/** Returns a shallow clone of the given object. */
-export function Clone(value) {
-    Metrics.clone += 1;
+function FromClassInstance(value) {
+    return value; // atomic
+}
+// ------------------------------------------------------------------
+// SchemaObject
+//
+// Schema objects have non-enumerable properties that MUST be preserved 
+// on Clone. The following is the optimal path these objects.
+// ------------------------------------------------------------------
+function IsSchemaObject(value) {
+    return (Guard.HasPropertyKey(value, '~kind') ||
+        Guard.HasPropertyKey(value, '~unsafe'));
+}
+function FromSchemaObject(value) {
     const result = {};
-    for (const key of Keys(value)) {
+    for (const key of Guard.Keys(value)) {
         if (Guard.IsUnsafePropertyKey(key))
             continue; // (ignore: prototype-pollution)
         const descriptor = Object.getOwnPropertyDescriptor(value, key); // safe-name!
+        descriptor.value = FromValue(descriptor.value);
         if (Guard.IsEqual(descriptor.enumerable, true)) {
             result[key] = descriptor.value;
         }
@@ -23,3 +38,76 @@ export function Clone(value) {
     }
     return result;
 }
+// ------------------------------------------------------------------
+// PlainObject
+// ------------------------------------------------------------------
+function FromPlainObject(value) {
+    const result = {};
+    for (const key of Guard.Keys(value)) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
+        result[key] = FromValue(value[key]);
+    }
+    for (const key of Guard.Symbols(value)) {
+        result[key] = FromValue(value[key]);
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function FromObject(value) {
+    return (Guard.IsClassInstance(value) ? FromClassInstance(value) :
+        IsSchemaObject(value) ? FromSchemaObject(value) :
+            FromPlainObject(value));
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function FromArray(value) {
+    return value.map((element) => FromValue(element));
+}
+// ------------------------------------------------------------------
+// TypeArray
+// ------------------------------------------------------------------
+function FromTypedArray(value) {
+    return value.slice();
+}
+// ------------------------------------------------------------------
+// RegExp
+// ------------------------------------------------------------------
+function FromRegExp(value) {
+    return new RegExp(value.source, value.flags);
+}
+// ------------------------------------------------------------------
+// Map
+// ------------------------------------------------------------------
+function FromMap(value) {
+    return new Map(FromValue([...value.entries()]));
+}
+// ------------------------------------------------------------------
+// Set
+// ------------------------------------------------------------------
+function FromSet(value) {
+    return new Set(FromValue([...value.values()]));
+}
+function FromValue(value) {
+    return (GlobalsGuard.IsTypeArray(value) ? FromTypedArray(value) :
+        GlobalsGuard.IsRegExp(value) ? FromRegExp(value) :
+            GlobalsGuard.IsMap(value) ? FromMap(value) :
+                GlobalsGuard.IsSet(value) ? FromSet(value) :
+                    Guard.IsArray(value) ? FromArray(value) :
+                        Guard.IsObject(value) ? FromObject(value) :
+                            value);
+}
+// ------------------------------------------------------------------
+// Clone
+// ------------------------------------------------------------------
+/**
+ * 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) {
+    Metrics.clone += 1;
+    return FromValue(value);
+}

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

@@ -1,4 +1,8 @@
 type ObjectLike = Record<PropertyKey, any>;
-/** Creates an object with hidden, enumerable, and optional property sets. */
+/**
+ * Creates an object with hidden, enumerable, and optional property sets. This function
+ * ensures types are instantiated according to configuration rules for enumerable and
+ * non-enumerable properties.
+ */
 export declare function Create(hidden: ObjectLike, enumerable: ObjectLike, options?: ObjectLike): ObjectLike;
 export {};

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

@@ -1,17 +1,8 @@
 // deno-lint-ignore-file no-explicit-any
 import { Settings } from '../settings/index.mjs';
 import { Metrics } from './metrics.mjs';
-import { Finalize } from './finalize.mjs';
-// ------------------------------------------------------------------
-// WithEnumerable
-// ------------------------------------------------------------------
-function WithEnumerable(left, right) {
-    return { ...left, ...right };
-}
-// ------------------------------------------------------------------
-// WithHidden
-// ------------------------------------------------------------------
-function WithHidden(left, right) {
+import { Freeze } from './freeze.mjs';
+function MergeHidden(left, right) {
     for (const key of Object.keys(right)) {
         Object.defineProperty(left, key, {
             configurable: true,
@@ -22,13 +13,17 @@ function WithHidden(left, right) {
     }
     return left;
 }
-// ------------------------------------------------------------------
-// Create
-// ------------------------------------------------------------------
-/** Creates an object with hidden, enumerable, and optional property sets. */
+function Merge(left, right) {
+    return { ...left, ...right };
+}
+/**
+ * Creates an object with hidden, enumerable, and optional property sets. This function
+ * ensures types are instantiated according to configuration rules for enumerable and
+ * non-enumerable properties.
+ */
 export function Create(hidden, enumerable, options = {}) {
     Metrics.create += 1;
-    const withEnumerable = WithEnumerable(enumerable, options);
-    const withHidden = Settings.Get().enumerableKind ? WithEnumerable(withEnumerable, hidden) : WithHidden(withEnumerable, hidden);
-    return Finalize(withHidden);
+    const withOptions = Merge(enumerable, options);
+    const withHidden = Settings.Get().enumerableKind ? Merge(withOptions, hidden) : MergeHidden(withOptions, hidden);
+    return Freeze(withHidden);
 }

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

@@ -1,4 +1,4 @@
 type ObjectLike = Record<PropertyKey, any>;
-/** Discards property keys from the given object. */
+/** Discards multiple property keys from the given object value */
 export declare function Discard(value: ObjectLike, propertyKeys: PropertyKey[]): ObjectLike;
 export {};

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

@@ -1,19 +1,18 @@
 // deno-lint-ignore-file no-explicit-any
+import { Guard } from '../../guard/index.mjs';
 import { Metrics } from './metrics.mjs';
-import { Finalize } from './finalize.mjs';
-import { Keys } from './keys.mjs';
-// ------------------------------------------------------------------
-// Discard
-// ------------------------------------------------------------------
-/** Discards property keys from the given object. */
+import { Freeze } from './freeze.mjs';
+import { Clone } from './clone.mjs';
+/** Discards multiple property keys from the given object value */
 export function Discard(value, propertyKeys) {
     Metrics.discard += 1;
     const result = {};
-    for (const key of Keys(value)) {
+    for (const key of Guard.Keys(value)) {
         if (propertyKeys.includes(key))
             continue;
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        const descriptor = Object.getOwnPropertyDescriptor(value, key); // safe-name!
+        descriptor.value = Clone(descriptor.value);
         Object.defineProperty(result, key, descriptor);
     }
-    return Finalize(result);
+    return Freeze(result);
 }

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

@@ -0,0 +1,4 @@
+type ObjectLike = Record<PropertyKey, any>;
+/** Conditionally freezes the value if `immutableTypes` is true, otherwise no action. */
+export declare function Freeze(value: ObjectLike): ObjectLike;
+export {};

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

@@ -0,0 +1,6 @@
+// deno-lint-ignore-file no-explicit-any
+import { Settings } from '../settings/index.mjs';
+/** Conditionally freezes the value if `immutableTypes` is true, otherwise no action. */
+export function Freeze(value) {
+    return Settings.Get().immutableTypes ? Object.freeze(value) : value;
+}

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

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

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

@@ -1,43 +1,27 @@
 // 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 { 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)
+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)) {
         Object.defineProperty(result, key, {
             configurable: true,
             writable: true,
-            enumerable: enumerableKind,
+            enumerable: settings.enumerableKind,
             value: hidden[key]
         });
     }
-}
-// ------------------------------------------------------------------
-// WithEnumerable
-// ------------------------------------------------------------------
-function WithEnumerable(enumerable, keys, result) {
-    for (const key of keys) {
-        if (Guard.IsUnsafePropertyKey(key))
-            continue; // (ignore: prototype-pollution)
+    // enumerable
+    for (const key of Object.keys(enumerable)) {
         Object.defineProperty(result, key, {
             configurable: true,
             enumerable: true,
@@ -45,16 +29,5 @@ function WithEnumerable(enumerable, keys, result) {
             value: enumerable[key]
         });
     }
-}
-// ------------------------------------------------------------------
-// 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);
+    return Freeze(result);
 }

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

@@ -16,17 +16,6 @@ export interface TSettings {
      * @default 8
      */
     maxErrors: number;
-    /**
-     * Specifies the maximum number of errors to gather for failed Parse operations. TypeBox will
-     * automatically run an error-gathering pass on failed Parses to attach diagnostics to the
-     * thrown exception. This setting controls the number of errors gathered in that pass. Higher
-     * values will reduce throughput on failure cases, so a maximum of 4 is recommended if more
-     * errors are needed. The default setting of 1 will terminate on the first error, while a
-     * setting of 0 will skip error gathering entirely.
-     *
-     * @default 1
-     */
-    maxParseErrors: number;
     /**
      * Specifies the maximum number of instantiations allowed within a top-level generic instantiation
      * context. This setting can be used to bound generic calls to a fixed count, which can be useful if

package/node_modules/typebox/build/system/settings/settings.mjs

@@ -1,12 +1,8 @@
 import { Guard } from '../../guard/index.mjs';
-// -------------------------------------------------------------------
-// State
-// -------------------------------------------------------------------
 // Internal mutable state
 const settings = {
     immutableTypes: false,
     maxErrors: 8,
-    maxParseErrors: 1,
     maxInstantiationCount: 128,
     useAcceleration: true,
     exactOptionalPropertyTypes: false,
@@ -14,14 +10,10 @@ const settings = {
     correctiveParse: false,
     unionPrioritySort: true
 };
-// -------------------------------------------------------------------
-// Reset
-// -------------------------------------------------------------------
 /** Resets system settings to defaults */
 export function Reset() {
     settings.immutableTypes = false;
     settings.maxErrors = 8;
-    settings.maxParseErrors = 1;
     settings.maxInstantiationCount = 128;
     settings.useAcceleration = true;
     settings.exactOptionalPropertyTypes = false;
@@ -29,9 +21,6 @@ export function Reset() {
     settings.correctiveParse = false;
     settings.unionPrioritySort = true;
 }
-// -------------------------------------------------------------------
-// Set
-// -------------------------------------------------------------------
 /** Sets system settings */
 export function Set(options) {
     for (const key of Guard.Keys(options)) {
@@ -41,9 +30,6 @@ export function Set(options) {
         }
     }
 }
-// -------------------------------------------------------------------
-// Get
-// -------------------------------------------------------------------
 /** Gets current system settings */
 export function Get() {
     return settings;

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

@@ -1,11 +1,33 @@
+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 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;
+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;
 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;