@xmachines/play-solid 1.0.0-beta.9 → 2.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mikael Karon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,299 +1,202 @@
-# @xmachines/play-solid
-
-**SolidJS renderer consuming signals and UI schema with provider pattern**
-
-Signal-driven SolidJS rendering layer observing actor state with zero SolidJS state for business logic.
+<!-- generated-by: gsd-doc-writer -->
 
-## Overview
-
-`@xmachines/play-solid` provides `PlayRenderer` for building SolidJS UIs that passively observe actor signals. This package enables framework-swappable architecture where SolidJS is just a rendering target subscribing to signal changes — business logic lives entirely in the actor.
-
-Per [RFC Play v1](https://gitlab.com/xmachin-es/rfc/-/blob/main/src/play-v1.md), this package implements:
+# @xmachines/play-solid
 
-- **Signal-Only Reactivity (INV-05):** No createSignal/createStore for business logic, TC39 signals only
-- **Passive Infrastructure (INV-04):** Components observe signals, send events to actor
+> Solid renderer for XMachines Play architecture
 
-**Key Principle:** SolidJS state is never used for business logic. Signals are the source of truth.
+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.
 
-Renderer receives actor via props (provider pattern), not children.
+Part of the [xmachines-js monorepo](../../README.md).
 
 ## Installation
 
 ```bash
-npm install solid-js@^1.8.0
-npm install @xmachines/play-solid
+pnpm add @xmachines/play-solid
 ```
 
-## Current Exports
+**Peer dependencies** — install alongside the package:
 
-- `PlayRenderer`
-- `PlayRendererProps` (type)
-
-**Peer dependencies:**
-
-- `solid-js` ^1.8.0 - SolidJS runtime
+```bash
+pnpm add solid-js xstate @xstate/store @xmachines/json-render-solid @xmachines/json-render-core @xmachines/json-render-xstate
+```
 
 ## Quick Start
 
 ```tsx
-import { render } from "solid-js/web";
+import { PlayUIProvider, PlayRenderer, defineRegistry } from "@xmachines/play-solid";
 import { definePlayer } from "@xmachines/play-xstate";
-import { defineCatalog } from "@xmachines/play-catalog";
-import { PlayRenderer } from "@xmachines/play-solid";
-import { z } from "zod";
-
-// 1. Define catalog (business logic layer)
-const catalog = defineCatalog({
-	LoginForm: z.object({ error: z.string().optional() }),
-	Dashboard: z.object({
-		userId: z.string(),
-		username: z.string(),
-	}),
+import { defineCatalog } from "@xmachines/json-render-core";
+import { schema } from "@xmachines/json-render-solid/schema";
+
+// 1. Define a catalog (authCatalogDef is a plain object describing components/actions)
+const catalog = defineCatalog(schema, authCatalogDef);
+
+// 2. 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>,
+	},
+	actions: {
+		login: async (args) => actor.send({ type: "auth.login", username: args.username }),
+		logout: async () => actor.send({ type: "auth.logout" }),
+	},
 });
 
-// 2. Create SolidJS components (view layer)
-const components = {
-	LoginForm: (props) => (
-		<form
-			onSubmit={(e) => {
-				e.preventDefault();
-				const data = new FormData(e.currentTarget);
-				props.send({
-					type: "auth.login",
-					username: data.get("username"),
-				});
-			}}
-		>
-			{props.error && <p style={{ color: "red" }}>{props.error}</p>}
-			<input name="username" required placeholder="Username" />
-			<button type="submit">Log In</button>
-		</form>
-	),
-	Dashboard: (props) => (
-		<div>
-			<h1>Welcome, {props.username}!</h1>
-			<p>User ID: {props.userId}</p>
-			<button onClick={() => props.send({ type: "auth.logout" })}>Log Out</button>
-		</div>
-	),
-};
-
-// 3. Create player actor (business logic runtime)
-const createPlayer = definePlayer({ machine: authMachine, catalog });
+// 3. Create and start an actor
+const createPlayer = definePlayer({ machine: myMachine });
 const actor = createPlayer();
 actor.start();
 
-// 4. Render UI (actor via props)
-render(
-	() => <PlayRenderer actor={actor} components={components} />,
-	document.getElementById("app")!,
-);
-```
-
-## API Reference
-
-### PlayRenderer
-
-Main renderer component subscribing to actor signals and dynamically rendering catalog components:
-
-```typescript
-interface PlayRendererProps {
-	actor: AbstractActor<any>;
-	components: Record<string, Component<any>>;
-	fallback?: JSX.Element;
+// 4. Render
+function App() {
+	return (
+		<PlayUIProvider actor={actor} registryResult={registryResult}>
+			<PlayRenderer />
+		</PlayUIProvider>
+	);
 }
 ```
 
-**Props:**
-
-- `actor` - Actor instance with `currentView` signal
-- `components` - Map of component names to SolidJS components
-- `fallback` - Component shown when `currentView` is null
-
-**Behavior:**
+## Usage
 
-1. Subscribes to `actor.currentView` signal using a `Signal.subtle.Watcher` inside the component
-2. Looks up component from `components` map using `view.component` string
-3. Renders component with props from `view.props` + `send` function using Solid's `<Dynamic />`
+### `PlayUIProvider` + `PlayRenderer` (recommended)
 
-**Example:**
+`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.
 
 ```tsx
-<PlayRenderer
+import { PlayUIProvider, PlayRenderer, defineRegistry } from "@xmachines/play-solid";
+
+<PlayUIProvider
 	actor={actor}
-	components={{
-		HomePage: (props) => <div>Home</div>,
-		AboutPage: (props) => <div>About</div>,
-	}}
-	fallback={<div>Loading...</div>}
-/>
+	registryResult={registryResult}
+	fallback={<div>Loading…</div>}
+	onError={(err) => console.error(err)}
+	navigate={navigateFn} // optional: passed to JSONUIProvider
+	validationFunctions={valFns} // optional: form validation helpers
+>
+	<PlayRenderer />
+</PlayUIProvider>;
 ```
 
-## Examples
+### `ActorProvider` (escape hatch)
 
-### Component Receiving Props from Catalog
+For library authors who need direct control over provider composition:
 
 ```tsx
-import { PlayRenderer } from "@xmachines/play-solid";
-import { defineCatalog } from "@xmachines/play-catalog";
-import { z } from "zod";
-
-// Define schema in catalog
-const catalog = defineCatalog({
-	UserProfile: z.object({
-		userId: z.string(),
-		name: z.string(),
-		avatar: z.string().url().optional(),
-		stats: z.object({
-			posts: z.number(),
-			followers: z.number(),
-		}),
-	}),
-});
-
-// Component receives type-safe props + send
-const components = {
-	UserProfile: (props) => (
-		<div>
-			{props.avatar && <img src={props.avatar} alt={props.name} />}
-			<h1>{props.name}</h1>
-			<p>ID: {props.userId}</p>
-			<div>
-				<span>{props.stats.posts} posts</span>
-				<span>{props.stats.followers} followers</span>
-			</div>
-			<button
-				onClick={() =>
-					props.send({
-						type: "profile.edit",
-						userId: props.userId,
-					})
-				}
-			>
-				Edit Profile
-			</button>
-		</div>
-	),
-};
+import { ActorProvider, PlayRenderer } from "@xmachines/play-solid";
 
-<PlayRenderer actor={actor} components={components} />;
+<ActorProvider actor={actor} registryResult={registryResult}>
+	<PlayRenderer />
+</ActorProvider>;
 ```
 
-### Provider Pattern
+### `useActor` hook
+
+Access the raw actor instance anywhere inside an `ActorProvider` or `PlayUIProvider` tree:
 
 ```tsx
-import { PlayTanStackRouterProvider } from "@xmachines/play-tanstack-solid-router";
-import { PlayRenderer } from "@xmachines/play-solid";
-import { createSignal, onCleanup } from "solid-js";
+import { useActor } from "@xmachines/play-solid";
 
-// Renderer receives actor via props (not children)
-function App() {
-	return (
-		<PlayTanStackRouterProvider
-			actor={actor}
-			router={router}
-			routeMap={routeMap}
-			renderer={(currentActor, currentRouter) => {
-				return (
-					<div>
-						<Header actor={currentActor} />
-						<PlayRenderer actor={currentActor} components={components} />
-						<Footer />
-					</div>
-				);
-			}}
-		/>
-	);
+function SubmitButton() {
+	const actor = useActor();
+	return <button onClick={() => actor.send({ type: "SUBMIT" })}>Submit</button>;
 }
+```
 
-// Header component also receives actor
-function Header(props) {
-	const [route, setRoute] = createSignal<string | null>(null);
+### `usePlayView` hook
 
-	// Manual watcher setup for custom component reading signals
-	let watcher: Signal.subtle.Watcher;
+Access the resolved view context (spec, handlers, registry, store) from within the provider tree:
 
-	// ... setup watcher to update route signal ...
+```tsx
+import { usePlayView } from "@xmachines/play-solid";
+import { Renderer } from "@xmachines/json-render-solid";
 
-	return (
-		<header>
-			<nav>Current: {route()}</nav>
-		</header>
-	);
-}
+const MyRenderer = () => {
+	const view = usePlayView();
+	return <Renderer spec={view.spec} registry={view.registry} />;
+};
 ```
 
-## Architecture
+## API Summary
 
-This package implements **Signal-Only Reactivity (INV-05)** and **Passive Infrastructure (INV-04)**:
+### Components
 
-1. **No Business Logic in SolidJS:**
-    - No createSignal/createStore for business state
-    - No createEffect for business side effects
-    - SolidJS only triggers renders, doesn't control state
+| 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                        |
 
-2. **Signals as Source of Truth:**
-    - `actor.currentView.get()` provides UI structure
-    - `actor.currentRoute.get()` provides navigation state
-    - Components observe signals via explicit watcher patterns
+### Hooks
 
-3. **Event Forwarding:**
-    - Components receive `send` function via props
-    - User actions send events to actor (e.g., `{ type: "auth.login" }`)
-    - Actor guards validate and process events
+| 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 |
 
-4. **Microtask Batching:**
-    - `Signal.subtle.Watcher` coalesces rapid signal changes
-    - Prevents SolidJS thrashing from multiple signal updates
-    - Single SolidJS render per microtask batch
+### Context
 
-5. **Explicit Disposal Contract:**
-    - Component teardown calls watcher `unwatch` in `onCleanup`
-    - Do not rely on GC-only cleanup
+| Export         | Description                                                                            |
+| -------------- | -------------------------------------------------------------------------------------- |
+| `ActorContext` | SolidJS context for the actor; use `ActorContext.Provider` directly as an escape hatch |
 
-**Pattern:**
+### Re-exports from `@xmachines/json-render-solid`
 
-- Renderer receives actor via props (provider pattern)
-- Enables composition with navigation, headers, footers
-- Supports multiple renderers in same app
+This package re-exports the full `@xmachines/json-render-solid` public API so consumers do not need a direct dependency:
 
-**Architectural Invariants:**
-
-- **Signal-Only Reactivity (INV-05):** No SolidJS state for business logic
-- **Passive Infrastructure (INV-04):** Components reflect, never decide
+```tsx
+import {
+	// Providers
+	JSONUIProvider,
+	StateProvider,
+	ActionProvider,
+	VisibilityProvider,
+	ValidationProvider,
+	// Renderer
+	Renderer,
+	// Registry factory + hooks
+	defineRegistry,
+	useBoundProp,
+	useStateBinding,
+	useStateValue,
+	useStateStore,
+	useActions,
+	useAction,
+	useIsVisible,
+	useFieldValidation,
+	useOptionalValidation,
+	useVisibility,
+} from "@xmachines/play-solid";
+```
 
-## Canonical Watcher Lifecycle
+### Key Types
 
-If you write your own custom integration, use the same watcher flow as `PlayRenderer`:
+| 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 |
 
-1. `notify` callback runs
-2. Schedule work with `queueMicrotask`
-3. Drain `watcher.getPending()`
-4. Read actor signals and update SolidJS-local signal state (`setSignal()`)
-5. Re-arm with `watch(...)` or `watch()`
+## Testing
 
-Watcher notify is one-shot. Re-arm is required for continuous observation.
+Run tests for this package in isolation:
 
-## Benefits
+```bash
+pnpm --filter @xmachines/play-solid test
+```
 
-- **Framework Swappable:** Business logic has zero SolidJS imports
-- **Type Safety:** Props validated against catalog schemas
-- **Simple Testing:** Test actors without SolidJS renderer
-- **Performance:** Microtask batching reduces unnecessary renders
-- **Composability:** Renderer prop enables complex layouts
+Or from within the package directory:
 
-## Related Packages
+```bash
+pnpm test          # single run (jsdom environment)
+pnpm run test:watch  # watch mode
+pnpm run test:ui     # interactive Vitest UI
+```
 
-- **[@xmachines/play-xstate](../play-xstate)** - XState adapter providing actors
-- **[@xmachines/play-catalog](../play-catalog)** - UI schema validation
-- **[@xmachines/play-solid-router](../play-solid-router)** - Solid Router integration
-- **[@xmachines/play-tanstack-solid-router](../play-tanstack-solid-router)** - TanStack Solid Router integration
-- **[@xmachines/play-actor](../play-actor)** - Actor base
-- **[@xmachines/play-signals](../play-signals)** - TC39 Signals primitives
+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.
 
 ## License
 
-Copyright (c) 2016 [Mikael Karon](mailto:mikael@karon.se). All rights reserved.
-
-This work is licensed under the terms of the MIT license.  
-For a copy, see <https://opensource.org/licenses/MIT>.
+MIT

package/dist/ActorProvider.js

@@ -0,0 +1,85 @@
+import { ActorContext as e } from "./useActor.js";
+import { createComponent as t } from "solid-js/web";
+import { StateProvider as n, useStateStore as r } from "@xmachines/json-render-solid";
+import { ErrorBoundary as i, createContext as a, createEffect as o, createMemo as s, createSignal as c, onCleanup as l, useContext as u } from "solid-js";
+import { createAtom as d } from "@xstate/store";
+import { xstateStoreStateStore as f } from "@xmachines/json-render-xstate";
+import { watchSignal as p } from "@xmachines/play-signals";
+import { assertNonNullable as m } from "@xmachines/play";
+import { attachRenderErrorHandler as h, toAtomState as g } from "@xmachines/play-actor";
+//#region src/ActorProvider.tsx
+var _ = a(null);
+function v() {
+	return m(u(_), "ViewContext");
+}
+var y = (e) => {
+	let n = r(), i = (e) => {
+		let t = n.getSnapshot();
+		n.update(e(t));
+	}, a = e.registryResult.handlers(() => i, () => n.getSnapshot()), o = {
+		spec: e.spec,
+		handlers: a,
+		registry: e.registryResult.registry,
+		store: e.store
+	};
+	return t(_.Provider, {
+		value: o,
+		get children() {
+			return e.children;
+		}
+	});
+}, b = (r) => {
+	let [a, u] = c(null), m = new Proxy({}, {
+		get(e, t) {
+			let n = r.actor, i = Reflect.get(n, t, n);
+			return typeof i == "function" ? i.bind(n) : i;
+		},
+		has(e, t) {
+			return t in r.actor;
+		}
+	}), _ = s(() => r.onRenderError ? {
+		...r.registryResult,
+		registry: h(r.registryResult.registry, r.onRenderError)
+	} : r.registryResult), v = null, b = null;
+	return o(() => {
+		let e = (e) => u(e);
+		e(r.actor.currentView.get());
+		let t = p(r.actor.currentView, (t) => {
+			e(t);
+		});
+		l(() => t());
+	}), t(e.Provider, {
+		value: m,
+		get children() {
+			return t(i, {
+				fallback: (e) => (r.onError?.(e), r.fallback ?? null),
+				get children() {
+					return (() => {
+						let e = a();
+						if (!e) return r.fallback ?? null;
+						let i;
+						return r.store ? i = r.store : ((v === null || b !== e) && (v = f({ atom: d(g(e.state)) }), b = e), i = v), t(n, {
+							store: i,
+							get children() {
+								return t(y, {
+									get registryResult() {
+										return _();
+									},
+									spec: e,
+									store: i,
+									get children() {
+										return r.children;
+									}
+								});
+							}
+						});
+					})();
+				}
+			});
+		}
+	});
+};
+//#endregion
+export { b as ActorProvider, v as usePlayView };
+
+//# sourceMappingURL=ActorProvider.js.map

package/dist/ActorProvider.js.map

@@ -0,0 +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","toAtomState","attachRenderErrorHandler","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","internalStore","lastView","nextView","currentView","unwatch","err","atom","state"],"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\ttoAtomState,\n\tattachRenderErrorHandler,\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// Per-view internal store — recreated on each view transition (uncontrolled mode)\n\tlet internalStore: StateStore | null = null;\n\tlet lastView: PlaySpec | null = null;\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 store: external (controlled) or internal per-view atom\n\t\t\t\t\tlet store: StateStore;\n\t\t\t\t\tif (props.store) {\n\t\t\t\t\t\tstore = props.store;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tif (internalStore === null || lastView !== currentView) {\n\t\t\t\t\t\t\t// Proto-safe guard: spec.state must be a plain object (T-37-05-02)\n\t\t\t\t\t\t\tinternalStore = xstateStoreStateStore({\n\t\t\t\t\t\t\t\tatom: createAtom(toAtomState(currentView.state)),\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\tlastView = currentView;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tstore = internalStore;\n\t\t\t\t\t}\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,IAAcvB,EAAuC,IAAI;AAiB/D,SAAgBwB,IAAgC;CAC/C,OAAOV,EAAkBb,EAAWsB,CAAW,GAAG,aAAa;AAChE;AA+BA,IAAMQ,KAKAI,MAAe;CACpB,IAAMC,IAAW9B,EAAc,GAGzB+B,KAA6BC,MAAY;EAC9C,IAAMC,IAAOH,EAASI,YAAY;EAClCJ,EAASK,OAAOH,EAAQC,CAAI,CAAC;CAC9B,GAEMG,IAAWP,EAAWH,eAAeU,eACpCL,SACAD,EAASI,YAAY,CAC5B,GAEMG,IAA8B;EACnCV,MAAME,EAAWF;EACjBS;EACAE,UAAUT,EAAWH,eAAeY;EACpCV,OAAOC,EAAWD;CACnB;CAEA,OAAAW,EAAQtB,EAAYuB,UAAQ;EAACC,OAAOJ;EAAS,IAAAb,WAAA;GAAA,OAAGK,EAAWL;EAAQ;CAAA,CAAA;AACpE,GAwBakB,KAAgDC,MAAU;CAEtE,IAAM,CAACC,GAAMC,KAAWvD,EAA8B,IAAI,GAYpDwD,IAAa,IAAIC,MAAM,CAAC,GAAmB;EAChDC,IAAIC,GAASC,GAAM;GAClB,IAAMC,IAAUR,EAAMS,OAChBX,IAAQY,QAAQL,IAAIG,GAASD,GAAMC,CAAO;GAChD,OAAO,OAAOV,KAAU,aAAaA,EAAMa,KAAKH,CAAO,IAAIV;EAC5D;EACAc,IAAIN,GAASC,GAAM;GAClB,OAAOA,KAASP,EAAMS;EACvB;CACD,CAAC,GAKKI,IAAyBhE,QACzBmD,EAAMc,gBACJ;EACN,GAAGd,EAAMjB;EACTY,UAAU5B,EAAyBiC,EAAMjB,eAAeY,UAAUK,EAAMc,aAAa;CACtF,IAJiCd,EAAMjB,cAKvC,GAGGgC,IAAmC,MACnCC,IAA4B;CAehC,OATApE,QAAmB;EAClB,IAAM4C,KAAUyB,MAA8Bf,EAAQe,CAAQ;EAC9DzB,EAAOQ,EAAMS,MAAMS,YAAYb,IAAI,CAAoB;EACvD,IAAMc,IAAUvD,EAAYoC,EAAMS,MAAMS,cAAcD,MAAa;GAClEzB,EAAOyB,CAA2B;EACnC,CAAC;EACDnE,QAAgBqE,EAAQ,CAAC;CAC1B,CAAC,GAEDvB,EACEzB,EAAa0B,UAAQ;EAACC,OAAOK;EAAU,IAAAtB,WAAA;GAAA,OAAAe,EACtC3C,GAAa;IACbwB,WAAW2C,OACVpB,EAAMrB,UAAUyC,CAAG,GACZpB,EAAMvB,YAAY;IACzB,IAAAI,WAAA;KAAA,cAEO;MACP,IAAMqC,IAAcjB,EAAK;MACzB,IAAI,CAACiB,GAAa,OAAOlB,EAAMvB,YAAY;MAG3C,IAAIQ;MAcJ,OAbIe,EAAMf,QACTA,IAAQe,EAAMf,UAEV8B,MAAkB,QAAQC,MAAaE,OAE1CH,IAAgBpD,EAAsB,EACrC0D,MAAM3D,EAAWI,EAAYoD,EAAYI,KAAK,CAAC,EAChD,CAAC,GACDN,IAAWE,IAEZjC,IAAQ8B,IAGTnB,EACExC,GAAa;OAAQ6B;OAAK,IAAAJ,WAAA;QAAA,OAAAe,EACzBd,GAAkB;SAAA,IAClBC,iBAAc;UAAA,OAAE8B,EAAuB;SAAC;SACxC7B,MAAMkC;SACCjC;SAAK,IAAAJ,WAAA;UAAA,OAEXmB,EAAMnB;SAAQ;QAAA,CAAA;OAAA;MAAA,CAAA;KAInB,EAAA,CAAG;IAAC;GAAA,CAAA;EAAA;CAAA,CAAA;AAIR"}

package/dist/PlayRenderer.js

@@ -1,31 +1,19 @@
-import { Dynamic as e, createComponent as t, insert as n, memo as r, mergeProps as i, template as a } from "solid-js/web";
-import { createSignal as o, onMount as s } from "solid-js";
-import { Signal as c } from "@xmachines/play-signals";
+import { usePlayView as e } from "./ActorProvider.js";
+import { createComponent as t } from "solid-js/web";
+import { Renderer as n } from "@xmachines/json-render-solid";
 //#region src/PlayRenderer.tsx
-var l = /* @__PURE__ */ a("<div class=play-renderer-error>Component \"<!>\" not found in catalog. Available: "), u = (a) => {
-	let [u, d] = o(a.actor.currentView.get());
-	s(() => {
-		let e = new c.subtle.Watcher(() => {
-			queueMicrotask(() => {
-				e.getPending(), d(a.actor.currentView.get()), e.watch(a.actor.currentView);
-			});
-		});
-		e.watch(a.actor.currentView);
+var r = () => {
+	let r = e();
+	return t(n, {
+		get spec() {
+			return r.spec;
+		},
+		get registry() {
+			return r.registry;
+		}
 	});
-	let f = a.actor.send.bind(a.actor);
-	return [
-		r(() => r(() => !u())() && (a.fallback || null)),
-		r(() => r(() => !!(u() && !a.components))() && (console.error(`Components catalog is ${a.components === null ? "null" : "undefined"}. Cannot render component "${u().component}".`), a.fallback || null)),
-		r(() => r(() => !!(u() && a.components && !a.components[u().component]))() && (console.error(`Component "${u().component}" not found in catalog. Available components: ${Object.keys(a.components).join(", ")}`), (() => {
-			var e = l(), t = e.firstChild.nextSibling;
-			return t.nextSibling, n(e, () => u().component, t), n(e, () => Object.keys(a.components).join(", "), null), e;
-		})())),
-		r(() => r(() => !!(u() && a.components && a.components[u().component]))() && t(e, i({ get component() {
-			return a.components[u().component];
-		} }, () => u().props, { send: f })))
-	];
 };
 //#endregion
-export { u as PlayRenderer };
+export { r as PlayRenderer };
 
 //# sourceMappingURL=PlayRenderer.js.map

package/dist/PlayRenderer.js.map

@@ -1 +1 @@
-{"version":3,"file":"PlayRenderer.js","names":["createSignal","onMount","Component","Dynamic","Signal","PlayRendererProps","SolidView","PlayRenderer","props","view","setView","actor","currentView","get","watcher","subtle","Watcher","queueMicrotask","getPending","watch","sendBound","send","bind","_$memo","fallback","components","console","error","component","Object","keys","join","_el$","_tmpl$","_el$2","firstChild","_el$5","nextSibling","_el$3","_$insert","_$createComponent","_$mergeProps"],"sources":["../src/PlayRenderer.tsx"],"sourcesContent":["/**\n * PlayRenderer - Main SolidJS renderer component for XMachines Play architecture\n *\n * @packageDocumentation\n */\n\nimport { createSignal, onMount, type Component } from \"solid-js\";\nimport { Dynamic } from \"solid-js/web\";\nimport { Signal } from \"@xmachines/play-signals\";\nimport type { PlayRendererProps, SolidView } from \"./types.js\";\n\n/**\n * Main renderer component that subscribes to actor signals and renders UI\n *\n * Architecture (per XMachines Play patterns):\n * - Subscribes to actor.currentView signal via TC39 Signal.subtle.Watcher\n * - Dynamically renders catalog components based on view.component string\n * - Forwards user events to actor via actor.send()\n * - SolidJS signal only for triggering renders, NOT business logic\n *\n * Invariant: Actor Authority - Actor decides all state transitions via guards.\n * Invariant: Passive Infrastructure - Component observes signals and sends events.\n * Invariant: Signal-Only Reactivity - Business logic state lives in actor signals.\n *\n * @example\n * ```typescript\n * import { PlayRenderer } from \"@xmachines/play-solidjs\";\n * import { definePlayer } from \"@xmachines/play-xstate\";\n *\n * const actor = definePlayer({ machine, catalog })();\n * actor.start();\n *\n * const components = {\n *   Dashboard: (props) => <div>User: {props.userId}</div>,\n *   LoginForm: (props) => (\n *     <form onSubmit={(e) => {\n *       e.preventDefault();\n *       props.send({ type: \"auth.login\", payload: {...} });\n *     }}>...</form>\n *   )\n * };\n *\n * <PlayRenderer actor={actor} components={components} />\n * ```\n *\n * @param props - Component props\n * @returns SolidJS element rendering current view from actor\n *\n * @remarks\n * **Component lookup:** Dynamically looks up component from `components` map\n * using `view.component` string from actor.currentView signal.\n *\n * **Event forwarding:** Injects `send` function as prop to components. Components\n * call `send(event)` to forward intents to actor. Actor guards decide validity.\n *\n * **Error handling:** If component not found in catalog, logs error and shows\n * fallback. This indicates missing component registration, not runtime error.\n *\n * **Signal bridge:** Uses one-shot re-watch pattern. TC39 Signal watchers stop\n * watching after notification, so watcher.watch() must be called in microtask\n * after getPending() to re-arm for next notification.\n *\n * **CRITICAL:** Never call actor.send() during render - only in event handlers.\n * Calling send during render causes infinite render loops.\n */\nexport const PlayRenderer: Component<PlayRendererProps> = (props) => {\n\t// Create SolidJS signal for view\n\t// Signal is NOT business logic state - it's just SolidJS's render trigger\n\tconst [view, setView] = createSignal<SolidView>(props.actor.currentView.get() as SolidView);\n\n\t// Bridge TC39 Signal to SolidJS signal\n\t// Uses one-shot re-watch pattern (must re-watch after each notification)\n\tonMount(() => {\n\t\tconst watcher = new Signal.subtle.Watcher(() => {\n\t\t\tqueueMicrotask(() => {\n\t\t\t\t// Acknowledge the notification\n\t\t\t\twatcher.getPending();\n\n\t\t\t\t// Update SolidJS signal (triggers SolidJS reactivity)\n\t\t\t\tsetView(props.actor.currentView.get() as SolidView);\n\n\t\t\t\t// Re-watch for next notification (one-shot pattern)\n\t\t\t\t// TC39 Signal watchers stop watching after notification\n\t\t\t\twatcher.watch(props.actor.currentView);\n\t\t\t});\n\t\t});\n\n\t\t// Watch actor.currentView for changes\n\t\twatcher.watch(props.actor.currentView);\n\n\t\t// Note: TC39 Signal watchers don't have explicit disposal\n\t\t// The watcher will be garbage collected when the component unmounts\n\t});\n\n\t// Bind send function (ensures correct 'this' context)\n\tconst sendBound = props.actor.send.bind(props.actor);\n\n\treturn (\n\t\t<>\n\t\t\t{/* No view - show fallback */}\n\t\t\t{!view() && (props.fallback || null)}\n\n\t\t\t{/* Handle null/undefined components catalog gracefully */}\n\t\t\t{view() &&\n\t\t\t\t!props.components &&\n\t\t\t\t(() => {\n\t\t\t\t\tconsole.error(\n\t\t\t\t\t\t`Components catalog is ${props.components === null ? \"null\" : \"undefined\"}. ` +\n\t\t\t\t\t\t\t`Cannot render component \"${view()!.component}\".`,\n\t\t\t\t\t);\n\t\t\t\t\treturn props.fallback || null;\n\t\t\t\t})()}\n\n\t\t\t{/* View exists but component not found */}\n\t\t\t{view() &&\n\t\t\t\tprops.components &&\n\t\t\t\t!props.components[view()!.component] &&\n\t\t\t\t(() => {\n\t\t\t\t\tconsole.error(\n\t\t\t\t\t\t`Component \"${view()!.component}\" not found in catalog. ` +\n\t\t\t\t\t\t\t`Available components: ${Object.keys(props.components).join(\", \")}`,\n\t\t\t\t\t);\n\t\t\t\t\treturn (\n\t\t\t\t\t\t<div class=\"play-renderer-error\">\n\t\t\t\t\t\t\tComponent \"{view()!.component}\" not found in catalog. Available:{\" \"}\n\t\t\t\t\t\t\t{Object.keys(props.components).join(\", \")}\n\t\t\t\t\t\t</div>\n\t\t\t\t\t);\n\t\t\t\t})()}\n\n\t\t\t{/* Render matched component dynamically */}\n\t\t\t{view() && props.components && props.components[view()!.component] && (\n\t\t\t\t<Dynamic\n\t\t\t\t\tcomponent={props.components[view()!.component]}\n\t\t\t\t\t{...view()!.props}\n\t\t\t\t\tsend={sendBound}\n\t\t\t\t/>\n\t\t\t)}\n\t\t</>\n\t);\n};\n"],"mappings":";;;;iHAiEaO,KAA8CC,MAAU;CAGpE,IAAM,CAACC,GAAMC,KAAWV,EAAwBQ,EAAMG,MAAMC,YAAYC,KAAK,CAAc;AAI3FZ,SAAc;EACb,IAAMa,IAAU,IAAIV,EAAOW,OAAOC,cAAc;AAC/CC,wBAAqB;AASpBH,IAPAA,EAAQI,YAAY,EAGpBR,EAAQF,EAAMG,MAAMC,YAAYC,KAAK,CAAc,EAInDC,EAAQK,MAAMX,EAAMG,MAAMC,YAAY;KACrC;IACD;AAGFE,IAAQK,MAAMX,EAAMG,MAAMC,YAAY;GAIrC;CAGF,IAAMQ,IAAYZ,EAAMG,MAAMU,KAAKC,KAAKd,EAAMG,MAAM;AAEpD,QAAA;EAAAY,QAGGA,QAAA,CAACd,GAAM,CAAA,EAAA,KAAKD,EAAMgB,YAAY,MAAK;EAAAD,QAGnCA,QAAA,CAAA,EAAAd,GAAM,IACN,CAACD,EAAMiB,YAAU,EAAA,KAEhBC,QAAQC,MACP,yBAAyBnB,EAAMiB,eAAe,OAAO,SAAS,YAAW,6BAC5ChB,GAAM,CAAEmB,UAAS,IAC9C,EACMpB,EAAMgB,YAAY,MACtB;EAAAD,QAGJA,QAAA,CAAA,EAAAd,GAAM,IACND,EAAMiB,cACN,CAACjB,EAAMiB,WAAWhB,GAAM,CAAEmB,YAAU,EAAA,KAEnCF,QAAQC,MACP,cAAclB,GAAM,CAAEmB,UAAS,gDACLC,OAAOC,KAAKtB,EAAMiB,WAAW,CAACM,KAAK,KAAK,GAClE,SACD;GAAA,IAAAC,IAAAC,GAAA,EAAAG,IAAAJ,EAAAG,WAAAE;AAG2C,UAH3CD,EAAAC,aAAAE,EAAAP,SAEcvB,GAAM,CAAEmB,WAASQ,EAAA,EAAAG,EAAAP,SAC5BH,OAAOC,KAAKtB,EAAMiB,WAAW,CAACM,KAAK,KAAK,EAAA,KAAA,EAAAC;MAAA,EAGxC;EAAAT,QAGJA,QAAA,CAAA,EAAAd,GAAM,IAAID,EAAMiB,cAAcjB,EAAMiB,WAAWhB,GAAM,CAAEmB,YAAU,EAAA,IAAAY,EAChErC,GAAOsC,EAAA,EAAA,IACPb,YAAS;AAAA,UAAEpB,EAAMiB,WAAWhB,GAAM,CAAEmB;KAAU,QAC1CnB,GAAM,CAAED,OAAK,EACjBa,MAAMD,GAAS,CAAA,CAEhB,CAAA;EAAA"}
+{"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,UAAgC;CAC5C,IAAMC,IAAOF,EAAY;CACzB,OAAAG,EAAQJ,GAAQ;EAAA,IAACK,OAAI;GAAA,OAAEF,EAAKE;EAAI;EAAA,IAAEC,WAAQ;GAAA,OAAEH,EAAKG;EAAQ;CAAA,CAAA;AAC1D"}

package/dist/PlayUIProvider.js

@@ -0,0 +1,35 @@
+import { ActorProvider as e, usePlayView as t } from "./ActorProvider.js";
+import { createComponent as n, mergeProps as r } from "solid-js/web";
+import { JSONUIProvider as i } from "@xmachines/json-render-solid";
+//#region src/PlayUIProvider.tsx
+var a = (e) => {
+	let a = t();
+	return n(i, r({
+		get registry() {
+			return a.registry;
+		},
+		get handlers() {
+			return a.handlers;
+		},
+		get store() {
+			return a.store;
+		}
+	}, () => e.validationFunctions !== void 0 && { validationFunctions: e.validationFunctions }, () => e.navigate !== void 0 && { navigate: e.navigate }, () => e.functions !== void 0 && { functions: e.functions }, { get children() {
+		return e.children;
+	} }));
+}, o = (t) => n(e, r({
+	get actor() {
+		return t.actor;
+	},
+	get registryResult() {
+		return t.registryResult;
+	}
+}, () => t.store !== void 0 && { store: t.store }, () => t.fallback !== void 0 && { fallback: t.fallback }, () => t.onError !== void 0 && { onError: t.onError }, () => t.onRenderError !== void 0 && { onRenderError: t.onRenderError }, { get children() {
+	return n(a, r(() => t.validationFunctions !== void 0 && { validationFunctions: t.validationFunctions }, () => t.navigate !== void 0 && { navigate: t.navigate }, () => t.functions !== void 0 && { functions: t.functions }, { get children() {
+		return t.children;
+	} }));
+} }));
+//#endregion
+export { o as PlayUIProvider };
+
+//# sourceMappingURL=PlayUIProvider.js.map

package/dist/PlayUIProvider.js.map

@@ -0,0 +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,KACLG,MACI;CACJ,IAAMC,IAAOV,EAAY;CAEzB,OAAAW,EACEd,GAAce,EAAA;EAAA,IACdC,WAAQ;GAAA,OAAEH,EAAKG;EAAQ;EAAA,IACvBC,WAAQ;GAAA,OAAEJ,EAAKI;EAAQ;EAAA,IACvBC,QAAK;GAAA,OAAEL,EAAKK;EAAK;CAAA,SACZN,EAAYO,wBAAwBC,KAAAA,KAAa,EACrDD,qBAAqBP,EAAYO,oBAClC,SACKP,EAAYS,aAAaD,KAAAA,KAAa,EAAEC,UAAUT,EAAYS,SAAS,SACvET,EAAYU,cAAcF,KAAAA,KAAa,EAAEE,WAAWV,EAAYU,UAAU,GAAC,EAAA,IAAAZ,WAAA;EAAA,OAE/EE,EAAYF;CAAQ,EAAA,CAAA,CAAA;AAGxB,GAkBaa,KAAkDC,MAC9DV,EACEZ,GAAaa,EAAA;CAAA,IACbU,QAAK;EAAA,OAAED,EAAMC;CAAK;CAAA,IAClBC,iBAAc;EAAA,OAAEF,EAAME;CAAc;AAAA,SAC/BF,EAAMN,UAAUE,KAAAA,KAAa,EAAEF,OAAOM,EAAMN,MAAM,SAClDM,EAAMG,aAAaP,KAAAA,KAAa,EAAEO,UAAUH,EAAMG,SAAS,SAC3DH,EAAMI,YAAYR,KAAAA,KAAa,EAAEQ,SAASJ,EAAMI,QAAQ,SACxDJ,EAAMK,kBAAkBT,KAAAA,KAAa,EAAES,eAAeL,EAAMK,cAAc,GAAC,EAAA,IAAAnB,WAAA;CAAA,OAAAI,EAE/EL,GAAYM,QACPS,EAAML,wBAAwBC,KAAAA,KAAa,EAC/CD,qBAAqBK,EAAML,oBAC5B,SACKK,EAAMH,aAAaD,KAAAA,KAAa,EAAEC,UAAUG,EAAMH,SAAS,SAC3DG,EAAMF,cAAcF,KAAAA,KAAa,EAAEE,WAAWE,EAAMF,UAAU,GAAC,EAAA,IAAAZ,WAAA;EAAA,OAEnEc,EAAMd;CAAQ,EAAA,CAAA,CAAA;AAAA,EAAA,CAAA,CAAA"}

package/dist/index.js

@@ -1,2 +1,6 @@
-import { PlayRenderer as e } from "./PlayRenderer.js";
-export { e as PlayRenderer };
+import { ActorContext as e, useActor as t } from "./useActor.js";
+import { ActorProvider as n, usePlayView as r } from "./ActorProvider.js";
+import { PlayRenderer as i } from "./PlayRenderer.js";
+import { PlayUIProvider as a } from "./PlayUIProvider.js";
+import { ActionProvider as o, JSONUIProvider as s, Renderer as c, StateProvider as l, ValidationProvider as u, VisibilityProvider as d, defineRegistry as f, useAction as p, useActions as m, useBoundProp as h, useFieldValidation as g, useIsVisible as _, useOptionalValidation as v, useStateBinding as y, useStateStore as b, useStateValue as x, useVisibility as S } from "@xmachines/json-render-solid";
+export { o as ActionProvider, e as ActorContext, n as ActorProvider, s as JSONUIProvider, i as PlayRenderer, a as PlayUIProvider, c as Renderer, l as StateProvider, u as ValidationProvider, d as VisibilityProvider, f as defineRegistry, p as useAction, m as useActions, t as useActor, h as useBoundProp, g as useFieldValidation, _ as useIsVisible, v as useOptionalValidation, r as usePlayView, y as useStateBinding, b as useStateStore, x as useStateValue, S as useVisibility };

package/dist/useActor.js

@@ -0,0 +1,11 @@
+import { createContext as e, useContext as t } from "solid-js";
+import { assertNonNullable as n } from "@xmachines/play";
+//#region src/useActor.ts
+var r = e(null);
+function i() {
+	return n(t(r), "ActorContext");
+}
+//#endregion
+export { r as ActorContext, i as useActor };
+
+//# sourceMappingURL=useActor.js.map

package/dist/useActor.js.map

@@ -0,0 +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,IAAe,EAAmC,IAAI;AAEnE,SAAgB,IAAyB;CACxC,OAAO,EAAkB,EAAW,CAAY,GAAG,cAAc;AAClE"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xmachines/play-solid",
-  "version": "1.0.0-beta.9",
-  "description": "SolidJS renderer for XMachines Play architecture",
+  "version": "2.0.0-alpha.1",
+  "description": "Solid renderer for XMachines Play architecture",
   "keywords": [
     "catalog",
     "play",
@@ -12,6 +12,11 @@
   ],
   "license": "MIT",
   "author": "XMachines Contributors",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@gitlab.com/xmachin-es/xmachines-js.git",
+    "directory": "packages/play-solid"
+  },
   "files": [
     "dist",
     "README.md",
@@ -20,6 +25,7 @@
   "type": "module",
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     }
@@ -29,29 +35,49 @@
   },
   "scripts": {
     "build": "vite build && tsc --build",
-    "clean": "rm -rf dist tsconfig.tsbuildinfo node_modules/.vite node_modules/.vite-temp",
-    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist *.tsbuildinfo coverage .vitest-attachments test/browser/__screenshots__ node_modules/.svelte2tsx-* node_modules/.vite*",
+    "lint": "oxlint .",
+    "format": "oxfmt .",
     "test": "vitest",
     "test:watch": "vitest",
     "test:ui": "vitest --ui",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@xmachines/play-actor": "1.0.0-beta.9",
-    "@xmachines/play-catalog": "1.0.0-beta.9",
-    "@xmachines/play-signals": "1.0.0-beta.9"
+    "@xmachines/play": "2.0.0-alpha.1",
+    "@xmachines/play-actor": "2.0.0-alpha.1",
+    "@xmachines/play-signals": "2.0.0-alpha.1"
   },
   "devDependencies": {
     "@solidjs/testing-library": "^0.8.10",
-    "@types/node": "^25.5.0",
-    "@xmachines/shared": "1.0.0-beta.9",
-    "solid-js": "^1.9.11",
-    "typescript": "^5.9.3",
-    "vite": "^8.0.0",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@types/node": "^26.1.1",
+    "@vitest/browser-playwright": "^4.1.10",
+    "@xmachines/json-render-core": "^0.19.0-xm.2",
+    "@xmachines/json-render-solid": "^0.19.0-xm.2",
+    "@xmachines/json-render-xstate": "^0.19.0-xm.2",
+    "@xmachines/shared": "2.0.0-alpha.1",
+    "@xstate/store": "^3.17.0",
+    "jsdom": "^29.1.0",
+    "oxfmt": "^0.58.0",
+    "oxlint": "^1.73.0",
+    "solid-js": "^1.9.12",
+    "typescript": "^5.9.3 || ^6.0.3",
+    "vite": "^8.0.10",
     "vite-plugin-solid": "^2.11.11",
-    "vitest": "^4.1.0"
+    "vitest": "^4.1.10",
+    "xstate": "^6.0.0-alpha.20",
+    "zod": "^4.4.1"
   },
   "peerDependencies": {
-    "solid-js": "^1.8.0"
+    "@xmachines/json-render-core": "^0.19.0-xm.2",
+    "@xmachines/json-render-solid": "^0.19.0-xm.2",
+    "@xmachines/json-render-xstate": "^0.19.0-xm.2",
+    "@xstate/store": "^3.17.0",
+    "solid-js": "^1.8.0",
+    "xstate": "^6.0.0-alpha.20"
+  },
+  "engines": {
+    "node": ">=22.0.0"
   }
 }

package/dist/PlayRenderer.d.ts

@@ -1,63 +0,0 @@
-/**
- * PlayRenderer - Main SolidJS renderer component for XMachines Play architecture
- *
- * @packageDocumentation
- */
-import { type Component } from "solid-js";
-import type { PlayRendererProps } from "./types.js";
-/**
- * Main renderer component that subscribes to actor signals and renders UI
- *
- * Architecture (per XMachines Play patterns):
- * - Subscribes to actor.currentView signal via TC39 Signal.subtle.Watcher
- * - Dynamically renders catalog components based on view.component string
- * - Forwards user events to actor via actor.send()
- * - SolidJS signal only for triggering renders, NOT business logic
- *
- * Invariant: Actor Authority - Actor decides all state transitions via guards.
- * Invariant: Passive Infrastructure - Component observes signals and sends events.
- * Invariant: Signal-Only Reactivity - Business logic state lives in actor signals.
- *
- * @example
- * ```typescript
- * import { PlayRenderer } from "@xmachines/play-solidjs";
- * import { definePlayer } from "@xmachines/play-xstate";
- *
- * const actor = definePlayer({ machine, catalog })();
- * actor.start();
- *
- * const components = {
- *   Dashboard: (props) => <div>User: {props.userId}</div>,
- *   LoginForm: (props) => (
- *     <form onSubmit={(e) => {
- *       e.preventDefault();
- *       props.send({ type: "auth.login", payload: {...} });
- *     }}>...</form>
- *   )
- * };
- *
- * <PlayRenderer actor={actor} components={components} />
- * ```
- *
- * @param props - Component props
- * @returns SolidJS element rendering current view from actor
- *
- * @remarks
- * **Component lookup:** Dynamically looks up component from `components` map
- * using `view.component` string from actor.currentView signal.
- *
- * **Event forwarding:** Injects `send` function as prop to components. Components
- * call `send(event)` to forward intents to actor. Actor guards decide validity.
- *
- * **Error handling:** If component not found in catalog, logs error and shows
- * fallback. This indicates missing component registration, not runtime error.
- *
- * **Signal bridge:** Uses one-shot re-watch pattern. TC39 Signal watchers stop
- * watching after notification, so watcher.watch() must be called in microtask
- * after getPending() to re-arm for next notification.
- *
- * **CRITICAL:** Never call actor.send() during render - only in event handlers.
- * Calling send during render causes infinite render loops.
- */
-export declare const PlayRenderer: Component<PlayRendererProps>;
-//# sourceMappingURL=PlayRenderer.d.ts.map

package/dist/PlayRenderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PlayRenderer.d.ts","sourceRoot":"","sources":["../src/PlayRenderer.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAyB,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AAGjE,OAAO,KAAK,EAAE,iBAAiB,EAAa,MAAM,YAAY,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,CAAC,iBAAiB,CA2ErD,CAAC"}

package/dist/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * SolidJS renderer for XMachines Play architecture
- *
- * @packageDocumentation
- */
-export { PlayRenderer } from "./PlayRenderer.js";
-export type { PlayRendererProps } from "./types.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC"}

package/dist/types.d.ts

@@ -1,28 +0,0 @@
-/**
- * TypeScript type definitions for play-solidjs
- *
- * @packageDocumentation
- */
-import type { AbstractActor, Viewable } from "@xmachines/play-actor";
-import type { JSX, ValidComponent } from "solid-js";
-import type { AnyActorLogic } from "xstate";
-export type SolidView = {
-    component: string;
-    props: Record<string, unknown>;
-} | null;
-/**
- * Props for PlayRenderer component
- *
- * @property actor - Actor instance with currentView signal (requires Viewable capability)
- * @property components - Map of component names to SolidJS components
- * @property fallback - Optional element shown when currentView is null
- */
-export interface PlayRendererProps {
-    /** Actor instance with currentView signal (requires Viewable capability) */
-    actor: AbstractActor<AnyActorLogic> & Viewable;
-    /** Map of component names to SolidJS components */
-    components: Record<string, ValidComponent>;
-    /** Optional element shown when currentView is null */
-    fallback?: JSX.Element;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,KAAK,EAAE,GAAG,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C,MAAM,MAAM,SAAS,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG,IAAI,CAAC;AAErF;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IACjC,4EAA4E;IAC5E,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC;IAE/C,mDAAmD;IACnD,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAE3C,sDAAsD;IACtD,QAAQ,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC;CACvB"}