@xmachines/play-actor 4.0.0 → 5.0.1

package/README.md

@@ -2,7 +2,7 @@
 
 The actor contract of the XMachines Play Architecture. It names no state machine library.
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-4.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-actor)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-5.0.1-blue)](https://www.npmjs.com/package/@xmachines/play-actor)
 
 ## Installation
 
@@ -13,7 +13,7 @@ pnpm add @xmachines/play-actor
 **Peer dependencies.** Install them with the package:
 
 ```bash
-pnpm add @xmachines/play-signals
+pnpm add @xmachines/play-atom
 ```
 
 ## Overview
@@ -23,7 +23,7 @@ An actor of XMachines holds exactly two things:
 
 | Member  | Type                      | Description                                |
 | ------- | ------------------------- | ------------------------------------------ |
-| `state` | `Signal.State<TSnapshot>` | The reactive snapshot of the current state |
+| `state` | `Atom<TSnapshot>`         | The reactive snapshot of the current state |
 | `send`  | `(event: TEvent) => void` | The typed event dispatch                   |
 
 **It is an interface, and no base class.** A state machine library is the concern of an
@@ -55,14 +55,15 @@ Both type parameters carry their real type through, and neither one erases it.
 
 ```ts
 import type { PlayActor } from "@xmachines/play-actor";
-import { Signal } from "@xmachines/play-signals";
+import { createAtom } from "@xmachines/play-atom";
+import type { Atom } from "@xmachines/play-atom";
 
 type Snapshot = { readonly value: string };
 type AuthEvent =
 	{ readonly type: "auth.login"; readonly username: string } | { readonly type: "auth.logout" };
 
 class AuthActor implements PlayActor<Snapshot, AuthEvent> {
-	readonly state = new Signal.State<Snapshot>({ value: "guest" });
+	readonly state = createAtom<Snapshot>({ value: "guest" });
 
 	send(event: AuthEvent): void {
 		if (event.type === "auth.login") this.state.set({ value: "authenticated" });
@@ -78,7 +79,7 @@ A plain object satisfies the contract as well. Nothing here asks for a class.
 
 ```ts
 const actor: PlayActor<Snapshot, AuthEvent> = {
-	state: new Signal.State<Snapshot>({ value: "guest" }),
+	state: createAtom<Snapshot>({ value: "guest" }),
 	send: () => {},
 };
 ```
@@ -97,15 +98,14 @@ actor class of its own engine, and the contract stays out of the inheritance.
 ```ts
 import type { PlayActor } from "@xmachines/play-actor";
 import type { Routable } from "@xmachines/play-router";
-import { Signal } from "@xmachines/play-signals";
 import { Actor, type AnyActorLogic } from "xstate";
 
 class MyRoutableActor
 	extends Actor<AnyActorLogic>
 	implements PlayActor<unknown, { readonly type: string }>, Routable
 {
-	readonly state = new Signal.State<unknown>({});
-	readonly currentRoute = new Signal.Computed<string | null>(() => null);
+	readonly state = createAtom<unknown>({});
+	readonly currentRoute = createAtom<string | null>(() => null);
 	readonly initialRoute = "/";
 }
 ```

package/dist/play-actor.d.ts

@@ -3,7 +3,7 @@
  *
  * An actor of XMachines holds exactly two things, and this file names both:
  *
- * - `state`: the reactive snapshot, as a TC39 Signal
+ * - `state`: the reactive snapshot, as an atom
  * - `send`: the typed event dispatch
  *
  * It names NO engine. A state machine library is the concern of an adapter, and
@@ -24,7 +24,7 @@
  * @packageDocumentation
  * @see [Play RFC](../../docs/rfc/play.md)
  */
-import type { Signal } from "@xmachines/play-signals";
+import type { Atom } from "@xmachines/play-atom";
 /**
  * The minimal shape of an event that an actor receives.
  *
@@ -44,7 +44,7 @@ export interface ActorEvent {
  * of an adapter, and `@xmachines/play-xstate` is the adapter of XState v5.
  *
  * Both type parameters carry their real type through, and neither one erases it.
- * `AbstractActor` declares `Signal.State<unknown>`, so every consumer of a snapshot reads
+ * `AbstractActor` declares `Atom<unknown>`, so every consumer of a snapshot reads
  * `unknown` and asserts its way back.
  *
  * A capability is optional, and each one lives with the package that holds its shared
@@ -73,10 +73,10 @@ export interface PlayActor<TSnapshot = unknown, TEvent extends ActorEvent = Acto
     /**
      * The reactive snapshot of the current actor state.
      *
-     * The infrastructure observes this signal, and it reacts to each state change. It
+     * The infrastructure observes this atom, and it reacts to each state change. It
      * therefore holds no coupling to the internal state machine of the actor.
      */
-    readonly state: Signal.State<TSnapshot>;
+    readonly state: Atom<TSnapshot>;
     /**
      * Sends an event to the actor.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"play-actor.d.ts","sourceRoot":"","sources":["../src/play-actor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEtD;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,WAAW,SAAS,CAAC,SAAS,GAAG,OAAO,EAAE,MAAM,SAAS,UAAU,GAAG,UAAU;IACrF;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAExC;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B"}
+{"version":3,"file":"play-actor.d.ts","sourceRoot":"","sources":["../src/play-actor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAEjD;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,WAAW,SAAS,CAAC,SAAS,GAAG,OAAO,EAAE,MAAM,SAAS,UAAU,GAAG,UAAU;IACrF;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IAEhC;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B"}

package/dist/play-actor.js

@@ -3,7 +3,7 @@
  *
  * An actor of XMachines holds exactly two things, and this file names both:
  *
- * - `state`: the reactive snapshot, as a TC39 Signal
+ * - `state`: the reactive snapshot, as an atom
  * - `send`: the typed event dispatch
  *
  * It names NO engine. A state machine library is the concern of an adapter, and

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@xmachines/play-actor",
-  "version": "4.0.0",
+  "version": "5.0.1",
   "private": false,
   "description": "The actor contract of the Play Architecture: state and send. It names no state machine library",
   "keywords": [
     "actor",
+    "atoms",
     "play-architecture",
-    "signals",
     "xmachines",
     "xstate"
   ],
@@ -50,16 +50,16 @@
   "devDependencies": {
     "@testing-library/jest-dom": "^7.0.1",
     "@types/node": "^26.6.2",
-    "@xmachines/play": "4.0.0",
-    "@xmachines/play-signals": "4.0.0",
-    "oxfmt": "^0.68.0",
-    "oxlint": "^1.83.0",
+    "@xmachines/play": "5.0.1",
+    "@xmachines/play-atom": "5.0.1",
+    "oxfmt": "^0.70.0",
+    "oxlint": "^1.85.0",
     "vite": "^8.3.0",
     "vitest": "^5.0.1",
     "xstate": "^5.33.0"
   },
   "peerDependencies": {
-    "@xmachines/play-signals": "4.0.0"
+    "@xmachines/play-atom": "5.0.1"
   },
   "engines": {
     "node": ">=24.0.0"