@xmachines/docs 2.0.0-alpha.1 → 2.1.0

package/api/@xmachines/play-signals/interfaces/SignalComputed.md

@@ -2,13 +2,13 @@
 
 # Interface: SignalComputed\<T\>
 
-Defined in: [packages/play-signals/src/types.ts:111](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-signals/src/types.ts#L111)
+Defined in: [packages/play-signals/src/types.ts:112](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-signals/src/types.ts#L112)
 
-Lazily-evaluated, memoized computed signal
+The computed signal. It evaluates late, and it memoizes the result
 
-Signal.Computed automatically tracks dependencies when its callback is executed.
-The computation is memoized and only re-runs when dependencies change. This enables
-automatic dependency tracking without manual subscription management.
+Signal.Computed tracks each dependency when it runs its callback. It memoizes the
+result, and it runs the callback again only after a dependency changes. It
+therefore tracks each dependency for you, and you manage no subscription.
 
 ## Example
 
@@ -20,8 +20,8 @@ const doubled = new Signal.Computed(() => count.get() * 2);
 
 console.log(doubled.get()); // 0
 count.set(5);
-console.log(doubled.get()); // 10 (recomputed)
-console.log(doubled.get()); // 10 (memoized, not recomputed)
+console.log(doubled.get()); // 10 (the signal computed it again)
+console.log(doubled.get()); // 10 (from the memory, with no new computation)
 ```
 
 ## Type Parameters
@@ -38,12 +38,12 @@ console.log(doubled.get()); // 10 (memoized, not recomputed)
 get(): T;
 ```
 
-Defined in: [packages/play-signals/src/types.ts:117](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-signals/src/types.ts#L117)
+Defined in: [packages/play-signals/src/types.ts:118](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-signals/src/types.ts#L118)
 
-Read computed value (recalculates only if dependencies changed)
+Reads the computed value. It computes the value again only after a dependency changed
 
 #### Returns
 
 `T`
 
-Computed value based on current dependencies
+The value from the current dependencies

package/api/@xmachines/play-signals/interfaces/SignalOptions.md

@@ -2,15 +2,15 @@
 
 # Interface: SignalOptions\<T\>
 
-Defined in: [packages/play-signals/src/types.ts:26](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-signals/src/types.ts#L26)
+Defined in: [packages/play-signals/src/types.ts:27](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-signals/src/types.ts#L27)
 
-Options for creating Signal.State
+The options of a Signal.State
 
 ## Param
 
 **equals**
 
-Optional custom equality function for determining if value changed
+The optional equality function of your own. It decides if the value changed
 
 ## Example
 
@@ -32,6 +32,6 @@ const count = new Signal.State(0, options);
 
 ## Properties
 
-| Property                               | Type                    | Description                                               | Defined in                                                                                                                                       |
-| -------------------------------------- | ----------------------- | --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
-| <a id="property-equals"></a> `equals?` | (`a`, `b`) => `boolean` | Custom equality function for determining if value changed | [packages/play-signals/src/types.ts:33](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-signals/src/types.ts#L33) |
+| Property                               | Type                    | Description                                                        | Defined in                                                                                                                               |
+| -------------------------------------- | ----------------------- | ------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-equals"></a> `equals?` | (`a`, `b`) => `boolean` | The equality function of your own. It decides if the value changed | [packages/play-signals/src/types.ts:34](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-signals/src/types.ts#L34) |

package/api/@xmachines/play-signals/interfaces/SignalState.md

@@ -2,13 +2,13 @@
 
 # Interface: SignalState\<T\>
 
-Defined in: [packages/play-signals/src/types.ts:53](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-signals/src/types.ts#L53)
+Defined in: [packages/play-signals/src/types.ts:54](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-signals/src/types.ts#L54)
 
-Writable state signal holding a single reactive value
+The writable state signal. It holds one reactive value
 
-Signal.State is the fundamental primitive for reactive state. Calling `get()` within
-a computed signal or watcher automatically tracks the state as a dependency. Calling
-`set()` notifies all dependent computations and watchers.
+Signal.State is the base primitive of a reactive state. A `get()` call inside a
+computed signal or inside a watcher tracks the state as a dependency. A `set()`
+call notifies every computation and every watcher that depends on the state.
 
 ## Example
 
@@ -35,15 +35,15 @@ console.log(name.get()); // 'Bob'
 get(): T;
 ```
 
-Defined in: [packages/play-signals/src/types.ts:59](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-signals/src/types.ts#L59)
+Defined in: [packages/play-signals/src/types.ts:60](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-signals/src/types.ts#L60)
 
-Read current value and track as dependency
+Reads the current value, and tracks the signal as a dependency
 
 #### Returns
 
 `T`
 
-Current value of the signal
+The current value of the signal
 
 ---
 
@@ -53,15 +53,15 @@ Current value of the signal
 set(value): void;
 ```
 
-Defined in: [packages/play-signals/src/types.ts:66](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-signals/src/types.ts#L66)
+Defined in: [packages/play-signals/src/types.ts:67](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-signals/src/types.ts#L67)
 
-Write new value and notify watchers if changed
+Writes a new value, and notifies the watchers when the value changed
 
 #### Parameters
 
-| Parameter | Type | Description      |
-| --------- | ---- | ---------------- |
-| `value`   | `T`  | New value to set |
+| Parameter | Type | Description   |
+| --------- | ---- | ------------- |
+| `value`   | `T`  | The new value |
 
 #### Returns
 

package/api/@xmachines/play-signals/interfaces/SignalWatcher.md

@@ -2,12 +2,12 @@
 
 # Interface: SignalWatcher
 
-Defined in: [packages/play-signals/src/types.ts:167](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-signals/src/types.ts#L167)
+Defined in: [packages/play-signals/src/types.ts:169](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-signals/src/types.ts#L169)
 
-Watcher for observing signal changes and scheduling effects
+The watcher. It observes each signal change and schedules an effect
 
-Signal.subtle.Watcher enables observing multiple signals and batching updates.
-This is the low-level primitive used by frameworks to implement reactive effects.
+Signal.subtle.Watcher observes more than one signal, and it groups the updates.
+It is the low-level primitive, and a framework uses it to make a reactive effect.
 
 ## Example
 
@@ -27,7 +27,7 @@ const watcher = new Signal.subtle.Watcher(() => {
 watcher.watch(count);
 watcher.watch(doubled);
 
-count.set(5); // Notification scheduled via microtask
+count.set(5); // The watcher schedules the notification in a microtask
 ```
 
 ## Methods
@@ -40,9 +40,9 @@ getPending(): (
   | SignalComputed<unknown>)[];
 ```
 
-Defined in: [packages/play-signals/src/types.ts:187](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-signals/src/types.ts#L187)
+Defined in: [packages/play-signals/src/types.ts:189](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-signals/src/types.ts#L189)
 
-Get signals that changed since last check
+Returns the signals that changed after the last check
 
 #### Returns
 
@@ -50,7 +50,7 @@ Get signals that changed since last check
 \| [`SignalState`](SignalState.md)\<`unknown`\>
 \| [`SignalComputed`](SignalComputed.md)\<`unknown`\>)[]
 
-Array of signals that have pending updates
+The array of the signals with an update that waits
 
 ---
 
@@ -60,15 +60,15 @@ Array of signals that have pending updates
 unwatch(signal): void;
 ```
 
-Defined in: [packages/play-signals/src/types.ts:180](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-signals/src/types.ts#L180)
+Defined in: [packages/play-signals/src/types.ts:182](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-signals/src/types.ts#L182)
 
-Stop watching a signal
+Stops the watch of one signal
 
 #### Parameters
 
-| Parameter | Type                                                                                                  | Description              |
-| --------- | ----------------------------------------------------------------------------------------------------- | ------------------------ |
-| `signal`  | \| [`SignalState`](SignalState.md)\<`unknown`\> \| [`SignalComputed`](SignalComputed.md)\<`unknown`\> | Signal to stop observing |
+| Parameter | Type                                                                                                  | Description         |
+| --------- | ----------------------------------------------------------------------------------------------------- | ------------------- |
+| `signal`  | \| [`SignalState`](SignalState.md)\<`unknown`\> \| [`SignalComputed`](SignalComputed.md)\<`unknown`\> | The signal to leave |
 
 #### Returns
 
@@ -82,15 +82,15 @@ Stop watching a signal
 watch(signal): void;
 ```
 
-Defined in: [packages/play-signals/src/types.ts:173](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-signals/src/types.ts#L173)
+Defined in: [packages/play-signals/src/types.ts:175](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-signals/src/types.ts#L175)
 
-Start watching a signal for changes
+Starts the watch of one signal
 
 #### Parameters
 
-| Parameter | Type                                                                                                  | Description                           |
-| --------- | ----------------------------------------------------------------------------------------------------- | ------------------------------------- |
-| `signal`  | \| [`SignalState`](SignalState.md)\<`unknown`\> \| [`SignalComputed`](SignalComputed.md)\<`unknown`\> | Signal to observe (State or Computed) |
+| Parameter | Type                                                                                                  | Description                                  |
+| --------- | ----------------------------------------------------------------------------------------------------- | -------------------------------------------- |
+| `signal`  | \| [`SignalState`](SignalState.md)\<`unknown`\> \| [`SignalComputed`](SignalComputed.md)\<`unknown`\> | The signal to observe: a State or a Computed |
 
 #### Returns
 

package/api/@xmachines/play-signals/type-aliases/WatcherNotify.md

@@ -6,12 +6,13 @@
 type WatcherNotify = () => void;
 ```
 
-Defined in: [packages/play-signals/src/types.ts:139](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-signals/src/types.ts#L139)
+Defined in: [packages/play-signals/src/types.ts:141](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-signals/src/types.ts#L141)
 
-Notification callback for Signal.subtle.Watcher
+The notification callback of a Signal.subtle.Watcher
 
-Invoked when watched signals change. Use microtask batching pattern to coalesce
-rapid updates (see signal-polyfill README for best practices).
+The watcher calls it after a signal that it watches changes. Use the microtask
+batching pattern to group rapid updates. The README of signal-polyfill gives the
+best practice.
 
 ## Returns
 
@@ -25,7 +26,7 @@ import { Signal } from "@xmachines/play-signals";
 const notify: WatcherNotify = () => {
 	queueMicrotask(() => {
 		const pending = watcher.getPending();
-		// Process pending signal changes
+		// Process the signal changes that wait
 	});
 };
 const watcher = new Signal.subtle.Watcher(notify);

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

@@ -1,14 +1,12 @@
 [API](../../README.md) / @xmachines/play-solid
 
-<!-- generated-by: gsd-doc-writer -->
-
 # @xmachines/play-solid
 
 > Solid renderer for XMachines Play architecture
 
-SolidJS rendering layer that passively observes actor signals and renders UI components via `@xmachines/json-render-solid`. SolidJS reactivity is used solely to trigger re-renders — TC39 Signals are the source of truth.
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-2.1.0-blue)](https://www.npmjs.com/package/@xmachines/play-solid)
 
-Part of the [xmachines-js monorepo](../../README.md).
+The SolidJS rendering layer observes the actor signals and renders the UI components through `@xmachines/json-render-solid`. SolidJS reactivity only triggers the re-render. The TC39 Signals are the source of truth.
 
 ## Installation
 
@@ -16,7 +14,7 @@ Part of the [xmachines-js monorepo](../../README.md).
 pnpm add @xmachines/play-solid
 ```
 
-**Peer dependencies** — install alongside the package:
+**Peer dependencies.** Install them with the package:
 
 ```bash
 pnpm add solid-js xstate @xstate/store @xmachines/json-render-solid @xmachines/json-render-core @xmachines/json-render-xstate
@@ -29,15 +27,24 @@ import { PlayUIProvider, PlayRenderer, defineRegistry } from "@xmachines/play-so
 import { definePlayer } from "@xmachines/play-xstate";
 import { defineCatalog } from "@xmachines/json-render-core";
 import { schema } from "@xmachines/json-render-solid/schema";
+import { myMachine } from "./machine.js"; // your xstate machine (states carry meta.view specs)
+// authCatalogDef is a plain object describing components/actions — in this repo it
+// comes from the workspace-only @xmachines/play-actor-shared demo package
+import { authCatalogDef } from "@xmachines/play-actor-shared";
 
-// 1. Define a catalog (authCatalogDef is a plain object describing components/actions)
+// 1. Define a catalog
 const catalog = defineCatalog(schema, authCatalogDef);
 
-// 2. Build a component registry
+// 2. Create and start an actor
+const createPlayer = definePlayer({ machine: myMachine });
+const actor = createPlayer();
+actor.start();
+
+// 3. Build a component registry
 const registryResult = defineRegistry(catalog, {
 	components: {
 		Home: () => <div>Welcome home!</div>,
-		Login: (ctx) => <div>Login {ctx.props.error && <span>{ctx.props.error}</span>}</div>,
+		Login: (ctx) => <div>Login {ctx.props.username && <span>{ctx.props.username}</span>}</div>,
 	},
 	actions: {
 		login: async (args) => actor.send({ type: "auth.login", username: args.username }),
@@ -45,11 +52,6 @@ const registryResult = defineRegistry(catalog, {
 	},
 });
 
-// 3. Create and start an actor
-const createPlayer = definePlayer({ machine: myMachine });
-const actor = createPlayer();
-actor.start();
-
 // 4. Render
 function App() {
 	return (
@@ -64,30 +66,32 @@ function App() {
 
 ### `PlayUIProvider` + `PlayRenderer` (recommended)
 
-`PlayUIProvider` is the batteries-included entry point. It wraps `ActorProvider` and `JSONUIProvider` into a single composite provider. `PlayRenderer` is a zero-prop leaf component that reads view context and renders the current spec.
+`PlayUIProvider` is the standard entry point. It wraps `ActorProvider` and `JSONUIProvider` into one composite provider. `PlayRenderer` is a leaf component without props. It reads the view context and renders the current spec.
 
 ```tsx
 import { PlayUIProvider, PlayRenderer, defineRegistry } from "@xmachines/play-solid";
 
+// actor, registryResult from the Quick Start above
 <PlayUIProvider
 	actor={actor}
 	registryResult={registryResult}
 	fallback={<div>Loading…</div>}
 	onError={(err) => console.error(err)}
-	navigate={navigateFn} // optional: passed to JSONUIProvider
-	validationFunctions={valFns} // optional: form validation helpers
+	navigate={navigateFn} // optional: your navigation callback, passed to JSONUIProvider
+	validationFunctions={valFns} // optional: your form validation helpers
 >
 	<PlayRenderer />
 </PlayUIProvider>;
 ```
 
-### `ActorProvider` (escape hatch)
+### `ActorProvider` (low-level)
 
 For library authors who need direct control over provider composition:
 
 ```tsx
 import { ActorProvider, PlayRenderer } from "@xmachines/play-solid";
 
+// actor, registryResult from the Quick Start above
 <ActorProvider actor={actor} registryResult={registryResult}>
 	<PlayRenderer />
 </ActorProvider>;
@@ -124,28 +128,28 @@ const MyRenderer = () => {
 
 ### Components
 
-| Export           | Description                                                                    |
-| ---------------- | ------------------------------------------------------------------------------ |
-| `PlayUIProvider` | Batteries-included composite provider (recommended entry point)                |
-| `PlayRenderer`   | Zero-prop leaf component; renders the current view spec inside a provider tree |
-| `ActorProvider`  | Lower-level smart provider for escape-hatch composition                        |
+| Export           | Description                                                                               |
+| ---------------- | ----------------------------------------------------------------------------------------- |
+| `PlayUIProvider` | The composite provider. Use it as the standard entry point                                |
+| `PlayRenderer`   | The leaf component without props. It renders the current view spec inside a provider tree |
+| `ActorProvider`  | The low-level provider for a custom provider composition                                  |
 
 ### Hooks
 
-| Export          | Description                                                                                   |
-| --------------- | --------------------------------------------------------------------------------------------- |
-| `useActor()`    | Returns the raw `AnyPlayActor` instance from context; throws outside a provider tree          |
-| `usePlayView()` | Returns the current `ViewContextValue` (spec, handlers, registry, store); throws outside tree |
+| Export          | Description                                                                                          |
+| --------------- | ---------------------------------------------------------------------------------------------------- |
+| `useActor()`    | Returns the raw `AnyPlayActor` instance from the context. It throws outside a provider tree          |
+| `usePlayView()` | Returns the current `ViewContextValue` (spec, handlers, registry, store). It throws outside the tree |
 
 ### Context
 
-| Export         | Description                                                                            |
-| -------------- | -------------------------------------------------------------------------------------- |
-| `ActorContext` | SolidJS context for the actor; use `ActorContext.Provider` directly as an escape hatch |
+| Export         | Description                                                                                     |
+| -------------- | ----------------------------------------------------------------------------------------------- |
+| `ActorContext` | The SolidJS context of the actor. Use `ActorContext.Provider` directly for a custom composition |
 
 ### Re-exports from `@xmachines/json-render-solid`
 
-This package re-exports the full `@xmachines/json-render-solid` public API so consumers do not need a direct dependency:
+This package re-exports the complete `@xmachines/json-render-solid` public API, so that a consumer does not need a direct dependency:
 
 ```tsx
 import {
@@ -174,12 +178,12 @@ import {
 
 ### Key Types
 
-| Type                  | Description                                                                    |
-| --------------------- | ------------------------------------------------------------------------------ |
-| `PlayUIProviderProps` | Props for `PlayUIProvider`                                                     |
-| `ActorProviderProps`  | Props for `ActorProvider`                                                      |
-| `ViewContextValue`    | Shape of the context value from `usePlayView()`                                |
-| `AnyPlayActor`        | `AbstractActor<AnyActorLogic>` — bare actor type accepted by context providers |
+| Type                  | Description                                                                            |
+| --------------------- | -------------------------------------------------------------------------------------- |
+| `PlayUIProviderProps` | Props for `PlayUIProvider`                                                             |
+| `ActorProviderProps`  | Props for `ActorProvider`                                                              |
+| `ViewContextValue`    | Shape of the context value from `usePlayView()`                                        |
+| `AnyPlayActor`        | `AbstractActor<AnyActorLogic>` — the bare actor type that the context providers accept |
 
 ## Testing
 
@@ -197,17 +201,17 @@ pnpm run test:watch  # watch mode
 pnpm run test:ui     # interactive Vitest UI
 ```
 
-Coverage is collected with v8 (80% threshold for lines, functions, branches, and statements). Browser-specific tests live in `test/browser/` and are excluded from the default jsdom run.
+The v8 provider collects the coverage, with a threshold of 80% for lines, functions, branches, and statements. The browser tests are in `test/browser/`. The default jsdom run excludes them.
 
 ## License
 
 MIT
 
-@xmachines/play-solid - SolidJS renderer for XMachines Play architecture
+@xmachines/play-solid - SolidJS renderer for the XMachines Play architecture
 
-Provides a SolidJS rendering layer that passively observes actor signals and
-renders UI components via @xmachines/json-render-solid. SolidJS reactivity is only used
-to trigger re-renders — signals are the source of truth.
+This package is the SolidJS rendering layer. It observes the actor signals and
+renders the UI components through @xmachines/json-render-solid. SolidJS
+reactivity only triggers the re-render. The signals are the source of truth.
 
 Primary entry point:
 
@@ -215,7 +219,7 @@ Primary entry point:
 import { PlayUIProvider, PlayRenderer, defineRegistry } from "@xmachines/play-solid";
 ```
 
-For escape-hatch provider composition:
+For a custom provider composition:
 
 ```tsx
 import { ActorProvider, ActorContext, usePlayView } from "@xmachines/play-solid";

package/api/@xmachines/play-solid/functions/useActor.md

@@ -6,7 +6,7 @@
 function useActor(): AnyPlayActor;
 ```
 
-Defined in: [packages/play-solid/src/useActor.ts:37](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-solid/src/useActor.ts#L37)
+Defined in: [packages/play-solid/src/useActor.ts:40](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-solid/src/useActor.ts#L40)
 
 ## Returns
 

package/api/@xmachines/play-solid/functions/usePlayView.md

@@ -6,9 +6,9 @@
 function usePlayView(): ViewContextValue;
 ```
 
-Defined in: [packages/play-solid/src/ActorProvider.tsx:75](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-solid/src/ActorProvider.tsx#L75)
+Defined in: [packages/play-solid/src/ActorProvider.tsx:75](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-solid/src/ActorProvider.tsx#L75)
 
-Hook to access the current view context inside an ActorProvider tree.
+The hook that gives the current view context inside an ActorProvider tree.
 
 ## Returns
 
@@ -16,7 +16,7 @@ Hook to access the current view context inside an ActorProvider tree.
 
 ## Throws
 
-If called outside an ActorProvider (or PlayUIProvider) tree
+When the caller is outside an ActorProvider tree or a PlayUIProvider tree
 
 ## Example
 

package/api/@xmachines/play-solid/interfaces/ActorProviderProps.md

@@ -2,12 +2,12 @@
 
 # Interface: ActorProviderProps
 
-Defined in: [packages/play-solid/src/ActorProvider.tsx:89](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-solid/src/ActorProvider.tsx#L89)
+Defined in: [packages/play-solid/src/ActorProvider.tsx:89](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-solid/src/ActorProvider.tsx#L89)
 
-Props for ActorProvider — the escape hatch primitive.
+The props of ActorProvider, the low-level provider.
 
-For batteries-included usage, prefer PlayUIProvider which wraps ActorProvider
-with JSONUIProvider and all required sub-providers.
+For the standard use, prefer PlayUIProvider. That component wraps ActorProvider
+with JSONUIProvider and with every necessary sub-provider.
 
 ## Extends
 
@@ -19,12 +19,12 @@ with JSONUIProvider and all required sub-providers.
 
 ## Properties
 
-| Property                                              | Type                                                                                                                                                                                                                                                             | Description                                                                                                                                                                                                                 | Inherited from                                                                                                                                                                      | Defined in                                                                                                                                                       |
-| ----------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-actor"></a> `actor`                   | [`AbstractActor`](../../play-actor/classes/AbstractActor.md)\<[`AnyActorLogic`](https://www.jsdocs.io/package/xstate#AnyActorLogic), [`EventObject`](https://www.jsdocs.io/package/xstate#EventObject)\> & [`Viewable`](../../play-actor/interfaces/Viewable.md) | Actor instance with currentView signal (requires Viewable capability).                                                                                                                                                      | [`BaseActorProviderProps`](../../play-actor/interfaces/BaseActorProviderProps.md).[`actor`](../../play-actor/interfaces/BaseActorProviderProps.md#property-actor)                   | [packages/play-actor/src/abstract-actor.ts:159](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-actor/src/abstract-actor.ts#L159) |
-| <a id="property-children"></a> `children`             | `any`                                                                                                                                                                                                                                                            | Children — required; must include <PlayRenderer /> (or use PlayUIProvider shorthand)                                                                                                                                        | -                                                                                                                                                                                   | [packages/play-solid/src/ActorProvider.tsx:97](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-solid/src/ActorProvider.tsx#L97)   |
-| <a id="property-fallback"></a> `fallback?`            | `any`                                                                                                                                                                                                                                                            | Optional fallback element shown when currentView is null or ErrorBoundary catches                                                                                                                                           | -                                                                                                                                                                                   | [packages/play-solid/src/ActorProvider.tsx:91](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-solid/src/ActorProvider.tsx#L91)   |
-| <a id="property-onerror"></a> `onError?`              | (`error`) => `void`                                                                                                                                                                                                                                              | Optional callback invoked when SolidJS ErrorBoundary catches an error                                                                                                                                                       | -                                                                                                                                                                                   | [packages/play-solid/src/ActorProvider.tsx:94](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-solid/src/ActorProvider.tsx#L94)   |
-| <a id="property-onrendererror"></a> `onRenderError?`  | [`RenderErrorHandler`](../type-aliases/RenderErrorHandler.md)                                                                                                                                                                                                    | Called when an individual catalog component throws during render. Takes precedence over any onRenderError set via defineRegistry.                                                                                           | [`BaseActorProviderProps`](../../play-actor/interfaces/BaseActorProviderProps.md).[`onRenderError`](../../play-actor/interfaces/BaseActorProviderProps.md#property-onrendererror)   | [packages/play-actor/src/abstract-actor.ts:172](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-actor/src/abstract-actor.ts#L172) |
-| <a id="property-registryresult"></a> `registryResult` | [`DefineRegistryResult`](DefineRegistryResult.md)                                                                                                                                                                                                                | Full result from defineRegistry() — contains the component registry and action handlers factory.                                                                                                                            | [`BaseActorProviderProps`](../../play-actor/interfaces/BaseActorProviderProps.md).[`registryResult`](../../play-actor/interfaces/BaseActorProviderProps.md#property-registryresult) | [packages/play-actor/src/abstract-actor.ts:161](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-actor/src/abstract-actor.ts#L161) |
-| <a id="property-store"></a> `store?`                  | `StateStore`                                                                                                                                                                                                                                                     | Optional external StateStore (controlled mode). When provided, spec.state is ignored and this store is the single source of truth. When omitted, a fresh @xstate/store atom is created per view transition from spec.state. | [`BaseActorProviderProps`](../../play-actor/interfaces/BaseActorProviderProps.md).[`store`](../../play-actor/interfaces/BaseActorProviderProps.md#property-store)                   | [packages/play-actor/src/abstract-actor.ts:167](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-actor/src/abstract-actor.ts#L167) |
+| Property                                              | Type                                                                                                                                                                                                                                                             | Description                                                                                                                                                                                                                                                                       | Inherited from                                                                                                                                                                      | Defined in                                                                                                                                               |
+| ----------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-actor"></a> `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 instance with the currentView signal. It requires the Viewable capability.                                                                                                                                                                                              | [`BaseActorProviderProps`](../../play-actor/interfaces/BaseActorProviderProps.md).[`actor`](../../play-actor/interfaces/BaseActorProviderProps.md#property-actor)                   | [packages/play-actor/src/abstract-actor.ts:163](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-actor/src/abstract-actor.ts#L163) |
+| <a id="property-children"></a> `children`             | `any`                                                                                                                                                                                                                                                            | The children. They are necessary, and they must hold a <PlayRenderer />. You can also use the PlayUIProvider short form                                                                                                                                                           | -                                                                                                                                                                                   | [packages/play-solid/src/ActorProvider.tsx:101](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-solid/src/ActorProvider.tsx#L101) |
+| <a id="property-fallback"></a> `fallback?`            | `any`                                                                                                                                                                                                                                                            | The optional fallback element. The provider shows it when currentView is null, and when the ErrorBoundary catches an error                                                                                                                                                        | -                                                                                                                                                                                   | [packages/play-solid/src/ActorProvider.tsx:93](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-solid/src/ActorProvider.tsx#L93)   |
+| <a id="property-onerror"></a> `onError?`              | (`error`) => `void`                                                                                                                                                                                                                                              | The optional callback. The provider calls it when the SolidJS ErrorBoundary catches an error                                                                                                                                                                                      | -                                                                                                                                                                                   | [packages/play-solid/src/ActorProvider.tsx:96](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-solid/src/ActorProvider.tsx#L96)   |
+| <a id="property-onrendererror"></a> `onRenderError?`  | [`RenderErrorHandler`](../type-aliases/RenderErrorHandler.md)                                                                                                                                                                                                    | The provider calls it when one catalog component throws during a render. This handler replaces every onRenderError of defineRegistry.                                                                                                                                             | [`BaseActorProviderProps`](../../play-actor/interfaces/BaseActorProviderProps.md).[`onRenderError`](../../play-actor/interfaces/BaseActorProviderProps.md#property-onrendererror)   | [packages/play-actor/src/abstract-actor.ts:177](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-actor/src/abstract-actor.ts#L177) |
+| <a id="property-registryresult"></a> `registryResult` | [`DefineRegistryResult`](DefineRegistryResult.md)                                                                                                                                                                                                                | The complete result of defineRegistry(). It holds the component registry and the factory of the action handlers.                                                                                                                                                                  | [`BaseActorProviderProps`](../../play-actor/interfaces/BaseActorProviderProps.md).[`registryResult`](../../play-actor/interfaces/BaseActorProviderProps.md#property-registryresult) | [packages/play-actor/src/abstract-actor.ts:165](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-actor/src/abstract-actor.ts#L165) |
+| <a id="property-store"></a> `store?`                  | `StateStore`                                                                                                                                                                                                                                                     | The optional external StateStore, which is the controlled mode. With this option, the provider ignores spec.state, and this store is the single source of truth. Without it, the provider makes a new @xstate/store atom for each view transition, with the values of spec.state. | [`BaseActorProviderProps`](../../play-actor/interfaces/BaseActorProviderProps.md).[`store`](../../play-actor/interfaces/BaseActorProviderProps.md#property-store)                   | [packages/play-actor/src/abstract-actor.ts:172](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-actor/src/abstract-actor.ts#L172) |