schema-components 1.22.0 → 1.24.0

package/dist/core/types.d.mts

@@ -1,2 +1,2 @@
-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";
+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-BTB73MB8.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/unionMatch.d.mts

@@ -0,0 +1,36 @@
+import { j as WalkedField } from "../types-BTB73MB8.mjs";
+
+//#region src/core/unionMatch.d.ts
+/**
+ * Pick the union option that structurally matches the supplied value.
+ *
+ * Heuristic only — picks by JavaScript typeof / array / object class. Returns
+ * `undefined` when the value's shape doesn't correspond to any option (for
+ * example a `null` value against a non-nullable union). Callers should
+ * fall back to the first option or render an empty state in that case.
+ */
+declare function matchUnionOption(options: readonly WalkedField[], value: unknown): WalkedField | undefined;
+/**
+ * Resolution of a discriminated union against a concrete value. The renderer
+ * uses `optionLabels` to title each tab, `activeIndex` to select the open
+ * tab, and `activeOption` as the field to render below.
+ */
+interface DiscriminatedActive {
+  readonly optionLabels: readonly string[];
+  readonly activeIndex: number;
+  readonly activeOption: WalkedField | undefined;
+}
+/**
+ * Derive labels, active index, and active option for a discriminated union.
+ *
+ * For each option, the label is the discriminator property's `const` value
+ * (when the option is an object with a literal discriminator) or, failing
+ * that, the option's `meta.title` or its `type`. The active index is chosen
+ * from the discriminator's value on `valueObject`; missing or non-matching
+ * values fall back to index 0.
+ *
+ * Pure data transformation — no rendering concerns, no React imports.
+ */
+declare function resolveDiscriminatedActive(options: readonly WalkedField[], discriminator: string, valueObject: Record<string, unknown> | undefined): DiscriminatedActive;
+//#endregion
+export { DiscriminatedActive, matchUnionOption, resolveDiscriminatedActive };

package/dist/core/unionMatch.mjs

@@ -0,0 +1,53 @@
+//#region src/core/unionMatch.ts
+/**
+* Pick the union option that structurally matches the supplied value.
+*
+* Heuristic only — picks by JavaScript typeof / array / object class. Returns
+* `undefined` when the value's shape doesn't correspond to any option (for
+* example a `null` value against a non-nullable union). Callers should
+* fall back to the first option or render an empty state in that case.
+*/
+function matchUnionOption(options, value) {
+	if (typeof value === "string") return options.find((o) => o.type === "string" || o.type === "enum");
+	if (typeof value === "number") return options.find((o) => o.type === "number");
+	if (typeof value === "boolean") return options.find((o) => o.type === "boolean");
+	if (Array.isArray(value)) return options.find((o) => o.type === "array");
+	if (typeof value === "object" && value !== null) return options.find((o) => o.type === "object");
+}
+/**
+* Derive labels, active index, and active option for a discriminated union.
+*
+* For each option, the label is the discriminator property's `const` value
+* (when the option is an object with a literal discriminator) or, failing
+* that, the option's `meta.title` or its `type`. The active index is chosen
+* from the discriminator's value on `valueObject`; missing or non-matching
+* values fall back to index 0.
+*
+* Pure data transformation — no rendering concerns, no React imports.
+*/
+function resolveDiscriminatedActive(options, discriminator, valueObject) {
+	const currentDiscriminatorValue = valueObject !== void 0 && typeof valueObject[discriminator] === "string" ? valueObject[discriminator] : void 0;
+	const optionLabels = options.map((opt) => {
+		if (opt.type === "object") {
+			const discriminatorField = opt.fields[discriminator];
+			if (discriminatorField?.type === "literal") {
+				const constVal = discriminatorField.literalValues[0];
+				if (typeof constVal === "string") return constVal;
+			}
+		}
+		if (typeof opt.meta.title === "string") return opt.meta.title;
+		return opt.type;
+	});
+	let activeIndex = 0;
+	if (currentDiscriminatorValue !== void 0) {
+		const found = optionLabels.indexOf(currentDiscriminatorValue);
+		if (found !== -1) activeIndex = found;
+	}
+	return {
+		optionLabels,
+		activeIndex,
+		activeOption: options[activeIndex]
+	};
+}
+//#endregion
+export { matchUnionOption, resolveDiscriminatedActive };

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-D2jfdX6E.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-BFTVLsdb.mjs";
 export { InferredDraft, JsonSchemaDialectInfo, JsonSchemaDraft, OpenApiVersionInfo, detectJsonSchemaDraft, detectOpenApiVersion, inferJsonSchemaDraft, inferJsonSchemaDraftWithReason, isOpenApi30, isOpenApi31, isSwagger2, matchJsonSchemaDraftUri, readJsonSchemaDialect };

package/dist/core/version.mjs

@@ -116,27 +116,39 @@ function inferJsonSchemaDraftWithReason(schema) {
 }
 /**
 * Detect the OpenAPI/Swagger version from a document.
-* Returns `undefined` for documents that are not OpenAPI or Swagger.
+*
+* Returns `undefined` when the document declares neither `swagger` nor
+* `openapi` strings, or when the declared version string is malformed
+* (missing parts or non-numeric segments). `Number("abc")` yields `NaN`,
+* which `parts[i] ?? default` does NOT replace — nullish coalescing only
+* substitutes `null`/`undefined` — so any unparseable segment surfaces
+* as `undefined` rather than a silent fabricated default.
 */
 function detectOpenApiVersion(doc) {
 	const swagger = doc.swagger;
-	if (typeof swagger === "string") {
-		const parts = swagger.split(".").map(Number);
-		return {
-			major: parts[0] ?? 2,
-			minor: parts[1] ?? 0,
-			patch: parts[2] ?? 0
-		};
-	}
+	if (typeof swagger === "string") return parseVersionString(swagger);
 	const openapi = doc.openapi;
-	if (typeof openapi === "string") {
-		const parts = openapi.split(".").map(Number);
-		return {
-			major: parts[0] ?? 3,
-			minor: parts[1] ?? 0,
-			patch: parts[2] ?? 0
-		};
-	}
+	if (typeof openapi === "string") return parseVersionString(openapi);
+}
+/**
+* Parse a dotted version string into `{ major, minor, patch }`.
+*
+* Returns `undefined` when any required segment is missing or fails to
+* parse as a finite number. A two-segment string ("3.1") fills `patch`
+* with `0` because the spec treats the patch as optional, but a missing
+* `major` or `minor` is a malformed declaration and yields `undefined`.
+*/
+function parseVersionString(version) {
+	const parts = version.split(".").map(Number);
+	const major = parts[0];
+	const minor = parts[1];
+	const patch = parts[2] ?? 0;
+	if (major === void 0 || minor === void 0 || !Number.isFinite(major) || !Number.isFinite(minor) || !Number.isFinite(patch)) return;
+	return {
+		major,
+		minor,
+		patch
+	};
 }
 /**
 * Check if an OpenAPI version is 3.0.x (uses modified Draft 04 schemas

package/dist/core/walkBuilders.d.mts

@@ -1,6 +1,6 @@
-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";
+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-BTB73MB8.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
+import { t as ExternalResolver } from "../ref-DCDuswPe.mjs";
 
 //#region src/core/walkBuilders.d.ts
 declare function getString(obj: Record<string, unknown>, key: string): string | undefined;
@@ -70,5 +70,24 @@ declare function walkDependentRequiredMap(map: Record<string, unknown>): Record<
  */
 declare function withoutKeys(schema: Record<string, unknown>, keys: string[]): Record<string, unknown>;
 declare function isPrimitive(value: unknown): value is string | number | boolean | null;
+/**
+ * Convert any JSON-shaped value to a display string suitable for
+ * form input attributes or text rendering.
+ *
+ * Centralises the conversion logic because `EnumField.enumValues` and
+ * `LiteralField.literalValues` are typed as `unknown[]` (Draft 2020-12
+ * permits any JSON value in `enum` / `const`). Renderers call this
+ * helper instead of inlining their own narrowing — the alternative
+ * `String(v)` on `unknown` trips `@typescript-eslint/no-base-to-string`.
+ *
+ * Inputs originate from parsed JSON (or runtime JSON-equivalents) so
+ * they are always `null | boolean | number | string | object | array`.
+ * Objects and arrays serialise via `JSON.stringify` so a discriminated
+ * union with object const values still produces a stable display key.
+ *
+ * Throws on non-JSON-shaped values (function, symbol, bigint, undefined)
+ * — their presence indicates the producer violated the JSON contract.
+ */
+declare function displayJsonValue(value: unknown): string;
 //#endregion
-export { WalkContext, WalkOptions, buildBase, buildBooleanField, buildFileField, buildNullField, buildNumberField, buildStringField, buildUnknownField, extractChildOverride, extractMetaFromJson, extractSchemaMetaFields, getArray, getObject, getString, isPrimitive, walkDependentRequiredMap, walkSubSchemaMap, withoutKeys };
+export { WalkContext, WalkOptions, buildBase, buildBooleanField, buildFileField, buildNullField, buildNumberField, buildStringField, buildUnknownField, displayJsonValue, extractChildOverride, extractMetaFromJson, extractSchemaMetaFields, getArray, getObject, getString, isPrimitive, walkDependentRequiredMap, walkSubSchemaMap, withoutKeys };

package/dist/core/walkBuilders.mjs

@@ -68,13 +68,8 @@ function buildBase(schema, ctx) {
 	const defaultValue = "default" in schema ? schema.default : void 0;
 	const examplesRaw = schema.examples;
 	const examples = Array.isArray(examplesRaw) ? examplesRaw : void 0;
-	const editability = resolveEditability(mergedMeta, ctx.componentMeta, ctx.rootMeta);
-	if ((overrideMeta !== void 0 && ("readOnly" in overrideMeta || "writeOnly" in overrideMeta) || Boolean(propertyMeta.readOnly) || Boolean(propertyMeta.writeOnly)) && ctx.componentMeta !== void 0) ctx = {
-		...ctx,
-		componentMeta: void 0
-	};
 	return {
-		editability,
+		editability: resolveEditability(mergedMeta, ctx.componentMeta, ctx.rootMeta),
 		meta: mergedMeta,
 		isOptional: ctx.isOptional,
 		isNullable: ctx.isNullable,
@@ -156,5 +151,30 @@ function withoutKeys(schema, keys) {
 function isPrimitive(value) {
 	return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null;
 }
+/**
+* Convert any JSON-shaped value to a display string suitable for
+* form input attributes or text rendering.
+*
+* Centralises the conversion logic because `EnumField.enumValues` and
+* `LiteralField.literalValues` are typed as `unknown[]` (Draft 2020-12
+* permits any JSON value in `enum` / `const`). Renderers call this
+* helper instead of inlining their own narrowing — the alternative
+* `String(v)` on `unknown` trips `@typescript-eslint/no-base-to-string`.
+*
+* Inputs originate from parsed JSON (or runtime JSON-equivalents) so
+* they are always `null | boolean | number | string | object | array`.
+* Objects and arrays serialise via `JSON.stringify` so a discriminated
+* union with object const values still produces a stable display key.
+*
+* Throws on non-JSON-shaped values (function, symbol, bigint, undefined)
+* — their presence indicates the producer violated the JSON contract.
+*/
+function displayJsonValue(value) {
+	if (value === null) return "null";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (typeof value === "object") return JSON.stringify(value);
+	throw new TypeError(`displayJsonValue: value of type ${typeof value} is not a JSON-shaped value`);
+}
 //#endregion
-export { buildBase, buildBooleanField, buildFileField, buildNullField, buildNumberField, buildStringField, buildUnknownField, extractChildOverride, extractMetaFromJson, extractSchemaMetaFields, getArray, getObject, getString, isPrimitive, walkDependentRequiredMap, walkSubSchemaMap, withoutKeys };
+export { buildBase, buildBooleanField, buildFileField, buildNullField, buildNumberField, buildStringField, buildUnknownField, displayJsonValue, extractChildOverride, extractMetaFromJson, extractSchemaMetaFields, getArray, getObject, getString, isPrimitive, walkDependentRequiredMap, walkSubSchemaMap, withoutKeys };

package/dist/core/walker.d.mts

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

package/dist/core/walker.mjs

@@ -5,7 +5,7 @@ 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 { buildBase, buildBooleanField, buildFileField, buildNullField, buildNumberField, buildStringField, buildUnknownField, extractChildOverride, extractSchemaMetaFields, getArray, getObject, getString, isPrimitive, walkDependentRequiredMap, walkSubSchemaMap, withoutKeys } from "./walkBuilders.mjs";
+import { buildBase, buildBooleanField, buildFileField, buildNullField, buildNumberField, buildStringField, buildUnknownField, extractChildOverride, extractSchemaMetaFields, getArray, getObject, getString, walkDependentRequiredMap, walkSubSchemaMap, withoutKeys } from "./walkBuilders.mjs";
 //#region src/core/walker.ts
 /**
 * Handle JSON Schema boolean values (Draft 06+).
@@ -208,15 +208,7 @@ function walkNode(schema, ctx) {
 	}
 	const enumValues = getArray(schema, "enum");
 	if (enumValues !== void 0) return walkEnum(schema, enumValues, ctx);
-	if ("const" in schema) {
-		if (!isPrimitive(schema.const)) emitDiagnostic(ctx.diagnostics, {
-			code: "invalid-const",
-			message: `const value is not a primitive: ${typeof schema.const}`,
-			pointer: ctx.pointer,
-			detail: { constValue: schema.const }
-		});
-		return walkLiteral(schema, ctx);
-	}
+	if ("const" in schema) return walkLiteral(schema, ctx);
 	const type = getString(schema, "type");
 	const typeArray = getArray(schema, "type");
 	if (type === void 0 && typeArray !== void 0) {
@@ -318,38 +310,19 @@ function walkBoolean(schema, ctx) {
 	return buildBooleanField(schema, ctx);
 }
 function walkEnum(schema, enumValues, ctx) {
-	const accepted = [];
-	for (let i = 0; i < enumValues.length; i++) {
-		const v = enumValues[i];
-		if (isPrimitive(v)) {
-			accepted.push(v);
-			continue;
-		}
-		emitDiagnostic(ctx.diagnostics, {
-			code: "enum-value-filtered",
-			message: `enum value at index ${String(i)} is not a primitive (${v === void 0 ? "undefined" : typeof v}); dropping the entry`,
-			pointer: appendPointer(ctx.pointer, `enum/${String(i)}`),
-			detail: {
-				index: i,
-				value: v
-			}
-		});
-	}
 	return {
 		...buildBase(schema, ctx),
 		type: "enum",
 		constraints: {},
-		enumValues: accepted
+		enumValues: [...enumValues]
 	};
 }
 function walkLiteral(schema, ctx) {
-	const constValue = schema.const;
-	const values = isPrimitive(constValue) ? [constValue] : [];
 	return {
 		...buildBase(schema, ctx),
 		type: "literal",
 		constraints: {},
-		literalValues: values
+		literalValues: [schema.const]
 	};
 }
 function walkObject(schema, properties, ctx) {
@@ -463,36 +436,61 @@ function walkRecord(schema, valueSchema, ctx) {
 		valueType
 	};
 }
+/**
+* Resolve the `unevaluatedItems` keyword into the structural shape the
+* field consumes. Returns the walked schema (object form), the
+* `unevaluatedItemsClosed` flag (`false` form), or both undefined
+* (absent or `true` — `true` permits everything and so has no
+* structural consequence beyond the absence of a constraint).
+*
+* Mirrors the equivalent dispatch in `walkObject` for
+* `unevaluatedProperties` — the parallel keeps the array/tuple and
+* object branches symmetrical.
+*/
+function resolveUnevaluatedItems(schema, ctx) {
+	if (!("unevaluatedItems" in schema)) return {};
+	const value = schema.unevaluatedItems;
+	if (value === false) return { unevaluatedItemsClosed: true };
+	if (value === true) return { unevaluatedItems: {
+		type: "unknown",
+		editability: "editable",
+		meta: {},
+		constraints: {}
+	} };
+	if (isObject(value)) return { unevaluatedItems: walkNode(value, ctx) };
+	return {};
+}
 function walkArray(schema, ctx) {
 	const walkedContains = "contains" in schema ? walkSubSchema(schema.contains, ctx) : void 0;
+	const unevaluatedInfo = resolveUnevaluatedItems(schema, ctx);
 	const prefixItems = getArray(schema, "prefixItems");
 	if (prefixItems !== void 0) {
-		const walkedItems = prefixItems.filter(isObject).map((item) => walkNode(item, ctx));
-		const restSchema = getObject(schema, "items");
-		const restItems = restSchema !== void 0 ? walkNode(restSchema, ctx) : void 0;
+		const walkedItems = prefixItems.map((item) => walkSubSchema(item, ctx));
+		const restItems = "items" in schema ? walkSubSchema(schema.items, ctx) : void 0;
 		return {
 			...buildBase(schema, ctx),
 			type: "tuple",
 			constraints: extractArrayConstraints(schema),
 			prefixItems: walkedItems,
 			...restItems !== void 0 ? { restItems } : {},
-			...walkedContains !== void 0 ? { contains: walkedContains } : {}
+			...walkedContains !== void 0 ? { contains: walkedContains } : {},
+			...unevaluatedInfo.unevaluatedItems !== void 0 ? { unevaluatedItems: unevaluatedInfo.unevaluatedItems } : {},
+			...unevaluatedInfo.unevaluatedItemsClosed === true ? { unevaluatedItemsClosed: true } : {}
 		};
 	}
-	const unevaluatedItemsSchema = getObject(schema, "unevaluatedItems");
-	const walkedUnevaluatedItems = unevaluatedItemsSchema !== void 0 ? walkNode(unevaluatedItemsSchema, ctx) : void 0;
-	const items = getObject(schema, "items");
-	if (items !== void 0) {
+	if ("items" in schema) {
 		const elementOverride = extractChildOverride(ctx.fieldOverrides, "[]");
+		const elementCtx = {
+			...ctx,
+			fieldOverrides: elementOverride
+		};
 		return {
 			...buildBase(schema, ctx),
 			type: "array",
 			constraints: extractArrayConstraints(schema),
-			element: walkNode(items, {
-				...ctx,
-				fieldOverrides: elementOverride
-			}),
-			...walkedUnevaluatedItems !== void 0 ? { unevaluatedItems: walkedUnevaluatedItems } : {},
+			element: walkSubSchema(schema.items, elementCtx),
+			...unevaluatedInfo.unevaluatedItems !== void 0 ? { unevaluatedItems: unevaluatedInfo.unevaluatedItems } : {},
+			...unevaluatedInfo.unevaluatedItemsClosed === true ? { unevaluatedItemsClosed: true } : {},
 			...walkedContains !== void 0 ? { contains: walkedContains } : {}
 		};
 	}
@@ -500,7 +498,8 @@ function walkArray(schema, ctx) {
 		...buildBase(schema, ctx),
 		type: "array",
 		constraints: extractArrayConstraints(schema),
-		...walkedUnevaluatedItems !== void 0 ? { unevaluatedItems: walkedUnevaluatedItems } : {},
+		...unevaluatedInfo.unevaluatedItems !== void 0 ? { unevaluatedItems: unevaluatedInfo.unevaluatedItems } : {},
+		...unevaluatedInfo.unevaluatedItemsClosed === true ? { unevaluatedItemsClosed: true } : {},
 		...walkedContains !== void 0 ? { contains: walkedContains } : {}
 	};
 }

package/dist/{diagnostics-D0QCYGv0.d.mts → diagnostics-Cbwak-ZX.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" | "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";
+type DiagnosticCode = "allof-conflict" | "assumed-draft" | "bare-exclusive-bound" | "conditional-fallback" | "cross-schema-relative-ref-unsupported" | "cyclic-header-ref" | "cyclic-link-ref" | "cyclic-parameter-ref" | "cyclic-path-item-ref" | "dependencies-conflict" | "dependent-required-invalid" | "depth-exceeded" | "discriminator-inconsistent" | "divisible-by-conflict" | "doc-not-object" | "dropped-swagger-feature" | "header-ref-too-deep" | "duplicate-body-parameter" | "duplicate-operation-id" | "dynamic-ref-degraded" | "enum-value-filtered" | "external-ref" | "invalid-const" | "invalid-id-fragment" | "keyword-out-of-draft" | "link-ref-too-deep" | "legacy-dependencies-split" | "legacy-dependencies-split-2019" | "non-json-media-type-fallback" | "parameter-missing-schema" | "parameter-ref-too-deep" | "path-item-ref-too-deep" | "path-webhook-name-collision" | "pattern-invalid" | "prototype-polluting-property" | "recursive-anchor-collision" | "relative-ref-resolved" | "required-non-string" | "schema-allof-incompatible" | "swagger-collection-format-dropped" | "swagger-cyclic-parameter-ref" | "swagger-invalid-file-parameter" | "swagger-malformed-oauth-flow" | "swagger-missing-consumes" | "swagger-missing-host" | "type-mismatch" | "type-negation-fallback" | "unknown-format" | "unknown-json-schema-dialect" | "unknown-keyword" | "unknown-openapi-version" | "unknown-parameter-location" | "unknown-security-scheme-type" | "unresolved-ref" | "unsupported-type" | "zod-codec-nested-output-only" | "zod-codec-output-only" | "zod-preprocess-output-only" | "zod-promise-nested-unwrap";
 /**
  * A single diagnostic emitted during schema processing.
  */

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

@@ -1,16 +1,6 @@
+import { T as SchemaType } from "./types-BTB73MB8.mjs";
+
 //#region src/core/errors.d.ts
-/**
- * Structured error types for schema-components.
- *
- * Every error produced by the library is one of these three types:
- *
- * - SchemaNormalisationError — the adapter failed to convert the input
- *   to JSON Schema (invalid Zod, bad OpenAPI ref, malformed schema)
- * - SchemaRenderError — a theme adapter's render function threw
- * - SchemaFieldError — a field path couldn't be resolved
- *
- * All extend `SchemaError` so consumers can catch the base class.
- */
 /**
  * Base class for all schema-components errors.
  * Catch this to handle any library error uniformly.
@@ -46,9 +36,13 @@ declare class SchemaNormalisationError extends SchemaError {
  * The `cause` is the original error from the render function.
  */
 declare class SchemaRenderError extends SchemaError {
-  /** The schema type being rendered when the error occurred. */
-  readonly schemaType: string;
-  constructor(message: string, schema: unknown, schemaType: string, cause: unknown);
+  /**
+   * The schema type being rendered when the error occurred. Drawn from
+   * the walker's discriminant union so consumers can switch on it
+   * exhaustively without a wider `string` fallback.
+   */
+  readonly schemaType: SchemaType;
+  constructor(message: string, schema: unknown, schemaType: SchemaType, cause: unknown);
 }
 /**
  * A field path couldn't be resolved against the walked schema tree.

package/dist/html/a11y.d.mts

@@ -1,5 +1,5 @@
-import { j as WalkedField } from "../types-BrRMV0en.mjs";
-import { t as AllConstraints } from "../renderer-BaRlQIuN.mjs";
+import { j as WalkedField } from "../types-BTB73MB8.mjs";
+import { t as AllConstraints } from "../renderer-CXJ8y0qw.mjs";
 import { HtmlAttributes, HtmlNode } from "./html.mjs";
 
 //#region src/html/a11y.d.ts
@@ -15,11 +15,16 @@ import { HtmlAttributes, HtmlNode } from "./html.mjs";
  */
 declare function joinPath(parent: string, suffix: string | undefined): string;
 /**
- * Build the input ID for a field at a given path.
+ * Build the input ID for a field at a given path. Joins `path` and `key`
+ * via `joinPath` then delegates to the canonical `fieldDomId` helper from
+ * `core/idPath.ts` so every render pipeline emits identical ids for the
+ * same structural position.
  */
 declare function buildInputId(path: string, key: string): string;
 /**
- * Derive the hint element ID from the input ID.
+ * Derive the hint element ID from the input ID. Thin re-export of the
+ * canonical helper so this module remains the one-stop a11y surface for
+ * the HTML renderers.
  */
 declare function buildHintId(inputId: string): string;
 /**

package/dist/html/a11y.mjs

@@ -1,3 +1,4 @@
+import { fieldDomId, hintIdFor } from "../core/idPath.mjs";
 import { h } from "./html.mjs";
 //#region src/html/a11y.ts
 /**
@@ -17,31 +18,21 @@ function joinPath(parent, suffix) {
 	return `${parent}.${suffix}`;
 }
 /**
-* Normalise a path into the id segment used after the `sc-` prefix.
-*
-* 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(/[^A-Za-z0-9_-]+/g, "-").replace(/-+$/g, "");
-}
-/**
-* Build the input ID for a field at a given path.
+* Build the input ID for a field at a given path. Joins `path` and `key`
+* via `joinPath` then delegates to the canonical `fieldDomId` helper from
+* `core/idPath.ts` so every render pipeline emits identical ids for the
+* same structural position.
 */
 function buildInputId(path, key) {
-	return `sc-${normaliseIdSegment(joinPath(path, key))}`;
+	return fieldDomId(joinPath(path, key));
 }
 /**
-* Derive the hint element ID from the input ID.
+* Derive the hint element ID from the input ID. Thin re-export of the
+* canonical helper so this module remains the one-stop a11y surface for
+* the HTML renderers.
 */
 function buildHintId(inputId) {
-	return `${inputId}-hint`;
+	return hintIdFor(inputId);
 }
 /**
 * Build a human-readable constraint description string.

package/dist/html/renderToHtml.d.mts

@@ -1,5 +1,5 @@
-import { w as SchemaMeta } from "../types-BrRMV0en.mjs";
-import { o as HtmlResolver } from "../renderer-BaRlQIuN.mjs";
+import { w as SchemaMeta } from "../types-BTB73MB8.mjs";
+import { o as HtmlResolver } from "../renderer-CXJ8y0qw.mjs";
 
 //#region src/html/renderToHtml.d.ts
 /**

package/dist/html/renderToHtmlStream.d.mts

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

package/dist/html/renderToHtmlStream.mjs

@@ -69,8 +69,19 @@ function prepareTree(schema, options) {
 		resolver: options.resolver ?? defaultHtmlResolver
 	};
 }
+/**
+* Cooperative scheduler yield used between async chunks. Resolves on the
+* next microtask so the event loop can process queued I/O and timers
+* without the four-millisecond clamp browsers apply to nested
+* `setTimeout(..., 0)` calls. The cumulative cost of `setTimeout`-based
+* yielding on a deep schema is measurable; the microtask form is free.
+*/
 function schedulerYield() {
-	return new Promise((resolve) => setTimeout(resolve, 0));
+	return new Promise((resolve) => {
+		queueMicrotask(() => {
+			resolve(void 0);
+		});
+	});
 }
 //#endregion
 export { renderToHtmlChunks, renderToHtmlReadable, renderToHtmlStream };

package/dist/html/renderers.d.mts

@@ -1,15 +1,39 @@
-import { j as WalkedField } from "../types-BrRMV0en.mjs";
-import { o as HtmlResolver } from "../renderer-BaRlQIuN.mjs";
+import { dateInputType } from "../core/formats.mjs";
+import { o as HtmlResolver } from "../renderer-CXJ8y0qw.mjs";
+import { matchUnionOption } from "../core/unionMatch.mjs";
 
 //#region src/html/renderers.d.ts
-declare function dateInputType(format: string | undefined): string | undefined;
 /**
- * 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.
+ * Thin wrapper over `fieldDomId` from `core/idPath.ts`. Every render
+ * pipeline must derive ids from the same canonical normaliser so that
+ * `aria-controls`, `aria-labelledby`, and `htmlFor` references resolve
+ * consistently across the React, sync-HTML, and streaming-HTML outputs.
+ *
+ * The wrapper tolerates an empty path here (returning `sc-`) so that
+ * a leaf renderer at the schema root — `renderToHtml(z.string())` — has
+ * a usable id without throwing. Container renderers always thread a
+ * non-empty path through `renderChild`, so the empty-id fallback can
+ * never produce sibling collisions inside a structured form.
  */
 declare function fieldId(path: string): string;
-declare function matchUnionOption(options: WalkedField[], value: unknown): WalkedField | undefined;
+/**
+ * Tab-panel id for a discriminated union at `path`. Delegates to the
+ * canonical `panelIdFor` from `core/idPath.ts` for the normal case so
+ * the sync, streaming, and React renderers all emit identical ids; falls
+ * back to a structurally-equivalent string when the renderer is invoked
+ * with an empty root path (a discriminated union at the schema root —
+ * see the `fieldId` doc comment for the wider context).
+ *
+ * Exported because `streamRenderers.ts` needs to derive identical ids
+ * — the panel id on the `<div role="tabpanel">` must match the
+ * `aria-controls` on every tab regardless of which pipeline rendered it.
+ */
+declare function panelId(path: string): string;
+/**
+ * Tab id for tab `i` within a discriminated union at `path`. Mirror of
+ * `panelId` above — see its comment.
+ */
+declare function tabId(path: string, i: number): string;
 declare const defaultHtmlResolver: HtmlResolver;
 //#endregion
-export { dateInputType, defaultHtmlResolver, fieldId, matchUnionOption };
+export { dateInputType, defaultHtmlResolver, fieldId, matchUnionOption, panelId, tabId };