@xmachines/docs 2.0.0-alpha.1 → 2.1.0

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

@@ -2,17 +2,19 @@
 
 # Class: SolidRouterBridge
 
-Defined in: [packages/play-solid-router/src/solid-router-bridge.ts:54](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-solid-router/src/solid-router-bridge.ts#L54)
+Defined in: [packages/play-solid-router/src/solid-router-bridge.ts:58](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-solid-router/src/solid-router-bridge.ts#L58)
 
-SolidJS Router integration bridge extending RouterBridgeBase
+The SolidJS Router integration bridge. It extends RouterBridgeBase
 
-Implements RouterBridge protocol for SolidJS Router using Solid's reactive
-primitives. The actor→router direction uses TC39 Signal watcher (from base class).
-The router→actor direction uses Solid's createEffect for native reactivity.
+The class implements the RouterBridge protocol for SolidJS Router with the
+reactive primitives of Solid. The actor-to-router direction uses the TC39 Signal
+watcher of the base class. The router-to-actor direction uses the Solid
+createEffect function for a native reactivity.
 
-Path parameters are extracted from Solid's `useParams()` reactive proxy rather than
-re-parsing the URL with URLPattern. This means parameterized routes work without the
-URLPattern polyfill — Solid's router has already extracted the values.
+The bridge reads each path parameter from the reactive `useParams()` proxy of
+Solid. It does not parse the URL again with URLPattern. Therefore a
+parameterized route works without the URLPattern polyfill, because the router of
+Solid holds the values already.
 
 ## Extends
 
@@ -31,21 +33,21 @@ new SolidRouterBridge(
    routeMap): SolidRouterBridge;
 ```
 
-Defined in: [packages/play-solid-router/src/solid-router-bridge.ts:75](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-solid-router/src/solid-router-bridge.ts#L75)
+Defined in: [packages/play-solid-router/src/solid-router-bridge.ts:81](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-solid-router/src/solid-router-bridge.ts#L81)
 
-Create a SolidJS Router bridge
+Creates a SolidJS Router bridge
 
-**CRITICAL:** `connect()` must be called inside a Solid component where hooks are available.
+**CRITICAL:** call `connect()` inside a Solid component, where the hooks are available.
 
 #### Parameters
 
-| Parameter       | Type                                                                 | Description                                                                                                                                     |
-| --------------- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
-| `solidNavigate` | `Navigator`                                                          | Result of useNavigate() hook                                                                                                                    |
-| `location`      | [`LocationLike`](../../play-router/interfaces/LocationLike.md)       | Result of useLocation() hook                                                                                                                    |
-| `params`        | `Params`                                                             | Result of useParams() hook — used directly for path parameter extraction, avoiding the URLPattern polyfill requirement for parameterized routes |
-| `actor`         | [`RoutableActor`](../../play-dom-router/interfaces/RoutableActor.md) | XMachines actor instance                                                                                                                        |
-| `routeMap`      | [`RouteMap`](RouteMap.md)                                            | Bidirectional state ID ↔ path mapping                                                                                                           |
+| 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                                                                                                        |
 
 #### Returns
 
@@ -63,21 +65,23 @@ Create a SolidJS Router bridge
 connect(): void;
 ```
 
-Defined in: [packages/play-router/src/router-bridge-base.ts:151](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/router-bridge-base.ts#L151)
+Defined in: [packages/play-router/src/router-bridge-base.ts:158](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/router-bridge-base.ts#L158)
 
-Connect the router bridge to the Actor.
+Connects the router bridge to the Actor.
 
-Sets up the TC39 Signal watcher for actor → router direction and
-starts watching router changes (framework-specific).
+The method installs the TC39 Signal 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.
 
-Ordering here is part of the bridge contract:
+The order of these steps is part of the contract of the bridge:
 
-- `lastSyncedPath` is seeded in the constructor from `actor.currentRoute`
-- the actor watcher is installed before adapter router subscriptions
-- initial sync then resolves deep-link vs restore using `actor.initialRoute`
+- The constructor seeds `lastSyncedPath` from `actor.currentRoute`
+- The method installs the actor watcher before the router subscriptions of the adapter
+- The first synchronization then separates a deep link from a restore, with `actor.initialRoute`
 
-Adapters that need custom initial-sync behavior should override
-`getInitialRouterPath()` rather than reordering `connect()` steps.
+An adapter that needs a different behavior of the first synchronization overrides
+`getInitialRouterPath()`. It does not change the order of the steps of
+`connect()`.
 
 #### Returns
 
@@ -95,11 +99,12 @@ Adapters that need custom initial-sync behavior should override
 disconnect(): void;
 ```
 
-Defined in: [packages/play-router/src/router-bridge-base.ts:256](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/router-bridge-base.ts#L256)
+Defined in: [packages/play-router/src/router-bridge-base.ts:270](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/router-bridge-base.ts#L270)
 
-Disconnect the router bridge from the Actor.
+Disconnects the router bridge from the Actor.
 
-Stops signal watching and unregisters framework-specific router listener.
+The method stops the watch of the signal, and it removes the router listener of the
+framework.
 
 #### Returns
 
@@ -111,15 +116,15 @@ Stops signal watching and unregisters framework-specific router listener.
 
 ---
 
-### dispose()
+### ~~dispose()~~
 
 ```ts
 dispose(): void;
 ```
 
-Defined in: [packages/play-solid-router/src/solid-router-bridge.ts:187](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-solid-router/src/solid-router-bridge.ts#L187)
+Defined in: [packages/play-solid-router/src/solid-router-bridge.ts:202](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-solid-router/src/solid-router-bridge.ts#L202)
 
-Dispose the bridge (alias for disconnect).
+Disposes of the bridge. This method is the alias of disconnect.
 
 #### Returns
 
@@ -130,3 +135,7 @@ Dispose the bridge (alias for disconnect).
 ```tsx
 onCleanup(() => bridge.dispose());
 ```
+
+#### Deprecated
+
+Use [disconnect](#disconnect). Will be removed in the next major.

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

@@ -6,17 +6,18 @@
 function createPlayRouterProvider<TRouter>(BridgeCtor): <TActor>(props) => any;
 ```
 
-Defined in: [packages/play-solid-router/src/create-play-router-provider.tsx:68](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-solid-router/src/create-play-router-provider.tsx#L68)
+Defined in: [packages/play-solid-router/src/create-play-router-provider.tsx:69](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-solid-router/src/create-play-router-provider.tsx#L69)
 
-Create a Solid `PlayRouterProvider` component bound to a specific bridge class.
+Creates a Solid `PlayRouterProvider` component of one bridge class.
 
-The returned component connects a `PlayerActor` to the framework router,
-keeping actor state and browser URL in sync bidirectionally.
+The component of the return value connects a `PlayerActor` to the framework
+router. It keeps the actor state and the browser URL in step, in both directions.
 
-The bridge is created synchronously at component evaluation time (Solid's
-execution model) and torn down via `onCleanup` when the component is disposed.
-Unlike React, prop stability is not a concern — Solid's `props` accessor is
-already reactive and the bridge is created once per component instance.
+The component creates the bridge synchronously, during its own evaluation, because
+this is the execution model of Solid. It disconnects the bridge in `onCleanup`,
+when Solid disposes of the component. React is different: the stability of a prop
+is no concern here, because the `props` accessor of Solid is reactive already, and
+the component creates the bridge one time for each of its instances.
 
 ## Type Parameters
 
@@ -26,14 +27,15 @@ already reactive and the bridge is created once per component instance.
 
 ## Parameters
 
-| Parameter    | Type                                                                                         | Description                                                            |
-| ------------ | -------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| `BridgeCtor` | [`PlayRouterBridgeConstructor`](../type-aliases/PlayRouterBridgeConstructor.md)\<`TRouter`\> | Bridge class constructed as `new BridgeCtor(router, actor, routeMap)`. |
+| Parameter    | Type                                                                                         | Description                                                                            |
+| ------------ | -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
+| `BridgeCtor` | [`PlayRouterBridgeConstructor`](../type-aliases/PlayRouterBridgeConstructor.md)\<`TRouter`\> | The bridge class. The provider builds it as `new BridgeCtor(router, actor, routeMap)`. |
 
 ## Returns
 
-A `PlayRouterProvider` component, generic over the actor type so the
-`renderer` callback receives the same concrete actor type that was passed in.
+A `PlayRouterProvider` component. It is generic over the actor type.
+Therefore the `renderer` callback receives the same concrete actor type as the
+prop.
 
 \<`TActor`\>(`props`) => `any`
 

package/api/@xmachines/play-solid-router/functions/createRouteMap.md

@@ -6,27 +6,28 @@
 function createRouteMap(machine, options?): RouteMap;
 ```
 
-Defined in: [packages/play-router/src/create-route-map.ts:45](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/create-route-map.ts#L45)
+Defined in: [packages/play-router/src/create-route-map.ts:47](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/create-route-map.ts#L47)
 
-Create a `RouteMap` from an XState state machine.
+Creates a `RouteMap` from an XState state machine.
 
-Extracts all routable states (those with `meta.route`) and builds a bidirectional
-path ↔ stateId lookup structure. The returned map is used by `RouterBridgeBase`
-subclasses to translate browser URL changes into `play.route` actor events and
-vice-versa.
+The function reads every state with a route, which means each state with a
+`meta.route` field. It then builds the lookup structure between a path and a
+stateId, for both directions. A subclass of `RouterBridgeBase` uses the map: it
+converts each change of the browser URL into a `play.route` actor event, and each
+actor route into a URL.
 
 ## Parameters
 
-| Parameter  | Type                                                                      | Description                                                                                                         |
-| ---------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
-| `machine`  | [`AnyStateMachine`](https://www.jsdocs.io/package/xstate#AnyStateMachine) | XState v6 state machine with `meta.route` annotations on states.                                                    |
-| `options?` | [`RouteMapOptions`](../interfaces/RouteMapOptions.md)                     | Optional configuration. Pass `{ cacheSize }` to override the default LRU cache size for parameterized path lookups. |
+| Parameter  | Type                                                                      | Description                                                                                                                     |
+| ---------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| `machine`  | [`AnyStateMachine`](https://www.jsdocs.io/package/xstate#AnyStateMachine) | The XState v5 state machine, with a `meta.route` annotation on each state with a route.                                         |
+| `options?` | [`RouteMapOptions`](../interfaces/RouteMapOptions.md)                     | The optional configuration. Give `{ cacheSize }` to change the default size of the LRU cache of the parameterized path lookups. |
 
 ## Returns
 
 [`RouteMap`](../classes/RouteMap.md)
 
-A `RouteMap` for passing to any `RouterBridgeBase`-based adapter.
+A `RouteMap` for each adapter on `RouterBridgeBase`.
 
 ## Example
 

package/api/@xmachines/play-solid-router/interfaces/AbstractActor.md

@@ -2,13 +2,20 @@
 
 # Abstract Interface: AbstractActor\<TLogic, TEvent\>
 
-Defined in: [packages/play-actor/src/abstract-actor.ts:185](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-actor/src/abstract-actor.ts#L185)
+Defined in: [packages/play-actor/src/abstract-actor.ts:197](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-actor/src/abstract-actor.ts#L197)
 
-Abstract base class for Play Architecture actors.
+The abstract base class of an actor of the Play Architecture.
 
-Provides signal-driven state observation that integrates with XState ecosystem
-tooling (devtools, inspection) while exposing reactive signals for
-Infrastructure layer communication.
+It observes the state through the signals, and it works with the tools of the
+XState ecosystem, such as the devtools and the inspection. It also exposes the
+reactive signals of the communication with the infrastructure layer.
+
+**A subclass IS the actor.** Give the logic _and_ its options to
+`super(logic, options)`, then observe `this`. A separate actor beside this
+instance leaves this instance as an empty second actor. Every inherited member
+then answers from that empty actor, until you forward each one: `system`,
+`sessionId`, `clock`, the internal `_send` that receives the traffic of
+`sendTo()`, and each member that a later XState version adds.
 
 ## Extends
 
@@ -16,27 +23,26 @@ Infrastructure layer communication.
 
 ## Type Parameters
 
-| Type Parameter                                                                           | Default type                                                      | Description                                     |
-| ---------------------------------------------------------------------------------------- | ----------------------------------------------------------------- | ----------------------------------------------- |
-| `TLogic` _extends_ [`AnyActorLogic`](https://www.jsdocs.io/package/xstate#AnyActorLogic) | -                                                                 | XState actor logic type                         |
-| `TEvent` _extends_ [`EventObject`](https://www.jsdocs.io/package/xstate#EventObject)     | [`EventObject`](https://www.jsdocs.io/package/xstate#EventObject) | Event type constraint (defaults to EventObject) |
+| Type Parameter                                                                           | Default type                                                      | Description                                                  |
+| ---------------------------------------------------------------------------------------- | ----------------------------------------------------------------- | ------------------------------------------------------------ |
+| `TLogic` _extends_ [`AnyActorLogic`](https://www.jsdocs.io/package/xstate#AnyActorLogic) | -                                                                 | The type of the XState actor logic                           |
+| `TEvent` _extends_ [`EventObject`](https://www.jsdocs.io/package/xstate#EventObject)     | [`EventObject`](https://www.jsdocs.io/package/xstate#EventObject) | The constraint of the event type. The default is EventObject |
 
 ## Properties
 
-| Property                                        | Modifier   | Type                                                                                                                                                                                                                                                                                                                                                     | Description                                                                                                                                                                             | Inherited from      | Defined in                                                                                                                                                       |
-| ----------------------------------------------- | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-_parent"></a> `_parent?`        | `public`   | `AnyActor`                                                                                                                                                                                                                                                                                                                                               | -                                                                                                                                                                                       | `Actor._parent`     | -                                                                                                                                                                |
-| <a id="property-clock"></a> `clock`             | `public`   | [`Clock`](https://www.jsdocs.io/package/xstate#Clock)                                                                                                                                                                                                                                                                                                    | The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.                                                                                | `Actor.clock`       | -                                                                                                                                                                |
-| <a id="property-id"></a> `id`                   | `public`   | `string`                                                                                                                                                                                                                                                                                                                                                 | The unique identifier for this actor relative to its parent.                                                                                                                            | `Actor.id`          | -                                                                                                                                                                |
-| <a id="property-logic"></a> `logic`             | `public`   | `TLogic`                                                                                                                                                                                                                                                                                                                                                 | -                                                                                                                                                                                       | `Actor.logic`       | -                                                                                                                                                                |
-| <a id="property-options"></a> `options`         | `public`   | `Readonly`\<[`ActorOptions`](https://www.jsdocs.io/package/xstate#ActorOptions)\<`TLogic`\>\>                                                                                                                                                                                                                                                            | -                                                                                                                                                                                       | `Actor.options`     | -                                                                                                                                                                |
-| <a id="property-ref"></a> `ref`                 | `public`   | [`ActorRef`](https://www.jsdocs.io/package/xstate#ActorRef)\<[`SnapshotFrom`](https://www.jsdocs.io/package/xstate#SnapshotFrom)\<`TLogic`\>, [`EventFromLogic`](https://www.jsdocs.io/package/xstate#EventFromLogic)\<`TLogic`\>, [`EmittedFrom`](https://www.jsdocs.io/package/xstate#EmittedFrom)\<`TLogic`\>, `SendableEventFromLogic`\<`TLogic`\>\> | -                                                                                                                                                                                       | `Actor.ref`         | -                                                                                                                                                                |
-| <a id="property-registrykey"></a> `registryKey` | `public`   | `string` \| `undefined`                                                                                                                                                                                                                                                                                                                                  | -                                                                                                                                                                                       | `Actor.registryKey` | -                                                                                                                                                                |
-| <a id="property-sessionid"></a> `sessionId`     | `public`   | `string`                                                                                                                                                                                                                                                                                                                                                 | The globally unique process ID for this invocation.                                                                                                                                     | `Actor.sessionId`   | -                                                                                                                                                                |
-| <a id="property-src"></a> `src`                 | `public`   | \| `string` \| [`AnyActorLogic`](https://www.jsdocs.io/package/xstate#AnyActorLogic)                                                                                                                                                                                                                                                                     | -                                                                                                                                                                                       | `Actor.src`         | -                                                                                                                                                                |
-| <a id="property-state"></a> `state`             | `abstract` | [`State`](../../play-signals/namespaces/Signal/classes/State.md)\<`unknown`\>                                                                                                                                                                                                                                                                            | Reactive snapshot of current actor state. Infrastructure observes this signal to react to state changes without directly coupling to the actor's internal state machine implementation. | -                   | [packages/play-actor/src/abstract-actor.ts:195](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-actor/src/abstract-actor.ts#L195) |
-| <a id="property-system"></a> `system`           | `public`   | [`AnyActorSystem`](https://www.jsdocs.io/package/xstate#AnyActorSystem)                                                                                                                                                                                                                                                                                  | The system to which this actor belongs.                                                                                                                                                 | `Actor.system`      | -                                                                                                                                                                |
-| <a id="property-trigger"></a> `trigger`         | `public`   | `ActorTrigger`\<`SendableEventFromLogic`\<`TLogic`\>\>                                                                                                                                                                                                                                                                                                   | -                                                                                                                                                                                       | `Actor.trigger`     | -                                                                                                                                                                |
+| Property                                    | Modifier   | Type                                                                                                                                                                                                                                                                                                               | Description                                                                                                                                                                                               | Inherited from    | Defined in                                                                                                                                               |
+| ------------------------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-_parent"></a> `_parent?`    | `public`   | [`AnyActorRef`](https://www.jsdocs.io/package/xstate#AnyActorRef)                                                                                                                                                                                                                                                  | -                                                                                                                                                                                                         | `Actor._parent`   | -                                                                                                                                                        |
+| <a id="property-clock"></a> `clock`         | `public`   | [`Clock`](https://www.jsdocs.io/package/xstate#Clock)                                                                                                                                                                                                                                                              | The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.                                                                                                  | `Actor.clock`     | -                                                                                                                                                        |
+| <a id="property-id"></a> `id`               | `public`   | `string`                                                                                                                                                                                                                                                                                                           | The unique identifier for this actor relative to its parent.                                                                                                                                              | `Actor.id`        | -                                                                                                                                                        |
+| <a id="property-logic"></a> `logic`         | `public`   | `TLogic`                                                                                                                                                                                                                                                                                                           | -                                                                                                                                                                                                         | `Actor.logic`     | -                                                                                                                                                        |
+| <a id="property-options"></a> `options`     | `public`   | `Readonly`\<[`ActorOptions`](https://www.jsdocs.io/package/xstate#ActorOptions)\<`TLogic`\>\>                                                                                                                                                                                                                      | -                                                                                                                                                                                                         | `Actor.options`   | -                                                                                                                                                        |
+| <a id="property-ref"></a> `ref`             | `public`   | [`ActorRef`](https://www.jsdocs.io/package/xstate#ActorRef)\<[`SnapshotFrom`](https://www.jsdocs.io/package/xstate#SnapshotFrom)\<`TLogic`\>, [`EventFromLogic`](https://www.jsdocs.io/package/xstate#EventFromLogic)\<`TLogic`\>, [`EmittedFrom`](https://www.jsdocs.io/package/xstate#EmittedFrom)\<`TLogic`\>\> | -                                                                                                                                                                                                         | `Actor.ref`       | -                                                                                                                                                        |
+| <a id="property-sessionid"></a> `sessionId` | `public`   | `string`                                                                                                                                                                                                                                                                                                           | The globally unique process ID for this invocation.                                                                                                                                                       | `Actor.sessionId` | -                                                                                                                                                        |
+| <a id="property-src"></a> `src`             | `public`   | \| `string` \| [`AnyActorLogic`](https://www.jsdocs.io/package/xstate#AnyActorLogic)                                                                                                                                                                                                                               | -                                                                                                                                                                                                         | `Actor.src`       | -                                                                                                                                                        |
+| <a id="property-state"></a> `state`         | `abstract` | [`State`](../../play-signals/namespaces/Signal/classes/State.md)\<`unknown`\>                                                                                                                                                                                                                                      | The reactive snapshot of the current actor state. The infrastructure observes this signal, and it reacts to each state change. It therefore holds no coupling to the internal state machine of the actor. | -                 | [packages/play-actor/src/abstract-actor.ts:207](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-actor/src/abstract-actor.ts#L207) |
+| <a id="property-system"></a> `system`       | `public`   | [`AnyActorSystem`](https://www.jsdocs.io/package/xstate#AnyActorSystem)                                                                                                                                                                                                                                            | The system to which this actor belongs.                                                                                                                                                                   | `Actor.system`    | -                                                                                                                                                        |
+| <a id="property-systemid"></a> `systemId`   | `public`   | `string` \| `undefined`                                                                                                                                                                                                                                                                                            | -                                                                                                                                                                                                         | `Actor.systemId`  | -                                                                                                                                                        |
 
 ## Methods
 
@@ -118,7 +124,7 @@ When an actor receives an event, its internal state may change. An actor
 may emit a snapshot when a state transition occurs.
 
 Note that some actors, such as callback actors generated with
-`createCallbackLogic`, will not emit snapshots.
+`fromCallback`, will not emit snapshots.
 
 #### See
 
@@ -143,9 +149,9 @@ Defined in: `xstate`
 
 #### Type Parameters
 
-| Type Parameter             |
-| -------------------------- |
-| `TType` _extends_ `string` |
+| Type Parameter          |
+| ----------------------- |
+| `TType` _extends_ `any` |
 
 #### Parameters
 
@@ -205,11 +211,20 @@ Actor.select;
 abstract send(event): void;
 ```
 
-Defined in: [packages/play-actor/src/abstract-actor.ts:202](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-actor/src/abstract-actor.ts#L202)
+Defined in: [packages/play-actor/src/abstract-actor.ts:223](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-actor/src/abstract-actor.ts#L223)
+
+Sends an event to the Actor.
 
-Send event to Actor.
+The constraint is TEvent, which gives the type safety of a concrete
+implementation.
 
-Constrained to TEvent for type safety in concrete implementations.
+A note for an implementation that wraps `send`, to check the event or to notify a
+hook around it: this declaration is abstract for one reason only, to narrow the
+event type, and TypeScript forbids a `super` call to an abstract member. Reach
+the implementation of XState with `Actor.prototype.send.call(this, event)`
+instead. A concrete declaration permits `super.send()`, but it also forces an
+`override` modifier in every subclass that exists now, and that is a breaking
+change for an adapter outside this repository.
 
 #### Parameters
 

package/api/@xmachines/play-solid-router/interfaces/PlayActor.md

@@ -2,22 +2,24 @@
 
 # Interface: PlayActor
 
-Defined in: [packages/play-router/src/types.ts:316](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L316)
+Defined in: [packages/play-router/src/types.ts:312](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/types.ts#L312)
 
-Full actor shape used by `PlayRouterProvider` components across all framework
-adapters (`play-solid-router`, `play-vue-router`, `play-react-router`, and the
-adapters built on the shared framework-router bridge bases).
+The complete actor shape of the `PlayRouterProvider` component of each framework
+adapter: `play-solid-router`, `play-vue-router`, `play-react-router`, and each
+adapter on the shared framework router bridge bases.
 
-Extends `RoutableActor` with `currentView` — the provider renders the current
-view spec in addition to synchronizing routes, so it needs both capabilities.
+The shape extends `RoutableActor` with `currentView`, because the provider renders
+the current view spec and also keeps the routes in step. It therefore needs both
+capabilities.
 
-- Use `RoutableActor` when only routing is needed (e.g. `RouterBridgeBase` subclasses,
-  `connectRouter`).
-- Use `PlayActor` when the component also renders the current view spec
-  (e.g. `PlayRouterProvider` renderer callback parameter, `PlayRenderer`).
+- Use `RoutableActor` when you need the routing alone, for example in a
+  `RouterBridgeBase` subclass, or in `connectRouter`.
+- Use `PlayActor` when the component also renders the current view spec, for
+  example for the renderer callback parameter of `PlayRouterProvider`, and in
+  `PlayRenderer`.
 
-All `AbstractActor` subclasses that implement both `Routable` and `Viewable`
-satisfy this interface structurally.
+Every `AbstractActor` subclass that implements both `Routable` and `Viewable`
+satisfies this interface structurally.
 
 ## Example
 
@@ -25,7 +27,7 @@ satisfy this interface structurally.
 import type { PlayActor } from "@xmachines/play-router";
 
 function MyRouterProvider({ actor }: { actor: PlayActor }) {
-	// access actor.currentRoute (routing) and actor.currentView (rendering)
+	// it reads actor.currentRoute for the routing, and actor.currentView for the render
 }
 ```
 
@@ -35,11 +37,11 @@ function MyRouterProvider({ actor }: { actor: PlayActor }) {
 
 ## Properties
 
-| Property                                          | Modifier   | Type                                                                                                                                | Description                                                                                                                                                                                                   | Inherited from                                                                                                                                                 | Defined in                                                                                                                                       |
-| ------------------------------------------------- | ---------- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
-| <a id="property-currentroute"></a> `currentRoute` | `readonly` | [`Computed`](../../play-signals/namespaces/Signal/classes/Computed.md)\<`string` \| `null`\>                                        | TC39 Signal exposing the actor's current URL path (or state ID).                                                                                                                                              | [`RoutableActor`](../../play-dom-router/interfaces/RoutableActor.md).[`currentRoute`](../../play-dom-router/interfaces/RoutableActor.md#property-currentroute) | [packages/play-router/src/types.ts:280](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L280) |
-| <a id="property-currentview"></a> `currentView`   | `readonly` | [`State`](../../play-signals/namespaces/Signal/classes/State.md)\<[`PlaySpec`](../../play-actor/interfaces/PlaySpec.md) \| `null`\> | TC39 Signal exposing the actor's current view spec, or `null` when inactive.                                                                                                                                  | -                                                                                                                                                              | [packages/play-router/src/types.ts:318](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L318) |
-| <a id="property-initialroute"></a> `initialRoute` | `readonly` | `string` \| `null`                                                                                                                  | The route derived from the machine's initial state — fixed at construction. Router bridges compare this against the browser URL to distinguish a deep-link (router wins) from a session restore (actor wins). | [`RoutableActor`](../../play-dom-router/interfaces/RoutableActor.md).[`initialRoute`](../../play-dom-router/interfaces/RoutableActor.md#property-initialroute) | [packages/play-router/src/types.ts:286](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L286) |
+| Property                                          | Modifier   | Type                                                                                                                                | Description                                                                                                                                                                                                                              | Inherited from                                                                                                                                                 | Defined in                                                                                                                               |
+| ------------------------------------------------- | ---------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-currentroute"></a> `currentRoute` | `readonly` | [`Computed`](../../play-signals/namespaces/Signal/classes/Computed.md)\<`string` \| `null`\>                                        | The TC39 Signal of the current URL path of the actor, or of its state ID.                                                                                                                                                                | [`RoutableActor`](../../play-dom-router/interfaces/RoutableActor.md).[`currentRoute`](../../play-dom-router/interfaces/RoutableActor.md#property-currentroute) | [packages/play-router/src/types.ts:274](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/types.ts#L274) |
+| <a id="property-currentview"></a> `currentView`   | `readonly` | [`State`](../../play-signals/namespaces/Signal/classes/State.md)\<[`PlaySpec`](../../play-actor/interfaces/PlaySpec.md) \| `null`\> | The TC39 Signal of the current view spec of the actor, or `null` when no view is active.                                                                                                                                                 | -                                                                                                                                                              | [packages/play-router/src/types.ts:314](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/types.ts#L314) |
+| <a id="property-initialroute"></a> `initialRoute` | `readonly` | `string` \| `null`                                                                                                                  | The route of the initial state of the machine. The constructor fixes it. A router bridge compares it with the browser URL. It therefore separates a deep link, where the router wins, from a restore of a session, where the actor wins. | [`RoutableActor`](../../play-dom-router/interfaces/RoutableActor.md).[`initialRoute`](../../play-dom-router/interfaces/RoutableActor.md#property-initialroute) | [packages/play-router/src/types.ts:280](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/types.ts#L280) |
 
 ## Methods
 
@@ -49,9 +51,9 @@ function MyRouterProvider({ actor }: { actor: PlayActor }) {
 send(event): void;
 ```
 
-Defined in: [packages/play-router/src/types.ts:288](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L288)
+Defined in: [packages/play-router/src/types.ts:282](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/types.ts#L282)
 
-Send a route navigation event to the actor.
+Sends a route navigation event to the actor.
 
 #### Parameters