@xmachines/docs 1.0.0-beta.46 → 1.0.0-beta.48

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

@@ -1,359 +1,214 @@
 [API](../../README.md) / @xmachines/play-vue
 
-# @xmachines/play-vue
+<!-- generated-by: gsd-doc-writer -->
 
-**Vue 3 renderer for XMachines Play Architecture**
+# `@xmachines/play-vue`
 
-Bridges TC39 Signal-driven actors to Vue's reactivity. Business logic stays in the actor; Vue is purely a rendering target.
+> Vue 3 renderer for the XMachines Play Architecture — passively observes actor signals and renders UI via `@json-render/vue`.
+
+Part of the [XMachines Play monorepo](../../README.md).
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Version](https://img.shields.io/badge/version-1.0.0--beta.46-blue.svg)](package.json)
+
+---
 
 ## Overview
 
-`@xmachines/play-vue` provides `PlayRenderer`, a Vue component that:
+`@xmachines/play-vue` is the Vue 3 rendering layer for XMachines Play. It bridges TC39 Signals (actor state) to Vue reactivity and drives component rendering through `@json-render/vue`.
 
-- Subscribes to `actor.currentView` (TC39 Signal) and re-renders on every state transition
-- Renders the current view's JSON spec via `@json-render/vue`
-- Routes action names from spec elements to `actor.send()` via the `actions` prop
-- Manages per-view UI state in an `@xstate/store` atom (automatic or caller-supplied)
+**Architecture invariants this package upholds:**
 
-Per [Play RFC](../../../rfc/play.md):
+- **Passive Infrastructure** — Components observe actor signals; they never decide state transitions.
+- **Signal-Only Reactivity** — TC39 Signals are the source of truth; Vue reactivity is used only to trigger re-renders.
+- **Actor Authority** — The actor controls view selection; the renderer reflects it.
 
-- **Actor Authority (INV-01):** Guards in the machine decide all state transitions
-- **Passive Infrastructure (INV-04):** Vue observes signals and dispatches events — never decides
-- **Signal-Only Reactivity (INV-05):** `actor.currentView` signal is the sole render trigger
+---
 
 ## Installation
 
 ```bash
 npm install @xmachines/play-vue
-npm install @json-render/vue @json-render/core    # peer deps
-npm install @json-render/xstate @xstate/store     # store integration
 ```
 
-In this monorepo, the root install applies a `patch-package` patch to `@json-render/vue`
-so `defineRegistry(..., { onRenderError })` can intercept inner element-boundary errors
-without muting console output.
-
-## Current Exports
-
-- `PlayRenderer` — main renderer component (Vue SFC)
-- `useActor` — composable for accessing the actor inside a `PlayRenderer` tree
-- `defineRegistry` — SFC-aware wrapper; auto-wraps `.vue` SFCs via `h(SFC, ctx)`
-- `useBoundProp` — re-exported from `@json-render/vue`
-- `ComponentFn` (type) — re-exported from `@json-render/vue`
-- `ComponentContext` (type) — re-exported from `@json-render/vue`
-- `ActorProvider` — escape hatch primitive (owns actor bridging, signal bridge, store lifecycle)
-- `PlayUIProvider` — batteries-included composite (wraps `ActorProvider` + `JSONUIProvider`)
-- `getPlayViewContext` — composable for accessing the current view spec inside a provider tree
-- `RenderErrorHandler` (type) — inner per-element error callback signature
-- `ActorProviderProps` (type)
-- `ViewContextValue` (type)
-- `PlayActor` (type)
-
-## Quick Start
-
-```ts
-// catalog.ts — shared contract
-import { defineCatalog } from "@json-render/core";
-import { z } from "zod";
-
-export const catalog = defineCatalog({
-	elements: {
-		Login: { props: z.object({ title: z.string() }), description: "Login form" },
-		Dashboard: { props: z.object({ username: z.string() }), description: "Dashboard" },
-	},
-});
+**Peer dependencies** (install alongside):
 
-export type Catalog = typeof catalog;
+```bash
+npm install vue@^3.5.0 xstate@^5.30.0 @xstate/store@^3.17.0 @json-render/vue@^0.18.0 @json-render/core@^0.18.0 @json-render/xstate@^0.18.0
 ```
 
-```vue
-<!-- Login.vue — Vue SFC; useBoundProp works in <script setup> -->
-<script setup lang="ts">
-import { useBoundProp } from "@xmachines/play-vue";
-import type { ComponentContext } from "@xmachines/play-vue";
-import type { Catalog } from "./catalog.js";
+---
 
-const { props, emit, bindings } = defineProps<ComponentContext<Catalog, "Login">>();
-const [username, setUsername] = useBoundProp<string>(bindings?.username ?? "/username");
-</script>
+## Quick Start
 
+```vue
+<!-- App.vue -->
 <template>
-	<div class="view">
-		<h2>{{ props.title }}</h2>
-		<form @submit.prevent="emit('submit')">
-			<input id="username" v-model="username" @input="setUsername(username)" />
-			<button type="submit">Log In</button>
-		</form>
-	</div>
+	<PlayUIProvider :actor="actor" :registryResult="registryResult">
+		<PlayRenderer />
+	</PlayUIProvider>
 </template>
-```
-
-```ts
-// registry.ts — pass SFCs directly; defineRegistry auto-wraps them
-import { defineRegistry } from "@xmachines/play-vue";
-import { catalog } from "./catalog.js";
-import LoginSFC from "./Login.vue";
-import DashboardSFC from "./Dashboard.vue";
-
-export const registryResult = defineRegistry(catalog, {
-	components: { Login: LoginSFC, Dashboard: DashboardSFC },
-	actions: {
-		login: async (params) => {
-			if (!params) return;
-			actor.send({ type: "auth.login", username: params.username });
-		},
-		logout: async (params) => {
-			actor.send({ type: "auth.logout" });
-		},
-	},
-});
-```
-
-```ts
-// machine.ts
-import { setup, assign } from "xstate";
-import { formatPlayRouteTransitions } from "@xmachines/play-xstate";
-
-export const machine = setup({
-	types: {
-		context: {} as {
-			isAuthenticated: boolean;
-			username: string | null;
-			params: Record<string, string>;
-			query: Record<string, string>;
-		},
-		events: {} as
-			| { type: "auth.login"; username: string }
-			| { type: "auth.logout" }
-			| { type: "play.route"; to: string; params?: Record<string, string> },
-	},
-}).createMachine(
-	formatPlayRouteTransitions({
-		id: "app",
-		initial: "login",
-		context: { isAuthenticated: false, username: null, params: {}, query: {} },
-		states: {
-			login: {
-				id: "login",
-				meta: {
-					route: "/login",
-					view: {
-						root: "root",
-						elements: {
-							root: { type: "Login", props: { title: "Sign In" }, children: [] },
-						},
-					},
-				},
-			},
-			dashboard: {
-				id: "dashboard",
-				meta: {
-					route: "/dashboard",
-					view: {
-						root: "root",
-						elements: {
-							root: { type: "Dashboard", props: { username: "" }, children: [] },
-						},
-					},
-				},
-			},
-		},
-		on: {
-			"auth.login": {
-				target: ".dashboard",
-				guard: ({ context }) => !context.isAuthenticated,
-				actions: assign({ isAuthenticated: true, username: ({ event }) => event.username }),
-			},
-			"auth.logout": {
-				target: ".login",
-				guard: ({ context }) => context.isAuthenticated,
-				actions: assign({ isAuthenticated: false, username: null }),
-			},
-		},
-	}),
-);
-```
 
-```vue
-<!-- App.vue -->
 <script setup lang="ts">
+import { defineRegistry, PlayUIProvider, PlayRenderer } from "@xmachines/play-vue";
 import { definePlayer } from "@xmachines/play-xstate";
-import { PlayUIProvider, PlayRenderer } from "@xmachines/play-vue";
-import { machine } from "./machine.js";
-import { registryResult } from "./registry.js";
+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 });
+const createPlayer = definePlayer({ machine: myMachine });
 const actor = createPlayer();
 actor.start();
-</script>
 
-<template>
-	<PlayUIProvider :actor="actor" :registryResult="registryResult">
-		<PlayRenderer />
-	</PlayUIProvider>
-</template>
+const registryResult = defineRegistry(myCatalog, {
+	components: {
+		Home: HomeSFC, // .vue SFCs are auto-wrapped
+		Login: LoginSFC,
+	},
+	actions: {
+		login: async (args) => actor.send({ type: "auth.login", ...args }),
+		logout: async () => actor.send({ type: "auth.logout" }),
+	},
+});
+</script>
 ```
 
-## API Reference
-
-### `PlayUIProvider`
+---
 
-Batteries-included composite provider. Wraps `ActorProvider` + `JSONUIProvider`. Pass `actor` and `registryResult` here, then place `<PlayRenderer />` inside as a zero-prop child.
+## API Summary
 
-```vue
-<PlayUIProvider
-	:actor="actor"
-	:registryResult="registryResult"
-	:store="myStore"
-	:onRenderError="(error, elementType) => console.warn(`<${elementType}> crashed:`, error)"
->
-	<template #fallback><p>Something went wrong.</p></template>
-	<PlayRenderer />
-</PlayUIProvider>
-```
+### Components
 
-**`actor`** — A `PlayerActor` (or any `AbstractActor & Viewable`). Provides the `currentView` signal.
+#### `<PlayUIProvider>`
 
-**`registryResult`** — The full `DefineRegistryResult` returned by `defineRegistry(catalog, { components, actions })` from.
+Batteries-included composite provider. Wraps `<ActorProvider>` and `JSONUIProvider` in one component. **Recommended for most apps.**
 
-**`store`** (optional) — Controls per-view UI state (`$state` bindings, form values):
+| 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 |
 
-- **Omitted (uncontrolled, default):** A fresh `@xstate/store` atom is created per view transition, seeded from `view.spec.state`.
-- **Provided (controlled):** The caller owns the store; `spec.state` is ignored.
+**Slots:** `default` (rendered content), `fallback` (shown while actor view is `null`)
 
-```ts
-import { createAtom } from "@xstate/store";
-import { xstateStoreStateStore } from "@json-render/xstate";
-import type { StateStore } from "@json-render/core";
+#### `<PlayRenderer>`
 
-const store: StateStore = xstateStoreStateStore({ atom: createAtom({ username: "" }) });
-```
+Zero-prop leaf component. Reads the current `spec` and `registry` from the nearest `<ActorProvider>` or `<PlayUIProvider>` context and renders via `<Renderer>`. Must be placed inside one of those providers.
 
 ```vue
-<PlayUIProvider :actor="actor" :registryResult="registryResult" :store="store">
-	<PlayRenderer />
+<PlayUIProvider :actor="actor" :registryResult="registryResult">
+  <PlayRenderer />
 </PlayUIProvider>
 ```
 
-**`onRenderError`** — Called when an individual catalog component throws during render. Caught by `@json-render/vue`'s inner per-element error boundary — the failed component is silently removed while the rest of the spec continues rendering. When both `onRenderError` on `PlayUIProvider` and on `defineRegistry` are set, the prop wins.
+#### `<ActorProvider>`
 
----
+Low-level escape hatch for custom provider composition. Owns the full actor lifecycle — signal subscription, per-view state store, handler resolution, and Vue context provision. Use `<PlayUIProvider>` unless you need fine-grained control.
 
-### `ActorProvider`
+| 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   |
 
-Escape hatch primitive. Owns actor bridging, signal bridge, and store lifecycle. Use this when you need direct control over the provider layer.
+---
 
-```vue
-<ActorProvider :actor="actor" :registryResult="registryResult" :onRenderError="handleError">
-	<!-- your own JSONUIProvider + PlayRenderer tree -->
-</ActorProvider>
-```
+### Functions
 
----
+#### `defineRegistry(catalog, options)`
 
-### `PlayRenderer`
+Drop-in replacement for `defineRegistry` from `@json-render/vue`. **Always import from `@xmachines/play-vue`** rather than `@json-render/vue` when working with Vue SFCs — this wrapper automatically detects `.vue` SFCs in the `components` map and wraps them via `h()` so Vue composables (including `inject`-based ones) work correctly inside `<script setup>`.
 
-Zero-prop leaf component. Must be rendered inside a `PlayUIProvider` (or `ActorProvider`) tree. Subscribes to `actor.currentView` via context and renders the current spec.
+```typescript
+import { defineRegistry } from "@xmachines/play-vue";
+// NOT: import { defineRegistry } from "@json-render/vue"
 
-```vue
-<PlayUIProvider :actor="actor" :registryResult="registryResult">
-	<PlayRenderer />
-</PlayUIProvider>
-```
+import LoginSFC from "./views/Login.vue";
+import DashboardSFC from "./views/Dashboard.vue";
 
-`PlayRenderer` accepts no props — all configuration (`actor`, `registryResult`, `store`, `fallback`, `onRenderError`) is provided by the enclosing `PlayUIProvider` or `ActorProvider`.
+const registryResult = defineRegistry(catalog, {
+	components: {
+		Login: LoginSFC, // .vue SFC — auto-wrapped via h()
+		Dashboard: DashboardSFC,
+	},
+	actions: {
+		login: async (args, setState, getState) => {
+			/* ... */
+		},
+	},
+});
+```
 
-## Error handling
+Plain `ComponentFn` functions (non-SFC) also work and are passed through unchanged. Mixing SFCs and plain functions in the same registry is supported.
 
-The provider tree has two layers of error boundaries:
+#### `useActor()`
 
-### Outer boundary — `fallback` slot
+Vue composable for accessing the raw actor inside a `PlayRenderer` tree. Avoids prop drilling for deeply nested components.
 
-Vue's `onErrorCaptured` wraps the entire renderer. Triggered when the spec or store setup throws, or when the inner boundary is not present. Use Vue's built-in `onErrorCaptured` in a parent component for observability.
+```typescript
+import { useActor } from "@xmachines/play-vue";
 
-```vue
-<PlayUIProvider :actor="actor" :registryResult="registryResult">
-	<template #fallback>
-		<p>Something went wrong.</p>
-	</template>
-	<PlayRenderer />
-</PlayUIProvider>
+// Inside a component rendered by PlayRenderer:
+const actor = useActor();
+actor.send({ type: "SUBMIT" });
 ```
 
-### Inner boundary — `onRenderError`
+Throws if called outside an `<ActorProvider>` or `<PlayUIProvider>` tree.
 
-Each catalog element is individually wrapped in an error boundary by `@json-render/vue`. When a component throws, it is silently removed while the rest of the spec continues rendering. The outer boundary is **not** triggered.
+#### `getPlayViewContext()`
 
-Pass `onRenderError` to `PlayUIProvider` (or `ActorProvider`) — overrides any registry-level handler — or bake it into `defineRegistry`:
+Access the current `ViewContextValue` — `{ spec, handlers, registry, store }` — from inside an `<ActorProvider>` tree.
 
-```vue
-<!-- via PlayUIProvider prop -->
-<PlayUIProvider
-	:actor="actor"
-	:registryResult="registryResult"
-	:onRenderError="(error, elementType) => console.warn(`<${elementType}> crashed:`, error)"
->
-	<PlayRenderer />
-</PlayUIProvider>
-```
+```typescript
+import { getPlayViewContext } from "@xmachines/play-vue";
 
-```ts
-// via defineRegistry — bakes the handler into the registry
-const registryResult = defineRegistry(catalog, {
-	components: { Login: LoginSFC, Dashboard: DashboardSFC },
-	actions: { login: async (params) => { ... }, logout: async () => { ... } },
-	onRenderError(error, elementType) {
-		reportExpectedRenderError(error, elementType);
-	},
-});
+// Inside setup() of a component within an ActorProvider tree:
+const view = getPlayViewContext();
+// view.spec, view.handlers, view.registry, view.store
 ```
 
-`onRenderError` is typed as `RenderErrorHandler` and exported from.
-
 ---
 
-### `useActor`
+### Re-exported from `@json-render/vue`
 
-Vue composable for accessing the actor from inside any component rendered by `PlayRenderer`.
+The following are re-exported so consumers import everything from `@xmachines/play-vue`:
 
-```ts
-import { useActor } from "@xmachines/play-vue";
+**Components:** `JSONUIProvider`, `StateProvider`, `ActionProvider`, `VisibilityProvider`, `ValidationProvider`, `Renderer`
 
-// Inside any component rendered inside PlayRenderer:
-const actor = useActor();
-actor.send({ type: "auth.logout" });
-```
+**Composables:** `useBoundProp`
 
-Throws `NonNullableError: "useActor() must be called inside <ActorProvider> (or <PlayUIProvider>)"` if called outside the tree.
+**Types:** `JSONUIProviderProps`, `StateProviderProps`, `ActionProviderProps`, `ValidationProviderProps`, `RendererProps`, `ComponentFn`, `ComponentContext`, `DefineRegistryResult`
 
 ---
 
-## Route Parameters in Props
+## Testing
 
-When using `formatPlayRouteTransitions`, URL path parameters flow automatically into component props. Declare an `undefined` slot in the spec to opt in:
+Run tests for this package in isolation:
 
-```ts
-// spec: { section: undefined, user: "alice" }
-// After play.route to /settings/profile → context.params = { section: "profile" }
-// Component receives: { section: "profile", user: "alice" }
-```
+```bash
+# From the monorepo root
+npm test -w packages/play-vue
 
-Priority: **route param fills `undefined` slots; explicit non-`undefined` spec props always win.**
+# Watch mode
+npm run test:watch -w packages/play-vue
 
----
+# With coverage (80% threshold enforced on lines, functions, branches, statements)
+npx vitest run --coverage --config packages/play-vue/vitest.config.ts
+```
 
-## Architecture Notes
+Tests use [Vitest](https://vitest.dev/) with `jsdom` environment and `@vue/test-utils` for component mounting.
 
-- Vue reactivity is only used to trigger re-renders — not for business logic
-- `actor.currentView` (TC39 Signal) is bridged to Vue's reactive system inside `PlayRenderer`
-- Per-view UI state lives in an `@xstate/store` atom, not in Vue reactive state
-- `@json-render/vue` drives rendering; `PlayRenderer` is the signal bridge — import `defineRegistry`, `ComponentFn`, `ComponentContext`, and `useBoundProp` from
-- Vue views should be `.vue` SFCs using `ComponentContext<MyCatalog, "X">` — `defineRegistry` from and Vue composables work correctly
+---
 
-## Learn More
+## License
 
-- [Demo](../../../examples/@xmachines/play-vue-demo/README.md)
-- [Vue Router adapter](../play-vue-router/README.md)
+MIT — see [LICENSE](LICENSE).
 
 @xmachines/play-vue - Vue 3 renderer for XMachines Play architecture
 

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:131](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-vue/src/define-registry.ts#L131)
+Defined in: [packages/play-vue/src/define-registry.ts:131](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-vue/src/define-registry.ts#L131)
 
 Create a component registry, automatically wrapping `.vue` SFCs so they work
 correctly with `@json-render/vue`'s rendering pipeline.

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

@@ -6,7 +6,7 @@
 function getPlayViewContext(): ViewContextValue;
 ```
 
-Defined in: [packages/play-vue/src/actor-provider-context.ts:44](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-vue/src/actor-provider-context.ts#L44)
+Defined in: [packages/play-vue/src/actor-provider-context.ts:44](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-vue/src/actor-provider-context.ts#L44)
 
 Access the current ViewContextValue from inside an ActorProvider tree.
 

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

@@ -6,7 +6,7 @@
 function useActor(): PlayActor;
 ```
 
-Defined in: [packages/play-vue/src/useActor.ts:43](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-vue/src/useActor.ts#L43)
+Defined in: [packages/play-vue/src/useActor.ts:43](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-vue/src/useActor.ts#L43)
 
 ## Returns
 

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

@@ -2,7 +2,7 @@
 
 # Interface: ActorProviderProps
 
-Defined in: [packages/play-vue/src/types.ts:14](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-vue/src/types.ts#L14)
+Defined in: [packages/play-vue/src/types.ts:14](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-vue/src/types.ts#L14)
 
 Props for the ActorProvider component.
 Extracted to types.ts so TypeScript can re-export without the vue-shim limitation.
@@ -19,7 +19,7 @@ Extracted to types.ts so TypeScript can re-export without the vue-shim limitatio
 
 | 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:154](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-actor/src/abstract-actor.ts#L154) |
-| <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:167](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-actor/src/abstract-actor.ts#L167) |
-| <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:156](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-actor/src/abstract-actor.ts#L156) |
-| <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:162](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-actor/src/abstract-actor.ts#L162) |
+| <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:154](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-actor/src/abstract-actor.ts#L154) |
+| <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:167](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-actor/src/abstract-actor.ts#L167) |
+| <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:156](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-actor/src/abstract-actor.ts#L156) |
+| <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:162](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-actor/src/abstract-actor.ts#L162) |

package/api/@xmachines/play-vue/interfaces/PlayUIProviderProps.md

@@ -2,7 +2,7 @@
 
 # Interface: PlayUIProviderProps
 
-Defined in: [packages/play-vue/src/types.ts:25](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-vue/src/types.ts#L25)
+Defined in: [packages/play-vue/src/types.ts:25](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-vue/src/types.ts#L25)
 
 Props for the ActorProvider component.
 Extracted to types.ts so TypeScript can re-export without the vue-shim limitation.
@@ -15,10 +15,10 @@ Extracted to types.ts so TypeScript can re-export without the vue-shim limitatio
 
 | 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).                                                                                                                                                      | [`ActorProviderProps`](ActorProviderProps.md).[`actor`](ActorProviderProps.md#property-actor)                   | [packages/play-actor/src/abstract-actor.ts:154](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-actor/src/abstract-actor.ts#L154) |
-| <a id="property-functions"></a> `functions?`                     | `Record`\<`string`, (`args?`, `state?`) => `unknown`\>                                                                                                                                                                                                           | Named functions for $computed expressions in props                                                                                                                                                                          | -                                                                                                               | [packages/play-vue/src/types.ts:34](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-vue/src/types.ts#L34)                         |
-| <a id="property-navigate"></a> `navigate?`                       | (`path`) => `void`                                                                                                                                                                                                                                               | Navigate function forwarded to JSONUIProvider for link resolution                                                                                                                                                           | -                                                                                                               | [packages/play-vue/src/types.ts:27](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-vue/src/types.ts#L27)                         |
-| <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.                                                                                           | [`ActorProviderProps`](ActorProviderProps.md).[`onRenderError`](ActorProviderProps.md#property-onrendererror)   | [packages/play-actor/src/abstract-actor.ts:167](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-actor/src/abstract-actor.ts#L167) |
-| <a id="property-registryresult"></a> `registryResult`            | [`DefineRegistryResult`](DefineRegistryResult.md)                                                                                                                                                                                                                | Full result from defineRegistry() — contains the component registry and action handlers factory.                                                                                                                            | [`ActorProviderProps`](ActorProviderProps.md).[`registryResult`](ActorProviderProps.md#property-registryresult) | [packages/play-actor/src/abstract-actor.ts:156](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-actor/src/abstract-actor.ts#L156) |
-| <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. | [`ActorProviderProps`](ActorProviderProps.md).[`store`](ActorProviderProps.md#property-store)                   | [packages/play-actor/src/abstract-actor.ts:162](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-actor/src/abstract-actor.ts#L162) |
-| <a id="property-validationfunctions"></a> `validationFunctions?` | `Record`\<`string`, (`value`, `args?`) => `boolean`\>                                                                                                                                                                                                            | Validation functions forwarded to JSONUIProvider                                                                                                                                                                            | -                                                                                                               | [packages/play-vue/src/types.ts:29](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.46/packages/play-vue/src/types.ts#L29)                         |
+| <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).                                                                                                                                                      | [`ActorProviderProps`](ActorProviderProps.md).[`actor`](ActorProviderProps.md#property-actor)                   | [packages/play-actor/src/abstract-actor.ts:154](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-actor/src/abstract-actor.ts#L154) |
+| <a id="property-functions"></a> `functions?`                     | `Record`\<`string`, (`args?`, `state?`) => `unknown`\>                                                                                                                                                                                                           | Named functions for $computed expressions in props                                                                                                                                                                          | -                                                                                                               | [packages/play-vue/src/types.ts:34](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-vue/src/types.ts#L34)                         |
+| <a id="property-navigate"></a> `navigate?`                       | (`path`) => `void`                                                                                                                                                                                                                                               | Navigate function forwarded to JSONUIProvider for link resolution                                                                                                                                                           | -                                                                                                               | [packages/play-vue/src/types.ts:27](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-vue/src/types.ts#L27)                         |
+| <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.                                                                                           | [`ActorProviderProps`](ActorProviderProps.md).[`onRenderError`](ActorProviderProps.md#property-onrendererror)   | [packages/play-actor/src/abstract-actor.ts:167](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-actor/src/abstract-actor.ts#L167) |
+| <a id="property-registryresult"></a> `registryResult`            | [`DefineRegistryResult`](DefineRegistryResult.md)                                                                                                                                                                                                                | Full result from defineRegistry() — contains the component registry and action handlers factory.                                                                                                                            | [`ActorProviderProps`](ActorProviderProps.md).[`registryResult`](ActorProviderProps.md#property-registryresult) | [packages/play-actor/src/abstract-actor.ts:156](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-actor/src/abstract-actor.ts#L156) |
+| <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. | [`ActorProviderProps`](ActorProviderProps.md).[`store`](ActorProviderProps.md#property-store)                   | [packages/play-actor/src/abstract-actor.ts:162](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-actor/src/abstract-actor.ts#L162) |
+| <a id="property-validationfunctions"></a> `validationFunctions?` | `Record`\<`string`, (`value`, `args?`) => `boolean`\>                                                                                                                                                                                                            | Validation functions forwarded to JSONUIProvider                                                                                                                                                                            | -                                                                                                               | [packages/play-vue/src/types.ts:29](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.48/packages/play-vue/src/types.ts#L29)                         |