@xmachines/docs 6.1.0 → 8.0.0-next.1

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

@@ -2,14 +2,14 @@
 
 # Interface: CreatePlayUIOptions
 
-Defined in: [packages/play-dom/src/types.ts:152](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-dom/src/types.ts#L152)
+Defined in: [packages/play-dom/src/types.ts:156](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-dom/src/types.ts#L156)
 
 The options of `createPlayUI()`, the complete DOM factory.
 
 This type extends [UIProviderOptions](UIProviderOptions.md), which gives `functions`,
-`directives`, `validationFunctions`, `navigate`, and `onRenderError`. The factory
-holds all of them from the moment of its creation, and it gives them to
-`PlayRenderer` on every `mount()` call.
+`directives`, `validationFunctions`, `navigate`, `onRenderError`, `onConfirm`, and
+`confirmDialog`. The factory holds all of them from the moment of its creation, and
+it gives them to `PlayRenderer` on every `mount()` call.
 
 It also takes [PlayDomOptions.onError](PlayDomOptions.md#property-onerror), which the factory forwards without a
 change: `PlayRenderer` owns it, and it receives every failure of a rebuild that the
@@ -28,13 +28,14 @@ createPlayUI
 
 ## Properties
 
-| Property                                                         | Type                                                                                                      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Inherited from                                                                                                         | 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] });`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | [`UIProviderOptions`](UIProviderOptions.md).[`directives`](UIProviderOptions.md#property-directives)                   | -                                                                                                                                  |
-| <a id="property-fallback"></a> `fallback?`                       | `HTMLElement` \| (() => `HTMLElement`) \| `null`                                                          | The optional fallback content — see [PlayDomOptions.fallback](PlayDomOptions.md#property-fallback) for what the renderer does with it. The factory shows it for every null view, and after a failure of a rebuild that the renderer contains. **Give a FUNCTION when the factory mounts more than one time.** ONE factory serves every `mount()` call, and `appendChild` MOVES a node. A single element therefore passes from one container to the next on every null view, and the container that loses it goes empty without a notice. A function runs one time for each mount, so every renderer owns its own element: `const mount = createPlayUI(registryResult, { 	fallback: () => { 		const element = document.createElement("p"); 		element.textContent = "Loading…"; 		return element; 	}, });` An element stays correct for a factory that mounts one time.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | -                                                                                                                      | [packages/play-dom/src/types.ts:176](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-dom/src/types.ts#L176) |
-| <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`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | [`UIProviderOptions`](UIProviderOptions.md).[`functions`](UIProviderOptions.md#property-functions)                     | -                                                                                                                                  |
-| <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" } } } }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | [`UIProviderOptions`](UIProviderOptions.md).[`navigate`](UIProviderOptions.md#property-navigate)                       | -                                                                                                                                  |
-| <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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | [`UIProviderOptions`](UIProviderOptions.md).[`onConfirm`](UIProviderOptions.md#property-onconfirm)                     | -                                                                                                                                  |
-| <a id="property-onerror"></a> `onError?`                         | (`error`, `reset`) => `void`                                                                              | The optional handler of a failure of a complete rebuild of the view. This option is NOT the same as `onRenderError`, which [UIProviderOptions](UIProviderOptions.md) gives: the inner renderer routes a render error of one component, and a rejection of one action handler, to `onRenderError`. It contains each of them per element, and the rebuild continues. `onError` receives the failure of the complete rebuild that no per-element boundary caught. The renderer CONTAINS a rebuild that throws, with this option and without it: it resets the state of the failed rebuild, so that the next emission makes a complete render again, and it clears the container. `connect()` renders the first view synchronously, and a bad initial view does not make `connect()` throw. A WRITE of the store takes the same path. The renderer resolves the props of every element that the write touched, so a `$computed` function that throws on the new state aborts that render too. The renderer contains such a failure as well, and the action handler that wrote the state receives no exception. This option says WHERE the report goes. Without it, the renderer writes the contained failure to `console.error`. A handler that THROWS reaches no caller: the renderer contains that throw too, and it writes the throw to `console.error`. A host that must escalate a failure raises it from a task of its own — `rethrowLater(error)` of `@xmachines/core/utils` — which reaches the global handler of the page and leaves the containment whole. The host installs `@xmachines/core` itself. The five renderers hold this one rule. The second parameter is the RESET, for a retry that the host starts — a "Retry" button of its own. It renders the view that the actor holds at the MOMENT OF THE CALL, so a host that keeps the callback cannot rewind the screen to the view that failed. A reset that the host calls from inside this handler does nothing, because no input changed between the two attempts, and a reset after `disconnect()` does nothing. A reset belongs to ONE connection. `connect()` starts a connection, and the reset of a report of an older connection does nothing. A host that calls `connect()` again from inside this handler abandons the connection that reported. The "Retry" button of that report must not render into the connection that took its place. Call the reset of the newest report. This option matches the `onError` prop of the framework renderer providers, and the five renderers hold the same three rules for the reset. | [`PlayDomOptions`](PlayDomOptions.md).[`onError`](PlayDomOptions.md#property-onerror)                                  | [packages/play-dom/src/types.ts:100](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-dom/src/types.ts#L100) |
-| <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 }); }, });`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | [`UIProviderOptions`](UIProviderOptions.md).[`onRenderError`](UIProviderOptions.md#property-onrendererror)             | -                                                                                                                                  |
-| <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 };`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | [`UIProviderOptions`](UIProviderOptions.md).[`validationFunctions`](UIProviderOptions.md#property-validationfunctions) | -                                                                                                                                  |
+| Property                                                         | Type                                                                                                      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Inherited from                                                                                                         | Defined in                                                                                                                                     |
+| ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-confirmdialog"></a> `confirmDialog?`             | `boolean`                                                                                                 | `false` turns the default confirm dialog off, for a host whose component shows the pending confirmation through `ctx.confirmation`. Without `onConfirm`, the default (`true`) shows the dialog on `document.body` for each binding with `confirm` that waits.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | [`UIProviderOptions`](UIProviderOptions.md).[`confirmDialog`](UIProviderOptions.md#property-confirmdialog)             | -                                                                                                                                              |
+| <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] });`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | [`UIProviderOptions`](UIProviderOptions.md).[`directives`](UIProviderOptions.md#property-directives)                   | -                                                                                                                                              |
+| <a id="property-fallback"></a> `fallback?`                       | `HTMLElement` \| (() => `HTMLElement`) \| `null`                                                          | The optional fallback content — see [PlayDomOptions.fallback](PlayDomOptions.md#property-fallback) for what the renderer does with it. The factory shows it for every null view, and after a failure of a rebuild that the renderer contains. **Give a FUNCTION when the factory mounts more than one time.** ONE factory serves every `mount()` call, and `appendChild` MOVES a node. A single element therefore passes from one container to the next on every null view, and the container that loses it goes empty without a notice. A function runs one time for each mount, so every renderer owns its own element: `const mount = createPlayUI(registryResult, { 	fallback: () => { 		const element = document.createElement("p"); 		element.textContent = "Loading…"; 		return element; 	}, });` An element stays correct for a factory that mounts one time.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | -                                                                                                                      | [packages/play-dom/src/types.ts:180](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-dom/src/types.ts#L180) |
+| <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`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | [`UIProviderOptions`](UIProviderOptions.md).[`functions`](UIProviderOptions.md#property-functions)                     | -                                                                                                                                              |
+| <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" } } } }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | [`UIProviderOptions`](UIProviderOptions.md).[`navigate`](UIProviderOptions.md#property-navigate)                       | -                                                                                                                                              |
+| <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, the binding waits as the pending confirmation of the tree (`ctx.confirmation`), and the default confirm dialog shows it. See [ConfirmHandler](../type-aliases/ConfirmHandler.md) for the full contract.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | [`UIProviderOptions`](UIProviderOptions.md).[`onConfirm`](UIProviderOptions.md#property-onconfirm)                     | -                                                                                                                                              |
+| <a id="property-onerror"></a> `onError?`                         | (`error`, `reset`) => `void`                                                                              | The optional handler of a failure of the view: a failure of the root, or of a complete rebuild. This option is NOT the same as `onRenderError`, which [UIProviderOptions](UIProviderOptions.md) gives: the inner renderer routes a render error of one component below the root, and a rejection of one action handler, to `onRenderError`. It contains each of them per element, and the rest of the view stays. `onError` receives a failure that leaves no view: the component, a prop, or the `visible` condition of the ROOT throws, or the resolution of the store of the view throws. The inner renderer also gives a failure of the root to `onRenderError`, with `info.kind` `"root"`. The renderer CONTAINS such a failure, with this option and without it: it resets the state of the failed rebuild, so that the next emission makes a complete render again, and it clears the container. `connect()` renders the first view synchronously, and a bad initial view does not make `connect()` throw. A WRITE of the store takes the same path. The inner renderer shows the write at its commit point, a microtask after the write, and it resolves the props of every element that the write touched there. A `$computed` function of the root that throws on the new state fails the root. The renderer contains such a failure as well, and the action handler that wrote the state receives no exception. This option says WHERE the report goes. Without it, the renderer writes the contained failure to `console.error`. A handler that THROWS reaches no caller: the renderer contains that throw too, and it writes the throw to `console.error`. A host that must escalate a failure raises it from a task of its own — `rethrowLater(error)` of `@xmachines/core/utils` — which reaches the global handler of the page and leaves the containment whole. The host installs `@xmachines/core` itself. The five renderers hold this one rule. The second parameter is the RESET, for a retry that the host starts — a "Retry" button of its own. It renders the view that the actor holds at the MOMENT OF THE CALL, so a host that keeps the callback cannot rewind the screen to the view that failed. A reset that the host calls from inside this handler does nothing, because no input changed between the two attempts, and a reset after `disconnect()` does nothing. A reset belongs to ONE connection. `connect()` starts a connection, and the reset of a report of an older connection does nothing. A host that calls `connect()` again from inside this handler abandons the connection that reported. The "Retry" button of that report must not render into the connection that took its place. Call the reset of the newest report. This option matches the `onError` prop of the framework renderer providers, and the five renderers hold the same three rules for the reset. | [`PlayDomOptions`](PlayDomOptions.md).[`onError`](PlayDomOptions.md#property-onerror)                                  | [packages/play-dom/src/types.ts:104](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-dom/src/types.ts#L104) |
+| <a id="property-onrendererror"></a> `onRenderError?`             | [`OnRenderError`](../type-aliases/OnRenderError.md)                                                       | Unified error handler, `(error, name, info)`, for every failure in code that the renderer runs. Each failure reaches it one time: - `info.kind` `"element"` — a component renderer below the root throws, an effect of it throws, or a read of its children after the pass fails - `"props"` / `"visible"` — a prop expression or the `visible` condition of an element throws; the boundary of the parent fails - `"root"` — the root fails (its component, a prop, or its `visible` condition); it has no boundary above it. The renderer shows nothing and throws nothing, also without a handler. A new version of the root renders again - `"action"` / `"watch"` — an `on` chain or a `watch` chain fails `name` is the element type (for `props` and `visible`, the type of the boundary that fails), or the action name for `action` and `watch`. `info.key`, `info.type` and `info.action` name the element and the action. A handler with two parameters still works. When provided, suppresses the `console.error` fallback for each of them. Without it, the renderer reads the handler that `defineRegistry(catalog, { onRenderError })` put on the registry, and then writes one `[json-render]` console line. A handler that throws gives its error to `reportError` one time, and no other element fails. 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, info) => { myErrorReporter.capture(err, { context: name, ...info }); }, });`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | [`UIProviderOptions`](UIProviderOptions.md).[`onRenderError`](UIProviderOptions.md#property-onrendererror)             | -                                                                                                                                              |
+| <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 };`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | [`UIProviderOptions`](UIProviderOptions.md).[`validationFunctions`](UIProviderOptions.md#property-validationfunctions) | -                                                                                                                                              |

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

@@ -8,23 +8,29 @@ Low-level render context passed to each `DomComponentRenderer`.
 
 ## Properties
 
-| Property                                                         | Type                                                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Defined in |
-| ---------------------------------------------------------------- | ------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
-| <a id="property-directives"></a> `directives?`                   | `DirectiveRegistry`                                           | Custom directive registry, converted from `UIProviderOptions.directives` (a `DirectiveDefinition[]`) once per render pass and forwarded to `PropResolutionContext.directives`. Components that resolve prop sub-values themselves (via `resolvePropValue` from `@xmachines/json-render-core`) should include this in their resolution context so custom `$`-prefixed dynamic values keep working inside those values. Mirrors the directives context from the framework renderers (`useDirectives` / `DirectivesContextProvider` / `DIRECTIVES_KEY`). | -          |
-| <a id="property-elementbindings"></a> `elementBindings?`         | `Record`\<`string`, `string`\>                                | Pre-computed two-way binding paths for this element's props.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | -          |
-| <a id="property-functions"></a> `functions?`                     | `Record`\<`string`, `ComputedFunction`\>                      | Optional map of named compute functions, forwarded to PropResolutionContext. Enables { $computed: "funcName", args: {...} } prop expressions to resolve. Mirrors the `functions` prop from framework renderer providers.                                                                                                                                                                                                                                                                                                                              | -          |
-| <a id="property-handlers"></a> `handlers`                        | `Record`\<`string`, `ActionHandler`\>                         | Map of json-render catalog action names → async ActionHandler functions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | -          |
-| <a id="property-loading"></a> `loading?`                         | `boolean`                                                     | When true, indicates the spec is still streaming (e.g. from an AI provider). Component implementations can use this to show skeleton/loading states. When loading=true, missing-child warnings are suppressed. Mirrors the `loading` prop from framework renderer providers.                                                                                                                                                                                                                                                                          | -          |
-| <a id="property-navigate"></a> `navigate?`                       | (`path`) => `void`                                            | Navigation function forwarded from `UIProviderOptions`. Called when an action binding has `onSuccess: { navigate: "/path" }`. Mirrors the `navigate` prop in `ActionProvider` from framework renderers.                                                                                                                                                                                                                                                                                                                                               | -          |
-| <a id="property-onconfirm"></a> `onConfirm?`                     | [`ConfirmHandler`](../type-aliases/ConfirmHandler.md)         | Confirmation hook forwarded from `UIProviderOptions.onConfirm`. Consulted by `emit()` before executing an action binding that declares `confirm`. When absent, confirm-gated actions are skipped with a `console.warn` instead of executing unconfirmed.                                                                                                                                                                                                                                                                                              | -          |
-| <a id="property-onrendererror"></a> `onRenderError?`             | [`RenderErrorHandler`](../type-aliases/RenderErrorHandler.md) | Error handler forwarded from `UIProviderOptions.onRenderError`. Matches `RenderErrorHandler = (error: unknown, name: string) => void`. Called by `emit()` when an action handler rejects, with `(error, actionName)`. Also called by `renderSpec` when a component renderer throws, with `(error, elementType)`. When absent, both fall back to `console.error`. Component implementations may call this directly via `ctx.ctx.onRenderError` to surface errors through the application's central error channel.                                      | -          |
-| <a id="property-renderchildren"></a> `renderChildren`            | (`keys`) => `Node`[]                                          | Render a list of child element keys into DOM nodes. In the incremental renderer, a node can be the node of an earlier render: a child whose subtree did not change keeps it. This occurs in a `setSpec` pass, and when the array of a `repeat` grows or shrinks. Do not add a listener or a child node to a returned node, because a kept node then receives it again. Put such decoration on a wrapper node.                                                                                                                                         | -          |
-| <a id="property-renderslot"></a> `renderSlot`                    | (`slotName`) => `Node`[]                                      | Render the children the element placed in a named slot (`element.slots`). Returns `[]` for a slot the element does not fill. Slot children render with the enclosing repeat scope, not once per item of this element's own `repeat`. As for [DomRenderContext.renderChildren](#property-renderchildren), a returned node can be the node of an earlier render.                                                                                                                                                                                        | -          |
-| <a id="property-repeatbasepath"></a> `repeatBasePath?`           | `string`                                                      | Absolute JSON Pointer path to the current repeat item (e.g. "/todos/0"). Mirrors `repeatBasePath` in `PropResolutionContext`.                                                                                                                                                                                                                                                                                                                                                                                                                         | -          |
-| <a id="property-repeatindex"></a> `repeatIndex?`                 | `number`                                                      | Current repeat array index when inside a repeat scope. Mirrors `repeatIndex` in `PropResolutionContext`.                                                                                                                                                                                                                                                                                                                                                                                                                                              | -          |
-| <a id="property-repeatitem"></a> `repeatItem?`                   | `unknown`                                                     | Current repeat item when inside a repeat scope. Mirrors `repeatItem` in `@xmachines/json-render-core`'s `PropResolutionContext`.                                                                                                                                                                                                                                                                                                                                                                                                                      | -          |
-| <a id="property-send"></a> `send`                                | (`event`) => `void`                                           | Dispatch an event (e.g. to an XState actor).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | -          |
-| <a id="property-spec"></a> `spec`                                | `Spec`                                                        | Full spec tree for this render pass.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | -          |
-| <a id="property-store"></a> `store`                              | `StateStore`                                                  | Live state store bound to `spec.state`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | -          |
-| <a id="property-validation"></a> `validation`                    | [`ValidationRegistry`](ValidationRegistry.md)                 | Field-validation registry for this tree. Components register their field's `ValidationConfig` here during render (`registerField`) and validate on change/blur (`validate`); the `validateForm` built-in validates every registered field. Mirrors the framework renderers' ValidationProvider.                                                                                                                                                                                                                                                       | -          |
-| <a id="property-validationfunctions"></a> `validationFunctions?` | `Record`\<`string`, (`value`, `args?`) => `boolean`\>         | Custom validation functions available to `runValidation` / `runValidationCheck`. Each function receives `(value, args?)` and returns a boolean. Mirrors `customFunctions` in `ValidationProvider` from framework renderers. Components that perform inline validation (e.g. form fields) should read this from `ctx.ctx.validationFunctions` and pass it as `customFunctions` to `runValidationCheck` / `runValidation` from `@xmachines/json-render-core`.                                                                                           | -          |
+| Property                                                         | Modifier   | Type                                                  | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | Defined in |
+| ---------------------------------------------------------------- | ---------- | ----------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| <a id="property-action"></a> `action`                            | `public`   | (`binding`) => `ActionHandle`                         | The action handle of `binding`: the loading state of an action and a way to run it, as `useAction(binding)` of the framework renderers. `execute()` runs the binding as an `on` binding runs, with the repeat scope of the element, and its promise rejects to the caller when the binding fails. `isLoading` is `true` while a handler of the action runs in this tree, from any element. A dom component re-renders for no change of it: it calls `subscribe` and changes its own nodes. A subscription in the render belongs to the instance. **Example** `const Save: ComponentFn<typeof catalog, "Save"> = ({ ctx }) => { const save = ctx.action({ action: "save" }); const button = document.createElement("button"); const show = () => { button.disabled = save.isLoading; button.textContent = save.isLoading ? "Saving…" : "Save"; }; show(); save.subscribe(show); button.addEventListener("click", () => void save.execute()); return button; };`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | -          |
+| <a id="property-bound"></a> `bound`                              | `public`   | \<`T`\>(`prop`) => `BoundProp`\<`T`\>                 | The bound prop helper of `prop`, as `useBoundProp(value, bindingPath)` of the framework renderers. `value` is the resolved value of the prop in this render, `path` is the state path that `$bindState` or `$bindItem` binds to the prop, and `set(value)` writes to that path. `set` does nothing when the prop binds no path. The path is read at each access, so a handler writes to the item of now after a keyed move. **Example** `const Input: ComponentFn<typeof catalog, "Input"> = ({ ctx }) => { const value = ctx.bound<string>("value"); const input = document.createElement("input"); input.value = value.value ?? ""; input.addEventListener("input", () => value.set(input.value)); return input; };`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | -          |
+| <a id="property-confirmation"></a> `confirmation`                | `readonly` | `ConfirmFlow`                                         | The confirm flow of the tree, as `pendingConfirmation`, `confirm` and `cancel` of `useActions()` of the framework renderers. Without an `onConfirm` hook, a binding with `confirm` waits as `pending` until a component calls `confirm()` or `cancel()`, or the user answers the default dialog. `subscribe` tells of each change. A subscription in the render belongs to the instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | -          |
+| <a id="property-directives"></a> `directives?`                   | `public`   | `DirectiveRegistry`                                   | Custom directive registry, converted from `UIProviderOptions.directives` (a `DirectiveDefinition[]`) once per render pass and forwarded to `PropResolutionContext.directives`. Components that resolve prop sub-values themselves (via `resolvePropValue` from `@xmachines/json-render-core`) should include this in their resolution context so custom `$`-prefixed dynamic values keep working inside those values. Mirrors the directives context from the framework renderers (`useDirectives` / `DirectivesContextProvider` / `DIRECTIVES_KEY`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | -          |
+| <a id="property-effect"></a> `effect`                            | `public`   | (`run`) => `void`                                     | Run `run` as an effect of this render, after the commit point of the render. Call it in the render of the component. A dom component has no lifecycle, so an effect runs one time for each render that gives it, while that render is on the screen. An effect does not run when its instance went or failed, or when a later render of the instance replaced its render before the effects ran: for example a touch and then a store write of one handler, which show at one commit point. A component that must run an effect only for a change compares the values in the render with the values of the last effect that ran, gives the effect only for a change, and records the values in the effect. `run` can return a cleanup function. Any other value that `run` returns does nothing. The renderer runs the cleanups of a render before the first effect of a later render of the same instance. When the instance goes or fails, its cleanups run with the effects of the commit that took it out, and `dispose` runs every cleanup. So a timer or a listener that an effect starts lives as long as its instance. A cleanup that throws before an effect takes the element out, as an effect that throws does. A cleanup that throws when the instance goes reaches `onUncaughtError`. A `renderSpec` host gets the cleanups through `onEffectCleanup`, and it calls them when it discards the tree. The renderer runs the effects of a commit after the commit point of that commit, in the order of the tree: a child before its parent, and a sibling before the next one. They run before the checks of the watches of the commit. The end of a pass of the host (see `ValidationRegistry.startPass`) runs the effects of the incremental renderer that wait before it returns, also the effects of a render before the pass. A component of `renderSpec` runs its effects in a microtask, after the host placed the node. In the incremental renderer, an effect that throws takes its element out: the element shows nothing, its fields go, and `onRenderError` gets the error with the type of the element. No later effect of that element runs. In `renderSpec`, the host owns the node, so the renderer only gives the error to `onRenderError`. A chain of 52 nested effects, such as an effect that writes the store at each render of its component, stops in the same way, so a loop does not hang the page. A microtask or a promise that a component queues itself is no effect of the renderer: it runs in its own time, also after the end of a pass of the host. | -          |
+| <a id="property-elementbindings"></a> `elementBindings?`         | `public`   | `Record`\<`string`, `string`\>                        | Pre-computed two-way binding paths for this element's props.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | -          |
+| <a id="property-field"></a> `field`                              | `public`   | (`path`, `config?`) => `FieldHandle`                  | The field helper of `path`, as `useFieldValidation(path, config)` of the framework renderers: `state`, `errors`, `isValid`, `validate`, `touch` and `clear`. With a `config`, the element holds the field: the call registers it through [DomRenderContext.validation](#property-validation). A read of `state`, `errors` or `isValid` in the render makes the element a reader of the field, so it renders again when the state changes. **Example** `const Email: ComponentFn<typeof catalog, "Email"> = ({ bindings, ctx }) => { const field = ctx.field(bindings?.value ?? "", { checks: [{ type: "email", message: "Enter an email" }], }); const input = document.createElement("input"); input.setAttribute("aria-invalid", String(!field.isValid)); input.title = field.errors.join(", "); input.addEventListener("blur", () => void field.validate()); return input; };`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | -          |
+| <a id="property-functions"></a> `functions?`                     | `public`   | `Record`\<`string`, `ComputedFunction`\>              | Optional map of named compute functions, forwarded to PropResolutionContext. Enables { $computed: "funcName", args: {...} } prop expressions to resolve. Mirrors the `functions` prop from framework renderer providers.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | -          |
+| <a id="property-handlers"></a> `handlers`                        | `public`   | `Record`\<`string`, `ActionHandler`\>                 | Map of json-render catalog action names → async ActionHandler functions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | -          |
+| <a id="property-isvisible"></a> `isVisible`                      | `public`   | (`condition`) => `boolean`                            | Evaluate a visibility condition, as `useIsVisible(condition)` of the framework renderers. `undefined` is visible. A call in the render makes the element a reader of each state path that the condition reads, so the element renders again when one of them changes. Inside a repeat, `$item` and `$index` read the repeat scope of the element. A call from a handler reads the state of now and makes the element a reader of nothing. **Example** `const Hint: ComponentFn<typeof catalog, "Hint"> = ({ props, ctx }) => { const node = document.createElement("p"); node.hidden = !ctx.isVisible({ $state: "/showHints" }); node.textContent = props.text; return node; };`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | -          |
+| <a id="property-loading"></a> `loading?`                         | `public`   | `boolean`                                             | When true, indicates the spec is still streaming (e.g. from an AI provider). Component implementations can use this to show skeleton/loading states. When loading=true, missing-child warnings are suppressed. Mirrors the `loading` prop from framework renderer providers.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | -          |
+| <a id="property-navigate"></a> `navigate?`                       | `public`   | (`path`) => `void`                                    | Navigation function forwarded from `UIProviderOptions`. Called when an action binding has `onSuccess: { navigate: "/path" }`. Mirrors the `navigate` prop in `ActionProvider` from framework renderers.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | -          |
+| <a id="property-onconfirm"></a> `onConfirm?`                     | `public`   | [`ConfirmHandler`](../type-aliases/ConfirmHandler.md) | Confirmation hook forwarded from `UIProviderOptions.onConfirm`. Consulted by `emit()` before executing an action binding that declares `confirm`. When absent, the binding waits as the pending confirmation of the tree (see [DomRenderContext.confirmation](#property-confirmation)).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | -          |
+| <a id="property-onrendererror"></a> `onRenderError?`             | `public`   | [`OnRenderError`](../type-aliases/OnRenderError.md)   | Error handler forwarded from `UIProviderOptions.onRenderError`, or the handler of the registry: `(error, name, info)`. Called by `emit()` when an action chain fails, with `(error, actionName, { kind: "action", ... })`, and by the renderer for each other failure that it catches (see `UIProviderOptions.onRenderError`). When absent, each failure gives one `console.error` line. Component implementations may call this directly via `ctx.ctx.onRenderError` to surface errors through the application's central error channel. Give it an `info`, for example `{ kind: "element", type: element.type }`, or call `reportRenderError` of core, which writes the console line when no handler is set.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | -          |
+| <a id="property-renderchildren"></a> `renderChildren`            | `public`   | (`keys`) => `Node`[]                                  | Render a list of child element keys into DOM nodes. In the incremental renderer, a node can be the node of an earlier render: a child whose subtree did not change keeps it. This occurs in a `setSpec` pass, and when the array of a `repeat` grows or shrinks. Do not add a listener or a child node to a returned node, because a kept node then receives it again. Put such decoration on a wrapper node.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | -          |
+| <a id="property-renderslot"></a> `renderSlot`                    | `public`   | (`slotName`) => `Node`[]                              | Render the children the element placed in a named slot (`element.slots`). Returns `[]` for a slot the element does not fill. Slot children render with the enclosing repeat scope, not once per item of this element's own `repeat`. As for [DomRenderContext.renderChildren](#property-renderchildren), a returned node can be the node of an earlier render.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | -          |
+| <a id="property-repeatbasepath"></a> `repeatBasePath?`           | `public`   | `string`                                              | Absolute JSON Pointer path to the current repeat item (e.g. "/todos/0"). Mirrors `repeatBasePath` in `PropResolutionContext`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | -          |
+| <a id="property-repeatindex"></a> `repeatIndex?`                 | `public`   | `number`                                              | Current repeat array index when inside a repeat scope. Mirrors `repeatIndex` in `PropResolutionContext`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | -          |
+| <a id="property-repeatitem"></a> `repeatItem?`                   | `public`   | `unknown`                                             | Current repeat item when inside a repeat scope. Mirrors `repeatItem` in `@xmachines/json-render-core`'s `PropResolutionContext`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | -          |
+| <a id="property-send"></a> `send`                                | `public`   | (`event`) => `void`                                   | Dispatch an event (e.g. to an XState actor).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | -          |
+| <a id="property-spec"></a> `spec`                                | `readonly` | `Spec`                                                | The full spec tree of now. In the pass it is the spec of the pass; a component that reads it later, when it reads its children late, gets the spec that those children render from.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | -          |
+| <a id="property-store"></a> `store`                              | `public`   | `StateStore`                                          | Live state store bound to `spec.state`. `renderSpec` gives the store of the host. The incremental renderer gives a view of that store, and not the store object: a `Proxy` that gives each member of the store, runs a function member with the store as `this`, and tells the renderer the path of each read while the component renders. So `ctx.store` is not the store object of the host, and a compare with that object, or a key of a `WeakMap` on it, finds no match. The context gives no way to reach the store object itself. A component that needs it gets it from the host, for example from the scope in which the host defines the registry. A path that the component reads through the view while it renders is a dependency: a change of the value at that path renders the component again. A subscription through the view while the component renders belongs to the instance, and the renderer stops it when the instance renders again or goes. A subscription in an effect lives until the cleanup of the effect stops it.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | -          |
+| <a id="property-validation"></a> `validation`                    | `public`   | [`ValidationRegistry`](ValidationRegistry.md)         | Field-validation registry for this tree. Components register their field's `ValidationConfig` here during render (`registerField`) and validate on change/blur (`validate`); the `validateForm` built-in validates every registered field. It does the job of the `ValidationProvider` of the framework renderers. The config is a part of the render: a holder renders one time at its mount, and a new config of its own field renders nothing again. When two holders give one path a config in one commit, the call that registered last holds. The state of a field belongs to the element that registers it: another element that takes over the path, or a new config from the only holder, starts the field fresh. A holder, and a component that read `fieldStates`, render again when the state that they read changes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | -          |
+| <a id="property-validationfunctions"></a> `validationFunctions?` | `public`   | `Record`\<`string`, (`value`, `args?`) => `boolean`\> | Custom validation functions available to `runValidation` / `runValidationCheck`. Each function receives `(value, args?)` and returns a boolean. Mirrors `customFunctions` in `ValidationProvider` from framework renderers. Components that perform inline validation (e.g. form fields) should read this from `ctx.ctx.validationFunctions` and pass it as `customFunctions` to `runValidationCheck` / `runValidation` from `@xmachines/json-render-core`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | -          |

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

@@ -2,7 +2,7 @@
 
 # Interface: MountOptions
 
-Defined in: [packages/play-dom/src/create-play-ui.ts:49](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-dom/src/create-play-ui.ts#L49)
+Defined in: [packages/play-dom/src/create-play-ui.ts:49](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-dom/src/create-play-ui.ts#L49)
 
 The mount options of the `MountFn` that `createPlayUI` returns.
 
@@ -13,7 +13,7 @@ time.
 
 ## Properties
 
-| Property                                 | Type         | Description                                                                                                                                                                              | Defined in                                                                                                                                         |
-| ---------------------------------------- | ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-loading"></a> `loading?` | `boolean`    | With the value `true`, the renderer stops each warning about an absent child during the ingestion of a streaming spec. It also gives `ctx.ctx.loading` to each component implementation. | [packages/play-dom/src/create-play-ui.ts:61](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-dom/src/create-play-ui.ts#L61) |
-| <a id="property-store"></a> `store?`     | `StateStore` | The optional external `StateStore`, which is the controlled mode. Without it, the renderer makes a new `@xstate/store` atom for each view transition, with the values of `spec.state`.   | [packages/play-dom/src/create-play-ui.ts:55](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-dom/src/create-play-ui.ts#L55) |
+| Property                                 | Type         | Description                                                                                                                                                                              | Defined in                                                                                                                                                     |
+| ---------------------------------------- | ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-loading"></a> `loading?` | `boolean`    | With the value `true`, the renderer stops each warning about an absent child during the ingestion of a streaming spec. It also gives `ctx.ctx.loading` to each component implementation. | [packages/play-dom/src/create-play-ui.ts:61](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-dom/src/create-play-ui.ts#L61) |
+| <a id="property-store"></a> `store?`     | `StateStore` | The optional external `StateStore`, which is the controlled mode. Without it, the renderer makes a new `@xstate/store` atom for each view transition, with the values of `spec.state`.   | [packages/play-dom/src/create-play-ui.ts:55](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-dom/src/create-play-ui.ts#L55) |

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

@@ -0,0 +1,14 @@
+[API](../../../README.md) / [@xmachines/play-dom](../README.md) / PassOptions
+
+# Interface: PassOptions
+
+Defined in: `@xmachines/json-render-dom`
+
+The options of [ValidationRegistry.startPass](ValidationRegistry.md#property-startpass).
+
+## Properties
+
+| Property                             | Type                      | Description                                                                                                                                                                                                                                                                                                                           | Defined in |
+| ------------------------------------ | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| <a id="property-batch"></a> `batch?` | `"microtask"` \| `"task"` | How long the pass holds the join open when it ends. `"microtask"`, the default, is the rule of a write of the store: react commits such a write in a microtask, so a pass after an `await` is a new one. `"task"` is the rule of a new spec from the host: react batches such renders to the end of the task, also across an `await`. | -          |
+| <a id="property-join"></a> `join?`   | `boolean`                 | `false` starts a new pass, also where the pass could join.                                                                                                                                                                                                                                                                            | -          |