schema-components 1.20.0 → 1.22.0

package/dist/core/constraints.mjs

@@ -61,8 +61,6 @@ function extractArrayConstraints(schema) {
 	const maxItems = getNumber(schema, "maxItems");
 	if (maxItems !== void 0) c.maxItems = maxItems;
 	if (schema.uniqueItems === true) c.uniqueItems = true;
-	const contains = getObject(schema, "contains");
-	if (contains !== void 0) c.contains = contains;
 	const minContains = getNumber(schema, "minContains");
 	if (minContains !== void 0) c.minContains = minContains;
 	const maxContains = getNumber(schema, "maxContains");

package/dist/core/diagnostics.d.mts

@@ -1,2 +1,2 @@
-import { a as appendPointer, i as DiagnosticsOptions, n as DiagnosticCode, o as emitDiagnostic, r as DiagnosticSink, t as Diagnostic } from "../diagnostics-CbBPsxSt.mjs";
+import { a as appendPointer, i as DiagnosticsOptions, n as DiagnosticCode, o as emitDiagnostic, r as DiagnosticSink, t as Diagnostic } from "../diagnostics-D0QCYGv0.mjs";
 export { Diagnostic, DiagnosticCode, DiagnosticSink, DiagnosticsOptions, appendPointer, emitDiagnostic };

package/dist/core/errors.d.mts

@@ -1,2 +1,2 @@
-import { i as SchemaRenderError, n as SchemaFieldError, r as SchemaNormalisationError, t as SchemaError } from "../errors-C2iABcn9.mjs";
+import { i as SchemaRenderError, n as SchemaFieldError, r as SchemaNormalisationError, t as SchemaError } from "../errors-DpFwqs5C.mjs";
 export { SchemaError, SchemaFieldError, SchemaNormalisationError, SchemaRenderError };

package/dist/core/errors.mjs

@@ -14,12 +14,17 @@
 /**
 * Base class for all schema-components errors.
 * Catch this to handle any library error uniformly.
+*
+* Forwards the optional `cause` to the native ES2022 `Error` constructor so
+* `error.cause` is wired up by the runtime and rendered correctly by
+* `util.inspect` ("Caused by: ..."). Subclasses that need a typed `cause`
+* field still get it via the platform's own `Error.cause` getter.
 */
 var SchemaError = class extends Error {
 	/** The schema input that caused the error. */
 	schema;
-	constructor(message, schema) {
-		super(message);
+	constructor(message, schema, cause) {
+		super(message, cause !== void 0 ? { cause } : void 0);
 		this.name = "SchemaError";
 		this.schema = schema;
 	}
@@ -37,19 +42,11 @@ var SchemaNormalisationError = class extends SchemaError {
 	* (e.g. "bigint", "date", "map", "set"). `undefined` for other kinds.
 	*/
 	zodType;
-	/**
-	* The original underlying error, when this normalisation error wraps
-	* another exception (typically the error thrown by `z.toJSONSchema()`).
-	* Preserves the source stack trace so the root cause is not lost when
-	* the classifier translates the message.
-	*/
-	cause;
 	constructor(message, schema, kind, zodType, cause) {
-		super(message, schema);
+		super(message, schema, cause);
 		this.name = "SchemaNormalisationError";
 		this.kind = kind;
 		this.zodType = zodType;
-		this.cause = cause;
 	}
 };
 /**
@@ -60,13 +57,10 @@ var SchemaNormalisationError = class extends SchemaError {
 var SchemaRenderError = class extends SchemaError {
 	/** The schema type being rendered when the error occurred. */
 	schemaType;
-	/** The original error from the render function. */
-	cause;
 	constructor(message, schema, schemaType, cause) {
-		super(message, schema);
+		super(message, schema, cause);
 		this.name = "SchemaRenderError";
 		this.schemaType = schemaType;
-		this.cause = cause;
 	}
 };
 /**

package/dist/core/fieldOrder.d.mts

@@ -1,4 +1,4 @@
-import { M as WalkedField } from "../types-C9zw9wbX.mjs";
+import { j as WalkedField } from "../types-BrRMV0en.mjs";
 
 //#region src/core/fieldOrder.d.ts
 /**

package/dist/core/formats.d.mts

@@ -1,4 +1,4 @@
-import { i as DiagnosticsOptions } from "../diagnostics-CbBPsxSt.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-D0QCYGv0.mjs";
 
 //#region src/core/formats.d.ts
 /**
@@ -16,6 +16,27 @@ type FormatValidator = RegExp | ((value: string) => boolean);
 /**
  * Recognised JSON Schema formats with their validation patterns.
  * Unknown formats emit an `unknown-format` diagnostic and skip derivation.
+ *
+ * Draft origin reference — formats first standardised by each draft:
+ *
+ * - Draft 04: `date-time`, `email`, `hostname`, `ipv4`, `ipv6`, `uri`
+ * - Draft 06: `uri-reference`, `uri-template`, `json-pointer`
+ * - Draft 07: `date`, `time`, `idn-email`, `idn-hostname`, `iri`,
+ *   `iri-reference`, `regex`, `relative-json-pointer`
+ * - Draft 2019-09: `duration`, `uuid`
+ * - Vocabulary extensions / non-standard: `binary` (OpenAPI), and the
+ *   Zod-emitted formats `cuid`, `cuid2`, `nanoid`, `cidrv4`, `cidrv6`,
+ *   `base64`, `base64url`, `e164`, `emoji`, `ulid`, `xid`, `ksuid`,
+ *   `lowercase`, `uppercase`, `jwt`, `json-string`
+ *
+ * Policy: schema-components accepts ALL formats in ALL drafts. We do
+ * not reject (e.g.) `uri-reference` on a Draft 04 schema or `uuid` on
+ * a Draft 06 schema, even though the spec did not standardise those
+ * names until a later draft. This matches the behaviour of every
+ * mainstream JSON Schema validator (Ajv, jsonschema, etc.) and avoids
+ * spurious failures on legitimate real-world schemas that pre-date or
+ * post-date the dialect they declare. Authors who want strict draft-
+ * locked behaviour should validate with a dedicated meta-schema tool.
  */
 /**
  * Email format pattern, exported as a named const so callers that need a

package/dist/core/formats.mjs

@@ -11,6 +11,27 @@ const MAX_REGEX_PATTERN_LENGTH = 500;
 /**
 * Recognised JSON Schema formats with their validation patterns.
 * Unknown formats emit an `unknown-format` diagnostic and skip derivation.
+*
+* Draft origin reference — formats first standardised by each draft:
+*
+* - Draft 04: `date-time`, `email`, `hostname`, `ipv4`, `ipv6`, `uri`
+* - Draft 06: `uri-reference`, `uri-template`, `json-pointer`
+* - Draft 07: `date`, `time`, `idn-email`, `idn-hostname`, `iri`,
+*   `iri-reference`, `regex`, `relative-json-pointer`
+* - Draft 2019-09: `duration`, `uuid`
+* - Vocabulary extensions / non-standard: `binary` (OpenAPI), and the
+*   Zod-emitted formats `cuid`, `cuid2`, `nanoid`, `cidrv4`, `cidrv6`,
+*   `base64`, `base64url`, `e164`, `emoji`, `ulid`, `xid`, `ksuid`,
+*   `lowercase`, `uppercase`, `jwt`, `json-string`
+*
+* Policy: schema-components accepts ALL formats in ALL drafts. We do
+* not reject (e.g.) `uri-reference` on a Draft 04 schema or `uuid` on
+* a Draft 06 schema, even though the spec did not standardise those
+* names until a later draft. This matches the behaviour of every
+* mainstream JSON Schema validator (Ajv, jsonschema, etc.) and avoids
+* spurious failures on legitimate real-world schemas that pre-date or
+* post-date the dialect they declare. Authors who want strict draft-
+* locked behaviour should validate with a dedicated meta-schema tool.
 */
 /**
 * Email format pattern, exported as a named const so callers that need a

package/dist/core/limits.d.mts

@@ -0,0 +1,2 @@
+import { i as MaxRefDepth, n as MAX_REF_DEPTH, r as MAX_RENDER_DEPTH, t as MAX_PATH_ITEM_REF_HOPS } from "../limits-Cw5QZND8.mjs";
+export { MAX_PATH_ITEM_REF_HOPS, MAX_REF_DEPTH, MAX_RENDER_DEPTH, MaxRefDepth };

package/dist/core/limits.mjs

@@ -0,0 +1,23 @@
+//#region src/core/limits.ts
+/**
+* Shared depth caps and hop counts used to bound recursion across
+* schema-components. All numeric limits live here so the renderer, the
+* ref resolver, the OpenAPI parser, and the type-level inference engine
+* agree on the same constants.
+*/
+/**
+* Maximum recursion depth for the schema walker, the React renderers,
+* the streaming HTML renderer, and the server-side renderer. Beyond
+* this depth a recursion sentinel is emitted instead of further descent
+* — the only safe response to a cyclic walked-field graph.
+*/
+const MAX_RENDER_DEPTH = 10;
+const MAX_REF_DEPTH = 64;
+/**
+* Maximum number of `$ref` hops permitted when walking a chain of
+* OpenAPI Path Item Object references. Beyond this a
+* `path-item-ref-too-deep` diagnostic is emitted and resolution stops.
+*/
+const MAX_PATH_ITEM_REF_HOPS = 8;
+//#endregion
+export { MAX_PATH_ITEM_REF_HOPS, MAX_REF_DEPTH, MAX_RENDER_DEPTH };

package/dist/core/merge.d.mts

@@ -1,4 +1,4 @@
-import { i as DiagnosticsOptions } from "../diagnostics-CbBPsxSt.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-D0QCYGv0.mjs";
 
 //#region src/core/merge.d.ts
 /**
@@ -25,8 +25,17 @@ declare function mergeRefSiblings(referencer: Record<string, unknown>, resolvedM
  * When a later branch redefines a keyword with a non-equal value the
  * later value is silently dropped — an `allof-conflict` diagnostic is
  * emitted so the loss is visible to consumers.
+ *
+ * Boolean branches (valid per Draft 06+) collapse the composite:
+ * - `false` makes the entire \`allOf\` unsatisfiable — return \`false\`,
+ *   which the walker turns into a \`NeverField\`.
+ * - \`true\` is the always-valid schema and contributes no constraints —
+ *   skip silently.
+ *
+ * Non-boolean, non-object entries (e.g. arrays, numbers) are malformed
+ * inputs that cannot represent a schema; skip them as before.
  */
-declare function mergeAllOf(schemas: unknown[], diagnostics?: DiagnosticsOptions, pointer?: string): Record<string, unknown>;
+declare function mergeAllOf(schemas: unknown[], diagnostics?: DiagnosticsOptions, pointer?: string): Record<string, unknown> | false;
 interface NormalisedAnyOf {
   inner: Record<string, unknown>;
   isNullable: boolean;

package/dist/core/merge.mjs

@@ -109,12 +109,23 @@ function mergeRefSiblings(referencer, resolvedMeta) {
 * When a later branch redefines a keyword with a non-equal value the
 * later value is silently dropped — an `allof-conflict` diagnostic is
 * emitted so the loss is visible to consumers.
+*
+* Boolean branches (valid per Draft 06+) collapse the composite:
+* - `false` makes the entire \`allOf\` unsatisfiable — return \`false\`,
+*   which the walker turns into a \`NeverField\`.
+* - \`true\` is the always-valid schema and contributes no constraints —
+*   skip silently.
+*
+* Non-boolean, non-object entries (e.g. arrays, numbers) are malformed
+* inputs that cannot represent a schema; skip them as before.
 */
 function mergeAllOf(schemas, diagnostics, pointer = "") {
 	const merged = {};
 	const properties = {};
 	const required = [];
 	for (const entry of schemas) {
+		if (entry === false) return false;
+		if (entry === true) continue;
 		if (!isObject(entry)) continue;
 		const props = getObject(entry, "properties");
 		if (props !== void 0) for (const [key, value] of Object.entries(props)) properties[key] = value;

package/dist/core/normalise.d.mts

@@ -1,23 +1,47 @@
-import { i as DiagnosticsOptions } from "../diagnostics-CbBPsxSt.mjs";
-import { i as OpenApiVersionInfo, r as JsonSchemaDraft } from "../version-D-u7aMfy.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-D0QCYGv0.mjs";
+import { i as OpenApiVersionInfo, r as JsonSchemaDraft } from "../version-D2jfdX6E.mjs";
 
 //#region src/core/normalise.d.ts
 type NodeTransform = (node: Record<string, unknown>) => Record<string, unknown>;
 /**
  * Deep-normalise a JSON Schema object by applying a per-node transform
  * and recursing into every sub-schema location.
+ *
+ * The optional `visited` set guards against shared object references and
+ * cycles introduced upstream (e.g. by the OpenAPI bundler's
+ * `structuredClone`-based inlining of external refs). The walk skips
+ * already-seen nodes by returning the original reference rather than
+ * recursing forever.
  */
-declare function deepNormalise(schema: Record<string, unknown>, transform: NodeTransform): Record<string, unknown>;
+declare function deepNormalise(schema: Record<string, unknown>, transform: NodeTransform, visited?: WeakSet<object>): Record<string, unknown>;
 /**
  * Per-node context threaded through `deepNormaliseWithContext`.
  *
  * Carries the diagnostics sink and the JSON Pointer to the current
  * node so per-node transforms can emit pointer-accurate diagnostics
  * when they translate or reject legacy constructs.
+ *
+ * `documentHasDynamicAnchor` is set once at the entry point by scanning
+ * the input for any `$dynamicAnchor`/`$recursiveAnchor` keyword. Per-
+ * node transforms read it to decide whether a `$dynamicRef`/`$recursiveRef`
+ * rewrite needs a `dynamic-ref-degraded` diagnostic — a ref pointing at
+ * an anchor in the document body cannot be statically resolved without
+ * losing dynamic-scope semantics, while a document with no dynamic
+ * anchors at all has no semantics to lose.
+ *
+ * `documentHasRecursiveAnchor` is the same idea for Draft 2019-09's
+ * `$recursiveAnchor` keyword.
+ *
+ * `declaredDraft` carries the draft the normaliser is operating under
+ * (when known) so per-node transforms can emit `keyword-out-of-draft`
+ * diagnostics for keywords introduced in a later draft.
  */
 interface NodeContext {
   diagnostics: DiagnosticsOptions | undefined;
   pointer: string;
+  documentHasDynamicAnchor: boolean;
+  documentHasRecursiveAnchor: boolean;
+  declaredDraft: JsonSchemaDraft | undefined;
 }
 type NodeTransformWithContext = (node: Record<string, unknown>, ctx: NodeContext) => Record<string, unknown>;
 /**
@@ -52,6 +76,14 @@ declare function deepNormaliseWithContext(schema: Record<string, unknown>, trans
  * {@link deepNormaliseWithContext} to thread diagnostics.
  */
 declare function normaliseDraft04Node(node: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Pick the per-node transform that normalises a single Schema Object to
+ * canonical Draft 2020-12 form for the supplied draft. Exposed so the
+ * OpenAPI 3.1 path can honour a non-default `jsonSchemaDialect`
+ * declaration by routing each Schema Object through the matching
+ * transform without re-implementing the dispatch.
+ */
+declare function selectDraftTransform(draft: JsonSchemaDraft): NodeTransformWithContext;
 /**
  * Normalise a JSON Schema to canonical Draft 2020-12 form.
  * Deep-clones the input — the original is never mutated.
@@ -71,4 +103,4 @@ declare function normaliseJsonSchema(schema: Record<string, unknown>, draft: Jso
  */
 declare function normaliseOpenApiSchemas(doc: Record<string, unknown>, version: OpenApiVersionInfo, diagnostics?: DiagnosticsOptions): Record<string, unknown>;
 //#endregion
-export { NodeContext, NodeTransform, NodeTransformWithContext, deepNormalise, deepNormaliseWithContext, normaliseDraft04Node, normaliseJsonSchema, normaliseOpenApiSchemas };
+export { NodeContext, NodeTransform, NodeTransformWithContext, deepNormalise, deepNormaliseWithContext, normaliseDraft04Node, normaliseJsonSchema, normaliseOpenApiSchemas, selectDraftTransform };

package/dist/core/normalise.mjs

@@ -1,2 +1,2 @@
-import { a as normaliseOpenApiSchemas, i as normaliseJsonSchema, n as deepNormaliseWithContext, r as normaliseDraft04Node, t as deepNormalise } from "../normalise-CMMEl4cd.mjs";
-export { deepNormalise, deepNormaliseWithContext, normaliseDraft04Node, normaliseJsonSchema, normaliseOpenApiSchemas };
+import { a as normaliseOpenApiSchemas, i as normaliseJsonSchema, n as deepNormaliseWithContext, o as selectDraftTransform, r as normaliseDraft04Node, t as deepNormalise } from "../normalise-DVEJQmF7.mjs";
+export { deepNormalise, deepNormaliseWithContext, normaliseDraft04Node, normaliseJsonSchema, normaliseOpenApiSchemas, selectDraftTransform };

package/dist/core/openapi30.d.mts

@@ -23,6 +23,29 @@ declare function normaliseOpenApi30Node(node: Record<string, unknown>): Record<s
  * `mapping` or infers them from `$ref` fragment names.
  */
 declare function normaliseOpenApi30Discriminator(node: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Document-level pre-pass for OpenAPI discriminators that are declared
+ * on a base schema and inherited by subtypes via `allOf`.
+ *
+ * The per-node {@link normaliseOpenApi30Discriminator} only handles
+ * discriminators that already sit alongside `oneOf`/`anyOf`. For the
+ * canonical "Cat extends Pet" pattern — where `Pet` carries the
+ * discriminator and `Cat`/`Dog` reference `Pet` via `allOf` — the
+ * discriminator is silently lost. This pre-pass:
+ *
+ * 1. Injects the discriminator `const` on each subtype's local
+ *    `properties` (so a direct render of the subtype validates the
+ *    discriminator value correctly).
+ * 2. Synthesises a `oneOf` on the base whenever it lacks one, listing
+ *    each subtype as `{ $ref, properties: { propertyName: { const } } }`.
+ *    The per-node discriminator transform then sees `oneOf` and clears
+ *    the `discriminator` keyword, and the walker's
+ *    `detectDiscriminated` finds the per-option `const`s.
+ *
+ * Mutates a shallow clone of `components/schemas` — the input document
+ * is never modified.
+ */
+declare function applyDiscriminatorAllOfPrepass(doc: Record<string, unknown>): Record<string, unknown>;
 /**
  * Combined OpenAPI 3.0.x node transform: Draft 04 + nullable + discriminator.
  * Applied to every schema node in an OpenAPI 3.0 document.
@@ -67,4 +90,4 @@ declare function deepNormaliseOpenApiDoc(doc: Record<string, unknown>, normalise
  */
 declare function deepNormaliseOpenApi30Doc(doc: Record<string, unknown>, deepNormalise: (schema: Record<string, unknown>, transform: NodeTransform) => Record<string, unknown>): Record<string, unknown>;
 //#endregion
-export { deepNormaliseOpenApi30Doc, deepNormaliseOpenApiDoc, normaliseOpenApi30Combined, normaliseOpenApi30Discriminator, normaliseOpenApi30Node };
+export { applyDiscriminatorAllOfPrepass, deepNormaliseOpenApi30Doc, deepNormaliseOpenApiDoc, normaliseOpenApi30Combined, normaliseOpenApi30Discriminator, normaliseOpenApi30Node };

package/dist/core/openapi30.mjs

@@ -1,2 +1,2 @@
-import { c as deepNormaliseOpenApiDoc, d as normaliseOpenApi30Node, l as normaliseOpenApi30Combined, s as deepNormaliseOpenApi30Doc, u as normaliseOpenApi30Discriminator } from "../normalise-CMMEl4cd.mjs";
-export { deepNormaliseOpenApi30Doc, deepNormaliseOpenApiDoc, normaliseOpenApi30Combined, normaliseOpenApi30Discriminator, normaliseOpenApi30Node };
+import { c as applyDiscriminatorAllOfPrepass, d as normaliseOpenApi30Combined, f as normaliseOpenApi30Discriminator, l as deepNormaliseOpenApi30Doc, p as normaliseOpenApi30Node, u as deepNormaliseOpenApiDoc } from "../normalise-DVEJQmF7.mjs";
+export { applyDiscriminatorAllOfPrepass, deepNormaliseOpenApi30Doc, deepNormaliseOpenApiDoc, normaliseOpenApi30Combined, normaliseOpenApi30Discriminator, normaliseOpenApi30Node };

package/dist/core/ref.d.mts

@@ -1,2 +1,2 @@
-import { a as findAnchor, i as dereference, n as RefOptions, o as resolveRef, r as countDistinctRefs, t as ExternalResolver } from "../ref-C8JbwfiS.mjs";
+import { a as findAnchor, i as dereference, n as RefOptions, o as resolveRef, r as countDistinctRefs, t as ExternalResolver } from "../ref-D-_JBZkF.mjs";
 export { ExternalResolver, RefOptions, countDistinctRefs, dereference, findAnchor, resolveRef };

package/dist/core/ref.mjs

@@ -1,5 +1,7 @@
 import { isObject } from "./guards.mjs";
+import "./limits.mjs";
 import { emitDiagnostic } from "./diagnostics.mjs";
+import { isPrototypePollutingKey } from "./uri.mjs";
 //#region src/core/ref.ts
 /**
 * $ref resolution for JSON Schema.
@@ -18,15 +20,27 @@ function getString(obj, key) {
 */
 function countDistinctRefs(root) {
 	const refs = /* @__PURE__ */ new Set();
-	collectRefs(root, refs);
+	collectRefs(root, refs, /* @__PURE__ */ new WeakSet());
 	return Math.max(refs.size, 1);
 }
-function collectRefs(node, refs) {
+/**
+* The OpenAPI bundler (`bundleOpenApiDoc`) inlines external refs via
+* `structuredClone`, which preserves shared object references and cycles.
+* Without the `visited` set this walk would recurse forever on cyclic or
+* diamond-shaped input. The set is a no-op for tree-shaped documents.
+*/
+function collectRefs(node, refs, visited) {
 	if (!isObject(node)) return;
+	if (visited.has(node)) return;
+	visited.add(node);
 	const ref = node.$ref;
 	if (typeof ref === "string") refs.add(ref);
-	for (const value of Object.values(node)) if (isObject(value)) collectRefs(value, refs);
-	else if (Array.isArray(value)) for (const item of value) collectRefs(item, refs);
+	for (const value of Object.values(node)) if (isObject(value)) collectRefs(value, refs, visited);
+	else if (Array.isArray(value)) {
+		if (visited.has(value)) continue;
+		visited.add(value);
+		for (const item of value) collectRefs(item, refs, visited);
+	}
 }
 /**
 * Resolve a `$ref` in a schema against a root document.
@@ -134,6 +148,7 @@ function dereference(ref, root) {
 		for (const part of parts) {
 			if (!isObject(current)) return void 0;
 			const decoded = part.replace(/~1/g, "/").replace(/~0/g, "~");
+			if (isPrototypePollutingKey(decoded)) return void 0;
 			current = current[decoded];
 		}
 		return isObject(current) ? current : void 0;
@@ -146,18 +161,29 @@ function dereference(ref, root) {
 /**
 * Recursively scan a schema document for a `$anchor` matching the given name.
 * Returns the schema object containing the anchor, or undefined.
+*
+* The optional `visited` set guards against shared object references and
+* cycles introduced by the OpenAPI bundler's `structuredClone`-based
+* inlining of external refs. Without it a recursive document would stack
+* overflow before reaching the matching anchor.
 */
-function findAnchor(node, anchorName) {
+function findAnchor(node, anchorName, visited = /* @__PURE__ */ new WeakSet()) {
 	if (!isObject(node)) return void 0;
+	if (visited.has(node)) return void 0;
+	visited.add(node);
 	if (node.$anchor === anchorName) return node;
 	for (const value of Object.values(node)) {
 		if (isObject(value)) {
-			const found = findAnchor(value, anchorName);
+			const found = findAnchor(value, anchorName, visited);
 			if (found !== void 0) return found;
 		}
-		if (Array.isArray(value)) for (const item of value) {
-			const found = findAnchor(item, anchorName);
-			if (found !== void 0) return found;
+		if (Array.isArray(value)) {
+			if (visited.has(value)) continue;
+			visited.add(value);
+			for (const item of value) {
+				const found = findAnchor(item, anchorName, visited);
+				if (found !== void 0) return found;
+			}
 		}
 	}
 }

package/dist/core/renderer.d.mts

@@ -1,2 +1,2 @@
-import { a as HtmlRenderProps, c as RenderFunction, d as getHtmlRenderFn, f as getRenderFunction, h as typeToKey, i as HtmlRenderFunction, l as RenderProps, m as mergeResolvers, n as BaseFieldProps, o as HtmlResolver, p as mergeHtmlResolvers, r as ComponentResolver, s as RESOLVER_KEYS, t as AllConstraints, u as buildRenderProps } from "../renderer-SOIbJBtk.mjs";
+import { a as HtmlRenderProps, c as RenderFunction, d as getHtmlRenderFn, f as getRenderFunction, h as typeToKey, i as HtmlRenderFunction, l as RenderProps, m as mergeResolvers, n as BaseFieldProps, o as HtmlResolver, p as mergeHtmlResolvers, r as ComponentResolver, s as RESOLVER_KEYS, t as AllConstraints, u as buildRenderProps } from "../renderer-BaRlQIuN.mjs";
 export { AllConstraints, BaseFieldProps, ComponentResolver, HtmlRenderFunction, HtmlRenderProps, HtmlResolver, RESOLVER_KEYS, RenderFunction, RenderProps, buildRenderProps, getHtmlRenderFn, getRenderFunction, mergeHtmlResolvers, mergeResolvers, typeToKey };

package/dist/core/renderer.mjs

@@ -43,7 +43,6 @@ const RESOLVER_KEYS = [
 	"discriminatedUnion",
 	"conditional",
 	"negation",
-	"recursive",
 	"literal",
 	"file",
 	"never",
@@ -70,7 +69,6 @@ function typeToKey(type) {
 		case "discriminatedUnion":
 		case "conditional":
 		case "negation":
-		case "recursive":
 		case "literal":
 		case "file":
 		case "never":

package/dist/core/swagger2.d.mts

@@ -1,4 +1,4 @@
-import { i as DiagnosticsOptions } from "../diagnostics-CbBPsxSt.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-D0QCYGv0.mjs";
 import { NodeTransform } from "./normalise.mjs";
 
 //#region src/core/swagger2.d.ts

package/dist/core/swagger2.mjs

@@ -1,2 +1,2 @@
-import { o as normaliseSwagger2Document } from "../normalise-CMMEl4cd.mjs";
+import { s as normaliseSwagger2Document } from "../normalise-DVEJQmF7.mjs";
 export { normaliseSwagger2Document };

package/dist/core/typeInference.d.mts

@@ -1,2 +1,2 @@
-import { a as InferResponseFields, c as PathOfType, d as TypeAtPath, f as UnrepresentableZodSchemaError, h as __SchemaInferenceFellBack, i as InferRequestBodyFields, l as RejectUnrepresentableZod, m as UnsafeFields, n as FromJSONSchema, o as OpenAPIRequestBodyType, p as UnrepresentableZodType, r as InferParameterOverrides, s as OpenAPIResponseType, t as DEFAULT_MAX_DEPTH, u as ResolveOpenAPIRef } from "../typeInference-CDoD_LZ_.mjs";
-export { DEFAULT_MAX_DEPTH, FromJSONSchema, InferParameterOverrides, InferRequestBodyFields, InferResponseFields, OpenAPIRequestBodyType, OpenAPIResponseType, PathOfType, RejectUnrepresentableZod, ResolveOpenAPIRef, TypeAtPath, UnrepresentableZodSchemaError, UnrepresentableZodType, UnsafeFields, __SchemaInferenceFellBack };
+import { _ as __SchemaInferenceFellBack, a as InferParameterOverrides, c as OpenAPIRequestBodyType, d as RejectUnrepresentableZod, f as ResolveOpenAPIRef, g as UnsafeFields, h as UnrepresentableZodType, i as FromJSONSchemaMode, l as OpenAPIResponseType, m as UnrepresentableZodSchemaError, n as DEFAULT_OPENAPI_CONTENT_TYPE, o as InferRequestBodyFields, p as TypeAtPath, r as FromJSONSchema, s as InferResponseFields, t as DEFAULT_MAX_DEPTH, u as PathOfType } from "../typeInference-DkcUHfaM.mjs";
+export { DEFAULT_MAX_DEPTH, DEFAULT_OPENAPI_CONTENT_TYPE, FromJSONSchema, FromJSONSchemaMode, InferParameterOverrides, InferRequestBodyFields, InferResponseFields, OpenAPIRequestBodyType, OpenAPIResponseType, PathOfType, RejectUnrepresentableZod, ResolveOpenAPIRef, TypeAtPath, UnrepresentableZodSchemaError, UnrepresentableZodType, UnsafeFields, __SchemaInferenceFellBack };

package/dist/core/types.d.mts

@@ -1,2 +1,2 @@
-import { A as UnionField, B as isNegationField, C as RecordField, D as StringConstraints, E as SchemaType, F as isConditionalField, G as isRecordField, H as isNullField, I as isDiscriminatedUnionField, J as isTupleField, K as isRecursiveField, L as isEnumField, M as WalkedField, N as isArrayField, O as StringField, P as isBooleanField, R as isFileField, S as ObjectField, T as SchemaMeta, U as isNumberField, V as isNeverField, W as isObjectField, X as isUnknownField, Y as isUnionField, Z as resolveEditability, _ as NeverField, a as DiscriminatedUnionField, b as NumberField, c as FieldBase, d as FieldOverrides, f as FileConstraints, g as NegationField, h as LiteralField, i as ConditionalField, j as UnknownField, k as TupleField, l as FieldConstraints, m as JsonObject, n as ArrayField, o as Editability, p as FileField, q as isStringField, r as BooleanField, s as EnumField, t as ArrayConstraints, u as FieldOverride, v as NullField, w as RecursiveField, x as ObjectConstraints, y as NumberConstraints, z as isLiteralField } from "../types-C9zw9wbX.mjs";
-export { ArrayConstraints, ArrayField, BooleanField, ConditionalField, DiscriminatedUnionField, Editability, EnumField, FieldBase, FieldConstraints, FieldOverride, FieldOverrides, FileConstraints, FileField, JsonObject, LiteralField, NegationField, NeverField, NullField, NumberConstraints, NumberField, ObjectConstraints, ObjectField, RecordField, RecursiveField, SchemaMeta, SchemaType, StringConstraints, StringField, TupleField, UnionField, UnknownField, WalkedField, isArrayField, isBooleanField, isConditionalField, isDiscriminatedUnionField, isEnumField, isFileField, isLiteralField, isNegationField, isNeverField, isNullField, isNumberField, isObjectField, isRecordField, isRecursiveField, isStringField, isTupleField, isUnionField, isUnknownField, resolveEditability };
+import { A as UnknownField, B as isNeverField, C as RecordField, D as StringField, E as StringConstraints, F as isDiscriminatedUnionField, G as isStringField, H as isNumberField, I as isEnumField, J as isUnknownField, K as isTupleField, L as isFileField, M as isArrayField, N as isBooleanField, O as TupleField, P as isConditionalField, R as isLiteralField, S as ObjectField, T as SchemaType, U as isObjectField, V as isNullField, W as isRecordField, Y as resolveEditability, _ as NeverField, a as DiscriminatedUnionField, b as NumberField, c as FieldBase, d as FieldOverrides, f as FileConstraints, g as NegationField, h as LiteralField, i as ConditionalField, j as WalkedField, k as UnionField, l as FieldConstraints, m as JsonObject, n as ArrayField, o as Editability, p as FileField, q as isUnionField, r as BooleanField, s as EnumField, t as ArrayConstraints, u as FieldOverride, v as NullField, w as SchemaMeta, x as ObjectConstraints, y as NumberConstraints, z as isNegationField } from "../types-BrRMV0en.mjs";
+export { ArrayConstraints, ArrayField, BooleanField, ConditionalField, DiscriminatedUnionField, Editability, EnumField, FieldBase, FieldConstraints, FieldOverride, FieldOverrides, FileConstraints, FileField, JsonObject, LiteralField, NegationField, NeverField, NullField, NumberConstraints, NumberField, ObjectConstraints, ObjectField, RecordField, SchemaMeta, SchemaType, StringConstraints, StringField, TupleField, UnionField, UnknownField, WalkedField, isArrayField, isBooleanField, isConditionalField, isDiscriminatedUnionField, isEnumField, isFileField, isLiteralField, isNegationField, isNeverField, isNullField, isNumberField, isObjectField, isRecordField, isStringField, isTupleField, isUnionField, isUnknownField, resolveEditability };

package/dist/core/types.mjs

@@ -83,9 +83,6 @@ function isNegationField(field) {
 function isFileField(field) {
 	return isField(field, "file");
 }
-function isRecursiveField(field) {
-	return isField(field, "recursive");
-}
 function isNeverField(field) {
 	return isField(field, "never");
 }
@@ -93,4 +90,4 @@ function isUnknownField(field) {
 	return isField(field, "unknown");
 }
 //#endregion
-export { isArrayField, isBooleanField, isConditionalField, isDiscriminatedUnionField, isEnumField, isFileField, isLiteralField, isNegationField, isNeverField, isNullField, isNumberField, isObjectField, isRecordField, isRecursiveField, isStringField, isTupleField, isUnionField, isUnknownField, resolveEditability };
+export { isArrayField, isBooleanField, isConditionalField, isDiscriminatedUnionField, isEnumField, isFileField, isLiteralField, isNegationField, isNeverField, isNullField, isNumberField, isObjectField, isRecordField, isStringField, isTupleField, isUnionField, isUnknownField, resolveEditability };

package/dist/core/version.d.mts

@@ -1,2 +1,2 @@
-import { a as detectJsonSchemaDraft, c as inferJsonSchemaDraftWithReason, d as isSwagger2, f as matchJsonSchemaDraftUri, i as OpenApiVersionInfo, l as isOpenApi30, n as JsonSchemaDialectInfo, o as detectOpenApiVersion, p as readJsonSchemaDialect, r as JsonSchemaDraft, s as inferJsonSchemaDraft, t as InferredDraft, u as isOpenApi31 } from "../version-D-u7aMfy.mjs";
+import { a as detectJsonSchemaDraft, c as inferJsonSchemaDraftWithReason, d as isSwagger2, f as matchJsonSchemaDraftUri, i as OpenApiVersionInfo, l as isOpenApi30, n as JsonSchemaDialectInfo, o as detectOpenApiVersion, p as readJsonSchemaDialect, r as JsonSchemaDraft, s as inferJsonSchemaDraft, t as InferredDraft, u as isOpenApi31 } from "../version-D2jfdX6E.mjs";
 export { InferredDraft, JsonSchemaDialectInfo, JsonSchemaDraft, OpenApiVersionInfo, detectJsonSchemaDraft, detectOpenApiVersion, inferJsonSchemaDraft, inferJsonSchemaDraftWithReason, isOpenApi30, isOpenApi31, isSwagger2, matchJsonSchemaDraftUri, readJsonSchemaDialect };

package/dist/core/walkBuilders.d.mts

@@ -1,6 +1,6 @@
-import { M as WalkedField, O as StringField, T as SchemaMeta, b as NumberField, c as FieldBase, j as UnknownField, o as Editability, p as FileField, r as BooleanField, v as NullField } from "../types-C9zw9wbX.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-CbBPsxSt.mjs";
-import { t as ExternalResolver } from "../ref-C8JbwfiS.mjs";
+import { A as UnknownField, D as StringField, b as NumberField, c as FieldBase, j as WalkedField, o as Editability, p as FileField, r as BooleanField, v as NullField, w as SchemaMeta } from "../types-BrRMV0en.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-D0QCYGv0.mjs";
+import { t as ExternalResolver } from "../ref-D-_JBZkF.mjs";
 
 //#region src/core/walkBuilders.d.ts
 declare function getString(obj: Record<string, unknown>, key: string): string | undefined;
@@ -52,8 +52,16 @@ declare function buildBooleanField(schema: Record<string, unknown>, ctx: WalkCon
 declare function buildNullField(schema: Record<string, unknown>, ctx: WalkContext): NullField;
 declare function buildUnknownField(schema: Record<string, unknown>, ctx: WalkContext): UnknownField;
 declare function buildFileField(schema: Record<string, unknown>, ctx: WalkContext): FileField;
-/** Walk a map of sub-schemas (patternProperties, dependentSchemas). */
-declare function walkSubSchemaMap<T>(map: Record<string, unknown>, walkNode: (schema: Record<string, unknown>, ctx: WalkContext) => T, ctx: WalkContext): Record<string, T>;
+/**
+ * Walk a map of sub-schemas (patternProperties, dependentSchemas, $defs).
+ *
+ * The callback receives each value as `unknown` so the caller can route
+ * boolean schemas (`true`/`false`, valid per Draft 06+) through the
+ * walker's boolean dispatch alongside object schemas. Non-schema values
+ * (numbers, strings, arrays, undefined) are silently skipped — they
+ * cannot represent a JSON Schema and have no walk-time meaning.
+ */
+declare function walkSubSchemaMap<T>(map: Record<string, unknown>, walkSubSchema: (schema: unknown, ctx: WalkContext) => T, ctx: WalkContext): Record<string, T>;
 /** Walk a dependentRequired map (Record<string, string[]>). */
 declare function walkDependentRequiredMap(map: Record<string, unknown>): Record<string, string[]>;
 /**

package/dist/core/walkBuilders.mjs

@@ -124,10 +124,18 @@ function buildFileField(schema, ctx) {
 		constraints: extractFileConstraints(schema)
 	};
 }
-/** Walk a map of sub-schemas (patternProperties, dependentSchemas). */
-function walkSubSchemaMap(map, walkNode, ctx) {
+/**
+* Walk a map of sub-schemas (patternProperties, dependentSchemas, $defs).
+*
+* The callback receives each value as `unknown` so the caller can route
+* boolean schemas (`true`/`false`, valid per Draft 06+) through the
+* walker's boolean dispatch alongside object schemas. Non-schema values
+* (numbers, strings, arrays, undefined) are silently skipped — they
+* cannot represent a JSON Schema and have no walk-time meaning.
+*/
+function walkSubSchemaMap(map, walkSubSchema, ctx) {
 	const result = {};
-	for (const [key, value] of Object.entries(map)) if (isObject(value)) result[key] = walkNode(value, ctx);
+	for (const [key, value] of Object.entries(map)) if (isObject(value) || typeof value === "boolean") result[key] = walkSubSchema(value, ctx);
 	return result;
 }
 /** Walk a dependentRequired map (Record<string, string[]>). */

package/dist/core/walker.d.mts

@@ -1,4 +1,4 @@
-import { M as WalkedField } from "../types-C9zw9wbX.mjs";
+import { j as WalkedField } from "../types-BrRMV0en.mjs";
 import { WalkOptions } from "./walkBuilders.mjs";
 
 //#region src/core/walker.d.ts