@xmachines/docs 3.0.0 → 4.0.0

package/rfc/play.md

@@ -136,10 +136,12 @@ Exports the minimal shared contracts that allow the Logic Engine and Infrastruct
 
 **Role:** Abstract Logic Engine
 
-Defines the minimal base class that all logic adapters must implement. By extending the XState `Actor` class, the `AbstractActor` remains fully compatible with the XState ecosystem (inspection, system registration, message passing) while enforcing the Play Architecture's **push–pull signal contract**.
+Defines the minimal base class that all logic adapters must implement. By extending the XState `Actor` class, the `PlayActor` remains fully compatible with the XState ecosystem (inspection, system registration, message passing) while enforcing the Play Architecture's **push–pull signal contract**.
 
 The base class requires only two abstract members: **reactive state** and **typed event dispatch**. Routing and view rendering are opt-in via separate interfaces, allowing actors to compose only the capabilities they need.
 
+**Design Rationale:** The RFC declared an abstract `AbstractActor` CLASS that extended `Actor` of `xstate`, and it declared both capability interfaces in this package. The implementation made the contract an INTERFACE, `PlayActor`, because the class carried no implementation: both of its members were abstract, and its whole effect was to force the inheritance of XState on every consumer of the contract. `@xmachines/play-actor` names `xstate` nowhere now. The implementation also moved each capability interface to the package that holds its shared machinery: `Routable` is in `@xmachines/play-router`, beside the bridge that reads it, and `Viewable` and `PlaySpec` are in `@xmachines/play-view`, beside the view store lifecycle. A consumer who needs no routing and no view therefore installs neither package, and `@xmachines/play-actor` names the capability packages nowhere. The shape of each interface is unchanged.
+
 ```ts
 import { Actor, type AnyActorLogic, type EventObject } from "xstate";
 import type { Signal } from "@xmachines/play-signals";
@@ -170,7 +172,7 @@ export interface Viewable {
 }
 
 // The Base Protocol — minimal contract
-export abstract class AbstractActor<
+export abstract class PlayActor<
 	TLogic extends AnyActorLogic,
 	TEvent extends EventObject = EventObject,
 > extends Actor<TLogic> {
@@ -182,7 +184,7 @@ export abstract class AbstractActor<
 }
 ```
 
-**Design Rationale:** The original design placed `currentRoute`, `currentView`, and `catalog` directly on `AbstractActor`. The implementation extracted these into `Routable` and `Viewable` interfaces because:
+**Design Rationale:** The original design placed `currentRoute`, `currentView`, and `catalog` directly on `PlayActor`. The implementation extracted these into `Routable` and `Viewable` interfaces because:
 
 1. Not all actors need routing (e.g. embedded sub-actors)
 2. Not all actors need view rendering (e.g. background logic actors)
@@ -194,16 +196,16 @@ export abstract class AbstractActor<
 
 **Role:** Concrete Logic Adapter (XState v5)
 
-Wraps XState v5 to satisfy the `AbstractActor` contract. Provides the primary API for creating actors from state machine definitions.
+Wraps XState v5 to satisfy the `PlayActor` contract. Provides the primary API for creating actors from state machine definitions.
 
 **Primary Exports:**
 
 - `definePlayer` — Factory builder: accepts a machine config, returns a factory function that creates `PlayerActor` instances
-- `PlayerActor` — Concrete class extending `AbstractActor` and implementing both `Routable` and `Viewable`
+- `PlayerActor` — Concrete class extending `PlayActor`. It carries state and send alone, and a capability mixin adds the rest
+- `compose`, `withRouting`, `withView` — The composition of the optional capabilities onto `PlayerActor`
 
 **Utility Exports:**
 
-- Guard combinators: `composeGuards`, `composeGuardsOr`, `negateGuard`, `hasContext`, `eventMatches`, `contextFieldMatches`
 - Route derivation: `deriveRoute`, `isAbsoluteRoute`, `buildRouteUrl`, `formatPlayRouteTransitions`
 
 **Responsibilities:**
@@ -228,18 +230,22 @@ const definePlayer = <TMachine extends AnyStateMachine>(
 	return (input?, restore?) => new PlayerActor(machine, options, input, restore?.snapshot);
 };
 
-// PlayerActor composes all capabilities
+// PlayerActor carries the core protocol alone. It extends the actor class of XState
+// directly, and `PlayActor` is a contract that it implements.
 class PlayerActor<TMachine extends AnyStateMachine>
-	extends AbstractActor<AnyActorLogic, EventFromLogic<TMachine>>
-	implements Routable, Viewable
+	extends Actor<AnyActorLogic>
+	implements PlayActor<SnapshotFrom<TMachine>, EventFromLogic<TMachine>>
 {
-	public state: Signal.State<AnyMachineSnapshot>;
-	public currentRoute: Signal.Computed<string | null>;
-	public currentView: Signal.State<PlaySpec | null>;
-	public readonly initialRoute: string | null;
+	public state: Signal.State<SnapshotFrom<TMachine>>;
 }
+
+// A capability arrives through `compose`, and each one brings its own package
+const RoutedPlayer = compose(PlayerActor, withRouting, withView);
+// RoutedPlayer instances hold `currentRoute`, `initialRoute` and `currentView`
 ```
 
+**Design Rationale:** The RFC made `PlayerActor` implement both capabilities directly. The implementation split them into mixins, because a direct implementation made `@xmachines/play-router` and `@xmachines/play-view` hard dependencies of every actor. Both packages are optional peer dependencies now: `definePlayer({ machine })` installs neither, `withRouting` needs `@xmachines/play-router`, and `withView` needs `@xmachines/play-view`.
+
 **Design Rationale:** The original design passed a `catalog` to `definePlayer` and returned `{ create, catalog }`. The implementation decoupled catalogs entirely — component schemas are defined via `@xmachines/json-render-core`'s `defineCatalog` and bound to renderers via `defineRegistry`, not to actors. This means a single actor can be rendered by different component libraries without change.
 
 ### 5.3 Router Layer
@@ -250,6 +256,14 @@ class PlayerActor<TMachine extends AnyStateMachine>
 
 Provides the complete routing infrastructure: route extraction from state machines, bidirectional route mapping, and the abstract `RouterBridgeBase` that all framework-specific router adapters extend.
 
+**Design Rationale:** The RFC put the whole of the routing in one package. The implementation split it at two boundaries, because a consumer paid for both halves and used one:
+
+- `@xmachines/play-router/xstate` holds the machine half — `extractMachineRoutes`, `createRouteMap`, `machineToGraph`, and the queries over a route tree. That half alone needs `xstate` and `@statelyai/graph`.
+- `@xmachines/play-url` holds the URL language — the URLPattern grammar, a base path, and the params of a framework router. It knows no machine and no bridge, and BOTH directions of the routing read it.
+- `@xmachines/play-router` keeps the route map, the match of a location, `RouterBridgeBase`, the provider lifecycle, and the `Routable` capability. It names no state machine.
+
+The export lists below name the original layout. Each package README names what it holds now.
+
 **Protocol Exports:**
 
 - `RouterBridge` — Interface: `{ connect(): void; disconnect(): void }`
@@ -266,7 +280,6 @@ Provides the complete routing infrastructure: route extraction from state machin
 - `extractMachineRoutes` — Build complete route tree from a machine definition
 - `buildRouteTree` — Construct hierarchical tree from flat route info
 - `createRouteMap` / `RouteMap` — Bidirectional path ↔ state ID resolution
-- `BaseRouteMap` / `BaseRouteMapping` — Shared base for adapter-specific route maps
 
 **Validation & Query Exports:**
 
@@ -284,13 +297,13 @@ Provides the complete routing infrastructure: route extraction from state machin
 
 Each adapter extends `RouterBridgeBase` and implements the three abstract methods for its target router. All share the same architectural pattern:
 
-| Package                                 | Router          | Framework |
-| --------------------------------------- | --------------- | --------- |
-| `@xmachines/play-tanstack-react-router` | TanStack Router | React     |
-| `@xmachines/play-tanstack-solid-router` | TanStack Router | SolidJS   |
-| `@xmachines/play-react-router`          | React Router v7 | React     |
-| `@xmachines/play-vue-router`            | Vue Router 4/5  | Vue       |
-| `@xmachines/play-solid-router`          | SolidJS Router  | SolidJS   |
+| Package                                 | Router           | Framework |
+| --------------------------------------- | ---------------- | --------- |
+| `@xmachines/play-tanstack-react-router` | TanStack Router  | React     |
+| `@xmachines/play-tanstack-solid-router` | TanStack Router  | SolidJS   |
+| `@xmachines/play-react-router`          | React Router 7/8 | React     |
+| `@xmachines/play-vue-router`            | Vue Router 4/5   | Vue       |
+| `@xmachines/play-solid-router`          | SolidJS Router   | SolidJS   |
 
 **Runtime Adapter Responsibilities (all adapters):**
 
@@ -431,7 +444,7 @@ import { createDashboard, machine } from "./features/dashboard/player";
 import { catalog } from "./catalog";
 import { PlayUIProvider, PlayRenderer, defineRegistry } from "@xmachines/play-react";
 import { TanStackReactRouterBridge } from "@xmachines/play-tanstack-react-router";
-import { extractMachineRoutes, createRouteMap } from "@xmachines/play-router";
+import { extractMachineRoutes, createRouteMap } from "@xmachines/play-router/xstate";
 
 // 1. Create the actor
 const actor = createDashboard();

package/api/@xmachines/play-actor/classes/AbstractActor.md

@@ -1,505 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-actor](../README.md) / AbstractActor
-
-# Abstract Class: AbstractActor\<TLogic, TEvent\>
-
-Defined in: [packages/play-actor/src/abstract-actor.ts:197](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-actor/src/abstract-actor.ts#L197)
-
-The abstract base class of an actor of the Play Architecture.
-
-It observes the state through the signals, and it works with the tools of the
-XState ecosystem, such as the devtools and the inspection. It also exposes the
-reactive signals of the communication with the infrastructure layer.
-
-**A subclass IS the actor.** Give the logic _and_ its options to
-`super(logic, options)`, then observe `this`. A separate actor beside this
-instance leaves this instance as an empty second actor. Every inherited member
-then answers from that empty actor, until you forward each one: `system`,
-`sessionId`, `clock`, the internal `_send` that receives the traffic of
-`sendTo()`, and each member that a later XState version adds.
-
-## Extends
-
-- [`Actor`](https://www.jsdocs.io/package/xstate#Actor)\<`TLogic`\>
-
-## Extended by
-
-- [`PlayerActor`](../../play-xstate/classes/PlayerActor.md)
-
-## Type Parameters
-
-| Type Parameter                                                                           | Default type                                                      | Description                                                  |
-| ---------------------------------------------------------------------------------------- | ----------------------------------------------------------------- | ------------------------------------------------------------ |
-| `TLogic` _extends_ [`AnyActorLogic`](https://www.jsdocs.io/package/xstate#AnyActorLogic) | -                                                                 | The type of the XState actor logic                           |
-| `TEvent` _extends_ [`EventObject`](https://www.jsdocs.io/package/xstate#EventObject)     | [`EventObject`](https://www.jsdocs.io/package/xstate#EventObject) | The constraint of the event type. The default is EventObject |
-
-## Constructors
-
-### Constructor
-
-```ts
-new AbstractActor<TLogic, TEvent>(logic, options?): AbstractActor<TLogic, TEvent>;
-```
-
-Defined in: `xstate`
-
-Creates a new actor instance for the given logic with the provided options,
-if any.
-
-#### Parameters
-
-| Parameter  | Type                                                                            | Description                       |
-| ---------- | ------------------------------------------------------------------------------- | --------------------------------- |
-| `logic`    | `TLogic`                                                                        | The logic to create an actor from |
-| `options?` | [`ActorOptions`](https://www.jsdocs.io/package/xstate#ActorOptions)\<`TLogic`\> | Actor options                     |
-
-#### Returns
-
-`AbstractActor`\<`TLogic`, `TEvent`\>
-
-#### Inherited from
-
-```ts
-Actor<TLogic>.constructor
-```
-
-## Properties
-
-| Property                                    | Modifier   | Type                                                                                                                                                                                                                                                                                                               | Description                                                                                                                                                                                               | Inherited from    | Defined in                                                                                                                                               |
-| ------------------------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-_parent"></a> `_parent?`    | `public`   | [`AnyActorRef`](https://www.jsdocs.io/package/xstate#AnyActorRef)                                                                                                                                                                                                                                                  | -                                                                                                                                                                                                         | `Actor._parent`   | -                                                                                                                                                        |
-| <a id="property-clock"></a> `clock`         | `public`   | [`Clock`](https://www.jsdocs.io/package/xstate#Clock)                                                                                                                                                                                                                                                              | The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.                                                                                                  | `Actor.clock`     | -                                                                                                                                                        |
-| <a id="property-id"></a> `id`               | `public`   | `string`                                                                                                                                                                                                                                                                                                           | The unique identifier for this actor relative to its parent.                                                                                                                                              | `Actor.id`        | -                                                                                                                                                        |
-| <a id="property-logic"></a> `logic`         | `public`   | `TLogic`                                                                                                                                                                                                                                                                                                           | -                                                                                                                                                                                                         | `Actor.logic`     | -                                                                                                                                                        |
-| <a id="property-options"></a> `options`     | `public`   | `Readonly`\<[`ActorOptions`](https://www.jsdocs.io/package/xstate#ActorOptions)\<`TLogic`\>\>                                                                                                                                                                                                                      | -                                                                                                                                                                                                         | `Actor.options`   | -                                                                                                                                                        |
-| <a id="property-ref"></a> `ref`             | `public`   | [`ActorRef`](https://www.jsdocs.io/package/xstate#ActorRef)\<[`SnapshotFrom`](https://www.jsdocs.io/package/xstate#SnapshotFrom)\<`TLogic`\>, [`EventFromLogic`](https://www.jsdocs.io/package/xstate#EventFromLogic)\<`TLogic`\>, [`EmittedFrom`](https://www.jsdocs.io/package/xstate#EmittedFrom)\<`TLogic`\>\> | -                                                                                                                                                                                                         | `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`         | `abstract` | [`State`](../../play-signals/namespaces/Signal/classes/State.md)\<`unknown`\>                                                                                                                                                                                                                                      | The reactive snapshot of the current actor state. The infrastructure observes this signal, and it reacts to each state change. It therefore holds no coupling to the internal state machine of the actor. | -                 | [packages/play-actor/src/abstract-actor.ts:207](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-actor/src/abstract-actor.ts#L207) |
-| <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
-
-### \[observable\]()
-
-```ts
-observable: InteropSubscribable<SnapshotFrom<TLogic>>;
-```
-
-Defined in: `xstate`
-
-#### Returns
-
-[`InteropSubscribable`](https://www.jsdocs.io/package/xstate#InteropSubscribable)\<[`SnapshotFrom`](https://www.jsdocs.io/package/xstate#SnapshotFrom)\<`TLogic`\>\>
-
-#### Inherited from
-
-```ts
-Actor.[observable]
-```
-
----
-
-### getPersistedSnapshot()
-
-```ts
-getPersistedSnapshot(): Snapshot<unknown>;
-```
-
-Defined in: `xstate`
-
-Obtain the internal state of the actor, which can be persisted.
-
-#### Returns
-
-[`Snapshot`](https://www.jsdocs.io/package/xstate#Snapshot)\<`unknown`\>
-
-#### Remarks
-
-The internal state can be persisted from any actor, not only machines.
-
-Note that the persisted state is not the same as the snapshot from
-[Actor.getSnapshot](#getsnapshot). Persisted state represents the internal state of
-the actor, while snapshots represent the actor's last emitted value.
-
-Can be restored with [ActorOptions.state](https://www.jsdocs.io/package/xstate#ActorOptions.state)
-
-#### See
-
-https://stately.ai/docs/persistence
-
-#### Inherited from
-
-```ts
-Actor.getPersistedSnapshot;
-```
-
----
-
-### getSnapshot()
-
-```ts
-getSnapshot(): SnapshotFrom<TLogic>;
-```
-
-Defined in: `xstate`
-
-Read an actor’s snapshot synchronously.
-
-#### Returns
-
-[`SnapshotFrom`](https://www.jsdocs.io/package/xstate#SnapshotFrom)\<`TLogic`\>
-
-#### Remarks
-
-The snapshot represent an actor's last emitted value.
-
-When an actor receives an event, its internal state may change. An actor
-may emit a snapshot when a state transition occurs.
-
-Note that some actors, such as callback actors generated with
-`fromCallback`, will not emit snapshots.
-
-#### See
-
-- [Actor.subscribe](#subscribe) to subscribe to an actor’s snapshot values.
-- [Actor.getPersistedSnapshot](#getpersistedsnapshot) to persist the internal state of an actor (which is more than just a snapshot).
-
-#### Inherited from
-
-```ts
-Actor.getSnapshot;
-```
-
----
-
-### on()
-
-```ts
-on<TType>(type, handler): Subscription;
-```
-
-Defined in: `xstate`
-
-#### Type Parameters
-
-| Type Parameter          |
-| ----------------------- |
-| `TType` _extends_ `any` |
-
-#### Parameters
-
-| Parameter | Type                  |
-| --------- | --------------------- |
-| `type`    | `TType`               |
-| `handler` | (`emitted`) => `void` |
-
-#### Returns
-
-[`Subscription`](https://www.jsdocs.io/package/xstate#Subscription)
-
-#### Inherited from
-
-```ts
-Actor.on;
-```
-
----
-
-### select()
-
-```ts
-select<TSelected>(selector, equalityFn?): Readable<TSelected>;
-```
-
-Defined in: `xstate`
-
-#### Type Parameters
-
-| Type Parameter |
-| -------------- |
-| `TSelected`    |
-
-#### Parameters
-
-| Parameter     | Type                        |
-| ------------- | --------------------------- |
-| `selector`    | (`snapshot`) => `TSelected` |
-| `equalityFn?` | (`a`, `b`) => `boolean`     |
-
-#### Returns
-
-`Readable`\<`TSelected`\>
-
-#### Inherited from
-
-```ts
-Actor.select;
-```
-
----
-
-### send()
-
-```ts
-abstract send(event): void;
-```
-
-Defined in: [packages/play-actor/src/abstract-actor.ts:223](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-actor/src/abstract-actor.ts#L223)
-
-Sends an event to the Actor.
-
-The constraint is TEvent, which gives the type safety of a concrete
-implementation.
-
-A note for an implementation that wraps `send`, to check the event or to notify a
-hook around it: this declaration is abstract for one reason only, to narrow the
-event type, and TypeScript forbids a `super` call to an abstract member. Reach
-the implementation of XState with `Actor.prototype.send.call(this, event)`
-instead. A concrete declaration permits `super.send()`, but it also forces an
-`override` modifier in every subclass that exists now, and that is a breaking
-change for an adapter outside this repository.
-
-#### Parameters
-
-| Parameter | Type     |
-| --------- | -------- |
-| `event`   | `TEvent` |
-
-#### Returns
-
-`void`
-
-#### Overrides
-
-```ts
-Actor.send;
-```
-
----
-
-### start()
-
-```ts
-start(): this;
-```
-
-Defined in: `xstate`
-
-Starts the Actor from the initial state
-
-#### Returns
-
-`this`
-
-#### Inherited from
-
-```ts
-Actor.start;
-```
-
----
-
-### stop()
-
-```ts
-stop(): this;
-```
-
-Defined in: `xstate`
-
-Stops the Actor and unsubscribe all listeners.
-
-#### Returns
-
-`this`
-
-#### Inherited from
-
-```ts
-Actor.stop;
-```
-
----
-
-### subscribe()
-
-#### Call Signature
-
-```ts
-subscribe(observer): Subscription;
-```
-
-Defined in: `xstate`
-
-Subscribe an observer to an actor’s snapshot values.
-
-##### Parameters
-
-| Parameter  | Type                                                                                                                                           | Description                                                                                                                                  |
-| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
-| `observer` | [`Observer`](https://www.jsdocs.io/package/xstate#Observer)\<[`SnapshotFrom`](https://www.jsdocs.io/package/xstate#SnapshotFrom)\<`TLogic`\>\> | Either a plain function that receives the latest snapshot, or an observer object whose `.next(snapshot)` method receives the latest snapshot |
-
-##### Returns
-
-[`Subscription`](https://www.jsdocs.io/package/xstate#Subscription)
-
-##### Remarks
-
-The observer will receive the actor’s snapshot value when it is emitted.
-The observer can be:
-
-- A plain function that receives the latest snapshot, or
-- An observer object whose `.next(snapshot)` method receives the latest
-  snapshot
-
-##### Examples
-
-```ts
-// Observer as a plain function
-const subscription = actor.subscribe((snapshot) => {
-	console.log(snapshot);
-});
-```
-
-```ts
-// Observer as an object
-const subscription = actor.subscribe({
-	next(snapshot) {
-		console.log(snapshot);
-	},
-	error(err) {
-		// ...
-	},
-	complete() {
-		// ...
-	},
-});
-```
-
-The return value of `actor.subscribe(observer)` is a subscription object
-that has an `.unsubscribe()` method. You can call
-`subscription.unsubscribe()` to unsubscribe the observer:
-
-```ts
-const subscription = actor.subscribe((snapshot) => {
-	// ...
-});
-
-// Unsubscribe the observer
-subscription.unsubscribe();
-```
-
-When the actor is stopped, all of its observers will automatically be
-unsubscribed.
-
-##### Inherited from
-
-```ts
-Actor.subscribe;
-```
-
-#### Call Signature
-
-```ts
-subscribe(
-   nextListener?,
-   errorListener?,
-   completeListener?): Subscription;
-```
-
-Defined in: `xstate`
-
-Subscribe an observer to an actor’s snapshot values.
-
-##### Parameters
-
-| Parameter           | Type                   |
-| ------------------- | ---------------------- |
-| `nextListener?`     | (`snapshot`) => `void` |
-| `errorListener?`    | (`error`) => `void`    |
-| `completeListener?` | () => `void`           |
-
-##### Returns
-
-[`Subscription`](https://www.jsdocs.io/package/xstate#Subscription)
-
-##### Remarks
-
-The observer will receive the actor’s snapshot value when it is emitted.
-The observer can be:
-
-- A plain function that receives the latest snapshot, or
-- An observer object whose `.next(snapshot)` method receives the latest
-  snapshot
-
-##### Examples
-
-```ts
-// Observer as a plain function
-const subscription = actor.subscribe((snapshot) => {
-	console.log(snapshot);
-});
-```
-
-```ts
-// Observer as an object
-const subscription = actor.subscribe({
-	next(snapshot) {
-		console.log(snapshot);
-	},
-	error(err) {
-		// ...
-	},
-	complete() {
-		// ...
-	},
-});
-```
-
-The return value of `actor.subscribe(observer)` is a subscription object
-that has an `.unsubscribe()` method. You can call
-`subscription.unsubscribe()` to unsubscribe the observer:
-
-```ts
-const subscription = actor.subscribe((snapshot) => {
-	// ...
-});
-
-// Unsubscribe the observer
-subscription.unsubscribe();
-```
-
-When the actor is stopped, all of its observers will automatically be
-unsubscribed.
-
-##### Inherited from
-
-```ts
-Actor.subscribe;
-```
-
----
-
-### toJSON()
-
-```ts
-toJSON(): object;
-```
-
-Defined in: `xstate`
-
-#### Returns
-
-`object`
-
-| Name           | Type     | Defined in |
-| -------------- | -------- | ---------- |
-| `id`           | `string` | -          |
-| `xstate$$type` | `number` | -          |
-
-#### Inherited from
-
-```ts
-Actor.toJSON;
-```