schema-components 2.0.1 → 2.1.0

package/dist/solid/SchemaComponent.mjs

@@ -0,0 +1,391 @@
+import { isObject, toRecordOrUndefined } from "../core/guards.mjs";
+import "../core/limits.mjs";
+import { SchemaNormalisationError, SchemaRenderError } from "../core/errors.mjs";
+import { isCodecSchema, normaliseSchema } from "../core/adapter.mjs";
+import { walk } from "../core/walker.mjs";
+import { UserResolverContext, WidgetsContext } from "./contexts.mjs";
+import { headlessSolidResolver } from "./headless.mjs";
+import { lookupGlobalSolidWidget } from "./widget.mjs";
+import { z } from "zod";
+import { createMemo, createUniqueId, splitProps, useContext } from "solid-js";
+import { jsx, jsxs } from "solid-js/jsx-runtime";
+//#region src/solid/SchemaComponent.tsx
+/** @jsxImportSource solid-js */
+/**
+* `<SchemaComponent>` — Solid renderer for Zod, JSON Schema, or OpenAPI
+* inputs.
+*
+* Auto-detects the input format, normalises it to canonical JSON Schema
+* via the shared adapter, walks the JSON Schema tree, and delegates
+* per-field rendering to the {@link SolidComponentResolver} supplied via
+* {@link SchemaProvider} — falling back to the headless renderer when
+* no provider sits above this component.
+*
+* Key differences from the React adapter:
+*
+* - State is held in plain Solid signals (`createSignal`) rather than
+*   React's `useState`; the renderer does not keep its own copy of
+*   `value` — controlled mode is the only supported pattern, matching
+*   the React surface.
+* - There are no per-render hooks. `useId` is replaced by
+*   `createUniqueId()`; `useMemo` / `useCallback` are unnecessary
+*   because Solid's fine-grained reactivity already avoids the
+*   re-allocation costs they exist to mitigate in React.
+* - `splitProps` separates the renderer-internal props from those
+*   forwarded to the host primitive.
+* - Context propagation uses Solid's `createContext` /
+*   `<Context.Provider>` (re-exported via `solid/contexts.ts`) — the
+*   public API matches the React `<SchemaProvider>` shape.
+*/
+/**
+* Provide a theme resolver and scoped widgets to every
+* `<SchemaComponent>` rendered inside the subtree.
+*
+* Wrap an application (or a region of it) with `<SchemaProvider>` so a
+* single resolver — typically a custom Solid `SolidComponentResolver`
+* — drives every schema render. Without a provider the headless
+* resolver is used.
+*
+* @group Components
+* @example
+* ```tsx
+* import { SchemaProvider, SchemaComponent } from "schema-components/solid/SchemaComponent";
+*
+* <SchemaProvider resolver={customResolver}>
+*   <SchemaComponent schema={userSchema} value={user} onChange={setUser} />
+* </SchemaProvider>
+* ```
+*/
+function SchemaProvider(props) {
+	return /* @__PURE__ */ jsx(UserResolverContext.Provider, {
+		value: props.resolver,
+		children: /* @__PURE__ */ jsx(WidgetsContext.Provider, {
+			value: props.widgets,
+			children: props.children
+		})
+	});
+}
+/**
+* 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 every shared id helper in `core/idPath.ts`.
+*/
+function joinPath(parent, suffix) {
+	if (suffix === void 0 || suffix.length === 0) return parent;
+	if (parent.length === 0) return suffix;
+	if (suffix.startsWith("[")) return `${parent}${suffix}`;
+	return `${parent}.${suffix}`;
+}
+/**
+* Normalise a `createUniqueId()` value into a DOM-id-safe prefix.
+* Solid's `createUniqueId()` already returns a usable id, but consumers
+* may also pass a label-derived string. Replace any run of
+* non-alphanumeric characters with a single hyphen and trim leading
+* and trailing hyphens.
+*/
+function sanitisePrefix(value) {
+	const sanitised = value.replace(/[^a-zA-Z0-9_]+/g, "-").replace(/^-+|-+$/g, "");
+	if (sanitised.length === 0) throw new Error(`Cannot derive a DOM-safe id prefix from "${value}". Pass an explicit idPrefix prop.`);
+	return sanitised;
+}
+/**
+* Render a single walked field through the resolved widget / resolver /
+* headless pipeline. Used internally by {@link SchemaComponent} and
+* exported so other Solid-side components (e.g. theme adapters) can
+* dispatch into the same fallback chain.
+*/
+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 `createUniqueId()`) 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) ?? lookupGlobalSolidWidget(componentHint);
+		if (widget !== void 0) {
+			const result = widget(buildSolidProps(tree, value, onChange, renderChild, path));
+			if (result !== null && result !== void 0) return result;
+		}
+	}
+	const resolver = userResolver !== void 0 ? mergeSolidResolvers(userResolver, headlessSolidResolver) : headlessSolidResolver;
+	const renderFn = getSolidRenderFunction(tree.type, resolver);
+	if (renderFn !== void 0) {
+		let result;
+		try {
+			result = renderFn(buildSolidProps(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 result;
+	}
+	if (value === void 0 || value === null) return /* @__PURE__ */ jsx("span", { children: "—" });
+	return /* @__PURE__ */ jsx("span", { children: typeof value === "string" ? value : JSON.stringify(value) });
+}
+/**
+* Build the Solid render props for a single field. Inlines the
+* editability resolution from `core/renderer.ts` `buildRenderProps`
+* because the React variant of that helper types its `renderChild`
+* parameter against React's `renderChild` signature (returns
+* `unknown`); Solid's signature returns `JSX.Element`, so we
+* compose the same shape locally rather than route through a function
+* whose static type does not accept the Solid signature.
+*
+* Editability resolution matches `buildRenderProps`:
+*
+* - `readOnly` is forced to `true` if `onChange` was supplied as the
+*   no-op (i.e. the caller passed `undefined`); the dispatcher does
+*   not currently exercise the read-only path on this surface (the
+*   Solid `<SchemaView>` component handles that) but the contract is
+*   the same.
+* - `writeOnly` is taken from `tree.editability === "input"`.
+*/
+function buildSolidProps(tree, value, onChange, renderChild, path) {
+	const props = {
+		value,
+		readOnly: tree.editability === "presentation",
+		writeOnly: tree.editability === "input",
+		meta: tree.meta,
+		constraints: tree.constraints,
+		path,
+		tree,
+		onChange,
+		renderChild
+	};
+	if (tree.examples !== void 0) props.examples = tree.examples;
+	return props;
+}
+/**
+* Merge two `SolidComponentResolver` instances — user values win,
+* fallback fills gaps. Local parallel to `core/renderer.ts`
+* `mergeResolvers` (which is typed against React's resolver shape).
+*/
+function mergeSolidResolvers(user, fallback) {
+	const merged = {};
+	for (const key of [
+		"string",
+		"number",
+		"boolean",
+		"null",
+		"enum",
+		"object",
+		"array",
+		"tuple",
+		"record",
+		"union",
+		"discriminatedUnion",
+		"conditional",
+		"negation",
+		"literal",
+		"file",
+		"never",
+		"unknown"
+	]) {
+		const fn = user[key] ?? fallback[key];
+		if (fn !== void 0) merged[key] = fn;
+	}
+	return merged;
+}
+/** Look up the render function for a schema type in a Solid resolver. */
+function getSolidRenderFunction(type, resolver) {
+	return resolver[type];
+}
+/**
+* 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
+* shared adapter, walks the JSON Schema tree, and delegates per-field
+* rendering to the {@link SolidComponentResolver} supplied via
+* {@link SchemaProvider} — falling back to the headless renderer when
+* no provider is present.
+*
+* Pass `readOnly` to render a presentational view instead of inputs.
+*
+* @group Components
+* @example
+* ```tsx
+* import { z } from "zod";
+* import { SchemaComponent } from "schema-components/solid/SchemaComponent";
+*
+* const userSchema = z.object({ name: z.string(), email: z.email() });
+*
+* <SchemaComponent schema={userSchema} value={user} onChange={setUser} />
+* ```
+*/
+function SchemaComponent(props) {
+	const [, rest] = splitProps(props, ["schema"]);
+	const schemaInput = props.schema;
+	const generatedId = createUniqueId();
+	const userResolver = readUserResolver();
+	const contextWidgets = readWidgets();
+	const computed = createMemo(() => {
+		const componentMeta = rest.meta;
+		const readOnly = rest.readOnly;
+		const writeOnly = rest.writeOnly;
+		const description = rest.description;
+		const onDiagnostic = rest.onDiagnostic;
+		const strict = rest.strict;
+		const io = rest.io;
+		const refInput = rest.ref;
+		const onError = rest.onError;
+		const idPrefix = rest.idPrefix;
+		const mergedMeta = { ...componentMeta };
+		if (readOnly === true) mergedMeta.readOnly = true;
+		if (writeOnly === true) mergedMeta.writeOnly = 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 zodSchema;
+		let rootMeta;
+		let rootDocument;
+		let normaliseError;
+		try {
+			const normalised = normaliseSchema(schemaInput, refInput, diagnostics !== void 0 || io !== void 0 ? {
+				...diagnostics !== void 0 ? { diagnostics } : {},
+				...io !== void 0 ? { io } : {}
+			} : void 0);
+			jsonSchema = normalised.jsonSchema;
+			zodSchema = normalised.zodSchema;
+			rootMeta = normalised.rootMeta;
+			rootDocument = normalised.rootDocument;
+		} catch (err) {
+			normaliseError = err instanceof SchemaNormalisationError ? err : new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", schemaInput, "unknown");
+		}
+		const rootPath = idPrefix ?? sanitisePrefix(generatedId);
+		return {
+			jsonSchema,
+			zodSchema,
+			rootMeta,
+			rootDocument,
+			mergedMeta,
+			diagnostics,
+			normaliseError,
+			rootPath,
+			onError,
+			io
+		};
+	});
+	const renderTree = () => {
+		const { jsonSchema, zodSchema, rootMeta, rootDocument, mergedMeta, diagnostics, normaliseError, rootPath, onError, io } = computed();
+		if (normaliseError !== void 0) {
+			if (onError !== void 0) {
+				onError(normaliseError);
+				return null;
+			}
+			throw normaliseError;
+		}
+		if (jsonSchema === void 0 || rootDocument === void 0) return null;
+		const fieldsRecord = toRecordOrUndefined(rest.fields);
+		const tree = walk(jsonSchema, {
+			componentMeta: mergedMeta,
+			rootMeta,
+			fieldOverrides: fieldsRecord,
+			rootDocument,
+			...diagnostics !== void 0 ? { diagnostics } : {}
+		});
+		const handleChange = (nextValue) => {
+			if (rest.validate === true) {
+				const error = runValidation(zodSchema, jsonSchema, nextValue, io, rest.onDiagnostic);
+				if (error !== void 0) {
+					rest.onValidationError?.(error);
+					dispatchFieldErrors(fieldsRecord, error);
+				}
+			}
+			if (rest.onChange !== void 0) rest.onChange(nextValue);
+		};
+		const makeRenderChild = (currentDepth, parentPath) => (childTree, childValue, childOnChange, pathSuffix) => {
+			const childPath = joinPath(parentPath, pathSuffix);
+			return renderField(childTree, childValue, childOnChange, userResolver, makeRenderChild(currentDepth + 1, childPath), childPath, rest.widgets, contextWidgets, currentDepth + 1);
+		};
+		const renderChild = makeRenderChild(0, rootPath);
+		return renderField(tree, rest.value ?? tree.defaultValue, handleChange, userResolver, renderChild, rootPath, rest.widgets, contextWidgets, 0);
+	};
+	return renderTree();
+}
+function readUserResolver() {
+	return useContext(UserResolverContext);
+}
+function readWidgets() {
+	return useContext(WidgetsContext);
+}
+/**
+* Run validation against the supplied value.
+*
+* Mirrors the React adapter's `runValidation`. Returns the validation
+* error on failure or `undefined` when the value is valid. Throws
+* `SchemaNormalisationError` (kind `zod-conversion-failed`) when the
+* `z.fromJSONSchema` fallback path is taken AND no diagnostic sink
+* is wired up — mirroring the React adapter's no-silent-fallback
+* contract.
+*/
+function runValidation(zodSchema, jsonSchema, value, io, onDiagnostic) {
+	if (zodSchema !== void 0 && isObject(zodSchema)) {
+		const resolvedIo = io ?? "output";
+		const validateFn = isCodecSchema(zodSchema) && resolvedIo === "output" ? zodSchema.safeEncode : zodSchema.safeParse;
+		if (isCallable(validateFn)) {
+			const result = validateFn(value);
+			if (isObject(result) && "success" in result && result.success !== true) return result.error;
+			return;
+		}
+	}
+	let parsed;
+	try {
+		parsed = z.fromJSONSchema(jsonSchema);
+	} catch (err) {
+		if (onDiagnostic !== void 0) {
+			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" }
+			});
+			return;
+		}
+		throw new SchemaNormalisationError(`Fallback validation failed: z.fromJSONSchema could not round-trip the normalised JSON Schema. Original message: ${err instanceof Error ? err.message : "z.fromJSONSchema threw a non-Error value"}`, jsonSchema, "zod-conversion-failed", void 0, err);
+	}
+	if (isObject(parsed)) {
+		const safeParseFn = parsed.safeParse;
+		if (isCallable(safeParseFn)) {
+			const result = safeParseFn(value);
+			if (isObject(result) && "success" in result && result.success !== true) return result.error;
+		}
+	}
+}
+function isCallable(value) {
+	return typeof value === "function";
+}
+function dispatchFieldErrors(fields, error) {
+	if (fields === void 0 || !isObject(error)) return;
+	if (!("issues" in error)) return;
+	const issues = error.issues;
+	if (!Array.isArray(issues)) return;
+	for (const [key, override] of Object.entries(fields)) {
+		if (override === void 0 || typeof override !== "object") continue;
+		if (override === null) continue;
+		if (!("onValidationError" in override)) continue;
+		const fieldCallback = override.onValidationError;
+		if (typeof fieldCallback !== "function") continue;
+		const fieldErrors = issues.filter((issue) => {
+			if (!isObject(issue)) return false;
+			if (!("path" in issue)) return false;
+			const path = issue.path;
+			if (!Array.isArray(path)) return false;
+			return path[0] === key;
+		});
+		if (fieldErrors.length > 0 && isFieldErrorCallback(fieldCallback)) fieldCallback({ issues: fieldErrors });
+	}
+}
+function isFieldErrorCallback(value) {
+	return typeof value === "function";
+}
+//#endregion
+export { SchemaComponent, SchemaProvider, joinPath, renderField, sanitisePrefix };

package/dist/solid/SchemaErrorBoundary.d.mts

@@ -0,0 +1,38 @@
+import { JSX } from "solid-js";
+
+//#region src/solid/SchemaErrorBoundary.d.ts
+/**
+ * Props accepted by {@link SchemaErrorBoundary}.
+ *
+ * @group Components
+ */
+interface SchemaErrorBoundaryProps {
+  /**
+   * Called with the caught error and a `reset` callback that clears
+   * the error state so children can re-mount. Mirrors the React
+   * adapter's signature.
+   */
+  fallback: (error: Error, reset: () => void) => JSX.Element;
+  children: JSX.Element;
+}
+/**
+ * Catch rendering errors from `<SchemaComponent>`, theme adapters, and
+ * any descendant. Wraps Solid's built-in `<ErrorBoundary>` so the API
+ * shape matches `react/SchemaErrorBoundary.tsx`.
+ *
+ * Solid's `ErrorBoundary` accepts `unknown` errors. The wrapper
+ * coerces non-`Error` throws into a generic `Error` with the original
+ * value's stringified form so consumers always receive an `Error`
+ * instance.
+ *
+ * @group Components
+ * @example
+ * ```tsx
+ * <SchemaErrorBoundary fallback={(error) => <p>{error.message}</p>}>
+ *   <SchemaComponent schema={userSchema} value={user} onChange={setUser} />
+ * </SchemaErrorBoundary>
+ * ```
+ */
+declare function SchemaErrorBoundary(props: SchemaErrorBoundaryProps): JSX.Element;
+//#endregion
+export { SchemaErrorBoundary, SchemaErrorBoundaryProps };

package/dist/solid/SchemaErrorBoundary.mjs

@@ -0,0 +1,57 @@
+import { SchemaError } from "../core/errors.mjs";
+import { ErrorBoundary } from "solid-js";
+import { jsx } from "solid-js/jsx-runtime";
+//#region src/solid/SchemaErrorBoundary.tsx
+/** @jsxImportSource solid-js */
+/**
+* Solid error boundary for schema-components.
+*
+* Wraps children in Solid's built-in `<ErrorBoundary>` and forwards the
+* caught error to a consumer-supplied `fallback` callback. Catches
+* render errors from `<SchemaComponent>`, theme adapters, and any
+* descendant — without this boundary, a throwing render function
+* propagates to the nearest enclosing root and tears down the entire
+* subtree.
+*
+* `SchemaError` instances (the structured failures emitted by
+* `<SchemaComponent>`'s normalisation and validation pipeline) are
+* routed without console noise — the consumer's `onError` prop on the
+* upstream `<SchemaComponent>` already handled them. Other errors are
+* logged once to `console.error` for unhandled-failure visibility,
+* matching the React adapter's behaviour.
+*
+* Does not catch:
+* - Errors thrown from event handlers (onChange, etc.).
+* - Asynchronous errors.
+* - Errors in server-side rendering (Solid Start has its own model).
+*/
+/**
+* Catch rendering errors from `<SchemaComponent>`, theme adapters, and
+* any descendant. Wraps Solid's built-in `<ErrorBoundary>` so the API
+* shape matches `react/SchemaErrorBoundary.tsx`.
+*
+* Solid's `ErrorBoundary` accepts `unknown` errors. The wrapper
+* coerces non-`Error` throws into a generic `Error` with the original
+* value's stringified form so consumers always receive an `Error`
+* instance.
+*
+* @group Components
+* @example
+* ```tsx
+* <SchemaErrorBoundary fallback={(error) => <p>{error.message}</p>}>
+*   <SchemaComponent schema={userSchema} value={user} onChange={setUser} />
+* </SchemaErrorBoundary>
+* ```
+*/
+function SchemaErrorBoundary(props) {
+	return /* @__PURE__ */ jsx(ErrorBoundary, {
+		fallback: (err, reset) => {
+			const error = err instanceof Error ? err : new Error(typeof err === "string" ? err : "Unknown render error");
+			if (!(error instanceof SchemaError)) console.error("[schema-components] Unhandled render error:", error);
+			return props.fallback(error, reset);
+		},
+		children: props.children
+	});
+}
+//#endregion
+export { SchemaErrorBoundary };

package/dist/solid/SchemaField.d.mts

@@ -0,0 +1,40 @@
+import { w as SchemaMeta } from "../types-BBQaEPfE.mjs";
+import { d as PathOfType, f as RejectUnrepresentableZod, r as FromJSONSchema } from "../typeInference-Y8tNEQJk.mjs";
+import { z } from "zod";
+import { JSX } from "solid-js";
+
+//#region src/solid/SchemaField.d.ts
+/**
+ * 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)> {
+  path: P;
+  schema: RejectUnrepresentableZod<T>;
+  ref?: Ref;
+  value?: unknown;
+  onChange?: (value: unknown) => void;
+  meta?: SchemaMeta;
+  validate?: boolean;
+  onValidationError?: (error: unknown) => void;
+}
+/**
+ * Render a single field from a schema by dot-separated `path`.
+ *
+ * Walks the full schema tree, resolves the field at the supplied
+ * `path`, then renders only that field through the same resolver
+ * pipeline as `<SchemaComponent>`.
+ *
+ * @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)>(props: SchemaFieldProps<T, Ref, P>): JSX.Element;
+//#endregion
+export { SchemaField, SchemaFieldProps };

package/dist/solid/SchemaField.mjs

@@ -0,0 +1,113 @@
+import { isObject } from "../core/guards.mjs";
+import { SchemaFieldError, SchemaNormalisationError } from "../core/errors.mjs";
+import { isCodecSchema, normaliseSchema } from "../core/adapter.mjs";
+import { resolvePath, resolveValue, setNestedValue } from "../core/fieldPath.mjs";
+import { walk } from "../core/walker.mjs";
+import { UserResolverContext, WidgetsContext } from "./contexts.mjs";
+import { joinPath, renderField, sanitisePrefix } from "./SchemaComponent.mjs";
+import { z } from "zod";
+import { createUniqueId, useContext } from "solid-js";
+//#region src/solid/SchemaField.tsx
+/** @jsxImportSource solid-js */
+/**
+* `<SchemaField>` — render a single field from a Solid schema by
+* dot-separated `path`.
+*
+* Mirrors the React adapter's `<SchemaField>`. Walks the full schema
+* tree, resolves the field at the supplied `path`, then renders only
+* that field through the same resolver pipeline as `<SchemaComponent>`.
+*
+* Reads context bindings (`UserResolverContext`, `WidgetsContext`)
+* exposed by `<SchemaProvider>`, so a single provider drives every
+* `<SchemaField>` inside its subtree just as it does for
+* `<SchemaComponent>`.
+*/
+/**
+* Render a single field from a schema by dot-separated `path`.
+*
+* Walks the full schema tree, resolves the field at the supplied
+* `path`, then renders only that field through the same resolver
+* pipeline as `<SchemaComponent>`.
+*
+* @group Components
+*/
+function SchemaField(props) {
+	const generatedId = createUniqueId();
+	const userResolver = useContext(UserResolverContext);
+	const contextWidgets = useContext(WidgetsContext);
+	let jsonSchema;
+	let zodSchema;
+	let rootMeta;
+	let rootDocument;
+	try {
+		const normalised = normaliseSchema(props.schema, props.ref);
+		jsonSchema = normalised.jsonSchema;
+		zodSchema = normalised.zodSchema;
+		rootMeta = normalised.rootMeta;
+		rootDocument = normalised.rootDocument;
+	} catch (err) {
+		if (err instanceof SchemaNormalisationError) throw err;
+		throw new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", props.schema, "unknown");
+	}
+	const walkOptions = {
+		componentMeta: props.meta,
+		rootMeta,
+		rootDocument
+	};
+	const fieldTree = resolvePath(walk(jsonSchema, walkOptions), props.path);
+	if (fieldTree === void 0) throw new SchemaFieldError(`Field not found: ${props.path}`, props.schema, props.path);
+	const fieldValue = resolveValue(props.value, props.path);
+	const handleChange = (nextFieldValue) => {
+		const newRootValue = setNestedValue(props.value, props.path, nextFieldValue);
+		if (props.validate === true) {
+			const error = runFieldValidation(zodSchema, jsonSchema, newRootValue);
+			if (error !== void 0) props.onValidationError?.(error);
+		}
+		props.onChange?.(newRootValue);
+	};
+	const rootPath = joinPath(sanitisePrefix(generatedId), props.path);
+	const makeRenderChild = (currentDepth, parentPath) => (childTree, childValue, childOnChange, pathSuffix) => {
+		const childPath = joinPath(parentPath, pathSuffix);
+		return renderField(childTree, childValue, childOnChange, userResolver, makeRenderChild(currentDepth + 1, childPath), childPath, void 0, contextWidgets, currentDepth + 1);
+	};
+	return renderField(fieldTree, fieldValue, handleChange, userResolver, makeRenderChild(0, rootPath), rootPath, void 0, contextWidgets, 0);
+}
+function isCallable(value) {
+	return typeof value === "function";
+}
+function runFieldValidation(zodSchema, jsonSchema, value, io, onDiagnostic) {
+	if (zodSchema !== void 0 && isObject(zodSchema)) {
+		const resolvedIo = io ?? "output";
+		const validateFn = isCodecSchema(zodSchema) && resolvedIo === "output" ? zodSchema.safeEncode : zodSchema.safeParse;
+		if (isCallable(validateFn)) {
+			const result = validateFn(value);
+			if (isObject(result) && "success" in result && result.success !== true) return result.error;
+			return;
+		}
+	}
+	let parsed;
+	try {
+		parsed = z.fromJSONSchema(jsonSchema);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "z.fromJSONSchema threw a non-Error value";
+		if (onDiagnostic !== void 0) {
+			onDiagnostic({
+				code: "unsupported-type",
+				message: `Skipping fallback validation: z.fromJSONSchema could not round-trip the normalised JSON Schema. Original message: ${message}`,
+				pointer: "",
+				detail: { source: "z.fromJSONSchema" }
+			});
+			return;
+		}
+		throw new SchemaNormalisationError(`Fallback validation failed: z.fromJSONSchema could not round-trip the normalised JSON Schema. Original message: ${message}`, jsonSchema, "zod-conversion-failed", void 0, err);
+	}
+	if (isObject(parsed)) {
+		const safeParseFn = parsed.safeParse;
+		if (isCallable(safeParseFn)) {
+			const result = safeParseFn(value);
+			if (isObject(result) && "success" in result && result.success !== true) return result.error;
+		}
+	}
+}
+//#endregion
+export { SchemaField };