@xmachines/play-solid-router 1.0.0-beta.4 → 1.0.0-beta.40

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

@@ -8,7 +8,7 @@ SolidJS Router adapter using `RouterBridgeBase` for consistent actor↔router sy
 
 `@xmachines/play-solid-router` provides seamless integration between SolidJS Router and XMachines state machines. Built on Solid's reactive primitives, it enables zero-adaptation signals synchronization.
 
-Per [RFC Play v1](https://gitlab.com/xmachin-es/rfc/-/blob/main/src/play-v1.md), this package implements:
+Per [Play RFC](../docs/rfc/play.md), this package implements:
 
 - **Actor Authority (INV-01):** State machine controls navigation, router reflects decisions
 - **Passive Infrastructure (INV-04):** Router observes `actor.currentRoute` signal
@@ -36,12 +36,12 @@ npm install @solidjs/router@^0.13.0 solid-js@^1.8.0 @xmachines/play-solid-router
 
 **Peer dependencies:**
 
-- `@solidjs/router` ^0.13.0 - SolidJS 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
+- `@solidjs/router` ^0.13.0 — SolidJS 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 primitives
 
 ## Quick Start
 
@@ -126,51 +126,57 @@ class SolidRouterBridge {
 
 **Methods:**
 
-- `connect()` - Start bidirectional synchronization.
+- `connect()` - Start bidirectional synchronization. Both `location.pathname` and `location.search` are forwarded to the actor on first connect, so users arriving on `/profile?tab=posts` have `query: { tab: "posts" }` in the initial `play.route` event.
 - `disconnect()` - Stop synchronization and cleanup bridge resources.
 - `dispose()` - Alias of `disconnect()`.
 
+`connect()` creates a Solid-owned router watcher, and `disconnect()`/`dispose()` tears it down immediately. Do not rely on owner unmount alone if you need the bridge to stop processing router updates earlier.
+
 **Internal Behavior:**
 
 - Uses `RouterBridgeBase` TC39 watcher lifecycle for actor→router synchronization
 - Updates SolidJS Router via `navigate(path)` when actor state changes
 - Uses `createEffect(on(...))` to watch `location.pathname` signal
-- Sends `play.route` events to actor when user navigates
+- Sends `play.route` events to actor when user navigates, using Solid's pre-parsed `useParams()` for path parameter extraction (no URLPattern polyfill required)
 - Prevents circular updates with path tracking and processing flags
 
 ### `RouteMap`
 
 Bidirectional mapping between XMachines state IDs and SolidJS Router paths with pattern matching support.
 
-**Type Signature:**
+`RouteMap` extends `BaseRouteMap` from `@xmachines/play-router`, inheriting bucket-indexed
+bidirectional route matching. No routing logic lives in the adapter itself.
 
 ```typescript
 interface RouteMapping {
-	stateId: string;
-	path: string;
+	readonly stateId: string;
+	readonly path: string;
 }
 
-class RouteMap {
-	constructor(mappings: RouteMapping[]);
-	getPath(stateId: string, params?: Record<string, string>): string | undefined;
-	getStateIdByPath(path: string): string | undefined;
-}
+// RouteMap is a thin subclass of BaseRouteMap — no extra methods
+class RouteMap extends BaseRouteMap {}
+
+// Inherited API:
+routeMap.getStateIdByPath(path: string): string | null
+routeMap.getPathByStateId(stateId: string): string | null
 ```
 
+`getStateIdByPath` and `getPathByStateId` both return `null` (not `undefined`) for misses.
+
 **Constructor Parameters:**
 
-- `mappings` - Array of mapping objects with:
-    - `stateId` - State machine state ID (e.g., `'#profile'`)
-    - `path` - SolidJS Router path pattern (e.g., `'/profile/:userId'`)
+- `mappings` - Array of `{ stateId, path }` entries:
+    - `stateId` — State machine state ID (e.g., `'#profile'`)
+    - `path` — SolidJS Router path pattern (e.g., `'/profile/:userId'`)
 
 **Methods:**
 
-- `getPath(stateId, params?)` - Find path from state ID, optionally substitute params
-- `getStateIdByPath(path)` - Find state ID from path with pattern matching (supports `:param` and `:param?` syntax)
+- `getPathByStateId(stateId)` — Find path pattern from state ID
+- `getStateIdByPath(path)` — Find state ID from path with pattern matching (supports `:param` and `:param?` syntax)
 
 **Pattern Matching:**
 
-Uses URLPattern API for robust dynamic route matching:
+Uses bucket-indexed RegExp matching for dynamic routes:
 
 ```typescript
 const routeMap = new RouteMap([{ stateId: "#settings", path: "/settings/:section?" }]);
@@ -178,6 +184,7 @@ const routeMap = new RouteMap([{ stateId: "#settings", path: "/settings/:section
 routeMap.getStateIdByPath("/settings"); // '#settings'
 routeMap.getStateIdByPath("/settings/account"); // '#settings'
 routeMap.getStateIdByPath("/settings/privacy"); // '#settings'
+routeMap.getStateIdByPath("/other"); // null
 ```
 
 ## Examples
@@ -186,8 +193,20 @@ routeMap.getStateIdByPath("/settings/privacy"); // '#settings'
 
 ```typescript
 import { Router, Route } from '@solidjs/router';
-import { createSignal } from 'solid-js';
-import { defineCatalog } from '@xmachines/play-catalog';
+import { defineCatalog } from "@json-render/core";
+import { schema } from "@json-render/react/schema";
+import { defineRegistry } from "@xmachines/play-solid";
+import { z } from "zod";
+
+// Catalog and registry
+const appCatalog = defineCatalog(schema, {
+  components: {
+    Home: { props: z.object({}) },
+    About: { props: z.object({}) },
+    Contact: { props: z.object({}) },
+  },
+});
+const registry = defineRegistry(appCatalog, { components: { Home, About, Contact } });
 
 // State machine with 3 states
 const appMachine = setup({
@@ -210,12 +229,6 @@ const appMachine = setup({
   }
 });
 
-const catalog = defineCatalog({
-  Home,
-  About,
-  Contact,
-});
-
 // Component setup
 function App() {
   const navigate = useNavigate();
@@ -224,7 +237,7 @@ function App() {
 
   const routeMap = createRouteMap(appMachine);
 
-  const createPlayer = definePlayer({ machine: appMachine, catalog });
+  const createPlayer = definePlayer({ machine: appMachine, catalog: appCatalog });
   const actor = createPlayer();
   actor.start();
   const bridge = new SolidRouterBridge(navigate, location, params, actor, routeMap);
@@ -246,7 +259,18 @@ function App() {
 ```typescript
 // State machine with parameter routes
 import { formatPlayRouteTransitions } from "@xmachines/play-xstate";
-import { defineCatalog } from "@xmachines/play-catalog";
+import { defineCatalog } from "@json-render/core";
+import { schema } from "@json-render/react/schema";
+import { defineRegistry } from "@xmachines/play-solid";
+import { z } from "zod";
+
+const appCatalog = defineCatalog(schema, {
+  components: {
+    Profile: { props: z.object({ userId: z.string() }) },
+    Settings: { props: z.object({ section: z.string().optional() }) },
+  },
+});
+const registry = defineRegistry(appCatalog, { components: { Profile, Settings } });
 
 const machineConfig = {
   id: 'app',
@@ -274,11 +298,6 @@ const appMachine = setup({
   }
 }).createMachine(formatPlayRouteTransitions(machineConfig));
 
-const catalog = defineCatalog({
-  Profile,
-  Settings,
-});
-
 // Router with dynamic routes
 function App() {
   const navigate = useNavigate();
@@ -287,7 +306,7 @@ function App() {
 
   const routeMap = createRouteMap(appMachine);
 
-  const createPlayer = definePlayer({ machine: appMachine, catalog });
+  const createPlayer = definePlayer({ machine: appMachine, catalog: appCatalog });
   const actor = createPlayer();
   actor.start();
   const bridge = new SolidRouterBridge(navigate, location, params, actor, routeMap);
@@ -328,7 +347,17 @@ function ProfileButton(props: { userId: string }) {
 ```typescript
 // State machine with query param handling
 import { formatPlayRouteTransitions } from "@xmachines/play-xstate";
-import { defineCatalog } from "@xmachines/play-catalog";
+import { defineCatalog } from "@json-render/core";
+import { schema } from "@json-render/react/schema";
+import { defineRegistry } from "@xmachines/play-solid";
+import { z } from "zod";
+
+const searchCatalog = defineCatalog(schema, {
+  components: {
+    Search: { props: z.object({ query: z.string().optional() }) },
+  },
+});
+const registry = defineRegistry(searchCatalog, { components: { Search } });
 
 const machineConfig = {
   context: { query: '', filters: {} },
@@ -349,11 +378,7 @@ const searchMachine = setup({
   }
 }).createMachine(formatPlayRouteTransitions(machineConfig));
 
-const catalog = defineCatalog({
-  Search,
-});
-
-const player = definePlayer({ machine: searchMachine, catalog });
+const player = definePlayer({ machine: searchMachine, catalog: searchCatalog });
 
 // Component sends query params
 function SearchBar(props) {
@@ -387,7 +412,19 @@ function SearchBar(props) {
 
 ```typescript
 // State machine with auth guards
-import { defineCatalog } from "@xmachines/play-catalog";
+import { defineCatalog } from "@json-render/core";
+import { schema } from "@json-render/react/schema";
+import { defineRegistry } from "@xmachines/play-solid";
+import { z } from "zod";
+
+const authCatalog = defineCatalog(schema, {
+	components: {
+		Home: { props: z.object({}) },
+		Login: { props: z.object({ title: z.string() }) },
+		Dashboard: { props: z.object({ username: z.string() }) },
+	},
+});
+const registry = defineRegistry(authCatalog, { components: { Home, Login, Dashboard } });
 
 const authMachine = setup({
 	types: {
@@ -420,13 +457,7 @@ const authMachine = setup({
 	},
 });
 
-const catalog = defineCatalog({
-	Home,
-	Login,
-	Dashboard,
-});
-
-const player = definePlayer({ machine: authMachine, catalog });
+const player = definePlayer({ machine: authMachine, catalog: authCatalog });
 ```
 
 **Guard behavior:**
@@ -479,7 +510,7 @@ function App() {
 2. `actor.currentRoute` signal updates
 3. `createEffect(on(...))` fires with new route value
 4. Bridge extracts state ID from signal
-5. Bridge looks up path via `routeMap.getPath(stateId, params)`
+5. Bridge looks up path via `routeMap.getPathByStateId(stateId)`
 6. Bridge calls `navigate(path)`
 7. SolidJS Router updates URL and renders component
 
@@ -603,15 +634,11 @@ function App() {
 
 ### Pattern Matching for Dynamic Routes
 
-**URLPattern API integration:**
+**Bucket-indexed matching via `BaseRouteMap`:**
 
-```typescript
-private matchesPattern(path: string, pattern: string): boolean {
-  // Use URLPattern for robust matching
-  const urlPattern = new URLPattern({ pathname: pattern });
-  return urlPattern.test({ pathname: path });
-}
-```
+Routes are grouped by their first path segment into buckets. On each lookup only the
+relevant bucket (plus the wildcard `*` bucket for `:param`-first routes) is scanned —
+typically far fewer than all registered routes.
 
 **Supported syntax:**
 
@@ -634,4 +661,7 @@ routeMap.getStateIdByPath("/settings/privacy"); // '#settings'
 
 ## License
 
-MIT
+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>.

package/dist/index.d.ts

@@ -6,7 +6,7 @@
 export { SolidRouterBridge } from "./solid-router-bridge.js";
 export { PlayRouterProvider } from "./play-router-provider.js";
 export type { PlayRouterProviderProps, RoutableActor, SolidRouterHooks, } from "./play-router-provider.js";
-export { RouteMap } from "./route-map.js";
-export { createRouteMap } from "./create-route-map.js";
-export type { RouteMapping, PlayRouteEvent, RouterBridge, AbstractActor } from "./types.js";
+export { RouteMap, createRouteMapFromMachine as createRouteMap, type RouteMapping, } from "@xmachines/play-router";
+export type { PlayRouteEvent, RouterBridge } from "./types.js";
+export type { AbstractActor } from "@xmachines/play-actor";
 //# 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,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,YAAY,EACX,uBAAuB,EACvB,aAAa,EACb,gBAAgB,GAChB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}
+{"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,gBAAgB,GAChB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACN,QAAQ,EACR,yBAAyB,IAAI,cAAc,EAC3C,KAAK,YAAY,GACjB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/D,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/index.js

@@ -5,6 +5,5 @@
  */
 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";
+export { RouteMap, createRouteMapFromMachine as createRouteMap, } from "@xmachines/play-router";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +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"}
+{"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,EACN,QAAQ,EACR,yBAAyB,IAAI,cAAc,GAE3C,MAAM,wBAAwB,CAAC"}

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

@@ -1,21 +1,72 @@
 import { type JSX } from "solid-js";
+import type { Navigator, Location, Params } from "@solidjs/router";
 import type { AbstractActor, Routable, Viewable } from "@xmachines/play-actor";
 import type { AnyActorLogic } from "xstate";
-import type { RouteMap } from "./route-map.js";
+import type { RouteMap } from "@xmachines/play-router";
+/** Minimum actor shape accepted by PlayRouterProvider. */
 export type RoutableActor = AbstractActor<AnyActorLogic> & Routable & Viewable;
+/**
+ * The three Solid Router hook results that `PlayRouterProvider` and `SolidRouterBridge`
+ * require. Pass these directly from your component's hook calls:
+ *
+ * ```tsx
+ * const navigate = useNavigate();   // → SolidRouterHooks.navigate
+ * const location = useLocation();   // → SolidRouterHooks.location
+ * const params   = useParams();     // → SolidRouterHooks.params
+ * ```
+ *
+ * - `navigate` — used to push URL changes when the actor's `currentRoute` changes.
+ * - `location` — `pathname` and `search` are read at `connect()` time for deep-link sync.
+ *   Subsequent pathname changes drive router→actor sync via `createEffect`.
+ * - `params` — Solid's pre-parsed path parameters for the current route segment. Used
+ *   directly in `extractParams()` to avoid re-parsing with URLPattern.
+ */
 export type SolidRouterHooks = {
-    navigate: ((path: string) => void) | ((path: string, ...args: unknown[]) => unknown);
-    location: {
-        pathname: string;
-        search: string;
-    };
-    params: Record<string, string | undefined>;
+    navigate: Navigator;
+    location: Location;
+    params: Params;
 };
-export interface PlayRouterProviderProps {
-    actor: RoutableActor;
+export interface PlayRouterProviderProps<TActor extends RoutableActor = RoutableActor> {
+    /** The actor to sync with Solid Router. */
+    actor: TActor;
+    /** Bidirectional route map for state ID ↔ URL path lookups. */
     routeMap: RouteMap;
+    /**
+     * The three Solid Router hook results that drive bidirectional sync.
+     * Obtain these from `useNavigate()`, `useLocation()`, and `useParams()`
+     * in the parent component (they must be called inside a router context).
+     */
     router: SolidRouterHooks;
-    renderer: (actor: RoutableActor, router: SolidRouterHooks) => JSX.Element;
+    /** Renderer callback receives the same concrete actor type that was passed in. */
+    renderer: (actor: TActor, router: SolidRouterHooks) => JSX.Element;
 }
-export declare function PlayRouterProvider(props: PlayRouterProviderProps): any;
+/**
+ * Connects a `PlayerActor` to Solid Router, keeping actor state and browser URL
+ * in sync bidirectionally.
+ *
+ * The bridge is created synchronously at component evaluation time (Solid's
+ * execution model) and torn down via `onCleanup` when the component is disposed.
+ * Unlike React, prop stability is not a concern — Solid's `props` accessor is
+ * already reactive and the bridge is created once per component instance.
+ *
+ * The `router` prop must be obtained from Solid Router hooks in the parent component:
+ *
+ * ```tsx
+ * function AppShell() {
+ *   const navigate = useNavigate();
+ *   const location = useLocation();
+ *   const params   = useParams();
+ *
+ *   return (
+ *     <PlayRouterProvider
+ *       actor={actor}
+ *       routeMap={routeMap}
+ *       router={{ navigate, location, params }}
+ *       renderer={(a) => <PlayRenderer actor={a} registry={registry} />}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare function PlayRouterProvider<TActor extends RoutableActor>(props: PlayRouterProviderProps<TActor>): any;
 //# 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;AAE5C,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,gBAAgB,GAAG;IAC9B,QAAQ,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAC;IACrF,QAAQ,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC3C,CAAC;AAEF,MAAM,WAAW,uBAAuB;IACvC,KAAK,EAAE,aAAa,CAAC;IACrB,QAAQ,EAAE,QAAQ,CAAC;IACnB,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,gBAAgB,KAAK,GAAG,CAAC,OAAO,CAAC;CAC1E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,OAehE"}
+{"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,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAC/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD,0DAA0D;AAC1D,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC,aAAa,CAAC,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE/E;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC9B,QAAQ,EAAE,SAAS,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,WAAW,uBAAuB,CAAC,MAAM,SAAS,aAAa,GAAG,aAAa;IACpF,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,QAAQ,EAAE,QAAQ,CAAC;IACnB;;;;OAIG;IACH,MAAM,EAAE,gBAAgB,CAAC;IACzB,kFAAkF;IAClF,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,KAAK,GAAG,CAAC,OAAO,CAAC;CACnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,SAAS,aAAa,EAC9D,KAAK,EAAE,uBAAuB,CAAC,MAAM,CAAC,OAgBtC"}

package/dist/play-router-provider.jsx

@@ -1,5 +1,33 @@
 import { onCleanup } from "solid-js";
 import { SolidRouterBridge } from "./solid-router-bridge.js";
+/**
+ * Connects a `PlayerActor` to Solid Router, keeping actor state and browser URL
+ * in sync bidirectionally.
+ *
+ * The bridge is created synchronously at component evaluation time (Solid's
+ * execution model) and torn down via `onCleanup` when the component is disposed.
+ * Unlike React, prop stability is not a concern — Solid's `props` accessor is
+ * already reactive and the bridge is created once per component instance.
+ *
+ * The `router` prop must be obtained from Solid Router hooks in the parent component:
+ *
+ * ```tsx
+ * function AppShell() {
+ *   const navigate = useNavigate();
+ *   const location = useLocation();
+ *   const params   = useParams();
+ *
+ *   return (
+ *     <PlayRouterProvider
+ *       actor={actor}
+ *       routeMap={routeMap}
+ *       router={{ navigate, location, params }}
+ *       renderer={(a) => <PlayRenderer actor={a} registry={registry} />}
+ *     />
+ *   );
+ * }
+ * ```
+ */
 export function PlayRouterProvider(props) {
     const bridge = new SolidRouterBridge(props.router.navigate, props.router.location, props.router.params, props.actor, props.routeMap);
     bridge.connect();

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

@@ -1 +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;AAiB7D,MAAM,UAAU,kBAAkB,CAAC,KAA8B;IAChE,MAAM,MAAM,GAAG,IAAI,iBAAiB,CACnC,KAAK,CAAC,MAAM,CAAC,QAAQ,EACrB,KAAK,CAAC,MAAM,CAAC,QAAQ,EACrB,KAAK,CAAC,MAAM,CAAC,MAAM,EACnB,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,QAAQ,CACd,CAAC;IACF,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"}
+{"version":3,"file":"play-router-provider.jsx","sourceRoot":"","sources":["../src/play-router-provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAY,MAAM,UAAU,CAAC;AAI/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AA2C7D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,kBAAkB,CACjC,KAAsC;IAEtC,MAAM,MAAM,GAAG,IAAI,iBAAiB,CACnC,KAAK,CAAC,MAAM,CAAC,QAAQ,EACrB,KAAK,CAAC,MAAM,CAAC,QAAQ,EACrB,KAAK,CAAC,MAAM,CAAC,MAAM,EACnB,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,QAAQ,CACd,CAAC;IACF,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/solid-router-bridge.d.ts

@@ -5,8 +5,10 @@
  * Uses Solid's native reactive primitives (createEffect) for router→actor direction.
  *
  * **IMPORTANT:** `connect()` MUST be called inside a Solid reactive owner (component
- * or createRoot). The createEffect() in watchRouterChanges() relies on Solid's
- * reactive system for automatic cleanup.
+ * or createRoot). The `createEffect()` in `watchRouterChanges()` runs inside
+ * `createRoot()`, which deliberately isolates it from any parent owner — automatic
+ * cleanup on component unmount does NOT happen. You MUST call `disconnect()` (or
+ * `dispose()`) explicitly, typically in `onCleanup()`.
  *
  * @example
  * ```tsx
@@ -30,20 +32,32 @@
  * }
  * ```
  */
+import type { Navigator, Params } from "@solidjs/router";
 import { RouterBridgeBase } from "@xmachines/play-router";
+import type { LocationLike } from "@xmachines/play-router";
 import type { AbstractActor, Routable } from "@xmachines/play-actor";
 import type { AnyActorLogic } from "xstate";
-import type { RouteMap } from "./route-map.js";
+import type { RouteMap } from "@xmachines/play-router";
 /**
  * SolidJS Router integration bridge extending RouterBridgeBase
  *
  * Implements RouterBridge protocol for SolidJS Router using Solid's reactive
  * primitives. The actor→router direction uses TC39 Signal watcher (from base class).
  * The router→actor direction uses Solid's createEffect for native reactivity.
+ *
+ * Path parameters are extracted from Solid's `useParams()` reactive proxy rather than
+ * re-parsing the URL with URLPattern. This means parameterized routes work without the
+ * URLPattern polyfill — Solid's router has already extracted the values.
  */
 export declare class SolidRouterBridge extends RouterBridgeBase {
     private readonly solidNavigate;
     private readonly location;
+    private disposeRouterWatcher;
+    /**
+     * Live reactive params object from Solid's `useParams()`.
+     * Read inside the createEffect callback so it always reflects the current route.
+     */
+    private readonly solidParams;
     /**
      * Create a SolidJS Router bridge
      *
@@ -51,14 +65,28 @@ export declare class SolidRouterBridge extends RouterBridgeBase {
      *
      * @param solidNavigate - Result of useNavigate() hook
      * @param location - Result of useLocation() hook
-     * @param _params - Result of useParams() hook
+     * @param params - Result of useParams() hook — used directly for path parameter extraction,
+     *   avoiding the URLPattern polyfill requirement for parameterized routes
      * @param actor - XMachines actor instance
      * @param routeMap - Bidirectional state ID ↔ path mapping
      */
-    constructor(solidNavigate: ((path: string) => void) | ((path: string, ...args: unknown[]) => unknown), location: {
-        pathname: string;
-        search: string;
-    }, _params: Record<string, string | undefined>, actor: AbstractActor<AnyActorLogic> & Routable, routeMap: RouteMap);
+    constructor(solidNavigate: Navigator, location: LocationLike, params: Params, actor: AbstractActor<AnyActorLogic> & Routable, routeMap: RouteMap);
+    /**
+     * Extract path parameters using Solid's pre-parsed `useParams()` values.
+     *
+     * Solid's router has already extracted all named parameters for the matched route
+     * segment. Reading `this.solidParams` inside the createEffect callback that drives
+     * `syncActorFromRouter` is safe — the reactive proxy always reflects the current
+     * route at the time the effect runs.
+     *
+     * Falls back to URLPattern-based extraction (base class) only when Solid provided
+     * no params for this route (i.e. the route has no `:param` segments).
+     *
+     * @param pathname - The actual URL path (unused — params already extracted by Solid)
+     * @param stateId - The matched state ID (unused — params already extracted by Solid)
+     * @returns Normalized path parameters with undefined/empty values filtered out
+     */
+    protected extractParams(pathname: string, stateId: string): Record<string, string>;
     /**
      * Navigate SolidJS Router to the given path.
      */
@@ -67,18 +95,32 @@ export declare class SolidRouterBridge extends RouterBridgeBase {
      * Get the current router pathname for initial URL -> actor sync on connect.
      */
     protected getInitialRouterPath(): string | null;
+    /**
+     * Return the initial URL search string for query-param forwarding on `connect()`.
+     *
+     * Reads `this.location.search` from Solid's `useLocation()` reactive object —
+     * the same source used by `getInitialRouterPath()`. An empty string (no query
+     * params) returns `undefined` so `syncActorFromRouter` produces `query: {}`.
+     */
+    protected getInitialRouterSearch(): string | undefined;
     /**
      * Subscribe to SolidJS Router location changes using createEffect.
      *
-     * MUST be called inside a Solid reactive owner (component/createRoot).
-     * Solid auto-cleans createEffect subscriptions on component unmount.
+     * MUST be called inside a Solid reactive owner (component or createRoot).
+     *
+     * The effect runs inside `createRoot()` to give it a stable owner independent
+     * of the calling component's lifecycle — this prevents the effect from being
+     * disposed if the component re-renders while the bridge should stay active.
+     * The trade-off is that component unmount does NOT automatically clean up the
+     * effect; `disconnect()` (or `dispose()`) MUST be called explicitly to avoid a leak.
      */
     protected watchRouterChanges(): void;
     /**
      * Stop watching SolidJS Router changes.
      *
-     * Solid auto-cleans createEffect subscriptions when component unmounts.
-     * This sets the processing flag to prevent pending operations.
+     * Calls the `dispose` function returned by `createRoot()` in `watchRouterChanges()`,
+     * tearing down the reactive effect and freeing the isolated owner. This is the only
+     * cleanup path — component unmount does NOT trigger this automatically.
      */
     protected unwatchRouterChanges(): void;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"solid-router-bridge.d.ts","sourceRoot":"","sources":["../src/solid-router-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;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;;;;;;GAMG;AACH,qBAAa,iBAAkB,SAAQ,gBAAgB;IAarD,OAAO,CAAC,QAAQ,CAAC,aAAa;IAG9B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAf1B;;;;;;;;;;OAUG;gBAEe,aAAa,EAC3B,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC,GACxB,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,EACjC,QAAQ,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAC/D,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,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;;OAEG;cACgB,oBAAoB,IAAI,MAAM,GAAG,IAAI;IAIxD;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,IAAI,IAAI;IAcpC;;;;;OAKG;IACH,SAAS,CAAC,oBAAoB,IAAI,IAAI;IAMtC;;;;;;;OAOG;IACH,OAAO,IAAI,IAAI;CAGf"}
+{"version":3,"file":"solid-router-bridge.d.ts","sourceRoot":"","sources":["../src/solid-router-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,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,wBAAwB,CAAC;AAEvD;;;;;;;;;;GAUG;AACH,qBAAa,iBAAkB,SAAQ,gBAAgB;IAsBrD,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAtB1B,OAAO,CAAC,oBAAoB,CAA6B;IAEzD;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IAErC;;;;;;;;;;;OAWG;gBAEe,aAAa,EAAE,SAAS,EACxB,QAAQ,EAAE,YAAY,EACvC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,QAAQ,EAC9C,QAAQ,EAAE,QAAQ;IASnB;;;;;;;;;;;;;;OAcG;cACgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAY3F;;OAEG;IACH,SAAS,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI5C;;OAEG;cACgB,oBAAoB,IAAI,MAAM,GAAG,IAAI;IAIxD;;;;;;OAMG;cACgB,sBAAsB,IAAI,MAAM,GAAG,SAAS;IAI/D;;;;;;;;;;OAUG;IACH,SAAS,CAAC,kBAAkB,IAAI,IAAI;IAepC;;;;;;OAMG;IACH,SAAS,CAAC,oBAAoB,IAAI,IAAI;IAKtC;;;;;;;OAOG;IACH,OAAO,IAAI,IAAI;CAGf"}

package/dist/solid-router-bridge.js

@@ -5,8 +5,10 @@
  * Uses Solid's native reactive primitives (createEffect) for router→actor direction.
  *
  * **IMPORTANT:** `connect()` MUST be called inside a Solid reactive owner (component
- * or createRoot). The createEffect() in watchRouterChanges() relies on Solid's
- * reactive system for automatic cleanup.
+ * or createRoot). The `createEffect()` in `watchRouterChanges()` runs inside
+ * `createRoot()`, which deliberately isolates it from any parent owner — automatic
+ * cleanup on component unmount does NOT happen. You MUST call `disconnect()` (or
+ * `dispose()`) explicitly, typically in `onCleanup()`.
  *
  * @example
  * ```tsx
@@ -30,7 +32,7 @@
  * }
  * ```
  */
-import { createEffect, on } from "solid-js";
+import { createEffect, createRoot, on } from "solid-js";
 import { RouterBridgeBase } from "@xmachines/play-router";
 /**
  * SolidJS Router integration bridge extending RouterBridgeBase
@@ -38,10 +40,20 @@ import { RouterBridgeBase } from "@xmachines/play-router";
  * Implements RouterBridge protocol for SolidJS Router using Solid's reactive
  * primitives. The actor→router direction uses TC39 Signal watcher (from base class).
  * The router→actor direction uses Solid's createEffect for native reactivity.
+ *
+ * Path parameters are extracted from Solid's `useParams()` reactive proxy rather than
+ * re-parsing the URL with URLPattern. This means parameterized routes work without the
+ * URLPattern polyfill — Solid's router has already extracted the values.
  */
 export class SolidRouterBridge extends RouterBridgeBase {
     solidNavigate;
     location;
+    disposeRouterWatcher = null;
+    /**
+     * Live reactive params object from Solid's `useParams()`.
+     * Read inside the createEffect callback so it always reflects the current route.
+     */
+    solidParams;
     /**
      * Create a SolidJS Router bridge
      *
@@ -49,17 +61,42 @@ export class SolidRouterBridge extends RouterBridgeBase {
      *
      * @param solidNavigate - Result of useNavigate() hook
      * @param location - Result of useLocation() hook
-     * @param _params - Result of useParams() hook
+     * @param params - Result of useParams() hook — used directly for path parameter extraction,
+     *   avoiding the URLPattern polyfill requirement for parameterized routes
      * @param actor - XMachines actor instance
      * @param routeMap - Bidirectional state ID ↔ path mapping
      */
-    constructor(solidNavigate, location, _params, actor, routeMap) {
+    constructor(solidNavigate, location, params, actor, routeMap) {
         super(actor, {
             getStateIdByPath: (path) => routeMap.getStateIdByPath(path),
-            getPathByStateId: (id) => routeMap.getPath(id),
+            getPathByStateId: (id) => routeMap.getPathByStateId(id),
         });
         this.solidNavigate = solidNavigate;
         this.location = location;
+        this.solidParams = params;
+    }
+    /**
+     * Extract path parameters using Solid's pre-parsed `useParams()` values.
+     *
+     * Solid's router has already extracted all named parameters for the matched route
+     * segment. Reading `this.solidParams` inside the createEffect callback that drives
+     * `syncActorFromRouter` is safe — the reactive proxy always reflects the current
+     * route at the time the effect runs.
+     *
+     * Falls back to URLPattern-based extraction (base class) only when Solid provided
+     * no params for this route (i.e. the route has no `:param` segments).
+     *
+     * @param pathname - The actual URL path (unused — params already extracted by Solid)
+     * @param stateId - The matched state ID (unused — params already extracted by Solid)
+     * @returns Normalized path parameters with undefined/empty values filtered out
+     */
+    extractParams(pathname, stateId) {
+        const entries = Object.entries(this.solidParams).filter((entry) => entry[1] !== undefined && entry[1] !== null && entry[1] !== "");
+        if (entries.length > 0) {
+            return Object.fromEntries(entries);
+        }
+        // No params from Solid — fall back to URLPattern for routes with no segments
+        return super.extractParams(pathname, stateId);
     }
     /**
      * Navigate SolidJS Router to the given path.
@@ -73,30 +110,46 @@ export class SolidRouterBridge extends RouterBridgeBase {
     getInitialRouterPath() {
         return this.location.pathname ?? null;
     }
+    /**
+     * Return the initial URL search string for query-param forwarding on `connect()`.
+     *
+     * Reads `this.location.search` from Solid's `useLocation()` reactive object —
+     * the same source used by `getInitialRouterPath()`. An empty string (no query
+     * params) returns `undefined` so `syncActorFromRouter` produces `query: {}`.
+     */
+    getInitialRouterSearch() {
+        return this.location.search || undefined;
+    }
     /**
      * Subscribe to SolidJS Router location changes using createEffect.
      *
-     * MUST be called inside a Solid reactive owner (component/createRoot).
-     * Solid auto-cleans createEffect subscriptions on component unmount.
+     * MUST be called inside a Solid reactive owner (component or createRoot).
+     *
+     * The effect runs inside `createRoot()` to give it a stable owner independent
+     * of the calling component's lifecycle — this prevents the effect from being
+     * disposed if the component re-renders while the bridge should stay active.
+     * The trade-off is that component unmount does NOT automatically clean up the
+     * effect; `disconnect()` (or `dispose()`) MUST be called explicitly to avoid a leak.
      */
     watchRouterChanges() {
-        // MUST be called inside Solid reactive owner (component or createRoot)
-        // createEffect in watchRouterChanges() relies on Solid's reactive system
-        createEffect(on(() => this.location.pathname, (pathname) => {
-            const search = this.location.search ?? "";
-            this.syncActorFromRouter(pathname, search);
-        }));
+        this.disposeRouterWatcher = createRoot((dispose) => {
+            createEffect(on(() => this.location.pathname, (pathname) => {
+                const search = this.location.search ?? "";
+                this.syncActorFromRouter(pathname, search);
+            }));
+            return dispose;
+        });
     }
     /**
      * Stop watching SolidJS Router changes.
      *
-     * Solid auto-cleans createEffect subscriptions when component unmounts.
-     * This sets the processing flag to prevent pending operations.
+     * Calls the `dispose` function returned by `createRoot()` in `watchRouterChanges()`,
+     * tearing down the reactive effect and freeing the isolated owner. This is the only
+     * cleanup path — component unmount does NOT trigger this automatically.
      */
     unwatchRouterChanges() {
-        // Solid auto-cleans createEffect on component unmount
-        // Set flag to prevent any pending operations
-        this.isProcessingNavigation = true;
+        this.disposeRouterWatcher?.();
+        this.disposeRouterWatcher = null;
     }
     /**
      * Dispose the bridge (alias for disconnect).

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

@@ -1 +1 @@
-{"version":3,"file":"solid-router-bridge.js","sourceRoot":"","sources":["../src/solid-router-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAK1D;;;;;;GAMG;AACH,MAAM,OAAO,iBAAkB,SAAQ,gBAAgB;IAapC;IAGA;IAflB;;;;;;;;;;OAUG;IACH,YACkB,aAEiC,EACjC,QAA8C,EAC/D,OAA2C,EAC3C,KAA8C,EAC9C,QAAkB;QAElB,KAAK,CAAC,KAAK,EAAE;YACZ,gBAAgB,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC;YACnE,gBAAgB,EAAE,CAAC,EAAU,EAAE,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;SACtD,CAAC,CAAC;QAXc,kBAAa,GAAb,aAAa,CAEoB;QACjC,aAAQ,GAAR,QAAQ,CAAsC;IAShE,CAAC;IAED;;OAEG;IACO,cAAc,CAAC,IAAY;QACpC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED;;OAEG;IACgB,oBAAoB;QACtC,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,IAAI,IAAI,CAAC;IACvC,CAAC;IAED;;;;;OAKG;IACO,kBAAkB;QAC3B,uEAAuE;QACvE,yEAAyE;QACzE,YAAY,CACX,EAAE,CACD,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAC5B,CAAC,QAAgB,EAAE,EAAE;YACpB,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,EAAE,CAAC;YAC1C,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAC5C,CAAC,CACD,CACD,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACO,oBAAoB;QAC7B,sDAAsD;QACtD,6CAA6C;QAC7C,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;IACpC,CAAC;IAED;;;;;;;OAOG;IACH,OAAO;QACN,IAAI,CAAC,UAAU,EAAE,CAAC;IACnB,CAAC;CACD"}
+{"version":3,"file":"solid-router-bridge.js","sourceRoot":"","sources":["../src/solid-router-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAExD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAM1D;;;;;;;;;;GAUG;AACH,MAAM,OAAO,iBAAkB,SAAQ,gBAAgB;IAsBpC;IACA;IAtBV,oBAAoB,GAAwB,IAAI,CAAC;IAEzD;;;OAGG;IACc,WAAW,CAAS;IAErC;;;;;;;;;;;OAWG;IACH,YACkB,aAAwB,EACxB,QAAsB,EACvC,MAAc,EACd,KAA8C,EAC9C,QAAkB;QAElB,KAAK,CAAC,KAAK,EAAE;YACZ,gBAAgB,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC;YACnE,gBAAgB,EAAE,CAAC,EAAU,EAAE,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;SAC/D,CAAC,CAAC;QATc,kBAAa,GAAb,aAAa,CAAW;QACxB,aAAQ,GAAR,QAAQ,CAAc;QASvC,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACgB,aAAa,CAAC,QAAgB,EAAE,OAAe;QACjE,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,CACtD,CAAC,KAAK,EAA6B,EAAE,CACpC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,EAAE,CAC/D,CAAC;QACF,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,OAAO,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;QACD,6EAA6E;QAC7E,OAAO,KAAK,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC/C,CAAC;IAED;;OAEG;IACO,cAAc,CAAC,IAAY;QACpC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED;;OAEG;IACgB,oBAAoB;QACtC,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,IAAI,IAAI,CAAC;IACvC,CAAC;IAED;;;;;;OAMG;IACgB,sBAAsB;QACxC,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,SAAS,CAAC;IAC1C,CAAC;IAED;;;;;;;;;;OAUG;IACO,kBAAkB;QAC3B,IAAI,CAAC,oBAAoB,GAAG,UAAU,CAAC,CAAC,OAAO,EAAE,EAAE;YAClD,YAAY,CACX,EAAE,CACD,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAC5B,CAAC,QAAgB,EAAE,EAAE;gBACpB,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,EAAE,CAAC;gBAC1C,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YAC5C,CAAC,CACD,CACD,CAAC;YACF,OAAO,OAAO,CAAC;QAChB,CAAC,CAAC,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACO,oBAAoB;QAC7B,IAAI,CAAC,oBAAoB,EAAE,EAAE,CAAC;QAC9B,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAClC,CAAC;IAED;;;;;;;OAOG;IACH,OAAO;QACN,IAAI,CAAC,UAAU,EAAE,CAAC;IACnB,CAAC;CACD"}

package/dist/types.d.ts

@@ -1,21 +1,6 @@
 /**
  * Type definitions for @xmachines/play-solid-router
  */
-/**
- * Mapping between state ID and URL path for SolidJS Router
- */
-export interface RouteMapping {
-    /**
-     * XMachines state ID with # prefix
-     * @example '#home', '#profile'
-     */
-    readonly stateId: string;
-    /**
-     * SolidJS Router path pattern
-     * @example '/', '/profile/:userId', '/settings/:section?'
-     */
-    readonly path: string;
-}
 export type { PlayRouteEvent, RouterBridge } from "@xmachines/play-router";
 export type { AbstractActor } from "@xmachines/play-actor";
 //# 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;;GAEG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACtB;AAGD,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3E,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3E,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-solid-router",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.40",
   "description": "SolidJS Router adapter for XMachines Universal Player Architecture",
   "license": "MIT",
   "author": "XMachines Contributors",
@@ -19,6 +19,7 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     }
@@ -28,27 +29,35 @@
   },
   "scripts": {
     "build": "tsc --build",
-    "test": "vitest run",
+    "lint": "oxlint .",
+    "format": "oxfmt .",
+    "test": "vitest",
     "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
-    "clean": "rm -rf dist *.tsbuildinfo",
+    "clean": "rm -rf dist *.tsbuildinfo coverage node_modules/.svelte2tsx-*",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@xmachines/play": "1.0.0-beta.4",
-    "@xmachines/play-actor": "1.0.0-beta.4",
-    "@xmachines/play-router": "1.0.0-beta.4",
-    "@xmachines/play-signals": "1.0.0-beta.4"
+    "@xmachines/play": "1.0.0-beta.40",
+    "@xmachines/play-actor": "1.0.0-beta.40",
+    "@xmachines/play-router": "1.0.0-beta.40",
+    "@xmachines/play-signals": "1.0.0-beta.40"
   },
   "devDependencies": {
     "@solidjs/router": "^0.16.1",
     "@solidjs/testing-library": "^0.8.10",
-    "@xmachines/shared": "1.0.0-beta.4",
-    "solid-js": "^1.9.11",
-    "vite-plugin-solid": "^2.11.11"
+    "@xmachines/play-xstate": "1.0.0-beta.40",
+    "@xmachines/shared": "1.0.0-beta.40",
+    "jsdom": "^29.0.2",
+    "oxfmt": "^0.45.0",
+    "oxlint": "^1.60.0",
+    "solid-js": "^1.9.12",
+    "vite-plugin-solid": "^2.11.11",
+    "vitest": "^4.1.4",
+    "xstate": "^5.30.0"
   },
   "peerDependencies": {
-    "@solidjs/router": "^0.15.4",
-    "solid-js": "^1.8.0"
+    "@solidjs/router": "^0.16.1",
+    "solid-js": "^1.8.0",
+    "xstate": "^5.30.0"
   }
 }

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

@@ -1,25 +0,0 @@
-/**
- * Create RouteMap helper for SolidJS 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-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

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

@@ -1,36 +0,0 @@
-/**
- * Create RouteMap helper for SolidJS 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-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

@@ -1 +0,0 @@
-{"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/route-map.d.ts

@@ -1,75 +0,0 @@
-/**
- * RouteMap for bidirectional state ID ↔ path mapping
- *
- * Provides efficient lookup between XMachines state IDs and SolidJS 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 undefined if not found
-     *
-     * @example
-     * ```typescript
-     * routeMap.getPath('#profile'); // '/profile/:userId'
-     * ```
-     */
-    getPath(stateId: string): string | undefined;
-    /**
-     * 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 undefined if no match found
-     *
-     * @example
-     * ```typescript
-     * routeMap.getStateIdByPath('/profile/123');  // '#profile'
-     * routeMap.getStateIdByPath('/settings');      // '#settings'
-     * routeMap.getStateIdByPath('/settings/account'); // '#settings'
-     * ```
-     */
-    getStateIdByPath(path: string): string | undefined;
-    /**
-     * 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

@@ -1 +0,0 @@
-{"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,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI5C;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAmBlD;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,cAAc;CAetB"}

package/dist/route-map.js

@@ -1,107 +0,0 @@
-/**
- * RouteMap for bidirectional state ID ↔ path mapping
- *
- * Provides efficient lookup between XMachines state IDs and SolidJS 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 undefined if not found
-     *
-     * @example
-     * ```typescript
-     * routeMap.getPath('#profile'); // '/profile/:userId'
-     * ```
-     */
-    getPath(stateId) {
-        return this.stateToPath.get(stateId);
-    }
-    /**
-     * 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 undefined 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 undefined;
-    }
-    /**
-     * 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

@@ -1 +0,0 @@
-{"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,OAAO,CAAC,OAAe;QACtB,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACtC,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,CAAC,CAAC;QACxC,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,SAAS,CAAC;IAClB,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"}