schema-components 1.20.0 → 1.22.0

package/dist/core/walker.mjs

@@ -1,9 +1,10 @@
 import { isObject } from "./guards.mjs";
 import { appendPointer, emitDiagnostic } from "./diagnostics.mjs";
+import { isPrototypePollutingKey } from "./uri.mjs";
 import { countDistinctRefs, resolveRef } from "./ref.mjs";
+import { matchJsonSchemaDraftUri } from "./version.mjs";
 import { extractArrayConstraints, extractObjectConstraints, stripInapplicableConstraints } from "./constraints.mjs";
 import { ANNOTATION_SIBLINGS, detectDiscriminated, mergeAllOf, mergeRefSiblings, normaliseAnyOf } from "./merge.mjs";
-import { isPrototypePollutingKey } from "./uri.mjs";
 import { buildBase, buildBooleanField, buildFileField, buildNullField, buildNumberField, buildStringField, buildUnknownField, extractChildOverride, extractSchemaMetaFields, getArray, getObject, getString, isPrimitive, walkDependentRequiredMap, walkSubSchemaMap, withoutKeys } from "./walkBuilders.mjs";
 //#region src/core/walker.ts
 /**
@@ -40,6 +41,55 @@ function walkSubSchema(value, ctx) {
 		constraints: {}
 	};
 }
+/**
+* Rank an `unevaluatedProperties`/`unevaluatedItems` value by how
+* restrictive it is. Higher is stricter. The ordering reflects
+* JSON Schema 2020-12 §11.2/§11.3 semantics:
+*
+*   false (forbid all extras)
+*     > schema-object (extras must match the schema)
+*     > true (extras explicitly permitted)
+*     > absent (extras implicitly permitted)
+*
+* Unknown shapes (numbers, arrays, strings) sort below absent — we
+* cannot reason about them, so do not let them override anything.
+*/
+function unevaluatedRank(value) {
+	if (value === false) return 3;
+	if (isObject(value)) return 2;
+	if (value === true) return 1;
+	if (value === void 0) return 0;
+	return -1;
+}
+/**
+* Pick the strictest `unevaluatedProperties` / `unevaluatedItems` across
+* a set of `allOf` branches (including the parent prepended as a
+* branch) and apply it to the merged node. `mergeAllOf` already collects
+* properties from every branch into the merged result; surfacing the
+* strictest unevaluated keyword closes the loop so the walker's object
+* builder sees the spec-correct value.
+*
+* The merged node is mutated in place — that is consistent with the
+* surrounding walker code, which treats the merge output as a fresh
+* working node.
+*/
+function applyStrictestUnevaluated(merged, branches) {
+	let strictestProps = merged.unevaluatedProperties;
+	let strictestItems = merged.unevaluatedItems;
+	for (const branch of branches) {
+		if (!isObject(branch)) continue;
+		if ("unevaluatedProperties" in branch) {
+			const candidate = branch.unevaluatedProperties;
+			if (unevaluatedRank(candidate) > unevaluatedRank(strictestProps)) strictestProps = candidate;
+		}
+		if ("unevaluatedItems" in branch) {
+			const candidate = branch.unevaluatedItems;
+			if (unevaluatedRank(candidate) > unevaluatedRank(strictestItems)) strictestItems = candidate;
+		}
+	}
+	if (strictestProps !== void 0) merged.unevaluatedProperties = strictestProps;
+	if (strictestItems !== void 0) merged.unevaluatedItems = strictestItems;
+}
 function walk(schema, options = {}) {
 	const { componentMeta, rootMeta, fieldOverrides, rootDocument, diagnostics, externalResolver } = options;
 	if (typeof schema === "boolean") return walkBooleanSchema(schema);
@@ -75,7 +125,13 @@ function walk(schema, options = {}) {
 }
 function walkNode(schema, ctx) {
 	const allOf = getArray(schema, "allOf");
-	if (allOf !== void 0 && allOf.length > 0) return walkNode(mergeAllOf(allOf, ctx.diagnostics, ctx.pointer), ctx);
+	if (allOf !== void 0 && allOf.length > 0) {
+		const branches = [withoutKeys(schema, ["allOf"]), ...allOf];
+		const merged = mergeAllOf(branches, ctx.diagnostics, ctx.pointer);
+		if (merged === false) return walkBooleanSchema(false);
+		applyStrictestUnevaluated(merged, branches);
+		return walkNode(merged, ctx);
+	}
 	const anyOf = getArray(schema, "anyOf");
 	if (anyOf !== void 0) {
 		const nullable = normaliseAnyOf(anyOf);
@@ -87,6 +143,11 @@ function walkNode(schema, ctx) {
 	}
 	const oneOf = getArray(schema, "oneOf");
 	if (oneOf !== void 0) {
+		const nullable = normaliseAnyOf(oneOf);
+		if (nullable !== void 0) return walkNode(nullable.inner, {
+			...ctx,
+			isNullable: true
+		});
 		const discriminated = detectDiscriminated(oneOf, ctx.diagnostics, ctx.pointer);
 		if (discriminated !== void 0) return walkDiscriminatedUnion(discriminated, ctx);
 		return walkUnion(oneOf, ctx);
@@ -112,32 +173,27 @@ function walkNode(schema, ctx) {
 		Object.assign(placeholder, result);
 		return placeholder;
 	}
-	const ifSchema = getObject(schema, "if");
-	if (ifSchema !== void 0) {
+	if ("if" in schema) {
 		emitDiagnostic(ctx.diagnostics, {
 			code: "conditional-fallback",
 			message: "if/then/else rendered as base schema; conditionals require runtime evaluation",
 			pointer: ctx.pointer
 		});
-		const base = buildBase(withoutKeys(schema, [
-			"if",
-			"then",
-			"else"
-		]), ctx);
-		const thenSchema = getObject(schema, "then");
-		const elseSchema = getObject(schema, "else");
 		const conditional = {
-			...base,
+			...buildBase(withoutKeys(schema, [
+				"if",
+				"then",
+				"else"
+			]), ctx),
 			type: "conditional",
 			constraints: {},
-			ifClause: walkNode(ifSchema, ctx)
+			ifClause: walkSubSchema(schema.if, ctx)
 		};
-		if (thenSchema !== void 0) conditional.thenClause = walkNode(thenSchema, ctx);
-		if (elseSchema !== void 0) conditional.elseClause = walkNode(elseSchema, ctx);
+		if ("then" in schema) conditional.thenClause = walkSubSchema(schema.then, ctx);
+		if ("else" in schema) conditional.elseClause = walkSubSchema(schema.else, ctx);
 		return conditional;
 	}
-	const notSchema = getObject(schema, "not");
-	if (notSchema !== void 0) {
+	if ("not" in schema) {
 		emitDiagnostic(ctx.diagnostics, {
 			code: "type-negation-fallback",
 			message: "not schema rendered as negation; TypeScript cannot negate types",
@@ -147,7 +203,7 @@ function walkNode(schema, ctx) {
 			...buildBase(withoutKeys(schema, ["not"]), ctx),
 			type: "negation",
 			constraints: {},
-			negated: walkNode(notSchema, ctx)
+			negated: walkSubSchema(schema.not, ctx)
 		};
 	}
 	const enumValues = getArray(schema, "enum");
@@ -223,11 +279,36 @@ function walkNode(schema, ctx) {
 	});
 	return buildUnknownField(schema, ctx);
 }
+/**
+* Drafts that pre-date the `contentSchema` keyword (added in Draft
+* 2019-09). Used to emit `keyword-out-of-draft` when a document
+* declaring one of these drafts uses `contentSchema` anyway.
+*/
+const PRE_CONTENT_SCHEMA_DRAFTS = new Set([
+	"draft-04",
+	"draft-06",
+	"draft-07"
+]);
 function walkString(schema, ctx) {
 	if (getString(schema, "format") === "binary") return buildFileField(schema, ctx);
 	const field = buildStringField(schema, ctx);
 	const contentSchema = getObject(schema, "contentSchema");
-	if (contentSchema !== void 0) field.meta.decodedSchema = walkNode(contentSchema, ctx);
+	if (contentSchema !== void 0) {
+		const rootSchema = getString(ctx.rootDocument, "$schema");
+		if (rootSchema !== void 0) {
+			const draft = matchJsonSchemaDraftUri(rootSchema);
+			if (draft !== void 0 && PRE_CONTENT_SCHEMA_DRAFTS.has(draft)) emitDiagnostic(ctx.diagnostics, {
+				code: "keyword-out-of-draft",
+				message: `\`contentSchema\` is a Draft 2019-09+ keyword; the document declares ${draft}`,
+				pointer: appendPointer(ctx.pointer, "contentSchema"),
+				detail: {
+					keyword: "contentSchema",
+					declaredDraft: draft
+				}
+			});
+		}
+		field.meta.decodedSchema = walkNode(contentSchema, ctx);
+	}
 	return field;
 }
 function walkNumber(schema, ctx) {
@@ -321,7 +402,7 @@ function walkObject(schema, properties, ctx) {
 		};
 	}
 	const patternProps = getObject(schema, "patternProperties");
-	const walkedPatternProps = patternProps !== void 0 ? walkSubSchemaMap(patternProps, walkNode, ctx) : void 0;
+	const walkedPatternProps = patternProps !== void 0 ? walkSubSchemaMap(patternProps, walkSubSchema, ctx) : void 0;
 	let additionalPropertiesClosed;
 	let additionalPropertiesSchema;
 	const additionalProps = schema.additionalProperties;
@@ -334,7 +415,7 @@ function walkObject(schema, properties, ctx) {
 	};
 	else if (isObject(additionalProps)) additionalPropertiesSchema = walkNode(additionalProps, ctx);
 	const depSchemas = getObject(schema, "dependentSchemas");
-	const walkedDepSchemas = depSchemas !== void 0 ? walkSubSchemaMap(depSchemas, walkNode, ctx) : void 0;
+	const walkedDepSchemas = depSchemas !== void 0 ? walkSubSchemaMap(depSchemas, walkSubSchema, ctx) : void 0;
 	const depReq = getObject(schema, "dependentRequired");
 	const walkedDepReq = depReq !== void 0 ? walkDependentRequiredMap(depReq) : void 0;
 	let unevaluatedProperties;
@@ -348,8 +429,7 @@ function walkObject(schema, properties, ctx) {
 		constraints: {}
 	};
 	else if (isObject(unevalProps)) unevaluatedProperties = walkNode(unevalProps, ctx);
-	const propertyNamesSchema = getObject(schema, "propertyNames");
-	const walkedPropertyNames = propertyNamesSchema !== void 0 ? walkNode(propertyNamesSchema, ctx) : void 0;
+	const walkedPropertyNames = "propertyNames" in schema ? walkSubSchema(schema.propertyNames, ctx) : void 0;
 	return {
 		...buildBase(schema, ctx),
 		type: "object",
@@ -384,6 +464,7 @@ function walkRecord(schema, valueSchema, ctx) {
 	};
 }
 function walkArray(schema, ctx) {
+	const walkedContains = "contains" in schema ? walkSubSchema(schema.contains, ctx) : void 0;
 	const prefixItems = getArray(schema, "prefixItems");
 	if (prefixItems !== void 0) {
 		const walkedItems = prefixItems.filter(isObject).map((item) => walkNode(item, ctx));
@@ -394,7 +475,8 @@ function walkArray(schema, ctx) {
 			type: "tuple",
 			constraints: extractArrayConstraints(schema),
 			prefixItems: walkedItems,
-			...restItems !== void 0 ? { restItems } : {}
+			...restItems !== void 0 ? { restItems } : {},
+			...walkedContains !== void 0 ? { contains: walkedContains } : {}
 		};
 	}
 	const unevaluatedItemsSchema = getObject(schema, "unevaluatedItems");
@@ -410,14 +492,16 @@ function walkArray(schema, ctx) {
 				...ctx,
 				fieldOverrides: elementOverride
 			}),
-			...walkedUnevaluatedItems !== void 0 ? { unevaluatedItems: walkedUnevaluatedItems } : {}
+			...walkedUnevaluatedItems !== void 0 ? { unevaluatedItems: walkedUnevaluatedItems } : {},
+			...walkedContains !== void 0 ? { contains: walkedContains } : {}
 		};
 	}
 	return {
 		...buildBase(schema, ctx),
 		type: "array",
 		constraints: extractArrayConstraints(schema),
-		...walkedUnevaluatedItems !== void 0 ? { unevaluatedItems: walkedUnevaluatedItems } : {}
+		...walkedUnevaluatedItems !== void 0 ? { unevaluatedItems: walkedUnevaluatedItems } : {},
+		...walkedContains !== void 0 ? { contains: walkedContains } : {}
 	};
 }
 function walkUnion(options, ctx) {

package/dist/{diagnostics-CbBPsxSt.d.mts → diagnostics-D0QCYGv0.d.mts}

@@ -16,7 +16,7 @@
  * Machine-readable codes identifying each class of diagnostic.
  * Stable across releases — consumers can pattern-match on these.
  */
-type DiagnosticCode = "unresolved-ref" | "unknown-keyword" | "unknown-format" | "invalid-const" | "unsupported-type" | "dropped-swagger-feature" | "external-ref" | "type-negation-fallback" | "conditional-fallback" | "assumed-draft" | "depth-exceeded" | "allof-conflict" | "discriminator-inconsistent" | "divisible-by-conflict" | "legacy-dependencies-split" | "dependent-required-invalid" | "unknown-json-schema-dialect" | "relative-ref-resolved" | "bare-exclusive-bound" | "enum-value-filtered" | "required-non-string" | "pattern-invalid" | "duplicate-body-parameter" | "prototype-polluting-property";
+type DiagnosticCode = "unresolved-ref" | "unknown-keyword" | "unknown-format" | "invalid-const" | "invalid-id-fragment" | "unsupported-type" | "dropped-swagger-feature" | "dynamic-ref-degraded" | "external-ref" | "type-negation-fallback" | "conditional-fallback" | "assumed-draft" | "depth-exceeded" | "allof-conflict" | "discriminator-inconsistent" | "divisible-by-conflict" | "keyword-out-of-draft" | "legacy-dependencies-split" | "dependent-required-invalid" | "unknown-json-schema-dialect" | "unknown-openapi-version" | "relative-ref-resolved" | "bare-exclusive-bound" | "enum-value-filtered" | "required-non-string" | "pattern-invalid" | "duplicate-body-parameter" | "prototype-polluting-property" | "cross-schema-relative-ref-unsupported" | "cyclic-path-item-ref" | "doc-not-object" | "path-item-ref-too-deep" | "swagger-cyclic-parameter-ref" | "swagger-invalid-file-parameter" | "swagger-missing-consumes" | "swagger-missing-host" | "type-mismatch" | "unknown-security-scheme-type" | "zod-codec-output-only";
 /**
  * A single diagnostic emitted during schema processing.
  */

package/dist/{errors-C2iABcn9.d.mts → errors-DpFwqs5C.d.mts}

@@ -14,11 +14,16 @@
 /**
  * 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.
  */
 declare class SchemaError extends Error {
   /** The schema input that caused the error. */
   readonly schema: unknown;
-  constructor(message: string, schema: unknown);
+  constructor(message: string, schema: unknown, cause?: unknown);
 }
 /**
  * The adapter failed to convert the input schema to JSON Schema.
@@ -27,19 +32,12 @@ declare class SchemaError extends Error {
  * JSON Schema, missing OpenAPI ref, unsupported ref format.
  */
 declare class SchemaNormalisationError extends SchemaError {
-  readonly kind: "invalid-zod" | "zod3-unsupported" | "zod-transform-unsupported" | "zod-type-unrepresentable" | "zod-conversion-failed" | "invalid-json-schema" | "openapi-missing-ref" | "openapi-invalid" | "unknown";
+  readonly kind: "invalid-zod" | "unsupported-schema" | "zod3-unsupported" | "zod-transform-unsupported" | "zod-type-unrepresentable" | "zod-conversion-failed" | "zod-conversion-bug" | "zod-cycle-detected" | "zod-duplicate-id" | "invalid-json-schema" | "openapi-missing-ref" | "openapi-invalid" | "unknown";
   /**
    * For `zod-type-unrepresentable`, the offending Zod type name
    * (e.g. "bigint", "date", "map", "set"). `undefined` for other kinds.
    */
   readonly zodType: string | undefined;
-  /**
-   * 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.
-   */
-  readonly cause: unknown;
   constructor(message: string, schema: unknown, kind: SchemaNormalisationError["kind"], zodType?: string, cause?: unknown);
 }
 /**
@@ -50,8 +48,6 @@ declare class SchemaNormalisationError extends SchemaError {
 declare class SchemaRenderError extends SchemaError {
   /** The schema type being rendered when the error occurred. */
   readonly schemaType: string;
-  /** The original error from the render function. */
-  readonly cause: unknown;
   constructor(message: string, schema: unknown, schemaType: string, cause: unknown);
 }
 /**

package/dist/html/a11y.d.mts

@@ -1,5 +1,5 @@
-import { M as WalkedField } from "../types-C9zw9wbX.mjs";
-import { t as AllConstraints } from "../renderer-SOIbJBtk.mjs";
+import { j as WalkedField } from "../types-BrRMV0en.mjs";
+import { t as AllConstraints } from "../renderer-BaRlQIuN.mjs";
 import { HtmlAttributes, HtmlNode } from "./html.mjs";
 
 //#region src/html/a11y.d.ts

package/dist/html/a11y.mjs

@@ -18,11 +18,18 @@ function joinPath(parent, suffix) {
 }
 /**
 * Normalise a path into the id segment used after the `sc-` prefix.
-* Dots (object nesting) and brackets (array indices) become hyphens so
-* the id remains a valid CSS selector and matches test query semantics.
+*
+* Whitelist-based: every character outside `[A-Za-z0-9_-]` collapses to
+* a single hyphen. A blacklist that only stripped `.[]` would still leak
+* spaces, slashes, and other punctuation through into ids when a path
+* is sourced from a free-text field like `meta.description` — producing
+* structurally invalid CSS selectors and `aria-labelledby` references.
+*
+* Trailing hyphens are trimmed so e.g. `tags[0]` → `tags-0` (not
+* `tags-0-`).
 */
 function normaliseIdSegment(value) {
-	return value.replace(/[.[\]]+/g, "-").replace(/-+$/g, "");
+	return value.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/-+$/g, "");
 }
 /**
 * Build the input ID for a field at a given path.

package/dist/html/renderToHtml.d.mts

@@ -1,7 +1,14 @@
-import { T as SchemaMeta } from "../types-C9zw9wbX.mjs";
-import { o as HtmlResolver } from "../renderer-SOIbJBtk.mjs";
+import { w as SchemaMeta } from "../types-BrRMV0en.mjs";
+import { o as HtmlResolver } from "../renderer-BaRlQIuN.mjs";
 
 //#region src/html/renderToHtml.d.ts
+/**
+ * Build the recursion-cap sentinel element. The label is interpolated
+ * via `h()` + `serialize` so any HTML in `meta.description` (which is
+ * schema-author content but can equally be sourced from user-supplied
+ * JSON Schema input) is escaped — never interpolated into raw markup.
+ */
+declare function recursionSentinelHtml(label: string): string;
 interface RenderToHtmlOptions {
   /** The data value to render. */
   value?: unknown;
@@ -29,4 +36,4 @@ interface RenderToHtmlOptions {
  */
 declare function renderToHtml(schema: unknown, options?: RenderToHtmlOptions): string;
 //#endregion
-export { RenderToHtmlOptions, renderToHtml };
+export { RenderToHtmlOptions, recursionSentinelHtml, renderToHtml };

package/dist/html/renderToHtml.mjs

@@ -1,6 +1,8 @@
+import "../core/limits.mjs";
 import { normaliseSchema } from "../core/adapter.mjs";
 import { getHtmlRenderFn, mergeHtmlResolvers } from "../core/renderer.mjs";
 import { walk } from "../core/walker.mjs";
+import { h, serialize } from "./html.mjs";
 import { joinPath } from "./a11y.mjs";
 import { defaultHtmlResolver } from "./renderers.mjs";
 //#region src/html/renderToHtml.ts
@@ -25,6 +27,15 @@ import { defaultHtmlResolver } from "./renderers.mjs";
 *   });
 */
 /**
+* Build the recursion-cap sentinel element. The label is interpolated
+* via `h()` + `serialize` so any HTML in `meta.description` (which is
+* schema-author content but can equally be sourced from user-supplied
+* JSON Schema input) is escaped — never interpolated into raw markup.
+*/
+function recursionSentinelHtml(label) {
+	return serialize(h("fieldset", { class: "sc-recursive" }, h("em", {}, `↻ ${label} (recursive)`)));
+}
+/**
 * Render a schema to an HTML string.
 *
 * @param schema - Zod schema, JSON Schema, or OpenAPI document
@@ -44,9 +55,8 @@ function renderToHtml(schema, options = {}) {
 		rootDocument
 	});
 	const resolver = options.resolver ?? defaultHtmlResolver;
-	const MAX_HTML_DEPTH = 10;
 	const makeRenderChild = (currentDepth, parentPath) => (childTree, childValue, pathSuffix) => {
-		if (currentDepth >= MAX_HTML_DEPTH) return `<fieldset class="sc-recursive"><em>\u21bb ${typeof childTree.meta.description === "string" ? childTree.meta.description : "schema"} (recursive)</em></fieldset>`;
+		if (currentDepth >= 10) return recursionSentinelHtml(typeof childTree.meta.description === "string" ? childTree.meta.description : "schema");
 		const childPath = joinPath(parentPath, pathSuffix);
 		return renderFieldHtml(childTree, childValue, resolver, childPath, makeRenderChild(currentDepth + 1, childPath));
 	};
@@ -73,4 +83,4 @@ function renderFieldHtml(tree, value, resolver, path, renderChild) {
 	return renderFn(props);
 }
 //#endregion
-export { renderToHtml };
+export { recursionSentinelHtml, renderToHtml };

package/dist/html/renderToHtmlStream.d.mts

@@ -1,5 +1,5 @@
-import { T as SchemaMeta } from "../types-C9zw9wbX.mjs";
-import { o as HtmlResolver } from "../renderer-SOIbJBtk.mjs";
+import { w as SchemaMeta } from "../types-BrRMV0en.mjs";
+import { o as HtmlResolver } from "../renderer-BaRlQIuN.mjs";
 
 //#region src/html/renderToHtmlStream.d.ts
 interface StreamRenderOptions {

package/dist/html/renderers.d.mts

@@ -1,5 +1,5 @@
-import { M as WalkedField } from "../types-C9zw9wbX.mjs";
-import { o as HtmlResolver } from "../renderer-SOIbJBtk.mjs";
+import { j as WalkedField } from "../types-BrRMV0en.mjs";
+import { o as HtmlResolver } from "../renderer-BaRlQIuN.mjs";
 
 //#region src/html/renderers.d.ts
 declare function dateInputType(format: string | undefined): string | undefined;

package/dist/html/renderers.mjs

@@ -1,5 +1,5 @@
-import { sortFieldsByOrder } from "../core/fieldOrder.mjs";
 import { isSafeHyperlink, isSafeMailtoAddress } from "../core/uri.mjs";
+import { sortFieldsByOrder } from "../core/fieldOrder.mjs";
 import { h, raw, serialize } from "./html.mjs";
 import { ariaDescribedByAttrs, ariaLabelAttrs, ariaReadonlyAttrs, ariaRequiredAttrs, buildHintElement, buildInputId, requiredIndicator } from "./a11y.mjs";
 //#region src/html/renderers.ts
@@ -334,10 +334,6 @@ function renderFileHtml(props) {
 	if (typeof props.meta.description === "string") Object.assign(attrs, ariaLabelAttrs(props.meta.description));
 	return serialize(h("input", attrs));
 }
-function renderRecursiveHtml(props) {
-	const refTarget = props.tree.type === "recursive" ? props.tree.refTarget : "";
-	return serialize(h("fieldset", { class: "sc-recursive" }, `↻ ${typeof props.meta.description === "string" ? props.meta.description : refTarget} (recursive)`));
-}
 function renderUnknownHtml(props) {
 	if (props.readOnly) {
 		if (props.value === void 0 || props.value === null) return serialize(h("span", { class: "sc-value sc-value--empty" }, "—"));
@@ -433,7 +429,6 @@ const defaultHtmlResolver = {
 	discriminatedUnion: renderDiscriminatedUnionHtml,
 	conditional: renderConditionalHtml,
 	negation: renderNegationHtml,
-	recursive: renderRecursiveHtml,
 	file: renderFileHtml,
 	never: renderNeverHtml,
 	unknown: renderUnknownHtml

package/dist/html/streamRenderers.d.mts

@@ -1,13 +1,14 @@
-import { M as WalkedField } from "../types-C9zw9wbX.mjs";
-import { o as HtmlResolver } from "../renderer-SOIbJBtk.mjs";
+import { j as WalkedField } from "../types-BrRMV0en.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-D0QCYGv0.mjs";
+import { o as HtmlResolver } from "../renderer-BaRlQIuN.mjs";
 import { HtmlElement } from "./html.mjs";
 
 //#region src/html/streamRenderers.d.ts
 declare function yieldOpen(el: HtmlElement): string;
 declare function yieldClose(el: HtmlElement): string;
 declare function renderLeaf(tree: WalkedField, value: unknown, mergedResolver: HtmlResolver, path: string): string;
-declare function renderFieldSync(tree: WalkedField, value: unknown, mergedResolver: HtmlResolver, path: string, rawResolver: HtmlResolver): string;
+declare function renderFieldSync(tree: WalkedField, value: unknown, mergedResolver: HtmlResolver, path: string, rawResolver: HtmlResolver, currentDepth: number, diagnostics: DiagnosticsOptions | undefined): string;
 declare function matchUnionOption(options: WalkedField[], value: unknown): WalkedField | undefined;
-declare function streamField(tree: WalkedField, value: unknown, mergedResolver: HtmlResolver, path: string, rawResolver: HtmlResolver): Iterable<string, void, undefined>;
+declare function streamField(tree: WalkedField, value: unknown, mergedResolver: HtmlResolver, path: string, rawResolver: HtmlResolver, currentDepth?: number, diagnostics?: DiagnosticsOptions): Iterable<string, void, undefined>;
 //#endregion
 export { matchUnionOption, renderFieldSync, renderLeaf, streamField, yieldClose, yieldOpen };