@xmachines/docs 2.2.0 → 4.0.0

package/api/@xmachines/play-view/index/interfaces/FailureLatch.md

@@ -0,0 +1,60 @@
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / FailureLatch
+
+# Interface: FailureLatch
+
+Defined in: [packages/play-view/src/failure-latch.ts:174](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L174)
+
+The record of what a provider reported. See [createFailureLatch](../functions/createFailureLatch.md).
+
+## Methods
+
+### clear()
+
+```ts
+clear(): void;
+```
+
+Defined in: [packages/play-view/src/failure-latch.ts:191](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L191)
+
+Forgets the record, so the next failure reports again.
+
+A caller clears it on EVERY emission of a view, the null emission included: a view,
+then null, then the same view is a real sequence of an actor, and the second failure
+of that view is a second attempt that the host must hear about. It also clears it on
+a resolution that works, and on a retry that the host starts — the host asked for
+that attempt, so it must hear the result.
+
+#### Returns
+
+`void`
+
+---
+
+### shouldReport()
+
+```ts
+shouldReport(
+   actor,
+   view,
+   store
+): boolean;
+```
+
+Defined in: [packages/play-view/src/failure-latch.ts:181](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L181)
+
+Answers whether a failure of these three inputs is new, and records it.
+
+#### Parameters
+
+| Parameter | Type      |
+| --------- | --------- |
+| `actor`   | `unknown` |
+| `view`    | `unknown` |
+| `store`   | `unknown` |
+
+#### Returns
+
+`boolean`
+
+`true` the first time for one set of inputs, and `false` for every repeat
+of the same set. A caller reports only when it returns `true`.

package/api/@xmachines/{play-actor → play-view/index}/interfaces/PlaySpec.md

@@ -1,8 +1,8 @@
-[API](../../../README.md) / [@xmachines/play-actor](../README.md) / PlaySpec
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / PlaySpec
 
 # Interface: PlaySpec
 
-Defined in: [packages/play-actor/src/abstract-actor.ts:47](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/abstract-actor.ts#L47)
+Defined in: [packages/play-view/src/view-types.ts:32](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-types.ts#L32)
 
 The XMachines extension of the `Spec` type of `@xmachines/json-render-core`.
 
@@ -18,9 +18,9 @@ spec reads only the paths that it needs.
 
 ## Properties
 
-| Property                                  | Modifier   | Type                              | Description                                                                                                                                                                                                                                                                                                                                                  | Inherited from  | Defined in                                                                                                                                             |
-| ----------------------------------------- | ---------- | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| <a id="property-elements"></a> `elements` | `public`   | `Record`\<`string`, `UIElement`\> | Flat map of elements by key                                                                                                                                                                                                                                                                                                                                  | `Spec.elements` | -                                                                                                                                                      |
-| <a id="property-root"></a> `root`         | `public`   | `string`                          | Root element key                                                                                                                                                                                                                                                                                                                                             | `Spec.root`     | -                                                                                                                                                      |
-| <a id="property-state"></a> `state?`      | `public`   | `Record`\<`string`, `unknown`\>   | Optional initial state to seed the state model. Components using statePath will read from / write to this state.                                                                                                                                                                                                                                             | `Spec.state`    | -                                                                                                                                                      |
-| <a id="property-viewkey"></a> `viewKey?`  | `readonly` | `string`                          | The identity of the view of this derived spec. `deriveCurrentView` sets it from the meta entry that the derivation selected. A provider uses it as the key of its store lifecycle: a new `viewKey` seeds the store again, and the same `viewKey` refreshes `/context` in place, which keeps the ephemeral view state. Never write this field in `meta.view`. | -               | [packages/play-actor/src/abstract-actor.ts:55](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/abstract-actor.ts#L55) |
+| Property                                  | Modifier   | Type                              | Description                                                                                                                                                                                                                                                                                                                                                  | Inherited from  | Defined in                                                                                                                                   |
+| ----------------------------------------- | ---------- | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-elements"></a> `elements` | `public`   | `Record`\<`string`, `UIElement`\> | Flat map of elements by key                                                                                                                                                                                                                                                                                                                                  | `Spec.elements` | -                                                                                                                                            |
+| <a id="property-root"></a> `root`         | `public`   | `string`                          | Root element key                                                                                                                                                                                                                                                                                                                                             | `Spec.root`     | -                                                                                                                                            |
+| <a id="property-state"></a> `state?`      | `public`   | `Record`\<`string`, `unknown`\>   | Optional initial state to seed the state model. Components using statePath will read from / write to this state.                                                                                                                                                                                                                                             | `Spec.state`    | -                                                                                                                                            |
+| <a id="property-viewkey"></a> `viewKey?`  | `readonly` | `string`                          | The identity of the view of this derived spec. `deriveCurrentView` sets it from the meta entry that the derivation selected. A provider uses it as the key of its store lifecycle: a new `viewKey` seeds the store again, and the same `viewKey` refreshes `/context` in place, which keeps the ephemeral view state. Never write this field in `meta.view`. | -               | [packages/play-view/src/view-types.ts:40](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-types.ts#L40) |

package/api/@xmachines/play-view/index/interfaces/ReportGuard.md

@@ -0,0 +1,92 @@
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / ReportGuard
+
+# Interface: ReportGuard
+
+Defined in: [packages/play-view/src/failure-latch.ts:59](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L59)
+
+A report guard of one provider.
+
+The rule it holds: a provider reports a contained failure to the host, and it must do
+that without letting the host defeat the containment. Two things follow — a reset that
+the host calls from INSIDE the report does nothing, because no input changed between
+the two attempts; and every callback that the provider handed out does nothing once the
+provider is gone, because a host can keep a reset (a "Retry" button of a toast outlives
+the route that opened it).
+
+## Methods
+
+### blocked()
+
+```ts
+blocked(): boolean;
+```
+
+Defined in: [packages/play-view/src/failure-latch.ts:61](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L61)
+
+True when a reset that the host starts must do nothing.
+
+#### Returns
+
+`boolean`
+
+---
+
+### dispose()
+
+```ts
+dispose(): void;
+```
+
+Defined in: [packages/play-view/src/failure-latch.ts:74](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L74)
+
+The provider is gone.
+
+#### Returns
+
+`void`
+
+---
+
+### disposed()
+
+```ts
+disposed(): boolean;
+```
+
+Defined in: [packages/play-view/src/failure-latch.ts:72](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L72)
+
+True once [ReportGuard.dispose](#dispose) ran, and never for a report that runs.
+
+[ReportGuard.blocked](#blocked) answers a different question: it is true for the
+re-entry of a report as well, and it goes back to false when that report ends. A
+caller that asks whether the guard is SPENT — play-react builds one again after the
+cleanup of `<StrictMode>` disposed it — must read this one: `blocked()` there would
+replace a live guard that is reporting, and the `finally` of that report would then
+clear the re-entry flag of a guard that nobody holds.
+
+#### Returns
+
+`boolean`
+
+---
+
+### report()
+
+```ts
+report(error, deliver): void;
+```
+
+Defined in: [packages/play-view/src/failure-latch.ts:86](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L86)
+
+Delivers one report, with the re-entry flag held for the call.
+
+#### Parameters
+
+| Parameter | Type                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| --------- | ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `error`   | `unknown`                     | The contained failure.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `deliver` | (() => `void`) \| `undefined` | The call of the handler of the host, or `undefined` when the host gave none. Without a handler the guard writes [ReportGuardMessages.noHandler](ReportGuardMessages.md#property-nohandler) to `console.error`: a contained failure that reaches no handler and no caller is the one result that nobody can debug. A handler that THROWS is contained where the guard carries [ReportGuardMessages.handlerThrew](ReportGuardMessages.md#property-handlerthrew), and it reaches the caller where it does not. |
+
+#### Returns
+
+`void`

package/api/@xmachines/play-view/index/interfaces/ReportGuardMessages.md

@@ -0,0 +1,18 @@
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / ReportGuardMessages
+
+# Interface: ReportGuardMessages
+
+Defined in: [packages/play-view/src/failure-latch.ts:96](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L96)
+
+What a [ReportGuard](ReportGuard.md) writes to `console.error`, and what it therefore contains.
+
+Each message is optional, and each one is a DECISION of the renderer that builds the
+guard. The rule that both serve is one rule: a contained failure is never silent, and
+a handler of the host never defeats the containment.
+
+## Properties
+
+| Property                                           | Type     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Defined in                                                                                                                                           |
+| -------------------------------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-handlerthrew"></a> `handlerThrew?` | `string` | What `console.error` says when the handler of the host THROWS. A guard that carries this message CONTAINS such a throw. All five renderers carry it, so a host learns one rule: a handler of the host never defeats the containment, and a host that must escalate raises the failure from a task of its own — `queueMicrotask(() => { throw error; })`. Omit it only where a throw must reach the caller, which no renderer of this workspace asks for today. A renderer needs the containment when a throw that leaves the report also stops the screen of the fallback: the flag of play-vue schedules a render, the fallback of play-solid is the RETURN of the callback that reports, `componentDidCatch` of play-react can take the complete React root down, and a throw that leaves the `onerror` of Svelte leaves its own `calling_on_error` flag raised, which makes every later reset of the host raise `svelte_boundary_reset_onerror`. | [packages/play-view/src/failure-latch.ts:120](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L120) |
+| <a id="property-nohandler"></a> `noHandler?`       | `string` | What `console.error` says when the host gave no handler. Omit it where the framework writes such a failure itself: React logs an error that a boundary caught, so play-react would report the same failure two times.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | [packages/play-view/src/failure-latch.ts:103](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L103) |

package/api/@xmachines/{play-actor → play-view/index}/interfaces/ResolveViewStoreOptions.md

@@ -1,11 +1,11 @@
-[API](../../../README.md) / [@xmachines/play-actor](../README.md) / ResolveViewStoreOptions
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / ResolveViewStoreOptions
 
 # Interface: ResolveViewStoreOptions
 
-Defined in: [packages/play-actor/src/view-store-lifecycle.ts:57](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/view-store-lifecycle.ts#L57)
+Defined in: [packages/play-view/src/view-store-lifecycle.ts:57](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-store-lifecycle.ts#L57)
 
 ## Properties
 
-| Property                                                           | Type      | Description                                                                                                                                                                                                                                                                    | Defined in                                                                                                                                                         |
-| ------------------------------------------------------------------ | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| <a id="property-refreshexternalstore"></a> `refreshExternalStore?` | `boolean` | The controlled mode only: refresh the /context subtree of the external store during this resolve. The default is true. Give false where the call site permits no notification of the store subscribers, which is the render path of React, and refresh from an effect instead. | [packages/play-actor/src/view-store-lifecycle.ts:64](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/view-store-lifecycle.ts#L64) |
+| Property                                                           | Type      | Description                                                                                                                                                                                                                                                                    | Defined in                                                                                                                                                       |
+| ------------------------------------------------------------------ | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-refreshexternalstore"></a> `refreshExternalStore?` | `boolean` | The controlled mode only: refresh the /context subtree of the external store during this resolve. The default is true. Give false where the call site permits no notification of the store subscribers, which is the render path of React, and refresh from an effect instead. | [packages/play-view/src/view-store-lifecycle.ts:64](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-store-lifecycle.ts#L64) |

package/api/@xmachines/play-view/index/interfaces/ViewInputs.md

@@ -0,0 +1,19 @@
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / ViewInputs
+
+# Interface: ViewInputs
+
+Defined in: [packages/play-view/src/failure-latch.ts:33](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L33)
+
+The three inputs that a provider resolves a store from.
+
+`ViewStoreLifecycle.resolve` takes exactly these, and every provider names all three in
+its reset rule. The type gives the rule one name, so the comparison below stands one
+time instead of once for each renderer that needs it.
+
+## Properties
+
+| Property                            | Type      | Defined in                                                                                                                                         |
+| ----------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-actor"></a> `actor` | `unknown` | [packages/play-view/src/failure-latch.ts:34](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L34) |
+| <a id="property-store"></a> `store` | `unknown` | [packages/play-view/src/failure-latch.ts:36](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L36) |
+| <a id="property-view"></a> `view`   | `unknown` | [packages/play-view/src/failure-latch.ts:35](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L35) |

package/api/@xmachines/{play-actor → play-view/index}/interfaces/ViewStoreLifecycle.md

@@ -1,8 +1,8 @@
-[API](../../../README.md) / [@xmachines/play-actor](../README.md) / ViewStoreLifecycle
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / ViewStoreLifecycle
 
 # Interface: ViewStoreLifecycle
 
-Defined in: [packages/play-actor/src/view-store-lifecycle.ts:67](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/view-store-lifecycle.ts#L67)
+Defined in: [packages/play-view/src/view-store-lifecycle.ts:67](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-store-lifecycle.ts#L67)
 
 ## Methods
 
@@ -12,7 +12,7 @@ Defined in: [packages/play-actor/src/view-store-lifecycle.ts:67](https://gitlab.
 reset(): void;
 ```
 
-Defined in: [packages/play-actor/src/view-store-lifecycle.ts:84](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/view-store-lifecycle.ts#L84)
+Defined in: [packages/play-view/src/view-store-lifecycle.ts:84](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-store-lifecycle.ts#L84)
 
 Drops everything, on an unmount or a disconnect. The next resolve makes a new seed.
 
@@ -29,10 +29,11 @@ resolve(
    actor,
    view,
    externalStore?,
-   options?): ViewStoreResolution;
+   options?
+): ViewStoreResolution;
 ```
 
-Defined in: [packages/play-actor/src/view-store-lifecycle.ts:77](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/view-store-lifecycle.ts#L77)
+Defined in: [packages/play-view/src/view-store-lifecycle.ts:77](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-store-lifecycle.ts#L77)
 
 Brings the store in line with an emission, and returns it with its guard.
 

package/api/@xmachines/{play-actor → play-view/index}/interfaces/ViewStoreResolution.md

@@ -1,15 +1,15 @@
-[API](../../../README.md) / [@xmachines/play-actor](../README.md) / ViewStoreResolution
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / ViewStoreResolution
 
 # Interface: ViewStoreResolution
 
-Defined in: [packages/play-actor/src/view-store-lifecycle.ts:38](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/view-store-lifecycle.ts#L38)
+Defined in: [packages/play-view/src/view-store-lifecycle.ts:38](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-store-lifecycle.ts#L38)
 
 The result of a resolve — see [ViewStoreLifecycle.resolve](ViewStoreLifecycle.md#resolve).
 
 ## Properties
 
-| Property                                          | Type         | Description                                                                                                                                                                                                                                                                       | Defined in                                                                                                                                                         |
-| ------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| <a id="property-guardedstore"></a> `guardedStore` | `StateStore` | The store to give to the children ($bindState, setState, and a chained set): a write under /context throws. There is one wrapper for each store below it, and the code caches the identity. Therefore a consumer in the style of `useSyncExternalStore` stays stable.             | [packages/play-actor/src/view-store-lifecycle.ts:47](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/view-store-lifecycle.ts#L47) |
-| <a id="property-reseeded"></a> `reseeded`         | `boolean`    | It is true when this resolve made a new store: at the first resolve, on a change of the viewKey, in the fallback for each emission, and on a change of the actor. A provider that mounts a subtree again for each store, such as the storeKey of Vue, uses this field as its key. | [packages/play-actor/src/view-store-lifecycle.ts:54](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/view-store-lifecycle.ts#L54) |
-| <a id="property-store"></a> `store`               | `StateStore` | The store WITHOUT the guard — the reference of the machinery for its own refresh.                                                                                                                                                                                                 | [packages/play-actor/src/view-store-lifecycle.ts:40](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/view-store-lifecycle.ts#L40) |
+| Property                                          | Type         | Description                                                                                                                                                                                                                                                                       | Defined in                                                                                                                                                       |
+| ------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-guardedstore"></a> `guardedStore` | `StateStore` | The store to give to the children ($bindState, setState, and a chained set): a write under /context throws. There is one wrapper for each store below it, and the code caches the identity. Therefore a consumer in the style of `useSyncExternalStore` stays stable.             | [packages/play-view/src/view-store-lifecycle.ts:47](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-store-lifecycle.ts#L47) |
+| <a id="property-reseeded"></a> `reseeded`         | `boolean`    | It is true when this resolve made a new store: at the first resolve, on a change of the viewKey, in the fallback for each emission, and on a change of the actor. A provider that mounts a subtree again for each store, such as the storeKey of Vue, uses this field as its key. | [packages/play-view/src/view-store-lifecycle.ts:54](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-store-lifecycle.ts#L54) |
+| <a id="property-store"></a> `store`               | `StateStore` | The store WITHOUT the guard — the reference of the machinery for its own refresh.                                                                                                                                                                                                 | [packages/play-view/src/view-store-lifecycle.ts:40](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-store-lifecycle.ts#L40) |

package/api/@xmachines/{play-actor → play-view/index}/interfaces/Viewable.md

@@ -1,8 +1,8 @@
-[API](../../../README.md) / [@xmachines/play-actor](../README.md) / Viewable
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / Viewable
 
 # Interface: Viewable
 
-Defined in: [packages/play-actor/src/abstract-actor.ts:103](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/abstract-actor.ts#L103)
+Defined in: [packages/play-view/src/view-types.ts:88](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-types.ts#L88)
 
 The actor capability that exposes a renderable view state.
 
@@ -13,6 +13,6 @@ therefore holds no view logic.
 
 ## Properties
 
-| Property                                        | Modifier   | Type                                                                                                    | Description                                                                                                                                                                                                 | Defined in                                                                                                                                               |
-| ----------------------------------------------- | ---------- | ------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-currentview"></a> `currentView` | `readonly` | [`State`](../../play-signals/namespaces/Signal/classes/State.md)\<[`PlaySpec`](PlaySpec.md) \| `null`\> | The signal of the current view. It holds the json-render PlaySpec of the current machine state, or null when no view is active. The infrastructure renders the view. This is the Logic-Driven UI invariant. | [packages/play-actor/src/abstract-actor.ts:110](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/abstract-actor.ts#L110) |
+| Property                                        | Modifier   | Type                                                                                                       | Description                                                                                                                                                                                                 | Defined in                                                                                                                                   |
+| ----------------------------------------------- | ---------- | ---------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-currentview"></a> `currentView` | `readonly` | [`State`](../../../play-signals/namespaces/Signal/classes/State.md)\<[`PlaySpec`](PlaySpec.md) \| `null`\> | The signal of the current view. It holds the json-render PlaySpec of the current machine state, or null when no view is active. The infrastructure renders the view. This is the Logic-Driven UI invariant. | [packages/play-view/src/view-types.ts:95](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-types.ts#L95) |

package/api/@xmachines/play-view/index/type-aliases/ViewActor.md

@@ -0,0 +1,26 @@
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / ViewActor
+
+# Type Alias: ViewActor\<TSnapshot, TEvent\>
+
+```ts
+type ViewActor<TSnapshot, TEvent> = PlayActor<TSnapshot, TEvent> & Viewable;
+```
+
+Defined in: [packages/play-view/src/view-types.ts:135](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/view-types.ts#L135)
+
+The actor that a view provider reads: the contract, and the view capability.
+
+It names NO engine. A provider reads `currentView` and `send`, and nothing else — the
+measurement is 20 reads of `currentView` and 16 of `send` across the five renderers, and
+no read of any other member. The type said `ViewActor`
+before, which named XState in every renderer AND erased the snapshot and the event union
+of the machine at the same time.
+
+It does NOT name `Routable`. The view implies no routing.
+
+## Type Parameters
+
+| Type Parameter                                                                  | Default type                                                 | Description                           |
+| ------------------------------------------------------------------------------- | ------------------------------------------------------------ | ------------------------------------- |
+| `TSnapshot`                                                                     | `unknown`                                                    | The snapshot type that `state` holds. |
+| `TEvent` _extends_ [`ActorEvent`](../../../play-actor/interfaces/ActorEvent.md) | [`ActorEvent`](../../../play-actor/interfaces/ActorEvent.md) | The event union that `send` accepts.  |

package/api/@xmachines/{play-actor → play-view/index}/variables/CONTEXT_STATE_KEY.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-actor](../README.md) / CONTEXT\_STATE\_KEY
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / CONTEXT\_STATE\_KEY
 
 # Variable: CONTEXT\_STATE\_KEY
 
@@ -6,7 +6,7 @@
 const CONTEXT_STATE_KEY: "context" = "context";
 ```
 
-Defined in: [packages/play-actor/src/context-projection.ts:32](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-actor/src/context-projection.ts#L32)
+Defined in: [packages/play-view/src/context-projection.ts:34](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/context-projection.ts#L34)
 
 The reserved top-level state key of the projection.
 

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

@@ -4,7 +4,7 @@
 
 > Vue 3 renderer for the XMachines Play Architecture. It observes the actor signals and renders the UI through `@xmachines/json-render-vue`.
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-2.2.0-blue)](https://www.npmjs.com/package/@xmachines/play-vue)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-4.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-vue)
 
 ---
 
@@ -29,7 +29,7 @@ pnpm add @xmachines/play-vue
 **Peer dependencies.** Install them with the package:
 
 ```bash
-pnpm add vue@^3.5.0 xstate@^5.31.0 @xstate/store@^3.17.0 @xmachines/json-render-vue@^0.20.0-xm.2 @xmachines/json-render-core@^0.20.0-xm.2 @xmachines/json-render-xstate@^0.20.0-xm.2
+pnpm add vue@^3.5.0 @xstate/store@^3.17.0 @xmachines/json-render-vue@^0.20.0-xm.4 @xmachines/json-render-core@^0.20.0-xm.4 @xmachines/json-render-xstate@^0.20.0-xm.4
 ```
 
 ---
@@ -46,13 +46,15 @@ pnpm add vue@^3.5.0 xstate@^5.31.0 @xstate/store@^3.17.0 @xmachines/json-render-
 
 <script setup lang="ts">
 import { defineRegistry, PlayUIProvider, PlayRenderer } from "@xmachines/play-vue";
-import { definePlayer } from "@xmachines/play-xstate";
+import { definePlayer, compose, PlayerActor } from "@xmachines/play-xstate";
+import { withView } from "@xmachines/play-xstate/view";
 import { myMachine } from "./machine.js";
 import { myCatalog } from "./catalog.js";
 import HomeSFC from "./views/Home.vue";
 import LoginSFC from "./views/Login.vue";
 
-const createPlayer = definePlayer({ machine: myMachine });
+// A renderer needs the view capability
+const createPlayer = definePlayer({ machine: myMachine, actor: compose(PlayerActor, withView) });
 const actor = createPlayer();
 actor.start();
 
@@ -79,17 +81,32 @@ const registryResult = defineRegistry(myCatalog, {
 
 The composite provider. It wraps `<ActorProvider>` and `JSONUIProvider` in one component. **Use it in most applications.**
 
-| Prop                  | Type                       | Required | Description                                 |
-| --------------------- | -------------------------- | -------- | ------------------------------------------- |
-| `actor`               | `AbstractActor & Viewable` | ✅       | The XMachines actor instance                |
-| `registryResult`      | `DefineRegistryResult`     | ✅       | Result of `defineRegistry()`                |
-| `store`               | `StateStore`               | —        | External controlled state store (optional)  |
-| `onRenderError`       | `RenderErrorHandler`       | —        | Error handler for render failures           |
-| `navigate`            | `(path: string) => void`   | —        | Link navigation function                    |
-| `validationFunctions` | `Record<string, Function>` | —        | Custom validation functions                 |
-| `functions`           | `Record<string, Function>` | —        | Named functions for `$computed` expressions |
+| Prop                  | Type                                          | Required | Description                                                            |
+| --------------------- | --------------------------------------------- | -------- | ---------------------------------------------------------------------- |
+| `actor`               | `PlayActor & Viewable`                        | ✅       | The XMachines actor instance                                           |
+| `registryResult`      | `DefineRegistryResult`                        | ✅       | Result of `defineRegistry()`                                           |
+| `store`               | `StateStore`                                  | —        | External controlled state store (optional)                             |
+| `onRenderError`       | `RenderErrorHandler`                          | —        | Error handler for render failures                                      |
+| `onError`             | `(error: unknown, reset: () => void) => void` | —        | Error handler of the outer boundary; the second parameter is the reset |
+| `navigate`            | `(path: string) => void`                      | —        | Link navigation function                                               |
+| `validationFunctions` | `Record<string, Function>`                    | —        | Custom validation functions                                            |
+| `functions`           | `Record<string, Function>`                    | —        | Named functions for `$computed` expressions                            |
 
-**Slots:** `default` (the rendered content), `fallback` (the content while the actor view is `null`)
+**Slots:** `default` (the rendered content), `fallback` (the content while the actor view is `null`, and while the boundary holds an error)
+
+The provider contains an error of the **render** of a descendant — the render function, the setup function, and a lifecycle hook — so that a subtree that throws cannot take the whole application down. It calls `onError`, and it renders the `fallback` slot instead of the children. The next view emission clears the error, so a view transition retries the render. A throw of a catalog component reaches the per-element boundary of `@xmachines/json-render-vue` first, and `onRenderError` reports it; this boundary is the outer net for everything else.
+
+The boundary stops a render error, so `app.config.errorHandler` sees it no longer. Without an `onError` prop the provider therefore writes the error to `console.error`.
+
+The second parameter is the **reset**, for a retry that the host starts. It renders the view that the actor holds at the moment of the call, so a retry cannot rewind the screen to the view that failed. A reset that the host calls from inside the handler does nothing, because no input changed between the two attempts, and a reset after the provider goes away does nothing. The five renderers hold the same three rules.
+
+**A handler that throws reaches no caller.** The provider contains that throw, and it writes the throw to `console.error`. The errored flag schedules a render, so a throw that left the handler would stop that render and skip the `return false` of `onErrorCaptured`: the subtree that threw stays on the screen and the error reaches `app.config.errorHandler` as well. Report a failure from `onError`. To escalate one, raise it from a task of your own — `queueMicrotask(() => { throw error; })` — which reaches the global handler of the page and leaves the containment whole. The five renderers hold this one rule.
+
+`onErrorCaptured` of Vue also fires for an error of an **event handler** and of a **watcher callback**, which the boundaries of React, Solid, and Svelte each see never. The provider leaves such an error alone: the view stays on the screen, `onError` stays silent, and the error continues to `app.config.errorHandler` exactly as it does without this provider. A click handler that throws therefore does not replace your view with the fallback, and it reaches your global handler one time. `onError` reports a failure of the render, in every renderer.
+
+Vue reports such an error a **second** time where the application wires no `app.config.errorHandler`: it re-throws the error, and a queued job carries it back as a failure of a render. The provider recognises that repeat and holds the view. It writes the error value to `console.error` with the name of this package, because Vue writes that value nowhere on this path, and `onError` stays silent. A development build re-throws every time, and a production build only where the application sets `app.config.throwUnhandledErrorInProduction`.
+
+**One case escapes that rule.** An ancestor `errorCaptured` hook that returns `false` stops Vue before the re-throw, so the record of the provider waits for a repeat that never comes. A second failure in the same flush can take that record. It must carry the same error value, and it must unwind out of the update job of a parent. Vue reports such a failure as a component update. The provider then holds the stale subtree on the screen, and `onError` stays silent.
 
 #### `<PlayRenderer>`
 
@@ -105,12 +122,12 @@ The leaf component without props. It reads the current `spec` and `registry` fro
 
 The low-level provider for a custom provider composition. It owns the complete actor lifecycle: the signal subscription, the state store of each view, the handler resolution, and the Vue context. Use `<PlayUIProvider>` when you do not need this control.
 
-| Prop             | Type                       | Required | Description                     |
-| ---------------- | -------------------------- | -------- | ------------------------------- |
-| `actor`          | `AbstractActor & Viewable` | ✅       | The XMachines actor instance    |
-| `registryResult` | `DefineRegistryResult`     | ✅       | Result of `defineRegistry()`    |
-| `store`          | `StateStore`               | —        | External controlled state store |
-| `onRenderError`  | `RenderErrorHandler`       | —        | Override render error handler   |
+| Prop             | Type                   | Required | Description                     |
+| ---------------- | ---------------------- | -------- | ------------------------------- |
+| `actor`          | `PlayActor & Viewable` | ✅       | The XMachines actor instance    |
+| `registryResult` | `DefineRegistryResult` | ✅       | Result of `defineRegistry()`    |
+| `store`          | `StateStore`           | —        | External controlled state store |
+| `onRenderError`  | `RenderErrorHandler`   | —        | Override render error handler   |
 
 ---
 
@@ -169,7 +186,14 @@ const view = usePlayView();
 // view.spec, view.handlers, view.registry, view.store
 ```
 
-> **Note:** `usePlayView` was previously named `getPlayViewContext`. The old name is still exported as a deprecated alias and will be removed in the next major.
+> **Read a field where you use it, and destructure it not.** The value is a live view of
+> the provider, so `const { spec } = usePlayView()` freezes at the first read and the
+> screen stops following the actor — with no error and no warning. Write `view.spec` at
+> the place that needs it.
+
+`usePlayView()` returns a **Proxy**: every property read goes to the live context of the provider.
+
+> **Note:** `usePlayView` was named `getPlayViewContext` before. That alias is gone.
 
 ---
 
@@ -185,25 +209,6 @@ This package re-exports the following, so that a consumer imports everything fro
 
 ---
 
-## Testing
-
-Run tests for this package in isolation:
-
-```bash
-# From the monorepo root
-pnpm --filter @xmachines/play-vue test
-
-# Watch mode
-pnpm --filter @xmachines/play-vue run test:watch
-
-# With coverage (80% threshold enforced on lines, functions, branches, statements)
-pnpm exec vitest run --coverage --config packages/play-vue/vitest.config.ts
-```
-
-The tests use [Vitest](https://vitest.dev/) in a `jsdom` environment. They mount the components with `@vue/test-utils`.
-
----
-
 ## License
 
 MIT — see [LICENSE](LICENSE).
@@ -231,7 +236,6 @@ everything from `@xmachines/play-vue`, and not from `@xmachines/json-render-vue`
 - [StateProviderProps](interfaces/StateProviderProps.md)
 - [ValidationProviderProps](interfaces/ValidationProviderProps.md)
 - [ViewContextValue](interfaces/ViewContextValue.md)
-- [~~VisibilityProviderProps~~](interfaces/VisibilityProviderProps.md)
 
 ## Type Aliases
 
@@ -245,10 +249,10 @@ everything from `@xmachines/play-vue`, and not from `@xmachines/json-render-vue`
 ## Variables
 
 - [ActionProvider](variables/ActionProvider.md)
-- [~~getPlayViewContext~~](variables/getPlayViewContext.md)
 - [JSONUIProvider](variables/JSONUIProvider.md)
 - [PlayRenderer](variables/PlayRenderer.md)
 - [Renderer](variables/Renderer.md)
+- [schema](variables/schema.md)
 - [StateProvider](variables/StateProvider.md)
 - [ValidationProvider](variables/ValidationProvider.md)
 - [VisibilityProvider](variables/VisibilityProvider.md)

package/api/@xmachines/play-vue/functions/defineRegistry.md

@@ -6,7 +6,7 @@
 function defineRegistry<C>(catalog, options): DefineRegistryResult;
 ```
 
-Defined in: [packages/play-vue/src/define-registry.ts:138](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-vue/src/define-registry.ts#L138)
+Defined in: [packages/play-vue/src/define-registry.ts:138](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-vue/src/define-registry.ts#L138)
 
 Creates a component registry. It wraps each `.vue` SFC, so that the SFC works
 correctly with the render pipeline of `@xmachines/json-render-vue`.

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

@@ -6,7 +6,7 @@
 function useActor(): AnyPlayActor;
 ```
 
-Defined in: [packages/play-vue/src/useActor.ts:64](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-vue/src/useActor.ts#L64)
+Defined in: [packages/play-vue/src/useActor.ts:71](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-vue/src/useActor.ts#L71)
 
 ## Returns
 

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

@@ -6,7 +6,7 @@
 function usePlayView(): ViewContextValue;
 ```
 
-Defined in: [packages/play-vue/src/actor-provider-context.ts:46](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-vue/src/actor-provider-context.ts#L46)
+Defined in: [packages/play-vue/src/actor-provider-context.ts:51](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-vue/src/actor-provider-context.ts#L51)
 
 Returns the current ViewContextValue inside an ActorProvider tree.
 
@@ -26,3 +26,8 @@ import { usePlayView } from "@xmachines/play-vue";
 const view = usePlayView();
 // view.spec, view.handlers, view.registry
 ```
+
+**Read a field where you use it, and destructure it not.** The return value is a Proxy
+over the live context of the provider, so `const { spec } = usePlayView()` freezes at
+the first read and the screen stops following the actor — with no error and no
+warning. play-svelte and play-solid hold the same rule, for the same reason.