@xmachines/docs 2.0.0-alpha.1 → 2.1.0

package/api/@xmachines/play-router/functions/extractRouteParams.md

@@ -6,40 +6,43 @@
 function extractRouteParams(pathname, pattern): Record<string, string>;
 ```
 
-Defined in: [router-sync.ts:112](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/router-sync.ts#L112)
+Defined in: [router-sync.ts:117](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/router-sync.ts#L117)
 
-Extract named path parameters from a URL using the URLPattern API.
+Reads the named path parameters of a URL, with the URLPattern API.
 
-Takes the pattern string directly — use this when the pattern is already known.
-For extraction via a state ID lookup, see `RouterBridgeBase.extractParams`.
+The function takes the string of the pattern directly. Use it when you know the
+pattern already. For a read through the lookup of a state ID, see
+`RouterBridgeBase.extractParams`.
 
-Undefined values (unmatched optional segments, e.g. `/settings` against
-`/settings/:section?`) are omitted from the returned object.
+The object of the return holds no undefined value. Such a value comes from an
+optional segment without a match, for example `/settings` against
+`/settings/:section?`.
 
-The pattern is normalized with the same rules `RouteMap` uses for matching
-(hyphenated names like `:cat-id` become `:cat_id` for URLPattern), and the
-extracted group names are mapped back to the original param names, so
-`/docs/123` against `/docs/:cat-id` yields `{ "cat-id": "123" }`.
+The function normalizes the pattern with the rules of the match in `RouteMap`: a
+name with a hyphen, such as `:cat-id`, becomes `:cat_id` for URLPattern. It then
+maps each group name back to the original param name. Therefore `/docs/123`
+against `/docs/:cat-id` gives `{ "cat-id": "123" }`.
 
-Values are percent-decoded (`john%20doe` → `john doe`), matching framework
-router semantics (e.g. vue-router). Malformed sequences are kept raw.
+The function decodes each percent sequence of a value (`john%20doe` → `john doe`),
+as a framework router does, for example vue-router. It keeps a malformed sequence
+raw.
 
 ## Parameters
 
-| Parameter  | Type     | Description                                          |
-| ---------- | -------- | ---------------------------------------------------- |
-| `pathname` | `string` | The concrete URL pathname (e.g. `/profile/alice`)    |
-| `pattern`  | `string` | The URL pattern template (e.g. `/profile/:username`) |
+| Parameter  | Type     | Description                                                       |
+| ---------- | -------- | ----------------------------------------------------------------- |
+| `pathname` | `string` | The concrete URL pathname, for example `/profile/alice`           |
+| `pattern`  | `string` | The template of the URL pattern, for example `/profile/:username` |
 
 ## Returns
 
 `Record`\<`string`, `string`\>
 
-A record of extracted parameter values, or `{}` for static patterns.
+The record of the parameter values of the read, or `{}` for a static pattern.
 
 ## Throws
 
-When `URLPattern` is absent and the pattern is parameterized.
+When `URLPattern` is absent and the pattern holds a parameter.
 
 ## Example
 
@@ -50,5 +53,5 @@ extractRouteParams("/profile/alice", "/profile/:username");
 // → { username: "alice" }
 
 extractRouteParams("/settings", "/settings/:section?");
-// → {}  (optional param absent — not included)
+// → {}  — the optional param is absent, and the object holds it not
 ```

package/api/@xmachines/play-router/functions/findRouteById.md

@@ -6,25 +6,26 @@
 function findRouteById(tree, id): RouteNode | undefined;
 ```
 
-Defined in: [find-route.ts:57](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/find-route.ts#L57)
+Defined in: [find-route.ts:59](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/find-route.ts#L59)
 
-Find route node by state ID
+Finds a route node by its state ID
 
-Looks up route node using the state's ID property. Used to get URL path
-from state ID for browser URL sync after play.route transitions.
+The function looks the route node up by the ID property of the state. It gives you
+the URL path of a state ID, for the update of the browser URL after a `play.route`
+transition.
 
 ## Parameters
 
-| Parameter | Type                                      | Description                                      |
-| --------- | ----------------------------------------- | ------------------------------------------------ |
-| `tree`    | [`RouteTree`](../interfaces/RouteTree.md) | Route tree from extractMachineRoutes             |
-| `id`      | `string`                                  | State ID (e.g., 'dashboard', 'settings.profile') |
+| Parameter | Type                                      | Description                                                 |
+| --------- | ----------------------------------------- | ----------------------------------------------------------- |
+| `tree`    | [`RouteTree`](../interfaces/RouteTree.md) | The route tree, from extractMachineRoutes                   |
+| `id`      | `string`                                  | The state ID, for example 'dashboard' or 'settings.profile' |
 
 ## Returns
 
 [`RouteNode`](../interfaces/RouteNode.md) \| `undefined`
 
-Route node if found, undefined otherwise
+The route node, or undefined when the function finds none
 
 ## Example
 

package/api/@xmachines/play-router/functions/findRouteByPath.md

@@ -6,30 +6,32 @@
 function findRouteByPath(tree, path): RouteNode | undefined;
 ```
 
-Defined in: [find-route.ts:82](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/find-route.ts#L82)
+Defined in: [find-route.ts:86](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/find-route.ts#L86)
 
-Find route node by URL path
+Finds a route node by its URL path
 
-Looks up route node using the URL path. Used to get state ID from browser
-URL for sending play.route events on navigation.
+The function looks the route node up by the URL path. It gives you the state ID of
+a browser URL, for the `play.route` event of a navigation.
 
-When multiple states share the same path (e.g., root and a state both at "/"),
-prefers routable nodes (with meta.route) over non-routable nodes.
+When more than one state holds the same path, for example the root and a second
+state both at "/", the function prefers a node with a route, which means a node
+with a `meta.route` field, over a node without one.
 
-Supports pattern matching for dynamic routes (e.g., '/settings/:section?').
+The function also matches a pattern of a dynamic route, for example
+'/settings/:section?'.
 
 ## Parameters
 
-| Parameter | Type                                      | Description                                        |
-| --------- | ----------------------------------------- | -------------------------------------------------- |
-| `tree`    | [`RouteTree`](../interfaces/RouteTree.md) | Route tree from extractMachineRoutes               |
-| `path`    | `string`                                  | URL path (e.g., '/dashboard', '/settings/profile') |
+| Parameter | Type                                      | Description                                                   |
+| --------- | ----------------------------------------- | ------------------------------------------------------------- |
+| `tree`    | [`RouteTree`](../interfaces/RouteTree.md) | The route tree, from extractMachineRoutes                     |
+| `path`    | `string`                                  | The URL path, for example '/dashboard' or '/settings/profile' |
 
 ## Returns
 
 [`RouteNode`](../interfaces/RouteNode.md) \| `undefined`
 
-Route node if found, undefined otherwise
+The route node, or undefined when the function finds none
 
 ## Example
 

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

@@ -6,25 +6,25 @@
 function getNavigableRoutes(tree, stateId): RouteNode[];
 ```
 
-Defined in: [query.ts:41](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/query.ts#L41)
+Defined in: [query.ts:41](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/query.ts#L41)
 
-Get all routes navigable from given state
+Returns every route of a navigation from the given state
 
-Returns child routes of the specified state. Future enhancement will
-include sibling routes reachable via transitions.
+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`](../interfaces/RouteTree.md) | Route tree from extractMachineRoutes() |
-| `stateId` | `string`                                  | Current state ID                       |
+| Parameter | Type                                      | Description                                 |
+| --------- | ----------------------------------------- | ------------------------------------------- |
+| `tree`    | [`RouteTree`](../interfaces/RouteTree.md) | The route tree, from extractMachineRoutes() |
+| `stateId` | `string`                                  | The ID of the current state                 |
 
 ## Returns
 
 [`RouteNode`](../interfaces/RouteNode.md)[]
 
-Array of route nodes reachable from state
+The array of the route nodes that the state can reach
 
 ## Example
 

package/api/@xmachines/play-router/functions/getRoutableRoutes.md

@@ -6,25 +6,25 @@
 function getRoutableRoutes(tree): RouteNode[];
 ```
 
-Defined in: [query.ts:103](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/query.ts#L103)
+Defined in: [query.ts:106](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/query.ts#L106)
 
-Get all routable routes from tree as flat array
+Returns every route of the tree that has a route, in one flat array
 
-Returns all routes that have meta.route defined, excluding non-routable
-states and the synthetic root node. Useful for dynamically generating
-router configurations in framework adapters.
+The function returns each route with a `meta.route` field. It returns no state
+without a route, and no synthetic root node. Use it to generate a router
+configuration in a framework adapter dynamically.
 
 ## Parameters
 
-| Parameter | Type                                      | Description                            |
-| --------- | ----------------------------------------- | -------------------------------------- |
-| `tree`    | [`RouteTree`](../interfaces/RouteTree.md) | Route tree from extractMachineRoutes() |
+| Parameter | Type                                      | Description                                 |
+| --------- | ----------------------------------------- | ------------------------------------------- |
+| `tree`    | [`RouteTree`](../interfaces/RouteTree.md) | The route tree, from extractMachineRoutes() |
 
 ## Returns
 
 [`RouteNode`](../interfaces/RouteNode.md)[]
 
-Array of routable route nodes with path and stateId
+The array of the route nodes with a route, with their path and their stateId
 
 ## Example
 

package/api/@xmachines/play-router/functions/getTransitionReachableRoutes.md

@@ -6,31 +6,32 @@
 function getTransitionReachableRoutes(graph, stateId): string[];
 ```
 
-Defined in: [query.ts:154](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/query.ts#L154)
+Defined in: [query.ts:158](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/query.ts#L158)
 
-Get routes reachable via transitions from current state
+Returns the routes that a transition from the current state can reach
 
-Uses the @statelyai/graph successor algorithm to find all states
-directly reachable via transition edges from the given state,
-then filters to those with defined routes.
+The function uses the successor algorithm of @statelyai/graph. It finds every
+state of a direct transition edge from the given state, then it keeps the states
+with a route.
 
-Returned values are the RAW `meta.route` strings from the machine — relative
-routes (e.g. `"detail"`) are NOT resolved to full paths and cannot be used as
-`tree.byPath` keys. For resolved `RouteNode`s use `getNavigableRoutes`, which
-resolves reachable states through `tree.byStateId`.
+The values of the return are the RAW `meta.route` strings of the machine. The
+function does NOT resolve a relative route, for example `"detail"`, to a complete
+path, and such a value is therefore no key of `tree.byPath`. For a resolved
+`RouteNode`, use `getNavigableRoutes`: that function resolves each state that the
+transition reaches through `tree.byStateId`.
 
 ## Parameters
 
-| Parameter | Type                                                                                                                    | Description                          |
-| --------- | ----------------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
-| `graph`   | `Graph`\<[`MachineNodeData`](../interfaces/MachineNodeData.md), [`MachineEdgeData`](../interfaces/MachineEdgeData.md)\> | Machine graph from RouteTree.graph   |
-| `stateId` | `string`                                                                                                                | Current state ID (e.g., "test.home") |
+| Parameter | Type                                                                                                                    | Description                                          |
+| --------- | ----------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- |
+| `graph`   | `Graph`\<[`MachineNodeData`](../interfaces/MachineNodeData.md), [`MachineEdgeData`](../interfaces/MachineEdgeData.md)\> | The machine graph, from RouteTree.graph              |
+| `stateId` | `string`                                                                                                                | The ID of the current state, for example "test.home" |
 
 ## Returns
 
 `string`[]
 
-Array of raw route strings reachable via transitions
+The array of the raw route strings that a transition can reach
 
 ## Example
 
@@ -38,6 +39,6 @@ Array of raw route strings reachable via transitions
 const tree = extractMachineRoutes(machine);
 if (tree.graph) {
 	const reachable = getTransitionReachableRoutes(tree.graph, "auth.loggedIn");
-	// ['/dashboard', '/settings'] — routes reachable via transitions
+	// ['/dashboard', '/settings'] — the routes that a transition can reach
 }
 ```

package/api/@xmachines/play-router/functions/isRouteReachable.md

@@ -6,26 +6,27 @@
 function isRouteReachable(graph, fromStateId, toStateId): boolean;
 ```
 
-Defined in: [query.ts:181](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/query.ts#L181)
+Defined in: [query.ts:186](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/query.ts#L186)
 
-Check if a route is reachable from current state via transitions
+Tells you if a transition from the current state can reach a route
 
-Uses @statelyai/graph path-finding to determine if there exists
-a chain of transition edges from the source state to the target state.
+The function uses the path search of @statelyai/graph. It decides if a chain of
+transition edges is present from the state of the origin to the state of the
+target.
 
 ## Parameters
 
-| Parameter     | Type                                                                                                                    | Description                        |
-| ------------- | ----------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
-| `graph`       | `Graph`\<[`MachineNodeData`](../interfaces/MachineNodeData.md), [`MachineEdgeData`](../interfaces/MachineEdgeData.md)\> | Machine graph from RouteTree.graph |
-| `fromStateId` | `string`                                                                                                                | Source state ID                    |
-| `toStateId`   | `string`                                                                                                                | Target state ID                    |
+| Parameter     | Type                                                                                                                    | Description                             |
+| ------------- | ----------------------------------------------------------------------------------------------------------------------- | --------------------------------------- |
+| `graph`       | `Graph`\<[`MachineNodeData`](../interfaces/MachineNodeData.md), [`MachineEdgeData`](../interfaces/MachineEdgeData.md)\> | The machine graph, from RouteTree.graph |
+| `fromStateId` | `string`                                                                                                                | The ID of the state of the origin       |
+| `toStateId`   | `string`                                                                                                                | The ID of the state of the target       |
 
 ## Returns
 
 `boolean`
 
-true if a transition path exists, false otherwise
+true when a transition path is present. In every other case, false
 
 ## Example
 
@@ -33,6 +34,6 @@ true if a transition path exists, false otherwise
 const tree = extractMachineRoutes(machine);
 if (tree.graph) {
 	const canReach = isRouteReachable(tree.graph, "auth.login", "auth.dashboard");
-	// true if login → dashboard transition path exists
+	// it is true when a transition path from login to dashboard is present
 }
 ```

package/api/@xmachines/play-router/functions/machineToGraph.md

@@ -6,7 +6,7 @@
 function machineToGraph(machine): MachineGraph;
 ```
 
-Defined in: [machine-to-graph.ts:71](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/machine-to-graph.ts#L71)
+Defined in: [machine-to-graph.ts:73](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/machine-to-graph.ts#L73)
 
 ## Parameters
 

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

@@ -6,21 +6,21 @@
 function routeExists(tree, path): boolean;
 ```
 
-Defined in: [query.ts:125](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/query.ts#L125)
+Defined in: [query.ts:128](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/query.ts#L128)
 
-Validate route path exists in tree
+Tells you if a route path is in the tree
 
-Checks if path has corresponding state with meta.route.
+The function tests if the path has a state with a `meta.route` field.
 
 ## Parameters
 
-| Parameter | Type                                      | Description                                   |
-| --------- | ----------------------------------------- | --------------------------------------------- |
-| `tree`    | [`RouteTree`](../interfaces/RouteTree.md) | Route tree from extractMachineRoutes()        |
-| `path`    | `string`                                  | Full route path (e.g., '/dashboard/settings') |
+| Parameter | Type                                      | Description                                                |
+| --------- | ----------------------------------------- | ---------------------------------------------------------- |
+| `tree`    | [`RouteTree`](../interfaces/RouteTree.md) | The route tree, from extractMachineRoutes()                |
+| `path`    | `string`                                  | The complete route path, for example '/dashboard/settings' |
 
 ## Returns
 
 `boolean`
 
-true if path exists, false otherwise
+true when the tree holds the path. In every other case, false

package/api/@xmachines/play-router/functions/sanitizePathname.md

@@ -6,29 +6,31 @@
 function sanitizePathname(pathname): string | null;
 ```
 
-Defined in: [router-sync.ts:72](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/router-sync.ts#L72)
+Defined in: [router-sync.ts:74](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/router-sync.ts#L74)
 
-Normalize a pathname before route-map lookup.
+Normalizes a pathname before a lookup in the route map.
 
-This strips query/hash fragments, collapses duplicate slashes, and rejects
-implausibly long paths that should never enter route resolution.
+The function removes a query fragment and a hash fragment, it joins each duplicate
+slash into one, and it refuses a path of an improbable length, because such a path
+must never enter the route resolution.
 
-Returns `null` for paths exceeding 2048 characters (malformed/adversarial input).
-Adapters that bypass `RouterBridgeBase.syncActorFromRouter()` (e.g. `VueRouterBridge`)
-must call this function directly and return early on `null` to apply the same
-defense-in-depth security guarantee as the shared base class.
+It returns `null` for a path of more than 2048 characters, which is malformed or
+hostile input. An adapter that passes around
+`RouterBridgeBase.syncActorFromRouter()`, for example `VueRouterBridge`, must call
+this function itself, and it must return at once on a `null` value. That adapter
+then gives the same guarantee of the defense in depth as the shared base class.
 
 ## Parameters
 
-| Parameter  | Type     | Description                                   |
-| ---------- | -------- | --------------------------------------------- |
-| `pathname` | `string` | Raw path string from router navigation event. |
+| Parameter  | Type     | Description                                              |
+| ---------- | -------- | -------------------------------------------------------- |
+| `pathname` | `string` | The raw path string of a navigation event of the router. |
 
 ## Returns
 
 `string` \| `null`
 
-Normalized path string, or `null` if the path is malformed/too long.
+The normalized path string, or `null` when the path is malformed or too long.
 
 ## Example
 
@@ -36,5 +38,5 @@ Normalized path string, or `null` if the path is malformed/too long.
 import { sanitizePathname } from "@xmachines/play-router";
 
 const clean = sanitizePathname(to.path);
-if (clean === null) return; // reject malformed path
+if (clean === null) return; // refuse a malformed path
 ```

package/api/@xmachines/play-router/functions/validateRouteFormat.md

@@ -6,20 +6,20 @@
 function validateRouteFormat(routePath, stateId): void;
 ```
 
-Defined in: [validate-routes.ts:27](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/validate-routes.ts#L27)
+Defined in: [validate-routes.ts:27](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/validate-routes.ts#L27)
 
-Validate route path format
+Checks the format of a route path
 
-Ensures route paths are non-empty strings. Both absolute paths ("/foo")
-and relative paths ("foo", "child/nested") are accepted. Relative routes
-inherit their parent state's path prefix when the tree is built.
+The function requires a string that is not empty. It accepts an absolute path
+("/foo") and also a relative path ("foo" or "child/nested"). A relative route
+receives the path prefix of its parent state during the construction of the tree.
 
 ## Parameters
 
-| Parameter   | Type     | Description                                   |
-| ----------- | -------- | --------------------------------------------- |
-| `routePath` | `string` | Route path to validate (absolute or relative) |
-| `stateId`   | `string` | State identifier for error messages           |
+| Parameter   | Type     | Description                                        |
+| ----------- | -------- | -------------------------------------------------- |
+| `routePath` | `string` | The route path to check: absolute or relative      |
+| `stateId`   | `string` | The identifier of the state, for the error message |
 
 ## Returns
 
@@ -27,4 +27,4 @@ inherit their parent state's path prefix when the tree is built.
 
 ## Throws
 
-If route path is empty
+When the route path is empty

package/api/@xmachines/play-router/functions/validateStateExists.md

@@ -6,19 +6,19 @@
 function validateStateExists(stateId, stateIds): void;
 ```
 
-Defined in: [validate-routes.ts:43](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/validate-routes.ts#L43)
+Defined in: [validate-routes.ts:43](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/validate-routes.ts#L43)
 
-Validate state exists in state ID set
+Checks that the set of the state IDs holds a state
 
-Ensures referenced state IDs exist in the machine graph.
-Build-time validation prevents broken route references.
+The function requires each state ID of a reference in the machine graph. This
+check at the build time therefore stops a broken route reference.
 
 ## Parameters
 
-| Parameter  | Type              | Description                                       |
-| ---------- | ----------------- | ------------------------------------------------- |
-| `stateId`  | `string`          | State identifier to validate                      |
-| `stateIds` | `Set`\<`string`\> | Set of all known state IDs from the machine graph |
+| Parameter  | Type              | Description                                          |
+| ---------- | ----------------- | ---------------------------------------------------- |
+| `stateId`  | `string`          | The identifier of the state to check                 |
+| `stateIds` | `Set`\<`string`\> | The set of every known state ID of the machine graph |
 
 ## Returns
 
@@ -26,4 +26,4 @@ Build-time validation prevents broken route references.
 
 ## Throws
 
-If state ID doesn't exist in set
+When the set does not hold the state ID

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

@@ -2,12 +2,12 @@
 
 # Interface: BuildPlayRouteEventOptions
 
-Defined in: [router-sync.ts:17](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/router-sync.ts#L17)
+Defined in: [router-sync.ts:17](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/router-sync.ts#L17)
 
 ## Properties
 
-| Property                                  | Type                                                   | Defined in                                                                                                                        |
-| ----------------------------------------- | ------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-match"></a> `match`       | (`sanitizedPathname`) => [`RouteMatch`](RouteMatch.md) | [router-sync.ts:20](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/router-sync.ts#L20) |
-| <a id="property-pathname"></a> `pathname` | `string`                                               | [router-sync.ts:18](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/router-sync.ts#L18) |
-| <a id="property-search"></a> `search?`    | `string`                                               | [router-sync.ts:19](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/router-sync.ts#L19) |
+| Property                                  | Type                                                   | Defined in                                                                                                                |
+| ----------------------------------------- | ------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-match"></a> `match`       | (`sanitizedPathname`) => [`RouteMatch`](RouteMatch.md) | [router-sync.ts:20](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/router-sync.ts#L20) |
+| <a id="property-pathname"></a> `pathname` | `string`                                               | [router-sync.ts:18](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/router-sync.ts#L18) |
+| <a id="property-search"></a> `search?`    | `string`                                               | [router-sync.ts:19](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/router-sync.ts#L19) |

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

@@ -2,26 +2,26 @@
 
 # Interface: LocationLike
 
-Defined in: [types.ts:433](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L433)
+Defined in: [types.ts:432](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/types.ts#L432)
 
-Minimal location interface required by adapters that read the current URL at
-`connect()` time. Injectable for SSR and testing — pass a mock instead of the
-global `location` when the DOM is unavailable.
+The minimal location interface of an adapter that reads the current URL at the
+moment of `connect()`. You can inject it for SSR and for a test: give a mock in
+place of the global `location` when no DOM is available.
 
-Defined structurally (no `Location` reference) so this package compiles without
-the DOM lib.
+The definition is structural, and it holds no reference to `Location`. This package
+therefore compiles without the DOM lib.
 
 ## Example
 
 ```typescript
-// SSR / test — injected mock
+// SSR or a test — an injected mock
 const mockLoc: LocationLike = { pathname: "/dashboard", search: "?tab=posts" };
 connectRouter({ actor, routeMap, location: mockLoc });
 ```
 
 ## Properties
 
-| Property                                  | Modifier   | Type     | Defined in                                                                                                              |
-| ----------------------------------------- | ---------- | -------- | ----------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-pathname"></a> `pathname` | `readonly` | `string` | [types.ts:434](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L434) |
-| <a id="property-search"></a> `search`     | `readonly` | `string` | [types.ts:435](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L435) |
+| Property                                  | Modifier   | Type     | Defined in                                                                                                      |
+| ----------------------------------------- | ---------- | -------- | --------------------------------------------------------------------------------------------------------------- |
+| <a id="property-pathname"></a> `pathname` | `readonly` | `string` | [types.ts:433](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/types.ts#L433) |
+| <a id="property-search"></a> `search`     | `readonly` | `string` | [types.ts:434](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/types.ts#L434) |

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

@@ -2,16 +2,14 @@
 
 # Interface: MachineEdgeData
 
-Defined in: [types.ts:24](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L24)
+Defined in: [types.ts:24](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/types.ts#L24)
 
-Data attached to each edge in the machine graph representation.
-Captures transition event and guard information.
+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-dynamic"></a> `dynamic?`         | `boolean` | True when the transition is an XState v6 function transition: the function acts as its own guard/resolver, so its target and conditionality are dynamic and unknowable statically (the edge's target falls back to the source state).                                                    | [types.ts:47](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L47) |
-| <a id="property-eventtype"></a> `eventType`      | `string`  | The event type that triggers this transition                                                                                                                                                                                                                                             | [types.ts:26](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L26) |
-| <a id="property-guarded"></a> `guarded?`         | `boolean` | True when a guard function gates this transition. XState v6 compiles all guards to functions (authored predicates, JSON-layer names, and the route-matching guard synthesized on native route transitions), so only the presence of a guard — not its identity — is statically knowable. | [types.ts:40](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L40) |
-| <a id="property-guardtype"></a> ~~`guardType?`~~ | `string`  | **Deprecated** Never populated under XState v6: every guard (including JSON-layer guard names via `createMachineFromConfig`) compiles to a function, so guard identity is unrecoverable statically. Use [MachineEdgeData.guarded](#property-guarded) instead.                            | [types.ts:33](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L33) |
+| Property                                         | Type     | Description                                                                                      | Defined in                                                                                                    |
+| ------------------------------------------------ | -------- | ------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------- |
+| <a id="property-eventtype"></a> `eventType`      | `string` | The event type that starts this transition                                                       | [types.ts:26](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/types.ts#L26) |
+| <a id="property-guardtype"></a> ~~`guardType?`~~ | `string` | The guard as a string, when a guard is present **Deprecated** Will be removed in the next major. | [types.ts:32](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.1.0/packages/play-router/src/types.ts#L32) |