@xmachines/docs 1.0.0-beta.9 → 2.0.0-alpha.1

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

@@ -1,4 +1,4 @@
-[Documentation](../../../README.md) / [@xmachines/play-router](../README.md) / detectDuplicateRoutes
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / detectDuplicateRoutes
 
 # Function: detectDuplicateRoutes()
 
@@ -6,11 +6,18 @@
 function detectDuplicateRoutes(routes): void;
 ```
 
-Defined in: [validate-routes.ts:51](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-router/src/validate-routes.ts#L51)
+Defined in: [validate-routes.ts:69](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/validate-routes.ts#L69)
 
 Detect duplicate route paths
 
-THROWS ERROR when multiple states share the same route path.
+THROWS ERROR when multiple states share the same RESOLVED full path.
+
+Detection operates on resolved full paths (after relative routes have been
+prefixed with their parent's path in `buildRouteTree`), not on raw route
+strings: two relative `"settings"` routes under different parents resolve to
+distinct full paths and are valid, while a relative route and an absolute
+route resolving to the same URL genuinely collide and must be rejected.
+Called from `buildRouteTree` once full paths are known.
 
 Rationale: URL-based routing requires one-to-one mapping between URLs and states.
 Multiple states at the same path creates ambiguity for browser navigation (back button,
@@ -19,9 +26,9 @@ conditional rendering.
 
 ## Parameters
 
-| Parameter | Type                                        | Description                          |
-| --------- | ------------------------------------------- | ------------------------------------ |
-| `routes`  | [`RouteInfo`](../interfaces/RouteInfo.md)[] | Array of extracted RouteInfo objects |
+| Parameter | Type                                                        | Description                                                         |
+| --------- | ----------------------------------------------------------- | ------------------------------------------------------------------- |
+| `routes`  | [`ResolvedRoutePath`](../interfaces/ResolvedRoutePath.md)[] | Array of route entries with resolved full paths (e.g. `RouteNode`s) |
 
 ## Returns
 
@@ -29,4 +36,4 @@ conditional rendering.
 
 ## Throws
 
-If duplicate route paths are detected
+If duplicate resolved route paths are detected

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

@@ -1,4 +1,4 @@
-[Documentation](../../../README.md) / [@xmachines/play-router](../README.md) / extractMachineRoutes
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / extractMachineRoutes
 
 # Function: extractMachineRoutes()
 
@@ -6,59 +6,23 @@
 function extractMachineRoutes(machine): RouteTree;
 ```
 
-Defined in: [extract-routes.ts:45](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-router/src/extract-routes.ts#L45)
+Defined in: [extract-routes.ts:89](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/extract-routes.ts#L89)
 
 Extract complete route tree from state machine graph
 
-Crawls machine starting from root, visits all state nodes (including nested
-and parallel), extracts meta.route metadata, validates route references,
-and builds hierarchical tree.
+Converts the XState machine to a @statelyai/graph Graph via machineToGraph(),
+then walks graph nodes to extract route metadata, validate route references,
+and build a hierarchical RouteTree. The graph is attached to the returned
+RouteTree for downstream transition-aware queries.
 
 ## Parameters
 
-| Parameter | Type              | Description             |
-| --------- | ----------------- | ----------------------- |
-| `machine` | `AnyStateMachine` | XState v5 state machine |
+| Parameter | Type                                                                      | Description             |
+| --------- | ------------------------------------------------------------------------- | ----------------------- |
+| `machine` | [`AnyStateMachine`](https://www.jsdocs.io/package/xstate#AnyStateMachine) | XState v6 state machine |
 
 ## Returns
 
 [`RouteTree`](../interfaces/RouteTree.md)
 
-Route tree with root, byStateId map, and byPath map
-
-## Throws
-
-If route references non-existent state
-
-## Throws
-
-If route path is malformed (doesn't start with /)
-
-## Throws
-
-If parallel states define conflicting routes
-
-## Example
-
-```typescript
-import { createMachine } from "xstate";
-import { extractMachineRoutes } from "@xmachines/play-router";
-
-const machine = createMachine({
-	initial: "home",
-	states: {
-		home: { id: "home", meta: { route: "/" } },
-		dashboard: {
-			id: "dashboard",
-			meta: { route: "/dashboard" },
-			initial: "overview",
-			states: {
-				overview: { id: "overview", meta: { route: "/overview" } },
-			},
-		},
-	},
-});
-
-const tree = extractMachineRoutes(machine);
-console.log(tree.byPath.get("/dashboard/overview"));
-```
+Route tree with root, byStateId map, byPath map, and graph

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

@@ -0,0 +1,22 @@
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / extractQuery
+
+# Function: extractQuery()
+
+```ts
+function extractQuery(search): Record<string, string>;
+```
+
+Defined in: [router-sync.ts:149](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/router-sync.ts#L149)
+
+Parse a URL search string into the plain object shape expected by
+`play.route` events.
+
+## Parameters
+
+| Parameter | Type     |
+| --------- | -------- |
+| `search`  | `string` |
+
+## Returns
+
+`Record`\<`string`, `string`\>

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

@@ -0,0 +1,54 @@
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / extractRouteParams
+
+# Function: extractRouteParams()
+
+```ts
+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)
+
+Extract named path parameters from a URL using 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`.
+
+Undefined values (unmatched optional segments, e.g. `/settings` against
+`/settings/:section?`) are omitted from the returned object.
+
+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" }`.
+
+Values are percent-decoded (`john%20doe` → `john doe`), matching framework
+router semantics (e.g. vue-router). Malformed sequences are kept 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`) |
+
+## Returns
+
+`Record`\<`string`, `string`\>
+
+A record of extracted parameter values, or `{}` for static patterns.
+
+## Throws
+
+When `URLPattern` is absent and the pattern is parameterized.
+
+## Example
+
+```typescript
+import { extractRouteParams } from "@xmachines/play-router";
+
+extractRouteParams("/profile/alice", "/profile/:username");
+// → { username: "alice" }
+
+extractRouteParams("/settings", "/settings/:section?");
+// → {}  (optional param absent — not included)
+```

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

@@ -1,4 +1,4 @@
-[Documentation](../../../README.md) / [@xmachines/play-router](../README.md) / findRouteById
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / findRouteById
 
 # Function: findRouteById()
 
@@ -6,7 +6,7 @@
 function findRouteById(tree, id): RouteNode | undefined;
 ```
 
-Defined in: [index.ts:65](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-router/src/index.ts#L65)
+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)
 
 Find route node by state ID
 

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

@@ -1,4 +1,4 @@
-[Documentation](../../../README.md) / [@xmachines/play-router](../README.md) / findRouteByPath
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / findRouteByPath
 
 # Function: findRouteByPath()
 
@@ -6,7 +6,7 @@
 function findRouteByPath(tree, path): RouteNode | undefined;
 ```
 
-Defined in: [index.ts:157](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-router/src/index.ts#L157)
+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)
 
 Find route node by URL path
 

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

@@ -1,4 +1,4 @@
-[Documentation](../../../README.md) / [@xmachines/play-router](../README.md) / getNavigableRoutes
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / getNavigableRoutes
 
 # Function: getNavigableRoutes()
 
@@ -6,7 +6,7 @@
 function getNavigableRoutes(tree, stateId): RouteNode[];
 ```
 
-Defined in: [query.ts:20](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-router/src/query.ts#L20)
+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)
 
 Get all routes navigable from given state
 

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

@@ -1,4 +1,4 @@
-[Documentation](../../../README.md) / [@xmachines/play-router](../README.md) / getRoutableRoutes
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / getRoutableRoutes
 
 # Function: getRoutableRoutes()
 
@@ -6,7 +6,7 @@
 function getRoutableRoutes(tree): RouteNode[];
 ```
 
-Defined in: [query.ts:50](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-router/src/query.ts#L50)
+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)
 
 Get all routable routes from tree as flat array
 

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

@@ -0,0 +1,43 @@
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / getTransitionReachableRoutes
+
+# Function: getTransitionReachableRoutes()
+
+```ts
+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)
+
+Get routes reachable via transitions from current state
+
+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.
+
+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`.
+
+## 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") |
+
+## Returns
+
+`string`[]
+
+Array of raw route strings reachable via transitions
+
+## Example
+
+```typescript
+const tree = extractMachineRoutes(machine);
+if (tree.graph) {
+	const reachable = getTransitionReachableRoutes(tree.graph, "auth.loggedIn");
+	// ['/dashboard', '/settings'] — routes reachable via transitions
+}
+```

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

@@ -0,0 +1,38 @@
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / isRouteReachable
+
+# Function: isRouteReachable()
+
+```ts
+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)
+
+Check if a route is reachable from current state via transitions
+
+Uses @statelyai/graph path-finding to determine if there exists
+a chain of transition edges from the source state to the target state.
+
+## 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                    |
+
+## Returns
+
+`boolean`
+
+true if a transition path exists, false otherwise
+
+## Example
+
+```typescript
+const tree = extractMachineRoutes(machine);
+if (tree.graph) {
+	const canReach = isRouteReachable(tree.graph, "auth.login", "auth.dashboard");
+	// true if login → dashboard transition path exists
+}
+```

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

@@ -0,0 +1,19 @@
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / machineToGraph
+
+# Function: machineToGraph()
+
+```ts
+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)
+
+## Parameters
+
+| Parameter | Type                                                                      |
+| --------- | ------------------------------------------------------------------------- |
+| `machine` | [`AnyStateMachine`](https://www.jsdocs.io/package/xstate#AnyStateMachine) |
+
+## Returns
+
+[`MachineGraph`](../type-aliases/MachineGraph.md)

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

@@ -1,4 +1,4 @@
-[Documentation](../../../README.md) / [@xmachines/play-router](../README.md) / routeExists
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / routeExists
 
 # Function: routeExists()
 
@@ -6,7 +6,7 @@
 function routeExists(tree, path): boolean;
 ```
 
-Defined in: [query.ts:72](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-router/src/query.ts#L72)
+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)
 
 Validate route path exists in tree
 

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

@@ -0,0 +1,40 @@
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / sanitizePathname
+
+# Function: sanitizePathname()
+
+```ts
+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)
+
+Normalize a pathname before route-map lookup.
+
+This strips query/hash fragments, collapses duplicate slashes, and rejects
+implausibly long paths that should never enter 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.
+
+## Parameters
+
+| Parameter  | Type     | Description                                   |
+| ---------- | -------- | --------------------------------------------- |
+| `pathname` | `string` | Raw path string from router navigation event. |
+
+## Returns
+
+`string` \| `null`
+
+Normalized path string, or `null` if the path is malformed/too long.
+
+## Example
+
+```typescript
+import { sanitizePathname } from "@xmachines/play-router";
+
+const clean = sanitizePathname(to.path);
+if (clean === null) return; // reject malformed path
+```

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

@@ -1,4 +1,4 @@
-[Documentation](../../../README.md) / [@xmachines/play-router](../README.md) / validateRouteFormat
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / validateRouteFormat
 
 # Function: validateRouteFormat()
 
@@ -6,19 +6,20 @@
 function validateRouteFormat(routePath, stateId): void;
 ```
 
-Defined in: [validate-routes.ts:14](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-router/src/validate-routes.ts#L14)
+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)
 
 Validate route path format
 
-Ensures route paths start with "/" (absolute or relative).
-Per Route Protocol spec, all routes must have explicit path structure.
+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.
 
 ## Parameters
 
-| Parameter   | Type     | Description                         |
-| ----------- | -------- | ----------------------------------- |
-| `routePath` | `string` | Route path to validate              |
-| `stateId`   | `string` | State identifier for error messages |
+| Parameter   | Type     | Description                                   |
+| ----------- | -------- | --------------------------------------------- |
+| `routePath` | `string` | Route path to validate (absolute or relative) |
+| `stateId`   | `string` | State identifier for error messages           |
 
 ## Returns
 
@@ -26,4 +27,4 @@ Per Route Protocol spec, all routes must have explicit path structure.
 
 ## Throws
 
-If route path doesn't start with /
+If route path is empty

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

@@ -1,24 +1,24 @@
-[Documentation](../../../README.md) / [@xmachines/play-router](../README.md) / validateStateExists
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / validateStateExists
 
 # Function: validateStateExists()
 
 ```ts
-function validateStateExists(stateId, stateMap): void;
+function validateStateExists(stateId, stateIds): void;
 ```
 
-Defined in: [validate-routes.ts:32](https://gitlab.com/xmachin-es/xmachines-js/-/blob/00a28432ed57807112288436d1ae4387d9f06919/packages/play-router/src/validate-routes.ts#L32)
+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)
 
-Validate state exists in state map
+Validate state exists in state ID set
 
 Ensures referenced state IDs exist in the machine graph.
 Build-time validation prevents broken route references.
 
 ## Parameters
 
-| Parameter  | Type                                                              | Description                        |
-| ---------- | ----------------------------------------------------------------- | ---------------------------------- |
-| `stateId`  | `string`                                                          | State identifier to validate       |
-| `stateMap` | `Map`\<`string`, `StateNode`\<`MachineContext`, `EventObject`\>\> | Map of all state IDs to StateNodes |
+| Parameter  | Type              | Description                                       |
+| ---------- | ----------------- | ------------------------------------------------- |
+| `stateId`  | `string`          | State identifier to validate                      |
+| `stateIds` | `Set`\<`string`\> | Set of all known state IDs from the machine graph |
 
 ## Returns
 
@@ -26,4 +26,4 @@ Build-time validation prevents broken route references.
 
 ## Throws
 
-If state ID doesn't exist in map
+If state ID doesn't exist in set

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

@@ -0,0 +1,13 @@
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / BuildPlayRouteEventOptions
+
+# 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)
+
+## 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) |

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

@@ -0,0 +1,27 @@
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / LocationLike
+
+# 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)
+
+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.
+
+Defined structurally (no `Location` reference) so this package compiles without
+the DOM lib.
+
+## Example
+
+```typescript
+// SSR / test — 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) |

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

@@ -0,0 +1,17 @@
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / MachineEdgeData
+
+# 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)
+
+Data attached to each edge in the machine graph representation.
+Captures transition event and guard information.
+
+## 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) |

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

@@ -0,0 +1,17 @@
+[API](../../../README.md) / [@xmachines/play-router](../README.md) / MachineNodeData
+
+# Interface: MachineNodeData
+
+Defined in: [types.ts:9](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L9)
+
+Data attached to each node in the machine graph representation.
+Captures the essential state metadata needed for route extraction and queries.
+
+## Properties
+
+| Property                                | Type                                                                   | Description                                        | Defined in                                                                                                            |
+| --------------------------------------- | ---------------------------------------------------------------------- | -------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-meta"></a> `meta?`      | `Record`\<`string`, `unknown`\>                                        | Original state meta object                         | [types.ts:15](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L15) |
+| <a id="property-route"></a> `route?`    | `string`                                                               | Extracted route path from meta.route (string form) | [types.ts:17](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L17) |
+| <a id="property-stateid"></a> `stateId` | `string`                                                               | XState state ID (e.g., "test.dashboard.overview")  | [types.ts:11](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L11) |
+| <a id="property-type"></a> `type`       | `"history"` \| `"atomic"` \| `"compound"` \| `"parallel"` \| `"final"` | State type from XState                             | [types.ts:13](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v2.0.0-alpha.1/packages/play-router/src/types.ts#L13) |