@xmachines/play-atom 5.0.2 → 6.0.0

package/README.md

@@ -2,17 +2,16 @@
 
 The atom primitives for XMachines. They give the Play Architecture fine-grained reactive state. The primitives propagate state without a glitch and without a subscription of the consumer.
 
-[![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.2-blue)](https://www.npmjs.com/package/@xmachines/play-atom)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-6.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-atom)
 
 ## Installation
 
 ```bash
-pnpm add @xmachines/play-atom @xmachines/play @xstate/store
+pnpm add @xmachines/play-atom @xstate/store
 ```
 
-**Peer dependencies.** Install them with the package:
+**Peer dependency.** Install it with the package:
 
-- [`@xmachines/play`](../play/README.md) — the core protocol. This package reads `asCleanup` and `Cleanup` from it.
 - `@xstate/store` `^4.2.3` — the atom engine.
 
 Install ONE copy of `@xstate/store` — see [One instance](#one-instance).
@@ -107,7 +106,7 @@ count.set(3); // → logs "count changed: 3" once, from a microtask
 cleanup();
 ```
 
-The cleanup function is idempotent. A second call is safe, and it does not throw. It is also a `Disposable`, so `using cleanup = watchAtom(...)` releases it at the end of the scope.
+The cleanup function is idempotent. A second call is safe, and it does not throw. It is a plain function. To release it at the end of a scope, publish it with `asDisposable` of [`@xmachines/core/utils`](../core/README.md): `using cleanup = asDisposable(watchAtom(...))`.
 
 ### `atom.subscribe` — synchronous observation
 
@@ -118,6 +117,18 @@ const subscription = count.subscribe((value) => console.log(value));
 subscription.unsubscribe();
 ```
 
+The subscription is the plain `{ unsubscribe }` of the engine. To hold it with `using`, publish it with `asDisposable` of [`@xmachines/core/utils`](../core/README.md):
+
+```typescript
+import { asDisposable } from "@xmachines/core/utils";
+
+{
+	const plain = count.subscribe((value) => console.log(value));
+	using subscription = asDisposable(plain, () => plain.unsubscribe());
+	count.set(1);
+} // the scope calls unsubscribe()
+```
+
 ### Custom equality
 
 `createAtom` accepts a `compare` option. It controls when an atom notifies its dependents. The default is `Object.is`.
@@ -143,25 +154,24 @@ This package therefore declares `@xstate/store` as a peer dependency. A renderer
 
 ## API Summary
 
-| Export                             | Kind      | Description                                                                                   |
-| ---------------------------------- | --------- | --------------------------------------------------------------------------------------------- |
-| `createAtom(value, options?)`      | function  | The writable atom                                                                             |
-| `createAtom(fn, options?)`         | function  | The computed atom                                                                             |
-| `createWritableAtom(value, opts?)` | function  | The writable atom, with one signature, for a generic value type                               |
-| `createAsyncAtom(fn, options?)`    | function  | The computed atom of a promise. It holds an `AsyncAtomState`. `fn` reads an `AbortSignal`     |
-| `watchAtom(atom, onValue)`         | function  | The coalesced subscription helper. It returns a `Cleanup`                                     |
-| `Atom<T>`                          | interface | The writable atom (`.get()`, `.set()`, `.subscribe()`)                                        |
-| `ReadonlyAtom<T>`                  | interface | The computed atom (`.get()`, `.subscribe()`)                                                  |
-| `Readable<T>`                      | interface | The read side of either one (`.get()`, `.subscribe()`)                                        |
-| `BaseAtom<T>`                      | interface | The common base of both kinds                                                                 |
-| `AnyAtom`                          | type      | An atom of an unknown value type                                                              |
-| `AtomOptions<T>`                   | interface | The options object of `createAtom` (`compare?`)                                               |
-| `AtomObserver<T>`                  | interface | The observer of `subscribe`, in the object form                                               |
-| `AtomSubscription`                 | interface | The release that `subscribe` returns                                                          |
-| `AsyncAtomState<TData>`            | type      | The state of `createAsyncAtom`: `pending`, `done`, or `error`                                 |
-| `AsyncAtomOptions`                 | interface | What `createAsyncAtom` hands its getter: the `signal` that aborts a stale run                 |
-| `CreateAtom`                       | interface | The two call signatures of `createAtom`                                                       |
-| `Cleanup`                          | type      | The release that `watchAtom` returns, re-exported from [`@xmachines/play`](../play/README.md) |
+| Export                             | Kind      | Description                                                                               |
+| ---------------------------------- | --------- | ----------------------------------------------------------------------------------------- |
+| `createAtom(value, options?)`      | function  | The writable atom                                                                         |
+| `createAtom(fn, options?)`         | function  | The computed atom                                                                         |
+| `createWritableAtom(value, opts?)` | function  | The writable atom, with one signature, for a generic value type                           |
+| `createAsyncAtom(fn, options?)`    | function  | The computed atom of a promise. It holds an `AsyncAtomState`. `fn` reads an `AbortSignal` |
+| `watchAtom(atom, onValue)`         | function  | The coalesced subscription helper. It returns a plain release                             |
+| `Atom<T>`                          | interface | The writable atom (`.get()`, `.set()`, `.subscribe()`)                                    |
+| `ReadonlyAtom<T>`                  | interface | The computed atom (`.get()`, `.subscribe()`)                                              |
+| `Readable<T>`                      | interface | The read side of either one (`.get()`, `.subscribe()`)                                    |
+| `BaseAtom<T>`                      | interface | The common base of both kinds                                                             |
+| `AnyAtom`                          | type      | An atom of an unknown value type                                                          |
+| `AtomOptions<T>`                   | interface | The options object of `createAtom` (`compare?`)                                           |
+| `AtomObserver<T>`                  | interface | The observer of `subscribe`, in the object form                                           |
+| `AtomSubscription`                 | interface | The release that `subscribe` returns                                                      |
+| `AsyncAtomState<TData>`            | type      | The state of `createAsyncAtom`: `pending`, `done`, or `error`                             |
+| `AsyncAtomOptions`                 | interface | What `createAsyncAtom` hands its getter: the `signal` that aborts a stale run             |
+| `CreateAtom`                       | interface | The two call signatures of `createAtom`                                                   |
 
 The observer types carry the `Atom` prefix on purpose: `xstate` declares `Observer` and `Subscription` too, so a plain name here would put two declarations of one name in one file. `Subscribable` stays out of the surface for the same reason.
 

package/dist/index.d.ts

@@ -59,5 +59,4 @@ export { createWritableAtom } from "./create-writable-atom.js";
 export { watchAtom } from "./watch-atom.js";
 export type { CreateAtom } from "./create-atom.js";
 export type { AnyAtom, AsyncAtomOptions, AsyncAtomState, Atom, AtomObserver, AtomOptions, AtomSubscription, BaseAtom, Readable, ReadonlyAtom, } from "./types.js";
-export { type Cleanup } from "@xmachines/play";
 //# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAGH,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI5C,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,YAAY,EACX,OAAO,EACP,gBAAgB,EAChB,cAAc,EACd,IAAI,EACJ,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,QAAQ,EACR,QAAQ,EACR,YAAY,GACZ,MAAM,YAAY,CAAC;AAKpB,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAGH,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI5C,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,YAAY,EACX,OAAO,EACP,gBAAgB,EAChB,cAAc,EACd,IAAI,EACJ,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,QAAQ,EACR,QAAQ,EACR,YAAY,GACZ,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -58,9 +58,4 @@
 export { createAsyncAtom, createAtom } from "./create-atom.js";
 export { createWritableAtom } from "./create-writable-atom.js";
 export { watchAtom } from "./watch-atom.js";
-// The release protocol of @xmachines/play. This package's own published `.d.ts` names
-// exactly these, so a consumer reads them from here and needs no second manifest
-// entry. It names `asCleanup` nowhere: a consumer of this package RECEIVES a
-// release, and builds one only with @xmachines/play itself.
-export {} from "@xmachines/play";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,oEAAoE;AACpE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAiB5C,sFAAsF;AACtF,iFAAiF;AACjF,6EAA6E;AAC7E,4DAA4D;AAC5D,OAAO,EAAgB,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,oEAAoE;AACpE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/watch-atom.d.ts

@@ -1,4 +1,3 @@
-import { type Cleanup } from "@xmachines/play";
 import type { Readable } from "./types.js";
 /**
  * Subscribes to one atom, and coalesces the notifications into one microtask.
@@ -29,12 +28,12 @@ import type { Readable } from "./types.js";
  * function bounds it not. A write of the SAME value ends the sequence by itself,
  * because an atom notifies for a value that it holds already never.
  *
- * The return is a {@link Cleanup}: a function, and a `Disposable`. A caller that keeps
- * the release in a field and runs it from a teardown keeps that code. A caller inside
- * one scope writes `using` and writes no teardown:
+ * The return is a plain function. A caller that keeps the release in a field runs it
+ * from a teardown. A caller inside one scope publishes it with `asDisposable` of
+ * `@xmachines/core/utils`, writes `using`, and writes no teardown:
  *
  * ```ts
- * using stop = watchAtom(count, render);
+ * using stop = asDisposable(watchAtom(count, render));
  * ```
  *
  * @param atom - The `Atom` or the `ReadonlyAtom` to subscribe to.
@@ -54,5 +53,5 @@ import type { Readable } from "./types.js";
  * stop();
  * ```
  */
-export declare function watchAtom<T>(atom: Readable<T>, onValue: (value: T) => void): Cleanup;
+export declare function watchAtom<T>(atom: Readable<T>, onValue: (value: T) => void): () => void;
 //# sourceMappingURL=watch-atom.d.ts.map

package/dist/watch-atom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch-atom.d.ts","sourceRoot":"","sources":["../src/watch-atom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,OAAO,CA0BpF"}
+{"version":3,"file":"watch-atom.d.ts","sourceRoot":"","sources":["../src/watch-atom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CA0BvF"}

package/dist/watch-atom.js

@@ -1,4 +1,3 @@
-import { asCleanup } from "@xmachines/play";
 /**
  * Subscribes to one atom, and coalesces the notifications into one microtask.
  *
@@ -28,12 +27,12 @@ import { asCleanup } from "@xmachines/play";
  * function bounds it not. A write of the SAME value ends the sequence by itself,
  * because an atom notifies for a value that it holds already never.
  *
- * The return is a {@link Cleanup}: a function, and a `Disposable`. A caller that keeps
- * the release in a field and runs it from a teardown keeps that code. A caller inside
- * one scope writes `using` and writes no teardown:
+ * The return is a plain function. A caller that keeps the release in a field runs it
+ * from a teardown. A caller inside one scope publishes it with `asDisposable` of
+ * `@xmachines/core/utils`, writes `using`, and writes no teardown:
  *
  * ```ts
- * using stop = watchAtom(count, render);
+ * using stop = asDisposable(watchAtom(count, render));
  * ```
  *
  * @param atom - The `Atom` or the `ReadonlyAtom` to subscribe to.
@@ -74,11 +73,11 @@ export function watchAtom(atom, onValue) {
             onValue(atom.get());
         });
     });
-    return asCleanup(() => {
+    return () => {
         if (disposed)
             return;
         disposed = true;
         subscription.unsubscribe();
-    });
+    };
 }
 //# sourceMappingURL=watch-atom.js.map

package/dist/watch-atom.js.map

@@ -1 +1 @@
-{"version":3,"file":"watch-atom.js","sourceRoot":"","sources":["../src/watch-atom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAgB,MAAM,iBAAiB,CAAC;AAG1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,UAAU,SAAS,CAAI,IAAiB,EAAE,OAA2B;IAC1E,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,IAAI,SAAS,GAAG,KAAK,CAAC;IAEtB,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE;QACxC,IAAI,QAAQ,IAAI,SAAS;YAAE,OAAO;QAClC,SAAS,GAAG,IAAI,CAAC;QACjB,cAAc,CAAC,GAAG,EAAE;YACnB,IAAI,QAAQ;gBAAE,OAAO;YACrB,gFAAgF;YAChF,+EAA+E;YAC/E,+EAA+E;YAC/E,gFAAgF;YAChF,8EAA8E;YAC9E,iFAAiF;YACjF,UAAU;YACV,SAAS,GAAG,KAAK,CAAC;YAClB,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,OAAO,SAAS,CAAC,GAAG,EAAE;QACrB,IAAI,QAAQ;YAAE,OAAO;QACrB,QAAQ,GAAG,IAAI,CAAC;QAChB,YAAY,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC,CAAC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"watch-atom.js","sourceRoot":"","sources":["../src/watch-atom.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,UAAU,SAAS,CAAI,IAAiB,EAAE,OAA2B;IAC1E,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,IAAI,SAAS,GAAG,KAAK,CAAC;IAEtB,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE;QACxC,IAAI,QAAQ,IAAI,SAAS;YAAE,OAAO;QAClC,SAAS,GAAG,IAAI,CAAC;QACjB,cAAc,CAAC,GAAG,EAAE;YACnB,IAAI,QAAQ;gBAAE,OAAO;YACrB,gFAAgF;YAChF,+EAA+E;YAC/E,+EAA+E;YAC/E,gFAAgF;YAChF,8EAA8E;YAC9E,iFAAiF;YACjF,UAAU;YACV,SAAS,GAAG,KAAK,CAAC;YAClB,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,OAAO,GAAG,EAAE;QACX,IAAI,QAAQ;YAAE,OAAO;QACrB,QAAQ,GAAG,IAAI,CAAC;QAChB,YAAY,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-atom",
-  "version": "5.0.2",
+  "version": "6.0.0",
   "private": false,
   "description": "Atom primitives for XMachines - fine-grained reactive state on @xstate/store",
   "keywords": [
@@ -52,7 +52,6 @@
     "@testing-library/jest-dom": "^7.0.1",
     "@types/node": "^26.6.2",
     "@vitest/browser-playwright": "^5.0.1",
-    "@xmachines/play": "5.0.2",
     "@xstate/store": "^4.2.3",
     "oxfmt": "^0.70.0",
     "oxlint": "^1.85.0",
@@ -60,7 +59,6 @@
     "vitest": "^5.0.1"
   },
   "peerDependencies": {
-    "@xmachines/play": "5.0.2",
     "@xstate/store": "^4.2.3"
   },
   "engines": {