schema-components 1.17.0 → 1.18.0

package/dist/openapi/bundle.mjs

@@ -29,28 +29,38 @@ import { isObject } from "../core/guards.mjs";
 *
 * Walks every $ref in the document. For external refs (not starting with `#`),
 * calls the resolver to fetch the external document, extracts the referenced
-* schema, inlines it into `components.schemas` with a synthesised name, and
-* rewrites the $ref to point to the inlined copy.
+* schema, inlines it into `components.schemas` under a synthesised name, and
+* rewrites the original $ref to point at the new internal location
+* (`#/components/schemas/<name>`).
+*
+* Identical external refs share a single entry — the second occurrence of
+* the same `(uri, fragment)` pair reuses the name produced for the first.
+* Name collisions between different refs are resolved by suffixing a counter.
 *
 * The resolver is called once per unique URI and the result is cached.
 *
-* Returns a deep-cloned document with all external refs resolved.
-* The original document is never mutated.
+* Returns a deep-cloned document with all external refs replaced by internal
+* refs. The original document is never mutated.
 */
 async function bundleOpenApiDoc(doc, resolver) {
 	const result = structuredClone(doc);
 	const uriCache = /* @__PURE__ */ new Map();
+	const inlineCache = /* @__PURE__ */ new Map();
 	if (!isObject(result.components)) result.components = {};
-	if (!isObject(result.components)) result.components = {};
-	if (isObject(result.components) && !isObject(result.components.schemas)) result.components.schemas = {};
-	await walkAndInline(result, uriCache, resolver);
+	const components = result.components;
+	if (!isObject(components)) throw new Error("bundleOpenApiDoc: components is not an object");
+	if (!isObject(components.schemas)) components.schemas = {};
+	const schemasNode = components.schemas;
+	if (!isObject(schemasNode)) throw new Error("bundleOpenApiDoc: components.schemas is not an object");
+	await walkAndInline(result, schemasNode, uriCache, inlineCache, resolver);
 	return result;
 }
 /**
 * Walk a document tree, find external $ref strings, resolve them,
-* inline the targets, and rewrite the refs.
+* inline the targets into `components.schemas`, and rewrite each $ref
+* to point at the new internal location.
 */
-async function walkAndInline(node, uriCache, resolver) {
+async function walkAndInline(node, schemasNode, uriCache, inlineCache, resolver) {
 	if (!isObject(node)) return;
 	if (typeof node.$ref === "string" && !node.$ref.startsWith("#")) {
 		const ref = node.$ref;
@@ -66,15 +76,21 @@ async function walkAndInline(node, uriCache, resolver) {
 			}
 		}
 		if (externalDoc !== void 0) {
-			const target = resolveFragment(externalDoc, fragment);
-			if (isObject(target)) {
-				delete node.$ref;
-				for (const [key, value] of Object.entries(target)) node[key] = value;
+			const cacheKey = `${uri}${fragment}`;
+			let inlinedName = inlineCache.get(cacheKey);
+			if (inlinedName === void 0) {
+				const target = resolveFragment(externalDoc, fragment);
+				if (isObject(target)) {
+					inlinedName = registerInline(schemasNode, uri, fragment, target);
+					inlineCache.set(cacheKey, inlinedName);
+					await walkAndInline(schemasNode[inlinedName], schemasNode, uriCache, inlineCache, resolver);
+				}
 			}
+			if (inlinedName !== void 0) node.$ref = `#/components/schemas/${inlinedName}`;
 		}
 	}
-	for (const value of Object.values(node)) if (isObject(value)) await walkAndInline(value, uriCache, resolver);
-	else if (Array.isArray(value)) for (const item of value) await walkAndInline(item, uriCache, resolver);
+	for (const value of Object.values(node)) if (isObject(value)) await walkAndInline(value, schemasNode, uriCache, inlineCache, resolver);
+	else if (Array.isArray(value)) for (const item of value) await walkAndInline(item, schemasNode, uriCache, inlineCache, resolver);
 }
 /**
 * Resolve a JSON Pointer fragment within a document.
@@ -91,5 +107,47 @@ function resolveFragment(doc, fragment) {
 	}
 	return isObject(current) ? current : void 0;
 }
+/**
+* Derive a candidate identifier for an inlined external schema. Prefers
+* the last meaningful segment of the JSON Pointer fragment; falls back
+* to the URI's filename (sans extension), then to a generic prefix.
+*/
+function deriveCandidateName(uri, fragment) {
+	if (fragment.startsWith("#/")) {
+		const last = fragment.slice(2).split("/").at(-1);
+		if (last !== void 0 && last.length > 0) return sanitiseName(last);
+	}
+	const pathOnly = uri.split(/[?#]/)[0] ?? uri;
+	const lastSlash = pathOnly.lastIndexOf("/");
+	const filename = lastSlash >= 0 ? pathOnly.slice(lastSlash + 1) : pathOnly;
+	const dot = filename.lastIndexOf(".");
+	const stem = dot > 0 ? filename.slice(0, dot) : filename;
+	if (stem.length > 0) return sanitiseName(stem);
+	return "ExternalSchema";
+}
+/**
+* Sanitise a string into a JSON Pointer-safe identifier: alphanumerics
+* and underscores only. An empty result falls back to "Schema".
+*/
+function sanitiseName(raw) {
+	const cleaned = raw.replace(/[^A-Za-z0-9_]/g, "_");
+	return cleaned.length > 0 ? cleaned : "Schema";
+}
+/**
+* Place the resolved target into `components.schemas` under a unique
+* name derived from the ref, and return the chosen name. Collisions
+* with existing entries are resolved by suffixing a counter.
+*/
+function registerInline(schemasNode, uri, fragment, target) {
+	const base = deriveCandidateName(uri, fragment);
+	let name = base;
+	let counter = 2;
+	while (name in schemasNode) {
+		name = `${base}_${String(counter)}`;
+		counter++;
+	}
+	schemasNode[name] = structuredClone(target);
+	return name;
+}
 //#endregion
 export { bundleOpenApiDoc };

package/dist/openapi/components.d.mts

@@ -1,5 +1,5 @@
 import { T as SchemaMeta, u as FieldOverride } from "../types-D_5ST7SS.mjs";
-import { i as InferResponseFields, n as InferParameterOverrides, r as InferRequestBodyFields, u as UnsafeFields } from "../typeInference-k7FXfTVO.mjs";
+import { a as InferResponseFields, d as UnsafeFields, i as InferRequestBodyFields, r as InferParameterOverrides } from "../typeInference-5JiqIZ8t.mjs";
 import { WidgetMap } from "../react/SchemaComponent.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/components.mjs

@@ -1,16 +1,14 @@
-import { toRecordOrUndefined } from "../core/guards.mjs";
-import { SchemaNormalisationError } from "../core/errors.mjs";
-import { normaliseSchema } from "../core/adapter.mjs";
+import { isObject, toRecordOrUndefined } from "../core/guards.mjs";
 import { walk } from "../core/walker.mjs";
+import { joinPath, renderField, sanitisePrefix } from "../react/SchemaComponent.mjs";
 import { ApiCallbacks } from "./ApiCallbacks.mjs";
 import { ApiLinks } from "./ApiLinks.mjs";
 import { ApiResponseHeaders } from "./ApiResponseHeaders.mjs";
 import { ApiSecurity } from "./ApiSecurity.mjs";
 import { getLinks, getSecurityRequirements, getSecuritySchemes, listCallbacks } from "./parser.mjs";
-import { joinPath, renderField, sanitisePrefix } from "../react/SchemaComponent.mjs";
 import { getParsed, resolveOperation, resolveParameters, resolveRequestBody, resolveResponse, toDoc } from "./resolve.mjs";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { useId } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 //#region src/openapi/components.tsx
 /**
 * OpenAPI React components with type-safe generics.
@@ -27,25 +25,17 @@ import { useId } from "react";
 */
 function noop() {}
 function renderSchema(schema, rootDocument, options) {
-	let jsonSchema;
-	let rootMeta;
-	try {
-		const normalised = normaliseSchema(schema);
-		jsonSchema = normalised.jsonSchema;
-		rootMeta = normalised.rootMeta;
-	} catch (err) {
-		throw new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", schema, "unknown");
-	}
+	if (!isObject(schema)) throw new Error("renderSchema received a non-object schema from the resolver.");
+	const rootMeta = extractRootMetaFromSchema(schema);
 	const componentMeta = {};
 	if (options.readOnly === true) componentMeta.readOnly = true;
 	if (options.meta !== void 0) for (const [k, v] of Object.entries(options.meta)) componentMeta[k] = v;
-	const walkOpts = {
+	const tree = walk(schema, {
 		componentMeta,
 		rootMeta,
 		fieldOverrides: toRecordOrUndefined(options.fields),
 		rootDocument
-	};
-	const tree = walk(jsonSchema, walkOpts);
+	});
 	const makeRenderChild = (parentPath) => (childTree, childValue, childOnChange, pathSuffix) => {
 		const childPath = joinPath(parentPath, pathSuffix);
 		return renderField(childTree, childValue, childOnChange, void 0, makeRenderChild(childPath), childPath, options.widgets);
@@ -262,5 +252,20 @@ function buildParamMeta(param, overrides, meta) {
 	if (meta !== void 0) for (const [k, v] of Object.entries(meta)) result[k] = v;
 	return Object.keys(result).length > 0 ? result : void 0;
 }
+/**
+* Extract root-level meta (title, description, readOnly, etc.) from a
+* JSON Schema node. Mirrors `extractRootMetaFromJson` in the adapter so
+* pre-normalised schemas (extracted from `getParsed`) still surface root
+* meta to the walker without an extra adapter round-trip.
+*/
+function extractRootMetaFromSchema(jsonSchema) {
+	const meta = {};
+	if (jsonSchema.readOnly === true) meta.readOnly = true;
+	if (jsonSchema.writeOnly === true) meta.writeOnly = true;
+	if (typeof jsonSchema.description === "string") meta.description = jsonSchema.description;
+	if (typeof jsonSchema.title === "string") meta.title = jsonSchema.title;
+	if (typeof jsonSchema.deprecated === "boolean") meta.deprecated = jsonSchema.deprecated;
+	return Object.keys(meta).length > 0 ? meta : void 0;
+}
 //#endregion
 export { ApiOperation, ApiParameters, ApiRequestBody, ApiResponse };

package/dist/openapi/parser.mjs

@@ -79,22 +79,22 @@ function getParameters(parsed, path, method) {
 	if (pathItem === void 0) return [];
 	const operation = getProperty(pathItem, method);
 	if (!isObject(operation)) return [];
-	const pathParams = extractParameterList(getProperty(pathItem, "parameters"));
-	const opParams = extractParameterList(getProperty(operation, "parameters"));
+	const pathParams = extractParameterList(parsed.doc, getProperty(pathItem, "parameters"));
+	const opParams = extractParameterList(parsed.doc, getProperty(operation, "parameters"));
 	const map = /* @__PURE__ */ new Map();
 	for (const param of pathParams) map.set(`${param.name}:${param.location}`, param);
 	for (const param of opParams) map.set(`${param.name}:${param.location}`, param);
 	return [...map.values()];
 }
-function extractParameterList(parameters) {
+function extractParameterList(doc, parameters) {
 	if (!Array.isArray(parameters)) return [];
 	const result = [];
 	for (const param of parameters) {
 		if (!isObject(param)) continue;
-		const name = getProperty(param, "name");
-		const location = getProperty(param, "in");
+		const resolved = resolveParam(doc, param);
+		const name = getProperty(resolved, "name");
+		const location = getProperty(resolved, "in");
 		if (typeof name !== "string" || typeof location !== "string") continue;
-		const resolved = resolveParam(param);
 		const schema = getProperty(resolved, "schema");
 		result.push({
 			name,
@@ -107,10 +107,10 @@ function extractParameterList(parameters) {
 	}
 	return result;
 }
-function resolveParam(param) {
+function resolveParam(doc, param) {
 	const ref = getProperty(param, "$ref");
 	if (typeof ref === "string" && ref.startsWith("#/")) {
-		const resolved = resolveRefInDoc(param, ref);
+		const resolved = resolveRefInDoc(doc, ref);
 		if (resolved !== void 0) return resolved;
 	}
 	return param;

package/dist/openapi/resolve.d.mts

@@ -2,8 +2,19 @@ import { OpenApiDocument, OperationInfo, ParameterInfo, ResponseInfo, getRequest
 
 //#region src/openapi/resolve.d.ts
 /**
- * Parse and cache an OpenAPI document. Returns cached version if
- * the same object identity has been seen before.
+ * Parse and cache an OpenAPI document. Returns the cached parse for the
+ * same object identity.
+ *
+ * Before parsing, the document is run through the version-aware
+ * normalisation pipeline (`normaliseOpenApiSchemas`) so OpenAPI 3.0.x
+ * keywords (`nullable`, `discriminator`, `example`) and Swagger 2.0
+ * documents are converted to canonical Draft 2020-12 form. The parser
+ * and downstream extractors (`getRequestBody`, `getResponses`, etc.) then
+ * observe schemas in the same form `<SchemaComponent>` does, keeping the
+ * OpenAPI components on the same pipeline as the top-level adapter.
+ *
+ * The cache is keyed by the caller-supplied document so subsequent calls
+ * with the same input bypass both normalisation and parsing.
  */
 declare function getParsed(doc: Record<string, unknown>): OpenApiDocument;
 /**

package/dist/openapi/resolve.mjs

@@ -1,4 +1,6 @@
 import { isObject } from "../core/guards.mjs";
+import { detectOpenApiVersion } from "../core/version.mjs";
+import { i as normaliseOpenApiSchemas } from "../normalise-tL9FckAk.mjs";
 import { getParameters, getRequestBody, getResponses, listOperations, parseOpenApiDocument } from "./parser.mjs";
 //#region src/openapi/resolve.ts
 /**
@@ -10,14 +12,28 @@ import { getParameters, getRequestBody, getResponses, listOperations, parseOpenA
 */
 const docCache = /* @__PURE__ */ new WeakMap();
 /**
-* Parse and cache an OpenAPI document. Returns cached version if
-* the same object identity has been seen before.
+* Parse and cache an OpenAPI document. Returns the cached parse for the
+* same object identity.
+*
+* Before parsing, the document is run through the version-aware
+* normalisation pipeline (`normaliseOpenApiSchemas`) so OpenAPI 3.0.x
+* keywords (`nullable`, `discriminator`, `example`) and Swagger 2.0
+* documents are converted to canonical Draft 2020-12 form. The parser
+* and downstream extractors (`getRequestBody`, `getResponses`, etc.) then
+* observe schemas in the same form `<SchemaComponent>` does, keeping the
+* OpenAPI components on the same pipeline as the top-level adapter.
+*
+* The cache is keyed by the caller-supplied document so subsequent calls
+* with the same input bypass both normalisation and parsing.
 */
 function getParsed(doc) {
 	const cached = docCache.get(doc);
 	if (cached !== void 0) return cached;
-	const parsed = parseOpenApiDocument(doc);
+	const version = detectOpenApiVersion(doc);
+	const normalisedDoc = version !== void 0 ? normaliseOpenApiSchemas(doc, version) : doc;
+	const parsed = parseOpenApiDocument(normalisedDoc);
 	docCache.set(doc, parsed);
+	if (normalisedDoc !== doc) docCache.set(normalisedDoc, parsed);
 	return parsed;
 }
 /**

package/dist/react/SchemaComponent.d.mts

@@ -1,11 +1,11 @@
 import { M as WalkedField, T as SchemaMeta, d as FieldOverrides, u as FieldOverride } from "../types-D_5ST7SS.mjs";
-import { t as Diagnostic } from "../diagnostics-DzbZmcLI.mjs";
+import { t as Diagnostic } from "../diagnostics-BYk63jsC.mjs";
 import { t as SchemaError } from "../errors-C5zRC2PU.mjs";
-import { l as RenderProps, r as ComponentResolver } from "../renderer-B3s8o2B8.mjs";
-import { c as ResolveOpenAPIRef, s as PathOfType, t as FromJSONSchema } from "../typeInference-k7FXfTVO.mjs";
+import { l as RenderProps, r as ComponentResolver } from "../renderer-DXo-rXHJ.mjs";
+import { c as PathOfType, l as ResolveOpenAPIRef, n as FromJSONSchema } from "../typeInference-5JiqIZ8t.mjs";
 import { z } from "zod";
-import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 import { ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 
 //#region src/react/SchemaComponent.d.ts
 /**

package/dist/react/SchemaComponent.mjs

@@ -2,13 +2,13 @@
 import { isObject, toRecordOrUndefined } from "../core/guards.mjs";
 import { SchemaFieldError, SchemaNormalisationError, SchemaRenderError } from "../core/errors.mjs";
 import { normaliseSchema } from "../core/adapter.mjs";
-import { getRenderFunction, mergeResolvers } from "../core/renderer.mjs";
+import { buildRenderProps, getRenderFunction, mergeResolvers } from "../core/renderer.mjs";
 import { walk } from "../core/walker.mjs";
 import { headlessResolver } from "./headless.mjs";
 import { resolvePath, resolveValue, setNestedValue } from "./fieldPath.mjs";
 import { z } from "zod";
-import { jsx, jsxs } from "react/jsx-runtime";
 import { createContext, isValidElement, useCallback, useContext, useId, useMemo } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
 //#region src/react/SchemaComponent.tsx
 /**
 * <SchemaComponent> — renders UI from Zod, JSON Schema, or OpenAPI schemas.
@@ -203,35 +203,6 @@ function renderField(tree, value, onChange, userResolver, renderChild, path, ins
 	if (value === void 0 || value === null) return /* @__PURE__ */ jsx("span", { children: "—" });
 	return /* @__PURE__ */ jsx("span", { children: typeof value === "string" ? value : JSON.stringify(value) });
 }
-function buildRenderProps(tree, value, onChange, renderChild, path) {
-	const props = {
-		value,
-		onChange,
-		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 === "recursive") props.refTarget = tree.refTarget;
-	if (tree.type === "literal") props.literalValues = tree.literalValues;
-	if (tree.examples !== void 0) props.examples = tree.examples;
-	return props;
-}
 function SchemaField({ path, schema: schemaInput, ref: refInput, value, onChange, meta: fieldMeta, validate, onValidationError }) {
 	const userResolver = useContext(UserResolverContext);
 	const contextWidgets = useContext(WidgetsContext);

package/dist/react/SchemaView.d.mts

@@ -1,6 +1,6 @@
 import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
-import { t as Diagnostic } from "../diagnostics-DzbZmcLI.mjs";
-import { r as ComponentResolver } from "../renderer-B3s8o2B8.mjs";
+import { t as Diagnostic } from "../diagnostics-BYk63jsC.mjs";
+import { r as ComponentResolver } from "../renderer-DXo-rXHJ.mjs";
 import { WidgetMap } from "./SchemaComponent.mjs";
 import { ReactNode } from "react";
 
@@ -38,7 +38,8 @@ interface SchemaViewProps {
   idPrefix?: string;
 }
 /**
- * Server-safe schema renderer — no hooks, no context, no state.
+ * Server-safe schema renderer — no context and no state. The only hook
+ * called is `useId()`, which is RSC-safe.
  *
  * Always renders in read-only mode. For editable forms, use
  * `<SchemaComponent>` with `"use client"`.

package/dist/react/SchemaView.mjs

@@ -1,18 +1,21 @@
 import { SchemaNormalisationError, SchemaRenderError } from "../core/errors.mjs";
 import { normaliseSchema } from "../core/adapter.mjs";
-import { getRenderFunction, mergeResolvers } from "../core/renderer.mjs";
+import { buildRenderProps, getRenderFunction, mergeResolvers } from "../core/renderer.mjs";
 import { walk } from "../core/walker.mjs";
 import { headlessResolver } from "./headless.mjs";
 import { joinPath, sanitisePrefix } from "./SchemaComponent.mjs";
-import { jsx } from "react/jsx-runtime";
 import { createElement, isValidElement, useId } from "react";
+import { jsx } from "react/jsx-runtime";
 //#region src/react/SchemaView.tsx
 /**
 * React Server Component for read-only schema rendering.
 *
-* This component has zero hooks — no `useContext`, no `useMemo`,
-* no `useCallback`. It can run in a React Server Component environment
-* without the `"use client"` directive.
+* Uses no React state, context, or effects — no `useContext`, `useMemo`,
+* `useCallback`, `useState`, or `useEffect`. The single hook called is
+* `useId()`, which is one of the few hooks permitted inside a React
+* Server Component (it is RSC-safe by design) and is used solely to
+* derive a stable per-instance `idPrefix`. The component therefore runs
+* in an RSC environment without the `"use client"` directive.
 *
 * **Read-only only.** For interactive forms with `onChange`, use
 * `<SchemaComponent>` (which requires `"use client"`).
@@ -31,9 +34,9 @@ import { createElement, isValidElement, useId } from "react";
 * Server Components cannot use React context, so the resolver
 * is passed explicitly.
 */
-function noop() {}
 /**
-* Server-safe schema renderer — no hooks, no context, no state.
+* Server-safe schema renderer — no context and no state. The only hook
+* called is `useId()`, which is RSC-safe.
 *
 * Always renders in read-only mode. For editable forms, use
 * `<SchemaComponent>` with `"use client"`.
@@ -81,22 +84,12 @@ function SchemaView({ schema: schemaInput, ref: refInput, value, fields, meta: c
 }
 function renderFieldServer(tree, value, resolver, renderChild, path, widgets) {
 	if (path.length === 0) throw new Error("renderFieldServer requires a non-empty path. Pass ROOT_PATH at the root and join children via joinPath().");
+	const adaptedRenderChild = (childTree, childValue, _childOnChange, pathSuffix) => renderChild(childTree, childValue, pathSuffix);
 	const componentHint = tree.meta.component;
 	if (typeof componentHint === "string") {
 		const widget = widgets?.get(componentHint);
 		if (widget !== void 0) {
-			const wrapRenderChild = (childTree, childValue, _childOnChange, pathSuffix) => renderChild(childTree, childValue, pathSuffix);
-			const result = widget({
-				value,
-				onChange: noop,
-				readOnly: true,
-				writeOnly: false,
-				meta: tree.meta,
-				constraints: tree.constraints,
-				path,
-				tree,
-				renderChild: wrapRenderChild
-			});
+			const result = widget(buildRenderProps(tree, value, void 0, adaptedRenderChild, path));
 			if (result !== void 0 && result !== null) {
 				if (isValidElement(result)) return result;
 				if (typeof result === "string" || typeof result === "number") return result;
@@ -105,31 +98,7 @@ function renderFieldServer(tree, value, resolver, renderChild, path, widgets) {
 	}
 	const renderFn = getRenderFunction(tree.type, resolver);
 	if (renderFn !== void 0) {
-		const props = {
-			value,
-			onChange: noop,
-			readOnly: true,
-			writeOnly: false,
-			meta: tree.meta,
-			constraints: tree.constraints,
-			path,
-			tree,
-			renderChild: (childTree, childValue, _childOnChange, pathSuffix) => renderChild(childTree, childValue, pathSuffix)
-		};
-		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 === "recursive") props.refTarget = tree.refTarget;
-		if (tree.type === "literal") props.literalValues = tree.literalValues;
+		const props = buildRenderProps(tree, value, void 0, adaptedRenderChild, path);
 		try {
 			const result = renderFn(props);
 			if (result !== void 0 && result !== null) {

package/dist/react/headless.d.mts

@@ -1,4 +1,4 @@
-import { r as ComponentResolver } from "../renderer-B3s8o2B8.mjs";
+import { r as ComponentResolver } from "../renderer-DXo-rXHJ.mjs";
 
 //#region src/react/headless.d.ts
 /**

package/dist/react/headlessRenderers.d.mts

@@ -1,5 +1,5 @@
 import { M as WalkedField } from "../types-D_5ST7SS.mjs";
-import { l as RenderProps } from "../renderer-B3s8o2B8.mjs";
+import { l as RenderProps } from "../renderer-DXo-rXHJ.mjs";
 import { ReactNode } from "react";
 
 //#region src/react/headlessRenderers.d.ts

package/dist/react/headlessRenderers.mjs

@@ -1,6 +1,6 @@
 import { isObject } from "../core/guards.mjs";
-import { jsx, jsxs } from "react/jsx-runtime";
 import { isValidElement, useCallback, useEffect, useRef } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
 //#region src/react/headlessRenderers.tsx
 /**
 * Headless renderer functions — one per schema type.
@@ -496,7 +496,7 @@ function DiscriminatedUnionTabs({ options, optionLabels, activeIndex, panelId, d
 	}, [
 		optionLabels,
 		discKey,
-		props
+		props.onChange
 	]);
 	const wrapIndex = useCallback((index) => (index % options.length + options.length) % options.length, [options.length]);
 	const handleKeyDown = useCallback((e) => {
@@ -537,6 +537,7 @@ function DiscriminatedUnionTabs({ options, optionLabels, activeIndex, panelId, d
 			},
 			type: "button",
 			role: "tab",
+			id: `${panelId}-tab-${String(i)}`,
 			"aria-selected": i === activeIndex ? "true" : void 0,
 			"aria-controls": `${panelId}-panel`,
 			tabIndex: i === activeIndex ? 0 : -1,

package/dist/{ref-DvWoULcy.d.mts → ref-Ckt5liZs.d.mts}

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

package/dist/{renderer-B3s8o2B8.d.mts → renderer-DXo-rXHJ.d.mts}

@@ -99,6 +99,23 @@ interface HtmlRenderProps extends BaseFieldProps {
    */
   renderChild: (tree: WalkedField, value: unknown, pathSuffix?: string) => string;
 }
+/**
+ * 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`.
+ *
+ * The duplicate sibling fields (`enumValues`, `element`, `fields`, etc.)
+ * are populated for backwards compatibility with renderers that have not
+ * yet migrated to reading from `tree` directly. New renderers should
+ * narrow on `tree.type` and read from `tree`.
+ */
+declare function buildRenderProps(tree: WalkedField, value: unknown, onChange: ((next: unknown) => void) | undefined, renderChild: RenderProps["renderChild"], path: string): RenderProps;
 type RenderFunction = (props: RenderProps) => unknown;
 interface ComponentResolver {
   string?: RenderFunction;
@@ -166,4 +183,4 @@ declare function mergeResolvers(user: ComponentResolver, fallback: ComponentReso
  */
 declare function mergeHtmlResolvers(user: HtmlResolver, fallback: HtmlResolver): HtmlResolver;
 //#endregion
-export { HtmlRenderProps as a, RenderFunction as c, getRenderFunction as d, mergeHtmlResolvers as f, HtmlRenderFunction as i, RenderProps as l, typeToKey as m, BaseFieldProps as n, HtmlResolver as o, mergeResolvers as p, ComponentResolver as r, RESOLVER_KEYS as s, AllConstraints as t, getHtmlRenderFn as u };
+export { HtmlRenderProps as a, RenderFunction as c, getHtmlRenderFn as d, getRenderFunction as f, typeToKey as h, HtmlRenderFunction as i, RenderProps as l, mergeResolvers as m, BaseFieldProps as n, HtmlResolver as o, mergeHtmlResolvers as p, ComponentResolver as r, RESOLVER_KEYS as s, AllConstraints as t, buildRenderProps as u };

package/dist/themes/mantine.d.mts

@@ -1,4 +1,4 @@
-import { r as ComponentResolver } from "../renderer-B3s8o2B8.mjs";
+import { r as ComponentResolver } from "../renderer-DXo-rXHJ.mjs";
 
 //#region src/themes/mantine.d.ts
 /**

package/dist/themes/mantine.mjs

@@ -103,6 +103,7 @@ function renderEnumInput(props) {
 		id,
 		children: enumValue || "—"
 	});
+	const enumValues = props.tree.type === "enum" ? props.tree.enumValues : [];
 	return /* @__PURE__ */ jsx(MantineSelect, {
 		id,
 		label,
@@ -110,15 +111,15 @@ function renderEnumInput(props) {
 		onChange: (v) => {
 			if (typeof v === "string") props.onChange(v);
 		},
-		data: (props.enumValues ?? []).map((v) => ({
+		data: enumValues.map((v) => ({
 			value: v,
 			label: v
 		}))
 	});
 }
 function renderObjectContainer(props) {
-	const fields = props.fields;
-	if (fields === void 0) return null;
+	if (props.tree.type !== "object") return null;
+	const fields = props.tree.fields;
 	const obj = isObject(props.value) ? props.value : {};
 	return /* @__PURE__ */ jsx(MantineFieldset, {
 		legend: getLabel(props),

package/dist/themes/mui.d.mts

@@ -1,4 +1,4 @@
-import { r as ComponentResolver } from "../renderer-B3s8o2B8.mjs";
+import { r as ComponentResolver } from "../renderer-DXo-rXHJ.mjs";
 
 //#region src/themes/mui.d.ts
 /**