toolcraft-schema 0.0.430 → 0.0.432

package/README.md

@@ -7,8 +7,9 @@ and JSON Schema generation.
 
 - Zero runtime dependencies
 - Typed schema descriptors
-- `Static<typeof schema>` type inference
-- Runtime validation with `validateValue()`
+- `Static<typeof schema>` for legacy inference; `Input` and `Output` for parsed defaults
+- Standard Schema v1 validation and Standard JSON Schema v1 conversion
+- Runtime validation with `validate()`
 - JSON Schema serialization via `toJsonSchema()`
 - JSON Schema document serialization via `toJsonSchemaDocument()`
 - Native JSON Schema compilation and property projection with reference support
@@ -16,7 +17,7 @@ and JSON Schema generation.
 ## Usage
 
 ```ts
-import { S, toJsonSchema, toJsonSchemaDocument, validateValue } from "toolcraft-schema";
+import { S, toJsonSchema, toJsonSchemaDocument, validate } from "toolcraft-schema";
 import type { Static } from "toolcraft-schema";
 
 const schema = S.Object({
@@ -39,7 +40,7 @@ const document = toJsonSchemaDocument(schema, {
   id: "https://example.test/schema.json",
   title: "Example schema"
 });
-const validation = validateValue(schema, {
+const validation = validate(schema, {
   name: "Ada",
   mode: "safe",
   tags: []
@@ -55,9 +56,9 @@ const validation = validateValue(schema, {
 - `S.Boolean({ description?, default?, short?, cliAliases? })`
 - `S.Enum(values, { description?, default?, short?, cliAliases? })`
 - `S.Array(itemSchema, { description?, default?, short?, cliAliases? })`
-- `S.Record(valueSchema, { description?, default? })`
-- `S.Union([schemaA, schemaB], { description?, default? })`
-- `S.OneOf([schemaA, schemaB], { description?, default? })`
+- `S.Record(valueSchema)`
+- `S.Union([objectSchemaA, objectSchemaB])`
+- `S.OneOf({ discriminator: "kind", branches: { text: objectSchemaA, count: objectSchemaB } })`
 - `S.Object({ [key]: schema })`
 - `S.Optional(schema)`
 
@@ -65,7 +66,8 @@ const validation = validateValue(schema, {
 
 - `Static<typeof schema>` infers the runtime TypeScript shape for a schema descriptor.
 - Object properties wrapped in `S.Optional(...)` become optional properties in `Static`.
-- Schemas declared with `nullable: true` infer `null` in `Static` and emit `nullable: true` in JSON Schema.
+- Schemas declared with `nullable: true` infer `null` and emit standard JSON Schema null unions.
+- `Input<typeof schema>` describes accepted inputs. `Output<typeof schema>` makes optional properties with defaults required after parsing, including nested objects and arrays. `Static` keeps its existing optional-property behavior.
 
 ### JSON Schema generation
 
@@ -80,9 +82,9 @@ const validation = validateValue(schema, {
 
 ### Runtime validation
 
-- `validateValue(schema, value)` returns `{ ok: true, value }` for valid input.
+- `validate(schema, value)` returns `{ ok: true, value }` for valid input.
 - Invalid input returns `{ ok: false, issues }` with path-aware diagnostics.
-- Validation applies defaults from schema descriptors.
+- Validation fills missing optional properties with their inner schema defaults. Required properties remain required. Use `{ defaults: "none" }` to disable defaults, or `{ defaults: "all" }` to also fill required properties. Each parsed default is an independent copy.
 
 `compileJsonSchema(document, options)` validates complete native JSON Schema
 documents. `projectJsonSchemaProperties(document, options)` supplies stable
@@ -101,6 +103,45 @@ Use `maxNodes` for larger bounded documents, or `maxDepth` (0–256) to choose a
 depth budget. Shared objects count once for each occurrence in the JSON tree;
 options never change other calls' budgets.
 
+## Use with Standard Schema consumers
+
+Pass a builder result directly to libraries that accept Standard Schema and
+Standard JSON Schema, including tiny MCP servers. No adapter is required.
+
+```ts
+import { S } from "toolcraft-schema";
+import { createServer } from "tiny-stdio-mcp-server";
+
+const input = S.Object({
+  query: S.String(),
+  limit: S.Optional(S.Number({ default: 10 }))
+});
+
+createServer({ name: "search", version: "1" })
+  .tool("search", "Search", input, ({ query, limit }) => {
+    // query: string; limit: number (the default has been applied)
+    return `${query}: ${limit}`;
+  });
+
+const parsed = await input["~standard"].validate({ query: "hello" });
+// { value: { query: "hello", limit: 10 } } or { issues: [...] }
+const document = input["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+const outputDocument = input["~standard"].jsonSchema.output({ target: "draft-2020-12" });
+```
+
+Standard validation uses the default optional-property behavior of `validate`.
+Input conversion keeps defaulted optional properties optional; output conversion
+marks them required. Direct `toJsonSchema(schema, { io: "output" })` also exposes
+this output shape. Converters support `draft-07` and `draft-2020-12`, and reject
+unsupported targets. Native schemas attached with `withJsonSchema` remain the
+authoritative contract; projection defaults do not alter their values.
+
+The `~standard` methods are non-enumerable. JSON serialization and structured
+cloning keep the existing data descriptors. A spread or structured clone does
+not retain methods: call `withStandardSchema(copiedDescriptor)` to attach them
+when passing the copy to a standard consumer. Existing `validate` and
+`toJsonSchema` functions continue to accept these plain descriptors.
+
 ## Environment Variables
 
 This package exposes no environment variables.

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { type Standardized } from "./standard.js";
 import { Json } from "./json.js";
 import { OneOf } from "./oneof.js";
 import { Record as RecordBuilder } from "./record.js";
@@ -79,11 +80,15 @@ type SchemaOptions<TDefault> = {
 };
 type WithNullable<TSchema extends AnySchema, TOptions extends {
     nullable?: boolean;
-}> = TOptions extends {
+}> = (TOptions extends {
     readonly nullable: true;
 } ? TSchema & {
     readonly nullable: true;
-} : TSchema;
+} : TSchema) & (TOptions extends {
+    readonly default: infer Value;
+} ? undefined extends Value ? unknown : {
+    readonly default: Exclude<TSchema["default"], undefined>;
+} : unknown);
 export interface SchemaBase<TKind extends SchemaKind, TStatic> {
     readonly kind: TKind;
     readonly cli?: CliSchemaOptions<TStatic>;
@@ -149,16 +154,29 @@ export interface ObjectSchema<TShape extends ObjectShape> extends SchemaBase<"ob
 export interface OptionalSchema<TInner extends AnySchema> extends SchemaBase<"optional", Static<TInner> | undefined> {
     readonly inner: TInner;
 }
-export type AnySchema = StringSchema | NumberSchema | BooleanSchema | EnumSchema<NonEmptyReadonlyArray<EnumValue>> | ArraySchema<AnySchema> | ObjectSchema<ObjectShape> | OptionalSchema<AnySchema> | OneOfSchema<Record<string, ObjectSchema<any>>, string> | UnionSchema<readonly ObjectSchema<any>[]> | RecordSchema<AnySchema> | JsonValueSchema;
+export type AnySchema = StringSchema | NumberSchema | BooleanSchema | EnumSchema<NonEmptyReadonlyArray<EnumValue>> | (SchemaBase<"array", any> & ArrayMetadata & {
+    readonly item: AnySchema;
+}) | (SchemaBase<"object", any> & ObjectMetadata & {
+    readonly shape: ObjectShape;
+}) | (SchemaBase<"optional", any> & {
+    readonly inner: AnySchema;
+}) | (SchemaBase<"oneOf", any> & {
+    readonly discriminator: string;
+    readonly branches: Record<string, ObjectSchema<any>>;
+}) | (SchemaBase<"union", any> & {
+    readonly branches: readonly ObjectSchema<any>[];
+}) | (SchemaBase<"record", any> & {
+    readonly value: AnySchema;
+}) | JsonValueSchema;
 export type Static<TSchema extends AnySchema> = TSchema extends {
     readonly nullable: true;
 } ? TSchema extends SchemaBase<any, infer TStatic> ? TStatic | null : never : TSchema extends SchemaBase<any, infer TStatic> ? TStatic : never;
 export declare const S: {
-    readonly String: <const TOptions extends SchemaOptions<string> & StringMetadata = EmptyOptions>(options?: TOptions) => WithNullable<StringSchema, TOptions>;
+    readonly String: <const TOptions extends SchemaOptions<string> & StringMetadata = EmptyOptions>(options?: TOptions) => Standardized<WithNullable<StringSchema, TOptions>>;
     readonly Number: <const TOptions extends SchemaOptions<number> & NumberMetadata & {
         jsonType?: NumberJsonType;
-    } = EmptyOptions>(options?: TOptions) => WithNullable<NumberSchema, TOptions>;
-    readonly Boolean: <const TOptions extends SchemaOptions<boolean> = EmptyOptions>(options?: TOptions) => WithNullable<BooleanSchema, TOptions>;
+    } = EmptyOptions>(options?: TOptions) => Standardized<WithNullable<NumberSchema, TOptions>>;
+    readonly Boolean: <const TOptions extends SchemaOptions<boolean> = EmptyOptions>(options?: TOptions) => Standardized<WithNullable<BooleanSchema, TOptions>>;
     readonly Enum: <const TValues extends NonEmptyReadonlyArray<EnumValue>, const TOptions extends SchemaOptions<TValues[number]> & {
         jsonType?: "integer";
         labels?: Partial<Record<string, string>>;
@@ -169,16 +187,20 @@ export declare const S: {
             label: string;
             value: string;
         }>>);
-    } = EmptyOptions>(values: TValues, options?: TOptions) => WithNullable<EnumSchema<TValues>, TOptions>;
-    readonly Array: <TItem extends AnySchema, const TOptions extends SchemaOptions<Array<Static<TItem>>> & ArrayMetadata = EmptyOptions>(item: TItem, options?: TOptions) => WithNullable<ArraySchema<TItem>, TOptions>;
-    readonly Object: <const TShape extends ObjectShape, const TOptions extends SchemaOptions<InferObject<TShape>> & ObjectMetadata = EmptyOptions>(shape: TShape, options?: TOptions) => WithNullable<ObjectSchema<TShape>, TOptions>;
-    readonly Optional: <TInner extends AnySchema>(inner: TInner) => OptionalSchema<TInner>;
+    } = EmptyOptions>(values: TValues, options?: TOptions) => Standardized<WithNullable<EnumSchema<TValues>, TOptions>>;
+    readonly Array: <TItem extends AnySchema, const TOptions extends SchemaOptions<Array<Static<TItem>>> & ArrayMetadata = EmptyOptions>(item: TItem, options?: TOptions) => Standardized<WithNullable<ArraySchema<TItem>, TOptions>>;
+    readonly Object: <const TShape extends ObjectShape, const TOptions extends SchemaOptions<InferObject<TShape>> & ObjectMetadata = EmptyOptions>(shape: TShape, options?: TOptions) => Standardized<WithNullable<ObjectSchema<TShape>, TOptions>>;
+    readonly Optional: <TInner extends AnySchema>(inner: TInner) => Standardized<OptionalSchema<TInner>>;
     readonly OneOf: typeof OneOf;
     readonly Union: typeof Union;
     readonly Record: typeof RecordBuilder;
     readonly Json: typeof Json;
 };
-export declare function toJsonSchema(schema: AnySchema): JsonSchema;
+export interface JsonSchemaOptions {
+    io?: "input" | "output";
+    target?: "draft-07" | "draft-2020-12";
+}
+export declare function toJsonSchema(schema: AnySchema, options?: JsonSchemaOptions): JsonSchema;
 export declare function toJsonSchemaDocument(schema: AnySchema, options?: JsonSchemaDocumentOptions): JsonSchemaDocument;
 export { Json, OneOf, RecordBuilder as Record, Union, isPlainRecord, validate };
 export { isJsonValue } from "./json.js";
@@ -194,3 +216,5 @@ export type { NativeSchema } from "./native-json-schema.js";
 export type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./json-schema/index.js";
 export type { JsonSchemaDocument, JsonSchemaDocumentOptions } from "./json-schema-document.js";
 export type { JsonValue, JsonValueSchema, OneOfSchema, RecordSchema, UnionSchema, ValidationIssue, ValidationOptions, ValidationResult };
+export { withStandardSchema } from "./standard.js";
+export type { Input, Output, StandardSchema, Standardized, StandardIssue, StandardResult, StandardJsonSchemaOptions } from "./standard.js";

package/dist/index.js

@@ -1,3 +1,4 @@
+import { withStandardSchema } from "./standard.js";
 import { Json } from "./json.js";
 import { nativeJsonSchema } from "./native-json-schema.js";
 import { cloneDefaultValue } from "./clone-default.js";
@@ -133,16 +134,16 @@ function unwrapOptional(schema) {
     }
     return schema;
 }
-function toObjectBranchJsonSchema(schema) {
+function toObjectBranchJsonSchema(schema, options) {
     const objectSchema = { ...schema, nullable: false };
-    const branchJsonSchema = toJsonSchema(objectSchema);
+    const branchJsonSchema = toJsonSchema(objectSchema, options);
     if (branchJsonSchema.default === null) {
         delete branchJsonSchema.default;
     }
     return branchJsonSchema;
 }
-function withInjectedDiscriminator(schema, discriminator, branchName) {
-    const branchJsonSchema = toObjectBranchJsonSchema(schema);
+function withInjectedDiscriminator(schema, discriminator, branchName, options) {
+    const branchJsonSchema = toObjectBranchJsonSchema(schema, options);
     if (branchJsonSchema.default !== undefined) {
         branchJsonSchema.default = {
             ...branchJsonSchema.default,
@@ -175,7 +176,7 @@ export const S = {
             ...options
         };
         assertValidDefault(schema);
-        return schema;
+        return withStandardSchema(schema);
     },
     Number(options = {}) {
         assertFiniteNumber(options.minimum, "minimum");
@@ -192,7 +193,7 @@ export const S = {
             ...options
         };
         assertValidDefault(schema);
-        return schema;
+        return withStandardSchema(schema);
     },
     Boolean(options = {}) {
         const schema = {
@@ -200,7 +201,7 @@ export const S = {
             ...options
         };
         assertValidDefault(schema);
-        return schema;
+        return withStandardSchema(schema);
     },
     Enum(values, options = {}) {
         assertValidEnumValues(values);
@@ -214,7 +215,7 @@ export const S = {
             ...options
         };
         assertValidDefault(schema);
-        return schema;
+        return withStandardSchema(schema);
     },
     Array(item, options = {}) {
         assertNonNegativeInteger(options.minItems, "minItems");
@@ -226,7 +227,7 @@ export const S = {
             ...options
         };
         assertValidDefault(schema);
-        return schema;
+        return withStandardSchema(schema);
     },
     Object(shape, options = {}) {
         const schema = {
@@ -235,24 +236,32 @@ export const S = {
             ...options
         };
         assertValidDefault(schema);
-        return schema;
+        return withStandardSchema(schema);
     },
     Optional(inner) {
-        return {
+        return withStandardSchema({
             kind: "optional",
             inner
-        };
+        });
     },
     OneOf,
     Union,
     Record: RecordBuilder,
     Json
 };
-export function toJsonSchema(schema) {
+export function toJsonSchema(schema, options = {}) {
     const unwrappedSchema = unwrapOptional(schema);
     const native = unwrappedSchema[nativeJsonSchema];
-    if (native !== undefined)
+    if (native !== undefined) {
+        if (options.target !== undefined) {
+            const declared = native.document.$schema;
+            const dialect = declared === "http://json-schema.org/draft-07/schema#" || declared === "http://json-schema.org/draft-07/schema"
+                ? "draft-07" : "draft-2020-12";
+            if (options.target !== dialect)
+                throw new Error(`Native JSON Schema dialect does not match target: ${options.target}`);
+        }
         return structuredClone(native.document);
+    }
     switch (unwrappedSchema.kind) {
         case "string":
             return withStringMetadata(unwrappedSchema, { type: "string" });
@@ -275,7 +284,7 @@ export function toJsonSchema(schema) {
         case "array":
             return withArrayMetadata(unwrappedSchema, {
                 type: "array",
-                items: toJsonSchema(unwrappedSchema.item)
+                items: toJsonSchema(unwrappedSchema.item, options)
             });
         case "object": {
             const properties = {};
@@ -285,9 +294,10 @@ export function toJsonSchema(schema) {
                     enumerable: true,
                     configurable: true,
                     writable: true,
-                    value: toJsonSchema(propertySchema)
+                    value: toJsonSchema(propertySchema, options)
                 });
-                if (!isOptionalSchema(propertySchema)) {
+                if (!isOptionalSchema(propertySchema) ||
+                    (options.io === "output" && unwrapOptional(propertySchema).default !== undefined)) {
                     required.push(key);
                 }
             }
@@ -299,16 +309,25 @@ export function toJsonSchema(schema) {
         }
         case "oneOf":
             return withMetadata(unwrappedSchema, {
-                oneOf: Object.entries(unwrappedSchema.branches).map(([branchName, branchSchema]) => withInjectedDiscriminator(branchSchema, unwrappedSchema.discriminator, branchName))
+                oneOf: Object.entries(unwrappedSchema.branches).map(([branchName, branchSchema]) => withInjectedDiscriminator(branchSchema, unwrappedSchema.discriminator, branchName, options))
             });
         case "union":
+            // Parsing defaults can make previously distinct branches produce the same
+            // object. Outputs need only satisfy one branch, not exactly one branch.
+            if (options.io === "output")
+                return withMetadata(unwrappedSchema, {
+                    anyOf: [
+                        ...unwrappedSchema.branches.map((branchSchema) => toObjectBranchJsonSchema(branchSchema, options)),
+                        ...(unwrappedSchema.nullable === true ? [{ type: "null" }] : [])
+                    ]
+                });
             return withMetadata(unwrappedSchema, {
-                oneOf: unwrappedSchema.branches.map((branchSchema) => toObjectBranchJsonSchema(branchSchema))
+                oneOf: unwrappedSchema.branches.map((branchSchema) => toObjectBranchJsonSchema(branchSchema, options))
             });
         case "record":
             return withMetadata(unwrappedSchema, {
                 type: "object",
-                additionalProperties: toJsonSchema(unwrappedSchema.value)
+                additionalProperties: toJsonSchema(unwrappedSchema.value, options)
             });
         case "json": {
             const constraints = {
@@ -332,3 +351,4 @@ export { compileJsonSchema, formatIssues } from "./json-schema/index.js";
 export { projectJsonSchemaProperties } from "./json-schema/properties.js";
 export { normalizeLegacyNullability } from "./json-schema/normalize-nullability.js";
 export { withJsonSchema, nativeJsonSchema } from "./native-json-schema.js";
+export { withStandardSchema } from "./standard.js";

package/dist/json.d.ts

@@ -1,3 +1,4 @@
+import { type Standardized } from "./standard.js";
 import type { SchemaBase } from "./index.js";
 type JsonPrimitive = string | number | boolean | null;
 export type JsonValue = JsonPrimitive | {
@@ -8,7 +9,12 @@ export interface JsonValueSchema extends SchemaBase<"json", JsonValue> {
     readonly const?: JsonValue;
     readonly enum?: readonly JsonValue[];
 }
-export declare function Json(options?: Omit<JsonValueSchema, "kind">): JsonValueSchema;
+type ConfiguredJson<TOptions> = JsonValueSchema & (TOptions extends {
+    readonly default: infer Value;
+} ? undefined extends Value ? unknown : {
+    readonly default: JsonValue;
+} : unknown);
+export declare function Json<const TOptions extends Omit<JsonValueSchema, "kind"> = Record<never, never>>(options?: TOptions): Standardized<ConfiguredJson<TOptions>>;
 export interface JsonValueValidationOptions {
     readonly maxNodes?: number;
     readonly maxDepth?: number;

package/dist/json.js

@@ -1,8 +1,9 @@
+import { withStandardSchema } from "./standard.js";
 export function Json(options = {}) {
-    return {
+    return withStandardSchema({
         kind: "json",
         ...options,
-    };
+    });
 }
 export function isJsonValue(value, options = {}) {
     const maxNodes = options.maxNodes ?? 10_000;

package/dist/native-json-schema.d.ts

@@ -1,3 +1,4 @@
+import { type Standardized } from "./standard.js";
 import type { AnySchema, JsonSchema } from "./index.js";
 import type { CompiledJsonSchema } from "./json-schema/types.js";
 export declare const nativeJsonSchema: unique symbol;
@@ -7,4 +8,6 @@ export type NativeSchema = AnySchema & {
         validator: CompiledJsonSchema;
     };
 };
-export declare function withJsonSchema<T extends AnySchema>(projection: T, document: object): T;
+export declare function withJsonSchema<T extends AnySchema>(projection: T, document: object): Standardized<T & {
+    [nativeJsonSchema]: NonNullable<NativeSchema[typeof nativeJsonSchema]>;
+}>;

package/dist/native-json-schema.js

@@ -1,3 +1,4 @@
+import { withStandardSchema } from "./standard.js";
 import { isJsonValue } from "./json.js";
 import { compileJsonSchema } from "./json-schema/index.js";
 export const nativeJsonSchema = Symbol("toolcraft.nativeJsonSchema");
@@ -7,5 +8,5 @@ export function withJsonSchema(projection, document) {
     }
     const snapshot = structuredClone(document);
     const validator = compileJsonSchema(snapshot);
-    return { ...projection, [nativeJsonSchema]: { document: snapshot, validator } };
+    return withStandardSchema({ ...projection, [nativeJsonSchema]: { document: snapshot, validator } });
 }

package/dist/oneof.d.ts

@@ -1,3 +1,4 @@
+import { type Standardized } from "./standard.js";
 import type { ObjectSchema, SchemaBase, Static } from "./index.js";
 type OneOfStatic<TBranches extends Record<string, ObjectSchema<any>>, TDiscriminator extends string> = {
     [TBranchName in keyof TBranches & string]: Omit<Static<TBranches[TBranchName]>, TDiscriminator> & {
@@ -11,5 +12,5 @@ export interface OneOfSchema<TBranches extends Record<string, ObjectSchema<any>>
 export declare function OneOf<TDiscriminator extends string, TBranches extends Record<string, ObjectSchema<any>>>(config: {
     discriminator: TDiscriminator;
     branches: TBranches;
-}): OneOfSchema<TBranches, TDiscriminator>;
+}): Standardized<OneOfSchema<TBranches, TDiscriminator>>;
 export {};

package/dist/oneof.js

@@ -1,3 +1,4 @@
+import { withStandardSchema } from "./standard.js";
 function assertValidBranches(branches, discriminator) {
     if (Object.keys(branches).length === 0) {
         throw new Error("OneOf schema requires at least one branch");
@@ -10,9 +11,9 @@ function assertValidBranches(branches, discriminator) {
 }
 export function OneOf(config) {
     assertValidBranches(config.branches, config.discriminator);
-    return {
+    return withStandardSchema({
         kind: "oneOf",
         discriminator: config.discriminator,
         branches: config.branches,
-    };
+    });
 }

package/dist/record.d.ts

@@ -1,5 +1,6 @@
+import { type Standardized } from "./standard.js";
 import type { AnySchema, SchemaBase, Static } from "./index.js";
 export interface RecordSchema<TValue extends AnySchema> extends SchemaBase<"record", Record<string, Static<TValue>>> {
     readonly value: TValue;
 }
-export declare function Record<TValue extends AnySchema>(value: TValue): RecordSchema<TValue>;
+export declare function Record<TValue extends AnySchema>(value: TValue): Standardized<RecordSchema<TValue>>;

package/dist/record.js

@@ -1,6 +1,7 @@
+import { withStandardSchema } from "./standard.js";
 export function Record(value) {
-    return {
+    return withStandardSchema({
         kind: "record",
         value,
-    };
+    });
 }

package/dist/standard.compile-check.d.ts

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

package/dist/standard.compile-check.js

@@ -0,0 +1,20 @@
+import { S, withJsonSchema, withStandardSchema, toJsonSchema } from "./index.js";
+const ignoredSchema = S.Object({
+    query: S.String(),
+    limit: S.Optional(S.Number({ default: 10 })),
+    note: S.Optional(S.String()),
+    nested: S.Array(S.Object({ enabled: S.Optional(S.Boolean({ default: true })) })),
+    nullable: S.String({ nullable: true })
+});
+// @ts-expect-error A parsed default is always present.
+const ignoredMissingDefault = { query: "x", nested: [], nullable: null };
+const ignoredNullableDefault = S.Optional(S.String({ nullable: true, default: "x" }));
+const ignoredUnionSchema = S.Union([S.Object({ a: S.Optional(S.Number({ default: 1 })) }), S.Object({ b: S.String() })]);
+const ignoredTaggedSchema = S.OneOf({ discriminator: "kind", branches: { text: S.Object({ text: S.Optional(S.String({ default: "x" })) }) } });
+const ignoredNative = withJsonSchema(S.Object({ count: S.Optional(S.Number({ default: 1 })) }), { type: "object" });
+toJsonSchema(withStandardSchema(descriptor));
+const ignoredJsonDefault = S.Object({ data: S.Optional(S.Json({ default: null })) });
+const ignoredUndefinedDefaults = S.Object({
+    count: S.Optional(S.Number({ default: undefined })),
+    data: S.Optional(S.Json({ default: undefined }))
+});

package/dist/standard.d.ts

@@ -0,0 +1,92 @@
+import { type AnySchema, type Static } from "./index.js";
+import { nativeJsonSchema } from "./native-json-schema.js";
+/** Structural Standard Schema / Standard JSON Schema v1 contracts. No runtime dependency. */
+export interface StandardIssue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | {
+        readonly key: PropertyKey;
+    }>;
+}
+export type StandardResult<T> = {
+    readonly value: T;
+    readonly issues?: undefined;
+} | {
+    readonly issues: readonly StandardIssue[];
+    readonly value?: undefined;
+};
+export interface StandardSchema<Input = unknown, Output = Input> {
+    readonly "~standard": {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        };
+        readonly validate: (value: unknown, options?: {
+            readonly libraryOptions?: Record<string, unknown>;
+        }) => StandardResult<Output> | Promise<StandardResult<Output>>;
+        readonly jsonSchema: {
+            readonly input: (options: StandardJsonSchemaOptions) => Record<string, unknown>;
+            readonly output: (options: StandardJsonSchemaOptions) => Record<string, unknown>;
+        };
+    };
+}
+export interface StandardJsonSchemaOptions {
+    readonly target: string;
+    readonly libraryOptions?: Record<string, unknown>;
+}
+export type Input<T extends AnySchema> = Static<T>;
+type HasDefault<T> = AnySchema extends T ? false : T extends {
+    readonly inner: infer Inner;
+} ? HasDefault<Inner> : T extends {
+    readonly default: infer Value;
+} ? undefined extends Value ? false : true : false;
+type OptionalOutputKeys<Shape> = {
+    [K in keyof Shape]: Shape[K] extends {
+        readonly kind: "optional";
+    } ? HasDefault<Shape[K]> extends true ? never : K : never;
+}[keyof Shape];
+type ObjectOutput<Shape extends Record<string, AnySchema>> = {
+    [K in Exclude<keyof Shape, OptionalOutputKeys<Shape>>]: Output<Shape[K]>;
+} & {
+    [K in OptionalOutputKeys<Shape>]?: Output<Shape[K]>;
+};
+type OutputValue<T extends AnySchema> = T extends {
+    readonly [nativeJsonSchema]: unknown;
+} ? Static<T> : T extends {
+    readonly kind: "object";
+    readonly shape: infer Shape extends Record<string, AnySchema>;
+} ? ObjectOutput<Shape> : T extends {
+    readonly kind: "array";
+    readonly item: infer Item extends AnySchema;
+} ? Output<Item>[] : T extends {
+    readonly kind: "record";
+    readonly value: infer Value extends AnySchema;
+} ? Record<string, Output<Value>> : T extends {
+    readonly kind: "optional";
+    readonly inner: infer Inner extends AnySchema;
+} ? Output<Inner> | (HasDefault<Inner> extends true ? never : undefined) : T extends {
+    readonly kind: "union";
+    readonly branches: infer Branches extends readonly AnySchema[];
+} ? Output<Branches[number]> : T extends {
+    readonly kind: "oneOf";
+    readonly branches: infer Branches extends Record<string, AnySchema>;
+    readonly discriminator: infer Key extends string;
+} ? {
+    [Name in keyof Branches & string]: Output<Branches[Name]> & Record<Key, Name>;
+}[keyof Branches & string] : Static<T>;
+export type Output<T extends AnySchema> = 0 extends (1 & T) ? any : AnySchema extends T ? Static<T> : T extends {
+    readonly "~standard": {
+        readonly types?: {
+            readonly output: infer Value;
+        };
+    };
+} ? Value : OutputValue<T> | (T extends {
+    readonly nullable: true;
+} ? null : never);
+export type Standardized<T extends AnySchema> = T extends unknown ? (T extends StandardSchema ? Omit<T, "~standard"> : T) & StandardSchema<Input<T>, OutputValue<T> | (T extends {
+    readonly nullable: true;
+} ? null : never)> : never;
+/** Attach interoperable methods without changing the enumerable descriptor or its JSON form. */
+export declare function withStandardSchema<T extends AnySchema>(schema: T): Standardized<T>;
+export {};

package/dist/standard.js

@@ -0,0 +1,38 @@
+import { toJsonSchema } from "./index.js";
+import { validate } from "./validate.js";
+import { nativeJsonSchema } from "./native-json-schema.js";
+function standardDocument(schema, io, options) {
+    const uri = options.target === "draft-2020-12" ? "https://json-schema.org/draft/2020-12/schema"
+        : options.target === "draft-07" ? "http://json-schema.org/draft-07/schema#" : undefined;
+    if (uri === undefined)
+        throw new Error(`Unsupported JSON Schema target: ${options.target}`);
+    const document = toJsonSchema(schema, { io, target: options.target });
+    if (document.$schema !== undefined && document.$schema !== uri && document.$schema !== (uri.endsWith("#") ? uri.slice(0, -1) : uri)) {
+        throw new Error(`Native JSON Schema dialect does not match target: ${options.target}`);
+    }
+    if ((schema.kind === "oneOf" || schema.kind === "union") && schema.nullable !== true)
+        document.type = "object";
+    return { $schema: uri, ...document };
+}
+/** Attach interoperable methods without changing the enumerable descriptor or its JSON form. */
+export function withStandardSchema(schema) {
+    Object.defineProperty(schema, "~standard", {
+        configurable: true,
+        get() {
+            const descriptor = this;
+            return {
+                version: 1,
+                vendor: "toolcraft-schema",
+                validate(value) {
+                    const result = validate(descriptor, value);
+                    return result.ok ? { value: result.value } : { issues: result.issues };
+                },
+                jsonSchema: {
+                    input: (options) => standardDocument(descriptor, "input", options),
+                    output: (options) => standardDocument(descriptor, "output", options)
+                }
+            };
+        }
+    });
+    return schema;
+}

package/dist/union.d.ts

@@ -1,8 +1,9 @@
+import { type Standardized } from "./standard.js";
 import type { ObjectSchema, SchemaBase, Static } from "./index.js";
 type UnionStatic<TBranches extends readonly ObjectSchema<any>[]> = Static<TBranches[number]>;
 export interface UnionSchema<TBranches extends readonly ObjectSchema<any>[]> extends SchemaBase<"union", UnionStatic<TBranches>> {
     readonly branches: TBranches;
 }
 export declare function getRequiredKeyFingerprint(schema: ObjectSchema<any>): string;
-export declare function Union<const TBranches extends readonly ObjectSchema<any>[]>(branches: TBranches): UnionSchema<TBranches>;
+export declare function Union<const TBranches extends readonly ObjectSchema<any>[]>(branches: TBranches): Standardized<UnionSchema<TBranches>>;
 export {};

package/dist/union.js

@@ -1,3 +1,4 @@
+import { withStandardSchema } from "./standard.js";
 function isOptionalSchema(schema) {
     return schema.kind === "optional";
 }
@@ -38,8 +39,8 @@ function assertValidBranches(branches) {
 }
 export function Union(branches) {
     assertValidBranches(branches);
-    return {
+    return withStandardSchema({
         kind: "union",
         branches,
-    };
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.430",
+  "version": "0.0.432",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",