@xmachines/docs 6.1.0 → 8.0.0-next.1

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.1.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/docs-v8.0.0-next.1/packages/play-xstate/src/types.ts#L8)
 
 The configuration of definePlayer()
 
@@ -15,8 +15,8 @@ The configuration of definePlayer()
 
 ## Properties
 
-| 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.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) |
+| 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/docs-v8.0.0-next.1/packages/play-xstate/src/types.ts#L31) |
+| <a id="property-machine"></a> `machine`  | `TMachine`                                                                                 | The XState v6 state machine                                                                                                                                                                                                                                                                                                                                                                                                        | [packages/play-xstate/src/types.ts:13](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/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/docs-v8.0.0-next.1/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.1.0/packages/play-xstate/src/types.ts#L134)
+Defined in: [packages/play-xstate/src/types.ts:137](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/types.ts#L137)
 
 The optional restore arguments of the player factory.
 
@@ -17,6 +17,6 @@ The shape follows the options object of `createActor` in XState. It also keeps t
 
 ## Properties
 
-| 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.1.0/packages/play-xstate/src/types.ts#L142) |
+| Property                                   | Type                                                                                               | Description                                                                                                                                                                                                                                                                                     | Defined in                                                                                                                                           |
+| ------------------------------------------ | -------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-snapshot"></a> `snapshot?` | Snapshot\<unknown, unknown\> & Partial\<RestorablePersistedSnapshotFor\<DoNotInfer\<TMachine\>\>\> | 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:145](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/types.ts#L145) |

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.1.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/docs-v8.0.0-next.1/packages/play-xstate/src/types.ts#L37)
 
 The lifecycle hooks of the player — the observability surface around the actor.
 
@@ -14,11 +14,11 @@ The lifecycle hooks of the player — the observability surface around the actor
 
 ## Properties
 
-| 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.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)   |
+| 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 type { InspectionEvent } from "xstate"; const inspect = (event: InspectionEvent) => { if (event.type === "@xstate.transition") console.log(event.eventType, event.snapshot); }; 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:128](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/types.ts#L128) |
+| <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:91](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/types.ts#L91)   |
+| <a id="property-onstart"></a> `onStart?`             | (`actor`) => `void`                                                                                                    | The actor calls it on the real start, which is the transition from "not started" to "running". A second `start()` call while the actor runs fires the hook not again. XState 6 starts an actor one time only, so a `start()` after a `stop()` throws and fires no hook.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | [packages/play-xstate/src/types.ts:44](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/types.ts#L44)   |
+| <a id="property-onstatechange"></a> `onStateChange?` | (`actor`, `state`) => `void`                                                                                           | The actor calls it when the state atom changes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | [packages/play-xstate/src/types.ts:66](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/types.ts#L66)   |
+| <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:51](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/types.ts#L51)   |
+| <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:59](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/types.ts#L59)   |

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.1.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/docs-v8.0.0-next.1/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.1.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/docs-v8.0.0-next.1/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.1.0/packages/play-xstate/src/types.ts#L154)
+Defined in: [packages/play-xstate/src/types.ts:157](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/types.ts#L157)
 
 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.1.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/docs-v8.0.0-next.1/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.1.0/packages/play-xstate/src/routing/derive-route.ts#L93)
+Defined in: [packages/play-xstate/src/routing/derive-route.ts:101](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/routing/derive-route.ts#L101)
 
 Derives the route from the metadata of an XState state
 
@@ -38,9 +38,15 @@ The basic read of a route
 
 ```typescript
 import { deriveRoute } from "@xmachines/play-xstate/routing";
-import { setup } from "xstate";
+import { createActor, setup, types } from "xstate";
 
-const machine = setup({}).createMachine({
+// XState 6 types `meta` from `schemas.meta`.
+const routed = setup({
+	schemas: { meta: types<{ route?: RouteMetadata; view?: unknown }>() },
+});
+
+const machine = routed.createMachine({
+	initial: "about",
 	states: {
 		about: {
 			meta: { route: "/about", view: { component: "AboutPage" } },
@@ -60,7 +66,8 @@ console.log(route); // "/about"
 A route with a parameter
 
 ```typescript
-const machine = setup({}).createMachine({
+const machine = routed.createMachine({
+	initial: "profile",
 	states: {
 		profile: {
 			meta: {
@@ -78,7 +85,8 @@ console.log(route); // "/profile/:userId" — the template, before the substitut
 The object form of a route
 
 ```typescript
-const machine = setup({}).createMachine({
+const machine = routed.createMachine({
+	initial: "dashboard",
 	states: {
 		dashboard: {
 			meta: {

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.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L216)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:249](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/routing/format-play-route-transitions.ts#L249)
 
 Makes the play.route transitions from the declarative route configs
 
@@ -14,8 +14,9 @@ The function walks the machine states. It looks for each state with a `meta.rout
 field, and it generates the transitions that handle a `play.route` event: each
 transition matches event.to against a state ID.
 
-The internal formatRouteTransitions function of XState was the model for this
-function (stateUtils.ts, line 391).
+The route transitions of XState 5 were the model for this function. XState 6 has
+route states of its own, with the `xstate.route` event; this function keeps the
+`play.route` event, which carries the params and the query of a URL.
 
 ## Type Parameters
 
@@ -38,20 +39,32 @@ The same machine config, with the generated `play.route` handlers in it. The ori
 ## Example
 
 ```typescript
-const machineConfig = {
-	id: "myMachine",
-	states: {
-		home: { id: "home", meta: { route: "/home" } },
-		dashboard: { id: "dashboard", meta: { route: "/dashboard" } },
+const machine = setup({
+	schemas: {
+		events: { "play.route": types<Omit<PlayRouteEvent, "type">>() },
+		meta: types<{ route?: RouteMetadata }>(),
 	},
-};
-
-const machine = createMachine(formatPlayRouteTransitions(machineConfig));
+}).createMachine(
+	formatPlayRouteTransitions({
+		id: "myMachine",
+		initial: "home",
+		context: { params: {}, query: {} },
+		states: {
+			home: { id: "home", meta: { route: "/home" } },
+			dashboard: { id: "dashboard", meta: { route: "/dashboard" } },
+		},
+	}),
+);
 ```
 
 The function generates the `play.route` handlers at the root level. Those
 handlers:
 
-- match event.to against a state ID, for example event.to === "#home"
+- match event.to against a state ID, with `matches: { to: "#home" }`
 - target the correct state
-- assign the params and the query of the event to the context
+- write the params and the query of the event into the context, with a context patch
+
+The `play.route` entry of the result is a LIST of transitions: the generated ones,
+then the transition of the user. The config types of XState 6 declare one transition
+for each event, and its runtime reads a list in its order, as it does for a JSON
+config. The return type is therefore `T`, the type of the config of the caller.

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.1.0/packages/play-xstate/src/routing/derive-route.ts#L269)
+Defined in: [packages/play-xstate/src/routing/derive-route.ts:277](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/routing/derive-route.ts#L277)
 
 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.1.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/docs-v8.0.0-next.1/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.1.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/docs-v8.0.0-next.1/packages/play-xstate/src/routing/types.ts#L28)
 
 The context of the route construction, from the machine context.
 
@@ -12,14 +12,14 @@ the compiler therefore checks the shape of a context, and the IDE completes each
 context field.
 
 A machine with `formatPlayRouteTransitions` receives its `params` field and its
-`query` field from each `play.route` event, and the transitions assign them. A
+`query` field from each `play.route` event, and the transitions write them. A
 machine that calls `buildRouteUrl` itself must fill `params` itself.
 
 ## Properties
 
-| 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.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) |
+| 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/docs-v8.0.0-next.1/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/docs-v8.0.0-next.1/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/docs-v8.0.0-next.1/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/docs-v8.0.0-next.1/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.1.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/docs-v8.0.0-next.1/packages/play-router/src/types.ts#L33)
 
 A route object, with more metadata.
 
@@ -23,9 +23,9 @@ the literal `true` alone turns the reentry on. Give a field of your own another
 
 ## 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: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)   |
+| 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/docs-v8.0.0-next.1/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/docs-v8.0.0-next.1/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/docs-v8.0.0-next.1/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/docs-v8.0.0-next.1/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.1.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/docs-v8.0.0-next.1/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.1.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/docs-v8.0.0-next.1/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.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L177)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:197](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/routing/format-play-route-transitions.ts#L197)
 
 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.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L178)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:198](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/routing/format-play-route-transitions.ts#L198)
 
 ---
 
@@ -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.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L180)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:200](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/routing/format-play-route-transitions.ts#L200)
 
 ---
 
@@ -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.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L179)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:199](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/routing/format-play-route-transitions.ts#L199)

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.1.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/docs-v8.0.0-next.1/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.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L30)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:29](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/routing/format-play-route-transitions.ts#L29)
 
 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.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L34)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:33](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/routing/format-play-route-transitions.ts#L33)
 
 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.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L36)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:35](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/routing/format-play-route-transitions.ts#L35)
 
 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.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L51)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:50](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/routing/format-play-route-transitions.ts#L50)
 
 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.1.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L46)
+Defined in: [packages/play-xstate/src/routing/format-play-route-transitions.ts:45](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/routing/format-play-route-transitions.ts#L45)
 
 The nested child states. The function walks them for each further route declaration.

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

@@ -6,7 +6,7 @@
 function withView<TMachine>(Base): PlayerConstructor<TMachine, Viewable>;
 ```
 
-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)
+Defined in: [packages/play-xstate/src/with-view.ts:61](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/with-view.ts#L61)
 
 Adds the view capability to an actor class.
 

package/api/@xmachines/shared/README.md

@@ -126,6 +126,7 @@ Use `xmAliases` for the aliases alone. Use `xmResolve` for a resolve config that
 In a browser test project, use `xmOptimizeDeps` to bundle the packages in advance. The optimizer then does not restart during a run. Use `xmCacheDir` to share one Vite dependency cache across the workspace:
 
 ```typescript
+import { defineConfig } from "vite";
 import { xmResolve, xmOptimizeDeps, xmCacheDir } from "@xmachines/shared/vite-aliases";
 
 export default defineConfig({

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

@@ -6,7 +6,7 @@
 function xmAliases(importMetaUrl, target?): Record<string, string>;
 ```
 
-Defined in: [vite-aliases.ts:292](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/shared/config/vite-aliases.ts#L292)
+Defined in: [vite-aliases.ts:292](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/shared/config/vite-aliases.ts#L292)
 
 Vite resolve.alias entries for all @xmachines/* workspace packages.