@xmachines/play-xstate 6.1.0 → 7.0.0

package/dist/player-actor.js

@@ -1,454 +1,324 @@
-import { Actor, } from "xstate";
-import { createWritableAtom } from "@xmachines/play-atom";
-import { isError } from "@xmachines/core/utils";
 import { ActorThrewNonErrorError, InvalidEventError, InvalidMachineError } from "./errors.js";
+import { isError } from "@xmachines/core/utils";
+import { Actor } from "xstate";
+import { createWritableAtom } from "@xmachines/play-atom";
+//#region packages/play-xstate/src/player-actor.ts
 /**
- * Normalizes a failure of the actor for `onError`.
- *
- * @internal
- *
- * The function gives an `Error` to the handler without a change. The error of the
- * machine therefore keeps its identity: an `instanceof` test of a consumer still
- * works, and the path without an `onError` throws that same object again. Every
- * other value is ours to build, and it becomes a `PlayError` with a code. That
- * error carries the value from the throw as its `cause`.
- */
-export const toError = (value) => {
-    try {
-        if (isError(value)) {
-            return value;
-        }
-    }
-    catch {
-        // The classification itself can throw for a hostile value, because a revoked
-        // Proxy traps instanceof and also the inspection of the brand. Continue, and wrap
-        // the value.
-    }
-    return new ActorThrewNonErrorError(value);
+* Normalizes a failure of the actor for `onError`.
+*
+* @internal
+*
+* The function gives an `Error` to the handler without a change. The error of the
+* machine therefore keeps its identity: an `instanceof` test of a consumer still
+* works, and the path without an `onError` throws that same object again. Every
+* other value is ours to build, and it becomes a `PlayError` with a code. That
+* error carries the value from the throw as its `cause`.
+*/
+var toError = (value) => {
+	try {
+		if (isError(value)) return value;
+	} catch {}
+	return new ActorThrewNonErrorError(value);
 };
 /**
- * Tells you if a snapshot is worth a propagation to the atoms: an active
- * snapshot, or a "done" snapshot, which means that the machine reached a final state
- * at the top level. The code skips an error snapshot and a stopped snapshot.
- * Therefore the atoms keep the last observable state, and they show no artifact of
- * a teardown or of an error.
- */
-const isObservableSnapshot = (snapshot) => snapshot.status === "active" || snapshot.status === "done";
+* Tells you if a snapshot is worth a propagation to the atoms: an active
+* snapshot, or a "done" snapshot, which means that the machine reached a final state
+* at the top level. The code skips an error snapshot and a stopped snapshot.
+* Therefore the atoms keep the last observable state, and they show no artifact of
+* a teardown or of an error.
+*/
+var isObservableSnapshot = (snapshot) => snapshot.status === "active" || snapshot.status === "done";
 /**
- * The concrete XState actor. It implements the atom protocol of the Play Architecture
- *
- * The class extends the `Actor` class of XState directly, and it implements
- * {@link @xmachines/play-actor!PlayActor}. It gives you the XState v5 integration, and it keeps the
- * compatibility with the ecosystem, such as the XState inspection and the devtools.
- * The constructor of the base class receives the machine. Therefore a `PlayerActor`
- * **is** the XState actor, and it is no wrapper around one: every member of the
- * XState `Actor` class works on the state of this instance, and this class adds the
- * reactive state on the atoms for the observation by the infrastructure.
- *
- * **Capabilities:** the class implements both the
- * {@link @xmachines/play-router!index.Routable} interface and the
- * {@link @xmachines/play-view!index.Viewable} interface. It therefore supports the
- * routing and the view rendering.
- *
- * **Architectural context:** the class implements **Actor Authority (INV-01)**,
- * because the guards of the XState machine control every decision of the
- * navigation. The infrastructure observes the atoms of the actor (`state`,
- * `currentRoute`, and `currentView`), but it changes no state directly: every
- * change goes through the event handlers of the state machine.
- *
- * @typeParam TMachine - The type of the XState v5 state machine
- *
- * @example
- * The creation of an actor, and its lifecycle
- * ```typescript
- * import { setup } from "xstate";
- * import { definePlayer, compose, PlayerActor } from "@xmachines/play-xstate";
- *
- * const machine = setup({}).createMachine({
- *   initial: 'idle',
- *   states: {
- *     idle: {
- *       meta: {
- *         route: '/',
- *         // A view spec needs `root` and `elements`. Every other shape derives null.
- *         view: {
- *           root: 'home',
- *           elements: { home: { type: 'HomePage', props: {}, children: [] } },
- *         },
- *       },
- *     }
- *   }
- * });
- *
- * const createPlayer = definePlayer({ machine });
- * const actor = createPlayer();
- * actor.start();
- *
- * // Observe the atoms
- * console.log(actor.currentRoute.get());          // '/'
- * console.log(actor.currentView.get()?.root);     // 'home'
- * ```
- *
- * @example
- * The atom lifecycle with a watch
- * ```typescript
- * import { watchAtom } from "@xmachines/play-atom";
- *
- * const stop = watchAtom(actor.state, (snapshot) => {
- *   console.log('State changed:', snapshot.value);
- * });
- *
- * actor.send({ type: 'play.route', to: '#about' });
- * // watchAtom delivers the new value from a microtask
- *
- * stop();
- * ```
- *
- * @see [Play RFC](../../docs/rfc/play.md)
- * @see {@link definePlayer} for the creation through a factory
- * @see {@link @xmachines/play-actor!PlayActor} for the atom protocol
- * @see {@link @xmachines/play-router!index.Routable} for the routing capability
- * @see {@link @xmachines/play-view!index.Viewable} for the view rendering capability
- *
- * @remarks
- * **The routing:** this actor supports the `route: {}` config pattern of XState and
- * also a `play.route` event with parameters. The `deriveRoute()` function reads
- * `meta.route`, which is the Stately pattern, for a URL template, and it substitutes
- * each parameter.
- *
- * **The pattern of the view atom:** `withView` of `@xmachines/play-xstate/view` adds
- * `currentView`, and that atom is a COMPUTED atom over `state`. One write for each
- * transition — `state.set(snapshot)` — therefore reaches the view and the route in one
- * flush, and no subscriber reads the new state beside an old derivation. The atom
- * memoizes the result, so a repeated read computes no view again.
- */
-export class PlayerActor extends Actor {
-    playerOptions;
-    /**
-     * The three inputs of the constructor that a CAPABILITY needs.
-     *
-     * A mixin over a generic base cannot declare a constructor: TypeScript then demands the
-     * signature `...args: any[]` (TS2545), which this workspace does not write. A field
-     * initializer of a subclass runs after `super()` instead, and it reads these. The
-     * routing capability derives `initialRoute` from all three.
-     */
-    playerMachine;
-    /** @see {@link playerMachine} */
-    playerInput;
-    /** @see {@link playerMachine} */
-    playerRestoredSnapshot;
-    /**
-     * The live options object of the caller, or an empty object during the construction.
-     *
-     * XState gives this actor to a context factory as `self`, and to an `inspect`
-     * observer as `actorRef`, from inside its own constructor, before the code assigns
-     * any field here. A read of a hook through this accessor therefore does not throw
-     * in that window. A throw goes to the initialization of XState, which parks it as
-     * an error snapshot. The accessor also keeps the behavior that the documentation of
-     * the object promises: a read at the moment of the delivery.
-     *
-     * The fields below that this window touches have a `declare` modifier for the same
-     * reason. This target compiles a class field into `Object.defineProperty`, which
-     * runs after `super()` returns. A plain declaration, with an initializer or without
-     * one, therefore resets each value of the window to `undefined`. A `declare`
-     * modifier emits nothing, and those values survive.
-     */
-    get hooks() {
-        return this.playerOptions ?? {};
-    }
-    // The requirements of the PlayActor contract
-    state;
-    /**
-     * Tells you if the current state of the actor accepts the given event.
-     *
-     * The type is the event union of the machine. An unknown event type is therefore a
-     * compile error. The method evaluates the event against the snapshot atom.
-     *
-     * @example
-     * ```typescript
-     * if (actor.can({ type: "auth.logout" })) { ... }
-     * ```
-     */
-    can(event) {
-        // A read of the atom keeps can() reactive: a computed atom over the atom
-        // computes its value again on each transition.
-        const snapshot = this.state?.get();
-        // The STATUS decides first, and the presence of the method decides second.
-        //
-        // An actor answers an event only while it is active. XState 5.32 made that test
-        // unnecessary by accident — the error snapshot of a failed initialization carried no
-        // `can` method, so a test of the method alone answered `false` for it — and 5.33
-        // gives that snapshot a working `can`, which then answered `true` for an actor that
-        // processes an event never. The status is what the question is really about, and a
-        // `done` actor answers `false` for the same reason.
-        //
-        // A STOPPED actor is the exception, and it is deliberate: the subscription below
-        // updates this atom on a stable state alone, so the atom keeps the last ACTIVE
-        // snapshot after a teardown rather than freezing on an artifact of it. `can()`
-        // therefore answers for the last live state of a stopped actor.
-        if (snapshot?.status !== "active")
-            return false;
-        return typeof snapshot.can === "function" ? snapshot.can(event) : false;
-    }
-    constructor(machine, options, input, restoredSnapshot) {
-        // A defensive check before super(): a machine that is not an object fails deep
-        // inside the constructor of XState, with an opaque TypeError, and not with a coded
-        // error.
-        if (!machine || typeof machine !== "object") {
-            throw new InvalidMachineError();
-        }
-        // THIS is the actor. The machine and its runtime options go directly to the Actor
-        // constructor of XState, which receives the same arguments as `createActor`
-        // forwards. Therefore no second instance answers for the real one, and every
-        // Actor member without an override here works on the real state.
-        //
-        // XState 5.28.0: the options object has a conditional type constraint on `input`,
-        // and TypeScript cannot resolve that constraint against an unbound generic
-        // TMachine. The cast stays inside the type system of XState, and the signature of
-        // this constructor gives `input` its type. Therefore each caller keeps the check
-        // at the compile time.
-        // Follow the improvements of the XState types: https://github.com/statelyai/xstate/issues
-        super(machine, {
-            input,
-            snapshot: restoredSnapshot,
-            inspect: options?.inspect,
-        });
-        this.playerMachine = machine;
-        this.playerInput = input;
-        this.playerRestoredSnapshot = restoredSnapshot;
-        this.playerOptions = options || {};
-        // Initialize the state atom. Each update is synchronous, with no batching in a
-        // microtask: XState groups the transitions of one send() call into one
-        // subscription callback already, and a synchronous update shows each guard
-        // redirect to a router bridge at once.
-        // `createWritableAtom`, and not `createAtom`. The overload pair of `createAtom` reads
-        // a function argument as a computed atom, and `ReturnType<TMachine["transition"]>` is
-        // an unresolved conditional type here, so TypeScript cannot rule a function out. It
-        // picks the computed signature, which returns a `ReadonlyAtom` that carries no `set`.
-        this.state = createWritableAtom(this.getSnapshot());
-        // Observe the transitions of this actor. The code uses `super`, and not `this`, so
-        // that the bookkeeping of the next-only subscriptions in the subscribe override
-        // stays about the subscriptions of the user code.
-        super.subscribe({
-            next: (snapshot) => {
-                // Update on a stable state only: an active snapshot, and the "done" snapshot of a
-                // final state at the top level. The code skips an error snapshot and a stopped
-                // snapshot. Therefore an atom never freezes on an artifact of a teardown.
-                if (isObservableSnapshot(snapshot)) {
-                    // Each state update is synchronous. Therefore a router bridge sees a guard redirect at once.
-                    this.state.set(snapshot);
-                    // ONE write for each transition, and the line above is it. `currentRoute` and
-                    // `currentView` are computed atoms over `state`, so that write propagates to
-                    // both in ONE flush, in topological order. No observer therefore reads the new
-                    // state beside an old derivation, and the composition order of the capabilities
-                    // decides nothing.
-                    //
-                    // A capability that must run an EFFECT on a transition overrides
-                    // `onSnapshot`. A capability that publishes a value derives it instead.
-                    //
-                    // The whole order of one transition:
-                    // 1. state receives its new value, and every computed atom over it follows
-                    // 2. onSnapshot runs each capability, in the composition order
-                    // 3. the onStateChange hook runs
-                    // 4. send() then calls onTransition
-                    this.onSnapshot(snapshot);
-                    // Call the onStateChange hook
-                    const onStateChange = this.hooks.onStateChange;
-                    if (onStateChange) {
-                        onStateChange(this, snapshot);
-                    }
-                }
-            },
-            // The code registers the listener always, and it reads the handler at the moment
-            // of the DELIVERY: the options object is shared by its reference. Therefore an
-            // onError handler on that object after the construction still receives each actor
-            // error, and the removal of a handler stops the silence again.
-            // Without a handler, the listener throws the error again. The observer dispatch of
-            // XState then sends it to its global unhandled rethrow, which is the same loud
-            // default as a listener that the code registers not.
-            error: (error) => {
-                const handler = this.hooks.onError;
-                if (handler) {
-                    handler(this, toError(error));
-                    return;
-                }
-                // A next-only subscription of the user code makes XState report this delivery
-                // globally already. A second throw here reports it two times.
-                if ((this.nextOnlySubscriptions ?? 0) > 0) {
-                    return;
-                }
-                throw error;
-            },
-        });
-        // The callbacks of the constructor of XState can reach everything above. After this
-        // point the instance is complete.
-        this.constructed = true;
-    }
-    /**
-     * Starts the actor.
-     *
-     * The method fires `onStart` on each real start, which is every transition from
-     * "not running" to "running". A start after a stop is such a transition, and XState
-     * permits it: its own `start()` stops only while the actor RUNS already. A second
-     * call while the actor runs fires no hook. Therefore a defensive double mount runs
-     * the side effects of `onStart` one time for one real start.
-     */
-    start() {
-        // See stop(): a call that reaches in through the construction window runs an actor
-        // that is not complete.
-        if (!this.constructed) {
-            return this;
-        }
-        super.start();
-        if (this.lifecycle !== "running") {
-            this.lifecycle = "running";
-            const onStart = this.hooks.onStart;
-            if (onStart) {
-                onStart(this);
-            }
-        }
-        return this;
-    }
-    /**
-     * Stops the actor and cleans up.
-     *
-     * The method fires `onStop` only when the actor ran. This matches XState, where a
-     * stop of an actor that never started, or of an actor that stopped already, does
-     * nothing and tears nothing down. Therefore the paired cleanup runs never two
-     * times, and it runs never against a resource that `onStart` did not take. A stop
-     * does not close the actor for ever: a later `start()` is a new lifecycle, and it
-     * fires `onStart` again.
-     */
-    stop() {
-        // A call that reaches in through the construction window, for example a context
-        // factory that stops its own `self`, marks the actor as stopped before the code
-        // registers its internal subscription. XState drops each observer of a stopped
-        // actor. The atoms therefore move never again. There is nothing to tear down
-        // during the construction, and the code ignores such a call.
-        if (!this.constructed) {
-            return this;
-        }
-        super.stop();
-        const wasRunning = this.lifecycle === "running";
-        this.lifecycle = "stopped";
-        const onStop = this.hooks.onStop;
-        if (wasRunning && onStop) {
-            onStop(this);
-        }
-        return this;
-    }
-    /**
-     * Sends an event to this actor.
-     *
-     * The guards of the state machine of the actor decide if the event causes a
-     * transition. Give any event of the event union of the machine: a domain event, a
-     * routing event, and so on.
-     *
-     * @param event - An event of the `EventFromLogic<TMachine>` union of the machine.
-     *
-     * @throws {InvalidEventError} When `event` is not a plain object, for example
-     *   `null`, `undefined`, a string, or a number. Import the class from
-     *   `@xmachines/play-xstate/errors`.
-     *
-     * @example
-     * ```typescript
-     * // A domain event, with the type of the event union of the machine
-     * actor.send({ type: "auth.login", userId: "123" });
-     *
-     * // A routing event
-     * actor.send({ type: "play.route", to: "#home" });
-     * ```
-     */
-    send(event) {
-        // A defensive check: the event must not be null and not undefined
-        if (!event || typeof event !== "object") {
-            throw new InvalidEventError(event);
-        }
-        // Inside the construction window there is no readable snapshot, and no hook can
-        // exist yet: deliver the event and return.
-        if (!this.constructed) {
-            Actor.prototype.send.call(this, event);
-            return;
-        }
-        // The code captures the snapshot always, because getSnapshot() is one property
-        // read, and because the options object is live: an onTransition handler that
-        // arrives during the processing of this event, for example from onStateChange,
-        // must still run for it, with the correct snapshot from before the send.
-        const prevSnapshot = this.getSnapshot();
-        // Send the event to the XState actor.
-        // The class declares send() to narrow the
-        // event type, and TypeScript forbids a super call to an abstract member.
-        // Therefore the code reaches the implementation of XState directly. `this` IS the
-        // actor. This call is therefore exactly the call of `super.send(event)`: the relay
-        // that emits the @xstate.event inspection event and puts the event in the mailbox
-        // of this actor.
-        Actor.prototype.send.call(this, event);
-        // Call the onTransition hook
-        const onTransition = this.hooks.onTransition;
-        if (onTransition) {
-            const nextSnapshot = this.getSnapshot();
-            onTransition(this, prevSnapshot, nextSnapshot);
-        }
-    }
-    subscribe(nextListenerOrObserver, errorListener, completeListener) {
-        // The subscribe() method of XState accepts a function and also an observer, and it
-        // normalizes them internally. The cast joins the two overload signatures only.
-        const subscription = super.subscribe(nextListenerOrObserver, errorListener, completeListener);
-        // An observer without an error listener makes XState throw each actor error again,
-        // globally, for that observer. The code counts those observers. Therefore the loud
-        // default of the internal listener, which also throws again, stands down while one
-        // of them is active. See the error listener of the constructor.
-        const hasErrorListener = typeof nextListenerOrObserver === "object" && nextListenerOrObserver !== null
-            ? typeof nextListenerOrObserver.error === "function"
-            : typeof errorListener === "function";
-        if (hasErrorListener) {
-            return subscription;
-        }
-        this.nextOnlySubscriptions = (this.nextOnlySubscriptions ?? 0) + 1;
-        let counted = true;
-        return {
-            unsubscribe: () => {
-                if (counted) {
-                    counted = false;
-                    this.nextOnlySubscriptions = (this.nextOnlySubscriptions ?? 1) - 1;
-                }
-                subscription.unsubscribe();
-            },
-        };
-    }
-    /**
-     * Returns the persisted snapshot of this actor.
-     *
-     * Use it to serialize the state, and to restore it later with the
-     * `restore.snapshot` option of the factory.
-     */
-    getPersistedSnapshot(options) {
-        const forward = super.getPersistedSnapshot;
-        return forward.call(this, options);
-    }
-    /**
-     * The point where a capability derives its own atoms from a new snapshot.
-     *
-     * The base derives nothing: `PlayActor` asks for `state` and `send`, and this class
-     * gives exactly those.
-     *
-     * A capability that PUBLISHES a value overrides this method NOT. It derives the value
-     * with a computed atom over `state`, as `withRouting` and `withView` both do, and the
-     * engine then evaluates every derivation from the one write of a transition, in
-     * topological order. The composition order therefore decides no value.
-     *
-     * This method remains for a capability that must run an EFFECT on a transition. Such a
-     * mixin overrides it and calls `super.onSnapshot(snapshot)` FIRST, so that every
-     * capability composed before it runs its own effect first.
-     *
-     * The method runs after `state` holds the new snapshot and before the `onStateChange`
-     * hook of the options.
-     *
-     * @param snapshot - The stable snapshot of this transition.
-     */
-    onSnapshot(snapshot) {
-        // The base class holds no capability. A mixin overrides this method.
-        void snapshot;
-    }
-}
+* The concrete XState actor. It implements the atom protocol of the Play Architecture
+*
+* The class extends the `Actor` class of XState directly, and it implements
+* {@link @xmachines/play-actor!PlayActor}. It gives you the XState v5 integration, and it keeps the
+* compatibility with the ecosystem, such as the XState inspection and the devtools.
+* The constructor of the base class receives the machine. Therefore a `PlayerActor`
+* **is** the XState actor, and it is no wrapper around one: every member of the
+* XState `Actor` class works on the state of this instance, and this class adds the
+* reactive state on the atoms for the observation by the infrastructure.
+*
+* **Capabilities:** the class implements both the
+* {@link @xmachines/play-router!index.Routable} interface and the
+* {@link @xmachines/play-view!index.Viewable} interface. It therefore supports the
+* routing and the view rendering.
+*
+* **Architectural context:** the class implements **Actor Authority (INV-01)**,
+* because the guards of the XState machine control every decision of the
+* navigation. The infrastructure observes the atoms of the actor (`state`,
+* `currentRoute`, and `currentView`), but it changes no state directly: every
+* change goes through the event handlers of the state machine.
+*
+* @typeParam TMachine - The type of the XState v5 state machine
+*
+* @example
+* The creation of an actor, and its lifecycle
+* ```typescript
+* import { setup } from "xstate";
+* import { definePlayer, compose, PlayerActor } from "@xmachines/play-xstate";
+*
+* const machine = setup({}).createMachine({
+*   initial: 'idle',
+*   states: {
+*     idle: {
+*       meta: {
+*         route: '/',
+*         // A view spec needs `root` and `elements`. Every other shape derives null.
+*         view: {
+*           root: 'home',
+*           elements: { home: { type: 'HomePage', props: {}, children: [] } },
+*         },
+*       },
+*     }
+*   }
+* });
+*
+* const createPlayer = definePlayer({ machine });
+* const actor = createPlayer();
+* actor.start();
+*
+* // Observe the atoms
+* console.log(actor.currentRoute.get());          // '/'
+* console.log(actor.currentView.get()?.root);     // 'home'
+* ```
+*
+* @example
+* The atom lifecycle with a watch
+* ```typescript
+* import { watchAtom } from "@xmachines/play-atom";
+*
+* const stop = watchAtom(actor.state, (snapshot) => {
+*   console.log('State changed:', snapshot.value);
+* });
+*
+* actor.send({ type: 'play.route', to: '#about' });
+* // watchAtom delivers the new value from a microtask
+*
+* stop();
+* ```
+*
+* @see [Play RFC](../../docs/rfc/play.md)
+* @see {@link definePlayer} for the creation through a factory
+* @see {@link @xmachines/play-actor!PlayActor} for the atom protocol
+* @see {@link @xmachines/play-router!index.Routable} for the routing capability
+* @see {@link @xmachines/play-view!index.Viewable} for the view rendering capability
+*
+* @remarks
+* **The routing:** this actor supports the `route: {}` config pattern of XState and
+* also a `play.route` event with parameters. The `deriveRoute()` function reads
+* `meta.route`, which is the Stately pattern, for a URL template, and it substitutes
+* each parameter.
+*
+* **The pattern of the view atom:** `withView` of `@xmachines/play-xstate/view` adds
+* `currentView`, and that atom is a COMPUTED atom over `state`. One write for each
+* transition — `state.set(snapshot)` — therefore reaches the view and the route in one
+* flush, and no subscriber reads the new state beside an old derivation. The atom
+* memoizes the result, so a repeated read computes no view again.
+*/
+var PlayerActor = class extends Actor {
+	playerOptions;
+	/**
+	* The three inputs of the constructor that a CAPABILITY needs.
+	*
+	* A mixin over a generic base cannot declare a constructor: TypeScript then demands the
+	* signature `...args: any[]` (TS2545), which this workspace does not write. A field
+	* initializer of a subclass runs after `super()` instead, and it reads these. The
+	* routing capability derives `initialRoute` from all three.
+	*/
+	playerMachine;
+	/** @see {@link playerMachine} */
+	playerInput;
+	/** @see {@link playerMachine} */
+	playerRestoredSnapshot;
+	/**
+	* The live options object of the caller, or an empty object during the construction.
+	*
+	* XState gives this actor to a context factory as `self`, and to an `inspect`
+	* observer as `actorRef`, from inside its own constructor, before the code assigns
+	* any field here. A read of a hook through this accessor therefore does not throw
+	* in that window. A throw goes to the initialization of XState, which parks it as
+	* an error snapshot. The accessor also keeps the behavior that the documentation of
+	* the object promises: a read at the moment of the delivery.
+	*
+	* The fields below that this window touches have a `declare` modifier for the same
+	* reason. This target compiles a class field into `Object.defineProperty`, which
+	* runs after `super()` returns. A plain declaration, with an initializer or without
+	* one, therefore resets each value of the window to `undefined`. A `declare`
+	* modifier emits nothing, and those values survive.
+	*/
+	get hooks() {
+		return this.playerOptions ?? {};
+	}
+	state;
+	/**
+	* Tells you if the current state of the actor accepts the given event.
+	*
+	* The type is the event union of the machine. An unknown event type is therefore a
+	* compile error. The method evaluates the event against the snapshot atom.
+	*
+	* @example
+	* ```typescript
+	* if (actor.can({ type: "auth.logout" })) { ... }
+	* ```
+	*/
+	can(event) {
+		const snapshot = this.state?.get();
+		if (snapshot?.status !== "active") return false;
+		return typeof snapshot.can === "function" ? snapshot.can(event) : false;
+	}
+	constructor(machine, options, input, restoredSnapshot) {
+		if (!machine || typeof machine !== "object") throw new InvalidMachineError();
+		super(machine, {
+			input,
+			snapshot: restoredSnapshot,
+			inspect: options?.inspect
+		});
+		this.playerMachine = machine;
+		this.playerInput = input;
+		this.playerRestoredSnapshot = restoredSnapshot;
+		this.playerOptions = options || {};
+		this.state = createWritableAtom(this.getSnapshot());
+		super.subscribe({
+			next: (snapshot) => {
+				if (isObservableSnapshot(snapshot)) {
+					this.state.set(snapshot);
+					this.onSnapshot(snapshot);
+					const onStateChange = this.hooks.onStateChange;
+					if (onStateChange) onStateChange(this, snapshot);
+				}
+			},
+			error: (error) => {
+				const handler = this.hooks.onError;
+				if (handler) {
+					handler(this, toError(error));
+					return;
+				}
+				if ((this.nextOnlySubscriptions ?? 0) > 0) return;
+				throw error;
+			}
+		});
+		this.constructed = true;
+	}
+	/**
+	* Starts the actor.
+	*
+	* The method fires `onStart` on each real start, which is every transition from
+	* "not running" to "running". A start after a stop is such a transition, and XState
+	* permits it: its own `start()` stops only while the actor RUNS already. A second
+	* call while the actor runs fires no hook. Therefore a defensive double mount runs
+	* the side effects of `onStart` one time for one real start.
+	*/
+	start() {
+		if (!this.constructed) return this;
+		super.start();
+		if (this.lifecycle !== "running") {
+			this.lifecycle = "running";
+			const onStart = this.hooks.onStart;
+			if (onStart) onStart(this);
+		}
+		return this;
+	}
+	/**
+	* Stops the actor and cleans up.
+	*
+	* The method fires `onStop` only when the actor ran. This matches XState, where a
+	* stop of an actor that never started, or of an actor that stopped already, does
+	* nothing and tears nothing down. Therefore the paired cleanup runs never two
+	* times, and it runs never against a resource that `onStart` did not take. A stop
+	* does not close the actor for ever: a later `start()` is a new lifecycle, and it
+	* fires `onStart` again.
+	*/
+	stop() {
+		if (!this.constructed) return this;
+		super.stop();
+		const wasRunning = this.lifecycle === "running";
+		this.lifecycle = "stopped";
+		const onStop = this.hooks.onStop;
+		if (wasRunning && onStop) onStop(this);
+		return this;
+	}
+	/**
+	* Sends an event to this actor.
+	*
+	* The guards of the state machine of the actor decide if the event causes a
+	* transition. Give any event of the event union of the machine: a domain event, a
+	* routing event, and so on.
+	*
+	* @param event - An event of the `EventFromLogic<TMachine>` union of the machine.
+	*
+	* @throws {InvalidEventError} When `event` is not a plain object, for example
+	*   `null`, `undefined`, a string, or a number. Import the class from
+	*   `@xmachines/play-xstate/errors`.
+	*
+	* @example
+	* ```typescript
+	* // A domain event, with the type of the event union of the machine
+	* actor.send({ type: "auth.login", userId: "123" });
+	*
+	* // A routing event
+	* actor.send({ type: "play.route", to: "#home" });
+	* ```
+	*/
+	send(event) {
+		if (!event || typeof event !== "object") throw new InvalidEventError(event);
+		if (!this.constructed) {
+			Actor.prototype.send.call(this, event);
+			return;
+		}
+		const prevSnapshot = this.getSnapshot();
+		Actor.prototype.send.call(this, event);
+		const onTransition = this.hooks.onTransition;
+		if (onTransition) {
+			const nextSnapshot = this.getSnapshot();
+			onTransition(this, prevSnapshot, nextSnapshot);
+		}
+	}
+	subscribe(nextListenerOrObserver, errorListener, completeListener) {
+		const subscription = super.subscribe(nextListenerOrObserver, errorListener, completeListener);
+		if (typeof nextListenerOrObserver === "object" && nextListenerOrObserver !== null ? typeof nextListenerOrObserver.error === "function" : typeof errorListener === "function") return subscription;
+		this.nextOnlySubscriptions = (this.nextOnlySubscriptions ?? 0) + 1;
+		let counted = true;
+		return { unsubscribe: () => {
+			if (counted) {
+				counted = false;
+				this.nextOnlySubscriptions = (this.nextOnlySubscriptions ?? 1) - 1;
+			}
+			subscription.unsubscribe();
+		} };
+	}
+	/**
+	* Returns the persisted snapshot of this actor.
+	*
+	* Use it to serialize the state, and to restore it later with the
+	* `restore.snapshot` option of the factory.
+	*/
+	getPersistedSnapshot(options) {
+		return super.getPersistedSnapshot.call(this, options);
+	}
+	/**
+	* The point where a capability derives its own atoms from a new snapshot.
+	*
+	* The base derives nothing: `PlayActor` asks for `state` and `send`, and this class
+	* gives exactly those.
+	*
+	* A capability that PUBLISHES a value overrides this method NOT. It derives the value
+	* with a computed atom over `state`, as `withRouting` and `withView` both do, and the
+	* engine then evaluates every derivation from the one write of a transition, in
+	* topological order. The composition order therefore decides no value.
+	*
+	* This method remains for a capability that must run an EFFECT on a transition. Such a
+	* mixin overrides it and calls `super.onSnapshot(snapshot)` FIRST, so that every
+	* capability composed before it runs its own effect first.
+	*
+	* The method runs after `state` holds the new snapshot and before the `onStateChange`
+	* hook of the options.
+	*
+	* @param snapshot - The stable snapshot of this transition.
+	*/
+	onSnapshot(snapshot) {}
+};
+//#endregion
+export { PlayerActor, toError };
+
 //# sourceMappingURL=player-actor.js.map