@xmachines/docs 1.0.0-beta.9 → 1.1.0

package/api/@xmachines/play-tanstack-solid-router/type-aliases/TanStackRouterInstance.md

@@ -1,9 +1,9 @@
-[Documentation](../../../README.md) / [@xmachines/play-tanstack-solid-router](../README.md) / TanStackRouterInstance
+[API](../../../README.md) / [@xmachines/play-tanstack-solid-router](../README.md) / TanStackRouterInstance
 
 # Type Alias: TanStackRouterInstance
 
 ```ts
-type TanStackRouterInstance = ConstructorParameters<typeof SolidRouterBridge>[0];
+type TanStackRouterInstance = ConstructorParameters<typeof TanStackSolidRouterBridge>[0];
 ```
 
-Defined in: [play-tanstack-solid-router/src/play-router-provider.tsx:8](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-tanstack-solid-router/src/play-router-provider.tsx#L8)
+Defined in: [play-tanstack-solid-router/src/play-router-provider.tsx:22](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.1.0/packages/play-tanstack-solid-router/src/play-router-provider.tsx#L22)

package/api/@xmachines/play-tanstack-solid-router/type-aliases/TanStackRouterLike.md

@@ -1,4 +1,4 @@
-[Documentation](../../../README.md) / [@xmachines/play-tanstack-solid-router](../README.md) / TanStackRouterLike
+[API](../../../README.md) / [@xmachines/play-tanstack-solid-router](../README.md) / TanStackRouterLike
 
 # Type Alias: TanStackRouterLike
 
@@ -6,7 +6,11 @@
 type TanStackRouterLike = object;
 ```
 
-Defined in: [play-tanstack-solid-router/src/solid-router-bridge.ts:28](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-tanstack-solid-router/src/solid-router-bridge.ts#L28)
+Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:36](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.1.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L36)
+
+Structural (type-only) interface for the TanStack Router surface used by
+`TanStackRouterBridgeBase`. Both `@tanstack/react-router` and
+`@tanstack/solid-router` instances satisfy it.
 
 ## Properties
 
@@ -16,7 +20,29 @@ Defined in: [play-tanstack-solid-router/src/solid-router-bridge.ts:28](https://g
 history: object;
 ```
 
-Defined in: [play-tanstack-solid-router/src/solid-router-bridge.ts:31](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-tanstack-solid-router/src/solid-router-bridge.ts#L31)
+Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:44](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.1.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L44)
+
+#### location
+
+```ts
+location: object;
+```
+
+Current location — populated from `window.location` when `createRouter()` runs,
+before `router.load()`. Always available in the browser.
+`router.state.location` is only populated after `router.load()` and may be stale.
+
+##### location.pathname
+
+```ts
+pathname: string;
+```
+
+##### location.search?
+
+```ts
+optional search?: string;
+```
 
 #### subscribe()
 
@@ -34,29 +60,25 @@ subscribe(handler): () => void;
 
 () => `void`
 
----
+## Methods
 
-### state?
+### load()?
 
 ```ts
-optional state?: object;
+optional load(): void | Promise<void>;
 ```
 
-Defined in: [play-tanstack-solid-router/src/solid-router-bridge.ts:30](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-tanstack-solid-router/src/solid-router-bridge.ts#L30)
-
-#### location?
+Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:43](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.1.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L43)
 
-```ts
-optional location?: object;
-```
+Re-runs TanStack route matching and loaders for the current location.
+Optional: the bridge calls it (fire-and-forget) after every navigation so
+matching/loaders stay in sync even without a mounted `<RouterProvider>`.
 
-##### location.pathname?
+#### Returns
 
-```ts
-optional pathname?: string;
-```
+`void` \| `Promise`\<`void`\>
 
-## Methods
+---
 
 ### navigate()
 
@@ -64,7 +86,7 @@ optional pathname?: string;
 navigate(args): void;
 ```
 
-Defined in: [play-tanstack-solid-router/src/solid-router-bridge.ts:29](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-tanstack-solid-router/src/solid-router-bridge.ts#L29)
+Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:37](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.1.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L37)
 
 #### Parameters
 

package/api/@xmachines/play-tanstack-solid-router/variables/PlayRouterProvider.md

@@ -0,0 +1,33 @@
+[API](../../../README.md) / [@xmachines/play-tanstack-solid-router](../README.md) / PlayRouterProvider
+
+# Variable: PlayRouterProvider
+
+```ts
+const PlayRouterProvider: <TActor>(props) => any;
+```
+
+Defined in: [play-tanstack-solid-router/src/play-router-provider.tsx:42](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.1.0/packages/play-tanstack-solid-router/src/play-router-provider.tsx#L42)
+
+Connects a `PlayerActor` to TanStack Solid Router, keeping actor state and
+browser URL in sync bidirectionally.
+
+The bridge is created once per component instance at component evaluation time
+and torn down via `onCleanup` when the component is disposed. Unlike React,
+prop stability is not a concern — Solid's `props` accessor is already reactive
+and the bridge is created once per component instance.
+
+## Type Parameters
+
+| Type Parameter                                               |
+| ------------------------------------------------------------ |
+| `TActor` _extends_ [`PlayActor`](../interfaces/PlayActor.md) |
+
+## Parameters
+
+| Parameter | Type                                                                                                                                                     |
+| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `props`   | [`PlayRouterProviderBaseProps`](../interfaces/PlayRouterProviderBaseProps.md)\<[`TanStackRouterLike`](../type-aliases/TanStackRouterLike.md), `TActor`\> |
+
+## Returns
+
+`any`

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

@@ -1,292 +1,272 @@
-[Documentation](../../README.md) / @xmachines/play-vue
+[API](../../README.md) / @xmachines/play-vue
 
-# @xmachines/play-vue
+# `@xmachines/play-vue`
 
-**Vue renderer consuming signals and UI schema with provider pattern**
+> Vue 3 renderer for the XMachines Play Architecture — passively observes actor signals and renders UI via `@xmachines/json-render-vue`.
 
-Signal-driven Vue rendering layer observing actor state with zero Vue state for business logic.
+Part of the [XMachines Play monorepo](../../README.md).
 
-## Overview
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Version](https://img.shields.io/badge/version-1.1.0-blue)](https://www.npmjs.com/package/@xmachines/play-vue)
+
+---
 
-`@xmachines/play-vue` provides `PlayRenderer` for building Vue 3 UIs that passively observe actor signals. This package enables framework-swappable architecture where Vue is just a rendering target subscribing to signal changes — business logic lives entirely in the actor.
+## Overview
 
-Per [RFC Play v1](https://gitlab.com/xmachin-es/rfc/-/blob/main/src/play-v1.md), this package implements:
+`@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 `@xmachines/json-render-vue`.
 
-- **Signal-Only Reactivity (INV-05):** No refs/reactive for business logic, TC39 signals only
-- **Passive Infrastructure (INV-04):** Components observe signals, send events to actor
+**Architecture invariants this package upholds:**
 
-**Key Principle:** Vue state is never used for business logic. Signals are the source of truth.
+- **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.
 
-Renderer receives actor via props (provider pattern), not children.
+---
 
 ## Installation
 
 ```bash
-npm install vue@^3.5.0
-npm install @xmachines/play-vue
+pnpm add @xmachines/play-vue
 ```
 
-## Current Exports
-
-- `PlayRenderer` (Vue component)
-- `PlayRendererProps` (TypeScript interface)
+**Peer dependencies** (install alongside):
 
-**Peer dependencies:**
+```bash
+pnpm add vue@^3.5.0 xstate@^5.31.0 @xstate/store@^3.17.0 @xmachines/json-render-vue@^0.18.0 @xmachines/json-render-core@^0.18.0 @xmachines/json-render-xstate@^0.18.0
+```
 
-- `vue` ^3.5.0 — Vue 3 runtime
+---
 
 ## Quick Start
 
 ```vue
 <!-- App.vue -->
+<template>
+	<PlayUIProvider :actor="actor" :registryResult="registryResult">
+		<PlayRenderer />
+	</PlayUIProvider>
+</template>
+
 <script setup lang="ts">
+import { defineRegistry, PlayUIProvider, PlayRenderer } from "@xmachines/play-vue";
 import { definePlayer } from "@xmachines/play-xstate";
-import { defineCatalog } from "@xmachines/play-catalog";
-import { PlayRenderer } from "@xmachines/play-vue";
-import { z } from "zod";
-import LoginForm from "./components/LoginForm.vue";
-import Dashboard from "./components/Dashboard.vue";
-
-// 1. Define catalog (business logic layer)
-const catalog = defineCatalog({
-	LoginForm: z.object({ error: z.string().optional() }),
-	Dashboard: z.object({
-		userId: z.string(),
-		username: z.string(),
-	}),
-});
+import { myMachine } from "./machine.js";
+import { myCatalog } from "./catalog.js";
+import HomeSFC from "./views/Home.vue";
+import LoginSFC from "./views/Login.vue";
 
-// 2. Define component map (view layer)
-const components = {
-	LoginForm,
-	Dashboard,
-};
-
-// 3. Create player actor (business logic runtime)
-const createPlayer = definePlayer({ machine: authMachine, catalog });
+const createPlayer = definePlayer({ machine: myMachine });
 const actor = createPlayer();
 actor.start();
-</script>
 
-<template>
-	<!-- 4. Render UI (actor via props) -->
-	<PlayRenderer :actor="actor" :components="components">
-		<template #fallback>
-			<div>Loading...</div>
-		</template>
-	</PlayRenderer>
-</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
+---
 
-### PlayRenderer
+## API Summary
 
-Main renderer component subscribing to actor signals and dynamically rendering catalog components:
+### Components
 
-```typescript
-interface PlayRendererProps {
-	actor: AbstractActor<any>;
-	components: Record<string, Component>;
-}
-```
+#### `<PlayUIProvider>`
 
-**Props:**
+Batteries-included composite provider. Wraps `<ActorProvider>` and `JSONUIProvider` in one component. **Recommended for most apps.**
 
-- `actor` - Actor instance with `currentView` signal
-- `components` - Map of component names to Vue components
+| 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 |
 
-**Slots:**
+**Slots:** `default` (rendered content), `fallback` (shown while actor view is `null`)
 
-- `fallback` - Slot shown when `currentView` is null
+#### `<PlayRenderer>`
 
-**Behavior:**
+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.
 
-1. Subscribes to `actor.currentView` signal using a `Signal.subtle.Watcher` inside a Vue component
-2. Looks up component from `components` map using `view.component` string
-3. Renders component with props from `view.props` + `send` function via Vue's dynamic `<component :is="..."/>`
+```vue
+<PlayUIProvider :actor="actor" :registryResult="registryResult">
+  <PlayRenderer />
+</PlayUIProvider>
+```
 
-**Example Component (LoginForm.vue):**
+#### `<ActorProvider>`
 
-```vue
-<script setup lang="ts">
-import type { AbstractActor } from "@xmachines/play-actor";
-import { ref } from "vue";
-
-const props = defineProps<{
-	error?: string;
-	send: AbstractActor<any>["send"];
-}>();
-
-const username = ref("");
-
-function handleSubmit() {
-	props.send({
-		type: "auth.login",
-		username: username.value,
-	});
-}
-</script>
+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.
 
-<template>
-	<form @submit.prevent="handleSubmit">
-		<p v-if="error" style="color: red">{{ error }}</p>
-		<input v-model="username" required placeholder="Username" />
-		<button type="submit">Log In</button>
-	</form>
-</template>
-```
+| 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   |
 
-## Examples
+---
 
-### Provider Pattern
+### Functions
 
-```vue
-<!-- App.vue -->
-<script setup lang="ts">
-import { PlayVueRouterProvider } from "@xmachines/play-vue-router";
-import { PlayRenderer } from "@xmachines/play-vue";
-import { provide } from "vue";
-import Header from "./components/Header.vue";
-import Footer from "./components/Footer.vue";
-
-// Provide actor to nested components like Header
-provide("actor", actor);
-</script>
+#### `defineRegistry(catalog, options)`
 
-<template>
-	<PlayVueRouterProvider :actor="actor" :router="router" :routeMap="routeMap">
-		<template #default="{ currentActor, currentRouter }">
-			<div>
-				<Header />
-				<PlayRenderer :actor="currentActor" :components="components" />
-				<Footer />
-			</div>
-		</template>
-	</PlayVueRouterProvider>
-</template>
-```
+Drop-in replacement for `defineRegistry` from `@xmachines/json-render-vue`. **Always import from `@xmachines/play-vue`** rather than `@xmachines/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>`.
 
-```vue
-<!-- Header.vue -->
-<script setup lang="ts">
-import { inject, ref, onMounted, onUnmounted } from "vue";
-import type { AbstractActor } from "@xmachines/play-actor";
-
-const actor = inject<AbstractActor<any>>("actor")!;
-const route = ref<string | null>(null);
-
-let watcher: any;
-
-onMounted(() => {
-	let pending = false;
-	watcher = new Signal.subtle.Watcher(() => {
-		if (!pending) {
-			pending = true;
-			queueMicrotask(() => {
-				pending = false;
-				for (const s of watcher.getPending()) s.get();
-				route.value = actor.currentRoute.get();
-				watcher.watch(actor.currentRoute);
-			});
-		}
-	});
-	route.value = actor.currentRoute.get();
-	watcher.watch(actor.currentRoute);
+```typescript
+import { defineRegistry } from "@xmachines/play-vue";
+// NOT: import { defineRegistry } from "@xmachines/json-render-vue"
+
+import LoginSFC from "./views/Login.vue";
+import DashboardSFC from "./views/Dashboard.vue";
+
+const registryResult = defineRegistry(catalog, {
+	components: {
+		Login: LoginSFC, // .vue SFC — auto-wrapped via h()
+		Dashboard: DashboardSFC,
+	},
+	actions: {
+		login: async (args, setState, getState) => {
+			/* ... */
+		},
+	},
 });
+```
 
-onUnmounted(() => {
-	if (watcher) watcher.unwatch(actor.currentRoute);
-});
-</script>
+Plain `ComponentFn` functions (non-SFC) also work and are passed through unchanged. Mixing SFCs and plain functions in the same registry is supported.
 
-<template>
-	<header>
-		<nav>Current: {{ route }}</nav>
-	</header>
-</template>
+#### `useActor()`
+
+Vue composable for accessing the raw actor inside a `PlayRenderer` tree. Avoids prop drilling for deeply nested components.
+
+```typescript
+import { useActor } from "@xmachines/play-vue";
+
+// Inside a component rendered by PlayRenderer:
+const actor = useActor();
+actor.send({ type: "SUBMIT" });
 ```
 
-## Architecture
+Throws if called outside an `<ActorProvider>` or `<PlayUIProvider>` tree.
 
-This package implements **Signal-Only Reactivity (INV-05)** and **Passive Infrastructure (INV-04)**:
+#### `getPlayViewContext()`
 
-1. **No Business Logic in Vue:**
-    - No ref/reactive for business state
-    - No watch/watchEffect for business side effects
-    - Vue only triggers renders, doesn't control state
+Access the current `ViewContextValue` — `{ spec, handlers, registry, store }` — from inside an `<ActorProvider>` tree.
 
-2. **Signals as Source of Truth:**
-    - `actor.currentView.get()` provides UI structure
-    - `actor.currentRoute.get()` provides navigation state
-    - Components observe signals via explicit watcher patterns
+```typescript
+import { getPlayViewContext } from "@xmachines/play-vue";
 
-3. **Event Forwarding:**
-    - Components receive `send` function via props
-    - User actions send events to actor (e.g., `{ type: "auth.login" }`)
-    - Actor guards validate and process events
+// Inside setup() of a component within an ActorProvider tree:
+const view = getPlayViewContext();
+// view.spec, view.handlers, view.registry, view.store
+```
 
-4. **Microtask Batching:**
-    - `Signal.subtle.Watcher` coalesces rapid signal changes
-    - Prevents Vue thrashing from multiple signal updates
-    - Single Vue render per microtask batch
+---
 
-5. **Explicit Disposal Contract:**
-    - Component teardown calls watcher `unwatch` in `onUnmounted`
-    - Do not rely on GC-only cleanup
+### Re-exported from `@xmachines/json-render-vue`
 
-**Pattern:**
+The following are re-exported so consumers import everything from `@xmachines/play-vue`:
 
-- Renderer receives actor via props (provider pattern)
-- Enables composition with navigation, headers, footers
-- Supports multiple renderers in same app
+**Components:** `JSONUIProvider`, `StateProvider`, `ActionProvider`, `VisibilityProvider`, `ValidationProvider`, `Renderer`
 
-**Architectural Invariants:**
+**Composables:** `useBoundProp`
 
-- **Signal-Only Reactivity (INV-05):** No Vue state for business logic
-- **Passive Infrastructure (INV-04):** Components reflect, never decide
+**Types:** `JSONUIProviderProps`, `StateProviderProps`, `ActionProviderProps`, `ValidationProviderProps`, `RendererProps`, `ComponentFn`, `ComponentContext`, `DefineRegistryResult`
 
-## Canonical Watcher Lifecycle
+---
 
-If you write your own custom integration, use the same watcher flow as `PlayRenderer`:
+## Testing
 
-1. `notify` callback runs
-2. Schedule work with `queueMicrotask`
-3. Drain `watcher.getPending()`
-4. Read actor signals and update Vue-local ref state
-5. Re-arm with `watch(...)` or `watch()`
+Run tests for this package in isolation:
 
-Watcher notify is one-shot. Re-arm is required for continuous observation.
+```bash
+# From the monorepo root
+pnpm --filter @xmachines/play-vue test
 
-## Benefits
+# Watch mode
+pnpm --filter @xmachines/play-vue run test:watch
 
-- **Framework Swappable:** Business logic has zero Vue imports
-- **Type Safety:** Props validated against catalog schemas
-- **Simple Testing:** Test actors without Vue renderer
-- **Performance:** Microtask batching reduces unnecessary renders
-- **Composability:** Renderer prop enables complex layouts
+# With coverage (80% threshold enforced on lines, functions, branches, statements)
+pnpm exec vitest run --coverage --config packages/play-vue/vitest.config.ts
+```
 
-## Related Packages
+Tests use [Vitest](https://vitest.dev/) with `jsdom` environment and `@vue/test-utils` for component mounting.
 
-- **[@xmachines/play-xstate](../play-xstate/README.md)** - XState adapter providing actors
-- **[@xmachines/play-catalog](../play-catalog/README.md)** - UI schema validation
-- **[@xmachines/play-vue-router](../play-vue-router/README.md)** - Vue Router integration
-- **[@xmachines/play-actor](../play-actor/README.md)** - Actor base
-- **[@xmachines/play-signals](../play-signals/README.md)** - TC39 Signals primitives
+---
 
 ## License
 
-Copyright (c) 2016 [Mikael Karon](mailto:mikael@karon.se). All rights reserved.
+MIT — see [LICENSE](LICENSE).
+
+@xmachines/play-vue - Vue 3 renderer for XMachines Play architecture
 
-This work is licensed under the terms of the MIT license.  
-For a copy, see <https://opensource.org/licenses/MIT>.
+Provides a thin Vue rendering layer that passively observes actor signals
+and renders UI components via @xmachines/json-render-vue. Vue reactivity is only used
+to trigger re-renders — signals are the source of truth.
 
-@xmachines/play-vue - Vue renderer for XMachines Play architecture
+Re-exports `defineRegistry` (SFC-aware — auto-wraps `.vue` SFCs via `h()`),
+`useBoundProp`, `ComponentFn`, `ComponentContext`, and all json-render providers
+so consumers import everything from `@xmachines/play-vue` rather than
+`@xmachines/json-render-vue` directly.
 
 ## Interfaces
 
-- [PlayRendererProps](interfaces/PlayRendererProps.md)
+- [ActionProviderProps](interfaces/ActionProviderProps.md)
+- [ActorProviderProps](interfaces/ActorProviderProps.md)
+- [ComponentContext](interfaces/ComponentContext.md)
+- [DefineRegistryResult](interfaces/DefineRegistryResult.md)
+- [JSONUIProviderProps](interfaces/JSONUIProviderProps.md)
+- [PlayUIProviderProps](interfaces/PlayUIProviderProps.md)
+- [RendererProps](interfaces/RendererProps.md)
+- [StateProviderProps](interfaces/StateProviderProps.md)
+- [ValidationProviderProps](interfaces/ValidationProviderProps.md)
+- [ViewContextValue](interfaces/ViewContextValue.md)
+- [VisibilityProviderProps](interfaces/VisibilityProviderProps.md)
+
+## Type Aliases
+
+- [AnyPlayActor](type-aliases/AnyPlayActor.md)
+- [ComponentEntry](type-aliases/ComponentEntry.md)
+- [ComponentFn](type-aliases/ComponentFn.md)
+- [ComponentsMap](type-aliases/ComponentsMap.md)
+- [DefineRegistryOptions](type-aliases/DefineRegistryOptions.md)
+- [RenderErrorHandler](type-aliases/RenderErrorHandler.md)
 
 ## Variables
 
+- [ActionProvider](variables/ActionProvider.md)
+- [JSONUIProvider](variables/JSONUIProvider.md)
 - [PlayRenderer](variables/PlayRenderer.md)
+- [Renderer](variables/Renderer.md)
+- [StateProvider](variables/StateProvider.md)
+- [ValidationProvider](variables/ValidationProvider.md)
+- [VisibilityProvider](variables/VisibilityProvider.md)
+
+## Functions
+
+- [defineRegistry](functions/defineRegistry.md)
+- [getPlayViewContext](functions/getPlayViewContext.md)
+- [useActor](functions/useActor.md)
+- [useBoundProp](functions/useBoundProp.md)
+
+## References
+
+### ActorProvider
+
+Renames and re-exports [PlayRenderer](variables/PlayRenderer.md)
+
+---
+
+### PlayUIProvider
+
+Renames and re-exports [PlayRenderer](variables/PlayRenderer.md)