@xmachines/play-xstate 2.0.0 → 2.1.0

package/dist/routing/derive-current-route.js.map

@@ -1 +1 @@
-{"version":3,"file":"derive-current-route.js","sourceRoot":"","sources":["../../src/routing/derive-current-route.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"derive-current-route.js","sourceRoot":"","sources":["../../src/routing/derive-current-route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACpC,QAA4B,EACK,EAAE;IACnC,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,EAAE,IAEnB,CAAC;IACb,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IAEvB,MAAM,OAAO,GAA4B,EAAE,CAAC;IAC5C,IAAI,IAAI,GAA4B,IAAI,CAAC;IACzC,IAAI,KAAK,GAAY,QAAQ,CAAC,KAAK,CAAC;IAEpC,OAAO,IAAI,EAAE,CAAC;QACb,IAAI,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAChD,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,mDAAmD;QAClF,CAAC;QAED,mFAAmF;QACnF,6EAA6E;QAC7E,2EAA2E;QAC3E,UAAU;QACV,IAAI,GAAuB,CAAC;QAC5B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC/B,GAAG,GAAG,KAAK,CAAC;QACb,CAAC;aAAM,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC/C,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7B,CAAC;QACD,IAAI,GAAG,KAAK,SAAS;YAAE,MAAM;QAE7B,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,GAAG,CAA4B,CAAC,CAAC,mDAAmD;QAChH,IAAI,CAAC,KAAK;YAAE,MAAM;QAClB,KAAK;YACJ,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;gBAC1C,CAAC,CAAE,KAAiC,CAAC,GAAG,CAAC,CAAC,mDAAmD;gBAC7F,CAAC,CAAC,EAAE,CAAC;QACP,IAAI,GAAG,KAAK,CAAC;IACd,CAAC;IAED,OAAO,OAAO,CAAC;AAChB,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,QAA4B,EAAkC,EAAE;IAC/F,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QACzD,OAAO,IAAI,CAAC;IACb,CAAC;IACD,MAAM,IAAI,GAAG,qBAAqB,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;IACnE,OAAO,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAE,IAAgC,CAAC,CAAC,CAAC,IAAI,CAAC;AACpF,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,QAA4B,EAAiB,EAAE;IACjF,MAAM,IAAI,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;IACvC,IAAI,CAAC,IAAI,EAAE,CAAC;QACX,OAAO,IAAI,CAAC;IACb,CAAC;IAED,MAAM,aAAa,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;IACxC,IAAI,CAAC,aAAa,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC;IACb,CAAC;IAED,IAAI,CAAC;QACJ,OAAO,aAAa,CAAC,aAAa,EAAE,CAAC,QAAQ,CAAC,OAAO,IAAI,EAAE,CAAiB,CAAC,CAAC;IAC/E,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,gFAAgF;QAChF,oFAAoF;QACpF,gFAAgF;QAChF,iFAAiF;QACjF,yBAAyB;QACzB,0FAA0F;QAC1F,uFAAuF;QACvF,iFAAiF;QACjF,0EAA0E;QAC1E,oCAAoC;QACpC,IAAI,KAAK,YAAY,sBAAsB,EAAE,CAAC;YAC7C,OAAO,IAAI,CAAC;QACb,CAAC;QACD,6DAA6D;QAC7D,MAAM,KAAK,CAAC;IACb,CAAC;AACF,CAAC,CAAC"}

package/dist/routing/derive-initial-route.d.ts

@@ -1,29 +1,32 @@
 import { type AnyStateMachine } from "xstate";
 /**
- * Derive the machine's initial route directly from the machine definition.
+ * Derives the initial route of the machine directly from the machine definition.
  *
- * Uses XState's pure `initialTransition` helper to compute the machine's initial
- * snapshot — resolving the full initial state chain (including nested compound
- * states) and the real initial context for the given `input` — without creating
- * an actor and without executing entry actions.
+ * The function uses the pure `initialTransition` helper of XState to compute the
+ * initial snapshot of the machine. That helper resolves the complete chain of the
+ * initial states, which includes each nested compound state, and also the real
+ * initial context for the given `input`. It makes no actor, and it runs no entry
+ * action.
  *
- * Route resolution follows the same rules as {@link deriveCurrentRoute} for live
- * snapshots: the deepest routed state wins, relative `meta.route` segments resolve
- * against routed ancestors, and `:param` placeholders substitute from the initial
- * `context.params`.
+ * The resolution of the route follows the same rules as {@link deriveCurrentRoute}
+ * for a live snapshot: the deepest state with a route wins, a relative `meta.route`
+ * segment resolves against the ancestors with a route, and each `:param` placeholder
+ * receives a value of the initial `context.params`.
  *
- * Router bridges compare the resulting value against the browser URL to distinguish
- * a deep-link (non-initial URL → router wins) from a restore (initial URL + actor at
- * a different restored route → actor wins). Because the derivation never consults a
- * restored snapshot, it always yields the machine's **default** initial route.
+ * A router bridge compares the result with the browser URL. It therefore separates a
+ * deep link (a URL that is not the initial one → the router wins) from a restore
+ * (the initial URL, and the actor at a different route from the restore → the actor
+ * wins). The derivation reads no snapshot of a restore. Therefore it always gives
+ * the **default** initial route of the machine.
  *
- * @param machine - XState v5 state machine definition.
- * @param input - Actor input, applied to the machine's context factory exactly as
- *   `createActor(machine, { input })` would.
- * @returns Resolved initial URL string, or `null` if the initial state has no
- *   `meta.route`, a required `:param` is absent from the initial context, or the
- *   machine's context/initial-transition logic throws for the given input (mirroring
- *   `createActor`'s error-status snapshot, which has no derivable route either).
+ * @param machine - The definition of the XState v5 state machine.
+ * @param input - The input of the actor. The function gives it to the context
+ *   factory of the machine, exactly like `createActor(machine, { input })`.
+ * @returns The resolved initial URL string, or `null`. The function returns `null`
+ *   in three cases: the initial state has no `meta.route` field; the initial context
+ *   does not hold a necessary `:param`; or the context logic or the initial-transition
+ *   logic of the machine throws for the given input. The last case matches the
+ *   error-status snapshot of `createActor`, which also has no route to derive.
  *
  * @example
  * ```typescript

package/dist/routing/derive-initial-route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derive-initial-route.d.ts","sourceRoot":"","sources":["../../src/routing/derive-initial-route.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8C,KAAK,eAAe,EAAE,MAAM,QAAQ,CAAC;AAI1F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,eAAe,EAAE,QAAQ,OAAO,KAAG,MAAM,GAAG,IAavF,CAAC"}
+{"version":3,"file":"derive-initial-route.d.ts","sourceRoot":"","sources":["../../src/routing/derive-initial-route.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8C,KAAK,eAAe,EAAE,MAAM,QAAQ,CAAC;AAI1F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,eAAe,EAAE,QAAQ,OAAO,KAAG,MAAM,GAAG,IAavF,CAAC"}

package/dist/routing/derive-initial-route.js

@@ -1,30 +1,33 @@
 import { initialTransition } from "xstate";
 import { deriveCurrentRoute } from "./derive-current-route.js";
 /**
- * Derive the machine's initial route directly from the machine definition.
+ * Derives the initial route of the machine directly from the machine definition.
  *
- * Uses XState's pure `initialTransition` helper to compute the machine's initial
- * snapshot — resolving the full initial state chain (including nested compound
- * states) and the real initial context for the given `input` — without creating
- * an actor and without executing entry actions.
+ * The function uses the pure `initialTransition` helper of XState to compute the
+ * initial snapshot of the machine. That helper resolves the complete chain of the
+ * initial states, which includes each nested compound state, and also the real
+ * initial context for the given `input`. It makes no actor, and it runs no entry
+ * action.
  *
- * Route resolution follows the same rules as {@link deriveCurrentRoute} for live
- * snapshots: the deepest routed state wins, relative `meta.route` segments resolve
- * against routed ancestors, and `:param` placeholders substitute from the initial
- * `context.params`.
+ * The resolution of the route follows the same rules as {@link deriveCurrentRoute}
+ * for a live snapshot: the deepest state with a route wins, a relative `meta.route`
+ * segment resolves against the ancestors with a route, and each `:param` placeholder
+ * receives a value of the initial `context.params`.
  *
- * Router bridges compare the resulting value against the browser URL to distinguish
- * a deep-link (non-initial URL → router wins) from a restore (initial URL + actor at
- * a different restored route → actor wins). Because the derivation never consults a
- * restored snapshot, it always yields the machine's **default** initial route.
+ * A router bridge compares the result with the browser URL. It therefore separates a
+ * deep link (a URL that is not the initial one → the router wins) from a restore
+ * (the initial URL, and the actor at a different route from the restore → the actor
+ * wins). The derivation reads no snapshot of a restore. Therefore it always gives
+ * the **default** initial route of the machine.
  *
- * @param machine - XState v5 state machine definition.
- * @param input - Actor input, applied to the machine's context factory exactly as
- *   `createActor(machine, { input })` would.
- * @returns Resolved initial URL string, or `null` if the initial state has no
- *   `meta.route`, a required `:param` is absent from the initial context, or the
- *   machine's context/initial-transition logic throws for the given input (mirroring
- *   `createActor`'s error-status snapshot, which has no derivable route either).
+ * @param machine - The definition of the XState v5 state machine.
+ * @param input - The input of the actor. The function gives it to the context
+ *   factory of the machine, exactly like `createActor(machine, { input })`.
+ * @returns The resolved initial URL string, or `null`. The function returns `null`
+ *   in three cases: the initial state has no `meta.route` field; the initial context
+ *   does not hold a necessary `:param`; or the context logic or the initial-transition
+ *   logic of the machine throws for the given input. The last case matches the
+ *   error-status snapshot of `createActor`, which also has no route to derive.
  *
  * @example
  * ```typescript
@@ -43,10 +46,10 @@ export const deriveInitialRoute = (machine, input) => {
         [initialSnapshot] = initialTransition(machine, input);
     }
     catch {
-        // Context factory or initial-transition logic threw for this input (e.g. a
-        // factory reading a required `input` field when none was provided). This is
-        // the pure-helper equivalent of createActor's error-status snapshot, which
-        // has no route metadata either — report "no derivable initial route".
+        // The context factory or the initial-transition logic threw for this input, for
+        // example a factory that reads a necessary `input` field and receives none. This is
+        // the equivalent of the error-status snapshot of createActor in the pure helper, and
+        // that snapshot also has no route metadata. Report "no initial route to derive".
         return null;
     }
     return deriveCurrentRoute(initialSnapshot);

package/dist/routing/derive-initial-route.js.map

@@ -1 +1 @@
-{"version":3,"file":"derive-initial-route.js","sourceRoot":"","sources":["../../src/routing/derive-initial-route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAiD,MAAM,QAAQ,CAAC;AAE1F,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,OAAwB,EAAE,KAAe,EAAiB,EAAE;IAC9F,IAAI,eAAmC,CAAC;IACxC,IAAI,CAAC;QACJ,CAAC,eAAe,CAAC,GAAG,iBAAiB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACvD,CAAC;IAAC,MAAM,CAAC;QACR,2EAA2E;QAC3E,4EAA4E;QAC5E,2EAA2E;QAC3E,sEAAsE;QACtE,OAAO,IAAI,CAAC;IACb,CAAC;IAED,OAAO,kBAAkB,CAAC,eAAe,CAAC,CAAC;AAC5C,CAAC,CAAC"}
+{"version":3,"file":"derive-initial-route.js","sourceRoot":"","sources":["../../src/routing/derive-initial-route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAiD,MAAM,QAAQ,CAAC;AAE1F,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,OAAwB,EAAE,KAAe,EAAiB,EAAE;IAC9F,IAAI,eAAmC,CAAC;IACxC,IAAI,CAAC;QACJ,CAAC,eAAe,CAAC,GAAG,iBAAiB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACvD,CAAC;IAAC,MAAM,CAAC;QACR,gFAAgF;QAChF,oFAAoF;QACpF,qFAAqF;QACrF,iFAAiF;QACjF,OAAO,IAAI,CAAC;IACb,CAAC;IAED,OAAO,kBAAkB,CAAC,eAAe,CAAC,CAAC;AAC5C,CAAC,CAAC"}

package/dist/routing/derive-route.d.ts

@@ -1,21 +1,22 @@
 import type { RouteMetadata } from "./types.js";
 /**
- * Derive route from XState state metadata
+ * Derives the route from the metadata of an XState state
  *
- * Extracts route URL template from `meta.route` in the active state's metadata.
- * Supports both string routes (`"/about"`) and object routes with path property
- * (`{ path: "/about" }`). Returns null for states without route metadata (not
- * all states need to be routable).
+ * The function reads the URL template of the route from the `meta.route` field in
+ * the metadata of the active state. It supports a string route (`"/about"`) and also
+ * an object route with a path property (`{ path: "/about" }`). It returns null for a
+ * state without route metadata, because not every state needs a route.
  *
- * **Architectural Context:** Implements **Actor Authority (INV-01)** by extracting
- * routing information from state machine definitions rather than external configuration.
- * The route is determined by the Actor's current state, not by infrastructure decisions.
+ * **Architectural context:** the function implements **Actor Authority (INV-01)**,
+ * because it reads the routing information from the state machine definition, and
+ * not from an external configuration. The current state of the Actor decides the
+ * route, and no decision of the infrastructure decides it.
  *
- * @param stateMeta - State metadata from snapshot.getMeta()
- * @returns Route path template (may include :params) or null if no route found
+ * @param stateMeta - The state metadata from snapshot.getMeta()
+ * @returns The template of the route path, which can hold a :param, or null when the function finds no route
  *
  * @example
- * Basic route extraction
+ * The basic read of a route
  * ```typescript
  * import { deriveRoute } from "@xmachines/play-xstate";
  * import { setup } from "xstate";
@@ -38,7 +39,7 @@ import type { RouteMetadata } from "./types.js";
  * ```
  *
  * @example
- * Route with parameters
+ * A route with a parameter
  * ```typescript
  * const machine = setup({}).createMachine({
  *   states: {
@@ -52,11 +53,11 @@ import type { RouteMetadata } from "./types.js";
  * });
  *
  * const route = deriveRoute(snapshot.getMeta());
- * console.log(route); // "/profile/:userId" (template, before substitution)
+ * console.log(route); // "/profile/:userId" — the template, before the substitution
  * ```
  *
  * @example
- * Route object format
+ * The object form of a route
  * ```typescript
  * const machine = setup({}).createMachine({
  *   states: {
@@ -74,41 +75,41 @@ import type { RouteMetadata } from "./types.js";
  * ```
  *
  * @see [Play RFC](../../../docs/rfc/play.md)
- * @see {@link buildRouteUrl} for URL construction with parameter substitution
- * @see {@link isAbsoluteRoute} for checking path absoluteness
+ * @see {@link buildRouteUrl} for the construction of a URL, with the substitution of each parameter
+ * @see {@link isAbsoluteRoute} for the test of an absolute path
  *
  * @remarks
- * This function checks `meta.route` for route definitions. States with `route: {}` config
- * are routable. Parameter substitution happens via {@link buildRouteUrl}, not in this
- * function (deriveRoute returns templates).
+ * This function reads the route definition from `meta.route`. A state with a
+ * `route: {}` config has a route. {@link buildRouteUrl} substitutes each parameter,
+ * and this function does not: deriveRoute returns a template.
  *
- * **Non-routable States:** States without `meta.route` return `null`. This is intentional—
- * not all states need routes. For example, intermediate loading states or substates may
- * not correspond to distinct URLs.
+ * **A state without a route:** a state without a `meta.route` field gives `null`.
+ * This is deliberate, because not every state needs a route. An intermediate loading
+ * state and a substate, for example, often have no URL of their own.
  */
 export declare const deriveRoute: (stateMeta: Record<string, unknown>) => string | null;
 /**
- * Normalize route metadata to string path
+ * Normalizes the route metadata into a string path
  *
- * Handles both string and object formats for route definitions, ensuring consistent
- * string output for URL construction.
+ * The function handles the string form and the object form of a route definition.
+ * The output is therefore always a string, for the construction of the URL.
  *
- * @param route - Route metadata (string or object with path property)
- * @param source - `PlayError.scope` to report when the metadata is invalid
- *   (defaults to `"deriveRoute"`)
- * @returns Normalized route path string
- * @throws {InvalidRouteMetadataError} If route format is invalid
+ * @param route - The route metadata: a string, or an object with a path property
+ * @param source - The `PlayError.scope` value to report for invalid metadata. The
+ *   default is `"deriveRoute"`
+ * @returns The normalized string of the route path
+ * @throws {InvalidRouteMetadataError} When the form of the route is invalid
  */
 export declare const normalizeRoute: (route: RouteMetadata, source?: string) => string;
 /**
- * Check if route path is absolute
+ * Tells you if the route path is absolute
  *
- * Determines whether a route path is absolute (starts with `/`) or relative.
- * Absolute paths don't inherit from parent routes, while relative paths can be
- * composed with parent paths for nested routing.
+ * The function decides if a route path is absolute, which means that it starts with
+ * `/`, or relative. An absolute path inherits nothing from a parent route. A
+ * relative path joins a parent path, for a nested routing.
  *
- * @param path - Route path to check
- * @returns true if path starts with '/', false otherwise
+ * @param path - The route path to test
+ * @returns true when the path starts with '/'. In every other case, false
  *
  * @example
  * ```typescript
@@ -119,7 +120,7 @@ export declare const normalizeRoute: (route: RouteMetadata, source?: string) =>
  * console.log(isAbsoluteRoute("./about"));    // false
  * ```
  *
- * @see {@link deriveRoute} for route extraction
+ * @see {@link deriveRoute} for the read of a route
  */
 export declare const isAbsoluteRoute: (path: string) => boolean;
 //# sourceMappingURL=derive-route.d.ts.map

package/dist/routing/derive-route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derive-route.d.ts","sourceRoot":"","sources":["../../src/routing/derive-route.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,YAAY,CAAC;AAG7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AACH,eAAO,MAAM,WAAW,GAAI,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAAM,GAAG,IAqBzE,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,aAAa,EAAE,eAAsB,KAAG,MAW7E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,OAE9C,CAAC"}
+{"version":3,"file":"derive-route.d.ts","sourceRoot":"","sources":["../../src/routing/derive-route.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,YAAY,CAAC;AAG7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,eAAO,MAAM,WAAW,GAAI,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAAM,GAAG,IAuBzE,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,aAAa,EAAE,eAAsB,KAAG,MAW7E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,OAE9C,CAAC"}

package/dist/routing/derive-route.js

@@ -1,21 +1,22 @@
 import { InvalidRouteMetadataError } from "../errors.js";
 /**
- * Derive route from XState state metadata
+ * Derives the route from the metadata of an XState state
  *
- * Extracts route URL template from `meta.route` in the active state's metadata.
- * Supports both string routes (`"/about"`) and object routes with path property
- * (`{ path: "/about" }`). Returns null for states without route metadata (not
- * all states need to be routable).
+ * The function reads the URL template of the route from the `meta.route` field in
+ * the metadata of the active state. It supports a string route (`"/about"`) and also
+ * an object route with a path property (`{ path: "/about" }`). It returns null for a
+ * state without route metadata, because not every state needs a route.
  *
- * **Architectural Context:** Implements **Actor Authority (INV-01)** by extracting
- * routing information from state machine definitions rather than external configuration.
- * The route is determined by the Actor's current state, not by infrastructure decisions.
+ * **Architectural context:** the function implements **Actor Authority (INV-01)**,
+ * because it reads the routing information from the state machine definition, and
+ * not from an external configuration. The current state of the Actor decides the
+ * route, and no decision of the infrastructure decides it.
  *
- * @param stateMeta - State metadata from snapshot.getMeta()
- * @returns Route path template (may include :params) or null if no route found
+ * @param stateMeta - The state metadata from snapshot.getMeta()
+ * @returns The template of the route path, which can hold a :param, or null when the function finds no route
  *
  * @example
- * Basic route extraction
+ * The basic read of a route
  * ```typescript
  * import { deriveRoute } from "@xmachines/play-xstate";
  * import { setup } from "xstate";
@@ -38,7 +39,7 @@ import { InvalidRouteMetadataError } from "../errors.js";
  * ```
  *
  * @example
- * Route with parameters
+ * A route with a parameter
  * ```typescript
  * const machine = setup({}).createMachine({
  *   states: {
@@ -52,11 +53,11 @@ import { InvalidRouteMetadataError } from "../errors.js";
  * });
  *
  * const route = deriveRoute(snapshot.getMeta());
- * console.log(route); // "/profile/:userId" (template, before substitution)
+ * console.log(route); // "/profile/:userId" — the template, before the substitution
  * ```
  *
  * @example
- * Route object format
+ * The object form of a route
  * ```typescript
  * const machine = setup({}).createMachine({
  *   states: {
@@ -74,23 +75,25 @@ import { InvalidRouteMetadataError } from "../errors.js";
  * ```
  *
  * @see [Play RFC](../../../docs/rfc/play.md)
- * @see {@link buildRouteUrl} for URL construction with parameter substitution
- * @see {@link isAbsoluteRoute} for checking path absoluteness
+ * @see {@link buildRouteUrl} for the construction of a URL, with the substitution of each parameter
+ * @see {@link isAbsoluteRoute} for the test of an absolute path
  *
  * @remarks
- * This function checks `meta.route` for route definitions. States with `route: {}` config
- * are routable. Parameter substitution happens via {@link buildRouteUrl}, not in this
- * function (deriveRoute returns templates).
+ * This function reads the route definition from `meta.route`. A state with a
+ * `route: {}` config has a route. {@link buildRouteUrl} substitutes each parameter,
+ * and this function does not: deriveRoute returns a template.
  *
- * **Non-routable States:** States without `meta.route` return `null`. This is intentional—
- * not all states need routes. For example, intermediate loading states or substates may
- * not correspond to distinct URLs.
+ * **A state without a route:** a state without a `meta.route` field gives `null`.
+ * This is deliberate, because not every state needs a route. An intermediate loading
+ * state and a substate, for example, often have no URL of their own.
  */
 export const deriveRoute = (stateMeta) => {
-    // snapshot.getMeta() orders keys ancestors-first. Fold routed entries top-down
-    // so the deepest active state's meta.route wins over an ancestor's, while a
-    // RELATIVE route resolves against its nearest routed ancestors — mirroring
-    // play-router's tree resolution (child fullPath = parent fullPath + "/" + path).
+    // snapshot.getMeta() puts the keys of the ancestors first. Fold each entry with a
+    // route from the top to the bottom. The meta.route of the deepest active state
+    // therefore wins over the route of an ancestor, and a RELATIVE route resolves
+    // against its nearest ancestors with a route. The tree resolution of play-router
+    // does the same: the fullPath of a child is the fullPath of its parent, then "/",
+    // then its own path.
     let resolved = null;
     for (const meta of Object.values(stateMeta)) {
         if (typeof meta !== "object" || meta === null)
@@ -111,36 +114,36 @@ export const deriveRoute = (stateMeta) => {
     return resolved;
 };
 /**
- * Normalize route metadata to string path
+ * Normalizes the route metadata into a string path
  *
- * Handles both string and object formats for route definitions, ensuring consistent
- * string output for URL construction.
+ * The function handles the string form and the object form of a route definition.
+ * The output is therefore always a string, for the construction of the URL.
  *
- * @param route - Route metadata (string or object with path property)
- * @param source - `PlayError.scope` to report when the metadata is invalid
- *   (defaults to `"deriveRoute"`)
- * @returns Normalized route path string
- * @throws {InvalidRouteMetadataError} If route format is invalid
+ * @param route - The route metadata: a string, or an object with a path property
+ * @param source - The `PlayError.scope` value to report for invalid metadata. The
+ *   default is `"deriveRoute"`
+ * @returns The normalized string of the route path
+ * @throws {InvalidRouteMetadataError} When the form of the route is invalid
  */
 export const normalizeRoute = (route, source = "deriveRoute") => {
     if (typeof route === "string") {
         return route;
     }
-    // Route object with path property
+    // A route object, with a path property
     if (route && typeof route === "object" && "path" in route) {
         return route.path;
     }
     throw new InvalidRouteMetadataError(route, source);
 };
 /**
- * Check if route path is absolute
+ * Tells you if the route path is absolute
  *
- * Determines whether a route path is absolute (starts with `/`) or relative.
- * Absolute paths don't inherit from parent routes, while relative paths can be
- * composed with parent paths for nested routing.
+ * The function decides if a route path is absolute, which means that it starts with
+ * `/`, or relative. An absolute path inherits nothing from a parent route. A
+ * relative path joins a parent path, for a nested routing.
  *
- * @param path - Route path to check
- * @returns true if path starts with '/', false otherwise
+ * @param path - The route path to test
+ * @returns true when the path starts with '/'. In every other case, false
  *
  * @example
  * ```typescript
@@ -151,7 +154,7 @@ export const normalizeRoute = (route, source = "deriveRoute") => {
  * console.log(isAbsoluteRoute("./about"));    // false
  * ```
  *
- * @see {@link deriveRoute} for route extraction
+ * @see {@link deriveRoute} for the read of a route
  */
 export const isAbsoluteRoute = (path) => {
     return path.startsWith("/");

package/dist/routing/derive-route.js.map

@@ -1 +1 @@
-{"version":3,"file":"derive-route.js","sourceRoot":"","sources":["../../src/routing/derive-route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,SAAkC,EAAiB,EAAE;IAChF,+EAA+E;IAC/E,4EAA4E;IAC5E,2EAA2E;IAC3E,iFAAiF;IACjF,IAAI,QAAQ,GAAkB,IAAI,CAAC;IACnC,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;QAC7C,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI;YAAE,SAAS;QACxD,IAAI,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,SAAS;QAEhD,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,KAAsB,CAAC,CAAC;QAC1D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,EAAE;YAAE,SAAS;QACxD,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5B,QAAQ,GAAG,KAAK,CAAC;QAClB,CAAC;aAAM,CAAC;YACP,MAAM,IAAI,GAAW,QAAQ,KAAK,IAAI,IAAI,QAAQ,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;YAC3E,QAAQ,GAAG,GAAG,IAAI,IAAI,KAAK,EAAE,CAAC;QAC/B,CAAC;IACF,CAAC;IAED,OAAO,QAAQ,CAAC;AACjB,CAAC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAoB,EAAE,MAAM,GAAG,aAAa,EAAU,EAAE;IACtF,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO,KAAK,CAAC;IACd,CAAC;IAED,kCAAkC;IAClC,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,IAAI,KAAK,EAAE,CAAC;QAC3D,OAAQ,KAAqB,CAAC,IAAI,CAAC;IACpC,CAAC;IAED,MAAM,IAAI,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AACpD,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,IAAY,EAAW,EAAE;IACxD,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC,CAAC"}
+{"version":3,"file":"derive-route.js","sourceRoot":"","sources":["../../src/routing/derive-route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,SAAkC,EAAiB,EAAE;IAChF,kFAAkF;IAClF,+EAA+E;IAC/E,8EAA8E;IAC9E,iFAAiF;IACjF,kFAAkF;IAClF,qBAAqB;IACrB,IAAI,QAAQ,GAAkB,IAAI,CAAC;IACnC,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;QAC7C,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI;YAAE,SAAS;QACxD,IAAI,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,SAAS;QAEhD,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,KAAsB,CAAC,CAAC;QAC1D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,EAAE;YAAE,SAAS;QACxD,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5B,QAAQ,GAAG,KAAK,CAAC;QAClB,CAAC;aAAM,CAAC;YACP,MAAM,IAAI,GAAW,QAAQ,KAAK,IAAI,IAAI,QAAQ,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;YAC3E,QAAQ,GAAG,GAAG,IAAI,IAAI,KAAK,EAAE,CAAC;QAC/B,CAAC;IACF,CAAC;IAED,OAAO,QAAQ,CAAC;AACjB,CAAC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAoB,EAAE,MAAM,GAAG,aAAa,EAAU,EAAE;IACtF,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO,KAAK,CAAC;IACd,CAAC;IAED,uCAAuC;IACvC,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,IAAI,KAAK,EAAE,CAAC;QAC3D,OAAQ,KAAqB,CAAC,IAAI,CAAC;IACpC,CAAC;IAED,MAAM,IAAI,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AACpD,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,IAAY,EAAW,EAAE;IACxD,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC,CAAC"}

package/dist/routing/format-play-route-transitions.d.ts

@@ -1,37 +1,40 @@
 import type { RouteMetadata } from "./types.js";
 /**
- * Minimal structural shape of a single XState state node as read by
- * `formatPlayRouteTransitions` when crawling the machine config.
+ * The minimal structural shape of one XState state node, as
+ * `formatPlayRouteTransitions` reads it during its walk over the machine config.
  *
- * Only the fields the function actually inspects are typed here; all other
- * state-node fields (e.g. `on`, `entry`, `after`) pass through unmodified via
- * the index signature.
+ * This type holds only the fields that the function reads. Every other field of a
+ * state node, such as `on`, `entry`, and `after`, passes through the index
+ * signature without a change.
  */
 export type RouteStateNode = {
-    /** Optional explicit state ID (e.g. `"home"`, `"settings"`). Used as the `#id` target in `play.route` events. */
+    /**
+     * The optional explicit state ID, for example `"home"` or `"settings"`. It is the `#id` target of a `play.route` event.
+     */
     id?: string;
-    /** State metadata — `meta.route` marks the state as routable. */
+    /** The state metadata. A `meta.route` field gives the state a route. */
     meta?: {
         /**
-         * URL path template — string form (e.g. `"/profile/:username"`) or object
-         * form (`{ path, title }`), matching {@link RouteMetadata}.
+         * The template of the URL path: the string form, for example
+         * `"/profile/:username"`, or the object form (`{ path, title }`). Both match
+         * {@link RouteMetadata}.
          */
         route?: RouteMetadata;
     };
-    /** Nested child states, recursively crawled for additional route declarations. */
+    /** The nested child states. The function walks them for each further route declaration. */
     states?: Record<string, RouteStateNode>;
     [key: string]: unknown;
 };
 /**
- * Minimal structural constraint for machine configs accepted by
- * `formatPlayRouteTransitions`.
+ * The minimal structural constraint of a machine config that
+ * `formatPlayRouteTransitions` accepts.
  *
- * This is intentionally loose so the function accepts both the bare `createMachine`
- * config object and the stricter `setup().createMachine` config without requiring
- * any type casts at the call site. The generic `T extends RouteMachineConfig`
- * parameter on `formatPlayRouteTransitions` preserves the original concrete type
- * through the transform, so the return value remains directly usable by
- * `setup().createMachine()`.
+ * The constraint is loose on purpose. The function therefore accepts the bare config
+ * object of `createMachine` and also the stricter config of
+ * `setup().createMachine`, and the call site needs no type cast. The generic
+ * parameter `T extends RouteMachineConfig` of `formatPlayRouteTransitions` keeps the
+ * original concrete type through the transform. Therefore
+ * `setup().createMachine()` accepts the return value directly.
  */
 export type RouteMachineConfig = {
     context?: unknown;
@@ -40,12 +43,14 @@ export type RouteMachineConfig = {
     [key: string]: unknown;
 };
 /**
- * Formats play.route transitions from declarative route configs
+ * Makes the play.route transitions from the declarative route configs
  *
- * Crawls machine states looking for states with meta.route and generates
- * transitions that handle `play.route` events by matching event.to to state IDs.
+ * The function walks the machine states. It looks for each state with a `meta.route`
+ * field, and it generates the transitions that handle a `play.route` event: each
+ * transition matches event.to against a state ID.
  *
- * Inspired by XState's internal formatRouteTransitions (stateUtils.ts line 391).
+ * The internal formatRouteTransitions function of XState was the model for this
+ * function (stateUtils.ts, line 391).
  *
  * @example
  * ```typescript
@@ -60,13 +65,14 @@ export type RouteMachineConfig = {
  * const machine = createMachine(formatPlayRouteTransitions(machineConfig));
  * ```
  *
- * This automatically generates play.route handlers at the root level that:
- * - Match event.to against state IDs (e.g., event.to === "#home")
- * - Target the appropriate state
- * - Assign params and query from the event to context
+ * The function generates the `play.route` handlers at the root level. Those
+ * handlers:
+ * - match event.to against a state ID, for example event.to === "#home"
+ * - target the correct state
+ * - assign the params and the query of the event to the context
  *
- * @param machineConfig - XState machine config (before createMachine). Must extend `RouteMachineConfig`.
- * @returns The same machine config with auto-generated `play.route` handlers merged in, preserving the original type `T`.
+ * @param machineConfig - The XState machine config, before `createMachine`. It must extend `RouteMachineConfig`.
+ * @returns The same machine config, with the generated `play.route` handlers in it. The original type `T` stays.
  */
 export declare function formatPlayRouteTransitions<T extends RouteMachineConfig>(machineConfig: T): T;
 //# sourceMappingURL=format-play-route-transitions.d.ts.map

package/dist/routing/format-play-route-transitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format-play-route-transitions.d.ts","sourceRoot":"","sources":["../../src/routing/format-play-route-transitions.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAkBhD;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG;IAC5B,iHAAiH;IACjH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,iEAAiE;IACjE,IAAI,CAAC,EAAE;QACN;;;WAGG;QACH,KAAK,CAAC,EAAE,aAAa,CAAC;KACtB,CAAC;IACF,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACxC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB,CAAC;AAaF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAChC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAC7C,EAAE,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IACzC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,kBAAkB,EAAE,aAAa,EAAE,CAAC,GAAG,CAAC,CAkF5F"}
+{"version":3,"file":"format-play-route-transitions.d.ts","sourceRoot":"","sources":["../../src/routing/format-play-route-transitions.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAkBhD;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG;IAC5B;;OAEG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,wEAAwE;IACxE,IAAI,CAAC,EAAE;QACN;;;;WAIG;QACH,KAAK,CAAC,EAAE,aAAa,CAAC;KACtB,CAAC;IACF,2FAA2F;IAC3F,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACxC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB,CAAC;AAaF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAChC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAC7C,EAAE,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IACzC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,kBAAkB,EAAE,aAAa,EAAE,CAAC,GAAG,CAAC,CAmF5F"}