@xmachines/docs 3.0.0 → 5.0.0

package/api/@xmachines/play-router/interfaces/RoutableActor.md

@@ -1,65 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / RoutableActor
-
-# Interface: RoutableActor
-
-Defined in: [play-router/src/types.ts:273](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L273)
-
-The minimal actor interface that `RouterBridgeBase` and every framework router
-adapter require.
-
-This interface, and not `AbstractActor<AnyActorLogic> & Routable`, gives
-`RouterBridgeBase.actor.send` the type that accepts a `PlayRouteEvent` directly.
-It therefore removes the unsafe cast `(actor.send as (e: PlayRouteEvent) => void)`,
-which the weaker `EventObject` constraint of the actor type needed before.
-
-Every `AbstractActor` subclass satisfies this interface structurally, for two
-reasons:
-
-- `AbstractActor` implements `send(event: TEvent): void`, and `TEvent` accepts each
-  `EventObject`. Therefore it always accepts a `PlayRouteEvent`, which is a subtype.
-- `Routable` gives `currentRoute` and `initialRoute`.
-
-## Example
-
-```typescript
-import type { RoutableActor } from "@xmachines/play-router";
-
-class MyBridge extends RouterBridgeBase {
-	constructor(actor: RoutableActor, routeMap: RouteMap) {
-		super(actor, routeMap);
-	}
-}
-```
-
-## Extended by
-
-- [`PlayActor`](PlayActor.md)
-
-## Properties
-
-| Property                                          | Modifier   | Type                                                                                         | Description                                                                                                                                                                                                                              | Defined in                                                                                                                      |
-| ------------------------------------------------- | ---------- | -------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-currentroute"></a> `currentRoute` | `readonly` | [`Computed`](../../play-signals/namespaces/Signal/classes/Computed.md)\<`string` \| `null`\> | The TC39 Signal of the current URL path of the actor, or of its state ID.                                                                                                                                                                | [play-router/src/types.ts:275](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L275) |
-| <a id="property-initialroute"></a> `initialRoute` | `readonly` | `string` \| `null`                                                                           | The route of the initial state of the machine. The constructor fixes it. A router bridge compares it with the browser URL. It therefore separates a deep link, where the router wins, from a restore of a session, where the actor wins. | [play-router/src/types.ts:281](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L281) |
-
-## Methods
-
-### send()
-
-```ts
-send(event): void;
-```
-
-Defined in: [play-router/src/types.ts:283](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L283)
-
-Sends a route navigation event to the actor.
-
-#### Parameters
-
-| Parameter | Type                                  |
-| --------- | ------------------------------------- |
-| `event`   | [`PlayRouteEvent`](PlayRouteEvent.md) |
-
-#### Returns
-
-`void`

package/api/@xmachines/play-router/interfaces/RouteMapOptions.md

@@ -1,13 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / RouteMapOptions
-
-# Interface: RouteMapOptions
-
-Defined in: [play-router/src/create-route-map.ts:9](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/create-route-map.ts#L9)
-
-The options of `createRouteMap` and of `createRouteMapFromTree`.
-
-## Properties
-
-| Property                                     | Type     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Defined in                                                                                                                                          |
-| -------------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-cachesize"></a> `cacheSize?` | `number` | The maximum number of the resolved parameterized path lookups in the cache. `RouteMap.getStateIdByPath()` resolves a parameterized pattern, for example `/profile/:userId`, with URLPattern on each call. The map keeps each path of a frequent visit in an LRU cache, and a later lookup of that path is therefore O(1). Raise this value for an application with a large set of parameterized routes, or with a high frequency of the navigation. The default is `500`. | [play-router/src/create-route-map.ts:21](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/create-route-map.ts#L21) |

package/api/@xmachines/play-router/interfaces/RouteMatch.md

@@ -1,12 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / RouteMatch
-
-# Interface: RouteMatch
-
-Defined in: [play-router/src/router-sync.ts:12](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/router-sync.ts#L12)
-
-## Properties
-
-| Property                               | Type                              | Defined in                                                                                                                                |
-| -------------------------------------- | --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-params"></a> `params?` | `Record`\<`string`, `string`\>    | [play-router/src/router-sync.ts:14](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/router-sync.ts#L14) |
-| <a id="property-to"></a> `to`          | `string` \| `null` \| `undefined` | [play-router/src/router-sync.ts:13](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/router-sync.ts#L13) |

package/api/@xmachines/play-router/interfaces/RouteObject.md

@@ -1,21 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / RouteObject
-
-# Interface: RouteObject
-
-Defined in: [play-router/src/types.ts:46](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L46)
-
-A route object, with more metadata.
-
-## Indexable
-
-```ts
-[key: string]: unknown
-```
-
-The additional metadata of the route: a title, a breadcrumb, and so on
-
-## Properties
-
-| Property                          | Type     | Description                                             | Defined in                                                                                                                    |
-| --------------------------------- | -------- | ------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-path"></a> `path` | `string` | The template of the route path, for example '/user/:id' | [play-router/src/types.ts:48](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L48) |

package/api/@xmachines/play-router/interfaces/RouteTree.md

@@ -1,21 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / RouteTree
-
-# Interface: RouteTree
-
-Defined in: [play-router/src/types.ts:123](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L123)
-
-The complete route tree, with its lookup maps
-
-It gives you the map between a state ID and a URL path, in both directions:
-
-- byStateId: it maps each state ID to its route node, for the target of a play.route event
-- byPath: it maps each URL path to its route node, for the browser navigation
-
-## Properties
-
-| Property                                    | Type                                                                                                      | Description                                                                                                                                                                                                                                                                                                                                                                                         | Defined in                                                                                                                      |
-| ------------------------------------------- | --------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-bypath"></a> `byPath`       | `Map`\<`string`, [`RouteNode`](RouteNode.md)\>                                                            | The map from a complete path to its route node. It gives you the state ID of a URL path, for the target of a play.route event                                                                                                                                                                                                                                                                       | [play-router/src/types.ts:135](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L135) |
-| <a id="property-bystateid"></a> `byStateId` | `Map`\<`string`, [`RouteNode`](RouteNode.md)\>                                                            | The map from a state ID to its route node. It gives you the URL path of a state ID, for the update of the browser URL                                                                                                                                                                                                                                                                               | [play-router/src/types.ts:130](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L130) |
-| <a id="property-graph"></a> `graph?`        | `Graph`\<[`MachineNodeData`](MachineNodeData.md), [`MachineEdgeData`](MachineEdgeData.md), `any`, `any`\> | The graph of the state machine, for an advanced query. extractMachineRoutes() fills it. Use it for a query of the hierarchy, for a test of the reachability, and for a navigation that knows the transitions, through the algorithms of @statelyai/graph. **Example** `import { getSuccessors, hasPath } from "@statelyai/graph"; const successors = getSuccessors(tree.graph!, "myMachine.home");` | [play-router/src/types.ts:148](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L148) |
-| <a id="property-root"></a> `root`           | [`RouteNode`](RouteNode.md)                                                                               | The root node of the routes                                                                                                                                                                                                                                                                                                                                                                         | [play-router/src/types.ts:125](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L125) |

package/api/@xmachines/play-router/interfaces/RouteWatcherHandle.md

@@ -1,55 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / RouteWatcherHandle
-
-# Interface: RouteWatcherHandle
-
-Defined in: [play-router/src/router-bridge-base.ts:79](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/router-bridge-base.ts#L79)
-
-The narrow interface of the TC39 Signal watcher. `RouterBridgeBase` uses it to
-observe each change of `actor.currentRoute`.
-
-The interface hides the complete `Signal.subtle.Watcher` surface. It exposes the
-two operations that `RouterBridgeBase` needs:
-
-- `watch(signal)` — it arms the watcher on one signal
-- `unwatch()` — it stops the watch and frees the resources
-
-A framework adapter subclass touches this handle never. `RouterBridgeBase` makes
-it and manages it internally.
-
-## Methods
-
-### unwatch()
-
-```ts
-unwatch(): void;
-```
-
-Defined in: [play-router/src/router-bridge-base.ts:83](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/router-bridge-base.ts#L83)
-
-Stops the observation and frees the watcher.
-
-#### Returns
-
-`void`
-
----
-
-### watch()
-
-```ts
-watch(signal): void;
-```
-
-Defined in: [play-router/src/router-bridge-base.ts:81](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/router-bridge-base.ts#L81)
-
-Arms the watcher on the given signal.
-
-#### Parameters
-
-| Parameter | Type                                                                                         |
-| --------- | -------------------------------------------------------------------------------------------- |
-| `signal`  | [`Computed`](../../play-signals/namespaces/Signal/classes/Computed.md)\<`string` \| `null`\> |
-
-#### Returns
-
-`void`

package/api/@xmachines/play-router/type-aliases/BaseRouteMapping.md

@@ -1,13 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / BaseRouteMapping
-
-# ~~Type Alias: BaseRouteMapping~~
-
-```ts
-type BaseRouteMapping = RouteMapping;
-```
-
-Defined in: [play-router/src/index.ts:103](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/index.ts#L103)
-
-## Deprecated
-
-Use [RouteMapping](../interfaces/RouteMapping.md). Will be removed in the next major.

package/api/@xmachines/play-router/type-aliases/PlayRouterBridgeConstructor.md

@@ -1,36 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / PlayRouterBridgeConstructor
-
-# Type Alias: PlayRouterBridgeConstructor\<TRouter\>
-
-```ts
-type PlayRouterBridgeConstructor<TRouter> = (router, actor, routeMap, options?) => RouterBridge;
-```
-
-Defined in: [play-router/src/provider-lifecycle.ts:103](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/provider-lifecycle.ts#L103)
-
-The constructor shape that a bridge class must satisfy for a provider factory: `(router, actor, routeMap, options?) → RouterBridge`.
-
-The return type is `RouterBridge`, the published contract of a bridge, so a
-consumer bridge of its own keeps compiling. Every bridge on `RouterBridgeBase` also
-satisfies `MountableRouterBridge`, and the provider finds that mount API at run
-time: a bridge without it ignores `basePath`, exactly as it did before the option
-existed.
-
-## Type Parameters
-
-| Type Parameter |
-| -------------- |
-| `TRouter`      |
-
-## Parameters
-
-| Parameter  | Type                                                  |
-| ---------- | ----------------------------------------------------- |
-| `router`   | `TRouter`                                             |
-| `actor`    | [`PlayActor`](../interfaces/PlayActor.md)             |
-| `routeMap` | [`RouteMap`](../classes/RouteMap.md)                  |
-| `options?` | [`BasePathOptions`](../interfaces/BasePathOptions.md) |
-
-## Returns
-
-[`RouterBridge`](../interfaces/RouterBridge.md)

package/api/@xmachines/play-router/type-aliases/RouteMetadata.md

@@ -1,11 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / RouteMetadata
-
-# Type Alias: RouteMetadata
-
-```ts
-type RouteMetadata = string | RouteObject;
-```
-
-Defined in: [play-router/src/types.ts:56](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L56)
-
-The route metadata of the `meta.route` field of a state machine.

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

@@ -1,231 +0,0 @@
-[API](../../README.md) / @xmachines/play-signals
-
-# @xmachines/play-signals
-
-TC39 Signals polyfill for XMachines. It gives the Play Architecture fine-grained reactive state primitives. The primitives propagate state without a glitch and without a subscription.
-
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-3.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-signals)
-
-## Installation
-
-```bash
-pnpm add @xmachines/play-signals
-```
-
-## Overview
-
-This package wraps the [`signal-polyfill`](https://github.com/nicolo-ribaudo/tc39-proposal-signals-polyfill) reference implementation of the [TC39 Signals proposal](https://github.com/tc39/proposal-signals) (Stage 1). It re-exports the complete `Signal` namespace, and it adds the memory-safe `watchSignal` utility. The wrapper keeps the rest of the code away from a Stage 1 API that can still change.
-
-**Import every signal in the XMachines ecosystem from this package**, not from `signal-polyfill`. One import point keeps each polyfill update and each API change in one place.
-
-## Usage
-
-### `Signal.State` — writable reactive state
-
-```typescript
-import { Signal } from "@xmachines/play-signals";
-
-const count = new Signal.State(0);
-
-console.log(count.get()); // 0
-count.set(5);
-console.log(count.get()); // 5
-```
-
-### `Signal.Computed` — lazy memoized derived values
-
-```typescript
-import { Signal } from "@xmachines/play-signals";
-
-const count = new Signal.State(0);
-const doubled = new Signal.Computed(() => 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 signal that it reads. A dynamic branch is safe: the computation keeps only the signals of the _current_ execution path as its dependencies.
-
-### `watchSignal` — memory-safe one-shot effect
-
-Use `watchSignal` to subscribe to a `Signal.State` or to a `Signal.Computed`. The callback receives the value after each change. `watchSignal` groups the updates of one synchronous batch into a single microtask.
-
-```typescript
-import { Signal, watchSignal } from "@xmachines/play-signals";
-
-const count = new Signal.State(0);
-
-const cleanup = watchSignal(count, (value) => {
-	console.log("count changed:", value);
-});
-
-count.set(1); // → logs "count changed: 1" (via microtask)
-count.set(2); // coalesced with any rapid synchronous changes
-count.set(3); // → logs "count changed: 3" once
-
-// Stop watching
-cleanup();
-```
-
-The cleanup function is idempotent. A second call is safe, and it does not throw.
-
-### `Signal.subtle.Watcher` — low-level multi-signal observation
-
-Advanced code, such as a framework integration, can use the complete `Signal.subtle.Watcher` API:
-
-```typescript
-import { Signal } from "@xmachines/play-signals";
-
-const count = new Signal.State(0);
-const doubled = new Signal.Computed(() => count.get() * 2);
-
-const watcher = new Signal.subtle.Watcher(() => {
-	queueMicrotask(() => {
-		const pending = watcher.getPending();
-		console.log("signals changed:", pending.length);
-		watcher.watch(...pending); // re-arm for future changes
-	});
-});
-
-watcher.watch(count);
-watcher.watch(doubled);
-
-count.set(5); // schedules microtask notification
-```
-
-### Custom equality
-
-Both `Signal.State` and `Signal.Computed` accept an `equals` option. The option controls when a signal notifies its dependents:
-
-```typescript
-import { Signal } from "@xmachines/play-signals";
-import type { SignalOptions } from "@xmachines/play-signals";
-
-const options: SignalOptions<{ name: string; age: number }> = {
-	equals: (a, b) => a.name === b.name && a.age === b.age,
-};
-
-const person = new Signal.State({ name: "Alice", age: 30 }, options);
-// A structurally identical value does not notify the dependents
-person.set({ name: "Alice", age: 30 });
-```
-
-## API Summary
-
-| Export                         | Kind      | Description                                                                                            |
-| ------------------------------ | --------- | ------------------------------------------------------------------------------------------------------ |
-| `Signal`                       | namespace | Full TC39 Signals namespace (`State`, `Computed`, `subtle.Watcher`) re-exported from `signal-polyfill` |
-| `watchSignal(signal, onValue)` | function  | The memory-safe subscription helper. It returns a `Cleanup`                                            |
-| `SignalState<T>`               | interface | Shape of `Signal.State<T>` (`.get()`, `.set()`)                                                        |
-| `SignalComputed<T>`            | interface | Shape of `Signal.Computed<T>` (`.get()`)                                                               |
-| `SignalWatcher`                | interface | Shape of `Signal.subtle.Watcher` (`.watch()`, `.unwatch()`, `.getPending()`)                           |
-| `SignalOptions<T>`             | interface | The options object for the `Signal.State` constructor (`equals?`)                                      |
-| `ComputedOptions<T>`           | interface | The options object for the `Signal.Computed` constructor (`equals?`)                                   |
-| `WatcherNotify`                | type      | The callback signature of the `Signal.subtle.Watcher` notify function                                  |
-| `Cleanup`                      | type      | The release that `watchSignal` returns, re-exported from `@xmachines/play`                             |
-
-## Testing
-
-Run tests for this package in isolation:
-
-```bash
-# From this package directory
-pnpm test
-
-# Watch mode
-pnpm test -- --watch
-```
-
-From the monorepo root:
-
-```bash
-# Run tests for this package
-pnpm --filter @xmachines/play-signals test
-
-# Run with coverage (lines ≥ 90 %, functions ≥ 90 %, branches ≥ 85 %, statements ≥ 90 %)
-pnpm run test:coverage
-```
-
-## Requirements
-
-- **Node.js** `>= 22.0.0`
-- **TypeScript** `5.7+` (for a consumer that uses TypeScript)
-
-## License
-
-MIT — see [LICENSE](LICENSE).
-
-The TC39 Signals polyfill of the XMachines Play Architecture
-
-This package gives you the fine-grained reactive state primitives of the TC39
-Signals proposal (Stage 1). It keeps the TC39 polyfill in one place, and it
-therefore protects the code from a change of the Stage 1 API.
-
-**Architectural context:** the package implements **Signal-Only Reactivity
-(INV-05)**. It gives the reactive primitives that carry the communication from
-the Actor to the infrastructure, without a subscription and without an event
-emitter. Every propagation of state in the Play Architecture uses a TC39 Signal,
-which tracks each dependency and updates without a glitch.
-
-## Example
-
-The basic use of a signal
-
-```typescript
-import { Signal } from "@xmachines/play-signals";
-
-// Create a state signal
-const count = new Signal.State(0);
-
-// Create a computed signal
-const doubled = new Signal.Computed(() => count.get() * 2);
-
-// Observe the changes
-const watcher = new Signal.subtle.Watcher(() => {
-	console.log("Count:", count.get(), "Doubled:", doubled.get());
-});
-watcher.watch(count);
-
-count.set(5); // Logs: Count: 5 Doubled: 10
-```
-
-## See
-
-- [Play RFC](../../../rfc/play.md) - invariant INV-05
-- [TC39 Signals Proposal](https://github.com/tc39/proposal-signals)
-
-## Remarks
-
-**Stage 1 status:** TC39 Signals is at Stage 1 in the TC39 process now. This
-package uses the official `signal-polyfill` reference implementation. The code
-therefore stays separate from an API that can change while the proposal
-develops. Import every signal through this package, and the separation stays
-complete.
-
-**The reason for the separation:** this dedicated package re-exports the
-polyfill. Therefore one place holds each new polyfill version and each change of
-the API, and no consuming package changes. This architectural decision protects
-the code from a change of the Stage 1 API.
-
-## Namespaces
-
-- [Signal](namespaces/Signal/README.md)
-
-## Interfaces
-
-- [ComputedOptions](interfaces/ComputedOptions.md)
-- [SignalComputed](interfaces/SignalComputed.md)
-- [SignalOptions](interfaces/SignalOptions.md)
-- [SignalState](interfaces/SignalState.md)
-- [SignalWatcher](interfaces/SignalWatcher.md)
-
-## Type Aliases
-
-- [Cleanup](type-aliases/Cleanup.md)
-- [WatcherNotify](type-aliases/WatcherNotify.md)
-
-## Functions
-
-- [watchSignal](functions/watchSignal.md)

package/api/@xmachines/play-signals/functions/watchSignal.md

@@ -1,65 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-signals](../README.md) / watchSignal
-
-# Function: watchSignal()
-
-```ts
-function watchSignal<T>(signal, onValue): Cleanup;
-```
-
-Defined in: [packages/play-signals/src/watch-signal.ts:45](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-signals/src/watch-signal.ts#L45)
-
-Subscribes to one signal, with the canonical one-shot watcher lifecycle.
-
-The callback runs from a microtask in the queue, after the watcher drains the
-notifications that wait. The watcher then arms itself again, so that it misses no
-later update. The cleanup function is idempotent, because it accepts a watcher
-that is detached already.
-
-**Memory safety (Phase 29):**
-
-- The `disposed` flag stops a callback after the cleanup: the microtask returns at
-  once when the cleanup runs before the microtask fires.
-- The `needsEnqueue` guard removes the duplicates of rapid synchronous signal
-  changes: one batch of synchronous changes queues one microtask only.
-- The watcher arms again BEFORE the callback: a callback that THROWS keeps the watch, a
-  callback that RELEASES the watch leaves no watcher attached to the signal, and a
-  callback that WRITES the signal reaches the caller with the value that it wrote.
-- The watcher arms with NO argument: `watch(signal)` records the edge a second time on
-  every emission, so the edge list of the watcher and the consumer list of the signal
-  grow by one for each change, for the life of the watch.
-
-A CAUTION for a callback that writes the signal 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 bound here would drop the write of a caller that repairs its state
-one time, which is the case that the order above exists to serve. A caller that repairs
-from a failure must repair to a state that succeeds, or it must stop after one attempt.
-A write of the SAME value ends the sequence by itself, because a signal 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 = watchSignal(count, render);
-```
-
-## Type Parameters
-
-| Type Parameter |
-| -------------- |
-| `T`            |
-
-## Parameters
-
-| Parameter | Type                                                                                                                        | Description                                                           |
-| --------- | --------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
-| `signal`  | \| [`State`](../namespaces/Signal/classes/State.md)\<`T`\> \| [`Computed`](../namespaces/Signal/classes/Computed.md)\<`T`\> | The `Signal.State` or `Signal.Computed` to subscribe to.              |
-| `onValue` | (`value`) => `void`                                                                                                         | The watcher calls it with the current signal value after each change. |
-
-## Returns
-
-[`Cleanup`](../type-aliases/Cleanup.md)
-
-The release. It removes the watcher.

package/api/@xmachines/play-signals/interfaces/ComputedOptions.md

@@ -1,36 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-signals](../README.md) / ComputedOptions
-
-# Interface: ComputedOptions\<T\>
-
-Defined in: [packages/play-signals/src/types.ts:85](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-signals/src/types.ts#L85)
-
-The options of a Signal.Computed
-
-## Param
-
-**equals**
-
-The optional equality function of your own, for the memoization
-
-## Example
-
-```typescript
-import { Signal } from "@xmachines/play-signals";
-import type { ComputedOptions } from "@xmachines/play-signals";
-
-const options: ComputedOptions<string> = {
-	equals: (a, b) => a.toLowerCase() === b.toLowerCase(),
-};
-```
-
-## Type Parameters
-
-| Type Parameter |
-| -------------- |
-| `T`            |
-
-## Properties
-
-| Property                               | Type                    | Description                                            | Defined in                                                                                                                               |
-| -------------------------------------- | ----------------------- | ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-equals"></a> `equals?` | (`a`, `b`) => `boolean` | The equality function of your own, for the memoization | [packages/play-signals/src/types.ts:89](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-signals/src/types.ts#L89) |

package/api/@xmachines/play-signals/interfaces/SignalComputed.md

@@ -1,49 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-signals](../README.md) / SignalComputed
-
-# Interface: SignalComputed\<T\>
-
-Defined in: [packages/play-signals/src/types.ts:112](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-signals/src/types.ts#L112)
-
-The computed signal. It evaluates late, and it memoizes the result
-
-Signal.Computed tracks each dependency when it runs its callback. It memoizes the
-result, and it runs the callback again only after a dependency changes. It
-therefore tracks each dependency for you, and you manage no subscription.
-
-## Example
-
-```typescript
-import { Signal } from "@xmachines/play-signals";
-
-const count = new Signal.State(0);
-const doubled = new Signal.Computed(() => count.get() * 2);
-
-console.log(doubled.get()); // 0
-count.set(5);
-console.log(doubled.get()); // 10 (the signal computed it again)
-console.log(doubled.get()); // 10 (from the memory, with no new computation)
-```
-
-## Type Parameters
-
-| Type Parameter |
-| -------------- |
-| `T`            |
-
-## Methods
-
-### get()
-
-```ts
-get(): T;
-```
-
-Defined in: [packages/play-signals/src/types.ts:118](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-signals/src/types.ts#L118)
-
-Reads the computed value. It computes the value again only after a dependency changed
-
-#### Returns
-
-`T`
-
-The value from the current dependencies