@xmachines/docs 6.0.0 → 6.1.0

package/api/@xmachines/play-xstate/index/functions/definePlayer.md

@@ -8,7 +8,7 @@
 function definePlayer<TMachine>(config): PlayerFactory<TMachine>;
 ```
 
-Defined in: [packages/play-xstate/src/define-player.ts:62](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/define-player.ts#L62)
+Defined in: [packages/play-xstate/src/define-player.ts:62](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/define-player.ts#L62)
 
 Creates a player factory from an XState machine
 
@@ -85,7 +85,7 @@ console.log(alice.state.get() !== bob.state.get());
 function definePlayer<TMachine, TCapabilities>(config): PlayerFactory<TMachine, TCapabilities>;
 ```
 
-Defined in: [packages/play-xstate/src/define-player.ts:65](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/define-player.ts#L65)
+Defined in: [packages/play-xstate/src/define-player.ts:65](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/define-player.ts#L65)
 
 Creates a player factory from an XState machine
 

package/api/@xmachines/play-xstate/index/interfaces/PlayerConfig.md

@@ -2,7 +2,7 @@
 
 # Interface: PlayerConfig\<TMachine, TCapabilities\>
 
-Defined in: [packages/play-xstate/src/types.ts:8](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L8)
+Defined in: [packages/play-xstate/src/types.ts:8](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L8)
 
 The configuration of definePlayer()
 
@@ -17,6 +17,6 @@ The configuration of definePlayer()
 
 | Property                                 | Type                                                                                       | Description                                                                                                                                                                                                                                                                                                                                                                                                                        | Defined in                                                                                                                             |
 | ---------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-actor"></a> `actor?`     | [`PlayerConstructor`](../type-aliases/PlayerConstructor.md)\<`TMachine`, `TCapabilities`\> | The actor class to build, which decides which CAPABILITIES the actor carries. `PlayerActor` is the default, and it holds `state` and `send` alone. Compose a class to add a capability, and the factory then answers an actor with it: `definePlayer({ machine, actor: compose(PlayerActor, withRouting, withView) });` An application that declares no route, and renders no view, passes nothing and loads neither body of code. | [packages/play-xstate/src/types.ts:31](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L31) |
-| <a id="property-machine"></a> `machine`  | `TMachine`                                                                                 | The XState v5 state machine                                                                                                                                                                                                                                                                                                                                                                                                        | [packages/play-xstate/src/types.ts:13](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L13) |
-| <a id="property-options"></a> `options?` | [`PlayerOptions`](PlayerOptions.md)\<`TMachine`\>                                          | The lifecycle hooks and the configuration                                                                                                                                                                                                                                                                                                                                                                                          | [packages/play-xstate/src/types.ts:16](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L16) |
+| <a id="property-actor"></a> `actor?`     | [`PlayerConstructor`](../type-aliases/PlayerConstructor.md)\<`TMachine`, `TCapabilities`\> | The actor class to build, which decides which CAPABILITIES the actor carries. `PlayerActor` is the default, and it holds `state` and `send` alone. Compose a class to add a capability, and the factory then answers an actor with it: `definePlayer({ machine, actor: compose(PlayerActor, withRouting, withView) });` An application that declares no route, and renders no view, passes nothing and loads neither body of code. | [packages/play-xstate/src/types.ts:31](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L31) |
+| <a id="property-machine"></a> `machine`  | `TMachine`                                                                                 | The XState v5 state machine                                                                                                                                                                                                                                                                                                                                                                                                        | [packages/play-xstate/src/types.ts:13](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L13) |
+| <a id="property-options"></a> `options?` | [`PlayerOptions`](PlayerOptions.md)\<`TMachine`\>                                          | The lifecycle hooks and the configuration                                                                                                                                                                                                                                                                                                                                                                                          | [packages/play-xstate/src/types.ts:16](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L16) |

package/api/@xmachines/play-xstate/index/interfaces/PlayerFactoryResumeOptions.md

@@ -2,7 +2,7 @@
 
 # Interface: PlayerFactoryResumeOptions\<TMachine\>
 
-Defined in: [packages/play-xstate/src/types.ts:134](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L134)
+Defined in: [packages/play-xstate/src/types.ts:134](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L134)
 
 The optional restore arguments of the player factory.
 
@@ -19,4 +19,4 @@ The shape follows the options object of `createActor` in XState. It also keeps t
 
 | Property                                   | Type                                                                     | Description                                                                                                                                                                                                                                                                                     | Defined in                                                                                                                               |
 | ------------------------------------------ | ------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-snapshot"></a> `snapshot?` | [`Snapshot`](https://www.jsdocs.io/package/xstate#Snapshot)\<`unknown`\> | The persisted XState snapshot. The factory restores the actor state from it. Its type is the `ActorOptions["snapshot"]` type of XState, which is the exact type that `createActor` accepts and that `getPersistedSnapshot()` returns. The restore of a stored snapshot therefore needs no cast. | [packages/play-xstate/src/types.ts:142](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L142) |
+| <a id="property-snapshot"></a> `snapshot?` | [`Snapshot`](https://www.jsdocs.io/package/xstate#Snapshot)\<`unknown`\> | The persisted XState snapshot. The factory restores the actor state from it. Its type is the `ActorOptions["snapshot"]` type of XState, which is the exact type that `createActor` accepts and that `getPersistedSnapshot()` returns. The restore of a stored snapshot therefore needs no cast. | [packages/play-xstate/src/types.ts:142](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L142) |

package/api/@xmachines/play-xstate/index/interfaces/PlayerOptions.md

@@ -2,7 +2,7 @@
 
 # Interface: PlayerOptions\<TMachine\>
 
-Defined in: [packages/play-xstate/src/types.ts:37](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L37)
+Defined in: [packages/play-xstate/src/types.ts:37](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L37)
 
 The lifecycle hooks of the player — the observability surface around the actor.
 
@@ -16,9 +16,9 @@ The lifecycle hooks of the player — the observability surface around the actor
 
 | Property                                             | Type                                                                                                                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Defined in                                                                                                                               |
 | ---------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-inspect"></a> `inspect?`             | \| [`Observer`](https://www.jsdocs.io/package/xstate#Observer)\<`InspectionEvent`\> \| ((`inspectionEvent`) => `void`) | The inspection observer. The factory gives it to `createActor` of XState without a change. This is the attachment at the moment of the creation, and it is the only route that observes the construction events of the actor. An attachment later, with `actor.system.inspect(fn)`, also works, but it sees only the events after that moment. A `PlayerActor` is the XState actor itself. Therefore its own events carry `actorRef === playerActor`, and you can recognize it by its identity. Each `PlayerActor` is also its own root system. Therefore `event.rootId === actor.sessionId` separates the complete tree, and this includes the events of an invoked child and of a spawned child, whose `actorRef` is the child. That identity brings one point to note: the `@xstate.actor` event fires from inside the constructor of the actor. Its `actorRef` value is therefore the instance during the construction, and `state`, `currentRoute`, `currentView`, and `initialRoute` do not exist yet. A read of one of them there throws. Keep the reference, and read the atoms from a later event, or outside the observer. **Example** `import { createBrowserInspector } from "@statelyai/inspect"; const { inspect } = createBrowserInspector(); const createPlayer = definePlayer({ machine, options: { inspect } });` For an inspector that you create after the factory, for example behind a dev-tools switch, give the factory a function that forwards each event: `inspect: (event) => currentInspector?.(event)`. | [packages/play-xstate/src/types.ts:125](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L125) |
-| <a id="property-onerror"></a> `onError?`             | (`actor`, `error`) => `void`                                                                                           | The actor calls it on an actor error: a snapshot restore that fails at `start()`, an action or a guard that throws, and a failure of the view derivation. The actor reads this field at the moment of the delivery of an error, and not at its construction. The options object is shared by its reference. Therefore a handler on that object still receives each actor error, also after a later attachment, and the removal of the handler restores the loud default below. With a handler in place, the actor sends the error there, and the error counts as handled. XState decides its own global rethrow for each observer, and this option does not reach that decision: a subscription of your own without an `error` listener still forces the rethrow, with an `onError` handler and without one. Without `onError`, each actor error stays loud, with an unhandled rethrow through `setTimeout`. No error therefore disappears in silence. Your own `error` subscribers stop that default not: `onError` alone stops it. A failure of the actor that is an `Error` already arrives without a change, and it keeps the identity of the machine. A machine that throws a value that is not an `Error` arrives as an `ActorThrewNonErrorError`, with the value from the throw on its `cause` field.                                                                                                                                                                                                                          | [packages/play-xstate/src/types.ts:90](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L90)   |
-| <a id="property-onstart"></a> `onStart?`             | (`actor`) => `void`                                                                                                    | The actor calls it on each real start, which is every transition from "not running" to "running". A start after a stop is such a transition. A second `start()` call while the actor runs fires the hook not again.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | [packages/play-xstate/src/types.ts:43](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L43)   |
-| <a id="property-onstatechange"></a> `onStateChange?` | (`actor`, `state`) => `void`                                                                                           | The actor calls it when the state atom changes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | [packages/play-xstate/src/types.ts:65](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L65)   |
-| <a id="property-onstop"></a> `onStop?`               | (`actor`) => `void`                                                                                                    | The actor calls it on each real stop, which means only after it tore a running actor down. A second `stop()` call, and a stop of an actor that never started fire the hook not.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | [packages/play-xstate/src/types.ts:50](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L50)   |
-| <a id="property-ontransition"></a> `onTransition?`   | (`actor`, `prevState`, `nextState`) => `void`                                                                          | The actor calls it after every event that `send()` processes. This includes an event that the machine ignores, and `prevState` and `nextState` are then the same snapshot. Compare the two values when only a real transition is important to you.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | [packages/play-xstate/src/types.ts:58](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L58)   |
+| <a id="property-inspect"></a> `inspect?`             | \| [`Observer`](https://www.jsdocs.io/package/xstate#Observer)\<`InspectionEvent`\> \| ((`inspectionEvent`) => `void`) | The inspection observer. The factory gives it to `createActor` of XState without a change. This is the attachment at the moment of the creation, and it is the only route that observes the construction events of the actor. An attachment later, with `actor.system.inspect(fn)`, also works, but it sees only the events after that moment. A `PlayerActor` is the XState actor itself. Therefore its own events carry `actorRef === playerActor`, and you can recognize it by its identity. Each `PlayerActor` is also its own root system. Therefore `event.rootId === actor.sessionId` separates the complete tree, and this includes the events of an invoked child and of a spawned child, whose `actorRef` is the child. That identity brings one point to note: the `@xstate.actor` event fires from inside the constructor of the actor. Its `actorRef` value is therefore the instance during the construction, and `state`, `currentRoute`, `currentView`, and `initialRoute` do not exist yet. A read of one of them there throws. Keep the reference, and read the atoms from a later event, or outside the observer. **Example** `import { createBrowserInspector } from "@statelyai/inspect"; const { inspect } = createBrowserInspector(); const createPlayer = definePlayer({ machine, options: { inspect } });` For an inspector that you create after the factory, for example behind a dev-tools switch, give the factory a function that forwards each event: `inspect: (event) => currentInspector?.(event)`. | [packages/play-xstate/src/types.ts:125](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L125) |
+| <a id="property-onerror"></a> `onError?`             | (`actor`, `error`) => `void`                                                                                           | The actor calls it on an actor error: a snapshot restore that fails at `start()`, an action or a guard that throws, and a failure of the view derivation. The actor reads this field at the moment of the delivery of an error, and not at its construction. The options object is shared by its reference. Therefore a handler on that object still receives each actor error, also after a later attachment, and the removal of the handler restores the loud default below. With a handler in place, the actor sends the error there, and the error counts as handled. XState decides its own global rethrow for each observer, and this option does not reach that decision: a subscription of your own without an `error` listener still forces the rethrow, with an `onError` handler and without one. Without `onError`, each actor error stays loud, with an unhandled rethrow through `setTimeout`. No error therefore disappears in silence. Your own `error` subscribers stop that default not: `onError` alone stops it. A failure of the actor that is an `Error` already arrives without a change, and it keeps the identity of the machine. A machine that throws a value that is not an `Error` arrives as an `ActorThrewNonErrorError`, with the value from the throw on its `cause` field.                                                                                                                                                                                                                          | [packages/play-xstate/src/types.ts:90](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L90)   |
+| <a id="property-onstart"></a> `onStart?`             | (`actor`) => `void`                                                                                                    | The actor calls it on each real start, which is every transition from "not running" to "running". A start after a stop is such a transition. A second `start()` call while the actor runs fires the hook not again.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | [packages/play-xstate/src/types.ts:43](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L43)   |
+| <a id="property-onstatechange"></a> `onStateChange?` | (`actor`, `state`) => `void`                                                                                           | The actor calls it when the state atom changes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | [packages/play-xstate/src/types.ts:65](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L65)   |
+| <a id="property-onstop"></a> `onStop?`               | (`actor`) => `void`                                                                                                    | The actor calls it on each real stop, which means only after it tore a running actor down. A second `stop()` call, and a stop of an actor that never started fire the hook not.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | [packages/play-xstate/src/types.ts:50](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L50)   |
+| <a id="property-ontransition"></a> `onTransition?`   | (`actor`, `prevState`, `nextState`) => `void`                                                                          | The actor calls it after every event that `send()` processes. This includes an event that the machine ignores, and `prevState` and `nextState` are then the same snapshot. Compare the two values when only a real transition is important to you.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | [packages/play-xstate/src/types.ts:58](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L58)   |

package/api/@xmachines/play-xstate/index/type-aliases/Capability.md

@@ -6,7 +6,7 @@
 type Capability<TMachine, TAdded> = (Base) => PlayerConstructor<TMachine, TAdded>;
 ```
 
-Defined in: [packages/play-xstate/src/capabilities.ts:70](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/capabilities.ts#L70)
+Defined in: [packages/play-xstate/src/capabilities.ts:70](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/capabilities.ts#L70)
 
 One capability of an actor: a function that takes an actor class and answers the same
 class with `TAdded` on the instance.

package/api/@xmachines/play-xstate/index/type-aliases/PlayerConstructor.md

@@ -11,7 +11,7 @@ type PlayerConstructor<TMachine, TCapabilities> = (
 ) => PlayerActor<TMachine> & TCapabilities;
 ```
 
-Defined in: [packages/play-xstate/src/capabilities.ts:49](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/capabilities.ts#L49)
+Defined in: [packages/play-xstate/src/capabilities.ts:49](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/capabilities.ts#L49)
 
 The constructor of a `PlayerActor`, with every capability that it carries already.
 

package/api/@xmachines/play-xstate/index/type-aliases/PlayerFactory.md

@@ -9,7 +9,7 @@ type PlayerFactory<TMachine, TCapabilities> =
 		: (input, options?) => PlayerActor<TMachine> & TCapabilities;
 ```
 
-Defined in: [packages/play-xstate/src/types.ts:154](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/types.ts#L154)
+Defined in: [packages/play-xstate/src/types.ts:154](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/types.ts#L154)
 
 The factory function that definePlayer() returns. Each call makes an independent
 actor instance from the same configuration.

package/api/@xmachines/play-xstate/with-routing/functions/buildRouteUrl.md

@@ -6,7 +6,7 @@
 function buildRouteUrl(routeTemplate, context?, options?): string;
 ```
 
-Defined in: [packages/play-xstate/src/routing/build-url.ts:46](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/build-url.ts#L46)
+Defined in: [packages/play-xstate/src/routing/build-url.ts:46](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/build-url.ts#L46)
 
 Builds a complete URL from a route template and the context of the actor.
 

package/api/@xmachines/play-xstate/with-routing/functions/deriveRoute.md

@@ -6,7 +6,7 @@
 function deriveRoute(stateMeta): string | null;
 ```
 
-Defined in: [packages/play-xstate/src/routing/derive-route.ts:93](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/derive-route.ts#L93)
+Defined in: [packages/play-xstate/src/routing/derive-route.ts:93](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/derive-route.ts#L93)
 
 Derives the route from the metadata of an XState state
 

package/api/@xmachines/play-xstate/with-routing/functions/formatPlayRouteTransitions.md

@@ -6,7 +6,7 @@
 function formatPlayRouteTransitions<T>(machineConfig): T;
 ```
 
-Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:216](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L216)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:216](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L216)
 
 Makes the play.route transitions from the declarative route configs
 

package/api/@xmachines/play-xstate/with-routing/functions/isAbsoluteRoute.md

@@ -6,7 +6,7 @@
 function isAbsoluteRoute(path): boolean;
 ```
 
-Defined in: [packages/play-xstate/src/routing/derive-route.ts:269](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/derive-route.ts#L269)
+Defined in: [packages/play-xstate/src/routing/derive-route.ts:269](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/derive-route.ts#L269)
 
 Tells you if the route path is absolute
 

package/api/@xmachines/play-xstate/with-routing/functions/withRouting.md

@@ -6,7 +6,7 @@
 function withRouting<TMachine>(Base): PlayerConstructor<TMachine, Routable>;
 ```
 
-Defined in: [packages/play-xstate/src/with-routing.ts:48](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/with-routing.ts#L48)
+Defined in: [packages/play-xstate/src/with-routing.ts:48](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/with-routing.ts#L48)
 
 Adds the routing capability to an actor class.
 

package/api/@xmachines/play-xstate/with-routing/interfaces/RouteContext.md

@@ -2,7 +2,7 @@
 
 # Interface: RouteContext
 
-Defined in: [packages/play-xstate/src/routing/types.ts:28](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/types.ts#L28)
+Defined in: [packages/play-xstate/src/routing/types.ts:28](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/types.ts#L28)
 
 The context of the route construction, from the machine context.
 
@@ -19,7 +19,7 @@ machine that calls `buildRouteUrl` itself must fill `params` itself.
 
 | Property                                   | Type                            | Description                                                                           | Defined in                                                                                                                                             |
 | ------------------------------------------ | ------------------------------- | ------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| <a id="property-basepath"></a> `basePath?` | `string`                        | The base path of a relative route                                                     | [packages/play-xstate/src/routing/types.ts:30](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/types.ts#L30) |
-| <a id="property-hash"></a> `hash?`         | `string`                        | The hash fragment                                                                     | [packages/play-xstate/src/routing/types.ts:36](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/types.ts#L36) |
-| <a id="property-params"></a> `params?`     | `Record`\<`string`, `unknown`\> | The parameters of the path to substitute, for example `:userId` of `/profile/:userId` | [packages/play-xstate/src/routing/types.ts:32](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/types.ts#L32) |
-| <a id="property-query"></a> `query?`       | `Record`\<`string`, `unknown`\> | The query parameters                                                                  | [packages/play-xstate/src/routing/types.ts:34](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/types.ts#L34) |
+| <a id="property-basepath"></a> `basePath?` | `string`                        | The base path of a relative route                                                     | [packages/play-xstate/src/routing/types.ts:30](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/types.ts#L30) |
+| <a id="property-hash"></a> `hash?`         | `string`                        | The hash fragment                                                                     | [packages/play-xstate/src/routing/types.ts:36](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/types.ts#L36) |
+| <a id="property-params"></a> `params?`     | `Record`\<`string`, `unknown`\> | The parameters of the path to substitute, for example `:userId` of `/profile/:userId` | [packages/play-xstate/src/routing/types.ts:32](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/types.ts#L32) |
+| <a id="property-query"></a> `query?`       | `Record`\<`string`, `unknown`\> | The query parameters                                                                  | [packages/play-xstate/src/routing/types.ts:34](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/types.ts#L34) |

package/api/@xmachines/play-xstate/with-routing/interfaces/RouteObject.md

@@ -2,7 +2,7 @@
 
 # Interface: RouteObject
 
-Defined in: [packages/play-router/src/types.ts:33](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-router/src/types.ts#L33)
+Defined in: [packages/play-router/src/types.ts:33](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-router/src/types.ts#L33)
 
 A route object, with more metadata.
 
@@ -15,20 +15,17 @@ A route object, with more metadata.
 The additional metadata of the route: a title, a breadcrumb, and so on.
 
 CAUTION: `path`, `handler`, `reenter` and `data` are RESERVED. The routing layer
-reads those four names, and a release before this one read `path` alone. A state
-that carries its own `handler` value now throws an `InvalidRouteHandlerError` from
-`formatPlayRouteTransitions`, so the machine builds never; a state that carries its
-own `data` value now writes that value to `context.data`, where the `/context`
-projection of every view reads it. A `reenter` value is read as the FLAG of the
-generated transition, and the literal `true` alone turns the reentry on: the
-default is `false`, and a release before this one generated every transition with
-`reenter: true`. Give such a field another name.
+reads those four names. An unknown `handler` value throws an
+`InvalidRouteHandlerError` from `formatPlayRouteTransitions`, so the machine builds
+never. A `data` value goes to `context.data`, where the `/context` projection of
+every view reads it. A `reenter` value is the FLAG of the generated transition, and
+the literal `true` alone turns the reentry on. Give a field of your own another name.
 
 ## Properties
 
-| Property                                 | Type                                                                                                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Defined in                                                                                                                               |
-| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-data"></a> `data?`       | \| [`RouteData`](../type-aliases/RouteData.md) \| [`RouteDataResolver`](../type-aliases/RouteDataResolver.md) | The extra data that the state threads into its `play.route` event. The shape follows `WithDynamicParams` of XState, which is how XState itself parameterizes an action and a guard: the field holds a literal value, OR a function of `{ context, event }` that returns one. `// The literal form. It survives a serialization of the machine. meta: { route: { path: "/doc/:docId", data: { titleKey: "doc.view" } } } // The function form, for a value that depends on the route. meta: { route: { path: "/doc/:docId", data: ({ event }) => ({ title: `Document ${event.params?.docId}` }), }, }` The generated transition resolves the value and assigns it to the `data` field of the context, beside `params` and `query`. The data of a state does NOT merge with the data of its ancestors: each state declares the whole value that its own route carries. This field and [PlayRouteEvent.data](../../../play-dom-router/interfaces/PlayRouteEvent.md#property-data) are two different things, and they meet in the resolver. This field is what the STATE declares, in its machine. `PlayRouteEvent.data` is what the SENDER of the event supplies, such as a router bridge or the code of an application. A resolver reads `event.data` and returns whatever mix of the two the state needs. CAUTION: the function form holds a function inside `meta`, and a function does not survive `JSON.stringify`. A machine that Stately Studio reads, or that a process sends over a wire, must use the literal form.                                                                                                                                                                                                                     | [packages/play-router/src/types.ts:131](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-router/src/types.ts#L131) |
-| <a id="property-handler"></a> `handler?` | `"root"` \| `"local"` \| `"both"`                                                                             | Where the generated `play.route` transition sits. `"root"` is the default, and it is what XState does: `formatRouteTransitions` installs every route transition on the ROOT of the machine, and each one targets its state by the ID. A route from any state therefore reaches this state. The cost is that the root is the domain of the transition, so XState re-enters each ancestor on the path to the target, and those ancestors run their `entry` actions again although they stay active. `"local"` installs the transition on the PARENT of this state instead, and it targets this state relatively. XState offers the transitions of the deepest active state node first, so the parent answers the event itself and runs its `exit` and its `entry` actions NOT again. `"both"` installs one transition in each place. The local one answers while the parent is active, and the root one answers a route that arrives from outside the parent. Use `"both"` where an ancestor holds an `entry` action that must run one time for each real entry, such as an analytics event or an audit record. CAUTION: `"local"` makes this state reachable by a route ONLY while its parent is active. A `play.route` event that arrives from anywhere else matches no transition and the actor does not move. A browser URL for this state therefore leaves the URL and the actor divergent. Choose `"local"` to SCOPE a route on purpose, for example a step that a person reaches only inside its wizard. Choose `"both"` where the state must stay reachable from everywhere. The field has no effect on a state whose parent IS the root: the root transition of such a state is already local to its parent, so all three values agree. | [packages/play-router/src/types.ts:95](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-router/src/types.ts#L95)   |
-| <a id="property-path"></a> `path`        | `string`                                                                                                      | The template of the route path, for example `"/user/:id"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | [packages/play-router/src/types.ts:35](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-router/src/types.ts#L35)   |
-| <a id="property-reenter"></a> `reenter?` | `boolean`                                                                                                     | The `reenter` flag of the generated `play.route` transition. The default is `false`, which is also the default of XState. The flag spares the DOMAIN of the transition, and not every ancestor that stays active. Under the default placement `handler: "root"` the domain is the root of the machine, so `false` spares the root alone: each ancestor BETWEEN the root and the target still runs its `exit` and its `entry` actions, because XState re-enters every descendant of the domain that lies on the path to the target. A move between two siblings therefore still runs the `entry` action of their shared parent. [RouteObject.handler](#property-handler) is the field that spares those intermediate ancestors: `"local"` and `"both"` move the domain down to the parent of the state. Use the two fields together where an `entry` action must run one time for each state that the actor really enters. Set the field to `true` where the domain must run its `entry` actions again on every route to a descendant. The flag does not decide the destination. The value of the machine after a route is identical under both settings. A route to a state that has children still enters the `initial` child of that state, because the generated transition targets the state by its id, and XState enters the initial child of an id target under both settings. **See** [Play RFC](../../../../../rfc/play.md)                                                                                                                                                                                                                                                                                                            | [packages/play-router/src/types.ts:64](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-router/src/types.ts#L64)   |
+| Property                                 | Type                                                                                                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Defined in                                                                                                                               |
+| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-data"></a> `data?`       | \| [`RouteData`](../type-aliases/RouteData.md) \| [`RouteDataResolver`](../type-aliases/RouteDataResolver.md) | The extra data that the state threads into its `play.route` event. The shape follows `WithDynamicParams` of XState, which is how XState itself parameterizes an action and a guard: the field holds a literal value, OR a function of `{ context, event }` that returns one. `// The literal form. It survives a serialization of the machine. meta: { route: { path: "/doc/:docId", data: { titleKey: "doc.view" } } } // The function form, for a value that depends on the route. meta: { route: { path: "/doc/:docId", data: ({ event }) => ({ title: `Document ${event.params?.docId}` }), }, }` The generated transition resolves the value and assigns it to the `data` field of the context, beside `params` and `query`. The data of a state does NOT merge with the data of its ancestors: each state declares the whole value that its own route carries. This field and [PlayRouteEvent.data](../../../play-dom-router/interfaces/PlayRouteEvent.md#property-data) are two different things, and they meet in the resolver. This field is what the STATE declares, in its machine. `PlayRouteEvent.data` is what the SENDER of the event supplies, such as a router bridge or the code of an application. A resolver reads `event.data` and returns whatever mix of the two the state needs. CAUTION: the function form holds a function inside `meta`, and a function does not survive `JSON.stringify`. A machine that Stately Studio reads, or that a process sends over a wire, must use the literal form.                                                                                                                                                                                                                                                                            | [packages/play-router/src/types.ts:134](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-router/src/types.ts#L134) |
+| <a id="property-handler"></a> `handler?` | `"root"` \| `"local"` \| `"both"`                                                                             | Where the generated `play.route` transition sits. `"root"` is the default, and it is what XState does: `formatRouteTransitions` installs every route transition on the ROOT of the machine, and each one targets its state by the ID. A route from any state therefore reaches this state. The cost is that the root is the domain of the transition, so XState re-enters each ancestor on the path to the target, and those ancestors run their `entry` actions again although they stay active. `"local"` installs the transition on the PARENT of this state instead, and it targets this state relatively. XState offers the transitions of the deepest active state node first, so the parent answers the event itself. The parent then runs its `exit` and its `entry` actions again only where the state declares `reenter: true`. `"both"` installs one transition in each place. The local one answers while the parent is active, and the root one answers a route that arrives from outside the parent. Use `"both"` where an ancestor holds an `entry` action that must run one time for each real entry, such as an analytics event or an audit record. CAUTION: `"local"` makes this state reachable by a route ONLY while its parent is active. A `play.route` event that arrives from anywhere else matches no transition and the actor does not move. A browser URL for this state therefore leaves the URL and the actor divergent. Choose `"local"` to SCOPE a route on purpose, for example a step that a person reaches only inside its wizard. Choose `"both"` where the state must stay reachable from everywhere. The field has no effect on a state whose parent IS the root: the root transition of such a state is already local to its parent, so all three values agree. | [packages/play-router/src/types.ts:98](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-router/src/types.ts#L98)   |
+| <a id="property-path"></a> `path`        | `string`                                                                                                      | The template of the route path, for example `"/user/:id"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | [packages/play-router/src/types.ts:35](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-router/src/types.ts#L35)   |
+| <a id="property-reenter"></a> `reenter?` | `boolean`                                                                                                     | The `reenter` flag of the generated `play.route` transition. The default is `false`, which is also the default of XState. The flag spares the DOMAIN of the transition, and not every ancestor that stays active. Under the default placement `handler: "root"` the domain is the root of the machine, so `false` spares the root alone: each ancestor BETWEEN the root and the target still runs its `exit` and its `entry` actions, because XState re-enters every descendant of the domain that lies on the path to the target. A move between two siblings therefore still runs the `entry` action of their shared parent. [RouteObject.handler](#property-handler) is the field that spares those intermediate ancestors: `"local"` and `"both"` move the domain down to the parent of the state, while the parent is active. Use the two fields together where an `entry` action must run one time for each state that the actor really enters. The target itself re-enters under both settings, so a route to the state that the actor already holds runs the `exit` and `entry` actions of that state again. The ROOT of the machine is the one exception: a route to the root has the root as its domain, so the flag decides. Set the field to `true` where the domain must run its `entry` actions again on each route to this state. The flag of a state applies to the routes to that state alone, and not to the routes to its descendants. The flag does not decide the destination. The value of the machine after a route is identical under both settings. A route to a state that has children still enters the `initial` child of that state, because XState enters the initial child of a compound target under both settings. **See** [Play RFC](../../../../../rfc/play.md)    | [packages/play-router/src/types.ts:67](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-router/src/types.ts#L67)   |

package/api/@xmachines/play-xstate/with-routing/type-aliases/RouteData.md

@@ -6,7 +6,7 @@
 type RouteData = Record<string, unknown>;
 ```
 
-Defined in: [packages/play-router/src/types.ts:15](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-router/src/types.ts#L15)
+Defined in: [packages/play-router/src/types.ts:15](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-router/src/types.ts#L15)
 
 The resolved extra data of a route. It reaches the consumer on the `data` field of a
 `play.route` event.

package/api/@xmachines/play-xstate/with-routing/type-aliases/RouteDataResolver.md

@@ -6,7 +6,7 @@
 type RouteDataResolver = (args) => RouteData;
 ```
 
-Defined in: [packages/play-router/src/types.ts:28](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-router/src/types.ts#L28)
+Defined in: [packages/play-router/src/types.ts:28](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-router/src/types.ts#L28)
 
 The function form of [RouteObject.data](../interfaces/RouteObject.md#property-data).
 

package/api/@xmachines/play-xstate/with-routing/type-aliases/RouteMachineConfig.md

@@ -6,7 +6,7 @@
 type RouteMachineConfig = object;
 ```
 
-Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:177](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L177)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:177](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L177)
 
 The minimal structural constraint of a machine config that
 `formatPlayRouteTransitions` accepts.
@@ -32,7 +32,7 @@ original concrete type through the transform. Therefore
 optional context?: unknown;
 ```
 
-Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:178](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L178)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:178](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L178)
 
 ---
 
@@ -42,7 +42,7 @@ Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:1
 optional on?: Record<string, unknown>;
 ```
 
-Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:180](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L180)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:180](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L180)
 
 ---
 
@@ -52,4 +52,4 @@ Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:1
 optional states?: Record<string, unknown>;
 ```
 
-Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:179](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L179)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:179](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L179)

package/api/@xmachines/play-xstate/with-routing/type-aliases/RouteMetadata.md

@@ -6,6 +6,6 @@
 type RouteMetadata = string | RouteObject;
 ```
 
-Defined in: [packages/play-router/src/types.ts:151](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-router/src/types.ts#L151)
+Defined in: [packages/play-router/src/types.ts:151](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-router/src/types.ts#L151)
 
 The route metadata of the `meta.route` field of a state machine.

package/api/@xmachines/play-xstate/with-routing/type-aliases/RouteStateNode.md

@@ -6,7 +6,7 @@
 type RouteStateNode = object;
 ```
 
-Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:30](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L30)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:30](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L30)
 
 The minimal structural shape of one XState state node, as
 `formatPlayRouteTransitions` reads it during its walk over the machine config.
@@ -29,7 +29,7 @@ signature without a change.
 optional id?: string;
 ```
 
-Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:34](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L34)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:34](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L34)
 
 The optional explicit state ID, for example `"home"` or `"settings"`. It is the `#id` target of a `play.route` event.
 
@@ -41,7 +41,7 @@ The optional explicit state ID, for example `"home"` or `"settings"`. It is the
 optional meta?: object;
 ```
 
-Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:36](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L36)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:36](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L36)
 
 The state metadata. A `meta.route` field gives the state a route.
 
@@ -64,7 +64,7 @@ generated transition, and that flag defaults to `false`.
 optional on?: Record<string, unknown>;
 ```
 
-Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:51](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L51)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:51](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L51)
 
 The event handlers of this state. The function reads them where a child asks for a
 local `play.route` handler, so that the transitions of the user survive the merge.
@@ -77,6 +77,6 @@ local `play.route` handler, so that the transitions of the user survive the merg
 optional states?: Record<string, RouteStateNode>;
 ```
 
-Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:46](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L46)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:46](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L46)
 
 The nested child states. The function walks them for each further route declaration.

package/api/@xmachines/play-xstate/with-view/functions/withView.md

@@ -6,15 +6,13 @@
 function withView<TMachine>(Base): PlayerConstructor<TMachine, Viewable>;
 ```
 
-Defined in: [packages/play-xstate/src/with-view.ts:99](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/play-xstate/src/with-view.ts#L99)
+Defined in: [packages/play-xstate/src/with-view.ts:97](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/with-view.ts#L97)
 
 Adds the view capability to an actor class.
 
 The ORDER of the composition does not matter. `currentView` and `currentRoute` are two
 computed atoms over `state`, and neither reads the other, so the engine evaluates both
-from one write in topological order. An earlier release wrote `currentView` from an
-`onSnapshot` override, and the order then decided which capability held its new value
-first.
+from one write in topological order.
 
 ## Type Parameters
 

package/api/@xmachines/shared/vite-aliases/README.md

@@ -2,10 +2,17 @@
 
 # vite-aliases
 
+## Type Aliases
+
+- [XmTestTarget](type-aliases/XmTestTarget.md)
+
 ## Functions
 
 - [xmAliases](functions/xmAliases.md)
+- [xmBuildOutput](functions/xmBuildOutput.md)
+- [xmBuildOutputFile](functions/xmBuildOutputFile.md)
 - [xmCacheDir](functions/xmCacheDir.md)
 - [xmOptimizeDeps](functions/xmOptimizeDeps.md)
 - [xmResolve](functions/xmResolve.md)
 - [xmSvelteRunes](functions/xmSvelteRunes.md)
+- [xmTestTarget](functions/xmTestTarget.md)

package/api/@xmachines/shared/vite-aliases/functions/xmAliases.md

@@ -3,10 +3,10 @@
 # Function: xmAliases()
 
 ```ts
-function xmAliases(importMetaUrl): Record<string, string>;
+function xmAliases(importMetaUrl, target?): Record<string, string>;
 ```
 
-Defined in: [vite-aliases.ts:238](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/shared/config/vite-aliases.ts#L238)
+Defined in: [vite-aliases.ts:292](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/shared/config/vite-aliases.ts#L292)
 
 Vite resolve.alias entries for all @xmachines/* workspace packages.
 
@@ -27,11 +27,17 @@ export default defineConfig({
 resolve: { alias: xmAliases(import.meta.url) },
 });
 
+The dist run (`XM_TEST_TARGET=dist`, see [xmTestTarget](xmTestTarget.md)) gets no entry for a
+published package, except `<name>/src`. Each `@xmachines/*` specifier of a published
+package then resolves through its `exports` map to `dist/`, and [xmBuildOutput](xmBuildOutput.md)
+moves each `src/` file that a test imports by path to its counterpart in `dist/`.
+
 ## Parameters
 
-| Parameter       | Type     | Description                                                                                                                    |
-| --------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------ |
-| `importMetaUrl` | `string` | Pass `import.meta.url` from the calling config file. Used to locate the workspace root (the directory containing `packages/`). |
+| Parameter       | Type                                              | Description                                                                                                                    |
+| --------------- | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| `importMetaUrl` | `string`                                          | Pass `import.meta.url` from the calling config file. Used to locate the workspace root (the directory containing `packages/`). |
+| `target`        | [`XmTestTarget`](../type-aliases/XmTestTarget.md) | The code to resolve to. The default reads `XM_TEST_TARGET`.                                                                    |
 
 ## Returns
 

package/api/@xmachines/shared/vite-aliases/functions/xmBuildOutput.md

@@ -0,0 +1,37 @@
+[API](../../../../README.md) / [@xmachines/shared](../../README.md) / [vite-aliases](../README.md) / xmBuildOutput
+
+# Function: xmBuildOutput()
+
+```ts
+function xmBuildOutput(importMetaUrl): Plugin;
+```
+
+Defined in: [vite-aliases.ts:388](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/shared/config/vite-aliases.ts#L388)
+
+The Vite plugin of the dist run: it moves each `src/` file of a published package to its
+counterpart in `dist/`.
+
+A specifier of a published package resolves through its `exports` map in the dist run (see
+[xmAliases](xmAliases.md)). A test also imports the module under test by path, as
+`../src/define-player.js`, and that import reaches no exports map. Without this plugin the
+test would exercise the source while every other import reads the build, and a class would
+exist two times, one copy for each tree. The plugin gives both imports the ONE file of
+`dist/`. A `vi.mock` of a `src/` path resolves through the same hook, so the mock replaces
+the module that the build output imports.
+
+A source file with no counterpart in `dist/` is a module that the build does not ship. The
+plugin then fails the import and names both files, because a fallback to the source would
+hide exactly the defect that the dist run exists to find.
+
+The plugin is part of every config of `defineXmVitestConfig` when `XM_TEST_TARGET` is
+`dist`, and of none when it is not.
+
+## Parameters
+
+| Parameter       | Type     | Description                                          |
+| --------------- | -------- | ---------------------------------------------------- |
+| `importMetaUrl` | `string` | Pass `import.meta.url` from the calling config file. |
+
+## Returns
+
+`Plugin`