schema-components 2.0.2 → 2.1.0

package/dist/lit/types.d.mts

@@ -0,0 +1,2 @@
+import { i as _LitFunctionShapeAssertion, n as LitRenderFunction, r as LitRenderProps, t as LitComponentResolver } from "../types-BCy7K3nk.mjs";
+export { LitComponentResolver, LitRenderFunction, LitRenderProps, _LitFunctionShapeAssertion };

package/dist/lit/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/lit/widget.d.mts

@@ -0,0 +1,71 @@
+//#region src/lit/widget.d.ts
+/**
+ * Widget registry for the Lit adapter.
+ *
+ * Where the React adapter's widget registry stores function values
+ * (`(props: RenderProps) => unknown`), the Lit adapter stores Custom
+ * Element tag names — because every renderer override on the Web
+ * Components side IS a Custom Element. A schema field carrying
+ * `.meta({ component: "color-picker" })` is rendered by looking up
+ * the tag name registered against `"color-picker"` and emitting an
+ * instance of that element with the per-field props attached.
+ *
+ * Two scopes are supported:
+ *
+ * 1. **Global** — `registerLitWidget(name, tag)` writes to a module-level
+ *    map shared by every `<schema-component>` in the document. Matches
+ *    the React `registerWidget()` global default behaviour.
+ * 2. **Instance** — the `widgets` property on `<schema-component>` (a
+ *    `LitWidgetMap` from `lit/contexts.ts`) overrides the global map
+ *    for the wrapped subtree.
+ *
+ * Resolution order: instance widgets → global widgets → resolver →
+ * default Custom Element registry. The same order the React adapter
+ * implements; the only difference is the per-step lookup returns a
+ * tag name rather than a function value.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Register a widget globally. The widget is resolved when a schema
+ * field has `.meta({ component: name })` and the rendered element is
+ * an instance of the matching Custom Element tag.
+ *
+ * `tag` must be a valid Custom Element name (containing a hyphen) and
+ * SHOULD be registered via `customElements.define` before any
+ * `<schema-component>` in the document instantiates the corresponding
+ * field — otherwise the browser emits an unupgraded element and the
+ * registered handler never runs.
+ *
+ * @example
+ * ```ts
+ * import { registerLitWidget } from "schema-components/lit/widget";
+ * import "./my-color-picker.ts";   // calls customElements.define("my-color-picker", ...)
+ *
+ * registerLitWidget("color-picker", "my-color-picker");
+ * ```
+ *
+ * @param name - Widget hint name (matches `.meta({ component })`).
+ * @param tag - Custom Element tag name (e.g. `my-color-picker`).
+ */
+declare function registerLitWidget(name: string, tag: string): void;
+/**
+ * Resolve a widget hint to a Custom Element tag name, considering
+ * instance widgets first and falling back to the global registry.
+ *
+ * @param name - Widget hint name from `.meta({ component })`.
+ * @param instanceWidgets - Optional instance-scoped overrides.
+ * @returns The Custom Element tag, or `undefined` when no widget is
+ *   registered under `name` at either scope.
+ */
+declare function resolveLitWidget(name: string, instanceWidgets?: ReadonlyMap<string, string>): string | undefined;
+/**
+ * Clear every globally registered widget. Intended for test isolation
+ * — `registerLitWidget` writes to module-level state, and that state
+ * leaks across test cases without an explicit reset.
+ *
+ * @internal
+ */
+declare function __clearGlobalLitWidgets(): void;
+//#endregion
+export { __clearGlobalLitWidgets, registerLitWidget, resolveLitWidget };

package/dist/lit/widget.mjs

@@ -0,0 +1,87 @@
+//#region src/lit/widget.ts
+/**
+* Widget registry for the Lit adapter.
+*
+* Where the React adapter's widget registry stores function values
+* (`(props: RenderProps) => unknown`), the Lit adapter stores Custom
+* Element tag names — because every renderer override on the Web
+* Components side IS a Custom Element. A schema field carrying
+* `.meta({ component: "color-picker" })` is rendered by looking up
+* the tag name registered against `"color-picker"` and emitting an
+* instance of that element with the per-field props attached.
+*
+* Two scopes are supported:
+*
+* 1. **Global** — `registerLitWidget(name, tag)` writes to a module-level
+*    map shared by every `<schema-component>` in the document. Matches
+*    the React `registerWidget()` global default behaviour.
+* 2. **Instance** — the `widgets` property on `<schema-component>` (a
+*    `LitWidgetMap` from `lit/contexts.ts`) overrides the global map
+*    for the wrapped subtree.
+*
+* Resolution order: instance widgets → global widgets → resolver →
+* default Custom Element registry. The same order the React adapter
+* implements; the only difference is the per-step lookup returns a
+* tag name rather than a function value.
+*
+* @packageDocumentation
+*/
+/**
+* Global widget registry — `widget-name` → custom element tag name.
+*
+* Internal; consumers register via {@link registerLitWidget} and read
+* via {@link resolveLitWidget} so the map shape can evolve without
+* breaking callers.
+*/
+const globalLitWidgets = /* @__PURE__ */ new Map();
+/**
+* Register a widget globally. The widget is resolved when a schema
+* field has `.meta({ component: name })` and the rendered element is
+* an instance of the matching Custom Element tag.
+*
+* `tag` must be a valid Custom Element name (containing a hyphen) and
+* SHOULD be registered via `customElements.define` before any
+* `<schema-component>` in the document instantiates the corresponding
+* field — otherwise the browser emits an unupgraded element and the
+* registered handler never runs.
+*
+* @example
+* ```ts
+* import { registerLitWidget } from "schema-components/lit/widget";
+* import "./my-color-picker.ts";   // calls customElements.define("my-color-picker", ...)
+*
+* registerLitWidget("color-picker", "my-color-picker");
+* ```
+*
+* @param name - Widget hint name (matches `.meta({ component })`).
+* @param tag - Custom Element tag name (e.g. `my-color-picker`).
+*/
+function registerLitWidget(name, tag) {
+	globalLitWidgets.set(name, tag);
+}
+/**
+* Resolve a widget hint to a Custom Element tag name, considering
+* instance widgets first and falling back to the global registry.
+*
+* @param name - Widget hint name from `.meta({ component })`.
+* @param instanceWidgets - Optional instance-scoped overrides.
+* @returns The Custom Element tag, or `undefined` when no widget is
+*   registered under `name` at either scope.
+*/
+function resolveLitWidget(name, instanceWidgets) {
+	const instance = instanceWidgets?.get(name);
+	if (instance !== void 0) return instance;
+	return globalLitWidgets.get(name);
+}
+/**
+* Clear every globally registered widget. Intended for test isolation
+* — `registerLitWidget` writes to module-level state, and that state
+* leaks across test cases without an explicit reset.
+*
+* @internal
+*/
+function __clearGlobalLitWidgets() {
+	globalLitWidgets.clear();
+}
+//#endregion
+export { __clearGlobalLitWidgets, registerLitWidget, resolveLitWidget };

package/dist/openapi/ApiCallbacks.d.mts

@@ -1,4 +1,4 @@
-import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
+import { w as SchemaMeta } from "../types-BBQaEPfE.mjs";
 import { CallbackInfo } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/ApiLinks.d.mts

@@ -1,4 +1,4 @@
-import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
+import { w as SchemaMeta } from "../types-BBQaEPfE.mjs";
 import { LinkInfo } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/ApiResponseHeaders.d.mts

@@ -1,4 +1,4 @@
-import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
+import { w as SchemaMeta } from "../types-BBQaEPfE.mjs";
 import { HeaderInfo } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/ApiSecurity.d.mts

@@ -1,4 +1,4 @@
-import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
+import { w as SchemaMeta } from "../types-BBQaEPfE.mjs";
 import { SecurityRequirement, SecurityScheme } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/components.d.mts

@@ -1,7 +1,7 @@
-import { u as FieldOverride, w as SchemaMeta } from "../types-BrYbjC7_.mjs";
-import { r as DiagnosticSink } from "../diagnostics-BTrm3O6J.mjs";
-import { WidgetMap } from "../core/renderer.mjs";
-import { InferParameterOverrides, InferRequestBodyFields, InferResponseFields, OpenAPIRequestBodyType, OpenAPIResponseType } from "../core/typeInference.mjs";
+import { u as FieldOverride, w as SchemaMeta } from "../types-BBQaEPfE.mjs";
+import { r as DiagnosticSink } from "../diagnostics-mftUZI7c.mjs";
+import { d as WidgetMap } from "../renderer-ab9E52Bp.mjs";
+import { a as InferParameterOverrides, l as OpenAPIRequestBodyType, o as InferRequestBodyFields, s as InferResponseFields, u as OpenAPIResponseType } from "../typeInference-Y8tNEQJk.mjs";
 import { ReactNode } from "react";
 
 //#region src/openapi/components.d.ts

package/dist/openapi/parser.d.mts

@@ -1,5 +1,5 @@
-import { m as JsonObject } from "../types-BrYbjC7_.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-BTrm3O6J.mjs";
+import { m as JsonObject } from "../types-BBQaEPfE.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-mftUZI7c.mjs";
 
 //#region src/openapi/parser.d.ts
 /**

package/dist/openapi/resolve.d.mts

@@ -1,4 +1,4 @@
-import { i as DiagnosticsOptions } from "../diagnostics-BTrm3O6J.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-mftUZI7c.mjs";
 import { OpenApiDocument, OperationInfo, ParameterInfo, RequestBodyInfo, ResponseInfo } from "./parser.mjs";
 
 //#region src/openapi/resolve.d.ts

package/dist/preact/SchemaComponent.d.mts

@@ -0,0 +1,3 @@
+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, n as SchemaComponentProps, r as SchemaField, t as SchemaComponent } from "../SchemaComponent-B__6-5-E.mjs";
+export { type InferFields, type InferredInputValue, type InferredOutputValue, type InferredValue, SchemaComponent, type SchemaComponentProps, SchemaField, type SchemaFieldProps, SchemaProvider, registerWidget };

package/dist/preact/SchemaComponent.mjs

@@ -0,0 +1,26 @@
+import { SchemaComponent, SchemaField, SchemaProvider, registerWidget } from "../react/SchemaComponent.mjs";
+//#region src/preact/SchemaComponent.ts
+/**
+* Preact entry point for `<SchemaComponent>`, `<SchemaProvider>`,
+* `<SchemaField>` and `registerWidget`.
+*
+* Every export below is the React adapter export imported under the
+* same name and re-exported. The Preact entry point works because the
+* consumer aliases `react` to `preact/compat` in their bundler — see
+* the "Preact support" section of the README for the alias config
+* required in Vite, Next.js, and Node consumers. Without the alias,
+* the React imports here resolve to the real React runtime, which
+* defeats the purpose of importing from the Preact entry point.
+*
+* Implementation note: the renderer tree is intentionally identical to
+* the React adapter. `preact/compat` translates React-style `onChange`
+* to `onInput`, matching the "fires on every keystroke" semantics that
+* the controlled inputs in `react/headlessRenderers.tsx` rely on.
+*
+* The `import` + plain `export { ... }` idiom below (rather than
+* `export { ... } from`) is deliberate: the project's lint rules ban
+* `export ... from` outside `index` files, so each binding is brought
+* into local scope before being exported.
+*/
+//#endregion
+export { SchemaComponent, SchemaField, SchemaProvider, registerWidget };

package/dist/preact/SchemaErrorBoundary.d.mts

@@ -0,0 +1,2 @@
+import { SchemaErrorBoundary, SchemaErrorBoundaryProps } from "../react/SchemaErrorBoundary.mjs";
+export { SchemaErrorBoundary, type SchemaErrorBoundaryProps };

package/dist/preact/SchemaErrorBoundary.mjs

@@ -0,0 +1,20 @@
+import { SchemaErrorBoundary } from "../react/SchemaErrorBoundary.mjs";
+//#region src/preact/SchemaErrorBoundary.ts
+/**
+* Preact entry point for `<SchemaErrorBoundary>`.
+*
+* The export is the React adapter export imported under the same name
+* and re-exported. The Preact entry point works because the consumer
+* aliases `react` to `preact/compat` in their bundler — see the
+* "Preact support" section of the README for the alias config required
+* in Vite, Next.js, and Node consumers. The class component relies on
+* `componentDidCatch` / `getDerivedStateFromError`, both of which are
+* provided by `preact/compat`.
+*
+* The `import` + plain `export { ... }` idiom below (rather than
+* `export { ... } from`) is deliberate: the project's lint rules ban
+* `export ... from` outside `index` files, so each binding is brought
+* into local scope before being exported.
+*/
+//#endregion
+export { SchemaErrorBoundary };

package/dist/preact/SchemaView.d.mts

@@ -0,0 +1,2 @@
+import { SchemaView, SchemaViewProps } from "../react/SchemaView.mjs";
+export { SchemaView, type SchemaViewProps };

package/dist/preact/SchemaView.mjs

@@ -0,0 +1,22 @@
+import { SchemaView } from "../react/SchemaView.mjs";
+//#region src/preact/SchemaView.ts
+/**
+* Preact entry point for `<SchemaView>` — the read-only renderer.
+*
+* The export is the React adapter export imported under the same name
+* and re-exported. The Preact entry point works because the consumer
+* aliases `react` to `preact/compat` in their bundler — see the
+* "Preact support" section of the README for the alias config required
+* in Vite, Next.js, and Node consumers.
+*
+* Limitation: React Server Components is React-only. Under Preact,
+* `<SchemaView>` runs as a client component and the zero-client-JS
+* deployment story documented in the React README does not apply.
+*
+* The `import` + plain `export { ... }` idiom below (rather than
+* `export { ... } from`) is deliberate: the project's lint rules ban
+* `export ... from` outside `index` files, so each binding is brought
+* into local scope before being exported.
+*/
+//#endregion
+export { SchemaView };

package/dist/preact/headless.d.mts

@@ -0,0 +1,2 @@
+import { headlessResolver } from "../react/headless.mjs";
+export { headlessResolver };

package/dist/preact/headless.mjs

@@ -0,0 +1,18 @@
+import { headlessResolver } from "../react/headless.mjs";
+//#region src/preact/headless.ts
+/**
+* Preact entry point for the default headless `ComponentResolver`.
+*
+* The export is the React adapter export imported under the same name
+* and re-exported. The Preact entry point works because the consumer
+* aliases `react` to `preact/compat` in their bundler — see the
+* "Preact support" section of the README for the alias config required
+* in Vite, Next.js, and Node consumers.
+*
+* The `import` + plain `export { ... }` idiom below (rather than
+* `export { ... } from`) is deliberate: the project's lint rules ban
+* `export ... from` outside `index` files, so each binding is brought
+* into local scope before being exported.
+*/
+//#endregion
+export { headlessResolver };

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-Ce-PviSD.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 };