typedriver 0.8.8 → 0.8.10

package/build/compile.d.mts

@@ -1,12 +1,6 @@
-import Type from 'typebox';
-import { type StandardSchemaV1, type StandardJSONSchemaV1 } from './_standard/standard-schema.mjs';
+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/errors/normal-issue.d.mts

@@ -1,4 +1,4 @@
-import type { StandardSchemaV1 } from '../_standard/standard-schema.mjs';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { TStandardSchemaError } from '../validator.mjs';
 /** (Internal) Normalize a StandardSchemaV1.Issue as TStandardSchemaError. */
 export declare function normalIssue(issue: StandardSchemaV1.Issue): TStandardSchemaError;

package/build/guard/standard-json-schema.d.mts

@@ -1,2 +1,2 @@
-import { StandardSchemaV1, StandardJSONSchemaV1 } from '../_standard/standard-schema.mjs';
+import { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';
 export declare function IsStandardJsonSchemaV1(value: unknown): value is StandardSchemaV1 & StandardJSONSchemaV1;

package/build/guard/standard-schema.d.mts

@@ -1,2 +1,2 @@
-import { StandardSchemaV1 } from '../_standard/standard-schema.mjs';
+import { StandardSchemaV1 } from '@standard-schema/spec';
 export declare function IsStandardSchemaV1(value: unknown): value is StandardSchemaV1;

package/build/static.d.mts

@@ -1,10 +1,10 @@
-import { type StandardSchemaV1 } from './_standard/standard-schema.mjs';
+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/build/validators/standard-json-schema/resolve.d.mts

@@ -1,3 +1,3 @@
-import { StandardJSONSchemaV1 } from '../../_standard/standard-schema.mjs';
+import { StandardJSONSchemaV1 } from '@standard-schema/spec';
 /** (Internal) Resolves a JsonSchema representation (need discovery mechanism here) */
 export declare function resolveJsonSchema(input: StandardJSONSchemaV1): Record<string, unknown>;

package/build/validators/standard-json-schema/validator.d.mts

@@ -1,4 +1,4 @@
-import { StandardJSONSchemaV1, StandardSchemaV1 } from '../../_standard/standard-schema.mjs';
+import { StandardJSONSchemaV1, StandardSchemaV1 } from '@standard-schema/spec';
 import { Validator, type TErrorOptions, type TErrorResult } from '../../validator.mjs';
 export declare class StandardJsonSchemaValidator<Input extends StandardJSONSchemaV1 & StandardSchemaV1, Output extends unknown = StandardSchemaV1.InferOutput<Input>> extends Validator<Input, Output> {
     private readonly input;

package/build/validators/standard-schema/validator.d.mts

@@ -1,4 +1,4 @@
-import { StandardSchemaV1 } from '../../_standard/standard-schema.mjs';
+import { StandardSchemaV1 } from '@standard-schema/spec';
 import { Validator, type TErrorOptions, type TErrorResult } from '../../validator.mjs';
 export declare class StandardSchemaValidator<Input extends StandardSchemaV1, Output extends unknown = StandardSchemaV1.InferOutput<Input>> extends Validator<Input, Output> {
     private readonly input;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typedriver",
   "description": "High Performance Driver for Runtime Type System Integration",
-  "version": "0.8.8",
+  "version": "0.8.10",
   "keywords": [
     "typescript",
     "json-schema",
@@ -14,7 +14,8 @@
     "url": "https://github.com/sinclairzx81/typedriver"
   },
   "dependencies": {
-    "typebox": "^1.0.61"
+    "@standard-schema/spec": "1.1.0",
+    "typebox": "^1.0.64"
   },
   "type": "module",
   "types": "./build/index.d.mts",

package/readme.md

@@ -423,7 +423,7 @@ type T = Static<typeof T>              // type T = number
 
 ## Accelerate
 
-TypeDriver provides acceleration support for libraries that implement the upcoming Standard JSON Schema specification. This is a new specification enables remote type libraries to be integrated directly into TypeBox validation infrastructure. This project tracks upstream implementations of this specification and maintains a benchmark measuring compariative performance with and without compile(...).
+TypeDriver provides acceleration support for libraries that implement the Standard JSON Schema specification.
 
 ```bash
 $ deno task bench
@@ -440,20 +440,17 @@ const Vector3 = compile(`{
 Accelerated Indicates Support for Standard JSON Schema
 
 ```bash
-┌────────────┬────────────┬─────────────┬──────────────┬──────────────┬─────────────────┐
-│ (idx)      │ iterations │ accelerated │ default(...) │ compile(...) │ result          │
-├────────────┼────────────┼─────────────┼──────────────┼──────────────┼─────────────────┤
-│ typescript │ 16000000   │ true        │ "  ------"   │ "   30 ms"   │ "  ------"      │
-│ jsonschema │ 16000000   │ true        │ "  ------"   │ "   29 ms"   │ "  ------"      │
-│ arktype    │ 16000000   │ true        │ "  537 ms"   │ "   30 ms"   │ "94.41% faster" │
-│ arri       │ 16000000   │ false       │ " 3086 ms"   │ " 3049 ms"   │ "1.20% faster"  │
-│ effect     │ 16000000   │ false       │ "24183 ms"   │ "23886 ms"   │ "1.23% faster"  │
-│ sury       │ 16000000   │ false       │ "  153 ms"   │ "  166 ms"   │ "8.33% slower"  │
-│ valibot    │ 16000000   │ false       │ " 3632 ms"   │ " 3515 ms"   │ "3.21% faster"  │
-│ zod        │ 16000000   │ false       │ "  575 ms"   │ "  603 ms"   │ "4.93% slower"  │
-└────────────┴────────────┴─────────────┴──────────────┴──────────────┴─────────────────┘
-
-Last Run: Thu Dec 04 2025
+┌────────────┬────────────┬─────────────┬────────────────┬───────────────┬──────────────┐
+│ (idx)      │ iterations │ accelerated │ standard (...) │ compile (...) │ performance  │
+├────────────┼────────────┼─────────────┼────────────────┼───────────────┼──────────────┤
+│ typescript │ 16000000   │ true        │ "     30 ms"   │ "     29 ms"  │ "    1.02 ×" │
+│ jsonschema │ 16000000   │ true        │ "     29 ms"   │ "     29 ms"  │ "    1.00 ×" │
+│ zod        │ 16000000   │ true        │ "    571 ms"   │ "     28 ms"  │ "   20.43 ×" │
+│ arktype    │ 16000000   │ true        │ "    483 ms"   │ "     30 ms"  │ "   16.10 ×" │
+│ valibot    │ 16000000   │ true        │ "   3239 ms"   │ "     28 ms"  │ "  113.72 ×" │
+└────────────┴────────────┴─────────────┴────────────────┴───────────────┴──────────────┘
+
+Last Run: Sat Dec 20 2025
 ```
 
 ## Compression

package/build/_standard/standard-schema.d.mts

@@ -1,120 +0,0 @@
-/** The Standard Typed interface. This is a base type extended by other specs. */
-export interface StandardTypedV1<Input = unknown, Output = Input> {
-    /** The Standard properties. */
-    readonly '~standard': StandardTypedV1.Props<Input, Output>;
-}
-export declare namespace StandardTypedV1 {
-    /** The Standard Typed properties interface. */
-    export interface Props<Input = unknown, Output = Input> {
-        /** The version number of the standard. */
-        readonly version: 1;
-        /** The vendor name of the schema library. */
-        readonly vendor: string;
-        /** Inferred types associated with the schema. */
-        readonly types?: Types<Input, Output> | undefined;
-    }
-    /** The Standard Typed types interface. */
-    export interface Types<Input = unknown, Output = Input> {
-        /** The input type of the schema. */
-        readonly input: Input;
-        /** The output type of the schema. */
-        readonly output: Output;
-    }
-    /** Infers the input type of a Standard Typed. */
-    export type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['input'];
-    /** Infers the output type of a Standard Typed. */
-    export type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['output'];
-    export {};
-}
-/** The Standard Schema interface. */
-export interface StandardSchemaV1<Input = unknown, Output = Input> {
-    /** The Standard Schema properties. */
-    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
-}
-export declare namespace StandardSchemaV1 {
-    /** The Standard Schema properties interface. */
-    export interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
-        /** Validates unknown input values. */
-        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
-    }
-    /** The result interface of the validate function. */
-    export type Result<Output> = SuccessResult<Output> | FailureResult;
-    /** The result interface if validation succeeds. */
-    export interface SuccessResult<Output> {
-        /** The typed output value. */
-        readonly value: Output;
-        /** A falsy value for `issues` indicates success. */
-        readonly issues?: undefined;
-    }
-    export interface Options {
-        /** Explicit support for additional vendor-specific parameters, if needed. */
-        readonly libraryOptions?: Record<string, unknown> | undefined;
-    }
-    /** The result interface if validation fails. */
-    export interface FailureResult {
-        /** The issues of failed validation. */
-        readonly issues: ReadonlyArray<Issue>;
-    }
-    /** The issue interface of the failure output. */
-    export interface Issue {
-        /** The error message of the issue. */
-        readonly message: string;
-        /** The path of the issue, if any. */
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-    }
-    /** The path segment interface of the issue. */
-    export interface PathSegment {
-        /** The key representing a path segment. */
-        readonly key: PropertyKey;
-    }
-    /** The Standard types interface. */
-    export interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
-    }
-    /** Infers the input type of a Standard. */
-    export type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
-    /** Infers the output type of a Standard. */
-    export type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
-    export {};
-}
-/** The Standard JSON Schema interface. */
-export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
-    /** The Standard JSON Schema properties. */
-    readonly '~standard': StandardJSONSchemaV1.Props<Input, Output>;
-}
-export declare namespace StandardJSONSchemaV1 {
-    /** The Standard JSON Schema properties interface. */
-    export interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
-        /** Methods for generating the input/output JSON Schema. */
-        readonly jsonSchema: StandardJSONSchemaV1.Converter;
-    }
-    /** The Standard JSON Schema converter interface. */
-    export interface Converter {
-        /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
-        readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
-        /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
-        readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
-    }
-    /**
-     * The target version of the generated JSON Schema.
-     *
-     * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
-     *
-     * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
-     */
-    export type Target = 'draft-2020-12' | 'draft-07' | 'openapi-3.0' | ({} & string);
-    /** The options for the input/output methods. */
-    export interface Options {
-        /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
-        readonly target: Target;
-        /** Explicit support for additional vendor-specific parameters, if needed. */
-        readonly libraryOptions?: Record<string, unknown> | undefined;
-    }
-    /** The Standard types interface. */
-    export interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
-    }
-    /** Infers the input type of a Standard. */
-    export type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
-    /** Infers the output type of a Standard. */
-    export type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
-    export {};
-}

package/build/_standard/standard-schema.mjs

@@ -1 +0,0 @@
-export {};