@xmachines/play-tanstack-solid-router 1.0.0-beta.6 → 1.0.0-beta.8

package/README.md

@@ -6,7 +6,7 @@ Signals-native integration with TanStack Solid Router enabling logic-driven navi
 
 ## Overview
 
-`@xmachines/play-tanstack-solid-router` provides seamless integration between TanStack Solid Router and XMachines state machines. Built on Solid's reactive primitives (`createEffect`), it implements the RouterBridge protocol for bidirectional synchronization.
+`@xmachines/play-tanstack-solid-router` provides seamless integration between TanStack Solid Router and XMachines state machines. Built on Solid's reactive primitives, it implements the `RouterBridgeBase` pattern for bidirectional synchronization while remaining framework-swappable.
 
 Per [RFC Play v1](https://gitlab.com/xmachin-es/rfc/-/blob/main/src/play-v1.md), this package implements:
 
@@ -17,26 +17,26 @@ Per [RFC Play v1](https://gitlab.com/xmachin-es/rfc/-/blob/main/src/play-v1.md),
 **Key Benefits:**
 
 - **Signals-native:** Zero adaptation layer between Solid signals and TC39 Signals
-- **RouterBridge pattern:** ~220 lines, 2 flags (consistent with Vue/Solid Router adapters)
-- **Automatic tracking:** `createEffect` handles dependency tracking (no manual Watcher)
+- **Bridge-first:** Extends shared `RouterBridgeBase` policy used by other adapters
+- **Automatic tracking:** `createEffect` handles dependency tracking (no manual Watcher setup needed for the bridge)
 - **Logic-driven navigation:** Business logic in state machines, not components
 - **Type-safe parameters:** Route params flow through state machine context
 
 **Framework Compatibility:**
 
-- TanStack Solid Router 1.0.0+
+- TanStack Solid Router 1.100.0+
 - SolidJS 1.8.0+
 - TC39 Signals polyfill integration
 
 ## Installation
 
 ```bash
-npm install @tanstack/solid-router@^1.0.0 solid-js@^1.8.0 @xmachines/play-tanstack-solid-router @xmachines/play-solid
+npm install @tanstack/solid-router@^1.167.0 solid-js@^1.8.0 @xmachines/play-tanstack-solid-router @xmachines/play-solid
 ```
 
 **Peer dependencies:**
 
-- `@tanstack/solid-router` ^1.0.0 - TanStack Solid Router library
+- `@tanstack/solid-router` ^1.167.0 - TanStack Solid Router library
 - `solid-js` ^1.8.0 - SolidJS runtime
 - `@xmachines/play-solid` - Solid renderer (`PlayRenderer`)
 - `@xmachines/play-actor` - Actor base
@@ -45,99 +45,110 @@ npm install @tanstack/solid-router@^1.0.0 solid-js@^1.8.0 @xmachines/play-tansta
 
 ## Quick Start
 
-```typescript
-import { createRouter } from '@tanstack/solid-router';
-import { onCleanup } from 'solid-js';
-import { PlayRenderer } from '@xmachines/play-solid';
-import { definePlayer } from '@xmachines/play-xstate';
-import { extractMachineRoutes } from '@xmachines/play-router';
-import { SolidRouterBridge, createRouteMapFromTree } from '@xmachines/play-tanstack-solid-router';
+```tsx
+import { Router, createRouter } from "@tanstack/solid-router";
+import { PlayTanStackRouterProvider } from "@xmachines/play-tanstack-solid-router";
+import { PlayRenderer } from "@xmachines/play-solid";
+import { definePlayer } from "@xmachines/play-xstate";
+import { extractMachineRoutes } from "@xmachines/play-router";
+import { routeTree as routerRouteTree } from "./routeTree.gen"; // from TanStack
 
 function App() {
-  // 1. Create actor
-  const actor = definePlayer({ machine, catalog })();
-
-  // 2. Create router
-  const router = createRouter({
-    routes: /* ... TanStack route config ... */
-  });
-
-  // 3. Extract routes from machine and create RouteMap
-  const routeTree = extractMachineRoutes(machine);
-  const routeMap = createRouteMapFromTree(routeTree);
-
-  // 4. Create and connect bridge (inside component with Solid ownership context)
-  const bridge = new SolidRouterBridge(router, actor, routeMap);
-  bridge.connect();
-
-  onCleanup(() => bridge.disconnect());
-
-  return (
-    <Router>
-      <PlayRenderer actor={actor} components={components} />
-    </Router>
-  );
+	// 1. Create player with state machine
+	const createPlayer = definePlayer({
+		machine: authMachine,
+		catalog: componentCatalog,
+	});
+	const actor = createPlayer();
+	actor.start();
+
+	// 2. Create TanStack router instance
+	const router = createRouter({ routeTree: routerRouteTree });
+
+	// 3. Create route mapping from machine routes
+	const machineRouteTree = extractMachineRoutes(authMachine);
+	const routeMap = createRouteMapFromTree(machineRouteTree);
+
+	return (
+		// 4. Wrap with provider to sync actor and router
+		<PlayTanStackRouterProvider
+			actor={actor}
+			router={router}
+			routeMap={routeMap}
+			renderer={(currentActor, currentRouter) => (
+				<Router router={currentRouter}>
+					<PlayRenderer actor={currentActor} components={components} />
+				</Router>
+			)}
+		/>
+	);
 }
 ```
 
-**Important:** The bridge must be created inside a component where Solid hooks (`createEffect`, `onCleanup`) are available. TanStack Solid Router requires Solid's ownership context for reactivity to work correctly.
-
 ## API Reference
 
 ### `SolidRouterBridge`
 
 Router adapter implementing the `RouterBridge` protocol for TanStack Solid Router.
 
-**Constructor:**
+**Type Signature:**
 
 ```typescript
-new SolidRouterBridge(
-  router: Router,
-  actor: AbstractActor<any>,
-  routeMap: RouteMap
-)
+class SolidRouterBridge {
+	constructor(router: Router, actor: AbstractActor<any>, routeMap: RouteMap);
+	dispose(): void;
+}
 ```
 
-**Parameters:**
+**Constructor Parameters:**
 
-- `router`: TanStack Solid Router instance (from `createRouter()`)
-- `actor`: XMachines player actor implementing signal protocol
-- `routeMap`: Bidirectional state ID ↔ path mapping
+- `router` - TanStack Solid Router instance
+- `actor` - XMachines actor instance
+- `routeMap` - Bidirectional state ID ↔ path mapping
 
 **Methods:**
 
-- `connect(): void` - Start bidirectional synchronization (actor ↔ router)
-- `disconnect(): void` - Stop synchronization and cleanup subscriptions
+- `connect()` - Start bidirectional synchronization.
+- `disconnect()` - Stop synchronization and cleanup bridge resources.
+- `dispose()` - Alias of `disconnect()`.
 
-**Important:** Must be created inside component where Solid hooks (`createEffect`, `onCleanup`) are available. Creating outside ownership context will cause reactivity to fail.
+**Internal Behavior:**
 
-### `RouteMap`
+- Uses `RouterBridgeBase` TC39 watcher lifecycle for actor→router synchronization
+- Updates TanStack Router via `router.navigate({ to: path })` when actor state changes
+- Uses `router.subscribe` to watch history navigation events
+- Sends `play.route` events to actor when user navigates
 
-Bidirectional mapping between XMachines state IDs and URL paths with pattern matching support.
+### `PlayTanStackRouterProvider`
 
-**Constructor:**
+A Solid component that automatically sets up, connects, and tears down the `SolidRouterBridge` using Solid's lifecycle.
 
-```typescript
-new RouteMap(routes: RouteMapping[])
+```tsx
+interface PlayTanStackRouterProviderProps {
+	actor: AbstractActor<any>;
+	router: Router;
+	routeMap: RouteMap;
+	renderer: (actor: AbstractActor<any>, router: Router) => JSX.Element;
+}
 ```
 
-**Interface:**
+**Props:**
 
-```typescript
-interface RouteMapping {
-	stateId: string; // XMachines state ID (e.g., '#home', '#profile')
-	path: string; // URL path pattern (e.g., '/', '/profile/:userId')
-}
-```
+- `actor` - The XMachines player actor
+- `router` - The TanStack Solid Router instance
+- `routeMap` - Mapping between paths and state IDs
+- `renderer` - A render prop function that receives the active actor and router
 
-**Methods:**
+**Behavior:**
 
-- `getStateIdByPath(path: string): string | null` - Lookup state ID by path (with URLPattern matching)
-- `getPathByStateId(stateId: string): string | null` - Lookup path by state ID
+1. Instantiates `SolidRouterBridge` on mount
+2. Calls `bridge.connect()`
+3. Renders the content returned by the `renderer` function
+4. Calls `bridge.disconnect()` when the component unmounts via `onCleanup`
 
 ### `createRouteMapFromTree()`
 
-Helper to create RouteMap from RouteTree extracted from state machine.
+Helper to automatically build a `RouteMap` instance from a generated machine route tree.
 
 **Signature:**
 
@@ -155,274 +166,115 @@ const routeTree = extractMachineRoutes(machine);
 const routeMap = createRouteMapFromTree(routeTree);
 ```
 
-This helper traverses the route tree and creates RouteMapping entries for all routable states.
-
 ## Usage Patterns
 
-### Creating RouteMap from Machine
-
-**Recommended:** Extract routes from state machine automatically:
-
-```typescript
-import { extractMachineRoutes } from "@xmachines/play-router";
-import { createRouteMapFromTree } from "@xmachines/play-tanstack-solid-router";
-
-const routeTree = extractMachineRoutes(machine);
-const routeMap = createRouteMapFromTree(routeTree);
-```
-
-**Manual:** Define routes explicitly:
-
-```typescript
-const routeMap = new RouteMap([
-	{ stateId: "#home", path: "/" },
-	{ stateId: "#profile", path: "/profile/:userId" },
-]);
-```
-
 ### Dynamic Routes with Parameters
 
-**Path parameters:**
+TanStack Router and URLPattern (used internally) support dynamic route matching syntax:
 
 ```typescript
-const routeMap = new RouteMap([
-	{ stateId: "#home", path: "/" },
-	{ stateId: "#settings", path: "/settings/:section?" }, // Optional param
-	{ stateId: "#profile", path: "/profile/:userId" }, // Required param
-]);
-```
-
-**Pattern matching examples:**
+// Machine configuration
+const machineConfig = {
+	states: {
+		profile: {
+			meta: {
+				route: "/profile/:userId",
+				view: { component: "Profile" },
+			},
+		},
+	},
+};
 
-```typescript
+// Route mapping will natively support URLPattern parameters
 routeMap.getStateIdByPath("/profile/123"); // → '#profile'
-routeMap.getStateIdByPath("/settings"); // → '#settings'
-routeMap.getStateIdByPath("/settings/privacy"); // → '#settings'
 ```
 
-### Cleanup on Component Unmount
+### Protected Routes and Guards
 
-**Always cleanup when component unmounts:**
+With XMachines, auth guards are handled entirely inside the state machine, preventing flashes of unauthorized content.
 
 ```typescript
-function MyApp() {
-  const bridge = new SolidRouterBridge(router, actor, routeMap);
-  bridge.connect();
-
-  onCleanup(() => {
-    bridge.disconnect();  // Stop synchronization
-    actor.stop();          // Stop actor if needed
-  });
-
-  return <Router>...</Router>;
+// Machine side
+dashboard: {
+  meta: { route: "/dashboard", view: { component: "Dashboard" } },
+  always: {
+    guard: ({ context }) => !context.isAuthenticated,
+    target: "login"
+  }
 }
 ```
 
-## Circular Update Prevention
-
-SolidRouterBridge uses a **2-flag pattern** to prevent infinite loops:
-
-1. **lastSyncedPath** - Skips redundant updates when path unchanged
-2. **isProcessingNavigation** - Prevents actor → router → actor loops
-
-**How it works:**
-
-```typescript
-// Actor state change → Router navigation
-private syncRouterFromActor(route: string | null): void {
-  if (this.isProcessingNavigation) return;  // Skip if processing router event
-  if (route === this.lastSyncedPath) return; // Skip if path unchanged
-
-  this.lastSyncedPath = route || '/';
-  this.router.navigate({ to: this.lastSyncedPath });
-}
+When a user navigates to `/dashboard`:
 
-// Router navigation → Actor event
-private syncActorFromRouter(location: RouterLocation): void {
-  this.isProcessingNavigation = true;  // Set flag
+1. TanStack Router updates location
+2. Bridge intercepts and sends `play.route`
+3. Actor evaluates guard -> denies target, transitions to `login` instead
+4. Bridge observes new actor state (`/login`)
+5. Bridge tells TanStack Router to redirect to `/login`
 
-  // Send event to actor...
+## Circular Update Prevention
 
-  queueMicrotask(() => {
-    this.isProcessingNavigation = false;  // Clear flag in microtask
-  });
-}
-```
+The `RouterBridgeBase` architecture prevents infinite loops between router and actor using two mechanisms:
 
-**Microtask timing:** The `isProcessingNavigation` flag is cleared in a microtask (via `queueMicrotask()`) to ensure the actor has processed the event before allowing router-initiated syncs again.
+1. **`lastSyncedPath` tracking:** Stores the last synchronized path to prevent redundant navigations back to the identical location.
+2. **`isProcessingNavigation` flag:** Set during a router event, preventing the router from immediately reacting to the actor's synchronous state update.
 
 ## Comparison with @solidjs/router Adapter
 
-| Aspect         | @solidjs/router   | @tanstack/solid-router       |
-| -------------- | ----------------- | ---------------------------- |
-| **Router API** | router.push()     | router.navigate({ to })      |
-| **Location**   | router.location   | router.state.location        |
-| **Guards**     | router.beforeEach | No guards (use createEffect) |
-| **Reactivity** | createEffect      | createEffect                 |
-
-**Key Differences:**
-
-- **TanStack Solid Router:** Uses `router.navigate({ to })` API (object-based navigation)
-- **SolidJS Router:** Uses `navigate(path)` function (string-based navigation)
-- **TanStack:** Router instance contains state, no separate hooks needed
-- **SolidJS:** Requires hooks (`useNavigate`, `useLocation`) for navigation primitives
-
-## Limitations
-
-### Solid Ownership Context Required
-
-The bridge must be created inside a component where Solid hooks are available:
-
-```typescript
-// ✅ CORRECT: Inside component
-function App() {
-	const bridge = new SolidRouterBridge(router, actor, routeMap);
-	bridge.connect();
-	onCleanup(() => bridge.disconnect());
-}
-
-// ❌ WRONG: Outside component (no ownership context)
-const bridge = new SolidRouterBridge(router, actor, routeMap);
-bridge.connect(); // Will fail - no owner for createEffect
-```
-
-**Error message:**
-
-```
-Error: createEffect can only be used within a component
-```
-
-### Router Creation
-
-Router must be created with TanStack's `createRouter()`:
-
-```typescript
-import { createRouter } from "@tanstack/solid-router";
-
-const router = createRouter({
-	routes: [
-		/* route config */
-	],
-});
-```
-
-### Pattern Matching Requirements
-
-Route patterns with parameters require URLPattern support:
-
-- **Modern browsers:** Safari 17.4+, Chrome 95+, Firefox 106+
-- **Node.js:** Requires `urlpattern-polyfill` for tests
-
-**Polyfill setup:**
-
-```typescript
-// Top of app entry point
-if (!globalThis.URLPattern) {
-	await import("urlpattern-polyfill");
-}
-```
+| Aspect            | @solidjs/router Adapter          | @tanstack/solid-router Adapter  |
+| ----------------- | -------------------------------- | ------------------------------- |
+| **Router API**    | `navigate(path)`                 | `router.navigate({ to })`       |
+| **Setup Context** | Must be _inside_ Router context  | Can wrap Router instance        |
+| **State Source**  | Uses Solid hooks (`useLocation`) | Subscribes to `router` directly |
+| **Reacting**      | `createEffect` on location       | `router.subscribe` callback     |
 
 ## Architecture
 
-SolidRouterBridge follows XMachines Play architectural invariants:
+This package implements standard Play invariants:
 
 ### INV-01: Actor Authority
 
-**Principle:** State machine has final authority over all transitions.
-
-**Implementation:** Router navigation triggers actor events, but actor guards decide validity:
-
-```typescript
-// Router navigation → Actor event
-syncActorFromRouter(location: RouterLocation): void {
-  const stateId = this.routeMap.getStateIdByPath(location.pathname);
-  this.actor.send({
-    type: 'play.route',
-    to: stateId,
-    params: extractParams(location)
-  });
-  // Actor guards validate - if rejected, URL reverts to actor's current route
-}
-```
+State machine has final authority over all transitions. TanStack Router navigation triggers actor events (`play.route`), but the actor's guards and transitions ultimately dictate if the view changes.
 
 ### INV-02: Passive Infrastructure
 
-**Principle:** Infrastructure reflects actor state, never decides navigation.
-
-**Implementation:** Router observes `actor.currentRoute` signal and updates URL:
-
-```typescript
-// Actor state change → Router navigation
-const actorEffect = createEffect(
-	on(
-		() => this.actor.currentRoute.get(),
-		(route) => this.syncRouterFromActor(route),
-	),
-);
-```
-
-### INV-05: Signal-Only Reactivity
-
-**Principle:** All reactivity through signals, never callbacks or promises.
+Infrastructure reflects actor state. The router observes `actor.currentRoute` and updates the browser URL, never storing independent business state.
 
-**Implementation:** Solid's `createEffect` watches actor signals automatically:
+### Cleanup Contract
 
-```typescript
-// Automatic dependency tracking
-createEffect(
-	on(
-		() => this.actor.currentRoute.get(), // Signal read
-		(route) => {
-			// Effect runs when signal changes
-		},
-	),
-);
-```
+The bridge implements an explicit `dispose()`/`disconnect()` method. `PlayTanStackRouterProvider` wires this automatically to Solid's `onCleanup` hook to prevent memory leaks and duplicate bridge subscriptions in hot-reloading scenarios.
 
 ## Browser Support
 
-This package uses the [URLPattern API](https://developer.mozilla.org/en-US/docs/Web/API/URLPattern) for route pattern matching.
+This package uses the [URLPattern API](https://developer.mozilla.org/en-US/docs/Web/API/URLPattern) for robust route pattern matching.
 
 **Native Support:**
 
-- Safari 17.4+ (Sept 2024)
-- Chrome 95+ (Oct 2021)
-- Firefox 106+ (Oct 2022)
-- **Baseline 2025** status (newly available)
+- Safari 17.4+
+- Chrome 95+
+- Firefox 106+
 
-**Polyfill Required:**
-
-- Node.js (all versions) - required for tests
-- Safari < 17.4
-- Older browsers
-
-**Polyfill Installation:**
+**Polyfill Required (Node.js/Tests/Old Browsers):**
 
 ```bash
 npm install urlpattern-polyfill
 ```
 
-**Usage:**
-
 ```typescript
-// Top of your app entry point (e.g., main.tsx)
 if (!globalThis.URLPattern) {
 	await import("urlpattern-polyfill");
 }
 ```
 
-**Bundle Size:** ~4KB gzipped (zero impact if URLPattern is native)
-
-## Examples
+## Related Packages
 
-See `examples/demo/` for the maintained integration example and tests.
+- **[@xmachines/play-solid](../play-solid)** - SolidJS renderer
+- **[@xmachines/play-router](../play-router)** - Core router primitives
+- **[@xmachines/play-solid-router](../play-solid-router)** - Native SolidJS Router equivalent
 
 ## License
 
-MIT
-
----
+Copyright (c) 2016 [Mikael Karon](mailto:mikael@karon.se). All rights reserved.
 
-**Package:** @xmachines/play-tanstack-solid-router  
-**Pattern:** RouterBridge (~220 lines, 2 flags)  
-**Framework:** TanStack Solid Router 1.0+ with SolidJS 1.8+
+This work is licensed under the terms of the MIT license.  
+For a copy, see <https://opensource.org/licenses/MIT>.

package/dist/play-router-provider.d.ts

@@ -11,5 +11,5 @@ export interface PlayRouterProviderProps {
     routeMap: RouteMap;
     renderer: (actor: RoutableActor, router: TanStackRouterInstance) => JSX.Element;
 }
-export declare function PlayRouterProvider(props: PlayRouterProviderProps): any;
+export declare function PlayRouterProvider(props: PlayRouterProviderProps): JSX.Element;
 //# sourceMappingURL=play-router-provider.d.ts.map

package/dist/play-router-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"play-router-provider.d.ts","sourceRoot":"","sources":["../src/play-router-provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAC/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC,aAAa,CAAC,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAC/E,MAAM,MAAM,sBAAsB,GAAG,qBAAqB,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;AAExF,MAAM,WAAW,uBAAuB;IACvC,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,sBAAsB,KAAK,GAAG,CAAC,OAAO,CAAC;CAChF;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,OAShE"}
+{"version":3,"file":"play-router-provider.d.ts","sourceRoot":"","sources":["../src/play-router-provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAC/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC,aAAa,CAAC,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAC/E,MAAM,MAAM,sBAAsB,GAAG,qBAAqB,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;AAExF,MAAM,WAAW,uBAAuB;IACvC,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,sBAAsB,KAAK,GAAG,CAAC,OAAO,CAAC;CAChF;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,eAShE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-tanstack-solid-router",
-  "version": "1.0.0-beta.6",
+  "version": "1.0.0-beta.8",
   "description": "TanStack Solid Router adapter for XMachines Universal Player Architecture",
   "license": "MIT",
   "author": "XMachines Contributors",
@@ -28,24 +28,26 @@
   },
   "scripts": {
     "build": "tsc --build",
-    "test": "vitest run",
+    "test": "vitest",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
-    "clean": "rm -rf dist *.tsbuildinfo",
+    "clean": "rm -rf dist *.tsbuildinfo node_modules/.vite node_modules/.vite-temp",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@xmachines/play": "1.0.0-beta.6",
-    "@xmachines/play-actor": "1.0.0-beta.6",
-    "@xmachines/play-router": "1.0.0-beta.6",
-    "@xmachines/play-signals": "1.0.0-beta.6"
+    "@xmachines/play": "1.0.0-beta.8",
+    "@xmachines/play-actor": "1.0.0-beta.8",
+    "@xmachines/play-router": "1.0.0-beta.8",
+    "@xmachines/play-signals": "1.0.0-beta.8"
   },
   "devDependencies": {
     "@solidjs/testing-library": "^0.8.10",
     "@tanstack/solid-router": "^1.167.5",
-    "@xmachines/shared": "1.0.0-beta.6",
+    "@xmachines/shared": "1.0.0-beta.8",
     "solid-js": "^1.9.11",
-    "vite-plugin-solid": "^2.11.11"
+    "vite-plugin-solid": "^2.11.11",
+    "vitest": "^4.1.0",
+    "xstate": "^5.28.0"
   },
   "peerDependencies": {
     "@tanstack/solid-router": "^1.166.7",