@sinclair/typebox 0.34.23 → 0.34.25

package/build/cjs/syntax/runtime.d.ts

@@ -1,6 +1,8 @@
 import { Runtime } from '../parser/index';
 import * as t from '../type/index';
 export declare const Module: Runtime.Module<{
+    GenericArgumentList: Runtime.IUnion<unknown[]>;
+    GenericArguments: Runtime.ITuple<{}>;
     Literal: Runtime.IUnion<t.TLiteral<string> | t.TLiteral<number> | t.TLiteral<boolean>>;
     Keyword: Runtime.IUnion<t.TAny | t.TBoolean | t.TBigInt | t.TNever | t.TString | t.TNumber | t.TInteger | t.TNull | t.TSymbol | t.TUndefined | t.TUnknown | t.TVoid>;
     KeyOf: Runtime.IUnion<boolean>;

package/build/cjs/syntax/runtime.js

@@ -40,6 +40,44 @@ const Dereference = (context, key) => {
     return key in context ? context[key] : t.Ref(key);
 };
 // ------------------------------------------------------------------
+// GenericArgumentList
+// ------------------------------------------------------------------
+// prettier-ignore
+const GenericArgumentListMapping = (results) => {
+    return (results.length === 3 ? [results[0], ...results[2]] :
+        results.length === 2 ? [results[0]] :
+            results.length === 1 ? [results[0]] :
+                []);
+};
+// prettier-ignore
+const GenericArgumentList = index_1.Runtime.Union([
+    index_1.Runtime.Tuple([index_1.Runtime.Ident(), index_1.Runtime.Const(Comma), index_1.Runtime.Ref('GenericArgumentList')]),
+    index_1.Runtime.Tuple([index_1.Runtime.Ident(), index_1.Runtime.Const(Comma)]),
+    index_1.Runtime.Tuple([index_1.Runtime.Ident()]),
+    index_1.Runtime.Tuple([]),
+], (results) => GenericArgumentListMapping(results));
+// ------------------------------------------------------------------
+// GenericArguments
+// ------------------------------------------------------------------
+// prettier-ignore
+const GenericArgumentsContext = (args) => {
+    return args.reduce((result, arg, index) => {
+        return { ...result, [arg]: t.Argument(index) };
+    }, {});
+};
+// prettier-ignore
+const GenericArgumentsMapping = (results) => {
+    return results.length === 3
+        ? GenericArgumentsContext(results[1])
+        : {};
+};
+// prettier-ignore
+const GenericArguments = index_1.Runtime.Tuple([
+    index_1.Runtime.Const(LAngle),
+    index_1.Runtime.Ref('GenericArgumentList'),
+    index_1.Runtime.Const(RAngle),
+], results => GenericArgumentsMapping(results));
+// ------------------------------------------------------------------
 // GenericReference
 // ------------------------------------------------------------------
 function GenericReferenceMapping(results, context) {
@@ -614,6 +652,11 @@ const Uint8Array = index_1.Runtime.Const('Uint8Array', index_1.Runtime.As(t.Uint
 // ------------------------------------------------------------------
 // prettier-ignore
 exports.Module = new index_1.Runtime.Module({
+    // ----------------------------------------------------------------
+    // Generic Arguments
+    // ----------------------------------------------------------------
+    GenericArgumentList,
+    GenericArguments,
     // ----------------------------------------------------------------
     // Type Expressions
     // ----------------------------------------------------------------

package/build/cjs/syntax/static.d.ts

@@ -42,6 +42,27 @@ type Delimit<Parser extends Static.IParser, Delimiter extends Static.IParser> =
     Static.Tuple<[]>
 ], DelimitMapping>);
 type Dereference<Context extends t.TProperties, Ref extends string> = (Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>);
+interface GenericArgumentListMapping extends Static.IMapping {
+    output: (this['input'] extends [infer Ident extends string, Comma, infer Rest extends unknown[]] ? [Ident, ...Rest] : this['input'] extends [infer Ident extends string, Comma] ? [Ident] : this['input'] extends [infer Ident extends string] ? [Ident] : [
+    ]);
+}
+type GenericArgumentList = Static.Union<[
+    Static.Tuple<[Static.Ident, Static.Const<Comma>, GenericArgumentList]>,
+    Static.Tuple<[Static.Ident, Static.Const<Comma>]>,
+    Static.Tuple<[Static.Ident]>,
+    Static.Tuple<[]>
+], GenericArgumentListMapping>;
+type GenericArgumentsContext<Args extends string[], Result extends t.TProperties = {}> = (Args extends [...infer Left extends string[], infer Right extends string] ? GenericArgumentsContext<Left, Result & {
+    [_ in Right]: t.TArgument<Left['length']>;
+}> : t.Evaluate<Result>);
+interface GenericArgumentsMapping extends Static.IMapping {
+    output: this['input'] extends [LAngle, infer Args extends string[], RAngle] ? GenericArgumentsContext<Args> : never;
+}
+export type GenericArguments = Static.Tuple<[
+    Static.Const<LAngle>,
+    GenericArgumentList,
+    Static.Const<RAngle>
+], GenericArgumentsMapping>;
 interface GenericReferenceMapping extends Static.IMapping {
     output: this['context'] extends t.TProperties ? this['input'] extends [infer Reference extends string, LAngle, infer Args extends t.TSchema[], RAngle] ? t.TInstantiate<Dereference<this['context'], Reference>, Args> : never : never;
 }

package/build/cjs/syntax/syntax.d.ts

@@ -1,33 +1,31 @@
-import * as Types from '../type/index';
+import * as t from '../type/index';
 import { Static } from '../parser/index';
-import { Type } from './static';
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
-export declare function NoInfer<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
-export declare function NoInfer<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
-/** Infers a TSchema type from TypeScript syntax. */
-export type TSyntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = (Static.Parse<Type, Code, Context> extends [infer Type extends Types.TSchema, string] ? Type : Types.TNever);
-/** Parses a TSchema type from TypeScript syntax */
-export declare function Syntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>;
-/** Parses a TSchema type from TypeScript syntax */
-export declare function Syntax<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>;
+import { Type, GenericArguments } from './static';
+type TParseSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (Static.Parse<GenericArguments, Code, {}> extends [infer Args extends t.TProperties, infer Rest extends string] ? Static.Parse<Type, Rest, Context & Args> : Static.Parse<Type, Code, Context>);
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+export declare function NoInfer<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema;
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+export declare function NoInfer<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema;
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
+export type TSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (TParseSyntax<Context, Code> extends [infer Type extends t.TSchema, string] ? Type : t.TNever);
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
+export declare function Syntax<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>;
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
+export declare function Syntax<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>;
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
-export declare function Parse<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>;
+export declare function Parse<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>;
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
-export declare function Parse<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>;
+export declare function Parse<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>;
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
-export declare function ParseOnly<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+export declare function ParseOnly<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema | undefined;
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
-export declare function ParseOnly<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+export declare function ParseOnly<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema | undefined;
+export {};

package/build/cjs/syntax/syntax.js

@@ -5,31 +5,36 @@ exports.NoInfer = NoInfer;
 exports.Syntax = Syntax;
 exports.Parse = Parse;
 exports.ParseOnly = ParseOnly;
-const Types = require("../type/index");
+const t = require("../type/index");
 const runtime_1 = require("./runtime");
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+// prettier-ignore
+function ParseSyntax(context, code) {
+    const results = runtime_1.Module.Parse('GenericArguments', code, {}); // [ArgumentContext, Rest]
+    return (results.length === 2
+        ? runtime_1.Module.Parse('Type', results[1], { ...context, ...results[0] })
+        : runtime_1.Module.Parse('Type', code, context));
+}
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
 // prettier-ignore
 function NoInfer(...args) {
     const withContext = typeof args[0] === 'string' ? false : true;
     const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}];
-    const type = runtime_1.Module.Parse('Type', code, context)[0];
-    return Types.KindGuard.IsSchema(type)
-        ? Types.CloneType(type, options)
-        : Types.Never(options);
+    const result = ParseSyntax(context, code)[0];
+    return t.KindGuard.IsSchema(result)
+        ? t.CloneType(result, options)
+        : t.Never(options);
 }
-/** Parses a TSchema type from TypeScript syntax */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
 function Syntax(...args) {
     return NoInfer.apply(null, args);
 }
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
 function Parse(...args) {
     return NoInfer.apply(null, args);
 }
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
 function ParseOnly(...args) {

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

@@ -1,6 +1,6 @@
 import { type TSchema } from '../schema/index';
 import { type TArgument } from '../argument/index';
-import { type TNever } from '../never/index';
+import { type TUnknown } from '../unknown/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type TReadonly } from '../readonly/index';
 import { type TOptional } from '../optional/index';
@@ -24,9 +24,9 @@ type TFromArray<Args extends TSchema[], Type extends TSchema, Result extends TAr
 type TFromAsyncIterator<Args extends TSchema[], Type extends TSchema, Result extends TAsyncIterator = TAsyncIterator<TFromType<Args, Type>>> = Result;
 type TFromIterator<Args extends TSchema[], Type extends TSchema, Result extends TIterator = TIterator<TFromType<Args, Type>>> = Result;
 type TFromPromise<Args extends TSchema[], Type extends TSchema, Result extends TPromise = TPromise<TFromType<Args, Type>>> = Result;
-type TFromObject<Args extends TSchema[], Properties extends TProperties, Result extends TObject = TObject<TFromProperties<Args, Properties>>> = Result;
+type TFromObject<Args extends TSchema[], Properties extends TProperties, MappedProperties extends TProperties = TFromProperties<Args, Properties>, Result extends TObject = TObject<MappedProperties>> = Result;
 type TFromRecord<Args extends TSchema[], Key extends TSchema, Value extends TSchema, MappedKey extends TSchema = TFromType<Args, Key>, MappedValue extends TSchema = TFromType<Args, Value>, Result extends TSchema = TRecordOrObject<MappedKey, MappedValue>> = Result;
-type TFromArgument<Args extends TSchema[], Index extends number> = (Index extends keyof Args ? Args[Index] : TNever);
+type TFromArgument<Args extends TSchema[], Index extends number, Result extends TSchema = Index extends keyof Args[Index] ? Args[Index] : TUnknown> = Result;
 type TFromProperty<Args extends TSchema[], Type extends TSchema, IsReadonly extends boolean = Type extends TReadonly<Type> ? true : false, IsOptional extends boolean = Type extends TOptional<Type> ? true : false, Mapped extends TSchema = TFromType<Args, Type>, Result extends TSchema = ([
     IsReadonly,
     IsOptional

package/build/cjs/type/instantiate/instantiate.js

@@ -4,11 +4,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromTypes = FromTypes;
 exports.Instantiate = Instantiate;
 const type_1 = require("../clone/type");
-const index_1 = require("../never/index");
+const index_1 = require("../unknown/index");
 const index_2 = require("../readonly-optional/index");
 const index_3 = require("../readonly/index");
 const index_4 = require("../optional/index");
-const index_5 = require("../record/index");
+const index_5 = require("../object/index");
+const index_6 = require("../record/index");
 const ValueGuard = require("../guard/value");
 const KindGuard = require("../guard/kind");
 // prettier-ignore
@@ -62,19 +63,19 @@ function FromPromise(args, type) {
 }
 // prettier-ignore
 function FromObject(args, type) {
-    type.properties = FromProperties(args, type.properties);
-    return type;
+    const mappedProperties = FromProperties(args, type.properties);
+    return { ...type, ...(0, index_5.Object)(mappedProperties) }; // retain options
 }
 // prettier-ignore
 function FromRecord(args, type) {
-    const mappedKey = FromType(args, (0, index_5.RecordKey)(type));
-    const mappedValue = FromType(args, (0, index_5.RecordValue)(type));
-    const result = (0, index_5.Record)(mappedKey, mappedValue);
+    const mappedKey = FromType(args, (0, index_6.RecordKey)(type));
+    const mappedValue = FromType(args, (0, index_6.RecordValue)(type));
+    const result = (0, index_6.Record)(mappedKey, mappedValue);
     return { ...type, ...result }; // retain options
 }
 // prettier-ignore
 function FromArgument(args, argument) {
-    return argument.index in args ? args[argument.index] : (0, index_1.Never)();
+    return argument.index in args ? args[argument.index] : (0, index_1.Unknown)();
 }
 // prettier-ignore
 function FromProperty(args, type) {

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

@@ -1,6 +1,8 @@
 import { Runtime } from '../parser/index.mjs';
 import * as t from '../type/index.mjs';
 export declare const Module: Runtime.Module<{
+    GenericArgumentList: Runtime.IUnion<unknown[]>;
+    GenericArguments: Runtime.ITuple<{}>;
     Literal: Runtime.IUnion<t.TLiteral<string> | t.TLiteral<number> | t.TLiteral<boolean>>;
     Keyword: Runtime.IUnion<t.TAny | t.TBoolean | t.TBigInt | t.TNever | t.TString | t.TNumber | t.TInteger | t.TNull | t.TSymbol | t.TUndefined | t.TUnknown | t.TVoid>;
     KeyOf: Runtime.IUnion<boolean>;

package/build/esm/syntax/runtime.mjs

@@ -36,6 +36,44 @@ const Dereference = (context, key) => {
     return key in context ? context[key] : t.Ref(key);
 };
 // ------------------------------------------------------------------
+// GenericArgumentList
+// ------------------------------------------------------------------
+// prettier-ignore
+const GenericArgumentListMapping = (results) => {
+    return (results.length === 3 ? [results[0], ...results[2]] :
+        results.length === 2 ? [results[0]] :
+            results.length === 1 ? [results[0]] :
+                []);
+};
+// prettier-ignore
+const GenericArgumentList = Runtime.Union([
+    Runtime.Tuple([Runtime.Ident(), Runtime.Const(Comma), Runtime.Ref('GenericArgumentList')]),
+    Runtime.Tuple([Runtime.Ident(), Runtime.Const(Comma)]),
+    Runtime.Tuple([Runtime.Ident()]),
+    Runtime.Tuple([]),
+], (results) => GenericArgumentListMapping(results));
+// ------------------------------------------------------------------
+// GenericArguments
+// ------------------------------------------------------------------
+// prettier-ignore
+const GenericArgumentsContext = (args) => {
+    return args.reduce((result, arg, index) => {
+        return { ...result, [arg]: t.Argument(index) };
+    }, {});
+};
+// prettier-ignore
+const GenericArgumentsMapping = (results) => {
+    return results.length === 3
+        ? GenericArgumentsContext(results[1])
+        : {};
+};
+// prettier-ignore
+const GenericArguments = Runtime.Tuple([
+    Runtime.Const(LAngle),
+    Runtime.Ref('GenericArgumentList'),
+    Runtime.Const(RAngle),
+], results => GenericArgumentsMapping(results));
+// ------------------------------------------------------------------
 // GenericReference
 // ------------------------------------------------------------------
 function GenericReferenceMapping(results, context) {
@@ -610,6 +648,11 @@ const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(t.Uint8Array()));
 // ------------------------------------------------------------------
 // prettier-ignore
 export const Module = new Runtime.Module({
+    // ----------------------------------------------------------------
+    // Generic Arguments
+    // ----------------------------------------------------------------
+    GenericArgumentList,
+    GenericArguments,
     // ----------------------------------------------------------------
     // Type Expressions
     // ----------------------------------------------------------------

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

@@ -42,6 +42,27 @@ type Delimit<Parser extends Static.IParser, Delimiter extends Static.IParser> =
     Static.Tuple<[]>
 ], DelimitMapping>);
 type Dereference<Context extends t.TProperties, Ref extends string> = (Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>);
+interface GenericArgumentListMapping extends Static.IMapping {
+    output: (this['input'] extends [infer Ident extends string, Comma, infer Rest extends unknown[]] ? [Ident, ...Rest] : this['input'] extends [infer Ident extends string, Comma] ? [Ident] : this['input'] extends [infer Ident extends string] ? [Ident] : [
+    ]);
+}
+type GenericArgumentList = Static.Union<[
+    Static.Tuple<[Static.Ident, Static.Const<Comma>, GenericArgumentList]>,
+    Static.Tuple<[Static.Ident, Static.Const<Comma>]>,
+    Static.Tuple<[Static.Ident]>,
+    Static.Tuple<[]>
+], GenericArgumentListMapping>;
+type GenericArgumentsContext<Args extends string[], Result extends t.TProperties = {}> = (Args extends [...infer Left extends string[], infer Right extends string] ? GenericArgumentsContext<Left, Result & {
+    [_ in Right]: t.TArgument<Left['length']>;
+}> : t.Evaluate<Result>);
+interface GenericArgumentsMapping extends Static.IMapping {
+    output: this['input'] extends [LAngle, infer Args extends string[], RAngle] ? GenericArgumentsContext<Args> : never;
+}
+export type GenericArguments = Static.Tuple<[
+    Static.Const<LAngle>,
+    GenericArgumentList,
+    Static.Const<RAngle>
+], GenericArgumentsMapping>;
 interface GenericReferenceMapping extends Static.IMapping {
     output: this['context'] extends t.TProperties ? this['input'] extends [infer Reference extends string, LAngle, infer Args extends t.TSchema[], RAngle] ? t.TInstantiate<Dereference<this['context'], Reference>, Args> : never : never;
 }

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

@@ -1,33 +1,31 @@
-import * as Types from '../type/index.mjs';
+import * as t from '../type/index.mjs';
 import { Static } from '../parser/index.mjs';
-import { Type } from './static.mjs';
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
-export declare function NoInfer<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
-export declare function NoInfer<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
-/** Infers a TSchema type from TypeScript syntax. */
-export type TSyntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = (Static.Parse<Type, Code, Context> extends [infer Type extends Types.TSchema, string] ? Type : Types.TNever);
-/** Parses a TSchema type from TypeScript syntax */
-export declare function Syntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>;
-/** Parses a TSchema type from TypeScript syntax */
-export declare function Syntax<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>;
+import { Type, GenericArguments } from './static.mjs';
+type TParseSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (Static.Parse<GenericArguments, Code, {}> extends [infer Args extends t.TProperties, infer Rest extends string] ? Static.Parse<Type, Rest, Context & Args> : Static.Parse<Type, Code, Context>);
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+export declare function NoInfer<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema;
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+export declare function NoInfer<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema;
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
+export type TSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (TParseSyntax<Context, Code> extends [infer Type extends t.TSchema, string] ? Type : t.TNever);
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
+export declare function Syntax<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>;
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
+export declare function Syntax<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>;
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
-export declare function Parse<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>;
+export declare function Parse<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>;
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
-export declare function Parse<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>;
+export declare function Parse<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>;
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
-export declare function ParseOnly<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+export declare function ParseOnly<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema | undefined;
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
-export declare function ParseOnly<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+export declare function ParseOnly<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema | undefined;
+export {};

package/build/esm/syntax/syntax.mjs

@@ -1,28 +1,33 @@
-import * as Types from '../type/index.mjs';
+import * as t from '../type/index.mjs';
 import { Module } from './runtime.mjs';
-/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+// prettier-ignore
+function ParseSyntax(context, code) {
+    const results = Module.Parse('GenericArguments', code, {}); // [ArgumentContext, Rest]
+    return (results.length === 2
+        ? Module.Parse('Type', results[1], { ...context, ...results[0] })
+        : Module.Parse('Type', code, context));
+}
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
 // prettier-ignore
 export function NoInfer(...args) {
     const withContext = typeof args[0] === 'string' ? false : true;
     const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}];
-    const type = Module.Parse('Type', code, context)[0];
-    return Types.KindGuard.IsSchema(type)
-        ? Types.CloneType(type, options)
-        : Types.Never(options);
+    const result = ParseSyntax(context, code)[0];
+    return t.KindGuard.IsSchema(result)
+        ? t.CloneType(result, options)
+        : t.Never(options);
 }
-/** Parses a TSchema type from TypeScript syntax */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
 export function Syntax(...args) {
     return NoInfer.apply(null, args);
 }
 /**
- * Parses a TSchema type from Syntax.
  * @deprecated Use Syntax() function
  */
 export function Parse(...args) {
     return NoInfer.apply(null, args);
 }
 /**
- * Parses a TSchema from TypeScript Syntax
  * @deprecated Use NoInfer() function
  */
 export function ParseOnly(...args) {

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

@@ -1,6 +1,6 @@
 import { type TSchema } from '../schema/index.mjs';
 import { type TArgument } from '../argument/index.mjs';
-import { type TNever } from '../never/index.mjs';
+import { type TUnknown } from '../unknown/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type TReadonly } from '../readonly/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
@@ -24,9 +24,9 @@ type TFromArray<Args extends TSchema[], Type extends TSchema, Result extends TAr
 type TFromAsyncIterator<Args extends TSchema[], Type extends TSchema, Result extends TAsyncIterator = TAsyncIterator<TFromType<Args, Type>>> = Result;
 type TFromIterator<Args extends TSchema[], Type extends TSchema, Result extends TIterator = TIterator<TFromType<Args, Type>>> = Result;
 type TFromPromise<Args extends TSchema[], Type extends TSchema, Result extends TPromise = TPromise<TFromType<Args, Type>>> = Result;
-type TFromObject<Args extends TSchema[], Properties extends TProperties, Result extends TObject = TObject<TFromProperties<Args, Properties>>> = Result;
+type TFromObject<Args extends TSchema[], Properties extends TProperties, MappedProperties extends TProperties = TFromProperties<Args, Properties>, Result extends TObject = TObject<MappedProperties>> = Result;
 type TFromRecord<Args extends TSchema[], Key extends TSchema, Value extends TSchema, MappedKey extends TSchema = TFromType<Args, Key>, MappedValue extends TSchema = TFromType<Args, Value>, Result extends TSchema = TRecordOrObject<MappedKey, MappedValue>> = Result;
-type TFromArgument<Args extends TSchema[], Index extends number> = (Index extends keyof Args ? Args[Index] : TNever);
+type TFromArgument<Args extends TSchema[], Index extends number, Result extends TSchema = Index extends keyof Args[Index] ? Args[Index] : TUnknown> = Result;
 type TFromProperty<Args extends TSchema[], Type extends TSchema, IsReadonly extends boolean = Type extends TReadonly<Type> ? true : false, IsOptional extends boolean = Type extends TOptional<Type> ? true : false, Mapped extends TSchema = TFromType<Args, Type>, Result extends TSchema = ([
     IsReadonly,
     IsOptional

package/build/esm/type/instantiate/instantiate.mjs

@@ -1,8 +1,9 @@
 import { CloneType } from '../clone/type.mjs';
-import { Never } from '../never/index.mjs';
+import { Unknown } from '../unknown/index.mjs';
 import { ReadonlyOptional } from '../readonly-optional/index.mjs';
 import { Readonly } from '../readonly/index.mjs';
 import { Optional } from '../optional/index.mjs';
+import { Object } from '../object/index.mjs';
 import { Record, RecordKey, RecordValue } from '../record/index.mjs';
 import * as ValueGuard from '../guard/value.mjs';
 import * as KindGuard from '../guard/kind.mjs';
@@ -57,8 +58,8 @@ function FromPromise(args, type) {
 }
 // prettier-ignore
 function FromObject(args, type) {
-    type.properties = FromProperties(args, type.properties);
-    return type;
+    const mappedProperties = FromProperties(args, type.properties);
+    return { ...type, ...Object(mappedProperties) }; // retain options
 }
 // prettier-ignore
 function FromRecord(args, type) {
@@ -69,7 +70,7 @@ function FromRecord(args, type) {
 }
 // prettier-ignore
 function FromArgument(args, argument) {
-    return argument.index in args ? args[argument.index] : Never();
+    return argument.index in args ? args[argument.index] : Unknown();
 }
 // prettier-ignore
 function FromProperty(args, type) {

package/package.json

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

package/readme.md

@@ -98,8 +98,9 @@ License MIT
 - [Syntax](#syntax)
   - [Create](#syntax-create)
   - [Parameters](#syntax-parameters)
-  - [Options](#syntax-options)
   - [Generics](#syntax-generics)
+  - [Options](#syntax-options)
+  - [NoInfer](#syntax-no-infer)
 - [TypeRegistry](#typeregistry)
   - [Type](#typeregistry-type)
   - [Format](#typeregistry-format)
@@ -1306,9 +1307,9 @@ ValuePointer.Set(A, '/z', 1)                         // A' = { x: 1, y: 1, z: 1
 
 ## Syntax Types
 
-TypeBox has support for parsing TypeScript syntax at runtime as well as statically in the type system. This feature offers a syntactical frontend to the TypeBox type builder.
+TypeBox provides experimental support for parsing TypeScript annotation syntax into TypeBox types.
 
-Syntax types are available via optional import.
+This feature is provided via optional import.
 
 ```typescript
 import { Syntax } from '@sinclair/typebox/syntax'
@@ -1318,20 +1319,25 @@ import { Syntax } from '@sinclair/typebox/syntax'
 
 ### Create
 
-Use the Syntax function to create TypeBox types from TypeScript syntax
+Use the Syntax function to create TypeBox types from TypeScript syntax ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgZQJ4DsYEMAecC+cAZlBCHAOQACAzsOgMYA2WwUA9DKmAKYBGEHOxoZsOCgChQkWIhTYYwBgWKly1OoxZtO3foMkSGEdDXgAVOAF4Uo3AAoABkhwAuOOgCuIPjygAaOFR3Lx8-AkcASjgY2Jj2djhjUwt3cwB5PgArHgYYAB4ECTiS0rLyisrYhNi3OHMAOW9fAOKq9o7OuBqY4PqmsKg2rpHR+MT8AD4JCS5eeut5LEUGfLmeCCJ6ybHKmvWFmyLdk86euDrQlv9h07uy876rv1v7t-GCIA))
 
 ```typescript
 const T = Syntax(`{ x: number, y: number }`)        // const T: TObject<{
                                                     //   x: TNumber,
                                                     //   y: TNumber
                                                     // }>
+
+type T = Static<typeof T>                            // type T = {
+                                                     //   x: number,
+                                                     //   y: number
+                                                     // }
 ```
 
 <a name="syntax-parameters"></a>
 
 ### Parameters
 
-Syntax types can be parameterized to receive exterior types.
+Syntax types can be parameterized to receive exterior types ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgZQJ4DsYEMAecC+cAZlBCHAOQACAzsOgMYA2WwUA9DKmAKYBGEHOxoZsOCgCgJDCOhrwAKnAC8KUbgAUAAyQ4AXHHQBXEHx5QANHFQHjp8wS0BKOK7ev27ODLmKDCgHk+ACseBhgAHgQJd1i4+ITEpLdPN304BQA5EzNLGOSCwqK4VNcbDOz7KHzi2rqPL3wAPikfeRQVNUxNJCV8Ky0ABSxYYCwmCIUm52LUtvhkfyDQ8Kia+o2C0rh0wLAYYFlxycrcpot1zav47fK9g6OJrJzzFuv3m8amoA))
 
 ```typescript
 const T = Syntax(`{ x: number, y: number }`)        // const T: TObject<{
@@ -1345,35 +1351,19 @@ const S = Syntax({ T }, `Partial<T>`)               // const S: TObject<{
                                                     // }>
 ```
 
-<a name='syntax-options'></a>
 
-### Options
-
-Options can be passed via the last parameter
-
-```typescript
-const T = Syntax(`number`, {                      // const T = {
-  minimum: 0,                                     //   type: 'number',
-  maximum: 10                                     //   minimum: 0,
-})                                                //   maximum: 10
-                                                  // }
-```
 
 <a name="syntax-generics"></a>
 
 ### Generics
 
-Generic types can be created using positional argument types ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgZQJ4DsYEMAecC+cAZlBCHAOQACAzsOgMYA2WwUA9DKmAKYBGEHOxoZsOCgChQkWIhTYYwBgWKly1OoxZtO3foMkSGEdDXgAVAAxwAvClG4AFBQCCUAOYBXED0wAeSwA+CgBKIxMzOHMARlt7TCdXD29fGD9o4LDjUwsAJji0BJxnNy8ff1zMiXCcuAA1HgYYaAKHYqQrABoo6O7zfPxugAMECTg4HAAuKMtOsbhUaZi58YAvJdyJfCGwmsiAISw6Ggam6BpWosckU+aoAmHR8an6xrv07tm4IJWF6dvoAFur1voFfutXmcoEDvsCwVsdtUuLw4IdjgCoBc7MgFEo-MieBAiKijsATm9zoFxtT2Ow4ASSeiKZi4k9qeyOZyudyeTzadSXkgXiDFrC4BDrIN5ryZbK5ez+eNRULpl9RSCJQ9pfKdbqFXS1tMVWLRV8IbF8Nq9da5fzCEA))
+Syntax types support generic parameters in the following way ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgZQJ4DsYEMAecC+cAZlBCHAOQACAzsOgMYA2WwUA9DKmAKYBGEHOxoZsOCgChQkWIhTYYwBgWKly1OoxZtO3foMkSGEdDXgA1HgxjQ4AXhSjcACgAGAHgAaAGjgBNXwAtAD45CTg4HAAuOB84cLhUGID4iIAvGMD4-FcASgkjEzM4ACEsOhpLa2gae0dMFyQqmygCX1cEBOi4Zuh3AEZfAAZh4O8EpJ6rFvcRuEG4IbGEjKnqqFnh337lnPyJLl5S8uBK6Zq65AUld0OeCCJjit6oGlCIiPZ2ODun05fag5Oh8QaCweCIZCoV8Pt0kN0FpM5qshm0ElCMZisSCYRFJvCYnNJgsUWjseSKeDcXBVgTFr4kb5Vv0COjKezsTD8EA))
 
 ```typescript
-const T0 = Syntax('Argument<0>')
-const T1 = Syntax('Argument<1>')
-const T2 = Syntax('Argument<2>')
-
-const Vector = Syntax({ T0, T1, T2 }, `{
-  x: T0,
-  y: T1,
-  z: T2
+const Vector = Syntax(`<X, Y, Z> { 
+  x: X, 
+  y: Y, 
+  z: Z 
 }`)
 
 const BasisVectors = Syntax({ Vector }, `{
@@ -1386,7 +1376,37 @@ type BasisVectors = Static<typeof BasisVectors>     // type BasisVectors = {
                                                     //   x: { x: 1, y: 0, z: 0 },
                                                     //   y: { x: 0, y: 1, z: 0 },
                                                     //   z: { x: 0, y: 0, z: 1 }
-                                                    // } 
+                                                    // }
+```
+
+<a name='syntax-options'></a>
+
+### Options
+
+Options can be passed via the last parameter
+
+```typescript
+const T = Syntax(`number`, { minimum: 42 })       // const T = {
+                                                  //   type: 'number',
+                                                  //   minimum: 42
+                                                  // }
+```
+
+<a name='syntax-no-infer'></a>
+
+### NoInfer
+
+Syntax parsing is an expensive type level operation and can impact on language service performance. Use the NoInfer function parse syntax at runtime only.
+
+```typescript
+import { NoInfer } from '@sinclair/typebox/syntax'
+
+const T = NoInfer(`number | string`)                // const T: TSchema = {
+                                                    //   anyOf: [
+                                                    //     { type: 'number' },
+                                                    //     { type: 'string' }
+                                                    //   ]
+                                                    // }
 ```
 
 <a name='typeregistry'></a>