schema-components 2.0.1 → 2.1.0

package/dist/react/SchemaComponent.d.mts

@@ -1,270 +1,3 @@
-import { j as WalkedField, w as SchemaMeta } from "../types-BrYbjC7_.mjs";
-import { t as Diagnostic } from "../diagnostics-BTrm3O6J.mjs";
-import { SchemaIoSide } from "../core/adapter.mjs";
-import { ComponentResolver, RenderProps, WidgetMap } from "../core/renderer.mjs";
-import { t as SchemaError } from "../errors-Dki7tji4.mjs";
-import { FromJSONSchema, PathOfType, RejectUnrepresentableZod } from "../core/typeInference.mjs";
-import { a as InferredValue, i as InferredOutputValue, n as InferSchemaValue, r as InferredInputValue, t as InferFields } from "../inferValue-PPXWJpbN.mjs";
-import { z } from "zod";
-import * as _$react_jsx_runtime0 from "react/jsx-runtime";
-import { ReactNode } from "react";
-
-//#region src/react/SchemaComponent.d.ts
-/**
- * Provide a theme resolver and scoped widgets to every `<SchemaComponent>`
- * and `<SchemaView>` rendered inside the subtree.
- *
- * Wrap an application (or a region of it) with `<SchemaProvider>` so a
- * single theme — typically one of the bundled adapters
- * (`shadcnResolver`, `muiResolver`, `mantineResolver`, `radixResolver`)
- * or a custom one — drives every schema render. Without a provider,
- * schema-components fall back to the headless HTML renderer.
- *
- * @group Components
- * @example
- * ```tsx
- * import { SchemaProvider } from "schema-components/react/SchemaComponent";
- * import { shadcnResolver } from "schema-components/themes/shadcn";
- *
- * <SchemaProvider resolver={shadcnResolver}>
- *   <SchemaComponent schema={userSchema} value={user} onChange={setUser} />
- * </SchemaProvider>
- * ```
- */
-declare function SchemaProvider({
-  resolver,
-  widgets,
-  children
-}: {
-  resolver: ComponentResolver; /** Scoped widgets available to all SchemaComponents in this subtree. */
-  widgets?: WidgetMap;
-  children: ReactNode;
-}): _$react_jsx_runtime0.JSX.Element;
-/**
- * Register a widget globally. The widget is resolved when a schema field
- * has `.meta({ component: name })`.
- *
- * For scoped registration, use the `widgets` prop on `<SchemaComponent>`
- * or `<SchemaProvider>` instead.
- */
-declare function registerWidget(name: string, render: (props: RenderProps) => unknown): void;
-/**
- * Clear every globally registered widget. Intended for test isolation —
- * `registerWidget` writes to module-level state and that state otherwise
- * leaks across test cases, making the test suite order-dependent. Tests
- * should call this from an `afterEach` hook.
- *
- * @internal
- */
-declare function __clearGlobalWidgets(): void;
-/**
- * Props accepted by {@link SchemaComponent}.
- *
- * The generic parameters carry the inferred schema shape through to
- * `value`, `onChange`, and `fields` so a typed `schema` prop drives
- * typed props on the rest of the component.
- *
- * @group Components
- */
-interface SchemaComponentProps<T = unknown, Ref extends string | undefined = undefined, Mode extends SchemaIoSide = "output"> {
-  /**
-   * Zod schema, JSON Schema object, or OpenAPI document.
-   *
-   * Zod 4 types that cannot round-trip through `z.toJSONSchema()`
-   * (bigint, date, map, set, symbol, function, undefined, void, nan,
-   * codec) are rejected at the type level via
-   * {@link RejectUnrepresentableZod}. Runtime conversion would throw
-   * `SchemaNormalisationError` with kind `zod-type-unrepresentable`
-   * — the static rejection surfaces the same failure at compile time.
-   */
-  schema: RejectUnrepresentableZod<T>;
-  /** For OpenAPI: a ref string like "#/components/schemas/User" or "/users/post". */
-  ref?: Ref;
-  /**
-   * Which side of every transform / pipe / codec to render.
-   *
-   * - `"output"` (default) — renderer draws the OUTPUT side of the
-   *   schema. For a `z.codec(z.string(), z.number(), …)` chain
-   *   this renders a number input. `value` and `onChange` therefore
-   *   carry the OUTPUT shape, and `validate` runs `safeEncode`
-   *   (the reverse direction) so user-supplied OUTPUT values are
-   *   validated against the codec.
-   * - `"input"` — renderer draws the INPUT side instead. For the
-   *   same codec this renders a string input, `value` and
-   *   `onChange` carry the INPUT shape, and `validate` runs
-   *   `safeParse` (the forward direction).
-   *
-   * The choice is propagated through `normaliseSchema` →
-   * `normaliseZod4` → `z.toJSONSchema(..., { io })` so a single
-   * source of truth drives both the rendered JSON Schema shape and
-   * the validation direction. Has no effect for plain JSON Schema
-   * or OpenAPI inputs — those advertise a single canonical shape.
-   */
-  io?: Mode;
-  /**
-   * Current value to render. Typed against `InferSchemaValue<T,
-   * Ref, Mode>` so the prop tracks the schema's inferred shape for
-   * the chosen `io` direction.
-   *
-   * Falls back to `unknown` when the schema's value type cannot be
-   * statically inferred (runtime `Record<string, unknown>` JSON
-   * Schemas, OpenAPI documents without a ref, etc.), so untyped
-   * call sites still compile.
-   *
-   * Use {@link InferredOutputValue} or {@link InferredInputValue}
-   * to narrow a value declared at the call site:
-   *
-   * ```tsx
-   * const user: InferredOutputValue<typeof userSchema> = { ... };
-   * <SchemaComponent schema={userSchema} value={user} readOnly />
-   * ```
-   */
-  value?: InferSchemaValue<T, Ref, Mode>;
-  /**
-   * Called when the value changes (editable fields). The parameter
-   * shares the same shape as {@link SchemaComponentProps.value} so
-   * a controlled component can round-trip the value through React
-   * state without re-shaping.
-   *
-   * Falls back to `unknown` for schemas whose value type cannot be
-   * statically inferred — see {@link SchemaComponentProps.value}.
-   */
-  onChange?: (value: InferSchemaValue<T, Ref, Mode>) => void;
-  /** Run schema.safeParse() on change and surface errors via onValidationError. */
-  validate?: boolean;
-  /** Called with the ZodError when validation fails. */
-  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. */
-  meta?: SchemaMeta;
-  /** Convenience: sets readOnly on all fields. */
-  readOnly?: boolean;
-  /** Convenience: sets writeOnly on all fields. */
-  writeOnly?: boolean;
-  /** Convenience: sets description on the root. */
-  description?: string;
-  /** Instance-scoped widgets — override context and global widgets. */
-  widgets?: WidgetMap;
-  /**
-   * Prefix used for every input `id`/label `htmlFor` in this component
-   * subtree. Defaults to a per-instance value from `useId()` so multiple
-   * `<SchemaComponent>` instances on the same page never collide. Override
-   * for deterministic ids in screenshot tests.
-   */
-  idPrefix?: string;
-}
-/**
- * Render an editable (or read-only) UI from a Zod schema, JSON Schema, or
- * OpenAPI document.
- *
- * Auto-detects the input format, normalises to JSON Schema via the
- * adapter, walks the JSON Schema tree, and delegates per-field rendering
- * to the {@link ComponentResolver} supplied via {@link SchemaProvider} —
- * falling back to a headless HTML renderer when no provider is present.
- *
- * Pass `readOnly` to render a presentational view instead of inputs, or
- * wrap with `<SchemaProvider resolver={…}>` to swap the theme.
- *
- * @group Components
- * @example
- * ```tsx
- * import { z } from "zod";
- * import { SchemaComponent } from "schema-components/react/SchemaComponent";
- *
- * const userSchema = z.object({ name: z.string(), email: z.email() });
- *
- * <SchemaComponent schema={userSchema} value={user} onChange={setUser} />
- * ```
- */
-declare function SchemaComponent<T = unknown, Ref extends string | undefined = undefined, Mode extends SchemaIoSide = "output">(props: SchemaComponentProps<T, Ref, Mode>): ReactNode;
-/**
- * Append a child path suffix to a parent path. When the suffix is omitted
- * (e.g. transparent wrappers like union options), the parent path is
- * returned unchanged so the child inherits the parent's id.
- *
- * Bracketed array indices like `[0]` append directly so `tags` + `[0]`
- * becomes `tags[0]` rather than `tags.[0]` — matching the canonical form
- * used by `html/a11y.ts` `joinPath` and `react/fieldPath.ts` `resolvePath`,
- * which already parses bracket notation when navigating WalkedField trees.
- */
-declare function joinPath(parent: string, suffix: string | undefined): string;
-/**
- * Normalise a `useId()` value into a DOM-id-safe prefix. React's `useId`
- * returns values containing `:` characters (e.g. `«:r0:»`) which are
- * invalid in CSS selectors. Replace any run of non-alphanumeric characters
- * with a single hyphen and trim leading/trailing hyphens.
- */
-declare function sanitisePrefix(value: string): string;
-/**
- * Render a single walked field through the resolved widget /
- * resolver / headless pipeline. Used internally by
- * {@link SchemaComponent} and {@link SchemaField}, exported so other
- * React-side components (e.g. the OpenAPI renderers) can dispatch
- * into the same fallback chain.
- */
-declare function renderField(tree: WalkedField, value: unknown, onChange: (v: unknown) => void, userResolver: ComponentResolver | undefined, renderChild: (tree: WalkedField, value: unknown, onChange: (v: unknown) => void, pathSuffix?: string) => ReactNode, path: string, instanceWidgets?: WidgetMap, contextWidgets?: WidgetMap, depth?: number): ReactNode;
-/**
- * Infer the schema's output type for SchemaField path inference.
- */
-type InferSchemaType<T> = T extends z.ZodType ? z.infer<T> : T extends object ? unknown extends FromJSONSchema<T> ? unknown : FromJSONSchema<T> : unknown;
-/**
- * Props accepted by {@link SchemaField}. The generic `P` constrains
- * `path` to dot-paths reachable through the schema's inferred value
- * type — typed schemas get autocomplete; runtime schemas fall back to
- * `string`.
- *
- * @group Components
- */
-interface SchemaFieldProps<T = unknown, Ref extends string | undefined = undefined, P extends string = PathOfType<InferSchemaType<T>> | (string extends PathOfType<InferSchemaType<T>> ? string : never)> {
-  /**
-   * Dot-separated path to the field (e.g. "address.city").
-   * When the schema is a Zod schema or typed `as const`, only valid
-   * paths are accepted. Falls back to `string` for runtime schemas.
-   */
-  path: P;
-  /**
-   * The schema to extract the field from. Subject to the same
-   * unrepresentable-Zod rejection as {@link SchemaComponentProps.schema}.
-   */
-  schema: RejectUnrepresentableZod<T>;
-  /** For OpenAPI: a ref string. */
-  ref?: Ref;
-  /** Current value of the field at the given path. */
-  value?: unknown;
-  /** Called with the updated root value when this field changes. */
-  onChange?: (value: unknown) => void;
-  /** Override meta for this specific field. */
-  meta?: SchemaMeta;
-  /** Run validation on change. */
-  validate?: boolean;
-  onValidationError?: (error: unknown) => void;
-}
-/**
- * Render a single field from a schema by dot-separated `path`.
- *
- * Walks the full schema tree and resolves the field at the supplied
- * `path`, then renders only that field through the same resolver
- * pipeline as {@link SchemaComponent}. Useful for embedding individual
- * fields inside bespoke layouts.
- *
- * @group Components
- */
-declare function SchemaField<T = unknown, Ref extends string | undefined = undefined, P extends string = PathOfType<InferSchemaType<T>> | (string extends PathOfType<InferSchemaType<T>> ? string : never)>({
-  path,
-  schema: schemaInput,
-  ref: refInput,
-  value,
-  onChange,
-  meta: fieldMeta,
-  validate,
-  onValidationError
-}: SchemaFieldProps<T, Ref, P>): ReactNode;
-//#endregion
-export { type InferFields, type InferredInputValue, type InferredOutputValue, type InferredValue, SchemaComponent, SchemaComponentProps, SchemaField, SchemaFieldProps, SchemaProvider, __clearGlobalWidgets, joinPath, registerWidget, renderField, sanitisePrefix };
+import { a as InferredValue, i as InferredOutputValue, r as InferredInputValue, t as InferFields } from "../inferValue-eAnh50EM.mjs";
+import { a as SchemaProvider, c as registerWidget, i as SchemaFieldProps, l as renderField, n as SchemaComponentProps, o as __clearGlobalWidgets, r as SchemaField, s as joinPath, t as SchemaComponent, u as sanitisePrefix } from "../SchemaComponent-B__6-5-E.mjs";
+export { InferFields, InferredInputValue, InferredOutputValue, InferredValue, SchemaComponent, SchemaComponentProps, SchemaField, SchemaFieldProps, SchemaProvider, __clearGlobalWidgets, joinPath, registerWidget, renderField, sanitisePrefix };

package/dist/react/SchemaComponent.mjs

@@ -1,12 +1,12 @@
 "use client";
 import { isObject, toRecordOrUndefined } from "../core/guards.mjs";
-import "../core/limits.mjs";
-import { SchemaFieldError, SchemaNormalisationError, SchemaRenderError } from "../core/errors.mjs";
+import { SchemaFieldError, SchemaNormalisationError } from "../core/errors.mjs";
 import { isCodecSchema, normaliseSchema } from "../core/adapter.mjs";
+import { resolvePath, resolveValue, setNestedValue } from "../core/fieldPath.mjs";
+import { dispatchRenderField } from "../core/renderField.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";
@@ -19,10 +19,10 @@ import { createContext, isValidElement, useCallback, useContext, useId, useMemo
 * ComponentResolver (theme adapter). Falls back to headless HTML.
 *
 * The `fields` prop type is inferred from the `schema` prop:
-* - Zod schemas → FieldOverrides<z.infer<T>> (full autocomplete)
-* - JSON Schema `as const` → FieldOverrides<FromJSONSchema<T>> (full autocomplete)
-* - OpenAPI `as const` + `ref` → FieldOverrides<ResolveOpenAPIRef<T, Ref>>
-* - Runtime schemas → Record<string, FieldOverride> (no autocomplete)
+* - Zod schemas → `FieldOverrides<z.infer<T>>` (full autocomplete)
+* - JSON Schema `as const` → `FieldOverrides<FromJSONSchema<T>>` (full autocomplete)
+* - OpenAPI `as const` + `ref` → `FieldOverrides<ResolveOpenAPIRef<T, Ref>>`
+* - Runtime schemas → `Record<string, FieldOverride>` (no autocomplete)
 */
 const UserResolverContext = createContext(void 0);
 const WidgetsContext = createContext(void 0);
@@ -199,7 +199,7 @@ function SchemaComponent(props) {
 *
 * Bracketed array indices like `[0]` append directly so `tags` + `[0]`
 * becomes `tags[0]` rather than `tags.[0]` — matching the canonical form
-* used by `html/a11y.ts` `joinPath` and `react/fieldPath.ts` `resolvePath`,
+* used by `html/a11y.ts` `joinPath` and `core/fieldPath.ts` `resolvePath`,
 * which already parses bracket notation when navigating WalkedField trees.
 */
 function joinPath(parent, suffix) {
@@ -281,41 +281,50 @@ function runValidation(zodSchema, jsonSchema, value, io, onDiagnostic) {
 * {@link SchemaComponent} and {@link SchemaField}, exported so other
 * React-side components (e.g. the OpenAPI renderers) can dispatch
 * into the same fallback chain.
+*
+* Thin React-flavoured wrapper around the framework-agnostic
+* `dispatchRenderField` (from `core/renderField`): it constructs a
+* React-shaped `DispatchConfig` (widget lookup against the
+* instance → context → global chain, recursion sentinel as a React
+* `<fieldset>`, fallback as a `<span>`-wrapped value) and forwards
+* the call.
 */
 function renderField(tree, value, onChange, userResolver, renderChild, path, instanceWidgets, contextWidgets, depth = 0) {
 	if (path.length === 0) throw new Error("renderField requires a non-empty path. Pass the root path (derived from `idPrefix` or `useId()`) for the root field, and use renderChild's pathSuffix to derive child paths.");
-	if (depth >= 10) return /* @__PURE__ */ jsx("fieldset", { children: /* @__PURE__ */ jsxs("em", { children: [
-		"↻ ",
-		typeof tree.meta.description === "string" ? tree.meta.description : "schema",
-		" (recursive)"
-	] }) });
-	const componentHint = tree.meta.component;
-	if (typeof componentHint === "string") {
-		const widget = instanceWidgets?.get(componentHint) ?? contextWidgets?.get(componentHint) ?? globalWidgets.get(componentHint);
-		if (widget !== void 0) {
-			const result = widget(buildRenderProps(tree, value, onChange, renderChild, path));
-			if (result !== void 0 && result !== null) {
+	return dispatchRenderField({
+		tree,
+		value,
+		path,
+		depth,
+		resolver: userResolver !== void 0 ? mergeResolvers(userResolver, headlessResolver) : headlessResolver,
+		config: {
+			buildProps: (fieldTree, fieldPath) => buildRenderProps(fieldTree, value, onChange, renderChild, fieldPath),
+			lookupRenderFn: (type, mergedResolver) => getRenderFunction(type, mergedResolver),
+			lookupWidget: (name) => instanceWidgets?.get(name) ?? contextWidgets?.get(name) ?? globalWidgets.get(name),
+			recursionSentinel: (fieldTree) => {
+				return /* @__PURE__ */ jsx("fieldset", { children: /* @__PURE__ */ jsxs("em", { children: [
+					"↻ ",
+					typeof fieldTree.meta.description === "string" ? fieldTree.meta.description : "schema",
+					" (recursive)"
+				] }) });
+			},
+			fallback: (_fieldTree, fieldValue) => {
+				if (fieldValue === void 0 || fieldValue === null) return /* @__PURE__ */ jsx("span", { children: "—" });
+				return /* @__PURE__ */ jsx("span", { children: typeof fieldValue === "string" ? fieldValue : JSON.stringify(fieldValue) });
+			},
+			coerceResult: (result, step) => {
+				if (step === "widget") {
+					if (result === void 0 || result === null) return void 0;
+					if (isValidElement(result)) return result;
+					if (typeof result === "string" || typeof result === "number") return result;
+					return null;
+				}
+				if (result === void 0 || result === null) return null;
 				if (isValidElement(result)) return result;
 				if (typeof result === "string" || typeof result === "number") return result;
-				return null;
 			}
 		}
-	}
-	const resolver = userResolver !== void 0 ? mergeResolvers(userResolver, headlessResolver) : headlessResolver;
-	const renderFn = getRenderFunction(tree.type, resolver);
-	if (renderFn !== void 0) {
-		let result;
-		try {
-			result = renderFn(buildRenderProps(tree, value, onChange, renderChild, path));
-		} catch (err) {
-			throw new SchemaRenderError(err instanceof Error ? err.message : `Render function threw for type "${tree.type}"`, tree, tree.type, err);
-		}
-		if (result === null || result === void 0) return null;
-		if (isValidElement(result)) return result;
-		if (typeof result === "string" || typeof result === "number") return result;
-	}
-	if (value === void 0 || value === null) return /* @__PURE__ */ jsx("span", { children: "—" });
-	return /* @__PURE__ */ jsx("span", { children: typeof value === "string" ? value : JSON.stringify(value) });
+	});
 }
 /**
 * Render a single field from a schema by dot-separated `path`.
@@ -384,9 +393,9 @@ function SchemaField({ path, schema: schemaInput, ref: refInput, value, onChange
 * (`FieldOverrides<U>`) and the loose `Record<string, FieldOverride>`
 * fallback share the same structural shape, so the dispatch logic only
 * needs the loose record. The previous parameter union
-* (`Record<string, FieldOverride> | FieldOverrides<unknown> |
-* undefined`) collapsed because `FieldOverrides<unknown>` reduces to
-* `{}`, contributing no extra precision while adding noise to readers.
+* (`Record<string, FieldOverride> | FieldOverrides<unknown> | undefined`)
+* collapsed because `FieldOverrides<unknown>` reduces to `{}`,
+* contributing no extra precision while adding noise to readers.
 */
 function dispatchFieldErrors(fields, error) {
 	if (fields === void 0 || !isObject(error)) return;

package/dist/react/SchemaErrorBoundary.mjs

@@ -10,11 +10,14 @@ import { Component } from "react";
 * crashes the entire React tree.
 *
 * Usage:
-*   import { SchemaErrorBoundary } from "schema-components/react/SchemaErrorBoundary";
 *
-*   <SchemaErrorBoundary fallback={(error) => <p>{error.message}</p>}>
-*     <SchemaComponent schema={userSchema} value={user} />
-*   </SchemaErrorBoundary>
+* ```tsx
+* import { SchemaErrorBoundary } from "schema-components/react/SchemaErrorBoundary";
+*
+* <SchemaErrorBoundary fallback={(error) => <p>{error.message}</p>}>
+*   <SchemaComponent schema={userSchema} value={user} />
+* </SchemaErrorBoundary>
+* ```
 *
 * The boundary catches `SchemaRenderError` from theme adapters and any
 * other errors thrown during rendering. It does NOT catch:

package/dist/react/SchemaView.d.mts

@@ -1,9 +1,9 @@
-import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
-import { t as Diagnostic } from "../diagnostics-BTrm3O6J.mjs";
-import { SchemaIoSide } from "../core/adapter.mjs";
-import { ComponentResolver, WidgetMap } from "../core/renderer.mjs";
-import { RejectUnrepresentableZod } from "../core/typeInference.mjs";
-import { a as InferredValue, t as InferFields } from "../inferValue-PPXWJpbN.mjs";
+import { w as SchemaMeta } from "../types-BBQaEPfE.mjs";
+import { t as Diagnostic } from "../diagnostics-mftUZI7c.mjs";
+import { r as SchemaIoSide } from "../adapter-ktQaheWB.mjs";
+import { d as WidgetMap, i as ComponentResolver } from "../renderer-ab9E52Bp.mjs";
+import { f as RejectUnrepresentableZod } from "../typeInference-Y8tNEQJk.mjs";
+import { a as InferredValue, t as InferFields } from "../inferValue-eAnh50EM.mjs";
 import { ReactNode } from "react";
 
 //#region src/react/SchemaView.d.ts
@@ -38,10 +38,11 @@ interface SchemaViewProps<T = unknown, Ref extends string | undefined = undefine
    */
   io?: Mode;
   /**
-   * Current value to render. Typed against `InferSchemaValue<T,
-   * Ref, Mode>` so the prop tracks the schema's inferred shape for
-   * the chosen `io` direction. Falls back to `unknown` for runtime
-   * schemas where the value type cannot be statically inferred.
+   * Current value to render. Typed against
+   * `InferSchemaValue<T, Ref, Mode>` so the prop tracks the schema's
+   * inferred shape for the chosen `io` direction. Falls back to
+   * `unknown` for runtime schemas where the value type cannot be
+   * statically inferred.
    */
   value?: InferredValue<T, Ref, undefined, Mode>;
   /**

package/dist/react/SchemaView.mjs

@@ -1,13 +1,13 @@
 import { toRecordOrUndefined } from "../core/guards.mjs";
-import "../core/limits.mjs";
-import { SchemaNormalisationError, SchemaRenderError } from "../core/errors.mjs";
+import { SchemaNormalisationError } from "../core/errors.mjs";
 import { normaliseSchema } from "../core/adapter.mjs";
+import { dispatchRenderField } from "../core/renderField.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 { isValidElement, useId } from "react";
 //#region src/react/SchemaView.tsx
 /**
 * React Server Component for read-only schema rendering.
@@ -97,41 +97,44 @@ function SchemaView({ schema: schemaInput, ref: refInput, io, value, fields, met
 	const userResolver = resolver !== void 0 ? mergeResolvers(resolver, headlessResolver) : headlessResolver;
 	const makeRenderChild = (currentDepth, parentPath) => (childTree, childValue, pathSuffix) => {
 		const childPath = joinPath(parentPath, pathSuffix);
-		if (currentDepth >= 10) return createElement("fieldset", null, createElement("em", null, `\u21bb ${typeof childTree.meta.description === "string" ? childTree.meta.description : "schema"} (recursive)`));
-		return renderFieldServer(childTree, childValue, userResolver, makeRenderChild(currentDepth + 1, childPath), childPath, widgets);
+		return renderFieldServer(childTree, childValue, userResolver, makeRenderChild(currentDepth + 1, childPath), childPath, widgets, currentDepth + 1);
 	};
 	const renderChild = makeRenderChild(0, rootPath);
-	return renderFieldServer(tree, value ?? tree.defaultValue, userResolver, renderChild, rootPath, widgets);
+	return renderFieldServer(tree, value ?? tree.defaultValue, userResolver, renderChild, rootPath, widgets, 0);
 }
-function renderFieldServer(tree, value, resolver, renderChild, path, widgets) {
+function renderFieldServer(tree, value, resolver, renderChild, path, widgets, depth = 0) {
 	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 result = widget(buildRenderProps(tree, value, void 0, adaptedRenderChild, path));
-			if (result !== void 0 && result !== null) {
+	return dispatchRenderField({
+		tree,
+		value,
+		path,
+		depth,
+		resolver,
+		config: {
+			buildProps: (fieldTree, fieldPath) => buildRenderProps(fieldTree, value, void 0, adaptedRenderChild, fieldPath),
+			lookupRenderFn: (type, mergedResolver) => getRenderFunction(type, mergedResolver),
+			...widgets !== void 0 ? { lookupWidget: (name) => widgets.get(name) } : {},
+			recursionSentinel: (fieldTree) => {
+				return /* @__PURE__ */ jsx("fieldset", { children: /* @__PURE__ */ jsx("em", { children: `↻ ${typeof fieldTree.meta.description === "string" ? fieldTree.meta.description : "schema"} (recursive)` }) });
+			},
+			fallback: (_fieldTree, fieldValue) => {
+				if (fieldValue === void 0 || fieldValue === null) return /* @__PURE__ */ jsx("span", { children: "—" });
+				return /* @__PURE__ */ jsx("span", { children: typeof fieldValue === "string" ? fieldValue : JSON.stringify(fieldValue) });
+			},
+			coerceResult: (result, step) => {
+				if (step === "widget") {
+					if (result === void 0 || result === null) return void 0;
+					if (isValidElement(result)) return result;
+					if (typeof result === "string" || typeof result === "number") return result;
+					return;
+				}
+				if (result === void 0 || result === null) return void 0;
 				if (isValidElement(result)) return result;
 				if (typeof result === "string" || typeof result === "number") return result;
 			}
 		}
-	}
-	const renderFn = getRenderFunction(tree.type, resolver);
-	if (renderFn !== void 0) {
-		const props = buildRenderProps(tree, value, void 0, adaptedRenderChild, path);
-		try {
-			const result = renderFn(props);
-			if (result !== void 0 && result !== null) {
-				if (isValidElement(result)) return result;
-				if (typeof result === "string" || typeof result === "number") return result;
-			}
-		} catch (err) {
-			throw new SchemaRenderError(err instanceof Error ? err.message : `Render function threw for type "${tree.type}"`, tree, tree.type, err);
-		}
-	}
-	if (value === void 0 || value === null) return /* @__PURE__ */ jsx("span", { children: "—" });
-	return /* @__PURE__ */ jsx("span", { children: typeof value === "string" ? value : JSON.stringify(value) });
+	});
 }
 //#endregion
 export { SchemaView };

package/dist/react/a11y.d.mts

@@ -1,5 +1,5 @@
-import { j as WalkedField } from "../types-BrYbjC7_.mjs";
-import { AllConstraints } from "../core/renderer.mjs";
+import { j as WalkedField } from "../types-BBQaEPfE.mjs";
+import { t as AllConstraints } from "../renderer-ab9E52Bp.mjs";
 
 //#region src/react/a11y.d.ts
 /**

package/dist/react/fieldShell.d.mts

@@ -1,4 +1,4 @@
-import { RenderProps } from "../core/renderer.mjs";
+import { u as RenderProps } from "../renderer-ab9E52Bp.mjs";
 import { ReactNode } from "react";
 
 //#region src/react/fieldShell.d.ts

package/dist/react/headless.d.mts

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

package/dist/react/headlessRenderers.d.mts

@@ -1,5 +1,5 @@
-import { j as WalkedField } from "../types-BrYbjC7_.mjs";
-import { RenderProps } from "../core/renderer.mjs";
+import { j as WalkedField } from "../types-BBQaEPfE.mjs";
+import { u as RenderProps } from "../renderer-ab9E52Bp.mjs";
 import { ReactNode } from "react";
 
 //#region src/react/headlessRenderers.d.ts

package/dist/{ref-DdsbekXX.d.mts → ref-DWrQG1Er.d.mts}

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