@xmachines/play-solid-router 2.0.0 → 2.1.0

package/README.md

@@ -1,10 +1,8 @@
 # @xmachines/play-solid-router
 
-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`.
+SolidJS Router adapter for the XMachines Universal Player Architecture. It keeps the state machine routes of a `PlayerActor` and the browser URL in step, in both directions, through `@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-2.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-solid-router)
-
-Part of the [xmachines-js monorepo](../../README.md).
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-2.1.0-blue)](https://www.npmjs.com/package/@xmachines/play-solid-router)
 
 ## Installation
 
@@ -12,7 +10,7 @@ Part of the [xmachines-js monorepo](../../README.md).
 pnpm add @xmachines/play-solid-router
 ```
 
-**Peer dependencies** (must be installed separately):
+**Peer dependencies.** Install them separately:
 
 ```bash
 pnpm add solid-js @solidjs/router xstate
@@ -36,6 +34,10 @@ actor.start();
 
 const routeMap = createRouteMap(myMachine);
 
+// Minimal app shell stub — a real app renders PlayUIProvider + PlayRenderer from
+// @xmachines/play-solid here (see the workspace-only @xmachines/play-solid-demo Shell)
+const MyApp = (props: { actor: typeof actor }) => <main />;
+
 const Layout: ParentComponent = () => {
 	const navigate = useNavigate();
 	const location = useLocation();
@@ -62,7 +64,7 @@ export default function App() {
 
 ### `PlayRouterProvider`
 
-A SolidJS component that wires a `PlayerActor` to Solid Router. It creates and connects a `SolidRouterBridge` on mount and disconnects it via `onCleanup` on unmount.
+This SolidJS component connects a `PlayerActor` to Solid Router. It creates and connects a `SolidRouterBridge` on mount. It disconnects the bridge with `onCleanup` on unmount.
 
 ```tsx
 interface PlayRouterProviderProps<TActor extends PlayActor> {
@@ -83,14 +85,17 @@ interface PlayRouterProviderProps<TActor extends PlayActor> {
 
 ### `SolidRouterBridge`
 
-Low-level class for manual integration. Extends `RouterBridgeBase` from `@xmachines/play-router` and uses Solid's `createEffect` for reactive router→actor sync.
+The low-level class for a manual integration. It extends `RouterBridgeBase` from `@xmachines/play-router`. It uses the Solid `createEffect` to send each router change to the actor.
 
-> **Important:** `connect()` must be called inside a Solid reactive owner (component or `createRoot`). Cleanup is not automatic — call `disconnect()` (or `dispose()`) explicitly, typically in `onCleanup()`.
+> **Important:** call `connect()` inside a Solid reactive owner: a component, or `createRoot`. The bridge does not clean up by itself. Call `disconnect()` or `dispose()` yourself, usually in `onCleanup()`.
 
 ```tsx
-import { useNavigate, useLocation, useParams, onCleanup } from "@solidjs/router";
+import { useNavigate, useLocation, useParams } from "@solidjs/router";
+import { onCleanup } from "solid-js";
 import { SolidRouterBridge, RouteMap } from "@xmachines/play-solid-router";
 
+// actor: your started player (see the Quick Start above)
+
 function App() {
 	const navigate = useNavigate();
 	const location = useLocation();
@@ -111,7 +116,7 @@ function App() {
 
 ### `createRouteMap(machine)`
 
-Factory that builds a `RouteMap` directly from an XState machine definition. Re-exported from `@xmachines/play-router`.
+This factory builds a `RouteMap` directly from an XState machine definition. It comes from `@xmachines/play-router`.
 
 ```ts
 import { createRouteMap } from "@xmachines/play-solid-router";
@@ -121,7 +126,7 @@ const routeMap = createRouteMap(myMachine);
 
 ### `RouteMap` / `RouteMapping`
 
-Bidirectional state ID ↔ URL path mapping. Re-exported from `@xmachines/play-router`.
+The bidirectional map between the state IDs and the URL paths. It comes from `@xmachines/play-router`.
 
 ```ts
 import { RouteMap } from "@xmachines/play-solid-router";
@@ -135,22 +140,22 @@ const routeMap = new RouteMap([
 
 ### Types
 
-| Export                    | Description                                                                                                                                                                                             |
-| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `PlayActor`               | `AbstractActor & Routable & Viewable` — canonical actor shape from `@xmachines/play-router`. Required by `PlayRouterProvider`, which renders the current view spec in addition to synchronizing routes. |
-| `RoutableActor`           | Deprecated alias for `PlayActor`. Use `PlayActor` from `@xmachines/play-router` in new code.                                                                                                            |
-| `AbstractActor`           | Re-exported from `@xmachines/play-actor` for convenience when typing renderer callbacks.                                                                                                                |
-| `SolidRouterHooks`        | Shape of the `router` prop: `{ navigate, location, params }`                                                                                                                                            |
-| `PlayRouterProviderProps` | Full props interface for `PlayRouterProvider`                                                                                                                                                           |
-| `PlayRouteEvent`          | Event type sent to the actor on URL change (`play.route`)                                                                                                                                               |
-| `RouterBridge`            | Interface implemented by `SolidRouterBridge`                                                                                                                                                            |
-| `RouteMapOptions`         | Options bag for `RouteMap` construction. Re-exported from `@xmachines/play-router`.                                                                                                                     |
+| Export                    | Description                                                                                                                                                                                                    |
+| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `PlayActor`               | `AbstractActor & Routable & Viewable` — the canonical actor shape from `@xmachines/play-router`. `PlayRouterProvider` requires it, because it renders the current view spec and also keeps the routes in step. |
+| `RoutableActor`           | Deprecated alias for `PlayActor`. Use `PlayActor` from `@xmachines/play-router` in new code.                                                                                                                   |
+| `AbstractActor`           | It comes from `@xmachines/play-actor`. Use it for the type of a renderer callback.                                                                                                                             |
+| `SolidRouterHooks`        | Shape of the `router` prop: `{ navigate, location, params }`                                                                                                                                                   |
+| `PlayRouterProviderProps` | Full props interface for `PlayRouterProvider`                                                                                                                                                                  |
+| `PlayRouteEvent`          | The event type that the bridge sends to the actor on a URL change (`play.route`)                                                                                                                               |
+| `RouterBridge`            | The interface that `SolidRouterBridge` implements                                                                                                                                                              |
+| `RouteMapOptions`         | The options object for the `RouteMap` constructor. It comes from `@xmachines/play-router`.                                                                                                                     |
 
 ## Usage Patterns
 
 ### Protected Routes and Guards
 
-Auth guards live entirely inside the state machine, preventing flashes of unauthorized content:
+The auth guards are inside the state machine only. Unauthorized content therefore never appears, not even for a moment:
 
 ```ts
 const machineConfig = {
@@ -166,13 +171,13 @@ const machineConfig = {
 };
 ```
 
-When a user navigates to `/dashboard` while unauthenticated:
+A user navigates to `/dashboard`, and the user is not authenticated:
 
 1. Solid Router updates the URL.
-2. Bridge intercepts and sends `play.route` to the actor.
-3. Actor evaluates the guard — denies transition, moves to `login` instead.
-4. Bridge observes new actor route (`/login`) via TC39 Signal.
-5. Bridge calls `navigate("/login")`.
+2. The bridge receives the change and sends `play.route` to the actor.
+3. The actor evaluates the guard. The guard refuses the transition, and the actor moves to `login`.
+4. The bridge reads the new actor route (`/login`) from the TC39 Signal.
+5. The bridge calls `navigate("/login")`.
 
 ### Dynamic Routes with Parameters
 
@@ -186,7 +191,7 @@ const routeMap = new RouteMap([
 // { type: "play.route", to: "#post", params: { userId: "123", postId: "456" }, query: {} }
 ```
 
-Path parameters are extracted from Solid's reactive `useParams()` proxy — no URLPattern polyfill is needed for parameterized routes.
+The bridge reads the path parameters from the reactive `useParams()` proxy of Solid. A parameterized route therefore does not need the URLPattern polyfill.
 
 ## Testing
 
@@ -200,7 +205,7 @@ pnpm --filter @xmachines/play-solid-router test
 pnpm test
 ```
 
-**Browser tests** (`test/browser/**/*.browser.test.ts`) run against real Chromium via Playwright, covering async sequencing that jsdom cannot faithfully reproduce:
+**Browser tests** (`test/browser/**/*.browser.test.ts`) run in real Chromium through Playwright. They cover the asynchronous sequences that jsdom cannot reproduce:
 
 ```bash
 pnpm exec vitest --config vitest.browser.config.ts --project play-solid-router-browser

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

@@ -1,57 +1,58 @@
 /**
- * createPlayRouterProvider — factory for Solid `PlayRouterProvider` components
+ * createPlayRouterProvider — the factory of a Solid `PlayRouterProvider` component
  *
- * 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.
+ * The factory holds the shape of the provider component of this package: it creates a
+ * bridge synchronously, during the evaluation of the component, it calls `connect()`,
+ * and it calls `disconnect()` in `onCleanup`. One call therefore wraps each Solid
+ * bridge with the standard `(router, actor, routeMap)` constructor in a provider. The
+ * bridge class, and therefore the type of the `router` prop, is the one difference
+ * between two providers of this factory.
  *
  * @packageDocumentation
  */
 import { type JSX } from "solid-js";
 import type { PlayActor, RouteMap, RouterBridge } from "@xmachines/play-router";
 /**
- * Constructor shape a bridge class must satisfy to be used with
+ * The constructor shape that a bridge class must satisfy for
  * `createPlayRouterProvider`: `(router, actor, routeMap) → RouterBridge`.
  *
- * Bridges with a different constructor shape (e.g. `SolidRouterBridge`, which
- * takes the hook results as separate arguments) are adapted with a thin
- * subclass that repackages the `router` prop.
+ * A bridge with another constructor shape, for example `SolidRouterBridge`, which
+ * takes each hook result as a separate argument, receives a thin subclass. That
+ * subclass packs the `router` prop again.
  */
 export type PlayRouterBridgeConstructor<TRouter> = new (router: TRouter, actor: PlayActor, routeMap: RouteMap) => RouterBridge;
 /**
- * Props shared by every factory-created Solid `PlayRouterProvider`.
+ * The props that every Solid `PlayRouterProvider` of the factory shares.
  *
- * Adapter packages re-export a concrete alias with `TRouter` bound to their
- * router type (e.g. `SolidRouterHooks` in `@xmachines/play-solid-router`).
+ * An adapter package re-exports a concrete alias, with `TRouter` bound to the type of
+ * its router. For example, `SolidRouterHooks` in `@xmachines/play-solid-router`.
  */
 export interface PlayRouterProviderBaseProps<TRouter, TActor extends PlayActor = PlayActor> {
-    /** The actor to sync with the router. */
+    /** The actor to keep in step with the router. */
     actor: TActor;
-    /** The router the bridge synchronizes with. */
+    /** The router that the bridge keeps in step with the actor. */
     router: TRouter;
-    /** Bidirectional route map for state ID ↔ URL path lookups. */
+    /** The route map of both directions, for the lookup between a state ID and a URL path. */
     routeMap: RouteMap;
-    /** Renderer callback receives the same concrete actor type that was passed in. */
+    /** The renderer callback receives the same concrete actor type as the prop. */
     renderer: (actor: TActor, router: TRouter) => JSX.Element;
 }
 /**
- * Create a Solid `PlayRouterProvider` component bound to a specific bridge class.
+ * Creates a Solid `PlayRouterProvider` component of one bridge class.
  *
- * The returned component connects a `PlayerActor` to the framework router,
- * keeping actor state and browser URL in sync bidirectionally.
+ * The component of the return value connects a `PlayerActor` to the framework
+ * router. It keeps the actor state and the browser URL in step, in both directions.
  *
- * 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 component creates the bridge synchronously, during its own evaluation, because
+ * this is the execution model of Solid. It disconnects the bridge in `onCleanup`,
+ * when Solid disposes of the component. React is different: the stability of a prop
+ * is no concern here, because the `props` accessor of Solid is reactive already, and
+ * the component creates the bridge one time for each of its instances.
  *
- * @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.
+ * @param BridgeCtor - The bridge class. The provider builds it as `new BridgeCtor(router, actor, routeMap)`.
+ * @returns A `PlayRouterProvider` component. It is generic over the actor type.
+ *   Therefore the `renderer` callback receives the same concrete actor type as the
+ *   prop.
  *
  * @example
  * ```tsx

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

@@ -1 +1 @@
-{"version":3,"file":"create-play-router-provider.d.ts","sourceRoot":"","sources":["../src/create-play-router-provider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAa,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEhF;;;;;;;GAOG;AACH,MAAM,MAAM,2BAA2B,CAAC,OAAO,IAAI,KAClD,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,QAAQ,KACd,YAAY,CAAC;AAElB;;;;;GAKG;AACH,MAAM,WAAW,2BAA2B,CAAC,OAAO,EAAE,MAAM,SAAS,SAAS,GAAG,SAAS;IACzF,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,+CAA+C;IAC/C,MAAM,EAAE,OAAO,CAAC;IAChB,+DAA+D;IAC/D,QAAQ,EAAE,QAAQ,CAAC;IACnB,kFAAkF;IAClF,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,GAAG,CAAC,OAAO,CAAC;CAC1D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAC/C,UAAU,EAAE,2BAA2B,CAAC,OAAO,CAAC,IAEb,MAAM,SAAS,SAAS,EAC1D,OAAO,2BAA2B,CAAC,OAAO,EAAE,MAAM,CAAC,SAWpD"}
+{"version":3,"file":"create-play-router-provider.d.ts","sourceRoot":"","sources":["../src/create-play-router-provider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAa,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEhF;;;;;;;GAOG;AACH,MAAM,MAAM,2BAA2B,CAAC,OAAO,IAAI,KAClD,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,QAAQ,KACd,YAAY,CAAC;AAElB;;;;;GAKG;AACH,MAAM,WAAW,2BAA2B,CAAC,OAAO,EAAE,MAAM,SAAS,SAAS,GAAG,SAAS;IACzF,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,MAAM,EAAE,OAAO,CAAC;IAChB,0FAA0F;IAC1F,QAAQ,EAAE,QAAQ,CAAC;IACnB,+EAA+E;IAC/E,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,GAAG,CAAC,OAAO,CAAC;CAC1D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAC/C,UAAU,EAAE,2BAA2B,CAAC,OAAO,CAAC,IAEb,MAAM,SAAS,SAAS,EAC1D,OAAO,2BAA2B,CAAC,OAAO,EAAE,MAAM,CAAC,SAWpD"}

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

@@ -2,32 +2,33 @@ 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
+* createPlayRouterProvider — the factory of a Solid `PlayRouterProvider` component
 *
-* 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.
+* The factory holds the shape of the provider component of this package: it creates a
+* bridge synchronously, during the evaluation of the component, it calls `connect()`,
+* and it calls `disconnect()` in `onCleanup`. One call therefore wraps each Solid
+* bridge with the standard `(router, actor, routeMap)` constructor in a provider. The
+* bridge class, and therefore the type of the `router` prop, is the one difference
+* between two providers of this factory.
 *
 * @packageDocumentation
 */
 /**
-* Create a Solid `PlayRouterProvider` component bound to a specific bridge class.
+* Creates a Solid `PlayRouterProvider` component of one bridge class.
 *
-* The returned component connects a `PlayerActor` to the framework router,
-* keeping actor state and browser URL in sync bidirectionally.
+* The component of the return value connects a `PlayerActor` to the framework
+* router. It keeps the actor state and the browser URL in step, in both directions.
 *
-* 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 component creates the bridge synchronously, during its own evaluation, because
+* this is the execution model of Solid. It disconnects the bridge in `onCleanup`,
+* when Solid disposes of the component. React is different: the stability of a prop
+* is no concern here, because the `props` accessor of Solid is reactive already, and
+* the component creates the bridge one time for each of its instances.
 *
-* @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.
+* @param BridgeCtor - The bridge class. The provider builds it as `new BridgeCtor(router, actor, routeMap)`.
+* @returns A `PlayRouterProvider` component. It is generic over the actor type.
+*   Therefore the `renderer` callback receives the same concrete actor type as the
+*   prop.
 *
 * @example
 * ```tsx

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

@@ -1 +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"}
+{"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 — the factory of a Solid `PlayRouterProvider` component\n *\n * The factory holds the shape of the provider component of this package: it creates a\n * bridge synchronously, during the evaluation of the component, it calls `connect()`,\n * and it calls `disconnect()` in `onCleanup`. One call therefore wraps each Solid\n * bridge with the standard `(router, actor, routeMap)` constructor in a provider. The\n * bridge class, and therefore the type of the `router` prop, is the one difference\n * between two providers of this factory.\n *\n * @packageDocumentation\n */\nimport { onCleanup, type JSX } from \"solid-js\";\nimport type { PlayActor, RouteMap, RouterBridge } from \"@xmachines/play-router\";\n\n/**\n * The constructor shape that a bridge class must satisfy for\n * `createPlayRouterProvider`: `(router, actor, routeMap) → RouterBridge`.\n *\n * A bridge with another constructor shape, for example `SolidRouterBridge`, which\n * takes each hook result as a separate argument, receives a thin subclass. That\n * subclass packs the `router` prop again.\n */\nexport type PlayRouterBridgeConstructor<TRouter> = new (\n\trouter: TRouter,\n\tactor: PlayActor,\n\trouteMap: RouteMap,\n) => RouterBridge;\n\n/**\n * The props that every Solid `PlayRouterProvider` of the factory shares.\n *\n * An adapter package re-exports a concrete alias, with `TRouter` bound to the type of\n * its router. For example, `SolidRouterHooks` in `@xmachines/play-solid-router`.\n */\nexport interface PlayRouterProviderBaseProps<TRouter, TActor extends PlayActor = PlayActor> {\n\t/** The actor to keep in step with the router. */\n\tactor: TActor;\n\t/** The router that the bridge keeps in step with the actor. */\n\trouter: TRouter;\n\t/** The route map of both directions, for the lookup between a state ID and a URL path. */\n\trouteMap: RouteMap;\n\t/** The renderer callback receives the same concrete actor type as the prop. */\n\trenderer: (actor: TActor, router: TRouter) => JSX.Element;\n}\n\n/**\n * Creates a Solid `PlayRouterProvider` component of one bridge class.\n *\n * The component of the return value connects a `PlayerActor` to the framework\n * router. It keeps the actor state and the browser URL in step, in both directions.\n *\n * The component creates the bridge synchronously, during its own evaluation, because\n * this is the execution model of Solid. It disconnects the bridge in `onCleanup`,\n * when Solid disposes of the component. React is different: the stability of a prop\n * is no concern here, because the `props` accessor of Solid is reactive already, and\n * the component creates the bridge one time for each of its instances.\n *\n * @param BridgeCtor - The bridge class. The provider builds it as `new BridgeCtor(router, actor, routeMap)`.\n * @returns A `PlayRouterProvider` component. It is generic over the actor type.\n *   Therefore the `renderer` callback receives the same concrete actor type as the\n *   prop.\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,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.d.ts

@@ -1,11 +1,11 @@
 /**
  * @xmachines/play-solid-router
  *
- * SolidJS Router adapter for XMachines Universal Player Architecture
+ * SolidJS Router adapter for the XMachines Universal Player Architecture
  */
 export { SolidRouterBridge } from "./solid-router-bridge.js";
 export { PlayRouterProvider } from "./play-router-provider.js";
-export type { PlayRouterProviderProps, PlayActor, RoutableActor, // @deprecated — use PlayActor from @xmachines/play-router
+export type { PlayRouterProviderProps, PlayActor, RoutableActor, // @deprecated — use PlayActor of @xmachines/play-router
 SolidRouterHooks, } from "./play-router-provider.js";
 export { createPlayRouterProvider } from "./create-play-router-provider.js";
 export type { PlayRouterProviderBaseProps, PlayRouterBridgeConstructor, } from "./create-play-router-provider.js";

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,SAAS,EACT,aAAa,EAAE,0DAA0D;AACzE,gBAAgB,GAChB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,YAAY,EACX,2BAA2B,EAC3B,2BAA2B,GAC3B,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACN,QAAQ,EACR,cAAc,EACd,KAAK,YAAY,EACjB,KAAK,eAAe,GACpB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/D,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,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,SAAS,EACT,aAAa,EAAE,wDAAwD;AACvE,gBAAgB,GAChB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,YAAY,EACX,2BAA2B,EAC3B,2BAA2B,GAC3B,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACN,QAAQ,EACR,cAAc,EACd,KAAK,YAAY,EACjB,KAAK,eAAe,GACpB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/D,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC"}

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

@@ -1,19 +1,19 @@
 /**
- * PlayRouterProvider — Solid convenience wrapper for SolidRouterBridge
+ * PlayRouterProvider — the Solid wrapper of SolidRouterBridge
  *
- * Created via the shared `createPlayRouterProvider` factory: the bridge is
- * created synchronously at component evaluation time and disconnected via
- * `onCleanup` when the component is disposed.
+ * The shared `createPlayRouterProvider` factory makes this component: it creates the
+ * bridge synchronously, during the evaluation of the component, and it disconnects the
+ * bridge in `onCleanup`, when Solid disposes of the component.
  */
 import type { Navigator, Location, Params } from "@solidjs/router";
 import type { PlayActor } from "@xmachines/play-router";
 import { type PlayRouterProviderBaseProps } from "./create-play-router-provider.js";
 export type { PlayActor };
-/** @deprecated Use `PlayActor` from `@xmachines/play-router`. Will be removed in the next major version. */
+/** @deprecated Use `PlayActor` from `@xmachines/play-router`. The next major version removes this alias. */
 export type RoutableActor = PlayActor;
 /**
- * The three Solid Router hook results that `PlayRouterProvider` and `SolidRouterBridge`
- * require. Pass these directly from your component's hook calls:
+ * The three results of the Solid Router hooks that `PlayRouterProvider` and
+ * `SolidRouterBridge` need. Give them directly from the hook calls of your component:
  *
  * ```tsx
  * const navigate = useNavigate();   // → SolidRouterHooks.navigate
@@ -21,11 +21,11 @@ export type RoutableActor = PlayActor;
  * 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.
+ * - `navigate` — the bridge pushes each URL change with it, when the `currentRoute` of the actor changes.
+ * - `location` — the bridge reads `pathname` and `search` at the moment of `connect()`, for a deep link.
+ *   Each later change of the pathname then goes to the actor, through `createEffect`.
+ * - `params` — the path parameters of the current route segment, which Solid parsed already. The bridge
+ *   uses them directly in `extractParams()`, and it parses them not again with URLPattern.
  */
 export type SolidRouterHooks = {
     navigate: Navigator;
@@ -33,24 +33,25 @@ export type SolidRouterHooks = {
     params: Params;
 };
 /**
- * Props for the Solid Router `PlayRouterProvider`.
+ * The props of the `PlayRouterProvider` of Solid Router.
  *
- * `router` bundles 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` holds the three results of the Solid Router hooks that drive the work in
+ * both directions. Take them from `useNavigate()`, from `useLocation()`, and from
+ * `useParams()` in the parent component. Call each hook inside a router context.
  */
 export interface PlayRouterProviderProps<TActor extends PlayActor = PlayActor> extends PlayRouterProviderBaseProps<SolidRouterHooks, TActor> {
 }
 /**
- * Connects a `PlayerActor` to Solid Router, keeping actor state and browser URL
- * in sync bidirectionally.
+ * Connects a `PlayerActor` to Solid Router. It keeps the actor state and the browser
+ * URL in step, in both directions.
  *
- * 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 component creates the bridge synchronously, during its own evaluation, because
+ * this is the execution model of Solid. It disconnects the bridge in `onCleanup`,
+ * when Solid disposes of the component. React is different: the stability of a prop
+ * is no concern here, because the `props` accessor of Solid is reactive already, and
+ * the component creates the bridge one time for each of its instances.
  *
- * The `router` prop must be obtained from Solid Router hooks in the parent component:
+ * Take the `router` prop from the Solid Router hooks in the parent component:
  *
  * ```tsx
  * function AppShell() {

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;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAY,MAAM,wBAAwB,CAAC;AAElE,OAAO,EAEN,KAAK,2BAA2B,EAChC,MAAM,kCAAkC,CAAC;AAE1C,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B,4GAA4G;AAC5G,MAAM,MAAM,aAAa,GAAG,SAAS,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC9B,QAAQ,EAAE,SAAS,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB,CACvC,MAAM,SAAS,SAAS,GAAG,SAAS,CACnC,SAAQ,2BAA2B,CAAC,gBAAgB,EAAE,MAAM,CAAC;CAAG;AAYlE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,kBAAkB,iGAAmD,CAAC"}
+{"version":3,"file":"play-router-provider.d.ts","sourceRoot":"","sources":["../src/play-router-provider.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAY,MAAM,wBAAwB,CAAC;AAElE,OAAO,EAEN,KAAK,2BAA2B,EAChC,MAAM,kCAAkC,CAAC;AAE1C,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B,4GAA4G;AAC5G,MAAM,MAAM,aAAa,GAAG,SAAS,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC9B,QAAQ,EAAE,SAAS,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB,CACvC,MAAM,SAAS,SAAS,GAAG,SAAS,CACnC,SAAQ,2BAA2B,CAAC,gBAAgB,EAAE,MAAM,CAAC;CAAG;AAalE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,kBAAkB,iGAAmD,CAAC"}

package/dist/play-router-provider.js

@@ -2,8 +2,9 @@ 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`.
+* The adapter binds the constructor of `SolidRouterBridge`, which takes the hook
+* results, to the `(router, actor, routeMap)` shape of
+* `createPlayRouterProvider`.
 */
 var SolidHooksRouterBridge = class extends SolidRouterBridge {
 	constructor(router, actor, routeMap) {
@@ -11,15 +12,16 @@ var SolidHooksRouterBridge = class extends SolidRouterBridge {
 	}
 };
 /**
-* Connects a `PlayerActor` to Solid Router, keeping actor state and browser URL
-* in sync bidirectionally.
+* Connects a `PlayerActor` to Solid Router. It keeps the actor state and the browser
+* URL in step, in both directions.
 *
-* 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 component creates the bridge synchronously, during its own evaluation, because
+* this is the execution model of Solid. It disconnects the bridge in `onCleanup`,
+* when Solid disposes of the component. React is different: the stability of a prop
+* is no concern here, because the `props` accessor of Solid is reactive already, and
+* the component creates the bridge one time for each of its instances.
 *
-* The `router` prop must be obtained from Solid Router hooks in the parent component:
+* Take the `router` prop from the Solid Router hooks in the parent component:
 *
 * ```tsx
 * function AppShell() {

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

@@ -1 +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"}
+{"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 — the Solid wrapper of SolidRouterBridge\n *\n * The shared `createPlayRouterProvider` factory makes this component: it creates the\n * bridge synchronously, during the evaluation of the component, and it disconnects the\n * bridge in `onCleanup`, when Solid disposes of the component.\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`. The next major version removes this alias. */\nexport type RoutableActor = PlayActor;\n\n/**\n * The three results of the Solid Router hooks that `PlayRouterProvider` and\n * `SolidRouterBridge` need. Give them directly from the hook calls of your component:\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` — the bridge pushes each URL change with it, when the `currentRoute` of the actor changes.\n * - `location` — the bridge reads `pathname` and `search` at the moment of `connect()`, for a deep link.\n *   Each later change of the pathname then goes to the actor, through `createEffect`.\n * - `params` — the path parameters of the current route segment, which Solid parsed already. The bridge\n *   uses them directly in `extractParams()`, and it parses them not again with URLPattern.\n */\nexport type SolidRouterHooks = {\n\tnavigate: Navigator;\n\tlocation: Location;\n\tparams: Params;\n};\n\n/**\n * The props of the `PlayRouterProvider` of Solid Router.\n *\n * `router` holds the three results of the Solid Router hooks that drive the work in\n * both directions. Take them from `useNavigate()`, from `useLocation()`, and from\n * `useParams()` in the parent component. Call each hook inside a router context.\n */\nexport interface PlayRouterProviderProps<\n\tTActor extends PlayActor = PlayActor,\n> extends PlayRouterProviderBaseProps<SolidRouterHooks, TActor> {}\n\n/**\n * The adapter binds the constructor of `SolidRouterBridge`, which takes the hook\n * results, to the `(router, actor, routeMap)` shape of\n * `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. It keeps the actor state and the browser\n * URL in step, in both directions.\n *\n * The component creates the bridge synchronously, during its own evaluation, because\n * this is the execution model of Solid. It disconnects the bridge in `onCleanup`,\n * when Solid disposes of the component. React is different: the stability of a prop\n * is no concern here, because the `props` accessor of Solid is reactive already, and\n * the component creates the bridge one time for each of its instances.\n *\n * Take the `router` prop from the 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":";;;;;;;;AA0DA,IAAMe,yBAAN,cAAqCV,kBAAkB;CACtDW,YAAYC,QAA0BC,OAAkBC,UAAoB;EAC3E,MAAMF,OAAOP,UAAUO,OAAON,UAAUM,OAAOL,QAAQM,OAAOC,QAAQ;CACvE;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAaC,qBAAqBd,yBAAyBS,sBAAsB"}

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

@@ -1,14 +1,16 @@
 /**
- * SolidJS Router bridge implementing RouterBridge protocol via RouterBridgeBase
+ * The SolidJS Router bridge. It implements the RouterBridge protocol through RouterBridgeBase
  *
- * Extends RouterBridgeBase to handle all common lifecycle and sync logic.
- * Uses Solid's native reactive primitives (createEffect) for router→actor direction.
+ * The class extends RouterBridgeBase, and the base class does all the common
+ * lifecycle work and synchronization work. This class uses the native reactive
+ * primitives of Solid (createEffect) for the router-to-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()`.
+ * **IMPORTANT:** call `connect()` inside a Solid reactive owner: a component, or
+ * createRoot. The `createEffect()` call in `watchRouterChanges()` runs inside
+ * `createRoot()`, which keeps the effect separate from every parent owner on
+ * purpose. Therefore the effect does NOT clean up by itself when the component
+ * unmounts. You MUST call `disconnect()` or `dispose()` yourself, usually in
+ * `onCleanup()`.
  *
  * @example
  * ```tsx
@@ -24,7 +26,7 @@
  *   const routeMap = new RouteMap([...]);
  *   const bridge = new SolidRouterBridge(navigate, location, params, actor, routeMap);
  *
- *   // connect() MUST be called inside a Solid reactive owner
+ *   // Call connect() inside a Solid reactive owner
  *   bridge.connect();
  *   onCleanup(() => bridge.disconnect());
  *
@@ -38,97 +40,110 @@ import type { LocationLike } from "@xmachines/play-router";
 import type { RoutableActor } from "@xmachines/play-router";
 import type { RouteMap } from "@xmachines/play-router";
 /**
- * SolidJS Router integration bridge extending RouterBridgeBase
+ * The SolidJS Router integration bridge. It extends 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.
+ * The class implements the RouterBridge protocol for SolidJS Router with the
+ * reactive primitives of Solid. The actor-to-router direction uses the TC39 Signal
+ * watcher of the base class. The router-to-actor direction uses the Solid
+ * createEffect function for a 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.
+ * The bridge reads each path parameter from the reactive `useParams()` proxy of
+ * Solid. It does not parse the URL again with URLPattern. Therefore a
+ * parameterized route works without the URLPattern polyfill, because the router of
+ * Solid holds the values already.
  */
 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.
+     * The live reactive params object from the `useParams()` function of Solid.
+     * The bridge reads it inside the createEffect callback, so the value always shows
+     * the current route.
      */
     private readonly solidParams;
     /**
-     * Create a SolidJS Router bridge
+     * Creates a SolidJS Router bridge
      *
-     * **CRITICAL:** `connect()` must be called inside a Solid component where hooks are available.
+     * **CRITICAL:** call `connect()` inside a Solid component, where the 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
+     * @param solidNavigate - The result of the useNavigate() hook
+     * @param location - The result of the useLocation() hook
+     * @param params - The result of the useParams() hook. The bridge reads each path
+     *   parameter directly from it. A parameterized route therefore does not need the
+     *   URLPattern polyfill
+     * @param actor - The XMachines actor instance
+     * @param routeMap - The bidirectional map between the state IDs and the paths
      */
     constructor(solidNavigate: Navigator, location: LocationLike, params: Params, actor: RoutableActor, routeMap: RouteMap);
     /**
-     * Extract path parameters using Solid's pre-parsed `useParams()` values.
+     * Reads each path parameter from the values that `useParams()` of Solid parsed before.
      *
-     * 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.
+     * The router of Solid holds every named parameter of the matched route segment
+     * already. A read of `this.solidParams` inside the createEffect callback that
+     * drives `syncActorFromRouter` is safe, because the reactive proxy always shows the
+     * route of the moment when 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).
+     * The method returns to the URLPattern method of the base class only when Solid
+     * gives no param for this route, which means that the route has no `:param`
+     * segment.
      *
-     * @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
+     * @param pathname - The real URL path. The method does not use it, because Solid
+     *   parsed the params before
+     * @param stateId - The matched state ID. The method does not use it, because Solid
+     *   parsed the params before
+     * @returns The normalized path parameters, without an undefined value and without
+     *   an empty value
      */
     protected extractParams(pathname: string, stateId: string): Record<string, string>;
     /**
-     * Navigate SolidJS Router to the given path.
+     * Navigates SolidJS Router to the given path.
      */
     protected navigateRouter(path: string): void;
     /**
-     * Get the current router pathname for initial URL -> actor sync on connect.
+     * Returns the current pathname of the router, for the first URL-to-actor synchronization in connect().
      */
     protected getInitialRouterPath(): string | null;
     /**
-     * Return the initial URL search string for query-param forwarding on `connect()`.
+     * Returns the initial URL search string, so that `connect()` can forward the query params.
      *
-     * 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: {}`.
+     * The method reads `this.location.search` from the reactive `useLocation()` object
+     * of Solid, the same source as `getInitialRouterPath()`. For an empty string, which
+     * means no query param, it returns `undefined`. `syncActorFromRouter` then makes
+     * `query: {}`.
      */
     protected getInitialRouterSearch(): string | undefined;
     /**
-     * Subscribe to SolidJS Router location changes using createEffect.
+     * Subscribes to each location change of SolidJS Router with createEffect.
      *
-     * MUST be called inside a Solid reactive owner (component or createRoot).
+     * Call this method inside a Solid reactive owner: a 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.
+     * The effect runs inside `createRoot()`. The effect then has a stable owner, and
+     * that owner is separate from the lifecycle of the component that calls the method.
+     * Solid therefore does not dispose of the effect when the component renders again
+     * while the bridge must stay active. The cost is that the unmount of the component
+     * does NOT clean up the effect. Call `disconnect()` or `dispose()` yourself, or the
+     * effect stays in memory.
      */
     protected watchRouterChanges(): void;
     /**
-     * Stop watching SolidJS Router changes.
+     * Stops the watch of the 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.
+     * The method calls the `dispose` function that `createRoot()` returned in
+     * `watchRouterChanges()`. This removes the reactive effect and frees the separate
+     * owner. This is the only path that cleans up. The unmount of the component does
+     * NOT start it.
      */
     protected unwatchRouterChanges(): void;
     /**
-     * Dispose the bridge (alias for disconnect).
+     * Disposes of the bridge. This method is the alias of disconnect.
      *
      * @example
      * ```tsx
      * onCleanup(() => bridge.dispose());
      * ```
+     *
+     * @deprecated Use {@link RouterBridgeBase.disconnect | disconnect}. Will be removed in the next major.
      */
     dispose(): 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,MAAM,wBAAwB,CAAC;AAC5D,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,EACpB,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"}
+{"version":3,"file":"solid-router-bridge.d.ts","sourceRoot":"","sources":["../src/solid-router-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;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,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAkB,SAAQ,gBAAgB;IAwBrD,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAxB1B,OAAO,CAAC,oBAAoB,CAA6B;IAEzD;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IAErC;;;;;;;;;;;;OAYG;gBAEe,aAAa,EAAE,SAAS,EACxB,QAAQ,EAAE,YAAY,EACvC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,QAAQ;IASnB;;;;;;;;;;;;;;;;;;OAkBG;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;;;;;;;OAOG;cACgB,sBAAsB,IAAI,MAAM,GAAG,SAAS;IAI/D;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,kBAAkB,IAAI,IAAI;IAepC;;;;;;;OAOG;IACH,SAAS,CAAC,oBAAoB,IAAI,IAAI;IAKtC;;;;;;;;;OASG;IACH,OAAO,IAAI,IAAI;CAGf"}

package/dist/solid-router-bridge.js

@@ -2,16 +2,18 @@ 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
+* The SolidJS Router bridge. It implements the RouterBridge protocol through RouterBridgeBase
 *
-* Extends RouterBridgeBase to handle all common lifecycle and sync logic.
-* Uses Solid's native reactive primitives (createEffect) for router→actor direction.
+* The class extends RouterBridgeBase, and the base class does all the common
+* lifecycle work and synchronization work. This class uses the native reactive
+* primitives of Solid (createEffect) for the router-to-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()`.
+* **IMPORTANT:** call `connect()` inside a Solid reactive owner: a component, or
+* createRoot. The `createEffect()` call in `watchRouterChanges()` runs inside
+* `createRoot()`, which keeps the effect separate from every parent owner on
+* purpose. Therefore the effect does NOT clean up by itself when the component
+* unmounts. You MUST call `disconnect()` or `dispose()` yourself, usually in
+* `onCleanup()`.
 *
 * @example
 * ```tsx
@@ -27,7 +29,7 @@ import { RouterBridgeBase } from "@xmachines/play-router";
 *   const routeMap = new RouteMap([...]);
 *   const bridge = new SolidRouterBridge(navigate, location, params, actor, routeMap);
 *
-*   // connect() MUST be called inside a Solid reactive owner
+*   // Call connect() inside a Solid reactive owner
 *   bridge.connect();
 *   onCleanup(() => bridge.disconnect());
 *
@@ -36,36 +38,40 @@ import { RouterBridgeBase } from "@xmachines/play-router";
 * ```
 */
 /**
-* SolidJS Router integration bridge extending RouterBridgeBase
+* The SolidJS Router integration bridge. It extends 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.
+* The class implements the RouterBridge protocol for SolidJS Router with the
+* reactive primitives of Solid. The actor-to-router direction uses the TC39 Signal
+* watcher of the base class. The router-to-actor direction uses the Solid
+* createEffect function for a 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.
+* The bridge reads each path parameter from the reactive `useParams()` proxy of
+* Solid. It does not parse the URL again with URLPattern. Therefore a
+* parameterized route works without the URLPattern polyfill, because the router of
+* Solid holds the values already.
 */
 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.
+	* The live reactive params object from the `useParams()` function of Solid.
+	* The bridge reads it inside the createEffect callback, so the value always shows
+	* the current route.
 	*/
 	solidParams;
 	/**
-	* Create a SolidJS Router bridge
+	* Creates a SolidJS Router bridge
 	*
-	* **CRITICAL:** `connect()` must be called inside a Solid component where hooks are available.
+	* **CRITICAL:** call `connect()` inside a Solid component, where the 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
+	* @param solidNavigate - The result of the useNavigate() hook
+	* @param location - The result of the useLocation() hook
+	* @param params - The result of the useParams() hook. The bridge reads each path
+	*   parameter directly from it. A parameterized route therefore does not need the
+	*   URLPattern polyfill
+	* @param actor - The XMachines actor instance
+	* @param routeMap - The bidirectional map between the state IDs and the paths
 	*/
 	constructor(solidNavigate, location, params, actor, routeMap) {
 		super(actor, {
@@ -77,19 +83,23 @@ var SolidRouterBridge = class extends RouterBridgeBase {
 		this.solidParams = params;
 	}
 	/**
-	* Extract path parameters using Solid's pre-parsed `useParams()` values.
+	* Reads each path parameter from the values that `useParams()` of Solid parsed before.
 	*
-	* 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.
+	* The router of Solid holds every named parameter of the matched route segment
+	* already. A read of `this.solidParams` inside the createEffect callback that
+	* drives `syncActorFromRouter` is safe, because the reactive proxy always shows the
+	* route of the moment when 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).
+	* The method returns to the URLPattern method of the base class only when Solid
+	* gives no param for this route, which means that the route has no `:param`
+	* segment.
 	*
-	* @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
+	* @param pathname - The real URL path. The method does not use it, because Solid
+	*   parsed the params before
+	* @param stateId - The matched state ID. The method does not use it, because Solid
+	*   parsed the params before
+	* @returns The normalized path parameters, without an undefined value and without
+	*   an empty value
 	*/
 	extractParams(pathname, stateId) {
 		const entries = Object.entries(this.solidParams).filter((entry) => entry[1] !== void 0 && entry[1] !== null && entry[1] !== "");
@@ -97,37 +107,39 @@ var SolidRouterBridge = class extends RouterBridgeBase {
 		return super.extractParams(pathname, stateId);
 	}
 	/**
-	* Navigate SolidJS Router to the given path.
+	* Navigates SolidJS Router to the given path.
 	*/
 	navigateRouter(path) {
 		this.solidNavigate(path);
 	}
 	/**
-	* Get the current router pathname for initial URL -> actor sync on connect.
+	* Returns the current pathname of the router, for the first URL-to-actor synchronization in connect().
 	*/
 	getInitialRouterPath() {
 		return this.location.pathname ?? null;
 	}
 	/**
-	* Return the initial URL search string for query-param forwarding on `connect()`.
+	* Returns the initial URL search string, so that `connect()` can forward the query params.
 	*
-	* 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: {}`.
+	* The method reads `this.location.search` from the reactive `useLocation()` object
+	* of Solid, the same source as `getInitialRouterPath()`. For an empty string, which
+	* means no query param, it returns `undefined`. `syncActorFromRouter` then makes
+	* `query: {}`.
 	*/
 	getInitialRouterSearch() {
 		return this.location.search || void 0;
 	}
 	/**
-	* Subscribe to SolidJS Router location changes using createEffect.
+	* Subscribes to each location change of SolidJS Router with createEffect.
 	*
-	* MUST be called inside a Solid reactive owner (component or createRoot).
+	* Call this method inside a Solid reactive owner: a 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.
+	* The effect runs inside `createRoot()`. The effect then has a stable owner, and
+	* that owner is separate from the lifecycle of the component that calls the method.
+	* Solid therefore does not dispose of the effect when the component renders again
+	* while the bridge must stay active. The cost is that the unmount of the component
+	* does NOT clean up the effect. Call `disconnect()` or `dispose()` yourself, or the
+	* effect stays in memory.
 	*/
 	watchRouterChanges() {
 		this.disposeRouterWatcher = createRoot((dispose) => {
@@ -139,23 +151,26 @@ var SolidRouterBridge = class extends RouterBridgeBase {
 		});
 	}
 	/**
-	* Stop watching SolidJS Router changes.
+	* Stops the watch of the 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.
+	* The method calls the `dispose` function that `createRoot()` returned in
+	* `watchRouterChanges()`. This removes the reactive effect and frees the separate
+	* owner. This is the only path that cleans up. The unmount of the component does
+	* NOT start it.
 	*/
 	unwatchRouterChanges() {
 		this.disposeRouterWatcher?.();
 		this.disposeRouterWatcher = null;
 	}
 	/**
-	* Dispose the bridge (alias for disconnect).
+	* Disposes of the bridge. This method is the alias of disconnect.
 	*
 	* @example
 	* ```tsx
 	* onCleanup(() => bridge.dispose());
 	* ```
+	*
+	* @deprecated Use {@link RouterBridgeBase.disconnect | disconnect}. Will be removed in the next major.
 	*/
 	dispose() {
 		this.disconnect();

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"solid-router-bridge.js","names":[],"sources":["../src/solid-router-bridge.ts"],"sourcesContent":["/**\n * The SolidJS Router bridge. It implements the RouterBridge protocol through RouterBridgeBase\n *\n * The class extends RouterBridgeBase, and the base class does all the common\n * lifecycle work and synchronization work. This class uses the native reactive\n * primitives of Solid (createEffect) for the router-to-actor direction.\n *\n * **IMPORTANT:** call `connect()` inside a Solid reactive owner: a component, or\n * createRoot. The `createEffect()` call in `watchRouterChanges()` runs inside\n * `createRoot()`, which keeps the effect separate from every parent owner on\n * purpose. Therefore the effect does NOT clean up by itself when the component\n * unmounts. You MUST call `disconnect()` or `dispose()` yourself, usually in\n * `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 *   // Call connect() 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 * The SolidJS Router integration bridge. It extends RouterBridgeBase\n *\n * The class implements the RouterBridge protocol for SolidJS Router with the\n * reactive primitives of Solid. The actor-to-router direction uses the TC39 Signal\n * watcher of the base class. The router-to-actor direction uses the Solid\n * createEffect function for a native reactivity.\n *\n * The bridge reads each path parameter from the reactive `useParams()` proxy of\n * Solid. It does not parse the URL again with URLPattern. Therefore a\n * parameterized route works without the URLPattern polyfill, because the router of\n * Solid holds the values already.\n */\nexport class SolidRouterBridge extends RouterBridgeBase {\n\tprivate disposeRouterWatcher: (() => void) | null = null;\n\n\t/**\n\t * The live reactive params object from the `useParams()` function of Solid.\n\t * The bridge reads it inside the createEffect callback, so the value always shows\n\t * the current route.\n\t */\n\tprivate readonly solidParams: Params;\n\n\t/**\n\t * Creates a SolidJS Router bridge\n\t *\n\t * **CRITICAL:** call `connect()` inside a Solid component, where the hooks are available.\n\t *\n\t * @param solidNavigate - The result of the useNavigate() hook\n\t * @param location - The result of the useLocation() hook\n\t * @param params - The result of the useParams() hook. The bridge reads each path\n\t *   parameter directly from it. A parameterized route therefore does not need the\n\t *   URLPattern polyfill\n\t * @param actor - The XMachines actor instance\n\t * @param routeMap - The bidirectional map between the state IDs and the paths\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 * Reads each path parameter from the values that `useParams()` of Solid parsed before.\n\t *\n\t * The router of Solid holds every named parameter of the matched route segment\n\t * already. A read of `this.solidParams` inside the createEffect callback that\n\t * drives `syncActorFromRouter` is safe, because the reactive proxy always shows the\n\t * route of the moment when the effect runs.\n\t *\n\t * The method returns to the URLPattern method of the base class only when Solid\n\t * gives no param for this route, which means that the route has no `:param`\n\t * segment.\n\t *\n\t * @param pathname - The real URL path. The method does not use it, because Solid\n\t *   parsed the params before\n\t * @param stateId - The matched state ID. The method does not use it, because Solid\n\t *   parsed the params before\n\t * @returns The normalized path parameters, without an undefined value and without\n\t *   an empty value\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// Solid gives no param: use URLPattern for a route with no segment\n\t\treturn super.extractParams(pathname, stateId);\n\t}\n\n\t/**\n\t * Navigates 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 * Returns the current pathname of the router, for the first URL-to-actor synchronization in connect().\n\t */\n\tprotected override getInitialRouterPath(): string | null {\n\t\treturn this.location.pathname ?? null;\n\t}\n\n\t/**\n\t * Returns the initial URL search string, so that `connect()` can forward the query params.\n\t *\n\t * The method reads `this.location.search` from the reactive `useLocation()` object\n\t * of Solid, the same source as `getInitialRouterPath()`. For an empty string, which\n\t * means no query param, it returns `undefined`. `syncActorFromRouter` then makes\n\t * `query: {}`.\n\t */\n\tprotected override getInitialRouterSearch(): string | undefined {\n\t\treturn this.location.search || undefined;\n\t}\n\n\t/**\n\t * Subscribes to each location change of SolidJS Router with createEffect.\n\t *\n\t * Call this method inside a Solid reactive owner: a component, or createRoot.\n\t *\n\t * The effect runs inside `createRoot()`. The effect then has a stable owner, and\n\t * that owner is separate from the lifecycle of the component that calls the method.\n\t * Solid therefore does not dispose of the effect when the component renders again\n\t * while the bridge must stay active. The cost is that the unmount of the component\n\t * does NOT clean up the effect. Call `disconnect()` or `dispose()` yourself, or the\n\t * effect stays in memory.\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 * Stops the watch of the SolidJS Router changes.\n\t *\n\t * The method calls the `dispose` function that `createRoot()` returned in\n\t * `watchRouterChanges()`. This removes the reactive effect and frees the separate\n\t * owner. This is the only path that cleans up. The unmount of the component does\n\t * NOT start it.\n\t */\n\tprotected unwatchRouterChanges(): void {\n\t\tthis.disposeRouterWatcher?.();\n\t\tthis.disposeRouterWatcher = null;\n\t}\n\n\t/**\n\t * Disposes of the bridge. This method is the alias of disconnect.\n\t *\n\t * @example\n\t * ```tsx\n\t * onCleanup(() => bridge.dispose());\n\t * ```\n\t *\n\t * @deprecated Use {@link RouterBridgeBase.disconnect | disconnect}. Will be removed in the next major.\n\t */\n\tdispose(): void {\n\t\tthis.disconnect();\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,IAAa,oBAAb,cAAuC,iBAAiB;CAwBrC;CACA;CAxBlB,uBAAoD;;;;;;CAOpD;;;;;;;;;;;;;;CAeA,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;;;;;;;;;;;;;;;;;;;;CAqBA,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;;;;;;;;;CAUA,yBAAgE;EAC/D,OAAO,KAAK,SAAS,UAAU,KAAA;CAChC;;;;;;;;;;;;;CAcA,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;;;;;;;;;CAUA,uBAAuC;EACtC,KAAK,uBAAuB;EAC5B,KAAK,uBAAuB;CAC7B;;;;;;;;;;;CAYA,UAAgB;EACf,KAAK,WAAW;CACjB;AACD"}

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 /**
- * Type definitions for @xmachines/play-solid-router
+ * The type definitions of @xmachines/play-solid-router
  */
 export type { PlayRouteEvent, RouterBridge } from "@xmachines/play-router";
 export type { AbstractActor } from "@xmachines/play-actor";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-solid-router",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "SolidJS Router adapter for XMachines Universal Player Architecture",
   "license": "MIT",
   "author": "XMachines Contributors",
@@ -33,14 +33,15 @@
     "lint": "oxlint .",
     "format": "oxfmt .",
     "test": "vitest",
+    "test:coverage": "vitest run --coverage",
     "test:watch": "vitest",
     "clean": "rm -rf dist *.tsbuildinfo coverage node_modules/.svelte2tsx-* node_modules/.vite*"
   },
   "dependencies": {
-    "@xmachines/play": "2.0.0",
-    "@xmachines/play-actor": "2.0.0",
-    "@xmachines/play-router": "2.0.0",
-    "@xmachines/play-signals": "2.0.0"
+    "@xmachines/play": "2.1.0",
+    "@xmachines/play-actor": "2.1.0",
+    "@xmachines/play-router": "2.1.0",
+    "@xmachines/play-signals": "2.1.0"
   },
   "devDependencies": {
     "@solidjs/router": "^0.16.1",
@@ -48,7 +49,7 @@
     "@testing-library/jest-dom": "^6.9.1",
     "@types/node": "^26.2.0",
     "@vitest/browser-playwright": "^4.1.11",
-    "@xmachines/play-xstate": "2.0.0",
+    "@xmachines/play-xstate": "2.1.0",
     "jsdom": "^29.1.0",
     "oxfmt": "^0.64.0",
     "oxlint": "^1.79.0",