@sinclair/typebox 0.34.9 → 0.34.11

package/build/cjs/type/type/json.d.ts

@@ -7,7 +7,7 @@ import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index';
 import { type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index';
 import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index';
 import { type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from '../extract/index';
-import { TIndex, type TIndexPropertyKeys } from '../indexed/index';
+import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult, type TIndexFromComputed } from '../indexed/index';
 import { type IntegerOptions, type TInteger } from '../integer/index';
 import { Intersect, type IntersectOptions } from '../intersect/index';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index';
@@ -93,13 +93,19 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, key: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+    Index<Type extends TRef, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, Key extends TMappedKey>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
+    Index<Type extends TSchema, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, Key extends TMappedResult>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
+    Index<Type extends TRef, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
+    Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TIndexFromMappedKey<Type, MappedKey>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, Key extends TSchema, PropertyKeys extends PropertyKey[] = TIndexPropertyKeys<Key>>(T: Type, K: Key, options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
     /** `[Json]` Creates an Integer type */
     Integer(options?: IntegerOptions): TInteger;
     /** `[Json]` Creates an Intersect type */

package/build/cjs/value/parse/parse.d.ts

@@ -4,7 +4,7 @@ import { StaticDecode } from '../../type/static/index';
 export declare class ParseError extends TypeBoxError {
     constructor(message: string);
 }
-export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | ({} & string);
+export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | 'Encode' | ({} & string);
 export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown;
 export declare namespace ParseRegistry {
     function Delete(key: string): void;

package/build/esm/compiler/compiler.mjs

@@ -9,6 +9,7 @@ import { TypeRegistry, FormatRegistry } from '../type/registry/index.mjs';
 import { KeyOfPattern } from '../type/keyof/index.mjs';
 import { ExtendsUndefinedCheck } from '../type/extends/extends-undefined.mjs';
 import { Never } from '../type/never/index.mjs';
+import { Ref } from '../type/ref/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -264,9 +265,10 @@ export var TypeCompiler;
         yield `(typeof ${value} === 'function')`;
     }
     function* FromImport(schema, references, value) {
-        const definitions = globalThis.Object.values(schema.$defs);
-        const target = schema.$defs[schema.$ref];
-        yield* Visit(target, [...references, ...definitions], value);
+        const members = globalThis.Object.getOwnPropertyNames(schema.$defs).reduce((result, key) => {
+            return [...result, schema.$defs[key]];
+        }, []);
+        yield* Visit(Ref(schema.$ref), [...references, ...members], value);
     }
     function* FromInteger(schema, references, value) {
         yield `Number.isInteger(${value})`;
@@ -385,13 +387,9 @@ export var TypeCompiler;
     function* FromRef(schema, references, value) {
         const target = Deref(schema, references);
         // Reference: If we have seen this reference before we can just yield and return the function call.
-        // If this isn't the case we defer to visit to generate and set the _recursion_end_for_ for subsequent
-        // passes. This operation is very awkward as we are using the functions state to store values to
-        // enable self referential types to terminate. This needs to be refactored.
-        const recursiveEnd = `_recursion_end_for_${schema.$ref}`;
-        if (state.functions.has(recursiveEnd))
+        // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
+        if (state.functions.has(schema.$ref))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
-        state.functions.set(recursiveEnd, ''); // terminate recursion here by setting the name.
         yield* Visit(target, references, value);
     }
     function* FromRegExp(schema, references, value) {
@@ -476,6 +474,10 @@ export var TypeCompiler;
                 return yield `${functionName}(${value})`;
             }
             else {
+                // Note: In the case of cyclic types, we need to create a 'functions' record
+                // to prevent infinitely re-visiting the CreateFunction. Subsequent attempts
+                // to visit will be caught by the above condition.
+                state.functions.set(functionName, '<deferred>');
                 const functionCode = CreateFunction(functionName, schema, references, 'value', false);
                 state.functions.set(functionName, functionCode);
                 return yield `${functionName}(${value})`;

package/build/esm/syntax/runtime.d.mts

@@ -48,7 +48,7 @@ export declare const Module: Runtime.Module<{
     Iterator: Runtime.ITuple<Types.TIterator<Types.TSchema>>;
     Awaited: Runtime.ITuple<Types.TSchema>;
     Array: Runtime.ITuple<Types.TArray<Types.TSchema>>;
-    Record: Runtime.ITuple<Types.TSchema>;
+    Record: Runtime.ITuple<Types.TNever>;
     Promise: Runtime.ITuple<Types.TPromise<Types.TSchema>>;
     ConstructorParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
     FunctionParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;

package/build/esm/type/indexed/indexed-from-mapped-result.mjs

@@ -5,8 +5,7 @@ import { Index } from './index.mjs';
 function FromProperties(type, properties, options) {
     const result = {};
     for (const K2 of Object.getOwnPropertyNames(properties)) {
-        const keys = IndexPropertyKeys(properties[K2]);
-        result[K2] = Index(type, keys, options);
+        result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
     }
     return result;
 }

package/build/esm/type/indexed/indexed-property-keys.d.mts

@@ -4,11 +4,11 @@ import type { TInteger } from '../integer/index.mjs';
 import type { TNumber } from '../number/index.mjs';
 import type { TSchema } from '../schema/index.mjs';
 import type { TUnion } from '../union/index.mjs';
-type TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, Result extends string[] = TTemplateLiteralGenerate<TemplateLiteral>> = Result;
+type TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, Keys extends string[] = TTemplateLiteralGenerate<TemplateLiteral>> = (Keys);
 type TFromUnion<Types extends TSchema[], Result extends string[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TIndexPropertyKeys<Left>]> : Result);
 type TFromLiteral<LiteralValue extends TLiteralValue> = (LiteralValue extends PropertyKey ? [`${LiteralValue}`] : []);
-export type TIndexPropertyKeys<Type extends TSchema, Result extends PropertyKey[] = (Type extends TTemplateLiteral ? TFromTemplateLiteral<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TLiteral<infer LiteralValue extends TLiteralValue> ? TFromLiteral<LiteralValue> : Type extends TNumber ? ['[number]'] : Type extends TInteger ? ['[number]'] : [
-])> = Result;
+export type TIndexPropertyKeys<Type extends TSchema> = (Type extends TTemplateLiteral ? TFromTemplateLiteral<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Type extends TNumber ? ['[number]'] : Type extends TInteger ? ['[number]'] : [
+]);
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 export declare function IndexPropertyKeys<Type extends TSchema>(type: Type): TIndexPropertyKeys<Type>;
 export {};

package/build/esm/type/indexed/indexed-property-keys.mjs

@@ -5,19 +5,19 @@ import { TemplateLiteralGenerate } from '../template-literal/index.mjs';
 import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/kind.mjs';
 // prettier-ignore
 function FromTemplateLiteral(templateLiteral) {
-    const result = TemplateLiteralGenerate(templateLiteral);
-    return result.map(S => S.toString());
+    const keys = TemplateLiteralGenerate(templateLiteral);
+    return keys.map(key => key.toString());
 }
 // prettier-ignore
-function FromUnion(type) {
+function FromUnion(types) {
     const result = [];
-    for (const left of type)
-        result.push(...IndexPropertyKeys(left));
+    for (const type of types)
+        result.push(...IndexPropertyKeys(type));
     return result;
 }
 // prettier-ignore
-function FromLiteral(T) {
-    return ([T.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
+function FromLiteral(literalValue) {
+    return ([literalValue.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
     );
 }
 /** Returns a tuple of PropertyKeys derived from the given TSchema */

package/build/esm/type/indexed/indexed.d.mts

@@ -1,54 +1,52 @@
 import { type TSchema, SchemaOptions } from '../schema/index.mjs';
-import { type TComputed } from '../computed/index.mjs';
-import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
-import { type TObject, type TProperties } from '../object/index.mjs';
 import { type Assert } from '../helpers/index.mjs';
+import { type TComputed } from '../computed/index.mjs';
 import { type TNever } from '../never/index.mjs';
-import { type TRecursive } from '../recursive/index.mjs';
+import { type TArray } from '../array/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
-import { TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TUnion } from '../union/index.mjs';
-import { type TTuple } from '../tuple/index.mjs';
-import { type TArray } from '../array/index.mjs';
+import { type TRecursive } from '../recursive/index.mjs';
 import { type TRef } from '../ref/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
 import { type TIntersectEvaluated } from '../intersect/index.mjs';
 import { type TUnionEvaluated } from '../union/index.mjs';
 import { type TIndexPropertyKeys } from './indexed-property-keys.mjs';
 import { type TIndexFromMappedKey } from './indexed-from-mapped-key.mjs';
 import { type TIndexFromMappedResult } from './indexed-from-mapped-result.mjs';
-type TFromRest<T extends TSchema[], K extends PropertyKey, Result extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Result, Assert<TIndexFromPropertyKey<L, K>, TSchema>]> : Result);
+type TFromRest<Types extends TSchema[], Key extends PropertyKey, Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<Right, Key, [...Result, Assert<TIndexFromPropertyKey<Left, Key>, TSchema>]> : Result);
 type TFromIntersectRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TNever ? TFromIntersectRest<Right, [...Result]> : TFromIntersectRest<Right, [...Result, Left]> : Result);
 type TFromIntersect<Types extends TSchema[], Key extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<Types, Key>>>);
 type TFromUnionRest<Types extends TSchema[], Result extends TSchema[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TNever ? [] : TFromUnionRest<Right, [Left, ...Result]> : Result;
 type TFromUnion<Types extends TSchema[], Key extends PropertyKey> = (TUnionEvaluated<TFromUnionRest<TFromRest<Types, Key>>>);
-type TFromTuple<Types extends TSchema[], Key extends PropertyKey, Result extends TSchema = (Key extends '[number]' ? TUnionEvaluated<Types> : Key extends keyof Types ? Types[Key] extends infer Type extends TSchema ? Type : TNever : TNever)> = Result;
+type TFromTuple<Types extends TSchema[], Key extends PropertyKey> = (Key extends keyof Types ? Types[Key] : Key extends '[number]' ? TUnionEvaluated<Types> : TNever);
 type TFromArray<Type extends TSchema, Key extends PropertyKey> = (Key extends '[number]' ? Type : TNever);
-type AssertPropertyKey<T extends unknown> = Assert<T, string | number>;
-type TFromProperty<Properties extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Properties ? Properties[Key] : `${AssertPropertyKey<Key>}` extends `${AssertPropertyKey<keyof Properties>}` ? Properties[AssertPropertyKey<Key>] : TNever)> = Result;
-export type TIndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = (Type extends TRecursive<infer S extends TSchema> ? TIndexFromPropertyKey<S, Key> : Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<S, Key> : Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<S, Key> : Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<S, Key> : Type extends TArray<infer S extends TSchema> ? TFromArray<S, Key> : Type extends TObject<infer S extends TProperties> ? TFromProperty<S, Key> : TNever);
-export declare function IndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key): TIndexFromPropertyKey<Type, Key>;
+type AssertPropertyKey<T> = Assert<T, string | number>;
+type TFromProperty<Properties extends TProperties, Key extends PropertyKey> = (Key extends keyof Properties ? Properties[Key] : `${AssertPropertyKey<Key>}` extends `${AssertPropertyKey<keyof Properties>}` ? Properties[AssertPropertyKey<Key>] : TNever);
+export type TIndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = (Type extends TRecursive<infer Type extends TSchema> ? TIndexFromPropertyKey<Type, Key> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types, Key> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types, Key> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Key> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Type, Key> : Type extends TObject<infer Properties extends TProperties> ? TFromProperty<Properties, Key> : TNever);
+export declare function IndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, propertyKey: Key): TIndexFromPropertyKey<Type, Key>;
 export type TIndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (PropertyKeys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? TIndexFromPropertyKeys<Type, Right, [...Result, Assert<TIndexFromPropertyKey<Type, Left>, TSchema>]> : Result);
 export declare function IndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): TIndexFromPropertyKeys<Type, PropertyKeys>;
-type TFromType<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TSchema[] = TIndexFromPropertyKeys<Type, PropertyKeys>> = TUnionEvaluated<Result>;
-type TUnionFromPropertyKeys<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = []> = (PropertyKeys extends [infer Key extends PropertyKey, ...infer Rest extends PropertyKey[]] ? Key extends TLiteralValue ? TUnionFromPropertyKeys<Rest, [...Result, TLiteral<Key>]> : TUnionFromPropertyKeys<Rest, [...Result]> : TUnionEvaluated<Result>);
-type TResolvePropertyKeys<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key;
-type TResolveTypeKey<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key;
-export type TIndex<Type extends TSchema, Key extends TSchema | PropertyKey[], IsTypeRef extends boolean = Type extends TRef ? true : false, IsKeyRef extends boolean = Key extends TRef ? true : false> = (Key extends TMappedResult ? TIndexFromMappedResult<Type, Key> : Key extends TMappedKey ? TIndexFromMappedKey<Type, Key> : [
-    IsTypeRef,
-    IsKeyRef
-] extends [true, true] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : [
-    IsTypeRef,
-    IsKeyRef
-] extends [false, true] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : [
-    IsTypeRef,
-    IsKeyRef
-] extends [true, false] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : TFromType<Type, TResolvePropertyKeys<Key>>);
-/** `[Json]` Returns an Indexed property type for the given keys */
-export declare function Index<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TIndex<Type, Key>;
-/** `[Json]` Returns an Indexed property type for the given keys */
-export declare function Index<Type extends TSchema, Key extends TMappedKey>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
-/** `[Json]` Returns an Indexed property type for the given keys */
-export declare function Index<Type extends TSchema, Key extends TMappedResult>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
-/** `[Json]` Returns an Indexed property type for the given keys */
-export declare function Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
+type FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (TUnionEvaluated<TIndexFromPropertyKeys<Type, PropertyKeys>>);
+declare function FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): FromSchema<Type, PropertyKeys>;
+export type TIndexFromComputed<Type extends TSchema, Key extends TSchema> = (TComputed<'Index', [Type, Key]>);
+export declare function IndexFromComputed<Type extends TSchema, Key extends TSchema>(type: Type, key: Key): TIndexFromComputed<Type, Key>;
+export type TIndex<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (FromSchema<Type, PropertyKeys>);
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TRef, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TRef, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TIndexFromMappedKey<Type, MappedKey>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, Key extends TSchema, PropertyKeys extends PropertyKey[] = TIndexPropertyKeys<Key>>(T: Type, K: Key, options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
 export {};

package/build/esm/type/indexed/indexed.mjs

@@ -1,27 +1,23 @@
 import { CreateType } from '../create/type.mjs';
+import { TypeBoxError } from '../error/index.mjs';
 import { Computed } from '../computed/index.mjs';
-import { Literal } from '../literal/index.mjs';
 import { Never } from '../never/index.mjs';
 import { IntersectEvaluated } from '../intersect/index.mjs';
 import { UnionEvaluated } from '../union/index.mjs';
-// ------------------------------------------------------------------
-// Infrastructure
-// ------------------------------------------------------------------
 import { IndexPropertyKeys } from './indexed-property-keys.mjs';
 import { IndexFromMappedKey } from './indexed-from-mapped-key.mjs';
 import { IndexFromMappedResult } from './indexed-from-mapped-result.mjs';
 // ------------------------------------------------------------------
-// KindGuard
+// TypeGuard
 // ------------------------------------------------------------------
-import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion, IsLiteralValue, IsRef } from '../guard/kind.mjs';
-import { IsArray as IsArrayValue } from '../guard/value.mjs';
+import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion, IsRef } from '../guard/kind.mjs';
 // prettier-ignore
 function FromRest(types, key) {
-    return types.map(left => IndexFromPropertyKey(left, key));
+    return types.map(type => IndexFromPropertyKey(type, key));
 }
 // prettier-ignore
 function FromIntersectRest(types) {
-    return types.filter(left => !IsNever(left));
+    return types.filter(type => !IsNever(type));
 }
 // prettier-ignore
 function FromIntersect(types, key) {
@@ -39,53 +35,57 @@ function FromUnion(types, key) {
 }
 // prettier-ignore
 function FromTuple(types, key) {
-    return (key === '[number]' ? UnionEvaluated(types) :
-        key in types ? types[key] :
+    return (key in types ? types[key] :
+        key === '[number]' ? UnionEvaluated(types) :
             Never());
 }
 // prettier-ignore
 function FromArray(type, key) {
-    // ... ?
-    return (key === '[number]' ? type : Never());
+    return (key === '[number]'
+        ? type
+        : Never());
 }
 // prettier-ignore
-function FromProperty(properties, key) {
-    return (key in properties ? properties[key] : Never());
+function FromProperty(properties, propertyKey) {
+    return (propertyKey in properties ? properties[propertyKey] : Never());
 }
 // prettier-ignore
-export function IndexFromPropertyKey(type, key) {
-    return (IsIntersect(type) ? FromIntersect(type.allOf, key) :
-        IsUnion(type) ? FromUnion(type.anyOf, key) :
-            IsTuple(type) ? FromTuple(type.items ?? [], key) :
-                IsArray(type) ? FromArray(type.items, key) :
-                    IsObject(type) ? FromProperty(type.properties, key) :
+export function IndexFromPropertyKey(type, propertyKey) {
+    return (IsIntersect(type) ? FromIntersect(type.allOf, propertyKey) :
+        IsUnion(type) ? FromUnion(type.anyOf, propertyKey) :
+            IsTuple(type) ? FromTuple(type.items ?? [], propertyKey) :
+                IsArray(type) ? FromArray(type.items, propertyKey) :
+                    IsObject(type) ? FromProperty(type.properties, propertyKey) :
                         Never());
 }
 // prettier-ignore
 export function IndexFromPropertyKeys(type, propertyKeys) {
-    return propertyKeys.map(left => IndexFromPropertyKey(type, left));
+    return propertyKeys.map(propertyKey => IndexFromPropertyKey(type, propertyKey));
 }
 // prettier-ignore
-function FromType(type, propertyKeys) {
-    const result = IndexFromPropertyKeys(type, propertyKeys);
-    return UnionEvaluated(result);
+function FromSchema(type, propertyKeys) {
+    return (UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys)));
 }
 // prettier-ignore
-function UnionFromPropertyKeys(propertyKeys) {
-    const result = propertyKeys.reduce((result, key) => IsLiteralValue(key) ? [...result, Literal(key)] : result, []);
-    return UnionEvaluated(result);
+export function IndexFromComputed(type, key) {
+    return Computed('Index', [type, key]);
 }
 /** `[Json]` Returns an Indexed property type for the given keys */
-// prettier-ignore
 export function Index(type, key, options) {
-    const typeKey = IsArrayValue(key) ? UnionFromPropertyKeys(key) : key;
-    const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
-    const isTypeRef = IsRef(type);
-    const isKeyRef = IsRef(key);
-    return (IsMappedResult(key) ? IndexFromMappedResult(type, key, options) :
-        IsMappedKey(key) ? IndexFromMappedKey(type, key, options) :
-            (isTypeRef && isKeyRef) ? Computed('Index', [type, typeKey], options) :
-                (!isTypeRef && isKeyRef) ? Computed('Index', [type, typeKey], options) :
-                    (isTypeRef && !isKeyRef) ? Computed('Index', [type, typeKey], options) :
-                        CreateType(FromType(type, propertyKeys), options));
+    // computed-type
+    if (IsRef(type) || IsRef(key)) {
+        const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
+        if (!IsSchema(type) || !IsSchema(key))
+            throw new TypeBoxError(error);
+        return Computed('Index', [type, key]);
+    }
+    // mapped-types
+    if (IsMappedResult(key))
+        return IndexFromMappedResult(type, key, options);
+    if (IsMappedKey(key))
+        return IndexFromMappedKey(type, key, options);
+    // prettier-ignore
+    return CreateType(IsSchema(key)
+        ? FromSchema(type, IndexPropertyKeys(key))
+        : FromSchema(type, key), options);
 }

package/build/esm/type/module/compute.d.mts

@@ -5,8 +5,8 @@ import { type TAwaited } from '../awaited/index.mjs';
 import { type TAsyncIterator } from '../async-iterator/index.mjs';
 import { TComputed } from '../computed/index.mjs';
 import { type TConstructor } from '../constructor/index.mjs';
-import { type TIndex } from '../indexed/index.mjs';
-import { TEnum, TEnumRecord } from '../enum/index.mjs';
+import { type TIndex, type TIndexPropertyKeys } from '../indexed/index.mjs';
+import { TEnum, type TEnumRecord } from '../enum/index.mjs';
 import { type TFunction } from '../function/index.mjs';
 import { type TIntersect, type TIntersectEvaluated } from '../intersect/index.mjs';
 import { type TIterator } from '../iterator/index.mjs';
@@ -26,7 +26,7 @@ import { type TUnion, type TUnionEvaluated } from '../union/index.mjs';
 type TDerefParameters<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TRef<infer Key extends string> ? TDerefParameters<ModuleProperties, Right, [...Result, TDeref<ModuleProperties, Key>]> : TDerefParameters<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
 type TDeref<ModuleProperties extends TProperties, Ref extends string, Result extends TSchema = (Ref extends keyof ModuleProperties ? ModuleProperties[Ref] extends TRef<infer Ref2 extends string> ? TDeref<ModuleProperties, Ref2> : TFromType<ModuleProperties, ModuleProperties[Ref]> : TNever)> = Result;
 type TFromAwaited<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TAwaited<T0> : never);
-type TFromIndex<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TIndex<T0, T1> : never);
+type TFromIndex<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TIndex<T0, TIndexPropertyKeys<T1>> extends infer Result extends TSchema ? Result : never : never);
 type TFromKeyOf<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TKeyOf<T0> : never);
 type TFromPartial<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TPartial<T0> : never);
 type TFromOmit<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TOmit<T0, T1> : never);

package/build/esm/type/module/compute.mjs

@@ -127,9 +127,6 @@ export function FromType(moduleProperties, type) {
             // Traveral
             KindGuard.IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) :
                 KindGuard.IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) :
-                    // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
-                    // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
-                    // be a priority as there is a potential for the current inference to break on TS compiler changes.
                     KindGuard.IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters)) :
                         KindGuard.IsConstructor(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
                             KindGuard.IsFunction(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) :

package/build/esm/type/module/infer.d.mts

@@ -37,7 +37,9 @@ type InferProperties<ModuleProperties extends TProperties, Properties extends TP
 }>;
 type TInferObject<ModuleProperties extends TProperties, Properties extends TProperties> = (InferProperties<ModuleProperties, Properties>);
 type TInferTuple<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferTuple<ModuleProperties, R, [...Result, TInfer<ModuleProperties, L>]> : Result);
-type TInferRecord<ModuleProperties extends TProperties, Key extends TSchema, Type extends TSchema, InferredKey extends PropertyKey = TInfer<ModuleProperties, Key> extends infer Key extends PropertyKey ? Key : never, InferedType extends unknown = TInfer<ModuleProperties, Type>> = Record<InferredKey, InferedType>;
+type TInferRecord<ModuleProperties extends TProperties, Key extends TSchema, Type extends TSchema, InferredKey extends PropertyKey = TInfer<ModuleProperties, Key> extends infer Key extends PropertyKey ? Key : never, InferedType extends unknown = TInfer<ModuleProperties, Type>> = Ensure<{
+    [_ in InferredKey]: InferedType;
+}>;
 type TInferRef<ModuleProperties extends TProperties, Ref extends string> = (Ref extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Ref]> : unknown);
 type TInferUnion<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = never> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferUnion<ModuleProperties, R, Result | TInfer<ModuleProperties, L>> : Result);
 type TInfer<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TInferArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TInferAsyncIterator<ModuleProperties, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TInferConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TInferFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TInferIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TInferIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TInferObject<ModuleProperties, Properties> : Type extends TRecord<infer Key extends TSchema, infer Type extends TSchema> ? TInferRecord<ModuleProperties, Key, Type> : Type extends TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Static<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> : Static<Type>);

package/build/esm/type/record/record.d.mts

@@ -52,7 +52,7 @@ export interface TRecord<Key extends TSchema = TSchema, Type extends TSchema = T
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [Key, TComputed<Target, Parameters>]> : Key extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [TComputed<Target, Parameters>, Type]> : Key extends TRef<infer Ref extends string> ? TComputed<'Record', [TRef<Ref>, Type]> : Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer Enum extends TEnumRecord> ? TFromEnumKey<Enum, Type> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Type> : Key extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteralKey<Value, Type> : Key extends TInteger ? TFromIntegerKey<Key, Type> : Key extends TNumber ? TFromNumberKey<Key, Type> : Key extends TRegExp ? TFromRegExpKey<Key, Type> : Key extends TString ? TFromStringKey<Key, Type> : Key extends TAny ? TFromAnyKey<Key, Type> : Key extends TNever ? TFromNeverKey<Key, Type> : Key);
+export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [Key, TComputed<Target, Parameters>]> : Key extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [TComputed<Target, Parameters>, Type]> : Key extends TRef<infer Ref extends string> ? TComputed<'Record', [TRef<Ref>, Type]> : Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer Enum extends TEnumRecord> ? TFromEnumKey<Enum, Type> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Type> : Key extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteralKey<Value, Type> : Key extends TInteger ? TFromIntegerKey<Key, Type> : Key extends TNumber ? TFromNumberKey<Key, Type> : Key extends TRegExp ? TFromRegExpKey<Key, Type> : Key extends TString ? TFromStringKey<Key, Type> : Key extends TAny ? TFromAnyKey<Key, Type> : Key extends TNever ? TFromNeverKey<Key, Type> : TNever);
 /** `[Json]` Creates a Record type */
 export declare function Record<Key extends TSchema, Type extends TSchema>(key: Key, type: Type, options?: ObjectOptions): TRecordOrObject<Key, Type>;
 export {};

package/build/esm/type/type/json.d.mts

@@ -7,7 +7,7 @@ import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index.mjs';
 import { type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index.mjs';
 import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index.mjs';
 import { type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from '../extract/index.mjs';
-import { TIndex, type TIndexPropertyKeys } from '../indexed/index.mjs';
+import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult, type TIndexFromComputed } from '../indexed/index.mjs';
 import { type IntegerOptions, type TInteger } from '../integer/index.mjs';
 import { Intersect, type IntersectOptions } from '../intersect/index.mjs';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index.mjs';
@@ -93,13 +93,19 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, key: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+    Index<Type extends TRef, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, Key extends TMappedKey>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
+    Index<Type extends TSchema, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, Key extends TMappedResult>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
+    Index<Type extends TRef, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
+    Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TIndexFromMappedKey<Type, MappedKey>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, Key extends TSchema, PropertyKeys extends PropertyKey[] = TIndexPropertyKeys<Key>>(T: Type, K: Key, options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
     /** `[Json]` Creates an Integer type */
     Integer(options?: IntegerOptions): TInteger;
     /** `[Json]` Creates an Intersect type */

package/build/esm/value/parse/parse.d.mts

@@ -4,7 +4,7 @@ import { StaticDecode } from '../../type/static/index.mjs';
 export declare class ParseError extends TypeBoxError {
     constructor(message: string);
 }
-export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | ({} & string);
+export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | 'Encode' | ({} & string);
 export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown;
 export declare namespace ParseRegistry {
     function Delete(key: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.9",
+  "version": "0.34.11",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -1022,7 +1022,7 @@ if(TypeGuard.IsString(T)) {
 
 ## Syntax Types
 
-Syntax Types is a feature that enables TypeBox to parse TypeScript type annotations directly into Json Schema. This feature works both at runtime and statically within the type system. Syntax Types use Json Schema as the Abstract Syntax Tree (AST) parse target for TypeScript types. Syntax Types are designed to offer a syntactical frontend to the standard Type Builder API.
+TypeBox has support for parsing TypeScript type annotations directly into TypeBox types. This feature supports both runtime and static parsing, with TypeBox implementing TypeScript parsers within the TypeScript type system itself. Syntax Types use the TypeBox Json Schema representations as an AST target for TypeScript types, providing a direct mapping between TypeScript syntax and Json Schema. Syntax Types are offered as a syntactical frontend to the Standard Type Builder API.
 
 This feature is available via optional import.
 
@@ -1051,7 +1051,7 @@ const C = Parse(`{ x: number, y: number }`)         // const C: TObject<{
                                                     // }>
 ```
 
-Syntax Types can be composed with Standard Types. 
+Syntax Types can compose with Standard Types created via the Type Builder API
 
 ```typescript
 const T = Type.Object({                             // const T: TObject<{
@@ -1061,7 +1061,7 @@ const T = Type.Object({                             // const T: TObject<{
 })                                                  // }>
 ```
 
-It is also possible to pass Standard Types to Syntax Types in the following way.
+Standard Types can also be passed to and referenced within Syntax Types.
 
 ```typescript
 const X = Type.Number()
@@ -1075,7 +1075,7 @@ const T = Parse({ X, Y, Z }, `{
 }`)
 ```
 
-Syntax Types can also be used to parse Module types.
+Syntax Types also support Module parsing.
 
 ```typescript
 const Foo = Parse(`module Foo {
@@ -1127,7 +1127,7 @@ type T = StaticParseAsType<{}, '{ x: number }'>     // type T = {
 
 ### Limitations
 
-Syntax Types work by having TypeBox parse TypeScript syntax within the TypeScript type system. This approach can place some strain on the TypeScript compiler and language service, potentially affecting responsiveness. While TypeBox makes a best-effort attempt to optimize for Syntax Types, users should be mindful of the following structures:
+TypeBox parses TypeScript types directly within the TypeScript type system. This process does come with an inference cost, which scales with the size and complexity of the types being parsed. Although TypeBox strives to optimize Syntax Types, users should be aware of the following structures:
 
 ```typescript
 // Excessively wide structures will result in instantiation limits exceeding
@@ -1154,12 +1154,12 @@ const B = Parse(`{
 }`)
 ```
 
-In cases where Syntax Types exceed TypeScript's instantiation limits, TypeBox offers a fallback ParseOnly function, which will only parse but not infer. This function can also be used to parse types where the syntax is statically unknown to TypeScript (for example, when loading types from disk).
+If Syntax Types exceed TypeScript's instantiation limits, users are advised to fall back to the Standard Type Builder API. Alternatively, TypeBox offers a `ParseOnly` function that parses the TypeScript syntax at runtime without statically inferring the schema.
 
 ```typescript
 import { ParseOnly } from '@sinclair/typebox/syntax'
 
-// Where A is TSchema | undefined 
+// const A: TSchema | undefined 
 
 const A = ParseOnly(`{
   x: {
@@ -1172,7 +1172,7 @@ const A = ParseOnly(`{
 }`)
 ```
 
-For more information on TypeBox's parsing infrastructure, refer to the [ParseBox](https://github.com/sinclairzx81/parsebox) project.
+For more information on static parsing, refer to the [ParseBox](https://github.com/sinclairzx81/parsebox) project.
 
 <a name='values'></a>
 
@@ -1333,7 +1333,7 @@ const R = Value.Parse(Type.String(), 'hello')      // const R: string = "hello"
 const E = Value.Parse(Type.String(), undefined)    // throws AssertError 
 ```
 
-You can override the order in which functions are are run, or omit functions entirely in the following way.
+You can override the order in which functions are run, or omit functions entirely using the following.
 
 ```typescript
 // Runs no functions.