schema-components 1.20.0 → 1.21.0

package/dist/openapi/components.mjs

@@ -6,7 +6,7 @@ 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 { getParsed, resolveOperationFromParsed, resolveParametersFromParsed, resolveRequestBodyFromParsed, resolveResponseFromParsed, toDoc } from "./resolve.mjs";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { useId } from "react";
 //#region src/openapi/components.tsx
@@ -23,6 +23,13 @@ import { useId } from "react";
 * rendered via the walker + headless resolver directly, bypassing
 * SchemaComponent to avoid deferred-conditional-type compatibility issues.
 */
+function buildDiagnostics(onDiagnostic, strict) {
+	if (onDiagnostic === void 0 && strict !== true) return void 0;
+	const opts = {};
+	if (onDiagnostic !== void 0) opts.diagnostics = onDiagnostic;
+	if (strict === true) opts.strict = true;
+	return opts;
+}
 function noop() {}
 function renderSchema(schema, rootDocument, options) {
 	if (!isObject(schema)) throw new Error("renderSchema received a non-object schema from the resolver.");
@@ -42,10 +49,10 @@ function renderSchema(schema, rootDocument, options) {
 	};
 	return renderField(tree, options.value, options.onChange ?? noop, void 0, makeRenderChild(options.rootPath), options.rootPath, options.widgets);
 }
-function ApiOperation({ schema: doc, path, method, requestBodyValue, onRequestBodyChange, responseValue, meta, requestBodyFields, widgets }) {
+function ApiOperation({ schema: doc, path, method, requestBodyValue, onRequestBodyChange, responseValue, meta, requestBodyFields, widgets, onDiagnostic, strict }) {
 	const rootDoc = toDoc(doc);
-	const resolved = resolveOperation(rootDoc, path, method);
-	const parsed = getParsed(rootDoc);
+	const parsed = getParsed(rootDoc, buildDiagnostics(onDiagnostic, strict));
+	const resolved = resolveOperationFromParsed(parsed, path, method);
 	const securityReqs = getSecurityRequirements(parsed, path, method);
 	const securitySchemes = getSecuritySchemes(parsed);
 	const callbacks = listCallbacks(parsed, path, method);
@@ -99,6 +106,7 @@ function ApiOperation({ schema: doc, path, method, requestBodyValue, onRequestBo
 				children: [/* @__PURE__ */ jsx("h4", { children: "Responses" }), resolved.responses.map((response) => /* @__PURE__ */ jsx(ResponseCard, {
 					response,
 					rootDoc,
+					parsed,
 					value: responseValue,
 					meta,
 					widgets,
@@ -110,9 +118,9 @@ function ApiOperation({ schema: doc, path, method, requestBodyValue, onRequestBo
 		]
 	});
 }
-function ApiParameters({ schema: doc, path, method, meta, overrides, widgets }) {
+function ApiParameters({ schema: doc, path, method, meta, overrides, widgets, onDiagnostic, strict }) {
 	const rootDoc = toDoc(doc);
-	const params = resolveParameters(rootDoc, path, method);
+	const params = resolveParametersFromParsed(getParsed(rootDoc, buildDiagnostics(onDiagnostic, strict)), path, method);
 	const instancePrefix = sanitisePrefix(useId());
 	if (params.length === 0) return null;
 	return /* @__PURE__ */ jsxs("section", {
@@ -127,9 +135,9 @@ function ApiParameters({ schema: doc, path, method, meta, overrides, widgets })
 		})]
 	});
 }
-function ApiRequestBody({ schema: doc, path, method, value, onChange, meta, fields, widgets }) {
+function ApiRequestBody({ schema: doc, path, method, value, onChange, meta, fields, widgets, onDiagnostic, strict }) {
 	const rootDoc = toDoc(doc);
-	const requestBody = resolveRequestBody(rootDoc, path, method);
+	const requestBody = resolveRequestBodyFromParsed(getParsed(rootDoc, buildDiagnostics(onDiagnostic, strict)), path, method);
 	const instancePrefix = sanitisePrefix(useId());
 	if (requestBody?.schema === void 0) return null;
 	return /* @__PURE__ */ jsxs("section", {
@@ -155,9 +163,10 @@ function ApiRequestBody({ schema: doc, path, method, value, onChange, meta, fiel
 		]
 	});
 }
-function ApiResponse({ schema: doc, path, method, status, value, meta, fields, widgets }) {
+function ApiResponse({ schema: doc, path, method, status, value, meta, fields, widgets, onDiagnostic, strict }) {
 	const rootDoc = toDoc(doc);
-	const response = resolveResponse(rootDoc, path, method, status);
+	const parsed = getParsed(rootDoc, buildDiagnostics(onDiagnostic, strict));
+	const response = resolveResponseFromParsed(parsed, path, method, status);
 	const instancePrefix = sanitisePrefix(useId());
 	if (response.schema === void 0) return /* @__PURE__ */ jsxs("div", {
 		"data-status": status,
@@ -170,6 +179,7 @@ function ApiResponse({ schema: doc, path, method, status, value, meta, fields, w
 	return /* @__PURE__ */ jsx(ResponseCard, {
 		response,
 		rootDoc,
+		parsed,
 		value,
 		fields,
 		meta,
@@ -227,7 +237,7 @@ function ParameterList({ parameters, rootDoc, overrides, meta, widgets, idPrefix
 		]
 	}, param.name)) });
 }
-function ResponseCard({ response, rootDoc, value, fields, meta, widgets, path, method, idPrefix }) {
+function ResponseCard({ response, rootDoc, parsed, value, fields, meta, widgets, path, method, idPrefix }) {
 	if (response.schema === void 0) return /* @__PURE__ */ jsxs("div", {
 		"data-status": response.statusCode,
 		children: [
@@ -237,7 +247,7 @@ function ResponseCard({ response, rootDoc, value, fields, meta, widgets, path, m
 		]
 	});
 	let links = [];
-	if (path !== void 0 && method !== void 0) links = getLinks(getParsed(rootDoc), path, method, response.statusCode);
+	if (path !== void 0 && method !== void 0) links = getLinks(parsed, path, method, response.statusCode);
 	return /* @__PURE__ */ jsxs("div", {
 		"data-status": response.statusCode,
 		children: [

package/dist/openapi/parser.d.mts

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

package/dist/openapi/parser.mjs

@@ -120,8 +120,10 @@ function resolveParam(doc, param) {
 	return param;
 }
 function getRequestBody(parsed, path, method) {
-	const requestBody = getProperty(getProperty(lookupPathItem(parsed, path), method), "requestBody");
-	if (!isObject(requestBody)) return void 0;
+	const requestBodyRaw = getProperty(getProperty(lookupPathItem(parsed, path), method), "requestBody");
+	if (!isObject(requestBodyRaw)) return void 0;
+	const requestBody = resolveWrapperRef(parsed.doc, requestBodyRaw);
+	if (requestBody === void 0) return void 0;
 	const content = getProperty(requestBody, "content");
 	if (!isObject(content)) return {
 		required: getProperty(requestBody, "required") === true,
@@ -142,8 +144,10 @@ function getResponses(parsed, path, method) {
 	const responses = getProperty(getProperty(lookupPathItem(parsed, path), method), "responses");
 	if (!isObject(responses)) return [];
 	const result = [];
-	for (const [statusCode, response] of Object.entries(responses)) {
-		if (!isObject(response)) continue;
+	for (const [statusCode, responseRaw] of Object.entries(responses)) {
+		if (!isObject(responseRaw)) continue;
+		const response = resolveWrapperRef(parsed.doc, responseRaw);
+		if (response === void 0) continue;
 		const content = getProperty(response, "content");
 		const contentTypes = isObject(content) ? Object.keys(content) : [];
 		const schema = isObject(content) ? extractSchemaFromContent(content) : void 0;
@@ -158,15 +162,46 @@ function getResponses(parsed, path, method) {
 	}
 	return result;
 }
+/**
+* Resolve a single-hop `$ref` on a wrapper object — Response Object,
+* Request Body Object, etc. — against the document root. Returns the
+* referenced node when the wrapper is a `$ref`, the wrapper itself when
+* it has no `$ref`, or `undefined` when the `$ref` is malformed or
+* cannot be resolved (so the caller skips the entry rather than reading
+* stale fields from the bare `{ $ref }` envelope).
+*/
+function resolveWrapperRef(doc, wrapper) {
+	const ref = getString(wrapper, "$ref");
+	if (ref === void 0) return wrapper;
+	return resolveRefInDoc(doc, ref);
+}
 function extractSchemaFromContent(content) {
 	const jsonSchema = getProperty(getProperty(content, "application/json"), "schema");
 	if (isObject(jsonSchema)) return jsonSchema;
+	for (const [mediaType, mediaObj] of Object.entries(content)) {
+		if (!isJsonSuffixMediaType(mediaType)) continue;
+		if (!isObject(mediaObj)) continue;
+		const schema = getProperty(mediaObj, "schema");
+		if (isObject(schema)) return schema;
+	}
 	for (const mediaType of Object.values(content)) {
 		if (!isObject(mediaType)) continue;
 		const schema = getProperty(mediaType, "schema");
 		if (isObject(schema)) return schema;
 	}
 }
+/**
+* Detect RFC 6839 structured-syntax-suffix media types that encode JSON.
+* Matches `application/<anything>+json`, optionally with parameters
+* (`; charset=utf-8`). Excludes the literal `application/json`, which
+* the caller checks separately to preserve preference order.
+*/
+function isJsonSuffixMediaType(mediaType) {
+	const lower = mediaType.toLowerCase();
+	if (lower === "application/json") return false;
+	const baseType = lower.split(";", 1)[0]?.trim() ?? "";
+	return baseType.startsWith("application/") && baseType.endsWith("+json");
+}
 function resolveRefInDoc(doc, ref) {
 	if (!ref.startsWith("#/")) return void 0;
 	const parts = ref.slice(2).split("/");

package/dist/openapi/resolve.d.mts

@@ -1,3 +1,4 @@
+import { i as DiagnosticsOptions } from "../diagnostics-CbBPsxSt.mjs";
 import { OpenApiDocument, OperationInfo, ParameterInfo, ResponseInfo, getRequestBody } from "./parser.mjs";
 
 //#region src/openapi/resolve.d.ts
@@ -14,10 +15,19 @@ import { OpenApiDocument, OperationInfo, ParameterInfo, ResponseInfo, getRequest
  * 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.
+ * When `diagnostics` is supplied, normalisation events
+ * (`duplicate-body-parameter`, `dropped-swagger-feature`,
+ * `unknown-json-schema-dialect`, `divisible-by-conflict`,
+ * `relative-ref-resolved`, etc.) are forwarded to the sink. Passing
+ * diagnostics also bypasses the cache so each call observes the
+ * normalisation pipeline running against the supplied sink — caching
+ * would silently swallow every emission after the first.
+ *
+ * The cache is keyed by the caller-supplied document so subsequent
+ * cache-eligible calls with the same input bypass both normalisation
+ * and parsing.
  */
-declare function getParsed(doc: Record<string, unknown>): OpenApiDocument;
+declare function getParsed(doc: Record<string, unknown>, diagnostics?: DiagnosticsOptions): OpenApiDocument;
 /**
  * Coerce an unknown value to a record, returning an empty record
  * for non-objects.
@@ -39,26 +49,67 @@ interface ResolvedOperation {
   requestBody: ReturnType<typeof getRequestBody>;
   responses: ResponseInfo[];
 }
+/**
+ * Resolve an operation against an already-parsed document. Throws if
+ * the operation is not found.
+ *
+ * Used by callers that have already obtained a parsed document via
+ * {@link getParsed} — most importantly the React components, which
+ * supply `diagnostics` to `getParsed` and must avoid re-running the
+ * normalisation pipeline (every re-run would emit each diagnostic
+ * again into the sink).
+ */
+declare function resolveOperationFromParsed(parsed: OpenApiDocument, path: string, method: string): ResolvedOperation;
 /**
  * Resolve an operation from an OpenAPI document by path and method.
  * Throws if the operation is not found.
+ *
+ * `diagnostics` is forwarded to {@link getParsed} so normalisation
+ * events surface to the caller's sink.
+ */
+declare function resolveOperation(doc: Record<string, unknown>, path: string, method: string, diagnostics?: DiagnosticsOptions): ResolvedOperation;
+/**
+ * Resolve parameters against an already-parsed document. See
+ * {@link resolveOperationFromParsed} for the rationale.
  */
-declare function resolveOperation(doc: Record<string, unknown>, path: string, method: string): ResolvedOperation;
+declare function resolveParametersFromParsed(parsed: OpenApiDocument, path: string, method: string): ParameterInfo[];
 /**
  * Resolve parameters for an operation. Returns empty array if none.
+ *
+ * `diagnostics` is forwarded to {@link getParsed} so normalisation
+ * events surface to the caller's sink.
  */
-declare function resolveParameters(doc: Record<string, unknown>, path: string, method: string): ParameterInfo[];
+declare function resolveParameters(doc: Record<string, unknown>, path: string, method: string, diagnostics?: DiagnosticsOptions): ParameterInfo[];
+/**
+ * Resolve a request body against an already-parsed document. See
+ * {@link resolveOperationFromParsed} for the rationale.
+ */
+declare function resolveRequestBodyFromParsed(parsed: OpenApiDocument, path: string, method: string): ReturnType<typeof getRequestBody>;
 /**
  * Resolve request body for an operation. Returns undefined if none.
+ *
+ * `diagnostics` is forwarded to {@link getParsed} so normalisation
+ * events surface to the caller's sink.
  */
-declare function resolveRequestBody(doc: Record<string, unknown>, path: string, method: string): ReturnType<typeof getRequestBody>;
+declare function resolveRequestBody(doc: Record<string, unknown>, path: string, method: string, diagnostics?: DiagnosticsOptions): ReturnType<typeof getRequestBody>;
+/**
+ * Resolve a specific response against an already-parsed document. See
+ * {@link resolveOperationFromParsed} for the rationale.
+ */
+declare function resolveResponseFromParsed(parsed: OpenApiDocument, path: string, method: string, statusCode: string): ResponseInfo;
 /**
  * Resolve a specific response by status code. Throws if not found.
+ *
+ * `diagnostics` is forwarded to {@link getParsed} so normalisation
+ * events surface to the caller's sink.
  */
-declare function resolveResponse(doc: Record<string, unknown>, path: string, method: string, statusCode: string): ResponseInfo;
+declare function resolveResponse(doc: Record<string, unknown>, path: string, method: string, statusCode: string, diagnostics?: DiagnosticsOptions): ResponseInfo;
 /**
  * Resolve all responses for an operation.
+ *
+ * `diagnostics` is forwarded to {@link getParsed} so normalisation
+ * events surface to the caller's sink.
  */
-declare function resolveResponses(doc: Record<string, unknown>, path: string, method: string): ResponseInfo[];
+declare function resolveResponses(doc: Record<string, unknown>, path: string, method: string, diagnostics?: DiagnosticsOptions): ResponseInfo[];
 //#endregion
-export { PathItemInfo, ResolvedOperation, getParsed, resolveOperation, resolveParameters, resolveRequestBody, resolveResponse, resolveResponses, toDoc };
+export { PathItemInfo, ResolvedOperation, getParsed, resolveOperation, resolveOperationFromParsed, resolveParameters, resolveParametersFromParsed, resolveRequestBody, resolveRequestBodyFromParsed, resolveResponse, resolveResponseFromParsed, resolveResponses, toDoc };

package/dist/openapi/resolve.mjs

@@ -1,6 +1,7 @@
 import { getProperty, isObject } from "../core/guards.mjs";
+import { isPrototypePollutingKey } from "../core/uri.mjs";
 import { detectOpenApiVersion } from "../core/version.mjs";
-import { a as normaliseOpenApiSchemas } from "../normalise-CMMEl4cd.mjs";
+import { a as normaliseOpenApiSchemas } from "../normalise-DaSrnr8g.mjs";
 import { getParameters, getRequestBody, getResponses, listOperations, parseOpenApiDocument } from "./parser.mjs";
 //#region src/openapi/resolve.ts
 /**
@@ -24,17 +25,30 @@ const docCache = /* @__PURE__ */ new WeakMap();
 * 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.
+* When `diagnostics` is supplied, normalisation events
+* (`duplicate-body-parameter`, `dropped-swagger-feature`,
+* `unknown-json-schema-dialect`, `divisible-by-conflict`,
+* `relative-ref-resolved`, etc.) are forwarded to the sink. Passing
+* diagnostics also bypasses the cache so each call observes the
+* normalisation pipeline running against the supplied sink — caching
+* would silently swallow every emission after the first.
+*
+* The cache is keyed by the caller-supplied document so subsequent
+* cache-eligible calls with the same input bypass both normalisation
+* and parsing.
 */
-function getParsed(doc) {
-	const cached = docCache.get(doc);
-	if (cached !== void 0) return cached;
+function getParsed(doc, diagnostics) {
+	if (diagnostics === void 0) {
+		const cached = docCache.get(doc);
+		if (cached !== void 0) return cached;
+	}
 	const version = detectOpenApiVersion(doc);
-	const normalisedDoc = version !== void 0 ? normaliseOpenApiSchemas(doc, version) : doc;
+	const normalisedDoc = version !== void 0 ? normaliseOpenApiSchemas(doc, version, diagnostics) : doc;
 	const parsed = parseOpenApiDocument(normalisedDoc);
-	docCache.set(doc, parsed);
-	if (normalisedDoc !== doc) docCache.set(normalisedDoc, parsed);
+	if (diagnostics === void 0) {
+		docCache.set(doc, parsed);
+		if (normalisedDoc !== doc) docCache.set(normalisedDoc, parsed);
+	}
 	return parsed;
 }
 /**
@@ -66,6 +80,7 @@ function resolvePathItemNode(parsed, pathItem) {
 	for (const part of parts) {
 		if (!isObject(current)) return void 0;
 		const decoded = part.replace(/~1/g, "/").replace(/~0/g, "~");
+		if (isPrototypePollutingKey(decoded)) return void 0;
 		current = current[decoded];
 	}
 	return isObject(current) ? current : pathItem;
@@ -79,11 +94,16 @@ function extractPathItemInfo(pathItem) {
 	};
 }
 /**
-* Resolve an operation from an OpenAPI document by path and method.
-* Throws if the operation is not found.
+* Resolve an operation against an already-parsed document. Throws if
+* the operation is not found.
+*
+* Used by callers that have already obtained a parsed document via
+* {@link getParsed} — most importantly the React components, which
+* supply `diagnostics` to `getParsed` and must avoid re-running the
+* normalisation pipeline (every re-run would emit each diagnostic
+* again into the sink).
 */
-function resolveOperation(doc, path, method) {
-	const parsed = getParsed(doc);
+function resolveOperationFromParsed(parsed, path, method) {
 	const operation = listOperations(parsed).find((op) => op.path === path && op.method === method);
 	if (operation === void 0) throw new Error(`Operation not found: ${method.toUpperCase()} ${path}`);
 	const pathItemNode = lookupPathItemNode(parsed, path);
@@ -97,30 +117,73 @@ function resolveOperation(doc, path, method) {
 	};
 }
 /**
+* Resolve an operation from an OpenAPI document by path and method.
+* Throws if the operation is not found.
+*
+* `diagnostics` is forwarded to {@link getParsed} so normalisation
+* events surface to the caller's sink.
+*/
+function resolveOperation(doc, path, method, diagnostics) {
+	return resolveOperationFromParsed(getParsed(doc, diagnostics), path, method);
+}
+/**
+* Resolve parameters against an already-parsed document. See
+* {@link resolveOperationFromParsed} for the rationale.
+*/
+function resolveParametersFromParsed(parsed, path, method) {
+	return getParameters(parsed, path, method);
+}
+/**
 * Resolve parameters for an operation. Returns empty array if none.
+*
+* `diagnostics` is forwarded to {@link getParsed} so normalisation
+* events surface to the caller's sink.
 */
-function resolveParameters(doc, path, method) {
-	return getParameters(getParsed(doc), path, method);
+function resolveParameters(doc, path, method, diagnostics) {
+	return resolveParametersFromParsed(getParsed(doc, diagnostics), path, method);
+}
+/**
+* Resolve a request body against an already-parsed document. See
+* {@link resolveOperationFromParsed} for the rationale.
+*/
+function resolveRequestBodyFromParsed(parsed, path, method) {
+	return getRequestBody(parsed, path, method);
 }
 /**
 * Resolve request body for an operation. Returns undefined if none.
+*
+* `diagnostics` is forwarded to {@link getParsed} so normalisation
+* events surface to the caller's sink.
 */
-function resolveRequestBody(doc, path, method) {
-	return getRequestBody(getParsed(doc), path, method);
+function resolveRequestBody(doc, path, method, diagnostics) {
+	return resolveRequestBodyFromParsed(getParsed(doc, diagnostics), path, method);
 }
 /**
-* Resolve a specific response by status code. Throws if not found.
+* Resolve a specific response against an already-parsed document. See
+* {@link resolveOperationFromParsed} for the rationale.
 */
-function resolveResponse(doc, path, method, statusCode) {
-	const response = getResponses(getParsed(doc), path, method).find((r) => r.statusCode === statusCode);
+function resolveResponseFromParsed(parsed, path, method, statusCode) {
+	const response = getResponses(parsed, path, method).find((r) => r.statusCode === statusCode);
 	if (response === void 0) throw new Error(`Response not found: ${statusCode}`);
 	return response;
 }
 /**
+* Resolve a specific response by status code. Throws if not found.
+*
+* `diagnostics` is forwarded to {@link getParsed} so normalisation
+* events surface to the caller's sink.
+*/
+function resolveResponse(doc, path, method, statusCode, diagnostics) {
+	return resolveResponseFromParsed(getParsed(doc, diagnostics), path, method, statusCode);
+}
+/**
 * Resolve all responses for an operation.
+*
+* `diagnostics` is forwarded to {@link getParsed} so normalisation
+* events surface to the caller's sink.
 */
-function resolveResponses(doc, path, method) {
-	return getResponses(getParsed(doc), path, method);
+function resolveResponses(doc, path, method, diagnostics) {
+	return getResponses(getParsed(doc, diagnostics), path, method);
 }
 //#endregion
-export { getParsed, resolveOperation, resolveParameters, resolveRequestBody, resolveResponse, resolveResponses, toDoc };
+export { getParsed, resolveOperation, resolveOperationFromParsed, resolveParameters, resolveParametersFromParsed, resolveRequestBody, resolveRequestBodyFromParsed, resolveResponse, resolveResponseFromParsed, resolveResponses, toDoc };

package/dist/react/SchemaComponent.d.mts

@@ -1,8 +1,8 @@
-import { M as WalkedField, T as SchemaMeta, d as FieldOverrides, u as FieldOverride } from "../types-C9zw9wbX.mjs";
+import { M as WalkedField, T as SchemaMeta, d as FieldOverrides, u as FieldOverride } from "../types-BnxPEElk.mjs";
 import { t as Diagnostic } from "../diagnostics-CbBPsxSt.mjs";
-import { t as SchemaError } from "../errors-C2iABcn9.mjs";
-import { l as RenderProps, r as ComponentResolver } from "../renderer-SOIbJBtk.mjs";
-import { c as PathOfType, l as RejectUnrepresentableZod, n as FromJSONSchema, u as ResolveOpenAPIRef } from "../typeInference-CDoD_LZ_.mjs";
+import { t as SchemaError } from "../errors-QEwOtQAA.mjs";
+import { l as RenderProps, r as ComponentResolver } from "../renderer-DI6ZYf7a.mjs";
+import { c as PathOfType, l as RejectUnrepresentableZod, n as FromJSONSchema, u as ResolveOpenAPIRef } from "../typeInference-Bxw3NOG1.mjs";
 import { z } from "zod";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 import { ReactNode } from "react";

package/dist/react/SchemaComponent.mjs

@@ -87,7 +87,7 @@ function SchemaComponent({ schema: schemaInput, ref: refInput, value, onChange,
 	}
 	const handleChange = useCallback((nextValue) => {
 		if (validate) {
-			const error = runValidation(zodSchema, jsonSchema, nextValue);
+			const error = runValidation(zodSchema, jsonSchema, nextValue, onDiagnostic);
 			if (error !== void 0) {
 				onValidationError?.(error);
 				dispatchFieldErrors(fields, error);
@@ -100,7 +100,8 @@ function SchemaComponent({ schema: schemaInput, ref: refInput, value, onChange,
 		jsonSchema,
 		onChange,
 		onValidationError,
-		fields
+		fields,
+		onDiagnostic
 	]);
 	const walkOptions = {
 		componentMeta: mergedMeta,
@@ -145,7 +146,7 @@ function sanitisePrefix(value) {
 	if (sanitised.length === 0) throw new Error(`Cannot derive a DOM-safe id prefix from "${value}". Pass an explicit idPrefix prop.`);
 	return sanitised;
 }
-function runValidation(zodSchema, jsonSchema, value) {
+function runValidation(zodSchema, jsonSchema, value, onDiagnostic) {
 	if (zodSchema !== void 0 && isObject(zodSchema)) {
 		const safeParseFn = zodSchema.safeParse;
 		if (isCallable(safeParseFn)) {
@@ -154,7 +155,13 @@ function runValidation(zodSchema, jsonSchema, value) {
 			return;
 		}
 	}
-	const parsed = z.fromJSONSchema(jsonSchema);
+	let parsed;
+	try {
+		parsed = z.fromJSONSchema(jsonSchema);
+	} catch (err) {
+		emitFromJsonSchemaDiagnostic(err, onDiagnostic);
+		return;
+	}
 	if (isObject(parsed)) {
 		const safeParseFn = parsed.safeParse;
 		if (isCallable(safeParseFn)) {
@@ -163,6 +170,27 @@ function runValidation(zodSchema, jsonSchema, value) {
 		}
 	}
 }
+/**
+* Emit a diagnostic when `z.fromJSONSchema` refuses to round-trip the
+* already-normalised JSON Schema. The diagnostic reuses the existing
+* `unsupported-type` code because the failure mode is the same — a
+* keyword/structure Zod cannot represent — and the consumer should be
+* able to opt in to noticing it via the existing diagnostics channel.
+*
+* Best-effort: when no `onDiagnostic` sink is configured we still swallow
+* the throw (the alternative would crash the React render for a
+* non-essential validation step), matching the silent-fallback contract
+* the rest of the diagnostics system uses.
+*/
+function emitFromJsonSchemaDiagnostic(err, onDiagnostic) {
+	if (onDiagnostic === void 0) return;
+	onDiagnostic({
+		code: "unsupported-type",
+		message: `Skipping fallback validation: z.fromJSONSchema could not round-trip the normalised JSON Schema. Original message: ${err instanceof Error ? err.message : "z.fromJSONSchema threw a non-Error value"}`,
+		pointer: "",
+		detail: { source: "z.fromJSONSchema" }
+	});
+}
 /** Maximum rendering depth before treating a field as recursive. */
 const MAX_RENDER_DEPTH = 10;
 function renderField(tree, value, onChange, userResolver, renderChild, path, instanceWidgets, contextWidgets, depth = 0) {

package/dist/react/SchemaView.d.mts

@@ -1,6 +1,6 @@
-import { T as SchemaMeta } from "../types-C9zw9wbX.mjs";
+import { T as SchemaMeta } from "../types-BnxPEElk.mjs";
 import { t as Diagnostic } from "../diagnostics-CbBPsxSt.mjs";
-import { r as ComponentResolver } from "../renderer-SOIbJBtk.mjs";
+import { r as ComponentResolver } from "../renderer-DI6ZYf7a.mjs";
 import { WidgetMap } from "./SchemaComponent.mjs";
 import { ReactNode } from "react";
 

package/dist/react/fieldPath.d.mts

@@ -1,4 +1,4 @@
-import { M as WalkedField } from "../types-C9zw9wbX.mjs";
+import { M as WalkedField } from "../types-BnxPEElk.mjs";
 
 //#region src/react/fieldPath.d.ts
 /**

package/dist/react/headless.d.mts

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

package/dist/react/headlessRenderers.d.mts

@@ -1,5 +1,5 @@
-import { M as WalkedField } from "../types-C9zw9wbX.mjs";
-import { l as RenderProps } from "../renderer-SOIbJBtk.mjs";
+import { M as WalkedField } from "../types-BnxPEElk.mjs";
+import { l as RenderProps } from "../renderer-DI6ZYf7a.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 { sortFieldsByOrder } from "../core/fieldOrder.mjs";
 import { isSafeHyperlink, isSafeMailtoAddress } from "../core/uri.mjs";
+import { sortFieldsByOrder } from "../core/fieldOrder.mjs";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { isValidElement, useCallback, useEffect, useRef } from "react";
 //#region src/react/headlessRenderers.tsx

package/dist/{ref-C8JbwfiS.d.mts → ref-si8ViYun.d.mts}

@@ -38,7 +38,12 @@ declare function dereference(ref: string, root: Record<string, unknown>): Record
 /**
  * Recursively scan a schema document for a `$anchor` matching the given name.
  * Returns the schema object containing the anchor, or undefined.
+ *
+ * The optional `visited` set guards against shared object references and
+ * cycles introduced by the OpenAPI bundler's `structuredClone`-based
+ * inlining of external refs. Without it a recursive document would stack
+ * overflow before reaching the matching anchor.
  */
-declare function findAnchor(node: unknown, anchorName: string): Record<string, unknown> | undefined;
+declare function findAnchor(node: unknown, anchorName: string, visited?: WeakSet<object>): Record<string, unknown> | undefined;
 //#endregion
 export { findAnchor as a, dereference as i, RefOptions as n, resolveRef as o, countDistinctRefs as r, ExternalResolver as t };

package/dist/{renderer-SOIbJBtk.d.mts → renderer-DI6ZYf7a.d.mts}

@@ -1,4 +1,4 @@
-import { D as StringConstraints, M as WalkedField, T as SchemaMeta, f as FileConstraints, t as ArrayConstraints, x as ObjectConstraints, y as NumberConstraints } from "./types-C9zw9wbX.mjs";
+import { D as StringConstraints, M as WalkedField, T as SchemaMeta, f as FileConstraints, t as ArrayConstraints, x as ObjectConstraints, y as NumberConstraints } from "./types-BnxPEElk.mjs";
 
 //#region src/core/renderer.d.ts
 /**

package/dist/themes/mantine.d.mts

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

package/dist/themes/mui.d.mts

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

package/dist/themes/radix.d.mts

@@ -1,4 +1,4 @@
-import { r as ComponentResolver } from "../renderer-SOIbJBtk.mjs";
+import { r as ComponentResolver } from "../renderer-DI6ZYf7a.mjs";
 
 //#region src/themes/radix.d.ts
 /**

package/dist/themes/shadcn.d.mts

@@ -1,4 +1,4 @@
-import { r as ComponentResolver } from "../renderer-SOIbJBtk.mjs";
+import { r as ComponentResolver } from "../renderer-DI6ZYf7a.mjs";
 
 //#region src/themes/shadcn.d.ts
 declare const shadcnResolver: ComponentResolver;