@xmachines/docs 6.1.0 → 7.1.0

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

@@ -0,0 +1,16 @@
+[API](../../../README.md) / [@xmachines/play-dom](../README.md) / RenderErrorInfo
+
+# Interface: RenderErrorInfo
+
+Defined in: `@xmachines/json-render-core`
+
+What a renderer tells the handler about a failure.
+
+## Properties
+
+| Property                               | Type                                                    | Description                                                                                       | Defined in |
+| -------------------------------------- | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | ---------- |
+| <a id="property-action"></a> `action?` | `string`                                                | The action name, for `action` and `watch`.                                                        | -          |
+| <a id="property-key"></a> `key?`       | `string`                                                | The key of the element whose code failed. For `props` and `visible`, the child, not the boundary. | -          |
+| <a id="property-kind"></a> `kind`      | [`RenderErrorKind`](../type-aliases/RenderErrorKind.md) | The place where the failure occurred.                                                             | -          |
+| <a id="property-type"></a> `type?`     | `string`                                                | The component type of that element.                                                               | -          |

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

@@ -11,18 +11,20 @@ empty map, so `renderSpec(spec, store, registry)` renders a static tree.
 
 ## Properties
 
-| Property                                                         | Type                                                                                                      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Defined in |
-| ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
-| <a id="property-directives"></a> `directives?`                   | `DirectiveDefinition`\<`ZodType`\<`unknown`, `unknown`, `$ZodTypeInternals`\<`unknown`, `unknown`\>\>\>[] | Custom directives — user-defined `$`-prefixed dynamic values that extend the spec expression language. Converted to a `DirectiveRegistry` once per `renderSpec` call and forwarded to `PropResolutionContext.directives`, matching the framework renderers' `directives` prop (@json-render 0.19). Built-in expressions always take precedence over custom directives.                                                                                                                                                                                                                                                | -          |
-| <a id="property-fallback"></a> `fallback?`                       | [`DomComponentRenderer`](../type-aliases/DomComponentRenderer.md)                                         | Renderer called when `registry` has no entry for an element's `type` (GAP-04). If absent, unknown types render as `null`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | -          |
-| <a id="property-functions"></a> `functions?`                     | `Record`\<`string`, `ComputedFunction`\>                                                                  | Map of named compute functions forwarded to `PropResolutionContext` (GAP-03). Enables `{ $computed: "fn", args }` prop expressions to resolve. When absent, `$computed` expressions return `undefined` (no throw).                                                                                                                                                                                                                                                                                                                                                                                                    | -          |
-| <a id="property-handlers"></a> `handlers?`                       | `Record`\<`string`, `ActionHandler`\>                                                                     | Map of catalog action names → async `ActionHandler` functions, consumed by `defineRegistry`'s `emit()`/`watch` dispatch. Defaults to `{}`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | -          |
-| <a id="property-loading"></a> `loading?`                         | `boolean`                                                                                                 | Flag indicating the spec is still streaming (GAP-06). When `true`, components can read `ctx.loading` to render skeleton states, and missing-child warnings (GAP-07) are suppressed since referenced elements may not yet have arrived in the incremental spec.                                                                                                                                                                                                                                                                                                                                                        | -          |
-| <a id="property-navigate"></a> `navigate?`                       | (`path`) => `void`                                                                                        | Navigation callback forwarded to `DomRenderContext.navigate`. Invoked automatically by `defineRegistry`'s `emit()` when an action binding resolves with `onSuccess: { navigate: "/path" }`. Also readable by component implementations via `ctx.navigate`.                                                                                                                                                                                                                                                                                                                                                            | -          |
-| <a id="property-onconfirm"></a> `onConfirm?`                     | [`ConfirmHandler`](../type-aliases/ConfirmHandler.md)                                                     | Confirmation hook forwarded to `DomRenderContext.onConfirm`. Consulted by `defineRegistry`'s `emit()` before executing an action binding that declares `confirm`. Without it, confirm-gated actions are skipped with a `console.warn` (never executed unconfirmed).                                                                                                                                                                                                                                                                                                                                                   | -          |
-| <a id="property-onrendererror"></a> `onRenderError?`             | [`RenderErrorHandler`](../type-aliases/RenderErrorHandler.md)                                             | Callback matching `RenderErrorHandler = (error, name)`. Invoked for three distinct error classes: - `(error, elementType)` when a component renderer throws (GAP-08) - `(error, actionName)` when an action handler rejects during `emit()` - `(error, actionName)` when an action handler rejects in a `watch` binding If absent, all three fall back to `console.error`. Forwarded into `DomRenderContext.onRenderError` so `emit()` and `watch` handlers route errors through the same channel as component render errors.                                                                                         | -          |
-| <a id="property-onvalidationsetup"></a> `onValidationSetup?`     | (`cleanup`) => `void`                                                                                     | Called with an unregister callback for every field an element registers through `ctx.validation.registerField`, so a host can release the registrations of an element instance when it unmounts. Mirrors `onWatchSetup`.                                                                                                                                                                                                                                                                                                                                                                                              | -          |
-| <a id="property-onwatchsetup"></a> `onWatchSetup?`               | (`cleanup`) => `void` \| (() => `void`)                                                                   | Callback invoked with each watch subscription cleanup function (GAP-02). When an element declares `watch`, the renderer sets up a store subscription and passes its unsubscribe function to this callback. Host renderers collect these to call on teardown. When absent, `watch` bindings are not wired. May return a replacement cleanup: when the caller wraps the supplied cleanup (e.g. to drop it from its own collection when invoked), the incremental renderer registers the returned wrapper so an unmount-driven release also runs the caller's bookkeeping. Returning nothing keeps the supplied cleanup. | -          |
-| <a id="property-send"></a> `send?`                               | (`event`) => `void`                                                                                       | Dispatcher for interaction events (e.g. `actor.send`), exposed to component implementations via `ctx.send`. Defaults to a no-op.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | -          |
-| <a id="property-validation"></a> `validation?`                   | [`ValidationRegistry`](ValidationRegistry.md)                                                             | Field-validation registry shared by the whole tree, exposed to components as `ctx.validation` and used by the `validateForm` built-in. One is created per `renderSpec` call when omitted; a host that re-renders (e.g. the incremental renderer) must create one for its lifetime and pass it on every pass so registrations survive.                                                                                                                                                                                                                                                                                 | -          |
-| <a id="property-validationfunctions"></a> `validationFunctions?` | `Record`\<`string`, (`value`, `args?`) => `boolean`\>                                                     | Custom validation functions forwarded to `DomRenderContext.validationFunctions`. Components pass these as `customFunctions` to `runValidationCheck` / `runValidation` from `@xmachines/json-render-core`. Has no effect on prop resolution.                                                                                                                                                                                                                                                                                                                                                                           | -          |
+| Property                                                         | Type                                                                                                      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 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`. The default, `true`, shows the dialog on `document.body` for each binding with `confirm` that waits, when the host gives no `onConfirm`, as `JSONUIProvider` of the framework renderers shows `ConfirmDialog`. The renderers that share one validation registry share the setting: the last pass sets it.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | -          |
+| <a id="property-directives"></a> `directives?`                   | `DirectiveDefinition`\<`ZodType`\<`unknown`, `unknown`, `$ZodTypeInternals`\<`unknown`, `unknown`\>\>\>[] | Custom directives — user-defined `$`-prefixed dynamic values that extend the spec expression language. Converted to a `DirectiveRegistry` once per `renderSpec` call and forwarded to `PropResolutionContext.directives`, matching the framework renderers' `directives` prop (@json-render 0.19). Built-in expressions always take precedence over custom directives.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | -          |
+| <a id="property-fallback"></a> `fallback?`                       | [`DomComponentRenderer`](../type-aliases/DomComponentRenderer.md)                                         | Renderer called when `registry` has no entry for an element's `type` (GAP-04). If absent, unknown types render as `null`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | -          |
+| <a id="property-functions"></a> `functions?`                     | `Record`\<`string`, `ComputedFunction`\>                                                                  | Map of named compute functions forwarded to `PropResolutionContext` (GAP-03). Enables `{ $computed: "fn", args }` prop expressions to resolve. When absent, `$computed` expressions return `undefined` (no throw).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | -          |
+| <a id="property-handlers"></a> `handlers?`                       | `Record`\<`string`, `ActionHandler`\>                                                                     | Map of catalog action names → async `ActionHandler` functions, consumed by `defineRegistry`'s `emit()`/`watch` dispatch. Defaults to `{}`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | -          |
+| <a id="property-loading"></a> `loading?`                         | `boolean`                                                                                                 | Flag indicating the spec is still streaming (GAP-06). When `true`, components can read `ctx.loading` to render skeleton states, and missing-child warnings (GAP-07) are suppressed since referenced elements may not yet have arrived in the incremental spec.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | -          |
+| <a id="property-navigate"></a> `navigate?`                       | (`path`) => `void`                                                                                        | Navigation callback forwarded to `DomRenderContext.navigate`. Invoked automatically by `defineRegistry`'s `emit()` when an action binding resolves with `onSuccess: { navigate: "/path" }`. Also readable by component implementations via `ctx.navigate`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | -          |
+| <a id="property-onconfirm"></a> `onConfirm?`                     | [`ConfirmHandler`](../type-aliases/ConfirmHandler.md)                                                     | Confirmation hook forwarded to `DomRenderContext.onConfirm`. Consulted by `defineRegistry`'s `emit()` before executing an action binding that declares `confirm`. Without it, the binding waits as the pending confirmation of the tree (`ctx.confirmation`), and the default confirm dialog shows it (see `confirmDialog`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | -          |
+| <a id="property-oneffectcleanup"></a> `onEffectCleanup?`         | (`cleanup`) => `void`                                                                                     | Called with each cleanup that an effect of a component returns (see `DomRenderContext.effect`). `renderSpec` keeps no instance from one call to the next, so the host calls each cleanup when it discards the tree. When absent, the renderer drops the cleanups. The incremental renderer runs the cleanups itself, and it ignores this option.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | -          |
+| <a id="property-onrendererror"></a> `onRenderError?`             | [`OnRenderError`](../type-aliases/OnRenderError.md)                                                       | The error handler, `(error, name, info)`. Each failure in code that the renderer runs reaches it one time. `info.kind` names the place: - `element`, with `name` the type of the element: a component renderer below the root throws (GAP-08), an effect of it throws, or a read of its children after the pass fails. The element shows nothing. - `props` and `visible`, with `name` the type of the PARENT: a prop expression or the `visible` condition of an element below the root throws. The boundary of the parent catches it, as in the framework renderers, and the parent shows nothing. `info.key` and `info.type` name the element whose expression threw. - `root`: the root fails, and it has no boundary above it: its component throws, a prop of it fails to resolve, or its `visible` condition throws. The renderer shows nothing and throws nothing, also without a handler, so a root that a stream gives half does not stop the host. A new version of the root renders again. - `action` and `watch`, with `name` the action name: an `on` chain or a `watch` chain fails. A handler that throws gives its error to `reportError` one time, and no other element fails. If absent, the renderer reads the handler of the registry, which `defineRegistry(catalog, { onRenderError })` sets. Without either, each failure gives one `console.error` line of the form `[json-render] <kind> error in <Type> "<key>":`. Forwarded into `DomRenderContext.onRenderError` so `emit()` and `watch` handlers route errors through the same channel as component render errors. | -          |
+| <a id="property-onvalidationsetup"></a> `onValidationSetup?`     | (`cleanup`) => `void`                                                                                     | Called with an unregister callback for every field an element registers through `ctx.validation.registerField`, so a host can release the registrations of an element instance when it unmounts. Mirrors `onWatchSetup`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | -          |
+| <a id="property-onwatchsetup"></a> `onWatchSetup?`               | (`cleanup`, `end`, `baseline`) => `void` \| (() => `void`)                                                | Callback invoked with each watch subscription cleanup function (GAP-02). When an element declares `watch`, the renderer sets up a store subscription and passes its unsubscribe function to this callback. Host renderers collect these to call on teardown. When absent, `watch` bindings are not wired. May return a replacement cleanup: when the caller wraps the supplied cleanup (e.g. to drop it from its own collection when invoked), the incremental renderer registers the returned wrapper so an unmount-driven release also runs the caller's bookkeeping. Returning nothing keeps the supplied cleanup. The cleanup stops the subscription, and the bindings that a change still runs go on. A host that renders the tree again on each change must do so after the store notification, for example in a microtask: each watch then hears the change before the host releases it. `end` stops the chain before its next binding, and a change that waits for its run. Call it when the element goes for good. The incremental renderer calls it for a removed element, for an element whose watched paths or item path a new render changes, after a pass that throws, and on `dispose`. `baseline` reads and sets the watched values that the next change compares against. The incremental renderer gives the values of an earlier subscription of the element to its new one, so a write that came before a new spec still fires, as the effect of react compares against the values of its last run.                                                                           | -          |
+| <a id="property-send"></a> `send?`                               | (`event`) => `void`                                                                                       | Dispatcher for interaction events (e.g. `actor.send`), exposed to component implementations via `ctx.send`. Defaults to a no-op.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | -          |
+| <a id="property-validation"></a> `validation?`                   | [`ValidationRegistry`](ValidationRegistry.md)                                                             | Field-validation registry shared by the whole tree, exposed to components as `ctx.validation` and used by the `validateForm` built-in. One is created per `renderSpec` call when omitted; a host that re-renders (e.g. the incremental renderer) must create one for its lifetime and pass it on every pass so registrations survive.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | -          |
+| <a id="property-validationfunctions"></a> `validationFunctions?` | `Record`\<`string`, (`value`, `args?`) => `boolean`\>                                                     | Custom validation functions forwarded to `DomRenderContext.validationFunctions`. Components pass these as `customFunctions` to `runValidationCheck` / `runValidation` from `@xmachines/json-render-core`. Has no effect on prop resolution.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | -          |

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

@@ -22,11 +22,12 @@ and are available to component implementations via `ctx.ctx.*`.
 
 ## Properties
 
-| Property                                                         | Type                                                                                                      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Defined in |
-| ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
-| <a id="property-directives"></a> `directives?`                   | `DirectiveDefinition`\<`ZodType`\<`unknown`, `unknown`, `$ZodTypeInternals`\<`unknown`, `unknown`\>\>\>[] | Custom directives — user-defined `$`-prefixed dynamic values that extend the spec expression language (e.g. `{ $format: "currency", value: ... }`). Each entry is a `DirectiveDefinition` built with `defineDirective` from `@xmachines/json-render-core`. The array is converted to a `DirectiveRegistry` once per render pass and forwarded to `resolveElementProps` via `PropResolutionContext.directives`. Built-in expressions (`$state`, `$cond`, etc.) always take precedence over custom directives. Mirrors the `directives` prop on `JSONUIProvider` / `JsonUIProvider` introduced in **Json-render** 0.19. **Example** `import { defineDirective, resolvePropValue } from "@xmachines/json-render-core"; import { z } from "zod"; const formatDirective = defineDirective({ name: "$format", description: "Locale-aware number formatting.", schema: z.object({ $format: z.enum(["number", "currency"]), value: z.unknown() }), resolve(value, ctx) { const resolved = resolvePropValue(value.value, ctx); return new Intl.NumberFormat().format(resolved as number); }, }); renderSpec(spec, store, registry, { directives: [formatDirective] });`                     | -          |
-| <a id="property-functions"></a> `functions?`                     | `Record`\<`string`, `ComputedFunction`\>                                                                  | Named compute functions for `{ $computed: "name", args: {...} }` prop expressions. Each function receives the resolved `args` object and returns the computed value. Forwarded directly to `resolveElementProps` via `PropResolutionContext.functions`, matching the `FunctionsContext` provider in the framework renderers. Without this option, `$computed` expressions resolve to `undefined` (no throw). **Example** `renderSpec(spec, store, registry, { functions: { fullName: (args) => `${args.first} ${args.last}`, formatCurrency: (args) => new Intl.NumberFormat().format(args.amount as number), }, });` Mirrors the `functions` prop on `JSONUIProvider` / `JsonUIProvider`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | -          |
-| <a id="property-navigate"></a> `navigate?`                       | (`path`) => `void`                                                                                        | Programmatic navigation function. Called automatically when an action binding resolves with `onSuccess: { navigate: "/path" }`. The resolved path string is passed as the sole argument. Mirrors the `navigate` prop in `ActionProvider` from the framework renderers, where it is captured in the `execute()` closure. Also available to component implementations directly via `ctx.ctx.navigate` for cases where navigation needs to be triggered outside of an action binding. **Example** `import { useNavigate } from "my-router"; const navigate = useNavigate(); renderSpec(spec, store, registry, { navigate });` Spec binding that triggers navigation: `{ "on": { "click": { "action": "doSomething", "onSuccess": { "navigate": "/dashboard" } } } }`                                                                                                                                                                                                                                                                                                                                                                                                                  | -          |
-| <a id="property-onconfirm"></a> `onConfirm?`                     | [`ConfirmHandler`](../type-aliases/ConfirmHandler.md)                                                     | Confirmation hook for actions that declare `confirm` in their binding. Consulted by `emit()` before executing a confirm-gated action. Return (or resolve) `true` to execute, `false` to skip. Without this handler, confirm-gated actions are skipped with a `console.warn` — they never execute unconfirmed. See [ConfirmHandler](../type-aliases/ConfirmHandler.md) for the full contract. This is the headless equivalent of the `pendingConfirmation` / `confirmAction()` / `cancelAction()` flow in the framework adapters.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | -          |
-| <a id="property-onrendererror"></a> `onRenderError?`             | [`RenderErrorHandler`](../type-aliases/RenderErrorHandler.md)                                             | Unified error handler for component render errors and action handler rejections. Matches `RenderErrorHandler = (error: unknown, name: string) => void`. Invoked for three distinct error classes: - `(error, elementType)` — when a component renderer throws synchronously during `renderSpec` - `(error, actionName)` — when an action handler rejects during `emit()` (on-event path) - `(error, actionName)` — when an action handler rejects during a `watch` binding callback When provided, suppresses the `console.error` fallback for all three error types. Forwarded into `renderSpec` as the `onRenderError` parameter and into `DomRenderContext.onRenderError` so both `emit()` and `watch` handlers route their errors through the same channel as component render errors. **Example** `renderSpec(spec, store, registry, { onRenderError: (err, name) => { myErrorReporter.capture(err, { context: name }); }, });`                                                                                                                                                                                                                                               | -          |
-| <a id="property-validationfunctions"></a> `validationFunctions?` | `Record`\<`string`, (`value`, `args?`) => `boolean`\>                                                     | Custom validation functions for inline field validation. Each function receives `(value, args?)` and returns `true` (valid) or `false` (invalid). Functions are available to component implementations via `ctx.ctx.validationFunctions` and should be passed as `customFunctions` to `runValidationCheck` / `runValidation` from `@xmachines/json-render-core`. Mirrors `customFunctions` in `ValidationProvider` from the framework renderers. The DOM renderer has no automatic `ValidationProvider` tree — validation must be invoked explicitly by component implementations. **Example** `import { runValidationCheck } from "@xmachines/json-render-core"; renderSpec(spec, store, registry, { validationFunctions: { isEven: (value) => typeof value === "number" && value % 2 === 0, phoneNumber: (value) => /^\+?[\d\s\-()]{7,}$/.test(String(value)), }, }); // Inside a ComponentFn: const MyField: ComponentFn<typeof catalog, "MyField"> = ({ ctx }) => { const result = runValidationCheck( { type: "isEven", message: "must be even" }, { value: someValue, stateModel: {}, customFunctions: ctx.ctx.validationFunctions }, ); // result.valid, result.message };` | -          |
+| Property                                                         | Type                                                                                                      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | -          |
+| <a id="property-directives"></a> `directives?`                   | `DirectiveDefinition`\<`ZodType`\<`unknown`, `unknown`, `$ZodTypeInternals`\<`unknown`, `unknown`\>\>\>[] | Custom directives — user-defined `$`-prefixed dynamic values that extend the spec expression language (e.g. `{ $format: "currency", value: ... }`). Each entry is a `DirectiveDefinition` built with `defineDirective` from `@xmachines/json-render-core`. The array is converted to a `DirectiveRegistry` once per render pass and forwarded to `resolveElementProps` via `PropResolutionContext.directives`. Built-in expressions (`$state`, `$cond`, etc.) always take precedence over custom directives. Mirrors the `directives` prop on `JSONUIProvider` / `JsonUIProvider` introduced in **Json-render** 0.19. **Example** `import { defineDirective, resolvePropValue } from "@xmachines/json-render-core"; import { z } from "zod"; const formatDirective = defineDirective({ name: "$format", description: "Locale-aware number formatting.", schema: z.object({ $format: z.enum(["number", "currency"]), value: z.unknown() }), resolve(value, ctx) { const resolved = resolvePropValue(value.value, ctx); return new Intl.NumberFormat().format(resolved as number); }, }); renderSpec(spec, store, registry, { directives: [formatDirective] });`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | -          |
+| <a id="property-functions"></a> `functions?`                     | `Record`\<`string`, `ComputedFunction`\>                                                                  | Named compute functions for `{ $computed: "name", args: {...} }` prop expressions. Each function receives the resolved `args` object and returns the computed value. Forwarded directly to `resolveElementProps` via `PropResolutionContext.functions`, matching the `FunctionsContext` provider in the framework renderers. Without this option, `$computed` expressions resolve to `undefined` (no throw). **Example** `renderSpec(spec, store, registry, { functions: { fullName: (args) => `${args.first} ${args.last}`, formatCurrency: (args) => new Intl.NumberFormat().format(args.amount as number), }, });` Mirrors the `functions` prop on `JSONUIProvider` / `JsonUIProvider`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | -          |
+| <a id="property-navigate"></a> `navigate?`                       | (`path`) => `void`                                                                                        | Programmatic navigation function. Called automatically when an action binding resolves with `onSuccess: { navigate: "/path" }`. The resolved path string is passed as the sole argument. Mirrors the `navigate` prop in `ActionProvider` from the framework renderers, where it is captured in the `execute()` closure. Also available to component implementations directly via `ctx.ctx.navigate` for cases where navigation needs to be triggered outside of an action binding. **Example** `import { useNavigate } from "my-router"; const navigate = useNavigate(); renderSpec(spec, store, registry, { navigate });` Spec binding that triggers navigation: `{ "on": { "click": { "action": "doSomething", "onSuccess": { "navigate": "/dashboard" } } } }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | -          |
+| <a id="property-onconfirm"></a> `onConfirm?`                     | [`ConfirmHandler`](../type-aliases/ConfirmHandler.md)                                                     | Confirmation hook for actions that declare `confirm` in their binding. Consulted by `emit()` before executing a confirm-gated action. Return (or resolve) `true` to execute, `false` to skip. Without this handler, 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | -          |
+| <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 }); }, });` | -          |
+| <a id="property-validationfunctions"></a> `validationFunctions?` | `Record`\<`string`, (`value`, `args?`) => `boolean`\>                                                     | Custom validation functions for inline field validation. Each function receives `(value, args?)` and returns `true` (valid) or `false` (invalid). Functions are available to component implementations via `ctx.ctx.validationFunctions` and should be passed as `customFunctions` to `runValidationCheck` / `runValidation` from `@xmachines/json-render-core`. Mirrors `customFunctions` in `ValidationProvider` from the framework renderers. The DOM renderer has no automatic `ValidationProvider` tree — validation must be invoked explicitly by component implementations. **Example** `import { runValidationCheck } from "@xmachines/json-render-core"; renderSpec(spec, store, registry, { validationFunctions: { isEven: (value) => typeof value === "number" && value % 2 === 0, phoneNumber: (value) => /^\+?[\d\s\-()]{7,}$/.test(String(value)), }, }); // Inside a ComponentFn: const MyField: ComponentFn<typeof catalog, "MyField"> = ({ ctx }) => { const result = runValidationCheck( { type: "isEven", message: "must be even" }, { value: someValue, stateModel: {}, customFunctions: ctx.ctx.validationFunctions }, ); // result.valid, result.message };`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | -          |

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

@@ -8,14 +8,17 @@ Registry of validated fields for one rendered tree.
 
 ## Properties
 
-| Property                                                | Modifier   | Type                                                                    | Description                                                                                                                                                                                                                                                                                                                                                                                                            | Defined in |
-| ------------------------------------------------------- | ---------- | ----------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
-| <a id="property-clear"></a> `clear`                     | `public`   | (`path`) => `void`                                                      | Forget a field's recorded state; the registration itself survives.                                                                                                                                                                                                                                                                                                                                                     | -          |
-| <a id="property-customfunctions"></a> `customFunctions` | `readonly` | `Record`\<`string`, `ValidationFunction`\>                              | Custom validation functions available to every check.                                                                                                                                                                                                                                                                                                                                                                  | -          |
-| <a id="property-fieldstates"></a> `fieldStates`         | `readonly` | `Record`\<`string`, [`FieldValidationState`](FieldValidationState.md)\> | Validation state by field state path.                                                                                                                                                                                                                                                                                                                                                                                  | -          |
-| <a id="property-registerfield"></a> `registerField`     | `public`   | (`path`, `config`) => `void`                                            | Register (or update) a field's validation config. Called by component implementations during render, normally via `ctx.validation`. Registrations are reference-counted per path: two elements bound to the same state path each hold one, so one of them going away does not un-validate the other.                                                                                                                   | -          |
-| <a id="property-releasefield"></a> `releaseField`       | `public`   | (`path`) => `void`                                                      | Drop one reference to a field's registration, keeping its recorded state. The registration itself goes away once the last reference is released. This is what the render context's per-element cleanup calls: an element instance releases its registrations when it unmounts or before it re-renders, and `fieldStates` survives — matching the framework ValidationProvider, whose field states outlive a re-render. | -          |
-| <a id="property-touch"></a> `touch`                     | `public`   | (`path`) => `void`                                                      | Mark a field as interacted with, without validating it.                                                                                                                                                                                                                                                                                                                                                                | -          |
-| <a id="property-unregisterfield"></a> `unregisterField` | `public`   | (`path`) => `void`                                                      | Drop a field's registration entirely, references and recorded state.                                                                                                                                                                                                                                                                                                                                                   | -          |
-| <a id="property-validate"></a> `validate`               | `public`   | (`path`, `config?`) => `ValidationResult`                               | Validate one field against the live store snapshot and record the result. Uses the field's registered config unless one is passed explicitly.                                                                                                                                                                                                                                                                          | -          |
-| <a id="property-validateall"></a> `validateAll`         | `public`   | () => `boolean`                                                         | Validate every registered field. Returns true when all are valid.                                                                                                                                                                                                                                                                                                                                                      | -          |
+| Property                                                | Modifier   | Type                                                               | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Defined in |
+| ------------------------------------------------------- | ---------- | ------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| <a id="property-clear"></a> `clear`                     | `public`   | (`path`) => `void`                                                 | Forget a field's recorded state; the registration itself survives.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | -          |
+| <a id="property-customfunctions"></a> `customFunctions` | `readonly` | `Record`\<`string`, `ValidationFunction`\>                         | Custom validation functions available to every check.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | -          |
+| <a id="property-dropreleased"></a> `dropReleased?`      | `public`   | () => `void`                                                       | End a pass. The registry forgets the state of each field whose last registration went away and that did not register again. It also forgets the state of a field that only new owners hold now: an element that goes and another element that registers the path in the same pass start the field fresh, as in the framework renderers, whatever the order of the two. What a new owner wrote in the pass stays, as if the field started fresh at the change: a `touch` of the new owner gives no result of the old one. A write of the old owner in the pass goes. An owner that registers again in place keeps the state. The fresh start comes when the pass ends. A component of the new element that reads `fieldStates` while it renders in that pass still reads the state of the old element. The incremental renderer then renders it again (see `onFreshPaths`), as React renders it again after the unmount of the old one. A caller that does not mark its passes with `startPass` calls it when a pass ends, for example a host that renders with `renderSpec` alone on a registry of its own. The incremental renderer and a host that uses `startPass` end a pass with the function that `startPass` returns, and not with this. The registry counts the passes by these calls, or by `startPass`: an owner that came to the path in an earlier pass is an owner from before the pass. Without the calls, no owner is from before, and the state of a field stays with its path.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | -          |
+| <a id="property-fieldstates"></a> `fieldStates`         | `readonly` | `Readonly`\<`Record`\<`string`, `ReadonlyFieldValidationState`\>\> | Validation state by field state path. The registry gives the same object until a state changes, as the state of react does. The object and each state in it are shared by every reader, so they are read-only at each level: the registry of this package freezes the object, each state, and the result of each state with its errors and its checks.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | -          |
+| <a id="property-onfreshpaths"></a> `onFreshPaths?`      | `public`   | (`listener`) => () => `void`                                       | Call `listener` with the paths whose state changed: a pass that started a field fresh for a new element that took over the path, or a write of the state, such as a `touch` or a `validateAll`. Each renderer of the registry renders the elements that hold such a path again, so they show the state of now, as React renders a component again when the state of its provider changes. A write in a pass reaches the listeners when the pass ends, and a write between two passes at once. The writes of one `validateAll` reach them together. The registry calls the listeners after the outermost pass ends, and it holds each one weakly: the caller keeps its listener while it needs the calls. An error of a listener goes to `reportError`, and the other listeners still run. Returns the function that stops the calls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | -          |
+| <a id="property-registerfield"></a> `registerField`     | `public`   | (`path`, `config`, `owner?`) => `void`                             | Register (or update) a field's validation config. Called by component implementations during render, normally via `ctx.validation`. Registrations are reference-counted per path: two elements bound to the same state path each hold one, so one of them going away does not un-validate the other. `owner` names the element instance that registers. For a registration through `ctx.validation`, the renderer gives the element, its type, its repeat rows, the keys and the types of the elements above it, and the named slot that holds it. Registrations that name no owner count as one owner. See [ValidationRegistry.dropReleased](#property-dropreleased) for what it changes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | -          |
+| <a id="property-releasefield"></a> `releaseField`       | `public`   | (`path`, `owner?`) => `void`                                       | Drop one reference to a field's registration. The registration goes away once the last reference is released, and [ValidationRegistry.dropReleased](#property-dropreleased) forgets its state, unless the field registers again first. Until then `fieldStates` keeps the state, so an element that renders before the field in the same pass still reads it. This is what the render context's per-element cleanup calls: an element instance releases its registrations when it unmounts or before it re-renders. An element that renders again in place registers again in the same pass, so its state survives — matching the framework ValidationProvider, whose field states outlive a re-render and go at the last unregister. `owner` is the owner that [ValidationRegistry.registerField](#property-registerfield) got.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | -          |
+| <a id="property-startpass"></a> `startPass?`            | `public`   | (`options?`) => () => `void`                                       | Start a pass, and return the function that ends it. The incremental renderer calls it before each pass, and a host that renders with `renderSpec` before its render. A pass of a renderer that starts inside a pass ends with the outer one. A pass of the host that starts inside a pass commits the passes that run when it ends, as react commits a nested `flushSync` when it returns, and a call of the host after it sees that commit. An owner that comes to a path between two passes, for example through a late read of the children of a component, then comes before the next pass. A caller that does not call it ends and counts each pass with `dropReleased` alone, and inside a pass `dropReleased` does nothing. All the callers of one registry follow the same rule: after the first `startPass`, `dropReleased` does nothing, and the registry warns one time. An outermost pass that starts before the join of the outermost pass before it ends joins that pass, as react joins the updates of one commit. The `batch` of the pass before sets how long its join lasts (see [PassOptions](PassOptions.md)): to the next microtask for a store write, and to the end of the task, also after an `await`, for a new spec. A write of a field state, a `clear`, or a field that registers between the two passes ends the join. A write of a field state or a `clear` before the commit point of a store write does not: it is part of that commit (see the pass of a store write below). The renderers of one registry that react to one write of the store, or that a host hands new specs in one task, then run one pass. A field that moves from one renderer to the other starts fresh, whatever the order of the two. A pass that a handler of a pass queued is a new pass, as an update that a commit schedules is a new commit: its caller gives `join: false`. The incremental renderer marks the pass of a store write and the pass of a new spec. React commits a store write and a new spec after the handler that gives them, so the registry holds the effects of such a pass on the fields, a release, a new config and a fresh start, until its commit point: the next microtask, the next pass that does not join it, the bindings of a `watch`, or a field that registers between two passes. The commit point of a store write ends the join, so a pass after it starts a new commit. The commit point of a new spec keeps the join to the end of the task (see [PassOptions](PassOptions.md)). The renderer shows the store writes of the task at the commit point, in one render, as react renders the writes of one handler in one render. The commit point then does the work of the commit, it runs the effects that the components of the commit gave `ctx.effect` and the checks of the watches, and it renders the holders of the commit again, before its microtask ends. React ends the commit of a synchronous update in its microtask in the same way: it runs the effects of the commit before the renders that its layout effects start. The checks of the watches run after the effects, as react runs the effect of a child before the watch of its parent. The watches of one change see one commit. Their writes and the writes of those effects make one commit after them, and the commit point shows its store writes before its microtask ends, as react renders a store write of an effect at the end of the flush of the effects. A watch compares the store of its commit, from before the effects: when an effect writes a watched path, the watch sees the change at the commit point of that write. A `touch`, a `validate`, a `clear` or a `validateAll` before the commit point sees the fields of before the write, as in react. A write of a field state between two passes renders the holders of its path, and the registry holds the effects of that render in the same way. The incremental renderer renders them at the commit point when a store write of it waits, in the one render of its store writes, as react renders them after the handler. A render of a holder for its new config, which the end of such a pass starts, waits with it. The end of a pass of the host shows the store writes that wait, as `flushSync` of react renders the updates that wait, and it commits them with the passes that it joins. A call of the host inside such a pass sees the fields of the last commit, as a call inside the callback of `flushSync` of react does. This also holds after a store write before the pass: the end of the pass shows and commits that write too. The end of a pass of the host then runs the effects of its commit, as `flushSync` of react does: the effects that the components of the incremental renderer gave `ctx.effect`, also in a render before the pass, and then the checks of the watches. It commits their writes, and it runs the effects of those writes in the same way. The end of an outermost pass of the host ends its join, so a later pass starts a new commit. | -          |
+| <a id="property-touch"></a> `touch`                     | `public`   | (`path`, `owner?`) => `void`                                       | Mark a field as interacted with, without validating it. `owner` names the element that touches it, as for `registerField`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | -          |
+| <a id="property-unregisterfield"></a> `unregisterField` | `public`   | (`path`) => `void`                                                 | Drop a field's registration entirely, references and recorded state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | -          |
+| <a id="property-validate"></a> `validate`               | `public`   | (`path`, `config?`, `owner?`) => `ReadonlyValidationResult`        | Validate one field against the live store snapshot and record the result. Uses the field's registered config unless one is passed explicitly. `owner` names the element that validates, as for `registerField`. The result is the result of the state of the field, which every reader of `fieldStates` shares, so it is read-only at each level: the registry of this package freezes it.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | -          |
+| <a id="property-validateall"></a> `validateAll`         | `public`   | () => `boolean`                                                    | Validate every registered field. Returns true when all are valid. The listeners of `onFreshPaths` hear of the new states one time, when the last field is validated, so no holder renders in the loop.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | -          |

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

@@ -18,10 +18,10 @@ Catalog-typed action function — mirrors `ActionFn<C, K>` from @xmachines/json-
 
 ## Type Parameters
 
-| Type Parameter                                   |
-| ------------------------------------------------ |
-| `C` _extends_ `Catalog`                          |
-| `K` _extends_ keyof `InferCatalogActions`\<`C`\> |
+| Type Parameter                                                                 |
+| ------------------------------------------------------------------------------ |
+| <a id="type-parameter-c"></a> `C` _extends_ `Catalog`                          |
+| <a id="type-parameter-k"></a> `K` _extends_ keyof `InferCatalogActions`\<`C`\> |
 
 ## Parameters
 

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

@@ -13,6 +13,6 @@ Each key is a catalog action name; each value is an `ActionFn<C, K>` for that ac
 
 ## Type Parameters
 
-| Type Parameter          |
-| ----------------------- |
-| `C` _extends_ `Catalog` |
+| Type Parameter                                        |
+| ----------------------------------------------------- |
+| <a id="type-parameter-c"></a> `C` _extends_ `Catalog` |

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

@@ -29,9 +29,9 @@ function MyButton({ props, emit }: BaseComponentProps<{ label: string }>) {
 
 ## Type Parameters
 
-| Type Parameter                                | Default type                    |
-| --------------------------------------------- | ------------------------------- |
-| `P` _extends_ `Record`\<`string`, `unknown`\> | `Record`\<`string`, `unknown`\> |
+| Type Parameter                                                              | Default type                    |
+| --------------------------------------------------------------------------- | ------------------------------- |
+| <a id="type-parameter-p"></a> `P` _extends_ `Record`\<`string`, `unknown`\> | `Record`\<`string`, `unknown`\> |
 
 ## Properties
 
@@ -118,7 +118,7 @@ Defined in: `@xmachines/json-render-dom`
 ### slots?
 
 ```ts
-optional slots?: Record<string, Node[]>;
+slots?: Record<string, Node[]>;
 ```
 
 Defined in: `@xmachines/json-render-dom`

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

@@ -20,6 +20,6 @@ catalog defines actions, and optional when it does not.
 
 ## Type Parameters
 
-| Type Parameter          |
-| ----------------------- |
-| `C` _extends_ `Catalog` |
+| Type Parameter                                        |
+| ----------------------------------------------------- |
+| <a id="type-parameter-c"></a> `C` _extends_ `Catalog` |

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

@@ -10,10 +10,10 @@ Defined in: `@xmachines/json-render-dom`
 
 ## Type Parameters
 
-| Type Parameter                                      |
-| --------------------------------------------------- |
-| `C` _extends_ `Catalog`                             |
-| `K` _extends_ keyof `InferCatalogComponents`\<`C`\> |
+| Type Parameter                                                                    |
+| --------------------------------------------------------------------------------- |
+| <a id="type-parameter-c"></a> `C` _extends_ `Catalog`                             |
+| <a id="type-parameter-k"></a> `K` _extends_ keyof `InferCatalogComponents`\<`C`\> |
 
 ## Parameters
 

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

@@ -10,6 +10,6 @@ Defined in: `@xmachines/json-render-dom`
 
 ## Type Parameters
 
-| Type Parameter          |
-| ----------------------- |
-| `C` _extends_ `Catalog` |
+| Type Parameter                                        |
+| ----------------------------------------------------- |
+| <a id="type-parameter-c"></a> `C` _extends_ `Catalog` |