typedriver 0.8.7 → 0.8.9

package/build/compile.d.mts

@@ -1,5 +1,5 @@
 import Type from 'typebox';
-import { type StandardSchemaV1, type StandardJSONSchemaV1 } from './_standard/standard-schema.mjs';
+import { type StandardSchemaV1, type StandardJSONSchemaV1 } from '@standard-schema/spec';
 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;

package/build/errors/error-to-issue.d.mts

@@ -1,3 +1,3 @@
-import { StandardSchemaV1 } from '../_standard/standard-schema.mjs';
-import { TLocalizedValidationError } from 'typebox/error';
-export declare function errorToIssue(error: TLocalizedValidationError): StandardSchemaV1.Issue;
+import type { TJsonSchemaError, TStandardSchemaError } from '../validator.mjs';
+/** (Internal) Transform TJsonSchemaError to TStandardSchemaError */
+export declare function errorToIssue(error: TJsonSchemaError): TStandardSchemaError;

package/build/errors/error-to-issue.mjs

@@ -8,6 +8,7 @@ function pathSegments(pointer) {
         return [];
     return pointer.slice(1).split('/').map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));
 }
+/** (Internal) Transform TJsonSchemaError to TStandardSchemaError */
 export function errorToIssue(error) {
     const path = pathSegments(error.instancePath);
     return { path, message: error.message };

package/build/errors/exceptions.mjs

@@ -1,4 +1,7 @@
 // deno-fmt-ignore-file
+// ------------------------------------------------------------------
+// ParseError
+// ------------------------------------------------------------------
 export class ParseError extends globalThis.Error {
     constructor(value, errors) {
         super('ParseError');
@@ -12,6 +15,9 @@ export class ParseError extends globalThis.Error {
         });
     }
 }
+// ------------------------------------------------------------------
+// UnknownError
+// ------------------------------------------------------------------
 export class UnknownError extends globalThis.Error {
     constructor(message) {
         super(`UnknownError: ${message}`);

package/build/errors/index.d.mts

@@ -1,3 +1,5 @@
 export * from './exceptions.mjs';
 export * from './error-to-issue.mjs';
 export * from './issue-to-error.mjs';
+export * from './normal-error.mjs';
+export * from './normal-issue.mjs';

package/build/errors/index.mjs

@@ -2,3 +2,5 @@
 export * from './exceptions.mjs';
 export * from './error-to-issue.mjs';
 export * from './issue-to-error.mjs';
+export * from './normal-error.mjs';
+export * from './normal-issue.mjs';

package/build/errors/issue-to-error.d.mts

@@ -1,3 +1,3 @@
-import { StandardSchemaV1 } from '../_standard/standard-schema.mjs';
-import { TLocalizedValidationError } from 'typebox/error';
-export declare function issueToError(issue: StandardSchemaV1.Issue): TLocalizedValidationError;
+import type { TStandardSchemaError, TJsonSchemaError } from '../validator.mjs';
+/** (Internal) Transform TStandardSchemaError to TJsonSchemaError */
+export declare function issueToError(issue: TStandardSchemaError): TJsonSchemaError;

package/build/errors/issue-to-error.mjs

@@ -1,15 +1,23 @@
 // deno-fmt-ignore-file
-import { Guard } from 'typebox/guard';
 // ------------------------------------------------------------------
-// Issues
+// Escape
 // ------------------------------------------------------------------
-function jsonPointer(segments) {
-    return `#${segments.join('/')}`;
+function escapeKey(segment) {
+    return `${segment}`.replace(/~/g, '~0').replace(/\//g, '~1');
 }
+// ------------------------------------------------------------------
+// Json Pointer
+// ------------------------------------------------------------------
+function pathToJsonPointer(path) {
+    const keys = path.map(escapeKey);
+    return `#/${keys.join('/')}`;
+}
+// ------------------------------------------------------------------
+// IssueToError
+// ------------------------------------------------------------------
+/** (Internal) Transform TStandardSchemaError to TJsonSchemaError */
 export function issueToError(issue) {
-    const instancePath = Guard.HasPropertyKey(issue, 'path') && Guard.IsArray(issue.path)
-        ? jsonPointer(issue.path)
-        : jsonPointer([]);
+    const instancePath = pathToJsonPointer(issue.path);
     return {
         instancePath,
         schemaPath: '#',

package/build/errors/normal-error.d.mts

@@ -0,0 +1,4 @@
+import type { TLocalizedValidationError } from 'typebox/error';
+import type { TJsonSchemaError } from '../validator.mjs';
+/** (Internal) Normalize a TLocalizedValidationError as TJsonSchemaError. */
+export declare function normalError(error: TLocalizedValidationError): TJsonSchemaError;

package/build/errors/normal-error.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+/** (Internal) Normalize a TLocalizedValidationError as TJsonSchemaError. */
+export function normalError(error) {
+    return error;
+}

package/build/errors/normal-issue.d.mts

@@ -0,0 +1,4 @@
+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/errors/normal-issue.mjs

@@ -0,0 +1,30 @@
+// deno-fmt-ignore-file
+import { Guard } from 'typebox/guard';
+// ------------------------------------------------------------------
+// Normal: Segments
+// ------------------------------------------------------------------
+function isSegmentObjectWithKey(segment) {
+    return Guard.IsObject(segment) && Guard.HasPropertyKey(segment, 'key') && (Guard.IsBigInt(segment.key)
+        || Guard.IsBoolean(segment.key)
+        || Guard.IsString(segment.key)
+        || Guard.IsNumber(segment.key));
+}
+function normalizeSegment(segment) {
+    return isSegmentObjectWithKey(segment) ? `${segment.key}` : `${segment}`;
+}
+function normalizeSegments(segments) {
+    return segments.map(normalizeSegment);
+}
+// ------------------------------------------------------------------
+// Resolve
+// ------------------------------------------------------------------
+function resolveSegments(issue) {
+    return (Guard.HasPropertyKey(issue, 'path') && Guard.IsArray(issue.path)
+        ? issue.path
+        : []);
+}
+/** (Internal) Normalize a StandardSchemaV1.Issue as TStandardSchemaError. */
+export function normalIssue(issue) {
+    const segments = resolveSegments(issue);
+    return ({ path: normalizeSegments(segments), message: issue.message });
+}

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,4 +1,4 @@
-import { type StandardSchemaV1 } from './_standard/standard-schema.mjs';
+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);

package/build/validator.d.mts

@@ -1,35 +1,27 @@
 import { System } from 'typebox/system';
-import { TLocalizedValidationError } from 'typebox/error';
-import { StandardSchemaV1 } from './_standard/standard-schema.mjs';
-export type TStandardSchemaError = StandardSchemaV1.Issue;
-export type TJsonSchemaError = TLocalizedValidationError;
 export type TErrorFormat = 'json-schema' | 'standard-schema';
+export interface TJsonSchemaError {
+    keyword: string;
+    schemaPath: string;
+    instancePath: string;
+    params: object;
+    message: string;
+}
+export interface TStandardSchemaError {
+    path: string[];
+    message: string;
+}
 declare const Locale: typeof System.Locale;
 export type TErrorLocale = (Exclude<keyof typeof Locale, 'Get' | 'Set' | 'Reset'> & ({} & string));
 /** Internal */
 export declare function resolveErrorOptions(options?: Partial<TErrorOptions>): TErrorOptions;
 export interface TErrorOptions {
-    /**
-     * Specifies the error message generation format.
-     *
-     * Supported values are `json-schema` and `standard-schema`.
-     *
-     * Default: `json-schema`
-     */
+    /** Specifies the error format. Default: `json-schema` */
     format: TErrorFormat;
-    /**
-     * Specifies the locale used when generating error messages.
-     *
-     * This setting applies only when used with TypeScript, JSON Schema,
-     * or implementations that follow the Standard JSON Schema specification.
-     * When the compiled type is Standard Schema only, the error message
-     * will be whatever is returned from that library.
-     *
-     * Default: `en_US`
-     */
+    /** Specifies the error format. Default: `en_US` */
     locale: TErrorLocale;
 }
-export type TErrorResult<Options extends Partial<TErrorOptions>> = (Options['format'] extends 'standard-schema' ? StandardSchemaV1.Issue[] : TLocalizedValidationError[]);
+export type TErrorResult<Options extends Partial<TErrorOptions>> = (Options['format'] extends 'standard-schema' ? TStandardSchemaError[] : TJsonSchemaError[]);
 /** Abstract Base for all Validator types. */
 export declare abstract class Validator<Input extends unknown = unknown, Output extends unknown = unknown> {
     /** Returns the schema used to construct this validator */

package/build/validators/json-schema/validator.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { System } from 'typebox/system';
 import { Validator as TBValidator } from 'typebox/compile';
-import { ParseError, errorToIssue } from '../../errors/index.mjs';
+import { ParseError, errorToIssue, normalError } from '../../errors/index.mjs';
 import { Validator, resolveErrorOptions } from '../../validator.mjs';
 export class JsonSchemaValidator extends Validator {
     constructor(input) {
@@ -46,7 +46,7 @@ export class JsonSchemaValidator extends Validator {
         System.Locale.Set(System.Locale[config.locale]);
         const errors = this.validator.Errors(value);
         return (config.format === 'standard-schema'
-            ? errors.map(error => errorToIssue(error))
-            : errors);
+            ? errors.map(error => errorToIssue(normalError(error)))
+            : errors.map(error => normalError(error)));
     }
 }

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

@@ -1,2 +1,3 @@
-import { StandardJSONSchemaV1 } from '../../_standard/standard-schema.mjs';
-export declare function ResolveJsonSchema(input: StandardJSONSchemaV1): Record<string, unknown>;
+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/resolve.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from 'typebox/guard';
-function AsOpenAPI3_0(input) {
+function OpenAPI3_0(input) {
     try {
         return input['~standard'].jsonSchema.input({ target: 'openapi-3.0' });
     }
@@ -8,7 +8,7 @@ function AsOpenAPI3_0(input) {
         return undefined;
     }
 }
-function AsDraft7(input) {
+function Draft7(input) {
     try {
         return input['~standard'].jsonSchema.input({ target: 'draft-07' });
     }
@@ -16,7 +16,7 @@ function AsDraft7(input) {
         return undefined;
     }
 }
-function AsDraft2020_12(input) {
+function Draft2020_12(input) {
     try {
         return input['~standard'].jsonSchema.input({ target: 'draft-2020-12' });
     }
@@ -24,9 +24,9 @@ function AsDraft2020_12(input) {
         return undefined;
     }
 }
-// Standard JSON Schema should provide mechanism to query supported specifications
-export function ResolveJsonSchema(input) {
-    const jsonschema = AsDraft2020_12(input) ?? AsDraft7(input) ?? AsOpenAPI3_0(input);
+/** (Internal) Resolves a JsonSchema representation (need discovery mechanism here) */
+export function resolveJsonSchema(input) {
+    const jsonschema = Draft2020_12(input) ?? Draft7(input) ?? OpenAPI3_0(input);
     if (Guard.IsUndefined(jsonschema))
         throw Error(`Vendor '${input['~standard'].vendor}' advertised itself as a Standard JSON Schema but failed to produce a schematic. Submit an issue with the vendor.`);
     return jsonschema;

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-json-schema/validator.mjs

@@ -1,14 +1,14 @@
 // deno-fmt-ignore-file
 import { System } from 'typebox/system';
 import { Validator, resolveErrorOptions } from '../../validator.mjs';
-import { ParseError, errorToIssue } from '../../errors/index.mjs';
+import { ParseError, errorToIssue, normalError } from '../../errors/index.mjs';
 import { Validator as TBValidator } from 'typebox/compile';
-import { ResolveJsonSchema } from './resolve.mjs';
+import { resolveJsonSchema } from './resolve.mjs';
 export class StandardJsonSchemaValidator extends Validator {
     constructor(input) {
         super();
         this.input = input;
-        const schema = ResolveJsonSchema(input);
+        const schema = resolveJsonSchema(input);
         this.validator = new TBValidator({}, schema);
     }
     // ----------------------------------------------------------------
@@ -48,7 +48,7 @@ export class StandardJsonSchemaValidator extends Validator {
         System.Locale.Set(System.Locale[config.locale]);
         const errors = this.validator.Errors(value);
         return (config.format === 'standard-schema'
-            ? errors.map(error => errorToIssue(error))
-            : errors);
+            ? errors.map(error => errorToIssue(normalError(error)))
+            : errors.map(error => normalError(error)));
     }
 }

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/build/validators/standard-schema/validator.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { ParseError, UnknownError, issueToError } from '../../errors/index.mjs';
+import { ParseError, UnknownError, issueToError, normalIssue } from '../../errors/index.mjs';
 import { Validator, resolveErrorOptions } from '../../validator.mjs';
 export class StandardSchemaValidator extends Validator {
     constructor(input) {
@@ -47,7 +47,7 @@ export class StandardSchemaValidator extends Validator {
         const issues = (('issues' in result) ? result.issues : []);
         const config = resolveErrorOptions(options);
         return (config.format === 'json-schema'
-            ? issues.map(issue => issueToError(issue))
-            : issues.map(issue => ({ path: issue.path, message: issue.message })));
+            ? issues.map(issue => issueToError(normalIssue(issue)))
+            : issues.map(issue => normalIssue(issue)));
     }
 }

package/build/validators/typescript/validator.d.mts

@@ -1,5 +1,5 @@
-import { Validator, type TErrorOptions, type TErrorResult } from '../../validator.mjs';
 import Type from 'typebox';
+import { Validator, type TErrorOptions, type TErrorResult } from '../../validator.mjs';
 export declare class TypeScriptValidator<Input extends string, Schema extends Type.TSchema = Type.TScript<{}, Input>, Output extends unknown = Type.Static<Schema>> extends Validator<Input, Output> {
     private readonly validator;
     private readonly script;

package/build/validators/typescript/validator.mjs

@@ -1,9 +1,9 @@
 // deno-fmt-ignore-file
+import Type from 'typebox';
 import { System } from 'typebox/system';
 import { Validator as TBValidator } from 'typebox/compile';
-import { ParseError, errorToIssue } from '../../errors/index.mjs';
+import { ParseError, errorToIssue, normalError } from '../../errors/index.mjs';
 import { Validator, resolveErrorOptions } from '../../validator.mjs';
-import Type from 'typebox';
 export class TypeScriptValidator extends Validator {
     constructor(script) {
         super();
@@ -48,7 +48,7 @@ export class TypeScriptValidator extends Validator {
         System.Locale.Set(System.Locale[config.locale]);
         const errors = this.validator.Errors(value);
         return (config.format === 'standard-schema'
-            ? errors.map(error => errorToIssue(error))
-            : errors);
+            ? errors.map(error => errorToIssue(normalError(error)))
+            : errors.map(error => normalError(error)));
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typedriver",
   "description": "High Performance Driver for Runtime Type System Integration",
-  "version": "0.8.7",
+  "version": "0.8.9",
   "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

@@ -34,8 +34,6 @@ const Vector3 = compile(`{
   z: number
 }`)
 
-declare const value: unknown
-
 const position = Vector3.parse(value)            // const position: {
                                                  //   x: number,
                                                  //   y: number,
@@ -65,7 +63,7 @@ License MIT
 - [Locales](#Locales)
 - [Static](#Static)
 - [Script](#Script)
-- [Reflect](#Schema)
+- [Reflect](#Reflect)
 - [Extensions](#Extensions)
 - [Accelerate](#Accelerate)
 - [Compression](#Compression)
@@ -425,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
@@ -442,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 {};