@xmachines/docs 2.2.0 → 4.0.0

package/api/@xmachines/play-tanstack-react-router/functions/createPlayRouterProvider.md

@@ -3,24 +3,27 @@
 # Function: createPlayRouterProvider()
 
 ```ts
-function createPlayRouterProvider<TRouter>(BridgeCtor): <TActor>(__namedParameters) => Element;
+function createPlayRouterProvider<TRouter, TActorBase>(
+	BridgeCtor,
+): <TActor>(__namedParameters) => Element;
 ```
 
-Defined in: [play-tanstack-react-router/src/create-play-router-provider.tsx:52](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-tanstack-react-router/src/create-play-router-provider.tsx#L52)
+Defined in: [play-tanstack-react-router/src/create-play-router-provider.tsx:52](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-tanstack-react-router/src/create-play-router-provider.tsx#L52)
 
 Builds a `PlayRouterProvider` for one React bridge class.
 
 ## Type Parameters
 
-| Type Parameter |
-| -------------- |
-| `TRouter`      |
+| Type Parameter                                                           | Default type                                      |
+| ------------------------------------------------------------------------ | ------------------------------------------------- |
+| `TRouter`                                                                | -                                                 |
+| `TActorBase` _extends_ [`RoutableActor`](../interfaces/RoutableActor.md) | [`RoutableActor`](../interfaces/RoutableActor.md) |
 
 ## Parameters
 
-| Parameter    | Type                                                                                         | Description                                                                    |
-| ------------ | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
-| `BridgeCtor` | [`PlayRouterBridgeConstructor`](../type-aliases/PlayRouterBridgeConstructor.md)\<`TRouter`\> | The bridge class, built as `new BridgeCtor(router, actor, routeMap, options)`. |
+| Parameter    | Type                                                                                                       | Description                                                                    |
+| ------------ | ---------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
+| `BridgeCtor` | [`PlayRouterBridgeConstructor`](../type-aliases/PlayRouterBridgeConstructor.md)\<`TRouter`, `TActorBase`\> | The bridge class, built as `new BridgeCtor(router, actor, routeMap, options)`. |
 
 ## Returns
 

package/api/@xmachines/play-tanstack-react-router/functions/createRouteMapFromTree.md

@@ -6,12 +6,13 @@
 function createRouteMapFromTree(routeTree, options?): RouteMap;
 ```
 
-Defined in: [play-router/src/create-route-map-from-tree.ts:33](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/create-route-map-from-tree.ts#L33)
+Defined in: [play-router/src/create-route-map-from-tree.ts:40](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/create-route-map-from-tree.ts#L40)
 
 Creates a `RouteMap` from the node structure of a `RouteTree`.
 
-A framework router adapter uses this function when it gives a `RouteTree` from
-`extractMachineRoutes()`, and not when it calls `createRouteMap()` directly.
+A framework router adapter uses this function when it holds a `RouteTree`, for example
+from `extractMachineRoutes()` of `@xmachines/play-router/xstate`, and not when it calls
+`createRouteMap()` of that package directly.
 
 The function walks every node, and it collects the pairs
 `{ stateId: node.id, path: node.fullPath }`. `node.fullPath` is always the
@@ -19,12 +20,17 @@ absolute resolved path, for example `"/dashboard/overview"`, and `RouteMap` need
 that path for the match of a browser URL. `createRouteMap(machine)` behaves in the
 same way, because it also uses `node.fullPath`.
 
+The walk SKIPS the synthetic root node. `buildRouteTree` makes that node to hold each
+absolute route, and no state of a machine declares it. `createRouteMap` skips it as
+well, through `getRoutableRoutes`, and the two functions therefore answer the same map
+for the same tree.
+
 ## Parameters
 
-| Parameter   | Type                                                     | Description                                                                                  |
-| ----------- | -------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
-| `routeTree` | [`RouteTree`](../../play-router/interfaces/RouteTree.md) | A `RouteTree`, as `extractMachineRoutes()` returns it.                                       |
-| `options?`  | [`RouteMapOptions`](../interfaces/RouteMapOptions.md)    | The optional configuration, for example `{ cacheSize }` to change the size of the LRU cache. |
+| Parameter   | Type                                                           | Description                                                                                  |
+| ----------- | -------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| `routeTree` | [`RouteTree`](../../play-router/index/interfaces/RouteTree.md) | A `RouteTree`, as `extractMachineRoutes()` returns it.                                       |
+| `options?`  | [`RouteMapOptions`](../interfaces/RouteMapOptions.md)          | The optional configuration, for example `{ cacheSize }` to change the size of the LRU cache. |
 
 ## Returns
 
@@ -36,11 +42,12 @@ A `RouteMap` for each adapter on `RouterBridgeBase`.
 
 ```typescript
 // The preferred form — one call for an XState machine:
-import { createRouteMap } from "@xmachines/play-router";
+import { createRouteMap } from "@xmachines/play-router/xstate";
 const routeMap = createRouteMap(machine); // it takes an AnyStateMachine
 
 // The two-step form, for a framework adapter that works with a route tree:
-import { extractMachineRoutes, createRouteMapFromTree } from "@xmachines/play-router";
+import { createRouteMapFromTree } from "@xmachines/play-router";
+import { extractMachineRoutes } from "@xmachines/play-router/xstate";
 const routeTree = extractMachineRoutes(machine);
 const routeMap = createRouteMapFromTree(routeTree); // it uses node.fullPath, which is absolute
 ```

package/api/@xmachines/play-tanstack-react-router/interfaces/PlayRouteEvent.md

@@ -2,7 +2,7 @@
 
 # Interface: PlayRouteEvent
 
-Defined in: [play-router/src/types.ts:238](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/types.ts#L238)
+Defined in: [play-router/src/types.ts:336](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L336)
 
 The routing event, with its parameters and its query
 
@@ -118,18 +118,13 @@ Use `play.route` when you need a navigation that knows the parameters, with the
 gives you the complete URLPatternResult, for an advanced use such as a debug or an
 analysis of the pattern.
 
-## Indexable
-
-```ts
-[key: string]: unknown
-```
-
 ## Properties
 
-| Property                               | Modifier   | Type                           | Defined in                                                                                                                      |
-| -------------------------------------- | ---------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-match"></a> `match?`   | `readonly` | `unknown`                      | [play-router/src/types.ts:243](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/types.ts#L243) |
-| <a id="property-params"></a> `params?` | `readonly` | `Record`\<`string`, `string`\> | [play-router/src/types.ts:241](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/types.ts#L241) |
-| <a id="property-query"></a> `query?`   | `readonly` | `Record`\<`string`, `string`\> | [play-router/src/types.ts:242](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/types.ts#L242) |
-| <a id="property-to"></a> `to`          | `readonly` | `string`                       | [play-router/src/types.ts:240](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/types.ts#L240) |
-| <a id="property-type"></a> `type`      | `readonly` | `"play.route"`                 | [play-router/src/types.ts:239](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/types.ts#L239) |
+| Property                               | Modifier   | Type                                                             | Description                                                                                                                                                                                                                                                                           | Defined in                                                                                                                      |
+| -------------------------------------- | ---------- | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-data"></a> `data?`     | `readonly` | [`RouteData`](../../play-router/index/type-aliases/RouteData.md) | The extra data that the SENDER of this event supplies: a router bridge, or the code of an application. It is not what the target state declares — that is [RouteObject.data](../../play-router/index/interfaces/RouteObject.md#property-data), and a resolver there reads this field. | [play-router/src/types.ts:346](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L346) |
+| <a id="property-match"></a> `match?`   | `readonly` | `unknown`                                                        | -                                                                                                                                                                                                                                                                                     | [play-router/src/types.ts:347](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L347) |
+| <a id="property-params"></a> `params?` | `readonly` | `Record`\<`string`, `string`\>                                   | -                                                                                                                                                                                                                                                                                     | [play-router/src/types.ts:339](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L339) |
+| <a id="property-query"></a> `query?`   | `readonly` | `Record`\<`string`, `string`\>                                   | -                                                                                                                                                                                                                                                                                     | [play-router/src/types.ts:340](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L340) |
+| <a id="property-to"></a> `to`          | `readonly` | `string`                                                         | -                                                                                                                                                                                                                                                                                     | [play-router/src/types.ts:338](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L338) |
+| <a id="property-type"></a> `type`      | `readonly` | `"play.route"`                                                   | -                                                                                                                                                                                                                                                                                     | [play-router/src/types.ts:337](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L337) |

package/api/@xmachines/play-tanstack-react-router/interfaces/PlayRouterProviderProps.md

@@ -2,7 +2,7 @@
 
 # Interface: PlayRouterProviderProps\<TActor\>
 
-Defined in: [play-tanstack-react-router/src/play-router-provider.tsx:45](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-tanstack-react-router/src/play-router-provider.tsx#L45)
+Defined in: [play-tanstack-react-router/src/play-router-provider.tsx:45](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-tanstack-react-router/src/play-router-provider.tsx#L45)
 
 The props of the `PlayRouterProvider` of TanStack React Router.
 
@@ -16,17 +16,17 @@ The props of the `PlayRouterProvider` of TanStack React Router.
 
 ## Type Parameters
 
-| Type Parameter                                 | Default type                |
-| ---------------------------------------------- | --------------------------- |
-| `TActor` _extends_ [`PlayActor`](PlayActor.md) | [`PlayActor`](PlayActor.md) |
+| Type Parameter                                         | Default type                        |
+| ------------------------------------------------------ | ----------------------------------- |
+| `TActor` _extends_ [`RoutableActor`](RoutableActor.md) | [`RoutableActor`](RoutableActor.md) |
 
 ## Properties
 
 | Property                                               | Type                                                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Inherited from                               | Defined in                                                                                                                                              |
 | ------------------------------------------------------ | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-actor"></a> `actor`                    | `TActor`                                                      | The actor to keep in step with the router. It must be a stable reference: give the same actor instance on every render. An actor in the JSX, or a new actor on each render, makes the bridge disconnect and connect again each time.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `PlayRouterProviderBaseProps.actor`          | [play-router/src/provider-lifecycle.ts:40](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/provider-lifecycle.ts#L40) |
-| <a id="property-basepath"></a> `basePath?`             | `string`                                                      | Mounts the routes of the machine under a URL prefix that the host owns, so that the routes of the host and the routes of the machine share one router. `actor`, `router`, and `routeMap` each need a stable reference. This prop needs none, and it rebuilds the bridge never: a change moves the live bridge with `setBasePath()`, so a host route that renders again with a new prefix keeps the actor, the route map, and its cache. The prefix says WHERE an actor is mounted, and never WHICH actor is mounted. An actor never changes identity, so a prefix segment that IDENTIFIES the actor gives a different `actor` prop instead, and THAT rebuilds the bridge — which is correct, because one actor takes one bridge. A location outside the prefix belongs completely to the host: the bridge sends no event there, and it corrects no URL there. Every `:param` needs a value. An unresolved one throws a `MissingBasePathParamError` out of the mount effect, because the bridge writes no URL without it. Render this component only after the host holds the value, which a route loader or a `useParams()` call does already. | `PlayRouterProviderBaseProps.basePath`       | [play-router/src/provider-lifecycle.ts:78](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/provider-lifecycle.ts#L78) |
-| <a id="property-basepathparams"></a> `basePathParams?` | `Record`\<`string`, `string` \| `number`\>                    | The values of the `:param` segments of [PlayRouterProviderBaseProps.basePath](../../play-react-router/interfaces/PlayRouterProviderProps.md#property-basepath), for example `{ machineId }` for `basePath="/:machineId/play"`. An inline object literal is correct here: the provider compares this prop by value, and a move to the same prefix does nothing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `PlayRouterProviderBaseProps.basePathParams` | [play-router/src/provider-lifecycle.ts:87](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/provider-lifecycle.ts#L87) |
-| <a id="property-renderer"></a> `renderer`              | (`actor`, `router`) => `ReactNode`                            | The renderer callback receives the same concrete actor type as the prop.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `PlayRouterProviderBaseProps.renderer`       | [play-router/src/provider-lifecycle.ts:89](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/provider-lifecycle.ts#L89) |
-| <a id="property-routemap"></a> `routeMap`              | [`RouteMap`](../classes/RouteMap.md)                          | The route map of both directions, for the lookup between a state ID and a URL path. **It must be a stable reference.** The provider builds the bridge again on each change of the identity of `routeMap`. A value in the JSX, for example `createRouteMapFromTree(routeTree)`, makes a new object on every render, and the bridge therefore connects again on every render. Hold the value with `useMemo`: `const routeMap = useMemo(() => createRouteMapFromTree(routeTree), [routeTree]);`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `PlayRouterProviderBaseProps.routeMap`       | [play-router/src/provider-lifecycle.ts:55](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/provider-lifecycle.ts#L55) |
-| <a id="property-router"></a> `router`                  | [`TanStackRouterLike`](../type-aliases/TanStackRouterLike.md) | The router instance that the bridge keeps in step with the actor. It must be a stable reference.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `PlayRouterProviderBaseProps.router`         | [play-router/src/provider-lifecycle.ts:42](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/provider-lifecycle.ts#L42) |
+| <a id="property-actor"></a> `actor`                    | `TActor`                                                      | The actor to keep in step with the router. It must be a stable reference: give the same actor instance on every render. An actor in the JSX, or a new actor on each render, makes the bridge disconnect and connect again each time.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `PlayRouterProviderBaseProps.actor`          | [play-router/src/provider-lifecycle.ts:42](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/provider-lifecycle.ts#L42) |
+| <a id="property-basepath"></a> `basePath?`             | `string`                                                      | Mounts the routes of the machine under a URL prefix that the host owns, so that the routes of the host and the routes of the machine share one router. `actor`, `router`, and `routeMap` each need a stable reference. This prop needs none, and it rebuilds the bridge never: a change moves the live bridge with `setBasePath()`, so a host route that renders again with a new prefix keeps the actor, the route map, and its cache. The prefix says WHERE an actor is mounted, and never WHICH actor is mounted. An actor never changes identity, so a prefix segment that IDENTIFIES the actor gives a different `actor` prop instead, and THAT rebuilds the bridge — which is correct, because one actor takes one bridge. A location outside the prefix belongs completely to the host: the bridge sends no event there, and it corrects no URL there. Every `:param` needs a value. An unresolved one throws a `MissingBasePathParamError` out of the mount effect, because the bridge writes no URL without it. Render this component only after the host holds the value, which a route loader or a `useParams()` call does already. | `PlayRouterProviderBaseProps.basePath`       | [play-router/src/provider-lifecycle.ts:80](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/provider-lifecycle.ts#L80) |
+| <a id="property-basepathparams"></a> `basePathParams?` | `Record`\<`string`, `string` \| `number`\>                    | The values of the `:param` segments of [PlayRouterProviderBaseProps.basePath](../../play-react-router/interfaces/PlayRouterProviderProps.md#property-basepath), for example `{ machineId }` for `basePath="/:machineId/play"`. An inline object literal is correct here: the provider compares this prop by value, and a move to the same prefix does nothing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `PlayRouterProviderBaseProps.basePathParams` | [play-router/src/provider-lifecycle.ts:89](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/provider-lifecycle.ts#L89) |
+| <a id="property-renderer"></a> `renderer`              | (`actor`, `router`) => `ReactNode`                            | The renderer callback receives the same concrete actor type as the prop.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `PlayRouterProviderBaseProps.renderer`       | [play-router/src/provider-lifecycle.ts:91](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/provider-lifecycle.ts#L91) |
+| <a id="property-routemap"></a> `routeMap`              | [`RouteMap`](../classes/RouteMap.md)                          | The route map of both directions, for the lookup between a state ID and a URL path. **It must be a stable reference.** The provider builds the bridge again on each change of the identity of `routeMap`. A value in the JSX, for example `createRouteMapFromTree(routeTree)`, makes a new object on every render, and the bridge therefore connects again on every render. Hold the value with `useMemo`: `const routeMap = useMemo(() => createRouteMapFromTree(routeTree), [routeTree]);`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `PlayRouterProviderBaseProps.routeMap`       | [play-router/src/provider-lifecycle.ts:57](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/provider-lifecycle.ts#L57) |
+| <a id="property-router"></a> `router`                  | [`TanStackRouterLike`](../type-aliases/TanStackRouterLike.md) | The router instance that the bridge keeps in step with the actor. It must be a stable reference.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `PlayRouterProviderBaseProps.router`         | [play-router/src/provider-lifecycle.ts:44](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/provider-lifecycle.ts#L44) |

package/api/@xmachines/play-tanstack-react-router/interfaces/RoutableActor.md

@@ -0,0 +1,72 @@
+[API](../../../README.md) / [@xmachines/play-tanstack-react-router](../README.md) / RoutableActor
+
+# Interface: RoutableActor
+
+Defined in: [play-router/src/types.ts:392](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L392)
+
+The minimal actor interface that `RouterBridgeBase` and every framework router
+adapter require.
+
+It names `send` itself, and it therefore gives `RouterBridgeBase.actor.send` a type that
+accepts a `PlayRouteEvent` directly. That removes the unsafe cast
+`(actor.send as (e: PlayRouteEvent) => void)`.
+
+It is [Routable](../../play-router/index/interfaces/Routable.md) with `send`. The two members of the capability are declared once,
+in `Routable`, and this interface extends it. A copy of them here drifts the day that
+one of the two files changes.
+
+**It names the view NOWHERE. Routing implies no rendering.** No file of this package,
+and no file of any of the eight router adapters, ever reads `currentView`. A provider
+whose renderer callback reads the view binds its own `TActor`, and a constraint keeps
+the concrete type of the actor whole, so that callback still reads the exact spec of
+that actor.
+
+Every `PlayActor` of `@xmachines/play-actor` that also implements `Routable`, and whose
+event union holds `PlayRouteEvent`, satisfies this interface structurally. A machine
+that declares no route event does NOT satisfy it, and that refusal is correct: a bridge
+cannot navigate an actor that receives no route event.
+
+## Example
+
+```typescript
+import type { RoutableActor } from "@xmachines/play-router";
+
+class MyBridge extends RouterBridgeBase {
+	constructor(actor: RoutableActor, routeMap: RouteMap) {
+		super(actor, routeMap);
+	}
+}
+```
+
+## Extends
+
+- [`Routable`](../../play-router/index/interfaces/Routable.md)
+
+## Properties
+
+| Property                                          | Modifier   | Type                                                                                         | Inherited from                                                                                                                                      | Defined in                                                                                                                      |
+| ------------------------------------------------- | ---------- | -------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-currentroute"></a> `currentRoute` | `readonly` | [`Computed`](../../play-signals/namespaces/Signal/classes/Computed.md)\<`string` \| `null`\> | [`Routable`](../../play-router/index/interfaces/Routable.md).[`currentRoute`](../../play-router/index/interfaces/Routable.md#property-currentroute) | [play-router/src/types.ts:354](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L354) |
+| <a id="property-initialroute"></a> `initialRoute` | `readonly` | `string` \| `null`                                                                           | [`Routable`](../../play-router/index/interfaces/Routable.md).[`initialRoute`](../../play-router/index/interfaces/Routable.md#property-initialroute) | [play-router/src/types.ts:355](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L355) |
+
+## Methods
+
+### send()
+
+```ts
+send(event): void;
+```
+
+Defined in: [play-router/src/types.ts:394](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L394)
+
+Sends a route navigation event to the actor.
+
+#### Parameters
+
+| Parameter | Type                                  |
+| --------- | ------------------------------------- |
+| `event`   | [`PlayRouteEvent`](PlayRouteEvent.md) |
+
+#### Returns
+
+`void`

package/api/@xmachines/play-tanstack-react-router/interfaces/RouteMapOptions.md

@@ -2,12 +2,12 @@
 
 # Interface: RouteMapOptions
 
-Defined in: [play-router/src/create-route-map.ts:9](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/create-route-map.ts#L9)
+Defined in: [play-router/src/types.ts:567](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L567)
 
 The options of `createRouteMap` and of `createRouteMapFromTree`.
 
 ## Properties
 
-| Property                                     | Type     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Defined in                                                                                                                                          |
-| -------------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-cachesize"></a> `cacheSize?` | `number` | The maximum number of the resolved parameterized path lookups in the cache. `RouteMap.getStateIdByPath()` resolves a parameterized pattern, for example `/profile/:userId`, with URLPattern on each call. The map keeps each path of a frequent visit in an LRU cache, and a later lookup of that path is therefore O(1). Raise this value for an application with a large set of parameterized routes, or with a high frequency of the navigation. The default is `500`. | [play-router/src/create-route-map.ts:21](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/create-route-map.ts#L21) |
+| Property                                     | Type     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Defined in                                                                                                                      |
+| -------------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-cachesize"></a> `cacheSize?` | `number` | The maximum number of the resolved parameterized path lookups in the cache. `RouteMap.getStateIdByPath()` resolves a parameterized pattern, for example `/profile/:userId`, with URLPattern on each call. The map keeps each path of a frequent visit in an LRU cache, and a later lookup of that path is therefore O(1). Raise this value for an application with a large set of parameterized routes, or with a high frequency of the navigation. The default is `500`. | [play-router/src/types.ts:579](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L579) |

package/api/@xmachines/play-tanstack-react-router/interfaces/RouteMapping.md

@@ -2,7 +2,7 @@
 
 # Interface: RouteMapping
 
-Defined in: [play-router/src/base-route-map.ts:54](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/base-route-map.ts#L54)
+Defined in: [play-router/src/base-route-map.ts:54](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/base-route-map.ts#L54)
 
 One entry of the map between a state ID and a path.
 
@@ -24,5 +24,5 @@ const optionalMapping: RouteMapping = { stateId: "settings", path: "/settings/:s
 
 | Property                                | Modifier   | Type     | Description                                                                                      | Defined in                                                                                                                                      |
 | --------------------------------------- | ---------- | -------- | ------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-path"></a> `path`       | `readonly` | `string` | The pattern of the URL path, for example `"/"`, `"/profile/:userId"`, or `"/settings/:section?"` | [play-router/src/base-route-map.ts:58](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/base-route-map.ts#L58) |
-| <a id="property-stateid"></a> `stateId` | `readonly` | `string` | The state ID of the state machine, for example `"home"` or `"#profile"`                          | [play-router/src/base-route-map.ts:56](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/base-route-map.ts#L56) |
+| <a id="property-path"></a> `path`       | `readonly` | `string` | The pattern of the URL path, for example `"/"`, `"/profile/:userId"`, or `"/settings/:section?"` | [play-router/src/base-route-map.ts:58](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/base-route-map.ts#L58) |
+| <a id="property-stateid"></a> `stateId` | `readonly` | `string` | The state ID of the state machine, for example `"home"` or `"#profile"`                          | [play-router/src/base-route-map.ts:56](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/base-route-map.ts#L56) |

package/api/@xmachines/play-tanstack-react-router/interfaces/RouterBridge.md

@@ -2,7 +2,7 @@
 
 # Interface: RouterBridge
 
-Defined in: [play-router/src/types.ts:359](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/types.ts#L359)
+Defined in: [play-router/src/types.ts:438](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L438)
 
 The RouterBridge interface of a runtime infrastructure adapter
 
@@ -56,7 +56,7 @@ class MyRouterBridge implements RouterBridge {
 connect(): void | Promise<void>;
 ```
 
-Defined in: [play-router/src/types.ts:376](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/types.ts#L376)
+Defined in: [play-router/src/types.ts:455](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L455)
 
 Connects the router bridge to the Actor
 
@@ -86,7 +86,7 @@ await bridge.connect();
 disconnect(): void | Promise<void>;
 ```
 
-Defined in: [play-router/src/types.ts:392](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/types.ts#L392)
+Defined in: [play-router/src/types.ts:471](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L471)
 
 Disconnects the router bridge from the Actor
 

package/api/@xmachines/play-tanstack-react-router/type-aliases/PlayRouterBridgeConstructor.md

@@ -1,15 +1,24 @@
 [API](../../../README.md) / [@xmachines/play-tanstack-react-router](../README.md) / PlayRouterBridgeConstructor
 
-# Type Alias: PlayRouterBridgeConstructor\<TRouter\>
+# Type Alias: PlayRouterBridgeConstructor\<TRouter, TActor\>
 
 ```ts
-type PlayRouterBridgeConstructor<TRouter> = (router, actor, routeMap, options?) => RouterBridge;
+type PlayRouterBridgeConstructor<TRouter, TActor> = (
+	router,
+	actor,
+	routeMap,
+	options?,
+) => RouterBridge;
 ```
 
-Defined in: [play-router/src/provider-lifecycle.ts:101](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/provider-lifecycle.ts#L101)
+Defined in: [play-router/src/provider-lifecycle.ts:107](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/provider-lifecycle.ts#L107)
 
 The constructor shape that a bridge class must satisfy for a provider factory: `(router, actor, routeMap, options?) → RouterBridge`.
 
+`TActor` carries the actor type of the caller through to the constructor, so the spec
+type of that actor reaches the bridge whole. A bridge that reads no spec binds nothing
+and receives the default.
+
 The return type is `RouterBridge`, the published contract of a bridge, so a
 consumer bridge of its own keeps compiling. Every bridge on `RouterBridgeBase` also
 satisfies `MountableRouterBridge`, and the provider finds that mount API at run
@@ -18,16 +27,17 @@ existed.
 
 ## Type Parameters
 
-| Type Parameter |
-| -------------- |
-| `TRouter`      |
+| Type Parameter                                                       | Default type                                      |
+| -------------------------------------------------------------------- | ------------------------------------------------- |
+| `TRouter`                                                            | -                                                 |
+| `TActor` _extends_ [`RoutableActor`](../interfaces/RoutableActor.md) | [`RoutableActor`](../interfaces/RoutableActor.md) |
 
 ## Parameters
 
 | Parameter  | Type                                                                     |
 | ---------- | ------------------------------------------------------------------------ |
 | `router`   | `TRouter`                                                                |
-| `actor`    | [`PlayActor`](../interfaces/PlayActor.md)                                |
+| `actor`    | `TActor`                                                                 |
 | `routeMap` | [`RouteMap`](../classes/RouteMap.md)                                     |
 | `options?` | [`BasePathOptions`](../../play-dom-router/interfaces/BasePathOptions.md) |
 

package/api/@xmachines/play-tanstack-react-router/type-aliases/PlayRouterProviderBaseProps.md

@@ -10,7 +10,7 @@ type PlayRouterProviderBaseProps<TRouter, TActor> = PlayRouterProviderBaseProps<
 >;
 ```
 
-Defined in: [play-tanstack-react-router/src/create-play-router-provider.tsx:35](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-tanstack-react-router/src/create-play-router-provider.tsx#L35)
+Defined in: [play-tanstack-react-router/src/create-play-router-provider.tsx:35](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-tanstack-react-router/src/create-play-router-provider.tsx#L35)
 
 The props of a React `PlayRouterProvider`.
 
@@ -20,7 +20,7 @@ bound to `ReactNode`. See `PlayRouterProviderBaseProps` of
 
 ## Type Parameters
 
-| Type Parameter                                               | Default type                              |
-| ------------------------------------------------------------ | ----------------------------------------- |
-| `TRouter`                                                    | -                                         |
-| `TActor` _extends_ [`PlayActor`](../interfaces/PlayActor.md) | [`PlayActor`](../interfaces/PlayActor.md) |
+| Type Parameter                                                       | Default type                                      |
+| -------------------------------------------------------------------- | ------------------------------------------------- |
+| `TRouter`                                                            | -                                                 |
+| `TActor` _extends_ [`RoutableActor`](../interfaces/RoutableActor.md) | [`RoutableActor`](../interfaces/RoutableActor.md) |

package/api/@xmachines/play-tanstack-react-router/type-aliases/TanStackRouterInstance.md

@@ -6,4 +6,4 @@
 type TanStackRouterInstance = ConstructorParameters<typeof TanStackReactRouterBridge>[0];
 ```
 
-Defined in: [play-tanstack-react-router/src/play-router-provider.tsx:36](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-tanstack-react-router/src/play-router-provider.tsx#L36)
+Defined in: [play-tanstack-react-router/src/play-router-provider.tsx:36](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-tanstack-react-router/src/play-router-provider.tsx#L36)

package/api/@xmachines/play-tanstack-react-router/type-aliases/TanStackRouterLike.md

@@ -6,7 +6,7 @@
 type TanStackRouterLike = object;
 ```
 
-Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:39](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L39)
+Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:39](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L39)
 
 The type-only interface of the TanStack Router surface that
 `TanStackRouterBridgeBase` uses. An instance of `@tanstack/react-router` and an
@@ -20,7 +20,7 @@ instance of `@tanstack/solid-router` both satisfy it.
 history: object;
 ```
 
-Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:72](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L72)
+Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:72](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L72)
 
 #### location
 
@@ -69,7 +69,7 @@ subscribe(handler): () => void;
 optional options?: object;
 ```
 
-Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:58](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L58)
+Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:58](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L58)
 
 The options of the router. The bridge reads `parseSearch` only.
 
@@ -103,7 +103,7 @@ optional parseSearch(search): Record<string, unknown>;
 optional load(): void | Promise<void>;
 ```
 
-Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:71](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L71)
+Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:71](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L71)
 
 Runs the TanStack route matching and the loaders again for the current location.
 This method is optional. The bridge calls it after every navigation. The matching
@@ -128,7 +128,7 @@ bridge then synchronizes synchronously.
 navigate(args): void;
 ```
 
-Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:48](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L48)
+Defined in: [play-tanstack-router/src/tanstack-router-bridge-base.ts:48](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-tanstack-router/src/tanstack-router-bridge-base.ts#L48)
 
 Navigates to a location. `search` carries the query of the target.
 

package/api/@xmachines/play-tanstack-react-router/variables/PlayRouterProvider.md

@@ -6,7 +6,7 @@
 const PlayRouterProvider: <TActor>(__namedParameters) => Element;
 ```
 
-Defined in: [play-tanstack-react-router/src/play-router-provider.tsx:60](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-tanstack-react-router/src/play-router-provider.tsx#L60)
+Defined in: [play-tanstack-react-router/src/play-router-provider.tsx:60](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-tanstack-react-router/src/play-router-provider.tsx#L60)
 
 Connects a `PlayerActor` to TanStack React Router. It keeps the actor state and the
 browser URL in step, in both directions.
@@ -20,9 +20,9 @@ connect), and the bridge supports this.
 
 ## Type Parameters
 
-| Type Parameter                                               |
-| ------------------------------------------------------------ |
-| `TActor` _extends_ [`PlayActor`](../interfaces/PlayActor.md) |
+| Type Parameter                                                       |
+| -------------------------------------------------------------------- |
+| `TActor` _extends_ [`RoutableActor`](../interfaces/RoutableActor.md) |
 
 ## Parameters
 

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

@@ -4,7 +4,7 @@
 
 Shared, framework-agnostic TanStack Router bridge base for XMachines Play.
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-2.2.0-blue)](https://www.npmjs.com/package/@xmachines/play-tanstack-router)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-4.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-tanstack-router)
 
 TanStack Router gives React and Solid the same `navigate`, `load`, and `history`
 surface. Therefore the complete bridge implementation lives here, in
@@ -24,8 +24,9 @@ type-only interface. It describes the small router surface that the bridge uses.
 
 ```typescript
 import { createMachine } from "xstate";
-import { definePlayer, formatPlayRouteTransitions } from "@xmachines/play-xstate";
-import { createRouteMap } from "@xmachines/play-router";
+import { definePlayer, compose, PlayerActor } from "@xmachines/play-xstate";
+import { formatPlayRouteTransitions, withRouting } from "@xmachines/play-xstate/routing";
+import { createRouteMap } from "@xmachines/play-router/xstate";
 import { TanStackRouterBridgeBase } from "@xmachines/play-tanstack-router";
 
 const machine = createMachine(
@@ -39,7 +40,8 @@ const machine = createMachine(
 	}),
 );
 
-const actor = definePlayer({ machine })();
+// The bridge needs the routing capability
+const actor = definePlayer({ machine, actor: compose(PlayerActor, withRouting) })();
 actor.start();
 
 const routeMap = createRouteMap(machine);