@xmachines/docs 1.0.0-beta.25 → 1.0.0-beta.27

package/api/@xmachines/play-dom-router/interfaces/RouteMapLike.md

@@ -0,0 +1,50 @@
+[Documentation](../../../README.md) / [@xmachines/play-dom-router](../README.md) / RouteMapLike
+
+# Interface: RouteMapLike
+
+Defined in: [play-dom-router/src/connect-router.ts:12](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-dom-router/src/connect-router.ts#L12)
+
+Structural route-map interface accepted by [connectRouter](../functions/connectRouter.md).
+
+Any object with these two methods satisfies the constraint — including
+`BaseRouteMap` instances, subclasses, and plain test objects.
+
+## Methods
+
+### getPathByStateId()
+
+```ts
+getPathByStateId(id): string | null | undefined;
+```
+
+Defined in: [play-dom-router/src/connect-router.ts:14](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-dom-router/src/connect-router.ts#L14)
+
+#### Parameters
+
+| Parameter | Type     |
+| --------- | -------- |
+| `id`      | `string` |
+
+#### Returns
+
+`string` \| `null` \| `undefined`
+
+---
+
+### getStateIdByPath()
+
+```ts
+getStateIdByPath(path): string | null | undefined;
+```
+
+Defined in: [play-dom-router/src/connect-router.ts:13](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-dom-router/src/connect-router.ts#L13)
+
+#### Parameters
+
+| Parameter | Type     |
+| --------- | -------- |
+| `path`    | `string` |
+
+#### Returns
+
+`string` \| `null` \| `undefined`

package/api/@xmachines/play-dom-router/interfaces/RouteMapping.md

@@ -0,0 +1,27 @@
+[Documentation](../../../README.md) / [@xmachines/play-dom-router](../README.md) / RouteMapping
+
+# Interface: RouteMapping
+
+Defined in: [play-router/src/base-route-map.ts:57](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-router/src/base-route-map.ts#L57)
+
+A single state ID ↔ path mapping entry.
+
+Both fields are `readonly` — mappings are immutable once passed to `BaseRouteMap`.
+Adapter packages re-export a structurally compatible `RouteMapping` type under
+their own name. This type is published from `@xmachines/play-router` as
+`BaseRouteMapping` to avoid name collisions with those adapter-local types.
+
+## Example
+
+```typescript
+const mapping: BaseRouteMapping = { stateId: "home", path: "/" };
+const paramMapping: BaseRouteMapping = { stateId: "profile", path: "/profile/:userId" };
+const optionalMapping: BaseRouteMapping = { stateId: "settings", path: "/settings/:section?" };
+```
+
+## Properties
+
+| Property                                | Modifier   | Type     | Description                                                                   | Defined in                                                                                                                                              |
+| --------------------------------------- | ---------- | -------- | ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-path"></a> `path`       | `readonly` | `string` | URL path pattern (e.g., `"/"`, `"/profile/:userId"`, `"/settings/:section?"`) | [play-router/src/base-route-map.ts:61](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-router/src/base-route-map.ts#L61) |
+| <a id="property-stateid"></a> `stateId` | `readonly` | `string` | State machine state ID (e.g., `"home"`, `"#profile"`)                         | [play-router/src/base-route-map.ts:59](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-router/src/base-route-map.ts#L59) |

package/api/@xmachines/play-dom-router/interfaces/RouterBridge.md

@@ -0,0 +1,104 @@
+[Documentation](../../../README.md) / [@xmachines/play-dom-router](../README.md) / RouterBridge
+
+# Interface: RouterBridge
+
+Defined in: [play-router/src/types.ts:271](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-router/src/types.ts#L271)
+
+RouterBridge interface for runtime infrastructure adapters
+
+Defines the lifecycle connection between Infrastructure (e.g., TanStack Router) and
+the Actor. Infrastructure "bridges" to the Actor by observing its signals and
+managing its own lifecycle accordingly.
+
+**Architectural Context:** Implements **Passive Infrastructure (INV-04)** by establishing
+a unidirectional observation pattern. Infrastructure connects to observe Actor signals
+(currentRoute, currentView, state) and reflects changes without making state decisions.
+
+## Example
+
+TanStack Router bridge implementation
+
+```typescript
+import type { RouterBridge } from "@xmachines/play-router";
+import { Signal } from "@xmachines/play-signals";
+
+class TanStackRouterBridge implements RouterBridge {
+	private watcher: Signal.Watcher | null = null;
+
+	async connect(): Promise<void> {
+		// Start observing actor.currentRoute signal
+		this.watcher = new Signal.subtle.Watcher(() => {
+			const route = actor.currentRoute.get();
+			if (route) router.navigate(route);
+		});
+		this.watcher.watch(actor.currentRoute);
+	}
+
+	async disconnect(): Promise<void> {
+		// Stop observing, cleanup watchers
+		this.watcher?.unwatch(actor.currentRoute);
+		this.watcher = null;
+	}
+}
+```
+
+## See
+
+[Play RFC](../../../../rfc/play.md) - Invariant INV-04
+
+## Methods
+
+### connect()
+
+```ts
+connect(): void | Promise<void>;
+```
+
+Defined in: [play-router/src/types.ts:287](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-router/src/types.ts#L287)
+
+Connect the router bridge to the Actor
+
+Called when Infrastructure should begin observing Actor signals and
+synchronizing its state (e.g., browser URL) with Actor state.
+
+#### Returns
+
+`void` \| `Promise`\<`void`\>
+
+Promise that resolves when connection is established, or void for synchronous connection
+
+#### Example
+
+```typescript
+const bridge: RouterBridge = createBridge(actor, router);
+await bridge.connect();
+// Bridge now observing actor.currentRoute signal
+```
+
+---
+
+### disconnect()
+
+```ts
+disconnect(): void | Promise<void>;
+```
+
+Defined in: [play-router/src/types.ts:303](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-router/src/types.ts#L303)
+
+Disconnect the router bridge from the Actor
+
+Called when Infrastructure should stop observing and clean up resources
+(e.g., signal watchers, event listeners).
+
+#### Returns
+
+`void` \| `Promise`\<`void`\>
+
+Promise that resolves when disconnection is complete, or void for synchronous disconnection
+
+#### Example
+
+```typescript
+await bridge.disconnect();
+// Bridge stopped observing, resources cleaned up
+```

package/api/@xmachines/play-dom-router/interfaces/VanillaRouter.md

@@ -2,14 +2,14 @@
 
 # Interface: VanillaRouter
 
-Defined in: [create-router.ts:4](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.25/packages/play-dom-router/src/create-router.ts#L4)
+Defined in: [play-dom-router/src/create-router.ts:4](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-dom-router/src/create-router.ts#L4)
 
 ## Properties
 
-| Property                                    | Modifier   | Type                                                     | Description                          | Defined in                                                                                                                                |
-| ------------------------------------------- | ---------- | -------------------------------------------------------- | ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-history"></a> `history`     | `readonly` | [`BrowserHistory`](BrowserHistory.md)                    | History instance                     | [create-router.ts:8](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.25/packages/play-dom-router/src/create-router.ts#L8)   |
-| <a id="property-routetree"></a> `routeTree` | `readonly` | [`RouteTree`](../../play-router/interfaces/RouteTree.md) | Route tree (for structure reference) | [create-router.ts:13](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.25/packages/play-dom-router/src/create-router.ts#L13) |
+| Property                                    | Modifier   | Type                                                     | Description                          | Defined in                                                                                                                                                    |
+| ------------------------------------------- | ---------- | -------------------------------------------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-history"></a> `history`     | `readonly` | [`BrowserHistory`](BrowserHistory.md)                    | History instance                     | [play-dom-router/src/create-router.ts:8](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-dom-router/src/create-router.ts#L8)   |
+| <a id="property-routetree"></a> `routeTree` | `readonly` | [`RouteTree`](../../play-router/interfaces/RouteTree.md) | Route tree (for structure reference) | [play-dom-router/src/create-router.ts:13](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-dom-router/src/create-router.ts#L13) |
 
 ## Methods
 
@@ -19,7 +19,7 @@ Defined in: [create-router.ts:4](https://gitlab.com/xmachin-es/xmachines-js/-/bl
 destroy(): void;
 ```
 
-Defined in: [create-router.ts:18](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.25/packages/play-dom-router/src/create-router.ts#L18)
+Defined in: [play-dom-router/src/create-router.ts:18](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-dom-router/src/create-router.ts#L18)
 
 Cleanup
 

package/api/@xmachines/play-dom-router/type-aliases/RoutableActor.md

@@ -0,0 +1,9 @@
+[Documentation](../../../README.md) / [@xmachines/play-dom-router](../README.md) / RoutableActor
+
+# Type Alias: RoutableActor
+
+```ts
+type RoutableActor = AbstractActor<AnyActorLogic> & Routable & Viewable;
+```
+
+Defined in: [play-dom-router/src/types.ts:9](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-dom-router/src/types.ts#L9)

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

@@ -1,19 +1,16 @@
 [Documentation](../../README.md) / @xmachines/play-dom-router-demo
 
-# Vanilla JavaScript Router Demo
+# Vanilla DOM Router Demo
 
-Pure JavaScript integration proving Play Architecture works without any framework.
+Pure TypeScript integration demo for `@xmachines/play-dom-router` — actor-authoritative routing with the Browser History API and no framework.
 
 ## What This Demonstrates
 
-This demo uses **no framework** - just vanilla JavaScript with the Browser History API and DOM manipulation. It proves that Play Architecture's universal abstractions work at the lowest level, making framework integrations simpler by comparison.
-
-## Key Features
-
-- **Zero Framework Dependencies**: Pure JavaScript and DOM
-- **Browser History API**: Direct integration with `window.history`
-- **Same Auth Machine**: Identical authentication logic as React/Vue/SolidJS demos
-- **Reference Implementation**: This demo serves as the visual reference for all framework demos
+- Shared auth machine reused without framework-specific business logic
+- `connectRouter` + `createBrowserHistory` wiring actor ↔ browser History API
+- Shell-driven DOM rendering via `connectRenderer` with actor-authoritative navigation
+- Manual TC39 Signal watcher lifecycle — the mechanism that framework adapters abstract
+- Non-browser invariant tests plus browser E2E coverage
 
 ## Running the Demo
 
@@ -24,21 +21,21 @@ npm install
 npm run dev -w packages/play-dom-router/examples/demo
 ```
 
-Visit `http://localhost:5174`.
+Then open `http://localhost:5174`.
 
 ## Step-by-Step Code Flow
 
-Use this order to understand the demo implementation:
+Use this order to understand the implementation:
 
-1. `src/main.ts` creates the actor from the shared machine/catalog and starts it.
-2. `src/router.ts` extracts machine routes, builds browser-history routing primitives, and connects actor <-> router sync.
-3. `src/shell.ts` subscribes to actor signals and renders state-projected DOM views.
-4. Navigation and auth interactions dispatch actor events (`play.route`, `auth.login`, `auth.logout`) rather than mutating URL/state directly.
-5. Browser tests in `test/browser/` validate startup rendering and the auth route flow end-to-end.
+1. `src/main.ts` creates the actor from the shared machine and starts it.
+2. `initRouter(actor)` from `src/router.ts` extracts route metadata, creates a browser history wrapper, instantiates a router, and calls `connectRouter` to wire bidirectional actor ↔ URL sync.
+3. `initShell(actor, app)` from `src/shell.ts` builds the DOM scaffold and sets up the `connectRenderer` loop for view switching.
+4. Navigation buttons and links dispatch `play.route`, `auth.login`, and `auth.logout` events directly to the actor — no URL mutations from the shell.
+5. Browser tests in `test/browser/` validate startup rendering and the full auth route flow.
 
 ```ts
 // src/main.ts (shape)
-const actor = createActorFromSharedMachine();
+const actor = createPlayer();
 actor.start();
 
 const cleanupRouter = initRouter(actor);
@@ -50,45 +47,52 @@ if (app) {
 
 ```ts
 // src/router.ts (shape)
-import { createBrowserHistory, createRouter, connectRouter } from "@xmachines/play-dom-router";
-import { extractMachineRoutes, createRouteMap } from "@xmachines/play-router";
-
-const routeTree = extractMachineRoutes(machine);
-const routeMap = createRouteMap(routeTree);
-const history = createBrowserHistory({ window });
-const router = createRouter({ routeTree, history });
-const disconnect = connectRouter({ actor, router, routeMap });
+export function initRouter(actor) {
+	const routeTree = extractMachineRoutes(authMachine);
+	const routeMap = createRouteMap(authMachine);
+	const history = createBrowserHistory({ window });
+	const router = createRouter({ routeTree, history });
+	const disconnect = connectRouter({ actor, router, routeMap });
+
+	return () => {
+		disconnect();
+		router.destroy();
+	};
+}
 ```
 
 ```ts
 // src/shell.ts (shape)
-actor.currentView.watch(() => {
-	renderView(actor.currentView.get());
+const disconnectRenderer = connectRenderer({ actor, registry, container: viewContent });
+
+const unwatchState = watchSignal(actor.state, () => {
+	navLogin.hidden = snapshot.context.isAuthenticated;
+	navLogout.hidden = !snapshot.context.isAuthenticated;
 });
 
-loginButton.onclick = () => actor.send({ type: "auth.login", username, password });
-logoutButton.onclick = () => actor.send({ type: "auth.logout" });
+navLogin.addEventListener("click", () => actor.send({ type: "play.route", to: "#login" }));
 ```
 
 ## Key Files
 
 - `src/main.ts` - actor startup, router initialization, and shell bootstrap
 - `src/router.ts` - `createBrowserHistory`, `createRouter`, and `connectRouter` wiring
-- `src/shell.ts` - DOM rendering and reactive watcher loop for state-driven updates
+- `src/shell.ts` - DOM scaffold, `DomRegistry` construction, `connectRenderer`, and reactive watcher loop
+- `test/library-pattern.test.ts` - architecture boundary and invariant assertions
 - `test/browser/startup.browser.test.ts` - startup rendering assertion for public home + login action
-- `test/browser/auth-flow.browser.test.ts` - login -> dashboard -> profile -> logout browser flow
+- `test/browser/auth-flow.browser.test.ts` - login → dashboard → profile → logout browser flow
 
 ## State Machine & Architecture Details
 
 The demo utilizes XMachines architectural invariants at the lowest level:
 
-1. **Actor Authority:** Intercepting browser `popstate` events or link clicks dispatches a `play.route` event to the actor. The actor processes the request against the current state, ensuring any auth logic is correctly applied.
-2. **Passive Infrastructure:** The router simply updates `window.history` and the DOM solely renders HTML text based on what `actor.currentView.get()` yields.
-3. **Signal-Only Reactivity:** The integration registers manual `Signal.subtle.Watcher` observers that manually trigger DOM reconciliation, illustrating the underlying mechanism abstraction used by framework adapters.
+1. **Actor Authority:** Intercepting browser `popstate` events or navigation button clicks dispatches a `play.route` event to the actor. The actor processes the request against the current state, ensuring any auth logic is correctly applied.
+2. **Passive Infrastructure:** The router simply updates `window.history` and the DOM solely renders HTML based on what `actor.currentView` yields. Neither holds business state.
+3. **Signal-Only Reactivity:** The integration registers `watchSignal` observers that trigger DOM reconciliation, illustrating the underlying mechanism that framework adapters abstract.
 
 ## Watcher Lifecycle and Cleanup Contract
 
-Even in the vanilla demo, watcher handling follows the same canonical lifecycle:
+Even in the vanilla demo, watcher handling follows the canonical lifecycle:
 
 1. `notify`
 2. `queueMicrotask`
@@ -96,21 +100,11 @@ Even in the vanilla demo, watcher handling follows the same canonical lifecycle:
 4. Read actor signals and project DOM state
 5. Re-arm with `watch()`/`watch(...signals)`
 
-Watcher notifications are one-shot, so re-arm is mandatory. Router/shell teardown must explicitly call cleanup (`disconnect`/`unwatch`) and not rely on GC-only behavior. In vanilla JS, this means retaining the cleanup functions and calling them during hot-module replacement or app unmount.
+Watcher notifications are one-shot, so re-arm is mandatory. Router/shell teardown must explicitly call cleanup (`disconnect`/`unwatch`) and not rely on GC-only behavior. In vanilla TypeScript, this means retaining cleanup functions and calling them on `beforeunload` or during hot-module replacement.
 
 ## Adapter Boundaries
 
-`connectRouter` and browser-history wiring (from `@xmachines/play-dom-router`) are passive infrastructure. Actor logic remains authoritative for route validity, and shared synchronization policy stays in `RouterBridgeBase` for framework bridges.
-
-## Why Vanilla?
-
-Vanilla JavaScript is the foundation:
-
-- **Universal Patterns**: If it works in vanilla, frameworks are just convenience layers
-- **No Magic**: Every interaction is explicit - great for learning
-- **Performance Baseline**: Shows the minimal overhead of Play Architecture
-
-This demo proves frameworks aren't required for Play Architecture to work.
+`connectRouter` and browser-history wiring (from `@xmachines/play-dom-router`) are passive infrastructure. Actor logic remains authoritative for route validity, and shared synchronization policy stays in `RouterBridgeBase` for framework bridges. This demo proves frameworks are not required for Play Architecture to work.
 
 ## Available Scripts
 
@@ -126,7 +120,7 @@ These commands are defined in `package.json`:
 
 ## Verification
 
-Validate the operational behavior with package-local tests:
+Use these checks to validate README claims against the current demo implementation:
 
 ```bash
 npm run test -w packages/play-dom-router/examples/demo
@@ -137,5 +131,6 @@ Expected result: tests pass, including startup rendering and the full browser au
 
 ## Learn More
 
-- **[Play DOM Router package README](../play-dom-router/README.md)** - `createBrowserHistory`, `createRouter`, `connectRouter` APIs
-- **[Play Router package README](../play-router/README.md)** - Route extraction and abstract routing infrastructure
+- [Play DOM Router package README](../play-dom-router/README.md)
+- [Play DOM demo README](../../../examples/README.md)
+- [Play Router package README](../play-router/README.md)

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

@@ -94,8 +94,8 @@ const machine = setup({
 		context: {} as {
 			isAuthenticated: boolean;
 			username: string | null;
-			routeParams: Record<string, string>;
-			queryParams: Record<string, string>;
+			params: Record<string, string>;
+			query: Record<string, string>;
 		},
 		events: {} as
 			| { type: "auth.login"; username: string }
@@ -106,7 +106,7 @@ const machine = setup({
 	formatPlayRouteTransitions({
 		id: "app",
 		initial: "login",
-		context: { isAuthenticated: false, username: null, routeParams: {}, queryParams: {} },
+		context: { isAuthenticated: false, username: null, params: {}, query: {} },
 		states: {
 			login: {
 				id: "login",
@@ -303,7 +303,7 @@ When using `formatPlayRouteTransitions`, URL path parameters flow automatically
 
 ```ts
 // spec: { section: undefined, user: "alice" }
-// After play.route to /settings/profile → context.routeParams = { section: "profile" }
+// After play.route to /settings/profile → context.params = { section: "profile" }
 // Component receives: { section: "profile", user: "alice" }
 ```
 

package/api/@xmachines/play-react/classes/PlayErrorBoundary.md

@@ -2,7 +2,7 @@
 
 # Class: PlayErrorBoundary
 
-Defined in: [packages/play-react/src/PlayErrorBoundary.tsx:53](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.25/packages/play-react/src/PlayErrorBoundary.tsx#L53)
+Defined in: [packages/play-react/src/PlayErrorBoundary.tsx:53](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-react/src/PlayErrorBoundary.tsx#L53)
 
 React class component error boundary for catching catalog component render errors.
 
@@ -36,7 +36,7 @@ Per CONS-14: Class component pattern works with all React versions (18 and 19).
 new PlayErrorBoundary(props): PlayErrorBoundary;
 ```
 
-Defined in: [packages/play-react/src/PlayErrorBoundary.tsx:57](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.25/packages/play-react/src/PlayErrorBoundary.tsx#L57)
+Defined in: [packages/play-react/src/PlayErrorBoundary.tsx:57](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-react/src/PlayErrorBoundary.tsx#L57)
 
 #### Parameters
 
@@ -75,7 +75,7 @@ React.Component<
 componentDidCatch(error, info): void;
 ```
 
-Defined in: [packages/play-react/src/PlayErrorBoundary.tsx:66](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.25/packages/play-react/src/PlayErrorBoundary.tsx#L66)
+Defined in: [packages/play-react/src/PlayErrorBoundary.tsx:66](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-react/src/PlayErrorBoundary.tsx#L66)
 
 Catches exceptions generated in descendant components. Unhandled exceptions will cause
 the entire component tree to unmount.
@@ -105,6 +105,8 @@ React.Component.componentDidCatch;
 optional componentDidMount(): void;
 ```
 
+Defined in: `@types/react`
+
 Called immediately after a component is mounted. Setting state here will trigger re-rendering.
 
 #### Returns
@@ -128,6 +130,8 @@ optional componentDidUpdate(
    snapshot?): void;
 ```
 
+Defined in: `@types/react`
+
 Called immediately after updating occurs. Not called for the initial render.
 
 The snapshot is only present if [getSnapshotBeforeUpdate](#getsnapshotbeforeupdate) is present and returns non-null.
@@ -158,6 +162,8 @@ React.Component.componentDidUpdate;
 optional componentWillMount(): void;
 ```
 
+Defined in: `@types/react`
+
 Called immediately before mounting occurs, and before [Component.render](https://www.jsdocs.io/package/@types/react#Component.render).
 Avoid introducing any side-effects or subscriptions in this method.
 
@@ -192,6 +198,8 @@ React.Component.componentWillMount;
 optional componentWillReceiveProps(nextProps, nextContext): void;
 ```
 
+Defined in: `@types/react`
+
 Called when the component may be receiving new props.
 React may call this even if props have not changed, so be sure to compare new and existing
 props if you only want to handle changes.
@@ -236,6 +244,8 @@ React.Component.componentWillReceiveProps;
 optional componentWillUnmount(): void;
 ```
 
+Defined in: `@types/react`
+
 Called immediately before a component is destroyed. Perform any necessary cleanup in this method, such as
 cancelled network requests, or cleaning up any DOM elements created in `componentDidMount`.
 
@@ -260,6 +270,8 @@ optional componentWillUpdate(
    nextContext): void;
 ```
 
+Defined in: `@types/react`
+
 Called immediately before rendering when new props or state is received. Not called for the initial render.
 
 Note: You cannot call [Component.setState](#setstate) here.
@@ -303,6 +315,8 @@ React.Component.componentWillUpdate;
 forceUpdate(callback?): void;
 ```
 
+Defined in: `@types/react`
+
 #### Parameters
 
 | Parameter   | Type         |
@@ -327,6 +341,8 @@ React.Component.forceUpdate;
 optional getSnapshotBeforeUpdate(prevProps, prevState): any;
 ```
 
+Defined in: `@types/react`
+
 Runs before React applies the result of [render](https://www.jsdocs.io/package/@types/react#Component.render) to the document, and
 returns an object to be given to [componentDidUpdate](#componentdidupdate). Useful for saving
 things such as scroll position before [render](https://www.jsdocs.io/package/@types/react#Component.render) causes changes to it.
@@ -359,7 +375,7 @@ React.Component.getSnapshotBeforeUpdate;
 render(): ReactNode;
 ```
 
-Defined in: [packages/play-react/src/PlayErrorBoundary.tsx:70](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.25/packages/play-react/src/PlayErrorBoundary.tsx#L70)
+Defined in: [packages/play-react/src/PlayErrorBoundary.tsx:70](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-react/src/PlayErrorBoundary.tsx#L70)
 
 #### Returns
 
@@ -379,6 +395,8 @@ React.Component.render;
 setState<K>(state, callback?): void;
 ```
 
+Defined in: `@types/react`
+
 #### Type Parameters
 
 | Type Parameter                                                                          |
@@ -413,6 +431,8 @@ optional shouldComponentUpdate(
    nextContext): boolean;
 ```
 
+Defined in: `@types/react`
+
 Called to determine whether the change in props and state should trigger a re-render.
 
 `Component` always returns true.
@@ -448,6 +468,8 @@ React.Component.shouldComponentUpdate;
 optional UNSAFE_componentWillMount(): void;
 ```
 
+Defined in: `@types/react`
+
 Called immediately before mounting occurs, and before [Component.render](https://www.jsdocs.io/package/@types/react#Component.render).
 Avoid introducing any side-effects or subscriptions in this method.
 
@@ -484,6 +506,8 @@ React.Component.UNSAFE_componentWillMount;
 optional UNSAFE_componentWillReceiveProps(nextProps, nextContext): void;
 ```
 
+Defined in: `@types/react`
+
 Called when the component may be receiving new props.
 React may call this even if props have not changed, so be sure to compare new and existing
 props if you only want to handle changes.
@@ -533,6 +557,8 @@ optional UNSAFE_componentWillUpdate(
    nextContext): void;
 ```
 
+Defined in: `@types/react`
+
 Called immediately before rendering when new props or state is received. Not called for the initial render.
 
 Note: You cannot call [Component.setState](#setstate) here.
@@ -578,7 +604,7 @@ React.Component.UNSAFE_componentWillUpdate;
 static getDerivedStateFromError(error): PlayErrorBoundaryState;
 ```
 
-Defined in: [packages/play-react/src/PlayErrorBoundary.tsx:62](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.25/packages/play-react/src/PlayErrorBoundary.tsx#L62)
+Defined in: [packages/play-react/src/PlayErrorBoundary.tsx:62](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-react/src/PlayErrorBoundary.tsx#L62)
 
 #### Parameters
 

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

@@ -6,6 +6,8 @@
 function defineRegistry<C>(_catalog, options): DefineRegistryResult;
 ```
 
+Defined in: `@json-render/react`
+
 Create a registry from a catalog with components and/or actions.
 
 When the catalog declares actions, the `actions` field is required.

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

@@ -6,7 +6,7 @@
 function useActor(): PlayActor;
 ```
 
-Defined in: [packages/play-react/src/useActor.ts:30](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.25/packages/play-react/src/useActor.ts#L30)
+Defined in: [packages/play-react/src/useActor.ts:30](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-react/src/useActor.ts#L30)
 
 ## Returns
 

package/api/@xmachines/play-react/functions/useBoundProp.md

@@ -6,6 +6,8 @@
 function useBoundProp<T>(propValue, bindingPath): [T | undefined, (value) => void];
 ```
 
+Defined in: `@json-render/react`
+
 Hook for two-way bound props. Returns `[value, setValue]` where:
 
 - `value` is the already-resolved prop value (passed through from render props)

package/api/@xmachines/play-react/functions/useSignalEffect.md

@@ -6,7 +6,7 @@
 function useSignalEffect(callback): void;
 ```
 
-Defined in: [packages/play-react/src/useSignalEffect.ts:71](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.25/packages/play-react/src/useSignalEffect.ts#L71)
+Defined in: [packages/play-react/src/useSignalEffect.ts:71](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v1.0.0-beta.27/packages/play-react/src/useSignalEffect.ts#L71)
 
 React hook that subscribes to signal changes and runs effect callback
 

package/api/@xmachines/play-react/functions/useStateBinding.md

@@ -6,6 +6,8 @@
 function useStateBinding<T>(path): [T | undefined, (value) => void];
 ```
 
+Defined in: `@json-render/react`
+
 Hook to get and set a value from the state model (like useState).
 
 ## Type Parameters

package/api/@xmachines/play-react/interfaces/ComponentContext.md

@@ -2,6 +2,8 @@
 
 # Interface: ComponentContext\<C, K\>
 
+Defined in: `@json-render/react`
+
 Context passed to component render functions
 
 ## Example