@xmachines/play-xstate 1.0.0-beta.3 → 1.0.0-beta.31

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mikael Karon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -6,9 +6,9 @@ Transform declarative state machines into live actors with TC39 Signals and para
 
 ## Overview
 
-`@xmachines/play-xstate` provides `definePlayer()`, the primary API for binding XState v5 state machines to the Play Architecture actor base. It enables business logic to control routing and state through guard-enforced transitions with catalog binding, signal lifecycle management, and XState DevTools compatibility.
+`@xmachines/play-xstate` provides `definePlayer()`, the primary API for binding XState v5 state machines to the Play Architecture actor base. It enables business logic to control routing and state through guard-enforced transitions, signal lifecycle management, and XState DevTools compatibility.
 
-Per [RFC Play v1](https://gitlab.com/xmachin-es/rfc/-/blob/main/src/play-v1.md), this package implements:
+Per [Play RFC](../docs/rfc/play.md), this package implements:
 
 - **Actor Authority (INV-01):** State machine guards decide navigation validity
 - **Strict Separation (INV-02):** Zero React/framework imports in business logic
@@ -19,89 +19,97 @@ Per [RFC Play v1](https://gitlab.com/xmachin-es/rfc/-/blob/main/src/play-v1.md),
 ## Installation
 
 ```bash
-npm install xstate@^5.0.0 zod@^3.23.0
+npm install xstate@^5.0.0
 npm install @xmachines/play-xstate
 ```
 
-## Current Exports
-
-- `definePlayer`, `PlayerActor`
-- player types: `PlayerConfig`, `PlayerOptions`, `PlayerFactory`
-- guard utilities: `composeGuards`, `composeGuardsOr`, `negateGuard`, `hasContext`, `eventMatches`, `stateMatches`
-- routing utilities: `deriveRoute`, `isAbsoluteRoute`, `buildRouteUrl`, `formatPlayRouteTransitions`
-- catalog utilities: `validateComponentBinding`, `validateViewProps`, `mergeViewProps`
-
 **Peer dependencies:**
 
-- `xstate` ^5.0.0 - State machine runtime
-- `zod` ^3.23.0 - Schema validation for component props
+- `xstate` ^5.0.0 — State machine runtime
 
 ## Quick Start
 
 ```typescript
-import { setup } from "xstate";
-import { z } from "zod";
-import { definePlayer } from "@xmachines/play-xstate";
-import { defineCatalog } from "@xmachines/play-catalog";
+import { setup, assign } from "xstate";
+import { definePlayer, formatPlayRouteTransitions } from "@xmachines/play-xstate";
 
-// 1. Define XState machine with meta.route
+// 1. Define XState machine with meta.route and view spec
 const machine = setup({
 	types: {
-		context: {} as { userId: string },
-		events: {} as { type: "play.route"; to: string } | { type: "auth.login"; userId: string },
-	},
-	guards: {
-		isLoggedIn: ({ context }) => !!context.userId,
+		context: {} as {
+			isAuthenticated: boolean;
+			params: Record<string, string>;
+			query: Record<string, string>;
+		},
+		events: {} as
+			| { type: "play.route"; to: string; params?: Record<string, string> }
+			| { type: "auth.login" }
+			| { type: "auth.logout" },
 	},
-}).createMachine({
-	id: "app",
-	initial: "login",
-	context: { userId: "" },
-	states: {
-		login: {
-			id: "login",
-			meta: {
-				route: "/login",
-				view: { component: "LoginForm" },
+}).createMachine(
+	formatPlayRouteTransitions({
+		id: "app",
+		initial: "login",
+		context: { isAuthenticated: false, params: {}, query: {} },
+		states: {
+			login: {
+				id: "login",
+				meta: {
+					route: "/login",
+					view: {
+						component: "Login",
+						spec: {
+							root: "root",
+							elements: {
+								root: { type: "Login", props: { title: "Sign In" }, children: [] },
+							},
+						},
+					},
+				},
 			},
-			on: {
-				"auth.login": {
-					guard: "isLoggedIn",
-					target: "dashboard",
+			dashboard: {
+				id: "dashboard",
+				meta: {
+					route: "/dashboard",
+					view: {
+						component: "Dashboard",
+						spec: {
+							root: "root",
+							elements: {
+								root: { type: "Dashboard", props: {}, children: [] },
+							},
+						},
+					},
 				},
+				always: [{ target: "login", guard: ({ context }) => !context.isAuthenticated }],
 			},
 		},
-		dashboard: {
-			id: "dashboard",
-			meta: {
-				route: "/dashboard",
-				view: { component: "Dashboard", props: { userId: "" } },
+		on: {
+			"auth.login": {
+				target: ".dashboard",
+				guard: ({ context }) => !context.isAuthenticated,
+				actions: assign({ isAuthenticated: true }),
+			},
+			"auth.logout": {
+				target: ".login",
+				actions: assign({ isAuthenticated: false }),
 			},
 		},
-	},
-});
-
-// 2. Define catalog with Zod schemas
-const catalog = defineCatalog({
-	LoginForm: z.object({ error: z.string().optional() }),
-	Dashboard: z.object({ userId: z.string() }),
-});
+	}),
+);
 
-// 3. Create player factory
-const createPlayer = definePlayer({ machine, catalog });
+// 2. Create player factory
+const createPlayer = definePlayer({ machine });
 
-// 4. Create and start actor
-const actor = createPlayer({ userId: "" });
+// 3. Create and start actor
+const actor = createPlayer();
 actor.start();
 
-// 5. Send events (play.route with parameters)
-actor.send({ type: "play.route", to: "/login" });
-
-// 6. Observe signals
+// 4. Observe signals
 console.log(actor.currentRoute.get()); // "/login"
-console.log(actor.currentView.get()); // { component: "LoginForm", props: {...} }
+console.log(actor.currentView.get()); // { component: "Login", spec: {...} }
 
-// 7. Cleanup
+// 5. Cleanup
 actor.dispose();
 ```
 
@@ -109,12 +117,11 @@ actor.dispose();
 
 ### definePlayer()
 
-Create a player factory from XState machine and catalog:
+Create a player factory from an XState machine:
 
 ```typescript
-const createPlayer = definePlayer<TMachine, TCatalog>({
+const createPlayer = definePlayer<TMachine>({
 	machine: AnyStateMachine,
-	catalog?: Catalog,
 	options?: PlayerOptions,
 }): PlayerFactory;
 ```
@@ -122,17 +129,15 @@ const createPlayer = definePlayer<TMachine, TCatalog>({
 **Config:**
 
 - `machine` (required) - XState v5 state machine
-- `catalog` (optional) - UI component catalog with Zod schemas
 - `options` (optional) - Lifecycle hooks
 
-**Returns:** Factory function `(input?) => PlayerActor`
+**Returns:** Factory function `(input?, { snapshot }?) => PlayerActor`
 
 **Example:**
 
 ```typescript
 const createPlayer = definePlayer({
 	machine: authMachine,
-	catalog: authCatalog,
 	options: {
 		onStart: (actor) => console.log("Started:", actor.id),
 		onTransition: (actor, prev, next) => {
@@ -146,26 +151,62 @@ const actor2 = createPlayer({ userId: "user2" });
 // Multiple independent actor instances
 ```
 
+**Restoring from a snapshot:**
+
+```typescript
+const createPlayer = definePlayer({ machine });
+
+const actor = createPlayer();
+actor.start();
+
+// ...persist the actor snapshot however your app stores it
+const snapshot = actor.getSnapshot();
+actor.stop();
+
+const restoredActor = createPlayer(undefined, { snapshot });
+restoredActor.start();
+```
+
+`restoredActor.initialRoute` still reflects the machine's default initial route, not the
+restored snapshot route. Router bridges rely on that invariant to distinguish a deep-link
+from a restored session during `connect()`.
+
 ### PlayerActor
 
 Concrete actor implementing Play signal protocol:
 
 **Signal Properties:**
 
-- `state: Signal.State<Snapshot>` - Reactive snapshot of current state
-- `currentRoute: Signal.Computed<string | null>` - Derived navigation path
-- `currentView: Signal.Computed<ViewStructure | null>` - Derived UI structure
+- `state: Signal.State<AnyMachineSnapshot>` — Reactive snapshot of current state
+- `currentRoute: Signal.Computed<string | null>` — Derived URL from the current state's `meta.route` and `context.params`. Returns `null` when no route metadata is present or a required route parameter is missing from context.
+- `currentView: Signal.State<ViewMetadata | null>` — Current view spec (updated on every state transition). The spec is automatically enriched with `context.params` (URL params) and any `contextProps`-allowlisted context fields before being emitted (see [Prop Enrichment from Routing and Context](#prop-enrichment-from-routing-and-context)).
 
-**Actor Properties:**
+**Lifecycle ordering:**
 
-- `catalog: Catalog` - Component catalog
+- `state` and `currentRoute` update synchronously from the active XState snapshot.
+- `currentView` is then validated and cached from that same snapshot.
+- `onStateChange` runs after those signals are current.
+- `onTransition` runs after `send()` completes, with both previous and next snapshots.
+- `onStart` runs after the initial active snapshot has been published.
 
 **Methods:**
 
-- `start()` - Start the actor (must call after creation)
-- `stop()` - Stop the actor
-- `send(event: PlayEvent)` - Send event to actor
-- `dispose()` - Convenience cleanup (calls stop())
+- `start()` — Start the actor (must call after creation)
+- `stop()` — Stop the actor
+- `send(event)` — Send event to actor. Typed as `EventFromLogic<TMachine>` when `TMachine` is specified.
+- `can(event)` — Returns `true` if the current state can accept the given event. Typed as `EventFromLogic<TMachine>` — passing an unknown event type is a compile error. Reads from the `state` signal (no allocation). Use instead of `getSnapshot().can()`.
+- `dispose()` — Convenience cleanup (calls `stop()`)
+- `getSnapshot()` — Get current XState snapshot, typed as `SnapshotFrom<TMachine>`
+
+**Routing failure behavior:**
+
+- `currentRoute` returns `null` instead of throwing when a required route parameter (e.g. `:username`) is absent from context. This handles transient states during navigation without crashing signal watchers.
+- Errors from `buildRouteUrl()` are typed as `MissingRouteParamError` (importable from `@xmachines/play-xstate/errors`).
+
+**View derivation and route-param enrichment:**
+
+- `currentView` emits a fresh `ViewMetadata` object on every transition so TC39 Signal equality checks always detect changes (including re-entries to the same state with different params).
+- `context.params` and `contextProps`-allowlisted context fields are merged into spec element props — see [Prop Enrichment from Routing and Context](#prop-enrichment-from-routing-and-context).
 
 **Example:**
 
@@ -193,7 +234,7 @@ import {
 	negateGuard,
 	hasContext,
 	eventMatches,
-	stateMatches,
+	contextFieldMatches,
 } from "@xmachines/play-xstate";
 
 const machine = setup({
@@ -226,13 +267,11 @@ const machine = setup({
 
 - `hasContext(path: string)` - Check if context property is truthy
 - `eventMatches(type: string)` - Check event type
-- `stateMatches(value: string)` - Check state value
+- `contextFieldMatches(fieldPath: string, expectedValue: unknown)` - Check context field with strict structural equality
 - `composeGuards(guards: Array)` - AND composition
 - `composeGuardsOr(guards: Array)` - OR composition
 - `negateGuard(guard)` - NOT composition
 
-**Complete API:** See [API Documentation](../../docs/api/@xmachines/play-xstate)
-
 ## Examples
 
 ### Guard Placement Philosophy
@@ -242,7 +281,6 @@ const machine = setup({
 ```typescript
 import { setup } from "xstate";
 import { definePlayer, formatPlayRouteTransitions } from "@xmachines/play-xstate";
-import { defineCatalog } from "@xmachines/play-catalog";
 
 // Pattern 1: RECOMMENDED - Use formatPlayRouteTransitions utility
 const machineConfig = {
@@ -275,17 +313,18 @@ const machineConfig = {
 // formatPlayRouteTransitions handles routing infrastructure
 const machine = setup({
 	types: {
-		events: {} as { type: "play.route"; to: string } | { type: "auth.login" },
+		context: {} as {
+			isAuthenticated: boolean;
+			params: Record<string, string>;
+			query: Record<string, string>;
+		},
+		events: {} as
+			| { type: "play.route"; to: string; params?: Record<string, string> }
+			| { type: "auth.login" },
 	},
 }).createMachine(formatPlayRouteTransitions(machineConfig));
 
-const catalog = defineCatalog({
-	Home,
-	Dashboard,
-	Login,
-});
-
-const createPlayer = definePlayer({ machine, catalog });
+const createPlayer = definePlayer({ machine });
 const actor = createPlayer();
 actor.start();
 
@@ -320,7 +359,6 @@ on: {
 ```typescript
 const createPlayer = definePlayer({
 	machine,
-	catalog,
 	options: {
 		onStart: (actor) => {
 			console.log("Actor started:", actor.id);
@@ -355,7 +393,7 @@ import { definePlayer } from "@xmachines/play-xstate";
 
 const { inspect } = createBrowserInspector();
 
-const createPlayer = definePlayer({ machine, catalog });
+const createPlayer = definePlayer({ machine });
 const actor = createPlayer();
 actor.start();
 
@@ -400,30 +438,155 @@ meta: {
 
 ### View Metadata
 
+View metadata drives the `currentView` signal. The `spec` field follows the `@json-render/core` `Spec` shape:
+
 ```typescript
 meta: {
 	view: {
-		component: "Dashboard", // Must exist in catalog
-		props: { userId: "user123" }, // Validated against Zod schema
-		title: "Dashboard", // Additional metadata
+		component: "Dashboard",  // Component name — must exist in the registry
+		spec: {
+			root: "root",         // Root element key
+			state: { tab: "general" },  // Optional: initial UI state (form values etc.)
+			elements: {
+				root: {
+					type: "Dashboard",
+					props: { title: "Dashboard" },  // Static props (non-undefined = cannot be overridden by route params)
+					children: [],
+				},
+			},
+		},
 	},
 }
+```
 
-// Dynamic props from context
-meta: {
-	view: {
-		component: "Dashboard",
-		props: (context) => ({
-			userId: context.userId,
-			notifications: context.unreadCount,
-		}),
-	},
+**Prop slots:** Declare a prop as `undefined` to allow URL params or context fields to fill
+it in automatically (see [Prop Enrichment from Routing and Context](#prop-enrichment-from-routing-and-context)):
+
+```typescript
+// Route: /settings/:section?   Context: { username: "alice" }
+spec: {
+  root: "root",
+  contextProps: ["username"],    // expose context.username to components
+  elements: {
+    root: { type: "Settings", props: { section: undefined, username: undefined, theme: "dark" }, children: [] },
+  },
+}
+// After play.route to /settings/profile:
+// Component receives: { section: "profile", username: "alice", theme: "dark" }
+//   section  → from context.params (URL)
+//   username → from contextProps (context)
+//   theme    → from spec (explicit value, untouched)
+```
+
+## Error Handling
+
+All runtime errors thrown by this package extend `PlayError` from `@xmachines/play` and
+are exported from the `./errors` subpath:
+
+```typescript
+import { MissingRouteParamError, InvalidEventError } from "@xmachines/play-xstate/errors";
+```
+
+| Class                    | Code                       | When thrown                                              |
+| ------------------------ | -------------------------- | -------------------------------------------------------- |
+| `MissingRouteParamError` | `PLAY_ROUTE_PARAM_MISSING` | Required `:param` has no matching value in actor context |
+| `InvalidEventError`      | `PLAY_INVALID_EVENT`       | `actor.send()` called with a non-object value            |
+
+`MissingRouteParamError` carries `param` and `template` fields for programmatic access.
+`InvalidEventError` carries a `detail` property with the offending value.
+
+> **Note:** `currentRoute` does NOT throw `MissingRouteParamError` — it catches the error internally and returns `null` instead, keeping signal watchers stable during transient states.
+
+```typescript
+import { MissingRouteParamError, InvalidEventError } from "@xmachines/play-xstate/errors";
+
+try {
+	actor.send(null as any);
+} catch (err) {
+	if (err instanceof InvalidEventError) {
+		console.error("Non-object event passed to actor.send():", err.detail);
+	}
+}
+
+try {
+	const route = actor.currentRoute.get();
+} catch (err) {
+	if (err instanceof MissingRouteParamError) {
+		console.error(`Missing "${err.param}" for template "${err.template}"`);
+	}
+}
+```
+
+## Prop Enrichment from Routing and Context
+
+When `currentView` is derived, each spec element's `props` are enriched from two sources.
+Both use the **opt-in slot** pattern: declare a prop as `undefined` in the spec to allow
+it to be filled in automatically.
+
+### Merge priority (highest → lowest)
+
+| Source                             | When it applies                  | Wins over                 |
+| ---------------------------------- | -------------------------------- | ------------------------- |
+| Explicit non-`undefined` spec prop | Always                           | Everything                |
+| URL route param (`context.params`) | State has a `:param` URL segment | `contextProps` values     |
+| `contextProps` field               | Listed in `spec.contextProps`    | Nothing (lowest priority) |
+
+### URL route parameters
+
+URL path parameters (`:section?`, `:username`) are filled automatically — declare the prop
+as `undefined` to opt in:
+
+```typescript
+// Route: /settings/:section?
+elements: {
+  root: { type: "Settings", props: { section: undefined, user: "alice" }, children: [] }
 }
+
+// play.route event: { to: "#settings", params: { section: "profile" } }
+// Component receives: { section: "profile", user: "alice" }
+```
+
+Extra params not declared in the spec are also passed through:
+
+```typescript
+// params: { section: "profile", tab: "security" }
+// Component receives: { section: "profile", tab: "security", user: "alice" }
+```
+
+### Context fields via `contextProps`
+
+For states where context data (e.g. `context.username`) should reach a component but there
+is no corresponding URL param, declare `contextProps` in the spec as an explicit allowlist:
+
+```typescript
+// Dashboard at /dashboard — no :username URL param, but we want to show context.username
+spec: {
+  root: "root",
+  contextProps: ["username"],          // ← explicit allowlist
+  elements: {
+    root: { type: "Dashboard", props: { username: undefined }, children: [] },
+  },
+}
+
+// After auth.login sets context.username = "alice":
+// Component receives: { username: "alice" }
+```
+
+**Nothing leaks from context without an explicit `contextProps` declaration.**
+Only the named fields are ever exposed. `null` and `undefined` context values are excluded.
+
+If both a route param and a `contextProps` field share the same key, the route param wins:
+
+```typescript
+// context.username = "alice" (logged-in user)
+// play.route to /profile/demo → context.params.username = "demo"
+// contextProps: ["username"], props: { username: undefined }
+// Component receives: { username: "demo" }  ← route param wins
 ```
 
 ## Architecture
 
-This package implements RFC Play v1 requirements:
+This package implements Play RFC requirements:
 
 **Architectural Invariants:**
 
@@ -445,10 +608,16 @@ This package implements RFC Play v1 requirements:
 
 - **[@xmachines/play-actor](../play-actor)** - AbstractActor base class
 - **[@xmachines/play-signals](../play-signals)** - TC39 Signals polyfill
-- **[@xmachines/play-catalog](../play-catalog)** - UI schema validation
-- **[@xmachines/play-router](../play-router)** - Route extraction
+- **[@xmachines/play-router](../play-router)** - Route extraction utilities
+- **[@xmachines/play-react](../play-react)** - React renderer
+- **[@xmachines/play-vue](../play-vue)** - Vue renderer
+- **[@xmachines/play-solid](../play-solid)** - SolidJS renderer
+- **[@xmachines/play-dom](../play-dom)** - Vanilla DOM renderer
 - **[@xmachines/play](../play)** - Protocol types (PlayEvent)
 
 ## License
 
-MIT
+Copyright (c) 2016 [Mikael Karon](mailto:mikael@karon.se). All rights reserved.
+
+This work is licensed under the terms of the MIT license.  
+For a copy, see <https://opensource.org/licenses/MIT>.

package/dist/define-player.d.ts

@@ -1,29 +1,23 @@
-import type { AnyStateMachine } from "xstate";
+import { type AnyStateMachine } from "xstate";
 import type { PlayerConfig, PlayerFactory } from "./types.js";
 /**
- * Create a player factory from XState machine and catalog
+ * Create a player factory from an XState machine
  *
- * Factory pattern that accepts an XState v5 machine and optional UI catalog,
+ * Factory pattern that accepts an XState v5 machine,
  * returning a function that creates {@link PlayerActor} instances. This enables
  * creating multiple actor instances from a single configuration, useful for
  * testing, multi-instance scenarios, or server-side rendering.
  *
- * **Architectural Context:** Implements **Strict Separation (INV-02)** by accepting
- * the machine definition (pure business logic) separately from the catalog (UI vocabulary).
- * The machine references component names in `meta.view` without importing React/framework code.
- *
  * @typeParam TMachine - XState v5 state machine type
- * @typeParam TCatalog - Optional UI component catalog type
  *
  * @param config - Player configuration object
  * @param config.machine - XState v5 state machine
- * @param config.catalog - Optional UI component catalog (allows machines without UI)
  * @param config.options - Optional lifecycle hooks (onStart, onTransition, etc.)
  *
  * @returns Factory function that creates actor instances with optional input context
  *
  * @example
- * Basic player factory without catalog
+ * Basic player factory
  * ```typescript
  * import { setup } from "xstate";
  * import { definePlayer } from "@xmachines/play-xstate";
@@ -42,53 +36,9 @@ import type { PlayerConfig, PlayerFactory } from "./types.js";
  * ```
  *
  * @example
- * Player factory with catalog and parameter-aware routing
- * ```typescript
- * import { setup } from "xstate";
- * import { defineCatalog } from "@xmachines/play-catalog";
- * import { definePlayer } from "@xmachines/play-xstate";
- * import { z } from "zod";
- *
- * const catalog = defineCatalog({
- *   HomePage: z.object({}),
- *   ProfilePage: z.object({ userId: z.string() })
- * });
- *
- * const machine = setup({
- *   types: {
- *     context: {} as { userId: string },
- *     events: {} as { type: 'play.route'; to: string; params?: Record<string, string> }
- *   }
- * }).createMachine({
- *   initial: 'home',
- *   context: { userId: '' },
- *   states: {
- *     home: {
- *       route: {},
- *       meta: {
- *         route: '/',
- *         view: { component: 'HomePage' }
- *       }
- *     },
- *     profile: {
- *       route: {},
- *       meta: {
- *         route: '/profile/:userId',
- *         view: { component: 'ProfilePage', userId: (ctx) => ctx.userId }
- *       }
- *     }
- *   }
- * });
- *
- * const createPlayer = definePlayer({ machine, catalog });
- * const actor = createPlayer({ userId: 'user123' });
- * actor.start();
- * ```
- *
- * @example
  * Multiple actor instances from single factory
  * ```typescript
- * const createPlayer = definePlayer({ machine, catalog });
+ * const createPlayer = definePlayer({ machine });
  *
  * // Create actors for different users
  * const alice = createPlayer({ userId: 'alice' });
@@ -101,10 +51,10 @@ import type { PlayerConfig, PlayerFactory } from "./types.js";
  * console.log(alice.state.get() !== bob.state.get());
  * ```
  *
- * @see {@link https://gitlab.com/xmachin-es/rfc/-/blob/main/src/play-v1.md | RFC Play v1}
+ * @see [Play RFC](../../docs/rfc/play.md)
  * @see {@link PlayerActor} for the concrete actor implementation
  * @see {@link PlayerConfig} for configuration options
  * @see {@link PlayerFactory} for factory function signature
  */
-export declare const definePlayer: <TMachine extends AnyStateMachine, TCatalog = Record<string, unknown>>(config: PlayerConfig<TMachine, TCatalog>) => PlayerFactory<TMachine>;
+export declare const definePlayer: <TMachine extends AnyStateMachine>(config: PlayerConfig<TMachine>) => PlayerFactory<TMachine>;
 //# sourceMappingURL=define-player.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"define-player.d.ts","sourceRoot":"","sources":["../src/define-player.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAa,MAAM,QAAQ,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAG9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGG;AACH,eAAO,MAAM,YAAY,GAAI,QAAQ,SAAS,eAAe,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChG,QAAQ,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,KACtC,aAAa,CAAC,QAAQ,CAQxB,CAAC"}
+{"version":3,"file":"define-player.d.ts","sourceRoot":"","sources":["../src/define-player.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,eAAe,EAA2C,MAAM,QAAQ,CAAC;AACpG,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAA8B,MAAM,YAAY,CAAC;AAG1F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,eAAO,MAAM,YAAY,GAAI,QAAQ,SAAS,eAAe,EAC5D,QAAQ,YAAY,CAAC,QAAQ,CAAC,KAC5B,aAAa,CAAC,QAAQ,CAsBxB,CAAC"}