@lovrozagar/honey 0.7.3 → 1.0.0-rc.1

package/dist/schema/naming.js

@@ -0,0 +1,116 @@
+/**
+ * Component names for the schemas a document hoists: read from the operation that uses the
+ * schema (`POST /v1/projects` body → `CreateProjectRequest`), from an error envelope's status and
+ * keys (`Err400InvalidInput`), and a short content hash for telling clashing names apart.
+ */
+import { compareCodeUnits } from "./canonicalize.js";
+/** A POST leaf that names the action rather than a resource. */
+const ACTIONS = ["accept", "cancel", "confirm", "invite", "refresh", "reset", "revoke", "verify"];
+/** djb2 of `text` as 8 lowercase hex characters. */
+function hashString(text) {
+    let hash = 5381;
+    for (let i = 0; i < text.length; i++)
+        hash = (hash * 33 + text.charCodeAt(i)) | 0;
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}
+/** Six hex characters of `canonical`'s hash: the suffix that tells two clashing names apart. */
+export function shortHash(canonical) {
+    return hashString(canonical).slice(0, 6);
+}
+/** `user-profiles`, `books:archive`, `v1.json` → one PascalCase word of letters and digits. */
+function pascal(segment) {
+    return segment
+        .split(/[^A-Za-z0-9]+/)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+}
+/**
+ * A name OpenAPI takes as a `components.schemas` key that also reads as an identifier in every
+ * SDK language: letters, digits and `_`, never a leading digit.
+ */
+export function sanitizeComponentName(name) {
+    const cleaned = name.replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
+    return /^[0-9]/.test(cleaned) ? `S${cleaned}` : cleaned;
+}
+const isParam = (segment) => segment.startsWith("{") && segment.endsWith("}");
+const isAction = (segment) => segment !== undefined && ACTIONS.includes(segment.toLowerCase());
+/**
+ * The path's segments without its version prefix, and without a variant that follows a
+ * collection (`/webhooks/github`): two variants share one base name, and the hash parts them.
+ */
+function segmentsOf(path) {
+    const segments = path.replace(/^\//, "").split("/");
+    if (/^v\d+$/.test(segments[0]))
+        segments.shift();
+    const [prev, last] = segments.slice(-2);
+    const variant = prev !== undefined && last !== undefined && !isParam(prev) && !isParam(last) && !isAction(last);
+    return variant && pascal(prev).endsWith("s") ? segments.slice(0, -1) : segments;
+}
+function verbOf(method, last) {
+    if (method === "get")
+        return last !== undefined && isParam(last) ? "Get" : "List";
+    if (method === "patch")
+        return "Update";
+    if (method === "put")
+        return "Replace";
+    if (method === "delete")
+        return "Delete";
+    return isAction(last) ? pascal(last) : "Create";
+}
+/** The resource words: an action leaf dropped, the last noun singular unless listed. */
+function resourceOf(segments, verb) {
+    const words = segments.filter((segment) => !isParam(segment)).map(pascal);
+    if (isAction(segments.at(-1)))
+        return words.slice(0, -1).join("");
+    const last = words.at(-1);
+    if (verb !== "List" && last !== undefined && last.length > 2 && last.endsWith("s")) {
+        words[words.length - 1] = last.slice(0, -1);
+    }
+    return words.join("");
+}
+/** The component name of the schema at `context`: verb, resource, then the field path or the role. */
+export function deriveSchemaName(context) {
+    const segments = segmentsOf(context.path);
+    const verb = verbOf(context.method, segments.at(-1));
+    const base = `${verb}${resourceOf(segments, verb)}`;
+    const { fieldPath } = context;
+    if (fieldPath !== undefined && fieldPath.length > 0)
+        return nestedSchemaName(base, fieldPath);
+    return sanitizeComponentName(base + (context.role === "request" ? "Request" : `Response${context.status}`));
+}
+/** The name of an object nested in the component `owner` at `fieldPath`. */
+export function nestedSchemaName(owner, fieldPath) {
+    return sanitizeComponentName(owner + fieldPath.map(pascal).join(""));
+}
+/** Whether `schema` is honey's error body: `error_key`, `status`, and a `success` that can only be false. */
+export function isErrorEnvelope(schema) {
+    const properties = schema.properties;
+    if (properties?.error_key === undefined || properties.status === undefined)
+        return false;
+    const success = properties.success;
+    if (success === undefined)
+        return false;
+    const only = success.enum;
+    return success.const === false || (Array.isArray(only) && only.length === 1 && only[0] === false);
+}
+/** The one status an envelope declares: its const, else its one-value enum. */
+function declaredStatus(status) {
+    if (status.const !== undefined)
+        return status.const;
+    const only = status.enum;
+    return Array.isArray(only) && only.length === 1 ? only[0] : undefined;
+}
+/**
+ * The name of an error envelope several answers share: `Err`, its status (declared, else the
+ * answer's `fallback`, else none), then every error key, sorted.
+ */
+export function deriveErrorEnvelopeName(schema, fallback) {
+    const properties = schema.properties;
+    const declared = declaredStatus(properties.status);
+    const status = typeof declared === "number" ? declared : (fallback ?? "");
+    const keys = properties.error_key.enum;
+    const words = Array.isArray(keys)
+        ? keys.filter((key) => typeof key === "string").sort(compareCodeUnits)
+        : [];
+    return sanitizeComponentName(`Err${status}${words.map(pascal).join("")}`);
+}

package/dist/schema/sanitize-spec.d.ts

@@ -0,0 +1,15 @@
+/**
+ * What a published OpenAPI document leaves out: security requirements and schemes the public
+ * must not see, and operation extensions (`x-*`). Pure: only what changes is rebuilt.
+ */
+import type { SchemaSpec } from "./slots.ts";
+export type OpenApiSanitizeOptions = {
+    /** Drop each security requirement that names one of these schemes, on operations and the root. */
+    readonly stripSecurityRequirements?: readonly string[];
+    /** Drop these schemes from `components.securitySchemes`. */
+    readonly stripSecuritySchemes?: readonly string[];
+    /** Drop every `x-*` key of each operation, or only the ones listed. */
+    readonly stripXExtensions?: boolean | readonly string[];
+};
+/** `spec` as the public sees it under `options`; `spec` itself is never changed. */
+export declare function sanitizeOpenApiSpec(spec: SchemaSpec, options: OpenApiSanitizeOptions): SchemaSpec;

package/dist/schema/sanitize-spec.js

@@ -0,0 +1,43 @@
+/** The path-item keys that are operations. */
+const METHODS = ["delete", "get", "head", "options", "patch", "post", "put", "trace"];
+/** `holder` without the requirements naming a stripped scheme, and without `security` once none is left. */
+function withoutRequirements(holder, stripped) {
+    if (stripped.length === 0 || !Array.isArray(holder.security))
+        return holder;
+    const { security, ...rest } = holder;
+    const kept = security.filter((requirement) => stripped.every((scheme) => !Object.hasOwn(requirement, scheme)));
+    return (kept.length === 0 ? rest : { ...rest, security: kept });
+}
+function withoutExtensions(operation, strip) {
+    if (strip === false)
+        return operation;
+    const drop = (key) => (strip === true ? key.startsWith("x-") : strip.includes(key));
+    return Object.fromEntries(Object.entries(operation).filter(([key]) => !drop(key)));
+}
+function withoutSchemes(components, stripped) {
+    const schemes = components?.securitySchemes;
+    if (components === undefined || schemes === undefined || stripped.length === 0)
+        return components;
+    const { securitySchemes: _dropped, ...rest } = components;
+    const kept = Object.fromEntries(Object.entries(schemes).filter(([name]) => !stripped.includes(name)));
+    return Object.keys(kept).length === 0 ? rest : { ...rest, securitySchemes: kept };
+}
+/** `spec` as the public sees it under `options`; `spec` itself is never changed. */
+export function sanitizeOpenApiSpec(spec, options) {
+    const requirements = options.stripSecurityRequirements ?? [];
+    const extensions = options.stripXExtensions ?? false;
+    const paths = Object.fromEntries(Object.entries(spec.paths).map(([path, item]) => [
+        path,
+        Object.fromEntries(Object.entries(item).map(([key, value]) => {
+            if (!METHODS.includes(key))
+                return [key, value];
+            const operation = value;
+            return [key, withoutExtensions(withoutRequirements(operation, requirements), extensions)];
+        })),
+    ]));
+    const sanitized = { ...withoutRequirements(spec, requirements), paths };
+    const components = withoutSchemes(spec.components, options.stripSecuritySchemes ?? []);
+    if (components !== undefined)
+        sanitized.components = components;
+    return sanitized;
+}

package/dist/schema/slots.d.ts

@@ -0,0 +1,15 @@
+import type { JsonSchema } from "./to-json-schema.ts";
+/** An OpenAPI document as far as its schemas go; every other key passes through. */
+export type SchemaSpec = {
+    readonly components?: {
+        readonly schemas?: Readonly<Record<string, JsonSchema>>;
+        readonly [key: string]: unknown;
+    };
+    readonly paths: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    readonly [key: string]: unknown;
+};
+/**
+ * `spec` with every inline body schema moved to `components.schemas`, one per distinct shape,
+ * and its paths sorted. A spec with nothing inline comes back as it is, so a second pass is a no-op.
+ */
+export declare function deduplicateSchemas(spec: SchemaSpec): SchemaSpec;

package/dist/schema/slots.js

@@ -0,0 +1,179 @@
+/**
+ * Schema slots → components. Every inline request and response schema of a spec becomes one
+ * component per distinct shape, named for the operation that uses it first (shared error
+ * envelopes for their status and keys), and each slot becomes a `$ref` to it. An object nested
+ * in two or more components is hoisted to its own component as well.
+ */
+import { canonicalizeSchema, compareCodeUnits } from "./canonicalize.js";
+import { deriveErrorEnvelopeName, deriveSchemaName, isErrorEnvelope, nestedSchemaName, shortHash, } from "./naming.js";
+const REF = "#/components/schemas/";
+/** The path-item keys that are operations, in the order slots are read. */
+const METHODS = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+/** A response key as a number: `"200"` → 200, `"4XX"` → 400, `"default"` → 0. */
+function statusNumber(key) {
+    if (/^[1-5][0-9][0-9]$/.test(key))
+        return Number(key);
+    return /^[1-5]XX$/i.test(key) ? Number(key[0]) * 100 : 0;
+}
+const inline = (schema) => schema !== undefined && typeof schema.$ref !== "string";
+function* operations(spec) {
+    for (const path of Object.keys(spec.paths).sort(compareCodeUnits)) {
+        const item = spec.paths[path];
+        for (const method of METHODS) {
+            if (Object.hasOwn(item, method))
+                yield [path, method, item[method]];
+        }
+    }
+}
+function slotsOf(spec) {
+    const slots = [];
+    const add = (content, context) => {
+        for (const media of Object.values(content ?? {})) {
+            if (inline(media.schema))
+                slots.push({ canonical: canonicalizeSchema(media.schema), context, schema: media.schema });
+        }
+    };
+    for (const [path, method, operation] of operations(spec)) {
+        add(operation.requestBody?.content, { method, path, role: "request" });
+        for (const [status, response] of Object.entries(operation.responses ?? {})) {
+            add(response.content, { method, path, role: "response", status: statusNumber(status) });
+        }
+    }
+    return slots;
+}
+/**
+ * A name nothing holds yet: `base`, else `base` with the content hash, else that with a counter
+ * (two hashes can agree in 24 bits).
+ */
+function uniqueName(base, canonical, taken) {
+    if (!taken(base))
+        return base;
+    const hashed = `${base}_${shortHash(canonical)}`;
+    let name = hashed;
+    for (let n = 2; taken(name); n++)
+        name = `${hashed}_${n}`;
+    return name;
+}
+function isObjectSchema(value) {
+    /* a boolean schema (`true`, `false`) holds no object to hoist */
+    if (!(value instanceof Object))
+        return false;
+    const schema = value;
+    return typeof schema.$ref !== "string" && (schema.type === "object" || typeof schema.properties === "object");
+}
+/** Each object nested under `schema`'s properties, at any depth, with its field path. */
+function* nested(schema, fieldPath = []) {
+    const properties = (schema.properties ?? {});
+    for (const [key, child] of Object.entries(properties)) {
+        if (!isObjectSchema(child))
+            continue;
+        yield [child, [...fieldPath, key]];
+        yield* nested(child, [...fieldPath, key]);
+    }
+}
+/** `schema` with each nested object `names` holds replaced by a `$ref` to it. */
+function withRefs(schema, names) {
+    const properties = schema.properties;
+    if (properties === undefined)
+        return schema;
+    const next = Object.fromEntries(Object.entries(properties).map(([key, child]) => {
+        if (!isObjectSchema(child))
+            return [key, child];
+        const name = names.get(canonicalizeSchema(child));
+        return [key, name === undefined ? withRefs(child, names) : { $ref: REF + name }];
+    }));
+    return { ...schema, properties: next };
+}
+/** One named component per distinct slot shape, keyed by canonical text. */
+function components(slots, existing) {
+    const groups = new Map();
+    for (const slot of slots)
+        groups.set(slot.canonical, [...(groups.get(slot.canonical) ?? []), slot]);
+    const byName = new Map();
+    const out = new Map();
+    for (const [canonical, [first, ...rest]] of groups) {
+        const { context, schema } = first;
+        const envelope = isErrorEnvelope(schema);
+        const status = context.role === "response" ? context.status : undefined;
+        const base = envelope && rest.length > 0 ? deriveErrorEnvelopeName(schema, status) : deriveSchemaName(context);
+        const name = uniqueName(base, canonical, (taken) => Object.hasOwn(existing, taken) || byName.has(taken));
+        byName.set(name, canonical);
+        out.set(canonical, { envelope, name, schema });
+    }
+    return out;
+}
+/**
+ * Objects nested in two or more components, each named for its first owner and field path.
+ * One only error envelopes share is left inline: its name would hang on whichever envelope sorts
+ * first, which differs from spec to spec.
+ */
+function hoisted(named, taken) {
+    const seen = new Map();
+    for (const { envelope, name, schema } of named.values()) {
+        for (const [child, fieldPath] of nested(schema)) {
+            const canonical = canonicalizeSchema(child);
+            const entry = seen.get(canonical) ?? { outsideEnvelopes: false, owners: [], schema: child };
+            entry.owners.push(nestedSchemaName(name, fieldPath));
+            entry.outsideEnvelopes ||= !envelope;
+            seen.set(canonical, entry);
+        }
+    }
+    const out = new Map();
+    for (const [canonical, { outsideEnvelopes, owners, schema }] of seen) {
+        if (owners.length < 2 || !outsideEnvelopes)
+            continue;
+        const base = owners.toSorted(compareCodeUnits)[0];
+        out.set(canonical, [
+            uniqueName(base, canonical, (name) => taken(name) || [...out.values()].some(([held]) => held === name)),
+            schema,
+        ]);
+    }
+    return out;
+}
+/** `content` with each inline schema replaced by a `$ref` to its component. */
+function referenced(content, named) {
+    return Object.fromEntries(Object.entries(content).map(([type, media]) => {
+        if (!inline(media.schema))
+            return [type, media];
+        const { name } = named.get(canonicalizeSchema(media.schema));
+        return [type, { ...media, schema: { $ref: REF + name } }];
+    }));
+}
+function rewritten(operation, named) {
+    const { requestBody, responses } = operation;
+    const next = { ...operation };
+    if (requestBody?.content !== undefined)
+        next.requestBody = { ...requestBody, content: referenced(requestBody.content, named) };
+    if (responses !== undefined) {
+        next.responses = Object.fromEntries(Object.entries(responses).map(([status, response]) => [
+            status,
+            response.content === undefined ? response : { ...response, content: referenced(response.content, named) },
+        ]));
+    }
+    return next;
+}
+/**
+ * `spec` with every inline body schema moved to `components.schemas`, one per distinct shape,
+ * and its paths sorted. A spec with nothing inline comes back as it is, so a second pass is a no-op.
+ */
+export function deduplicateSchemas(spec) {
+    const slots = slotsOf(spec);
+    if (slots.length === 0)
+        return spec;
+    const existing = spec.components?.schemas ?? {};
+    const named = components(slots, existing);
+    const names = new Set([...named.values()].map(({ name }) => name));
+    const nestedNames = hoisted(named, (name) => Object.hasOwn(existing, name) || names.has(name));
+    const refs = new Map([...nestedNames].map(([canonical, [name]]) => [canonical, name]));
+    const schemas = { ...existing };
+    for (const { name, schema } of named.values())
+        schemas[name] = withRefs(schema, refs);
+    for (const [name, schema] of nestedNames.values())
+        schemas[name] = withRefs(schema, refs);
+    const paths = {};
+    for (const path of Object.keys(spec.paths).sort(compareCodeUnits))
+        paths[path] = { ...spec.paths[path] };
+    for (const [path, method, operation] of operations(spec))
+        paths[path][method] = rewritten(operation, named);
+    return { ...spec, components: { ...spec.components, schemas }, paths };
+}

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

@@ -0,0 +1,34 @@
+export type JsonSchema = Record<string, unknown>;
+/** Which side of a schema to describe: what it accepts, or what it hands back. */
+export type SchemaIo = "input" | "output";
+/** Effect's `JSONSchema.make`, or any function of that shape. */
+export type EffectConverter = (schema: never) => unknown;
+/** Why a schema came out wholly or partly unconstrained. */
+export type ConversionIssue = {
+    readonly io: SchemaIo;
+    readonly kind: "degraded";
+    readonly nodes: readonly string[];
+    readonly vendor: string;
+} | {
+    readonly io: SchemaIo;
+    readonly kind: "unsupported";
+    readonly vendor: string;
+} | {
+    readonly error: unknown;
+    readonly io: SchemaIo;
+    readonly kind: "failed";
+    readonly vendor: string;
+};
+export type JsonSchemaOptions = {
+    /** Converters core cannot import itself. */
+    readonly converters?: {
+        readonly effect?: EffectConverter;
+    };
+    /** Hears each schema that came out unconstrained, once. */
+    readonly report?: (issue: ConversionIssue) => void;
+};
+/**
+ * The JSON Schema of `schema` on the `io` side. A JSON Schema is handed back as given; anything
+ * that is neither a schema nor an object is `{}`.
+ */
+export declare function jsonSchemaOf(schema: unknown, io: SchemaIo, options?: JsonSchemaOptions): JsonSchema;

package/dist/schema/to-json-schema.js

@@ -0,0 +1,94 @@
+/**
+ * A schema of any validator → JSON Schema. Zod runs its own converter with a wire override;
+ * a vendor that publishes Standard JSON Schema is read through it; valibot, yup and older
+ * ArkType are walked; Effect converts through the function its caller passes. Core never
+ * imports a validator (F2), and never writes to the console: what cannot be converted is
+ * answered as `{}` and told to `report`.
+ */
+import { arktypeJsonSchema } from "./arktype.js";
+import { effectJsonSchema } from "./effect.js";
+import { valibotJsonSchema } from "./valibot.js";
+import { yupJsonSchema } from "./yup.js";
+import { zodJsonSchema } from "./zod.js";
+/* keywords whose value is a schema, or a list of schemas */
+const SCHEMA_VALUE = [
+    "allOf",
+    "anyOf",
+    "additionalProperties",
+    "contains",
+    "else",
+    "if",
+    "items",
+    "not",
+    "oneOf",
+    "prefixItems",
+    "propertyNames",
+    "then",
+    "unevaluatedItems",
+    "unevaluatedProperties",
+];
+/* keywords whose value maps names to schemas */
+const SCHEMA_MAP = ["$defs", "definitions", "dependentSchemas", "patternProperties", "properties"];
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function cleanValue(value) {
+    if (Array.isArray(value))
+        return value.map(cleanValue);
+    return isRecord(value) ? withoutDialect(value) : value;
+}
+/** `schema` without `$schema` wherever a schema sits; a payload such as `example` kept as it is. */
+function withoutDialect(schema) {
+    const out = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === "$schema")
+            continue;
+        if (SCHEMA_MAP.includes(key) && isRecord(value)) {
+            out[key] = Object.fromEntries(Object.entries(value).map(([name, child]) => [name, cleanValue(child)]));
+        }
+        else
+            out[key] = SCHEMA_VALUE.includes(key) ? cleanValue(value) : value;
+    }
+    return out;
+}
+function converted(schema, io, options, report) {
+    const standard = schema["~standard"];
+    const { vendor } = standard;
+    if (vendor === "zod")
+        return zodJsonSchema(schema, io, (nodes) => report({ io, kind: "degraded", nodes, vendor }));
+    const fromStandard = standard.jsonSchema?.[io];
+    if (typeof fromStandard === "function")
+        return fromStandard({ target: "draft-2020-12" });
+    if (vendor === "valibot")
+        return valibotJsonSchema(schema);
+    if (vendor === "arktype")
+        return arktypeJsonSchema(schema);
+    if (vendor === "yup")
+        return yupJsonSchema(schema);
+    if (vendor === "effect")
+        return effectJsonSchema(schema, options.converters?.effect);
+    return null;
+}
+/**
+ * The JSON Schema of `schema` on the `io` side. A JSON Schema is handed back as given; anything
+ * that is neither a schema nor an object is `{}`.
+ */
+export function jsonSchemaOf(schema, io, options = {}) {
+    if (schema === null || (typeof schema !== "object" && typeof schema !== "function"))
+        return {};
+    const standard = schema["~standard"];
+    if (standard === undefined)
+        return isRecord(schema) ? schema : {};
+    const report = options.report ?? (() => { });
+    const { vendor } = standard;
+    try {
+        const json = converted(schema, io, options, report);
+        if (isRecord(json))
+            return withoutDialect(json);
+        report({ io, kind: "unsupported", vendor });
+    }
+    catch (error) {
+        report({ error, io, kind: "failed", vendor });
+    }
+    return {};
+}

package/dist/schema/valibot.d.ts

@@ -0,0 +1,4 @@
+type JsonSchema = Record<string, unknown>;
+/** The JSON Schema of the valibot schema `schema`; past the depth bound, or for an unknown node, unconstrained. */
+export declare function valibotJsonSchema(schema: unknown, depth?: number): JsonSchema;
+export {};

package/dist/schema/valibot.js

@@ -0,0 +1,153 @@
+/**
+ * Valibot → JSON Schema, by walking the schema object valibot hands over: its `type`, `entries`,
+ * `wrapped`, `options` and `pipe`. valibot publishes no JSON Schema of its own, and core never
+ * imports a validator (F2), so the walk reads only what the schema carries.
+ */
+import { dict } from "../routing/tree.js";
+/* past this depth a node is unconstrained: a recursive lazy schema would not end */
+const MAX_DEPTH = 32;
+/** The node types an object key may be left out under. */
+const OPTIONAL = ["exact_optional", "nullish", "optional", "undefinedable"];
+/** Pipe actions that name a JSON Schema format. */
+const FORMATS = {
+    email: "email",
+    ipv4: "ipv4",
+    ipv6: "ipv6",
+    iso_date: "date",
+    iso_date_time: "date-time",
+    iso_timestamp: "date-time",
+    url: "uri",
+    uuid: "uuid",
+};
+/** `json` with the constraints of `node`'s pipe that JSON Schema can say. */
+function piped(node, json) {
+    const pipe = node.pipe;
+    if (!Array.isArray(pipe))
+        return json;
+    const array = json.type === "array";
+    for (const action of pipe.slice(1)) {
+        const requirement = action.requirement;
+        const format = FORMATS[action.type];
+        if (format !== undefined)
+            json.format = format;
+        else if (action.type === "integer")
+            json.type = "integer";
+        else if (action.type === "regex")
+            json.pattern = requirement.source;
+        else if (action.type === "description")
+            json.description = action.description;
+        else if (typeof requirement === "number")
+            bound(json, action.type, requirement, array);
+    }
+    return json;
+}
+/** A length or value bound onto `json`. */
+function bound(json, action, value, array) {
+    const [min, max] = array ? ["minItems", "maxItems"] : ["minLength", "maxLength"];
+    if (action === "min_length" || action === "length")
+        json[min] = value;
+    if (action === "max_length" || action === "length")
+        json[max] = value;
+    if (action === "min_value")
+        json.minimum = value;
+    if (action === "max_value")
+        json.maximum = value;
+}
+function object(node, walk) {
+    const entries = node.entries;
+    const keys = Object.keys(entries);
+    if (keys.length === 0 && node.type === "object")
+        return { type: "object" };
+    const properties = dict();
+    const required = [];
+    for (const key of keys) {
+        const entry = entries[key];
+        properties[key] = walk(entry);
+        if (!OPTIONAL.includes(entry.type))
+            required.push(key);
+    }
+    const json = { properties, type: "object" };
+    if (required.length > 0)
+        json.required = required;
+    if (node.type === "strict_object")
+        json.additionalProperties = false;
+    if (node.type === "object_with_rest")
+        json.additionalProperties = walk(node.rest);
+    return json;
+}
+function tuple(node, walk) {
+    const entries = node.items;
+    const items = entries.map(walk);
+    /* an optional tail may be left out; an optional element before a required one may not */
+    const required = entries.reduce((count, entry, at) => (OPTIONAL.includes(entry.type) ? count : at + 1), 0);
+    const json = { minItems: required, prefixItems: items, type: "array" };
+    if (node.type === "tuple_with_rest")
+        json.items = walk(node.rest);
+    else if (node.type !== "loose_tuple") {
+        json.items = false;
+        json.maxItems = items.length;
+    }
+    return json;
+}
+/** Enum values: a TS numeric enum's reverse mappings left out. */
+function enumValues(node) {
+    const values = node.enum;
+    return {
+        enum: Object.keys(values)
+            .filter((key) => typeof values[values[key]] !== "number")
+            .map((key) => values[key]),
+    };
+}
+/** The wrapped schema, its default kept when it is a value. */
+function unwrapped(node, walk) {
+    const inner = walk(node.wrapped);
+    return node.default === undefined || typeof node.default === "function" ? inner : { ...inner, default: node.default };
+}
+const nullable = (node, walk) => ({ anyOf: [walk(node.wrapped), { type: "null" }] });
+const union = (node, walk) => ({ anyOf: node.options.map(walk) });
+const binary = () => ({ contentEncoding: "binary", format: "binary", type: "string" });
+/** Each node type's JSON Schema; a type not listed (any, unknown, undefined, void…) is unconstrained. */
+const BY_TYPE = {
+    array: (node, walk) => piped(node, { items: walk(node.item), type: "array" }),
+    bigint: () => ({ format: "int64", type: "integer" }),
+    blob: binary,
+    boolean: () => ({ type: "boolean" }),
+    date: () => ({ format: "date-time", type: "string" }),
+    enum: enumValues,
+    exact_optional: unwrapped,
+    file: binary,
+    intersect: (node, walk) => ({ allOf: node.options.map(walk) }),
+    lazy: (node, walk) => walk(node.getter(undefined)),
+    literal: (node) => ({ const: node.literal }),
+    loose_object: object,
+    loose_tuple: tuple,
+    non_nullable: unwrapped,
+    non_nullish: unwrapped,
+    non_optional: unwrapped,
+    null: () => ({ type: "null" }),
+    nullable,
+    nullish: nullable,
+    number: (node) => piped(node, { type: "number" }),
+    object,
+    object_with_rest: object,
+    optional: unwrapped,
+    picklist: (node) => ({ enum: node.options }),
+    record: (node, walk) => ({ additionalProperties: walk(node.value), type: "object" }),
+    strict_object: object,
+    strict_tuple: tuple,
+    string: (node) => piped(node, { type: "string" }),
+    tuple,
+    tuple_with_rest: tuple,
+    undefinedable: unwrapped,
+    union,
+    variant: union,
+};
+/** The JSON Schema of the valibot schema `schema`; past the depth bound, or for an unknown node, unconstrained. */
+export function valibotJsonSchema(schema, depth = 0) {
+    if (depth > MAX_DEPTH || schema === null || typeof schema !== "object")
+        return {};
+    const node = schema;
+    if (!Object.hasOwn(BY_TYPE, node.type))
+        return {};
+    return BY_TYPE[node.type](node, (child) => valibotJsonSchema(child, depth + 1));
+}

package/dist/schema/yup.d.ts

@@ -0,0 +1,3 @@
+import type { JsonSchema } from "./to-json-schema.ts";
+/** The JSON Schema of the yup schema `schema`; {} for anything without `describe()`. */
+export declare function yupJsonSchema(schema: unknown): JsonSchema;