@xmachines/play-xstate 1.0.0-beta.2 → 1.0.0-beta.21

package/dist/define-player.js

@@ -1,28 +1,22 @@
 import { PlayerActor } from "./player-actor.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";
@@ -41,53 +35,9 @@ import { PlayerActor } from "./player-actor.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' });
@@ -100,17 +50,15 @@ import { PlayerActor } from "./player-actor.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 const definePlayer = (config) => {
-    const { machine, catalog, options } = config;
-    // Return factory function
-    // Per CONTEXT.md: "Factory function for creating multiple actor instances"
-    return (input) => {
-        return new PlayerActor(machine, catalog || {}, options || {}, input);
+    const { machine, options } = config;
+    return (input, restore) => {
+        return new PlayerActor(machine, options ?? {}, input, restore?.snapshot);
     };
 };
 //# sourceMappingURL=define-player.js.map

package/dist/define-player.js.map

@@ -1 +1 @@
-{"version":3,"file":"define-player.js","sourceRoot":"","sources":["../src/define-player.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAC3B,MAAwC,EACxB,EAAE;IAClB,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;IAE7C,0BAA0B;IAC1B,2EAA2E;IAC3E,OAAO,CAAC,KAAW,EAAO,EAAE;QAC3B,OAAO,IAAI,WAAW,CAAC,OAAO,EAAE,OAAO,IAAI,EAAE,EAAE,OAAO,IAAI,EAAE,EAAE,KAAK,CAAC,CAAC;IACtE,CAAC,CAAC;AACH,CAAC,CAAC"}
+{"version":3,"file":"define-player.js","sourceRoot":"","sources":["../src/define-player.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAC3B,MAA8B,EACJ,EAAE;IAC5B,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;IAEpC,OAAO,CAAC,KAA2B,EAAE,OAA8C,EAAE,EAAE;QACtF,OAAO,IAAI,WAAW,CAAC,OAAO,EAAE,OAAO,IAAI,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC1E,CAAC,CAAC;AACH,CAAC,CAAC"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=define-player.typecheck.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"define-player.typecheck.d.ts","sourceRoot":"","sources":["../src/define-player.typecheck.ts"],"names":[],"mappings":""}

package/dist/define-player.typecheck.js

@@ -0,0 +1,48 @@
+import { setup } from "xstate";
+import { definePlayer } from "./define-player.js";
+const machine = setup({
+    types: {
+        context: {},
+        input: {},
+        events: {},
+    },
+}).createMachine({
+    context: ({ input }) => ({ count: input.count }),
+    initial: "active",
+    states: {
+        active: {
+            on: {
+                inc: {
+                    actions: ({ context }) => {
+                        context.count += 1;
+                    },
+                },
+            },
+        },
+    },
+});
+const createPlayer = definePlayer({
+    machine,
+    options: {
+        onTransition: (actor, prevState, nextState) => {
+            const actorNotAny = false;
+            const prevNotAny = false;
+            const nextNotAny = false;
+            void actorNotAny;
+            void prevNotAny;
+            void nextNotAny;
+        },
+    },
+});
+const actor = createPlayer({ count: 1 });
+const snapshot = actor.getSnapshot();
+const restoredActor = createPlayer({ count: 1 }, { snapshot });
+const returnNotAny = false;
+const restoredReturnNotAny = false;
+void returnNotAny;
+void restoredReturnNotAny;
+// @ts-expect-error factory input must match machine input shape
+createPlayer("invalid");
+// @ts-expect-error snapshot must be nested under the `snapshot` key
+createPlayer({ count: 1 }, { persisted: snapshot });
+//# sourceMappingURL=define-player.typecheck.js.map

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

@@ -0,0 +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"}

package/dist/errors.d.ts

@@ -0,0 +1,66 @@
+import { PlayError } from "@xmachines/play";
+/**
+ * Thrown by `buildRouteUrl()` when a required route parameter is absent from the
+ * actor's context.
+ *
+ * Use the `param` and `template` fields to identify the missing parameter without
+ * parsing the `.message` string.
+ *
+ * **Error code:** `PLAY_ROUTE_PARAM_MISSING`
+ *
+ * @example
+ * ```typescript
+ * import { MissingRouteParamError } from "@xmachines/play-xstate/errors";
+ *
+ * // The route template "/profile/:userId" requires "userId" in context.
+ * // If userId is absent, MissingRouteParamError is thrown when the
+ * // actor.currentRoute signal is read.
+ *
+ * try {
+ *   actor.currentRoute.get();
+ * } catch (err) {
+ *   if (err instanceof MissingRouteParamError) {
+ *     console.error(
+ *       `Missing "${err.param}" for template "${err.template}"`
+ *     );
+ *   }
+ * }
+ * ```
+ */
+export declare class MissingRouteParamError extends PlayError {
+    /** The name of the route parameter that was missing (e.g. `"userId"`). */
+    readonly param: string;
+    /** The route template that required the missing parameter (e.g. `"/profile/:userId"`). */
+    readonly template: string;
+    constructor(param: string, template: string);
+}
+/**
+ * Thrown by `PlayerActor.send()` when the event argument is not a plain object.
+ *
+ * `PlayEvent` requires `{ type: string, ...fields }`. Passing `null`, `undefined`,
+ * a string, or any other non-object value is a programmer error.
+ *
+ * The offending value is attached as the `detail` readonly class field for debugging.
+ * TypeScript consumers can access `err.detail` directly without any unsafe cast.
+ *
+ * **Error code:** `PLAY_INVALID_EVENT`
+ *
+ * @example
+ * ```typescript
+ * import { InvalidEventError } from "@xmachines/play-xstate/errors";
+ *
+ * try {
+ *   actor.send(null as any);
+ * } catch (err) {
+ *   if (err instanceof InvalidEventError) {
+ *     // err.detail is typed as `unknown` — no cast needed
+ *     console.error("Invalid event passed to actor.send():", err.detail);
+ *   }
+ * }
+ * ```
+ */
+export declare class InvalidEventError extends PlayError {
+    readonly detail: unknown;
+    constructor(detail: unknown);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC/C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;gBAEb,MAAM,EAAE,OAAO;CAU3B"}

package/dist/errors.js

@@ -0,0 +1,76 @@
+import { PlayError } from "@xmachines/play";
+/**
+ * Thrown by `buildRouteUrl()` when a required route parameter is absent from the
+ * actor's context.
+ *
+ * Use the `param` and `template` fields to identify the missing parameter without
+ * parsing the `.message` string.
+ *
+ * **Error code:** `PLAY_ROUTE_PARAM_MISSING`
+ *
+ * @example
+ * ```typescript
+ * import { MissingRouteParamError } from "@xmachines/play-xstate/errors";
+ *
+ * // The route template "/profile/:userId" requires "userId" in context.
+ * // If userId is absent, MissingRouteParamError is thrown when the
+ * // actor.currentRoute signal is read.
+ *
+ * try {
+ *   actor.currentRoute.get();
+ * } catch (err) {
+ *   if (err instanceof MissingRouteParamError) {
+ *     console.error(
+ *       `Missing "${err.param}" for template "${err.template}"`
+ *     );
+ *   }
+ * }
+ * ```
+ */
+export class MissingRouteParamError extends PlayError {
+    /** The name of the route parameter that was missing (e.g. `"userId"`). */
+    param;
+    /** The route template that required the missing parameter (e.g. `"/profile/:userId"`). */
+    template;
+    constructor(param, template) {
+        super("buildRouteUrl", "PLAY_ROUTE_PARAM_MISSING", `Route parameter '${param}' is required by template '${template}' but was not found in context.`);
+        this.name = "MissingRouteParamError";
+        this.param = param;
+        this.template = template;
+    }
+}
+/**
+ * Thrown by `PlayerActor.send()` when the event argument is not a plain object.
+ *
+ * `PlayEvent` requires `{ type: string, ...fields }`. Passing `null`, `undefined`,
+ * a string, or any other non-object value is a programmer error.
+ *
+ * The offending value is attached as the `detail` readonly class field for debugging.
+ * TypeScript consumers can access `err.detail` directly without any unsafe cast.
+ *
+ * **Error code:** `PLAY_INVALID_EVENT`
+ *
+ * @example
+ * ```typescript
+ * import { InvalidEventError } from "@xmachines/play-xstate/errors";
+ *
+ * try {
+ *   actor.send(null as any);
+ * } catch (err) {
+ *   if (err instanceof InvalidEventError) {
+ *     // err.detail is typed as `unknown` — no cast needed
+ *     console.error("Invalid event passed to actor.send():", err.detail);
+ *   }
+ * }
+ * ```
+ */
+export class InvalidEventError extends PlayError {
+    detail;
+    constructor(detail) {
+        super("PlayerActor", "PLAY_INVALID_EVENT", "PlayerActor.send() received a non-object event.");
+        this.name = "InvalidEventError";
+        // Attach the invalid value for debugging without it appearing in the message
+        Object.defineProperty(this, "detail", { value: detail, enumerable: true });
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,OAAO,sBAAuB,SAAQ,SAAS;IACpD,0EAA0E;IACjE,KAAK,CAAS;IAEvB,0FAA0F;IACjF,QAAQ,CAAS;IAE1B,YAAY,KAAa,EAAE,QAAgB;QAC1C,KAAK,CACJ,eAAe,EACf,0BAA0B,EAC1B,oBAAoB,KAAK,8BAA8B,QAAQ,iCAAiC,CAChG,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;QACrC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC1B,CAAC;CACD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,OAAO,iBAAkB,SAAQ,SAAS;IACtC,MAAM,CAAU;IAEzB,YAAY,MAAe;QAC1B,KAAK,CACJ,aAAa,EACb,oBAAoB,EACpB,iDAAiD,CACjD,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;QAChC,6EAA6E;QAC7E,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5E,CAAC;CACD"}

package/dist/guards/compose.d.ts

@@ -1,4 +1,15 @@
+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.
+ *
+ * `GuardPredicate<MachineContext, EventObject, unknown, ParameterizedObject>` is the
+ * widest-compatible concrete XState guard type that does not use `any`.
+ *
+ * @public
+ */
+export type ComposedGuard = GuardPredicate<MachineContext, EventObject, unknown, ParameterizedObject>;
 /**
  * Compose guards with AND logic using XState's and() helper
  *
@@ -54,7 +65,7 @@ import type { Guard, GuardArray } from "./types.js";
  * @see {@link composeGuardsOr} for OR composition
  * @see {@link negateGuard} for NOT logic
  */
-export declare const composeGuards: <TContext = any, TEvent = any>(guards: GuardArray<TContext, TEvent>) => any;
+export declare const composeGuards: <TContext = any, TEvent = any>(guards: GuardArray<TContext, TEvent>) => ComposedGuard;
 /**
  * Compose guards with OR logic using XState's or() helper
  *
@@ -95,7 +106,7 @@ export declare const composeGuards: <TContext = any, TEvent = any>(guards: Guard
  * @see {@link composeGuards} for AND composition
  * @see {@link negateGuard} for NOT logic
  */
-export declare const composeGuardsOr: <TContext = any, TEvent = any>(guards: GuardArray<TContext, TEvent>) => any;
+export declare const composeGuardsOr: <TContext = any, TEvent = any>(guards: GuardArray<TContext, TEvent>) => ComposedGuard;
 /**
  * Negate a guard using XState's not() helper
  *
@@ -132,5 +143,5 @@ export declare const composeGuardsOr: <TContext = any, TEvent = any>(guards: Gua
  * @see {@link composeGuards} for AND composition
  * @see {@link composeGuardsOr} for OR composition
  */
-export declare const negateGuard: <TContext = any, TEvent = any>(guard: Guard<TContext, TEvent> | string) => any;
+export declare const negateGuard: <TContext = any, TEvent = any>(guard: Guard<TContext, TEvent> | string) => ComposedGuard;
 //# sourceMappingURL=compose.d.ts.map

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,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,EACzD,QAAQ,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,KAClC,GAYF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,eAAe,GAAI,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,EAC3D,QAAQ,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,KAClC,GAUF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,EACvD,OAAO,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,MAAM,KACrC,GAEF,CAAC"}
+{"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;AAE/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"}

package/dist/guards/compose.js

@@ -54,15 +54,25 @@ import { and, or, not } from "xstate";
  * @see {@link composeGuardsOr} for OR composition
  * @see {@link negateGuard} for NOT logic
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const composeGuards = (guards) => {
     if (guards.length === 0) {
         throw new Error("composeGuards requires at least one guard");
     }
     if (guards.length === 1) {
+        // Single guard passthrough — cast through unknown because our Guard<TContext, TEvent>
+        // does not structurally match ComposedGuard at compile time (generic event mismatch).
+        // At runtime both are plain function objects with identical shape.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return guards[0];
     }
     // Use XState's built-in and() for type inference and serialization
     // Per RESEARCH.md: Don't hand-roll guard composition
+    // XState 5.28.0: and() requires `readonly [...tuple]` but our GuardArray is a mutable array.
+    // We cast through unknown to express the narrowest possible type boundary rather than
+    // escaping to `any`. The runtime value is identical.
+    // Track XState typing improvements: https://github.com/statelyai/xstate/issues
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return and(guards);
 };
 /**
@@ -105,13 +115,23 @@ export const composeGuards = (guards) => {
  * @see {@link composeGuards} for AND composition
  * @see {@link negateGuard} for NOT logic
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const composeGuardsOr = (guards) => {
     if (guards.length === 0) {
         throw new Error("composeGuardsOr requires at least one guard");
     }
     if (guards.length === 1) {
+        // Single guard passthrough — cast through unknown because our Guard<TContext, TEvent>
+        // does not structurally match ComposedGuard at compile time (generic event mismatch).
+        // At runtime both are plain function objects with identical shape.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return guards[0];
     }
+    // XState 5.28.0: or() requires `readonly [...tuple]` but our GuardArray is a mutable array.
+    // We cast through unknown to express the narrowest possible type boundary rather than
+    // escaping to `any`. The runtime value is identical.
+    // Track XState typing improvements: https://github.com/statelyai/xstate/issues
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return or(guards);
 };
 /**
@@ -150,7 +170,13 @@ export const composeGuardsOr = (guards) => {
  * @see {@link composeGuards} for AND composition
  * @see {@link composeGuardsOr} for OR composition
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const negateGuard = (guard) => {
+    // XState 5.28.0: not() requires a specific SingleGuardArg shape, not our Guard type.
+    // We cast through unknown to express the narrowest possible type boundary rather than
+    // escaping to `any`. The runtime value is identical.
+    // Track XState typing improvements: https://github.com/statelyai/xstate/issues
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return not(guard);
 };
 //# sourceMappingURL=compose.js.map

package/dist/guards/compose.js.map

@@ -1 +1 @@
-{"version":3,"file":"compose.js","sourceRoot":"","sources":["../../src/guards/compose.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAGtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC5B,MAAoC,EAC9B,EAAE;IACR,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC9D,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,mEAAmE;IACnE,qDAAqD;IACrD,OAAO,GAAG,CAAC,MAAa,CAAC,CAAC;AAC3B,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC9B,MAAoC,EAC9B,EAAE;IACR,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;IAChE,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,OAAO,EAAE,CAAC,MAAa,CAAC,CAAC;AAC1B,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAC1B,KAAuC,EACjC,EAAE;IACR,OAAO,GAAG,CAAC,KAAY,CAAC,CAAC;AAC1B,CAAC,CAAC"}
+{"version":3,"file":"compose.js","sourceRoot":"","sources":["../../src/guards/compose.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAoBtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,8DAA8D;AAC9D,MAAM,CAAC,MAAM,aAAa,GAAG,CAC5B,MAAoC,EACpB,EAAE;IAClB,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC9D,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,sFAAsF;QACtF,sFAAsF;QACtF,mEAAmE;QACnE,8DAA8D;QAC9D,OAAO,MAAM,CAAC,CAAC,CAA6B,CAAC;IAC9C,CAAC;IAED,mEAAmE;IACnE,qDAAqD;IACrD,6FAA6F;IAC7F,sFAAsF;IACtF,qDAAqD;IACrD,+EAA+E;IAC/E,8DAA8D;IAC9D,OAAO,GAAG,CAAC,MAA8C,CAAC,CAAC;AAC5D,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,8DAA8D;AAC9D,MAAM,CAAC,MAAM,eAAe,GAAG,CAC9B,MAAoC,EACpB,EAAE;IAClB,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;IAChE,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,sFAAsF;QACtF,sFAAsF;QACtF,mEAAmE;QACnE,8DAA8D;QAC9D,OAAO,MAAM,CAAC,CAAC,CAA6B,CAAC;IAC9C,CAAC;IAED,4FAA4F;IAC5F,sFAAsF;IACtF,qDAAqD;IACrD,+EAA+E;IAC/E,8DAA8D;IAC9D,OAAO,EAAE,CAAC,MAA6C,CAAC,CAAC;AAC1D,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,8DAA8D;AAC9D,MAAM,CAAC,MAAM,WAAW,GAAG,CAC1B,KAAuC,EACvB,EAAE;IAClB,qFAAqF;IACrF,sFAAsF;IACtF,qDAAqD;IACrD,+EAA+E;IAC/E,8DAA8D;IAC9D,OAAO,GAAG,CAAC,KAA6C,CAAC,CAAC;AAC3D,CAAC,CAAC"}

package/dist/guards/helpers.d.ts

@@ -1,4 +1,5 @@
 import type { Guard } from "./types.js";
+import type { PlayEvent } from "@xmachines/play";
 /**
  * Check if context has a truthy value at path
  *
@@ -17,7 +18,7 @@ import type { Guard } from "./types.js";
  * @param path - Dot-separated path to context property
  * @returns Guard predicate checking if property is truthy
  */
-export declare const hasContext: <TContext = any>(path: string) => Guard<TContext, any>;
+export declare const hasContext: <TContext = Record<string, unknown>>(path: string) => Guard<TContext, PlayEvent>;
 /**
  * Check if event type matches expected type
  *
@@ -37,24 +38,19 @@ export declare const hasContext: <TContext = any>(path: string) => Guard<TContex
  * @param eventType - Expected event type
  * @returns Guard predicate checking event type
  */
-export declare const eventMatches: <TEvent extends {
-    type: string;
-} = any>(eventType: string) => Guard<any, TEvent>;
+export declare const eventMatches: <TEvent extends PlayEvent = PlayEvent>(eventType: string) => Guard<unknown, TEvent>;
 /**
- * Check if current state matches expected value
+ * Check if a context field matches an expected value.
  *
- * @example
- * ```typescript
- * const machine = setup({
- *   guards: {
- *     isLoggedIn: stateMatches('authenticated'),
- *     isDashboard: stateMatches('authenticated.dashboard')
- *   }
- * });
- * ```
+ * - Accepts an explicit dot-separated field path (e.g. `"user.role"`)
+ * - Uses strict equality for primitives, deep structural equality for objects
+ * - Does NOT use substring matching — `"a"` will not match `"active"`
+ *
+ * For XState state-node matching, use the built-in `in:` guard syntax instead.
  *
- * @param stateValue - Expected state value (string or object)
- * @returns Guard predicate checking state value
+ * @param fieldPath - Dot-separated path to context property (e.g., "status", "user.role")
+ * @param expectedValue - Value to compare against (string or object)
+ * @returns Guard predicate checking if context field matches
  */
-export declare const stateMatches: <TContext = any>(stateValue: string) => Guard<TContext, any>;
+export declare const contextFieldMatches: <TContext = Record<string, unknown>>(fieldPath: string, expectedValue: unknown) => Guard<TContext, PlayEvent>;
 //# sourceMappingURL=helpers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/guards/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,GACrB,QAAQ,GAAG,GAAG,EAAE,MAAM,MAAM,KAAG,KAAK,CAAC,QAAQ,EAAE,GAAG,CAIlD,CAAC;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,YAAY,GACvB,MAAM,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,GAAG,EAAE,WAAW,MAAM,KAAG,KAAK,CAAC,GAAG,EAAE,MAAM,CAG5E,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,GACvB,QAAQ,GAAG,GAAG,EAAE,YAAY,MAAM,KAAG,KAAK,CAAC,QAAQ,EAAE,GAAG,CAexD,CAAC"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/guards/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,GACrB,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,MAAM,KAAG,KAAK,CAAC,QAAQ,EAAE,SAAS,CAI5E,CAAC;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,YAAY,GACvB,MAAM,SAAS,SAAS,GAAG,SAAS,EAAE,WAAW,MAAM,KAAG,KAAK,CAAC,OAAO,EAAE,MAAM,CAG/E,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,WAAW,MAAM,EACjB,eAAe,OAAO,KACpB,KAAK,CAAC,QAAQ,EAAE,SAAS,CAa3B,CAAC"}

package/dist/guards/helpers.js

@@ -43,34 +43,29 @@ export const eventMatches = (eventType) => ({ event }) => {
     return event.type === eventType;
 };
 /**
- * Check if current state matches expected value
+ * Check if a context field matches an expected value.
  *
- * @example
- * ```typescript
- * const machine = setup({
- *   guards: {
- *     isLoggedIn: stateMatches('authenticated'),
- *     isDashboard: stateMatches('authenticated.dashboard')
- *   }
- * });
- * ```
+ * - Accepts an explicit dot-separated field path (e.g. `"user.role"`)
+ * - Uses strict equality for primitives, deep structural equality for objects
+ * - Does NOT use substring matching — `"a"` will not match `"active"`
+ *
+ * For XState state-node matching, use the built-in `in:` guard syntax instead.
  *
- * @param stateValue - Expected state value (string or object)
- * @returns Guard predicate checking state value
+ * @param fieldPath - Dot-separated path to context property (e.g., "status", "user.role")
+ * @param expectedValue - Value to compare against (string or object)
+ * @returns Guard predicate checking if context field matches
  */
-export const stateMatches = (stateValue) => ({ context }) => {
-    // Note: This helper checks context for state info
-    // For actual XState state matching, use machine.matches() in actions
-    // This is a simplified version for context-based state checks
-    const currentState = context._state || context.state;
-    if (!currentState)
-        return false;
-    // Simple string matching (can be enhanced for nested states)
-    if (typeof currentState === "string") {
-        return currentState === stateValue;
+export const contextFieldMatches = (fieldPath, expectedValue) => ({ context }) => {
+    const actual = getNestedValue(context, fieldPath);
+    if (actual === expectedValue)
+        return true;
+    if (typeof actual === "object" &&
+        typeof expectedValue === "object" &&
+        actual !== null &&
+        expectedValue !== null) {
+        return JSON.stringify(actual) === JSON.stringify(expectedValue);
     }
-    // Object state matching
-    return JSON.stringify(currentState).includes(stateValue);
+    return false;
 };
 /**
  * Get nested value from object using dot-separated path
@@ -81,7 +76,7 @@ const getNestedValue = (obj, path) => {
     const keys = path.split(".");
     let value = obj;
     for (const key of keys) {
-        if (value === null || value === undefined) {
+        if (value === null || value === undefined || typeof value !== "object") {
             return undefined;
         }
         value = value[key];

package/dist/guards/helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/guards/helpers.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,UAAU,GACtB,CAAiB,IAAY,EAAwB,EAAE,CACvD,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;IACf,MAAM,KAAK,GAAG,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC5C,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;AAC9D,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,YAAY,GACxB,CAAwC,SAAiB,EAAsB,EAAE,CACjF,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE;IACb,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;AACjC,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,YAAY,GACxB,CAAiB,UAAkB,EAAwB,EAAE,CAC7D,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;IACf,kDAAkD;IAClD,qEAAqE;IACrE,8DAA8D;IAC9D,MAAM,YAAY,GAAI,OAAe,CAAC,MAAM,IAAK,OAAe,CAAC,KAAK,CAAC;IACvE,IAAI,CAAC,YAAY;QAAE,OAAO,KAAK,CAAC;IAEhC,6DAA6D;IAC7D,IAAI,OAAO,YAAY,KAAK,QAAQ,EAAE,CAAC;QACtC,OAAO,YAAY,KAAK,UAAU,CAAC;IACpC,CAAC;IAED,wBAAwB;IACxB,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AAC1D,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,cAAc,GAAG,CAAC,GAAQ,EAAE,IAAY,EAAO,EAAE;IACtD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC7B,IAAI,KAAK,GAAG,GAAG,CAAC;IAEhB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACxB,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YAC3C,OAAO,SAAS,CAAC;QAClB,CAAC;QACD,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;IACpB,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC,CAAC"}
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/guards/helpers.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,UAAU,GACtB,CAAqC,IAAY,EAA8B,EAAE,CACjF,CAAC,EAAE,OAAO,EAAyB,EAAE,EAAE;IACtC,MAAM,KAAK,GAAG,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC5C,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;AAC9D,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,YAAY,GACxB,CAAuC,SAAiB,EAA0B,EAAE,CACpF,CAAC,EAAE,KAAK,EAAqB,EAAE,EAAE;IAChC,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;AACjC,CAAC,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAC/B,CACC,SAAiB,EACjB,aAAsB,EACO,EAAE,CAChC,CAAC,EAAE,OAAO,EAAyB,EAAE,EAAE;IACtC,MAAM,MAAM,GAAG,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAClD,IAAI,MAAM,KAAK,aAAa;QAAE,OAAO,IAAI,CAAC;IAC1C,IACC,OAAO,MAAM,KAAK,QAAQ;QAC1B,OAAO,aAAa,KAAK,QAAQ;QACjC,MAAM,KAAK,IAAI;QACf,aAAa,KAAK,IAAI,EACrB,CAAC;QACF,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;IACjE,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,cAAc,GAAG,CAAC,GAAY,EAAE,IAAY,EAAW,EAAE;IAC9D,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC7B,IAAI,KAAK,GAAG,GAAG,CAAC;IAEhB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACxB,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YACxE,OAAO,SAAS,CAAC;QAClB,CAAC;QACD,KAAK,GAAI,KAAiC,CAAC,GAAG,CAAC,CAAC;IACjD,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC,CAAC"}

package/dist/guards/index.d.ts

@@ -7,6 +7,7 @@
  * @packageDocumentation
  */
 export { composeGuards, composeGuardsOr, negateGuard } from "./compose.js";
-export { hasContext, eventMatches, stateMatches } from "./helpers.js";
+export type { ComposedGuard } from "./compose.js";
+export { hasContext, eventMatches, contextFieldMatches } from "./helpers.js";
 export type { Guard, GuardArray } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/guards/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACtE,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/guards/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3E,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAC7E,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/guards/index.js

@@ -7,5 +7,5 @@
  * @packageDocumentation
  */
 export { composeGuards, composeGuardsOr, negateGuard } from "./compose.js";
-export { hasContext, eventMatches, stateMatches } from "./helpers.js";
+export { hasContext, eventMatches, contextFieldMatches } from "./helpers.js";
 //# sourceMappingURL=index.js.map

package/dist/guards/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/guards/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/guards/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3E,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC"}

package/dist/guards/types.d.ts

@@ -1,3 +1,4 @@
+import type { PlayEvent } from "@xmachines/play";
 /**
  * Standard XState guard function signature
  *
@@ -8,7 +9,7 @@
  * @param args.event - Event that triggered the guard evaluation
  * @returns boolean indicating if guard passes
  */
-export type Guard<TContext = any, TEvent = any> = (args: {
+export type Guard<TContext = Record<string, unknown>, TEvent = PlayEvent> = (args: {
     context: TContext;
     event: TEvent;
 }) => boolean;
@@ -17,5 +18,5 @@ export type Guard<TContext = any, TEvent = any> = (args: {
  *
  * Per CONTEXT.md: Array means AND - all guards must pass
  */
-export type GuardArray<TContext = any, TEvent = any> = Array<Guard<TContext, TEvent>> | Array<string>;
+export type GuardArray<TContext = Record<string, unknown>, TEvent = PlayEvent> = Array<Guard<TContext, TEvent>> | Array<string>;
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/guards/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,MAAM,KAAK,CAAC,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,EAAE;IACxD,OAAO,EAAE,QAAQ,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACd,KAAK,OAAO,CAAC;AAEd;;;;GAIG;AACH,MAAM,MAAM,UAAU,CAAC,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,IAChD,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,GAC9B,KAAK,CAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/guards/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;;;;;;;GASG;AACH,MAAM,MAAM,KAAK,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,IAAI,CAAC,IAAI,EAAE;IAClF,OAAO,EAAE,QAAQ,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACd,KAAK,OAAO,CAAC;AAEd;;;;GAIG;AACH,MAAM,MAAM,UAAU,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,IAC1E,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,GAC9B,KAAK,CAAC,MAAM,CAAC,CAAC"}