@xmachines/play-xstate 2.2.0 → 4.0.0

package/dist/errors.js

@@ -1,4 +1,4 @@
-import { PlayError } from "@xmachines/play";
+import { PlayError } from "@xmachines/play/errors";
 /**
  * Converts a value from a throw into a string, and it trusts that value not:
  * `String()` itself throws for an object with a null prototype, and also for a value
@@ -35,7 +35,7 @@ const safeString = (value) => {
  *
  * @example
  * ```typescript
- * import { buildRouteUrl } from "@xmachines/play-xstate";
+ * import { buildRouteUrl } from "@xmachines/play-xstate/routing";
  * import { MissingRouteParamError } from "@xmachines/play-xstate/errors";
  *
  * try {
@@ -61,28 +61,6 @@ export class MissingRouteParamError extends PlayError {
         this.template = template;
     }
 }
-/**
- * @deprecated Nothing throws this error now. `buildRouteUrl` reads an absent `query`
- * field as `query: {}`. The generated `play.route` transitions assign `query` on
- * every navigation, and the loss that this error guarded against therefore cannot
- * happen through the route derivation. A machine that handles `play.route` itself
- * and wants the query must assign `event.query` to its context itself. This class
- * stays in the exports, so that an `instanceof` handler that exists now still
- * compiles. Remove such a handler when you have the time.
- *
- * `buildRouteUrl()` threw this error before, when the context had a `params` field,
- * which means a context that knows the routing, but no `query` field.
- *
- * **Error code:** `PLAY_XSTATE_MISSING_QUERY_CONTEXT`
- */
-export class MissingQueryContextError extends PlayError {
-    constructor() {
-        super("buildRouteUrl", "PLAY_XSTATE_MISSING_QUERY_CONTEXT", "buildRouteUrl() received a context without a 'query' field. " +
-            "Declare 'query: Record<string, string>' in the machine context type and " +
-            "initialise it to {} so query parameters from play.route events are not silently dropped.");
-        this.name = "MissingQueryContextError";
-    }
-}
 /**
  * `formatPlayRouteTransitions()` throws this error when a state node declares a
  * `meta.route` field but no explicit `id` field.
@@ -140,6 +118,25 @@ export class InvalidMachineError extends PlayError {
         this.name = "InvalidMachineError";
     }
 }
+/**
+ * Describes an unknown value for the message of an error, and throws nothing itself.
+ *
+ * `JSON.stringify` alone is not enough for a value that arrives from the config of a
+ * user. It returns the VALUE `undefined` for a function, for a symbol, and for
+ * `undefined`, which puts the text "undefined" in a field that is declared `string`.
+ * It also THROWS a `TypeError` for a circular object, and an error constructor that
+ * throws hides the error that it was built to report.
+ *
+ * The fallback names the type instead, for example `[function]`.
+ */
+function describeValue(value) {
+    try {
+        return JSON.stringify(value) ?? `[${typeof value}]`;
+    }
+    catch {
+        return `[${typeof value}]`;
+    }
+}
 /**
  * `normalizeRoute()` throws this error when the `meta.route` value of a state is not
  * a string and not an object with a `path` property.
@@ -150,25 +147,46 @@ export class InvalidRouteMetadataError extends PlayError {
     /** The invalid route value, as a string, for the debug work. */
     detail;
     constructor(route, source = "deriveRoute") {
-        const detail = JSON.stringify(route);
+        const detail = describeValue(route);
         super(source, "PLAY_XSTATE_INVALID_ROUTE_METADATA", `Invalid route metadata: ${detail}. Expected string or { path: string }`);
         this.name = "InvalidRouteMetadataError";
         this.detail = detail;
     }
 }
 /**
- * `composeGuards()` and `composeGuardsOr()` throw this error for an empty array of
- * guards. A composition of zero guards has no meaning.
+ * `formatPlayRouteTransitions()` throws this error for a `meta.route` object whose
+ * `handler` field holds a value that the routing layer does not know.
+ *
+ * The field decides WHERE the generated `play.route` transition sits, and each value
+ * produces a different reachability. `"local"` in particular makes a state reachable
+ * only while its parent is active. A typo such as `"locale"` would therefore fall back
+ * to a placement that the author did not ask for, and the route would behave correctly
+ * in the test that the author wrote and wrongly everywhere else. The error refuses the
+ * value instead.
  *
- * **Error code:** `PLAY_XSTATE_EMPTY_GUARD_ARRAY`
+ * **Error code:** `PLAY_XSTATE_INVALID_ROUTE_HANDLER`
+ *
+ * @example
+ * ```typescript
+ * import { InvalidRouteHandlerError } from "@xmachines/play-xstate/errors";
+ *
+ * try {
+ *   formatPlayRouteTransitions(config);
+ * } catch (error) {
+ *   if (error instanceof InvalidRouteHandlerError) {
+ *     console.error(error.handler); // the value that the config declared
+ *   }
+ * }
+ * ```
  */
-export class EmptyGuardArrayError extends PlayError {
-    /** The combinator of the call with the empty array: `"and"` or `"or"`. */
-    combinator;
-    constructor(combinator) {
-        super(combinator === "and" ? "composeGuards" : "composeGuardsOr", "PLAY_XSTATE_EMPTY_GUARD_ARRAY", `${combinator === "and" ? "composeGuards" : "composeGuardsOr"} requires at least one guard`);
-        this.name = "EmptyGuardArrayError";
-        this.combinator = combinator;
+export class InvalidRouteHandlerError extends PlayError {
+    /** The value that the config declared, as a string, for the debug work. */
+    handler;
+    constructor(handler, source = "formatPlayRouteTransitions") {
+        const detail = describeValue(handler);
+        super(source, "PLAY_XSTATE_INVALID_ROUTE_HANDLER", `Invalid route handler: ${detail}. Expected "root", "local", or "both"`);
+        this.name = "InvalidRouteHandlerError";
+        this.handler = detail;
     }
 }
 /**

package/dist/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -13,9 +13,8 @@
  */
 export { definePlayer } from "./define-player.js";
 export { PlayerActor } from "./player-actor.js";
+export { compose } from "./capabilities.js";
+export type { Capability, PlayerConstructor } from "./capabilities.js";
 export type { PlayerConfig, PlayerOptions, PlayerFactory, PlayerFactoryResumeOptions, } from "./types.js";
-export { composeGuards, composeGuardsOr, negateGuard, hasContext, eventMatches, contextFieldMatches, } from "./guards/index.js";
-export type { Guard, GuardArray, ComposedGuard } from "./guards/index.js";
-export { deriveRoute, isAbsoluteRoute, buildRouteUrl, formatPlayRouteTransitions, } from "./routing/index.js";
-export type { RouteMachineConfig, RouteStateNode, RouteContext, RouteObject, RouteMetadata, } from "./routing/index.js";
+export { DISPOSE } from "@xmachines/play";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EACX,YAAY,EACZ,aAAa,EACb,aAAa,EACb,0BAA0B,GAC1B,MAAM,YAAY,CAAC;AAGpB,OAAO,EACN,aAAa,EACb,eAAe,EACf,WAAW,EACX,UAAU,EACV,YAAY,EACZ,mBAAmB,GACnB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAG1E,OAAO,EACN,WAAW,EACX,eAAe,EACf,aAAa,EACb,0BAA0B,GAC1B,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACX,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,WAAW,EACX,aAAa,GACb,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIhD,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACvE,YAAY,EACX,YAAY,EACZ,aAAa,EACb,aAAa,EACb,0BAA0B,GAC1B,MAAM,YAAY,CAAC;AAWpB,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -13,8 +13,18 @@
  */
 export { definePlayer } from "./define-player.js";
 export { PlayerActor } from "./player-actor.js";
-// The guard utilities
-export { composeGuards, composeGuardsOr, negateGuard, hasContext, eventMatches, contextFieldMatches, } from "./guards/index.js";
-// The routing utilities
-export { deriveRoute, isAbsoluteRoute, buildRouteUrl, formatPlayRouteTransitions, } from "./routing/index.js";
+// The composition of the capabilities. Each capability itself lives behind its own entry
+// point — `@xmachines/play-xstate/routing` and `@xmachines/play-xstate/view` — so this
+// module imports neither, and an application loads only what it composes.
+export { compose } from "./capabilities.js";
+// The routing utilities live behind `@xmachines/play-xstate/routing`, with the mixin
+// that needs them: `deriveRoute`, `isAbsoluteRoute`, `buildRouteUrl`,
+// `formatPlayRouteTransitions`, and the route types. Each one names
+// `@xmachines/play-router` in its `.d.ts`, and that package is an OPTIONAL peer. This
+// entry therefore names no capability package, exactly as the view half does.
+// The release protocol of @xmachines/play. This package's own published `.d.ts` names
+// exactly these, so a consumer reads them from here and needs no second manifest
+// entry. It names `asCleanup` nowhere: a consumer of this package RECEIVES a
+// release, and builds one only with @xmachines/play itself.
+export { DISPOSE } from "@xmachines/play";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAQhD,sBAAsB;AACtB,OAAO,EACN,aAAa,EACb,eAAe,EACf,WAAW,EACX,UAAU,EACV,YAAY,EACZ,mBAAmB,GACnB,MAAM,mBAAmB,CAAC;AAG3B,wBAAwB;AACxB,OAAO,EACN,WAAW,EACX,eAAe,EACf,aAAa,EACb,0BAA0B,GAC1B,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,yFAAyF;AACzF,uFAAuF;AACvF,0EAA0E;AAC1E,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAS5C,qFAAqF;AACrF,sEAAsE;AACtE,oEAAoE;AACpE,sFAAsF;AACtF,8EAA8E;AAC9E,sFAAsF;AACtF,iFAAiF;AACjF,6EAA6E;AAC7E,4DAA4D;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/player-actor.d.ts

@@ -1,12 +1,25 @@
-import { Actor, type AnyStateMachine, type AnyActorLogic, type EmittedFrom, type InputFrom, type ActorOptions, type Observer, type Snapshot, type SnapshotFrom, type Subscription, type EventFromLogic } from "xstate";
-import { AbstractActor, type Routable, type Viewable, type PlaySpec } from "@xmachines/play-actor";
+import { Actor, type AnyStateMachine, type AnyMachineSnapshot, type InputFrom, type ActorOptions, type Observer, type Snapshot, type SnapshotFrom, type Subscription, type EventFromLogic } from "xstate";
+import type { PlayActor } from "@xmachines/play-actor";
+import { DISPOSE } from "@xmachines/play";
 import { Signal } from "@xmachines/play-signals";
 import type { PlayerOptions } from "./types.js";
+/**
+ * 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 declare const toError: (value: unknown) => Error;
 /**
  * The concrete XState actor. It implements the signal protocol of the Play Architecture
  *
- * The class extends {@link @xmachines/play-actor!AbstractActor}, and therefore the
- * `Actor` class of XState. It gives you the XState v5 integration, and it keeps the
+ * 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
@@ -14,8 +27,8 @@ import type { PlayerOptions } from "./types.js";
  * reactive state on the TC39 Signals for the observation by the infrastructure.
  *
  * **Capabilities:** the class implements both the
- * {@link @xmachines/play-actor!Routable} interface and the
- * {@link @xmachines/play-actor!Viewable} interface. It therefore supports 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)**,
@@ -30,7 +43,7 @@ import type { PlayerOptions } from "./types.js";
  * The creation of an actor, and its lifecycle
  * ```typescript
  * import { setup } from "xstate";
- * import { definePlayer } from "@xmachines/play-xstate";
+ * import { definePlayer, compose, PlayerActor } from "@xmachines/play-xstate";
  *
  * const machine = setup({}).createMachine({
  *   initial: 'idle',
@@ -76,9 +89,9 @@ import type { PlayerOptions } from "./types.js";
  *
  * @see [Play RFC](../../docs/rfc/play.md)
  * @see {@link definePlayer} for the creation through a factory
- * @see {@link @xmachines/play-actor!AbstractActor} for the signal protocol
- * @see {@link @xmachines/play-actor!Routable} for the routing capability
- * @see {@link @xmachines/play-actor!Viewable} for the view rendering capability
+ * @see {@link @xmachines/play-actor!PlayActor} for the signal 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
@@ -91,8 +104,21 @@ import type { PlayerOptions } from "./types.js";
  * PlayRenderer is therefore correct. The class derives each view at the entry of a
  * state and keeps it, and it computes no view on a read.
  */
-export declare class PlayerActor<TMachine extends AnyStateMachine> extends AbstractActor<AnyActorLogic, EventFromLogic<TMachine>> implements Routable, Viewable {
+export declare class PlayerActor<TMachine extends AnyStateMachine> extends Actor<TMachine> implements PlayActor<ReturnType<TMachine["transition"]>, EventFromLogic<TMachine>> {
     private 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.
+     */
+    protected readonly playerMachine: TMachine;
+    /** @see {@link playerMachine} */
+    protected readonly playerInput: InputFrom<TMachine> | undefined;
+    /** @see {@link playerMachine} */
+    protected readonly playerRestoredSnapshot: ActorOptions<TMachine>["snapshot"] | undefined;
     /**
      * Tells you if this constructor returned already.
      *
@@ -119,7 +145,7 @@ export declare class PlayerActor<TMachine extends AnyStateMachine> extends Abstr
      * one, therefore resets each value of the window to `undefined`. A `declare`
      * modifier emits nothing, and those values survive.
      */
-    private get hooks();
+    protected get hooks(): PlayerOptions<TMachine>;
     /**
      * The record of the real lifecycle transitions, so that onStart and onStop each
      * fire one time. The status of XState is internal, and a machine snapshot reads
@@ -136,15 +162,6 @@ export declare class PlayerActor<TMachine extends AnyStateMachine> extends Abstr
      * times.
      */
     private nextOnlySubscriptions?;
-    /**
-     * The last snapshot of the view pipeline. XState notifies each observer on EVERY
-     * event that it processes, and an event that it ignores delivers the identical
-     * snapshot again. deriveCurrentView is pure in the snapshot. Therefore an identical
-     * reference can change no result. The first value is undefined, and never a
-     * snapshot: the snapshot of the construction has the same reference as the snapshot
-     * that start() replays, and that value therefore stops the first view.
-     */
-    private lastViewSnapshot;
     state: Signal.State<ReturnType<TMachine["transition"]>>;
     /**
      * Tells you if the current state of the actor accepts the given event.
@@ -158,77 +175,6 @@ export declare class PlayerActor<TMachine extends AnyStateMachine> extends Abstr
      * ```
      */
     can(event: EventFromLogic<TMachine>): boolean;
-    /**
-     * A TC39 `Signal.Computed`. It derives the current URL path from the `meta.route`
-     * template of the active machine state and from the context of the actor.
-     *
-     * It returns `null` when the current state has no `meta.route` field, and also when
-     * it cannot resolve the complete route template. A necessary `:param` that the
-     * context does not hold is caught inside the signal, and a
-     * `MissingRouteParamError` therefore never leaves `get()`: that condition is
-     * temporary during a transition, and the signal computes the value again on the next
-     * snapshot.
-     *
-     * @example
-     * ```typescript
-     * // It returns "/profile/alice" when context.params.userId === "alice",
-     * // and null while the param is still absent.
-     * const route = actor.currentRoute.get();
-     * ```
-     */
-    currentRoute: Signal.Computed<string | null>;
-    /**
-     * The route of the initial state of the machine. The constructor fixes it, and it
-     * never changes, also when the code restores the actor from a snapshot.
-     *
-     * A router bridge compares it with the browser URL, and it therefore separates a
-     * deep link (a URL that is not the initial one → the router wins) from a restore
-     * (the initial URL, and the actor at a different route from the restore → the actor
-     * wins).
-     *
-     * `deriveInitialRoute` derives the value statically from the machine definition,
-     * with the pure `initialTransition` helper of XState: the chain of the initial states
-     * and their `meta.route` templates are fixed at the moment of the machine
-     * definition, and the substitution of a `:param` uses the real initial context of
-     * the machine for the `input` of this actor. The code makes no second actor, and a
-     * snapshot of a restore changes the value never: it is always the **default**
-     * initial route of the machine.
-     */
-    readonly initialRoute: string | null;
-    /**
-     * The reactive signal of the current view spec. The signal derives the spec from
-     * the `meta.view` metadata of the active state.
-     *
-     * It emits a **new object reference** on each real change of the view on the
-     * screen: the view of a different state, or a change of a param or of the context
-     * that changes the resolved spec. A re-entry with `reenter: true` and new params
-     * also changes the spec. A snapshot that changes no view on the screen, such as an
-     * assign of the context alone, keeps the previous reference. A provider below the
-     * signal therefore mounts the UI again not on every event.
-     *
-     * The `PlaySpec` of the emission carries the context of the machine in its composed
-     * `state` field, under the read-only `/context` subtree. A spec therefore reads the
-     * context, and also each URL param, through the ordinary state grammar
-     * (`{ $state: "/context/params/section" }`). The context-projection module of
-     * `@xmachines/play-actor` holds the complete contract.
-     *
-     * The signal returns `null` when the current state has no `meta.view` metadata.
-     *
-     * Two states can declare two separate `meta.view` literals with an identical
-     * structure. A transition between those two states then emits two different
-     * references, and a provider mounts the UI again. Move the shared literal into one
-     * `typedSpec` constant, and the identity then removes the duplicate.
-     *
-     * @example
-     * ```typescript
-     * const view = actor.currentView.get();
-     * if (view) {
-     *   console.log(view.root);     // for example "root"
-     *   console.log(view.elements); // the Spec elements of @xmachines/json-render-core
-     * }
-     * ```
-     */
-    readonly currentView: Signal.State<PlaySpec | null>;
     constructor(machine: TMachine, options: PlayerOptions<TMachine>, input?: InputFrom<TMachine>, restoredSnapshot?: ActorOptions<TMachine>["snapshot"]);
     /**
      * Starts the actor.
@@ -274,10 +220,6 @@ export declare class PlayerActor<TMachine extends AnyStateMachine> extends Abstr
      * ```
      */
     send(event: EventFromLogic<TMachine>): void;
-    /**
-     * Returns the current snapshot
-     */
-    getSnapshot(): ReturnType<Actor<TMachine>["getSnapshot"]>;
     /**
      * Subscribes to the snapshot updates of this actor.
      *
@@ -298,16 +240,6 @@ export declare class PlayerActor<TMachine extends AnyStateMachine> extends Abstr
      * @returns The subscription, with an `unsubscribe()` method.
      */
     subscribe(nextListener?: (snapshot: SnapshotFrom<TMachine>) => void, errorListener?: (error: unknown) => void, completeListener?: () => void): Subscription;
-    /**
-     * Listens for the events that this actor emits with the `emit` action.
-     *
-     * @param type - The type of the emitted event to listen for, or `"*"` for every event.
-     * @param handler - The actor calls it with each emitted event that matches.
-     * @returns The subscription, with an `unsubscribe()` method.
-     */
-    on<TType extends EmittedFrom<TMachine>["type"] | "*">(type: TType, handler: (emitted: EmittedFrom<TMachine> & (TType extends "*" ? unknown : {
-        type: TType;
-    })) => void): Subscription;
     /**
      * Returns the persisted snapshot of this actor.
      *
@@ -316,18 +248,46 @@ export declare class PlayerActor<TMachine extends AnyStateMachine> extends Abstr
      */
     getPersistedSnapshot(options?: unknown): Snapshot<unknown>;
     /**
-     * Derives the view at the entry of a state, and keeps it. This happens one time for
-     * each transition. The signal holds the view, and the code computes it not on each
-     * read.
+     * The point where a capability derives its own signals from a new snapshot.
+     *
+     * The base derives nothing: `PlayActor` asks for `state` and `send`, and this class
+     * gives exactly those. A capability is a mixin that overrides this method, calls
+     * `super.onSnapshot(snapshot)` FIRST, and then writes its own signal.
+     *
+     * That one rule fixes the order, and the order is load-bearing. The view of a state
+     * reads the route and the state that the same transition produced, and a router bridge
+     * must see a guard redirect synchronously. `compose(PlayerActor, withRouting, withView)`
+     * therefore derives the route before the view, because `withView` wraps the class that
+     * `withRouting` returned.
+     *
+     * The method runs after `state` holds the new snapshot and before the `onStateChange`
+     * hook of the options.
      *
-     * @param snapshot - The current XState snapshot
+     * @param snapshot - The stable snapshot of this transition.
      */
-    private validateAndCacheView;
+    protected onSnapshot(snapshot: AnyMachineSnapshot): void;
     /**
-     * The dispose method, for the cleanup. It is the alias of {@link stop}.
+     * Stops the actor when the scope of a `using` declaration ends.
+     *
+     * The actor is a `Disposable`, so a scope that owns one writes no teardown:
+     *
+     * ```ts
+     * {
+     *   using actor = definePlayer({ machine })();
+     *   actor.start();
+     *   actor.send({ type: "go" });
+     *   // stop() runs here, and it runs even when send() throws
+     * }
+     * ```
+     *
+     * The release is {@link stop}, which is synchronous and idempotent. `Disposable` and
+     * not `AsyncDisposable`: a `Disposable` serves `using` AND `await using`, while an
+     * `AsyncDisposable` raises a TypeError under a plain `using`.
      *
-     * @deprecated Use {@link stop}. Will be removed in the next major.
+     * The key is `DISPOSE` of `@xmachines/play` and not a bare `Symbol.dispose`, so that
+     * the method still answers a `using` that a bundler downlevelled for a target without
+     * the well-known symbol.
      */
-    dispose(): void;
+    [DISPOSE](): void;
 }
 //# sourceMappingURL=player-actor.d.ts.map

package/dist/player-actor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"player-actor.d.ts","sourceRoot":"","sources":["../src/player-actor.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,EACL,KAAK,eAAe,EACpB,KAAK,aAAa,EAElB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,MAAM,QAAQ,CAAC;AAChB,OAAO,EACN,aAAa,EAGb,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAGjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAuFhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFG;AACH,qBAAa,WAAW,CAAC,QAAQ,SAAS,eAAe,CACxD,SAAQ,aAAa,CAAC,aAAa,EAAE,cAAc,CAAC,QAAQ,CAAC,CAC7D,YAAW,QAAQ,EAAE,QAAQ;IAE7B,OAAO,CAAC,aAAa,CAAC,CAA0B;IAChD;;;;;;;;OAQG;IACH,QAAgB,WAAW,CAAC,CAAU;IACtC;;;;;;;;;;;;;;;OAeG;IACH,OAAO,KAAK,KAAK,GAEhB;IACD;;;;;OAKG;IACH,QAAgB,SAAS,CAAC,CAAoC;IAC9D;;;;;;;OAOG;IACH,QAAgB,qBAAqB,CAAC,CAAS;IAC/C;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB,CAA6C;IAG9D,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAE/D;;;;;;;;;;OAUG;IACI,GAAG,CAAC,KAAK,EAAE,cAAc,CAAC,QAAQ,CAAC,GAAG,OAAO;IAUpD;;;;;;;;;;;;;;;;;OAiBG;IACI,YAAY,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAEpD;;;;;;;;;;;;;;;;OAgBG;IACH,SAAgB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,SAAgB,WAAW,gCAA2C;gBAGrE,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,EAChC,KAAK,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,EAC3B,gBAAgB,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC;IA6GtD;;;;;;;;OAQG;IACM,KAAK,IAAI,IAAI;IAoBtB;;;;;;;;;OASG;IACM,IAAI,IAAI,IAAI;IAsBrB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACM,IAAI,CAAC,KAAK,EAAE,cAAc,CAAC,QAAQ,CAAC,GAAG,IAAI;IAoCpD;;OAEG;IACM,WAAW,IAAI,UAAU,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,aAAa,CAAC,CAAC;IAelE;;;;;;;OAOG;IACM,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,GAAG,YAAY;IAC5E;;;;;;;;;OASG;IACM,SAAS,CACjB,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,KAAK,IAAI,EACzD,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,EACxC,gBAAgB,CAAC,EAAE,MAAM,IAAI,GAC3B,YAAY;IAyCf;;;;;;OAMG;IACM,EAAE,CAAC,KAAK,SAAS,WAAW,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,GAAG,EAC5D,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,CACR,OAAO,EAAE,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,SAAS,GAAG,GAAG,OAAO,GAAG;QAAE,IAAI,EAAE,KAAK,CAAA;KAAE,CAAC,KAC5E,IAAI,GACP,YAAY;IAIf;;;;;OAKG;IACM,oBAAoB,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;IAKnE;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAsC5B;;;;OAIG;IACH,OAAO,IAAI,IAAI;CAGf"}
+{"version":3,"file":"player-actor.d.ts","sourceRoot":"","sources":["../src/player-actor.ts"],"names":[],"mappings":"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"}