@xmachines/docs 3.0.0 → 5.0.0

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

@@ -2,9 +2,9 @@
 
 # @xmachines/play-dom
 
-Vanilla DOM renderer for XMachines Play architecture with signal-driven rendering.
+Vanilla DOM renderer for XMachines Play architecture with atom-driven rendering.
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-3.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-dom)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-5.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-dom)
 
 ## Installation
 
@@ -15,14 +15,19 @@ pnpm add @xmachines/play-dom
 **Peer dependencies:**
 
 ```bash
-pnpm add xstate @xstate/store @xmachines/json-render-core @xmachines/json-render-dom @xmachines/json-render-xstate
+pnpm add @xmachines/play @xmachines/play-atom @xstate/store @xmachines/json-render-core @xmachines/json-render-dom @xmachines/json-render-xstate
 ```
 
+`@xstate/store` is the peer of [`@xmachines/play-atom`](../play-atom/README.md), and not of this
+package: this package reads the atom through [`@xmachines/play-atom`](../play-atom/README.md) and
+imports the engine in no source file. Install ONE copy of it.
+
 ## Quick Start
 
 ```typescript
 import { createRenderer, schema } from "@xmachines/play-dom";
-import { definePlayer } from "@xmachines/play-xstate";
+import { definePlayer, compose, PlayerActor } from "@xmachines/play-xstate";
+import { withView } from "@xmachines/play-xstate/view";
 import { defineCatalog } from "@xmachines/json-render-core";
 import { createMachine } from "xstate";
 import { z } from "zod";
@@ -82,7 +87,8 @@ const machine = createMachine({
 		},
 	},
 });
-const actor = definePlayer({ machine })();
+// `mount` needs the view capability
+const actor = definePlayer({ machine, actor: compose(PlayerActor, withView) })();
 actor.start();
 
 // 5. Mount when actor and container are ready
@@ -169,7 +175,7 @@ renderer.disconnect();
 **Controlled store mode.** Give the renderer an external `StateStore`. The renderer then shares the state with the other parts of your application:
 
 ```typescript
-import { createAtom } from "@xstate/store";
+import { createAtom } from "@xmachines/play-atom";
 import { xstateStoreStateStore } from "@xmachines/json-render-xstate";
 
 const atom = createAtom<Record<string, unknown>>({ username: "" });
@@ -284,7 +290,7 @@ Without `onRenderError`, the renderer writes all three types of error to `consol
 **Read this if you catch what `mount()` or `connect()` throws.**
 
 In 2.2.0 the renderer had no containment. A view that failed the rebuild threw out of
-`mount()` and out of the callback of the signal watcher, so a `try` of the host, an error
+`mount()` and out of the callback of the atom watcher, so a `try` of the host, an error
 boundary of the framework around it, or the global handler of the page received it.
 
 In 2.3.0 the renderer contains such a failure ALWAYS. No option turns the containment on,
@@ -361,57 +367,43 @@ const Home: ComponentFn<typeof catalog, "Home"> = ({ ctx }) => {
 
 ### XMachines Layer
 
-| Export                                   | Kind     | Description                                                         |
-| ---------------------------------------- | -------- | ------------------------------------------------------------------- |
-| `createRenderer(catalog, components)`    | function | The one-call factory. Its `mount` hands a `Cleanup` back            |
-| `createPlayUI(registryResult, options?)` | function | The complete factory. It returns a `DisposablePlayUI`               |
-| `PlayRenderer`                           | class    | The renderer class, with a `connect()` and `disconnect()` lifecycle |
-| `defineRegistry(catalog, options)`       | function | Build a catalog-typed `DomRegistry` with typed handlers             |
-| `renderSpec(...)`                        | function | The pure low-level Spec → DOM renderer                              |
-| `schema`                                 | const    | The `@xmachines/json-render-dom` schema — pass to `defineCatalog()` |
-| `Cleanup`                                | type     | The release a mount returns, re-exported from `@xmachines/play`     |
+| Export                                   | Kind     | Description                                                                          |
+| ---------------------------------------- | -------- | ------------------------------------------------------------------------------------ |
+| `createRenderer(catalog, components)`    | function | The one-call factory. Its `mount` hands a `Cleanup` back                             |
+| `createPlayUI(registryResult, options?)` | function | The complete factory. It returns a `MountFn`                                         |
+| `PlayRenderer`                           | class    | The renderer class, with a `connect()` and `disconnect()` lifecycle                  |
+| `defineRegistry(catalog, options)`       | function | Build a catalog-typed `DomRegistry` with typed handlers                              |
+| `renderSpec(...)`                        | function | The pure low-level Spec → DOM renderer                                               |
+| `schema`                                 | const    | The `@xmachines/json-render-dom` schema — pass to `defineCatalog()`                  |
+| `asCleanup`, `Cleanup`                   | —        | The release a mount returns, re-exported from [`@xmachines/play`](../play/README.md) |
 
 ### Key Types
 
-| Type                     | Description                                                                                   |
-| ------------------------ | --------------------------------------------------------------------------------------------- |
-| `ComponentFn<C, K>`      | Catalog-typed component function — returns `HTMLElement \| Text \| null`                      |
-| `ComponentContext<C, K>` | The context of each component: `props`, `children`, `emit`, `on`, `bindings`, and `ctx`       |
-| `ActionFn<C, K>`         | Catalog-typed action function — receives `(params, setState, state)`                          |
-| `EventHandle`            | The handle that `on(eventName)` returns. It has `emit()`, `shouldPreventDefault`, and `bound` |
-| `SetState`               | State updater: `(prev => next) => void`                                                       |
-| `DefineRegistryResult`   | The result of `defineRegistry`. It has `registry`, `handlers`, and `executeAction`            |
-| `PlayDomOptions`         | Options for `PlayRenderer` — extends `UIProviderOptions`, adds `fallback` and `onError`       |
-| `CreatePlayUIOptions`    | Options for `createPlayUI` — extends `UIProviderOptions`, adds `fallback` and `onError`       |
-| `MountOptions`           | Per-mount options for `MountFn`: `store`, `loading`                                           |
-| `MountFn`                | The type of a mount that a consumer writes: `(actor, container, options?) → disconnect`       |
-| `DisposablePlayUI`       | The mount that `createPlayUI` builds. It hands a `Cleanup` back, so `using` releases it       |
-| `UIProviderOptions`      | Shared options: `functions`, `validationFunctions`, `navigate`, `onRenderError`               |
-| `BaseComponentProps<P>`  | Catalog-agnostic component props for shared component libraries                               |
-| `DomRegistry`            | Raw registry type: `Record<string, DomComponentRenderer>`                                     |
-| `DomSchema`              | Type of the `schema` export                                                                   |
-| `ComputedFunction`       | The type of a named compute function for the `functions` option                               |
-| `Cleanup`                | The release of a mount, re-exported from `@xmachines/play`                                    |
+| Type                     | Description                                                                                                   |
+| ------------------------ | ------------------------------------------------------------------------------------------------------------- |
+| `ComponentFn<C, K>`      | Catalog-typed component function — returns `HTMLElement \| Text \| null`                                      |
+| `ComponentContext<C, K>` | The context of each component: `props`, `children`, `emit`, `on`, `bindings`, and `ctx`                       |
+| `ActionFn<C, K>`         | Catalog-typed action function — receives `(params, setState, state)`                                          |
+| `EventHandle`            | The handle that `on(eventName)` returns. It has `emit()`, `shouldPreventDefault`, and `bound`                 |
+| `SetState`               | State updater: `(prev => next) => void`                                                                       |
+| `DefineRegistryResult`   | The result of `defineRegistry`. It has `registry`, `handlers`, and `executeAction`                            |
+| `PlayDomOptions`         | Options for `PlayRenderer` — extends `UIProviderOptions`, adds `fallback` and `onError`                       |
+| `CreatePlayUIOptions`    | Options for `createPlayUI` — extends `UIProviderOptions`, adds `fallback` and `onError`                       |
+| `MountOptions`           | Per-mount options for `MountFn`: `store`, `loading`                                                           |
+| `MountFn`                | The mount: `(actor, container, options?) → Cleanup`. `createPlayUI` returns one, and a consumer may write one |
+| `UIProviderOptions`      | Shared options: `functions`, `validationFunctions`, `navigate`, `onRenderError`                               |
+| `BaseComponentProps<P>`  | Catalog-agnostic component props for shared component libraries                                               |
+| `DomRegistry`            | Raw registry type: `Record<string, DomComponentRenderer>`                                                     |
+| `DomSchema`              | Type of the `schema` export                                                                                   |
+| `Cleanup`                | The release of a mount, re-exported from [`@xmachines/play`](../play/README.md)                               |
 
 ## Rendering Behavior
 
 - **The first render is synchronous** — the renderer fills the container before `connect()` returns.
-- **A signal-driven render waits for a microtask** — `watchSignal` puts each update on the next tick of the microtask queue.
+- **An atom-driven render waits for a microtask** — `watchAtom` puts each update on the next tick of the microtask queue.
 - **A null view** clears the container, and the renderer then shows the `fallback` element when you give one. It shows it for every null view, and not for the first mount only — the four framework providers hold the same rule for their placeholder content.
 - **A second `connect()` is safe** — a `connect()` call on a connected renderer disconnects it first.
-- **`disconnect()` clears the container** and cancels every signal watcher and store watcher.
-
-## Testing
-
-```bash
-# Run all tests (jsdom environment)
-pnpm test
-
-# Run with coverage
-pnpm run test:coverage
-```
-
-The tests are in `test/`. They use [Vitest](https://vitest.dev/) in a jsdom environment. The coverage thresholds are 80% for lines, functions, branches, and statements.
+- **`disconnect()` clears the container** and cancels every atom watcher and store watcher.
 
 @xmachines/play-dom — the vanilla DOM renderer of the XMachines Play architecture.
 
@@ -420,9 +412,9 @@ The public API has two layers:
 **The XMachines layer**, in this package:
 
 - `createRenderer()` — the one-call factory. It returns `mount(actor, container, options?) → disconnect`
-- `createPlayUI()` — the complete factory, with every option. It returns a `DisposablePlayUI`
+- `createPlayUI()` — the complete factory, with every option. It returns a `MountFn`
 - `PlayRenderer` — the renderer class, with a `connect()` and `disconnect()` lifecycle
-- `PlayDomOptions`, `CreatePlayUIOptions`, `MountFn`, `DisposablePlayUI`, `MountOptions`
+- `PlayDomOptions`, `CreatePlayUIOptions`, `MountFn`, `MountOptions`
 
 **The json-render layer**, re-exported from @xmachines/json-render-dom:
 
@@ -468,7 +460,6 @@ The public API has two layers:
 - [ComponentRegistry](type-aliases/ComponentRegistry.md)
 - [ConfirmHandler](type-aliases/ConfirmHandler.md)
 - [DefineRegistryOptions](type-aliases/DefineRegistryOptions.md)
-- [DisposablePlayUI](type-aliases/DisposablePlayUI.md)
 - [DomComponentRenderer](type-aliases/DomComponentRenderer.md)
 - [DomRegistry](type-aliases/DomRegistry.md)
 - [DomSchema](type-aliases/DomSchema.md)
@@ -482,6 +473,7 @@ The public API has two layers:
 
 ## Functions
 
+- [asCleanup](functions/asCleanup.md)
 - [createPlayUI](functions/createPlayUI.md)
 - [createRenderer](functions/createRenderer.md)
 - [createValidationRegistry](functions/createValidationRegistry.md)

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

@@ -2,11 +2,11 @@
 
 # Class: PlayRenderer
 
-Defined in: [packages/play-dom/src/PlayRenderer.ts:131](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom/src/PlayRenderer.ts#L131)
+Defined in: [packages/play-dom/src/PlayRenderer.ts:129](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-dom/src/PlayRenderer.ts#L129)
 
-PlayRenderer connects the `currentView` signal of an actor to the DOM renderer.
+PlayRenderer connects the `currentView` atom of an actor to the DOM renderer.
 
-It watches `actor.currentView` through the TC39 Signals. It renders each
+It watches `actor.currentView` through the atoms. It renders each
 `DomComponentRenderer` function into `container` on every view transition.
 `disconnect()` clears the container.
 
@@ -38,7 +38,7 @@ renderer.disconnect();
 **The controlled store mode** — you give your own `StateStore`:
 
 ```typescript
-import { createAtom } from "@xstate/store";
+import { createAtom } from "@xmachines/play-atom";
 import { xstateStoreStateStore } from "@xmachines/json-render-xstate";
 
 const atom = createAtom({ username: "" });
@@ -60,19 +60,20 @@ new PlayRenderer(
    container,
    actor,
    registry,
-   options?): PlayRenderer;
+   options?
+): PlayRenderer;
 ```
 
-Defined in: [packages/play-dom/src/PlayRenderer.ts:225](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom/src/PlayRenderer.ts#L225)
+Defined in: [packages/play-dom/src/PlayRenderer.ts:223](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-dom/src/PlayRenderer.ts#L223)
 
 #### Parameters
 
-| Parameter   | Type                                                                                                                                                                                                                                                             | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `container` | `HTMLElement`                                                                                                                                                                                                                                                    | The `HTMLElement` to render into. Each view transition clears it and fills it again.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `actor`     | [`AbstractActor`](../../play-actor/classes/AbstractActor.md)\<[`AnyActorLogic`](https://www.jsdocs.io/package/xstate#AnyActorLogic), [`EventObject`](https://www.jsdocs.io/package/xstate#EventObject)\> & [`Viewable`](../../play-actor/interfaces/Viewable.md) | The actor with the `currentView` signal. It must implement `Viewable`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `registry`  | [`DomRegistry`](../type-aliases/DomRegistry.md)                                                                                                                                                                                                                  | The map of the component renderers, usually `registryResult.registry` from `defineRegistry`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `options`   | [`PlayDomOptions`](../interfaces/PlayDomOptions.md)                                                                                                                                                                                                              | The configuration. See [PlayDomOptions](../interfaces/PlayDomOptions.md): - `registryResult` — it connects `setState` and `state` of the xstate store for you. - `store` — an external `StateStore`, which is the controlled mode. It replaces the values of `spec.state`. - `loading` — the flag of the streaming mode. It stops each warning about an absent child. - `functions` — the named compute functions of a `$computed` prop expression. - `directives` — your own dynamic values with a `$` prefix. The renderer resolves them with the props. - `validationFunctions` — your own check functions. They are available at `ctx.ctx.validationFunctions`. - `navigate` — the navigation callback. The renderer calls it for `onSuccess: { navigate: "..." }`. - `onRenderError` — the `(error, name)` handler of a component render error and of an action handler rejection. It stops the `console.error` fallback. - `onError` — the `(error, reset)` handler of a failure of a complete rebuild. The renderer contains such a failure always, and this option says where the report goes. - `fallback` — the element to show for every null view, and after a contained failure. |
+| Parameter   | Type                                                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| ----------- | -------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `container` | `HTMLElement`                                                  | The `HTMLElement` to render into. Each view transition clears it and fills it again.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `actor`     | [`ViewActor`](../../play-view/index/type-aliases/ViewActor.md) | The actor with the `currentView` atom. It must implement `Viewable`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `registry`  | [`DomRegistry`](../type-aliases/DomRegistry.md)                | The map of the component renderers, usually `registryResult.registry` from `defineRegistry`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `options`   | [`PlayDomOptions`](../interfaces/PlayDomOptions.md)            | The configuration. See [PlayDomOptions](../interfaces/PlayDomOptions.md): - `registryResult` — it connects `setState` and `state` of the xstate store for you. - `store` — an external `StateStore`, which is the controlled mode. It replaces the values of `spec.state`. - `loading` — the flag of the streaming mode. It stops each warning about an absent child. - `functions` — the named compute functions of a `$computed` prop expression. - `directives` — your own dynamic values with a `$` prefix. The renderer resolves them with the props. - `validationFunctions` — your own check functions. They are available at `ctx.ctx.validationFunctions`. - `navigate` — the navigation callback. The renderer calls it for `onSuccess: { navigate: "..." }`. - `onRenderError` — the `(error, name)` handler of a component render error and of an action handler rejection. It stops the `console.error` fallback. - `onError` — the `(error, reset)` handler of a failure of a complete rebuild. The renderer contains such a failure always, and this option says where the report goes. - `fallback` — the element to show for every null view, and after a contained failure. |
 
 #### Returns
 
@@ -86,13 +87,13 @@ Defined in: [packages/play-dom/src/PlayRenderer.ts:225](https://gitlab.com/xmach
 connect(): void;
 ```
 
-Defined in: [packages/play-dom/src/PlayRenderer.ts:241](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom/src/PlayRenderer.ts#L241)
+Defined in: [packages/play-dom/src/PlayRenderer.ts:239](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-dom/src/PlayRenderer.ts#L239)
 
 Starts the watch of actor.currentView, and renders into the container.
-It renders the first view synchronously, then it subscribes to the signal changes.
+It renders the first view synchronously, then it subscribes to the atom changes.
 
 A `connect()` call on a connected renderer, where a `disconnect()` call did not
-follow the previous `connect()`, installs a second `watchSignal` subscription.
+follow the previous `connect()`, installs a second `watchAtom` subscription.
 Each view change then renders two times. Therefore this method disconnects the
 renderer first.
 
@@ -108,7 +109,7 @@ renderer first.
 disconnect(): void;
 ```
 
-Defined in: [packages/play-dom/src/PlayRenderer.ts:285](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom/src/PlayRenderer.ts#L285)
+Defined in: [packages/play-dom/src/PlayRenderer.ts:283](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-dom/src/PlayRenderer.ts#L283)
 
 Stops the watch and clears the container.
 

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

@@ -0,0 +1,77 @@
+[API](../../../README.md) / [@xmachines/play-dom](../README.md) / asCleanup
+
+# Function: asCleanup()
+
+```ts
+function asCleanup<R>(release): Cleanup;
+```
+
+Defined in: [packages/play/src/disposable.ts:149](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play/src/disposable.ts#L149)
+
+Makes one release function serve as a [Cleanup](../type-aliases/Cleanup.md).
+
+The function comes back as itself, with [DISPOSE](../../play/index/variables/DISPOSE.md) added. Nothing wraps it, so
+the identity of the release holds: a caller that compares two releases, or that puts
+one in a `Set`, sees what it saw before this protocol existed.
+
+The release therefore must be idempotent. A scope releases the value one time, but a
+caller that runs the function AND lets the scope end runs it two times. Every release
+of this workspace already accepts that, because a teardown that runs two times is
+older than this protocol.
+
+The release must be synchronous. `Disposable` and not `AsyncDisposable`: a
+`Disposable` serves `using` AND `await using`, because `await using` falls back to
+`Symbol.dispose`, while an `AsyncDisposable` raises a TypeError under a plain `using`
+and forces every holder into an async function. Nothing in this workspace releases
+asynchronously. An `AsyncCleanup` can arrive the day something does.
+
+The `R extends void | undefined` bound is what holds that line. A plain `() => void`
+parameter would ACCEPT `async () => {}`, because TypeScript lets a function that
+returns a value stand where one returning `void` is wanted. The promise would then go
+on the floor: the scope releases, the release looks finished, and the work runs later
+with nobody able to await it. The bound rejects that at the call, and it rejects a
+release that returns any other value as well.
+
+The bound holds where the compiler knows the return type. It cannot hold where the
+caller erased it: `R` infers `any` for a release typed `any`, such as a bare
+`vi.fn()`, and `any` satisfies every constraint. A release declared `() => void` whose
+body is async passes for the same reason — the declaration, and not the body, is what
+the call site sees. Write the release inline, or type it, and the bound applies.
+
+The release lands under [DISPOSE](../../play/index/variables/DISPOSE.md) and, when the two differ, under the
+`Symbol.dispose` that exists at the CALL. `DISPOSE` resolves when the module evaluates,
+so a polyfill that installs the well-known symbol later would otherwise leave the
+release on the registered key while a downlevelled `using` reads the well-known one.
+Writing both closes that window for every release this function publishes.
+
+## Type Parameters
+
+| Type Parameter                      |
+| ----------------------------------- |
+| `R` _extends_ `void` \| `undefined` |
+
+## Parameters
+
+| Parameter | Type      | Description                                                                                                                                                                                                         |
+| --------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `release` | () => `R` | The release to publish. It must return nothing. The function is changed in place, so pass a function that this release owns: a shared or module-level function becomes a `Disposable` for every other holder of it. |
+
+## Returns
+
+[`Cleanup`](../type-aliases/Cleanup.md)
+
+The same function, now also a `Disposable`.
+
+## Throws
+
+TypeError - When the release is frozen or is otherwise not extensible. The
+protocol adds a property, and a sealed function accepts none.
+
+## Example
+
+```ts
+export function watchAtom<T>(atom: Readable<T>, onValue: (v: T) => void): Cleanup {
+	const subscription = atom.subscribe(() => onValue(atom.get()));
+	return asCleanup(() => subscription.unsubscribe());
+}
+```

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

@@ -3,10 +3,10 @@
 # Function: createPlayUI()
 
 ```ts
-function createPlayUI(registryResult, options?): DisposablePlayUI;
+function createPlayUI(registryResult, options?): MountFn;
 ```
 
-Defined in: [packages/play-dom/src/create-play-ui.ts:126](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom/src/create-play-ui.ts#L126)
+Defined in: [packages/play-dom/src/create-play-ui.ts:118](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-dom/src/create-play-ui.ts#L118)
 
 Creates the mount function of the complete DOM renderer.
 
@@ -23,6 +23,6 @@ and a container.
 
 ## Returns
 
-[`DisposablePlayUI`](../type-aliases/DisposablePlayUI.md)
+[`MountFn`](../type-aliases/MountFn.md)
 
-The [DisposablePlayUI](../type-aliases/DisposablePlayUI.md): `(actor, container, mountOptions?) → disconnect`
+The [MountFn](../type-aliases/MountFn.md): `(actor, container, mountOptions?) → disconnect`

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

@@ -6,7 +6,7 @@
 function createRenderer<C>(catalog, componentMap): (actor, container, options?) => Cleanup;
 ```
 
-Defined in: [packages/play-dom/src/create-renderer.ts:89](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom/src/create-renderer.ts#L89)
+Defined in: [packages/play-dom/src/create-renderer.ts:88](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-dom/src/create-renderer.ts#L88)
 
 Creates a DOM renderer factory from a catalog and a component map. You can use
 the factory more than one time.

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

@@ -2,7 +2,7 @@
 
 # Interface: CreatePlayUIOptions
 
-Defined in: [packages/play-dom/src/types.ts:152](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom/src/types.ts#L152)
+Defined in: [packages/play-dom/src/types.ts:152](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-dom/src/types.ts#L152)
 
 The options of `createPlayUI()`, the complete DOM factory.
 
@@ -31,10 +31,10 @@ createPlayUI
 | Property                                                         | Type                                                                                                      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | Inherited from                                                                                                         | Defined in                                                                                                                         |
 | ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
 | <a id="property-directives"></a> `directives?`                   | `DirectiveDefinition`\<`ZodType`\<`unknown`, `unknown`, `$ZodTypeInternals`\<`unknown`, `unknown`\>\>\>[] | Custom directives — user-defined `$`-prefixed dynamic values that extend the spec expression language (e.g. `{ $format: "currency", value: ... }`). Each entry is a `DirectiveDefinition` built with `defineDirective` from `@xmachines/json-render-core`. The array is converted to a `DirectiveRegistry` once per render pass and forwarded to `resolveElementProps` via `PropResolutionContext.directives`. Built-in expressions (`$state`, `$cond`, etc.) always take precedence over custom directives. Mirrors the `directives` prop on `JSONUIProvider` / `JsonUIProvider` introduced in **Json-render** 0.19. **Example** `import { defineDirective, resolvePropValue } from "@xmachines/json-render-core"; import { z } from "zod"; const formatDirective = defineDirective({ name: "$format", description: "Locale-aware number formatting.", schema: z.object({ $format: z.enum(["number", "currency"]), value: z.unknown() }), resolve(value, ctx) { const resolved = resolvePropValue(value.value, ctx); return new Intl.NumberFormat().format(resolved as number); }, }); renderSpec(spec, store, registry, { directives: [formatDirective] });`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | [`UIProviderOptions`](UIProviderOptions.md).[`directives`](UIProviderOptions.md#property-directives)                   | -                                                                                                                                  |
-| <a id="property-fallback"></a> `fallback?`                       | `HTMLElement` \| (() => `HTMLElement`) \| `null`                                                          | The optional fallback content — see [PlayDomOptions.fallback](PlayDomOptions.md#property-fallback) for what the renderer does with it. The factory shows it for every null view, and after a failure of a rebuild that the renderer contains. **Give a FUNCTION when the factory mounts more than one time.** ONE factory serves every `mount()` call, and `appendChild` MOVES a node. A single element therefore passes from one container to the next on every null view, and the container that loses it goes empty without a notice. A function runs one time for each mount, so every renderer owns its own element: `const mount = createPlayUI(registryResult, { 	fallback: () => { 		const element = document.createElement("p"); 		element.textContent = "Loading…"; 		return element; 	}, });` An element stays correct for a factory that mounts one time.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | -                                                                                                                      | [packages/play-dom/src/types.ts:176](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom/src/types.ts#L176) |
+| <a id="property-fallback"></a> `fallback?`                       | `HTMLElement` \| (() => `HTMLElement`) \| `null`                                                          | The optional fallback content — see [PlayDomOptions.fallback](PlayDomOptions.md#property-fallback) for what the renderer does with it. The factory shows it for every null view, and after a failure of a rebuild that the renderer contains. **Give a FUNCTION when the factory mounts more than one time.** ONE factory serves every `mount()` call, and `appendChild` MOVES a node. A single element therefore passes from one container to the next on every null view, and the container that loses it goes empty without a notice. A function runs one time for each mount, so every renderer owns its own element: `const mount = createPlayUI(registryResult, { 	fallback: () => { 		const element = document.createElement("p"); 		element.textContent = "Loading…"; 		return element; 	}, });` An element stays correct for a factory that mounts one time.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | -                                                                                                                      | [packages/play-dom/src/types.ts:176](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-dom/src/types.ts#L176) |
 | <a id="property-functions"></a> `functions?`                     | `Record`\<`string`, `ComputedFunction`\>                                                                  | Named compute functions for `{ $computed: "name", args: {...} }` prop expressions. Each function receives the resolved `args` object and returns the computed value. Forwarded directly to `resolveElementProps` via `PropResolutionContext.functions`, matching the `FunctionsContext` provider in the framework renderers. Without this option, `$computed` expressions resolve to `undefined` (no throw). **Example** `renderSpec(spec, store, registry, { functions: { fullName: (args) => `${args.first} ${args.last}`, formatCurrency: (args) => new Intl.NumberFormat().format(args.amount as number), }, });` Mirrors the `functions` prop on `JSONUIProvider` / `JsonUIProvider`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | [`UIProviderOptions`](UIProviderOptions.md).[`functions`](UIProviderOptions.md#property-functions)                     | -                                                                                                                                  |
 | <a id="property-navigate"></a> `navigate?`                       | (`path`) => `void`                                                                                        | Programmatic navigation function. Called automatically when an action binding resolves with `onSuccess: { navigate: "/path" }`. The resolved path string is passed as the sole argument. Mirrors the `navigate` prop in `ActionProvider` from the framework renderers, where it is captured in the `execute()` closure. Also available to component implementations directly via `ctx.ctx.navigate` for cases where navigation needs to be triggered outside of an action binding. **Example** `import { useNavigate } from "my-router"; const navigate = useNavigate(); renderSpec(spec, store, registry, { navigate });` Spec binding that triggers navigation: `{ "on": { "click": { "action": "doSomething", "onSuccess": { "navigate": "/dashboard" } } } }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [`UIProviderOptions`](UIProviderOptions.md).[`navigate`](UIProviderOptions.md#property-navigate)                       | -                                                                                                                                  |
 | <a id="property-onconfirm"></a> `onConfirm?`                     | [`ConfirmHandler`](../type-aliases/ConfirmHandler.md)                                                     | Confirmation hook for actions that declare `confirm` in their binding. Consulted by `emit()` before executing a confirm-gated action. Return (or resolve) `true` to execute, `false` to skip. Without this handler, confirm-gated actions are skipped with a `console.warn` — they never execute unconfirmed. See [ConfirmHandler](../type-aliases/ConfirmHandler.md) for the full contract. This is the headless equivalent of the `pendingConfirmation` / `confirmAction()` / `cancelAction()` flow in the framework adapters.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | [`UIProviderOptions`](UIProviderOptions.md).[`onConfirm`](UIProviderOptions.md#property-onconfirm)                     | -                                                                                                                                  |
-| <a id="property-onerror"></a> `onError?`                         | (`error`, `reset`) => `void`                                                                              | The optional handler of a failure of a complete rebuild of the view. This option is NOT the same as `onRenderError`, which [UIProviderOptions](UIProviderOptions.md) gives: the inner renderer routes a render error of one component, and a rejection of one action handler, to `onRenderError`. It contains each of them per element, and the rebuild continues. `onError` receives the failure of the complete rebuild that no per-element boundary caught. The renderer CONTAINS a rebuild that throws, with this option and without it: it resets the state of the failed rebuild, so that the next emission makes a complete render again, and it clears the container. `connect()` renders the first view synchronously, so a bad initial view makes `connect()` throw no more. A WRITE of the store takes the same path. The renderer resolves the props of every element that the write touched, so a `$computed` function that throws on the new state aborts that render too. The renderer contains such a failure as well, and the action handler that wrote the state receives no exception. This option says WHERE the report goes. Without it, the renderer writes the contained failure to `console.error`. A handler that THROWS reaches no caller: the renderer contains that throw too, and it writes the throw to `console.error`. A host that must escalate a failure raises it from a task of its own — `queueMicrotask(() => { throw error; })` — which reaches the global handler of the page and leaves the containment whole. The five renderers hold this one rule. The second parameter is the RESET, for a retry that the host starts — a "Retry" button of its own. It renders the view that the actor holds at the MOMENT OF THE CALL, so a host that keeps the callback cannot rewind the screen to the view that failed. A reset that the host calls from inside this handler does nothing, because no input changed between the two attempts, and a reset after `disconnect()` does nothing. A reset belongs to ONE connection. `connect()` starts a connection, and the reset of a report of an older connection does nothing. A host that calls `connect()` again from inside this handler abandons the connection that reported. The "Retry" button of that report must not render into the connection that took its place. Call the reset of the newest report. This option matches the `onError` prop of the framework renderer providers, and the five renderers hold the same three rules for the reset. | [`PlayDomOptions`](PlayDomOptions.md).[`onError`](PlayDomOptions.md#property-onerror)                                  | [packages/play-dom/src/types.ts:100](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom/src/types.ts#L100) |
+| <a id="property-onerror"></a> `onError?`                         | (`error`, `reset`) => `void`                                                                              | The optional handler of a failure of a complete rebuild of the view. This option is NOT the same as `onRenderError`, which [UIProviderOptions](UIProviderOptions.md) gives: the inner renderer routes a render error of one component, and a rejection of one action handler, to `onRenderError`. It contains each of them per element, and the rebuild continues. `onError` receives the failure of the complete rebuild that no per-element boundary caught. The renderer CONTAINS a rebuild that throws, with this option and without it: it resets the state of the failed rebuild, so that the next emission makes a complete render again, and it clears the container. `connect()` renders the first view synchronously, so a bad initial view makes `connect()` throw no more. A WRITE of the store takes the same path. The renderer resolves the props of every element that the write touched, so a `$computed` function that throws on the new state aborts that render too. The renderer contains such a failure as well, and the action handler that wrote the state receives no exception. This option says WHERE the report goes. Without it, the renderer writes the contained failure to `console.error`. A handler that THROWS reaches no caller: the renderer contains that throw too, and it writes the throw to `console.error`. A host that must escalate a failure raises it from a task of its own — `queueMicrotask(() => { throw error; })` — which reaches the global handler of the page and leaves the containment whole. The five renderers hold this one rule. The second parameter is the RESET, for a retry that the host starts — a "Retry" button of its own. It renders the view that the actor holds at the MOMENT OF THE CALL, so a host that keeps the callback cannot rewind the screen to the view that failed. A reset that the host calls from inside this handler does nothing, because no input changed between the two attempts, and a reset after `disconnect()` does nothing. A reset belongs to ONE connection. `connect()` starts a connection, and the reset of a report of an older connection does nothing. A host that calls `connect()` again from inside this handler abandons the connection that reported. The "Retry" button of that report must not render into the connection that took its place. Call the reset of the newest report. This option matches the `onError` prop of the framework renderer providers, and the five renderers hold the same three rules for the reset. | [`PlayDomOptions`](PlayDomOptions.md).[`onError`](PlayDomOptions.md#property-onerror)                                  | [packages/play-dom/src/types.ts:100](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-dom/src/types.ts#L100) |
 | <a id="property-onrendererror"></a> `onRenderError?`             | [`RenderErrorHandler`](../type-aliases/RenderErrorHandler.md)                                             | Unified error handler for component render errors and action handler rejections. Matches `RenderErrorHandler = (error: unknown, name: string) => void`. Invoked for three distinct error classes: - `(error, elementType)` — when a component renderer throws synchronously during `renderSpec` - `(error, actionName)` — when an action handler rejects during `emit()` (on-event path) - `(error, actionName)` — when an action handler rejects during a `watch` binding callback When provided, suppresses the `console.error` fallback for all three error types. Forwarded into `renderSpec` as the `onRenderError` parameter and into `DomRenderContext.onRenderError` so both `emit()` and `watch` handlers route their errors through the same channel as component render errors. **Example** `renderSpec(spec, store, registry, { onRenderError: (err, name) => { myErrorReporter.capture(err, { context: name }); }, });`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | [`UIProviderOptions`](UIProviderOptions.md).[`onRenderError`](UIProviderOptions.md#property-onrendererror)             | -                                                                                                                                  |
 | <a id="property-validationfunctions"></a> `validationFunctions?` | `Record`\<`string`, (`value`, `args?`) => `boolean`\>                                                     | Custom validation functions for inline field validation. Each function receives `(value, args?)` and returns `true` (valid) or `false` (invalid). Functions are available to component implementations via `ctx.ctx.validationFunctions` and should be passed as `customFunctions` to `runValidationCheck` / `runValidation` from `@xmachines/json-render-core`. Mirrors `customFunctions` in `ValidationProvider` from the framework renderers. The DOM renderer has no automatic `ValidationProvider` tree — validation must be invoked explicitly by component implementations. **Example** `import { runValidationCheck } from "@xmachines/json-render-core"; renderSpec(spec, store, registry, { validationFunctions: { isEven: (value) => typeof value === "number" && value % 2 === 0, phoneNumber: (value) => /^\+?[\d\s\-()]{7,}$/.test(String(value)), }, }); // Inside a ComponentFn: const MyField: ComponentFn<typeof catalog, "MyField"> = ({ ctx }) => { const result = runValidationCheck( { type: "isEven", message: "must be even" }, { value: someValue, stateModel: {}, customFunctions: ctx.ctx.validationFunctions }, ); // result.valid, result.message };`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | [`UIProviderOptions`](UIProviderOptions.md).[`validationFunctions`](UIProviderOptions.md#property-validationfunctions) | -                                                                                                                                  |

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

@@ -2,7 +2,7 @@
 
 # Interface: MountOptions
 
-Defined in: [packages/play-dom/src/create-play-ui.ts:51](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom/src/create-play-ui.ts#L51)
+Defined in: [packages/play-dom/src/create-play-ui.ts:50](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-dom/src/create-play-ui.ts#L50)
 
 The mount options of the `MountFn` that `createPlayUI` returns.
 
@@ -15,5 +15,5 @@ time.
 
 | Property                                 | Type         | Description                                                                                                                                                                              | Defined in                                                                                                                                         |
 | ---------------------------------------- | ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-loading"></a> `loading?` | `boolean`    | With the value `true`, the renderer stops each warning about an absent child during the ingestion of a streaming spec. It also gives `ctx.ctx.loading` to each component implementation. | [packages/play-dom/src/create-play-ui.ts:63](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom/src/create-play-ui.ts#L63) |
-| <a id="property-store"></a> `store?`     | `StateStore` | The optional external `StateStore`, which is the controlled mode. Without it, the renderer makes a new `@xstate/store` atom for each view transition, with the values of `spec.state`.   | [packages/play-dom/src/create-play-ui.ts:57](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom/src/create-play-ui.ts#L57) |
+| <a id="property-loading"></a> `loading?` | `boolean`    | With the value `true`, the renderer stops each warning about an absent child during the ingestion of a streaming spec. It also gives `ctx.ctx.loading` to each component implementation. | [packages/play-dom/src/create-play-ui.ts:62](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-dom/src/create-play-ui.ts#L62) |
+| <a id="property-store"></a> `store?`     | `StateStore` | The optional external `StateStore`, which is the controlled mode. Without it, the renderer makes a new `@xstate/store` atom for each view transition, with the values of `spec.state`.   | [packages/play-dom/src/create-play-ui.ts:56](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-dom/src/create-play-ui.ts#L56) |