@xmachines/docs 3.0.0 → 5.0.0

package/api/@xmachines/play-solid/variables/ActorContext.md

@@ -6,7 +6,7 @@
 const ActorContext: Context<AnyPlayActor | null>;
 ```
 
-Defined in: [packages/play-solid/src/useActor.ts:38](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-solid/src/useActor.ts#L38)
+Defined in: [packages/play-solid/src/useActor.ts:45](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-solid/src/useActor.ts#L45)
 
 The SolidJS context of the actor. This package exports it, so that a consumer
 can use ActorContext.Provider directly for a custom composition (see D-11). The

package/api/@xmachines/play-solid/variables/ActorProvider.md

@@ -6,9 +6,9 @@
 const ActorProvider: Component<ActorProviderProps>;
 ```
 
-Defined in: [packages/play-solid/src/ActorProvider.tsx:226](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-solid/src/ActorProvider.tsx#L226)
+Defined in: [packages/play-solid/src/ActorProvider.tsx:225](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-solid/src/ActorProvider.tsx#L225)
 
-The ActorProvider component. It owns the actor bridge, the signal subscription, the
+The ActorProvider component. It owns the actor bridge, the atom subscription, the
 StateStore lifecycle, the resolution of the handlers, and the error boundary.
 
 D-11: this component replaces the old raw alias

package/api/@xmachines/play-solid/variables/PlayRenderer.md

@@ -6,7 +6,7 @@
 const PlayRenderer: Component;
 ```
 
-Defined in: [packages/play-solid/src/PlayRenderer.tsx:30](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-solid/src/PlayRenderer.tsx#L30)
+Defined in: [packages/play-solid/src/PlayRenderer.tsx:30](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-solid/src/PlayRenderer.tsx#L30)
 
 The leaf renderer without props. Put it inside an ActorProvider tree or a
 PlayUIProvider tree.

package/api/@xmachines/play-solid/variables/PlayUIProvider.md

@@ -6,7 +6,7 @@
 const PlayUIProvider: Component<PlayUIProviderProps>;
 ```
 
-Defined in: [packages/play-solid/src/PlayUIProvider.tsx:84](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-solid/src/PlayUIProvider.tsx#L84)
+Defined in: [packages/play-solid/src/PlayUIProvider.tsx:84](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-solid/src/PlayUIProvider.tsx#L84)
 
 The composite provider: ActorProvider and JSONUIProvider.
 

package/api/@xmachines/play-solid/variables/schema.md

@@ -0,0 +1,71 @@
+[API](../../../README.md) / [@xmachines/play-solid](../README.md) / schema
+
+# Variable: schema
+
+```ts
+const schema: _json_render_core.Schema<{
+	catalog: _json_render_core.SchemaType<
+		"object",
+		{
+			actions: _json_render_core.SchemaType<
+				"map",
+				{
+					description: _json_render_core.SchemaType<"string", unknown>;
+					params: _json_render_core.SchemaType<"zod", unknown>;
+				}
+			>;
+			components: _json_render_core.SchemaType<
+				"map",
+				{
+					description: _json_render_core.SchemaType<"string", unknown>;
+					example: _json_render_core.SchemaType<"any", unknown>;
+					props: _json_render_core.SchemaType<"zod", unknown>;
+					slots: _json_render_core.SchemaType<
+						"array",
+						_json_render_core.SchemaType<"string", unknown>
+					>;
+				}
+			>;
+		}
+	>;
+	spec: _json_render_core.SchemaType<
+		"object",
+		{
+			elements: _json_render_core.SchemaType<
+				"record",
+				_json_render_core.SchemaType<
+					"object",
+					{
+						children: _json_render_core.SchemaType<
+							"array",
+							_json_render_core.SchemaType<"string", unknown>
+						>;
+						props: _json_render_core.SchemaType<"propsOf", string>;
+						repeat: {
+							inner?: unknown;
+							kind: "any";
+							optional: true;
+						};
+						type: _json_render_core.SchemaType<"ref", string>;
+						visible: {
+							inner?: unknown;
+							kind: "any";
+							optional: true;
+						};
+					}
+				>
+			>;
+			root: _json_render_core.SchemaType<"string", unknown>;
+		}
+	>;
+}>;
+```
+
+Defined in: `@xmachines/json-render-solid`
+
+The schema for @xmachines/json-render-solid
+
+Defines:
+
+- Spec: A flat tree of elements with keys, types, props, and children references
+- Catalog: Components with props schemas, and optional actions

package/api/@xmachines/play-solid-router/README.md

@@ -4,34 +4,36 @@
 
 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-3.0.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-5.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-solid-router)
 
 ## Installation
 
 ```bash
-pnpm add @xmachines/play-solid-router
+pnpm add @xmachines/play-solid-router @xmachines/play-router
 ```
 
 **Peer dependencies.** Install them separately:
 
 ```bash
-pnpm add solid-js @solidjs/router xstate
+pnpm add solid-js @solidjs/router
 ```
 
 - `solid-js` `^1.8.0`
-- `@solidjs/router` `^0.16.1`
-- `xstate` `^5.31.0`
+- `@solidjs/router` `^0.16.1` or `^1.0.0`
 
 ## Quick Start
 
 ```tsx
 import { Router, Route, useNavigate, useLocation, useParams } from "@solidjs/router";
 import { onCleanup, type ParentComponent } from "solid-js";
-import { PlayRouterProvider, createRouteMap } from "@xmachines/play-solid-router";
-import { definePlayer } from "@xmachines/play-xstate";
+import { PlayRouterProvider } from "@xmachines/play-solid-router";
+import { createRouteMap } from "@xmachines/play-router/xstate";
+import { definePlayer, compose, PlayerActor } from "@xmachines/play-xstate";
+import { withRouting } from "@xmachines/play-xstate/routing";
 import { myMachine } from "./machine.js";
 
-const actor = definePlayer({ machine: myMachine })();
+// PlayRouterProvider needs the routing capability
+const actor = definePlayer({ machine: myMachine, actor: compose(PlayerActor, withRouting) })();
 actor.start();
 
 const routeMap = createRouteMap(myMachine);
@@ -69,7 +71,7 @@ export default function App() {
 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> {
+interface PlayRouterProviderProps<TActor extends RoutableActor> {
 	/** The actor to sync with Solid Router. */
 	actor: TActor;
 	/** Bidirectional route map for state ID ↔ URL path lookups. */
@@ -87,9 +89,9 @@ interface PlayRouterProviderProps<TActor extends PlayActor> {
 
 ### `SolidRouterBridge`
 
-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.
+The low-level class for a manual integration. It extends `RouterBridgeBase` from [`@xmachines/play-router`](../play-router/README.md). It uses the Solid `createEffect` to send each router change to the actor.
 
-> **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()`.
+> **Important:** call `connect()` inside a Solid reactive owner: a component, or `createRoot`. The bridge does not clean up by itself. Call `disconnect()` yourself, usually in `onCleanup()`.
 
 ```tsx
 import { useNavigate, useLocation, useParams } from "@solidjs/router";
@@ -116,19 +118,18 @@ function App() {
 }
 ```
 
-### `createRouteMap(machine)`
+### `createRouteMap(machine)` — from `@xmachines/play-router/xstate`
 
-This factory builds a `RouteMap` directly from an XState machine definition. It comes from `@xmachines/play-router`.
+This factory builds a `RouteMap` directly from an XState machine definition. This package re-exports it never: the barrel names no state machine.
 
 ```ts
-import { createRouteMap } from "@xmachines/play-solid-router";
-
+import { createRouteMap } from "@xmachines/play-router/xstate";
 const routeMap = createRouteMap(myMachine);
 ```
 
 ### `RouteMap` / `RouteMapping`
 
-The bidirectional map between the state IDs and the URL paths. It comes from `@xmachines/play-router`.
+The bidirectional map between the state IDs and the URL paths. It comes from [`@xmachines/play-router`](../play-router/README.md).
 
 ```ts
 import { RouteMap } from "@xmachines/play-solid-router";
@@ -142,16 +143,15 @@ const routeMap = new RouteMap([
 
 ### Types
 
-| 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`.                                                                                                                     |
+| Export                    | Description                                                                                                                                                                                                                                                                                                                                                              |
+| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `RoutableActor`           | `currentRoute`, `initialRoute` and `send`, from [`@xmachines/play-router`](../play-router/README.md). It names no view and no engine: routing implies no rendering. `PlayRouterProvider` constrains its actor to this shape, and a constraint keeps the concrete type whole, so a renderer callback that reads `currentView` still reports the exact spec of that actor. |
+| `PlayActor`               | It comes from [`@xmachines/play-actor`](../play-actor/README.md). 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`](../play-router/README.md).                                                                                                                                                                                                                                                   |
 
 ## Usage Patterns
 
@@ -178,7 +178,7 @@ A user navigates to `/dashboard`, and the user is not authenticated:
 1. Solid Router updates the URL.
 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.
+4. The bridge reads the new actor route (`/login`) from the atom.
 5. The bridge calls `navigate("/login")`.
 
 ### Dynamic Routes with Parameters
@@ -193,11 +193,12 @@ const routeMap = new RouteMap([
 // { type: "play.route", to: "#post", params: { userId: "123", postId: "456" }, query: {} }
 ```
 
-> **The polyfill is a question of the route map, and not of this bridge.** A `RouteMap`
-> that holds one parameterized route compiles it in the CONSTRUCTOR, and it throws a
-> `URLPatternUnavailableError` there when the runtime has no URLPattern. An application
-> with such a route therefore needs the polyfill at startup, whatever this bridge does.
-> Only a route map of static paths alone escapes it.
+> **A bad pattern is a question of the route map, and not of this bridge.** A `RouteMap`
+> that holds one parameterized route compiles it in the CONSTRUCTOR, and it throws an
+> `InvalidRoutePatternError` there for a pattern that URLPattern refuses. Such a route
+> therefore fails at startup, whatever this bridge does. You install no polyfill:
+> [`@xmachines/play-router`](../play-router/README.md) carries `urlpattern-polyfill` as an ordinary dependency and it
+> uses the native API when the runtime has one.
 
 What follows is about the CALLS that a navigation makes, which cost time and which the
 bridge avoids where the path already answers.
@@ -211,26 +212,6 @@ Two cases still read the params with URLPattern:
 
 A path that fills NO optional segment reaches URLPattern never. `/settings` against `/settings/:section?` is the bare form of the pattern, so the params are `{}` and the bridge reads that from the path alone.
 
-## Testing
-
-Run tests for this package in isolation:
-
-```bash
-# From the monorepo root
-pnpm --filter @xmachines/play-solid-router test
-
-# Or from this package directory
-pnpm test
-```
-
-**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
-```
-
-Coverage thresholds: **80%** lines, functions, branches, and statements.
-
 ## Related Packages
 
 - [@xmachines/play-router](../play-router/README.md) — core router primitives and `RouterBridgeBase`
@@ -253,10 +234,10 @@ MIT — see [LICENSE](LICENSE).
 
 ## Interfaces
 
-- [AbstractActor](interfaces/AbstractActor.md)
 - [PlayActor](interfaces/PlayActor.md)
 - [PlayRouteEvent](interfaces/PlayRouteEvent.md)
 - [PlayRouterProviderProps](interfaces/PlayRouterProviderProps.md)
+- [RoutableActor](interfaces/RoutableActor.md)
 - [RouteMapOptions](interfaces/RouteMapOptions.md)
 - [RouteMapping](interfaces/RouteMapping.md)
 - [RouterBridge](interfaces/RouterBridge.md)
@@ -265,7 +246,6 @@ MIT — see [LICENSE](LICENSE).
 
 - [PlayRouterBridgeConstructor](type-aliases/PlayRouterBridgeConstructor.md)
 - [PlayRouterProviderBaseProps](type-aliases/PlayRouterProviderBaseProps.md)
-- [~~RoutableActor~~](type-aliases/RoutableActor.md)
 - [SolidRouterHooks](type-aliases/SolidRouterHooks.md)
 
 ## Variables
@@ -275,4 +255,3 @@ MIT — see [LICENSE](LICENSE).
 ## Functions
 
 - [createPlayRouterProvider](functions/createPlayRouterProvider.md)
-- [createRouteMap](functions/createRouteMap.md)

package/api/@xmachines/play-solid-router/classes/RouteMap.md

@@ -2,7 +2,7 @@
 
 # Class: RouteMap
 
-Defined in: [packages/play-router/src/base-route-map.ts:105](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/base-route-map.ts#L105)
+Defined in: [play-router/src/base-route-map.ts:177](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/base-route-map.ts#L177)
 
 The shared base class of the route map for both directions.
 
@@ -14,15 +14,22 @@ of its own, and it inherits the complete public API from here.
 - A static path, without a `:param` → a `Map` lookup in O(1)
 - A dynamic path → a scan of the bucket index in O(k), with `URLPattern`, where
   `k` is the number of the routes with the same first path segment
-- The class keeps each result of a first match in an LRU cache. The default size
-  is 500 entries, and the `cacheSize` constructor option changes it
+- The class keeps each result of a first match in an LRU cache. The default cache
+  holds between 500 and 1000 entries, and the `pathCache` constructor option
+  replaces it
 
-**The syntax of a pattern** (`:param`, `:param?`, and `*`):
+**The syntax of a pattern:** the whole URLPattern pathname grammar. The forms used most
+often are:
 
 - `:param` — a necessary segment. It matches exactly one segment without a `/`
 - `:param?` — an optional segment. It matches zero segments or one segment without a `/`
 - `*` — a wildcard. It matches each number of segments, as URLPattern defines
 
+A `{…}` group, a `:param(\d+)` constraint, a `+` modifier and a `\:` escape are read
+too. The [routing guide](../../../../guides/routing.md) states every form, the prefix
+rule, and the one divergence from the standard: a param name of this library can hold a
+hyphen.
+
 **The forms of a stateId:** you can register a stateId, and you can look one up,
 in the form `"#stateId"` or in the form `"stateId"`. `RouteMap` makes the
 canonical form itself. `getStateIdByPath` returns the stateId exactly as you
@@ -58,7 +65,7 @@ map.getPathByStateId("missing"); // null
 new RouteMap(mappings, options?): RouteMap;
 ```
 
-Defined in: [packages/play-router/src/base-route-map.ts:133](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/base-route-map.ts#L133)
+Defined in: [play-router/src/base-route-map.ts:210](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/base-route-map.ts#L210)
 
 Builds a route map from an array of the mappings between a state ID and a path.
 
@@ -69,11 +76,10 @@ candidates is therefore efficient.
 
 #### Parameters
 
-| Parameter            | Type                                              | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| -------------------- | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `mappings`           | [`RouteMapping`](../interfaces/RouteMapping.md)[] | The array of the `{ stateId, path }` entries. The order gives the priority when more than one pattern can match the same path.                                                                                                                                                                                                                                                                                                                                                     |
-| `options`            | \{ `cacheSize?`: `number`; \}                     | The optional configuration. `options.cacheSize`: the maximum number of the resolved parameterized path lookups in the cache. The default is `500`. Raise it for an application with many different values in a parameterized URL, for example a page of a user profile with thousands of different IDs. After an eviction, the path goes to the bucket pattern scan in O(k) again, which is correct but slower. The smallest effective value is `1`, because QuickLRU requires it. |
-| `options.cacheSize?` | `number`                                          | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| Parameter  | Type                                                  | Description                                                                                                                                               |
+| ---------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mappings` | [`RouteMapping`](../interfaces/RouteMapping.md)[]     | The array of the `{ stateId, path }` entries. The order gives the priority when more than one pattern can match the same path.                            |
+| `options`  | [`RouteMapOptions`](../interfaces/RouteMapOptions.md) | See [RouteMapOptions](../interfaces/RouteMapOptions.md). A map holds TWO caches, so no option is named `cache`: each one names the cache that it carries. |
 
 #### Returns
 
@@ -87,7 +93,7 @@ candidates is therefore efficient.
 getPathByStateId(stateId): string | null;
 ```
 
-Defined in: [packages/play-router/src/base-route-map.ts:229](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/base-route-map.ts#L229)
+Defined in: [play-router/src/base-route-map.ts:324](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/base-route-map.ts#L324)
 
 Returns the path pattern of a state ID.
 
@@ -123,7 +129,7 @@ map.getPathByStateId("missing"); // null
 getStateIdByPath(path): string | null;
 ```
 
-Defined in: [packages/play-router/src/base-route-map.ts:189](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/base-route-map.ts#L189)
+Defined in: [play-router/src/base-route-map.ts:279](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/base-route-map.ts#L279)
 
 Resolves a URL path to its state ID.
 

package/api/@xmachines/play-solid-router/classes/SolidRouterBridge.md

@@ -2,12 +2,12 @@
 
 # Class: SolidRouterBridge
 
-Defined in: [packages/play-solid-router/src/solid-router-bridge.ts:71](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-solid-router/src/solid-router-bridge.ts#L71)
+Defined in: [play-solid-router/src/solid-router-bridge.ts:73](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-solid-router/src/solid-router-bridge.ts#L73)
 
 The SolidJS Router integration bridge. It extends RouterBridgeBase
 
 The class implements the RouterBridge protocol for SolidJS Router with the
-reactive primitives of Solid. The actor-to-router direction uses the TC39 Signal
+reactive primitives of Solid. The actor-to-router direction uses the atom
 watcher of the base class. The router-to-actor direction uses the Solid
 createEffect function for a native reactivity.
 
@@ -17,14 +17,16 @@ it. Two cases still reach it: a bridge under a `basePath`, where Solid matched a
 of the HOST and its params describe the route of the machine never, and a location
 that fills a segment of the pattern while Solid reports none of its names.
 
-This is about the CALLS, and not about the polyfill. A `RouteMap` that holds one
-parameterized route compiles it in the constructor and throws there without
-URLPattern, so an application with such a route needs the polyfill whatever this
-bridge does. See the `extractParams` override of this class.
+This is about the CALLS that a navigation makes, and not about the availability of the
+API. `@xmachines/play-router` carries `urlpattern-polyfill` as an ordinary dependency
+and it uses the native URLPattern when the runtime has one, so the API is present
+whatever this bridge does. A BAD pattern is a question of the route map: `RouteMap`
+compiles each parameterized route in its constructor and throws an
+`InvalidRoutePatternError` there. See the `extractParams` override of this class.
 
 ## Extends
 
-- [`RouterBridgeBase`](../../play-router/classes/RouterBridgeBase.md)
+- [`RouterBridgeBase`](../../play-router/index/classes/RouterBridgeBase.md)
 
 ## Constructors
 
@@ -37,10 +39,11 @@ new SolidRouterBridge(
    params,
    actor,
    routeMap,
-   options?): SolidRouterBridge;
+   options?
+): SolidRouterBridge;
 ```
 
-Defined in: [packages/play-solid-router/src/solid-router-bridge.ts:94](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-solid-router/src/solid-router-bridge.ts#L94)
+Defined in: [play-solid-router/src/solid-router-bridge.ts:96](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-solid-router/src/solid-router-bridge.ts#L96)
 
 Creates a SolidJS Router bridge
 
@@ -48,14 +51,14 @@ Creates a SolidJS Router bridge
 
 #### Parameters
 
-| Parameter       | Type                                                                     | Description                                                                                                                                                      |
-| --------------- | ------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `solidNavigate` | `Navigator`                                                              | The result of the useNavigate() hook                                                                                                                             |
-| `location`      | [`LocationLike`](../../play-router/interfaces/LocationLike.md)           | The result of the useLocation() hook                                                                                                                             |
-| `params`        | `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 |
-| `actor`         | [`RoutableActor`](../../play-dom-router/interfaces/RoutableActor.md)     | The XMachines actor instance                                                                                                                                     |
-| `routeMap`      | [`RouteMap`](RouteMap.md)                                                | The bidirectional map between the state IDs and the paths                                                                                                        |
-| `options?`      | [`BasePathOptions`](../../play-dom-router/interfaces/BasePathOptions.md) | -                                                                                                                                                                |
+| Parameter       | Type                                                                               | Description                                                                                                                                                    |
+| --------------- | ---------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `solidNavigate` | `Navigator`                                                                        | The result of the useNavigate() hook                                                                                                                           |
+| `location`      | [`LocationLike`](../../play-router/index/interfaces/LocationLike.md)               | The result of the useLocation() hook                                                                                                                           |
+| `params`        | `Params`                                                                           | The result of the useParams() hook. The bridge reads each path parameter directly from it. A parameterized route therefore runs no URLPattern match of its own |
+| `actor`         | [`RoutableActor`](../interfaces/RoutableActor.md)                                  | The XMachines actor instance                                                                                                                                   |
+| `routeMap`      | [`RouteMap`](RouteMap.md)                                                          | The bidirectional map between the state IDs and the paths                                                                                                      |
+| `options?`      | [`RouterBridgeOptions`](../../play-router/index/interfaces/RouterBridgeOptions.md) | -                                                                                                                                                              |
 
 #### Returns
 
@@ -63,7 +66,7 @@ Creates a SolidJS Router bridge
 
 #### Overrides
 
-[`RouterBridgeBase`](../../play-router/classes/RouterBridgeBase.md).[`constructor`](../../play-router/classes/RouterBridgeBase.md#constructor)
+[`RouterBridgeBase`](../../play-router/index/classes/RouterBridgeBase.md).[`constructor`](../../play-router/index/classes/RouterBridgeBase.md#constructor)
 
 ## Accessors
 
@@ -75,7 +78,7 @@ Creates a SolidJS Router bridge
 get basePath(): string;
 ```
 
-Defined in: [packages/play-router/src/router-bridge-base.ts:255](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/router-bridge-base.ts#L255)
+Defined in: [play-router/src/router-bridge-base.ts:282](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/router-bridge-base.ts#L282)
 
 The resolved URL prefix that the machine of this bridge is mounted under, or `""`
 when the machine owns the complete router.
@@ -88,7 +91,7 @@ The resolved URL prefix of the mount, or `""` when the machine owns the complete
 
 #### Inherited from
 
-[`RouterBridgeBase`](../../play-router/classes/RouterBridgeBase.md).[`basePath`](../../play-router/classes/RouterBridgeBase.md#basepath)
+[`RouterBridgeBase`](../../play-router/index/classes/RouterBridgeBase.md).[`basePath`](../../play-router/index/classes/RouterBridgeBase.md#basepath)
 
 ---
 
@@ -100,7 +103,7 @@ The resolved URL prefix of the mount, or `""` when the machine owns the complete
 get basePathParams(): Readonly<Record<string, string>>;
 ```
 
-Defined in: [packages/play-router/src/router-bridge-base.ts:284](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/router-bridge-base.ts#L284)
+Defined in: [play-router/src/router-bridge-base.ts:311](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/router-bridge-base.ts#L311)
 
 The resolved values of the `:param` segments of the mount, or `{}` for a prefix
 without a param.
@@ -141,7 +144,7 @@ mount while the machine stays on the same route, and no event goes out.
 
 #### Inherited from
 
-[`RouterBridgeBase`](../../play-router/classes/RouterBridgeBase.md).[`basePathParams`](../../play-router/classes/RouterBridgeBase.md#basepathparams)
+[`RouterBridgeBase`](../../play-router/index/classes/RouterBridgeBase.md).[`basePathParams`](../../play-router/index/classes/RouterBridgeBase.md#basepathparams)
 
 ## Methods
 
@@ -151,11 +154,11 @@ mount while the machine stays on the same route, and no event goes out.
 connect(): void;
 ```
 
-Defined in: [packages/play-router/src/router-bridge-base.ts:506](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/router-bridge-base.ts#L506)
+Defined in: [play-router/src/router-bridge-base.ts:533](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/router-bridge-base.ts#L533)
 
 Connects the router bridge to the Actor.
 
-The method installs the TC39 Signal watcher of the direction from the actor to the
+The method installs the atom watcher of the direction from the actor to the
 router. It then starts the watch of the router changes, which each framework does
 in its own way.
 
@@ -175,7 +178,7 @@ An adapter that needs a different behavior of the first synchronization override
 
 #### Inherited from
 
-[`RouterBridgeBase`](../../play-router/classes/RouterBridgeBase.md).[`connect`](../../play-router/classes/RouterBridgeBase.md#connect)
+[`RouterBridgeBase`](../../play-router/index/classes/RouterBridgeBase.md).[`connect`](../../play-router/index/classes/RouterBridgeBase.md#connect)
 
 ---
 
@@ -185,11 +188,11 @@ An adapter that needs a different behavior of the first synchronization override
 disconnect(): void;
 ```
 
-Defined in: [packages/play-router/src/router-bridge-base.ts:728](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/router-bridge-base.ts#L728)
+Defined in: [play-router/src/router-bridge-base.ts:791](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/router-bridge-base.ts#L791)
 
 Disconnects the router bridge from the Actor.
 
-The method stops the watch of the signal, and it removes the router listener of the
+The method stops the watch of the atom, and it removes the router listener of the
 framework.
 
 #### Returns
@@ -198,33 +201,7 @@ framework.
 
 #### Inherited from
 
-[`RouterBridgeBase`](../../play-router/classes/RouterBridgeBase.md).[`disconnect`](../../play-router/classes/RouterBridgeBase.md#disconnect)
-
----
-
-### ~~dispose()~~
-
-```ts
-dispose(): void;
-```
-
-Defined in: [packages/play-solid-router/src/solid-router-bridge.ts:256](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-solid-router/src/solid-router-bridge.ts#L256)
-
-Disposes of the bridge. This method is the alias of disconnect.
-
-#### Returns
-
-`void`
-
-#### Example
-
-```tsx
-onCleanup(() => bridge.dispose());
-```
-
-#### Deprecated
-
-Use [disconnect](#disconnect). Will be removed in the next major.
+[`RouterBridgeBase`](../../play-router/index/classes/RouterBridgeBase.md).[`disconnect`](../../play-router/index/classes/RouterBridgeBase.md#disconnect)
 
 ---
 
@@ -234,7 +211,7 @@ Use [disconnect](#disconnect). Will be removed in the next major.
 setBasePath(basePath?, basePathParams?): void;
 ```
 
-Defined in: [packages/play-router/src/router-bridge-base.ts:324](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/router-bridge-base.ts#L324)
+Defined in: [play-router/src/router-bridge-base.ts:351](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/router-bridge-base.ts#L351)
 
 Moves the machine to a different mount point, while it stays connected.
 
@@ -286,4 +263,4 @@ bridge.setBasePath("/:region/:machineId/play", { region: "us", machineId });
 
 #### Inherited from
 
-[`RouterBridgeBase`](../../play-router/classes/RouterBridgeBase.md).[`setBasePath`](../../play-router/classes/RouterBridgeBase.md#setbasepath)
+[`RouterBridgeBase`](../../play-router/index/classes/RouterBridgeBase.md).[`setBasePath`](../../play-router/index/classes/RouterBridgeBase.md#setbasepath)