@xmachines/docs 2.2.0 → 4.0.0

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

@@ -0,0 +1,46 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / PlayRouterBridgeConstructor
+
+# Type Alias: PlayRouterBridgeConstructor\<TRouter, TActor\>
+
+```ts
+type PlayRouterBridgeConstructor<TRouter, TActor> = (
+	router,
+	actor,
+	routeMap,
+	options?,
+) => RouterBridge;
+```
+
+Defined in: [packages/play-router/src/provider-lifecycle.ts:107](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/provider-lifecycle.ts#L107)
+
+The constructor shape that a bridge class must satisfy for a provider factory: `(router, actor, routeMap, options?) → RouterBridge`.
+
+`TActor` carries the actor type of the caller through to the constructor, so the spec
+type of that actor reaches the bridge whole. A bridge that reads no spec binds nothing
+and receives the default.
+
+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                                                       | Default type                                      |
+| -------------------------------------------------------------------- | ------------------------------------------------- |
+| `TRouter`                                                            | -                                                 |
+| `TActor` _extends_ [`RoutableActor`](../interfaces/RoutableActor.md) | [`RoutableActor`](../interfaces/RoutableActor.md) |
+
+## Parameters
+
+| Parameter  | Type                                                  |
+| ---------- | ----------------------------------------------------- |
+| `router`   | `TRouter`                                             |
+| `actor`    | `TActor`                                              |
+| `routeMap` | [`RouteMap`](../classes/RouteMap.md)                  |
+| `options?` | [`BasePathOptions`](../interfaces/BasePathOptions.md) |
+
+## Returns
+
+[`RouterBridge`](../interfaces/RouterBridge.md)

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

@@ -0,0 +1,12 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / RouteData
+
+# Type Alias: RouteData
+
+```ts
+type RouteData = Record<string, unknown>;
+```
+
+Defined in: [packages/play-router/src/types.ts:15](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L15)
+
+The resolved extra data of a route. It reaches the consumer on the `data` field of a
+`play.route` event.

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

@@ -0,0 +1,31 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / RouteDataResolver
+
+# Type Alias: RouteDataResolver
+
+```ts
+type RouteDataResolver = (args) => RouteData;
+```
+
+Defined in: [packages/play-router/src/types.ts:28](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/types.ts#L28)
+
+The function form of [RouteObject.data](../interfaces/RouteObject.md#property-data).
+
+The signature mirrors `WithDynamicParams` of XState: the resolver reads the context
+of the machine and the event that asks for the route, and it returns the data.
+
+The resolver reads every field of the event, and `event.data` among them: that field
+carries what the SENDER of the event supplied, and the resolver decides how it
+combines with what the state declares. The `data` that the resolver RETURNS goes to
+`context.data`, and it does not go back onto the event.
+
+## Parameters
+
+| Parameter      | Type                                                                                      |
+| -------------- | ----------------------------------------------------------------------------------------- |
+| `args`         | \{ `context`: `unknown`; `event`: [`PlayRouteEvent`](../interfaces/PlayRouteEvent.md); \} |
+| `args.context` | `unknown`                                                                                 |
+| `args.event`   | [`PlayRouteEvent`](../interfaces/PlayRouteEvent.md)                                       |
+
+## Returns
+
+[`RouteData`](RouteData.md)

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

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

package/api/@xmachines/play-router/index/variables/DISPOSE.md

@@ -0,0 +1,34 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / DISPOSE
+
+# Variable: DISPOSE
+
+```ts
+const DISPOSE: DisposeKey;
+```
+
+Defined in: [packages/play/src/disposable.ts:94](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play/src/disposable.ts#L94)
+
+The key that a release is stored under.
+
+`Symbol.dispose` where the runtime has it, and `Symbol.for("Symbol.dispose")` where it
+does not. This is not a convenience — it is the difference between a `using` that
+releases and one that raises.
+
+A bundler that downlevels `using` for a target below Chrome 134 emits a helper that
+reads `object[Symbol.dispose || Symbol.for("Symbol.dispose")]`. A release stored under
+a bare `[Symbol.dispose]` lands on the string key `"undefined"` in that runtime,
+because the well-known symbol is absent and the computed key takes the value
+`undefined`. The helper then looks up the registered symbol, finds nothing, and throws
+`TypeError: Object is not disposable`. Storing under the same fallback closes the gap.
+
+The type assertion states what the fallback IS. `Symbol.for` returns a plain `symbol`,
+TypeScript declares `Symbol.dispose` as a `unique symbol`, and no expression produces
+a `unique symbol` other than the declaration itself.
+
+This binding resolves ONE time, when the module evaluates. [asCleanup](../../../play/index/functions/asCleanup.md) therefore
+reads `Symbol.dispose` again at each call and stores the release under both keys, so a
+polyfill that installs the well-known symbol after this module evaluates still finds
+the release. A class or an object literal that writes `[DISPOSE]()` has no such second
+chance: it carries the key that existed when it was defined. Install an Explicit
+Resource Management polyfill before the first import of `@xmachines/play`, which is the
+ordinary contract of a polyfill.

package/api/@xmachines/play-router/index/variables/NO_BASE_PATH.md

@@ -0,0 +1,18 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / NO\_BASE\_PATH
+
+# Variable: NO\_BASE\_PATH
+
+```ts
+const NO_BASE_PATH: ResolvedBasePath;
+```
+
+Defined in: [packages/play-url/src/base-path.ts:102](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-url/src/base-path.ts#L102)
+
+The base path of a bridge that has no `basePath` option.
+
+The object is FROZEN, and both levels of it: [resolveBasePath](../functions/resolveBasePath.md) returns this
+exact instance for every bridge with no mount, and
+`RouterBridgeBase.basePathParams` hands its `params` to the caller.
+`Readonly<Record<string, string>>` is gone at run time, so without the freeze one
+write in consumer code would leak that key into every other unmounted bridge in
+the process.

package/api/@xmachines/play-router/index/variables/ROOT_NODE_ID.md

@@ -0,0 +1,18 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / ROOT\_NODE\_ID
+
+# Variable: ROOT\_NODE\_ID
+
+```ts
+const ROOT_NODE_ID: "__root__" = "__root__";
+```
+
+Defined in: [packages/play-router/src/build-tree.ts:14](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/build-tree.ts#L14)
+
+The ID and the state ID of the synthetic root node of every `RouteTree`.
+
+`buildRouteTree` always makes this node, and no state of a machine declares it. It
+gives the tree one parent for each absolute route, and it holds `routable: false`.
+
+A consumer that walks a tree must SKIP this node. `createRouteMapFromTree` skips it,
+and `getRoutableRoutes` of `@xmachines/play-router/xstate` skips it. A walk that keeps
+it maps the path `/` to a state that the machine does not hold.

package/api/@xmachines/play-router/xstate/README.md

@@ -0,0 +1,53 @@
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / xstate
+
+# xstate
+
+`@xmachines/play-router/xstate` - the routes of an XState machine
+
+A route of XMachines is a fact about a STATE. This entry point reads that fact out of an
+XState v5 machine: it walks the machine, collects each `meta.route`, builds the route
+tree, and answers the questions that the tree can be asked — which routes are reachable,
+which are navigable from a state, and which path maps to which state id.
+
+The MAIN entry point holds what happens AFTERWARDS: the route map, the match of a
+location, the bridge, and the provider lifecycle. It names no machine, and it reads this
+module never. `xstate` is therefore an OPTIONAL peer of this package, and a bundler drops
+`@statelyai/graph` for a consumer that imports this entry point nowhere.
+
+This is the same shape as `@xmachines/play-xstate/routing` and
+`@xmachines/play-xstate/view`: an optional capability behind its own entry point, with
+its own dependency.
+
+## Example
+
+```typescript
+import { createRouteMap } from "@xmachines/play-router/xstate";
+import { connectRouter } from "@xmachines/play-dom-router";
+
+const routeMap = createRouteMap(myMachine);
+```
+
+## See
+
+[Routing guide](../../../../guides/routing.md)
+
+## Interfaces
+
+- [MachineEdgeData](interfaces/MachineEdgeData.md)
+- [MachineNodeData](interfaces/MachineNodeData.md)
+
+## Type Aliases
+
+- [MachineGraph](type-aliases/MachineGraph.md)
+
+## Functions
+
+- [createRouteMap](functions/createRouteMap.md)
+- [extractMachineRoutes](functions/extractMachineRoutes.md)
+- [getNavigableRoutes](functions/getNavigableRoutes.md)
+- [getRoutableRoutes](functions/getRoutableRoutes.md)
+- [getRouteMappings](functions/getRouteMappings.md)
+- [getTransitionReachableRoutes](functions/getTransitionReachableRoutes.md)
+- [isRouteReachable](functions/isRouteReachable.md)
+- [machineToGraph](functions/machineToGraph.md)
+- [routeExists](functions/routeExists.md)

package/api/@xmachines/{play-dom-router → play-router/xstate}/functions/createRouteMap.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-dom-router](../README.md) / createRouteMap
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [xstate](../README.md) / createRouteMap
 
 # Function: createRouteMap()
 
@@ -6,12 +6,14 @@
 function createRouteMap(machine, options?): RouteMap;
 ```
 
-Defined in: [play-router/src/create-route-map.ts:47](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/create-route-map.ts#L47)
+Defined in: [packages/play-router/src/xstate/create-route-map.ts:32](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/create-route-map.ts#L32)
 
 Creates a `RouteMap` from an XState state machine.
 
 The function reads every state with a route, which means each state with a
-`meta.route` field. It then builds the lookup structure between a path and a
+`meta.route` field. It keeps the routable states alone, and it drops the synthetic
+root of the tree. `createRouteMapFromTree` of the main entry point drops the same
+node, and the two functions therefore answer the same map for the same machine. It then builds the lookup structure between a path and a
 stateId, for both directions. A subclass of `RouterBridgeBase` uses the map: it
 converts each change of the browser URL into a `play.route` actor event, and each
 actor route into a URL.
@@ -21,18 +23,18 @@ actor route into a URL.
 | Parameter  | Type                                                                      | Description                                                                                                                     |
 | ---------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
 | `machine`  | [`AnyStateMachine`](https://www.jsdocs.io/package/xstate#AnyStateMachine) | The XState v5 state machine, with a `meta.route` annotation on each state with a route.                                         |
-| `options?` | [`RouteMapOptions`](../interfaces/RouteMapOptions.md)                     | The optional configuration. Give `{ cacheSize }` to change the default size of the LRU cache of the parameterized path lookups. |
+| `options?` | [`RouteMapOptions`](../../index/interfaces/RouteMapOptions.md)            | The optional configuration. Give `{ cacheSize }` to change the default size of the LRU cache of the parameterized path lookups. |
 
 ## Returns
 
-[`RouteMap`](../interfaces/RouteMap.md)
+[`RouteMap`](../../index/classes/RouteMap.md)
 
 A `RouteMap` for each adapter on `RouterBridgeBase`.
 
 ## Example
 
 ```typescript
-import { createRouteMap } from "@xmachines/play-router";
+import { createRouteMap } from "@xmachines/play-router/xstate";
 import { connectRouter } from "@xmachines/play-dom-router";
 
 const routeMap = createRouteMap(myMachine);

package/api/@xmachines/play-router/{functions → xstate/functions}/extractMachineRoutes.md

@@ -1,12 +1,12 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / extractMachineRoutes
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [xstate](../README.md) / extractMachineRoutes
 
 # Function: extractMachineRoutes()
 
 ```ts
-function extractMachineRoutes(machine): RouteTree;
+function extractMachineRoutes(machine): RouteTree<MachineGraph>;
 ```
 
-Defined in: [extract-routes.ts:92](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/extract-routes.ts#L92)
+Defined in: [packages/play-router/src/xstate/extract-routes.ts:98](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/extract-routes.ts#L98)
 
 Reads the complete route tree from the graph of a state machine
 
@@ -24,6 +24,6 @@ needs the transitions.
 
 ## Returns
 
-[`RouteTree`](../interfaces/RouteTree.md)
+[`RouteTree`](../../index/interfaces/RouteTree.md)\<[`MachineGraph`](../type-aliases/MachineGraph.md)\>
 
 The route tree, with its root, its byStateId map, its byPath map, and its graph

package/api/@xmachines/play-router/xstate/functions/getNavigableRoutes.md

@@ -0,0 +1,35 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [xstate](../README.md) / getNavigableRoutes
+
+# Function: getNavigableRoutes()
+
+```ts
+function getNavigableRoutes(tree, stateId): RouteNode[];
+```
+
+Defined in: [packages/play-router/src/xstate/query.ts:56](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/query.ts#L56)
+
+Returns every route of a navigation from the given state
+
+The function returns the child routes of the state. A later version also returns
+the sibling routes of a transition.
+
+## Parameters
+
+| Parameter | Type                                                                                                    | Description                                 |
+| --------- | ------------------------------------------------------------------------------------------------------- | ------------------------------------------- |
+| `tree`    | [`RouteTree`](../../index/interfaces/RouteTree.md)\<[`MachineGraph`](../type-aliases/MachineGraph.md)\> | The route tree, from extractMachineRoutes() |
+| `stateId` | `string`                                                                                                | The ID of the current state                 |
+
+## Returns
+
+[`RouteNode`](../../index/interfaces/RouteNode.md)[]
+
+The array of the route nodes that the state can reach
+
+## Example
+
+```typescript
+const tree = extractMachineRoutes(machine);
+const routes = getNavigableRoutes(tree, "dashboard");
+// [{ id: 'overview', path: '/overview', ... }, { id: 'settings', ... }]
+```

package/api/@xmachines/play-router/{functions → xstate/functions}/getRoutableRoutes.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / getRoutableRoutes
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [xstate](../README.md) / getRoutableRoutes
 
 # Function: getRoutableRoutes()
 
@@ -6,7 +6,7 @@
 function getRoutableRoutes(tree): RouteNode[];
 ```
 
-Defined in: [query.ts:113](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/query.ts#L113)
+Defined in: [packages/play-router/src/xstate/query.ts:121](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/query.ts#L121)
 
 Returns every route of the tree that has a route, in one flat array
 
@@ -16,13 +16,13 @@ configuration in a framework adapter dynamically.
 
 ## Parameters
 
-| Parameter | Type                                      | Description                                 |
-| --------- | ----------------------------------------- | ------------------------------------------- |
-| `tree`    | [`RouteTree`](../interfaces/RouteTree.md) | The route tree, from extractMachineRoutes() |
+| Parameter | Type                                               | Description                                 |
+| --------- | -------------------------------------------------- | ------------------------------------------- |
+| `tree`    | [`RouteTree`](../../index/interfaces/RouteTree.md) | The route tree, from extractMachineRoutes() |
 
 ## Returns
 
-[`RouteNode`](../interfaces/RouteNode.md)[]
+[`RouteNode`](../../index/interfaces/RouteNode.md)[]
 
 The array of the route nodes with a route, with their path and their stateId
 

package/api/@xmachines/play-router/{functions → xstate/functions}/getRouteMappings.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / getRouteMappings
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [xstate](../README.md) / getRouteMappings
 
 # Function: getRouteMappings()
 
@@ -6,7 +6,7 @@
 function getRouteMappings(tree, options?): RouteMapping[];
 ```
 
-Defined in: [query.ts:250](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/query.ts#L250)
+Defined in: [packages/play-router/src/xstate/query.ts:258](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/query.ts#L258)
 
 Returns the `{ stateId, path }` entries that a host router needs, so that it can
 register the routes of a machine under a base path, and remove them again later.
@@ -30,14 +30,14 @@ those are the params that the route of the host must match.
 
 ## Parameters
 
-| Parameter  | Type                                                  | Description                                                                                                                                                                                                                                                                                              |
-| ---------- | ----------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `tree`     | [`RouteTree`](../interfaces/RouteTree.md)             | The route tree of extractMachineRoutes()                                                                                                                                                                                                                                                                 |
-| `options?` | [`BasePathOptions`](../interfaces/BasePathOptions.md) | The optional `{ basePath, basePathParams }`, the same option as the bridge takes. Each `stateId` comes from the route tree, so it carries NO `#` prefix. A host that keys its route table on the target of a `play.route` event adds the `#` itself, because the event always carries the prefixed form. |
+| Parameter  | Type                                                           | Description                                                                                                                                                                                                                                                                                              |
+| ---------- | -------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `tree`     | [`RouteTree`](../../index/interfaces/RouteTree.md)             | The route tree of extractMachineRoutes()                                                                                                                                                                                                                                                                 |
+| `options?` | [`BasePathOptions`](../../index/interfaces/BasePathOptions.md) | The optional `{ basePath, basePathParams }`, the same option as the bridge takes. Each `stateId` comes from the route tree, so it carries NO `#` prefix. A host that keys its route table on the target of a `play.route` event adds the `#` itself, because the event always carries the prefixed form. |
 
 ## Returns
 
-[`RouteMapping`](../interfaces/RouteMapping.md)[]
+[`RouteMapping`](../../index/interfaces/RouteMapping.md)[]
 
 One entry for each state with a route, in the order of the route tree.
 

package/api/@xmachines/play-router/{functions → xstate/functions}/getTransitionReachableRoutes.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / getTransitionReachableRoutes
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [xstate](../README.md) / getTransitionReachableRoutes
 
 # Function: getTransitionReachableRoutes()
 
@@ -6,7 +6,7 @@
 function getTransitionReachableRoutes(graph, stateId): string[];
 ```
 
-Defined in: [query.ts:165](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/query.ts#L165)
+Defined in: [packages/play-router/src/xstate/query.ts:173](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/query.ts#L173)
 
 Returns the routes that a transition from the current state can reach
 

package/api/@xmachines/play-router/{functions → xstate/functions}/isRouteReachable.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / isRouteReachable
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [xstate](../README.md) / isRouteReachable
 
 # Function: isRouteReachable()
 
@@ -6,7 +6,7 @@
 function isRouteReachable(graph, fromStateId, toStateId): boolean;
 ```
 
-Defined in: [query.ts:193](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/query.ts#L193)
+Defined in: [packages/play-router/src/xstate/query.ts:201](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/query.ts#L201)
 
 Tells you if a transition from the current state can reach a route
 

package/api/@xmachines/play-router/{functions → xstate/functions}/machineToGraph.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / machineToGraph
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [xstate](../README.md) / machineToGraph
 
 # Function: machineToGraph()
 
@@ -6,7 +6,7 @@
 function machineToGraph(machine): MachineGraph;
 ```
 
-Defined in: [machine-to-graph.ts:73](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/machine-to-graph.ts#L73)
+Defined in: [packages/play-router/src/xstate/machine-to-graph.ts:73](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/machine-to-graph.ts#L73)
 
 ## Parameters
 

package/api/@xmachines/play-router/xstate/functions/routeExists.md

@@ -0,0 +1,26 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [xstate](../README.md) / routeExists
+
+# Function: routeExists()
+
+```ts
+function routeExists(tree, path): boolean;
+```
+
+Defined in: [packages/play-router/src/xstate/query.ts:143](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/query.ts#L143)
+
+Tells you if a route path is in the tree
+
+The function tests if the path has a state with a `meta.route` field.
+
+## Parameters
+
+| Parameter | Type                                               | Description                                                |
+| --------- | -------------------------------------------------- | ---------------------------------------------------------- |
+| `tree`    | [`RouteTree`](../../index/interfaces/RouteTree.md) | The route tree, from extractMachineRoutes()                |
+| `path`    | `string`                                           | The complete route path, for example '/dashboard/settings' |
+
+## Returns
+
+`boolean`
+
+true when the tree holds the path. In every other case, false

package/api/@xmachines/play-router/xstate/interfaces/MachineEdgeData.md

@@ -0,0 +1,15 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [xstate](../README.md) / MachineEdgeData
+
+# Interface: MachineEdgeData
+
+Defined in: [packages/play-router/src/xstate/machine-types.ts:27](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/machine-types.ts#L27)
+
+The data on each edge of the graph that represents the machine.
+It holds the event of the transition and the information of its guard.
+
+## Properties
+
+| Property                                     | Type     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Defined in                                                                                                                                                           |
+| -------------------------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-eventtype"></a> `eventType`  | `string` | The event type that starts this transition                                                                                                                                                                                                                                                                                                                                                                                                                                       | [packages/play-router/src/xstate/machine-types.ts:29](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/machine-types.ts#L29) |
+| <a id="property-guardtype"></a> `guardType?` | `string` | The guard as a string, when a guard is present XState 5 holds the guard of a transition as a value that `String()` describes, and `machineToGraph` writes that string here. The field carried a "removed in the next major" notice before, and it keeps no such notice now. XState 6 populates it never, so it leaves with the migration to XState 6 and not before: a removal while XState 5 fills it deletes a field that works, and it gives a consumer nothing in its place. | [packages/play-router/src/xstate/machine-types.ts:41](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/machine-types.ts#L41) |

package/api/@xmachines/play-router/xstate/interfaces/MachineNodeData.md

@@ -0,0 +1,17 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [xstate](../README.md) / MachineNodeData
+
+# Interface: MachineNodeData
+
+Defined in: [packages/play-router/src/xstate/machine-types.ts:12](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/machine-types.ts#L12)
+
+The data on each node of the graph that represents the machine.
+It holds the state metadata that the route extraction and the queries need.
+
+## Properties
+
+| Property                                | Type                                                                   | Description                                                | Defined in                                                                                                                                                           |
+| --------------------------------------- | ---------------------------------------------------------------------- | ---------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-meta"></a> `meta?`      | `Record`\<`string`, `unknown`\>                                        | The original meta object of the state                      | [packages/play-router/src/xstate/machine-types.ts:18](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/machine-types.ts#L18) |
+| <a id="property-route"></a> `route?`    | `string`                                                               | The route path of meta.route, in its string form           | [packages/play-router/src/xstate/machine-types.ts:20](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/machine-types.ts#L20) |
+| <a id="property-stateid"></a> `stateId` | `string`                                                               | The XState state ID, for example "test.dashboard.overview" | [packages/play-router/src/xstate/machine-types.ts:14](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/machine-types.ts#L14) |
+| <a id="property-type"></a> `type`       | `"atomic"` \| `"compound"` \| `"parallel"` \| `"final"` \| `"history"` | The state type of XState                                   | [packages/play-router/src/xstate/machine-types.ts:16](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/machine-types.ts#L16) |

package/api/@xmachines/play-router/{type-aliases → xstate/type-aliases}/MachineGraph.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / MachineGraph
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [xstate](../README.md) / MachineGraph
 
 # Type Alias: MachineGraph
 
@@ -6,7 +6,7 @@
 type MachineGraph = Graph<MachineNodeData, MachineEdgeData>;
 ```
 
-Defined in: [machine-to-graph.ts:19](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.2.0/packages/play-router/src/machine-to-graph.ts#L19)
+Defined in: [packages/play-router/src/xstate/machine-to-graph.ts:19](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-router/src/xstate/machine-to-graph.ts#L19)
 
 The typed Graph of @statelyai/graph that represents a state machine.
 It gives you the queries of the hierarchy, the algorithms of a walk, and the tests

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

@@ -4,7 +4,7 @@
 
 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-2.2.0-blue)](https://www.npmjs.com/package/@xmachines/play-signals)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-4.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-signals)
 
 ## Installation
 
@@ -117,39 +117,18 @@ person.set({ name: "Alice", age: 30 });
 | 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 function                                     |
+| `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                                  |
-
-## 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
-```
+| `Cleanup`                      | type      | The release that `watchSignal` returns, re-exported from `@xmachines/play`                             |
 
 ## Requirements
 
-- **Node.js** `>= 22.0.0`
+- **Node.js** `>= 24.0.0`
 - **TypeScript** `5.7+` (for a consumer that uses TypeScript)
 
 ## License
@@ -222,6 +201,7 @@ the code from a change of the Stage 1 API.
 
 ## Type Aliases
 
+- [Cleanup](type-aliases/Cleanup.md)
 - [WatcherNotify](type-aliases/WatcherNotify.md)
 
 ## Functions