npm - @xmachines/docs - Versions diffs - 6.1.0 → 7.0.0 - Mend

@xmachines/docs 6.1.0 → 7.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (595) hide show

package/api/@xmachines/play-xstate/errors/classes/MissingStateIdError.md CHANGED Viewed

@@ -2,7 +2,7 @@
 # Class: MissingStateIdError
-Defined in: [packages/play-xstate/src/errors.ts:135](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/errors.ts#L135)
+Defined in: [packages/play-xstate/src/errors.ts:135](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/errors.ts#L135)
 `formatPlayRouteTransitions()` throws this error when a state node declares a
 `meta.route` field but no explicit `id` field.
@@ -47,7 +47,7 @@ states: {
 new MissingStateIdError(stateKey, route): MissingStateIdError;
 ```
-Defined in: [packages/play-xstate/src/errors.ts:141](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/errors.ts#L141)
+Defined in: [packages/play-xstate/src/errors.ts:141](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/errors.ts#L141)
 #### Parameters
@@ -69,13 +69,13 @@ Defined in: [packages/play-xstate/src/errors.ts:141](https://gitlab.com/xmachin-
 | Property                                                | Modifier   | Type      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                       | Inherited from                                                                                                                                   | Defined in                                                                                                                                 |
 | ------------------------------------------------------- | ---------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
 | <a id="property-cause"></a> `cause?`                    | `public`   | `unknown` | -                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [`PlayError`](../../../play/errors/classes/PlayError.md).[`cause`](../../../play/errors/classes/PlayError.md#property-cause)                     | -                                                                                                                                          |
-| <a id="property-code"></a> `code`                       | `readonly` | `string`  | A stable, machine-readable identifier of the error. An error code follows the naming convention `<PACKAGE>_<DESCRIPTION>`, and a Play package writes `PLAY_<PACKAGE>_<DESCRIPTION>`. A code stays the same across each patch release and each minor release of one major version. Never match on `.message`. Always match on `.code`, or on the subclass.                                                                                         | [`PlayError`](../../../play/errors/classes/PlayError.md).[`code`](../../../play/errors/classes/PlayError.md#property-code)                       | [packages/core/src/errors.ts:56](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/core/src/errors.ts#L56)                 |
+| <a id="property-code"></a> `code`                       | `readonly` | `string`  | A stable, machine-readable identifier of the error. An error code follows the naming convention `<PACKAGE>_<DESCRIPTION>`, and a Play package writes `PLAY_<PACKAGE>_<DESCRIPTION>`. A code stays the same across each patch release and each minor release of one major version. Never match on `.message`. Always match on `.code`, or on the subclass.                                                                                         | [`PlayError`](../../../play/errors/classes/PlayError.md).[`code`](../../../play/errors/classes/PlayError.md#property-code)                       | [packages/core/src/errors.ts:56](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/core/src/errors.ts#L56)                 |
 | <a id="property-message"></a> `message`                 | `public`   | `string`  | -                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [`PlayError`](../../../play/errors/classes/PlayError.md).[`message`](../../../play/errors/classes/PlayError.md#property-message)                 | -                                                                                                                                          |
 | <a id="property-name"></a> `name`                       | `public`   | `string`  | -                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [`PlayError`](../../../play/errors/classes/PlayError.md).[`name`](../../../play/errors/classes/PlayError.md#property-name)                       | -                                                                                                                                          |
-| <a id="property-route"></a> `route`                     | `readonly` | `string`  | The route template of the state, for example `"/profile/:username"`.                                                                                                                                                                                                                                                                                                                                                                              | -                                                                                                                                                | [packages/play-xstate/src/errors.ts:139](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/errors.ts#L139) |
-| <a id="property-scope"></a> `scope`                     | `readonly` | `string`  | The class or the module that threw this error, for example `"asDisposable"`.                                                                                                                                                                                                                                                                                                                                                                      | [`PlayError`](../../../play/errors/classes/PlayError.md).[`scope`](../../../play/errors/classes/PlayError.md#property-scope)                     | [packages/core/src/errors.ts:46](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/core/src/errors.ts#L46)                 |
+| <a id="property-route"></a> `route`                     | `readonly` | `string`  | The route template of the state, for example `"/profile/:username"`.                                                                                                                                                                                                                                                                                                                                                                              | -                                                                                                                                                | [packages/play-xstate/src/errors.ts:139](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/errors.ts#L139) |
+| <a id="property-scope"></a> `scope`                     | `readonly` | `string`  | The class or the module that threw this error, for example `"asDisposable"`.                                                                                                                                                                                                                                                                                                                                                                      | [`PlayError`](../../../play/errors/classes/PlayError.md).[`scope`](../../../play/errors/classes/PlayError.md#property-scope)                     | [packages/core/src/errors.ts:46](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/core/src/errors.ts#L46)                 |
 | <a id="property-stack"></a> `stack?`                    | `public`   | `string`  | -                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [`PlayError`](../../../play/errors/classes/PlayError.md).[`stack`](../../../play/errors/classes/PlayError.md#property-stack)                     | -                                                                                                                                          |
-| <a id="property-statekey"></a> `stateKey`               | `readonly` | `string`  | The state key, which is the position in the tree of the states, without an explicit `id` field.                                                                                                                                                                                                                                                                                                                                                   | -                                                                                                                                                | [packages/play-xstate/src/errors.ts:137](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/errors.ts#L137) |
+| <a id="property-statekey"></a> `stateKey`               | `readonly` | `string`  | The state key, which is the position in the tree of the states, without an explicit `id` field.                                                                                                                                                                                                                                                                                                                                                   | -                                                                                                                                                | [packages/play-xstate/src/errors.ts:137](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/errors.ts#L137) |
 | <a id="property-stacktracelimit"></a> `stackTraceLimit` | `static`   | `number`  | The `Error.stackTraceLimit` property specifies the number of stack frames collected by a stack trace (whether generated by `new Error().stack` or `Error.captureStackTrace(obj)`). The default value is `10` but may be set to any valid JavaScript number. Changes will affect any stack trace captured _after_ the value has been changed. If set to a non-number value, or set to a negative number, stack traces will not capture any frames. | [`PlayError`](../../../play/errors/classes/PlayError.md).[`stackTraceLimit`](../../../play/errors/classes/PlayError.md#property-stacktracelimit) | -                                                                                                                                          |
 ## Methods

package/api/@xmachines/play-xstate/index/classes/PlayerActor.md CHANGED Viewed

@@ -2,7 +2,7 @@
 # Class: PlayerActor\<TMachine\>
-Defined in: [packages/play-xstate/src/player-actor.ts:144](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/player-actor.ts#L144)
+Defined in: [packages/play-xstate/src/player-actor.ts:144](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/player-actor.ts#L144)
 The concrete XState actor. It implements the atom protocol of the Play Architecture
@@ -121,7 +121,7 @@ new PlayerActor<TMachine>(
 ): PlayerActor<TMachine>;
 ```
-Defined in: [packages/play-xstate/src/player-actor.ts:242](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/player-actor.ts#L242)
+Defined in: [packages/play-xstate/src/player-actor.ts:242](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/player-actor.ts#L242)
 #### Parameters
@@ -154,7 +154,7 @@ Actor<TMachine>.constructor
 | <a id="property-ref"></a> `ref`             | `public` | [`ActorRef`](https://www.jsdocs.io/package/xstate#ActorRef)\<[`SnapshotFrom`](https://www.jsdocs.io/package/xstate#SnapshotFrom)\<`TMachine`\>, [`EventFromLogic`](https://www.jsdocs.io/package/xstate#EventFromLogic)\<`TMachine`\>, [`EmittedFrom`](https://www.jsdocs.io/package/xstate#EmittedFrom)\<`TMachine`\>\> | -                                                                                                                                                                                                       | `Actor.ref`       | -                                                                                                                                                      |
 | <a id="property-sessionid"></a> `sessionId` | `public` | `string`                                                                                                                                                                                                                                                                                                                 | The globally unique process ID for this invocation.                                                                                                                                                     | `Actor.sessionId` | -                                                                                                                                                      |
 | <a id="property-src"></a> `src`             | `public` | \| `string` \| [`AnyActorLogic`](https://www.jsdocs.io/package/xstate#AnyActorLogic)                                                                                                                                                                                                                                     | -                                                                                                                                                                                                       | `Actor.src`       | -                                                                                                                                                      |
-| <a id="property-state"></a> `state`         | `public` | [`Atom`](../../../play-atom/interfaces/Atom.md)\<`ReturnType`\<`TMachine`\[`"transition"`\]\>\>                                                                                                                                                                                                                          | The reactive snapshot of the current actor state. The infrastructure observes this atom, and it reacts to each state change. It therefore holds no coupling to the internal state machine of the actor. | -                 | [packages/play-xstate/src/player-actor.ts:208](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/player-actor.ts#L208) |
+| <a id="property-state"></a> `state`         | `public` | [`Atom`](../../../play-atom/interfaces/Atom.md)\<`ReturnType`\<`TMachine`\[`"transition"`\]\>\>                                                                                                                                                                                                                          | The reactive snapshot of the current actor state. The infrastructure observes this atom, and it reacts to each state change. It therefore holds no coupling to the internal state machine of the actor. | -                 | [packages/play-xstate/src/player-actor.ts:208](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/player-actor.ts#L208) |
 | <a id="property-system"></a> `system`       | `public` | [`AnyActorSystem`](https://www.jsdocs.io/package/xstate#AnyActorSystem)                                                                                                                                                                                                                                                  | The system to which this actor belongs.                                                                                                                                                                 | `Actor.system`    | -                                                                                                                                                      |
 | <a id="property-systemid"></a> `systemId`   | `public` | `string` \| `undefined`                                                                                                                                                                                                                                                                                                  | -                                                                                                                                                                                                       | `Actor.systemId`  | -                                                                                                                                                      |
@@ -186,7 +186,7 @@ Actor.[observable]
 can(event): boolean;
 ```
-Defined in: [packages/play-xstate/src/player-actor.ts:221](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/player-actor.ts#L221)
+Defined in: [packages/play-xstate/src/player-actor.ts:221](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/player-actor.ts#L221)
 Tells you if the current state of the actor accepts the given event.
@@ -217,7 +217,7 @@ if (actor.can({ type: "auth.logout" })) { ... }
 getPersistedSnapshot(options?): Snapshot<unknown>;
 ```
-Defined in: [packages/play-xstate/src/player-actor.ts:555](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/player-actor.ts#L555)
+Defined in: [packages/play-xstate/src/player-actor.ts:555](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/player-actor.ts#L555)
 Returns the persisted snapshot of this actor.
@@ -351,7 +351,7 @@ Actor.select;
 send(event): void;
 ```
-Defined in: [packages/play-xstate/src/player-actor.ts:432](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/player-actor.ts#L432)
+Defined in: [packages/play-xstate/src/player-actor.ts:432](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/player-actor.ts#L432)
 Sends an event to this actor.
@@ -403,7 +403,7 @@ Actor.send;
 start(): this;
 ```
-Defined in: [packages/play-xstate/src/player-actor.ts:358](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/player-actor.ts#L358)
+Defined in: [packages/play-xstate/src/player-actor.ts:358](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/player-actor.ts#L358)
 Starts the actor.
@@ -431,7 +431,7 @@ Actor.start;
 stop(): this;
 ```
-Defined in: [packages/play-xstate/src/player-actor.ts:388](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/player-actor.ts#L388)
+Defined in: [packages/play-xstate/src/player-actor.ts:388](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/player-actor.ts#L388)
 Stops the actor and cleans up.
@@ -462,7 +462,7 @@ Actor.stop;
 subscribe(observer): Subscription;
 ```
-Defined in: [packages/play-xstate/src/player-actor.ts:493](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/player-actor.ts#L493)
+Defined in: [packages/play-xstate/src/player-actor.ts:493](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/player-actor.ts#L493)
 Subscribes to the snapshot updates of this actor.
@@ -496,7 +496,7 @@ subscribe(
 ): Subscription;
 ```
-Defined in: [packages/play-xstate/src/player-actor.ts:504](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/player-actor.ts#L504)
+Defined in: [packages/play-xstate/src/player-actor.ts:504](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/player-actor.ts#L504)
 Subscribes to the snapshot updates of this actor.

package/api/@xmachines/play-xstate/index/functions/compose.md CHANGED Viewed

@@ -8,7 +8,7 @@
 function compose<TMachine>(Base): PlayerConstructor<TMachine>;
 ```
-Defined in: [packages/play-xstate/src/capabilities.ts:103](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/capabilities.ts#L103)
+Defined in: [packages/play-xstate/src/capabilities.ts:103](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/capabilities.ts#L103)
 Builds an actor class from a base and a list of capabilities.
@@ -59,7 +59,7 @@ applies them from left to right.
 function compose<TMachine, TC1>(Base, c1): PlayerConstructor<TMachine, TC1>;
 ```
-Defined in: [packages/play-xstate/src/capabilities.ts:106](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/capabilities.ts#L106)
+Defined in: [packages/play-xstate/src/capabilities.ts:106](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/capabilities.ts#L106)
 Builds an actor class from a base and a list of capabilities.
@@ -112,7 +112,7 @@ applies them from left to right.
 function compose<TMachine, TC1, TC2>(Base, c1, c2): PlayerConstructor<TMachine, TC1 & TC2>;
 ```
-Defined in: [packages/play-xstate/src/capabilities.ts:110](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/capabilities.ts#L110)
+Defined in: [packages/play-xstate/src/capabilities.ts:110](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/capabilities.ts#L110)
 Builds an actor class from a base and a list of capabilities.
@@ -172,7 +172,7 @@ function compose<TMachine, TC1, TC2, TC3>(
 ): PlayerConstructor<TMachine, TC1 & TC2 & TC3>;
 ```
-Defined in: [packages/play-xstate/src/capabilities.ts:115](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/capabilities.ts#L115)
+Defined in: [packages/play-xstate/src/capabilities.ts:115](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/capabilities.ts#L115)
 Builds an actor class from a base and a list of capabilities.

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

@@ -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.1.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/v7.0.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.1.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/v7.0.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 CHANGED Viewed

@@ -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/v7.0.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.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) |
+| <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/v7.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/v7.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/v7.0.0/packages/play-xstate/src/types.ts#L16) |

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

@@ -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:134](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.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.1.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/v7.0.0/packages/play-xstate/src/types.ts#L142) |

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

@@ -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/v7.0.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.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)   |
+| <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/v7.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/v7.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/v7.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/v7.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/v7.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/v7.0.0/packages/play-xstate/src/types.ts#L58)   |

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

@@ -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/v7.0.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 CHANGED Viewed

@@ -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/v7.0.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 CHANGED Viewed

@@ -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:154](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.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 CHANGED Viewed

@@ -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/v7.0.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 CHANGED Viewed

@@ -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:93](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.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 CHANGED Viewed

@@ -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:216](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.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 CHANGED Viewed

@@ -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:269](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.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 CHANGED Viewed

@@ -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/v7.0.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 CHANGED Viewed

@@ -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/v7.0.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.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) |
+| <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/v7.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/v7.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/v7.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/v7.0.0/packages/play-xstate/src/routing/types.ts#L34) |

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

@@ -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/v7.0.0/packages/play-router/src/types.ts#L33)
 A route object, with more metadata.
@@ -25,7 +25,7 @@ the literal `true` alone turns the reentry on. Give a field of your own another
 | 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)   |
+| <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/v7.0.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/v7.0.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/v7.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, 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/v7.0.0/packages/play-router/src/types.ts#L67)   |

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

@@ -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/v7.0.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 CHANGED Viewed

@@ -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/v7.0.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 CHANGED Viewed

@@ -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:177](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.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.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:178](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.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.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:180](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.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.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:179](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v7.0.0/packages/play-xstate/src/routing/format-play-route-transitions.ts#L179)

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

@@ -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/v7.0.0/packages/play-router/src/types.ts#L151)
 The route metadata of the `meta.route` field of a state machine.