diff --git a/examples/index.ts b/examples/index.ts
index de5058a87..e75241a79 100644
--- a/examples/index.ts
+++ b/examples/index.ts
@@ -1,133 +1,155 @@
 import { TypeSystem } from '@sinclair/typebox/system'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
-import { Type, Static, TSchema, TProperties, TArray, TLiteral, TTemplateLiteral, TypeGuard, TemplateLiteralParser, TemplateLiteralGenerator, TemplateLiteralResolver } from '@sinclair/typebox'
+import {
+  Type,
+  Static,
+  TSchema,
+  TProperties,
+  TArray,
+  TLiteral,
+  TTemplateLiteral,
+  TypeGuard,
+  TemplateLiteralParser,
+  TemplateLiteralGenerator,
+  TemplateLiteralResolver,
+  TemplateLiteralFinite,
+  IsTemplateLiteralFiniteCheck,
+  KeyResolver,
+  TOptional,
+  UnionTypeIsOptional,
+} from '@sinclair/typebox'
 import { TObject, TUnion, UnionToTuple, TInteger, TBigInt, TIntersect, TString, TNumber, TBoolean, TNever, TTuple, UnionType, TRecursive } from '@sinclair/typebox'
 
-// ------------------------------------------------------------------
-// TIndex
-// ------------------------------------------------------------------
-// prettier-ignore
-export type TIndexProperties<T extends TProperties, K extends PropertyKey> =
-  K extends keyof T
-    ? [T[K]]
-    : []
-// prettier-ignore
-export type TIndexTuple<T extends TSchema[], K extends PropertyKey> =
-  K extends keyof T
-    ? [T[K]]
-    : []
-// prettier-ignore
-export type TIndexArray<T extends TSchema, K extends PropertyKey> =
-  K extends number
-    ? [T]
-    : []
-// prettier-ignore
-export type TIndexIntersect<T extends TSchema[], K extends PropertyKey> =
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? [...TIndexKey<L, K>, ...TIndexIntersect<R, K>]
-    : []
-// prettier-ignore
-export type TIndexUnionGather<T extends TSchema[], K extends PropertyKey> =
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? [TIndexKey<L, K>, ...TIndexUnionGather<R, K>]
-    : []
-// prettier-ignore
-export type TIndexUnionCheck<T extends TSchema[][]> =
-  T extends [infer L extends TSchema[], ...infer R extends TSchema[][]]
-    ? L extends []
-      ? false
-      : TIndexUnionCheck<R>
-    : true
-// prettier-ignore
-export type TIndexUnionFinal<T extends TSchema[][]> =
-  T extends [infer L extends TSchema[], ...infer R extends TSchema[][]]
-    ? [...L, ...TIndexUnionFinal<R>]
-    : []
-// prettier-ignore
-export type TIndexUnion<T extends TSchema[], K extends PropertyKey, G extends TSchema[][] = TIndexUnionGather<T, K>, C extends boolean = TIndexUnionCheck<G>> =
-  C extends true
-    ? TIndexUnionFinal<G>
-    : []
-// prettier-ignore
-export type TIndexKey<T extends TSchema, K extends PropertyKey> =
-  T extends TRecursive<infer S> ? TIndexKey<S, K> :
-  T extends TIntersect<infer S> ? TIndexIntersect<S, K> :
-  T extends TUnion<infer S> ? TIndexUnion<S, K> :
-  T extends TTuple<infer S> ? TIndexTuple<S, K> :
-  T extends TArray<infer S> ? TIndexArray<S, K> :
-  T extends TObject<infer S> ? TIndexProperties<S, K> :
-  []
-// prettier-ignore
-export type TIndexKeys<T extends TSchema, K extends PropertyKey[]> =
-  K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
-    ? [...TIndexKey<T, L>, ...TIndexKeys<T, R>]
-    : []
-export type TIndex<T extends TSchema, K extends PropertyKey[], R extends TSchema[] = TIndexKeys<T, K>> = UnionType<R>
+const T = Type.Intersect([Type.Object({ x: Type.Optional(Type.Number()) }), Type.Object({ x: Type.Optional(Type.Number()) })])
 
-export function Index<T extends TSchema, K extends string[]>(schema: T, keys: [...K]): TIndex<T, K>
-export function Index<T extends TSchema, I extends TSchema, K extends PropertyKey[] = TIndexer<I>>(schema: T, keys: I): TIndex<T, K>
-export function Index(schema: TSchema, keys: unknown): any {
+const S = Type.Intersect([Type.Number(), Type.Object({ x: Type.Number() })])
 
-}
-// ------------------------------------------------------------------
-// TIndexer
-// ------------------------------------------------------------------
-export type TIndexerTemplateLiteral<T extends TTemplateLiteral> = UnionToTuple<Static<T>>
-export type TIndexerUnion<T extends TSchema[]> =
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? [...TIndexer<L>, ...TIndexerUnion<R>]
-    : []
-// 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> ? [S] :
-  T extends TString ? [string] :
-  T extends TNumber ? [number] :
-  T extends TInteger ? [number] :
-  T extends TBigInt ? [bigint] :
-  []
-
-export namespace Indexer {
-  function TIndexerTemplateLiteral(schema: TUnion<TLiteral[]> | TString | TNever): string[] {
-    switch(true) {
-      case TypeGuard.TUnionLiteral(schema): return schema.anyOf.map(schema => schema.const.toString())
-      case TypeGuard.TString(schema): return [`{string}`]
-      default: return []
-    }
-  }
-  function TIndexerUnion(schemas: TSchema[]): string[] {
-    const [L, R] = [schemas.slice(0, 1), ...schemas.slice(1)]
-    return []
-  }
-  function Visit(schema: TSchema, keys: string): string[] {
-    switch (true) {
-      case TypeGuard.TTemplateLiteral(schema): return TIndexerTemplateLiteral(TemplateLiteralResolver.Resolve(schema))
-      case TypeGuard.TUnion(schema): return TIndexerUnion(schema.anyOf)
-      case TypeGuard.TLiteral(schema): return [schema.const.toString()]
-      case TypeGuard.TString(schema): return ['{string}']
-      case TypeGuard.TNumber(schema): return ['{number}']
-      case TypeGuard.TInteger(schema): return ['{number}']
-      case TypeGuard.TBigInt(schema): return ['{bigint}']
-      default: return []
-    }
-  }
-}
+type A = Static<typeof S>
 
+const I = Type.Index(T, Type.KeyOf(T))
 
-
-
-const A = Type.TemplateLiteral('a${1|2|3}')
-
-const R = TemplateLiteralResolver.Resolve(A)
-console.log(R)
-
-const S = Type.Intersect([
-  Type.Object({ x: Type.Number() }),
-  Type.Object({ y: Type.String() }),
-  Type.Object({ z: Type.Boolean() })
-])
+// prettier-ignore
+// export type UnionTypeIsOptional<T extends TSchema[]> =
+//   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+//     ? L extends TOptional<L>
+//       ? UnionTypeIsOptional<R>
+//       : false
+//     : true
+
+type X = UnionTypeIsOptional<[
+  TOptional<TNumber>,
+  TOptional<TNumber>,
+]>
+
+// // ------------------------------------------------------------------
+// // TIndex
+// // ------------------------------------------------------------------
+// // prettier-ignore
+// export type TIndexProperties<T extends TProperties, K extends PropertyKey> =
+//   K extends keyof T
+//     ? [T[K]]
+//     : []
+// // prettier-ignore
+// export type TIndexTuple<T extends TSchema[], K extends PropertyKey> =
+//   K extends keyof T
+//     ? [T[K]]
+//     : []
+// // prettier-ignore
+// export type TIndexArray<T extends TSchema, K extends PropertyKey> =
+//   K extends number
+//     ? [T]
+//     : []
+// // prettier-ignore
+// export type TIndexIntersect<T extends TSchema[], K extends PropertyKey> =
+//   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+//     ? [...TIndexKey<L, K>, ...TIndexIntersect<R, K>]
+//     : []
+// // prettier-ignore
+// export type TIndexUnionGather<T extends TSchema[], K extends PropertyKey> =
+//   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+//     ? [TIndexKey<L, K>, ...TIndexUnionGather<R, K>]
+//     : []
+// // prettier-ignore
+// export type TIndexUnionCheck<T extends TSchema[][]> =
+//   T extends [infer L extends TSchema[], ...infer R extends TSchema[][]]
+//     ? L extends []
+//       ? false
+//       : TIndexUnionCheck<R>
+//     : true
+// // prettier-ignore
+// export type TIndexUnionFinal<T extends TSchema[][]> =
+//   T extends [infer L extends TSchema[], ...infer R extends TSchema[][]]
+//     ? [...L, ...TIndexUnionFinal<R>]
+//     : []
+// // prettier-ignore
+// export type TIndexUnion<T extends TSchema[], K extends PropertyKey, G extends TSchema[][] = TIndexUnionGather<T, K>, C extends boolean = TIndexUnionCheck<G>> =
+//   C extends true
+//     ? TIndexUnionFinal<G>
+//     : []
+// // prettier-ignore
+// export type TIndexKey<T extends TSchema, K extends PropertyKey> =
+//   T extends TRecursive<infer S> ? TIndexKey<S, K> :
+//   T extends TIntersect<infer S> ? TIndexIntersect<S, K> :
+//   T extends TUnion<infer S> ? TIndexUnion<S, K> :
+//   T extends TTuple<infer S> ? TIndexTuple<S, K> :
+//   T extends TArray<infer S> ? TIndexArray<S, K> :
+//   T extends TObject<infer S> ? TIndexProperties<S, K> :
+//   []
+// // prettier-ignore
+// export type TIndexKeys<T extends TSchema, K extends PropertyKey[]> =
+//   K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+//     ? [...TIndexKey<T, L>, ...TIndexKeys<T, R>]
+//     : []
+// export type TIndex<T extends TSchema, K extends PropertyKey[], R extends TSchema[] = TIndexKeys<T, K>> = UnionType<R>
+
+// export function Index<T extends TSchema, K extends string[]>(schema: T, keys: [...K]): TIndex<T, K>
+// export function Index<T extends TSchema, I extends TSchema, K extends PropertyKey[] = TKeyResolver<I>>(schema: T, keys: I): TIndex<T, K>
+// export function Index(schema: TSchema, keys: unknown): any {
+
+// }
+
+// import {} from '@sinclair/typebox'
+// // ------------------------------------------------------------------
+// // TIndexer
+// // ------------------------------------------------------------------
+// export type TKeyResolverTemplateLiteral<T extends TTemplateLiteral, F = IsTemplateLiteralFiniteCheck<T>> =
+//   F extends true
+//     ? UnionToTuple<Static<T>>
+//     : []
+// export type TKeyResolverUnion<T extends TSchema[]> =
+//   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+//     ? [...TKeyResolver<L>, ...TKeyResolverUnion<R>]
+//     : []
+// // prettier-ignore
+// export type TKeyResolver<T extends TSchema> =
+//   T extends TTemplateLiteral ? TKeyResolverTemplateLiteral<T> :
+//   T extends TUnion<infer S> ? TKeyResolverUnion<S> :
+//   T extends TLiteral<infer S> ? [S] :
+//   T extends TString ? [] :
+//   T extends TNumber ? [] :
+//   T extends TInteger ? [] :
+//   T extends TBigInt ? [] :
+//   []
+
+// const T = Type.TemplateLiteral('a${a|b}${string}')
+// const S = KeyResolver.ResolveKeys(T, { includePatterns: false })
+
+// console.log(S, 1)
+
+// console.log(S)
+
+// const E = Type.TemplateLiteral('a${string}')
+// type E = TKeyResolver<typeof E>
+
+// const R = TemplateLiteralResolver.Resolve(A)
+// console.log(R)
+
+// const S = Type.Intersect([
+//   Type.Object({ x: Type.Number() }),
+//   Type.Object({ y: Type.String() }),
+//   Type.Object({ z: Type.Boolean() })
+// ])
 
 // const T = Type.Object({
 //   x: Type.Object({
@@ -139,7 +161,6 @@ const S = Type.Intersect([
 
 // type T = Static<typeof T>
 
-
 // type A = TObject<{ x: TNumber }>
 // type B = TObject<{ x: TString }>
 // type C = TIntersect<[A, B]>
@@ -151,12 +172,10 @@ const S = Type.Intersect([
 
 // type S = TIndex<Z, [1]>
 
-
 // type Q = Array<{ x: 1 }>
 
 // type U = Q[number]
 
-
-
-
-
+export function Resolve(T: TObject<{}>, arg1: {}) {
+  throw new Error('Function not implemented.')
+}
diff --git a/package-lock.json b/package-lock.json
index 88740ec7e..7f6bb758f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -16,7 +16,7 @@
         "ajv-formats": "^2.1.1",
         "mocha": "^9.2.2",
         "prettier": "^2.7.1",
-        "typescript": "^5.3.2"
+        "typescript": "^5.4.0-dev.20231122"
       }
     },
     "node_modules/@esbuild/linux-loong64": {
@@ -1317,9 +1317,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.2.tgz",
-      "integrity": "sha512-6l+RyNy7oAHDfxC4FzSJcz9vnjTKxrLpDG5M2Vu4SHRVNg6xzqZp6LYSR9zjqQTu8DU/f5xwxUdADOkbrIX2gQ==",
+      "version": "5.4.0-dev.20231122",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.0-dev.20231122.tgz",
+      "integrity": "sha512-jEdb2OJDseS3Vi8dg4ARi3ZDqwopyxJP9qsIFawXzTrVSfcIj4WGbBvDx4MIJuwFqGhkJ4G2cJESi3+eN0Rydw==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -2279,9 +2279,9 @@
       }
     },
     "typescript": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.2.tgz",
-      "integrity": "sha512-6l+RyNy7oAHDfxC4FzSJcz9vnjTKxrLpDG5M2Vu4SHRVNg6xzqZp6LYSR9zjqQTu8DU/f5xwxUdADOkbrIX2gQ==",
+      "version": "5.4.0-dev.20231122",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.0-dev.20231122.tgz",
+      "integrity": "sha512-jEdb2OJDseS3Vi8dg4ARi3ZDqwopyxJP9qsIFawXzTrVSfcIj4WGbBvDx4MIJuwFqGhkJ4G2cJESi3+eN0Rydw==",
       "dev": true
     },
     "uri-js": {
diff --git a/package.json b/package.json
index 064dc20a4..f3c144a3d 100644
--- a/package.json
+++ b/package.json
@@ -59,6 +59,6 @@
     "ajv-formats": "^2.1.1",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.3.2"
+    "typescript": "^5.4.0-dev.20231122"
   }
 }
diff --git a/src/typebox.ts b/src/typebox.ts
index be90cb8b3..9476d489f 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -74,65 +74,71 @@ export type TOptional<T extends TSchema> = T & { [Optional]: 'Optional' }
 // --------------------------------------------------------------------------
 // prettier-ignore
 export type ReadonlyUnwrapType<T extends TSchema> =
-  T extends TReadonly<infer S> ? ReadonlyUnwrapType<S> : 
-  T extends TOptional<infer S> ? TOptional<ReadonlyUnwrapType<S>> :
+  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, ...infer R]
-  ? L extends TReadonly<infer S>
-    ? [ReadonlyUnwrapType<AssertType<S>>, ...ReadonlyUnwrapRest<AssertRest<R>>] 
-    : [L, ...ReadonlyUnwrapRest<AssertRest<R>>]
+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> ? TReadonly<OptionalUnwrapType<S>> :
-  T extends TOptional<infer S> ? OptionalUnwrapType<S> : 
+  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, ...infer R]
-  ? L extends TOptional<infer S>
-    ? [OptionalUnwrapType<AssertType<S>>, ...OptionalUnwrapRest<AssertRest<R>>] 
-    : [L, ...OptionalUnwrapRest<AssertRest<R>>]
-  :  []
+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>]
+    :  []
 // --------------------------------------------------------------------------
 // IntersectType
 // --------------------------------------------------------------------------
 // prettier-ignore
-export type IntersectOptional<T extends TSchema[]> = T extends [infer L, ...infer R] 
-  ? L extends TOptional<AssertType<L>> 
-    ? IntersectOptional<AssertRest<R>> 
+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 IntersectResolve<T extends TSchema[], U = OptionalUnwrapRest<AssertRest<T>>> = IntersectOptional<AssertRest<T>> extends true
-  ? TOptional<TIntersect<AssertRest<U>>>
-  : TIntersect<AssertRest<U>>
+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[]> = 
-    T extends [] ? TNever : 
-    T extends [TSchema] ? AssertType<T[0]> : 
-    IntersectResolve<T>
+  T extends [] ? TNever : 
+  T extends [TSchema] ? AssertType<T[0]> : 
+  IntersectTypeOptional<T>
 // --------------------------------------------------------------------------
 // UnionType
 // --------------------------------------------------------------------------
 // prettier-ignore
-export type UnionOptional<T extends TSchema[]> = T extends [infer L, ...infer R]
-  ? L extends (TOptional<AssertType<L>>)
-    ? true 
-    : UnionOptional<AssertRest<R>> 
-  : false
+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 UnionResolve<T extends TSchema[], U = OptionalUnwrapRest<AssertRest<T>>> = UnionOptional<AssertRest<T>> extends true
-  ? TOptional<TUnion<AssertRest<U>>>
-  : TUnion<AssertRest<U>>
+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[]> = 
   T extends [] ? TNever : 
-  T extends [TSchema] ? AssertType<T[0]> : 
-  UnionResolve<T>
+  T extends [TSchema] ? T[0] : 
+  UnionTypeOptional<T>
 // --------------------------------------------------------------------------
 // TSchema
 // --------------------------------------------------------------------------
@@ -252,8 +258,9 @@ export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
 // TAwaited
 // -------------------------------------------------------------------------------
 // prettier-ignore
-export type TAwaitedRest<T extends TSchema[]> = T extends [infer L, ...infer R]
-  ? [TAwaited<AssertType<L>>, ...TAwaitedRest<AssertRest<R>>]
+export type TAwaitedRest<T extends TSchema[]> = 
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+  ? [TAwaited<L>, ...TAwaitedRest<R>]
   : []
 // prettier-ignore
 export type TAwaited<T extends TSchema> = 
@@ -289,12 +296,14 @@ export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['retur
 // TComposite
 // --------------------------------------------------------------------------
 // prettier-ignore
-export type TCompositeKeys<T extends TObject[]> = T extends [infer L, ...infer R] 
-  ? keyof Assert<L, TObject>['properties'] | TCompositeKeys<Assert<R, TObject[]>>
-  : never
+export type TCompositeKeys<T extends TObject[]> = 
+  T extends [infer L extends TObject, ...infer R extends TObject[]] 
+    ? keyof L['properties'] | TCompositeKeys<R>
+    : never
 // prettier-ignore
-export type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L, ...infer R] 
-  ? { [_ in Assert<L, string>]: TIndexType<T, Assert<L, string>> } & TCompositeIndex<T, Assert<R, string[]>> 
+export type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[]> = 
+  K extends [infer L extends string, ...infer R extends string[]] 
+  ? { [_ in L]: TIndex<T, [L]> } & TCompositeIndex<T, R> 
   : {}
 // prettier-ignore
 export type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K 
@@ -354,8 +363,10 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
 // --------------------------------------------------------------------------
 // prettier-ignore
 export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = 
-  (Static<L> extends Static<R> ? T : U) extends infer O ? 
-    UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[AssertType<X>, AssertType<Y>]> : AssertType<O>
+  (Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ? 
+    UnionToTuple<O> extends [infer X extends TSchema, infer Y extends TSchema] 
+      ? TUnion<[X, Y]> 
+      : O
   : never
 // --------------------------------------------------------------------------
 // TExclude
@@ -365,7 +376,7 @@ export type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchem
 // 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 ? UnionType<AssertRest<R>> : never
+}[number]>> extends infer R extends TSchema[] ? UnionType<R> : never
 // prettier-ignore
 export type TExclude<T extends TSchema, U extends TSchema> = 
   T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> : 
@@ -379,7 +390,7 @@ export type TExtractTemplateLiteral<T extends TTemplateLiteral, U extends TSchem
 // 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 ? UnionType<AssertRest<R>> : never
+}[number]>> extends infer R extends TSchema[] ? UnionType<R> : never
 // prettier-ignore
 export type TExtract<T extends TSchema, U extends TSchema> = 
   T extends TTemplateLiteral ? TExtractTemplateLiteral<T, U> : 
@@ -399,40 +410,106 @@ export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema =
   returns: U
 }
 // --------------------------------------------------------------------------
-// TIndex
+// TKeyResolver
 // --------------------------------------------------------------------------
-export type TIndexRest<T extends TSchema[], K extends TPropertyKey> = T extends [infer L, ...infer R] ? [TIndexType<AssertType<L>, K>, ...TIndexRest<AssertRest<R>, K>] : []
-export type TIndexProperty<T extends TProperties, K extends TPropertyKey> = K extends keyof T ? [T[K]] : []
-export type TIndexTuple<T extends TSchema[], K extends TPropertyKey> = K extends keyof T ? [T[K]] : []
+export type TKeyResolverTemplateLiteral<T extends TTemplateLiteral, F = IsTemplateLiteralFiniteCheck<T>> = F extends true ? UnionToTuple<Static<T>> : []
+export type TKeyResolverUnion<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...TKeyResolver<L>, ...TKeyResolverUnion<R>] : []
+export type TKeyResolverLiteral<T extends TLiteralValue> = T extends PropertyKey ? [T] : []
 // prettier-ignore
-export type TIndexType<T extends TSchema, K extends TPropertyKey> =
-  T extends TRecursive<infer S> ? TIndexType<S, K> :
-  T extends TIntersect<infer S> ? IntersectType<AssertRest<Discard<Flat<TIndexRest<S, K>>, TNever>>> :
-  T extends TUnion<infer S>     ? UnionType<AssertRest<Flat<TIndexRest<S, K>>>> :
-  T extends TObject<infer S>    ? UnionType<AssertRest<Flat<TIndexProperty<S, K>>>> :
-  T extends TTuple<infer S>     ? UnionType<AssertRest<Flat<TIndexTuple<S, K>>>> :
+export type TKeyResolver<T extends TSchema> =
+  T extends TTemplateLiteral ? TKeyResolverTemplateLiteral<T> :
+  T extends TUnion<infer S> ? TKeyResolverUnion<S> :
+  T extends TLiteral<infer S> ? TKeyResolverLiteral<S> :
+  T extends TString ? [] :
+  T extends TNumber ? [] :
+  T extends TInteger ? [] :
+  T extends TBigInt ? [] :
   []
+// ------------------------------------------------------------------
+// TIndex
+// ------------------------------------------------------------------
 // prettier-ignore
-export type TIndexRestMany<T extends TSchema, K extends TPropertyKey[]> = 
- K extends [infer L, ...infer R] ? [TIndexType<T, Assert<L, TPropertyKey>>, ...TIndexRestMany<T, Assert<R, TPropertyKey[]>>] :
- []
+export type TIndexProperties<T extends TProperties, K extends PropertyKey> =
+  K extends keyof T
+    ? [T[K]]
+    : []
 // prettier-ignore
-export type TIndex<T extends TSchema, K extends TPropertyKey[]> =
-  T extends TRecursive<infer S> ? TIndex<S, K> :
-  T extends TIntersect ? UnionType<Flat<TIndexRestMany<T, K>>> :
-  T extends TUnion     ? UnionType<Flat<TIndexRestMany<T, K>>> :
-  T extends TObject    ? UnionType<Flat<TIndexRestMany<T, K>>> :
-  T extends TTuple     ? UnionType<Flat<TIndexRestMany<T, K>>> :
-  TNever
+export type TIndexTuple<T extends TSchema[], K extends PropertyKey> =
+  K extends keyof T
+    ? [T[K]]
+    : []
+// prettier-ignore
+export type TIndexArray<T extends TSchema, K extends PropertyKey> =
+  K extends number
+    ? [T]
+    : []
+// prettier-ignore
+export type TIndexIntersect<T extends TSchema[], K extends PropertyKey> =
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? [...TIndexKeyResolve<L, K>, ...TIndexIntersect<R, K>]
+    : []
+// prettier-ignore
+export type TIndexUnionGather<T extends TSchema[], K extends PropertyKey> =
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? [TIndexKeyResolve<L, K>, ...TIndexUnionGather<R, K>]
+    : []
+// prettier-ignore
+export type TIndexUnionCheck<T extends TSchema[][]> =
+  T extends [infer L extends TSchema[], ...infer R extends TSchema[][]]
+    ? L extends []
+      ? false
+      : TIndexUnionCheck<R>
+    : true
+// prettier-ignore
+export type TIndexUnionFinal<T extends TSchema[][]> =
+  T extends [infer L extends TSchema[], ...infer R extends TSchema[][]]
+    ? [...L, ...TIndexUnionFinal<R>]
+    : []
+// prettier-ignore
+export type TIndexUnion<T extends TSchema[], K extends PropertyKey, G extends TSchema[][] = TIndexUnionGather<T, K>, C extends boolean = TIndexUnionCheck<G>> =
+  C extends true
+    ? TIndexUnionFinal<G>
+    : []
+// prettier-ignore
+export type TIndexKeyResolve<T extends TSchema, K extends PropertyKey> =
+  T extends TRecursive<infer S> ? TIndexKeyResolve<S, K> :
+  T extends TIntersect<infer S> ? TIndexIntersect<S, K> :
+  T extends TUnion<infer S> ? TIndexUnion<S, K> :
+  T extends TTuple<infer S> ? TIndexTuple<S, K> :
+  T extends TArray<infer S> ? TIndexArray<S, K> :
+  T extends TObject<infer S> ? TIndexProperties<S, K> :
+  []
+// prettier-ignore
+export type TIndexKey<T extends TSchema, K extends PropertyKey, R = TIndexKeyResolve<T, K>> = 
+  R extends TSchema[] 
+    ? IntersectType<R> 
+    : TNever
+// prettier-ignore
+export type TIndexKeysResolve<T extends TSchema, K extends PropertyKey[]> =
+  K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]]
+    ? [...TIndexKeyResolve<T, L>, ...TIndexKeysResolve<T, R>]
+    : []
+// prettier-ignore
+export type TIndexKeys<T extends TSchema, K extends PropertyKey[], R = TIndexKeysResolve<T, K>> = 
+  R extends TSchema[] 
+    ? UnionType<R> 
+    : TNever
+export type TIndex<T extends TSchema, K extends PropertyKey[]> = TIndexKeys<T, K>
 // --------------------------------------------------------------------------
 // TIntrinsic
 // --------------------------------------------------------------------------
 export type TIntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize'
 // prettier-ignore
 export type TIntrinsicTemplateLiteral<T extends TTemplateLiteralKind[], M extends TIntrinsicMode> =
-  M extends ('Lowercase' | 'Uppercase')     ? T extends [infer L, ...infer R] ? [TIntrinsic<AssertType<L>, M>, ...TIntrinsicTemplateLiteral<AssertRest<R>, M>] : T :  
-  M extends ('Capitalize' | 'Uncapitalize') ? T extends [infer L, ...infer R] ? [TIntrinsic<AssertType<L>, M>, ...R] : T :  
-  T
+  M extends ('Lowercase' | 'Uppercase') ? 
+    T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] 
+      ? [TIntrinsic<L, M>, ...TIntrinsicTemplateLiteral<R, M>] 
+      : T :  
+  M extends ('Capitalize' | 'Uncapitalize') 
+    ? T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] 
+      ? [TIntrinsic<L, M>, ...TIntrinsicTemplateLiteral<R, M>] 
+      : T 
+    : T
 // prettier-ignore
 export type TIntrinsicLiteral<T, M extends TIntrinsicMode> = 
   T extends string ? 
@@ -443,8 +520,9 @@ export type TIntrinsicLiteral<T, M extends TIntrinsicMode> =
     string
   : T
 // prettier-ignore
-export type TIntrinsicRest<T extends TSchema[], M extends TIntrinsicMode> = T extends [infer L, ...infer R]
-  ? [TIntrinsic<AssertType<L>, M>, ...TIntrinsicRest<AssertRest<R>, M>]
+export type TIntrinsicRest<T extends TSchema[], M extends TIntrinsicMode> = 
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+  ? [TIntrinsic<L, M>, ...TIntrinsicRest<R, M>]
   : []
 // prettier-ignore
 export type TIntrinsic<T extends TSchema, M extends TIntrinsicMode> =
@@ -467,9 +545,10 @@ export type TUnevaluatedProperties = undefined | TSchema | boolean
 export interface IntersectOptions extends SchemaOptions {
   unevaluatedProperties?: TUnevaluatedProperties
 }
+export type TIntersectResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? Static<L, P> & TIntersectResolve<R, P> : {}
 export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
   [Kind]: 'Intersect'
-  static: TupleToIntersect<{ [K in keyof T]: Static<AssertType<T[K]>, this['params']> }>
+  static: TIntersectResolve<T, this['params']>
   type?: 'object'
   allOf: [...T]
 }
@@ -2489,6 +2568,14 @@ export namespace KeyResolver {
   function UnwrapPattern(key: string) {
     return key[0] === '^' && key[key.length - 1] === '$' ? key.slice(1, key.length - 1) : key
   }
+  function TTemplateLiteral(schema: TTemplateLiteral, options: KeyResolverOptions): 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()) : []
+  }
   function TIntersect(schema: TIntersect, options: KeyResolverOptions): string[] {
     return schema.allOf.reduce((acc, schema) => [...acc, ...Visit(schema, options)], [] as string[])
   }
@@ -2505,6 +2592,7 @@ export namespace KeyResolver {
   function Visit(schema: TSchema, options: KeyResolverOptions): string[] {
     // prettier-ignore
     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) :
@@ -2982,7 +3070,7 @@ export class JsonTypeBuilder extends TypeBuilder {
     // prettier-ignore
     return (
       TypeGuard.TTemplateLiteral(type) ? this.Extract(TemplateLiteralResolver.Resolve(type), union, options) :
-      TypeGuard.TTemplateLiteral(union) ? this.Extract(type, TemplateLiteralResolver.Resolve(union), options) :
+      TypeGuard.TTemplateLiteral(union) ? this.Extract(type, TemplateLiteralResolver.Resolve(union) as any, options) :
       TypeGuard.TUnion(type) ? (() => {
         const narrowed = type.anyOf.filter((inner) => TypeExtends.Extends(inner, union) !== TypeExtendsResult.False)
         return (narrowed.length === 1 ? TypeClone.Type(narrowed[0], options) : this.Union(narrowed, options))
@@ -2991,22 +3079,27 @@ export class JsonTypeBuilder extends TypeBuilder {
       this.Never(options)
     ) as TExtract<L, R>
   }
+  // /** `[Json]` Returns an Indexed property type for the given keys */
+  // public Index<T extends TArray, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): AssertType<T['items']>
+  // /** `[Json]` Returns an Indexed property type for the given keys */
+  // public Index<T extends TTuple, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, TPropertyKey[]>>
+  // /** `[Json]` Returns an Indexed property type for the given keys */
+  // public Index<T extends TTuple, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): UnionType<AssertRest<T['items']>>
+  // /** `[Json]` Returns an Indexed property type for the given keys */
+  // public Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyRest<K>>
+  // /** `[Json]` Returns an Indexed property type for the given keys */
+  // public Index<T extends TSchema, K extends TLiteral<TPropertyKey>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, [K['const']]>
+  // /** `[Json]` Returns an Indexed property type for the given keys */
+  // public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, TPropertyKey[]>>
+  // /** `[Json]` Returns an Indexed property type for the given keys */
+  // public Index<T extends TSchema, K extends TUnion<TLiteral<TPropertyKey>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TUnionLiteralKeyRest<K>>
+  // /** `[Json]` Returns an Indexed property type for the given keys */
+  // public Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TSchema
+
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TArray, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): AssertType<T['items']>
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TTuple, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, TPropertyKey[]>>
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TTuple, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): UnionType<AssertRest<T['items']>>
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyRest<K>>
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends TLiteral<TPropertyKey>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, [K['const']]>
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, TPropertyKey[]>>
-  /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends TUnion<TLiteral<TPropertyKey>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TUnionLiteralKeyRest<K>>
+  public Index<T extends TSchema, I extends TSchema, K extends PropertyKey[] = TKeyResolver<I>>(schema: T, keys: I, options?: SchemaOptions): TIndex<T, K>
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TSchema
+  public Index<T extends TSchema, K extends PropertyKey[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, K>
   /** `[Json]` Returns an Indexed property type for the given keys */
   public Index(schema: TSchema, unresolved: any, options: SchemaOptions = {}): any {
     // prettier-ignore