@xmachines/docs 3.0.0 → 5.0.0

package/api/@xmachines/play-router/{functions → index/functions}/isMountableBridge.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / isMountableBridge
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / isMountableBridge
 
 # Function: isMountableBridge()
 
@@ -6,7 +6,7 @@
 function isMountableBridge(bridge): bridge is MountableRouterBridge;
 ```
 
-Defined in: [play-router/src/provider-lifecycle.ts:118](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/provider-lifecycle.ts#L118)
+Defined in: [packages/play-router/src/provider-lifecycle.ts:137](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/provider-lifecycle.ts#L137)
 
 Tells you whether a bridge can move its mount.
 

package/api/@xmachines/play-router/index/functions/joinBasePath.md

@@ -0,0 +1,38 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / joinBasePath
+
+# Function: joinBasePath()
+
+```ts
+function joinBasePath(basePath, path): string;
+```
+
+Defined in: [packages/play-url/src/base-path.ts:307](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/base-path.ts#L307)
+
+Adds the base path to an outbound path of the machine.
+
+The function joins the PATHNAME only. A query string and a hash fragment of the
+path of the machine stay at the end, because the prefix belongs in front of the
+path.
+
+## Parameters
+
+| Parameter  | Type     | Description                                                                      |
+| ---------- | -------- | -------------------------------------------------------------------------------- |
+| `basePath` | `string` | The concrete prefix of [resolveBasePath](resolveBasePath.md). `""` adds nothing. |
+| `path`     | `string` | The path of the machine, for example `"/dashboard"` or `"/dates?trip=one-way"`.  |
+
+## Returns
+
+`string`
+
+The location for the router of the host.
+
+## Example
+
+```typescript
+joinBasePath("/abc123/play", "/dashboard"); // "/abc123/play/dashboard"
+joinBasePath("/abc123/play", "/"); // "/abc123/play"
+joinBasePath("/abc123/play", "/x?tab=a"); // "/abc123/play/x?tab=a"
+joinBasePath("/abc123/play", "#/home"); // "/abc123/play#/home"
+joinBasePath("", "/dashboard"); // "/dashboard"
+```

package/api/@xmachines/play-router/{functions → index/functions}/mountKey.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / mountKey
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / mountKey
 
 # Function: mountKey()
 
@@ -6,7 +6,7 @@
 function mountKey(basePath?, basePathParams?): string;
 ```
 
-Defined in: [play-router/src/provider-lifecycle.ts:136](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/provider-lifecycle.ts#L136)
+Defined in: [packages/play-router/src/provider-lifecycle.ts:155](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/provider-lifecycle.ts#L155)
 
 A key that changes when the MOUNT changes, and never when its identity changes.
 

package/api/@xmachines/play-router/index/functions/normalizeBasePath.md

@@ -0,0 +1,43 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / normalizeBasePath
+
+# Function: normalizeBasePath()
+
+```ts
+function normalizeBasePath(basePath?): string;
+```
+
+Defined in: [packages/play-url/src/base-path.ts:134](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/base-path.ts#L134)
+
+Normalizes a base path, and it substitutes no `:param` segment of that path.
+
+Use this function when you want the form of the pattern, for example to declare
+the routes of a machine in a route config of a host that substitutes each param
+itself. [resolveBasePath](resolveBasePath.md) gives the form that a bridge needs.
+
+## Parameters
+
+| Parameter   | Type     | Description                                                                                     |
+| ----------- | -------- | ----------------------------------------------------------------------------------------------- |
+| `basePath?` | `string` | The prefix, as a pattern or as a concrete path. An absent value, `""`, and `"/"` all give `""`. |
+
+## Returns
+
+`string`
+
+The normalized prefix. It starts with `/`, and it carries no trailing `/`.
+
+## Throws
+
+For a wildcard segment, for an optional `:param?`
+segment, for a `$param` segment, for a query string or a hash fragment, for a URL
+scheme, for a dot segment (`.`, `..`, and their percent-encoded forms), and for any
+segment that a browser rewrites — one that holds whitespace, a backslash, or a
+character that a URL percent-encodes.
+
+## Example
+
+```typescript
+normalizeBasePath("/:machineId/play/"); // "/:machineId/play"
+normalizeBasePath("admin"); // "/admin"
+normalizeBasePath("/"); // ""
+```

package/api/@xmachines/play-router/{functions → index/functions}/openProviderBridge.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / openProviderBridge
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / openProviderBridge
 
 # Function: openProviderBridge()
 
@@ -6,7 +6,7 @@
 function openProviderBridge<TRouter, TActor>(BridgeCtor, __namedParameters): object;
 ```
 
-Defined in: [play-router/src/provider-lifecycle.ts:179](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/provider-lifecycle.ts#L179)
+Defined in: [packages/play-router/src/provider-lifecycle.ts:201](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/provider-lifecycle.ts#L201)
 
 Builds a bridge, connects it, and hands back the way to close it.
 
@@ -17,17 +17,17 @@ disconnect a later one when two mounts overlap.
 
 ## Type Parameters
 
-| Type Parameter                                               |
-| ------------------------------------------------------------ |
-| `TRouter`                                                    |
-| `TActor` _extends_ [`PlayActor`](../interfaces/PlayActor.md) |
+| Type Parameter                                                       |
+| -------------------------------------------------------------------- |
+| `TRouter`                                                            |
+| `TActor` _extends_ [`RoutableActor`](../interfaces/RoutableActor.md) |
 
 ## Parameters
 
-| Parameter           | Type                                                                                         |
-| ------------------- | -------------------------------------------------------------------------------------------- |
-| `BridgeCtor`        | [`PlayRouterBridgeConstructor`](../type-aliases/PlayRouterBridgeConstructor.md)\<`TRouter`\> |
-| `__namedParameters` | [`OpenProviderBridgeArgs`](../interfaces/OpenProviderBridgeArgs.md)\<`TRouter`, `TActor`\>   |
+| Parameter           | Type                                                                                                   |
+| ------------------- | ------------------------------------------------------------------------------------------------------ |
+| `BridgeCtor`        | [`PlayRouterBridgeConstructor`](../type-aliases/PlayRouterBridgeConstructor.md)\<`TRouter`, `TActor`\> |
+| `__namedParameters` | [`OpenProviderBridgeArgs`](../interfaces/OpenProviderBridgeArgs.md)\<`TRouter`, `TActor`\>             |
 
 ## Returns
 
@@ -35,7 +35,7 @@ disconnect a later one when two mounts overlap.
 
 The bridge, and a `close` that disconnects it one time.
 
-| Name      | Type                                            | Defined in                                                                                                                                                |
-| --------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `bridge`  | [`RouterBridge`](../interfaces/RouterBridge.md) | [play-router/src/provider-lifecycle.ts:182](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/provider-lifecycle.ts#L182) |
-| `close()` | () => `void`                                    | [play-router/src/provider-lifecycle.ts:182](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/provider-lifecycle.ts#L182) |
+| Name      | Type                                            | Defined in                                                                                                                                                         |
+| --------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `bridge`  | [`RouterBridge`](../interfaces/RouterBridge.md) | [packages/play-router/src/provider-lifecycle.ts:204](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/provider-lifecycle.ts#L204) |
+| `close()` | () => `void`                                    | [packages/play-router/src/provider-lifecycle.ts:204](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/provider-lifecycle.ts#L204) |

package/api/@xmachines/play-router/index/functions/parsePattern.md

@@ -0,0 +1,28 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / parsePattern
+
+# Function: parsePattern()
+
+```ts
+function parsePattern(pattern, options?): ParsedPattern;
+```
+
+Defined in: [packages/play-pattern/src/pattern-grammar.ts:264](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L264)
+
+Reads a route pattern, one time for each distinct pattern.
+
+The parser reports a fault never. A pattern that it cannot read reports
+`parameterized: true` and `bareForm: null`, which sends it to the URLPattern
+constructor and keeps every derived answer on the safe side.
+
+## Parameters
+
+| Parameter  | Type                                            | Description                                        |
+| ---------- | ----------------------------------------------- | -------------------------------------------------- |
+| `pattern`  | `string`                                        | The route pattern, for example `/profile/:userId`. |
+| `options?` | [`ParseOptions`](../interfaces/ParseOptions.md) | -                                                  |
+
+## Returns
+
+[`ParsedPattern`](../interfaces/ParsedPattern.md)
+
+The parse. The caller treats it as read-only: the cache holds this object.

package/api/@xmachines/play-router/index/functions/pickOwnParams.md

@@ -0,0 +1,41 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / pickOwnParams
+
+# Function: pickOwnParams()
+
+```ts
+function pickOwnParams(params, names, requiredNames?): Record<string, string> | null;
+```
+
+Defined in: [packages/play-url/src/framework-params.ts:43](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/framework-params.ts#L43)
+
+Keeps the entries of `params` whose name the pattern of the machine declares, and
+only when the result covers EVERY name of that pattern.
+
+A complete pick is an answer, and a partial pick is not: a wrapper route of the host
+can declare a subset of the params of the machine — a tenant segment, for example,
+but not the document one — and keeping that subset drops the rest from a route that
+declares them. The caller falls back to its own extraction for `null`.
+
+The result has a null prototype, so a param named `__proto__` stays an own key.
+
+An OPTIONAL name of the pattern (`:name?`) is covered whether the framework reports
+it or not: a segment that did not match has no value, and that is a complete answer.
+At least one declared name must come back, though — a framework that reports none
+matched another route, and the path may still hold a value that only the fallback
+reads. A pattern whose params are ALL optional therefore always answers `null` here
+when the framework reports nothing; [resolveFrameworkParams](resolveFrameworkParams.md) then reads the PATH,
+which settles the question without the framework and without URLPattern.
+
+## Parameters
+
+| Parameter       | Type                           | Default value | Description                                                                                                                                                                                                                                                                    |
+| --------------- | ------------------------------ | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `params`        | `Record`\<`string`, `string`\> | `undefined`   | The params of the framework router. [cleanFrameworkParams](cleanFrameworkParams.md) removes each empty value already, and one that reaches here anyway counts as absent: an empty value says that the segment did not match, and never that the path carries the empty string. |
+| `names`         | readonly `string`[]            | `undefined`   | The names that the pattern of the machine declares.                                                                                                                                                                                                                            |
+| `requiredNames` | readonly `string`[]            | `names`       | The names the pattern REQUIRES. The default treats every name as required, so a two-argument call keeps the strict test.                                                                                                                                                       |
+
+## Returns
+
+`Record`\<`string`, `string`\> \| `null`
+
+The params of the machine, or `null` when the framework covers them not.

package/api/@xmachines/play-router/{functions → index/functions}/repointProviderBridge.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / repointProviderBridge
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / repointProviderBridge
 
 # Function: repointProviderBridge()
 
@@ -6,7 +6,7 @@
 function repointProviderBridge(bridge, basePath?, basePathParams?): void;
 ```
 
-Defined in: [play-router/src/provider-lifecycle.ts:243](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/provider-lifecycle.ts#L243)
+Defined in: [packages/play-router/src/provider-lifecycle.ts:270](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/provider-lifecycle.ts#L270)
 
 Moves the mount of a live bridge, and rebuilds nothing.
 

package/api/@xmachines/play-router/index/functions/resolveBasePath.md

@@ -0,0 +1,51 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / resolveBasePath
+
+# Function: resolveBasePath()
+
+```ts
+function resolveBasePath(basePath?, params?): ResolvedBasePath;
+```
+
+Defined in: [packages/play-url/src/base-path.ts:184](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/base-path.ts#L184)
+
+Resolves a base path and its params to the concrete prefix that a browser URL
+carries.
+
+A bridge calls this function one time, and again on each `setBasePath()` call. The
+result is always concrete. [stripBasePath](stripBasePath.md) therefore compares a literal
+prefix, and no URLPattern match runs on the hot path of a navigation.
+
+## Parameters
+
+| Parameter   | Type                                       | Description                                        |
+| ----------- | ------------------------------------------ | -------------------------------------------------- |
+| `basePath?` | `string`                                   | The prefix, as a pattern or as a concrete path.    |
+| `params?`   | `Record`\<`string`, `string` \| `number`\> | The values of the `:param` segments of `basePath`. |
+
+## Returns
+
+[`ResolvedBasePath`](../interfaces/ResolvedBasePath.md)
+
+The concrete prefix, and the values of each param for a `play.route` event.
+
+## Throws
+
+For a wildcard segment, for an optional `:param?`
+segment, for a `$param` segment, for a query string or a hash fragment, for a URL
+scheme, for a dot segment (`.`, `..`, and their percent-encoded forms), and for any
+segment that a browser rewrites — one that holds whitespace, a backslash, or a
+character that a URL percent-encodes.
+
+## Throws
+
+When a `:param` of the prefix has no value.
+
+## Example
+
+```typescript
+resolveBasePath("/:machineId/play", { machineId: "abc123" });
+// → { path: "/abc123/play", params: { machineId: "abc123" } }
+
+resolveBasePath("/admin");
+// → { path: "/admin", params: {} }
+```

package/api/@xmachines/play-router/index/functions/resolveFrameworkParams.md

@@ -0,0 +1,49 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / resolveFrameworkParams
+
+# Function: resolveFrameworkParams()
+
+```ts
+function resolveFrameworkParams(source): Record<string, string>;
+```
+
+Defined in: [packages/play-url/src/framework-params.ts:220](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/framework-params.ts#L220)
+
+Decides which params describe the route of the machine.
+
+The four branches, in the order that they apply:
+
+- **The pattern declares no name** — a static path, a bare `*` wildcard, or an
+  unknown stateId. The answer is `{}`. The params of the framework must NOT travel
+  here: under a catch-all they hold the splat of the host, and that value would reach
+  the actor as a param of the machine. A bare `*` names nothing that a machine can
+  read, and URLPattern numbers its group `0`.
+- **The bridge sits under a mount** — the framework matched a route of the HOST by
+  construction, because the machine owns the suffix of the path only. Its params
+  therefore describe this pattern never, whatever they are named, and a name that
+  happens to collide carries the value of the host. Read the params of the machine
+  from its own pattern instead.
+- **The framework covers every REQUIRED name** — it matched the machine route. Keep
+  its parse, together with its decoding. An optional `:name?` that the framework
+  reports not is covered too: a segment that did not match has no value. A gap in a
+  required name falls back, because keeping it would drop a name the route declares.
+- **The path IS the bare form of the pattern** — every optional part is absent, so `{}`
+  is the complete answer. The branch reads the path and trusts the framework with
+  nothing, which is what makes it safe under a catch-all of the host, and it calls
+  URLPattern for a location that needs none.
+
+What these branches decide is whether a NAVIGATION compiles and runs a URLPattern
+again. The API itself is always present: `url-pattern-utils.ts` imports the polyfill as
+an ordinary dependency, and no code path asks whether the runtime carries the native
+one.
+
+## Parameters
+
+| Parameter | Type                                                              |
+| --------- | ----------------------------------------------------------------- |
+| `source`  | [`FrameworkParamsSource`](../interfaces/FrameworkParamsSource.md) |
+
+## Returns
+
+`Record`\<`string`, `string`\>
+
+The path parameters of the machine route, or `{}`.

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

@@ -0,0 +1,27 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / sanitizePathname
+
+# Function: sanitizePathname()
+
+```ts
+function sanitizePathname(pathname): string | null;
+```
+
+Defined in: [packages/play-url/src/location.ts:89](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/location.ts#L89)
+
+Reads the pathname of a location, and refuses a location that no route can match.
+
+The function removes the query and the fragment, and it joins every run of separators
+into one: `//docs//api` gives `/docs/api`. A route map holds one pattern for one path,
+and a doubled separator is the same path written another way.
+
+## Parameters
+
+| Parameter  | Type     | Description                                    |
+| ---------- | -------- | ---------------------------------------------- |
+| `pathname` | `string` | The raw value that a framework router reports. |
+
+## Returns
+
+`string` \| `null`
+
+The clean pathname, or `null` when the value is longer than 2048 characters.

package/api/@xmachines/play-router/index/functions/splitLocation.md

@@ -0,0 +1,37 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / splitLocation
+
+# Function: splitLocation()
+
+```ts
+function splitLocation(location): SplitLocation;
+```
+
+Defined in: [packages/play-url/src/location.ts:55](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/location.ts#L55)
+
+Splits a location into its pathname, its query and its fragment.
+
+The search for the `#` starts at the SECOND character, so a leading `#` belongs to the
+pathname. A hash router writes a location of the form `#/home`, and that location names
+the path `#/home` and no fragment. The rule decides `#` alone, and a `?` ends the
+pathname wherever it stands.
+
+## Parameters
+
+| Parameter  | Type     | Description                                             |
+| ---------- | -------- | ------------------------------------------------------- |
+| `location` | `string` | The location string, for example `/docs?tab=api#intro`. |
+
+## Returns
+
+[`SplitLocation`](../interfaces/SplitLocation.md)
+
+The parts. Each absent part is `""`, and never `undefined`.
+
+## Example
+
+```typescript
+splitLocation("/docs?tab=api#intro");
+// → { pathname: "/docs", query: "tab=api", fragment: "#intro", suffix: "?tab=api#intro" }
+
+splitLocation("#/home"); // → { pathname: "#/home", query: "", fragment: "", suffix: "" }
+```

package/api/@xmachines/play-router/index/functions/stripBasePath.md

@@ -0,0 +1,44 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / stripBasePath
+
+# Function: stripBasePath()
+
+```ts
+function stripBasePath(pathname, basePath): string | null;
+```
+
+Defined in: [packages/play-url/src/base-path.ts:280](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/base-path.ts#L280)
+
+Removes the base path from an inbound location of the router.
+
+The return value separates the two cases that make a shared router work:
+
+- A string is the MACHINE half of the location, for example `"/dashboard"` of
+  `"/abc123/play/dashboard"`. The bridge matches it against the route map.
+- `null` means that the location is FOREIGN: it lies outside the mount, so it
+  belongs to the host. The bridge sends no `play.route` event, AND it runs no
+  corrective navigation. A correction here would drag the user off a page of the
+  host.
+
+The match is exact, and it respects each segment boundary. `"/abc/playground"` is
+therefore foreign to the mount `"/abc/play"`.
+
+## Parameters
+
+| Parameter  | Type     | Description                                                                         |
+| ---------- | -------- | ----------------------------------------------------------------------------------- |
+| `pathname` | `string` | A sanitized pathname of the router, with no query and no duplicate slash.           |
+| `basePath` | `string` | The concrete prefix of [resolveBasePath](resolveBasePath.md). `""` removes nothing. |
+
+## Returns
+
+`string` \| `null`
+
+The machine half of the path, or `null` when the location is foreign.
+
+## Example
+
+```typescript
+stripBasePath("/abc123/play/dashboard", "/abc123/play"); // "/dashboard"
+stripBasePath("/abc123/play", "/abc123/play"); // "/"
+stripBasePath("/settings", "/abc123/play"); // null — the host owns it
+```

package/api/@xmachines/play-router/{functions → index/functions}/validateRouteFormat.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / validateRouteFormat
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / validateRouteFormat
 
 # Function: validateRouteFormat()
 
@@ -6,7 +6,7 @@
 function validateRouteFormat(routePath, stateId): void;
 ```
 
-Defined in: [play-router/src/validate-routes.ts:27](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/validate-routes.ts#L27)
+Defined in: [packages/play-router/src/validate-routes.ts:27](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/validate-routes.ts#L27)
 
 Checks the format of a route path
 

package/api/@xmachines/play-router/{functions → index/functions}/validateStateExists.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / validateStateExists
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / validateStateExists
 
 # Function: validateStateExists()
 
@@ -6,7 +6,7 @@
 function validateStateExists(stateId, stateIds): void;
 ```
 
-Defined in: [play-router/src/validate-routes.ts:43](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/validate-routes.ts#L43)
+Defined in: [packages/play-router/src/validate-routes.ts:43](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/validate-routes.ts#L43)
 
 Checks that the set of the state IDs holds a state
 

package/api/@xmachines/play-router/index/interfaces/BasePathOptions.md

@@ -0,0 +1,32 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / BasePathOptions
+
+# Interface: BasePathOptions
+
+Defined in: [packages/play-url/src/base-path.ts:48](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/base-path.ts#L48)
+
+The base-path options that every router bridge, `connectRouter` function, and
+`PlayRouterProvider` component accepts.
+
+## Example
+
+```typescript
+// A host that mounts a machine under a route it resolved in a loader
+connectRouter({
+	actor,
+	router,
+	routeMap,
+	basePath: "/:machineId/play",
+	basePathParams: { machineId },
+});
+```
+
+## Extended by
+
+- [`RouterBridgeOptions`](RouterBridgeOptions.md)
+
+## Properties
+
+| Property                                               | Modifier   | Type                                       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Defined in                                                                                                                               |
+| ------------------------------------------------------ | ---------- | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-basepath"></a> `basePath?`             | `readonly` | `string`                                   | The URL prefix that the routes of the machine hang off, for example `"/admin"` or `"/:machineId/play"`. A `:param` segment is a declarative convenience, so that a host keeps ONE string that mirrors its own route config. Every `:param` must have a value in [BasePathOptions.basePathParams](#property-basepathparams), because the bridge writes a real URL. An optional segment (`:param?`) and a wildcard (`*`) are therefore refused: neither of them resolves to one concrete prefix. An absent value, `""`, and `"/"` all mean "no prefix", which is the behaviour of every release before this option existed.                                                 | [packages/play-url/src/base-path.ts:62](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/base-path.ts#L62) |
+| <a id="property-basepathparams"></a> `basePathParams?` | `readonly` | `Record`\<`string`, `string` \| `number`\> | The values of the `:param` segments of [BasePathOptions.basePath](#property-basepath). These values belong to the HOST, which wrote the prefix and resolved them, so they travel in NO `play.route` event: the machine is authoritative over its own params, and `event.params` holds what the pattern of the machine declares, and nothing else. A param of the host that shares a name with one of the machine can therefore shadow it never. A host reads them back from `bridge.basePathParams`, where they cannot go stale. A machine that needs the identity of its host takes it through the `input` of the actor, where that identity decides WHICH machine runs. | [packages/play-url/src/base-path.ts:76](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/base-path.ts#L76) |

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

@@ -0,0 +1,13 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / BuildPlayRouteEventOptions
+
+# Interface: BuildPlayRouteEventOptions
+
+Defined in: [packages/play-router/src/router-sync.ts:15](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/router-sync.ts#L15)
+
+## Properties
+
+| Property                                  | Type                                                   | Defined in                                                                                                                                         |
+| ----------------------------------------- | ------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-match"></a> `match`       | (`sanitizedPathname`) => [`RouteMatch`](RouteMatch.md) | [packages/play-router/src/router-sync.ts:18](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/router-sync.ts#L18) |
+| <a id="property-pathname"></a> `pathname` | `string`                                               | [packages/play-router/src/router-sync.ts:16](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/router-sync.ts#L16) |
+| <a id="property-search"></a> `search?`    | `string`                                               | [packages/play-router/src/router-sync.ts:17](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-router/src/router-sync.ts#L17) |

package/api/@xmachines/play-router/index/interfaces/CompileOptions.md

@@ -0,0 +1,35 @@
+[API](../../../../README.md) / [@xmachines/play-router](../../README.md) / [index](../README.md) / CompileOptions
+
+# Interface: CompileOptions
+
+Defined in: [packages/play-url/src/url-pattern-utils.ts:106](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/url-pattern-utils.ts#L106)
+
+What [getCompiledPattern](../../../play-url/index/functions/getCompiledPattern.md) reads: [ParseOptions](ParseOptions.md) with the compiled cache.
+
+A caller holds ONE object and hands it to every call of the routing layer, because
+`RouteMapOptions` and `RouterBridgeOptions` extend this one in turn.
+
+## Extends
+
+- [`ParseOptions`](ParseOptions.md)
+
+## Extended by
+
+- [`RouterBridgeOptions`](RouterBridgeOptions.md)
+- [`PlayRouterProviderBaseProps`](PlayRouterProviderBaseProps.md)
+- [`RouteMapOptions`](RouteMapOptions.md)
+- [`RouteMapOptions`](../../../play-dom-router/interfaces/RouteMapOptions.md)
+- [`RouteMapOptions`](../../../play-react-router/interfaces/RouteMapOptions.md)
+- [`RouteMapOptions`](../../../play-solid-router/interfaces/RouteMapOptions.md)
+- [`RouteMapOptions`](../../../play-sveltekit-router/interfaces/RouteMapOptions.md)
+- [`RouteMapOptions`](../../../play-svelte-spa-router/interfaces/RouteMapOptions.md)
+- [`RouteMapOptions`](../../../play-tanstack-react-router/interfaces/RouteMapOptions.md)
+- [`RouteMapOptions`](../../../play-tanstack-solid-router/interfaces/RouteMapOptions.md)
+- [`RouteMapOptions`](../../../play-vue-router/index/interfaces/RouteMapOptions.md)
+
+## Properties
+
+| Property                                             | Modifier   | Type                                                                                       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Inherited from                                                                            | Defined in                                                                                                                                                 |
+| ---------------------------------------------------- | ---------- | ------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-compiledcache"></a> `compiledCache?` | `readonly` | [`PatternCache`](PatternCache.md)\<[`URLPatternLike`](../type-aliases/URLPatternLike.md)\> | The cache of the COMPILED `URLPattern`, which is what this function returns. The default is a cache that this module shares with every caller of the process. Pass one to give a tenant or a request a compilation that no other evicts, and pass `{ get: () => undefined, set: () => {} }` to compile each time. A caller that passes `patternCache` for isolation passes this one too. The compiled cache is read FIRST, so a hit on it answers before the parse runs at all — a passed parse cache alone therefore isolates nothing once another caller has compiled the same pattern. | -                                                                                         | [packages/play-url/src/url-pattern-utils.ts:119](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/url-pattern-utils.ts#L119) |
+| <a id="property-patterncache"></a> `patternCache?`   | `readonly` | [`PatternCache`](PatternCache.md)\<[`ParsedPattern`](ParsedPattern.md)\>                   | The cache of the PARSE of a pattern. The default is the cache that this package shares with every caller of the process.                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | [`ParseOptions`](ParseOptions.md).[`patternCache`](ParseOptions.md#property-patterncache) | [packages/play-pattern/src/cache.ts:40](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/cache.ts#L40)                   |