@xmachines/play-xstate 1.0.0 → 2.0.0-alpha.1

package/README.md

@@ -2,7 +2,7 @@
 
 # @xmachines/play-xstate
 
-> XState v5 adapter for the XMachines Play Architecture — bind state machines to the actor base with signal-driven reactivity and router integration.
+> XState v6 adapter for the XMachines Play Architecture — bind state machines to the actor base with signal-driven reactivity and router integration.
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Version](https://img.shields.io/badge/version-1.0.0--beta.51-blue)](https://www.npmjs.com/package/@xmachines/play-xstate)
@@ -17,7 +17,7 @@ Part of the [XMachines Play](../../README.md) monorepo.
 pnpm add @xmachines/play-xstate xstate
 ```
 
-`xstate ^5.31.0` is a peer dependency and must be installed alongside this package.
+`xstate ^6.0.0-alpha.19` is a peer dependency and must be installed alongside this package.
 
 ---
 
@@ -25,13 +25,18 @@ pnpm add @xmachines/play-xstate xstate
 
 ```typescript
 import { setup } from "xstate";
-import { definePlayer } from "@xmachines/play-xstate";
+import { definePlayer, emptyEventSchema, playMetaSchema } from "@xmachines/play-xstate";
 
-// 1. Define your XState v5 machine
-const machine = setup({}).createMachine({
+// 1. Define your XState v6 machine
+const machine = setup({
+	schemas: {
+		events: { activate: emptyEventSchema },
+		meta: playMetaSchema, // types meta.route / meta.view on state nodes
+	},
+}).createMachine({
 	initial: "idle",
 	states: {
-		idle: { meta: { route: "/" } },
+		idle: { meta: { route: "/" }, on: { activate: { target: "active" } } },
 		active: { meta: { route: "/active" } },
 	},
 });
@@ -59,16 +64,16 @@ actor.stop();
 
 ### `definePlayer(config)`
 
-Creates a `PlayerFactory` from an XState v5 machine. The factory pattern enables multiple independent actor instances from a single configuration — useful for multi-user scenarios, SSR, or testing.
+Creates a `PlayerFactory` from an XState v6 machine. The factory pattern enables multiple independent actor instances from a single configuration — useful for multi-user scenarios, SSR, or testing.
 
 ```typescript
-import { setup } from "xstate";
+import { setup, types } from "xstate";
 import { definePlayer } from "@xmachines/play-xstate";
 
 const machine = setup({
-	types: {
-		context: {} as { userId: string },
-		input: {} as { userId: string },
+	schemas: {
+		context: types<{ userId: string }>(),
+		input: types<{ userId: string }>(),
 	},
 }).createMachine({
 	context: ({ input }) => ({ userId: input.userId }),
@@ -117,7 +122,7 @@ console.log(restored.currentRoute.get()); // same route as when saved
 
 ### `PlayerActor<TMachine>`
 
-Concrete actor class that wraps an XState v5 actor and exposes TC39 Signal-based reactive signals. Implements both `Routable` and `Viewable` interfaces from `@xmachines/play-actor`.
+Concrete actor class that wraps an XState v6 actor and exposes TC39 Signal-based reactive signals. Implements both `Routable` and `Viewable` interfaces from `@xmachines/play-actor`.
 
 #### Signals
 
@@ -158,7 +163,7 @@ actor.start();
 
 ### Guard utilities
 
-Composable guard helpers that wrap XState's built-in `and()`, `or()`, and `not()` for use in machine `setup({ guards })` definitions.
+Composable guard helpers that combine predicates with AND, OR, and NOT logic. Each helper returns a plain predicate — call it inside a transition function with the transition arguments and return early to block the transition. String guard names are resolved against the named guards declared in `setup({ guards })`.
 
 ```typescript
 import { setup } from "xstate";
@@ -171,20 +176,24 @@ import {
 	contextFieldMatches, // guard: context field equals a value
 } from "@xmachines/play-xstate";
 
+const canAccessAdmin = composeGuards(["isLoggedIn", "hasAdminRole"]);
+const isAuthenticated = negateGuard("isGuest");
+
 const machine = setup({
 	guards: {
 		isLoggedIn: ({ context }) => !!context.userId,
 		hasAdminRole: ({ context }) => context.role === "admin",
+		isGuest: ({ context }) => !context.userId,
 	},
 }).createMachine({
 	on: {
-		accessAdmin: {
-			guard: composeGuards(["isLoggedIn", "hasAdminRole"]),
-			target: "adminPanel",
+		accessAdmin: (args) => {
+			if (!canAccessAdmin(args)) return;
+			return { target: "adminPanel" };
 		},
-		accessDashboard: {
-			guard: negateGuard("isGuest"),
-			target: "dashboard",
+		accessDashboard: (args) => {
+			if (!isAuthenticated(args)) return;
+			return { target: "dashboard" };
 		},
 	},
 	// ...
@@ -197,13 +206,42 @@ const machine = setup({
 
 Helper functions for declarative route configuration in XState machines.
 
+#### `createRoutedMachine(setup)`
+
+The recommended entry point: returns a `createMachine` with the same signature as the setup's own — full contextual typing for the config — that wires routing up at runtime.
+
+```typescript
+import { setup } from "xstate";
+import { createRoutedMachine } from "@xmachines/play-xstate";
+
+const appSetup = setup({/* schemas, guards, ... */});
+
+const machine = createRoutedMachine(appSetup)({
+	id: "app",
+	states: {
+		home: {
+			id: "home",
+			meta: { route: "/home" },
+		},
+		profile: {
+			id: "profile",
+			meta: { route: "/users/:userId" },
+		},
+	},
+});
+```
+
 #### `formatPlayRouteTransitions(machineConfig)`
 
-Crawls machine states with `meta.route` and auto-generates `play.route` event handlers at the root level — eliminating boilerplate routing transitions.
+The underlying transform. Crawls machine states with `meta.route` and wires them to XState v6's native routing: each routed state gets a native `route: {}` config (targetable via the built-in `xstate.route` event and visible to graph tooling), and one root `play.route` forwarder navigates those targets in a single atomic transition — patching `params`/`query` into context — while re-raising `xstate.route` only for states that declare their own `route` config. Unknown targets fall through to user-defined `play.route` fallbacks (e.g. a 404 route); one `play.route` send is one atomic transition, so exit actions see the old `params` and entry actions the new ones.
 
 ```typescript
 import { setup } from "xstate";
-import { formatPlayRouteTransitions } from "@xmachines/play-xstate";
+import {
+	formatPlayRouteTransitions,
+	playMetaSchema,
+	playRouteEventSchema,
+} from "@xmachines/play-xstate";
 
 const config = formatPlayRouteTransitions({
 	id: "app",
@@ -219,17 +257,30 @@ const config = formatPlayRouteTransitions({
 	},
 });
 
-// config now includes auto-generated play.route handlers:
-// on: { "play.route": [ { target: ".home", guard: e => e.to === "#home" }, ... ] }
-const machine = setup({}).createMachine(config);
+// config now carries native route configs plus the play.route forwarder:
+// states: { home: { ..., route: {} }, profile: { ..., route: {} } }
+// on: { "play.route": [forwarder, ...userFallbacks] }
+// The forwarder navigates injected-route targets directly (atomically);
+// xstate.route is raised only for states declaring their own route config.
+const machine = setup({
+	schemas: {
+		events: { "play.route": playRouteEventSchema },
+		meta: playMetaSchema,
+	},
+}).createMachine(config);
 ```
 
+Because the injected `route` configs are static, route transitions keep statically-known targets — `machineToGraph()` sees real edges to every routed state, so reachability queries work.
+
 > **Note:** Every state with `meta.route` must also have an explicit `id` field; omitting it throws `MissingStateIdError` at machine-definition time.
 
 #### Other routing exports
 
 | Export                             | Description                                                               |
 | ---------------------------------- | ------------------------------------------------------------------------- |
+| `playMetaSchema`                   | Shared `schemas.meta` declaration for `meta.route` / `meta.view` metadata |
+| `playRouteEventSchema`             | Shared `schemas.events` entry for the `play.route` event payload          |
+| `emptyEventSchema`                 | Shared `schemas.events` entry for events that carry no payload            |
 | `deriveRoute(meta)`                | Extract the route template string from a state's metadata object          |
 | `isAbsoluteRoute(route)`           | Returns `true` if the route string is an absolute URL path                |
 | `buildRouteUrl(template, context)` | Substitute `:param` placeholders in a route template using context values |
@@ -270,6 +321,8 @@ import {
 	InvalidEventError, // actor.send() called with null/undefined/non-object
 	InvalidRouteMetadataError, // meta.route is neither a string nor { path: string }
 	EmptyGuardArrayError, // composeGuards/composeGuardsOr called with empty array
+	UnresolvableGuardNameError, // string guard name could not be resolved at call time
+	InvalidGuardEntryError, // guard entry was neither a predicate nor a name (e.g. undefined)
 } from "@xmachines/play-xstate/errors";
 ```
 

package/dist/define-player.d.ts

@@ -3,15 +3,15 @@ import type { PlayerConfig, PlayerFactory } from "./types.js";
 /**
  * Create a player factory from an XState machine
  *
- * Factory pattern that accepts an XState v5 machine,
+ * Factory pattern that accepts an XState v6 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.
  *
- * @typeParam TMachine - XState v5 state machine type
+ * @typeParam TMachine - XState v6 state machine type
  *
  * @param config - Player configuration object
- * @param config.machine - XState v5 state machine
+ * @param config.machine - XState v6 state machine
  * @param config.options - Optional lifecycle hooks (onStart, onTransition, etc.)
  *
  * @returns Factory function that creates actor instances with optional input context

package/dist/define-player.js

@@ -2,15 +2,15 @@ import { PlayerActor } from "./player-actor.js";
 /**
  * Create a player factory from an XState machine
  *
- * Factory pattern that accepts an XState v5 machine,
+ * Factory pattern that accepts an XState v6 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.
  *
- * @typeParam TMachine - XState v5 state machine type
+ * @typeParam TMachine - XState v6 state machine type
  *
  * @param config - Player configuration object
- * @param config.machine - XState v5 state machine
+ * @param config.machine - XState v6 state machine
  * @param config.options - Optional lifecycle hooks (onStart, onTransition, etc.)
  *
  * @returns Factory function that creates actor instances with optional input context

package/dist/define-player.typecheck.js

@@ -1,10 +1,13 @@
-import { setup } from "xstate";
+import { setup, types } from "xstate";
+import { emptyEventSchema } from "./schemas.js";
 import { definePlayer } from "./define-player.js";
 const machine = setup({
-    types: {
-        context: {},
-        input: {},
-        events: {},
+    schemas: {
+        context: types(),
+        input: types(),
+        events: {
+            inc: emptyEventSchema,
+        },
     },
 }).createMachine({
     context: ({ input }) => ({ count: input.count }),
@@ -12,11 +15,8 @@ const machine = setup({
     states: {
         active: {
             on: {
-                inc: {
-                    actions: ({ context }) => {
-                        context.count += 1;
-                    },
-                },
+                // XState v6: transitions are functions returning a context patch.
+                inc: ({ context }) => ({ context: { count: context.count + 1 } }),
             },
         },
     },

package/dist/define-player.typecheck.js.map

@@ -1 +1 @@
-{"version":3,"file":"define-player.typecheck.js","sourceRoot":"","sources":["../src/define-player.typecheck.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKlD,MAAM,OAAO,GAAG,KAAK,CAAC;IACrB,KAAK,EAAE;QACN,OAAO,EAAE,EAAuB;QAChC,KAAK,EAAE,EAAuB;QAC9B,MAAM,EAAE,EAAqB;KAC7B;CACD,CAAC,CAAC,aAAa,CAAC;IAChB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IAChD,OAAO,EAAE,QAAQ;IACjB,MAAM,EAAE;QACP,MAAM,EAAE;YACP,EAAE,EAAE;gBACH,GAAG,EAAE;oBACJ,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;wBACxB,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC;oBACpB,CAAC;iBACD;aACD;SACD;KACD;CACD,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,YAAY,CAAC;IACjC,OAAO;IACP,OAAO,EAAE;QACR,YAAY,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE;YAK7C,MAAM,WAAW,GAA4B,KAAK,CAAC;YACnD,MAAM,UAAU,GAA2B,KAAK,CAAC;YACjD,MAAM,UAAU,GAA2B,KAAK,CAAC;YAEjD,KAAK,WAAW,CAAC;YACjB,KAAK,UAAU,CAAC;YAChB,KAAK,UAAU,CAAC;QACjB,CAAC;KACD;CACD,CAAC,CAAC;AAEH,MAAM,KAAK,GAAG,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;AACzC,MAAM,QAAQ,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;AACrC,MAAM,aAAa,GAAG,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;AAI/D,MAAM,YAAY,GAA6B,KAAK,CAAC;AACrD,MAAM,oBAAoB,GAAqC,KAAK,CAAC;AACrE,KAAK,YAAY,CAAC;AAClB,KAAK,oBAAoB,CAAC;AAE1B,gEAAgE;AAChE,YAAY,CAAC,SAAS,CAAC,CAAC;AAExB,oEAAoE;AACpE,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC"}
+{"version":3,"file":"define-player.typecheck.js","sourceRoot":"","sources":["../src/define-player.typecheck.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKlD,MAAM,OAAO,GAAG,KAAK,CAAC;IACrB,OAAO,EAAE;QACR,OAAO,EAAE,KAAK,EAAqB;QACnC,KAAK,EAAE,KAAK,EAAqB;QACjC,MAAM,EAAE;YACP,GAAG,EAAE,gBAAgB;SACrB;KACD;CACD,CAAC,CAAC,aAAa,CAAC;IAChB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IAChD,OAAO,EAAE,QAAQ;IACjB,MAAM,EAAE;QACP,MAAM,EAAE;YACP,EAAE,EAAE;gBACH,kEAAkE;gBAClE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,GAAG,CAAC,EAAE,EAAE,CAAC;aACjE;SACD;KACD;CACD,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,YAAY,CAAC;IACjC,OAAO;IACP,OAAO,EAAE;QACR,YAAY,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE;YAK7C,MAAM,WAAW,GAA4B,KAAK,CAAC;YACnD,MAAM,UAAU,GAA2B,KAAK,CAAC;YACjD,MAAM,UAAU,GAA2B,KAAK,CAAC;YAEjD,KAAK,WAAW,CAAC;YACjB,KAAK,UAAU,CAAC;YAChB,KAAK,UAAU,CAAC;QACjB,CAAC;KACD;CACD,CAAC,CAAC;AAEH,MAAM,KAAK,GAAG,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;AACzC,MAAM,QAAQ,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;AACrC,MAAM,aAAa,GAAG,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;AAI/D,MAAM,YAAY,GAA6B,KAAK,CAAC;AACrD,MAAM,oBAAoB,GAAqC,KAAK,CAAC;AACrE,KAAK,YAAY,CAAC;AAClB,KAAK,oBAAoB,CAAC;AAE1B,gEAAgE;AAChE,YAAY,CAAC,SAAS,CAAC,CAAC;AAExB,oEAAoE;AACpE,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC"}

package/dist/errors.d.ts

@@ -137,6 +137,44 @@ export declare class EmptyGuardArrayError extends PlayError {
     readonly combinator: "and" | "or";
     constructor(combinator: "and" | "or");
 }
+/**
+ * The guard-composition helper a composed guard was built by. Threaded into
+ * guard errors so `PlayError.scope` names the actual origin.
+ */
+export type GuardCombinator = "composeGuards" | "composeGuardsOr" | "negateGuard";
+/**
+ * Thrown when a composed guard cannot resolve a string guard name at call time.
+ *
+ * String names in `composeGuards`/`composeGuardsOr`/`negateGuard` resolve
+ * against `args.guards` — the named guards from `setup({ guards })` that
+ * XState v6 provides to transition functions, `always`, entry/exit actions
+ * (since 6.0.0-alpha.20), and function-form route resolvers. Resolution fails
+ * when the name was never declared or when the composed guard is called
+ * without transition arguments.
+ *
+ * **Error code:** `PLAY_XSTATE_UNRESOLVABLE_GUARD_NAME`
+ */
+export declare class UnresolvableGuardNameError extends PlayError {
+    /** The guard name that could not be resolved. */
+    readonly guardName: string;
+    constructor(guardName: string, origin: GuardCombinator);
+}
+/**
+ * Thrown when a composed guard evaluates an entry that is neither a predicate
+ * function nor a guard name — typically `null`/`undefined` from a typo'd
+ * import or an optional lookup.
+ *
+ * XState v5 failed loudly when evaluating such entries; silently treating them
+ * as never-passing would turn `negateGuard(undefined)` into an always-allow.
+ * Composition stays lazy (no throw at compose time); evaluation throws.
+ *
+ * **Error code:** `PLAY_XSTATE_INVALID_GUARD_ENTRY`
+ */
+export declare class InvalidGuardEntryError extends PlayError {
+    /** `typeof` of the invalid entry (e.g. `"undefined"`, `"object"` for null). */
+    readonly entryType: string;
+    constructor(entryType: string, origin: GuardCombinator);
+}
 /**
  * Thrown by `PlayerActor.send()` when the event argument is not a plain object.
  *

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACpD,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,0FAA0F;IAC1F,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAU3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,wBAAyB,SAAQ,SAAS;;CAWtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IACjD,oFAAoF;IACpF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAW3C;AAED;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;;CASjD;AAED;;;;;GAKG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;IACvD,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,KAAK,EAAE,OAAO,EAAE,MAAM,SAAgB;CAUlD;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IAClD,8EAA8E;IAC9E,QAAQ,CAAC,UAAU,EAAE,KAAK,GAAG,IAAI,CAAC;gBAEtB,UAAU,EAAE,KAAK,GAAG,IAAI;CASpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC/C,8CAA8C;IAC9C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;gBAEb,MAAM,EAAE,OAAO;CAS3B"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACpD,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,0FAA0F;IAC1F,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAU3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,wBAAyB,SAAQ,SAAS;;CAWtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IACjD,oFAAoF;IACpF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAW3C;AAED;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;;CASjD;AAED;;;;;GAKG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;IACvD,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,KAAK,EAAE,OAAO,EAAE,MAAM,SAAgB;CAUlD;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IAClD,8EAA8E;IAC9E,QAAQ,CAAC,UAAU,EAAE,KAAK,GAAG,IAAI,CAAC;gBAEtB,UAAU,EAAE,KAAK,GAAG,IAAI;CASpC;AAED;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,eAAe,GAAG,iBAAiB,GAAG,aAAa,CAAC;AAElF;;;;;;;;;;;GAWG;AACH,qBAAa,0BAA2B,SAAQ,SAAS;IACxD,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe;CAWtD;AAED;;;;;;;;;;GAUG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACpD,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe;CAWtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC/C,8CAA8C;IAC9C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;gBAEb,MAAM,EAAE,OAAO;CAS3B"}

package/dist/errors.js

@@ -165,6 +165,51 @@ export class EmptyGuardArrayError extends PlayError {
         this.combinator = combinator;
     }
 }
+/**
+ * Thrown when a composed guard cannot resolve a string guard name at call time.
+ *
+ * String names in `composeGuards`/`composeGuardsOr`/`negateGuard` resolve
+ * against `args.guards` — the named guards from `setup({ guards })` that
+ * XState v6 provides to transition functions, `always`, entry/exit actions
+ * (since 6.0.0-alpha.20), and function-form route resolvers. Resolution fails
+ * when the name was never declared or when the composed guard is called
+ * without transition arguments.
+ *
+ * **Error code:** `PLAY_XSTATE_UNRESOLVABLE_GUARD_NAME`
+ */
+export class UnresolvableGuardNameError extends PlayError {
+    /** The guard name that could not be resolved. */
+    guardName;
+    constructor(guardName, origin) {
+        super(origin, "PLAY_XSTATE_UNRESOLVABLE_GUARD_NAME", `Guard "${guardName}" is not a function. Either the name was never declared ` +
+            `in setup({ guards }) or the composed guard was called without ` +
+            `transition arguments.`);
+        this.name = "UnresolvableGuardNameError";
+        this.guardName = guardName;
+    }
+}
+/**
+ * Thrown when a composed guard evaluates an entry that is neither a predicate
+ * function nor a guard name — typically `null`/`undefined` from a typo'd
+ * import or an optional lookup.
+ *
+ * XState v5 failed loudly when evaluating such entries; silently treating them
+ * as never-passing would turn `negateGuard(undefined)` into an always-allow.
+ * Composition stays lazy (no throw at compose time); evaluation throws.
+ *
+ * **Error code:** `PLAY_XSTATE_INVALID_GUARD_ENTRY`
+ */
+export class InvalidGuardEntryError extends PlayError {
+    /** `typeof` of the invalid entry (e.g. `"undefined"`, `"object"` for null). */
+    entryType;
+    constructor(entryType, origin) {
+        super(origin, "PLAY_XSTATE_INVALID_GUARD_ENTRY", `Guard entry of type "${entryType}" is neither a predicate function nor a ` +
+            `guard name. Check for typo'd imports or optional lookups that resolved ` +
+            `to null/undefined.`);
+        this.name = "InvalidGuardEntryError";
+        this.entryType = entryType;
+    }
+}
 /**
  * Thrown by `PlayerActor.send()` when the event argument is not a plain object.
  *

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/guards/compose.d.ts

@@ -1,33 +1,50 @@
-import type { GuardPredicate } from "xstate";
 import type { Guard, GuardArray } from "./types.js";
-import type { MachineContext, EventObject, ParameterizedObject } from "xstate";
 /**
- * Narrowest public return type for guard composition helpers.
+ * Composed guard: a plain predicate over transition arguments.
  *
- * `GuardPredicate<MachineContext, EventObject, unknown, ParameterizedObject>` is the
- * widest-compatible concrete XState guard type that does not use `any`.
+ * XState v6 removed guard objects and the `and()`/`or()`/`not()` creators —
+ * guards are now plain functions evaluated inside transition functions. A
+ * composed guard is therefore just another predicate with the same shape as
+ * {@link Guard}, callable anywhere transition args are available.
+ *
+ * String guard names are resolved against `args.guards` (the named guards
+ * declared in `setup({ guards })`, which XState v6 passes to every transition
+ * function). Resolving a name outside a transition function — or a name that
+ * was never declared — throws `UnresolvableGuardNameError` immediately.
+ *
+ * String names work in `on` transitions, `always`, entry/exit actions (since
+ * xstate 6.0.0-alpha.20 populates `guards` there), and function-form route
+ * resolvers.
  *
  * @public
  */
-export type ComposedGuard = GuardPredicate<MachineContext, EventObject, unknown, ParameterizedObject>;
+export type ComposedGuard = (args: unknown) => boolean;
 /**
- * Compose guards with AND logic using XState's and() helper
+ * Compose guards with AND logic.
  *
  * Combines multiple guard predicates using AND semantics—all guards must pass for
- * the composition to succeed. Uses XState's built-in `and()` helper to ensure proper
- * type inference and machine serialization.
+ * the composition to succeed. Evaluation is short-circuiting, left to right.
  *
  * **Architectural Context:** Supports **Actor Authority (INV-01)** by enabling
  * declarative guard composition in state machine transitions. Guards enforce business
  * logic rules that determine whether navigation or actions are valid.
  *
- * @typeParam TContext - State machine context type
+ * **XState v6:** the composed value is a plain predicate. Call it inside a
+ * transition function and return early to block the transition:
+ *
+ * @typeParam TContext - State machine context type (defaults to `any` so the
+ *   documented inline-predicate examples compile without annotations)
+ * @typeParam TEvent - Event type
+ *
+ * @typeParam TContext - State machine context type (defaults to `any` so the
+ *   documented inline-predicate examples compile without annotations)
  * @typeParam TEvent - Event type
  *
- * @param guards - Array of guard predicates or guard names (string references)
- * @returns XState and() guard composition
+ * @param guards - Array of guard predicates or guard names (string references
+ *   resolved against `args.guards` from `setup({ guards })`)
+ * @returns Predicate returning `true` only when every guard passes
  *
- * @throws {Error} If guards array is empty
+ * @throws {EmptyGuardArrayError} If guards array is empty
  *
  * @example
  * AND composition with named guards
@@ -35,6 +52,8 @@ export type ComposedGuard = GuardPredicate<MachineContext, EventObject, unknown,
  * import { setup } from "xstate";
  * import { composeGuards } from "@xmachines/play-xstate";
  *
+ * const canAccessAdmin = composeGuards(['isLoggedIn', 'hasPermission']);
+ *
  * const machine = setup({
  *   guards: {
  *     isLoggedIn: ({ context }) => !!context.userId,
@@ -42,10 +61,9 @@ export type ComposedGuard = GuardPredicate<MachineContext, EventObject, unknown,
  *   }
  * }).createMachine({
  *   on: {
- *     accessAdmin: {
- *       // Both guards must pass
- *       guard: composeGuards(['isLoggedIn', 'hasPermission']),
- *       target: 'adminPanel'
+ *     accessAdmin: (args) => {
+ *       if (!canAccessAdmin(args)) return;
+ *       return { target: 'adminPanel' };
  *     }
  *   }
  * });
@@ -56,10 +74,10 @@ export type ComposedGuard = GuardPredicate<MachineContext, EventObject, unknown,
  * ```typescript
  * import { composeGuards } from "@xmachines/play-xstate";
  *
- * guard: composeGuards([
+ * const isEligible = composeGuards([
  *   ({ context }) => context.age >= 18,
  *   ({ context }) => context.verified
- * ])
+ * ]);
  * ```
  *
  * @see {@link composeGuardsOr} for OR composition
@@ -67,19 +85,16 @@ export type ComposedGuard = GuardPredicate<MachineContext, EventObject, unknown,
  */
 export declare const composeGuards: <TContext = any, TEvent = any>(guards: GuardArray<TContext, TEvent>) => ComposedGuard;
 /**
- * Compose guards with OR logic using XState's or() helper
+ * Compose guards with OR logic.
  *
  * Combines multiple guard predicates using OR semantics—at least one guard must pass
- * for the composition to succeed. Uses XState's built-in `or()` helper for proper
- * type inference.
- *
- * @typeParam TContext - State machine context type
- * @typeParam TEvent - Event type
+ * for the composition to succeed. Evaluation is short-circuiting, left to right.
  *
- * @param guards - Array of guard predicates or guard names
- * @returns XState or() guard composition
+ * @param guards - Array of guard predicates or guard names (string references
+ *   resolved against `args.guards` from `setup({ guards })`)
+ * @returns Predicate returning `true` when any guard passes
  *
- * @throws {Error} If guards array is empty
+ * @throws {EmptyGuardArrayError} If guards array is empty
  *
  * @example
  * OR composition with named guards
@@ -87,6 +102,8 @@ export declare const composeGuards: <TContext = any, TEvent = any>(guards: Guard
  * import { setup } from "xstate";
  * import { composeGuardsOr } from "@xmachines/play-xstate";
  *
+ * const canDelete = composeGuardsOr(['isOwner', 'isAdmin']);
+ *
  * const machine = setup({
  *   guards: {
  *     isOwner: ({ context }) => context.role === 'owner',
@@ -94,10 +111,9 @@ export declare const composeGuards: <TContext = any, TEvent = any>(guards: Guard
  *   }
  * }).createMachine({
  *   on: {
- *     deleteResource: {
- *       // Either guard can pass
- *       guard: composeGuardsOr(['isOwner', 'isAdmin']),
- *       actions: 'delete'
+ *     deleteResource: (args, enq) => {
+ *       if (!canDelete(args)) return;
+ *       enq(() => deleteIt());
  *     }
  *   }
  * });
@@ -108,16 +124,17 @@ export declare const composeGuards: <TContext = any, TEvent = any>(guards: Guard
  */
 export declare const composeGuardsOr: <TContext = any, TEvent = any>(guards: GuardArray<TContext, TEvent>) => ComposedGuard;
 /**
- * Negate a guard using XState's not() helper
+ * Negate a guard.
  *
  * Inverts a guard's result—if the guard passes, NOT fails; if guard fails, NOT passes.
- * Uses XState's built-in `not()` helper for proper serialization.
  *
- * @typeParam TContext - State machine context type
+ * @typeParam TContext - State machine context type (defaults to `any` so
+ *   inline predicates compile without annotations)
  * @typeParam TEvent - Event type
  *
- * @param guard - Guard predicate or guard name to negate
- * @returns XState not() guard negation
+ * @param guard - Guard predicate or guard name (resolved against `args.guards`
+ *   from `setup({ guards })`) to negate
+ * @returns Predicate returning the inverted guard result
  *
  * @example
  * NOT composition with named guard
@@ -125,16 +142,17 @@ export declare const composeGuardsOr: <TContext = any, TEvent = any>(guards: Gua
  * import { setup } from "xstate";
  * import { negateGuard } from "@xmachines/play-xstate";
  *
+ * const isAuthenticated = negateGuard('isGuest');
+ *
  * const machine = setup({
  *   guards: {
  *     isGuest: ({ context }) => !context.userId
  *   }
  * }).createMachine({
  *   on: {
- *     accessDashboard: {
- *       // Allow if NOT a guest (i.e., authenticated)
- *       guard: negateGuard('isGuest'),
- *       target: 'dashboard'
+ *     accessDashboard: (args) => {
+ *       if (!isAuthenticated(args)) return;
+ *       return { target: 'dashboard' };
  *     }
  *   }
  * });

package/dist/guards/compose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../src/guards/compose.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAG/E;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,cAAc,CACzC,cAAc,EACd,WAAW,EACX,OAAO,EACP,mBAAmB,CACnB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,eAAO,MAAM,aAAa,GAAI,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,EACzD,QAAQ,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,KAClC,aAqBF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,eAAO,MAAM,eAAe,GAAI,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,EAC3D,QAAQ,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,KAClC,aAmBF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,eAAO,MAAM,WAAW,GAAI,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,EACvD,OAAO,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,MAAM,KACrC,aAOF,CAAC"}
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../src/guards/compose.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAQpD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;AAqCvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAEH,eAAO,MAAM,aAAa,GAAI,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,EACzD,QAAQ,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,KAClC,aAgBF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,eAAO,MAAM,eAAe,GAAI,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,EAC3D,QAAQ,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,KAClC,aAgBF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,eAAO,MAAM,WAAW,GAAI,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,EACvD,OAAO,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,MAAM,KACrC,aAGF,CAAC"}