@xmachines/docs 1.0.0-beta.51 → 1.0.0-beta.52

package/api/@xmachines/play-dom/README.md

@@ -6,7 +6,7 @@
 
 Vanilla DOM renderer for XMachines Play architecture with signal-driven rendering.
 
-Part of the [xmachines-js monorepo](../../README.md).
+Part of the [XMachines Play monorepo](../../README.md).
 
 ## Installation
 
@@ -89,7 +89,9 @@ disconnect();
 
 ### `createPlayUI` — batteries-included factory with full options
 
-Use `createPlayUI` when you need render error handling, a fallback element, or a shared `registryResult` that you also need to reference programmatically (e.g. for `executeAction`).
+Use `createPlayUI` when you need render error handling, a fallback element, navigation integration, computed functions, or custom validation — or when you need to reference `registryResult` programmatically (e.g. for `executeAction`).
+
+Factory-level options (`functions`, `validationFunctions`, `navigate`, `onRenderError`, `fallback`) are closed over at creation time and applied on every `mount()` call. Per-mount options (`store`, `loading`) are passed to `mount()` itself.
 
 ```typescript
 import { defineRegistry, createPlayUI, schema } from "@xmachines/play-dom";
@@ -112,6 +114,10 @@ const registryResult = defineRegistry(catalog, {
 const mount = createPlayUI(registryResult, {
 	onRenderError: console.error,
 	fallback: document.getElementById("loading")!,
+	navigate: (path) => myRouter.push(path),
+	functions: {
+		fullName: (args) => `${args.first} ${args.last}`,
+	},
 });
 
 const disconnect = mount(actor, document.getElementById("app")!);
@@ -150,35 +156,112 @@ const renderer = new PlayRenderer(container, actor, registryResult.registry, {
 renderer.connect();
 ```
 
-### `connectRenderer` — functional API (backward-compatible)
+## Provider Options
 
-`connectRenderer` is the original functional API, equivalent to creating a `PlayRenderer` and calling `connect()` in one step. Prefer `createRenderer` or `createPlayUI` for new code.
+All entry points (`createPlayUI`, `PlayRenderer`) accept the same set of UI-provider options via `UIProviderOptions`. These are forwarded into `DomRenderContext` on every render pass, making them available to component implementations via `ctx.ctx.*`.
 
-```typescript
-import { connectRenderer, defineRegistry, schema } from "@xmachines/play-dom";
+### `functions` — named compute functions for `$computed` prop expressions
 
-const registryResult = defineRegistry(catalog, {
-	components: {
-		Home: ({ props }) => {
-			const el = document.createElement("section");
-			el.textContent = props.title;
-			return el;
-		},
+Enables `{ "$computed": "name", "args": {...} }` dynamic prop values in specs. Each function receives the resolved `args` object and returns the computed value.
+
+```typescript
+const mount = createPlayUI(registryResult, {
+	functions: {
+		fullName: (args) => `${args.first} ${args.last}`,
+		formatDate: (args) => new Date(args.iso as string).toLocaleDateString(),
 	},
-	actions: {
-		logout: async () => actor.send({ type: "auth.logout" }),
+});
+```
+
+Without `functions`, any `$computed` expression silently resolves to `undefined` (no throw, backward-compatible).
+
+### `validationFunctions` — custom field validation
+
+Provides named validation functions for inline field validation within components. Functions receive `(value, args?)` and return `true` (valid) or `false` (invalid).
+
+Unlike the framework renderers, the DOM renderer has no automatic `ValidationProvider` tree. Components must invoke validation explicitly using `runValidationCheck` / `runValidation` from `@json-render/core`, passing `ctx.ctx.validationFunctions` as `customFunctions`.
+
+```typescript
+import { runValidationCheck } from "@json-render/core";
+
+const mount = createPlayUI(registryResult, {
+	validationFunctions: {
+		isEven: (value) => typeof value === "number" && value % 2 === 0,
+		phoneNumber: (value) => /^\+?[\d\s\-()]{7,}$/.test(String(value)),
 	},
 });
 
-const disconnect = connectRenderer({
-	actor,
-	registry: registryResult.registry,
-	registryResult,
-	container: document.getElementById("app")!,
+// Inside a ComponentFn:
+const MyField: ComponentFn<typeof catalog, "MyField"> = ({ ctx }) => {
+	const result = runValidationCheck(
+		{ type: "isEven", message: "must be even" },
+		{ value: someValue, stateModel: {}, customFunctions: ctx.ctx.validationFunctions },
+	);
+	// result.valid, result.message
+};
+```
+
+### `navigate` — programmatic navigation from action bindings
+
+A callback invoked when an action binding resolves with `onSuccess: { navigate: "/path" }`. The resolved path string is passed as the sole argument. Integrate with any router:
+
+```typescript
+// React Router / TanStack Router / any push-based router:
+const mount = createPlayUI(registryResult, {
+	navigate: (path) => myRouter.push(path),
 });
+```
 
-// Later:
-disconnect();
+With a spec binding:
+
+```json
+{
+	"on": {
+		"click": {
+			"action": "submitForm",
+			"onSuccess": { "navigate": "/dashboard" }
+		}
+	}
+}
+```
+
+When `submitForm` completes successfully, `navigate("/dashboard")` is called automatically.
+
+The function is also readable by component implementations directly via `ctx.ctx.navigate` for cases where navigation needs to be triggered outside of an action binding.
+
+### `onRenderError` — unified error handler
+
+Receives `(error, name)` for three distinct error classes:
+
+- **Component render errors** — when a `ComponentFn` throws synchronously during `renderSpec`. `name` is the catalog component name (e.g. `"Home"`).
+- **Action handler rejections (emit path)** — when an `ActionFn` throws or returns a rejected promise during `emit()`. `name` is the catalog action name (e.g. `"submitForm"`).
+- **Action handler rejections (watch path)** — when an `ActionFn` rejects during a `watch` binding callback. `name` is the catalog action name.
+
+```typescript
+const mount = createPlayUI(registryResult, {
+	onRenderError: (err, name) => {
+		// Route to your application's error tracking
+		Sentry.captureException(err, { extra: { name } });
+	},
+});
+```
+
+The argument order matches the upstream `RenderErrorHandler` type from `@json-render/core`: **error first, name second**. This is consistent with the framework renderers (`@json-render/solid`, `@json-render/react`).
+
+Without `onRenderError`, all three error types are logged via `console.error` and swallowed. No exception propagates, and no unhandled promise rejection is created.
+
+The handler is also available to component implementations via `ctx.ctx.onRenderError`, enabling components to route their own internal errors through the same channel:
+
+```typescript
+const MyComponent: ComponentFn<typeof catalog, "MyComponent"> = ({ ctx }) => {
+	try {
+		const el = doSomethingRisky();
+		return el;
+	} catch (err) {
+		ctx.ctx.onRenderError?.(err, "MyComponent");
+		return null;
+	}
+};
 ```
 
 ## API Summary
@@ -190,36 +273,33 @@ disconnect();
 | `createRenderer(catalog, components)`    | function | One-call factory — returns `mount(actor, container, options?) → disconnect` |
 | `createPlayUI(registryResult, options?)` | function | Batteries-included factory — returns `MountFn`                              |
 | `PlayRenderer`                           | class    | Class-based renderer with `connect()` / `disconnect()` lifecycle            |
-| `connectRenderer(options)`               | function | Functional API; backward-compatible alternative to `PlayRenderer`           |
 | `defineRegistry(catalog, options)`       | function | Build a catalog-typed `DomRegistry` with typed handlers                     |
 | `renderSpec(...)`                        | function | Pure Spec → DOM renderer (low-level)                                        |
 | `schema`                                 | const    | The `@json-render/dom` schema — pass to `defineCatalog()`                   |
 
 ### Key Types
 
-| Type                     | Description                                                                            |
-| ------------------------ | -------------------------------------------------------------------------------------- |
-| `ComponentFn<C, K>`      | Catalog-typed component function — returns `HTMLElement \| Text \| null`               |
-| `ComponentContext<C, K>` | Context passed to each component: `props`, `children`, `emit`, `on`, `bindings`, `ctx` |
-| `ActionFn<C, K>`         | Catalog-typed action function — receives `(params, setState, state)`                   |
-| `EventHandle`            | Handle returned by `on(eventName)` — has `emit()`, `shouldPreventDefault`, `bound`     |
-| `SetState`               | State updater: `(prev => next) => void`                                                |
-| `DefineRegistryResult`   | Result from `defineRegistry` — has `registry`, `handlers`, `executeAction`             |
-| `PlayDomOptions`         | Options for `PlayRenderer` and `connectRenderer`                                       |
-| `BaseComponentProps<P>`  | Catalog-agnostic component props for shared component libraries                        |
-| `DomRegistry`            | Raw registry type: `Record<string, DomComponentRenderer>`                              |
-| `DomSchema`              | Type of the `schema` export                                                            |
-
-### Error Classes
-
-| Class                   | Error Code                        | Description                              |
-| ----------------------- | --------------------------------- | ---------------------------------------- |
-| `MissingCatalogError`   | `PLAY_RENDERER_MISSING_CATALOG`   | Components map was `null` or `undefined` |
-| `MissingComponentError` | `PLAY_RENDERER_MISSING_COMPONENT` | Component name not found in catalog      |
+| Type                     | Description                                                                                |
+| ------------------------ | ------------------------------------------------------------------------------------------ |
+| `ComponentFn<C, K>`      | Catalog-typed component function — returns `HTMLElement \| Text \| null`                   |
+| `ComponentContext<C, K>` | Context passed to each component: `props`, `children`, `emit`, `on`, `bindings`, `ctx`     |
+| `ActionFn<C, K>`         | Catalog-typed action function — receives `(params, setState, state)`                       |
+| `EventHandle`            | Handle returned by `on(eventName)` — has `emit()`, `shouldPreventDefault`, `bound`         |
+| `SetState`               | State updater: `(prev => next) => void`                                                    |
+| `DefineRegistryResult`   | Result from `defineRegistry` — has `registry`, `handlers`, `executeAction`                 |
+| `PlayDomOptions`         | Options for `PlayRenderer` — extends `UIProviderOptions`                                   |
+| `CreatePlayUIOptions`    | Options for `createPlayUI` — extends `UIProviderOptions`, adds `fallback`                  |
+| `MountOptions`           | Per-mount options for `MountFn`: `store`, `loading`                                        |
+| `MountFn`                | The mount function returned by `createPlayUI`: `(actor, container, options?) → disconnect` |
+| `UIProviderOptions`      | Shared options: `functions`, `validationFunctions`, `navigate`, `onRenderError`            |
+| `BaseComponentProps<P>`  | Catalog-agnostic component props for shared component libraries                            |
+| `DomRegistry`            | Raw registry type: `Record<string, DomComponentRenderer>`                                  |
+| `DomSchema`              | Type of the `schema` export                                                                |
+| `ComputedFunction`       | Type for named compute functions used with the `functions` option                          |
 
 ## Rendering Behaviour
 
-- **Initial render is synchronous** — the container is populated before `connect()` or `connectRenderer()` returns.
+- **Initial render is synchronous** — the container is populated before `connect()` returns.
 - **Signal-driven re-renders are microtask-deferred** — `watchSignal` schedules updates on the next microtask queue tick.
 - **Null view** clears the container. A `fallback` element can be shown on initial mount when the view is `null`; it is **not** re-appended if the view later transitions back to `null` after a non-null view.
 - **Double `connect()` is safe** — calling `connect()` on an already-connected renderer auto-disconnects first.
@@ -244,9 +324,9 @@ Public API split into two layers:
 **XMachines layer** (this package):
 
 - `createRenderer()` — one-call factory: returns `mount(actor, container, options?) → disconnect`
+- `createPlayUI()` — batteries-included factory with full options: returns `MountFn`
 - `PlayRenderer` — class-based renderer with `connect()` / `disconnect()` lifecycle
-- `connectRenderer()` — functional API (backward-compat alternative to `PlayRenderer`)
-- `ConnectRendererOptions`, `PlayDomOptions`
+- `PlayDomOptions`, `CreatePlayUIOptions`, `MountFn`, `MountOptions`
 
 **json-render layer** (upstreamable to @json-render/dom):
 
@@ -270,7 +350,6 @@ Public API split into two layers:
 ## Interfaces
 
 - [ComponentContext](interfaces/ComponentContext.md)
-- [ConnectRendererOptions](interfaces/ConnectRendererOptions.md)
 - [CreatePlayUIOptions](interfaces/CreatePlayUIOptions.md)
 - [DefineRegistryResult](interfaces/DefineRegistryResult.md)
 - [DomRenderContext](interfaces/DomRenderContext.md)
@@ -301,7 +380,6 @@ Public API split into two layers:
 
 ## Functions
 
-- [connectRenderer](functions/connectRenderer.md)
 - [createPlayUI](functions/createPlayUI.md)
 - [createRenderer](functions/createRenderer.md)
 - [defineRegistry](functions/defineRegistry.md)

package/api/@xmachines/play-dom/classes/PlayRenderer.md

@@ -2,13 +2,21 @@
 
 # Class: PlayRenderer
 
-Defined in: [packages/play-dom/src/PlayRenderer.ts:78](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/PlayRenderer.ts#L78)
+Defined in: [packages/play-dom/src/PlayRenderer.ts:87](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/PlayRenderer.ts#L87)
 
 PlayRenderer connects an actor's `currentView` signal to the DOM renderer.
 
 Watches `actor.currentView` via TC39 Signals and renders `DomComponentRenderer`
 functions into `container` on every view transition. Cleared on `disconnect()`.
 
+Options from `PlayDomOptions` (which extends `UIProviderOptions`) are all forwarded
+into `DomRenderContext` on every render pass:
+
+- `functions` — named compute functions for `{ $computed: "name" }` prop expressions
+- `validationFunctions` — custom validation functions, available at `ctx.ctx.validationFunctions`
+- `navigate` — navigation callback, invoked on `onSuccess: { navigate: "..." }` action bindings
+- `onRenderError` — called with `(error, name)` for component render errors and action handler rejections
+
 **Preferred usage — via `registryResult`:**
 
 ```typescript
@@ -17,6 +25,8 @@ import { PlayRenderer, defineRegistry } from "@xmachines/play-dom";
 const registryResult = defineRegistry(catalog, { components, actions });
 const renderer = new PlayRenderer(container, actor, registryResult.registry, {
 	registryResult, // wires setState/getState from xstate store automatically
+	navigate: (path) => myRouter.push(path),
+	functions: { fullName: (args) => `${args.first} ${args.last}` },
 });
 renderer.connect();
 // Later:
@@ -50,16 +60,16 @@ new PlayRenderer(
    options?): PlayRenderer;
 ```
 
-Defined in: [packages/play-dom/src/PlayRenderer.ts:101](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/PlayRenderer.ts#L101)
+Defined in: [packages/play-dom/src/PlayRenderer.ts:113](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/PlayRenderer.ts#L113)
 
 #### Parameters
 
-| Parameter   | Type                                                                                                                                                                                                                                                             | Description                                                                                                                                                                                                                                                                                                                                            |
-| ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `container` | `HTMLElement`                                                                                                                                                                                                                                                    | `HTMLElement` to render into. Cleared and repopulated on every view transition.                                                                                                                                                                                                                                                                        |
-| `actor`     | [`AbstractActor`](../../play-actor/classes/AbstractActor.md)\<[`AnyActorLogic`](https://www.jsdocs.io/package/xstate#AnyActorLogic), [`EventObject`](https://www.jsdocs.io/package/xstate#EventObject)\> & [`Viewable`](../../play-actor/interfaces/Viewable.md) | Actor providing the `currentView` signal (must implement `Viewable`).                                                                                                                                                                                                                                                                                  |
-| `registry`  | [`DomRegistry`](../type-aliases/DomRegistry.md)                                                                                                                                                                                                                  | Component renderer map — typically `registryResult.registry` from `defineRegistry`.                                                                                                                                                                                                                                                                    |
-| `options`   | [`PlayDomOptions`](../interfaces/PlayDomOptions.md)                                                                                                                                                                                                              | Configuration: - `registryResult` — preferred; auto-wires `setState`/`state` from the xstate store. - `handlers` — pre-resolved handler map (legacy; used when `registryResult` is absent). - `store` — external `StateStore` (controlled mode; overrides `spec.state` seeding). - `loading` — streaming mode flag; suppresses missing-child warnings. |
+| Parameter   | Type                                                                                                                                                                                                                                                             | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `container` | `HTMLElement`                                                                                                                                                                                                                                                    | `HTMLElement` to render into. Cleared and repopulated on every view transition.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `actor`     | [`AbstractActor`](../../play-actor/classes/AbstractActor.md)\<[`AnyActorLogic`](https://www.jsdocs.io/package/xstate#AnyActorLogic), [`EventObject`](https://www.jsdocs.io/package/xstate#EventObject)\> & [`Viewable`](../../play-actor/interfaces/Viewable.md) | Actor providing the `currentView` signal (must implement `Viewable`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `registry`  | [`DomRegistry`](../type-aliases/DomRegistry.md)                                                                                                                                                                                                                  | Component renderer map — typically `registryResult.registry` from `defineRegistry`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `options`   | [`PlayDomOptions`](../interfaces/PlayDomOptions.md)                                                                                                                                                                                                              | Configuration (see [PlayDomOptions](../interfaces/PlayDomOptions.md)): - `registryResult` — auto-wires `setState`/`state` from the xstate store. - `store` — external `StateStore` (controlled mode; overrides `spec.state` seeding). - `loading` — streaming mode flag; suppresses missing-child warnings. - `functions` — named compute functions for `$computed` prop expressions. - `validationFunctions` — custom validation functions; available at `ctx.ctx.validationFunctions`. - `navigate` — navigation callback; invoked on `onSuccess: { navigate: "..." }`. - `onRenderError` — `(error, name)` handler for component render errors and action handler rejections; suppresses `console.error` fallback. |
 
 #### Returns
 
@@ -73,7 +83,7 @@ Defined in: [packages/play-dom/src/PlayRenderer.ts:101](https://gitlab.com/xmach
 connect(): void;
 ```
 
-Defined in: [packages/play-dom/src/PlayRenderer.ts:117](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/PlayRenderer.ts#L117)
+Defined in: [packages/play-dom/src/PlayRenderer.ts:129](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/PlayRenderer.ts#L129)
 
 Start watching actor.currentView and render to container.
 Renders the initial view synchronously, then subscribes to signal changes.
@@ -95,7 +105,7 @@ change. Guard against this by auto-disconnecting first.
 disconnect(): void;
 ```
 
-Defined in: [packages/play-dom/src/PlayRenderer.ts:126](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/PlayRenderer.ts#L126)
+Defined in: [packages/play-dom/src/PlayRenderer.ts:138](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/PlayRenderer.ts#L138)
 
 Stop watching and clear the container.
 

package/api/@xmachines/play-dom/functions/createPlayUI.md

@@ -6,23 +6,23 @@
 function createPlayUI(registryResult, options?): MountFn;
 ```
 
-Defined in: [packages/play-dom/src/create-play-ui.ts:64](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/create-play-ui.ts#L64)
+Defined in: [packages/play-dom/src/create-play-ui.ts:92](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/create-play-ui.ts#L92)
 
 Create a batteries-included DOM renderer mount function.
 
-The user is responsible for calling defineRegistry to produce registryResult.
-createPlayUI closes over the registryResult and returns a mount function that
-can be called once per actor/container pair.
+The caller is responsible for producing `registryResult` via `defineRegistry`.
+`createPlayUI` closes over it and returns a `MountFn` that can be invoked
+once per actor/container pair.
 
 ## Parameters
 
-| Parameter        | Type                                                            | Description                                                                |
-| ---------------- | --------------------------------------------------------------- | -------------------------------------------------------------------------- |
-| `registryResult` | [`DefineRegistryResult`](../interfaces/DefineRegistryResult.md) | Result from defineRegistry() containing registry + handlers factory.       |
-| `options`        | [`CreatePlayUIOptions`](../interfaces/CreatePlayUIOptions.md)   | Optional factory-level configuration (validationFunctions, navigate, etc.) |
+| Parameter        | Type                                                            | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| ---------------- | --------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `registryResult` | [`DefineRegistryResult`](../interfaces/DefineRegistryResult.md) | Result from `defineRegistry()` — provides the registry and the lazy handlers factory.                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `options`        | [`CreatePlayUIOptions`](../interfaces/CreatePlayUIOptions.md)   | Factory-level configuration (see [CreatePlayUIOptions](../interfaces/CreatePlayUIOptions.md)): - `functions` — named compute functions for `$computed` prop expressions. - `validationFunctions` — custom validation functions; available at `ctx.ctx.validationFunctions`. - `navigate` — navigation callback; invoked on `onSuccess: { navigate: "..." }`. - `onRenderError` — `(error, name)` handler for component render errors and action handler rejections. - `fallback` — element shown when the actor's initial view is `null`. |
 
 ## Returns
 
 [`MountFn`](../type-aliases/MountFn.md)
 
-mount function: (actor, container, mountOptions?) → disconnect
+`MountFn`: `(actor, container, mountOptions?) → disconnect`

package/api/@xmachines/play-dom/functions/createRenderer.md

@@ -6,7 +6,7 @@
 function createRenderer<C>(catalog, componentMap): (actor, container, options?) => () => void;
 ```
 
-Defined in: [packages/play-dom/src/create-renderer.ts:83](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/create-renderer.ts#L83)
+Defined in: [packages/play-dom/src/create-renderer.ts:84](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/create-renderer.ts#L84)
 
 Create a reusable DOM renderer factory from a catalog and component map.
 
@@ -39,5 +39,6 @@ reuses the result across all `mount()` calls. The `mount` options type therefore
 `registryResult` (it is always provided by `createRenderer` itself and cannot be overridden).
 
 If you need to call `registryResult.executeAction()` programmatically (outside the emit/on
-flow), or share the same `registryResult` with `connectRenderer`, use `defineRegistry` and
+flow), or pass additional provider options (`navigate`, `onRenderError`, `functions`, etc.),
+use `createPlayUI` (which accepts the full `CreatePlayUIOptions`) or `defineRegistry` with
 `PlayRenderer` directly rather than `createRenderer`.

package/api/@xmachines/play-dom/functions/defineRegistry.md

@@ -6,7 +6,7 @@
 function defineRegistry<C>(_catalog, options): DefineRegistryResult;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:398](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/json-render/types.ts#L398)
+Defined in: [packages/play-dom/src/json-render/types.ts:527](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/json-render/types.ts#L527)
 
 ## Type Parameters
 

package/api/@xmachines/play-dom/functions/renderSpec.md

@@ -14,10 +14,12 @@ function renderSpec(
 	functions?,
 	loading?,
 	onWatchSetup?,
+	validationFunctions?,
+	navigate?,
 ): Node | null;
 ```
 
-Defined in: [packages/play-dom/src/json-render/renderer.ts:116](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/json-render/renderer.ts#L116)
+Defined in: [packages/play-dom/src/json-render/renderer.ts:135](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/json-render/renderer.ts#L135)
 
 Render a Spec tree into DOM nodes using the provided `DomRegistry`.
 
@@ -30,18 +32,20 @@ built by `defineRegistry` — this function only orchestrates the traversal.
 
 ## Parameters
 
-| Parameter        | Type                                                              | Description                                                                                                                                                                                                                                                                            |
-| ---------------- | ----------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `spec`           | `Spec`                                                            | The json-render `Spec` describing the UI tree.                                                                                                                                                                                                                                         |
-| `store`          | `StateStore`                                                      | Live `StateStore` bound to `spec.state`.                                                                                                                                                                                                                                               |
-| `registry`       | [`DomRegistry`](../type-aliases/DomRegistry.md)                   | Map of element type names → `DomComponentRenderer`.                                                                                                                                                                                                                                    |
-| `send`           | (`event`) => `void`                                               | Dispatcher for interaction events (e.g. actor.send).                                                                                                                                                                                                                                   |
-| `handlers`       | `Record`\<`string`, `ActionHandler`\>                             | Map of catalog action names → async ActionHandler functions.                                                                                                                                                                                                                           |
-| `fallback?`      | [`DomComponentRenderer`](../type-aliases/DomComponentRenderer.md) | Optional renderer called when `registry` has no entry for an element's `type` (GAP-04). If absent, unknown types return `null`.                                                                                                                                                        |
-| `onRenderError?` | (`type`, `err`) => `void`                                         | Optional callback invoked with `(type, error)` when a component renderer throws (GAP-08). If absent, errors are logged via `console.error` with the prefix `[json-render] Rendering error in`.                                                                                         |
-| `functions?`     | `Record`\<`string`, `ComputedFunction`\>                          | Optional map of named compute functions forwarded to `PropResolutionContext` (GAP-03). Enables `{ $computed: "fn", args }` prop expressions to resolve. When absent, `$computed` expressions return `undefined` (backward-compatible, no throw).                                       |
-| `loading?`       | `boolean`                                                         | Optional flag indicating the spec is still streaming (GAP-06). When `true`, components can read `ctx.loading` to render skeleton states, and missing-child warnings (GAP-07) are suppressed since referenced elements may not yet have arrived in the incremental spec.                |
-| `onWatchSetup?`  | (`cleanup`) => `void`                                             | Optional callback invoked with each watch subscription cleanup function (GAP-02). When an element declares `watch`, the renderer sets up a store subscription and passes its unsubscribe function to this callback. Callers (e.g. PlayRenderer) collect these to call on disconnect(). |
+| Parameter              | Type                                                              | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| ---------------------- | ----------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `spec`                 | `Spec`                                                            | The json-render `Spec` describing the UI tree.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `store`                | `StateStore`                                                      | Live `StateStore` bound to `spec.state`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `registry`             | [`DomRegistry`](../type-aliases/DomRegistry.md)                   | Map of element type names → `DomComponentRenderer`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `send`                 | (`event`) => `void`                                               | Dispatcher for interaction events (e.g. actor.send).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `handlers`             | `Record`\<`string`, `ActionHandler`\>                             | Map of catalog action names → async ActionHandler functions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `fallback?`            | [`DomComponentRenderer`](../type-aliases/DomComponentRenderer.md) | Optional renderer called when `registry` has no entry for an element's `type` (GAP-04). If absent, unknown types return `null`.                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `onRenderError?`       | [`RenderErrorHandler`](../type-aliases/RenderErrorHandler.md)     | Optional callback matching `RenderErrorHandler = (error, name)`. Invoked for three distinct error classes: - `(error, elementType)` when a component renderer throws (GAP-08) - `(error, actionName)` when an action handler rejects during `emit()` - `(error, actionName)` when an action handler rejects in a `watch` binding If absent, all three fall back to `console.error`. Forwarded into `DomRenderContext.onRenderError` so `emit()` and `watch` handlers route errors through the same channel as component render errors. |
+| `functions?`           | `Record`\<`string`, `ComputedFunction`\>                          | Optional map of named compute functions forwarded to `PropResolutionContext` (GAP-03). Enables `{ $computed: "fn", args }` prop expressions to resolve. When absent, `$computed` expressions return `undefined` (backward-compatible, no throw).                                                                                                                                                                                                                                                                                       |
+| `loading?`             | `boolean`                                                         | Optional flag indicating the spec is still streaming (GAP-06). When `true`, components can read `ctx.loading` to render skeleton states, and missing-child warnings (GAP-07) are suppressed since referenced elements may not yet have arrived in the incremental spec.                                                                                                                                                                                                                                                                |
+| `onWatchSetup?`        | (`cleanup`) => `void`                                             | Optional callback invoked with each watch subscription cleanup function (GAP-02). When an element declares `watch`, the renderer sets up a store subscription and passes its unsubscribe function to this callback. Callers (e.g. PlayRenderer) collect these to call on disconnect().                                                                                                                                                                                                                                                 |
+| `validationFunctions?` | `Record`\<`string`, (`value`, `args?`) => `boolean`\>             | Optional map of custom validation functions forwarded to `DomRenderContext.validationFunctions`. Components pass these as `customFunctions` to `runValidationCheck` / `runValidation` from `@json-render/core`. Has no effect on prop resolution.                                                                                                                                                                                                                                                                                      |
+| `navigate?`            | (`path`) => `void`                                                | Optional navigation callback forwarded to `DomRenderContext.navigate`. Invoked automatically by `defineRegistry`'s `emit()` when an action binding resolves with `onSuccess: { navigate: "/path" }`. Also readable by component implementations via `ctx.navigate`.                                                                                                                                                                                                                                                                    |
 
 ## Returns
 

package/api/@xmachines/play-dom/interfaces/ComponentContext.md

@@ -2,7 +2,7 @@
 
 # Interface: ComponentContext\<C, K\>
 
-Defined in: [packages/play-dom/src/json-render/types.ts:184](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/json-render/types.ts#L184)
+Defined in: [packages/play-dom/src/json-render/types.ts:305](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/json-render/types.ts#L305)
 
 ## Type Parameters
 
@@ -15,9 +15,9 @@ Defined in: [packages/play-dom/src/json-render/types.ts:184](https://gitlab.com/
 
 | Property                                  | Type                                          | Description                                                                      | Defined in                                                                                                                                                         |
 | ----------------------------------------- | --------------------------------------------- | -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| <a id="property-bindings"></a> `bindings` | `Record`\<`string`, `string`\> \| `undefined` | Two-way binding paths resolved from `$bindState` / `$bindItem` prop expressions. | [packages/play-dom/src/json-render/types.ts:194](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/json-render/types.ts#L194) |
-| <a id="property-children"></a> `children` | `Node`[]                                      | Rendered child nodes from the spec's `children` list.                            | [packages/play-dom/src/json-render/types.ts:190](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/json-render/types.ts#L190) |
-| <a id="property-ctx"></a> `ctx`           | [`DomRenderContext`](DomRenderContext.md)     | Low-level render context.                                                        | [packages/play-dom/src/json-render/types.ts:206](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/json-render/types.ts#L206) |
-| <a id="property-emit"></a> `emit`         | (`event`) => `void`                           | Dispatch a named event defined in the spec's `on` map.                           | [packages/play-dom/src/json-render/types.ts:198](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/json-render/types.ts#L198) |
-| <a id="property-on"></a> `on`             | (`event`) => [`EventHandle`](EventHandle.md)  | Get an `EventHandle` for a named event from the spec's `on` map.                 | [packages/play-dom/src/json-render/types.ts:202](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/json-render/types.ts#L202) |
-| <a id="property-props"></a> `props`       | `InferComponentProps`\<`C`, `K`\>             | Catalog-typed, store-resolved props for this component.                          | [packages/play-dom/src/json-render/types.ts:186](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/json-render/types.ts#L186) |
+| <a id="property-bindings"></a> `bindings` | `Record`\<`string`, `string`\> \| `undefined` | Two-way binding paths resolved from `$bindState` / `$bindItem` prop expressions. | [packages/play-dom/src/json-render/types.ts:315](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/json-render/types.ts#L315) |
+| <a id="property-children"></a> `children` | `Node`[]                                      | Rendered child nodes from the spec's `children` list.                            | [packages/play-dom/src/json-render/types.ts:311](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/json-render/types.ts#L311) |
+| <a id="property-ctx"></a> `ctx`           | [`DomRenderContext`](DomRenderContext.md)     | Low-level render context.                                                        | [packages/play-dom/src/json-render/types.ts:327](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/json-render/types.ts#L327) |
+| <a id="property-emit"></a> `emit`         | (`event`) => `void`                           | Dispatch a named event defined in the spec's `on` map.                           | [packages/play-dom/src/json-render/types.ts:319](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/json-render/types.ts#L319) |
+| <a id="property-on"></a> `on`             | (`event`) => [`EventHandle`](EventHandle.md)  | Get an `EventHandle` for a named event from the spec's `on` map.                 | [packages/play-dom/src/json-render/types.ts:323](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/json-render/types.ts#L323) |
+| <a id="property-props"></a> `props`       | `InferComponentProps`\<`C`, `K`\>             | Catalog-typed, store-resolved props for this component.                          | [packages/play-dom/src/json-render/types.ts:307](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/json-render/types.ts#L307) |

package/api/@xmachines/play-dom/interfaces/CreatePlayUIOptions.md

@@ -2,13 +2,16 @@
 
 # Interface: CreatePlayUIOptions
 
-Defined in: [packages/play-dom/src/types.ts:139](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/types.ts#L139)
+Defined in: [packages/play-dom/src/types.ts:67](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/types.ts#L67)
 
-Options for createPlayUI() — the batteries-included DOM factory.
+Options for `createPlayUI()` — the batteries-included DOM factory.
 
-Extends UIProviderOptions (shared configurable UI behaviours) with the
-DOM-specific `fallback` element. Parallel to PlayUIProvider's extra props
-in the framework renderers.
+Extends [UIProviderOptions](UIProviderOptions.md), which contributes `functions`,
+`validationFunctions`, `navigate`, and `onRenderError`. All four are
+closed over at factory creation time and forwarded into `PlayRenderer`
+on every `mount()` call.
+
+Parallel to `PlayUIProvider`'s props in the framework renderers.
 
 ## See
 
@@ -20,10 +23,10 @@ createPlayUI
 
 ## Properties
 
-| Property                                                         | Type                                                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Inherited from                                                                                                         | Defined in                                                                                                                                                       |
-| ---------------------------------------------------------------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-fallback"></a> `fallback?`                       | `HTMLElement` \| `null`                                       | Optional fallback element shown when `currentView` is `null` on **initial mount** only. The fallback is appended immediately after `mount()` if the container is empty at that moment (i.e. the actor's initial view is `null`). **Limitation:** If the actor's view transitions to `null` after mount, the container will be cleared but this fallback will NOT be re-appended. For dynamic fallback behavior (null view after non-null), use `PlayRenderer` directly and wrap the `actor.currentView` signal to inject fallback content. | -                                                                                                                      | [packages/play-dom/src/types.ts:151](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/types.ts#L151)                       |
-| <a id="property-functions"></a> `functions?`                     | `Record`\<`string`, `ComputedFunction`\>                      | Custom computed functions available to `$computed` field expressions in specs. Mirrors the `functions` prop on `JSONUIProvider` / `JsonUIProvider`.                                                                                                                                                                                                                                                                                                                                                                                        | [`UIProviderOptions`](UIProviderOptions.md).[`functions`](UIProviderOptions.md#property-functions)                     | [packages/play-dom/src/json-render/types.ts:83](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/json-render/types.ts#L83) |
-| <a id="property-navigate"></a> `navigate?`                       | (`path`) => `void`                                            | Navigation function forwarded to json-render computed functions that need to trigger programmatic navigation (e.g. a `navigate` action in the catalog).                                                                                                                                                                                                                                                                                                                                                                                    | [`UIProviderOptions`](UIProviderOptions.md).[`navigate`](UIProviderOptions.md#property-navigate)                       | [packages/play-dom/src/json-render/types.ts:77](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/json-render/types.ts#L77) |
-| <a id="property-onrendererror"></a> `onRenderError?`             | [`RenderErrorHandler`](../type-aliases/RenderErrorHandler.md) | Called when an individual catalog component throws during render. Forwarded as `onRenderError` to the underlying renderer.                                                                                                                                                                                                                                                                                                                                                                                                                 | [`UIProviderOptions`](UIProviderOptions.md).[`onRenderError`](UIProviderOptions.md#property-onrendererror)             | [packages/play-dom/src/json-render/types.ts:89](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/json-render/types.ts#L89) |
-| <a id="property-validationfunctions"></a> `validationFunctions?` | `Record`\<`string`, (`value`, `args?`) => `boolean`\>         | Custom validation functions for the json-render ValidationProvider equivalent. Each function receives `(value, args?)` and returns a boolean.                                                                                                                                                                                                                                                                                                                                                                                              | [`UIProviderOptions`](UIProviderOptions.md).[`validationFunctions`](UIProviderOptions.md#property-validationfunctions) | [packages/play-dom/src/json-render/types.ts:68](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.51/packages/play-dom/src/json-render/types.ts#L68) |
+| Property                                                         | Type                                                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Inherited from                                                                                                         | Defined in                                                                                                                                                         |
+| ---------------------------------------------------------------- | ------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| <a id="property-fallback"></a> `fallback?`                       | `HTMLElement` \| `null`                                       | Optional fallback element shown when `currentView` is `null` on **initial mount** only. The fallback is appended immediately after `mount()` if the container is empty at that moment (i.e. the actor's initial view is `null`). **Limitation:** If the actor's view transitions to `null` after mount, the container will be cleared but this fallback will NOT be re-appended. For dynamic fallback behavior (null view after non-null), use `PlayRenderer` directly and wrap the `actor.currentView` signal to inject fallback content.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | -                                                                                                                      | [packages/play-dom/src/types.ts:79](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/types.ts#L79)                           |
+| <a id="property-functions"></a> `functions?`                     | `Record`\<`string`, `ComputedFunction`\>                      | Named compute functions for `{ $computed: "name", args: {...} }` prop expressions. Each function receives the resolved `args` object and returns the computed value. Forwarded directly to `resolveElementProps` via `PropResolutionContext.functions`, matching the `FunctionsContext` provider in the framework renderers. Without this option, `$computed` expressions resolve to `undefined` (no throw). **Example** `const mount = createPlayUI(registryResult, { functions: { fullName: (args) => `${args.first} ${args.last}`, formatCurrency: (args) => new Intl.NumberFormat().format(args.amount as number), }, });` Mirrors the `functions` prop on `JSONUIProvider` / `JsonUIProvider`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | [`UIProviderOptions`](UIProviderOptions.md).[`functions`](UIProviderOptions.md#property-functions)                     | [packages/play-dom/src/json-render/types.ts:88](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/json-render/types.ts#L88)   |
+| <a id="property-navigate"></a> `navigate?`                       | (`path`) => `void`                                            | Programmatic navigation function. Called automatically when an action binding resolves with `onSuccess: { navigate: "/path" }`. The resolved path string is passed as the sole argument. Mirrors the `navigate` prop in `ActionProvider` from the framework renderers, where it is captured in the `execute()` closure. Also available to component implementations directly via `ctx.ctx.navigate` for cases where navigation needs to be triggered outside of an action binding. **Example** `import { useNavigate } from "my-router"; const navigate = useNavigate(); const mount = createPlayUI(registryResult, { navigate });` Spec binding that triggers navigation: `{ "on": { "click": { "action": "doSomething", "onSuccess": { "navigate": "/dashboard" } } } }`                                                                                                                                                                                                                                                                                                                                                                                              | [`UIProviderOptions`](UIProviderOptions.md).[`navigate`](UIProviderOptions.md#property-navigate)                       | [packages/play-dom/src/json-render/types.ts:152](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/json-render/types.ts#L152) |
+| <a id="property-onrendererror"></a> `onRenderError?`             | [`RenderErrorHandler`](../type-aliases/RenderErrorHandler.md) | Unified error handler for component render errors and action handler rejections. Matches `RenderErrorHandler = (error: unknown, name: string) => void`. Invoked for three distinct error classes: - `(error, elementType)` — when a component renderer throws synchronously during `renderSpec` - `(error, actionName)` — when an action handler rejects during `emit()` (on-event path) - `(error, actionName)` — when an action handler rejects during a `watch` binding callback When provided, suppresses the `console.error` fallback for all three error types. Forwarded into `renderSpec` as the `onRenderError` parameter and into `DomRenderContext.onRenderError` so both `emit()` and `watch` handlers route their errors through the same channel as component render errors. **Example** `const mount = createPlayUI(registryResult, { onRenderError: (err, name) => { myErrorReporter.capture(err, { context: name }); }, });`                                                                                                                                                                                                                           | [`UIProviderOptions`](UIProviderOptions.md).[`onRenderError`](UIProviderOptions.md#property-onrendererror)             | [packages/play-dom/src/json-render/types.ts:178](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/json-render/types.ts#L178) |
+| <a id="property-validationfunctions"></a> `validationFunctions?` | `Record`\<`string`, (`value`, `args?`) => `boolean`\>         | Custom validation functions for inline field validation. Each function receives `(value, args?)` and returns `true` (valid) or `false` (invalid). Functions are available to component implementations via `ctx.ctx.validationFunctions` and should be passed as `customFunctions` to `runValidationCheck` / `runValidation` from `@json-render/core`. Mirrors `customFunctions` in `ValidationProvider` from the framework renderers. The DOM renderer has no automatic `ValidationProvider` tree — validation must be invoked explicitly by component implementations. **Example** `import { runValidationCheck } from "@json-render/core"; const mount = createPlayUI(registryResult, { validationFunctions: { isEven: (value) => typeof value === "number" && value % 2 === 0, phoneNumber: (value) => /^\+?[\d\s\-()]{7,}$/.test(String(value)), }, }); // Inside a ComponentFn: const MyField: ComponentFn<typeof catalog, "MyField"> = ({ ctx }) => { const result = runValidationCheck( { type: "isEven", message: "must be even" }, { value: someValue, stateModel: {}, customFunctions: ctx.ctx.validationFunctions }, ); // result.valid, result.message };` | [`UIProviderOptions`](UIProviderOptions.md).[`validationFunctions`](UIProviderOptions.md#property-validationfunctions) | [packages/play-dom/src/json-render/types.ts:123](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.52/packages/play-dom/src/json-render/types.ts#L123) |