diff --git a/examples/index.ts b/examples/index.ts
index 791529c88..576a0b569 100644
--- a/examples/index.ts
+++ b/examples/index.ts
@@ -1,141 +1,107 @@
-import { TypeSystem } from '@sinclair/typebox/system'
-import { TypeCompiler } from '@sinclair/typebox/compiler'
-import { Value, ValuePointer } from '@sinclair/typebox/value'
-import { Type,  Accessor, TemplateLiteralParser, TemplateLiteralFinite, TemplateLiteralResolver, TypeGuard, TIntersect, TUnion, TTemplateLiteral, IsTemplateLiteralFiniteCheck, UnionToTuple, Static, TSchema, TLiteralValue, TLiteral, TNumber, TInteger, TBigInt, TString, IndexerOptions, PatternNumber } from '@sinclair/typebox'
-import { TObject } from '@sinclair/typebox'
-
-//   function TTemplateLiteral(schema: TTemplateLiteral, options: IndexerOptions): string[] {
-//     const expression = TemplateLiteralParser.ParseExact(schema.pattern)
-//     const finite = TemplateLiteralFinite.Check(expression)
-//     if (!finite && options.includePatterns) return [schema.pattern]
-//     if (!finite && !options.includePatterns) return []
-//     const resolved = TemplateLiteralResolver.Resolve(schema)
-//     return TypeGuard.TUnionLiteral(resolved) ? resolved.anyOf.map((schema) => schema.const.toString()) : []
-//   }
-
 // --------------------------------------------------------------------------
-// TIndexer
+// Accessor
 // --------------------------------------------------------------------------
-export type TIndexerTemplateLiteral<T extends TTemplateLiteral, F = IsTemplateLiteralFiniteCheck<T>> = F extends true ? UnionToTuple<Static<T>> : []
-export type TIndexerUnion<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...TIndexer<L>, ...TIndexerUnion<R>] : []
-export type TIndexerLiteral<T extends TLiteralValue> = T extends PropertyKey ? [T] : []
-// prettier-ignore
-export type TIndexer<T extends TSchema> =
-  T extends TTemplateLiteral ? TIndexerTemplateLiteral<T> :
-  T extends TUnion<infer S> ? TIndexerUnion<S> :
-  T extends TLiteral<infer S> ? TIndexerLiteral<S> :
-  T extends TNumber ? ['number'] :  // tuple + array indexing
-  T extends TInteger ? ['number'] : // tuple + array indexing
-  []
 
-export namespace Indexer {
-  function TTemplateLiteral(schema: TTemplateLiteral): string[] {
-    const expression = TemplateLiteralParser.ParseExact(schema.pattern)
-    const finite = TemplateLiteralFinite.Check(expression)
-    if (!finite) return []
-    const resolved = TemplateLiteralResolver.Resolve(schema)
-    return TypeGuard.TUnionLiteral(resolved) ? resolved.anyOf.map((schema) => schema.const.toString()) : []
-  }
-  function Union(schema: TSchema[]): string[] {
-    const [L, ...R] = schema
-    return (schema.length > 0) ? [...Keys(L), ...Union(R)] : []
-  }
-  function TLiteral(schema: TLiteral): string[] {
-    return [schema.const.toString()]
-  }
-  function Visit(schema: TSchema) {
-    return (
-      TypeGuard.TTemplateLiteral(schema) ? TTemplateLiteral(schema) :
-      TypeGuard.TUnion(schema) ? Union(schema.anyOf) :
-      TypeGuard.TLiteral(schema) ? TLiteral(schema) :
-      TypeGuard.TNumber(schema) ? ['number'] :  // tuple + array indexing
-      TypeGuard.TInteger(schema) ? ['number'] : // tuple + array indexing
-      []
-    )
-  }
-  export function Pattern(schema: TSchema) {
-    const keys = Keys(schema)
-    const pattern = keys.map((key) => key === 'number' ? PatternNumber : key)
-    return `^(${pattern.join('|')})$`
-  }
-  export function Keys(schema: TSchema) {
-    return [...new Set(Visit(schema))]
-  }
-}
+import { Type, Optional, TOptional, TReadonly, TObject, TTuple, TIntersect, TUnion, Kind, TSchema, TypeClone, TypeGuard, ValueGuard, TPropertyKey, SchemaOptions, TProperties, TNever, TRecursive, TArray, Discard, TNumber, TString, TBoolean } from "@sinclair/typebox"
 
-const K = Indexer.Pattern(Type.Union([
-  Type.String(),
-  Type.Number(),
-  Type.String()
-]))
+export function Into<T>(func: () => T): T {
+  return func()
+}
 
+const T = Type.Object({
+  x: Type.String(),
+  y: Type.Union([
+    Type.Number(),
+    Type.BigInt()
+  ])
+})
 
+const I = Type.Index(T, Type.KeyOf(T))
 
-console.log(K)
 
-// export interface IndexerOptions {
-//   includePatterns: boolean
-// }
+// ------------------------------------------------------------------
+// Accessor
+// ------------------------------------------------------------------
+// export type TAccessorProperty<T extends TProperties, K extends PropertyKey> = K extends keyof T ? T[K] : TNever
+// export type TAccessorTuple<T extends TSchema[], K extends PropertyKey> = K extends keyof T ? T[K] : K extends 'number' ? UnionTypeResolve<T> : TNever
+// export type TAccessorArray<T extends TSchema, K extends PropertyKey> = K extends number ? T : TNever
 // // prettier-ignore
-// export namespace Indexer {
-//   function UnwrapPattern(key: string) {
-//     return key[0] === '^' && key[key.length - 1] === '$' ? key.slice(1, key.length - 1) : key
-//   }
+// export type TAccessorRest<T extends TSchema[], K extends PropertyKey> =
+//   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+//   ? TAccessorKey<L, K> extends infer N extends TSchema
+//     ? N extends TNever
+//       ? [...TAccessorRest<R, K>]
+//       : [N, ...TAccessorRest<R, K>]
+//     : []
+//   : []
+// // prettier-ignore
+// export type TAccessorKey<T extends TSchema, K extends PropertyKey> =
+//   T extends TRecursive<infer S> ? TAccessorKey<S, K> :
+//   T extends TIntersect<infer S> ? IntersectTypeResolve<TAccessorRest<S, K>> :
+//   T extends TUnion<infer S> ? UnionTypeResolve<TAccessorRest<S, K>> :
+//   T extends TTuple<infer S> ? TAccessorTuple<S, K> :
+//   T extends TArray<infer S> ? TAccessorArray<S, K> :
+//   T extends TObject<infer S> ? TAccessorProperty<S, K> :
+//   TNever
+// // prettier-ignore
+// export type TAccessorKeys<T extends TSchema, K extends PropertyKey[]> =
+//   K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+//     ? [TAccessorKey<T, L>, ...TAccessorKeys<T, R>]
+//     : []
 
-//   function TIntersect(schema: TIntersect, options: IndexerOptions): string[] {
-//     return schema.allOf.reduce((acc, schema) => [...acc, ...Visit(schema, options)], [] as string[])
-//   }
-//   function TUnion(schema: TUnion, options: IndexerOptions): string[] {
-//     const sets = schema.anyOf.reduce((acc, schema) => [...acc, ...Visit(schema, options)], [] as string[])
-//     console.log('Accessor Union', sets)
-//     return [...sets.reduce((set, outer) => outer.map((key) => (sets.every((inner) => inner.includes(key)) ? set.add(key) : set))[0], new Set<string>())]
-//   }
-//   function TObject(schema: TObject, options: IndexerOptions): string[] {
-//     return Object.getOwnPropertyNames(schema.properties)
-//   }
-//   function TRecord(schema: TRecord, options: IndexerOptions): string[] {
-//     return options.includePatterns ? Object.getOwnPropertyNames(schema.patternProperties) : []
+// export type TAccessor<T extends TSchema, K extends PropertyKey[]> = UnionTypeResolve<TAccessorKeys<T, K>>
+
+// // prettier-ignore
+// export namespace Accessor {
+//   function Property(T: TProperties, K: PropertyKey): TSchema  {
+//     return K in T ? T[K as string] : Type.Never()
 //   }
-//   function TLiteral(schema: TLiteral, options: IndexerOptions): string[] {
-//     return [schema.const.toString()]
+//   function Tuple(T: TSchema[], K: PropertyKey): TSchema  {
+//     return K in T ? T[K as number] : K === 'number' ? Union.Resolve(T) : Type.Never()
 //   }
-//   function TNumber(schema: TNumber, options: IndexerOptions): string[] {
-//     return ['number']
+//   function Array(T: TSchema, K: PropertyKey): TSchema  {
+//     return K === 'number' ? T : Type.Never()
 //   }
-//   function TInteger(schema: TInteger, options: IndexerOptions): string[] {
-//     return ['number']
+//   function Rest(T: TSchema[], K: PropertyKey): TSchema[] {
+//     const [L, ...R] = T
+//     return T.length > 0
+//       ? Into(() => {
+//         const N = Key(L, K)
+//         return TypeGuard.TNever(N)
+//           ? [...Rest(R, K)]
+//           : [N, ...Rest(R, K)]
+//       })
+//       : []
 //   }
-//   function Visit(schema: TSchema, options: IndexerOptions): string[] {
+//   function Key(T: TSchema, K: PropertyKey) {
 //     return (
-//       TypeGuard.TTemplateLiteral(schema) ? TTemplateLiteral(schema, options) :
-//       TypeGuard.TIntersect(schema) ? TIntersect(schema, options) :
-//       TypeGuard.TUnion(schema) ? TUnion(schema, options) :
-//       TypeGuard.TObject(schema) ? TObject(schema, options) :
-//       TypeGuard.TRecord(schema) ? TRecord(schema, options) :
-//       TypeGuard.TLiteral(schema) ? TLiteral(schema, options) :
-//       TypeGuard.TInteger(schema) ? TInteger(schema, options) :
-//       TypeGuard.TNumber(schema) ? TNumber(schema, options) :
-//       []
+//       TypeGuard.TIntersect(T) ? Intersect.Resolve(Rest(T.allOf, K)) :
+//       TypeGuard.TUnion(T) ? Union.Resolve(Rest(T.anyOf, K)) :
+//       TypeGuard.TTuple(T) ? Tuple(T.items ?? [], K) :
+//       TypeGuard.TArray(T) ? Array(T.items, K) :
+//       TypeGuard.TObject(T) ? Property(T.properties, K) :
+//       Type.Never()
 //     )
 //   }
-//   /** Resolves a regular expression pattern matching all keys in this schema */
-//   export function Pattern(schema: TSchema): string {
-//     const keys = Keys(schema, { includePatterns: true })
-//     const pattern = keys.map((key) => `(${UnwrapPattern(key)})`)
-//     return `^(${pattern.join('|')})$`
+//   function Keys(T: TSchema, K: PropertyKey[]): TSchema[] {
+//     const [L, ...R] = K
+//     return (K.length > 0)
+//       ? [Key(T, L), ...Keys(T, R)]
+//       : []
 //   }
-//   /** Resolves an array of keys derived from this schema */
-//   export function Keys(schema: TSchema, options: IndexerOptions): string[] {
-//     console.log('Indexer', Visit(schema, options))
-//     return [...new Set(Visit(schema, options))]
+//   export function Resolve(schema: TSchema, keys: PropertyKey[]) {
+//     return Union.Resolve(Keys(schema, keys))
 //   }
 // }
 
-// const T = Type.Object({
-//   0: Type.Number(),
-//   1: Type.String(),
-//   2: Type.Boolean(),
-// })
-// const I = Type.Index(T, Type.Union([Type.Literal(0), Type.Literal(2)]))
+// const T = Type.Composite([
+//   Type.Object({ x: Type.Optional(Type.Number()) }),
+//   Type.Object({ x: Type.Optional(Type.Number()) })
+// ])
+
+// const A = Accessor.Resolve(T, ['x'])
+// const I = Type.Index(T, ['x'])
+
+
 
-// console.log(I)
+// console.log(A)
\ No newline at end of file
diff --git a/examples/next/accessor.ts b/examples/next/accessor.ts
new file mode 100644
index 000000000..b624ce3ec
--- /dev/null
+++ b/examples/next/accessor.ts
@@ -0,0 +1,101 @@
+// // --------------------------------------------------------------------------
+// // Accessor
+// // --------------------------------------------------------------------------
+
+// import { Type, Optional, TObject, TTuple, TIntersect, TUnion, Kind, TSchema, TypeClone, TypeGuard, ValueGuard, TPropertyKey, SchemaOptions, TProperties, TNever, IntersectType, TRecursive, TArray, UnionTypeResolve } from "@sinclair/typebox"
+
+// // ------------------------------------------------------------------
+// // TAccessor
+// // ------------------------------------------------------------------
+// export type TAccessorProperty<T extends TProperties, K extends PropertyKey> = K extends keyof T ? T[K] : TNever
+// export type TAccessorTuple<T extends TSchema[], K extends PropertyKey> = K extends keyof T ? T[K] : K extends 'number' ? UnionTypeResolve<T> : TNever
+// export type TAccessorArray<T extends TSchema, K extends PropertyKey> = K extends number ? T : TNever
+// // prettier-ignore
+// export type TAccessorRest<T extends TSchema[], K extends PropertyKey> =
+//   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+//   ? TIndexKey<L, K> extends infer N extends TSchema
+//   ? N extends TNever
+//   ? [...TAccessorRest<R, K>]
+//   : [N, ...TAccessorRest<R, K>]
+//   : []
+//   : []
+// // prettier-ignore
+// export type TIndexKey<T extends TSchema, K extends PropertyKey> =
+//   T extends TRecursive<infer S> ? TIndexKey<S, K> :
+//   T extends TIntersect<infer S> ? IntersectType.Resolve<TAccessorRest<S, K>> :
+//   T extends TUnion<infer S> ? UnionTypeResolve<TAccessorRest<S, K>> :
+//   T extends TTuple<infer S> ? TAccessorTuple<S, K> :
+//   T extends TArray<infer S> ? TAccessorArray<S, K> :
+//   T extends TObject<infer S> ? TAccessorProperty<S, K> :
+//   TNever
+// // prettier-ignore
+// export type TAccessorKeys<T extends TSchema, K extends PropertyKey[]> =
+//   K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+//   ? [TIndexKey<T, L>, ...TAccessorKeys<T, R>]
+//   : []
+
+// export type TAccessor<T extends TSchema, K extends PropertyKey[]> = UnionTypeResolve<TAccessorKeys<T, K>>
+
+// // prettier-ignore
+// export namespace Accessor {
+//   function OptionalUnwrap(schema: TSchema[]): TSchema[] {
+//     return schema.map((schema) => {
+//       const { [Optional]: _, ...clone } = TypeClone.Type(schema)
+//       return clone
+//     })
+//   }
+//   function IsIntersectOptional(schema: TSchema[]): boolean {
+//     return schema.every((schema) => TypeGuard.TOptional(schema))
+//   }
+//   function IsUnionOptional(schema: TSchema[]): boolean {
+//     return schema.some((schema) => TypeGuard.TOptional(schema))
+//   }
+//   function ResolveIntersect(schema: TIntersect): TSchema {
+//     return IsIntersectOptional(schema.allOf) ? Type.Optional(Type.Intersect(OptionalUnwrap(schema.allOf))) : schema
+//   }
+//   function ResolveUnion(schema: TUnion): TSchema {
+//     return IsUnionOptional(schema.anyOf) ? Type.Optional(Type.Union(OptionalUnwrap(schema.anyOf))) : schema
+//   }
+//   function ResolveOptional(schema: TSchema) {
+//     return (
+//       schema[Kind] === 'Intersect' ? ResolveIntersect(schema as TIntersect) :
+//       schema[Kind] === 'Union' ? ResolveUnion(schema as TUnion) :
+//       schema
+//     )
+//   }
+//   function TIntersect(schema: TIntersect, key: string): TSchema {
+//     const resolved = schema.allOf.reduce((acc, schema) => {
+//       const indexed = Visit(schema, key)
+//       return indexed[Kind] === 'Never' ? acc : [...acc, indexed]
+//     }, [] as TSchema[])
+//     return ResolveOptional(Type.Intersect(resolved))
+//   }
+//   function TUnion(schema: TUnion, key: string): TSchema {
+//     const resolved = schema.anyOf.map((schema) => Visit(schema, key))
+//     return ResolveOptional(Type.Union(resolved))
+//   }
+//   function TObject(schema: TObject, key: string): TSchema {
+//     const property = schema.properties[key]
+//     return ValueGuard.IsUndefined(property) ? Type.Never() : Type.Union([property])
+//   }
+//   function TTuple(schema: TTuple, key: string): TSchema {
+//     const items = schema.items
+//     if (ValueGuard.IsUndefined(items)) return Type.Never()
+//     const element = items[key as any as number] //
+//     if (ValueGuard.IsUndefined(element)) return Type.Never()
+//     return element
+//   }
+//   function Visit(schema: TSchema, key: string): TSchema {
+//     return (
+//       schema[Kind] === 'Intersect' ? TIntersect(schema as TIntersect, key) :
+//       schema[Kind] === 'Union' ? TUnion(schema as TUnion, key) :
+//       schema[Kind] === 'Object' ? TObject(schema as TObject, key) :
+//       schema[Kind] === 'Tuple' ? TTuple(schema as TTuple, key) :
+//       Type.Never()
+//     )
+//   }
+//   export function Resolve(schema: TSchema, keys: TPropertyKey[], options: SchemaOptions = {}): TSchema {
+//     const resolved = keys.map((key) => Visit(schema, key.toString()))
+//     return ResolveOptional(Type.Union(resolved, options))
+//   }
+// }
\ No newline at end of file
diff --git a/examples/next/distinct.ts b/examples/next/distinct.ts
new file mode 100644
index 000000000..6bea27e08
--- /dev/null
+++ b/examples/next/distinct.ts
@@ -0,0 +1,33 @@
+// ------------------------------------------------------------------
+// Distinct
+// ------------------------------------------------------------------
+import { TSchema, TypeExtends, TypeExtendsResult } from "@sinclair/typebox"
+
+// prettier-ignore
+export type TDistinctIncludes<T extends TSchema[], C extends TSchema> =
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+  ? C extends L
+    ? true
+    : TDistinctIncludes<R, C>
+  : false
+// prettier-ignore
+export type TDistinct<T extends TSchema[], Acc extends TSchema[] = []> =
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+  ? TDistinctIncludes<Acc, L> extends false
+    ? TDistinct<R, [...Acc, L]>
+    : TDistinct<R, [...Acc]>
+  : Acc
+
+export namespace Distinct {
+  function DistinctIncludes(schemas: TSchema[], candidate: TSchema) {
+    return schemas.find((schema) => TypeExtends.Extends(candidate, schema) === TypeExtendsResult.True) !== undefined
+  }
+  // prettier-ignore
+  export function Distinct<T extends TSchema[]>(schemas: [...T]): TDistinct<T> {
+    return schemas.reduce((acc, candidate) => {
+      return !DistinctIncludes(acc, candidate)
+        ? [...acc, candidate]
+        : [...acc]
+    }, [] as TSchema[]) as TDistinct<T>
+  }
+}
\ No newline at end of file
diff --git a/examples/next/indexer.ts b/examples/next/indexer.ts
new file mode 100644
index 000000000..7c9156938
--- /dev/null
+++ b/examples/next/indexer.ts
@@ -0,0 +1,55 @@
+import { TypeSystem } from '@sinclair/typebox/system'
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { Value, ValuePointer } from '@sinclair/typebox/value'
+import { Type,  Accessor, TemplateLiteralParser, TemplateLiteralFinite, TemplateLiteralResolver, TypeGuard, TIntersect, TUnion, TTemplateLiteral, IsTemplateLiteralFiniteCheck, UnionToTuple, Static, TSchema, TLiteralValue, TLiteral, TNumber, TInteger, TBigInt, TString, IndexerOptions, PatternNumber } from '@sinclair/typebox'
+import { TObject } from '@sinclair/typebox'
+
+// --------------------------------------------------------------------------
+// TIndexer
+// --------------------------------------------------------------------------
+export type TIndexerTemplateLiteral<T extends TTemplateLiteral, F = IsTemplateLiteralFiniteCheck<T>> = F extends true ? UnionToTuple<Static<T>> : []
+export type TIndexerUnion<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...TIndexer<L>, ...TIndexerUnion<R>] : []
+export type TIndexerLiteral<T extends TLiteralValue> = T extends PropertyKey ? [T] : []
+// prettier-ignore
+export type TIndexer<T extends TSchema> =
+  T extends TTemplateLiteral ? TIndexerTemplateLiteral<T> :
+  T extends TUnion<infer S> ? TIndexerUnion<S> :
+  T extends TLiteral<infer S> ? TIndexerLiteral<S> :
+  T extends TNumber ? ['number'] :  // tuple + array indexing
+  T extends TInteger ? ['number'] : // tuple + array indexing
+  []
+
+export namespace Indexer {
+  function TTemplateLiteral(schema: TTemplateLiteral): string[] {
+    const expression = TemplateLiteralParser.ParseExact(schema.pattern)
+    const finite = TemplateLiteralFinite.Check(expression)
+    if (!finite) return []
+    const resolved = TemplateLiteralResolver.Resolve(schema)
+    return TypeGuard.TUnionLiteral(resolved) ? resolved.anyOf.map((schema) => schema.const.toString()) : []
+  }
+  function Union(schema: TSchema[]): string[] {
+    const [L, ...R] = schema
+    return (schema.length > 0) ? [...Keys(L), ...Union(R)] : []
+  }
+  function TLiteral(schema: TLiteral): string[] {
+    return [schema.const.toString()]
+  }
+  function Visit(schema: TSchema) {
+    return (
+      TypeGuard.TTemplateLiteral(schema) ? TTemplateLiteral(schema) :
+      TypeGuard.TUnion(schema) ? Union(schema.anyOf) :
+      TypeGuard.TLiteral(schema) ? TLiteral(schema) :
+      TypeGuard.TNumber(schema) ? ['number'] :  // tuple + array indexing
+      TypeGuard.TInteger(schema) ? ['number'] : // tuple + array indexing
+      []
+    )
+  }
+  export function Pattern(schema: TSchema) {
+    const keys = Keys(schema)
+    const pattern = keys.map((key) => key === 'number' ? PatternNumber : key)
+    return `^(${pattern.join('|')})$`
+  }
+  export function Keys(schema: TSchema) {
+    return [...new Set(Visit(schema))]
+  }
+}
diff --git a/examples/prototypes/const.ts b/examples/prototypes/const.ts
index 75399a0aa..ef6289879 100644
--- a/examples/prototypes/const.ts
+++ b/examples/prototypes/const.ts
@@ -26,7 +26,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { Type, ObjectMap, TypeGuard, TSchema, TIntersect, TUnion, TObject, TProperties, TReadonly, AssertProperties, AssertType, AssertRest, Evaluate, ReadonlyUnwrapType } from '@sinclair/typebox'
+import { Type, ObjectMap, TypeGuard, TSchema, TIntersect, TUnion, TObject, TProperties, TReadonly, AssertProperties, AssertType, AssertRest, Evaluate, ModifiersRemoveReadonly } from '@sinclair/typebox'
 
 // -------------------------------------------------------------------------------------
 // TConst
@@ -37,7 +37,7 @@ export type TConstArray<T extends TSchema[], E extends boolean> = T extends [inf
   : []
 // prettier-ignore
 export type TConstProperties<T extends TProperties, E extends boolean> = Evaluate<AssertProperties<{
-  [K in keyof T]: TConst<ReadonlyUnwrapType<T[K]>, E>
+  [K in keyof T]: TConst<ModifiersRemoveReadonly<T[K]>, E>
 }>>
 // prettier-ignore
 export type TConst<T extends TSchema, E extends boolean> =
diff --git a/examples/prototypes/evaluate.ts b/examples/prototypes/evaluate.ts
index 5fa7b2128..576cf06bb 100644
--- a/examples/prototypes/evaluate.ts
+++ b/examples/prototypes/evaluate.ts
@@ -44,7 +44,7 @@ import {
   TTuple, 
   TProperties, 
   TIntersect, 
-  IntersectType, 
+  IntersectTypeResolve, 
   TUnion, 
   TNever 
 } from '@sinclair/typebox'
@@ -75,7 +75,7 @@ export type TEvaluateArray<T extends TSchema[]> =  T extends [infer L, ...infer
   []
 // prettier-ignore
 export type TEvaluate<T extends TSchema> = 
-  T extends TIntersect<infer S>            ? IntersectType<TEvaluateIntersectRest<S>> :
+  T extends TIntersect<infer S>            ? IntersectTypeResolve<TEvaluateIntersectRest<S>> :
   T extends TUnion<infer S>                ? TUnion<TEvaluateArray<S>> :
   T extends TConstructor<infer P, infer R> ? TConstructor<TEvaluateArray<P>, TEvaluate<R>> : 
   T extends TFunction<infer P, infer R>    ? TFunction<TEvaluateArray<P>, TEvaluate<R>> : 
diff --git a/src/typebox.ts b/src/typebox.ts
index 9fadd4219..7c972027f 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -44,6 +44,10 @@ export const PatternBooleanExact = `^${PatternBoolean}$`
 export const PatternNumberExact = `^${PatternNumber}$`
 export const PatternStringExact = `^${PatternString}$`
 // --------------------------------------------------------------------------
+// Into
+// --------------------------------------------------------------------------
+export const Into = <T>(func: () => T): T => func()
+// --------------------------------------------------------------------------
 // Helpers
 // --------------------------------------------------------------------------
 export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never
@@ -70,93 +74,6 @@ export type TReadonlyOptional<T extends TSchema> = TOptional<T> & TReadonly<T>
 export type TReadonly<T extends TSchema> = T & { [Readonly]: 'Readonly' }
 export type TOptional<T extends TSchema> = T & { [Optional]: 'Optional' }
 // --------------------------------------------------------------------------
-// Readonly Unwrap
-// --------------------------------------------------------------------------
-
-export type ReadonlyUnwrapType<T extends TSchema> =
-  T extends TReadonly<infer S extends TSchema> ? ReadonlyUnwrapType<S> :
-  T extends TOptional<infer S extends TSchema> ? TOptional<ReadonlyUnwrapType<S>> :
-  T
-// prettier-ignore
-export type ReadonlyUnwrapRest<T extends TSchema[]> =
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-  ? L extends TReadonly<infer S extends TSchema>
-  ? [ReadonlyUnwrapType<S>, ...ReadonlyUnwrapRest<R>]
-  : [L, ...ReadonlyUnwrapRest<R>]
-  : []
-// --------------------------------------------------------------------------
-// Optional Unwrap
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type OptionalUnwrapType<T extends TSchema> =
-  T extends TReadonly<infer S extends TSchema> ? TReadonly<OptionalUnwrapType<S>> :
-  T extends TOptional<infer S extends TSchema> ? OptionalUnwrapType<S> :
-  T
-// prettier-ignore
-export type OptionalUnwrapRest<T extends TSchema[]> =
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-  ? L extends TOptional<infer S extends TSchema>
-  ? [OptionalUnwrapType<S>, ...OptionalUnwrapRest<R>]
-  : [L, ...OptionalUnwrapRest<R>]
-  : []
-// ------------------------------------------------------------------
-// DistinctRest
-// ------------------------------------------------------------------
-// prettier-ignore
-export type DistinctRestIncludes<T extends TSchema[], C extends TSchema> =
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-  ? C extends L
-  ? true
-  : DistinctRestIncludes<R, C>
-  : false
-// prettier-ignore
-export type DistinctRest<T extends TSchema[], Acc extends TSchema[] = []> =
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-  ? DistinctRestIncludes<Acc, L> extends false
-  ? DistinctRest<R, [...Acc, L]>
-  : DistinctRest<R, [...Acc]>
-  : Acc
-// --------------------------------------------------------------------------
-// IntersectType
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type IntersectTypeIsOptional<T extends TSchema[]> =
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-  ? L extends TOptional<L>
-  ? IntersectTypeIsOptional<R>
-  : false
-  : true
-// prettier-ignore
-export type IntersectTypeOptional<T extends TSchema[], U extends TSchema[] = OptionalUnwrapRest<T>> =
-  IntersectTypeIsOptional<T> extends true
-  ? TOptional<TIntersect<U>>
-  : TIntersect<U>
-// prettier-ignore
-export type IntersectType<T extends TSchema[], D extends TSchema[] = T> = //extends TSchema[] = DistinctRest<T>> =
-  D extends [] ? TNever :
-  D extends [TSchema] ? T[0] :
-  IntersectTypeOptional<D>
-// --------------------------------------------------------------------------
-// UnionType
-// --------------------------------------------------------------------------
-// prettier-ignore
-export type UnionTypeIsOptional<T extends TSchema[]> =
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-  ? L extends TOptional<L>
-  ? true
-  : UnionTypeIsOptional<R>
-  : false
-// prettier-ignore
-export type UnionTypeOptional<T extends TSchema[], U extends TSchema[] = OptionalUnwrapRest<T>> =
-  UnionTypeIsOptional<T> extends true
-  ? TOptional<TUnion<U>>
-  : TUnion<U>
-// prettier-ignore
-export type UnionType<T extends TSchema[], D extends TSchema[] = T> = // = DistinctRest<T>> = 
-  D extends [] ? TNever :
-  D extends [TSchema] ? T[0] :
-  UnionTypeOptional<D>
-// --------------------------------------------------------------------------
 // TSchema
 // --------------------------------------------------------------------------
 export interface SchemaOptions {
@@ -388,12 +305,12 @@ export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U
 // --------------------------------------------------------------------------
 // TExclude
 // --------------------------------------------------------------------------
-export type TExcludeTemplateLiteralResult<T extends string> = UnionType<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
+export type TExcludeTemplateLiteralResult<T extends string> = UnionType.Resolve<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
 export type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never
 // prettier-ignore
 export type TExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
   [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K]
-}[number]>> extends infer R extends TSchema[] ? UnionType<R> : never
+}[number]>> extends infer R extends TSchema[] ? UnionType.Resolve<R> : never
 // prettier-ignore
 export type TExclude<T extends TSchema, U extends TSchema> =
   T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> :
@@ -402,12 +319,12 @@ export type TExclude<T extends TSchema, U extends TSchema> =
 // --------------------------------------------------------------------------
 // TExtract
 // --------------------------------------------------------------------------
-export type TExtractTemplateLiteralResult<T extends string> = UnionType<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
+export type TExtractTemplateLiteralResult<T extends string> = UnionType.Resolve<AssertRest<UnionToTuple<{ [K in T]: TLiteral<K> }[T]>>>
 export type TExtractTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never
 // prettier-ignore
 export type TExtractArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<
   { [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never
-  }[number]>> extends infer R extends TSchema[] ? UnionType<R> : never
+  }[number]>> extends infer R extends TSchema[] ? UnionType.Resolve<R> : never
 // prettier-ignore
 export type TExtract<T extends TSchema, U extends TSchema> =
   T extends TTemplateLiteral ? TExtractTemplateLiteral<T, U> :
@@ -446,7 +363,7 @@ export type TIndexer<T extends TSchema> =
 // TIndex
 // ------------------------------------------------------------------
 export type TIndexProperty<T extends TProperties, K extends PropertyKey> = K extends keyof T ? T[K] : TNever
-export type TIndexTuple<T extends TSchema[], K extends PropertyKey> = K extends keyof T ? T[K] : K extends 'number' ? UnionType<T> : TNever
+export type TIndexTuple<T extends TSchema[], K extends PropertyKey> = K extends keyof T ? T[K] : K extends 'number' ? UnionType.Resolve<T> : TNever
 export type TIndexArray<T extends TSchema, K extends PropertyKey> = K extends number ? T : TNever
 // prettier-ignore
 export type TIndexRest<T extends TSchema[], K extends PropertyKey> =
@@ -460,8 +377,8 @@ export type TIndexRest<T extends TSchema[], K extends PropertyKey> =
 // prettier-ignore
 export type TIndexKey<T extends TSchema, K extends PropertyKey> =
   T extends TRecursive<infer S> ? TIndexKey<S, K> :
-  T extends TIntersect<infer S> ? IntersectType<TIndexRest<S, K>> :
-  T extends TUnion<infer S> ? UnionType<TIndexRest<S, K>> :
+  T extends TIntersect<infer S> ? IntersectType.Resolve<TIndexRest<S, K>> :
+  T extends TUnion<infer S> ? UnionType.Resolve<TIndexRest<S, K>> :
   T extends TTuple<infer S> ? TIndexTuple<S, K> :
   T extends TArray<infer S> ? TIndexArray<S, K> :
   T extends TObject<infer S> ? TIndexProperty<S, K> :
@@ -472,7 +389,7 @@ export type TIndexKeys<T extends TSchema, K extends PropertyKey[]> =
   ? [TIndexKey<T, L>, ...TIndexKeys<T, R>]
   : []
 
-export type TIndex<T extends TSchema, K extends PropertyKey[]> = UnionType<TIndexKeys<T, K>>
+export type TIndex<T extends TSchema, K extends PropertyKey[]> = UnionType.Resolve<TIndexKeys<T, K>>
 // --------------------------------------------------------------------------
 // TIntrinsic
 // --------------------------------------------------------------------------
@@ -561,7 +478,7 @@ export type TKeyOf<T extends TSchema = TSchema> = (
   T extends TArray ? [TNumber] :
   T extends TRecord<infer K> ? [K] :
   []
-) extends infer R ? UnionType<AssertRest<R>> : never
+) extends infer R ? UnionType.Resolve<AssertRest<R>> : never
 // --------------------------------------------------------------------------
 // TLiteral
 // --------------------------------------------------------------------------
@@ -866,7 +783,7 @@ export type TTemplateLiteralDslParserUnionLiteral<T extends string> =
   T extends `${infer L}|${infer R}` ? [TLiteral<Trim<L>>, ...TTemplateLiteralDslParserUnionLiteral<R>] :
   T extends `${infer L}` ? [TLiteral<Trim<L>>] :
   []
-export type TTemplateLiteralDslParserUnion<T extends string> = UnionType<TTemplateLiteralDslParserUnionLiteral<T>>
+export type TTemplateLiteralDslParserUnion<T extends string> = UnionType.Resolve<TTemplateLiteralDslParserUnionLiteral<T>>
 // prettier-ignore
 export type TTemplateLiteralDslParserTerminal<T extends string> =
   T extends 'boolean' ? TBoolean :
@@ -1002,7 +919,7 @@ export type TUnionLiteralKeyRest<T extends TUnion<TLiteral<string | number>[]>>
 // TUnion
 // --------------------------------------------------------------------------
 // prettier-ignore
-export type TUnionTemplateLiteral<T extends TTemplateLiteral, S extends string = Static<T>> = Ensure<UnionType<Assert<UnionToTuple<{ [K in S]: TLiteral<K> }[S]>, TLiteral[]>>>
+export type TUnionTemplateLiteral<T extends TTemplateLiteral, S extends string = Static<T>> = Ensure<UnionType.Resolve<Assert<UnionToTuple<{ [K in S]: TLiteral<K> }[S]>, TLiteral[]>>>
 export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
   [Kind]: 'Union'
   static: { [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : never }[number]
@@ -1126,6 +1043,19 @@ export namespace FormatRegistry {
     return map.get(format)
   }
 }
+// ------------------------------------------------------------------
+// Discard
+// ------------------------------------------------------------------
+/** Discards properties from record types */
+export namespace Discard {
+  function Key(value: Record<PropertyKey, any>, key: PropertyKey) {
+    const { [key]: _, ...rest } = value
+    return rest
+  }
+  export function Keys(value: Record<PropertyKey, any>, keys: PropertyKey[]) {
+    return keys.reduce((acc, key) => Key(acc, key), value)
+  }
+}
 // --------------------------------------------------------------------------
 // ValueGuard
 // --------------------------------------------------------------------------
@@ -1651,6 +1581,139 @@ export namespace TypeGuard {
       )
   }
 }
+// ----------------------------------------------------------------
+// Modifiers
+// ----------------------------------------------------------------
+// prettier-ignore
+export namespace Modifiers {
+  // ----------------------------------------------------------------
+  // isOptionalIntersect
+  // ----------------------------------------------------------------
+  export type IsOptionalIntersect<T extends TSchema[]> = 
+    T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
+      ? L extends TOptional<TSchema> 
+        ? IsOptionalIntersect<R> 
+        : false 
+      : true
+  // IsOptional
+  function IsOptionalIntersect(T: TSchema[]): boolean {
+    const [L, ...R] = T
+    return T.length > 0 ? TypeGuard.TOptional(L) ? IsOptionalIntersect(R) : false : true
+  }
+  // ----------------------------------------------------------------
+  // IsOptionalUnion
+  // ----------------------------------------------------------------
+  export type IsOptionalUnion<T extends TSchema[]> = 
+    T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? 
+      L extends TOptional<TSchema> 
+        ? true 
+        : IsOptionalUnion<R> 
+      : false
+  function IsOptionalUnion(T: TSchema[]): boolean {
+    const [L, ...R] = T
+    return T.length > 0 ? TypeGuard.TOptional(L) ? true : IsOptionalUnion(R) : false
+  }
+  // ----------------------------------------------------------------
+  // RemoveReadonly
+  // ----------------------------------------------------------------
+  export type RemoveReadonlyRest<T extends TSchema[]> =
+    T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+      ? L extends TReadonly<infer S extends TSchema>
+        ? [RemoveReadonly<S>, ...RemoveReadonlyRest<R>]
+        : [L, ...RemoveReadonlyRest<R>]
+      : []
+  export type RemoveReadonly<T extends TSchema> =
+    T extends TReadonly<infer S extends TSchema> ? RemoveReadonly<S> :
+    T extends TOptional<infer S extends TSchema> ? TOptional<RemoveReadonly<S>> :
+    T
+  export function RemoveReadonlyRest(T: TSchema[]) {
+    return T.map(T => RemoveReadonly(T))
+  }
+  export function RemoveReadonly(T: TSchema): TSchema {
+    return Discard.Keys(T, [Optional]) as TSchema
+  }
+  // ----------------------------------------------------------------
+  // RemoveOptional
+  // ----------------------------------------------------------------
+  export type RemoveOptionalRest<T extends TSchema[]> =
+    T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? L extends TOptional<infer S extends TSchema>
+      ? [RemoveOptional<S>, ...RemoveOptionalRest<R>]
+      : [L, ...RemoveOptionalRest<R>]
+    : []
+  export type RemoveOptional<T extends TSchema> =
+    T extends TReadonly<infer S extends TSchema> ? TReadonly<RemoveOptional<S>> :
+    T extends TOptional<infer S extends TSchema> ? RemoveOptional<S> :
+    T
+  export function RemoveOptionalRest(T: TSchema[]) {
+    return T.map(T => RemoveOptional(T))
+  }
+  export function RemoveOptional(T: TSchema): TSchema {
+    return Discard.Keys(T, [Optional]) as TSchema
+  }
+  // ----------------------------------------------------------------
+  // ResolveOptionalIntersect
+  // ----------------------------------------------------------------
+  export type ResolveOptionalIntersect<T extends TSchema[]> = 
+    IsOptionalIntersect<T> extends true 
+      ? TOptional<TIntersect<RemoveOptionalRest<T>>> 
+      : TIntersect<T>
+  export function ResolveOptionalIntersect(T: TSchema[]): TIntersect {
+    const D = RemoveOptionalRest(T)
+    return IsOptionalIntersect(T)
+      ? Type.Optional(Type.Intersect(D))
+      : Type.Intersect(D)
+  }
+  // ----------------------------------------------------------------
+  // ResolveOptionalUnion
+  // ----------------------------------------------------------------
+  export type ResolveOptionalUnion<T extends TSchema[]> = 
+    IsOptionalUnion<T> extends true 
+      ? TOptional<TUnion<RemoveOptionalRest<T>>> 
+      : TUnion<T>
+  export function ResolveOptionalUnion(T: TSchema[]): TUnion{
+    const D = RemoveOptionalRest(T)
+    return IsOptionalUnion(T)
+      ? Type.Optional(Type.Union(D))
+      : Type.Union(D)
+  }
+}
+// ------------------------------------------------------------------
+// Intersect
+// ------------------------------------------------------------------
+// prettier-ignore
+export namespace IntersectType {
+  export type Resolve<T extends TSchema[]> = (
+    T extends [] ? TNever :
+    T extends [TSchema] ? T[0] :
+    Modifiers.ResolveOptionalIntersect<T>
+  )
+  export function Resolve(T: TSchema[]): TIntersect<TSchema[]> | TSchema {
+    return (
+      T.length === 0 ? Type.Never() :
+      T.length === 1 ? T[0] :
+      Modifiers.ResolveOptionalIntersect(T)
+    )
+  }
+}
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+export namespace UnionType {
+  export type Resolve<T extends TSchema[]> = (
+    T extends [] ? TNever :
+    T extends [TSchema] ? T[0] :
+    Modifiers.ResolveOptionalUnion<T>
+  )
+  export function Resolve(T: TSchema[]): TUnion<TSchema[]> | TSchema {
+    return (
+      T.length === 0 ? Type.Never() :
+      T.length === 1 ? T[0] :
+      Modifiers.ResolveOptionalUnion(T)
+    )
+  }
+}
 // --------------------------------------------------------------------------
 // ExtendsUndefined
 // --------------------------------------------------------------------------
@@ -2321,10 +2384,9 @@ export namespace TypeExtends {
   }
 }
 // --------------------------------------------------------------------------
-// TypeClone
+// Clone
 // --------------------------------------------------------------------------
-/** Specialized Clone for Types */
-export namespace TypeClone {
+export namespace Clone {
   function ArrayType(value: unknown[]) {
     return (value as any).map((value: unknown) => Visit(value as any))
   }
@@ -2339,36 +2401,66 @@ export namespace TypeClone {
     const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key as any]) }), {})
     return { ...clonedProperties, ...clonedSymbols }
   }
+  // prettier-ignore
   function Visit(value: unknown): any {
-    return ValueGuard.IsArray(value) ? ArrayType(value) : ValueGuard.IsDate(value) ? DateType(value) : ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) : ValueGuard.IsObject(value) ? ObjectType(value) : value
+    return (
+      ValueGuard.IsArray(value) ? ArrayType(value) : 
+      ValueGuard.IsDate(value) ? DateType(value) : 
+      ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) : 
+      ValueGuard.IsObject(value) ? ObjectType(value) : 
+      value
+    )
+  }
+  /** Clones a value */
+  export function Value<T>(value: T): T {
+    return Visit(value)
   }
+}
+// --------------------------------------------------------------------------
+// TypeClone
+// --------------------------------------------------------------------------
+/** Specialized Clone for Types */
+export namespace TypeClone {
   /** Clones a Rest */
   export function Rest<T extends TSchema[]>(schemas: [...T]): T {
     return schemas.map((schema) => Type(schema)) as T
   }
   /** Clones a Type */
   export function Type<T extends TSchema>(schema: T, options: SchemaOptions = {}): T {
-    return { ...Visit(schema), ...options }
+    return { ...Clone.Value(schema), ...options }
   }
 }
+// ------------------------------------------------------------------
+// Distinct
+// ------------------------------------------------------------------
+// prettier-ignore
+export type TDistinctIncludes<T extends TSchema[], C extends TSchema> =
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+  ? C extends L
+  ? true
+  : TDistinctIncludes<R, C>
+  : false
+// prettier-ignore
+export type TDistinct<T extends TSchema[], Acc extends TSchema[] = []> =
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+  ? TDistinctIncludes<Acc, L> extends false
+    ? TDistinct<R, [...Acc, L]>
+    : TDistinct<R, [...Acc]>
+  : Acc
 
-// --------------------------------------------------------------------------
-// DistinctRest
-// --------------------------------------------------------------------------
-export namespace DistinctRest {
+export namespace Distinct {
   function DistinctIncludes(schemas: TSchema[], candidate: TSchema) {
     return schemas.find((schema) => TypeExtends.Extends(candidate, schema) === TypeExtendsResult.True) !== undefined
   }
   // prettier-ignore
-  export function Distinct<T extends TSchema[]>(schemas: [...T]): DistinctRest<T> {
+  export function Distinct<T extends TSchema[]>(schemas: [...T]): TDistinct<T> {
     return schemas.reduce((acc, candidate) => {
       return !DistinctIncludes(acc, candidate)
         ? [...acc, candidate]
         : [...acc]
-    }, [] as TSchema[]) as DistinctRest<T>
+    }, [] as TSchema[]) as TDistinct<T>
   }
 }
-
 // --------------------------------------------------------------------------
 // Intrinsic
 // --------------------------------------------------------------------------
@@ -2580,7 +2672,6 @@ export namespace Accessor {
       schema[Kind] === 'Tuple' ? TTuple(schema as TTuple, key) :
       Type.Never()
     )
-
   }
   export function Resolve(schema: TSchema, keys: TPropertyKey[], options: SchemaOptions = {}): TSchema {
     const resolved = keys.map((key) => Visit(schema, key.toString()))