@xmachines/docs 4.0.0 → 5.0.0

package/api/@xmachines/play-atom/README.md

@@ -0,0 +1,281 @@
+[API](../../README.md) / @xmachines/play-atom
+
+# @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](../../../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).
+
+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.
+
+## 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](../../../rfc/play.md) - invariant INV-03
+- [XState Store](https://stately.ai/docs/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.
+
+## Interfaces
+
+- [AsyncAtomOptions](interfaces/AsyncAtomOptions.md)
+- [Atom](interfaces/Atom.md)
+- [AtomObserver](interfaces/AtomObserver.md)
+- [AtomOptions](interfaces/AtomOptions.md)
+- [AtomSubscription](interfaces/AtomSubscription.md)
+- [BaseAtom](interfaces/BaseAtom.md)
+- [CreateAtom](interfaces/CreateAtom.md)
+- [Readable](interfaces/Readable.md)
+- [ReadonlyAtom](interfaces/ReadonlyAtom.md)
+
+## Type Aliases
+
+- [AnyAtom](type-aliases/AnyAtom.md)
+- [AsyncAtomState](type-aliases/AsyncAtomState.md)
+- [Cleanup](type-aliases/Cleanup.md)
+
+## Variables
+
+- [createAsyncAtom](variables/createAsyncAtom.md)
+- [createAtom](variables/createAtom.md)
+- [createWritableAtom](variables/createWritableAtom.md)
+
+## Functions
+
+- [watchAtom](functions/watchAtom.md)

package/api/@xmachines/play-atom/functions/watchAtom.md

@@ -0,0 +1,79 @@
+[API](../../../README.md) / [@xmachines/play-atom](../README.md) / watchAtom
+
+# Function: watchAtom()
+
+```ts
+function watchAtom<T>(atom, onValue): Cleanup;
+```
+
+Defined in: [play-atom/src/watch-atom.ts:58](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/watch-atom.ts#L58)
+
+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 [Cleanup](../type-aliases/Cleanup.md): 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);
+```
+
+## Type Parameters
+
+| Type Parameter |
+| -------------- |
+| `T`            |
+
+## Parameters
+
+| Parameter | Type                                           | Description                                                  |
+| --------- | ---------------------------------------------- | ------------------------------------------------------------ |
+| `atom`    | [`Readable`](../interfaces/Readable.md)\<`T`\> | The `Atom` or the `ReadonlyAtom` to subscribe to.            |
+| `onValue` | (`value`) => `void`                            | The function reads the current atom value after each change. |
+
+## Returns
+
+[`Cleanup`](../type-aliases/Cleanup.md)
+
+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();
+```

package/api/@xmachines/play-atom/interfaces/AsyncAtomOptions.md

@@ -0,0 +1,16 @@
+[API](../../../README.md) / [@xmachines/play-atom](../README.md) / AsyncAtomOptions
+
+# Interface: AsyncAtomOptions
+
+Defined in: [play-atom/src/types.ts:168](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L168)
+
+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.
+
+## Properties
+
+| Property                              | Modifier   | Type          | Description                                                  | Defined in                                                                                                                  |
+| ------------------------------------- | ---------- | ------------- | ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-signal"></a> `signal` | `readonly` | `AbortSignal` | Aborted when the atom derives again before this run settles. | [play-atom/src/types.ts:170](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L170) |

package/api/@xmachines/play-atom/interfaces/Atom.md

@@ -0,0 +1,149 @@
+[API](../../../README.md) / [@xmachines/play-atom](../README.md) / Atom
+
+# Interface: Atom\<T\>
+
+Defined in: [play-atom/src/types.ts:117](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L117)
+
+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"
+```
+
+## Extends
+
+- [`BaseAtom`](BaseAtom.md)\<`T`\>
+
+## Type Parameters
+
+| Type Parameter |
+| -------------- |
+| `T`            |
+
+## Methods
+
+### get()
+
+```ts
+get(): T;
+```
+
+Defined in: [play-atom/src/types.ts:59](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L59)
+
+#### Returns
+
+`T`
+
+#### Inherited from
+
+[`BaseAtom`](BaseAtom.md).[`get`](BaseAtom.md#get)
+
+---
+
+### set()
+
+#### Call Signature
+
+```ts
+set(fn): void;
+```
+
+Defined in: [play-atom/src/types.ts:119](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L119)
+
+Sets the value of the atom from the previous value.
+
+##### Parameters
+
+| Parameter | Type                |
+| --------- | ------------------- |
+| `fn`      | (`previous`) => `T` |
+
+##### Returns
+
+`void`
+
+#### Call Signature
+
+```ts
+set(value): void;
+```
+
+Defined in: [play-atom/src/types.ts:121](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L121)
+
+Sets the value of the atom.
+
+##### Parameters
+
+| Parameter | Type |
+| --------- | ---- |
+| `value`   | `T`  |
+
+##### Returns
+
+`void`
+
+---
+
+### subscribe()
+
+#### Call Signature
+
+```ts
+subscribe(observer): AtomSubscription;
+```
+
+Defined in: [play-atom/src/types.ts:60](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L60)
+
+##### Parameters
+
+| Parameter  | Type                                     |
+| ---------- | ---------------------------------------- |
+| `observer` | [`AtomObserver`](AtomObserver.md)\<`T`\> |
+
+##### Returns
+
+[`AtomSubscription`](AtomSubscription.md)
+
+##### Inherited from
+
+[`BaseAtom`](BaseAtom.md).[`subscribe`](BaseAtom.md#subscribe)
+
+#### Call Signature
+
+```ts
+subscribe(
+   next,
+   error?,
+   complete?
+): AtomSubscription;
+```
+
+Defined in: [play-atom/src/types.ts:61](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L61)
+
+##### Parameters
+
+| Parameter   | Type                |
+| ----------- | ------------------- |
+| `next`      | (`value`) => `void` |
+| `error?`    | (`error`) => `void` |
+| `complete?` | () => `void`        |
+
+##### Returns
+
+[`AtomSubscription`](AtomSubscription.md)
+
+##### Inherited from
+
+[`BaseAtom`](BaseAtom.md).[`subscribe`](BaseAtom.md#subscribe)

package/api/@xmachines/play-atom/interfaces/AtomObserver.md

@@ -0,0 +1,25 @@
+[API](../../../README.md) / [@xmachines/play-atom](../README.md) / AtomObserver
+
+# Interface: AtomObserver\<T\>
+
+Defined in: [play-atom/src/types.ts:34](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L34)
+
+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.
+
+## Type Parameters
+
+| Type Parameter |
+| -------------- |
+| `T`            |
+
+## Properties
+
+| Property                                   | Type                | Defined in                                                                                                                |
+| ------------------------------------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-complete"></a> `complete?` | () => `void`        | [play-atom/src/types.ts:37](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L37) |
+| <a id="property-error"></a> `error?`       | (`error`) => `void` | [play-atom/src/types.ts:36](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L36) |
+| <a id="property-next"></a> `next?`         | (`value`) => `void` | [play-atom/src/types.ts:35](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L35) |

package/api/@xmachines/play-atom/interfaces/AtomOptions.md

@@ -0,0 +1,33 @@
+[API](../../../README.md) / [@xmachines/play-atom](../README.md) / AtomOptions
+
+# Interface: AtomOptions\<T\>
+
+Defined in: [play-atom/src/types.ts:147](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L147)
+
+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 },
+);
+```
+
+## Type Parameters
+
+| Type Parameter |
+| -------------- |
+| `T`            |
+
+## Properties
+
+| Property                                 | Type                              | Defined in                                                                                                                  |
+| ---------------------------------------- | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-compare"></a> `compare?` | (`previous`, `next`) => `boolean` | [play-atom/src/types.ts:148](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L148) |

package/api/@xmachines/play-atom/interfaces/AtomSubscription.md

@@ -0,0 +1,23 @@
+[API](../../../README.md) / [@xmachines/play-atom](../README.md) / AtomSubscription
+
+# Interface: AtomSubscription
+
+Defined in: [play-atom/src/types.ts:23](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L23)
+
+The release of one subscription
+
+`subscribe` returns it. Call `unsubscribe` one time. A second call does nothing.
+
+## Methods
+
+### unsubscribe()
+
+```ts
+unsubscribe(): void;
+```
+
+Defined in: [play-atom/src/types.ts:24](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-atom/src/types.ts#L24)
+
+#### Returns
+
+`void`