schema-components 1.17.0 → 1.18.1

package/dist/core/adapter.d.mts

@@ -1,5 +1,5 @@
 import { T as SchemaMeta, m as JsonObject } from "../types-D_5ST7SS.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-DzbZmcLI.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-BYk63jsC.mjs";
 
 //#region src/core/adapter.d.ts
 type SchemaInput = Record<string, unknown>;

package/dist/core/constraints.d.mts

@@ -1,5 +1,5 @@
 import { D as StringConstraints, f as FileConstraints, t as ArrayConstraints, x as ObjectConstraints, y as NumberConstraints } from "../types-D_5ST7SS.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-DzbZmcLI.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-BYk63jsC.mjs";
 
 //#region src/core/constraints.d.ts
 declare function extractStringConstraints(schema: Record<string, unknown>, diagnostics?: DiagnosticsOptions, pointer?: string): StringConstraints;

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-DzbZmcLI.mjs";
+import { a as appendPointer, i as DiagnosticsOptions, n as DiagnosticCode, o as emitDiagnostic, r as DiagnosticSink, t as Diagnostic } from "../diagnostics-BYk63jsC.mjs";
 export { Diagnostic, DiagnosticCode, DiagnosticSink, DiagnosticsOptions, appendPointer, emitDiagnostic };

package/dist/core/fieldOrder.d.mts

@@ -0,0 +1,10 @@
+import { M as WalkedField } from "../types-D_5ST7SS.mjs";
+
+//#region src/core/fieldOrder.d.ts
+/**
+ * Sort `Object.entries(fields)` by `meta.order`. Lower values come
+ * first; fields without `meta.order` fall back to `Infinity` (last).
+ */
+declare function sortFieldsByOrder(fields: Record<string, WalkedField>): [string, WalkedField][];
+//#endregion
+export { sortFieldsByOrder };

package/dist/core/fieldOrder.mjs

@@ -0,0 +1,12 @@
+//#region src/core/fieldOrder.ts
+/**
+* Sort `Object.entries(fields)` by `meta.order`. Lower values come
+* first; fields without `meta.order` fall back to `Infinity` (last).
+*/
+function sortFieldsByOrder(fields) {
+	return Object.entries(fields).sort((a, b) => {
+		return (typeof a[1].meta.order === "number" ? a[1].meta.order : Infinity) - (typeof b[1].meta.order === "number" ? b[1].meta.order : Infinity);
+	});
+}
+//#endregion
+export { sortFieldsByOrder };

package/dist/core/merge.d.mts

@@ -1,10 +1,6 @@
+import { i as DiagnosticsOptions } from "../diagnostics-BYk63jsC.mjs";
+
 //#region src/core/merge.d.ts
-/**
- * Schema merging, nullable detection, and discriminated union detection.
- *
- * Used by the walker to handle `allOf`, `anyOf [T, null]`, and
- * `oneOf` with discriminator properties.
- */
 /**
  * Annotation keywords that can appear as siblings of `$ref` per
  * Draft 2020-12 / OpenAPI 3.1. Structural keywords (type, properties,
@@ -24,8 +20,13 @@ declare function mergeRefSiblings(referencer: Record<string, unknown>, resolvedM
 /**
  * Merge multiple JSON Schema objects from allOf into one.
  * Merges: properties, required, meta fields, and constraints.
+ *
+ * Semantics are first-write-wins for meta and constraint keywords.
+ * 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.
  */
-declare function mergeAllOf(schemas: unknown[]): Record<string, unknown>;
+declare function mergeAllOf(schemas: unknown[], diagnostics?: DiagnosticsOptions, pointer?: string): Record<string, unknown>;
 interface NormalisedAnyOf {
   inner: Record<string, unknown>;
   isNullable: boolean;
@@ -42,7 +43,12 @@ interface Discriminated {
 /**
  * Detect oneOf where every option is an object with a property
  * that has a `const` value → discriminated union.
+ *
+ * When options carry inconsistent discriminator candidates (e.g. one
+ * uses `kind` while another uses `type`) detection fails and a
+ * `discriminator-inconsistent` diagnostic is emitted so callers can
+ * see why the union falls back to a generic oneOf.
  */
-declare function detectDiscriminated(options: unknown[]): Discriminated | undefined;
+declare function detectDiscriminated(options: unknown[], diagnostics?: DiagnosticsOptions, pointer?: string): Discriminated | undefined;
 //#endregion
 export { ANNOTATION_SIBLINGS, Discriminated, NormalisedAnyOf, detectDiscriminated, mergeAllOf, mergeRefSiblings, normaliseAnyOf };

package/dist/core/merge.mjs

@@ -1,4 +1,5 @@
 import { isObject } from "./guards.mjs";
+import { emitDiagnostic } from "./diagnostics.mjs";
 //#region src/core/merge.ts
 /**
 * Schema merging, nullable detection, and discriminated union detection.
@@ -19,6 +20,59 @@ function getObject(obj, key) {
 	return isObject(value) ? value : void 0;
 }
 /**
+* Structural equality for arbitrary JSON-like values. Used to decide
+* whether a duplicated keyword across `allOf` branches genuinely
+* conflicts (different values) or is benign (identical values).
+*
+* Cycle-safe: bundling external $refs via `structuredClone` preserves
+* object cycles, so constraint values reaching this comparator can be
+* cyclic. The co-recursive convention applies — when a pair of objects
+* (or arrays) is re-encountered during the same comparison we assume
+* equality holds and return true, letting any genuine inequality
+* elsewhere in the structure surface naturally without recursing
+* forever.
+*/
+function deepEqual(a, b) {
+	return deepEqualInner(a, b, /* @__PURE__ */ new WeakMap());
+}
+function deepEqualInner(a, b, seen) {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (Array.isArray(a)) {
+		if (!Array.isArray(b) || a.length !== b.length) return false;
+		if (hasSeenPair(seen, a, b)) return true;
+		recordPair(seen, a, b);
+		for (let i = 0; i < a.length; i++) if (!deepEqualInner(a[i], b[i], seen)) return false;
+		return true;
+	}
+	if (isObject(a) && isObject(b)) {
+		const keysA = Object.keys(a);
+		const keysB = Object.keys(b);
+		if (keysA.length !== keysB.length) return false;
+		if (hasSeenPair(seen, a, b)) return true;
+		recordPair(seen, a, b);
+		for (const key of keysA) {
+			if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+			if (!deepEqualInner(a[key], b[key], seen)) return false;
+		}
+		return true;
+	}
+	return false;
+}
+function hasSeenPair(seen, a, b) {
+	return seen.get(a)?.has(b) === true;
+}
+function recordPair(seen, a, b) {
+	const existing = seen.get(a);
+	if (existing === void 0) {
+		const partners = /* @__PURE__ */ new WeakSet();
+		partners.add(b);
+		seen.set(a, partners);
+		return;
+	}
+	existing.add(b);
+}
+/**
 * Annotation keywords that can appear as siblings of `$ref` per
 * Draft 2020-12 / OpenAPI 3.1. Structural keywords (type, properties,
 * etc.) are NOT annotation siblings and should not be merged.
@@ -50,8 +104,13 @@ function mergeRefSiblings(referencer, resolvedMeta) {
 /**
 * Merge multiple JSON Schema objects from allOf into one.
 * Merges: properties, required, meta fields, and constraints.
+*
+* Semantics are first-write-wins for meta and constraint keywords.
+* 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.
 */
-function mergeAllOf(schemas) {
+function mergeAllOf(schemas, diagnostics, pointer = "") {
 	const merged = {};
 	const properties = {};
 	const required = [];
@@ -66,10 +125,30 @@ function mergeAllOf(schemas) {
 		for (const [key, value] of Object.entries(entry)) {
 			if (key === "properties" || key === "required" || key === "allOf" || key === "type") continue;
 			if (!(key in merged)) merged[key] = value;
+			else if (!deepEqual(merged[key], value)) emitDiagnostic(diagnostics, {
+				code: "allof-conflict",
+				message: `allOf branches define conflicting values for "${key}"; keeping the first occurrence and discarding subsequent values`,
+				pointer,
+				detail: {
+					key,
+					kept: merged[key],
+					discarded: value
+				}
+			});
 		}
-		if (!("type" in merged)) {
-			const type = getString(entry, "type");
-			if (type !== void 0) merged.type = type;
+		const entryType = getString(entry, "type");
+		if (entryType !== void 0) {
+			if (!("type" in merged)) merged.type = entryType;
+			else if (!deepEqual(merged.type, entryType)) emitDiagnostic(diagnostics, {
+				code: "allof-conflict",
+				message: `allOf branches define conflicting values for "type"; keeping the first occurrence and discarding subsequent values`,
+				pointer,
+				detail: {
+					key: "type",
+					kept: merged.type,
+					discarded: entryType
+				}
+			});
 		}
 	}
 	if (Object.keys(properties).length > 0) merged.properties = properties;
@@ -98,22 +177,40 @@ function normaliseAnyOf(options) {
 /**
 * Detect oneOf where every option is an object with a property
 * that has a `const` value → discriminated union.
+*
+* When options carry inconsistent discriminator candidates (e.g. one
+* uses `kind` while another uses `type`) detection fails and a
+* `discriminator-inconsistent` diagnostic is emitted so callers can
+* see why the union falls back to a generic oneOf.
 */
-function detectDiscriminated(options) {
+function detectDiscriminated(options, diagnostics, pointer = "") {
 	if (options.length === 0) return void 0;
 	let discriminator;
+	const perOptionKeys = [];
 	for (const opt of options) {
 		if (!isObject(opt)) return void 0;
 		const props = getObject(opt, "properties");
 		if (props === void 0) return void 0;
-		let foundKey;
-		for (const [key, value] of Object.entries(props)) if (isObject(value) && "const" in value) {
-			foundKey = key;
-			break;
+		const constKeys = [];
+		for (const [key, value] of Object.entries(props)) if (isObject(value) && "const" in value) constKeys.push(key);
+		if (constKeys.length === 0) {
+			perOptionKeys.push(void 0);
+			continue;
 		}
-		if (foundKey === void 0) return void 0;
-		if (discriminator === void 0) discriminator = foundKey;
-		else if (discriminator !== foundKey) return;
+		const foundKey = constKeys[0];
+		perOptionKeys.push(foundKey);
+		discriminator ??= foundKey;
+	}
+	if (perOptionKeys.some((k) => k === void 0)) return void 0;
+	const uniqueKeys = new Set(perOptionKeys);
+	if (uniqueKeys.size > 1) {
+		emitDiagnostic(diagnostics, {
+			code: "discriminator-inconsistent",
+			message: `oneOf options use inconsistent discriminator keys (${[...uniqueKeys].map((k) => `"${k ?? ""}"`).join(", ")}); rendering as a generic union`,
+			pointer,
+			detail: { candidates: perOptionKeys }
+		});
+		return;
 	}
 	if (discriminator === void 0) return void 0;
 	return {

package/dist/core/normalise.d.mts

@@ -1,4 +1,4 @@
-import { i as DiagnosticsOptions } from "../diagnostics-DzbZmcLI.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-BYk63jsC.mjs";
 import { n as JsonSchemaDraft, r as OpenApiVersionInfo } from "../version-B5NV-35j.mjs";
 
 //#region src/core/normalise.d.ts

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-DvWoULcy.mjs";
+import { a as findAnchor, i as dereference, n as RefOptions, o as resolveRef, r as countDistinctRefs, t as ExternalResolver } from "../ref-Ckt5liZs.mjs";
 export { ExternalResolver, RefOptions, countDistinctRefs, dereference, findAnchor, resolveRef };

package/dist/core/renderer.d.mts

@@ -1,2 +1,2 @@
-import { a as HtmlRenderProps, c as RenderFunction, d as getRenderFunction, f as mergeHtmlResolvers, i as HtmlRenderFunction, l as RenderProps, m as typeToKey, n as BaseFieldProps, o as HtmlResolver, p as mergeResolvers, r as ComponentResolver, s as RESOLVER_KEYS, t as AllConstraints, u as getHtmlRenderFn } from "../renderer-B3s8o2B8.mjs";
-export { AllConstraints, BaseFieldProps, ComponentResolver, HtmlRenderFunction, HtmlRenderProps, HtmlResolver, RESOLVER_KEYS, RenderFunction, RenderProps, getHtmlRenderFn, getRenderFunction, mergeHtmlResolvers, mergeResolvers, typeToKey };
+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-BAGoX4AK.mjs";
+export { AllConstraints, BaseFieldProps, ComponentResolver, HtmlRenderFunction, HtmlRenderProps, HtmlResolver, RESOLVER_KEYS, RenderFunction, RenderProps, buildRenderProps, getHtmlRenderFn, getRenderFunction, mergeHtmlResolvers, mergeResolvers, typeToKey };

package/dist/core/renderer.mjs

@@ -1,4 +1,34 @@
 //#region src/core/renderer.ts
+/** No-op onChange used when callers render in read-only mode. */
+function noopOnChange() {}
+/**
+* Build the `RenderProps` object handed to a resolver render function or a
+* widget. Used by both the server-side `<SchemaView>` (which has no
+* `onChange`) and the client-side `<SchemaComponent>` (which threads an
+* `onChange` callback).
+*
+* When `onChange` is `undefined` the caller is rendering in read-only mode:
+* a noop `onChange` is wired up, `readOnly` is forced to `true`, and
+* `writeOnly` is forced to `false`. Otherwise the editability is taken
+* from `tree.editability`.
+*/
+function buildRenderProps(tree, value, onChange, renderChild, path) {
+	const isReadOnly = onChange === void 0 || tree.editability === "presentation";
+	const isWriteOnly = onChange !== void 0 && tree.editability === "input";
+	const props = {
+		value,
+		onChange: onChange ?? noopOnChange,
+		readOnly: isReadOnly,
+		writeOnly: isWriteOnly,
+		meta: tree.meta,
+		constraints: tree.constraints,
+		path,
+		tree,
+		renderChild
+	};
+	if (tree.examples !== void 0) props.examples = tree.examples;
+	return props;
+}
 const RESOLVER_KEYS = [
 	"string",
 	"number",
@@ -77,4 +107,4 @@ function mergeHtmlResolvers(user, fallback) {
 	return merged;
 }
 //#endregion
-export { RESOLVER_KEYS, getHtmlRenderFn, getRenderFunction, mergeHtmlResolvers, mergeResolvers, typeToKey };
+export { RESOLVER_KEYS, buildRenderProps, getHtmlRenderFn, getRenderFunction, mergeHtmlResolvers, mergeResolvers, typeToKey };

package/dist/core/swagger2.d.mts

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

package/dist/core/typeInference.d.mts

@@ -1,2 +1,2 @@
-import { a as OpenAPIRequestBodyType, c as ResolveOpenAPIRef, d as __SchemaInferenceFellBack, i as InferResponseFields, l as TypeAtPath, n as InferParameterOverrides, o as OpenAPIResponseType, r as InferRequestBodyFields, s as PathOfType, t as FromJSONSchema, u as UnsafeFields } from "../typeInference-k7FXfTVO.mjs";
-export { FromJSONSchema, InferParameterOverrides, InferRequestBodyFields, InferResponseFields, OpenAPIRequestBodyType, OpenAPIResponseType, PathOfType, ResolveOpenAPIRef, TypeAtPath, UnsafeFields, __SchemaInferenceFellBack };
+import { a as InferResponseFields, c as PathOfType, d as UnsafeFields, f as __SchemaInferenceFellBack, i as InferRequestBodyFields, l as ResolveOpenAPIRef, n as FromJSONSchema, o as OpenAPIRequestBodyType, r as InferParameterOverrides, s as OpenAPIResponseType, t as DEFAULT_MAX_DEPTH, u as TypeAtPath } from "../typeInference-5JiqIZ8t.mjs";
+export { DEFAULT_MAX_DEPTH, FromJSONSchema, InferParameterOverrides, InferRequestBodyFields, InferResponseFields, OpenAPIRequestBodyType, OpenAPIResponseType, PathOfType, ResolveOpenAPIRef, TypeAtPath, UnsafeFields, __SchemaInferenceFellBack };

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-D_5ST7SS.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-DzbZmcLI.mjs";
-import { t as ExternalResolver } from "../ref-DvWoULcy.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-BYk63jsC.mjs";
+import { t as ExternalResolver } from "../ref-Ckt5liZs.mjs";
 
 //#region src/core/walkBuilders.d.ts
 declare function getString(obj: Record<string, unknown>, key: string): string | undefined;

package/dist/core/walker.mjs

@@ -74,7 +74,7 @@ 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);
+	if (allOf !== void 0 && allOf.length > 0) return walkNode(mergeAllOf(allOf, ctx.diagnostics, ctx.pointer), ctx);
 	const anyOf = getArray(schema, "anyOf");
 	if (anyOf !== void 0) {
 		const nullable = normaliseAnyOf(anyOf);
@@ -86,7 +86,7 @@ function walkNode(schema, ctx) {
 	}
 	const oneOf = getArray(schema, "oneOf");
 	if (oneOf !== void 0) {
-		const discriminated = detectDiscriminated(oneOf);
+		const discriminated = detectDiscriminated(oneOf, ctx.diagnostics, ctx.pointer);
 		if (discriminated !== void 0) return walkDiscriminatedUnion(discriminated, ctx);
 		return walkUnion(oneOf, ctx);
 	}

package/dist/{diagnostics-DzbZmcLI.d.mts → diagnostics-BYk63jsC.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";
+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";
 /**
  * A single diagnostic emitted during schema processing.
  */

package/dist/html/a11y.d.mts

@@ -1,8 +1,19 @@
 import { M as WalkedField } from "../types-D_5ST7SS.mjs";
-import { t as AllConstraints } from "../renderer-B3s8o2B8.mjs";
+import { t as AllConstraints } from "../renderer-BAGoX4AK.mjs";
 import { HtmlAttributes, HtmlNode } from "./html.mjs";
 
 //#region src/html/a11y.d.ts
+/**
+ * Append a structural suffix to a parent path. Mirrors the canonical
+ * `joinPath` used by the React renderers: when the suffix is omitted
+ * (e.g. transparent wrappers like union options) the parent path is
+ * returned unchanged so the child inherits the parent's id.
+ *
+ * Suffixes are dot-joined except for bracketed array indices like `[0]`
+ * which append directly so `tags` + `[0]` becomes `tags[0]` rather than
+ * `tags.[0]`.
+ */
+declare function joinPath(parent: string, suffix: string | undefined): string;
 /**
  * Build the input ID for a field at a given path.
  */
@@ -45,4 +56,4 @@ declare function buildHintElement(inputId: string, constraints: AllConstraints):
  */
 declare function requiredIndicator(field: WalkedField): HtmlNode;
 //#endregion
-export { ariaDescribedByAttrs, ariaLabelAttrs, ariaReadonlyAttrs, ariaRequiredAttrs, buildHintElement, buildHintId, buildInputId, constraintHint, requiredIndicator };
+export { ariaDescribedByAttrs, ariaLabelAttrs, ariaReadonlyAttrs, ariaRequiredAttrs, buildHintElement, buildHintId, buildInputId, constraintHint, joinPath, requiredIndicator };

package/dist/html/a11y.mjs

@@ -1,10 +1,34 @@
 import { h } from "./html.mjs";
 //#region src/html/a11y.ts
 /**
+* Append a structural suffix to a parent path. Mirrors the canonical
+* `joinPath` used by the React renderers: when the suffix is omitted
+* (e.g. transparent wrappers like union options) the parent path is
+* returned unchanged so the child inherits the parent's id.
+*
+* Suffixes are dot-joined except for bracketed array indices like `[0]`
+* which append directly so `tags` + `[0]` becomes `tags[0]` rather than
+* `tags.[0]`.
+*/
+function joinPath(parent, suffix) {
+	if (suffix === void 0 || suffix.length === 0) return parent;
+	if (parent.length === 0) return suffix;
+	if (suffix.startsWith("[")) return `${parent}${suffix}`;
+	return `${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.
+*/
+function normaliseIdSegment(value) {
+	return value.replace(/[.[\]]+/g, "-").replace(/-+$/g, "");
+}
+/**
 * Build the input ID for a field at a given path.
 */
 function buildInputId(path, key) {
-	return `sc-${path ? `${path}-${key}` : key}`;
+	return `sc-${normaliseIdSegment(joinPath(path, key))}`;
 }
 /**
 * Derive the hint element ID from the input ID.
@@ -78,4 +102,4 @@ function requiredIndicator(field) {
 	}, " *");
 }
 //#endregion
-export { ariaDescribedByAttrs, ariaLabelAttrs, ariaReadonlyAttrs, ariaRequiredAttrs, buildHintElement, buildHintId, buildInputId, constraintHint, requiredIndicator };
+export { ariaDescribedByAttrs, ariaLabelAttrs, ariaReadonlyAttrs, ariaRequiredAttrs, buildHintElement, buildHintId, buildInputId, constraintHint, joinPath, requiredIndicator };

package/dist/html/renderToHtml.d.mts

@@ -1,5 +1,5 @@
 import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
-import { o as HtmlResolver } from "../renderer-B3s8o2B8.mjs";
+import { o as HtmlResolver } from "../renderer-BAGoX4AK.mjs";
 
 //#region src/html/renderToHtml.d.ts
 interface RenderToHtmlOptions {

package/dist/html/renderToHtml.mjs

@@ -1,7 +1,7 @@
 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
 /**
@@ -45,11 +45,12 @@ function renderToHtml(schema, options = {}) {
 	});
 	const resolver = options.resolver ?? defaultHtmlResolver;
 	const MAX_HTML_DEPTH = 10;
-	const makeRenderChild = (currentDepth) => (childTree, childValue, pathSuffix) => {
+	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>`;
-		return renderFieldHtml(childTree, childValue, resolver, pathSuffix ?? childTree.meta.description ?? "", makeRenderChild(currentDepth + 1));
+		const childPath = joinPath(parentPath, pathSuffix);
+		return renderFieldHtml(childTree, childValue, resolver, childPath, makeRenderChild(currentDepth + 1, childPath));
 	};
-	const renderChild = makeRenderChild(0);
+	const renderChild = makeRenderChild(0, "");
 	return renderFieldHtml(tree, options.value ?? tree.defaultValue, resolver, "", renderChild);
 }
 function renderFieldHtml(tree, value, resolver, path, renderChild) {
@@ -57,35 +58,19 @@ function renderFieldHtml(tree, value, resolver, path, renderChild) {
 	const effectiveValue = value ?? tree.defaultValue;
 	const mergedResolver = mergeHtmlResolvers(resolver, defaultHtmlResolver);
 	const renderFn = getHtmlRenderFn(tree.type, mergedResolver);
-	if (renderFn !== void 0) {
-		const props = {
-			value: effectiveValue,
-			readOnly: tree.editability === "presentation",
-			writeOnly: tree.editability === "input",
-			meta: tree.meta,
-			constraints: tree.constraints,
-			path,
-			tree,
-			renderChild
-		};
-		if (tree.type === "enum") props.enumValues = tree.enumValues;
-		if (tree.type === "array" && tree.element !== void 0) props.element = tree.element;
-		if (tree.type === "object") props.fields = tree.fields;
-		if (tree.type === "union" || tree.type === "discriminatedUnion") props.options = tree.options;
-		if (tree.type === "discriminatedUnion") props.discriminator = tree.discriminator;
-		if (tree.type === "record") props.keyType = tree.keyType;
-		if (tree.type === "record") props.valueType = tree.valueType;
-		if (tree.type === "tuple") props.prefixItems = tree.prefixItems;
-		if (tree.type === "conditional") props.ifClause = tree.ifClause;
-		if (tree.type === "conditional" && tree.thenClause !== void 0) props.thenClause = tree.thenClause;
-		if (tree.type === "conditional" && tree.elseClause !== void 0) props.elseClause = tree.elseClause;
-		if (tree.type === "negation") props.negated = tree.negated;
-		if (tree.type === "literal") props.literalValues = tree.literalValues;
-		if (tree.examples !== void 0) props.examples = tree.examples;
-		return renderFn(props);
-	}
-	if (effectiveValue === void 0 || effectiveValue === null) return serialize(h("span", { class: "sc-value sc-value--empty" }, "—"));
-	return serialize(h("span", { class: "sc-value" }, typeof effectiveValue === "string" ? effectiveValue : JSON.stringify(effectiveValue)));
+	if (renderFn === void 0) throw new Error(`renderToHtml: no HTML renderer registered for type "${tree.type}"`);
+	const props = {
+		value: effectiveValue,
+		readOnly: tree.editability === "presentation",
+		writeOnly: tree.editability === "input",
+		meta: tree.meta,
+		constraints: tree.constraints,
+		path,
+		tree,
+		renderChild
+	};
+	if (tree.examples !== void 0) props.examples = tree.examples;
+	return renderFn(props);
 }
 //#endregion
 export { renderToHtml };

package/dist/html/renderToHtmlStream.d.mts

@@ -1,5 +1,5 @@
 import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
-import { o as HtmlResolver } from "../renderer-B3s8o2B8.mjs";
+import { o as HtmlResolver } from "../renderer-BAGoX4AK.mjs";
 
 //#region src/html/renderToHtmlStream.d.ts
 interface StreamRenderOptions {

package/dist/html/renderers.d.mts

@@ -1,11 +1,12 @@
 import { M as WalkedField } from "../types-D_5ST7SS.mjs";
-import { o as HtmlResolver } from "../renderer-B3s8o2B8.mjs";
+import { o as HtmlResolver } from "../renderer-BAGoX4AK.mjs";
 
 //#region src/html/renderers.d.ts
 declare function dateInputType(format: string | undefined): string | undefined;
 /**
- * Normalise a dot-separated path into a valid, `sc-` prefixed HTML ID.
- * Dots in paths (from nested objects) become hyphens.
+ * Normalise a structural path into a valid, `sc-` prefixed HTML ID.
+ * Dots (object nesting) and brackets (array indices) become hyphens so
+ * the id remains a valid CSS selector and predictable in test queries.
  */
 declare function fieldId(path: string): string;
 declare function matchUnionOption(options: WalkedField[], value: unknown): WalkedField | undefined;