schema-components 1.12.10 → 1.13.0

package/dist/openapi/parser.d.mts

@@ -1,4 +1,4 @@
-import { l as JsonObject } from "../types-BJzEgJdX.mjs";
+import { m as JsonObject } from "../types-ag2jYLqQ.mjs";
 
 //#region src/openapi/parser.d.ts
 interface OpenApiDocument {
@@ -28,6 +28,7 @@ interface ResponseInfo {
   description: string | undefined;
   contentTypes: string[];
   schema: JsonObject | undefined;
+  headers: Map<string, HeaderInfo>;
 }
 interface RequestBodyInfo {
   required: boolean;
@@ -35,11 +36,67 @@ interface RequestBodyInfo {
   contentTypes: string[];
   schema: JsonObject | undefined;
 }
+interface SecurityRequirement {
+  name: string;
+  scopes: string[];
+}
+interface SecurityScheme {
+  type: string;
+  description: string | undefined;
+  name: string | undefined;
+  location: string | undefined;
+  scheme: string | undefined;
+  bearerFormat: string | undefined;
+  flows: JsonObject | undefined;
+  openIdConnectUrl: string | undefined;
+}
+interface HeaderInfo {
+  name: string;
+  description: string | undefined;
+  required: boolean;
+  deprecated: boolean;
+  schema: JsonObject | undefined;
+}
+interface WebhookInfo {
+  name: string;
+  operations: OperationInfo[];
+}
+interface ExternalDocs {
+  url: string;
+  description: string | undefined;
+}
+interface XmlInfo {
+  name: string | undefined;
+  namespace: string | undefined;
+  prefix: string | undefined;
+  attribute: boolean;
+  wrapped: boolean;
+}
+interface CallbackInfo {
+  name: string;
+  operations: OperationInfo[];
+}
+interface LinkInfo {
+  name: string;
+  operationId: string | undefined;
+  operationRef: string | undefined;
+  description: string | undefined;
+  parameters: Map<string, string>;
+  requestBody: string | undefined;
+}
 declare function parseOpenApiDocument(doc: JsonObject): OpenApiDocument;
 declare function getSchema(parsed: OpenApiDocument, ref: string): JsonObject | undefined;
 declare function listOperations(parsed: OpenApiDocument): OperationInfo[];
 declare function getParameters(parsed: OpenApiDocument, path: string, method: string): ParameterInfo[];
 declare function getRequestBody(parsed: OpenApiDocument, path: string, method: string): RequestBodyInfo | undefined;
 declare function getResponses(parsed: OpenApiDocument, path: string, method: string): ResponseInfo[];
+declare function getSecurityRequirements(parsed: OpenApiDocument, path: string, method: string): SecurityRequirement[];
+declare function getSecuritySchemes(parsed: OpenApiDocument): Map<string, SecurityScheme>;
+declare function getResponseHeaders(response: JsonObject): Map<string, HeaderInfo>;
+declare function listWebhooks(parsed: OpenApiDocument): WebhookInfo[];
+declare function getExternalDocs(obj: JsonObject): ExternalDocs | undefined;
+declare function getXmlInfo(schema: JsonObject): XmlInfo | undefined;
+declare function listCallbacks(parsed: OpenApiDocument, path: string, method: string): CallbackInfo[];
+declare function getLinks(parsed: OpenApiDocument, path: string, method: string, statusCode: string): LinkInfo[];
 //#endregion
-export { OpenApiDocument, OperationInfo, ParameterInfo, ParameterLocation, RequestBodyInfo, ResponseInfo, getParameters, getRequestBody, getResponses, getSchema, listOperations, parseOpenApiDocument };
+export { CallbackInfo, ExternalDocs, HeaderInfo, LinkInfo, OpenApiDocument, OperationInfo, ParameterInfo, ParameterLocation, RequestBodyInfo, ResponseInfo, SecurityRequirement, SecurityScheme, WebhookInfo, XmlInfo, getExternalDocs, getLinks, getParameters, getRequestBody, getResponseHeaders, getResponses, getSchema, getSecurityRequirements, getSecuritySchemes, getXmlInfo, listCallbacks, listOperations, listWebhooks, parseOpenApiDocument };

package/dist/openapi/parser.mjs

@@ -35,12 +35,29 @@ const METHODS = [
 	"patch",
 	"delete"
 ];
+/**
+* Resolve a path item, following a `$ref` to `components/pathItems/<Name>`
+* (OpenAPI 3.1) if present. Returns `undefined` when the value is not a
+* path item, the ref is malformed, or the target does not resolve.
+*/
+function resolvePathItem(parsed, pathItem) {
+	if (!isObject(pathItem)) return void 0;
+	const ref = getString(pathItem, "$ref");
+	if (ref === void 0) return pathItem;
+	return resolveRefInDoc(parsed.doc, ref) ?? void 0;
+}
+function lookupPathItem(parsed, path) {
+	const resolved = resolvePathItem(parsed, getProperty(getProperty(parsed.doc, "paths"), path));
+	if (resolved !== void 0) return resolved;
+	return resolvePathItem(parsed, getProperty(getProperty(parsed.doc, "webhooks"), path));
+}
 function listOperations(parsed) {
 	const operations = [];
 	const paths = getProperty(parsed.doc, "paths");
 	if (!isObject(paths)) return operations;
-	for (const [path, pathItem] of Object.entries(paths)) {
-		if (!isObject(pathItem)) continue;
+	for (const [path, rawPathItem] of Object.entries(paths)) {
+		const pathItem = resolvePathItem(parsed, rawPathItem);
+		if (pathItem === void 0) continue;
 		for (const method of METHODS) {
 			const operation = getProperty(pathItem, method);
 			if (!isObject(operation)) continue;
@@ -58,8 +75,8 @@ function listOperations(parsed) {
 	return operations;
 }
 function getParameters(parsed, path, method) {
-	const pathItem = getProperty(getProperty(parsed.doc, "paths"), path);
-	if (!isObject(pathItem)) return [];
+	const pathItem = lookupPathItem(parsed, path);
+	if (pathItem === void 0) return [];
 	const operation = getProperty(pathItem, method);
 	if (!isObject(operation)) return [];
 	const pathParams = extractParameterList(getProperty(pathItem, "parameters"));
@@ -99,7 +116,7 @@ function resolveParam(param) {
 	return param;
 }
 function getRequestBody(parsed, path, method) {
-	const requestBody = getProperty(getProperty(getProperty(getProperty(parsed.doc, "paths"), path), method), "requestBody");
+	const requestBody = getProperty(getProperty(lookupPathItem(parsed, path), method), "requestBody");
 	if (!isObject(requestBody)) return void 0;
 	const content = getProperty(requestBody, "content");
 	if (!isObject(content)) return {
@@ -118,7 +135,7 @@ function getRequestBody(parsed, path, method) {
 	};
 }
 function getResponses(parsed, path, method) {
-	const responses = getProperty(getProperty(getProperty(getProperty(parsed.doc, "paths"), path), method), "responses");
+	const responses = getProperty(getProperty(lookupPathItem(parsed, path), method), "responses");
 	if (!isObject(responses)) return [];
 	const result = [];
 	for (const [statusCode, response] of Object.entries(responses)) {
@@ -126,11 +143,13 @@ function getResponses(parsed, path, method) {
 		const content = getProperty(response, "content");
 		const contentTypes = isObject(content) ? Object.keys(content) : [];
 		const schema = isObject(content) ? extractSchemaFromContent(content) : void 0;
+		const headers = getResponseHeaders(response);
 		result.push({
 			statusCode,
 			description: getString(response, "description"),
 			contentTypes,
-			schema
+			schema,
+			headers
 		});
 	}
 	return result;
@@ -155,5 +174,167 @@ function resolveRefInDoc(doc, ref) {
 	}
 	return isObject(current) ? current : void 0;
 }
+function getSecurityRequirements(parsed, path, method) {
+	const opSecurity = getProperty(getProperty(lookupPathItem(parsed, path), method), "security");
+	const globalSecurity = getProperty(parsed.doc, "security");
+	const securityArray = Array.isArray(opSecurity) ? opSecurity : Array.isArray(globalSecurity) ? globalSecurity : [];
+	const result = [];
+	for (const entry of securityArray) {
+		if (!isObject(entry)) continue;
+		for (const [name, scopes] of Object.entries(entry)) result.push({
+			name,
+			scopes: Array.isArray(scopes) ? scopes.filter((s) => typeof s === "string") : []
+		});
+	}
+	return result;
+}
+function getSecuritySchemes(parsed) {
+	const result = /* @__PURE__ */ new Map();
+	const securitySchemes = getProperty(getProperty(parsed.doc, "components"), "securitySchemes");
+	if (!isObject(securitySchemes)) return result;
+	for (const [name, scheme] of Object.entries(securitySchemes)) {
+		if (!isObject(scheme)) continue;
+		const flowsProp = getProperty(scheme, "flows");
+		result.set(name, {
+			type: getString(scheme, "type") ?? "",
+			description: getString(scheme, "description"),
+			name: getString(scheme, "name"),
+			location: getString(scheme, "in"),
+			scheme: getString(scheme, "scheme"),
+			bearerFormat: getString(scheme, "bearerFormat"),
+			flows: isObject(flowsProp) ? flowsProp : void 0,
+			openIdConnectUrl: getString(scheme, "openIdConnectUrl")
+		});
+	}
+	return result;
+}
+function getResponseHeaders(response) {
+	const result = /* @__PURE__ */ new Map();
+	const headers = getProperty(response, "headers");
+	if (!isObject(headers)) return result;
+	for (const [name, headerObj] of Object.entries(headers)) {
+		if (!isObject(headerObj)) continue;
+		const ref = getString(headerObj, "$ref");
+		const header = (ref !== void 0 ? resolveRefInDoc(headerObj, ref) : void 0) ?? headerObj;
+		const schemaProp = getProperty(header, "schema");
+		result.set(name, {
+			name,
+			description: getString(header, "description"),
+			required: getProperty(header, "required") === true,
+			deprecated: getProperty(header, "deprecated") === true,
+			schema: isObject(schemaProp) ? schemaProp : void 0
+		});
+	}
+	return result;
+}
+function listWebhooks(parsed) {
+	const result = [];
+	const webhooks = getProperty(parsed.doc, "webhooks");
+	if (!isObject(webhooks)) return result;
+	for (const [name, hookItem] of Object.entries(webhooks)) {
+		if (!isObject(hookItem)) continue;
+		const operations = [];
+		for (const method of METHODS) {
+			const operation = getProperty(hookItem, method);
+			if (!isObject(operation)) continue;
+			operations.push({
+				path: name,
+				method,
+				operationId: getString(operation, "operationId"),
+				summary: getString(operation, "summary"),
+				description: getString(operation, "description"),
+				deprecated: getProperty(operation, "deprecated") === true,
+				operation
+			});
+		}
+		result.push({
+			name,
+			operations
+		});
+	}
+	return result;
+}
+function getExternalDocs(obj) {
+	const docs = getProperty(obj, "externalDocs");
+	if (!isObject(docs)) return void 0;
+	const url = getString(docs, "url");
+	if (typeof url !== "string") return void 0;
+	return {
+		url,
+		description: getString(docs, "description")
+	};
+}
+function getXmlInfo(schema) {
+	const xml = getProperty(schema, "xml");
+	if (!isObject(xml)) return void 0;
+	return {
+		name: getString(xml, "name"),
+		namespace: getString(xml, "namespace"),
+		prefix: getString(xml, "prefix"),
+		attribute: getProperty(xml, "attribute") === true,
+		wrapped: getProperty(xml, "wrapped") === true
+	};
+}
+function listCallbacks(parsed, path, method) {
+	const operation = getProperty(lookupPathItem(parsed, path), method);
+	if (!isObject(operation)) return [];
+	const callbacks = getProperty(operation, "callbacks");
+	if (!isObject(callbacks)) return [];
+	const result = [];
+	for (const [name, callbackItem] of Object.entries(callbacks)) {
+		if (!isObject(callbackItem)) continue;
+		const operations = [];
+		for (const [cbPath, cbPathItem] of Object.entries(callbackItem)) {
+			if (!isObject(cbPathItem)) continue;
+			for (const cbMethod of METHODS) {
+				const cbOp = getProperty(cbPathItem, cbMethod);
+				if (!isObject(cbOp)) continue;
+				const ref = getString(cbOp, "$ref");
+				const resolved = ref !== void 0 ? resolveRefInDoc(parsed.doc, ref) ?? cbOp : cbOp;
+				operations.push({
+					path: `${name}/${cbPath}`,
+					method: cbMethod,
+					operationId: getString(resolved, "operationId"),
+					summary: getString(resolved, "summary"),
+					description: getString(resolved, "description"),
+					deprecated: getProperty(resolved, "deprecated") === true,
+					operation: isObject(resolved) ? resolved : cbOp
+				});
+			}
+		}
+		result.push({
+			name,
+			operations
+		});
+	}
+	return result;
+}
+function getLinks(parsed, path, method, statusCode) {
+	const response = getProperty(getProperty(getProperty(lookupPathItem(parsed, path), method), "responses"), statusCode);
+	if (!isObject(response)) return [];
+	const links = getProperty(response, "links");
+	if (!isObject(links)) return [];
+	const result = [];
+	for (const [name, linkObj] of Object.entries(links)) {
+		if (!isObject(linkObj)) continue;
+		const ref = getString(linkObj, "$ref");
+		const resolved = ref !== void 0 ? resolveRefInDoc(parsed.doc, ref) ?? linkObj : linkObj;
+		const link = isObject(resolved) ? resolved : linkObj;
+		const params = getProperty(link, "parameters");
+		const paramMap = /* @__PURE__ */ new Map();
+		if (isObject(params)) {
+			for (const [paramName, paramValue] of Object.entries(params)) if (typeof paramValue === "string") paramMap.set(paramName, paramValue);
+		}
+		result.push({
+			name,
+			operationId: getString(link, "operationId"),
+			operationRef: getString(link, "operationRef"),
+			description: getString(link, "description"),
+			parameters: paramMap,
+			requestBody: getString(link, "requestBody")
+		});
+	}
+	return result;
+}
 //#endregion
-export { getParameters, getRequestBody, getResponses, getSchema, listOperations, parseOpenApiDocument };
+export { getExternalDocs, getLinks, getParameters, getRequestBody, getResponseHeaders, getResponses, getSchema, getSecurityRequirements, getSecuritySchemes, getXmlInfo, listCallbacks, listOperations, listWebhooks, parseOpenApiDocument };

package/dist/react/SchemaComponent.d.mts

@@ -1,5 +1,7 @@
-import { E as RenderProps, _ as WalkedField, a as FromJSONSchema, b as ComponentResolver, f as PathOfType, i as FieldOverrides, m as SchemaMeta, p as ResolveOpenAPIRef, r as FieldOverride } from "../types-BJzEgJdX.mjs";
+import { d as FieldOverrides, j as WalkedField, u as FieldOverride, w as SchemaMeta } from "../types-ag2jYLqQ.mjs";
 import { t as SchemaError } from "../errors-DIKI2C78.mjs";
+import { l as RenderProps, r as ComponentResolver } from "../renderer-DseHeliw.mjs";
+import { c as ResolveOpenAPIRef, s as PathOfType, t as FromJSONSchema } from "../typeInference-CRPqVwKu.mjs";
 import { z } from "zod";
 import { ReactNode } from "react";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
@@ -79,7 +81,7 @@ declare function SchemaComponent<T = unknown, Ref extends string | undefined = u
   description,
   widgets: instanceWidgets
 }: SchemaComponentProps<T, Ref>): ReactNode;
-declare function renderField(tree: WalkedField, value: unknown, onChange: (v: unknown) => void, userResolver: ComponentResolver | undefined, renderChild: (tree: WalkedField, value: unknown, onChange: (v: unknown) => void) => ReactNode, instanceWidgets?: WidgetMap, contextWidgets?: WidgetMap): ReactNode;
+declare function renderField(tree: WalkedField, value: unknown, onChange: (v: unknown) => void, userResolver: ComponentResolver | undefined, renderChild: (tree: WalkedField, value: unknown, onChange: (v: unknown) => void) => ReactNode, instanceWidgets?: WidgetMap, contextWidgets?: WidgetMap, depth?: number): ReactNode;
 /**
  * Infer the schema's output type for SchemaField path inference.
  */

package/dist/react/SchemaComponent.mjs

@@ -1,13 +1,14 @@
 "use client";
-import { isObject, toRecord, toRecordOrUndefined } from "../core/guards.mjs";
+import { isObject, toRecordOrUndefined } from "../core/guards.mjs";
 import { normaliseSchema } from "../core/adapter.mjs";
 import { SchemaFieldError, SchemaNormalisationError, SchemaRenderError } from "../core/errors.mjs";
 import { 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 { createContext, isValidElement, useCallback, useContext, useMemo } from "react";
-import { jsx } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
 //#region src/react/SchemaComponent.tsx
 /**
 * <SchemaComponent> — renders UI from Zod, JSON Schema, or OpenAPI schemas.
@@ -101,10 +102,11 @@ function SchemaComponent({ schema: schemaInput, ref: refInput, value, onChange,
 		fieldOverrides: fields,
 		rootDocument
 	});
-	const renderChild = (childTree, childValue, childOnChange) => {
-		return renderField(childTree, childValue, childOnChange, userResolver, renderChild, instanceWidgets, contextWidgets);
+	const makeRenderChild = (currentDepth) => (childTree, childValue, childOnChange) => {
+		return renderField(childTree, childValue, childOnChange, userResolver, makeRenderChild(currentDepth + 1), instanceWidgets, contextWidgets, currentDepth + 1);
 	};
-	return renderField(tree, value ?? tree.defaultValue, handleChange, userResolver, renderChild, instanceWidgets, contextWidgets);
+	const renderChild = makeRenderChild(0);
+	return renderField(tree, value ?? tree.defaultValue, handleChange, userResolver, renderChild, instanceWidgets, contextWidgets, 0);
 }
 function runValidation(zodSchema, jsonSchema, value) {
 	if (zodSchema !== void 0 && isObject(zodSchema)) {
@@ -124,8 +126,17 @@ function runValidation(zodSchema, jsonSchema, value) {
 		}
 	}
 }
-function renderField(tree, value, onChange, userResolver, renderChild, instanceWidgets, contextWidgets) {
-	if (tree.meta.visible === false) return null;
+/** Maximum rendering depth before treating a field as recursive. */
+const MAX_RENDER_DEPTH = 10;
+function renderField(tree, value, onChange, userResolver, renderChild, instanceWidgets, contextWidgets, depth = 0) {
+	if (depth >= MAX_RENDER_DEPTH) {
+		const refTarget = tree.type === "recursive" ? tree.refTarget : "";
+		return /* @__PURE__ */ jsx("fieldset", { children: /* @__PURE__ */ jsxs("em", { children: [
+			"↻ ",
+			(typeof tree.meta.description === "string" ? tree.meta.description : refTarget) || "schema",
+			" (recursive)"
+		] }) });
+	}
 	const componentHint = tree.meta.component;
 	if (typeof componentHint === "string") {
 		const widget = instanceWidgets?.get(componentHint) ?? contextWidgets?.get(componentHint) ?? globalWidgets.get(componentHint);
@@ -166,13 +177,21 @@ function buildRenderProps(tree, value, onChange, renderChild) {
 		tree,
 		renderChild
 	};
-	if (tree.enumValues !== void 0) props.enumValues = tree.enumValues;
-	if (tree.element !== void 0) props.element = tree.element;
-	if (tree.fields !== void 0) props.fields = tree.fields;
-	if (tree.options !== void 0) props.options = tree.options;
-	if (tree.discriminator !== void 0) props.discriminator = tree.discriminator;
-	if (tree.keyType !== void 0) props.keyType = tree.keyType;
-	if (tree.valueType !== void 0) props.valueType = tree.valueType;
+	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 }) {
@@ -215,78 +234,10 @@ function SchemaField({ path, schema: schemaInput, ref: refInput, value, onChange
 		onChange,
 		onValidationError
 	]);
-	const renderChild = (childTree, childValue, childOnChange) => {
-		return renderField(childTree, childValue, childOnChange, userResolver, renderChild, void 0, contextWidgets);
+	const makeRenderChild = (currentDepth) => (childTree, childValue, childOnChange) => {
+		return renderField(childTree, childValue, childOnChange, userResolver, makeRenderChild(currentDepth + 1), void 0, contextWidgets, currentDepth + 1);
 	};
-	return renderField(fieldTree, fieldValue, handleChange, userResolver, renderChild, void 0, contextWidgets);
-}
-function resolvePath(tree, path) {
-	if (path.length === 0) return tree;
-	const parts = path.split(".");
-	let current = tree;
-	for (const part of parts) {
-		if (current === void 0) return void 0;
-		const bracketMatch = /^(.+)\[(\d+)\]$/.exec(part);
-		if (bracketMatch?.[1] !== void 0 && bracketMatch[2] !== void 0) {
-			const arrayField = bracketMatch[1];
-			if (current.fields !== void 0) current = current.fields[arrayField];
-			if (current?.element !== void 0) current = current.element;
-			continue;
-		}
-		if (current.fields !== void 0) current = current.fields[part];
-		else if (current.element !== void 0) current = current.element;
-		else return;
-	}
-	return current;
-}
-function resolveValue(root, path) {
-	if (path.length === 0) return root;
-	const parts = path.split(".");
-	let current = root;
-	for (const part of parts) {
-		if (typeof current !== "object" || current === null) return void 0;
-		const bracketMatch = /^(.+)\[(\d+)\]$/.exec(part);
-		if (bracketMatch?.[1] !== void 0 && bracketMatch[2] !== void 0) {
-			const key = bracketMatch[1];
-			const index = Number(bracketMatch[2]);
-			const arr = toRecord(current)[key];
-			if (Array.isArray(arr)) current = arr[index];
-			else return;
-		} else current = toRecord(current)[part];
-	}
-	return current;
-}
-function setNestedValue(root, path, leafValue) {
-	if (path.length === 0) return leafValue;
-	const parts = path.split(".");
-	const result = isObject(root) ? { ...toRecord(root) } : {};
-	let current = result;
-	for (let i = 0; i < parts.length; i++) {
-		const part = parts[i];
-		if (part === void 0) break;
-		const isLast = i === parts.length - 1;
-		const bracketMatch = /^(.+)\[(\d+)\]$/.exec(part);
-		if (bracketMatch?.[1] !== void 0 && bracketMatch[2] !== void 0) {
-			const key = bracketMatch[1];
-			const index = Number(bracketMatch[2]);
-			const existing = current[key];
-			const arr = Array.isArray(existing) ? existing.slice() : [];
-			if (isLast) arr[index] = leafValue;
-			current[key] = arr;
-			const nextCurrent = arr[index];
-			if (nextCurrent !== void 0 && isObject(nextCurrent)) current = toRecord(nextCurrent);
-		} else if (isLast) current[part] = leafValue;
-		else {
-			const existing = current[part];
-			const next = isObject(existing) ? { ...toRecord(existing) } : {};
-			current[part] = next;
-			current = next;
-		}
-	}
-	return result;
-}
-function isFieldErrorCallback(value) {
-	return typeof value === "function";
+	return renderField(fieldTree, fieldValue, handleChange, userResolver, makeRenderChild(0), void 0, contextWidgets, 0);
 }
 /**
 * Dispatch Zod errors to per-field onValidationError callbacks.
@@ -315,6 +266,9 @@ function dispatchFieldErrors(fields, error) {
 		if (fieldErrors.length > 0 && isFieldErrorCallback(fieldCallback)) fieldCallback({ issues: fieldErrors });
 	}
 }
+function isFieldErrorCallback(value) {
+	return typeof value === "function";
+}
 function isCallable(value) {
 	return typeof value === "function";
 }

package/dist/react/SchemaView.d.mts

@@ -1,4 +1,5 @@
-import { b as ComponentResolver, m as SchemaMeta } from "../types-BJzEgJdX.mjs";
+import { w as SchemaMeta } from "../types-ag2jYLqQ.mjs";
+import { r as ComponentResolver } from "../renderer-DseHeliw.mjs";
 import { WidgetMap } from "./SchemaComponent.mjs";
 import { ReactNode } from "react";
 

package/dist/react/SchemaView.mjs

@@ -3,7 +3,7 @@ import { SchemaNormalisationError, SchemaRenderError } from "../core/errors.mjs"
 import { getRenderFunction, mergeResolvers } from "../core/renderer.mjs";
 import { walk } from "../core/walker.mjs";
 import { headlessResolver } from "./headless.mjs";
-import { isValidElement } from "react";
+import { createElement, isValidElement } from "react";
 import { jsx } from "react/jsx-runtime";
 //#region src/react/SchemaView.tsx
 /**
@@ -61,7 +61,12 @@ function SchemaView({ schema: schemaInput, ref: refInput, value, fields, meta: c
 		rootDocument
 	});
 	const userResolver = resolver !== void 0 ? mergeResolvers(resolver, headlessResolver) : headlessResolver;
-	const renderChild = (childTree, childValue) => renderFieldServer(childTree, childValue, userResolver, renderChild, widgets);
+	const MAX_SERVER_DEPTH = 10;
+	const makeRenderChild = (currentDepth) => (childTree, childValue) => {
+		if (currentDepth >= MAX_SERVER_DEPTH) return createElement("fieldset", null, createElement("em", null, `\u21bb ${typeof childTree.meta.description === "string" ? childTree.meta.description : childTree.type === "recursive" ? childTree.refTarget : "schema"} (recursive)`));
+		return renderFieldServer(childTree, childValue, userResolver, makeRenderChild(currentDepth + 1), widgets);
+	};
+	const renderChild = makeRenderChild(0);
 	return renderFieldServer(tree, value ?? tree.defaultValue, userResolver, renderChild, widgets);
 }
 function renderFieldServer(tree, value, resolver, renderChild, widgets) {
@@ -99,13 +104,20 @@ function renderFieldServer(tree, value, resolver, renderChild, widgets) {
 			tree,
 			renderChild: (childTree, childValue) => renderChild(childTree, childValue)
 		};
-		if (tree.enumValues !== void 0) props.enumValues = tree.enumValues;
-		if (tree.element !== void 0) props.element = tree.element;
-		if (tree.fields !== void 0) props.fields = tree.fields;
-		if (tree.options !== void 0) props.options = tree.options;
-		if (tree.discriminator !== void 0) props.discriminator = tree.discriminator;
-		if (tree.keyType !== void 0) props.keyType = tree.keyType;
-		if (tree.valueType !== void 0) props.valueType = tree.valueType;
+		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;
 		try {
 			const result = renderFn(props);
 			if (result !== void 0 && result !== null) {

package/dist/react/fieldPath.d.mts

@@ -0,0 +1,20 @@
+import { j as WalkedField } from "../types-ag2jYLqQ.mjs";
+
+//#region src/react/fieldPath.d.ts
+/**
+ * Resolve a dot-separated path through a WalkedField tree.
+ * Supports array index notation: `field[0]`.
+ */
+declare function resolvePath(tree: WalkedField, path: string): WalkedField | undefined;
+/**
+ * Resolve a dot-separated path through a data value.
+ * Supports array index notation: `field[0]`.
+ */
+declare function resolveValue(root: unknown, path: string): unknown;
+/**
+ * Set a value at a dot-separated path, producing a new root object.
+ * Does not mutate the input — returns a shallow-updated copy at each level.
+ */
+declare function setNestedValue(root: unknown, path: string, leafValue: unknown): unknown;
+//#endregion
+export { resolvePath, resolveValue, setNestedValue };