@xmachines/docs 6.1.0 → 8.0.0-next.1

package/api/@xmachines/play-xstate/README.md

@@ -2,20 +2,21 @@
 
 # @xmachines/play-xstate
 
-> XState v5 adapter for the XMachines Play Architecture. It binds a state machine to the actor base, with atom-driven reactivity and a router integration.
+> XState v6 adapter for the XMachines Play Architecture. It binds a state machine to the actor base, with atom-driven reactivity and a router integration.
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-6.1.0-blue)](https://www.npmjs.com/package/@xmachines/play-xstate)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-8.0.0--next.1-blue)](https://www.npmjs.com/package/@xmachines/play-xstate)
 
 ---
 
-> **Browser floor: Chrome 110, Firefox 115, Safari 16.4.** This package calls the ES2023
-> change-by-copy array methods, so a browser below that floor throws
-> `TypeError: ... is not a function`. The root README carries the table.
+> **Browser floor:** the table of the root README covers this package. Its own code calls
+> no ES2023 change-by-copy array method, and its routing capability imports only types from
+> [`@xmachines/play-router`](../play-router/README.md). A router bridge of play-router sets
+> the floor of the table.
 
 ## Installation
 
 ```bash
-pnpm add @xmachines/play-xstate @xmachines/core @xmachines/play @xmachines/play-atom xstate
+pnpm add @xmachines/play-xstate @xmachines/core @xmachines/play @xmachines/play-atom xstate@6.0.0-alpha.71
 ```
 
 **Peer dependencies.** Install them with the package:
@@ -23,7 +24,7 @@ pnpm add @xmachines/play-xstate @xmachines/core @xmachines/play @xmachines/play-
 - [`@xmachines/core`](../core/README.md) — the base package. This package reads the helpers of its `utils` subpath.
 - [`@xmachines/play`](../play/README.md) — the core protocol. This package reads the error classes from its `errors` subpath.
 - [`@xmachines/play-atom`](../play-atom/README.md) — the atom primitives. `PlayerActor` holds `currentView` and `currentRoute` as atoms.
-- `xstate` ^5.33.0 — the XState v5 runtime.
+- `xstate` 6.0.0-alpha.71 — the XState v6 runtime. The peer range names this one prerelease, because each alpha of XState 6 can change its API.
 
 **Optional peers.** Each capability subpath carries one. Install it when you read that subpath, and not before:
 
@@ -40,15 +41,17 @@ pnpm add @xmachines/play-view     # @xmachines/play-xstate/view
 ## Quick Start
 
 ```typescript
-import { setup } from "xstate";
+import { setup, types } from "xstate";
 import { definePlayer, compose, PlayerActor } from "@xmachines/play-xstate";
 import { withRouting } from "@xmachines/play-xstate/routing";
 
-// 1. Define your XState v5 machine
-const machine = setup({}).createMachine({
+// 1. Define your XState v6 machine. `schemas.meta` types the `meta` of each state.
+const machine = setup({
+	schemas: { meta: types<{ route?: string }>() },
+}).createMachine({
 	initial: "idle",
 	states: {
-		idle: { meta: { route: "/" }, on: { activate: "active" } },
+		idle: { meta: { route: "/" }, on: { activate: { target: "active" } } },
 		active: { meta: { route: "/active" } },
 	},
 });
@@ -76,16 +79,16 @@ actor.stop();
 
 ### `definePlayer(config)`
 
-This function creates a `PlayerFactory` from an XState v5 machine. One configuration can therefore make more than one independent actor instance. This helps with a multi-user application, with SSR, and with a test.
+This function creates a `PlayerFactory` from an XState v6 machine. One configuration can therefore make more than one independent actor instance. This helps with a multi-user application, with SSR, and with a test.
 
 ```typescript
-import { setup } from "xstate";
+import { setup, types } from "xstate";
 import { definePlayer } from "@xmachines/play-xstate";
 
 const machine = setup({
-	types: {
-		context: {} as { userId: string },
-		input: {} as { userId: string },
+	schemas: {
+		context: types<{ userId: string }>(),
+		input: types<{ userId: string }>(),
 	},
 }).createMachine({
 	context: ({ input }) => ({ userId: input.userId }),
@@ -101,7 +104,7 @@ const createPlayer = definePlayer({
 		onTransition: (actor, prev, next) => console.log("transitioned"),
 		onStateChange: (actor, state) => console.log("state changed"),
 		onError: (actor, err) => console.error(err),
-		inspect: (event) => console.log(event.type), // handed to XState's actor constructor — enables @statelyai/inspect
+		inspect: (event) => console.log(event.type), // handed to XState's actor constructor: "@xstate.actor" or "@xstate.transition"
 	},
 });
 
@@ -117,21 +120,36 @@ machine cannot be `undefined`, the first argument of the factory is necessary. A
 input is then a compile error, not an actor that stops in an error status.
 
 ```typescript
-type PlayerFactory<TMachine> =
+import type { AnyStateMachine, InputFrom } from "xstate";
+import type { PlayerActor, PlayerFactoryResumeOptions } from "@xmachines/play-xstate";
+
+type PlayerFactory<TMachine extends AnyStateMachine, TCapabilities extends object = object> =
 	undefined extends InputFrom<TMachine>
 		? (
 				input?: InputFrom<TMachine>,
 				options?: PlayerFactoryResumeOptions<TMachine>,
-			) => PlayerActor<TMachine>
+			) => PlayerActor<TMachine> & TCapabilities
 		: (
 				input: InputFrom<TMachine>,
 				options?: PlayerFactoryResumeOptions<TMachine>,
-			) => PlayerActor<TMachine>;
+			) => PlayerActor<TMachine> & TCapabilities;
 ```
 
+`TCapabilities` is what `compose` adds, for example `Routable` of [`@xmachines/play-router`](../play-router/README.md).
+
 #### Restoring from a snapshot
 
 ```typescript
+import { definePlayer, compose, PlayerActor } from "@xmachines/play-xstate";
+import { withRouting } from "@xmachines/play-xstate/routing";
+import type { AnyStateMachine } from "xstate";
+
+declare const machine: AnyStateMachine; // your machine, with an input and routed states
+
+const createPlayer = definePlayer({ machine, actor: compose(PlayerActor, withRouting) });
+const actor = createPlayer({ userId: "alice" });
+actor.start();
+
 const snapshot = actor.getPersistedSnapshot();
 actor.stop();
 
@@ -149,7 +167,7 @@ console.log(restored.currentRoute.get()); // same route as when saved
 
 ### `PlayerActor<TMachine>`
 
-This concrete actor class is an XState v5 actor that exposes reactive atoms. It holds the protocol of `PlayActor` and nothing else: `state` and `send`.
+This concrete actor class is an XState v6 actor that exposes reactive atoms. It holds the protocol of `PlayActor` and nothing else: `state` and `send`.
 
 #### Atoms
 
@@ -184,6 +202,9 @@ carries the route utilities — `deriveRoute`, `isAbsoluteRoute`, `buildRouteUrl
 import { definePlayer, PlayerActor, compose } from "@xmachines/play-xstate";
 import { withRouting } from "@xmachines/play-xstate/routing";
 import { withView } from "@xmachines/play-xstate/view";
+import type { AnyStateMachine } from "xstate";
+
+declare const machine: AnyStateMachine; // your machine
 
 // Both capabilities
 const createPlayer = definePlayer({
@@ -203,6 +224,15 @@ const createBare = definePlayer({ machine });
 **A lifecycle hook receives the bare actor.** `PlayerOptions` is typed before the class is composed, so it cannot name the capabilities, and a narrower hook parameter is refused under `strictFunctionTypes`. A hook that reads `currentRoute` or `currentView` reads them through a binding of the composed type:
 
 ```typescript
+import { definePlayer, PlayerActor, compose } from "@xmachines/play-xstate";
+import { withRouting } from "@xmachines/play-xstate/routing";
+import { withView } from "@xmachines/play-xstate/view";
+import type { Routable } from "@xmachines/play-router";
+import type { Viewable } from "@xmachines/play-view";
+import type { AnyStateMachine } from "xstate";
+
+declare const machine: AnyStateMachine; // your machine
+
 let composed: PlayerActor<typeof machine> & Routable & Viewable;
 
 const actor = definePlayer({
@@ -244,18 +274,23 @@ the path yourself, when you run work that belongs to a change of the route alone
 
 #### Methods
 
-| Method          | Description                                                               |
-| --------------- | ------------------------------------------------------------------------- |
-| `start()`       | Starts the actor and calls the `onStart` hook                             |
-| `stop()`        | Stops the actor, cleans up the subscriptions, and calls the `onStop` hook |
-| `send(event)`   | Sends a typed event to the machine and calls the `onTransition` hook      |
-| `can(event)`    | Returns `true` when the current state accepts the given event             |
-| `getSnapshot()` | Returns the current XState snapshot                                       |
+| Method          | Description                                                                                                                                           |
+| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `start()`       | Starts the actor and calls the `onStart` hook                                                                                                         |
+| `stop()`        | Stops the actor, cleans up the subscriptions, and calls the `onStop` hook                                                                             |
+| `send(event)`   | Sends a typed event to the machine and calls the `onTransition` hook. `send` is an accessor, as in XState 6, so `actor.send` passes on without a bind |
+| `can(event)`    | Returns `true` when the current state accepts the given event                                                                                         |
+| `getSnapshot()` | Returns the current XState snapshot                                                                                                                   |
 
 #### Atom usage example
 
 ```typescript
 import { watchAtom } from "@xmachines/play-atom";
+import type { PlayerActor } from "@xmachines/play-xstate";
+import type { Routable } from "@xmachines/play-router";
+import type { AnyStateMachine } from "xstate";
+
+declare const actor: PlayerActor<AnyStateMachine> & Routable; // composed with withRouting
 
 const stop = watchAtom(actor.currentRoute, (route) => {
 	console.log("Route changed:", route);
@@ -271,34 +306,42 @@ stop();
 
 ### Guards
 
-This package gives no guard utility. Compose a guard with the `and()`, `or()` and `not()` combinators of XState:
+This package gives no guard utility. XState 6 has no guard combinators: a transition function is the guard. It calls each named guard of `setup()` through its `guards` argument, and it combines them with `&&`, `||` and `!`. A transition function that returns `undefined` leaves the event unhandled:
 
 ```typescript
-import { and, not, setup } from "xstate";
+import { setup, types } from "xstate";
 
 const machine = setup({
+	schemas: {
+		context: types<{ userId: string; role: string }>(),
+		events: { accessAdmin: types<void>(), accessLogin: types<void>() },
+	},
 	guards: {
-		isLoggedIn: ({ context }) => context.userId !== "",
-		hasAdminRole: ({ context }) => context.role === "admin",
+		isLoggedIn: (userId: string) => userId !== "",
+		hasAdminRole: (role: string) => role === "admin",
 	},
 }).createMachine({
+	context: { userId: "", role: "guest" },
+	initial: "home",
 	on: {
-		accessAdmin: {
-			guard: and(["isLoggedIn", "hasAdminRole"]),
-			target: "adminPanel",
-		},
-		accessLogin: {
-			guard: not("isLoggedIn"),
-			target: "login",
-		},
+		accessAdmin: ({ context, guards }) =>
+			guards.isLoggedIn(context.userId) && guards.hasAdminRole(context.role)
+				? { target: ".adminPanel" }
+				: undefined,
+		accessLogin: ({ context, guards }) =>
+			guards.isLoggedIn(context.userId) ? undefined : { target: ".login" },
+	},
+	states: {
+		home: {},
+		adminPanel: {},
+		login: {},
 	},
-	// ...
 });
 ```
 
-A combinator resolves each name against the `guards` of `setup()`. A name that the map does not hold therefore fails to compile, and it names the fault: `Type '"typoGuardName"' is not assignable to type '"isLoggedIn"'`.
+A name that the `guards` map does not hold fails to compile.
 
-`composeGuards`, `composeGuardsOr`, `negateGuard`, `hasContext`, `eventMatches` and `contextFieldMatches` stood here before. They closed two gaps of the types of XState 5.28. The peer floor of this package is `^5.33.0`, and 5.33 holds neither gap. The helpers also fitted a guard slot that `setup()` types never: the example of this package reached them through an `as never` cast. Write the combinator instead, and write a plain predicate in place of each helper.
+`composeGuards`, `composeGuardsOr`, `negateGuard`, `hasContext`, `eventMatches` and `contextFieldMatches` stood here before. They closed two gaps of the types of XState 5.28. XState 6 removed the combinators that they wrapped. Write a plain predicate in place of each helper.
 
 ---
 
@@ -310,12 +353,15 @@ These helper functions configure the routes of an XState machine declaratively.
 
 This function reads each machine state that has a `meta.route` field. It then generates the `play.route` event handlers at the root level. You therefore write no repetitive routing transition.
 
+Each generated transition is a config object, and not a function. Its `matches: { to: "#<id>" }` field selects the `play.route` event for the state, and its `context` field writes the `params`, the `query` and the `data` of the route into the context, as a patch. A graph of the machine therefore still sees the target of each route. The `play.route` entry of the result is a list: the generated transitions first, then the `play.route` transition of the machine, which is the fallback. The config types of XState 6 declare one transition for each event, and its runtime reads a list in its order.
+
 ```typescript
-import { setup } from "xstate";
-import { formatPlayRouteTransitions } from "@xmachines/play-xstate/routing";
+import { setup, types } from "xstate";
+import { formatPlayRouteTransitions, type RouteMetadata } from "@xmachines/play-xstate/routing";
 
 const config = formatPlayRouteTransitions({
 	id: "app",
+	initial: "home",
 	states: {
 		home: {
 			id: "home",
@@ -329,8 +375,10 @@ const config = formatPlayRouteTransitions({
 });
 
 // config now includes auto-generated play.route handlers:
-// on: { "play.route": [ { target: ".home", guard: e => e.to === "#home" }, ... ] }
-const machine = setup({}).createMachine(config);
+// on: { "play.route": [ { target: ".home", matches: { to: "#home" }, context: ... }, ... ] }
+const machine = setup({
+	schemas: { meta: types<{ route?: RouteMetadata }>() },
+}).createMachine(config);
 ```
 
 > **Note:** every state with a `meta.route` field must also have an explicit `id` field. A state without an `id` field throws `MissingStateIdError` when you define the machine.
@@ -350,6 +398,10 @@ with `asDisposable` of [`@xmachines/core/utils`](../core/README.md):
 
 ```typescript
 import { asDisposable } from "@xmachines/core/utils";
+import { definePlayer } from "@xmachines/play-xstate";
+import type { AnyStateMachine } from "xstate";
+
+declare const machine: AnyStateMachine; // your machine
 
 {
 	const actor = definePlayer({ machine })();
@@ -365,16 +417,28 @@ import { asDisposable } from "@xmachines/core/utils";
 ## Inspection
 
 The factory gives `options.inspect` to `createActor` of XState without a change.
-Therefore every XState inspection tool works with a `PlayerActor`, and this
-includes [`@statelyai/inspect`](https://stately.ai/docs/inspector):
+Therefore every tool that reads the inspection events of XState 6 works with a
+`PlayerActor`. XState 6 emits two events: `@xstate.actor` for each new actor, and
+`@xstate.transition` for each transition, with its event and its snapshot:
 
 ```typescript
-import { createBrowserInspector } from "@statelyai/inspect";
+import { definePlayer } from "@xmachines/play-xstate";
+import type { AnyStateMachine, InspectionEvent } from "xstate";
 
-const { inspect } = createBrowserInspector();
+declare const machine: AnyStateMachine; // your machine
+
+const inspect = (event: InspectionEvent): void => {
+	if (event.type === "@xstate.transition") {
+		console.log(event.event.type, event.snapshot.status);
+	}
+};
 const createPlayer = definePlayer({ machine, options: { inspect } });
 ```
 
+`@statelyai/inspect` 0.7 does not load beside XState 6: it imports `toObserver`, which
+XState 6 no longer exports. The [inspector guide](../../../guides/inspector.md) shows how a
+demo of this repository converts the events for the Stately inspector itself.
+
 Three points are important:
 
 - **`inspect` is an option of the factory, not of one instance.** Every actor of a
@@ -394,7 +458,7 @@ For an inspector that you create after the factory, such as a dev-tools switch,
 factory a function that forwards each event: `inspect: (event) => currentInspector?.(event)`.
 
 The [inspector guide](../../../guides/inspector.md) gives the complete procedure: a late
-attachment with a replay, a WebSocket inspection without a browser, and the points to
+attachment with a replay, an inspection without a browser, and the points to
 consider in production.
 
 ---
@@ -431,7 +495,7 @@ every consumer, including one that composes no routing.
 The string form declares the path only. The object form declares the path and the
 behaviour of the generated `play.route` transition:
 
-```typescript
+```typescript fragment
 meta: {
 	route: {
 		path: "/doc/:docId",
@@ -450,7 +514,7 @@ meta: {
 		// and the target still runs its exit and its entry actions. `handler` is the
 		// field that spares those intermediate ancestors.
 		reenter: false,
-		// The extra data of the route. The generated transition assigns it to
+		// The extra data of the route. The generated transition writes it to
 		// `context.data`. A literal value, or a function of { context, event }.
 		data: { titleKey: "doc.view" },
 	},
@@ -466,10 +530,9 @@ An unknown `handler` value throws `InvalidRouteHandlerError` at the format time.
 > active. A route to the ROOT of the machine is the one exception: the root is then the
 > target and the domain, so the root runs those actions only under `reenter: true`.
 
-The `data` field follows the `WithDynamicParams` shape of XState, so the function form
-reads the context and the event:
+The function form of the `data` field reads the context and the event:
 
-```typescript
+```typescript fragment
 data: ({ context, event }) => ({ title: `Document ${event.params?.docId}` });
 ```
 

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

@@ -2,7 +2,7 @@
 
 # Class: ActorThrewNonErrorError
 
-Defined in: [packages/play-xstate/src/errors.ts:309](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/errors.ts#L309)
+Defined in: [packages/play-xstate/src/errors.ts:309](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/errors.ts#L309)
 
 The actor gives this error to `PlayerOptions.onError` when it failed with a value
 that is not an `Error`, for example after a machine action ran
@@ -46,7 +46,7 @@ definePlayer({
 new ActorThrewNonErrorError(value): ActorThrewNonErrorError;
 ```
 
-Defined in: [packages/play-xstate/src/errors.ts:310](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/errors.ts#L310)
+Defined in: [packages/play-xstate/src/errors.ts:310](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/errors.ts#L310)
 
 #### Parameters
 
@@ -64,15 +64,15 @@ Defined in: [packages/play-xstate/src/errors.ts:310](https://gitlab.com/xmachin-
 
 ## Properties
 
-| 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-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-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-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) | -                                                                                                                          |
+| 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/docs-v8.0.0-next.1/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-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/docs-v8.0.0-next.1/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-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/errors/classes/InvalidEventError.md

@@ -2,7 +2,7 @@
 
 # Class: InvalidEventError
 
-Defined in: [packages/play-xstate/src/errors.ts:264](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/errors.ts#L264)
+Defined in: [packages/play-xstate/src/errors.ts:264](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/errors.ts#L264)
 
 `PlayerActor.send()` throws this error when the event argument is not a plain
 object.
@@ -44,7 +44,7 @@ try {
 new InvalidEventError(detail): InvalidEventError;
 ```
 
-Defined in: [packages/play-xstate/src/errors.ts:268](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/errors.ts#L268)
+Defined in: [packages/play-xstate/src/errors.ts:268](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/errors.ts#L268)
 
 #### Parameters
 
@@ -62,16 +62,16 @@ Defined in: [packages/play-xstate/src/errors.ts:268](https://gitlab.com/xmachin-
 
 ## Properties
 
-| 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-detail"></a> `detail`                   | `readonly` | `unknown` | The value in question, from the `send()` call.                                                                                                                                                                                                                                                                                                                                                                                                    | -                                                                                                                                                | [packages/play-xstate/src/errors.ts:266](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/errors.ts#L266) |
-| <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-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-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) | -                                                                                                                                          |
+| 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/docs-v8.0.0-next.1/packages/core/src/errors.ts#L56)                 |
+| <a id="property-detail"></a> `detail`                   | `readonly` | `unknown` | The value in question, from the `send()` call.                                                                                                                                                                                                                                                                                                                                                                                                    | -                                                                                                                                                | [packages/play-xstate/src/errors.ts:266](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/errors.ts#L266) |
+| <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-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/docs-v8.0.0-next.1/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-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/errors/classes/InvalidMachineError.md

@@ -2,7 +2,7 @@
 
 # Class: InvalidMachineError
 
-Defined in: [packages/play-xstate/src/errors.ts:161](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/errors.ts#L161)
+Defined in: [packages/play-xstate/src/errors.ts:161](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/errors.ts#L161)
 
 The `PlayerActor` constructor throws this error when the `machine` argument is not
 a valid XState machine object, which means that it is null, undefined, or not an
@@ -22,7 +22,7 @@ object.
 new InvalidMachineError(): InvalidMachineError;
 ```
 
-Defined in: [packages/play-xstate/src/errors.ts:162](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.1.0/packages/play-xstate/src/errors.ts#L162)
+Defined in: [packages/play-xstate/src/errors.ts:162](https://gitlab.com/xmachin-es/xmachines-js/-/blob/docs-v8.0.0-next.1/packages/play-xstate/src/errors.ts#L162)
 
 #### Returns
 
@@ -34,15 +34,15 @@ Defined in: [packages/play-xstate/src/errors.ts:162](https://gitlab.com/xmachin-
 
 ## Properties
 
-| 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-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-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-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) | -                                                                                                                          |
+| 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/docs-v8.0.0-next.1/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-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/docs-v8.0.0-next.1/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-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