@xmachines/docs 5.0.2 → 6.1.0

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

@@ -2,7 +2,7 @@
 
 # Class: MissingStateIdError
 
-Defined in: [packages/play-xstate/src/errors.ts:154](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/errors.ts#L154)
+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)
 
 `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:160](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/errors.ts#L160)
+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)
 
 #### Parameters
 
@@ -69,13 +69,13 @@ Defined in: [packages/play-xstate/src/errors.ts:160](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 `PLAY_<PACKAGE>_<DESCRIPTION>`. It 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/play/src/errors.ts:76](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play/src/errors.ts#L76)                 |
+| <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-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:158](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/errors.ts#L158) |
-| <a id="property-scope"></a> `scope`                     | `readonly` | `string`  | The class or the module that threw this error, for example `"RouterBridgeBase"`.                                                                                                                                                                                                                                                                                                                                                                  | [`PlayError`](../../../play/errors/classes/PlayError.md).[`scope`](../../../play/errors/classes/PlayError.md#property-scope)                     | [packages/play/src/errors.ts:66](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play/src/errors.ts#L66)                 |
+| <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-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:156](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/errors.ts#L156) |
+| <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-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/README.md

@@ -28,10 +28,6 @@ reactivity.
 - [PlayerConstructor](type-aliases/PlayerConstructor.md)
 - [PlayerFactory](type-aliases/PlayerFactory.md)
 
-## Variables
-
-- [DISPOSE](variables/DISPOSE.md)
-
 ## Functions
 
 - [compose](functions/compose.md)

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

@@ -2,7 +2,7 @@
 
 # Class: PlayerActor\<TMachine\>
 
-Defined in: [packages/play-xstate/src/player-actor.ts:160](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/player-actor.ts#L160)
+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)
 
 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:258](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/player-actor.ts#L258)
+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)
 
 #### Parameters
 
@@ -154,47 +154,12 @@ 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:224](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/player-actor.ts#L224) |
+| <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-system"></a> `system`       | `public` | [`AnyActorSystem`](https://www.jsdocs.io/package/xstate#AnyActorSystem)                                                                                                                                                                                                                                                  | The system to which this actor belongs.                                                                                                                                                                 | `Actor.system`    | -                                                                                                                                                      |
 | <a id="property-systemid"></a> `systemId`   | `public` | `string` \| `undefined`                                                                                                                                                                                                                                                                                                  | -                                                                                                                                                                                                       | `Actor.systemId`  | -                                                                                                                                                      |
 
 ## Methods
 
-### \[dispose\]()
-
-```ts
-dispose: void;
-```
-
-Defined in: [packages/play-xstate/src/player-actor.ts:622](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/player-actor.ts#L622)
-
-Stops the actor when the scope of a `using` declaration ends.
-
-The actor is a `Disposable`, so a scope that owns one writes no teardown:
-
-```ts
-{
-	using actor = definePlayer({ machine })();
-	actor.start();
-	actor.send({ type: "go" });
-	// stop() runs here, and it runs even when send() throws
-}
-```
-
-The release is [stop](#stop), which is synchronous and idempotent. `Disposable` and
-not `AsyncDisposable`: a `Disposable` serves `using` AND `await using`, while an
-`AsyncDisposable` raises a TypeError under a plain `using`.
-
-The key is `DISPOSE` of `@xmachines/play` and not a bare `Symbol.dispose`, so that
-the method still answers a `using` that a bundler downlevelled for a target without
-the well-known symbol.
-
-#### Returns
-
-`void`
-
----
-
 ### \[observable\]()
 
 ```ts
@@ -221,7 +186,7 @@ Actor.[observable]
 can(event): boolean;
 ```
 
-Defined in: [packages/play-xstate/src/player-actor.ts:237](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/player-actor.ts#L237)
+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)
 
 Tells you if the current state of the actor accepts the given event.
 
@@ -252,7 +217,7 @@ if (actor.can({ type: "auth.logout" })) { ... }
 getPersistedSnapshot(options?): Snapshot<unknown>;
 ```
 
-Defined in: [packages/play-xstate/src/player-actor.ts:571](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/player-actor.ts#L571)
+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)
 
 Returns the persisted snapshot of this actor.
 
@@ -386,7 +351,7 @@ Actor.select;
 send(event): void;
 ```
 
-Defined in: [packages/play-xstate/src/player-actor.ts:448](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/player-actor.ts#L448)
+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)
 
 Sends an event to this actor.
 
@@ -438,7 +403,7 @@ Actor.send;
 start(): this;
 ```
 
-Defined in: [packages/play-xstate/src/player-actor.ts:374](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/player-actor.ts#L374)
+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)
 
 Starts the actor.
 
@@ -466,7 +431,7 @@ Actor.start;
 stop(): this;
 ```
 
-Defined in: [packages/play-xstate/src/player-actor.ts:404](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/player-actor.ts#L404)
+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)
 
 Stops the actor and cleans up.
 
@@ -497,7 +462,7 @@ Actor.stop;
 subscribe(observer): Subscription;
 ```
 
-Defined in: [packages/play-xstate/src/player-actor.ts:509](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/player-actor.ts#L509)
+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)
 
 Subscribes to the snapshot updates of this actor.
 
@@ -531,7 +496,7 @@ subscribe(
 ): Subscription;
 ```
 
-Defined in: [packages/play-xstate/src/player-actor.ts:520](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.2/packages/play-xstate/src/player-actor.ts#L520)
+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)
 
 Subscribes to the snapshot updates of this actor.
 

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

@@ -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/v5.0.2/packages/play-xstate/src/capabilities.ts#L103)
+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)
 
 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/v5.0.2/packages/play-xstate/src/capabilities.ts#L106)
+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)
 
 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/v5.0.2/packages/play-xstate/src/capabilities.ts#L110)
+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)
 
 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/v5.0.2/packages/play-xstate/src/capabilities.ts#L115)
+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)
 
 Builds an actor class from a base and a list of capabilities.
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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