toolcraft-openapi 0.0.123 → 0.0.124

package/dist/composition.json

@@ -38,7 +38,12 @@
     },
     {
       "name": "toolcraft-openapi",
-      "version": "0.0.123",
+      "version": "0.0.124",
+      "license": "MIT"
+    },
+    {
+      "name": "toolcraft-schema",
+      "version": "0.0.124",
       "license": "MIT"
     },
     {

package/node_modules/toolcraft-schema/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/toolcraft-schema/README.md

@@ -0,0 +1,89 @@
+# toolcraft-schema
+
+Zero-dependency schema builder for typed command inputs, runtime validation,
+and JSON Schema generation.
+
+## Features
+
+- Zero runtime dependencies
+- Typed schema descriptors
+- `Static<typeof schema>` type inference
+- Runtime validation with `validateValue()`
+- JSON Schema serialization via `toJsonSchema()`
+- JSON Schema document serialization via `toJsonSchemaDocument()`
+
+## Usage
+
+```ts
+import { S, toJsonSchema, toJsonSchemaDocument, validateValue } from "toolcraft-schema";
+import type { Static } from "toolcraft-schema";
+
+const schema = S.Object({
+  name: S.String({ description: "User name" }),
+  retries: S.Optional(S.Number({ default: 3 })),
+  mode: S.Enum(["fast", "safe"] as const, { default: "safe" }),
+  tags: S.Array(S.String(), { default: [] })
+});
+
+type Input = Static<typeof schema>;
+// {
+//   name: string;
+//   retries?: number;
+//   mode: "fast" | "safe";
+//   tags: string[];
+// }
+
+const jsonSchema = toJsonSchema(schema);
+const document = toJsonSchemaDocument(schema, {
+  id: "https://example.test/schema.json",
+  title: "Example schema"
+});
+const validation = validateValue(schema, {
+  name: "Ada",
+  mode: "safe",
+  tags: []
+});
+```
+
+## API
+
+### Builders
+
+- `S.String({ description?, default?, short?, cliAliases? })`
+- `S.Number({ description?, default?, short?, cliAliases? })`
+- `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.Object({ [key]: schema })`
+- `S.Optional(schema)`
+
+### Type helpers
+
+- `Static<typeof schema>` infers the runtime TypeScript shape for a schema descriptor.
+- Object properties wrapped in `S.Optional(...)` become optional properties in `Static`.
+
+### JSON Schema generation
+
+- `toJsonSchema(schema)` converts any schema descriptor to standard JSON Schema.
+- `toJsonSchemaDocument(schema, options)` wraps `toJsonSchema(schema)` in a full JSON Schema document with `$schema`, optional `$id`, `title`, and `description`.
+- Object properties not wrapped in `S.Optional(...)` are emitted in `required`.
+- Defaults provided to schema builders are emitted as JSON Schema `default`.
+- Nested `S.Object(...)` schemas produce nested JSON Schema objects.
+- `S.Enum(...)` rejects empty or duplicate values at runtime for JavaScript callers.
+
+### Runtime validation
+
+- `validateValue(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.
+
+## Environment Variables
+
+This package exposes no environment variables.
+
+## Configuration
+
+This package currently exposes no package-level configuration options.

package/node_modules/toolcraft-schema/dist/index.compile-check.d.ts

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

package/node_modules/toolcraft-schema/dist/index.compile-check.js

@@ -0,0 +1,17 @@
+import { S, toJsonSchemaDocument } from "./index.js";
+const ignoredStringSchema = S.String({ description: "Name", default: "guest" });
+const ignoredNumberSchema = S.Number({ description: "Count", default: 1 });
+const ignoredBooleanSchema = S.Boolean({ description: "Enabled", default: false });
+const ignoredEnumSchema = S.Enum(["admin", "user"], { default: "admin" });
+const ignoredIntegerEnumSchema = S.Enum([1, 2], { jsonType: "integer" });
+const ignoredArraySchema = S.Array(S.String(), { default: ["a"] });
+const ignoredObjectSchema = S.Object({
+    name: S.String(),
+    retries: S.Optional(S.Number())
+});
+const ignoredOptionalSchema = S.Optional(S.Boolean());
+const ignoredJsonSchemaDocument = toJsonSchemaDocument(ignoredObjectSchema, {
+    id: "https://example.test/schema.json",
+    title: "Example schema",
+    description: "Example schema document"
+});

package/node_modules/toolcraft-schema/dist/index.d.ts

@@ -0,0 +1,184 @@
+import { Json } from "./json.js";
+import { OneOf } from "./oneof.js";
+import { Record as RecordBuilder } from "./record.js";
+import { Union } from "./union.js";
+import { validate } from "./validate.js";
+import type { JsonValue, JsonValueSchema } from "./json.js";
+import type { JsonSchemaDocument, JsonSchemaDocumentOptions } from "./json-schema-document.js";
+import type { OneOfSchema } from "./oneof.js";
+import type { RecordSchema } from "./record.js";
+import type { UnionSchema } from "./union.js";
+import type { ValidationIssue, ValidationResult } from "./validate.js";
+type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "array" | "object";
+type SchemaKind = "string" | "number" | "boolean" | "enum" | "array" | "object" | "optional" | "oneOf" | "union" | "record" | "json";
+type EnumValue = string | number | boolean;
+type JsonSchemaEnumValue = EnumValue | null;
+type NumberJsonType = "number" | "integer";
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+type ObjectShape = Record<string, AnySchema>;
+type EmptyOptions = Record<never, never>;
+type SchemaScope = "cli" | "mcp" | "sdk";
+export type CliOutputMode = "rich" | "md" | "json";
+export interface CliMissingParameterChoice<TValue> {
+    label: string;
+    value: TValue;
+}
+export interface CliMissingParameterContext {
+    commandPath: string;
+    params: Readonly<Record<string, unknown>>;
+    output: CliOutputMode;
+    stdinTTY: boolean;
+    stdoutTTY: boolean;
+}
+export interface CliMissingParameterResolution<TValue> {
+    choices: readonly CliMissingParameterChoice<TValue>[];
+    message?: string;
+}
+export interface CliSchemaOptions<TValue> {
+    resolveMissing?: (context: CliMissingParameterContext) => CliMissingParameterResolution<TValue> | undefined | Promise<CliMissingParameterResolution<TValue> | undefined>;
+}
+type StringMetadata = {
+    format?: string;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    secret?: boolean;
+};
+type NumberMetadata = {
+    maximum?: number;
+    minimum?: number;
+    secret?: boolean;
+};
+type ArrayMetadata = {
+    maxItems?: number;
+    minItems?: number;
+};
+type ObjectMetadata = {
+    additionalProperties?: boolean;
+};
+type OptionalKeys<TShape extends ObjectShape> = {
+    [TKey in keyof TShape]: TShape[TKey] extends OptionalSchema<any> ? TKey : never;
+}[keyof TShape];
+type RequiredKeys<TShape extends ObjectShape> = Exclude<keyof TShape, OptionalKeys<TShape>>;
+type PropertyStatic<TSchema extends AnySchema> = TSchema extends OptionalSchema<infer TInner> ? Static<TInner> : Static<TSchema>;
+type InferObject<TShape extends ObjectShape> = {
+    [TKey in RequiredKeys<TShape>]: PropertyStatic<TShape[TKey]>;
+} & {
+    [TKey in OptionalKeys<TShape>]?: PropertyStatic<TShape[TKey]>;
+};
+type SchemaOptions<TDefault> = {
+    cli?: CliSchemaOptions<TDefault>;
+    description?: string;
+    cliDescription?: string;
+    cliAliases?: readonly string[];
+    default?: TDefault;
+    nullable?: boolean;
+    requiredScopes?: readonly SchemaScope[];
+    short?: string;
+    scope?: readonly SchemaScope[];
+    global?: boolean;
+};
+type WithNullable<TSchema extends AnySchema, TOptions extends {
+    nullable?: boolean;
+}> = TOptions extends {
+    readonly nullable: true;
+} ? TSchema & {
+    readonly nullable: true;
+} : TSchema;
+export interface SchemaBase<TKind extends SchemaKind, TStatic> {
+    readonly kind: TKind;
+    readonly cli?: CliSchemaOptions<TStatic>;
+    readonly description?: string;
+    readonly cliDescription?: string;
+    readonly cliAliases?: readonly string[];
+    readonly default?: TStatic;
+    readonly nullable?: boolean;
+    readonly requiredScopes?: readonly SchemaScope[];
+    readonly short?: string;
+    readonly scope?: readonly SchemaScope[];
+    readonly global?: boolean;
+    readonly __static?: TStatic;
+}
+export interface JsonSchema {
+    additionalProperties?: boolean | JsonSchema;
+    type?: JsonSchemaType;
+    description?: string;
+    default?: unknown;
+    enum?: ReadonlyArray<JsonSchemaEnumValue>;
+    format?: string;
+    items?: JsonSchema;
+    maxItems?: number;
+    maximum?: number;
+    maxLength?: number;
+    minItems?: number;
+    minimum?: number;
+    minLength?: number;
+    nullable?: boolean;
+    oneOf?: JsonSchema[];
+    pattern?: string;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+}
+export interface StringSchema extends SchemaBase<"string", string>, StringMetadata {
+}
+export interface NumberSchema extends SchemaBase<"number", number>, NumberMetadata {
+    readonly jsonType?: NumberJsonType;
+}
+export type BooleanSchema = SchemaBase<"boolean", boolean>;
+export interface EnumSchema<TValues extends NonEmptyReadonlyArray<EnumValue>> extends SchemaBase<"enum", TValues[number]> {
+    readonly values: TValues;
+    readonly jsonType?: "integer";
+    readonly labels?: Partial<Record<string, string>>;
+    readonly loadOptions?: (() => Array<{
+        label: string;
+        value: string;
+    }>) | (() => Promise<Array<{
+        label: string;
+        value: string;
+    }>>);
+}
+export interface ArraySchema<TItem extends AnySchema> extends SchemaBase<"array", Array<Static<TItem>>>, ArrayMetadata {
+    readonly item: TItem;
+}
+export interface ObjectSchema<TShape extends ObjectShape> extends SchemaBase<"object", InferObject<TShape>>, ObjectMetadata {
+    readonly shape: TShape;
+}
+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 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 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>;
+    readonly Enum: <const TValues extends NonEmptyReadonlyArray<EnumValue>, const TOptions extends SchemaOptions<TValues[number]> & {
+        jsonType?: "integer";
+        labels?: Partial<Record<string, string>>;
+        loadOptions?: (() => Array<{
+            label: string;
+            value: string;
+        }>) | (() => Promise<Array<{
+            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>;
+    readonly OneOf: typeof OneOf;
+    readonly Union: typeof Union;
+    readonly Record: typeof RecordBuilder;
+    readonly Json: typeof Json;
+};
+export declare function toJsonSchema(schema: AnySchema): JsonSchema;
+export declare function toJsonSchemaDocument(schema: AnySchema, options?: JsonSchemaDocumentOptions): JsonSchemaDocument;
+export { Json, OneOf, RecordBuilder as Record, Union, validate };
+export { compileJsonSchema, formatIssues } from "./json-schema/index.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, ValidationResult };

package/node_modules/toolcraft-schema/dist/index.js

@@ -0,0 +1,295 @@
+import { Json } from "./json.js";
+import { createJsonSchemaDocument } from "./json-schema-document.js";
+import { OneOf } from "./oneof.js";
+import { Record as RecordBuilder } from "./record.js";
+import { Union } from "./union.js";
+import { validate } from "./validate.js";
+function withMetadata(schema, jsonSchema) {
+    if (schema.description !== undefined) {
+        jsonSchema.description = schema.description;
+    }
+    if (schema.default !== undefined) {
+        jsonSchema.default = schema.default;
+    }
+    if (schema.nullable === true) {
+        jsonSchema.nullable = true;
+    }
+    return jsonSchema;
+}
+function withStringMetadata(schema, jsonSchema) {
+    if (schema.minLength !== undefined) {
+        jsonSchema.minLength = schema.minLength;
+    }
+    if (schema.maxLength !== undefined) {
+        jsonSchema.maxLength = schema.maxLength;
+    }
+    if (schema.pattern !== undefined) {
+        jsonSchema.pattern = schema.pattern;
+    }
+    if (schema.format !== undefined) {
+        jsonSchema.format = schema.format;
+    }
+    return withMetadata(schema, jsonSchema);
+}
+function withNumberMetadata(schema, jsonSchema) {
+    if (schema.minimum !== undefined) {
+        jsonSchema.minimum = schema.minimum;
+    }
+    if (schema.maximum !== undefined) {
+        jsonSchema.maximum = schema.maximum;
+    }
+    return withMetadata(schema, jsonSchema);
+}
+function withArrayMetadata(schema, jsonSchema) {
+    if (schema.minItems !== undefined) {
+        jsonSchema.minItems = schema.minItems;
+    }
+    if (schema.maxItems !== undefined) {
+        jsonSchema.maxItems = schema.maxItems;
+    }
+    return withMetadata(schema, jsonSchema);
+}
+function withObjectMetadata(schema, jsonSchema) {
+    jsonSchema.additionalProperties = schema.additionalProperties ?? false;
+    return withMetadata(schema, jsonSchema);
+}
+function getEnumJsonType(values) {
+    const [firstValue] = values;
+    if (firstValue === undefined) {
+        return undefined;
+    }
+    const firstType = typeof firstValue;
+    const isSinglePrimitiveType = values.every((value) => typeof value === firstType);
+    if (!isSinglePrimitiveType) {
+        return undefined;
+    }
+    if (firstType === "string" || firstType === "number" || firstType === "boolean") {
+        return firstType;
+    }
+    return undefined;
+}
+function isOptionalSchema(schema) {
+    return schema.kind === "optional";
+}
+function assertValidEnumValues(values) {
+    if (values.length === 0) {
+        throw new Error("Enum schema requires at least one value");
+    }
+    const uniqueValues = new Set(values);
+    if (uniqueValues.size !== values.length) {
+        throw new Error("Enum schema values must be unique");
+    }
+    if (values.some((value) => typeof value === "number" && !Number.isFinite(value))) {
+        throw new Error("Enum schema numeric values must be finite");
+    }
+}
+function assertNonNegativeInteger(value, name) {
+    if (value !== undefined && (!Number.isInteger(value) || value < 0)) {
+        throw new Error(`${name} must be a non-negative integer`);
+    }
+}
+function assertFiniteNumber(value, name) {
+    if (value !== undefined && !Number.isFinite(value)) {
+        throw new Error(`${name} must be finite`);
+    }
+}
+function assertMinMaxOrder(minimum, maximum, minimumName, maximumName) {
+    if (minimum !== undefined && maximum !== undefined && minimum > maximum) {
+        throw new Error(`${minimumName} must be less than or equal to ${maximumName}`);
+    }
+}
+function assertValidDefault(schema) {
+    if (schema.default === undefined) {
+        return;
+    }
+    const result = validate(schema, schema.default);
+    if (!result.ok) {
+        throw new Error(`default must satisfy schema: ${result.issues[0]?.message ?? "invalid default"}`);
+    }
+}
+function assertPattern(pattern) {
+    if (pattern === undefined) {
+        return;
+    }
+    try {
+        new RegExp(pattern);
+    }
+    catch {
+        throw new Error("pattern must be a valid regular expression");
+    }
+}
+function unwrapOptional(schema) {
+    if (isOptionalSchema(schema)) {
+        return unwrapOptional(schema.inner);
+    }
+    return schema;
+}
+function withInjectedDiscriminator(schema, discriminator, branchName) {
+    const branchJsonSchema = toJsonSchema(schema);
+    const properties = {
+        ...(branchJsonSchema.properties ?? {}),
+        [discriminator]: {
+            type: "string",
+            enum: [branchName]
+        }
+    };
+    const required = [...new Set([...(branchJsonSchema.required ?? []), discriminator])];
+    return {
+        ...branchJsonSchema,
+        type: "object",
+        properties,
+        required
+    };
+}
+export const S = {
+    String(options = {}) {
+        assertNonNegativeInteger(options.minLength, "minLength");
+        assertNonNegativeInteger(options.maxLength, "maxLength");
+        assertMinMaxOrder(options.minLength, options.maxLength, "minLength", "maxLength");
+        assertPattern(options.pattern);
+        const schema = {
+            kind: "string",
+            ...options
+        };
+        assertValidDefault(schema);
+        return schema;
+    },
+    Number(options = {}) {
+        assertFiniteNumber(options.minimum, "minimum");
+        assertFiniteNumber(options.maximum, "maximum");
+        assertMinMaxOrder(options.minimum, options.maximum, "minimum", "maximum");
+        assertFiniteNumber(options.default, "default");
+        if (options.jsonType === "integer" &&
+            options.default !== undefined &&
+            !Number.isInteger(options.default)) {
+            throw new Error("default must be an integer");
+        }
+        const schema = {
+            kind: "number",
+            ...options
+        };
+        assertValidDefault(schema);
+        return schema;
+    },
+    Boolean(options = {}) {
+        const schema = {
+            kind: "boolean",
+            ...options
+        };
+        assertValidDefault(schema);
+        return schema;
+    },
+    Enum(values, options = {}) {
+        assertValidEnumValues(values);
+        if (options.jsonType === "integer" &&
+            values.some((value) => typeof value !== "number" || !Number.isInteger(value))) {
+            throw new Error("Integer enum values must be integers");
+        }
+        const schema = {
+            kind: "enum",
+            values,
+            ...options
+        };
+        assertValidDefault(schema);
+        return schema;
+    },
+    Array(item, options = {}) {
+        assertNonNegativeInteger(options.minItems, "minItems");
+        assertNonNegativeInteger(options.maxItems, "maxItems");
+        assertMinMaxOrder(options.minItems, options.maxItems, "minItems", "maxItems");
+        const schema = {
+            kind: "array",
+            item,
+            ...options
+        };
+        assertValidDefault(schema);
+        return schema;
+    },
+    Object(shape, options = {}) {
+        const schema = {
+            kind: "object",
+            shape,
+            ...options
+        };
+        assertValidDefault(schema);
+        return schema;
+    },
+    Optional(inner) {
+        return {
+            kind: "optional",
+            inner
+        };
+    },
+    OneOf,
+    Union,
+    Record: RecordBuilder,
+    Json
+};
+export function toJsonSchema(schema) {
+    const unwrappedSchema = unwrapOptional(schema);
+    switch (unwrappedSchema.kind) {
+        case "string":
+            return withStringMetadata(unwrappedSchema, { type: "string" });
+        case "number":
+            return withNumberMetadata(unwrappedSchema, { type: unwrappedSchema.jsonType ?? "number" });
+        case "boolean":
+            return withMetadata(unwrappedSchema, { type: "boolean" });
+        case "enum": {
+            const jsonSchema = {
+                enum: unwrappedSchema.nullable === true
+                    ? [...unwrappedSchema.values, null]
+                    : [...unwrappedSchema.values]
+            };
+            const enumType = unwrappedSchema.jsonType ?? getEnumJsonType(unwrappedSchema.values);
+            if (enumType !== undefined) {
+                jsonSchema.type = enumType;
+            }
+            return withMetadata(unwrappedSchema, jsonSchema);
+        }
+        case "array":
+            return withArrayMetadata(unwrappedSchema, {
+                type: "array",
+                items: toJsonSchema(unwrappedSchema.item)
+            });
+        case "object": {
+            const properties = {};
+            const required = [];
+            for (const [key, propertySchema] of Object.entries(unwrappedSchema.shape)) {
+                Object.defineProperty(properties, key, {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: toJsonSchema(propertySchema)
+                });
+                if (!isOptionalSchema(propertySchema)) {
+                    required.push(key);
+                }
+            }
+            return withObjectMetadata(unwrappedSchema, {
+                type: "object",
+                properties,
+                required
+            });
+        }
+        case "oneOf":
+            return withMetadata(unwrappedSchema, {
+                oneOf: Object.entries(unwrappedSchema.branches).map(([branchName, branchSchema]) => withInjectedDiscriminator(branchSchema, unwrappedSchema.discriminator, branchName))
+            });
+        case "union":
+            return withMetadata(unwrappedSchema, {
+                oneOf: unwrappedSchema.branches.map((branchSchema) => toJsonSchema(branchSchema))
+            });
+        case "record":
+            return withMetadata(unwrappedSchema, {
+                type: "object",
+                additionalProperties: toJsonSchema(unwrappedSchema.value)
+            });
+        case "json":
+            return withMetadata(unwrappedSchema, {});
+    }
+}
+export function toJsonSchemaDocument(schema, options = {}) {
+    return createJsonSchemaDocument(toJsonSchema(schema), options);
+}
+export { Json, OneOf, RecordBuilder as Record, Union, validate };
+export { compileJsonSchema, formatIssues } from "./json-schema/index.js";

package/node_modules/toolcraft-schema/dist/json-schema/compiler.d.ts

@@ -0,0 +1,11 @@
+import type { CompileJsonSchemaOptions, SchemaNode } from "./types.js";
+export interface CompiledGraph {
+    root: SchemaNode;
+    locations: Map<string, SchemaNode>;
+    resources: Map<string, SchemaNode>;
+    anchors: Map<string, SchemaNode>;
+    dynamicAnchors: Map<string, SchemaNode>;
+    resolve(node: SchemaNode, reference: string): SchemaNode;
+    dynamicAnchor(scope: SchemaNode, name: string): SchemaNode | undefined;
+}
+export declare function compileGraph(schema: unknown, options?: CompileJsonSchemaOptions): CompiledGraph;