@xmachines/play-tanstack-solid-router 1.0.0-beta.1

package/README.md

@@ -0,0 +1,428 @@
+# @xmachines/play-tanstack-solid-router
+
+**TanStack Solid Router adapter for XMachines Universal Player Architecture**
+
+Signals-native integration with TanStack Solid Router enabling logic-driven navigation through Solid.js reactivity.
+
+## 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.
+
+Per [RFC Play v1](https://gitlab.com/xmachin-es/rfc/-/blob/main/src/play-v1.md), this package implements:
+
+- **Actor Authority (INV-01):** State machine controls navigation, router reflects decisions
+- **Passive Infrastructure (INV-04):** Router observes `actor.currentRoute` signal
+- **Signal-Only Reactivity (INV-05):** `createEffect` synchronizes URL with actor state
+
+**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)
+- **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+
+- 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
+```
+
+**Peer dependencies:**
+
+- `@tanstack/solid-router` ^1.0.0 - TanStack Solid Router library
+- `solid-js` ^1.8.0 - SolidJS runtime
+- `@xmachines/play-solid` - Solid renderer (`PlayRenderer`)
+- `@xmachines/play-actor` - Actor base
+- `@xmachines/play-router` - Route extraction
+- `@xmachines/play-signals` - TC39 Signals polyfill
+
+## 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';
+
+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>
+  );
+}
+```
+
+**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:**
+
+```typescript
+new SolidRouterBridge(
+  router: Router,
+  actor: AbstractActor<any>,
+  routeMap: RouteMap
+)
+```
+
+**Parameters:**
+
+- `router`: TanStack Solid Router instance (from `createRouter()`)
+- `actor`: XMachines player actor implementing signal protocol
+- `routeMap`: Bidirectional state ID ↔ path mapping
+
+**Methods:**
+
+- `connect(): void` - Start bidirectional synchronization (actor ↔ router)
+- `disconnect(): void` - Stop synchronization and cleanup subscriptions
+
+**Important:** Must be created inside component where Solid hooks (`createEffect`, `onCleanup`) are available. Creating outside ownership context will cause reactivity to fail.
+
+### `RouteMap`
+
+Bidirectional mapping between XMachines state IDs and URL paths with pattern matching support.
+
+**Constructor:**
+
+```typescript
+new RouteMap(routes: RouteMapping[])
+```
+
+**Interface:**
+
+```typescript
+interface RouteMapping {
+	stateId: string; // XMachines state ID (e.g., '#home', '#profile')
+	path: string; // URL path pattern (e.g., '/', '/profile/:userId')
+}
+```
+
+**Methods:**
+
+- `getStateIdByPath(path: string): string | null` - Lookup state ID by path (with URLPattern matching)
+- `getPathByStateId(stateId: string): string | null` - Lookup path by state ID
+
+### `createRouteMapFromTree()`
+
+Helper to create RouteMap from RouteTree extracted from state machine.
+
+**Signature:**
+
+```typescript
+function createRouteMapFromTree(routeTree: RouteTree): RouteMap;
+```
+
+**Usage:**
+
+```typescript
+import { extractMachineRoutes } from "@xmachines/play-router";
+import { createRouteMapFromTree } from "@xmachines/play-tanstack-solid-router";
+
+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:**
+
+```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:**
+
+```typescript
+routeMap.getStateIdByPath("/profile/123"); // → '#profile'
+routeMap.getStateIdByPath("/settings"); // → '#settings'
+routeMap.getStateIdByPath("/settings/privacy"); // → '#settings'
+```
+
+### Cleanup on Component Unmount
+
+**Always cleanup when component unmounts:**
+
+```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>;
+}
+```
+
+## 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 });
+}
+
+// Router navigation → Actor event
+private syncActorFromRouter(location: RouterLocation): void {
+  this.isProcessingNavigation = true;  // Set flag
+
+  // Send event to actor...
+
+  queueMicrotask(() => {
+    this.isProcessingNavigation = false;  // Clear flag in microtask
+  });
+}
+```
+
+**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.
+
+## 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");
+}
+```
+
+## Architecture
+
+SolidRouterBridge follows XMachines Play architectural 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
+}
+```
+
+### 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.
+
+**Implementation:** Solid's `createEffect` watches actor signals automatically:
+
+```typescript
+// Automatic dependency tracking
+createEffect(
+	on(
+		() => this.actor.currentRoute.get(), // Signal read
+		(route) => {
+			// Effect runs when signal changes
+		},
+	),
+);
+```
+
+## Browser Support
+
+This package uses the [URLPattern API](https://developer.mozilla.org/en-US/docs/Web/API/URLPattern) for route pattern matching.
+
+**Native Support:**
+
+- Safari 17.4+ (Sept 2024)
+- Chrome 95+ (Oct 2021)
+- Firefox 106+ (Oct 2022)
+- **Baseline 2025** status (newly available)
+
+**Polyfill Required:**
+
+- Node.js (all versions) - required for tests
+- Safari < 17.4
+- Older browsers
+
+**Polyfill Installation:**
+
+```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
+
+See `examples/demo/` for the maintained integration example and tests.
+
+## License
+
+MIT
+
+---
+
+**Package:** @xmachines/play-tanstack-solid-router  
+**Pattern:** RouterBridge (~220 lines, 2 flags)  
+**Framework:** TanStack Solid Router 1.0+ with SolidJS 1.8+

package/dist/create-route-map.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Create RouteMap helper for TanStack Solid Router adapter
+ *
+ * Simplifies demo code by hiding route extraction complexity.
+ * Internally calls extractMachineRoutes() and getRoutableRoutes(),
+ * then constructs RouteMap with proper state ID ↔ path mappings.
+ */
+import type { AnyStateMachine } from "xstate";
+import { RouteMap } from "./route-map.js";
+/**
+ * Create a RouteMap from an XState machine
+ *
+ * @param machine - XState machine with route: {} config on states
+ * @returns RouteMap for bidirectional state ID ↔ path resolution
+ *
+ * @example
+ * ```typescript
+ * import { createRouteMap } from '@xmachines/play-tanstack-solid-router';
+ * import { authMachine } from './machine.js';
+ *
+ * const routeMap = createRouteMap(authMachine);
+ * ```
+ */
+export declare function createRouteMap(machine: AnyStateMachine): RouteMap;
+//# sourceMappingURL=create-route-map.d.ts.map

package/dist/create-route-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-route-map.d.ts","sourceRoot":"","sources":["../src/create-route-map.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAE9C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,QAAQ,CAcjE"}

package/dist/create-route-map.js

@@ -0,0 +1,36 @@
+/**
+ * Create RouteMap helper for TanStack Solid Router adapter
+ *
+ * Simplifies demo code by hiding route extraction complexity.
+ * Internally calls extractMachineRoutes() and getRoutableRoutes(),
+ * then constructs RouteMap with proper state ID ↔ path mappings.
+ */
+import { extractMachineRoutes, getRoutableRoutes } from "@xmachines/play-router";
+import { RouteMap } from "./route-map.js";
+/**
+ * Create a RouteMap from an XState machine
+ *
+ * @param machine - XState machine with route: {} config on states
+ * @returns RouteMap for bidirectional state ID ↔ path resolution
+ *
+ * @example
+ * ```typescript
+ * import { createRouteMap } from '@xmachines/play-tanstack-solid-router';
+ * import { authMachine } from './machine.js';
+ *
+ * const routeMap = createRouteMap(authMachine);
+ * ```
+ */
+export function createRouteMap(machine) {
+    // Extract route tree from machine
+    const routeTree = extractMachineRoutes(machine);
+    // Get only routable nodes (states with route: {} config)
+    const routes = getRoutableRoutes(routeTree);
+    // Map to RouteMapping format expected by RouteMap constructor
+    const mappings = routes.map((node) => ({
+        stateId: node.stateId,
+        path: node.fullPath,
+    }));
+    return new RouteMap(mappings);
+}
+//# sourceMappingURL=create-route-map.js.map

package/dist/create-route-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-route-map.js","sourceRoot":"","sources":["../src/create-route-map.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,cAAc,CAAC,OAAwB;IACtD,kCAAkC;IAClC,MAAM,SAAS,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAEhD,yDAAyD;IACzD,MAAM,MAAM,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAC;IAE5C,8DAA8D;IAC9D,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QACtC,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,IAAI,EAAE,IAAI,CAAC,QAAQ;KACnB,CAAC,CAAC,CAAC;IAEJ,OAAO,IAAI,QAAQ,CAAC,QAAQ,CAAC,CAAC;AAC/B,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @xmachines/play-tanstack-solid-router
+ *
+ * TanStack Solid Router adapter for XMachines Universal Player Architecture
+ */
+export { SolidRouterBridge } from "./solid-router-bridge.js";
+export { PlayRouterProvider } from "./play-router-provider.js";
+export type { PlayRouterProviderProps, RoutableActor, TanStackRouterInstance, } from "./play-router-provider.js";
+export { RouteMap } from "./route-map.js";
+export { createRouteMap } from "./create-route-map.js";
+export type { TanStackRouterLike } from "./solid-router-bridge.js";
+export type { RouteMapping, RouterBridge, PlayRouteEvent } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,YAAY,EACX,uBAAuB,EACvB,aAAa,EACb,sBAAsB,GACtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,YAAY,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+/**
+ * @xmachines/play-tanstack-solid-router
+ *
+ * TanStack Solid Router adapter for XMachines Universal Player Architecture
+ */
+export { SolidRouterBridge } from "./solid-router-bridge.js";
+export { PlayRouterProvider } from "./play-router-provider.js";
+export { RouteMap } from "./route-map.js";
+export { createRouteMap } from "./create-route-map.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAM/D,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC"}

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

@@ -0,0 +1,15 @@
+import { type JSX } from "solid-js";
+import type { AbstractActor, Routable, Viewable } from "@xmachines/play-actor";
+import type { AnyActorLogic } from "xstate";
+import { SolidRouterBridge } from "./solid-router-bridge.js";
+import type { RouteMap } from "./route-map.js";
+export type RoutableActor = AbstractActor<AnyActorLogic> & Routable & Viewable;
+export type TanStackRouterInstance = ConstructorParameters<typeof SolidRouterBridge>[0];
+export interface PlayRouterProviderProps {
+    actor: RoutableActor;
+    router: TanStackRouterInstance;
+    routeMap: RouteMap;
+    renderer: (actor: RoutableActor, router: TanStackRouterInstance) => JSX.Element;
+}
+export declare function PlayRouterProvider(props: PlayRouterProviderProps): any;
+//# sourceMappingURL=play-router-provider.d.ts.map

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

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

package/dist/play-router-provider.jsx

@@ -0,0 +1,11 @@
+import { onCleanup } from "solid-js";
+import { SolidRouterBridge } from "./solid-router-bridge.js";
+export function PlayRouterProvider(props) {
+    const bridge = new SolidRouterBridge(props.router, props.actor, props.routeMap);
+    bridge.connect();
+    onCleanup(() => {
+        bridge.disconnect();
+    });
+    return <>{props.renderer(props.actor, props.router)}</>;
+}
+//# sourceMappingURL=play-router-provider.jsx.map

package/dist/play-router-provider.jsx.map

@@ -0,0 +1 @@
+{"version":3,"file":"play-router-provider.jsx","sourceRoot":"","sources":["../src/play-router-provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAY,MAAM,UAAU,CAAC;AAG/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAa7D,MAAM,UAAU,kBAAkB,CAAC,KAA8B;IAChE,MAAM,MAAM,GAAG,IAAI,iBAAiB,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IAChF,MAAM,CAAC,OAAO,EAAE,CAAC;IAEjB,SAAS,CAAC,GAAG,EAAE;QACd,MAAM,CAAC,UAAU,EAAE,CAAC;IACrB,CAAC,CAAC,CAAC;IAEH,OAAO,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC;AACzD,CAAC"}

package/dist/route-map.d.ts

@@ -0,0 +1,75 @@
+/**
+ * RouteMap for bidirectional state ID ↔ path mapping
+ *
+ * Provides efficient lookup between XMachines state IDs and TanStack Router paths.
+ * Supports pattern matching for dynamic routes with parameters.
+ */
+import type { RouteMapping } from "./types.js";
+export declare class RouteMap {
+    private stateToPath;
+    private pathToState;
+    /**
+     * Create a RouteMap with bidirectional mappings
+     *
+     * @param mappings - Array of state ID to path mappings
+     *
+     * @example
+     * ```typescript
+     * const routeMap = new RouteMap([
+     *   { stateId: '#home', path: '/' },
+     *   { stateId: '#profile', path: '/profile/:userId' },
+     *   { stateId: '#settings', path: '/settings/:section?' }
+     * ]);
+     * ```
+     */
+    constructor(mappings: RouteMapping[]);
+    /**
+     * Get path pattern for a state ID
+     *
+     * @param stateId - XMachines state ID (e.g., '#profile')
+     * @returns Path pattern or null if not found
+     *
+     * @example
+     * ```typescript
+     * routeMap.getPathByStateId('#profile'); // '/profile/:userId'
+     * ```
+     */
+    getPathByStateId(stateId: string): string | null;
+    /**
+     * Get state ID for a path, with pattern matching support
+     *
+     * Performs exact match first, then fuzzy pattern matching for dynamic routes.
+     * Supports both required (:param) and optional (:param?) parameters.
+     *
+     * @param path - Actual URL path (e.g., '/profile/123')
+     * @returns State ID or null if no match found
+     *
+     * @example
+     * ```typescript
+     * routeMap.getStateIdByPath('/profile/123');  // '#profile'
+     * routeMap.getStateIdByPath('/settings');      // '#settings'
+     * routeMap.getStateIdByPath('/settings/account'); // '#settings'
+     * ```
+     */
+    getStateIdByPath(path: string): string | null;
+    /**
+     * Check if a path matches a pattern
+     *
+     * Supports:
+     * - Required parameters: :param
+     * - Optional parameters: :param?
+     *
+     * @param path - Actual URL path
+     * @param pattern - Route pattern with :param syntax
+     * @returns true if path matches pattern
+     *
+     * @example
+     * ```typescript
+     * matchesPattern('/profile/123', '/profile/:userId');  // true
+     * matchesPattern('/settings', '/settings/:section?');  // true
+     * matchesPattern('/settings/account', '/settings/:section?'); // true
+     * ```
+     */
+    private matchesPattern;
+}
+//# sourceMappingURL=route-map.d.ts.map

package/dist/route-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-map.d.ts","sourceRoot":"","sources":["../src/route-map.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,qBAAa,QAAQ;IACpB,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,WAAW,CAA6B;IAEhD;;;;;;;;;;;;;OAaG;gBACS,QAAQ,EAAE,YAAY,EAAE;IAOpC;;;;;;;;;;OAUG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIhD;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAmB7C;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,cAAc;CAetB"}

package/dist/route-map.js

@@ -0,0 +1,107 @@
+/**
+ * RouteMap for bidirectional state ID ↔ path mapping
+ *
+ * Provides efficient lookup between XMachines state IDs and TanStack Router paths.
+ * Supports pattern matching for dynamic routes with parameters.
+ */
+export class RouteMap {
+    stateToPath = new Map();
+    pathToState = new Map();
+    /**
+     * Create a RouteMap with bidirectional mappings
+     *
+     * @param mappings - Array of state ID to path mappings
+     *
+     * @example
+     * ```typescript
+     * const routeMap = new RouteMap([
+     *   { stateId: '#home', path: '/' },
+     *   { stateId: '#profile', path: '/profile/:userId' },
+     *   { stateId: '#settings', path: '/settings/:section?' }
+     * ]);
+     * ```
+     */
+    constructor(mappings) {
+        mappings.forEach(({ stateId, path }) => {
+            this.stateToPath.set(stateId, path);
+            this.pathToState.set(path, stateId);
+        });
+    }
+    /**
+     * Get path pattern for a state ID
+     *
+     * @param stateId - XMachines state ID (e.g., '#profile')
+     * @returns Path pattern or null if not found
+     *
+     * @example
+     * ```typescript
+     * routeMap.getPathByStateId('#profile'); // '/profile/:userId'
+     * ```
+     */
+    getPathByStateId(stateId) {
+        return this.stateToPath.get(stateId) ?? null;
+    }
+    /**
+     * Get state ID for a path, with pattern matching support
+     *
+     * Performs exact match first, then fuzzy pattern matching for dynamic routes.
+     * Supports both required (:param) and optional (:param?) parameters.
+     *
+     * @param path - Actual URL path (e.g., '/profile/123')
+     * @returns State ID or null if no match found
+     *
+     * @example
+     * ```typescript
+     * routeMap.getStateIdByPath('/profile/123');  // '#profile'
+     * routeMap.getStateIdByPath('/settings');      // '#settings'
+     * routeMap.getStateIdByPath('/settings/account'); // '#settings'
+     * ```
+     */
+    getStateIdByPath(path) {
+        // Strip query string and hash fragment for matching
+        const cleanPath = path.split("?")[0].split("#")[0];
+        // Direct lookup first (exact match)
+        if (this.pathToState.has(cleanPath)) {
+            return this.pathToState.get(cleanPath);
+        }
+        // Fuzzy match for dynamic routes
+        for (const [pattern, stateId] of this.pathToState) {
+            if (this.matchesPattern(cleanPath, pattern)) {
+                return stateId;
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if a path matches a pattern
+     *
+     * Supports:
+     * - Required parameters: :param
+     * - Optional parameters: :param?
+     *
+     * @param path - Actual URL path
+     * @param pattern - Route pattern with :param syntax
+     * @returns true if path matches pattern
+     *
+     * @example
+     * ```typescript
+     * matchesPattern('/profile/123', '/profile/:userId');  // true
+     * matchesPattern('/settings', '/settings/:section?');  // true
+     * matchesPattern('/settings/account', '/settings/:section?'); // true
+     * ```
+     */
+    matchesPattern(path, pattern) {
+        // Convert route pattern to regex
+        // Process replacements in correct order: optional params first, then required
+        let regexPattern = pattern
+            // Replace /:param? with optional segment (matches both /value and nothing)
+            .replace(/\/:(\w+)\?/g, "(?:/([^/]+))?")
+            // Replace /:param with required segment
+            .replace(/\/:(\w+)/g, "/([^/]+)");
+        // Add anchors for exact match
+        regexPattern = "^" + regexPattern + "$";
+        const regex = new RegExp(regexPattern);
+        return regex.test(path);
+    }
+}
+//# sourceMappingURL=route-map.js.map

package/dist/route-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-map.js","sourceRoot":"","sources":["../src/route-map.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,OAAO,QAAQ;IACZ,WAAW,GAAG,IAAI,GAAG,EAAkB,CAAC;IACxC,WAAW,GAAG,IAAI,GAAG,EAAkB,CAAC;IAEhD;;;;;;;;;;;;;OAaG;IACH,YAAY,QAAwB;QACnC,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE;YACtC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YACpC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;IACJ,CAAC;IAED;;;;;;;;;;OAUG;IACH,gBAAgB,CAAC,OAAe;QAC/B,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;IAC9C,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,IAAY;QAC5B,oDAAoD;QACpD,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAEnD,oCAAoC;QACpC,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YACrC,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,SAAS,CAAE,CAAC;QACzC,CAAC;QAED,iCAAiC;QACjC,KAAK,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACnD,IAAI,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC;gBAC7C,OAAO,OAAO,CAAC;YAChB,CAAC;QACF,CAAC;QAED,OAAO,IAAI,CAAC;IACb,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACK,cAAc,CAAC,IAAY,EAAE,OAAe;QACnD,iCAAiC;QACjC,8EAA8E;QAC9E,IAAI,YAAY,GAAG,OAAO;YACzB,2EAA2E;aAC1E,OAAO,CAAC,aAAa,EAAE,eAAe,CAAC;YACxC,wCAAwC;aACvC,OAAO,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;QAEnC,8BAA8B;QAC9B,YAAY,GAAG,GAAG,GAAG,YAAY,GAAG,GAAG,CAAC;QAExC,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,YAAY,CAAC,CAAC;QACvC,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;CACD"}

package/dist/solid-router-bridge.d.ts

@@ -0,0 +1,97 @@
+/**
+ * TanStack Solid Router bridge implementing RouterBridge protocol via RouterBridgeBase
+ *
+ * Extends RouterBridgeBase to handle all common lifecycle and sync logic.
+ *
+ * @example
+ * \`\`\`tsx
+ * import { createRouter } from '@tanstack/solid-router';
+ * import { onCleanup } from 'solid-js';
+ * import { SolidRouterBridge, RouteMap } from '@xmachines/play-tanstack-solid-router';
+ *
+ * function App() {
+ *   const routeMap = new RouteMap([...]);
+ *   const bridge = new SolidRouterBridge(router, actor, routeMap);
+ *   bridge.connect();
+ *   onCleanup(() => bridge.disconnect());
+ *   return <div>...</div>;
+ * }
+ * \`\`\`
+ */
+import { RouterBridgeBase } from "@xmachines/play-router";
+import type { AbstractActor, Routable } from "@xmachines/play-actor";
+import type { AnyActorLogic } from "xstate";
+import type { RouteMap } from "./route-map.js";
+export type TanStackRouterLike = {
+    navigate(args: {
+        to: string;
+    }): void;
+    state?: {
+        location?: {
+            pathname?: string;
+        };
+    };
+    history: {
+        subscribe(handler: (event: {
+            location: {
+                pathname: string;
+                search?: string;
+            };
+        }) => void): () => void;
+    };
+};
+/**
+ * TanStack Solid Router integration bridge extending RouterBridgeBase
+ *
+ * Uses router.subscribe("onBeforeLoad", fn) for router→actor sync.
+ * This mirrors the TanStack React Router bridge pattern and uses the
+ * public router events API instead of the internal __store.
+ */
+export declare class SolidRouterBridge extends RouterBridgeBase {
+    private readonly router;
+    private _unsubscribeRouter;
+    /**
+     * Create a TanStack Solid Router bridge
+     *
+     * @param router - TanStack Router instance (from createRouter)
+     * @param actor - XMachines actor instance
+     * @param routeMap - Bidirectional state ID ↔ path mapping
+     */
+    constructor(router: TanStackRouterLike, actor: AbstractActor<AnyActorLogic> & Routable, routeMap: RouteMap);
+    /**
+     * Navigate TanStack Solid Router to the given path.
+     */
+    protected navigateRouter(path: string): void;
+    /**
+     * Get the router's current path at connect() time for initial sync.
+     *
+     * TanStack Router exposes router.state.location.pathname synchronously,
+     * so we can read it here to drive the actor to the correct initial state
+     * when the user cold-loads on a deep-link URL.
+     */
+    protected getInitialRouterPath(): string | null;
+    /**
+     * Subscribe to ALL navigation events via router.history.
+     *
+     * router.history.subscribe fires for PUSH, POP, BACK, FORWARD, REPLACE, and GO —
+     * covering both link clicks and browser back/forward button presses.
+     *
+     * The subscriber callback receives { location, action } where location is the
+     * new history location with pathname and search already updated.
+     *
+     * Using router.history rather than router.subscribe("onBeforeLoad") ensures
+     * back/forward works regardless of whether <RouterProvider> is mounted.
+     *
+     * Also registers onCleanup() so Solid automatically disconnects on unmount.
+     */
+    protected watchRouterChanges(): void;
+    /**
+     * Stop watching TanStack Router changes.
+     */
+    protected unwatchRouterChanges(): void;
+    /**
+     * Dispose the bridge (alias for disconnect).
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=solid-router-bridge.d.ts.map

package/dist/solid-router-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid-router-bridge.d.ts","sourceRoot":"","sources":["../src/solid-router-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,MAAM,MAAM,kBAAkB,GAAG;IAChC,QAAQ,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACrC,KAAK,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE;YAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IAC7C,OAAO,EAAE;QACR,SAAS,CACR,OAAO,EAAE,CAAC,KAAK,EAAE;YAAE,QAAQ,EAAE;gBAAE,QAAQ,EAAE,MAAM,CAAC;gBAAC,MAAM,CAAC,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE,KAAK,IAAI,GAC3E,MAAM,IAAI,CAAC;KACd,CAAC;CACF,CAAC;AAEF;;;;;;GAMG;AACH,qBAAa,iBAAkB,SAAQ,gBAAgB;IAWrD,OAAO,CAAC,QAAQ,CAAC,MAAM;IAVxB,OAAO,CAAC,kBAAkB,CAA6B;IAEvD;;;;;;OAMG;gBAEe,MAAM,EAAE,kBAAkB,EAC3C,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,QAAQ,EAC9C,QAAQ,EAAE,QAAQ;IAQnB;;OAEG;IACH,SAAS,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI5C;;;;;;OAMG;cACgB,oBAAoB,IAAI,MAAM,GAAG,IAAI;IAIxD;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,kBAAkB,IAAI,IAAI;IAWpC;;OAEG;IACH,SAAS,CAAC,oBAAoB,IAAI,IAAI;IAKtC;;OAEG;IACH,OAAO,IAAI,IAAI;CAGf"}

package/dist/solid-router-bridge.js

@@ -0,0 +1,98 @@
+/**
+ * TanStack Solid Router bridge implementing RouterBridge protocol via RouterBridgeBase
+ *
+ * Extends RouterBridgeBase to handle all common lifecycle and sync logic.
+ *
+ * @example
+ * \`\`\`tsx
+ * import { createRouter } from '@tanstack/solid-router';
+ * import { onCleanup } from 'solid-js';
+ * import { SolidRouterBridge, RouteMap } from '@xmachines/play-tanstack-solid-router';
+ *
+ * function App() {
+ *   const routeMap = new RouteMap([...]);
+ *   const bridge = new SolidRouterBridge(router, actor, routeMap);
+ *   bridge.connect();
+ *   onCleanup(() => bridge.disconnect());
+ *   return <div>...</div>;
+ * }
+ * \`\`\`
+ */
+import { onCleanup } from "solid-js";
+import { RouterBridgeBase } from "@xmachines/play-router";
+/**
+ * TanStack Solid Router integration bridge extending RouterBridgeBase
+ *
+ * Uses router.subscribe("onBeforeLoad", fn) for router→actor sync.
+ * This mirrors the TanStack React Router bridge pattern and uses the
+ * public router events API instead of the internal __store.
+ */
+export class SolidRouterBridge extends RouterBridgeBase {
+    router;
+    _unsubscribeRouter = null;
+    /**
+     * Create a TanStack Solid Router bridge
+     *
+     * @param router - TanStack Router instance (from createRouter)
+     * @param actor - XMachines actor instance
+     * @param routeMap - Bidirectional state ID ↔ path mapping
+     */
+    constructor(router, actor, routeMap) {
+        super(actor, {
+            getStateIdByPath: (path) => routeMap.getStateIdByPath(path) ?? undefined,
+            getPathByStateId: (id) => routeMap.getPathByStateId(id) ?? undefined,
+        });
+        this.router = router;
+    }
+    /**
+     * Navigate TanStack Solid Router to the given path.
+     */
+    navigateRouter(path) {
+        this.router.navigate({ to: path });
+    }
+    /**
+     * Get the router's current path at connect() time for initial sync.
+     *
+     * TanStack Router exposes router.state.location.pathname synchronously,
+     * so we can read it here to drive the actor to the correct initial state
+     * when the user cold-loads on a deep-link URL.
+     */
+    getInitialRouterPath() {
+        return this.router.state?.location?.pathname ?? null;
+    }
+    /**
+     * Subscribe to ALL navigation events via router.history.
+     *
+     * router.history.subscribe fires for PUSH, POP, BACK, FORWARD, REPLACE, and GO —
+     * covering both link clicks and browser back/forward button presses.
+     *
+     * The subscriber callback receives { location, action } where location is the
+     * new history location with pathname and search already updated.
+     *
+     * Using router.history rather than router.subscribe("onBeforeLoad") ensures
+     * back/forward works regardless of whether <RouterProvider> is mounted.
+     *
+     * Also registers onCleanup() so Solid automatically disconnects on unmount.
+     */
+    watchRouterChanges() {
+        this._unsubscribeRouter = this.router.history.subscribe(({ location }) => {
+            this.syncActorFromRouter(location.pathname, location.search ?? "");
+        });
+        // Solid's onCleanup — automatically disconnects when component unmounts
+        onCleanup(() => this.disconnect());
+    }
+    /**
+     * Stop watching TanStack Router changes.
+     */
+    unwatchRouterChanges() {
+        this._unsubscribeRouter?.();
+        this._unsubscribeRouter = null;
+    }
+    /**
+     * Dispose the bridge (alias for disconnect).
+     */
+    dispose() {
+        this.disconnect();
+    }
+}
+//# sourceMappingURL=solid-router-bridge.js.map

package/dist/solid-router-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid-router-bridge.js","sourceRoot":"","sources":["../src/solid-router-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAe1D;;;;;;GAMG;AACH,MAAM,OAAO,iBAAkB,SAAQ,gBAAgB;IAWpC;IAVV,kBAAkB,GAAwB,IAAI,CAAC;IAEvD;;;;;;OAMG;IACH,YACkB,MAA0B,EAC3C,KAA8C,EAC9C,QAAkB;QAElB,KAAK,CAAC,KAAK,EAAE;YACZ,gBAAgB,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,SAAS;YAChF,gBAAgB,EAAE,CAAC,EAAU,EAAE,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC,IAAI,SAAS;SAC5E,CAAC,CAAC;QAPc,WAAM,GAAN,MAAM,CAAoB;IAQ5C,CAAC;IAED;;OAEG;IACO,cAAc,CAAC,IAAY;QACpC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;OAMG;IACgB,oBAAoB;QACtC,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,IAAI,IAAI,CAAC;IACtD,CAAC;IAED;;;;;;;;;;;;;OAaG;IACO,kBAAkB;QAC3B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CACtD,CAAC,EAAE,QAAQ,EAAuD,EAAE,EAAE;YACrE,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;QACpE,CAAC,CACD,CAAC;QAEF,wEAAwE;QACxE,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;IACpC,CAAC;IAED;;OAEG;IACO,oBAAoB;QAC7B,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC;QAC5B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,OAAO;QACN,IAAI,CAAC,UAAU,EAAE,CAAC;IACnB,CAAC;CACD"}

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Type definitions for TanStack Solid Router adapter
+ */
+export type { RouterBridge, PlayRouteEvent } from "@xmachines/play-router";
+export type { AbstractActor } from "@xmachines/play-actor";
+export interface RouteMapping {
+    stateId: string;
+    path: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC3E,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,MAAM,WAAW,YAAY;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACb"}

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * Type definitions for TanStack Solid Router adapter
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@xmachines/play-tanstack-solid-router",
+  "version": "1.0.0-beta.1",
+  "description": "TanStack Solid Router adapter for XMachines Universal Player Architecture",
+  "license": "MIT",
+  "author": "XMachines Contributors",
+  "repository": {
+    "type": "git",
+    "url": "git@gitlab.com:xmachin-es/xmachines-js.git",
+    "directory": "packages/play-tanstack-solid-router"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@xmachines/play": "1.0.0-beta.1",
+    "@xmachines/play-actor": "1.0.0-beta.1",
+    "@xmachines/play-router": "1.0.0-beta.1",
+    "@xmachines/play-signals": "1.0.0-beta.1"
+  },
+  "devDependencies": {
+    "@solidjs/testing-library": "^0.8.0",
+    "@tanstack/solid-router": "^1.166.7",
+    "solid-js": "^1.8.0"
+  },
+  "peerDependencies": {
+    "@tanstack/solid-router": "^1.166.7",
+    "solid-js": "^1.8.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}