typedriver 0.8.9 → 0.8.11

package/build/compile.d.mts

@@ -1,12 +1,6 @@
-import Type from 'typebox';
-import { type StandardSchemaV1, type StandardJSONSchemaV1 } from '@standard-schema/spec';
+import { type Static } from './static.mjs';
 import { Validator } from './validator.mjs';
-type TFromStandardSchema<Input extends StandardSchemaV1, Output extends unknown = StandardSchemaV1.InferInput<Input>, Result extends Validator = Validator<Input, Output>> = Result;
-type TFromStandardJsonSchema<Input extends StandardSchemaV1 & StandardJSONSchemaV1, Output extends unknown = StandardSchemaV1.InferInput<Input>, Result extends Validator = Validator<Input, Output>> = Result;
-type TFromJsonSchema<Input extends Type.TSchema, Output extends unknown = Type.Static<Input>, Result extends Validator = Validator<Input, Output>> = Result;
-type TFromTypeScript<Input extends string, Schema extends Type.TSchema = Type.TScript<{}, Input>, Output extends unknown = Type.Static<Schema>, Result extends Validator = Validator<Input, Output>> = Result;
 /** Compiles a schema into a typed Validator */
-export type TCompile<Schema extends unknown> = (Schema extends string ? TFromTypeScript<Schema> : Schema extends StandardSchemaV1 ? (Schema extends StandardJSONSchemaV1 ? TFromStandardJsonSchema<Schema> : TFromStandardSchema<Schema>) : Schema extends Type.TSchema ? TFromJsonSchema<Schema> : TFromJsonSchema<{}>);
+export type TCompile<Input, Output extends unknown = Static<Input>, Result extends Validator<Input, Output> = Validator<Input, Output>> = Result;
 /** Compiles a schema into a typed Validator */
-export declare function compile<const Schema extends unknown>(schema: Schema): TCompile<Schema>;
-export {};
+export declare function compile<const Input, Output extends Validator = TCompile<Input>>(input: Input): Output;

package/build/compile.mjs

@@ -4,24 +4,22 @@ import { JsonSchemaValidator } from './validators/json-schema/validator.mjs';
 import { StandardJsonSchemaValidator } from './validators/standard-json-schema/validator.mjs';
 import { StandardSchemaValidator } from './validators/standard-schema/validator.mjs';
 import { TypeScriptValidator } from './validators/typescript/validator.mjs';
-function FromStandardSchema(schema) {
-    return new StandardSchemaValidator(schema);
+// ------------------------------------------------------------------
+// Validators
+// ------------------------------------------------------------------
+function CreateStandardSchemaV1Validator(input) {
+    return IsStandardJsonSchemaV1(input) ? new StandardJsonSchemaValidator(input) : new StandardSchemaValidator(input);
 }
-function FromStandardJsonSchema(schema) {
-    return new StandardJsonSchemaValidator(schema);
+function CreateJsonSchemaValidator(input) {
+    return new JsonSchemaValidator(input);
 }
-function FromJsonSchema(schema) {
-    return new JsonSchemaValidator(schema);
-}
-function FromTypeScript(script) {
-    return new TypeScriptValidator(script);
+function CreateTypeScriptValidator(input) {
+    return new TypeScriptValidator(input);
 }
 /** Compiles a schema into a typed Validator */
-export function compile(schema) {
-    return (IsTypeScript(schema) ? FromTypeScript(schema) :
-        IsStandardSchemaV1(schema) ? (IsStandardJsonSchemaV1(schema)
-            ? FromStandardJsonSchema(schema)
-            : FromStandardSchema(schema)) :
-            IsJsonSchema(schema) ? FromJsonSchema(schema) :
-                FromJsonSchema({}));
+export function compile(input) {
+    return (IsTypeScript(input) ? CreateTypeScriptValidator(input) :
+        IsStandardSchemaV1(input) ? CreateStandardSchemaV1Validator(input) :
+            IsJsonSchema(input) ? CreateJsonSchemaValidator(input) :
+                CreateJsonSchemaValidator({}));
 }

package/build/index.d.mts

@@ -1,3 +1,4 @@
+export { Type } from 'typebox';
 export { type TCompile, compile } from './compile.mjs';
 export { type Static } from './static.mjs';
 export { Validator, type TErrorFormat, type TErrorLocale, type TErrorOptions, type TErrorResult, type TJsonSchemaError, type TStandardSchemaError, } from './validator.mjs';

package/build/index.mjs

@@ -1,5 +1,9 @@
 // deno-fmt-ignore-file
 // ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+export { Type } from 'typebox';
+// ------------------------------------------------------------------
 // Compile
 // ------------------------------------------------------------------
 export { compile } from './compile.mjs';

package/build/static.d.mts

@@ -1,10 +1,10 @@
+import { type TSchema, type TScript, type Static as TStatic } from 'typebox';
 import { type StandardSchemaV1 } from '@standard-schema/spec';
 import { type Validator } from './validator.mjs';
-import Type from 'typebox';
 type StaticValidator<_Input extends unknown, Output extends unknown> = (Output);
-type StaticTypeScript<Input extends string, Schema extends Type.TSchema = Type.TScript<{}, Input>, Output extends unknown = Type.Static<Schema>> = Output;
+type StaticTypeScript<Input extends string, Schema extends TSchema = TScript<{}, Input>, Output extends unknown = TStatic<Schema>> = Output;
 type StaticStandardSchema<Input extends StandardSchemaV1, Output extends unknown = StandardSchemaV1.InferOutput<Input>> = Output;
-type StaticJsonSchema<Input extends Type.TSchema, Output extends unknown = Type.Static<Input>> = Output;
-type StaticInput<Input extends unknown> = (Input extends Validator<infer Input extends unknown, infer Output extends unknown> ? StaticValidator<Input, Output> : Input extends string ? StaticTypeScript<Input> : Input extends StandardSchemaV1 ? StaticStandardSchema<Input> : Input extends Type.TSchema ? StaticJsonSchema<Input> : unknown);
+type StaticJsonSchema<Input extends TSchema, Output extends unknown = TStatic<Input>> = Output;
+type StaticInput<Input extends unknown> = (Input extends Validator<infer Input extends unknown, infer Output extends unknown> ? StaticValidator<Input, Output> : Input extends string ? StaticTypeScript<Input> : Input extends StandardSchemaV1 ? StaticStandardSchema<Input> : Input extends TSchema ? StaticJsonSchema<Input> : unknown);
 export type Static<Input, Output = StaticInput<Input>> = Output;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typedriver",
   "description": "High Performance Driver for Runtime Type System Integration",
-  "version": "0.8.9",
+  "version": "0.8.11",
   "keywords": [
     "typescript",
     "json-schema",

package/readme.md

@@ -45,9 +45,7 @@ Compiles: [TypeScript](https://www.typescriptlang.org/play/?target=99&module=7#c
 
 ## Overview
 
-TypeDriver is a validation compiler and type-inference middleware designed to integrate JSON Schema and Standard Schema compliant validation into framework interfaces such as HTTP routes and RPC endpoints. It also functions as a validation optimizer built to accelerate high-throughput messaging systems.
-
-This project is designed to unify heterogeneous runtime schema systems based on JSON Schema and Standard Schema into a single system that preserves static type inference, runtime validation, and schema reflection, while remaining compatible with multiple schema ecosystems.
+TypeDriver is a multi-library compiler and type-inference middleware designed to integrate JSON Schema and Standard Schema validation into framework I/O interfaces such as HTTP routes and RPC endpoints. It provides high-performance compiler support for a wide range of ecosystem libraries and offers first-class TypeScript and JSON Schema validation and type inference as standard.
 
 License MIT
 
@@ -71,25 +69,20 @@ License MIT
 
 ## Features
 
-- Framework Integration
-  - Designed specifically for [type-safe](#Framework) I/O interfaces.
-  - One function to [compile](#compile) schematics into Validators.
-  - One type to [infer](#Static) schematics into TypeScript types.
-  - Schema [extension](#Extensions) model for Framework specific runtime type API
-- Schema Support
-  - TypeScript [DSL](#Script) for TS7-native (supported in TS5+).
-  - Scalable JSON Schema type inference ([demo](https://tsplay.dev/wjrYMw))
-  - Supports JSON Schema Drafts 3 through 2020-12.
-  - Full support for Standard Schema
-- Validation Compiler
-  - High-performance JIT compiler for faster application start up.
-  - High-performance runtime validation (approx 2x Ajv performance)
-  - Automatic [acceleration](#Accelerate) for libraries supporting Standard JSON Schema.
-  - Automatic JIT fallback for [content-security](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/CSP) restrictive environments (Cloudflare)
-- Tooling and Interoperability
-  - JSON Schema [reflect](#Reflect) API for OpenAPI, MCP, and IDL-Based Systems
-  - Error [formats](#Errors) for JSON Schema and Standard Schema Based Systems
-  - Includes [localized](#Locales) error messages (i18n) as standard.
+TypeDriver provides a comprehensive set of features for integrating type-safe validation across multiple schema ecosystems:
+
+- Single [function](#Compile) to compile multiple schematics into validators.
+- Single [type](#Static) for inferring TypeScript types from multiple schematics.
+- Integrated TypeScript [DSL](#Script) for TS7-native (supported in TS5+).
+- Validation support for JSON Schema Drafts 3 through 2020-12.
+- Supports Standard Schema and Standard JSON Schema (with [acceleration](#Accelerate))
+- High-performance JIT compiler for improved application start up.
+- High-performance runtime validation (approx 2x Ajv check performance)
+- JIT compile fallback for [content-security](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/CSP) restrictive edge environments (e.g. Cloudflare)
+- Schema [extension](#Extensions) model for custom type safe builder API's.
+- JSON Schema [reflect](#Reflect) API for OpenAPI, MCP, and IDL-Based Systems
+- Error [formats](#Errors) for JSON Schema and Standard Schema Based Systems
+- Includes [localized](#Locales) error messages (i18n) as standard.
 
 ## Framework
 
@@ -400,25 +393,28 @@ validator.schema()          // will return the schematic used for compile.
 
 ## Extensions
 
-TypeDriver enables Frameworks to define custom Runtime Types specific to the Framework. This can be achieved by creating functions that return statically observable JSON Schema. These schematics can be passed to compile(...) and Static and used like any other type.
+TypeDriver supports the creation of framework specific type builder API. This can be achieved by creating functions that return statically observable JSON Schema. These schematics can be passed directly to compile(...) and Static. TypeDriver will derive the correct TypeScript type based on the schema returned.
 
-Ref: [Framework Types](https://www.typescriptlang.org/play/?target=99&module=7#code/JYWwDg9gTgLgBAbzgYwuYAbApgGjjATzCzgGUYBDGYZOAXzgDMo04ByQ4gEymADcsUNgChhAejFwAtDNlz5CxUuUrVU8ZICqAZwoBzLBulqTps2uGoAdtvgA1LMhjQAzHAC8KNGExYAFBAARgBWjjB+CMJwcAAeAFxwVgCuIIGCfgCUOFFwBAnJqelZOQBe+SlpUJnCdBkZopwkDk6uHmSU1MgAPI0QjHDNzlAuAHyiEsbmU9MmRppWwBBWACoQy0lg2Ak6WFz4EHAAojEwUBROcAAKLMSwBADSWATaTCwgVzeC1FjaRjP-AIUwkacHmixWEAAklYYIJtGFwV1NCM2n5NHAsCcsFYuC8KFYCHAAPxwPzxUEZDwovgQYB7fJYARQSmY2E4l5khLAKyMQRwSGU9zU2l7EmQuAMpnAogkAAyFFsAHlGEiUZ4wUtVtDYVB4U5EaCMVj2XB8YSSZyKVS4DS6RLEoy+SjWdjcaTydzeVA4LLBcK7STZfarI6oNLiKCFpq1htsEi8PLbG1EzBlaq1XAANqaAC6RrZbszIaZeZJmbzCUzADoaxqIetNlgusdkBgklwm5oEwqYCMRt3bDnxpJAaPAUYAGJnEBYADu0AA1oqQmE-mP11NwyQAEpYACOSWAUF2AEEoGcCF1rhBbt8Xi6TbvUFAuF1bLwrHo8EkrAurBBZysfscmvW8Hiee9jTdd9uT0NpjlOc4YC6Bcnj6D4by+YAfjwGDP2A6JdwPI9T3PChCXVKN61jJtQK+cDnjGDMiMPY8uDPC9hExSBYDgbkdUYc4SCnCgZ3nKAlxXJwr0+WBsMggsXifaBXzwr84B-P8AKAlFImiRoEjYIJQicNg8ByMBZLvBI6LknC4ByY9iLYhIWJI9iyMvWy7zGOguJiHj4EYH99SWOBjLCLprCTbz5PzV0lMcFS31OWDv1-f9AL7PxLMwuztBsqz5IyBIRLExdlxM5DYp+XTHKwGAkigKxEHwGVDIi0y8Cc1jdgSSqwirVDnhyoqfiyOBctvOKGAVB0pT8iYN2W0xJ2nOdFwAOQqQQ1xW-alGEfjBEE5BhPW8SF22wpvT0triEMgpKhEPzuOgIKQuoMKnqKUqLq2nbboc6Jj0a5rWoM9gfqEegaiAA)
+Ref: [Advanced Framework Types](https://tsplay.dev/mMkoZw)
 
 ```typescript
-import compile, { type Static } from 'typedriver'
+import { type Static } from 'typedriver'
 
-interface FrameworkString {
+interface TEmail {
   type: 'string'
 }
-export function number(): FrameworkString { 
-  return { type: 'string' }
+export function email(): TEmail { 
+  return { type: 'string', format: 'email' }
 }
 
 // ... Usage
 
-const T = number()                     // const T: FrameworkString = { type: 'number' }
+const T = email()                      // const T: TEmail = { 
+                                       //   type: 'string', 
+                                       //   format: 'email' 
+                                       // }
 
-type T = Static<typeof T>              // type T = number
+type T = Static<typeof T>              // type T = string
 ```
 
 ## Accelerate