@xmachines/play-solid-router 1.1.0 → 2.0.0

package/README.md

@@ -2,8 +2,7 @@
 
 SolidJS Router adapter for the XMachines Universal Player Architecture. Provides bidirectional synchronisation between a `PlayerActor`'s state machine routes and the browser URL via `@solidjs/router`.
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-1.1.0-blue)](https://www.npmjs.com/package/@xmachines/play-solid-router)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-2.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-solid-router)
 
 Part of the [xmachines-js monorepo](../../README.md).
 

package/dist/create-play-router-provider.js

@@ -0,0 +1,50 @@
+import { onCleanup } from "solid-js";
+import { memo } from "solid-js/web";
+//#region packages/play-solid-router/src/create-play-router-provider.tsx
+/**
+* createPlayRouterProvider — factory for Solid `PlayRouterProvider` components
+*
+* Captures the provider component shape used by this package's
+* `PlayRouterProvider` — create a bridge synchronously at component evaluation
+* time, `connect()` it, and `disconnect()` in `onCleanup` — so that Solid
+* bridges with the standard `(router, actor, routeMap)` constructor can be
+* wrapped in a provider with a single call. Only the bridge class (and
+* therefore the `router` prop type) differs between providers created by this
+* factory.
+*
+* @packageDocumentation
+*/
+/**
+* Create a Solid `PlayRouterProvider` component bound to a specific bridge class.
+*
+* The returned component connects a `PlayerActor` to the framework 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.
+*
+* @param BridgeCtor - Bridge class constructed as `new BridgeCtor(router, actor, routeMap)`.
+* @returns A `PlayRouterProvider` component, generic over the actor type so the
+*   `renderer` callback receives the same concrete actor type that was passed in.
+*
+* @example
+* ```tsx
+* export const PlayRouterProvider = createPlayRouterProvider(MySolidRouterBridge);
+* ```
+*/
+function createPlayRouterProvider(BridgeCtor) {
+	return function PlayRouterProvider(props) {
+		const bridge = new BridgeCtor(props.router, props.actor, props.routeMap);
+		bridge.connect();
+		onCleanup(() => {
+			bridge.disconnect();
+		});
+		return memo(() => props.renderer(props.actor, props.router));
+	};
+}
+//#endregion
+export { createPlayRouterProvider };
+
+//# sourceMappingURL=create-play-router-provider.js.map

package/dist/create-play-router-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-play-router-provider.js","names":["onCleanup","JSX","PlayActor","RouteMap","RouterBridge","PlayRouterBridgeConstructor","router","TRouter","actor","routeMap","PlayRouterProviderBaseProps","TActor","renderer","Element","createPlayRouterProvider","BridgeCtor","PlayRouterProvider","props","bridge","connect","disconnect","_$memo"],"sources":["../src/create-play-router-provider.tsx"],"sourcesContent":["/**\n * createPlayRouterProvider — factory for Solid `PlayRouterProvider` components\n *\n * Captures the provider component shape used by this package's\n * `PlayRouterProvider` — create a bridge synchronously at component evaluation\n * time, `connect()` it, and `disconnect()` in `onCleanup` — so that Solid\n * bridges with the standard `(router, actor, routeMap)` constructor can be\n * wrapped in a provider with a single call. Only the bridge class (and\n * therefore the `router` prop type) differs between providers created by this\n * factory.\n *\n * @packageDocumentation\n */\nimport { onCleanup, type JSX } from \"solid-js\";\nimport type { PlayActor, RouteMap, RouterBridge } from \"@xmachines/play-router\";\n\n/**\n * Constructor shape a bridge class must satisfy to be used with\n * `createPlayRouterProvider`: `(router, actor, routeMap) → RouterBridge`.\n *\n * Bridges with a different constructor shape (e.g. `SolidRouterBridge`, which\n * takes the hook results as separate arguments) are adapted with a thin\n * subclass that repackages the `router` prop.\n */\nexport type PlayRouterBridgeConstructor<TRouter> = new (\n\trouter: TRouter,\n\tactor: PlayActor,\n\trouteMap: RouteMap,\n) => RouterBridge;\n\n/**\n * Props shared by every factory-created Solid `PlayRouterProvider`.\n *\n * Adapter packages re-export a concrete alias with `TRouter` bound to their\n * router type (e.g. `SolidRouterHooks` in `@xmachines/play-solid-router`).\n */\nexport interface PlayRouterProviderBaseProps<TRouter, TActor extends PlayActor = PlayActor> {\n\t/** The actor to sync with the router. */\n\tactor: TActor;\n\t/** The router the bridge synchronizes with. */\n\trouter: TRouter;\n\t/** Bidirectional route map for state ID ↔ URL path lookups. */\n\trouteMap: RouteMap;\n\t/** Renderer callback receives the same concrete actor type that was passed in. */\n\trenderer: (actor: TActor, router: TRouter) => JSX.Element;\n}\n\n/**\n * Create a Solid `PlayRouterProvider` component bound to a specific bridge class.\n *\n * The returned component connects a `PlayerActor` to the framework router,\n * keeping actor state and browser URL in sync bidirectionally.\n *\n * The bridge is created synchronously at component evaluation time (Solid's\n * execution model) and torn down via `onCleanup` when the component is disposed.\n * Unlike React, prop stability is not a concern — Solid's `props` accessor is\n * already reactive and the bridge is created once per component instance.\n *\n * @param BridgeCtor - Bridge class constructed as `new BridgeCtor(router, actor, routeMap)`.\n * @returns A `PlayRouterProvider` component, generic over the actor type so the\n *   `renderer` callback receives the same concrete actor type that was passed in.\n *\n * @example\n * ```tsx\n * export const PlayRouterProvider = createPlayRouterProvider(MySolidRouterBridge);\n * ```\n */\nexport function createPlayRouterProvider<TRouter>(\n\tBridgeCtor: PlayRouterBridgeConstructor<TRouter>,\n) {\n\treturn function PlayRouterProvider<TActor extends PlayActor>(\n\t\tprops: PlayRouterProviderBaseProps<TRouter, TActor>,\n\t) {\n\t\tconst bridge = new BridgeCtor(props.router, props.actor, props.routeMap);\n\t\tvoid bridge.connect();\n\n\t\tonCleanup(() => {\n\t\t\tvoid bridge.disconnect();\n\t\t});\n\n\t\treturn <>{props.renderer(props.actor, props.router)}</>;\n\t};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,SAAgBc,yBACfC,YACC;CACD,OAAO,SAASC,mBACfC,OACC;EACD,MAAMC,SAAS,IAAIH,WAAWE,MAAMX,QAAQW,MAAMT,OAAOS,MAAMR,QAAQ;EACvE,OAAYU,QAAQ;EAEpBnB,gBAAgB;GACf,OAAYoB,WAAW;EACxB,CAAC;EAED,OAAAC,WAAUJ,MAAML,SAASK,MAAMT,OAAOS,MAAMX,MAAM,CAAC;CACpD;AACD"}

package/dist/index.js

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

package/dist/play-router-provider.js

@@ -0,0 +1,45 @@
+import { SolidRouterBridge } from "./solid-router-bridge.js";
+import { createPlayRouterProvider } from "./create-play-router-provider.js";
+//#region packages/play-solid-router/src/play-router-provider.tsx
+/**
+* Adapter binding `SolidRouterBridge`'s hook-argument constructor to the
+* `(router, actor, routeMap)` shape expected by `createPlayRouterProvider`.
+*/
+var SolidHooksRouterBridge = class extends SolidRouterBridge {
+	constructor(router, actor, routeMap) {
+		super(router.navigate, router.location, router.params, actor, routeMap);
+	}
+};
+/**
+* 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} />}
+*     />
+*   );
+* }
+* ```
+*/
+var PlayRouterProvider = createPlayRouterProvider(SolidHooksRouterBridge);
+//#endregion
+export { PlayRouterProvider };
+
+//# sourceMappingURL=play-router-provider.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"play-router-provider.js","names":["Navigator","Location","Params","PlayActor","RouteMap","SolidRouterBridge","createPlayRouterProvider","PlayRouterProviderBaseProps","RoutableActor","SolidRouterHooks","navigate","location","params","PlayRouterProviderProps","TActor","SolidHooksRouterBridge","constructor","router","actor","routeMap","PlayRouterProvider"],"sources":["../src/play-router-provider.tsx"],"sourcesContent":["/**\n * PlayRouterProvider — Solid convenience wrapper for SolidRouterBridge\n *\n * Created via the shared `createPlayRouterProvider` factory: the bridge is\n * created synchronously at component evaluation time and disconnected via\n * `onCleanup` when the component is disposed.\n */\nimport type { Navigator, Location, Params } from \"@solidjs/router\";\nimport type { PlayActor, RouteMap } from \"@xmachines/play-router\";\nimport { SolidRouterBridge } from \"./solid-router-bridge.js\";\nimport {\n\tcreatePlayRouterProvider,\n\ttype PlayRouterProviderBaseProps,\n} from \"./create-play-router-provider.js\";\n\nexport type { PlayActor };\n\n/** @deprecated Use `PlayActor` from `@xmachines/play-router`. Will be removed in the next major version. */\nexport type RoutableActor = PlayActor;\n\n/**\n * The three Solid Router hook results that `PlayRouterProvider` and `SolidRouterBridge`\n * require. Pass these directly from your component's hook calls:\n *\n * ```tsx\n * const navigate = useNavigate();   // → SolidRouterHooks.navigate\n * const location = useLocation();   // → SolidRouterHooks.location\n * const params   = useParams();     // → SolidRouterHooks.params\n * ```\n *\n * - `navigate` — used to push URL changes when the actor's `currentRoute` changes.\n * - `location` — `pathname` and `search` are read at `connect()` time for deep-link sync.\n *   Subsequent pathname changes drive router→actor sync via `createEffect`.\n * - `params` — Solid's pre-parsed path parameters for the current route segment. Used\n *   directly in `extractParams()` to avoid re-parsing with URLPattern.\n */\nexport type SolidRouterHooks = {\n\tnavigate: Navigator;\n\tlocation: Location;\n\tparams: Params;\n};\n\n/**\n * Props for the Solid Router `PlayRouterProvider`.\n *\n * `router` bundles the three Solid Router hook results that drive bidirectional\n * sync. Obtain these from `useNavigate()`, `useLocation()`, and `useParams()`\n * in the parent component (they must be called inside a router context).\n */\nexport interface PlayRouterProviderProps<\n\tTActor extends PlayActor = PlayActor,\n> extends PlayRouterProviderBaseProps<SolidRouterHooks, TActor> {}\n\n/**\n * Adapter binding `SolidRouterBridge`'s hook-argument constructor to the\n * `(router, actor, routeMap)` shape expected by `createPlayRouterProvider`.\n */\nclass SolidHooksRouterBridge extends SolidRouterBridge {\n\tconstructor(router: SolidRouterHooks, actor: PlayActor, routeMap: RouteMap) {\n\t\tsuper(router.navigate, router.location, router.params, actor, routeMap);\n\t}\n}\n\n/**\n * Connects a `PlayerActor` to Solid Router, keeping actor state and browser URL\n * in sync bidirectionally.\n *\n * The bridge is created synchronously at component evaluation time (Solid's\n * execution model) and torn down via `onCleanup` when the component is disposed.\n * Unlike React, prop stability is not a concern — Solid's `props` accessor is\n * already reactive and the bridge is created once per component instance.\n *\n * The `router` prop must be obtained from Solid Router hooks in the parent component:\n *\n * ```tsx\n * function AppShell() {\n *   const navigate = useNavigate();\n *   const location = useLocation();\n *   const params   = useParams();\n *\n *   return (\n *     <PlayRouterProvider\n *       actor={actor}\n *       routeMap={routeMap}\n *       router={{ navigate, location, params }}\n *       renderer={(a) => <PlayRenderer actor={a} registry={registry} />}\n *     />\n *   );\n * }\n * ```\n */\nexport const PlayRouterProvider = createPlayRouterProvider(SolidHooksRouterBridge);\n"],"mappings":";;;;;;;AAyDA,IAAMe,yBAAN,cAAqCV,kBAAkB;CACtDW,YAAYC,QAA0BC,OAAkBC,UAAoB;EAC3E,MAAMF,OAAOP,UAAUO,OAAON,UAAUM,OAAOL,QAAQM,OAAOC,QAAQ;CACvE;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAaC,qBAAqBd,yBAAyBS,sBAAsB"}

package/dist/solid-router-bridge.js

@@ -1,166 +1,167 @@
-/**
- * SolidJS Router bridge implementing RouterBridge protocol via RouterBridgeBase
- *
- * Extends RouterBridgeBase to handle all common lifecycle and sync logic.
- * 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()` 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
- * import { useNavigate, useLocation, useParams } from '@solidjs/router';
- * import { onCleanup } from 'solid-js';
- * import { SolidRouterBridge, RouteMap } from '@xmachines/play-solid-router';
- *
- * function App() {
- *   const navigate = useNavigate();
- *   const location = useLocation();
- *   const params = useParams();
- *
- *   const routeMap = new RouteMap([...]);
- *   const bridge = new SolidRouterBridge(navigate, location, params, actor, routeMap);
- *
- *   // connect() MUST be called inside a Solid reactive owner
- *   bridge.connect();
- *   onCleanup(() => bridge.disconnect());
- *
- *   return <div>...</div>;
- * }
- * ```
- */
 import { createEffect, createRoot, on } from "solid-js";
 import { RouterBridgeBase } from "@xmachines/play-router";
+//#region packages/play-solid-router/src/solid-router-bridge.ts
+/**
+* SolidJS Router bridge implementing RouterBridge protocol via RouterBridgeBase
+*
+* Extends RouterBridgeBase to handle all common lifecycle and sync logic.
+* 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()` 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
+* import { useNavigate, useLocation, useParams } from '@solidjs/router';
+* import { onCleanup } from 'solid-js';
+* import { SolidRouterBridge, RouteMap } from '@xmachines/play-solid-router';
+*
+* function App() {
+*   const navigate = useNavigate();
+*   const location = useLocation();
+*   const params = useParams();
+*
+*   const routeMap = new RouteMap([...]);
+*   const bridge = new SolidRouterBridge(navigate, location, params, actor, routeMap);
+*
+*   // connect() MUST be called inside a Solid reactive owner
+*   bridge.connect();
+*   onCleanup(() => bridge.disconnect());
+*
+*   return <div>...</div>;
+* }
+* ```
+*/
 /**
- * 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 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
-     *
-     * **CRITICAL:** `connect()` must be called inside a Solid component where hooks are available.
-     *
-     * @param solidNavigate - Result of useNavigate() hook
-     * @param location - Result of useLocation() 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) {
-        super(actor, {
-            getStateIdByPath: (path) => routeMap.getStateIdByPath(path),
-            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.
-     */
-    navigateRouter(path) {
-        this.solidNavigate(path);
-    }
-    /**
-     * Get the current router pathname for initial URL -> actor sync on connect.
-     */
-    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 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() {
-        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.
-     *
-     * 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() {
-        this.disposeRouterWatcher?.();
-        this.disposeRouterWatcher = null;
-    }
-    /**
-     * Dispose the bridge (alias for disconnect).
-     *
-     * @example
-     * ```tsx
-     * onCleanup(() => bridge.dispose());
-     * ```
-     */
-    dispose() {
-        this.disconnect();
-    }
-}
+* 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.
+*/
+var SolidRouterBridge = class 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
+	*
+	* **CRITICAL:** `connect()` must be called inside a Solid component where hooks are available.
+	*
+	* @param solidNavigate - Result of useNavigate() hook
+	* @param location - Result of useLocation() 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) {
+		super(actor, {
+			getStateIdByPath: (path) => routeMap.getStateIdByPath(path),
+			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] !== void 0 && entry[1] !== null && entry[1] !== "");
+		if (entries.length > 0) return Object.fromEntries(entries);
+		return super.extractParams(pathname, stateId);
+	}
+	/**
+	* Navigate SolidJS Router to the given path.
+	*/
+	navigateRouter(path) {
+		this.solidNavigate(path);
+	}
+	/**
+	* Get the current router pathname for initial URL -> actor sync on connect.
+	*/
+	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 || void 0;
+	}
+	/**
+	* Subscribe to SolidJS Router location changes using createEffect.
+	*
+	* 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() {
+		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.
+	*
+	* 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() {
+		this.disposeRouterWatcher?.();
+		this.disposeRouterWatcher = null;
+	}
+	/**
+	* Dispose the bridge (alias for disconnect).
+	*
+	* @example
+	* ```tsx
+	* onCleanup(() => bridge.dispose());
+	* ```
+	*/
+	dispose() {
+		this.disconnect();
+	}
+};
+//#endregion
+export { SolidRouterBridge };
+
 //# sourceMappingURL=solid-router-bridge.js.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAExD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAK1D;;;;;;;;;;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,KAAoB,EACpB,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"}
+{"version":3,"file":"solid-router-bridge.js","names":[],"sources":["../src/solid-router-bridge.ts"],"sourcesContent":["/**\n * SolidJS Router bridge implementing RouterBridge protocol via RouterBridgeBase\n *\n * Extends RouterBridgeBase to handle all common lifecycle and sync logic.\n * Uses Solid's native reactive primitives (createEffect) for router→actor direction.\n *\n * **IMPORTANT:** `connect()` MUST be called inside a Solid reactive owner (component\n * or createRoot). The `createEffect()` in `watchRouterChanges()` runs inside\n * `createRoot()`, which deliberately isolates it from any parent owner — automatic\n * cleanup on component unmount does NOT happen. You MUST call `disconnect()` (or\n * `dispose()`) explicitly, typically in `onCleanup()`.\n *\n * @example\n * ```tsx\n * import { useNavigate, useLocation, useParams } from '@solidjs/router';\n * import { onCleanup } from 'solid-js';\n * import { SolidRouterBridge, RouteMap } from '@xmachines/play-solid-router';\n *\n * function App() {\n *   const navigate = useNavigate();\n *   const location = useLocation();\n *   const params = useParams();\n *\n *   const routeMap = new RouteMap([...]);\n *   const bridge = new SolidRouterBridge(navigate, location, params, actor, routeMap);\n *\n *   // connect() MUST be called inside a Solid reactive owner\n *   bridge.connect();\n *   onCleanup(() => bridge.disconnect());\n *\n *   return <div>...</div>;\n * }\n * ```\n */\n\nimport { createEffect, createRoot, on } from \"solid-js\";\nimport type { Navigator, Params } from \"@solidjs/router\";\nimport { RouterBridgeBase } from \"@xmachines/play-router\";\nimport type { LocationLike } from \"@xmachines/play-router\";\nimport type { RoutableActor } from \"@xmachines/play-router\";\nimport type { RouteMap } from \"@xmachines/play-router\";\n\n/**\n * SolidJS Router integration bridge extending RouterBridgeBase\n *\n * Implements RouterBridge protocol for SolidJS Router using Solid's reactive\n * primitives. The actor→router direction uses TC39 Signal watcher (from base class).\n * The router→actor direction uses Solid's createEffect for native reactivity.\n *\n * Path parameters are extracted from Solid's `useParams()` reactive proxy rather than\n * re-parsing the URL with URLPattern. This means parameterized routes work without the\n * URLPattern polyfill — Solid's router has already extracted the values.\n */\nexport class SolidRouterBridge extends RouterBridgeBase {\n\tprivate disposeRouterWatcher: (() => void) | null = null;\n\n\t/**\n\t * Live reactive params object from Solid's `useParams()`.\n\t * Read inside the createEffect callback so it always reflects the current route.\n\t */\n\tprivate readonly solidParams: Params;\n\n\t/**\n\t * Create a SolidJS Router bridge\n\t *\n\t * **CRITICAL:** `connect()` must be called inside a Solid component where hooks are available.\n\t *\n\t * @param solidNavigate - Result of useNavigate() hook\n\t * @param location - Result of useLocation() hook\n\t * @param params - Result of useParams() hook — used directly for path parameter extraction,\n\t *   avoiding the URLPattern polyfill requirement for parameterized routes\n\t * @param actor - XMachines actor instance\n\t * @param routeMap - Bidirectional state ID ↔ path mapping\n\t */\n\tconstructor(\n\t\tprivate readonly solidNavigate: Navigator,\n\t\tprivate readonly location: LocationLike,\n\t\tparams: Params,\n\t\tactor: RoutableActor,\n\t\trouteMap: RouteMap,\n\t) {\n\t\tsuper(actor, {\n\t\t\tgetStateIdByPath: (path: string) => routeMap.getStateIdByPath(path),\n\t\t\tgetPathByStateId: (id: string) => routeMap.getPathByStateId(id),\n\t\t});\n\t\tthis.solidParams = params;\n\t}\n\n\t/**\n\t * Extract path parameters using Solid's pre-parsed `useParams()` values.\n\t *\n\t * Solid's router has already extracted all named parameters for the matched route\n\t * segment. Reading `this.solidParams` inside the createEffect callback that drives\n\t * `syncActorFromRouter` is safe — the reactive proxy always reflects the current\n\t * route at the time the effect runs.\n\t *\n\t * Falls back to URLPattern-based extraction (base class) only when Solid provided\n\t * no params for this route (i.e. the route has no `:param` segments).\n\t *\n\t * @param pathname - The actual URL path (unused — params already extracted by Solid)\n\t * @param stateId - The matched state ID (unused — params already extracted by Solid)\n\t * @returns Normalized path parameters with undefined/empty values filtered out\n\t */\n\tprotected override extractParams(pathname: string, stateId: string): Record<string, string> {\n\t\tconst entries = Object.entries(this.solidParams).filter(\n\t\t\t(entry): entry is [string, string] =>\n\t\t\t\tentry[1] !== undefined && entry[1] !== null && entry[1] !== \"\",\n\t\t);\n\t\tif (entries.length > 0) {\n\t\t\treturn Object.fromEntries(entries);\n\t\t}\n\t\t// No params from Solid — fall back to URLPattern for routes with no segments\n\t\treturn super.extractParams(pathname, stateId);\n\t}\n\n\t/**\n\t * Navigate SolidJS Router to the given path.\n\t */\n\tprotected navigateRouter(path: string): void {\n\t\tthis.solidNavigate(path);\n\t}\n\n\t/**\n\t * Get the current router pathname for initial URL -> actor sync on connect.\n\t */\n\tprotected override getInitialRouterPath(): string | null {\n\t\treturn this.location.pathname ?? null;\n\t}\n\n\t/**\n\t * Return the initial URL search string for query-param forwarding on `connect()`.\n\t *\n\t * Reads `this.location.search` from Solid's `useLocation()` reactive object —\n\t * the same source used by `getInitialRouterPath()`. An empty string (no query\n\t * params) returns `undefined` so `syncActorFromRouter` produces `query: {}`.\n\t */\n\tprotected override getInitialRouterSearch(): string | undefined {\n\t\treturn this.location.search || undefined;\n\t}\n\n\t/**\n\t * Subscribe to SolidJS Router location changes using createEffect.\n\t *\n\t * MUST be called inside a Solid reactive owner (component or createRoot).\n\t *\n\t * The effect runs inside `createRoot()` to give it a stable owner independent\n\t * of the calling component's lifecycle — this prevents the effect from being\n\t * disposed if the component re-renders while the bridge should stay active.\n\t * The trade-off is that component unmount does NOT automatically clean up the\n\t * effect; `disconnect()` (or `dispose()`) MUST be called explicitly to avoid a leak.\n\t */\n\tprotected watchRouterChanges(): void {\n\t\tthis.disposeRouterWatcher = createRoot((dispose) => {\n\t\t\tcreateEffect(\n\t\t\t\ton(\n\t\t\t\t\t() => this.location.pathname,\n\t\t\t\t\t(pathname: string) => {\n\t\t\t\t\t\tconst search = this.location.search ?? \"\";\n\t\t\t\t\t\tthis.syncActorFromRouter(pathname, search);\n\t\t\t\t\t},\n\t\t\t\t),\n\t\t\t);\n\t\t\treturn dispose;\n\t\t});\n\t}\n\n\t/**\n\t * Stop watching SolidJS Router changes.\n\t *\n\t * Calls the `dispose` function returned by `createRoot()` in `watchRouterChanges()`,\n\t * tearing down the reactive effect and freeing the isolated owner. This is the only\n\t * cleanup path — component unmount does NOT trigger this automatically.\n\t */\n\tprotected unwatchRouterChanges(): void {\n\t\tthis.disposeRouterWatcher?.();\n\t\tthis.disposeRouterWatcher = null;\n\t}\n\n\t/**\n\t * Dispose the bridge (alias for disconnect).\n\t *\n\t * @example\n\t * ```tsx\n\t * onCleanup(() => bridge.dispose());\n\t * ```\n\t */\n\tdispose(): void {\n\t\tthis.disconnect();\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,IAAa,oBAAb,cAAuC,iBAAiB;CAsBrC;CACA;CAtBlB,uBAAoD;;;;;CAMpD;;;;;;;;;;;;;CAcA,YACC,eACA,UACA,QACA,OACA,UACC;EACD,MAAM,OAAO;GACZ,mBAAmB,SAAiB,SAAS,iBAAiB,IAAI;GAClE,mBAAmB,OAAe,SAAS,iBAAiB,EAAE;EAC/D,CAAC;EATgB,KAAA,gBAAA;EACA,KAAA,WAAA;EASjB,KAAK,cAAc;CACpB;;;;;;;;;;;;;;;;CAiBA,cAAiC,UAAkB,SAAyC;EAC3F,MAAM,UAAU,OAAO,QAAQ,KAAK,WAAW,CAAC,CAAC,QAC/C,UACA,MAAM,OAAO,KAAA,KAAa,MAAM,OAAO,QAAQ,MAAM,OAAO,EAC9D;EACA,IAAI,QAAQ,SAAS,GACpB,OAAO,OAAO,YAAY,OAAO;EAGlC,OAAO,MAAM,cAAc,UAAU,OAAO;CAC7C;;;;CAKA,eAAyB,MAAoB;EAC5C,KAAK,cAAc,IAAI;CACxB;;;;CAKA,uBAAyD;EACxD,OAAO,KAAK,SAAS,YAAY;CAClC;;;;;;;;CASA,yBAAgE;EAC/D,OAAO,KAAK,SAAS,UAAU,KAAA;CAChC;;;;;;;;;;;;CAaA,qBAAqC;EACpC,KAAK,uBAAuB,YAAY,YAAY;GACnD,aACC,SACO,KAAK,SAAS,WACnB,aAAqB;IACrB,MAAM,SAAS,KAAK,SAAS,UAAU;IACvC,KAAK,oBAAoB,UAAU,MAAM;GAC1C,CACD,CACD;GACA,OAAO;EACR,CAAC;CACF;;;;;;;;CASA,uBAAuC;EACtC,KAAK,uBAAuB;EAC5B,KAAK,uBAAuB;CAC7B;;;;;;;;;CAUA,UAAgB;EACf,KAAK,WAAW;CACjB;AACD"}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@xmachines/play-solid-router",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "SolidJS Router adapter for XMachines Universal Player Architecture",
   "license": "MIT",
   "author": "XMachines Contributors",
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@gitlab.com/xmachin-es/xmachines-js.git",
+    "url": "git+https://gitlab.com/xmachin-es/xmachines-js.git",
     "directory": "packages/play-solid-router"
   },
   "files": [
@@ -22,13 +22,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc --build",
+    "build": "vite build && tsc --build",
     "lint": "oxlint .",
     "format": "oxfmt .",
     "test": "vitest",
@@ -36,22 +37,23 @@
     "clean": "rm -rf dist *.tsbuildinfo coverage node_modules/.svelte2tsx-* node_modules/.vite*"
   },
   "dependencies": {
-    "@xmachines/play": "1.1.0",
-    "@xmachines/play-actor": "1.1.0",
-    "@xmachines/play-router": "1.1.0",
-    "@xmachines/play-signals": "1.1.0"
+    "@xmachines/play": "2.0.0",
+    "@xmachines/play-actor": "2.0.0",
+    "@xmachines/play-router": "2.0.0",
+    "@xmachines/play-signals": "2.0.0"
   },
   "devDependencies": {
     "@solidjs/router": "^0.16.1",
     "@solidjs/testing-library": "^0.8.10",
     "@testing-library/jest-dom": "^6.9.1",
     "@types/node": "^26.2.0",
-    "@vitest/browser-playwright": "^4.1.10",
-    "@xmachines/play-xstate": "1.1.0",
+    "@vitest/browser-playwright": "^4.1.11",
+    "@xmachines/play-xstate": "2.0.0",
     "jsdom": "^29.1.0",
     "oxfmt": "^0.64.0",
     "oxlint": "^1.79.0",
     "solid-js": "^1.9.12",
+    "vite": "^8.0.10",
     "vite-plugin-solid": "^2.11.11",
     "vitest": "^4.1.11",
     "xstate": "^5.31.0"

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

@@ -1,45 +0,0 @@
-/**
- * createPlayRouterProvider — factory for Solid `PlayRouterProvider` components
- *
- * Captures the provider component shape used by this package's
- * `PlayRouterProvider` — create a bridge synchronously at component evaluation
- * time, `connect()` it, and `disconnect()` in `onCleanup` — so that Solid
- * bridges with the standard `(router, actor, routeMap)` constructor can be
- * wrapped in a provider with a single call. Only the bridge class (and
- * therefore the `router` prop type) differs between providers created by this
- * factory.
- *
- * @packageDocumentation
- */
-import { onCleanup } from "solid-js";
-/**
- * Create a Solid `PlayRouterProvider` component bound to a specific bridge class.
- *
- * The returned component connects a `PlayerActor` to the framework 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.
- *
- * @param BridgeCtor - Bridge class constructed as `new BridgeCtor(router, actor, routeMap)`.
- * @returns A `PlayRouterProvider` component, generic over the actor type so the
- *   `renderer` callback receives the same concrete actor type that was passed in.
- *
- * @example
- * ```tsx
- * export const PlayRouterProvider = createPlayRouterProvider(MySolidRouterBridge);
- * ```
- */
-export function createPlayRouterProvider(BridgeCtor) {
-    return function PlayRouterProvider(props) {
-        const bridge = new BridgeCtor(props.router, props.actor, props.routeMap);
-        void bridge.connect();
-        onCleanup(() => {
-            void bridge.disconnect();
-        });
-        return <>{props.renderer(props.actor, props.router)}</>;
-    };
-}
-//# sourceMappingURL=create-play-router-provider.jsx.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"create-play-router-provider.jsx","sourceRoot":"","sources":["../src/create-play-router-provider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,SAAS,EAAY,MAAM,UAAU,CAAC;AAkC/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,wBAAwB,CACvC,UAAgD;IAEhD,OAAO,SAAS,kBAAkB,CACjC,KAAmD;QAEnD,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;QACzE,KAAK,MAAM,CAAC,OAAO,EAAE,CAAC;QAEtB,SAAS,CAAC,GAAG,EAAE;YACd,KAAK,MAAM,CAAC,UAAU,EAAE,CAAC;QAC1B,CAAC,CAAC,CAAC;QAEH,OAAO,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC;IACzD,CAAC,CAAC;AACH,CAAC"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"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;AAO/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAK5E,OAAO,EACN,QAAQ,EACR,cAAc,GAGd,MAAM,wBAAwB,CAAC"}

package/dist/play-router-provider.jsx

@@ -1,41 +0,0 @@
-import { SolidRouterBridge } from "./solid-router-bridge.js";
-import { createPlayRouterProvider, } from "./create-play-router-provider.js";
-/**
- * Adapter binding `SolidRouterBridge`'s hook-argument constructor to the
- * `(router, actor, routeMap)` shape expected by `createPlayRouterProvider`.
- */
-class SolidHooksRouterBridge extends SolidRouterBridge {
-    constructor(router, actor, routeMap) {
-        super(router.navigate, router.location, router.params, actor, routeMap);
-    }
-}
-/**
- * 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 const PlayRouterProvider = createPlayRouterProvider(SolidHooksRouterBridge);
-//# sourceMappingURL=play-router-provider.jsx.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"play-router-provider.jsx","sourceRoot":"","sources":["../src/play-router-provider.tsx"],"names":[],"mappings":"AASA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EACN,wBAAwB,GAExB,MAAM,kCAAkC,CAAC;AAwC1C;;;GAGG;AACH,MAAM,sBAAuB,SAAQ,iBAAiB;IACrD,YAAY,MAAwB,EAAE,KAAgB,EAAE,QAAkB;QACzE,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;IACzE,CAAC;CACD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,wBAAwB,CAAC,sBAAsB,CAAC,CAAC"}

package/dist/types.js

@@ -1,5 +0,0 @@
-/**
- * Type definitions for @xmachines/play-solid-router
- */
-export {};
-//# sourceMappingURL=types.js.map

package/dist/types.js.map

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