schema-components 1.21.0 → 1.23.0

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-BnxPEElk.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-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/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/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-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-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 { 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-BnxPEElk.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-CbBPsxSt.mjs";
-import { t as ExternalResolver } from "../ref-si8ViYun.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-BS2kaUyE.mjs";
+import { t as ExternalResolver } from "../ref-DjLEKa_E.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 { M as WalkedField } from "../types-BnxPEElk.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

@@ -2,9 +2,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 { 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+).
@@ -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);
@@ -76,8 +126,10 @@ function walk(schema, options = {}) {
 function walkNode(schema, ctx) {
 	const allOf = getArray(schema, "allOf");
 	if (allOf !== void 0 && allOf.length > 0) {
-		const merged = mergeAllOf(allOf, ctx.diagnostics, ctx.pointer);
+		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");
@@ -156,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) {
@@ -227,11 +271,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) {
@@ -241,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) {
@@ -386,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 } : {}
 		};
 	}
@@ -423,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-CbBPsxSt.d.mts → diagnostics-BS2kaUyE.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 = "allof-conflict" | "assumed-draft" | "bare-exclusive-bound" | "conditional-fallback" | "cross-schema-relative-ref-unsupported" | "cyclic-path-item-ref" | "dependencies-conflict" | "dependent-required-invalid" | "depth-exceeded" | "discriminator-inconsistent" | "divisible-by-conflict" | "doc-not-object" | "dropped-swagger-feature" | "duplicate-body-parameter" | "duplicate-operation-id" | "dynamic-ref-degraded" | "enum-value-filtered" | "external-ref" | "invalid-const" | "invalid-id-fragment" | "keyword-out-of-draft" | "legacy-dependencies-split" | "legacy-dependencies-split-2019" | "non-json-media-type-fallback" | "parameter-missing-schema" | "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-QEwOtQAA.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.
@@ -32,7 +22,7 @@ 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" | "zod-conversion-bug" | "zod-cycle-detected" | "zod-duplicate-id" | "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.
@@ -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 { M as WalkedField } from "../types-BnxPEElk.mjs";
-import { t as AllConstraints } from "../renderer-DI6ZYf7a.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;
 /**