schema-components 1.13.0 → 1.15.0

package/dist/openapi/ApiCallbacks.d.mts

@@ -0,0 +1,16 @@
+import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
+import { CallbackInfo } from "./parser.mjs";
+import { ReactNode } from "react";
+
+//#region src/openapi/ApiCallbacks.d.ts
+interface ApiCallbacksProps {
+  /** Callback definitions for this operation. */
+  callbacks: CallbackInfo[];
+  /** Optional meta overrides. */
+  meta?: SchemaMeta;
+}
+declare function ApiCallbacks({
+  callbacks
+}: ApiCallbacksProps): ReactNode;
+//#endregion
+export { ApiCallbacks, ApiCallbacksProps };

package/dist/openapi/ApiCallbacks.mjs

@@ -0,0 +1,34 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/openapi/ApiCallbacks.tsx
+function ApiCallbacks({ callbacks }) {
+	if (callbacks.length === 0) return null;
+	return /* @__PURE__ */ jsxs("section", {
+		"data-callbacks": true,
+		children: [/* @__PURE__ */ jsx("h4", { children: "Callbacks" }), callbacks.map((callback) => /* @__PURE__ */ jsxs("div", {
+			"data-callback": callback.name,
+			children: [/* @__PURE__ */ jsx("span", {
+				"data-callback-name": true,
+				children: callback.name
+			}), callback.operations.map((op) => /* @__PURE__ */ jsxs("div", {
+				"data-callback-operation": true,
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						"data-callback-method": true,
+						children: op.method.toUpperCase()
+					}),
+					" ",
+					/* @__PURE__ */ jsx("span", {
+						"data-callback-path": true,
+						children: op.path
+					}),
+					op.summary && /* @__PURE__ */ jsx("span", {
+						"data-callback-summary": true,
+						children: op.summary
+					})
+				]
+			}, `${op.method}-${op.path}`))]
+		}, callback.name))]
+	});
+}
+//#endregion
+export { ApiCallbacks };

package/dist/openapi/ApiLinks.d.mts

@@ -0,0 +1,16 @@
+import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
+import { LinkInfo } from "./parser.mjs";
+import { ReactNode } from "react";
+
+//#region src/openapi/ApiLinks.d.ts
+interface ApiLinksProps {
+  /** Link definitions for a response. */
+  links: LinkInfo[];
+  /** Optional meta overrides. */
+  meta?: SchemaMeta;
+}
+declare function ApiLinks({
+  links
+}: ApiLinksProps): ReactNode;
+//#endregion
+export { ApiLinks, ApiLinksProps };

package/dist/openapi/ApiLinks.mjs

@@ -0,0 +1,42 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/openapi/ApiLinks.tsx
+function ApiLinks({ links }) {
+	if (links.length === 0) return null;
+	return /* @__PURE__ */ jsxs("section", {
+		"data-links": true,
+		children: [/* @__PURE__ */ jsx("h4", { children: "Links" }), links.map((link) => /* @__PURE__ */ jsxs("div", {
+			"data-link": link.name,
+			children: [
+				/* @__PURE__ */ jsx("span", {
+					"data-link-name": true,
+					children: link.name
+				}),
+				link.operationId && /* @__PURE__ */ jsx("span", {
+					"data-link-operation-id": true,
+					children: link.operationId
+				}),
+				link.operationRef && /* @__PURE__ */ jsx("span", {
+					"data-link-operation-ref": true,
+					children: link.operationRef
+				}),
+				link.description && /* @__PURE__ */ jsx("span", {
+					"data-link-description": true,
+					children: link.description
+				}),
+				link.parameters.size > 0 && /* @__PURE__ */ jsx("dl", {
+					"data-link-parameters": true,
+					children: [...link.parameters.entries()].map(([paramName, paramValue]) => /* @__PURE__ */ jsxs("span", {
+						"data-link-parameter": paramName,
+						children: [
+							paramName,
+							": ",
+							paramValue
+						]
+					}, paramName))
+				})
+			]
+		}, link.name))]
+	});
+}
+//#endregion
+export { ApiLinks };

package/dist/openapi/ApiResponseHeaders.d.mts

@@ -0,0 +1,16 @@
+import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
+import { HeaderInfo } from "./parser.mjs";
+import { ReactNode } from "react";
+
+//#region src/openapi/ApiResponseHeaders.d.ts
+interface ApiResponseHeadersProps {
+  /** Header definitions for a response. */
+  headers: Map<string, HeaderInfo>;
+  /** Optional meta overrides. */
+  meta?: SchemaMeta;
+}
+declare function ApiResponseHeaders({
+  headers
+}: ApiResponseHeadersProps): ReactNode;
+//#endregion
+export { ApiResponseHeaders, ApiResponseHeadersProps };

package/dist/openapi/ApiResponseHeaders.mjs

@@ -0,0 +1,35 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/openapi/ApiResponseHeaders.tsx
+function ApiResponseHeaders({ headers }) {
+	if (headers.size === 0) return null;
+	return /* @__PURE__ */ jsxs("section", {
+		"data-response-headers": true,
+		children: [/* @__PURE__ */ jsx("h5", { children: "Headers" }), [...headers.entries()].map(([name, header]) => /* @__PURE__ */ jsxs("div", {
+			"data-header": name,
+			children: [
+				/* @__PURE__ */ jsx("span", {
+					"data-header-name": true,
+					children: name
+				}),
+				header.description && /* @__PURE__ */ jsx("span", {
+					"data-header-description": true,
+					children: header.description
+				}),
+				header.required && /* @__PURE__ */ jsx("span", {
+					"data-required": true,
+					children: "*"
+				}),
+				header.deprecated && /* @__PURE__ */ jsx("span", {
+					"data-deprecated": true,
+					children: "Deprecated"
+				}),
+				header.schema !== void 0 && "type" in header.schema && typeof header.schema.type === "string" ? /* @__PURE__ */ jsx("span", {
+					"data-header-type": true,
+					children: header.schema.type
+				}) : void 0
+			]
+		}, name))]
+	});
+}
+//#endregion
+export { ApiResponseHeaders };

package/dist/openapi/ApiSecurity.d.mts

@@ -0,0 +1,19 @@
+import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
+import { SecurityRequirement, SecurityScheme } from "./parser.mjs";
+import { ReactNode } from "react";
+
+//#region src/openapi/ApiSecurity.d.ts
+interface ApiSecurityProps {
+  /** Security requirements for this operation. */
+  requirements: SecurityRequirement[];
+  /** Security schemes from the document's components. */
+  schemes: Map<string, SecurityScheme>;
+  /** Optional meta overrides. */
+  meta?: SchemaMeta;
+}
+declare function ApiSecurity({
+  requirements,
+  schemes
+}: ApiSecurityProps): ReactNode;
+//#endregion
+export { ApiSecurity, ApiSecurityProps };

package/dist/openapi/ApiSecurity.mjs

@@ -0,0 +1,33 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/openapi/ApiSecurity.tsx
+function ApiSecurity({ requirements, schemes }) {
+	if (requirements.length === 0) return null;
+	return /* @__PURE__ */ jsxs("section", {
+		"data-security": true,
+		children: [/* @__PURE__ */ jsx("h4", { children: "Security" }), requirements.map((req, index) => {
+			const scheme = schemes.get(req.name);
+			return /* @__PURE__ */ jsxs("div", {
+				"data-security-scheme": req.name,
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						"data-security-name": true,
+						children: req.name
+					}),
+					scheme !== void 0 && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+						"data-security-type": true,
+						children: scheme.type
+					}), scheme.description && /* @__PURE__ */ jsx("span", {
+						"data-security-description": true,
+						children: scheme.description
+					})] }),
+					req.scopes.length > 0 && /* @__PURE__ */ jsx("span", {
+						"data-security-scopes": true,
+						children: req.scopes.join(", ")
+					})
+				]
+			}, `${req.name}-${String(index)}`);
+		})]
+	});
+}
+//#endregion
+export { ApiSecurity };

package/dist/openapi/bundle.d.mts

@@ -0,0 +1,47 @@
+//#region src/openapi/bundle.d.ts
+/**
+ * OpenAPI document bundler — inlines external $ref files.
+ *
+ * Walks all `$ref` strings in an OpenAPI document, fetches external
+ * documents via a user-provided resolver, inlines their schemas into
+ * `components.schemas` with synthesised names, and rewrites the refs
+ * to point to the inlined copies.
+ *
+ * This is an opt-in async pre-step. The synchronous core API is unchanged;
+ * consumers call `bundleOpenApiDoc` once before rendering.
+ *
+ * Usage:
+ * ```ts
+ * import { bundleOpenApiDoc } from "schema-components/openapi/bundle";
+ *
+ * const resolver = async (uri: string) => {
+ *     const response = await fetch(uri);
+ *     return response.json();
+ * };
+ *
+ * const bundled = await bundleOpenApiDoc(doc, resolver);
+ * // Now pass bundled to SchemaComponent / ApiOperation
+ * ```
+ */
+/**
+ * Resolver function for external documents.
+ * Called with the URI portion of an external $ref (everything before `#`).
+ * Returns the parsed JSON document.
+ */
+type BundleResolver = (uri: string) => unknown;
+/**
+ * Bundle an OpenAPI document by inlining all external $ref targets.
+ *
+ * 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.
+ *
+ * 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.
+ */
+declare function bundleOpenApiDoc(doc: Record<string, unknown>, resolver: BundleResolver): Promise<Record<string, unknown>>;
+//#endregion
+export { BundleResolver, bundleOpenApiDoc };

package/dist/openapi/bundle.mjs

@@ -0,0 +1,95 @@
+import { isObject } from "../core/guards.mjs";
+//#region src/openapi/bundle.ts
+/**
+* OpenAPI document bundler — inlines external $ref files.
+*
+* Walks all `$ref` strings in an OpenAPI document, fetches external
+* documents via a user-provided resolver, inlines their schemas into
+* `components.schemas` with synthesised names, and rewrites the refs
+* to point to the inlined copies.
+*
+* This is an opt-in async pre-step. The synchronous core API is unchanged;
+* consumers call `bundleOpenApiDoc` once before rendering.
+*
+* Usage:
+* ```ts
+* import { bundleOpenApiDoc } from "schema-components/openapi/bundle";
+*
+* const resolver = async (uri: string) => {
+*     const response = await fetch(uri);
+*     return response.json();
+* };
+*
+* const bundled = await bundleOpenApiDoc(doc, resolver);
+* // Now pass bundled to SchemaComponent / ApiOperation
+* ```
+*/
+/**
+* Bundle an OpenAPI document by inlining all external $ref targets.
+*
+* 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.
+*
+* 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.
+*/
+async function bundleOpenApiDoc(doc, resolver) {
+	const result = structuredClone(doc);
+	const uriCache = /* @__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);
+	return result;
+}
+/**
+* Walk a document tree, find external $ref strings, resolve them,
+* inline the targets, and rewrite the refs.
+*/
+async function walkAndInline(node, uriCache, resolver) {
+	if (!isObject(node)) return;
+	if (typeof node.$ref === "string" && !node.$ref.startsWith("#")) {
+		const ref = node.$ref;
+		const hashIndex = ref.indexOf("#");
+		const uri = hashIndex >= 0 ? ref.slice(0, hashIndex) : ref;
+		const fragment = hashIndex >= 0 ? ref.slice(hashIndex) : "#";
+		let externalDoc = uriCache.get(uri);
+		if (externalDoc === void 0) {
+			const resolved = await resolver(uri);
+			if (isObject(resolved)) {
+				externalDoc = resolved;
+				uriCache.set(uri, externalDoc);
+			}
+		}
+		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;
+			}
+		}
+	}
+	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);
+}
+/**
+* Resolve a JSON Pointer fragment within a document.
+*/
+function resolveFragment(doc, fragment) {
+	if (fragment === "#" || fragment === "") return doc;
+	if (!fragment.startsWith("#/")) return void 0;
+	const parts = fragment.slice(2).split("/");
+	let current = doc;
+	for (const part of parts) {
+		if (!isObject(current)) return void 0;
+		const decoded = part.replace(/~1/g, "/").replace(/~0/g, "~");
+		current = current[decoded];
+	}
+	return isObject(current) ? current : void 0;
+}
+//#endregion
+export { bundleOpenApiDoc };

package/dist/openapi/components.d.mts

@@ -1,5 +1,5 @@
-import { u as FieldOverride, w as SchemaMeta } from "../types-ag2jYLqQ.mjs";
-import { i as InferResponseFields, n as InferParameterOverrides, r as InferRequestBodyFields } from "../typeInference-CRPqVwKu.mjs";
+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 { WidgetMap } from "../react/SchemaComponent.mjs";
 import { ReactNode } from "react";
 
@@ -13,6 +13,11 @@ interface ApiOperationProps<Doc = unknown, Path extends string = string, Method
   responseValue?: unknown;
   meta?: SchemaMeta;
   requestBodyFields?: Doc extends Record<string, unknown> ? InferRequestBodyFields<Doc, Path, Method> : Record<string, FieldOverride>;
+  /** Escape hatch for recursive schemas where type-level inference fails.
+   * Typed as Record<string, FieldOverride> — use when the schema contains
+   * deeply nested $ref chains.
+   */
+  unsafeFields?: UnsafeFields;
   /** Instance-scoped widgets. */
   widgets?: WidgetMap;
 }

package/dist/openapi/components.mjs

@@ -1,9 +1,14 @@
 import { toRecordOrUndefined } from "../core/guards.mjs";
-import { normaliseSchema } from "../core/adapter.mjs";
 import { SchemaNormalisationError } from "../core/errors.mjs";
+import { normaliseSchema } from "../core/adapter.mjs";
 import { walk } from "../core/walker.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 { renderField } from "../react/SchemaComponent.mjs";
-import { resolveOperation, resolveParameters, resolveRequestBody, resolveResponse, toDoc } from "./resolve.mjs";
+import { getParsed, resolveOperation, resolveParameters, resolveRequestBody, resolveResponse, toDoc } from "./resolve.mjs";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 //#region src/openapi/components.tsx
 function noop() {}
@@ -33,10 +38,19 @@ function renderSchema(schema, rootDocument, options) {
 function ApiOperation({ schema: doc, path, method, requestBodyValue, onRequestBodyChange, responseValue, meta, requestBodyFields, widgets }) {
 	const rootDoc = toDoc(doc);
 	const resolved = resolveOperation(rootDoc, path, method);
+	const parsed = getParsed(rootDoc);
+	const securityReqs = getSecurityRequirements(parsed, path, method);
+	const securitySchemes = getSecuritySchemes(parsed);
+	const callbacks = listCallbacks(parsed, path, method);
 	return /* @__PURE__ */ jsxs("section", {
 		"data-operation": `${method.toUpperCase()} ${path}`,
 		children: [
 			/* @__PURE__ */ jsx(OperationHeader, { operation: resolved.operation }),
+			/* @__PURE__ */ jsx(ApiSecurity, {
+				requirements: securityReqs,
+				schemes: securitySchemes
+			}),
+			/* @__PURE__ */ jsx(ApiCallbacks, { callbacks }),
 			resolved.parameters.length > 0 && /* @__PURE__ */ jsxs("section", {
 				"data-parameters": true,
 				children: [/* @__PURE__ */ jsx("h4", { children: "Parameters" }), /* @__PURE__ */ jsx(ParameterList, {
@@ -74,7 +88,9 @@ function ApiOperation({ schema: doc, path, method, requestBodyValue, onRequestBo
 					rootDoc,
 					value: responseValue,
 					meta,
-					widgets
+					widgets,
+					path,
+					method
 				}, response.statusCode))]
 			})
 		]
@@ -138,7 +154,9 @@ function ApiResponse({ schema: doc, path, method, status, value, meta, fields, w
 		value,
 		fields,
 		meta,
-		widgets
+		widgets,
+		path,
+		method
 	});
 }
 function OperationHeader({ operation }) {
@@ -174,7 +192,7 @@ function ParameterList({ parameters, rootDoc, overrides, meta, widgets }) {
 		]
 	}, param.name)) });
 }
-function ResponseCard({ response, rootDoc, value, fields, meta, widgets }) {
+function ResponseCard({ response, rootDoc, value, fields, meta, widgets, path, method }) {
 	if (response.schema === void 0) return /* @__PURE__ */ jsxs("div", {
 		"data-status": response.statusCode,
 		children: [
@@ -183,6 +201,10 @@ function ResponseCard({ response, rootDoc, value, fields, meta, widgets }) {
 			/* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx("em", { children: "No schema" }) })
 		]
 	});
+	let links = [];
+	if (path !== void 0 && method !== void 0) try {
+		links = getLinks(getParsed(rootDoc), path, method, response.statusCode);
+	} catch {}
 	return /* @__PURE__ */ jsxs("div", {
 		"data-status": response.statusCode,
 		children: [
@@ -196,7 +218,9 @@ function ResponseCard({ response, rootDoc, value, fields, meta, widgets }) {
 					...meta
 				},
 				widgets
-			})
+			}),
+			/* @__PURE__ */ jsx(ApiResponseHeaders, { headers: response.headers }),
+			/* @__PURE__ */ jsx(ApiLinks, { links })
 		]
 	});
 }

package/dist/openapi/parser.d.mts

@@ -1,4 +1,4 @@
-import { m as JsonObject } from "../types-ag2jYLqQ.mjs";
+import { m as JsonObject } from "../types-D_5ST7SS.mjs";
 
 //#region src/openapi/parser.d.ts
 interface OpenApiDocument {

package/dist/react/SchemaComponent.d.mts

@@ -1,10 +1,11 @@
-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 { 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 SchemaError } from "../errors-C5zRC2PU.mjs";
+import { l as RenderProps, r as ComponentResolver } from "../renderer-BdSqllx5.mjs";
+import { c as ResolveOpenAPIRef, s as PathOfType, t as FromJSONSchema } from "../typeInference-k7FXfTVO.mjs";
 import { z } from "zod";
-import { ReactNode } from "react";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+import { ReactNode } from "react";
 
 //#region src/react/SchemaComponent.d.ts
 /**
@@ -53,6 +54,10 @@ interface SchemaComponentProps<T = unknown, Ref extends string | undefined = und
   onValidationError?: (error: unknown) => void;
   /** Called when schema normalisation or rendering fails. */
   onError?: (error: SchemaError) => void;
+  /** Called with each diagnostic emitted during schema processing. */
+  onDiagnostic?: (diagnostic: Diagnostic) => void;
+  /** When true, any diagnostic becomes a thrown error. */
+  strict?: boolean;
   /** Per-field meta overrides — nested object mirroring schema shape. */
   fields?: InferFields<T, Ref>;
   /** Meta overrides applied to the root schema. */
@@ -74,6 +79,8 @@ declare function SchemaComponent<T = unknown, Ref extends string | undefined = u
   validate,
   onValidationError,
   onError,
+  onDiagnostic,
+  strict,
   fields,
   meta: componentMeta,
   readOnly,

package/dist/react/SchemaComponent.mjs

@@ -1,14 +1,14 @@
 "use client";
 import { isObject, toRecordOrUndefined } from "../core/guards.mjs";
-import { normaliseSchema } from "../core/adapter.mjs";
 import { SchemaFieldError, SchemaNormalisationError, SchemaRenderError } from "../core/errors.mjs";
+import { normaliseSchema } from "../core/adapter.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, jsxs } from "react/jsx-runtime";
+import { createContext, isValidElement, useCallback, useContext, useMemo } from "react";
 //#region src/react/SchemaComponent.tsx
 /**
 * <SchemaComponent> — renders UI from Zod, JSON Schema, or OpenAPI schemas.
@@ -46,7 +46,7 @@ const globalWidgets = /* @__PURE__ */ new Map();
 function registerWidget(name, render) {
 	globalWidgets.set(name, render);
 }
-function SchemaComponent({ schema: schemaInput, ref: refInput, value, onChange, validate, onValidationError, onError, fields, meta: componentMeta, readOnly, writeOnly, description, widgets: instanceWidgets }) {
+function SchemaComponent({ schema: schemaInput, ref: refInput, value, onChange, validate, onValidationError, onError, onDiagnostic, strict, fields, meta: componentMeta, readOnly, writeOnly, description, widgets: instanceWidgets }) {
 	const userResolver = useContext(UserResolverContext);
 	const contextWidgets = useContext(WidgetsContext);
 	const mergedMeta = useMemo(() => {
@@ -61,12 +61,16 @@ function SchemaComponent({ schema: schemaInput, ref: refInput, value, onChange,
 		writeOnly,
 		description
 	]);
+	const diagnostics = onDiagnostic !== void 0 || strict === true ? {
+		...onDiagnostic !== void 0 ? { diagnostics: onDiagnostic } : {},
+		...strict !== void 0 ? { strict } : {}
+	} : void 0;
 	let jsonSchema;
 	let zodSchema;
 	let rootMeta;
 	let rootDocument;
 	try {
-		const normalised = normaliseSchema(schemaInput, refInput);
+		const normalised = normaliseSchema(schemaInput, refInput, diagnostics !== void 0 ? { diagnostics } : void 0);
 		jsonSchema = normalised.jsonSchema;
 		zodSchema = normalised.zodSchema;
 		rootMeta = normalised.rootMeta;
@@ -96,12 +100,14 @@ function SchemaComponent({ schema: schemaInput, ref: refInput, value, onChange,
 		onValidationError,
 		fields
 	]);
-	const tree = walk(jsonSchema, {
+	const walkOptions = {
 		componentMeta: mergedMeta,
 		rootMeta,
 		fieldOverrides: fields,
-		rootDocument
-	});
+		rootDocument,
+		...diagnostics !== void 0 ? { diagnostics } : {}
+	};
+	const tree = walk(jsonSchema, walkOptions);
 	const makeRenderChild = (currentDepth) => (childTree, childValue, childOnChange) => {
 		return renderField(childTree, childValue, childOnChange, userResolver, makeRenderChild(currentDepth + 1), instanceWidgets, contextWidgets, currentDepth + 1);
 	};

package/dist/react/SchemaView.d.mts

@@ -1,5 +1,6 @@
-import { w as SchemaMeta } from "../types-ag2jYLqQ.mjs";
-import { r as ComponentResolver } from "../renderer-DseHeliw.mjs";
+import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
+import { t as Diagnostic } from "../diagnostics-DzbZmcLI.mjs";
+import { r as ComponentResolver } from "../renderer-BdSqllx5.mjs";
 import { WidgetMap } from "./SchemaComponent.mjs";
 import { ReactNode } from "react";
 
@@ -25,6 +26,10 @@ interface SchemaViewProps {
   resolver?: ComponentResolver;
   /** Instance-scoped widgets. */
   widgets?: WidgetMap;
+  /** Called with each diagnostic emitted during schema processing. */
+  onDiagnostic?: (diagnostic: Diagnostic) => void;
+  /** When true, any diagnostic becomes a thrown error. */
+  strict?: boolean;
 }
 /**
  * Server-safe schema renderer — no hooks, no context, no state.
@@ -40,7 +45,9 @@ declare function SchemaView({
   meta: componentMeta,
   description,
   resolver,
-  widgets
+  widgets,
+  onDiagnostic,
+  strict
 }: SchemaViewProps): ReactNode;
 //#endregion
 export { SchemaView, SchemaViewProps };

package/dist/react/SchemaView.mjs

@@ -1,10 +1,10 @@
-import { normaliseSchema } from "../core/adapter.mjs";
 import { SchemaNormalisationError, SchemaRenderError } from "../core/errors.mjs";
+import { normaliseSchema } from "../core/adapter.mjs";
 import { getRenderFunction, mergeResolvers } from "../core/renderer.mjs";
 import { walk } from "../core/walker.mjs";
 import { headlessResolver } from "./headless.mjs";
-import { createElement, isValidElement } from "react";
 import { jsx } from "react/jsx-runtime";
+import { createElement, isValidElement } from "react";
 //#region src/react/SchemaView.tsx
 /**
 * React Server Component for read-only schema rendering.
@@ -37,29 +37,35 @@ function noop() {}
 * Always renders in read-only mode. For editable forms, use
 * `<SchemaComponent>` with `"use client"`.
 */
-function SchemaView({ schema: schemaInput, ref: refInput, value, fields, meta: componentMeta, description, resolver, widgets }) {
+function SchemaView({ schema: schemaInput, ref: refInput, value, fields, meta: componentMeta, description, resolver, widgets, onDiagnostic, strict }) {
 	const mergedMeta = {
 		...componentMeta,
 		readOnly: true
 	};
 	if (description !== void 0) mergedMeta.description = description;
+	const diagnostics = onDiagnostic !== void 0 || strict === true ? {
+		...onDiagnostic !== void 0 ? { diagnostics: onDiagnostic } : {},
+		...strict !== void 0 ? { strict } : {}
+	} : void 0;
 	let jsonSchema;
 	let rootMeta;
 	let rootDocument;
 	try {
-		const normalised = normaliseSchema(schemaInput, refInput);
+		const normalised = normaliseSchema(schemaInput, refInput, diagnostics !== void 0 ? { diagnostics } : void 0);
 		jsonSchema = normalised.jsonSchema;
 		rootMeta = normalised.rootMeta;
 		rootDocument = normalised.rootDocument;
 	} catch (err) {
 		throw new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", schemaInput, "unknown");
 	}
-	const tree = walk(jsonSchema, {
+	const walkOptions = {
 		componentMeta: mergedMeta,
 		rootMeta,
 		fieldOverrides: fields,
-		rootDocument
-	});
+		rootDocument,
+		...diagnostics !== void 0 ? { diagnostics } : {}
+	};
+	const tree = walk(jsonSchema, walkOptions);
 	const userResolver = resolver !== void 0 ? mergeResolvers(resolver, headlessResolver) : headlessResolver;
 	const MAX_SERVER_DEPTH = 10;
 	const makeRenderChild = (currentDepth) => (childTree, childValue) => {