@xmachines/play-actor 1.0.0-beta.25 → 1.0.0-beta.26

package/dist/abstract-actor.d.ts

@@ -21,72 +21,11 @@ import type { Signal } from "@xmachines/play-signals";
 import type { Spec } from "@json-render/core";
 /**
  * Optional capability: Routing support
- *
- * Actors implementing this interface can derive a route from their state.
- * Router adapters observe the currentRoute signal to sync browser URLs.
- *
- * @example
- * ```typescript
- * class MyActor extends AbstractActor implements Routable {
- *   currentRoute = new Signal.Computed(() => deriveRoute(this.state.get()));
- * }
- *
- * // Router requires Routable
- * function connectRouter<T extends AbstractActor & Routable>(actor: T) {
- *   watcher.watch(actor.currentRoute);
- * }
- * ```
  */
 export interface Routable {
-    /**
-     * Current route signal
-     *
-     * Computed signal derived from state machine. Infrastructure observes to sync browser URL.
-     *
-     * Invariant: Passive Infrastructure - Infrastructure reflects route, never decides.
-     *
-     * @example
-     * ```typescript
-     * const watcher = new Signal.subtle.Watcher(() => {
-     *   const route = actor.currentRoute.get();
-     *   console.log('Route changed:', route);
-     * });
-     * watcher.watch(actor.currentRoute);
-     * ```
-     */
     readonly currentRoute: Signal.Computed<string | null>;
-    /**
-     * The route derived from the machine's **initial** state — fixed at construction
-     * and never changes, even after `start()` with a restored snapshot.
-     *
-     * Router bridges use this to distinguish a deep-link (browser URL differs from
-     * the initial route because the user navigated there) from a restore (browser is
-     * at the machine's default starting URL while the actor was restored to a
-     * different route from a snapshot).
-     *
-     * `null` when the machine's initial state has no `meta.route`.
-     */
     readonly initialRoute: string | null;
 }
-/**
- * Optional capability: View rendering support
- *
- * Actors implementing this interface can derive view structures from their state.
- * Renderers observe the currentView signal to update the UI.
- *
- * @example
- * ```typescript
- * class MyActor extends AbstractActor implements Viewable {
- *   currentView = new Signal.State(null);
- * }
- *
- * // Renderer requires Viewable
- * function renderView<T extends AbstractActor & Viewable>(actor: T) {
- *   const view = actor.currentView.get();
- *   // view.component is the component name; view.spec is the json-render spec
- * }
- * ```
- */
 /**
  * XMachines extension of `@json-render/core` `Spec`.
  *
@@ -95,31 +34,56 @@ export interface Routable {
  * fields named here are ever exposed to components; nothing leaks from context
  * without an opt-in declaration.
  *
- * @example
- * ```ts
- * spec: {
- *   root: "root",
- *   contextProps: ["username"],   // expose context.username as a prop slot
- *   elements: {
- *     root: { type: "Dashboard", props: { username: undefined }, children: [] },
- *   },
- * }
- * ```
+ * Use `typedSpec<TContext>(...)` at the definition site to validate `contextProps`
+ * entries against your machine's context type at compile time.
  */
 export interface PlaySpec extends Spec {
     /**
      * Explicit allowlist of machine context field names to expose as prop slots.
-     *
      * Each named field is merged into every spec element's `props` at view derivation
-     * time, filling any slot whose current value is `undefined`. `null` and
-     * `undefined` context values are skipped. URL route params (from `context.routeParams`)
-     * take priority over `contextProps` values; explicit non-`undefined` spec props
-     * always take priority over both.
+     * time, filling any slot whose current value is `undefined`.
+     *
+     * Use `typedSpec<TContext>(...)` to constrain entries to `keyof TContext & string`.
      */
-    contextProps?: string[];
+    readonly contextProps?: readonly string[];
 }
 /**
- * View metadata for rendering
+ * Identity helper that constrains a `PlaySpec` object's `contextProps` to keys
+ * of a specific machine context type, giving compile-time validation and IDE
+ * autocomplete at the definition site.
+ *
+ * XState's `meta` field is typed as `Record<string, unknown>`, so TypeScript
+ * cannot infer the constraint from context. `typedSpec<MyCtx>(...)` is the
+ * opt-in mechanism that activates enforcement where the spec is written.
+ *
+ * At runtime this is a no-op — the spec object is returned unchanged.
+ *
+ * @example
+ * ```ts
+ * interface DashboardCtx {
+ *   username: string;
+ *   params: Record<string, string>;
+ *   query: Record<string, string>;
+ * }
+ *
+ * meta: {
+ *   view: {
+ *     component: "Dashboard",
+ *     spec: typedSpec<DashboardCtx>({
+ *       root: "root",
+ *       contextProps: ["username"],    // ✓ key of DashboardCtx
+ *       // contextProps: ["usernaem"], // ✗ compile error
+ *       elements: { root: { type: "Dashboard", props: {}, children: [] } },
+ *     }),
+ *   },
+ * }
+ * ```
+ */
+export declare function typedSpec<TContext extends object>(spec: Omit<PlaySpec, "contextProps"> & {
+    readonly contextProps?: readonly (keyof TContext & string)[];
+}): PlaySpec;
+/**
+ * View metadata for rendering.
  *
  * Describes the component to be rendered and the json-render Spec to use.
  * Used by PlayRenderer to dynamically render UI based on actor state.
@@ -130,6 +94,9 @@ export interface ViewMetadata {
     /**
      * XMachines view spec — extends `@json-render/core` Spec with `contextProps`
      * for explicit context field exposure.
+     *
+     * Use `typedSpec<TContext>(...)` at the definition site to validate
+     * `contextProps` entries against the machine context type.
      */
     spec: PlaySpec;
 }
@@ -139,131 +106,39 @@ export interface ViewMetadata {
  * `Viewable` marks actors that publish a `currentView` signal.
  * Renderers such as `PlayRenderer` consume this contract to resolve the
  * current view description into concrete UI without embedding view logic inside the
- * framework adapter. Component lookup is handled by the json-render registry
- * passed to PlayRenderer, not stored on the actor.
+ * framework adapter.
  */
 export interface Viewable {
     /**
-     * Current view signal
+     * Current view signal.
      *
-     * State signal containing view.component and view.spec from meta.view. Infrastructure renders view.
-     *
-     * Invariant: Logic-Driven UI - View structure is defined by business logic, not JSX.
-     *
-     * @example
-     * ```typescript
-     * const watcher = new Signal.subtle.Watcher(() => {
-     *   const view = actor.currentView.get();
-     *   console.log('View changed:', view.component, view.spec);
-     * });
-     * watcher.watch(actor.currentView);
-     * ```
+     * State signal containing view.component and view.spec from meta.view.
+     * Infrastructure renders view — Logic-Driven UI invariant.
      */
     readonly currentView: Signal.State<ViewMetadata | null>;
 }
 /**
  * Abstract base class for Play Architecture actors.
  *
- * Extends XState Actor to maintain ecosystem compatibility (inspection, devtools)
- * while enforcing minimal signal protocol for Actor ↔ Infrastructure communication.
- *
- * The core protocol contains only:
- * - state: Reactive state snapshot
- * - send: Event dispatch method
- *
- * Optional capabilities (routing, view rendering) are provided via interfaces:
- * - Implement Routable for routing support
- * - Implement Viewable for view rendering support
- *
- * Concrete implementations created by @xmachines/play-xstate adapter.
- *
- * @typeParam TLogic - XState actor logic type (maintains type safety)
- * @typeParam TEvent - Event type union that this actor's send() accepts.
- *   Defaults to `EventObject` (`{ type: string }`) for backward compatibility.
- *   Use `EventFromLogic<TMachine>` from xstate to infer the exact event union
- *   from a state machine (e.g., in `PlayerActor`).
- *
- * Invariant: Actor Authority - Actor is the sole source of truth for state transitions.
- * Invariant: Signal-Only Reactivity - Infrastructure observes via TC39 Signals.
- * Invariant: Passive Infrastructure - Infrastructure reflects, never decides.
+ * Provides signal-driven state observation that integrates with XState ecosystem
+ * tooling (devtools, inspection) while exposing reactive signals for
+ * Infrastructure layer communication.
  *
- * @example
- * Simple actor (no routing, no view) - single type param, backward compat
- * ```typescript
- * class SimpleActor extends AbstractActor<AnyActorLogic> {
- *   state = new Signal.State({...});
- *   send(event) { ... }
- * }
- * ```
- *
- * @example
- * Typed event actor - two type params
- * ```typescript
- * type AuthEvent = { type: "auth.login"; username: string } | { type: "auth.logout" };
- * class AuthActor extends AbstractActor<AnyActorLogic, AuthEvent> {
- *   state = new Signal.State({...});
- *   send(event: AuthEvent) { ... }
- * }
- * ```
- *
- * @example
- * Full-featured actor (routing + view)
- * ```typescript
- * class PlayerActor extends AbstractActor<AnyActorLogic, EventFromLogic<TMachine>>
- *   implements Routable, Viewable {
- *   state = new Signal.State({...});
- *   currentRoute = new Signal.Computed(() => deriveRoute(this.state.get()));
- *   currentView = new Signal.State(null);
- *   send(event) { ... }
- * }
- * ```
- *
- * @see [Play RFC](../../docs/rfc/play.md)
- * @see {@link Routable} for routing capability
- * @see {@link Viewable} for view rendering capability
+ * @typeParam TLogic - XState actor logic type
+ * @typeParam TEvent - Event type constraint (defaults to EventObject)
  */
 export declare abstract class AbstractActor<TLogic extends AnyActorLogic, TEvent extends EventObject = EventObject> extends Actor<TLogic> {
     /**
      * Reactive snapshot of current actor state.
      *
-     * Typed as `Signal.State<unknown>` at the abstract level; concrete implementations
-     * narrow this to the actual snapshot type (e.g., `Signal.State<AnyMachineSnapshot>`
-     * in `@xmachines/play-xstate`'s `PlayerActor`).
-     *
      * Infrastructure observes this signal to react to state changes without
-     * directly coupling to the Actor's internal state machine implementation.
-     *
-     * @example
-     * ```typescript
-     * // Infrastructure observes state signal
-     * const watcher = new Signal.subtle.Watcher(() => {
-     *   console.log('Actor state changed:', actor.state.get());
-     * });
-     * watcher.watch(actor.state);
-     * ```
+     * directly coupling to the actor's internal state machine implementation.
      */
     abstract state: Signal.State<unknown>;
     /**
-     * Send event to Actor
-     *
-     * Infrastructure forwards user intents (navigation, domain events, custom events)
-     * as events to the Actor. The Actor's state machine guards determine whether
-     * each event is valid from the current state.
-     *
-     * @param event - Event object with type property (e.g., PlayEvent, PlayRouteEvent)
-     *
-     * Invariant: Actor Authority - Only Actor decides whether an event is valid.
-     *
-     * @example
-     * ```typescript
-     * // Infrastructure forwards user intent
-     * actor.send({ type: 'auth.login', userId: '123' });
-     * // Actor's guards determine if event is allowed
-     * ```
+     * Send event to Actor.
      *
-     * @remarks
-     * Accepts any event object with a type property. Core events (PlayEvent) are in
-     * @xmachines/play, routing events (PlayRouteEvent) are in @xmachines/play-router.
+     * Constrained to TEvent for type safety in concrete implementations.
      */
     abstract send(event: TEvent): void;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"abstract-actor.d.ts","sourceRoot":"","sources":["../src/abstract-actor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,KAAK,EAAE,KAAK,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,QAAQ,CAAC;AACrE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAE9C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,QAAQ;IACxB;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACtD;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,QAAS,SAAQ,IAAI;IACrC;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC5B,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,IAAI,EAAE,QAAQ,CAAC;CACf;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,QAAQ;IACxB;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;CACxD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,8BAAsB,aAAa,CAClC,MAAM,SAAS,aAAa,EAC5B,MAAM,SAAS,WAAW,GAAG,WAAW,CACvC,SAAQ,KAAK,CAAC,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;;;OAkBG;IACH,SAAgB,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAE7C;;;;;;;;;;;;;;;;;;;;;OAqBG;aACsB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAClD"}
+{"version":3,"file":"abstract-actor.d.ts","sourceRoot":"","sources":["../src/abstract-actor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,KAAK,EAAE,KAAK,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,QAAQ,CAAC;AACrE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACtD,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,QAAS,SAAQ,IAAI;IACrC;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,SAAS,CAAC,QAAQ,SAAS,MAAM,EAChD,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,cAAc,CAAC,GAAG;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,EAAE,CAAC;CAC7D,GACC,QAAQ,CAEV;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC5B,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,IAAI,EAAE,QAAQ,CAAC;CACf;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;CACxD;AAED;;;;;;;;;GASG;AACH,8BAAsB,aAAa,CAClC,MAAM,SAAS,aAAa,EAC5B,MAAM,SAAS,WAAW,GAAG,WAAW,CACvC,SAAQ,KAAK,CAAC,MAAM,CAAC;IACtB;;;;;OAKG;IACH,SAAgB,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAE7C;;;;OAIG;aACsB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAClD"}

package/dist/abstract-actor.js

@@ -18,65 +18,49 @@
  */
 import { Actor } from "xstate";
 /**
- * Abstract base class for Play Architecture actors.
- *
- * Extends XState Actor to maintain ecosystem compatibility (inspection, devtools)
- * while enforcing minimal signal protocol for Actor ↔ Infrastructure communication.
- *
- * The core protocol contains only:
- * - state: Reactive state snapshot
- * - send: Event dispatch method
- *
- * Optional capabilities (routing, view rendering) are provided via interfaces:
- * - Implement Routable for routing support
- * - Implement Viewable for view rendering support
+ * Identity helper that constrains a `PlaySpec` object's `contextProps` to keys
+ * of a specific machine context type, giving compile-time validation and IDE
+ * autocomplete at the definition site.
  *
- * Concrete implementations created by @xmachines/play-xstate adapter.
+ * XState's `meta` field is typed as `Record<string, unknown>`, so TypeScript
+ * cannot infer the constraint from context. `typedSpec<MyCtx>(...)` is the
+ * opt-in mechanism that activates enforcement where the spec is written.
  *
- * @typeParam TLogic - XState actor logic type (maintains type safety)
- * @typeParam TEvent - Event type union that this actor's send() accepts.
- *   Defaults to `EventObject` (`{ type: string }`) for backward compatibility.
- *   Use `EventFromLogic<TMachine>` from xstate to infer the exact event union
- *   from a state machine (e.g., in `PlayerActor`).
- *
- * Invariant: Actor Authority - Actor is the sole source of truth for state transitions.
- * Invariant: Signal-Only Reactivity - Infrastructure observes via TC39 Signals.
- * Invariant: Passive Infrastructure - Infrastructure reflects, never decides.
+ * At runtime this is a no-op — the spec object is returned unchanged.
  *
  * @example
- * Simple actor (no routing, no view) - single type param, backward compat
- * ```typescript
- * class SimpleActor extends AbstractActor<AnyActorLogic> {
- *   state = new Signal.State({...});
- *   send(event) { ... }
+ * ```ts
+ * interface DashboardCtx {
+ *   username: string;
+ *   params: Record<string, string>;
+ *   query: Record<string, string>;
  * }
- * ```
  *
- * @example
- * Typed event actor - two type params
- * ```typescript
- * type AuthEvent = { type: "auth.login"; username: string } | { type: "auth.logout" };
- * class AuthActor extends AbstractActor<AnyActorLogic, AuthEvent> {
- *   state = new Signal.State({...});
- *   send(event: AuthEvent) { ... }
+ * meta: {
+ *   view: {
+ *     component: "Dashboard",
+ *     spec: typedSpec<DashboardCtx>({
+ *       root: "root",
+ *       contextProps: ["username"],    // ✓ key of DashboardCtx
+ *       // contextProps: ["usernaem"], // ✗ compile error
+ *       elements: { root: { type: "Dashboard", props: {}, children: [] } },
+ *     }),
+ *   },
  * }
  * ```
+ */
+export function typedSpec(spec) {
+    return spec;
+}
+/**
+ * Abstract base class for Play Architecture actors.
  *
- * @example
- * Full-featured actor (routing + view)
- * ```typescript
- * class PlayerActor extends AbstractActor<AnyActorLogic, EventFromLogic<TMachine>>
- *   implements Routable, Viewable {
- *   state = new Signal.State({...});
- *   currentRoute = new Signal.Computed(() => deriveRoute(this.state.get()));
- *   currentView = new Signal.State(null);
- *   send(event) { ... }
- * }
- * ```
+ * Provides signal-driven state observation that integrates with XState ecosystem
+ * tooling (devtools, inspection) while exposing reactive signals for
+ * Infrastructure layer communication.
  *
- * @see [Play RFC](../../docs/rfc/play.md)
- * @see {@link Routable} for routing capability
- * @see {@link Viewable} for view rendering capability
+ * @typeParam TLogic - XState actor logic type
+ * @typeParam TEvent - Event type constraint (defaults to EventObject)
  */
 export class AbstractActor extends Actor {
 }

package/dist/abstract-actor.js.map

@@ -1 +1 @@
-{"version":3,"file":"abstract-actor.js","sourceRoot":"","sources":["../src/abstract-actor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,KAAK,EAAwC,MAAM,QAAQ,CAAC;AAsJrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,OAAgB,aAGpB,SAAQ,KAAa;CA6CtB"}
+{"version":3,"file":"abstract-actor.js","sourceRoot":"","sources":["../src/abstract-actor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,KAAK,EAAwC,MAAM,QAAQ,CAAC;AAkCrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,SAAS,CACxB,IAEC;IAED,OAAO,IAAgB,CAAC;AACzB,CAAC;AAuCD;;;;;;;;;GASG;AACH,MAAM,OAAgB,aAGpB,SAAQ,KAAa;CAetB"}

package/dist/index.d.ts

@@ -15,5 +15,5 @@
  * @packageDocumentation
  * @see [Play RFC](../../docs/rfc/play.md)
  */
-export { AbstractActor, type Routable, type Viewable, type ViewMetadata, type PlaySpec, } from "./abstract-actor.js";
+export { AbstractActor, typedSpec, type Routable, type Viewable, type ViewMetadata, type PlaySpec, } from "./abstract-actor.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACN,aAAa,EACb,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,QAAQ,GACb,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACN,aAAa,EACb,SAAS,EACT,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,QAAQ,GACb,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -15,5 +15,5 @@
  * @packageDocumentation
  * @see [Play RFC](../../docs/rfc/play.md)
  */
-export { AbstractActor, } from "./abstract-actor.js";
+export { AbstractActor, typedSpec, } from "./abstract-actor.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACN,aAAa,GAKb,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACN,aAAa,EACb,SAAS,GAKT,MAAM,qBAAqB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-actor",
-  "version": "1.0.0-beta.25",
+  "version": "1.0.0-beta.26",
   "private": false,
   "description": "Abstract Actor base class for XMachines Play Architecture",
   "keywords": [
@@ -43,15 +43,15 @@
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
-    "@xmachines/shared": "1.0.0-beta.25",
+    "@xmachines/shared": "1.0.0-beta.26",
     "oxfmt": "^0.43.0",
     "oxlint": "^1.57.0",
     "vitest": "^4.1.2",
     "xstate": "^5.30.0"
   },
   "peerDependencies": {
-    "@xmachines/play": "1.0.0-beta.25",
-    "@xmachines/play-signals": "1.0.0-beta.25",
+    "@xmachines/play": "1.0.0-beta.26",
+    "@xmachines/play-signals": "1.0.0-beta.26",
     "xstate": "^5.30.0"
   },
   "engines": {