@xmachines/play-solid 1.0.0-beta.9 → 1.1.0

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,203 @@
 # @xmachines/play-solid
 
-**SolidJS renderer consuming signals and UI schema with provider pattern**
+> Solid renderer for XMachines Play architecture
 
-Signal-driven SolidJS rendering layer observing actor state with zero SolidJS state for business logic.
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Version](https://img.shields.io/badge/version-1.1.0-blue)](https://www.npmjs.com/package/@xmachines/play-solid)
 
-## Overview
+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.
 
-`@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:
-
-- **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
-
-**Key Principle:** SolidJS state is never used for business logic. 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
-
-- `PlayRenderer`
-- `PlayRendererProps` (type)
-
-**Peer dependencies:**
+**Peer dependencies** — install alongside the package:
 
-- `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
+## Usage
 
-**Behavior:**
+### `PlayUIProvider` + `PlayRenderer` (recommended)
 
-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 />`
-
-**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
-
-This package implements **Signal-Only Reactivity (INV-05)** and **Passive Infrastructure (INV-04)**:
+## API Summary
 
-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
+### Components
 
-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
+| 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                        |
 
-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
+### Hooks
 
-4. **Microtask Batching:**
-    - `Signal.subtle.Watcher` coalesces rapid signal changes
-    - Prevents SolidJS thrashing from multiple signal updates
-    - Single SolidJS render per microtask batch
+| 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 |
 
-5. **Explicit Disposal Contract:**
-    - Component teardown calls watcher `unwatch` in `onCleanup`
-    - Do not rely on GC-only cleanup
+### Context
 
-**Pattern:**
+| Export         | Description                                                                            |
+| -------------- | -------------------------------------------------------------------------------------- |
+| `ActorContext` | SolidJS context for the actor; use `ActorContext.Provider` directly as an escape hatch |
 
-- Renderer receives actor via props (provider pattern)
-- Enables composition with navigation, headers, footers
-- Supports multiple renderers in same app
+### Re-exports from `@xmachines/json-render-solid`
 
-**Architectural Invariants:**
+This package re-exports the full `@xmachines/json-render-solid` public API so consumers do not need a direct dependency:
 
-- **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.d.ts

@@ -0,0 +1,79 @@
+/**
+ * ActorProvider — Smart SolidJS provider component for 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 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
+ *
+ * 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.
+ *
+ * @packageDocumentation
+ */
+import type { Component, JSX } from "solid-js";
+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.
+ */
+export interface ViewContextValue extends BaseViewContextValue<ComponentRegistry> {
+}
+/**
+ * Hook to access the current view context inside an ActorProvider tree.
+ *
+ * @throws {Error} If called outside an ActorProvider (or PlayUIProvider) tree
+ *
+ * @example
+ * ```tsx
+ * import { usePlayView } from "@xmachines/play-solid";
+ *
+ * const MyRenderer: Component = () => {
+ *   const view = usePlayView();
+ *   return <Renderer spec={view.spec} registry={view.registry} />;
+ * };
+ * ```
+ */
+export declare function usePlayView(): ViewContextValue;
+/**
+ * Props for ActorProvider — the escape hatch primitive.
+ *
+ * For batteries-included usage, prefer PlayUIProvider which wraps ActorProvider
+ * with JSONUIProvider and all required sub-providers.
+ */
+export interface ActorProviderProps extends BaseActorProviderProps<DefineRegistryResult> {
+    /** Optional fallback element shown when currentView is null or ErrorBoundary catches */
+    fallback?: JSX.Element;
+    /** Optional callback invoked when SolidJS ErrorBoundary catches an error */
+    onError?: (error: unknown) => void;
+    /** Children — required; must include <PlayRenderer /> (or use PlayUIProvider shorthand) */
+    children: JSX.Element;
+}
+/**
+ * Smart ActorProvider component — owns actor bridging, signal subscription,
+ * StateStore lifecycle, handler resolution, and 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.
+ *
+ * @example
+ * ```tsx
+ * import { ActorProvider, PlayRenderer } from "@xmachines/play-solid";
+ *
+ * <ActorProvider actor={myActor} registryResult={registryResult}>
+ *   <PlayRenderer />
+ * </ActorProvider>
+ * ```
+ */
+export declare const ActorProvider: Component<ActorProviderProps>;
+//# sourceMappingURL=ActorProvider.d.ts.map

package/dist/ActorProvider.d.ts.map

@@ -0,0 +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"}

package/dist/PlayRenderer.d.ts

@@ -1,63 +1,24 @@
 /**
- * PlayRenderer - Main SolidJS renderer component for XMachines Play architecture
+ * PlayRenderer - Zero-prop leaf component for XMachines Play SolidJS 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>
- *   )
- * };
+ * Reads view context from the enclosing ActorProvider (or PlayUIProvider) via
+ * usePlayView() and renders the spec using @xmachines/json-render-solid's Renderer.
  *
- * <PlayRenderer actor={actor} components={components} />
+ * Standard usage:
+ * ```tsx
+ * <PlayUIProvider actor={myActor} registryResult={registryResult}>
+ *   <PlayRenderer />
+ * </PlayUIProvider>
  * ```
  *
- * @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.
+ * @packageDocumentation
+ */
+import type { Component } from "solid-js";
+/**
+ * Zero-prop leaf renderer. Must be placed inside an ActorProvider or PlayUIProvider tree.
  *
- * **CRITICAL:** Never call actor.send() during render - only in event handlers.
- * Calling send during render causes infinite render loops.
+ * Reads ViewContextValue (spec, handlers, registry) from the enclosing provider
+ * via usePlayView() and renders the spec via @xmachines/json-render-solid's Renderer.
  */
-export declare const PlayRenderer: Component<PlayRendererProps>;
+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;;;;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"}
+{"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"}

package/dist/PlayUIProvider.d.ts

@@ -0,0 +1,49 @@
+/**
+ * PlayUIProvider — Batteries-included SolidJS provider for XMachines Play.
+ *
+ * Wraps ActorProvider + JSONUIProvider into a single composite provider.
+ * This is the recommended entry point for most users.
+ *
+ * Standard usage:
+ * ```tsx
+ * import { PlayUIProvider, PlayRenderer, defineRegistry } from "@xmachines/play-solid";
+ *
+ * const registryResult = defineRegistry(myCatalog, { components, actions });
+ *
+ * <PlayUIProvider actor={myActor} registryResult={registryResult}>
+ *   <PlayRenderer />
+ * </PlayUIProvider>
+ * ```
+ *
+ * For full control (library authors), use ActorProvider directly.
+ *
+ * @packageDocumentation
+ */
+import type { Component } from "solid-js";
+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.
+ */
+export interface PlayUIProviderProps extends ActorProviderProps, Partial<JSONUIForwardedProps> {
+}
+/**
+ * Batteries-included composite provider: ActorProvider + 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)
+ *
+ * @example
+ * ```tsx
+ * <PlayUIProvider actor={myActor} registryResult={registryResult} navigate={navigate}>
+ *   <PlayRenderer />
+ * </PlayUIProvider>
+ * ```
+ */
+export declare const PlayUIProvider: Component<PlayUIProviderProps>;
+export {};
+//# sourceMappingURL=PlayUIProvider.d.ts.map

package/dist/PlayUIProvider.d.ts.map

@@ -0,0 +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"}

package/dist/index.d.ts

@@ -1,8 +1,29 @@
 /**
- * SolidJS renderer for XMachines Play architecture
+ * @xmachines/play-solid - SolidJS renderer for 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.
+ *
+ * Primary entry point:
+ * ```tsx
+ * import { PlayUIProvider, PlayRenderer, defineRegistry } from "@xmachines/play-solid";
+ * ```
+ *
+ * For escape-hatch provider composition:
+ * ```tsx
+ * import { ActorProvider, ActorContext, usePlayView } from "@xmachines/play-solid";
+ * ```
  *
  * @packageDocumentation
  */
 export { PlayRenderer } from "./PlayRenderer.js";
-export type { PlayRendererProps } from "./types.js";
+export { ActorProvider, usePlayView } from "./ActorProvider.js";
+export { PlayUIProvider } from "./PlayUIProvider.js";
+export { ActorContext, useActor } from "./useActor.js";
+export { JSONUIProvider, StateProvider, ActionProvider, VisibilityProvider, ValidationProvider, Renderer, defineRegistry, useBoundProp, useStateBinding, useStateValue, useStateStore, useActions, useAction, useIsVisible, useFieldValidation, useOptionalValidation, useVisibility, } from "@xmachines/json-render-solid";
+export type { JSONUIProviderProps, StateProviderProps, ActionProviderProps, VisibilityProviderProps, ValidationProviderProps, RendererProps, ComponentFn, ComponentContext, ComponentRegistry, DefineRegistryResult, SetState, } from "@xmachines/json-render-solid";
+export type { RenderErrorHandler } from "@xmachines/json-render-solid";
+export type { ActorProviderProps, PlayUIProviderProps, ViewContextValue } from "./types.js";
+export type { AnyPlayActor } from "./useActor.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"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"}

package/dist/types.d.ts

@@ -1,28 +1,12 @@
 /**
- * TypeScript type definitions for play-solidjs
+ * TypeScript type definitions for play-solid
  *
- * @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
+ * Re-exports the primary prop types from their respective source files.
+ * PlayRendererProps has been removed per D-06 (replaced by ActorProviderProps / PlayUIProviderProps).
  *
- * @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
+ * @packageDocumentation
  */
-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;
-}
+export type { RenderErrorHandler } from "@xmachines/json-render-solid";
+export type { ActorProviderProps, ViewContextValue } from "./ActorProvider.js";
+export type { PlayUIProviderProps } from "./PlayUIProvider.js";
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,YAAY,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACvE,YAAY,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC/E,YAAY,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/useActor.d.ts

@@ -0,0 +1,32 @@
+/**
+ * useActor — SolidJS hook for accessing 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.
+ *
+ * @throws {Error} If called outside an ActorProvider tree
+ *
+ * @example
+ * ```typescript
+ * import { useActor } from "@xmachines/play-solid";
+ *
+ * function MyComponent() {
+ *   const actor = useActor();
+ *   return <button onClick={() => actor.send({ type: "SUBMIT" })}>Submit</button>;
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+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`. */
+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.
+ */
+export declare const ActorContext: import("solid-js").Context<AnyPlayActor | null>;
+export declare function useActor(): AnyPlayActor;
+//# sourceMappingURL=useActor.d.ts.map

package/dist/useActor.d.ts.map

@@ -0,0 +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"}

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": "1.1.0",
+  "description": "Solid renderer for XMachines Play architecture",
   "keywords": [
     "catalog",
     "play",
@@ -12,12 +12,18 @@
   ],
   "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",
     "LICENSE"
   ],
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -29,29 +35,47 @@
   },
   "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"
+    "test:ui": "vitest --ui"
   },
   "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": "1.1.0",
+    "@xmachines/play-actor": "1.1.0",
+    "@xmachines/play-signals": "1.1.0"
   },
   "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.2.0",
+    "@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",
+    "@xstate/store": "^3.17.0",
+    "jsdom": "^29.1.0",
+    "oxfmt": "^0.64.0",
+    "oxlint": "^1.79.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.11",
+    "xstate": "^5.31.0",
+    "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": "^5.31.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
   }
 }

package/dist/PlayRenderer.js

@@ -1,31 +0,0 @@
-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";
-//#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);
-	});
-	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 };
-
-//# sourceMappingURL=PlayRenderer.js.map

package/dist/PlayRenderer.js.map

@@ -1 +0,0 @@
-{"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"}

package/dist/index.js

@@ -1,2 +0,0 @@
-import { PlayRenderer as e } from "./PlayRenderer.js";
-export { e as PlayRenderer };