@xmachines/play-solid 2.0.0 → 2.1.0

package/README.md

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

package/dist/ActorProvider.d.ts

@@ -1,19 +1,19 @@
 /**
- * ActorProvider — Smart SolidJS provider component for the XMachines Play actor lifecycle.
+ * ActorProvider — the SolidJS provider component of the XMachines Play actor lifecycle.
  *
- * Escape hatch primitive for library authors who need direct control. Most users should
- * use PlayUIProvider (batteries-included composite) instead.
+ * This is the low-level provider, for the author of a library who needs the control.
+ * Most users take PlayUIProvider, the composite provider, instead.
  *
  * This component:
- * - Subscribes to actor.currentView signal via watchSignal (in component body per Phase 29)
- * - Manages per-view StateStore lifecycle (controlled/uncontrolled)
- * - Resolves action handlers via inner component pattern (inside StateProvider)
- * - Injects onRenderError into registry if provided
- * - Provides ActorContext (actor) and ViewContext (spec + handlers + registry) to children
- * - Wraps render path in SolidJS ErrorBoundary
+ * - subscribes to the actor.currentView signal with watchSignal, in the body of the component (Phase 29)
+ * - manages the StateStore lifecycle of each view, controlled and uncontrolled
+ * - resolves each action handler with the inner component pattern, inside StateProvider
+ * - puts onRenderError into the registry, when the caller gives one
+ * - gives ActorContext (the actor) and ViewContext (the spec, the handlers, and the registry) to the children
+ * - wraps the render path in a SolidJS ErrorBoundary
  *
- * Per D-11: The old `ActorProvider = ActorContext.Provider` alias is removed. This new smart
- * component takes the name. Use `ActorContext.Provider` directly for escape-hatch access.
+ * D-11: the old alias `ActorProvider = ActorContext.Provider` is gone. This component
+ * has the name now. Use `ActorContext.Provider` directly for the raw access.
  *
  * @packageDocumentation
  */
@@ -22,15 +22,15 @@ import type { DefineRegistryResult } from "@xmachines/json-render-solid";
 import type { ComponentRegistry } from "@xmachines/json-render-solid";
 import { type BaseActorProviderProps, type BaseViewContextValue } from "@xmachines/play-actor";
 /**
- * Value provided by ActorProvider's ViewContext.
- * Access via usePlayView() inside the ActorProvider tree.
+ * The value that the ViewContext of ActorProvider provides.
+ * usePlayView() gives it inside the ActorProvider tree.
  */
 export interface ViewContextValue extends BaseViewContextValue<ComponentRegistry> {
 }
 /**
- * Hook to access the current view context inside an ActorProvider tree.
+ * The hook that gives the current view context inside an ActorProvider tree.
  *
- * @throws {Error} If called outside an ActorProvider (or PlayUIProvider) tree
+ * @throws {Error} When the caller is outside an ActorProvider tree or a PlayUIProvider tree
  *
  * @example
  * ```tsx
@@ -44,27 +44,32 @@ export interface ViewContextValue extends BaseViewContextValue<ComponentRegistry
  */
 export declare function usePlayView(): ViewContextValue;
 /**
- * Props for ActorProvider — the escape hatch primitive.
+ * The props of ActorProvider, the low-level provider.
  *
- * For batteries-included usage, prefer PlayUIProvider which wraps ActorProvider
- * with JSONUIProvider and all required sub-providers.
+ * For the standard use, prefer PlayUIProvider. That component wraps ActorProvider
+ * with JSONUIProvider and with every necessary sub-provider.
  */
 export interface ActorProviderProps extends BaseActorProviderProps<DefineRegistryResult> {
-    /** Optional fallback element shown when currentView is null or ErrorBoundary catches */
+    /**
+     * The optional fallback element. The provider shows it when currentView is null, and when the ErrorBoundary catches an error
+     */
     fallback?: JSX.Element;
-    /** Optional callback invoked when SolidJS ErrorBoundary catches an error */
+    /** The optional callback. The provider calls it when the SolidJS ErrorBoundary catches an error */
     onError?: (error: unknown) => void;
-    /** Children — required; must include <PlayRenderer /> (or use PlayUIProvider shorthand) */
+    /**
+     * The children. They are necessary, and they must hold a <PlayRenderer />. You can also use the PlayUIProvider short form
+     */
     children: JSX.Element;
 }
 /**
- * Smart ActorProvider component — owns actor bridging, signal subscription,
- * StateStore lifecycle, handler resolution, and error boundary.
+ * The ActorProvider component. It owns the actor bridge, the signal subscription, the
+ * StateStore lifecycle, the resolution of the handlers, and the error boundary.
  *
- * Per D-11: Replaces the old raw alias `ActorProvider = ActorContext.Provider`.
- * Consumers who previously used `<ActorProvider value={actor}>` should now use
- * `<ActorContext.Provider value={actor}>` for raw provider access, or migrate to
- * this smart component / PlayUIProvider.
+ * D-11: this component replaces the old raw alias
+ * `ActorProvider = ActorContext.Provider`. A consumer with an
+ * `<ActorProvider value={actor}>` element takes
+ * `<ActorContext.Provider value={actor}>` now, for the raw access to the provider.
+ * That consumer can also move to this component, or to PlayUIProvider.
  *
  * @example
  * ```tsx

package/dist/ActorProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ActorProvider.d.ts","sourceRoot":"","sources":["../src/ActorProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAWH,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/C,OAAO,KAAK,EAAE,oBAAoB,EAAY,MAAM,8BAA8B,CAAC;AAEnF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAKtE,OAAO,EAIN,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,MAAM,uBAAuB,CAAC;AAO/B;;;GAGG;AACH,MAAM,WAAW,gBAAiB,SAAQ,oBAAoB,CAAC,iBAAiB,CAAC;CAAG;AAIpF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,IAAI,gBAAgB,CAE9C;AAMD;;;;;GAKG;AACH,MAAM,WAAW,kBAAmB,SAAQ,sBAAsB,CAAC,oBAAoB,CAAC;IACvF,wFAAwF;IACxF,QAAQ,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC;IAEvB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAEnC,2FAA2F;IAC3F,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC;CACtB;AA2CD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,aAAa,EAAE,SAAS,CAAC,kBAAkB,CA+FvD,CAAC"}
+{"version":3,"file":"ActorProvider.d.ts","sourceRoot":"","sources":["../src/ActorProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAWH,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/C,OAAO,KAAK,EAAE,oBAAoB,EAAY,MAAM,8BAA8B,CAAC;AAEnF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAKtE,OAAO,EAIN,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,MAAM,uBAAuB,CAAC;AAO/B;;;GAGG;AACH,MAAM,WAAW,gBAAiB,SAAQ,oBAAoB,CAAC,iBAAiB,CAAC;CAAG;AAIpF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,IAAI,gBAAgB,CAE9C;AAMD;;;;;GAKG;AACH,MAAM,WAAW,kBAAmB,SAAQ,sBAAsB,CAAC,oBAAoB,CAAC;IACvF;;OAEG;IACH,QAAQ,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC;IAEvB,mGAAmG;IACnG,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAEnC;;OAEG;IACH,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC;CACtB;AA4CD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,EAAE,SAAS,CAAC,kBAAkB,CAkGvD,CAAC"}

package/dist/ActorProvider.js

@@ -9,29 +9,29 @@ import { assertNonNullable } from "@xmachines/play";
 import { attachRenderErrorHandler, createViewStoreLifecycle } from "@xmachines/play-actor";
 //#region packages/play-solid/src/ActorProvider.tsx
 /**
-* ActorProvider — Smart SolidJS provider component for the XMachines Play actor lifecycle.
+* ActorProvider — the SolidJS provider component of the XMachines Play actor lifecycle.
 *
-* Escape hatch primitive for library authors who need direct control. Most users should
-* use PlayUIProvider (batteries-included composite) instead.
+* This is the low-level provider, for the author of a library who needs the control.
+* Most users take PlayUIProvider, the composite provider, instead.
 *
 * This component:
-* - Subscribes to actor.currentView signal via watchSignal (in component body per Phase 29)
-* - Manages per-view StateStore lifecycle (controlled/uncontrolled)
-* - Resolves action handlers via inner component pattern (inside StateProvider)
-* - Injects onRenderError into registry if provided
-* - Provides ActorContext (actor) and ViewContext (spec + handlers + registry) to children
-* - Wraps render path in SolidJS ErrorBoundary
+* - subscribes to the actor.currentView signal with watchSignal, in the body of the component (Phase 29)
+* - manages the StateStore lifecycle of each view, controlled and uncontrolled
+* - resolves each action handler with the inner component pattern, inside StateProvider
+* - puts onRenderError into the registry, when the caller gives one
+* - gives ActorContext (the actor) and ViewContext (the spec, the handlers, and the registry) to the children
+* - wraps the render path in a SolidJS ErrorBoundary
 *
-* Per D-11: The old `ActorProvider = ActorContext.Provider` alias is removed. This new smart
-* component takes the name. Use `ActorContext.Provider` directly for escape-hatch access.
+* D-11: the old alias `ActorProvider = ActorContext.Provider` is gone. This component
+* has the name now. Use `ActorContext.Provider` directly for the raw access.
 *
 * @packageDocumentation
 */
 var ViewContext = createContext(null);
 /**
-* Hook to access the current view context inside an ActorProvider tree.
+* The hook that gives the current view context inside an ActorProvider tree.
 *
-* @throws {Error} If called outside an ActorProvider (or PlayUIProvider) tree
+* @throws {Error} When the caller is outside an ActorProvider tree or a PlayUIProvider tree
 *
 * @example
 * ```tsx
@@ -47,8 +47,9 @@ function usePlayView() {
 	return assertNonNullable(useContext(ViewContext), "ViewContext");
 }
 /**
-* Inner component that runs inside StateProvider so it can call useStateStore()
-* to get live set/getSnapshot for handler resolution.
+* The inner component runs inside StateProvider. It can therefore call
+* useStateStore() to get the live set function and the live getSnapshot function, for
+* the resolution of the handlers.
 */
 var ActorProviderInner = (innerProps) => {
 	const stateCtx = useStateStore();
@@ -71,13 +72,14 @@ var ActorProviderInner = (innerProps) => {
 	});
 };
 /**
-* Smart ActorProvider component — owns actor bridging, signal subscription,
-* StateStore lifecycle, handler resolution, and error boundary.
+* The ActorProvider component. It owns the actor bridge, the signal subscription, the
+* StateStore lifecycle, the resolution of the handlers, and the error boundary.
 *
-* Per D-11: Replaces the old raw alias `ActorProvider = ActorContext.Provider`.
-* Consumers who previously used `<ActorProvider value={actor}>` should now use
-* `<ActorContext.Provider value={actor}>` for raw provider access, or migrate to
-* this smart component / PlayUIProvider.
+* D-11: this component replaces the old raw alias
+* `ActorProvider = ActorContext.Provider`. A consumer with an
+* `<ActorProvider value={actor}>` element takes
+* `<ActorContext.Provider value={actor}>` now, for the raw access to the provider.
+* That consumer can also move to this component, or to PlayUIProvider.
 *
 * @example
 * ```tsx

package/dist/ActorProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"ActorProvider.js","names":["createSignal","createEffect","createMemo","onCleanup","createContext","useContext","ErrorBoundary","Component","JSX","StateProvider","useStateStore","DefineRegistryResult","SetState","StateStore","ComponentRegistry","createAtom","xstateStoreStateStore","watchSignal","assertNonNullable","attachRenderErrorHandler","createViewStoreLifecycle","PlaySpec","BaseActorProviderProps","BaseViewContextValue","ActorContext","AnyPlayActor","ViewContextValue","ViewContext","usePlayView","ActorProviderProps","fallback","Element","onError","error","children","ActorProviderInner","registryResult","spec","store","innerProps","stateCtx","setStateAdapter","updater","prev","getSnapshot","update","handlers","viewValue","registry","_$createComponent","Provider","value","ActorProvider","props","view","setView","actorProxy","Proxy","get","_target","prop","current","actor","Reflect","bind","has","resolvedRegistryResult","onRenderError","storeLifecycle","seed","atom","nextView","currentView","unwatch","err","resolve","guardedStore"],"sources":["../src/ActorProvider.tsx"],"sourcesContent":["/**\n * ActorProvider — Smart SolidJS provider component for the XMachines Play actor lifecycle.\n *\n * Escape hatch primitive for library authors who need direct control. Most users should\n * use PlayUIProvider (batteries-included composite) instead.\n *\n * This component:\n * - Subscribes to actor.currentView signal via watchSignal (in component body per Phase 29)\n * - Manages per-view StateStore lifecycle (controlled/uncontrolled)\n * - Resolves action handlers via inner component pattern (inside StateProvider)\n * - Injects onRenderError into registry if provided\n * - Provides ActorContext (actor) and ViewContext (spec + handlers + registry) to children\n * - Wraps render path in SolidJS ErrorBoundary\n *\n * Per D-11: The old `ActorProvider = ActorContext.Provider` alias is removed. This new smart\n * component takes the name. Use `ActorContext.Provider` directly for escape-hatch access.\n *\n * @packageDocumentation\n */\n\nimport {\n\tcreateSignal,\n\tcreateEffect,\n\tcreateMemo,\n\tonCleanup,\n\tcreateContext,\n\tuseContext,\n\tErrorBoundary,\n} from \"solid-js\";\nimport type { Component, JSX } from \"solid-js\";\nimport { StateProvider, useStateStore } from \"@xmachines/json-render-solid\";\nimport type { DefineRegistryResult, SetState } from \"@xmachines/json-render-solid\";\nimport type { StateStore } from \"@xmachines/json-render-core\";\nimport type { ComponentRegistry } from \"@xmachines/json-render-solid\";\nimport { createAtom } from \"@xstate/store\";\nimport { xstateStoreStateStore } from \"@xmachines/json-render-xstate\";\nimport { watchSignal } from \"@xmachines/play-signals\";\nimport { assertNonNullable } from \"@xmachines/play\";\nimport {\n\tattachRenderErrorHandler,\n\tcreateViewStoreLifecycle,\n\ttype PlaySpec,\n\ttype BaseActorProviderProps,\n\ttype BaseViewContextValue,\n} from \"@xmachines/play-actor\";\nimport { ActorContext, type AnyPlayActor } from \"./useActor.js\";\n\n// ---------------------------------------------------------------------------\n// ViewContextValue — shape of the context value provided by ActorProvider\n// ---------------------------------------------------------------------------\n\n/**\n * Value provided by ActorProvider's ViewContext.\n * Access via usePlayView() inside the ActorProvider tree.\n */\nexport interface ViewContextValue extends BaseViewContextValue<ComponentRegistry> {}\n\nconst ViewContext = createContext<ViewContextValue | null>(null);\n\n/**\n * Hook to access the current view context inside an ActorProvider tree.\n *\n * @throws {Error} If called outside an ActorProvider (or PlayUIProvider) tree\n *\n * @example\n * ```tsx\n * import { usePlayView } from \"@xmachines/play-solid\";\n *\n * const MyRenderer: Component = () => {\n *   const view = usePlayView();\n *   return <Renderer spec={view.spec} registry={view.registry} />;\n * };\n * ```\n */\nexport function usePlayView(): ViewContextValue {\n\treturn assertNonNullable(useContext(ViewContext), \"ViewContext\");\n}\n\n// ---------------------------------------------------------------------------\n// ActorProviderProps\n// ---------------------------------------------------------------------------\n\n/**\n * Props for ActorProvider — the escape hatch primitive.\n *\n * For batteries-included usage, prefer PlayUIProvider which wraps ActorProvider\n * with JSONUIProvider and all required sub-providers.\n */\nexport interface ActorProviderProps extends BaseActorProviderProps<DefineRegistryResult> {\n\t/** Optional fallback element shown when currentView is null or ErrorBoundary catches */\n\tfallback?: JSX.Element;\n\n\t/** Optional callback invoked when SolidJS ErrorBoundary catches an error */\n\tonError?: (error: unknown) => void;\n\n\t/** Children — required; must include <PlayRenderer /> (or use PlayUIProvider shorthand) */\n\tchildren: JSX.Element;\n}\n\n// ---------------------------------------------------------------------------\n// ActorProviderInner — resolves handlers inside StateProvider tree\n// ---------------------------------------------------------------------------\n\n/**\n * Inner component that runs inside StateProvider so it can call useStateStore()\n * to get live set/getSnapshot for handler resolution.\n */\nconst ActorProviderInner: Component<{\n\tregistryResult: DefineRegistryResult;\n\tspec: PlaySpec;\n\tstore: StateStore;\n\tchildren: JSX.Element;\n}> = (innerProps) => {\n\tconst stateCtx = useStateStore();\n\n\t// Build SetState adapter bridging stateCtx.update/getSnapshot\n\tconst setStateAdapter: SetState = (updater) => {\n\t\tconst prev = stateCtx.getSnapshot();\n\t\tstateCtx.update(updater(prev));\n\t};\n\n\tconst handlers = innerProps.registryResult.handlers(\n\t\t() => setStateAdapter,\n\t\t() => stateCtx.getSnapshot(),\n\t);\n\n\tconst viewValue: ViewContextValue = {\n\t\tspec: innerProps.spec,\n\t\thandlers,\n\t\tregistry: innerProps.registryResult.registry,\n\t\tstore: innerProps.store,\n\t};\n\n\treturn <ViewContext.Provider value={viewValue}>{innerProps.children}</ViewContext.Provider>;\n};\n\n// ---------------------------------------------------------------------------\n// ActorProvider — the smart component (per D-11 takes the ActorProvider name)\n// ---------------------------------------------------------------------------\n\n/**\n * Smart ActorProvider component — owns actor bridging, signal subscription,\n * StateStore lifecycle, handler resolution, and error boundary.\n *\n * Per D-11: Replaces the old raw alias `ActorProvider = ActorContext.Provider`.\n * Consumers who previously used `<ActorProvider value={actor}>` should now use\n * `<ActorContext.Provider value={actor}>` for raw provider access, or migrate to\n * this smart component / PlayUIProvider.\n *\n * @example\n * ```tsx\n * import { ActorProvider, PlayRenderer } from \"@xmachines/play-solid\";\n *\n * <ActorProvider actor={myActor} registryResult={registryResult}>\n *   <PlayRenderer />\n * </ActorProvider>\n * ```\n */\nexport const ActorProvider: Component<ActorProviderProps> = (props) => {\n\t// SolidJS signal for current view (PlaySpec | null)\n\tconst [view, setView] = createSignal<PlaySpec | null>(null);\n\n\t// A stable Proxy is provided as the ActorContext value instead of the raw\n\t// actor: Solid's Context.Provider reads `value` once at creation, so passing\n\t// `props.actor` directly would snapshot the FIRST actor and useActor()\n\t// consumers would never see a prop swap. With the proxy, consumers keep the\n\t// reference obtained at creation time, yet every property access (send,\n\t// currentView, …) resolves against the latest actor. Reading `props.actor`\n\t// inside the traps is a reactive read, so consumers accessing properties in\n\t// tracking scopes (createEffect, createMemo, JSX) re-run on swap. Methods\n\t// are bound to the current actor so `this` (including private fields) works\n\t// exactly as with a direct call. Mirrors play-vue's ActorProvider proxy.\n\tconst actorProxy = new Proxy({} as AnyPlayActor, {\n\t\tget(_target, prop) {\n\t\t\tconst current = props.actor as AnyPlayActor;\n\t\t\tconst value = Reflect.get(current, prop, current) as unknown;\n\t\t\treturn typeof value === \"function\" ? value.bind(current) : value;\n\t\t},\n\t\thas(_target, prop) {\n\t\t\treturn prop in (props.actor as AnyPlayActor);\n\t\t},\n\t});\n\n\t// Inject onRenderError into registry if provided (non-enumerable override).\n\t// Memoized so that creating a new object on every reactive evaluation does not\n\t// cause unnecessary re-renders of child components that receive this as a prop.\n\tconst resolvedRegistryResult = createMemo(() => {\n\t\tif (!props.onRenderError) return props.registryResult;\n\t\treturn {\n\t\t\t...props.registryResult,\n\t\t\tregistry: attachRenderErrorHandler(props.registryResult.registry, props.onRenderError),\n\t\t};\n\t});\n\n\t// Store lifecycle (reseed on viewKey change, refresh /context in place\n\t// otherwise, actor-swap reset, guard identity cache) — the shared\n\t// coordinator from @xmachines/play-actor; only the reactivity wiring in the\n\t// tracked JSX scope below is Solid's.\n\tconst storeLifecycle = createViewStoreLifecycle((seed) =>\n\t\txstateStoreStateStore({ atom: createAtom(seed) }),\n\t);\n\n\t// Bridge TC39 Signal to SolidJS signal — seed AND watch atomically inside a single\n\t// createEffect to eliminate the race window between .get() and watcher registration.\n\t// If the TC39 signal changes between the initial .get() and first watcher notification,\n\t// the update function captures the latest value without missing it.\n\tcreateEffect(() => {\n\t\tconst update = (nextView: PlaySpec | null) => setView(nextView);\n\t\tupdate(props.actor.currentView.get() as PlaySpec | null);\n\t\tconst unwatch = watchSignal(props.actor.currentView, (nextView) => {\n\t\t\tupdate(nextView as PlaySpec | null);\n\t\t});\n\t\tonCleanup(() => unwatch());\n\t});\n\n\treturn (\n\t\t<ActorContext.Provider value={actorProxy}>\n\t\t\t<ErrorBoundary\n\t\t\t\tfallback={(err: unknown) => {\n\t\t\t\t\tprops.onError?.(err);\n\t\t\t\t\treturn props.fallback ?? null;\n\t\t\t\t}}\n\t\t\t>\n\t\t\t\t{(() => {\n\t\t\t\t\tconst currentView = view();\n\t\t\t\t\tif (!currentView) return props.fallback ?? null;\n\n\t\t\t\t\t// Resolve the store (external/controlled or internal\n\t\t\t\t\t// per-viewKey) via the shared lifecycle; children get the\n\t\t\t\t\t// guarded store — /context is read-only to the spec. Reading\n\t\t\t\t\t// props.actor and props.store HERE keeps both tracked in this\n\t\t\t\t\t// scope, so swaps re-run the resolution.\n\t\t\t\t\tconst store: StateStore = storeLifecycle.resolve(\n\t\t\t\t\t\tprops.actor,\n\t\t\t\t\t\tcurrentView,\n\t\t\t\t\t\tprops.store,\n\t\t\t\t\t).guardedStore;\n\n\t\t\t\t\treturn (\n\t\t\t\t\t\t<StateProvider store={store}>\n\t\t\t\t\t\t\t<ActorProviderInner\n\t\t\t\t\t\t\t\tregistryResult={resolvedRegistryResult()}\n\t\t\t\t\t\t\t\tspec={currentView}\n\t\t\t\t\t\t\t\tstore={store}\n\t\t\t\t\t\t\t>\n\t\t\t\t\t\t\t\t{props.children}\n\t\t\t\t\t\t\t</ActorProviderInner>\n\t\t\t\t\t\t</StateProvider>\n\t\t\t\t\t);\n\t\t\t\t})()}\n\t\t\t</ErrorBoundary>\n\t\t</ActorContext.Provider>\n\t);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,IAAM2B,cAAcvB,cAAuC,IAAI;;;;;;;;;;;;;;;;AAiB/D,SAAgBwB,cAAgC;CAC/C,OAAOV,kBAAkBb,WAAWsB,WAAW,GAAG,aAAa;AAChE;;;;;AA+BA,IAAMQ,sBAKAI,eAAe;CACpB,MAAMC,WAAW9B,cAAc;CAG/B,MAAM+B,mBAA6BC,YAAY;EAC9C,MAAMC,OAAOH,SAASI,YAAY;EAClCJ,SAASK,OAAOH,QAAQC,IAAI,CAAC;CAC9B;CAEA,MAAMG,WAAWP,WAAWH,eAAeU,eACpCL,uBACAD,SAASI,YAAY,CAC5B;CAEA,MAAMG,YAA8B;EACnCV,MAAME,WAAWF;EACjBS;EACAE,UAAUT,WAAWH,eAAeY;EACpCV,OAAOC,WAAWD;CACnB;CAEA,OAAAW,gBAAQtB,YAAYuB,UAAQ;EAACC,OAAOJ;EAAS,IAAAb,WAAA;GAAA,OAAGK,WAAWL;EAAQ;CAAA,CAAA;AACpE;;;;;;;;;;;;;;;;;;;AAwBA,IAAakB,iBAAgDC,UAAU;CAEtE,MAAM,CAACC,MAAMC,WAAWvD,aAA8B,IAAI;CAY1D,MAAMwD,aAAa,IAAIC,MAAM,CAAC,GAAmB;EAChDC,IAAIC,SAASC,MAAM;GAClB,MAAMC,UAAUR,MAAMS;GACtB,MAAMX,QAAQY,QAAQL,IAAIG,SAASD,MAAMC,OAAO;GAChD,OAAO,OAAOV,UAAU,aAAaA,MAAMa,KAAKH,OAAO,IAAIV;EAC5D;EACAc,IAAIN,SAASC,MAAM;GAClB,OAAOA,QAASP,MAAMS;EACvB;CACD,CAAC;CAKD,MAAMI,yBAAyBhE,iBAAiB;EAC/C,IAAI,CAACmD,MAAMc,eAAe,OAAOd,MAAMjB;EACvC,OAAO;GACN,GAAGiB,MAAMjB;GACTY,UAAU7B,yBAAyBkC,MAAMjB,eAAeY,UAAUK,MAAMc,aAAa;EACtF;CACD,CAAC;CAMD,MAAMC,iBAAiBhD,0BAA0BiD,SAChDrD,sBAAsB,EAAEsD,MAAMvD,WAAWsD,IAAI,EAAE,CAAC,CACjD;CAMApE,mBAAmB;EAClB,MAAM4C,UAAU0B,aAA8BhB,QAAQgB,QAAQ;EAC9D1B,OAAOQ,MAAMS,MAAMU,YAAYd,IAAI,CAAoB;EACvD,MAAMe,UAAUxD,YAAYoC,MAAMS,MAAMU,cAAcD,aAAa;GAClE1B,OAAO0B,QAA2B;EACnC,CAAC;EACDpE,gBAAgBsE,QAAQ,CAAC;CAC1B,CAAC;CAED,OAAAxB,gBACEzB,aAAa0B,UAAQ;EAACC,OAAOK;EAAU,IAAAtB,WAAA;GAAA,OAAAe,gBACtC3C,eAAa;IACbwB,WAAW4C,QAAiB;KAC3BrB,MAAMrB,UAAU0C,GAAG;KACnB,OAAOrB,MAAMvB,YAAY;IAC1B;IAAC,IAAAI,WAAA;KAAA,cAEO;MACP,MAAMsC,cAAclB,KAAK;MACzB,IAAI,CAACkB,aAAa,OAAOnB,MAAMvB,YAAY;MAO3C,MAAMQ,QAAoB8B,eAAeO,QACxCtB,MAAMS,OACNU,aACAnB,MAAMf,KACP,CAAC,CAACsC;MAEF,OAAA3B,gBACExC,eAAa;OAAQ6B;OAAK,IAAAJ,WAAA;QAAA,OAAAe,gBACzBd,oBAAkB;SAAA,IAClBC,iBAAc;UAAA,OAAE8B,uBAAuB;SAAC;SACxC7B,MAAMmC;SACClC;SAAK,IAAAJ,WAAA;UAAA,OAEXmB,MAAMnB;SAAQ;QAAA,CAAA;OAAA;MAAA,CAAA;KAInB,EAAA,CAAG;IAAC;GAAA,CAAA;EAAA;CAAA,CAAA;AAIR"}
+{"version":3,"file":"ActorProvider.js","names":["createSignal","createEffect","createMemo","onCleanup","createContext","useContext","ErrorBoundary","Component","JSX","StateProvider","useStateStore","DefineRegistryResult","SetState","StateStore","ComponentRegistry","createAtom","xstateStoreStateStore","watchSignal","assertNonNullable","attachRenderErrorHandler","createViewStoreLifecycle","PlaySpec","BaseActorProviderProps","BaseViewContextValue","ActorContext","AnyPlayActor","ViewContextValue","ViewContext","usePlayView","ActorProviderProps","fallback","Element","onError","error","children","ActorProviderInner","registryResult","spec","store","innerProps","stateCtx","setStateAdapter","updater","prev","getSnapshot","update","handlers","viewValue","registry","_$createComponent","Provider","value","ActorProvider","props","view","setView","actorProxy","Proxy","get","_target","prop","current","actor","Reflect","bind","has","resolvedRegistryResult","onRenderError","storeLifecycle","seed","atom","nextView","currentView","unwatch","err","resolve","guardedStore"],"sources":["../src/ActorProvider.tsx"],"sourcesContent":["/**\n * ActorProvider — the SolidJS provider component of the XMachines Play actor lifecycle.\n *\n * This is the low-level provider, for the author of a library who needs the control.\n * Most users take PlayUIProvider, the composite provider, instead.\n *\n * This component:\n * - subscribes to the actor.currentView signal with watchSignal, in the body of the component (Phase 29)\n * - manages the StateStore lifecycle of each view, controlled and uncontrolled\n * - resolves each action handler with the inner component pattern, inside StateProvider\n * - puts onRenderError into the registry, when the caller gives one\n * - gives ActorContext (the actor) and ViewContext (the spec, the handlers, and the registry) to the children\n * - wraps the render path in a SolidJS ErrorBoundary\n *\n * D-11: the old alias `ActorProvider = ActorContext.Provider` is gone. This component\n * has the name now. Use `ActorContext.Provider` directly for the raw access.\n *\n * @packageDocumentation\n */\n\nimport {\n\tcreateSignal,\n\tcreateEffect,\n\tcreateMemo,\n\tonCleanup,\n\tcreateContext,\n\tuseContext,\n\tErrorBoundary,\n} from \"solid-js\";\nimport type { Component, JSX } from \"solid-js\";\nimport { StateProvider, useStateStore } from \"@xmachines/json-render-solid\";\nimport type { DefineRegistryResult, SetState } from \"@xmachines/json-render-solid\";\nimport type { StateStore } from \"@xmachines/json-render-core\";\nimport type { ComponentRegistry } from \"@xmachines/json-render-solid\";\nimport { createAtom } from \"@xstate/store\";\nimport { xstateStoreStateStore } from \"@xmachines/json-render-xstate\";\nimport { watchSignal } from \"@xmachines/play-signals\";\nimport { assertNonNullable } from \"@xmachines/play\";\nimport {\n\tattachRenderErrorHandler,\n\tcreateViewStoreLifecycle,\n\ttype PlaySpec,\n\ttype BaseActorProviderProps,\n\ttype BaseViewContextValue,\n} from \"@xmachines/play-actor\";\nimport { ActorContext, type AnyPlayActor } from \"./useActor.js\";\n\n// ---------------------------------------------------------------------------\n// ViewContextValue — the shape of the context value that ActorProvider gives\n// ---------------------------------------------------------------------------\n\n/**\n * The value that the ViewContext of ActorProvider provides.\n * usePlayView() gives it inside the ActorProvider tree.\n */\nexport interface ViewContextValue extends BaseViewContextValue<ComponentRegistry> {}\n\nconst ViewContext = createContext<ViewContextValue | null>(null);\n\n/**\n * The hook that gives the current view context inside an ActorProvider tree.\n *\n * @throws {Error} When the caller is outside an ActorProvider tree or a PlayUIProvider tree\n *\n * @example\n * ```tsx\n * import { usePlayView } from \"@xmachines/play-solid\";\n *\n * const MyRenderer: Component = () => {\n *   const view = usePlayView();\n *   return <Renderer spec={view.spec} registry={view.registry} />;\n * };\n * ```\n */\nexport function usePlayView(): ViewContextValue {\n\treturn assertNonNullable(useContext(ViewContext), \"ViewContext\");\n}\n\n// ---------------------------------------------------------------------------\n// ActorProviderProps\n// ---------------------------------------------------------------------------\n\n/**\n * The props of ActorProvider, the low-level provider.\n *\n * For the standard use, prefer PlayUIProvider. That component wraps ActorProvider\n * with JSONUIProvider and with every necessary sub-provider.\n */\nexport interface ActorProviderProps extends BaseActorProviderProps<DefineRegistryResult> {\n\t/**\n\t * The optional fallback element. The provider shows it when currentView is null, and when the ErrorBoundary catches an error\n\t */\n\tfallback?: JSX.Element;\n\n\t/** The optional callback. The provider calls it when the SolidJS ErrorBoundary catches an error */\n\tonError?: (error: unknown) => void;\n\n\t/**\n\t * The children. They are necessary, and they must hold a <PlayRenderer />. You can also use the PlayUIProvider short form\n\t */\n\tchildren: JSX.Element;\n}\n\n// ---------------------------------------------------------------------------\n// ActorProviderInner — it resolves the handlers inside the StateProvider tree\n// ---------------------------------------------------------------------------\n\n/**\n * The inner component runs inside StateProvider. It can therefore call\n * useStateStore() to get the live set function and the live getSnapshot function, for\n * the resolution of the handlers.\n */\nconst ActorProviderInner: Component<{\n\tregistryResult: DefineRegistryResult;\n\tspec: PlaySpec;\n\tstore: StateStore;\n\tchildren: JSX.Element;\n}> = (innerProps) => {\n\tconst stateCtx = useStateStore();\n\n\t// Build the SetState adapter. It joins stateCtx.update and stateCtx.getSnapshot\n\tconst setStateAdapter: SetState = (updater) => {\n\t\tconst prev = stateCtx.getSnapshot();\n\t\tstateCtx.update(updater(prev));\n\t};\n\n\tconst handlers = innerProps.registryResult.handlers(\n\t\t() => setStateAdapter,\n\t\t() => stateCtx.getSnapshot(),\n\t);\n\n\tconst viewValue: ViewContextValue = {\n\t\tspec: innerProps.spec,\n\t\thandlers,\n\t\tregistry: innerProps.registryResult.registry,\n\t\tstore: innerProps.store,\n\t};\n\n\treturn <ViewContext.Provider value={viewValue}>{innerProps.children}</ViewContext.Provider>;\n};\n\n// ---------------------------------------------------------------------------\n// ActorProvider — the component. D-11 gives it the ActorProvider name\n// ---------------------------------------------------------------------------\n\n/**\n * The ActorProvider component. It owns the actor bridge, the signal subscription, the\n * StateStore lifecycle, the resolution of the handlers, and the error boundary.\n *\n * D-11: this component replaces the old raw alias\n * `ActorProvider = ActorContext.Provider`. A consumer with an\n * `<ActorProvider value={actor}>` element takes\n * `<ActorContext.Provider value={actor}>` now, for the raw access to the provider.\n * That consumer can also move to this component, or to PlayUIProvider.\n *\n * @example\n * ```tsx\n * import { ActorProvider, PlayRenderer } from \"@xmachines/play-solid\";\n *\n * <ActorProvider actor={myActor} registryResult={registryResult}>\n *   <PlayRenderer />\n * </ActorProvider>\n * ```\n */\nexport const ActorProvider: Component<ActorProviderProps> = (props) => {\n\t// The SolidJS signal of the current view (PlaySpec | null)\n\tconst [view, setView] = createSignal<PlaySpec | null>(null);\n\n\t// The code gives a stable Proxy as the value of ActorContext, and not the raw actor.\n\t// The Context.Provider of Solid reads `value` one time, at its creation. Therefore\n\t// `props.actor` gives the FIRST actor only, and a useActor() consumer sees a change of\n\t// the prop never. With the proxy, each consumer keeps the reference of the creation,\n\t// and every property access (send, currentView, and the others) resolves against the\n\t// newest actor. A read of `props.actor` inside a trap is a reactive read. Therefore a\n\t// consumer that reads a property in a tracking scope, such as createEffect,\n\t// createMemo, or the JSX, runs again after a change of the actor. Each method binds to\n\t// the current actor. Therefore `this`, and also each private field, works exactly as\n\t// in a direct call. The ActorProvider proxy of play-vue does the same.\n\tconst actorProxy = new Proxy({} as AnyPlayActor, {\n\t\tget(_target, prop) {\n\t\t\tconst current = props.actor as AnyPlayActor;\n\t\t\tconst value = Reflect.get(current, prop, current) as unknown;\n\t\t\treturn typeof value === \"function\" ? value.bind(current) : value;\n\t\t},\n\t\thas(_target, prop) {\n\t\t\treturn prop in (props.actor as AnyPlayActor);\n\t\t},\n\t});\n\n\t// Put onRenderError into the registry, when the caller gives one. The property is\n\t// not enumerable, and it replaces the handler below it.\n\t// The code keeps the result, because a new object on each reactive evaluation renders\n\t// each child component that receives it as a prop again, for nothing.\n\tconst resolvedRegistryResult = createMemo(() => {\n\t\tif (!props.onRenderError) return props.registryResult;\n\t\treturn {\n\t\t\t...props.registryResult,\n\t\t\tregistry: attachRenderErrorHandler(props.registryResult.registry, props.onRenderError),\n\t\t};\n\t});\n\n\t// The store lifecycle: it seeds the store again on a change of the viewKey, it\n\t// refreshes /context in place in every other case, it resets the store on a change of\n\t// the actor, and it guards the identity cache. The shared coordinator comes from\n\t// @xmachines/play-actor. Only the wiring of the reactivity in the tracked JSX scope\n\t// below belongs to Solid.\n\tconst storeLifecycle = createViewStoreLifecycle((seed) =>\n\t\txstateStoreStateStore({ atom: createAtom(seed) }),\n\t);\n\n\t// Connect the TC39 Signal to the SolidJS signal. The code seeds the value AND starts\n\t// the watch in one createEffect, at the same moment. Therefore no race window is\n\t// between the .get() call and the registration of the watcher. The TC39 signal can\n\t// change between the first .get() call and the first notification of the watcher, and\n\t// the update function then holds the newest value.\n\tcreateEffect(() => {\n\t\tconst update = (nextView: PlaySpec | null) => setView(nextView);\n\t\tupdate(props.actor.currentView.get() as PlaySpec | null);\n\t\tconst unwatch = watchSignal(props.actor.currentView, (nextView) => {\n\t\t\tupdate(nextView as PlaySpec | null);\n\t\t});\n\t\tonCleanup(() => unwatch());\n\t});\n\n\treturn (\n\t\t<ActorContext.Provider value={actorProxy}>\n\t\t\t<ErrorBoundary\n\t\t\t\tfallback={(err: unknown) => {\n\t\t\t\t\tprops.onError?.(err);\n\t\t\t\t\treturn props.fallback ?? null;\n\t\t\t\t}}\n\t\t\t>\n\t\t\t\t{(() => {\n\t\t\t\t\tconst currentView = view();\n\t\t\t\t\tif (!currentView) return props.fallback ?? null;\n\n\t\t\t\t\t// Resolve the store, which is external and controlled, or internal for each viewKey,\n\t\t\t\t\t// through the shared lifecycle. The children receive the store with the guard, because\n\t\t\t\t\t// /context is read-only to the spec. The code reads props.actor and props.store HERE.\n\t\t\t\t\t// Both are therefore tracked in this scope, and a change of one of them runs the\n\t\t\t\t\t// resolution again.\n\t\t\t\t\tconst store: StateStore = storeLifecycle.resolve(\n\t\t\t\t\t\tprops.actor,\n\t\t\t\t\t\tcurrentView,\n\t\t\t\t\t\tprops.store,\n\t\t\t\t\t).guardedStore;\n\n\t\t\t\t\treturn (\n\t\t\t\t\t\t<StateProvider store={store}>\n\t\t\t\t\t\t\t<ActorProviderInner\n\t\t\t\t\t\t\t\tregistryResult={resolvedRegistryResult()}\n\t\t\t\t\t\t\t\tspec={currentView}\n\t\t\t\t\t\t\t\tstore={store}\n\t\t\t\t\t\t\t>\n\t\t\t\t\t\t\t\t{props.children}\n\t\t\t\t\t\t\t</ActorProviderInner>\n\t\t\t\t\t\t</StateProvider>\n\t\t\t\t\t);\n\t\t\t\t})()}\n\t\t\t</ErrorBoundary>\n\t\t</ActorContext.Provider>\n\t);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,IAAM2B,cAAcvB,cAAuC,IAAI;;;;;;;;;;;;;;;;AAiB/D,SAAgBwB,cAAgC;CAC/C,OAAOV,kBAAkBb,WAAWsB,WAAW,GAAG,aAAa;AAChE;;;;;;AAoCA,IAAMQ,sBAKAI,eAAe;CACpB,MAAMC,WAAW9B,cAAc;CAG/B,MAAM+B,mBAA6BC,YAAY;EAC9C,MAAMC,OAAOH,SAASI,YAAY;EAClCJ,SAASK,OAAOH,QAAQC,IAAI,CAAC;CAC9B;CAEA,MAAMG,WAAWP,WAAWH,eAAeU,eACpCL,uBACAD,SAASI,YAAY,CAC5B;CAEA,MAAMG,YAA8B;EACnCV,MAAME,WAAWF;EACjBS;EACAE,UAAUT,WAAWH,eAAeY;EACpCV,OAAOC,WAAWD;CACnB;CAEA,OAAAW,gBAAQtB,YAAYuB,UAAQ;EAACC,OAAOJ;EAAS,IAAAb,WAAA;GAAA,OAAGK,WAAWL;EAAQ;CAAA,CAAA;AACpE;;;;;;;;;;;;;;;;;;;;AAyBA,IAAakB,iBAAgDC,UAAU;CAEtE,MAAM,CAACC,MAAMC,WAAWvD,aAA8B,IAAI;CAY1D,MAAMwD,aAAa,IAAIC,MAAM,CAAC,GAAmB;EAChDC,IAAIC,SAASC,MAAM;GAClB,MAAMC,UAAUR,MAAMS;GACtB,MAAMX,QAAQY,QAAQL,IAAIG,SAASD,MAAMC,OAAO;GAChD,OAAO,OAAOV,UAAU,aAAaA,MAAMa,KAAKH,OAAO,IAAIV;EAC5D;EACAc,IAAIN,SAASC,MAAM;GAClB,OAAOA,QAASP,MAAMS;EACvB;CACD,CAAC;CAMD,MAAMI,yBAAyBhE,iBAAiB;EAC/C,IAAI,CAACmD,MAAMc,eAAe,OAAOd,MAAMjB;EACvC,OAAO;GACN,GAAGiB,MAAMjB;GACTY,UAAU7B,yBAAyBkC,MAAMjB,eAAeY,UAAUK,MAAMc,aAAa;EACtF;CACD,CAAC;CAOD,MAAMC,iBAAiBhD,0BAA0BiD,SAChDrD,sBAAsB,EAAEsD,MAAMvD,WAAWsD,IAAI,EAAE,CAAC,CACjD;CAOApE,mBAAmB;EAClB,MAAM4C,UAAU0B,aAA8BhB,QAAQgB,QAAQ;EAC9D1B,OAAOQ,MAAMS,MAAMU,YAAYd,IAAI,CAAoB;EACvD,MAAMe,UAAUxD,YAAYoC,MAAMS,MAAMU,cAAcD,aAAa;GAClE1B,OAAO0B,QAA2B;EACnC,CAAC;EACDpE,gBAAgBsE,QAAQ,CAAC;CAC1B,CAAC;CAED,OAAAxB,gBACEzB,aAAa0B,UAAQ;EAACC,OAAOK;EAAU,IAAAtB,WAAA;GAAA,OAAAe,gBACtC3C,eAAa;IACbwB,WAAW4C,QAAiB;KAC3BrB,MAAMrB,UAAU0C,GAAG;KACnB,OAAOrB,MAAMvB,YAAY;IAC1B;IAAC,IAAAI,WAAA;KAAA,cAEO;MACP,MAAMsC,cAAclB,KAAK;MACzB,IAAI,CAACkB,aAAa,OAAOnB,MAAMvB,YAAY;MAO3C,MAAMQ,QAAoB8B,eAAeO,QACxCtB,MAAMS,OACNU,aACAnB,MAAMf,KACP,CAAC,CAACsC;MAEF,OAAA3B,gBACExC,eAAa;OAAQ6B;OAAK,IAAAJ,WAAA;QAAA,OAAAe,gBACzBd,oBAAkB;SAAA,IAClBC,iBAAc;UAAA,OAAE8B,uBAAuB;SAAC;SACxC7B,MAAMmC;SACClC;SAAK,IAAAJ,WAAA;UAAA,OAEXmB,MAAMnB;SAAQ;QAAA,CAAA;OAAA;MAAA,CAAA;KAInB,EAAA,CAAG;IAAC;GAAA,CAAA;EAAA;CAAA,CAAA;AAIR"}

package/dist/PlayRenderer.d.ts

@@ -1,10 +1,11 @@
 /**
- * PlayRenderer - Zero-prop leaf component for XMachines Play SolidJS architecture.
+ * PlayRenderer - the leaf component without props of the XMachines Play SolidJS architecture.
  *
- * Reads view context from the enclosing ActorProvider (or PlayUIProvider) via
- * usePlayView() and renders the spec using @xmachines/json-render-solid's Renderer.
+ * It reads the view context of the ActorProvider around it, or of the
+ * PlayUIProvider, with usePlayView(). It then renders the spec with the Renderer of
+ * @xmachines/json-render-solid.
  *
- * Standard usage:
+ * The standard use:
  * ```tsx
  * <PlayUIProvider actor={myActor} registryResult={registryResult}>
  *   <PlayRenderer />
@@ -15,10 +16,12 @@
  */
 import type { Component } from "solid-js";
 /**
- * Zero-prop leaf renderer. Must be placed inside an ActorProvider or PlayUIProvider tree.
+ * The leaf renderer without props. Put it inside an ActorProvider tree or a
+ * PlayUIProvider tree.
  *
- * Reads ViewContextValue (spec, handlers, registry) from the enclosing provider
- * via usePlayView() and renders the spec via @xmachines/json-render-solid's Renderer.
+ * It reads the ViewContextValue (the spec, the handlers, and the registry) of the
+ * provider around it, with usePlayView(). It then renders the spec with the Renderer
+ * of @xmachines/json-render-solid.
  */
 export declare const PlayRenderer: Component;
 //# sourceMappingURL=PlayRenderer.d.ts.map

package/dist/PlayRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PlayRenderer.d.ts","sourceRoot":"","sources":["../src/PlayRenderer.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAI1C;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,SAG1B,CAAC"}
+{"version":3,"file":"PlayRenderer.d.ts","sourceRoot":"","sources":["../src/PlayRenderer.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAI1C;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,EAAE,SAG1B,CAAC"}

package/dist/PlayRenderer.js

@@ -3,10 +3,12 @@ import { createComponent } from "solid-js/web";
 import { Renderer } from "@xmachines/json-render-solid";
 //#region packages/play-solid/src/PlayRenderer.tsx
 /**
-* Zero-prop leaf renderer. Must be placed inside an ActorProvider or PlayUIProvider tree.
+* The leaf renderer without props. Put it inside an ActorProvider tree or a
+* PlayUIProvider tree.
 *
-* Reads ViewContextValue (spec, handlers, registry) from the enclosing provider
-* via usePlayView() and renders the spec via @xmachines/json-render-solid's Renderer.
+* It reads the ViewContextValue (the spec, the handlers, and the registry) of the
+* provider around it, with usePlayView(). It then renders the spec with the Renderer
+* of @xmachines/json-render-solid.
 */
 var PlayRenderer = () => {
 	const view = usePlayView();

package/dist/PlayRenderer.js.map

@@ -1 +1 @@
-{"version":3,"file":"PlayRenderer.js","names":["Component","Renderer","usePlayView","PlayRenderer","view","_$createComponent","spec","registry"],"sources":["../src/PlayRenderer.tsx"],"sourcesContent":["/**\n * PlayRenderer - Zero-prop leaf component for XMachines Play SolidJS architecture.\n *\n * Reads view context from the enclosing ActorProvider (or PlayUIProvider) via\n * usePlayView() and renders the spec using @xmachines/json-render-solid's Renderer.\n *\n * Standard usage:\n * ```tsx\n * <PlayUIProvider actor={myActor} registryResult={registryResult}>\n *   <PlayRenderer />\n * </PlayUIProvider>\n * ```\n *\n * @packageDocumentation\n */\n\nimport type { Component } from \"solid-js\";\nimport { Renderer } from \"@xmachines/json-render-solid\";\nimport { usePlayView } from \"./ActorProvider.js\";\n\n/**\n * Zero-prop leaf renderer. Must be placed inside an ActorProvider or PlayUIProvider tree.\n *\n * Reads ViewContextValue (spec, handlers, registry) from the enclosing provider\n * via usePlayView() and renders the spec via @xmachines/json-render-solid's Renderer.\n */\nexport const PlayRenderer: Component = () => {\n\tconst view = usePlayView();\n\treturn <Renderer spec={view.spec} registry={view.registry} />;\n};\n"],"mappings":";;;;;;;;;;AA0BA,IAAaG,qBAAgC;CAC5C,MAAMC,OAAOF,YAAY;CACzB,OAAAG,gBAAQJ,UAAQ;EAAA,IAACK,OAAI;GAAA,OAAEF,KAAKE;EAAI;EAAA,IAAEC,WAAQ;GAAA,OAAEH,KAAKG;EAAQ;CAAA,CAAA;AAC1D"}
+{"version":3,"file":"PlayRenderer.js","names":["Component","Renderer","usePlayView","PlayRenderer","view","_$createComponent","spec","registry"],"sources":["../src/PlayRenderer.tsx"],"sourcesContent":["/**\n * PlayRenderer - the leaf component without props of the XMachines Play SolidJS architecture.\n *\n * It reads the view context of the ActorProvider around it, or of the\n * PlayUIProvider, with usePlayView(). It then renders the spec with the Renderer of\n * @xmachines/json-render-solid.\n *\n * The standard use:\n * ```tsx\n * <PlayUIProvider actor={myActor} registryResult={registryResult}>\n *   <PlayRenderer />\n * </PlayUIProvider>\n * ```\n *\n * @packageDocumentation\n */\n\nimport type { Component } from \"solid-js\";\nimport { Renderer } from \"@xmachines/json-render-solid\";\nimport { usePlayView } from \"./ActorProvider.js\";\n\n/**\n * The leaf renderer without props. Put it inside an ActorProvider tree or a\n * PlayUIProvider tree.\n *\n * It reads the ViewContextValue (the spec, the handlers, and the registry) of the\n * provider around it, with usePlayView(). It then renders the spec with the Renderer\n * of @xmachines/json-render-solid.\n */\nexport const PlayRenderer: Component = () => {\n\tconst view = usePlayView();\n\treturn <Renderer spec={view.spec} registry={view.registry} />;\n};\n"],"mappings":";;;;;;;;;;;;AA6BA,IAAaG,qBAAgC;CAC5C,MAAMC,OAAOF,YAAY;CACzB,OAAAG,gBAAQJ,UAAQ;EAAA,IAACK,OAAI;GAAA,OAAEF,KAAKE;EAAI;EAAA,IAAEC,WAAQ;GAAA,OAAEH,KAAKG;EAAQ;CAAA,CAAA;AAC1D"}

package/dist/PlayUIProvider.d.ts

@@ -1,10 +1,10 @@
 /**
- * PlayUIProvider — Batteries-included SolidJS provider for XMachines Play.
+ * PlayUIProvider — the composite SolidJS provider of XMachines Play.
  *
- * Wraps ActorProvider + JSONUIProvider into a single composite provider.
+ * It wraps ActorProvider and JSONUIProvider into one composite provider.
  * This is the recommended entry point for most users.
  *
- * Standard usage:
+ * The standard use:
  * ```tsx
  * import { PlayUIProvider, PlayRenderer, defineRegistry } from "@xmachines/play-solid";
  *
@@ -15,7 +15,8 @@
  * </PlayUIProvider>
  * ```
  *
- * For full control (library authors), use ActorProvider directly.
+ * For the complete control, which the author of a library needs, use ActorProvider
+ * directly.
  *
  * @packageDocumentation
  */
@@ -24,18 +25,18 @@ import { type JSONUIProviderProps } from "@xmachines/json-render-solid";
 import { type ActorProviderProps } from "./ActorProvider.js";
 type JSONUIForwardedProps = Pick<JSONUIProviderProps, "validationFunctions" | "navigate" | "functions">;
 /**
- * Props for PlayUIProvider — all ActorProvider props plus JSONUIProvider's forwarded props.
+ * The props of PlayUIProvider — every ActorProvider prop, and also the props that it forwards to JSONUIProvider.
  */
 export interface PlayUIProviderProps extends ActorProviderProps, Partial<JSONUIForwardedProps> {
 }
 /**
- * Batteries-included composite provider: ActorProvider + JSONUIProvider.
+ * The composite provider: ActorProvider and JSONUIProvider.
  *
- * Provides the full JSON render context stack:
- * - ActorContext (actor instance via ActorProvider)
- * - ViewContext (spec, handlers, registry via ActorProvider)
- * - StateProvider + ActionProvider + VisibilityProvider + ValidationProvider (via JSONUIProvider)
- * - ConfirmDialogManager (via JSONUIProvider)
+ * It gives you the complete stack of the JSON render context:
+ * - ActorContext, which holds the actor instance, through ActorProvider
+ * - ViewContext, which holds the spec, the handlers, and the registry, through ActorProvider
+ * - StateProvider, ActionProvider, VisibilityProvider, and ValidationProvider, through JSONUIProvider
+ * - ConfirmDialogManager, through JSONUIProvider
  *
  * @example
  * ```tsx

package/dist/PlayUIProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PlayUIProvider.d.ts","sourceRoot":"","sources":["../src/PlayUIProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAO,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAkB,KAAK,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACxF,OAAO,EAA8B,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAGzF,KAAK,oBAAoB,GAAG,IAAI,CAC/B,mBAAmB,EACnB,qBAAqB,GAAG,UAAU,GAAG,WAAW,CAChD,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB,EAAE,OAAO,CAAC,oBAAoB,CAAC;CAAG;AA8BjG;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,CAAC,mBAAmB,CAqBzD,CAAC"}
+{"version":3,"file":"PlayUIProvider.d.ts","sourceRoot":"","sources":["../src/PlayUIProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAO,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAkB,KAAK,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACxF,OAAO,EAA8B,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAGzF,KAAK,oBAAoB,GAAG,IAAI,CAC/B,mBAAmB,EACnB,qBAAqB,GAAG,UAAU,GAAG,WAAW,CAChD,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB,EAAE,OAAO,CAAC,oBAAoB,CAAC;CAAG;AA+BjG;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,CAAC,mBAAmB,CAqBzD,CAAC"}

package/dist/PlayUIProvider.js

@@ -3,11 +3,12 @@ import { createComponent, mergeProps } from "solid-js/web";
 import { JSONUIProvider } from "@xmachines/json-render-solid";
 //#region packages/play-solid/src/PlayUIProvider.tsx
 /**
-* Inner bridge component — must be inside ActorProvider's tree so usePlayView() has
-* access to the resolved ViewContextValue. Reads handlers and registry from the view
-* context and passes them to JSONUIProvider.
+* The inner bridge component. Put it inside the tree of ActorProvider, so that
+* usePlayView() can read the resolved ViewContextValue. It reads the handlers and the
+* registry of the view context, and it gives them to JSONUIProvider.
 *
-* This bridge pattern mirrors the React implementation (JSONUIBridge in play-react).
+* The React implementation uses the same bridge pattern, in JSONUIBridge of
+* play-react.
 */
 var JSONUIBridge = (bridgeProps) => {
 	const view = usePlayView();
@@ -26,13 +27,13 @@ var JSONUIBridge = (bridgeProps) => {
 	} }));
 };
 /**
-* Batteries-included composite provider: ActorProvider + JSONUIProvider.
+* The composite provider: ActorProvider and JSONUIProvider.
 *
-* Provides the full JSON render context stack:
-* - ActorContext (actor instance via ActorProvider)
-* - ViewContext (spec, handlers, registry via ActorProvider)
-* - StateProvider + ActionProvider + VisibilityProvider + ValidationProvider (via JSONUIProvider)
-* - ConfirmDialogManager (via JSONUIProvider)
+* It gives you the complete stack of the JSON render context:
+* - ActorContext, which holds the actor instance, through ActorProvider
+* - ViewContext, which holds the spec, the handlers, and the registry, through ActorProvider
+* - StateProvider, ActionProvider, VisibilityProvider, and ValidationProvider, through JSONUIProvider
+* - ConfirmDialogManager, through JSONUIProvider
 *
 * @example
 * ```tsx

package/dist/PlayUIProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"PlayUIProvider.js","names":["Component","JSX","JSONUIProvider","JSONUIProviderProps","ActorProvider","usePlayView","ActorProviderProps","JSONUIForwardedProps","Pick","PlayUIProviderProps","Partial","JSONUIBridge","children","Element","bridgeProps","view","_$createComponent","_$mergeProps","registry","handlers","store","validationFunctions","undefined","navigate","functions","PlayUIProvider","props","actor","registryResult","fallback","onError","onRenderError"],"sources":["../src/PlayUIProvider.tsx"],"sourcesContent":["/**\n * PlayUIProvider — Batteries-included SolidJS provider for XMachines Play.\n *\n * Wraps ActorProvider + JSONUIProvider into a single composite provider.\n * This is the recommended entry point for most users.\n *\n * Standard usage:\n * ```tsx\n * import { PlayUIProvider, PlayRenderer, defineRegistry } from \"@xmachines/play-solid\";\n *\n * const registryResult = defineRegistry(myCatalog, { components, actions });\n *\n * <PlayUIProvider actor={myActor} registryResult={registryResult}>\n *   <PlayRenderer />\n * </PlayUIProvider>\n * ```\n *\n * For full control (library authors), use ActorProvider directly.\n *\n * @packageDocumentation\n */\n\nimport type { Component, JSX } from \"solid-js\";\nimport { JSONUIProvider, type JSONUIProviderProps } from \"@xmachines/json-render-solid\";\nimport { ActorProvider, usePlayView, type ActorProviderProps } from \"./ActorProvider.js\";\n\n// Pick only the forwarded props from JSONUIProviderProps (per D-16)\ntype JSONUIForwardedProps = Pick<\n\tJSONUIProviderProps,\n\t\"validationFunctions\" | \"navigate\" | \"functions\"\n>;\n\n/**\n * Props for PlayUIProvider — all ActorProvider props plus JSONUIProvider's forwarded props.\n */\nexport interface PlayUIProviderProps extends ActorProviderProps, Partial<JSONUIForwardedProps> {}\n\n/**\n * Inner bridge component — must be inside ActorProvider's tree so usePlayView() has\n * access to the resolved ViewContextValue. Reads handlers and registry from the view\n * context and passes them to JSONUIProvider.\n *\n * This bridge pattern mirrors the React implementation (JSONUIBridge in play-react).\n */\nconst JSONUIBridge: Component<Partial<JSONUIForwardedProps> & { children: JSX.Element }> = (\n\tbridgeProps,\n) => {\n\tconst view = usePlayView();\n\n\treturn (\n\t\t<JSONUIProvider\n\t\t\tregistry={view.registry}\n\t\t\thandlers={view.handlers}\n\t\t\tstore={view.store}\n\t\t\t{...(bridgeProps.validationFunctions !== undefined && {\n\t\t\t\tvalidationFunctions: bridgeProps.validationFunctions,\n\t\t\t})}\n\t\t\t{...(bridgeProps.navigate !== undefined && { navigate: bridgeProps.navigate })}\n\t\t\t{...(bridgeProps.functions !== undefined && { functions: bridgeProps.functions })}\n\t\t>\n\t\t\t{bridgeProps.children}\n\t\t</JSONUIProvider>\n\t);\n};\n\n/**\n * Batteries-included composite provider: ActorProvider + JSONUIProvider.\n *\n * Provides the full JSON render context stack:\n * - ActorContext (actor instance via ActorProvider)\n * - ViewContext (spec, handlers, registry via ActorProvider)\n * - StateProvider + ActionProvider + VisibilityProvider + ValidationProvider (via JSONUIProvider)\n * - ConfirmDialogManager (via JSONUIProvider)\n *\n * @example\n * ```tsx\n * <PlayUIProvider actor={myActor} registryResult={registryResult} navigate={navigate}>\n *   <PlayRenderer />\n * </PlayUIProvider>\n * ```\n */\nexport const PlayUIProvider: Component<PlayUIProviderProps> = (props) => {\n\treturn (\n\t\t<ActorProvider\n\t\t\tactor={props.actor}\n\t\t\tregistryResult={props.registryResult}\n\t\t\t{...(props.store !== undefined && { store: props.store })}\n\t\t\t{...(props.fallback !== undefined && { fallback: props.fallback })}\n\t\t\t{...(props.onError !== undefined && { onError: props.onError })}\n\t\t\t{...(props.onRenderError !== undefined && { onRenderError: props.onRenderError })}\n\t\t>\n\t\t\t<JSONUIBridge\n\t\t\t\t{...(props.validationFunctions !== undefined && {\n\t\t\t\t\tvalidationFunctions: props.validationFunctions,\n\t\t\t\t})}\n\t\t\t\t{...(props.navigate !== undefined && { navigate: props.navigate })}\n\t\t\t\t{...(props.functions !== undefined && { functions: props.functions })}\n\t\t\t>\n\t\t\t\t{props.children}\n\t\t\t</JSONUIBridge>\n\t\t</ActorProvider>\n\t);\n};\n"],"mappings":";;;;;;;;;;;AA4CA,IAAMW,gBACLG,gBACI;CACJ,MAAMC,OAAOV,YAAY;CAEzB,OAAAW,gBACEd,gBAAce,WAAA;EAAA,IACdC,WAAQ;GAAA,OAAEH,KAAKG;EAAQ;EAAA,IACvBC,WAAQ;GAAA,OAAEJ,KAAKI;EAAQ;EAAA,IACvBC,QAAK;GAAA,OAAEL,KAAKK;EAAK;CAAA,SACZN,YAAYO,wBAAwBC,KAAAA,KAAa,EACrDD,qBAAqBP,YAAYO,oBAClC,SACKP,YAAYS,aAAaD,KAAAA,KAAa,EAAEC,UAAUT,YAAYS,SAAS,SACvET,YAAYU,cAAcF,KAAAA,KAAa,EAAEE,WAAWV,YAAYU,UAAU,GAAC,EAAA,IAAAZ,WAAA;EAAA,OAE/EE,YAAYF;CAAQ,EAAA,CAAA,CAAA;AAGxB;;;;;;;;;;;;;;;;;AAkBA,IAAaa,kBAAkDC,UAAU;CACxE,OAAAV,gBACEZ,eAAaa,WAAA;EAAA,IACbU,QAAK;GAAA,OAAED,MAAMC;EAAK;EAAA,IAClBC,iBAAc;GAAA,OAAEF,MAAME;EAAc;CAAA,SAC/BF,MAAMN,UAAUE,KAAAA,KAAa,EAAEF,OAAOM,MAAMN,MAAM,SAClDM,MAAMG,aAAaP,KAAAA,KAAa,EAAEO,UAAUH,MAAMG,SAAS,SAC3DH,MAAMI,YAAYR,KAAAA,KAAa,EAAEQ,SAASJ,MAAMI,QAAQ,SACxDJ,MAAMK,kBAAkBT,KAAAA,KAAa,EAAES,eAAeL,MAAMK,cAAc,GAAC,EAAA,IAAAnB,WAAA;EAAA,OAAAI,gBAE/EL,cAAYM,iBACPS,MAAML,wBAAwBC,KAAAA,KAAa,EAC/CD,qBAAqBK,MAAML,oBAC5B,SACKK,MAAMH,aAAaD,KAAAA,KAAa,EAAEC,UAAUG,MAAMH,SAAS,SAC3DG,MAAMF,cAAcF,KAAAA,KAAa,EAAEE,WAAWE,MAAMF,UAAU,GAAC,EAAA,IAAAZ,WAAA;GAAA,OAEnEc,MAAMd;EAAQ,EAAA,CAAA,CAAA;CAAA,EAAA,CAAA,CAAA;AAInB"}
+{"version":3,"file":"PlayUIProvider.js","names":["Component","JSX","JSONUIProvider","JSONUIProviderProps","ActorProvider","usePlayView","ActorProviderProps","JSONUIForwardedProps","Pick","PlayUIProviderProps","Partial","JSONUIBridge","children","Element","bridgeProps","view","_$createComponent","_$mergeProps","registry","handlers","store","validationFunctions","undefined","navigate","functions","PlayUIProvider","props","actor","registryResult","fallback","onError","onRenderError"],"sources":["../src/PlayUIProvider.tsx"],"sourcesContent":["/**\n * PlayUIProvider — the composite SolidJS provider of XMachines Play.\n *\n * It wraps ActorProvider and JSONUIProvider into one composite provider.\n * This is the recommended entry point for most users.\n *\n * The standard use:\n * ```tsx\n * import { PlayUIProvider, PlayRenderer, defineRegistry } from \"@xmachines/play-solid\";\n *\n * const registryResult = defineRegistry(myCatalog, { components, actions });\n *\n * <PlayUIProvider actor={myActor} registryResult={registryResult}>\n *   <PlayRenderer />\n * </PlayUIProvider>\n * ```\n *\n * For the complete control, which the author of a library needs, use ActorProvider\n * directly.\n *\n * @packageDocumentation\n */\n\nimport type { Component, JSX } from \"solid-js\";\nimport { JSONUIProvider, type JSONUIProviderProps } from \"@xmachines/json-render-solid\";\nimport { ActorProvider, usePlayView, type ActorProviderProps } from \"./ActorProvider.js\";\n\n// Take only the forwarded props of JSONUIProviderProps (D-16)\ntype JSONUIForwardedProps = Pick<\n\tJSONUIProviderProps,\n\t\"validationFunctions\" | \"navigate\" | \"functions\"\n>;\n\n/**\n * The props of PlayUIProvider — every ActorProvider prop, and also the props that it forwards to JSONUIProvider.\n */\nexport interface PlayUIProviderProps extends ActorProviderProps, Partial<JSONUIForwardedProps> {}\n\n/**\n * The inner bridge component. Put it inside the tree of ActorProvider, so that\n * usePlayView() can read the resolved ViewContextValue. It reads the handlers and the\n * registry of the view context, and it gives them to JSONUIProvider.\n *\n * The React implementation uses the same bridge pattern, in JSONUIBridge of\n * play-react.\n */\nconst JSONUIBridge: Component<Partial<JSONUIForwardedProps> & { children: JSX.Element }> = (\n\tbridgeProps,\n) => {\n\tconst view = usePlayView();\n\n\treturn (\n\t\t<JSONUIProvider\n\t\t\tregistry={view.registry}\n\t\t\thandlers={view.handlers}\n\t\t\tstore={view.store}\n\t\t\t{...(bridgeProps.validationFunctions !== undefined && {\n\t\t\t\tvalidationFunctions: bridgeProps.validationFunctions,\n\t\t\t})}\n\t\t\t{...(bridgeProps.navigate !== undefined && { navigate: bridgeProps.navigate })}\n\t\t\t{...(bridgeProps.functions !== undefined && { functions: bridgeProps.functions })}\n\t\t>\n\t\t\t{bridgeProps.children}\n\t\t</JSONUIProvider>\n\t);\n};\n\n/**\n * The composite provider: ActorProvider and JSONUIProvider.\n *\n * It gives you the complete stack of the JSON render context:\n * - ActorContext, which holds the actor instance, through ActorProvider\n * - ViewContext, which holds the spec, the handlers, and the registry, through ActorProvider\n * - StateProvider, ActionProvider, VisibilityProvider, and ValidationProvider, through JSONUIProvider\n * - ConfirmDialogManager, through JSONUIProvider\n *\n * @example\n * ```tsx\n * <PlayUIProvider actor={myActor} registryResult={registryResult} navigate={navigate}>\n *   <PlayRenderer />\n * </PlayUIProvider>\n * ```\n */\nexport const PlayUIProvider: Component<PlayUIProviderProps> = (props) => {\n\treturn (\n\t\t<ActorProvider\n\t\t\tactor={props.actor}\n\t\t\tregistryResult={props.registryResult}\n\t\t\t{...(props.store !== undefined && { store: props.store })}\n\t\t\t{...(props.fallback !== undefined && { fallback: props.fallback })}\n\t\t\t{...(props.onError !== undefined && { onError: props.onError })}\n\t\t\t{...(props.onRenderError !== undefined && { onRenderError: props.onRenderError })}\n\t\t>\n\t\t\t<JSONUIBridge\n\t\t\t\t{...(props.validationFunctions !== undefined && {\n\t\t\t\t\tvalidationFunctions: props.validationFunctions,\n\t\t\t\t})}\n\t\t\t\t{...(props.navigate !== undefined && { navigate: props.navigate })}\n\t\t\t\t{...(props.functions !== undefined && { functions: props.functions })}\n\t\t\t>\n\t\t\t\t{props.children}\n\t\t\t</JSONUIBridge>\n\t\t</ActorProvider>\n\t);\n};\n"],"mappings":";;;;;;;;;;;;AA8CA,IAAMW,gBACLG,gBACI;CACJ,MAAMC,OAAOV,YAAY;CAEzB,OAAAW,gBACEd,gBAAce,WAAA;EAAA,IACdC,WAAQ;GAAA,OAAEH,KAAKG;EAAQ;EAAA,IACvBC,WAAQ;GAAA,OAAEJ,KAAKI;EAAQ;EAAA,IACvBC,QAAK;GAAA,OAAEL,KAAKK;EAAK;CAAA,SACZN,YAAYO,wBAAwBC,KAAAA,KAAa,EACrDD,qBAAqBP,YAAYO,oBAClC,SACKP,YAAYS,aAAaD,KAAAA,KAAa,EAAEC,UAAUT,YAAYS,SAAS,SACvET,YAAYU,cAAcF,KAAAA,KAAa,EAAEE,WAAWV,YAAYU,UAAU,GAAC,EAAA,IAAAZ,WAAA;EAAA,OAE/EE,YAAYF;CAAQ,EAAA,CAAA,CAAA;AAGxB;;;;;;;;;;;;;;;;;AAkBA,IAAaa,kBAAkDC,UAAU;CACxE,OAAAV,gBACEZ,eAAaa,WAAA;EAAA,IACbU,QAAK;GAAA,OAAED,MAAMC;EAAK;EAAA,IAClBC,iBAAc;GAAA,OAAEF,MAAME;EAAc;CAAA,SAC/BF,MAAMN,UAAUE,KAAAA,KAAa,EAAEF,OAAOM,MAAMN,MAAM,SAClDM,MAAMG,aAAaP,KAAAA,KAAa,EAAEO,UAAUH,MAAMG,SAAS,SAC3DH,MAAMI,YAAYR,KAAAA,KAAa,EAAEQ,SAASJ,MAAMI,QAAQ,SACxDJ,MAAMK,kBAAkBT,KAAAA,KAAa,EAAES,eAAeL,MAAMK,cAAc,GAAC,EAAA,IAAAnB,WAAA;EAAA,OAAAI,gBAE/EL,cAAYM,iBACPS,MAAML,wBAAwBC,KAAAA,KAAa,EAC/CD,qBAAqBK,MAAML,oBAC5B,SACKK,MAAMH,aAAaD,KAAAA,KAAa,EAAEC,UAAUG,MAAMH,SAAS,SAC3DG,MAAMF,cAAcF,KAAAA,KAAa,EAAEE,WAAWE,MAAMF,UAAU,GAAC,EAAA,IAAAZ,WAAA;GAAA,OAEnEc,MAAMd;EAAQ,EAAA,CAAA,CAAA;CAAA,EAAA,CAAA,CAAA;AAInB"}

package/dist/index.d.ts

@@ -1,16 +1,16 @@
 /**
- * @xmachines/play-solid - SolidJS renderer for XMachines Play architecture
+ * @xmachines/play-solid - SolidJS renderer for the XMachines Play architecture
  *
- * Provides a SolidJS rendering layer that passively observes actor signals and
- * renders UI components via @xmachines/json-render-solid. SolidJS reactivity is only used
- * to trigger re-renders — signals are the source of truth.
+ * This package is the SolidJS rendering layer. It observes the actor signals and
+ * renders the UI components through @xmachines/json-render-solid. SolidJS
+ * reactivity only triggers the re-render. The signals are the source of truth.
  *
  * Primary entry point:
  * ```tsx
  * import { PlayUIProvider, PlayRenderer, defineRegistry } from "@xmachines/play-solid";
  * ```
  *
- * For escape-hatch provider composition:
+ * For a custom provider composition:
  * ```tsx
  * import { ActorProvider, ActorContext, usePlayView } from "@xmachines/play-solid";
  * ```

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAIrD,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAMvD,OAAO,EAEN,cAAc,EACd,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAElB,QAAQ,EAER,cAAc,EACd,YAAY,EACZ,eAAe,EACf,aAAa,EACb,aAAa,EACb,UAAU,EACV,SAAS,EACT,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,aAAa,GACb,MAAM,8BAA8B,CAAC;AAGtC,YAAY,EACX,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,uBAAuB,EACvB,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,QAAQ,GACR,MAAM,8BAA8B,CAAC;AACtC,YAAY,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAGvE,YAAY,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC5F,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAKrD,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAOvD,OAAO,EAEN,cAAc,EACd,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAElB,QAAQ,EAER,cAAc,EACd,YAAY,EACZ,eAAe,EACf,aAAa,EACb,aAAa,EACb,UAAU,EACV,SAAS,EACT,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,aAAa,GACb,MAAM,8BAA8B,CAAC;AAGtC,YAAY,EACX,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,uBAAuB,EACvB,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,QAAQ,GACR,MAAM,8BAA8B,CAAC;AACtC,YAAY,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAGvE,YAAY,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC5F,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC"}

package/dist/types.d.ts

@@ -1,8 +1,8 @@
 /**
- * TypeScript type definitions for play-solid
+ * The TypeScript type definitions of play-solid
  *
- * Re-exports the primary prop types from their respective source files.
- * PlayRendererProps has been removed per D-06 (replaced by ActorProviderProps / PlayUIProviderProps).
+ * This file re-exports the primary prop types from their own source files.
+ * D-06 removed PlayRendererProps. Use ActorProviderProps or PlayUIProviderProps.
  *
  * @packageDocumentation
  */

package/dist/useActor.d.ts

@@ -1,10 +1,10 @@
 /**
- * useActor — SolidJS hook for accessing the raw actor inside an ActorProvider tree.
+ * useActor — the SolidJS hook that gives the raw actor inside an ActorProvider tree.
  *
- * Components rendered inside ActorProvider (or PlayUIProvider) can call useActor()
- * to get direct access to the actor instance without prop drilling.
+ * A component inside ActorProvider, or inside PlayUIProvider, calls useActor() to
+ * get the actor instance directly. The actor is then not necessary as a prop.
  *
- * @throws {Error} If called outside an ActorProvider tree
+ * @throws {Error} When the caller is outside an ActorProvider tree
  *
  * @example
  * ```typescript
@@ -20,12 +20,15 @@
  */
 import type { AbstractActor } from "@xmachines/play-actor";
 import type { AnyActorLogic } from "xstate";
-/** Bare actor type accepted by Solid context providers. For the full routing + view shape, use `PlayActor` from `@xmachines/play-router`. */
+/**
+ * The bare actor type that the Solid context providers accept. For the complete routing and view shape, use `PlayActor` from `@xmachines/play-router`.
+ */
 export type AnyPlayActor = AbstractActor<AnyActorLogic>;
 /**
- * SolidJS context for the actor — exported so consumers can use ActorContext.Provider
- * directly as an escape hatch (per D-11). The smart ActorProvider component takes
- * the name "ActorProvider" and is the recommended entry point.
+ * The SolidJS context of the actor. This package exports it, so that a consumer
+ * can use ActorContext.Provider directly for a custom composition (see D-11). The
+ * ActorProvider component has the name "ActorProvider", and it is the recommended
+ * entry point.
  */
 export declare const ActorContext: import("solid-js").Context<AnyPlayActor | null>;
 export declare function useActor(): AnyPlayActor;

package/dist/useActor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useActor.d.ts","sourceRoot":"","sources":["../src/useActor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C,6IAA6I;AAC7I,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,YAAY,iDAA2C,CAAC;AAErE,wBAAgB,QAAQ,IAAI,YAAY,CAEvC"}
+{"version":3,"file":"useActor.d.ts","sourceRoot":"","sources":["../src/useActor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;AAExD;;;;;GAKG;AACH,eAAO,MAAM,YAAY,iDAA2C,CAAC;AAErE,wBAAgB,QAAQ,IAAI,YAAY,CAEvC"}

package/dist/useActor.js

@@ -2,12 +2,12 @@ import { createContext, useContext } from "solid-js";
 import { assertNonNullable } from "@xmachines/play";
 //#region packages/play-solid/src/useActor.ts
 /**
-* useActor — SolidJS hook for accessing the raw actor inside an ActorProvider tree.
+* useActor — the SolidJS hook that gives the raw actor inside an ActorProvider tree.
 *
-* Components rendered inside ActorProvider (or PlayUIProvider) can call useActor()
-* to get direct access to the actor instance without prop drilling.
+* A component inside ActorProvider, or inside PlayUIProvider, calls useActor() to
+* get the actor instance directly. The actor is then not necessary as a prop.
 *
-* @throws {Error} If called outside an ActorProvider tree
+* @throws {Error} When the caller is outside an ActorProvider tree
 *
 * @example
 * ```typescript
@@ -22,9 +22,10 @@ import { assertNonNullable } from "@xmachines/play";
 * @packageDocumentation
 */
 /**
-* SolidJS context for the actor — exported so consumers can use ActorContext.Provider
-* directly as an escape hatch (per D-11). The smart ActorProvider component takes
-* the name "ActorProvider" and is the recommended entry point.
+* The SolidJS context of the actor. This package exports it, so that a consumer
+* can use ActorContext.Provider directly for a custom composition (see D-11). The
+* ActorProvider component has the name "ActorProvider", and it is the recommended
+* entry point.
 */
 var ActorContext = createContext(null);
 function useActor() {

package/dist/useActor.js.map

@@ -1 +1 @@
-{"version":3,"file":"useActor.js","names":[],"sources":["../src/useActor.ts"],"sourcesContent":["/**\n * useActor — SolidJS hook for accessing the raw actor inside an ActorProvider tree.\n *\n * Components rendered inside ActorProvider (or PlayUIProvider) can call useActor()\n * to get direct access to the actor instance without prop drilling.\n *\n * @throws {Error} If called outside an ActorProvider tree\n *\n * @example\n * ```typescript\n * import { useActor } from \"@xmachines/play-solid\";\n *\n * function MyComponent() {\n *   const actor = useActor();\n *   return <button onClick={() => actor.send({ type: \"SUBMIT\" })}>Submit</button>;\n * }\n * ```\n *\n * @packageDocumentation\n */\n\nimport { createContext, useContext } from \"solid-js\";\nimport { assertNonNullable } from \"@xmachines/play\";\nimport type { AbstractActor } from \"@xmachines/play-actor\";\nimport type { AnyActorLogic } from \"xstate\";\n\n/** Bare actor type accepted by Solid context providers. For the full routing + view shape, use `PlayActor` from `@xmachines/play-router`. */\nexport type AnyPlayActor = AbstractActor<AnyActorLogic>;\n\n/**\n * SolidJS context for the actor — exported so consumers can use ActorContext.Provider\n * directly as an escape hatch (per D-11). The smart ActorProvider component takes\n * the name \"ActorProvider\" and is the recommended entry point.\n */\nexport const ActorContext = createContext<AnyPlayActor | null>(null);\n\nexport function useActor(): AnyPlayActor {\n\treturn assertNonNullable(useContext(ActorContext), \"ActorContext\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,eAAe,cAAmC,IAAI;AAEnE,SAAgB,WAAyB;CACxC,OAAO,kBAAkB,WAAW,YAAY,GAAG,cAAc;AAClE"}
+{"version":3,"file":"useActor.js","names":[],"sources":["../src/useActor.ts"],"sourcesContent":["/**\n * useActor — the SolidJS hook that gives the raw actor inside an ActorProvider tree.\n *\n * A component inside ActorProvider, or inside PlayUIProvider, calls useActor() to\n * get the actor instance directly. The actor is then not necessary as a prop.\n *\n * @throws {Error} When the caller is outside an ActorProvider tree\n *\n * @example\n * ```typescript\n * import { useActor } from \"@xmachines/play-solid\";\n *\n * function MyComponent() {\n *   const actor = useActor();\n *   return <button onClick={() => actor.send({ type: \"SUBMIT\" })}>Submit</button>;\n * }\n * ```\n *\n * @packageDocumentation\n */\n\nimport { createContext, useContext } from \"solid-js\";\nimport { assertNonNullable } from \"@xmachines/play\";\nimport type { AbstractActor } from \"@xmachines/play-actor\";\nimport type { AnyActorLogic } from \"xstate\";\n\n/**\n * The bare actor type that the Solid context providers accept. For the complete routing and view shape, use `PlayActor` from `@xmachines/play-router`.\n */\nexport type AnyPlayActor = AbstractActor<AnyActorLogic>;\n\n/**\n * The SolidJS context of the actor. This package exports it, so that a consumer\n * can use ActorContext.Provider directly for a custom composition (see D-11). The\n * ActorProvider component has the name \"ActorProvider\", and it is the recommended\n * entry point.\n */\nexport const ActorContext = createContext<AnyPlayActor | null>(null);\n\nexport function useActor(): AnyPlayActor {\n\treturn assertNonNullable(useContext(ActorContext), \"ActorContext\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,eAAe,cAAmC,IAAI;AAEnE,SAAgB,WAAyB;CACxC,OAAO,kBAAkB,WAAW,YAAY,GAAG,cAAc;AAClE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-solid",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Solid renderer for XMachines Play architecture",
   "keywords": [
     "catalog",
@@ -42,13 +42,14 @@
     "lint": "oxlint .",
     "format": "oxfmt .",
     "test": "vitest",
+    "test:coverage": "vitest run --coverage",
     "test:watch": "vitest",
     "test:ui": "vitest --ui"
   },
   "dependencies": {
-    "@xmachines/play": "2.0.0",
-    "@xmachines/play-actor": "2.0.0",
-    "@xmachines/play-signals": "2.0.0"
+    "@xmachines/play": "2.1.0",
+    "@xmachines/play-actor": "2.1.0",
+    "@xmachines/play-signals": "2.1.0"
   },
   "devDependencies": {
     "@solidjs/testing-library": "^0.8.10",