@xmachines/docs 1.0.0-beta.55 → 1.0.0-beta.56

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

@@ -2,7 +2,7 @@
 
 # Interface: RenderSpecOptions
 
-Defined in: [packages/play-dom/src/json-render/renderer.ts:115](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/renderer.ts#L115)
+Defined in: `.pnpm`
 
 Named options for [renderSpec](../functions/renderSpec.md).
 
@@ -11,15 +11,16 @@ empty map, so `renderSpec(spec, store, registry)` renders a static tree.
 
 ## Properties
 
-| Property                                                         | Type                                                              | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Defined in                                                                                                                                                               |
-| ---------------------------------------------------------------- | ----------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| <a id="property-fallback"></a> `fallback?`                       | [`DomComponentRenderer`](../type-aliases/DomComponentRenderer.md) | Renderer called when `registry` has no entry for an element's `type` (GAP-04). If absent, unknown types render as `null`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | [packages/play-dom/src/json-render/renderer.ts:130](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/renderer.ts#L130) |
-| <a id="property-functions"></a> `functions?`                     | `Record`\<`string`, `ComputedFunction`\>                          | Map of named compute functions forwarded to `PropResolutionContext` (GAP-03). Enables `{ $computed: "fn", args }` prop expressions to resolve. When absent, `$computed` expressions return `undefined` (no throw).                                                                                                                                                                                                                                                                                                                                                                                                                     | [packages/play-dom/src/json-render/renderer.ts:147](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/renderer.ts#L147) |
-| <a id="property-handlers"></a> `handlers?`                       | `Record`\<`string`, `ActionHandler`\>                             | Map of catalog action names → async `ActionHandler` functions, consumed by `defineRegistry`'s `emit()`/`watch` dispatch. Defaults to `{}`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | [packages/play-dom/src/json-render/renderer.ts:125](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/renderer.ts#L125) |
-| <a id="property-loading"></a> `loading?`                         | `boolean`                                                         | 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.                                                                                                                                                                                                                                                                                                                                                                         | [packages/play-dom/src/json-render/renderer.ts:154](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/renderer.ts#L154) |
-| <a id="property-navigate"></a> `navigate?`                       | (`path`) => `void`                                                | 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`.                                                                                                                                                                                                                                                                                                                                                                             | [packages/play-dom/src/json-render/renderer.ts:182](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/renderer.ts#L182) |
-| <a id="property-onconfirm"></a> `onConfirm?`                     | [`ConfirmHandler`](../type-aliases/ConfirmHandler.md)             | Confirmation hook forwarded to `DomRenderContext.onConfirm`. Consulted by `defineRegistry`'s `emit()` before executing an action binding that declares `confirm`. Without it, confirm-gated actions are skipped with a `console.warn` (never executed unconfirmed).                                                                                                                                                                                                                                                                                                                                                                    | [packages/play-dom/src/json-render/renderer.ts:189](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/renderer.ts#L189) |
-| <a id="property-onrendererror"></a> `onRenderError?`             | [`RenderErrorHandler`](../type-aliases/RenderErrorHandler.md)     | 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.                                                                                                          | [packages/play-dom/src/json-render/renderer.ts:141](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/renderer.ts#L141) |
-| <a id="property-onwatchsetup"></a> `onWatchSetup?`               | (`cleanup`) => `void` \| (() => `void`)                           | 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(). When absent, `watch` bindings are not wired. May return a replacement cleanup: when the caller wraps the supplied cleanup (e.g. to drop it from its own collection when invoked), the incremental renderer registers the returned wrapper so an unmount-driven release also runs the caller's bookkeeping. Returning nothing keeps the supplied cleanup. | [packages/play-dom/src/json-render/renderer.ts:168](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/renderer.ts#L168) |
-| <a id="property-send"></a> `send?`                               | (`event`) => `void`                                               | Dispatcher for interaction events (e.g. `actor.send`), exposed to component implementations via `ctx.send`. Defaults to a no-op.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | [packages/play-dom/src/json-render/renderer.ts:120](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/renderer.ts#L120) |
-| <a id="property-validationfunctions"></a> `validationFunctions?` | `Record`\<`string`, (`value`, `args?`) => `boolean`\>             | 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.                                                                                                                                                                                                                                                                                                                                                                                                      | [packages/play-dom/src/json-render/renderer.ts:175](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/renderer.ts#L175) |
+| Property                                                         | Type                                                                                                      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Defined in |
+| ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| <a id="property-directives"></a> `directives?`                   | `DirectiveDefinition`\<`ZodType`\<`unknown`, `unknown`, `$ZodTypeInternals`\<`unknown`, `unknown`\>\>\>[] | Custom directives — user-defined `$`-prefixed dynamic values that extend the spec expression language. Converted to a `DirectiveRegistry` once per `renderSpec` call and forwarded to `PropResolutionContext.directives`, matching the framework renderers' `directives` prop (@json-render 0.19). Built-in expressions always take precedence over custom directives.                                                                                                                                                                                                                                                | -          |
+| <a id="property-fallback"></a> `fallback?`                       | [`DomComponentRenderer`](../type-aliases/DomComponentRenderer.md)                                         | Renderer called when `registry` has no entry for an element's `type` (GAP-04). If absent, unknown types render as `null`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | -          |
+| <a id="property-functions"></a> `functions?`                     | `Record`\<`string`, `ComputedFunction`\>                                                                  | Map of named compute functions forwarded to `PropResolutionContext` (GAP-03). Enables `{ $computed: "fn", args }` prop expressions to resolve. When absent, `$computed` expressions return `undefined` (no throw).                                                                                                                                                                                                                                                                                                                                                                                                    | -          |
+| <a id="property-handlers"></a> `handlers?`                       | `Record`\<`string`, `ActionHandler`\>                                                                     | Map of catalog action names → async `ActionHandler` functions, consumed by `defineRegistry`'s `emit()`/`watch` dispatch. Defaults to `{}`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | -          |
+| <a id="property-loading"></a> `loading?`                         | `boolean`                                                                                                 | 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.                                                                                                                                                                                                                                                                                                                                                        | -          |
+| <a id="property-navigate"></a> `navigate?`                       | (`path`) => `void`                                                                                        | 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`.                                                                                                                                                                                                                                                                                                                                                            | -          |
+| <a id="property-onconfirm"></a> `onConfirm?`                     | [`ConfirmHandler`](../type-aliases/ConfirmHandler.md)                                                     | Confirmation hook forwarded to `DomRenderContext.onConfirm`. Consulted by `defineRegistry`'s `emit()` before executing an action binding that declares `confirm`. Without it, confirm-gated actions are skipped with a `console.warn` (never executed unconfirmed).                                                                                                                                                                                                                                                                                                                                                   | -          |
+| <a id="property-onrendererror"></a> `onRenderError?`             | [`RenderErrorHandler`](../type-aliases/RenderErrorHandler.md)                                             | 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.                                                                                         | -          |
+| <a id="property-onwatchsetup"></a> `onWatchSetup?`               | (`cleanup`) => `void` \| (() => `void`)                                                                   | 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. Host renderers collect these to call on teardown. When absent, `watch` bindings are not wired. May return a replacement cleanup: when the caller wraps the supplied cleanup (e.g. to drop it from its own collection when invoked), the incremental renderer registers the returned wrapper so an unmount-driven release also runs the caller's bookkeeping. Returning nothing keeps the supplied cleanup. | -          |
+| <a id="property-send"></a> `send?`                               | (`event`) => `void`                                                                                       | Dispatcher for interaction events (e.g. `actor.send`), exposed to component implementations via `ctx.send`. Defaults to a no-op.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | -          |
+| <a id="property-validationfunctions"></a> `validationFunctions?` | `Record`\<`string`, (`value`, `args?`) => `boolean`\>                                                     | Custom validation functions forwarded to `DomRenderContext.validationFunctions`. Components pass these as `customFunctions` to `runValidationCheck` / `runValidation` from `@xmachines/json-render-core`. Has no effect on prop resolution.                                                                                                                                                                                                                                                                                                                                                                           | -          |

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

@@ -2,15 +2,15 @@
 
 # Interface: UIProviderOptions
 
-Defined in: [packages/play-dom/src/json-render/types.ts:103](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L103)
+Defined in: `.pnpm`
 
 Shared UI-provider options — the configurable rendering behaviours that sit
 above the core actor/registry wiring.
 
 These fields mirror the forwarded props on `JSONUIProvider` /
-`JsonUIProvider` across @json-render/react, /vue, /solid, /svelte.
-Grouping them here lets `PlayDomOptions` and `CreatePlayUIOptions` both extend
-a single source of truth without repeating field declarations.
+`JsonUIProvider` across @xmachines/json-render-react, /vue, /solid, /svelte.
+Grouping them here lets host renderers extend a single source of truth
+without repeating field declarations.
 
 All four fields are threaded into `DomRenderContext` on every render pass
 and are available to component implementations via `ctx.ctx.*`.
@@ -22,10 +22,11 @@ and are available to component implementations via `ctx.ctx.*`.
 
 ## Properties
 
-| Property                                                         | Type                                                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Defined in                                                                                                                                                         |
-| ---------------------------------------------------------------- | ------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| <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`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | [packages/play-dom/src/json-render/types.ts:125](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L125) |
-| <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" } } } }`                                                                                                                                                                                                                                                                                                                                                                                              | [packages/play-dom/src/json-render/types.ts:189](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L189) |
-| <a id="property-onconfirm"></a> `onConfirm?`                     | [`ConfirmHandler`](../type-aliases/ConfirmHandler.md)         | Confirmation hook for actions that declare `confirm` in their binding. Consulted by `emit()` before executing a confirm-gated action. Return (or resolve) `true` to execute, `false` to skip. Without this handler, confirm-gated actions are skipped with a `console.warn` — they never execute unconfirmed. See [ConfirmHandler](../type-aliases/ConfirmHandler.md) for the full contract. This is the headless equivalent of the `pendingConfirmation` / `confirmAction()` / `cancelAction()` flow in the framework adapters.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | [packages/play-dom/src/json-render/types.ts:228](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L228) |
-| <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 }); }, });`                                                                                                                                                                                                                           | [packages/play-dom/src/json-render/types.ts:215](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L215) |
-| <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 };` | [packages/play-dom/src/json-render/types.ts:160](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L160) |
+| Property                                                         | Type                                                                                                      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Defined in |
+| ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| <a id="property-directives"></a> `directives?`                   | `DirectiveDefinition`\<`ZodType`\<`unknown`, `unknown`, `$ZodTypeInternals`\<`unknown`, `unknown`\>\>\>[] | Custom directives — user-defined `$`-prefixed dynamic values that extend the spec expression language (e.g. `{ $format: "currency", value: ... }`). Each entry is a `DirectiveDefinition` built with `defineDirective` from `@xmachines/json-render-core`. The array is converted to a `DirectiveRegistry` once per render pass and forwarded to `resolveElementProps` via `PropResolutionContext.directives`. Built-in expressions (`$state`, `$cond`, etc.) always take precedence over custom directives. Mirrors the `directives` prop on `JSONUIProvider` / `JsonUIProvider` introduced in **Json-render** 0.19. **Example** `import { defineDirective, resolvePropValue } from "@xmachines/json-render-core"; import { z } from "zod"; const formatDirective = defineDirective({ name: "$format", description: "Locale-aware number formatting.", schema: z.object({ $format: z.enum(["number", "currency"]), value: z.unknown() }), resolve(value, ctx) { const resolved = resolvePropValue(value.value, ctx); return new Intl.NumberFormat().format(resolved as number); }, }); renderSpec(spec, store, registry, { directives: [formatDirective] });`                     | -          |
+| <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** `renderSpec(spec, store, registry, { functions: { fullName: (args) => `${args.first} ${args.last}`, formatCurrency: (args) => new Intl.NumberFormat().format(args.amount as number), }, });` Mirrors the `functions` prop on `JSONUIProvider` / `JsonUIProvider`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | -          |
+| <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(); renderSpec(spec, store, registry, { navigate });` Spec binding that triggers navigation: `{ "on": { "click": { "action": "doSomething", "onSuccess": { "navigate": "/dashboard" } } } }`                                                                                                                                                                                                                                                                                                                                                                                                                  | -          |
+| <a id="property-onconfirm"></a> `onConfirm?`                     | [`ConfirmHandler`](../type-aliases/ConfirmHandler.md)                                                     | Confirmation hook for actions that declare `confirm` in their binding. Consulted by `emit()` before executing a confirm-gated action. Return (or resolve) `true` to execute, `false` to skip. Without this handler, confirm-gated actions are skipped with a `console.warn` — they never execute unconfirmed. See [ConfirmHandler](../type-aliases/ConfirmHandler.md) for the full contract. This is the headless equivalent of the `pendingConfirmation` / `confirmAction()` / `cancelAction()` flow in the framework adapters.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | -          |
+| <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** `renderSpec(spec, store, registry, { onRenderError: (err, name) => { myErrorReporter.capture(err, { context: name }); }, });`                                                                                                                                                                                                                                               | -          |
+| <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 `@xmachines/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 "@xmachines/json-render-core"; renderSpec(spec, store, registry, { 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 };` | -          |

package/api/@xmachines/play-dom/type-aliases/ActionFn.md

@@ -6,13 +6,13 @@
 type ActionFn<C, K> = (params, setState, state) => Promise<void>;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:454](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L454)
+Defined in: `.pnpm`
 
-Catalog-typed action function — mirrors `ActionFn<C, K>` from @json-render/react, /solid, /vue.
+Catalog-typed action function — mirrors `ActionFn<C, K>` from @xmachines/json-render-react, /solid, /vue.
 
 - `params` is typed to the exact param schema defined in the catalog, or `undefined` if the
   spec provided no params. Guard against undefined before accessing params.
-- `setState` writes to the @xstate/store-backed local state store. Use it to update ephemeral
+- `setState` writes to the backing local state store. Use it to update ephemeral
   UI state (e.g. form field values, error messages) from within an action handler.
 - `state` is a snapshot of the current state model at the time the action was invoked.
 

package/api/@xmachines/play-dom/type-aliases/Actions.md

@@ -6,7 +6,7 @@
 type Actions<C> = { [K in keyof InferCatalogActions<C>]: ActionFn<C, K> };
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:464](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L464)
+Defined in: `.pnpm`
 
 Map of catalog-typed action handler functions.
 Each key is a catalog action name; each value is an `ActionFn<C, K>` for that action.

package/api/@xmachines/play-dom/type-aliases/BaseComponentProps.md

@@ -6,18 +6,18 @@
 type BaseComponentProps<P> = object;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:409](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L409)
+Defined in: `.pnpm`
 
 Catalog-agnostic component props type.
 
 Use this when building shared component libraries that should not be tied to
 a specific catalog instance. Mirrors `BaseComponentProps<P>` from
-@json-render/react, /vue, /svelte.
+@xmachines/json-render-react, /vue, /svelte.
 
 ## Example
 
 ```ts
-import type { BaseComponentProps } from "@xmachines/play-dom";
+import type { BaseComponentProps } from "@xmachines/json-render-dom";
 
 function MyButton({ props, emit }: BaseComponentProps<{ label: string }>) {
 	const el = document.createElement("button");
@@ -41,7 +41,7 @@ function MyButton({ props, emit }: BaseComponentProps<{ label: string }>) {
 bindings: Record<string, string> | undefined;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:412](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L412)
+Defined in: `.pnpm`
 
 ---
 
@@ -51,7 +51,7 @@ Defined in: [packages/play-dom/src/json-render/types.ts:412](https://gitlab.com/
 children: Node[];
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:411](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L411)
+Defined in: `.pnpm`
 
 ---
 
@@ -61,7 +61,7 @@ Defined in: [packages/play-dom/src/json-render/types.ts:411](https://gitlab.com/
 ctx: DomRenderContext;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:415](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L415)
+Defined in: `.pnpm`
 
 ---
 
@@ -71,7 +71,7 @@ Defined in: [packages/play-dom/src/json-render/types.ts:415](https://gitlab.com/
 emit: (event) => void;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:413](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L413)
+Defined in: `.pnpm`
 
 #### Parameters
 
@@ -91,7 +91,7 @@ Defined in: [packages/play-dom/src/json-render/types.ts:413](https://gitlab.com/
 on: (event) => EventHandle;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:414](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L414)
+Defined in: `.pnpm`
 
 #### Parameters
 
@@ -111,4 +111,4 @@ Defined in: [packages/play-dom/src/json-render/types.ts:414](https://gitlab.com/
 props: P;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:410](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L410)
+Defined in: `.pnpm`

package/api/@xmachines/play-dom/type-aliases/CatalogHasActions.md

@@ -10,11 +10,11 @@ type CatalogHasActions<C> = [InferCatalogActions<C>] extends [never]
 		: true;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:240](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L240)
+Defined in: `.pnpm`
 
 Evaluates to `true` when a catalog declares at least one action; `false` otherwise.
 
-Mirrors `CatalogHasActions<C>` from @json-render/react, /solid, /vue.
+Mirrors `CatalogHasActions<C>` from @xmachines/json-render-react, /solid, /vue.
 Used to make the `actions` field required in `DefineRegistryOptions` when the
 catalog defines actions, and optional when it does not.
 

package/api/@xmachines/play-dom/type-aliases/ComponentFn.md

@@ -6,7 +6,7 @@
 type ComponentFn<C, K> = (ctx) => HTMLElement | Text | null;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:420](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L420)
+Defined in: `.pnpm`
 
 ## Type Parameters
 

package/api/@xmachines/play-dom/type-aliases/ComponentRegistry.md

@@ -6,7 +6,7 @@
 type ComponentRegistry<C> = { [K in keyof InferCatalogComponents<C>]: ComponentFn<C, K> };
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:426](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L426)
+Defined in: `.pnpm`
 
 ## Type Parameters
 

package/api/@xmachines/play-dom/type-aliases/ConfirmHandler.md

@@ -6,13 +6,13 @@
 type ConfirmHandler = (confirm, action) => boolean | Promise<boolean>;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:84](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L84)
+Defined in: `.pnpm`
 
 Hook consulted before executing an action binding that declares `confirm`.
 
 The DOM renderer is headless, so instead of the framework adapters'
 `pendingConfirmation` state (which a dialog component resolves via
-`confirmAction()` / `cancelAction()`), play-dom exposes a single async
+`confirmAction()` / `cancelAction()`), @xmachines/json-render-dom exposes a single async
 callback: return (or resolve) `true` to execute the action, `false` to
 skip it. The confirmation flow — `window.confirm`, a custom dialog, or a
 test stub — is entirely the host's responsibility.
@@ -38,7 +38,7 @@ falsy to skip it silently.
 ## Example
 
 ```typescript
-const mount = createPlayUI(registryResult, {
+renderSpec(spec, store, registry, {
 	onConfirm: (confirm) => window.confirm(`${confirm.title}\n${confirm.message}`),
 });
 ```

package/api/@xmachines/play-dom/type-aliases/DefineRegistryOptions.md

@@ -6,19 +6,19 @@
 type DefineRegistryOptions<C> = object & CatalogHasActions<C> extends true ? object : object;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:486](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L486)
+Defined in: `.pnpm`
 
 Options for `defineRegistry`.
 
-Mirrors `DefineRegistryOptions<C>` from @json-render/react, /solid, /svelte, /vue.
+Mirrors `DefineRegistryOptions<C>` from @xmachines/json-render-react, /solid, /svelte, /vue.
 `actions` accepts catalog-typed async handler functions — params, setState, and state are
 fully typed. When the catalog declares actions, `actions` is required; otherwise optional.
 
 ## Type Declaration
 
-| Name          | Type                                               | Description                                                                                                                                                             | Defined in                                                                                                                                                         |
-| ------------- | -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `components?` | [`ComponentRegistry`](ComponentRegistry.md)\<`C`\> | Catalog-typed component implementations. If omitted, all elements fall through to the `fallback` renderer (if provided) or return `null` — the container will be empty. | [packages/play-dom/src/json-render/types.ts:492](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L492) |
+| Name          | Type                                               | Description                                                                                                                                                             | Defined in |
+| ------------- | -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| `components?` | [`ComponentRegistry`](ComponentRegistry.md)\<`C`\> | Catalog-typed component implementations. If omitted, all elements fall through to the `fallback` renderer (if provided) or return `null` — the container will be empty. | -          |
 
 ## Type Parameters
 

package/api/@xmachines/play-dom/type-aliases/DomComponentRenderer.md

@@ -6,7 +6,7 @@
 type DomComponentRenderer = (element, ctx) => HTMLElement | Text | null;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:356](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L356)
+Defined in: `.pnpm`
 
 ## Parameters
 

package/api/@xmachines/play-dom/type-aliases/DomRegistry.md

@@ -6,4 +6,4 @@
 type DomRegistry = Record<string, DomComponentRenderer>;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:432](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L432)
+Defined in: `.pnpm`

package/api/@xmachines/play-dom/type-aliases/DomSchema.md

@@ -6,4 +6,4 @@
 type DomSchema = typeof schema;
 ```
 
-Defined in: [packages/play-dom/src/json-render/schema.ts:60](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/schema.ts#L60)
+Defined in: `.pnpm`

package/api/@xmachines/play-dom/type-aliases/MountFn.md

@@ -6,7 +6,7 @@
 type MountFn = (actor, container, options?) => () => void;
 ```
 
-Defined in: [packages/play-dom/src/create-play-ui.ts:69](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/create-play-ui.ts#L69)
+Defined in: [packages/play-dom/src/create-play-ui.ts:69](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.56/packages/play-dom/src/create-play-ui.ts#L69)
 
 The mount function returned by `createPlayUI`.
 

package/api/@xmachines/play-dom/type-aliases/SetState.md

@@ -6,12 +6,12 @@
 type SetState = (updater) => void;
 ```
 
-Defined in: [packages/play-dom/src/json-render/types.ts:49](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/types.ts#L49)
+Defined in: `.pnpm`
 
 Function to update the local state store.
 
-Mirrors `SetState` from @json-render/react, /solid, /vue, /svelte.
-In the DOM renderer, this writes through to the @xstate/store-backed StateStore.
+Mirrors `SetState` from @xmachines/json-render-react, /solid, /vue, /svelte.
+In the DOM renderer, this writes through to the backing `StateStore`.
 
 ## Parameters
 

package/api/@xmachines/play-dom/variables/schema.md

@@ -3,52 +3,58 @@
 # Variable: schema
 
 ```ts
-const schema: Schema<{
-	catalog: SchemaType<
+const schema: _json_render_core.Schema<{
+	catalog: _json_render_core.SchemaType<
 		"object",
 		{
-			actions: SchemaType<
+			actions: _json_render_core.SchemaType<
 				"map",
 				{
-					description: SchemaType<"string", unknown>;
-					params: SchemaType<"zod", unknown>;
+					description: _json_render_core.SchemaType<"string", unknown>;
+					params: _json_render_core.SchemaType<"zod", unknown>;
 				}
 			>;
-			components: SchemaType<
+			components: _json_render_core.SchemaType<
 				"map",
 				{
-					description: SchemaType<"string", unknown>;
-					example: SchemaType<"any", unknown>;
-					props: SchemaType<"zod", unknown>;
-					slots: SchemaType<"array", SchemaType<"string", unknown>>;
+					description: _json_render_core.SchemaType<"string", unknown>;
+					example: _json_render_core.SchemaType<"any", unknown>;
+					props: _json_render_core.SchemaType<"zod", unknown>;
+					slots: _json_render_core.SchemaType<
+						"array",
+						_json_render_core.SchemaType<"string", unknown>
+					>;
 				}
 			>;
 		}
 	>;
-	spec: SchemaType<
+	spec: _json_render_core.SchemaType<
 		"object",
 		{
-			elements: SchemaType<
+			elements: _json_render_core.SchemaType<
 				"record",
-				SchemaType<
+				_json_render_core.SchemaType<
 					"object",
 					{
-						children: SchemaType<"array", SchemaType<"string", unknown>>;
-						props: SchemaType<"propsOf", string>;
-						type: SchemaType<"ref", string>;
-						visible: SchemaType<"any", unknown>;
+						children: _json_render_core.SchemaType<
+							"array",
+							_json_render_core.SchemaType<"string", unknown>
+						>;
+						props: _json_render_core.SchemaType<"propsOf", string>;
+						type: _json_render_core.SchemaType<"ref", string>;
+						visible: _json_render_core.SchemaType<"any", unknown>;
 					}
 				>
 			>;
-			root: SchemaType<"string", unknown>;
+			root: _json_render_core.SchemaType<"string", unknown>;
 		}
 	>;
 }>;
 ```
 
-Defined in: [packages/play-dom/src/json-render/schema.ts:20](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom/src/json-render/schema.ts#L20)
+Defined in: `.pnpm`
 
-The schema for @xmachines/play-dom
+The schema for @xmachines/json-render-dom
 
 Defines:
 

package/api/@xmachines/play-dom-router/functions/connectRouter.md

@@ -6,7 +6,7 @@
 function connectRouter(options): () => void;
 ```
 
-Defined in: [play-dom-router/src/connect-router.ts:51](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom-router/src/connect-router.ts#L51)
+Defined in: [play-dom-router/src/connect-router.ts:51](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.56/packages/play-dom-router/src/connect-router.ts#L51)
 
 Connect vanilla router to actor (pure browser integration).
 

package/api/@xmachines/play-dom-router/functions/createBrowserHistory.md

@@ -6,7 +6,7 @@
 function createBrowserHistory(options): BrowserHistory;
 ```
 
-Defined in: [play-dom-router/src/create-browser-history.ts:120](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom-router/src/create-browser-history.ts#L120)
+Defined in: [play-dom-router/src/create-browser-history.ts:120](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.56/packages/play-dom-router/src/create-browser-history.ts#L120)
 
 Create browser history that wraps window.history
 

package/api/@xmachines/play-dom-router/functions/createRouteMap.md

@@ -6,7 +6,7 @@
 function createRouteMap(machine, options?): RouteMap;
 ```
 
-Defined in: [play-router/src/create-route-map.ts:45](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-router/src/create-route-map.ts#L45)
+Defined in: [play-router/src/create-route-map.ts:45](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.56/packages/play-router/src/create-route-map.ts#L45)
 
 Create a `RouteMap` from an XState state machine.
 

package/api/@xmachines/play-dom-router/functions/createRouter.md

@@ -6,7 +6,7 @@
 function createRouter(options): VanillaRouter;
 ```
 
-Defined in: [play-dom-router/src/create-router.ts:52](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.55/packages/play-dom-router/src/create-router.ts#L52)
+Defined in: [play-dom-router/src/create-router.ts:52](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.56/packages/play-dom-router/src/create-router.ts#L52)
 
 Create vanilla router for framework-agnostic routing.