@xmachines/play-atom 5.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mikael Karon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,194 @@
+# @xmachines/play-atom
+
+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.0-blue)](https://www.npmjs.com/package/@xmachines/play-atom)
+
+## Installation
+
+```bash
+pnpm add @xmachines/play-atom @xmachines/play @xstate/store
+```
+
+**Peer dependencies.** Install them 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).
+
+## Overview
+
+This package DECLARES the reactive contract of the Play Architecture, and it binds an engine to that contract in one module. The engine of today is [`@xstate/store`](https://stately.ai/docs/xstate-store), whose reactive core adapts the [Alien Signals](https://github.com/stackblitz/alien-signals) algorithm. It adds the `watchAtom` utility, which owns the subscription lifecycle, and `createWritableAtom`, which removes an overload hazard for a generic value type.
+
+The types belong to THIS package. `Atom`, `Readable` and each name beside them are declarations here, and no forward of a type of the engine. Therefore the published `.d.ts` of a consumer names the engine never, and a change of the engine reaches this package alone.
+
+**Import every atom in the XMachines ecosystem from this package**, and not from `@xstate/store`. One import point keeps each update and each API change in one place.
+
+## Usage
+
+### `createAtom(value)` — writable reactive state
+
+```typescript
+import { createAtom } from "@xmachines/play-atom";
+
+const count = createAtom(0);
+
+console.log(count.get()); // 0
+count.set(5);
+count.set((previous) => previous + 1);
+console.log(count.get()); // 6
+```
+
+### `createAtom(fn)` — memoized derived values
+
+```typescript
+import { createAtom } from "@xmachines/play-atom";
+
+const count = createAtom(0);
+const doubled = createAtom(() => count.get() * 2);
+
+console.log(doubled.get()); // 0  (computed on first access)
+count.set(5);
+console.log(doubled.get()); // 10 (recomputed because dependency changed)
+console.log(doubled.get()); // 10 (memoized — no recomputation)
+```
+
+A computation tracks each atom that it reads. A dynamic branch is safe: the computation keeps only the atoms of the _current_ execution path as its dependencies.
+
+The getter takes ONE parameter: the value that the atom holds already. It is `undefined` before the first derivation. Return it to keep the atom still, which stops the propagation at this atom:
+
+```typescript
+const view = createAtom((previous) => {
+	const next = derive(source.get());
+	return equivalent(previous, next) ? (previous ?? null) : next;
+});
+```
+
+> A computed atom that something SUBSCRIBES to is eager. `@xstate/store` builds a subscription on an effect that reads the atom, so a write to a dependency evaluates the derivation at once, inside that write. A computed atom with no subscriber stays lazy.
+
+### `createWritableAtom(value)` — the writable atom, with one signature
+
+`createAtom` carries two signatures, and TypeScript must prove the argument is not a function before it reaches the writable one. For a concrete type it proves that at once. For a type parameter, or a conditional type over one, it cannot, so it picks the computed signature and returns a `ReadonlyAtom` that carries no `set`.
+
+```typescript
+import { createWritableAtom, type Atom } from "@xmachines/play-atom";
+
+class Holder<T extends { value: unknown }> {
+	public readonly state: Atom<T["value"]>;
+
+	constructor(seed: T["value"]) {
+		// createAtom(seed) would give a ReadonlyAtom here.
+		this.state = createWritableAtom(seed);
+	}
+}
+```
+
+Use `createAtom` everywhere else.
+
+### `watchAtom` — the coalesced subscription
+
+Use `watchAtom` to subscribe to an `Atom` or to a `ReadonlyAtom`. The callback receives the value after each change. `watchAtom` groups the updates of one synchronous batch into a single microtask.
+
+```typescript
+import { createAtom, watchAtom } from "@xmachines/play-atom";
+
+const count = createAtom(0);
+
+const cleanup = watchAtom(count, (value) => {
+	console.log("count changed:", value);
+});
+
+count.set(1); // coalesced with any rapid synchronous changes
+count.set(2);
+count.set(3); // → logs "count changed: 3" once, from a microtask
+
+// Stop watching
+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.
+
+### `atom.subscribe` — synchronous observation
+
+Every atom carries `subscribe`. The observer runs SYNCHRONOUSLY, inside the `set` of the atom that changed, and nothing coalesces the calls. An observer that throws therefore throws inside that `set`, and the failure lands in the code that wrote the atom. Prefer `watchAtom` unless you need the notification at the exact moment of the write.
+
+```typescript
+const subscription = count.subscribe((value) => console.log(value));
+subscription.unsubscribe();
+```
+
+### Custom equality
+
+`createAtom` accepts a `compare` option. It controls when an atom notifies its dependents. The default is `Object.is`.
+
+```typescript
+import { createAtom } from "@xmachines/play-atom";
+import type { AtomOptions } from "@xmachines/play-atom";
+
+const options: AtomOptions<{ name: string; age: number }> = {
+	compare: (a, b) => a.name === b.name && a.age === b.age,
+};
+
+const person = createAtom({ name: "Alice", age: 30 }, options);
+// A structurally identical value does not notify the dependents
+person.set({ name: "Alice", age: 30 });
+```
+
+## One instance
+
+`@xstate/store` holds the active subscriber in a variable of its own module. Two copies in one application build two separate graphs: a computed atom of the first copy and a subscription of the second copy never meet, the subscriber stays silent, and no error reports the fault. Every propagation of state in this architecture goes through an atom, so the second copy stops the whole reactivity of an application.
+
+This package therefore declares `@xstate/store` as a peer dependency. A renderer declares it no more: a renderer imports the engine in no source file, and it reads the atom through this package. Bring one copy, and bring it yourself.
+
+## 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) |
+
+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.
+
+## Migrating from `@xmachines/play-signals`
+
+This package replaces `@xmachines/play-signals`, which wrapped the TC39 Signals polyfill. A codemod rewrites the call sites:
+
+```bash
+curl -O https://gitlab.com/xmachin-es/xmachines-js/-/raw/main/scripts/codemod-play-atom.mjs
+node codemod-play-atom.mjs --dry-run .
+```
+
+See [Migrating to @xmachines/play-atom](../docs/contributing/migrating-to-play-atom.md) for the name table and the three behaviour changes that no codemod can make for you.
+
+## Requirements
+
+- **Node.js** `>= 24.0.0`
+- **TypeScript** `5.7+` (for a consumer that uses TypeScript)
+- **`@xstate/store`** `^4.2.3` — the atom engine, and a PEER dependency
+
+XMachines 5.0.0 moved the engine from `@xstate/store` 3 to 4. A computed getter took a `read` helper in its first position there, and it takes the previous value alone now. Delete that first parameter:
+
+```diff
+-const derived = createAtom((_read, previous) => …);
++const derived = createAtom((previous) => …);
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/dist/create-atom.d.ts

@@ -0,0 +1,45 @@
+import type { AsyncAtomOptions, AsyncAtomState, Atom, AtomOptions, ReadonlyAtom } from "./types.js";
+/**
+ * The two forms of `createAtom`
+ *
+ * A function argument builds a COMPUTED atom, which reads its dependencies and gives a
+ * `ReadonlyAtom`. Any other argument builds a WRITABLE atom, which holds the value and
+ * gives an `Atom`.
+ *
+ * A computed getter reads each dependency with the `get` of that dependency, and the
+ * engine records the edge as it reads. Its one parameter is the PREVIOUS value, which is
+ * `undefined` on the first derivation. `@xstate/store` 3 passed a `read` helper in that
+ * first position and the previous value in the second; version 4 dropped the helper,
+ * because `get` tracked the edge already.
+ */
+export interface CreateAtom {
+    <T>(getValue: (previous?: T) => T, options?: AtomOptions<T>): ReadonlyAtom<T>;
+    <T>(initialValue: T, options?: AtomOptions<T>): Atom<T>;
+}
+/**
+ * Builds a writable atom from a value, and a computed atom from a function
+ *
+ * @example
+ * ```typescript
+ * const count = createAtom(0);
+ * const doubled = createAtom(() => count.get() * 2);
+ * ```
+ */
+export declare const createAtom: CreateAtom;
+/**
+ * Builds a read-only atom that holds the state of a promise
+ *
+ * The atom starts at `pending`, and it moves to `done` or to `error`.
+ *
+ * The getter receives an `AbortSignal`. The engine aborts it when the atom derives again
+ * before the run settles, so a stale answer reaches the atom never. A getter that needs no
+ * signal takes no parameter.
+ *
+ * @example
+ * ```typescript
+ * const user = createAsyncAtom(() => fetch("/me").then((response) => response.json()));
+ * if (user.get().status === "done") console.log("ready");
+ * ```
+ */
+export declare const createAsyncAtom: <T>(getValue: (options: AsyncAtomOptions) => Promise<T>, options?: AtomOptions<AsyncAtomState<T>>) => ReadonlyAtom<AsyncAtomState<T>>;
+//# sourceMappingURL=create-atom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-atom.d.ts","sourceRoot":"","sources":["../src/create-atom.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEpG;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,UAAU;IAC1B,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IAC9E,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;CACxD;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,EAAE,UAA6B,CAAC;AAEvD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,CAAC,CAAC,EACnD,OAAO,CAAC,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,KACpC,YAAY,CAAC,cAAc,CAAC,CAAC,CAAC,CAAyB,CAAC"}

package/dist/create-atom.js

@@ -0,0 +1,40 @@
+/**
+ * The constructors of an atom, bound to the vocabulary of this package
+ *
+ * The module imports the engine, and it gives back the SAME functions under the types
+ * of `./types.js`. It adds no wrapper at runtime: a binding of a constant costs
+ * nothing, and the identity of the function stays the identity of the engine.
+ *
+ * The declaration is what matters. Without it, `createAtom` carries the return type of
+ * the engine, and every `.d.ts` that holds an atom names `@xstate/store`. A consumer
+ * then needs that manifest entry to compile, and a change of the engine becomes a
+ * breaking change of nineteen packages. With it, the name of the engine stops here.
+ */
+import { createAsyncAtom as createEngineAsyncAtom, createAtom as createEngineAtom, } from "@xstate/store";
+/**
+ * Builds a writable atom from a value, and a computed atom from a function
+ *
+ * @example
+ * ```typescript
+ * const count = createAtom(0);
+ * const doubled = createAtom(() => count.get() * 2);
+ * ```
+ */
+export const createAtom = createEngineAtom;
+/**
+ * Builds a read-only atom that holds the state of a promise
+ *
+ * The atom starts at `pending`, and it moves to `done` or to `error`.
+ *
+ * The getter receives an `AbortSignal`. The engine aborts it when the atom derives again
+ * before the run settles, so a stale answer reaches the atom never. A getter that needs no
+ * signal takes no parameter.
+ *
+ * @example
+ * ```typescript
+ * const user = createAsyncAtom(() => fetch("/me").then((response) => response.json()));
+ * if (user.get().status === "done") console.log("ready");
+ * ```
+ */
+export const createAsyncAtom = createEngineAsyncAtom;
+//# sourceMappingURL=create-atom.js.map

package/dist/create-atom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-atom.js","sourceRoot":"","sources":["../src/create-atom.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EACN,eAAe,IAAI,qBAAqB,EACxC,UAAU,IAAI,gBAAgB,GAC9B,MAAM,eAAe,CAAC;AAsBvB;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,UAAU,GAAe,gBAAgB,CAAC;AAEvD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,eAAe,GAGW,qBAAqB,CAAC"}

package/dist/create-writable-atom.d.ts

@@ -0,0 +1,49 @@
+import type { Atom, AtomOptions } from "./types.js";
+/**
+ * Builds a WRITABLE atom, and never a computed one.
+ *
+ * `createAtom` carries two signatures: a function argument builds a computed atom, and
+ * a value argument builds a writable one. TypeScript reads the signatures in order, so
+ * it needs to prove that the argument is NOT a function before it reaches the second
+ * one. For a concrete type it proves that at once, and `createAtom` is then the right
+ * call.
+ *
+ * For an UNRESOLVED type the proof fails. `ReturnType<TMachine["transition"]>` inside a
+ * generic class is a conditional type that TypeScript cannot evaluate yet, so it cannot
+ * rule a function out, it picks the first signature, and the call returns a
+ * `ReadonlyAtom` that carries no `set`. The error arrives at the assignment, and it
+ * names a type that the reader never wrote.
+ *
+ * This function states the one signature. The assignment below checks that the
+ * signature belongs to `createAtom`, so the two stay in step and no cast hides a
+ * mistake.
+ *
+ * Use `createAtom` everywhere else. Reach for this function when the value type is a
+ * type parameter, or a conditional type over one.
+ *
+ * A CAUTION: the signature states ONE overload, and the implementation is `createAtom`
+ * itself, which reads a FUNCTION argument as a computed atom. A `T` that a function
+ * satisfies therefore gets a `ReadonlyAtom` at run time while the type says `Atom`, and
+ * the first `set` call throws. Hold a function in a wrapper — `createWritableAtom({ fn })`
+ * — as the value types of this workspace already do.
+ *
+ * @param initialValue - The first value of the atom. It must not be a function.
+ * @param options - The optional `compare` function. The default is `Object.is`.
+ * @returns The writable atom.
+ *
+ * @example
+ * ```typescript
+ * import { createWritableAtom, type Atom } from "@xmachines/play-atom";
+ *
+ * class Holder<T extends { value: unknown }> {
+ *   // `createAtom(seed)` would give a ReadonlyAtom<T["value"]> here.
+ *   public readonly state: Atom<T["value"]>;
+ *
+ *   constructor(seed: T["value"]) {
+ *     this.state = createWritableAtom(seed);
+ *   }
+ * }
+ * ```
+ */
+export declare const createWritableAtom: <T>(initialValue: T, options?: AtomOptions<T>) => Atom<T>;
+//# sourceMappingURL=create-writable-atom.d.ts.map

package/dist/create-writable-atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-writable-atom.d.ts","sourceRoot":"","sources":["../src/create-writable-atom.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,kBAAkB,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAC9E,CAAC"}

package/dist/create-writable-atom.js

@@ -0,0 +1,49 @@
+import { createAtom } from "./create-atom.js";
+/**
+ * Builds a WRITABLE atom, and never a computed one.
+ *
+ * `createAtom` carries two signatures: a function argument builds a computed atom, and
+ * a value argument builds a writable one. TypeScript reads the signatures in order, so
+ * it needs to prove that the argument is NOT a function before it reaches the second
+ * one. For a concrete type it proves that at once, and `createAtom` is then the right
+ * call.
+ *
+ * For an UNRESOLVED type the proof fails. `ReturnType<TMachine["transition"]>` inside a
+ * generic class is a conditional type that TypeScript cannot evaluate yet, so it cannot
+ * rule a function out, it picks the first signature, and the call returns a
+ * `ReadonlyAtom` that carries no `set`. The error arrives at the assignment, and it
+ * names a type that the reader never wrote.
+ *
+ * This function states the one signature. The assignment below checks that the
+ * signature belongs to `createAtom`, so the two stay in step and no cast hides a
+ * mistake.
+ *
+ * Use `createAtom` everywhere else. Reach for this function when the value type is a
+ * type parameter, or a conditional type over one.
+ *
+ * A CAUTION: the signature states ONE overload, and the implementation is `createAtom`
+ * itself, which reads a FUNCTION argument as a computed atom. A `T` that a function
+ * satisfies therefore gets a `ReadonlyAtom` at run time while the type says `Atom`, and
+ * the first `set` call throws. Hold a function in a wrapper — `createWritableAtom({ fn })`
+ * — as the value types of this workspace already do.
+ *
+ * @param initialValue - The first value of the atom. It must not be a function.
+ * @param options - The optional `compare` function. The default is `Object.is`.
+ * @returns The writable atom.
+ *
+ * @example
+ * ```typescript
+ * import { createWritableAtom, type Atom } from "@xmachines/play-atom";
+ *
+ * class Holder<T extends { value: unknown }> {
+ *   // `createAtom(seed)` would give a ReadonlyAtom<T["value"]> here.
+ *   public readonly state: Atom<T["value"]>;
+ *
+ *   constructor(seed: T["value"]) {
+ *     this.state = createWritableAtom(seed);
+ *   }
+ * }
+ * ```
+ */
+export const createWritableAtom = createAtom;
+//# sourceMappingURL=create-writable-atom.js.map

package/dist/create-writable-atom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-writable-atom.js","sourceRoot":"","sources":["../src/create-writable-atom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAC9B,UAAU,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The atom primitives of the XMachines Play Architecture
+ *
+ * This package gives you the fine-grained reactive state primitives that carry every
+ * value across a boundary of the Play Architecture. It keeps the reactive primitive in
+ * one place, and it therefore protects the code from a change of the underlying
+ * library.
+ *
+ * **Architectural context:** the package implements **Atom-Only Reactivity (INV-03)**.
+ * It gives the reactive primitives that carry the communication from the Actor to the
+ * infrastructure, without a subscription of the consumer and without an event emitter.
+ * Every propagation of state in the Play Architecture uses an atom, which tracks each
+ * dependency and updates without a glitch.
+ *
+ * @packageDocumentation
+ * @module @xmachines/play-atom
+ *
+ * @example
+ * The basic use of an atom
+ * ```typescript
+ * import { createAtom, watchAtom } from "@xmachines/play-atom";
+ *
+ * // Create a writable atom
+ * const count = createAtom(0);
+ *
+ * // Create a computed atom
+ * const doubled = createAtom(() => count.get() * 2);
+ *
+ * // Observe the changes
+ * const stop = watchAtom(doubled, (value) => {
+ *   console.log("Count:", count.get(), "Doubled:", value);
+ * });
+ *
+ * count.set(5); // Logs: Count: 5 Doubled: 10
+ * ```
+ *
+ * @see [Play RFC](../../docs/rfc/play.md) - invariant INV-03
+ * @see {@link https://stately.ai/docs/xstate-store | XState Store}
+ *
+ * @remarks
+ * **The engine:** the atom comes from `@xstate/store`, whose reactive core adapts the
+ * Alien Signals algorithm. The algorithm resolves the diamond problem, it recomputes no
+ * value that no dependency changed, and it accepts an equality function of your own
+ * through the `compare` option.
+ *
+ * **The reason for the separation:** this dedicated package DECLARES the contract, and
+ * it binds the engine to that contract in one module. Therefore one place holds each
+ * new version, each change of the API, and the choice of the engine itself. A consumer
+ * names the engine in no import and in no manifest, so a change of the engine reaches
+ * this package alone.
+ *
+ * **`@xstate/store` is a PEER dependency, and it must resolve to ONE instance.** The
+ * library holds the active subscriber in a module variable. Two copies in one
+ * application track no dependency across a package boundary, and a computed atom then
+ * updates never.
+ */
+export { createAsyncAtom, createAtom } from "./create-atom.js";
+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

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

package/dist/index.js

@@ -0,0 +1,66 @@
+/**
+ * The atom primitives of the XMachines Play Architecture
+ *
+ * This package gives you the fine-grained reactive state primitives that carry every
+ * value across a boundary of the Play Architecture. It keeps the reactive primitive in
+ * one place, and it therefore protects the code from a change of the underlying
+ * library.
+ *
+ * **Architectural context:** the package implements **Atom-Only Reactivity (INV-03)**.
+ * It gives the reactive primitives that carry the communication from the Actor to the
+ * infrastructure, without a subscription of the consumer and without an event emitter.
+ * Every propagation of state in the Play Architecture uses an atom, which tracks each
+ * dependency and updates without a glitch.
+ *
+ * @packageDocumentation
+ * @module @xmachines/play-atom
+ *
+ * @example
+ * The basic use of an atom
+ * ```typescript
+ * import { createAtom, watchAtom } from "@xmachines/play-atom";
+ *
+ * // Create a writable atom
+ * const count = createAtom(0);
+ *
+ * // Create a computed atom
+ * const doubled = createAtom(() => count.get() * 2);
+ *
+ * // Observe the changes
+ * const stop = watchAtom(doubled, (value) => {
+ *   console.log("Count:", count.get(), "Doubled:", value);
+ * });
+ *
+ * count.set(5); // Logs: Count: 5 Doubled: 10
+ * ```
+ *
+ * @see [Play RFC](../../docs/rfc/play.md) - invariant INV-03
+ * @see {@link https://stately.ai/docs/xstate-store | XState Store}
+ *
+ * @remarks
+ * **The engine:** the atom comes from `@xstate/store`, whose reactive core adapts the
+ * Alien Signals algorithm. The algorithm resolves the diamond problem, it recomputes no
+ * value that no dependency changed, and it accepts an equality function of your own
+ * through the `compare` option.
+ *
+ * **The reason for the separation:** this dedicated package DECLARES the contract, and
+ * it binds the engine to that contract in one module. Therefore one place holds each
+ * new version, each change of the API, and the choice of the engine itself. A consumer
+ * names the engine in no import and in no manifest, so a change of the engine reaches
+ * this package alone.
+ *
+ * **`@xstate/store` is a PEER dependency, and it must resolve to ONE instance.** The
+ * library holds the active subscriber in a module variable. Two copies in one
+ * application track no dependency across a package boundary, and a computed atom then
+ * updates never.
+ */
+// The atom constructors, under the types that this package declares
+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

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

package/dist/types.d.ts

@@ -0,0 +1,165 @@
+/**
+ * The type definitions of the atom API
+ *
+ * This module DECLARES the vocabulary, and it re-exports the vocabulary of no other
+ * library. A consumer therefore reads the whole reactive contract of the Play
+ * Architecture from `@xmachines/play-atom`, and the published `.d.ts` of a consumer
+ * names the engine never.
+ *
+ * The declarations are structural, and they say the minimum that this architecture
+ * uses: `get`, `subscribe`, and `set`. The atom of `@xstate/store` satisfies each one,
+ * so `createAtom` returns a value that fits with no cast. A second engine that gives
+ * the same three members fits in the same way, and the seam therefore holds the choice
+ * of the engine inside this package.
+ *
+ * @see {@link https://stately.ai/docs/xstate-store | XState Store} - the engine of today
+ */
+/**
+ * The release of one subscription
+ *
+ * `subscribe` returns it. Call `unsubscribe` one time. A second call does nothing.
+ */
+export interface AtomSubscription {
+    unsubscribe(): void;
+}
+/**
+ * The observer of an atom, in the object form
+ *
+ * Each member is optional, so an observer of the value alone gives `next` alone. An
+ * atom completes never and it fails never, so `error` and `complete` stay for the
+ * consumers that adapt an atom to an observable.
+ */
+export interface AtomObserver<T> {
+    next?: (value: T) => void;
+    error?: (error: unknown) => void;
+    complete?: () => void;
+}
+/**
+ * The read side of an atom
+ *
+ * `Readable` holds `get()` and `subscribe()`. A function that only READS an atom takes
+ * this type, and it therefore accepts an `Atom`, a `ReadonlyAtom`, and a store
+ * selection alike.
+ *
+ * @example
+ * ```typescript
+ * import { createAtom, type Readable } from "@xmachines/play-atom";
+ *
+ * function show(source: Readable<string>): string {
+ *   return source.get();
+ * }
+ *
+ * show(createAtom("ready")); // "ready"
+ * ```
+ */
+export interface Readable<T> {
+    get(): T;
+    subscribe(observer: AtomObserver<T>): AtomSubscription;
+    subscribe(next: (value: T) => void, error?: (error: unknown) => void, complete?: () => void): AtomSubscription;
+}
+/**
+ * The common base of a writable atom and a computed atom
+ *
+ * Use it for a value that a caller reads and observes, when the caller must accept
+ * both kinds.
+ */
+export interface BaseAtom<T> extends Readable<T> {
+}
+/**
+ * The computed atom. It evaluates late, and it memoizes the result
+ *
+ * `createAtom` returns this type for a function argument. The atom tracks each
+ * dependency when it runs the function, and it runs the function again only after a
+ * dependency changes. The atom therefore tracks each dependency for you, and you
+ * manage no subscription.
+ *
+ * @example
+ * ```typescript
+ * import { createAtom } from "@xmachines/play-atom";
+ *
+ * const count = createAtom(0);
+ * const doubled = createAtom(() => count.get() * 2);
+ *
+ * console.log(doubled.get()); // 0
+ * count.set(5);
+ * console.log(doubled.get()); // 10 (the atom computed it again)
+ * console.log(doubled.get()); // 10 (from the memory, with no new computation)
+ * ```
+ */
+export interface ReadonlyAtom<T> extends BaseAtom<T> {
+}
+/**
+ * The writable atom. It holds one reactive value
+ *
+ * A `get()` call inside a computed atom or inside a subscription tracks the atom as a
+ * dependency. A `set()` call notifies every computation and every observer that
+ * depends on the atom. `set` accepts a value, and it accepts a function of the
+ * previous value.
+ *
+ * @example
+ * ```typescript
+ * import { createAtom } from "@xmachines/play-atom";
+ *
+ * const name = createAtom("Alice");
+ * console.log(name.get()); // "Alice"
+ * name.set("Bob");
+ * name.set((previous) => previous.toUpperCase()); // "BOB"
+ * ```
+ */
+export interface Atom<T> extends BaseAtom<T> {
+    /** Sets the value of the atom from the previous value. */
+    set(fn: (previous: T) => T): void;
+    /** Sets the value of the atom. */
+    set(value: T): void;
+}
+/**
+ * An atom of an unknown value type
+ *
+ * Use it for a collection that holds atoms of mixed types.
+ */
+export type AnyAtom = BaseAtom<unknown>;
+/**
+ * The options of `createAtom`
+ *
+ * `compare` decides if the value changed. The default is `Object.is`. An atom that
+ * compares equal notifies no observer.
+ *
+ * @example
+ * ```typescript
+ * import { createAtom } from "@xmachines/play-atom";
+ *
+ * const point = createAtom(
+ *   { x: 0, y: 0 },
+ *   { compare: (previous, next) => previous.x === next.x && previous.y === next.y },
+ * );
+ * ```
+ */
+export interface AtomOptions<T> {
+    compare?: (previous: T, next: T) => boolean;
+}
+/**
+ * The state of an atom that reads a promise
+ *
+ * `createAsyncAtom` holds this shape. Read `status` first, and the compiler then gives
+ * you `data` or `error`.
+ */
+export type AsyncAtomState<TData, TError = unknown> = {
+    status: "pending";
+} | {
+    status: "done";
+    data: TData;
+} | {
+    status: "error";
+    error: TError;
+};
+/**
+ * What `createAsyncAtom` gives its getter
+ *
+ * The engine aborts the signal when the atom derives again before the run settles, so a
+ * stale answer reaches the atom never. Pass it to `fetch`, and the request stops with it.
+ */
+export interface AsyncAtomOptions {
+    /** Aborted when the atom derives again before this run settles. */
+    readonly signal: AbortSignal;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAChC,WAAW,IAAI,IAAI,CAAC;CACpB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC9B,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC1B,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACjC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IAC1B,GAAG,IAAI,CAAC,CAAC;IACT,SAAS,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC;IACvD,SAAS,CACR,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EACxB,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,EAChC,QAAQ,CAAC,EAAE,MAAM,IAAI,GACnB,gBAAgB,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC;CAAG;AAEnD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC;CAAG;AAEvD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC;IAC3C,0DAA0D;IAC1D,GAAG,CAAC,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAClC,kCAAkC;IAClC,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;AAExC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC;IAC7B,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;CAC5C;AAED;;;;;GAKG;AACH,MAAM,MAAM,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,IAC/C;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAAE,GAC/B;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtC;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAChC,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC7B"}

package/dist/types.js

@@ -0,0 +1,24 @@
+/**
+ * The type definitions of the atom API
+ *
+ * This module DECLARES the vocabulary, and it re-exports the vocabulary of no other
+ * library. A consumer therefore reads the whole reactive contract of the Play
+ * Architecture from `@xmachines/play-atom`, and the published `.d.ts` of a consumer
+ * names the engine never.
+ *
+ * The declarations are structural, and they say the minimum that this architecture
+ * uses: `get`, `subscribe`, and `set`. The atom of `@xstate/store` satisfies each one,
+ * so `createAtom` returns a value that fits with no cast. A second engine that gives
+ * the same three members fits in the same way, and the seam therefore holds the choice
+ * of the engine inside this package.
+ *
+ * @see {@link https://stately.ai/docs/xstate-store | XState Store} - the engine of today
+ */
+export {};
+// `Observer`, `Subscribable` and `Subscription` carry no declaration here, and the two
+// names above carry the `Atom` prefix for the same reason. The three names are common,
+// and `@xstate/store` is not the only library that declares them: `xstate` declares
+// `Observer` and `Subscription` too, and `packages/play-xstate/src/player-actor.ts`
+// imports both. A plain name here therefore puts two declarations of one name in one
+// file.
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;;AA6JH,uFAAuF;AACvF,uFAAuF;AACvF,oFAAoF;AACpF,oFAAoF;AACpF,qFAAqF;AACrF,QAAQ"}

package/dist/watch-atom.d.ts

@@ -0,0 +1,58 @@
+import { type Cleanup } from "@xmachines/play";
+import type { Readable } from "./types.js";
+/**
+ * Subscribes to one atom, and coalesces the notifications into one microtask.
+ *
+ * `@xstate/store` notifies an observer SYNCHRONOUSLY from `set`. This function keeps
+ * that notification, and it defers the callback to a microtask. One batch of
+ * synchronous writes therefore calls the callback one time, with the last value. The
+ * cleanup function is idempotent.
+ *
+ * **The lifecycle:**
+ * - The `disposed` flag stops a callback after the cleanup: the microtask returns at
+ *   once when the cleanup runs before the microtask fires.
+ * - The `scheduled` guard removes the duplicates of rapid synchronous writes: one
+ *   batch of synchronous writes queues one microtask only.
+ * - The guard clears BEFORE the callback, and not after it. A callback that WRITES the
+ *   atom that it watches therefore schedules the next delivery, and it reaches the
+ *   caller with the value that it wrote. A callback that THROWS keeps the watch,
+ *   because the throw leaves the microtask and never reaches the subscription.
+ *
+ * The library owns the dependency edges. `@xstate/store` builds the subscription on an
+ * effect, and the effect holds ONE edge to the atom for the life of the watch. A caller
+ * therefore arms the watch one time, and no call site of this function counts emissions
+ * or re-arms anything.
+ *
+ * A CAUTION for a callback that writes the atom that it watches: the write reaches the
+ * callback, so a callback that writes a NEW value on every call runs again for ever,
+ * and the microtask queue drains never. That is the loop of the caller, and this
+ * 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:
+ *
+ * ```ts
+ * using stop = watchAtom(count, render);
+ * ```
+ *
+ * @param atom - The `Atom` or the `ReadonlyAtom` to subscribe to.
+ * @param onValue - The function reads the current atom value after each change.
+ * @returns The release. It removes the subscription.
+ *
+ * @example
+ * ```typescript
+ * import { createAtom, watchAtom } from "@xmachines/play-atom";
+ *
+ * const count = createAtom(0);
+ * const stop = watchAtom(count, (value) => console.log(value));
+ *
+ * count.set(1);
+ * count.set(2); // One microtask, and the callback reads 2 one time.
+ *
+ * stop();
+ * ```
+ */
+export declare function watchAtom<T>(atom: Readable<T>, onValue: (value: T) => void): Cleanup;
+//# sourceMappingURL=watch-atom.d.ts.map

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

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

package/dist/watch-atom.js

@@ -0,0 +1,84 @@
+import { asCleanup } from "@xmachines/play";
+/**
+ * Subscribes to one atom, and coalesces the notifications into one microtask.
+ *
+ * `@xstate/store` notifies an observer SYNCHRONOUSLY from `set`. This function keeps
+ * that notification, and it defers the callback to a microtask. One batch of
+ * synchronous writes therefore calls the callback one time, with the last value. The
+ * cleanup function is idempotent.
+ *
+ * **The lifecycle:**
+ * - The `disposed` flag stops a callback after the cleanup: the microtask returns at
+ *   once when the cleanup runs before the microtask fires.
+ * - The `scheduled` guard removes the duplicates of rapid synchronous writes: one
+ *   batch of synchronous writes queues one microtask only.
+ * - The guard clears BEFORE the callback, and not after it. A callback that WRITES the
+ *   atom that it watches therefore schedules the next delivery, and it reaches the
+ *   caller with the value that it wrote. A callback that THROWS keeps the watch,
+ *   because the throw leaves the microtask and never reaches the subscription.
+ *
+ * The library owns the dependency edges. `@xstate/store` builds the subscription on an
+ * effect, and the effect holds ONE edge to the atom for the life of the watch. A caller
+ * therefore arms the watch one time, and no call site of this function counts emissions
+ * or re-arms anything.
+ *
+ * A CAUTION for a callback that writes the atom that it watches: the write reaches the
+ * callback, so a callback that writes a NEW value on every call runs again for ever,
+ * and the microtask queue drains never. That is the loop of the caller, and this
+ * 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:
+ *
+ * ```ts
+ * using stop = watchAtom(count, render);
+ * ```
+ *
+ * @param atom - The `Atom` or the `ReadonlyAtom` to subscribe to.
+ * @param onValue - The function reads the current atom value after each change.
+ * @returns The release. It removes the subscription.
+ *
+ * @example
+ * ```typescript
+ * import { createAtom, watchAtom } from "@xmachines/play-atom";
+ *
+ * const count = createAtom(0);
+ * const stop = watchAtom(count, (value) => console.log(value));
+ *
+ * count.set(1);
+ * count.set(2); // One microtask, and the callback reads 2 one time.
+ *
+ * stop();
+ * ```
+ */
+export function watchAtom(atom, onValue) {
+    let disposed = false;
+    let scheduled = false;
+    const subscription = atom.subscribe(() => {
+        if (disposed || scheduled)
+            return;
+        scheduled = true;
+        queueMicrotask(() => {
+            if (disposed)
+                return;
+            // Clear the guard BEFORE the callback, and not after it. A callback that WRITES
+            // the atom notifies the subscription on that write — a renderer that gives its
+            // host an error handler, and the host repairs the actor from that handler. The
+            // guard must accept that notification at this moment. A line after the callback
+            // clears it too late: the write finds the guard still set, the observer drops
+            // the notification, and the line then clears the guard for a change that reaches
+            // nobody.
+            scheduled = false;
+            onValue(atom.get());
+        });
+    });
+    return asCleanup(() => {
+        if (disposed)
+            return;
+        disposed = true;
+        subscription.unsubscribe();
+    });
+}
+//# sourceMappingURL=watch-atom.js.map

package/dist/watch-atom.js.map

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

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@xmachines/play-atom",
+  "version": "5.0.0",
+  "private": false,
+  "description": "Atom primitives for XMachines - fine-grained reactive state on @xstate/store",
+  "keywords": [
+    "atom",
+    "reactive",
+    "state-management",
+    "xmachines",
+    "xstate"
+  ],
+  "homepage": "https://gitlab.com/xmachin-es/xmachines-js/tree/main/packages/play-atom",
+  "license": "MIT",
+  "author": "XMachines Contributors",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/xmachin-es/xmachines-js.git",
+    "directory": "packages/play-atom"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vite build && tsc --build",
+    "clean": "rm -rf dist *.tsbuildinfo coverage .vitest-attachments test/browser/__screenshots__ node_modules/.svelte2tsx-* node_modules/.vite*",
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "oxlint .",
+    "lint:security": "node ../../scripts/semgrep-scan.mjs",
+    "lint:fix": "oxlint --fix .",
+    "format": "oxfmt .",
+    "format:check": "oxfmt --check ."
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "^7.0.1",
+    "@types/node": "^26.6.2",
+    "@vitest/browser-playwright": "^5.0.1",
+    "@xmachines/play": "5.0.0",
+    "@xstate/store": "^4.2.3",
+    "oxfmt": "^0.70.0",
+    "oxlint": "^1.85.0",
+    "vite": "^8.3.0",
+    "vitest": "^5.0.1"
+  },
+  "peerDependencies": {
+    "@xmachines/play": "5.0.0",
+    "@xstate/store": "^4.2.3"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  }
+}