@xmachines/play-router 2.1.1 → 3.0.0

package/dist/index.js

@@ -6,7 +6,19 @@ export { sanitizePathname, buildPlayRouteEvent, extractQuery, extractRouteParams
 export { validateRouteFormat, validateStateExists, detectDuplicateRoutes, } from "./validate-routes.js";
 export { buildRouteTree } from "./build-tree.js";
 export { extractMachineRoutes } from "./extract-routes.js";
-export { getNavigableRoutes, getRoutableRoutes, routeExists, getTransitionReachableRoutes, isRouteReachable, } from "./query.js";
+export { getNavigableRoutes, getRoutableRoutes, routeExists, getRouteMappings, getTransitionReachableRoutes, isRouteReachable, } from "./query.js";
+// The base-path mount — it lets a host own a part of the same router as a machine.
+// A consumer normally gives `basePath` to a bridge, to `connectRouter`, or to a
+// `PlayRouterProvider`. These primitives serve an adapter, and a host that builds its
+// own route table.
+export { normalizeBasePath, resolveBasePath, stripBasePath, joinBasePath, NO_BASE_PATH, } from "./base-path.js";
+// The params of a framework router, reconciled with the pattern of the machine. A
+// bridge whose framework parses the params itself calls this, and it keeps that parse.
+export { cleanFrameworkParams, getPatternParamNames, getRequiredPatternParamNames, pickOwnParams, resolveFrameworkParams, } from "./framework-params.js";
+// The framework-free half of a PlayRouterProvider: the props, the constructor shape,
+// and the lifecycle of the bridge. A provider of a framework adds its own effects and
+// nothing else. This entry stays framework-agnostic — nothing here imports one.
+export { isMountableBridge, mountKey, createRouterConnection, openProviderBridge, repointProviderBridge, } from "./provider-lifecycle.js";
 // The graph adapter — it converts an XState machine into a Graph of @statelyai/graph
 export { machineToGraph } from "./machine-to-graph.js";
 // The shared base class of the route map for both directions.
@@ -19,4 +31,9 @@ export { createRouteMap } from "./create-route-map.js";
 export { createRouteMapFromTree } from "./create-route-map-from-tree.js";
 // The helpers of a route lookup. matchesPattern stays private inside find-route.ts
 export { findRouteById, findRouteByPath } from "./find-route.js";
+// The release protocol of @xmachines/play. This package's own published `.d.ts` names
+// exactly these, so a consumer reads them from here and needs no second manifest
+// entry. It names `asCleanup` nowhere: a consumer of this package RECEIVES a
+// release, and builds one only with @xmachines/play itself.
+export { DISPOSE } from "@xmachines/play";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,mEAAmE;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAG3D,wHAAwH;AACxH,OAAO,EACN,gBAAgB,EAChB,mBAAmB,EACnB,YAAY,EACZ,kBAAkB,GAClB,MAAM,kBAAkB,CAAC;AAG1B,sBAAsB;AACtB,OAAO,EACN,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,GACrB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EACN,kBAAkB,EAClB,iBAAiB,EACjB,WAAW,EACX,4BAA4B,EAC5B,gBAAgB,GAChB,MAAM,YAAY,CAAC;AAEpB,qFAAqF;AACrF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAmBvD,8DAA8D;AAC9D,qFAAqF;AACrF,qBAAqB;AACrB,OAAO,EAAE,QAAQ,EAAqB,MAAM,qBAAqB,CAAC;AAOlE,kFAAkF;AAClF,iFAAiF;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAEzE,mFAAmF;AACnF,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,mEAAmE;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAG3D,wHAAwH;AACxH,OAAO,EACN,gBAAgB,EAChB,mBAAmB,EACnB,YAAY,EACZ,kBAAkB,GAClB,MAAM,kBAAkB,CAAC;AAG1B,sBAAsB;AACtB,OAAO,EACN,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,GACrB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EACN,kBAAkB,EAClB,iBAAiB,EACjB,WAAW,EACX,gBAAgB,EAChB,4BAA4B,EAC5B,gBAAgB,GAChB,MAAM,YAAY,CAAC;AAEpB,mFAAmF;AACnF,gFAAgF;AAChF,sFAAsF;AACtF,mBAAmB;AACnB,OAAO,EACN,iBAAiB,EACjB,eAAe,EACf,aAAa,EACb,YAAY,EACZ,YAAY,GACZ,MAAM,gBAAgB,CAAC;AAExB,kFAAkF;AAClF,uFAAuF;AACvF,OAAO,EACN,oBAAoB,EACpB,oBAAoB,EACpB,4BAA4B,EAC5B,aAAa,EACb,sBAAsB,GAEtB,MAAM,uBAAuB,CAAC;AAE/B,qFAAqF;AACrF,sFAAsF;AACtF,gFAAgF;AAChF,OAAO,EACN,iBAAiB,EACjB,QAAQ,EACR,sBAAsB,EACtB,kBAAkB,EAClB,qBAAqB,GACrB,MAAM,yBAAyB,CAAC;AAQjC,qFAAqF;AACrF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAoBvD,8DAA8D;AAC9D,qFAAqF;AACrF,qBAAqB;AACrB,OAAO,EAAE,QAAQ,EAAqB,MAAM,qBAAqB,CAAC;AAOlE,kFAAkF;AAClF,iFAAiF;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAEzE,mFAAmF;AACnF,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEjE,sFAAsF;AACtF,iFAAiF;AACjF,6EAA6E;AAC7E,4DAA4D;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/provider-lifecycle.d.ts

@@ -0,0 +1,197 @@
+/**
+ * The framework-free half of a `PlayRouterProvider`.
+ *
+ * A provider of a framework is two things: the lifecycle of a bridge, and about fifteen
+ * lines that bind that lifecycle to the effects of the framework. The lifecycle carries
+ * every decision — when the bridge is built, in which order it connects and
+ * disconnects, when a mount moves rather than rebuilds, and how a bridge that never
+ * heard of `basePath` is detected — and none of those decisions is framework-specific.
+ * They therefore live here, in a module that imports no framework, and each adapter
+ * keeps only its own effects.
+ *
+ * Four adapters used to hold a copy of the whole provider: React Router beside TanStack
+ * React, Solid Router beside TanStack Solid. Neither member of a pair could import the
+ * other, because each declares its own router as a `peerDependency`. This module is the
+ * home they all already depend on, and it stays framework-agnostic, so a consumer of
+ * `@xmachines/play-router` gains no framework dependency of any kind.
+ *
+ * @see [Multi-router integration](../../docs/examples/multi-router-integration.md)
+ */
+import { DISPOSE } from "@xmachines/play";
+import { type BasePathOptions } from "./base-path.js";
+import type { MountableRouterBridge, PlayActor, RouterBridge } from "./types.js";
+import type { RouteMap } from "./base-route-map.js";
+/**
+ * The props that every `PlayRouterProvider` of a framework shares.
+ *
+ * `TNode` is what the framework renders: `ReactNode` for React, `JSX.Element` for
+ * Solid. It is the ONLY thing in these props that a framework decides, which is why
+ * they live here and not in an adapter.
+ *
+ * An adapter re-exports a two-parameter alias of this type, with `TRouter` bound to
+ * the type of its router instance and `TNode` bound to its own node type.
+ */
+export interface PlayRouterProviderBaseProps<TRouter, TActor extends PlayActor, TNode> {
+    /**
+     * The actor to keep in step with the router. It must be a stable reference: give
+     * the same actor instance on every render. An actor in the JSX, or a new actor on
+     * each render, makes the bridge disconnect and connect again each time.
+     */
+    actor: TActor;
+    /** The router instance that the bridge keeps in step with the actor. It must be a stable reference. */
+    router: TRouter;
+    /**
+     * The route map of both directions, for the lookup between a state ID and a URL path.
+     *
+     * **It must be a stable reference.** The provider builds the bridge again on each
+     * change of the identity of `routeMap`. A value in the JSX, for example
+     * `createRouteMapFromTree(routeTree)`, makes a new object on every render, and the
+     * bridge therefore connects again on every render. Hold the value with `useMemo`:
+     *
+     * ```tsx
+     * const routeMap = useMemo(() => createRouteMapFromTree(routeTree), [routeTree]);
+     * ```
+     */
+    routeMap: RouteMap;
+    /**
+     * Mounts the routes of the machine under a URL prefix that the host owns, so that
+     * the routes of the host and the routes of the machine share one router.
+     *
+     * `actor`, `router`, and `routeMap` each need a stable reference. This prop needs
+     * none, and it rebuilds the bridge never: a change moves the live bridge with
+     * `setBasePath()`, so a host route that renders again with a new prefix keeps the
+     * actor, the route map, and its cache.
+     *
+     * The prefix says WHERE an actor is mounted, and never WHICH actor is mounted. An
+     * actor never changes identity, so a prefix segment that IDENTIFIES the actor gives
+     * a different `actor` prop instead, and THAT rebuilds the bridge — which is correct,
+     * because one actor takes one bridge.
+     *
+     * A location outside the prefix belongs completely to the host: the bridge sends no
+     * event there, and it corrects no URL there.
+     *
+     * Every `:param` needs a value. An unresolved one throws a
+     * `MissingBasePathParamError` out of the mount effect, because the bridge writes no
+     * URL without it. Render this component only after the host holds the value, which
+     * a route loader or a `useParams()` call does already.
+     */
+    basePath?: string;
+    /**
+     * The values of the `:param` segments of
+     * {@link PlayRouterProviderBaseProps.basePath}, for example `{ machineId }` for
+     * `basePath="/:machineId/play"`.
+     *
+     * An inline object literal is correct here: the provider compares this prop by
+     * value, and a move to the same prefix does nothing.
+     */
+    basePathParams?: Record<string, string | number>;
+    /** The renderer callback receives the same concrete actor type as the prop. */
+    renderer: (actor: TActor, router: TRouter) => TNode;
+}
+/**
+ * The constructor shape that a bridge class must satisfy for a provider factory: `(router, actor, routeMap, options?) → RouterBridge`.
+ *
+ * The return type is `RouterBridge`, the published contract of a bridge, so a
+ * consumer bridge of its own keeps compiling. Every bridge on `RouterBridgeBase` also
+ * satisfies `MountableRouterBridge`, and the provider finds that mount API at run
+ * time: a bridge without it ignores `basePath`, exactly as it did before the option
+ * existed.
+ */
+export type PlayRouterBridgeConstructor<TRouter> = new (router: TRouter, actor: PlayActor, routeMap: RouteMap, options?: BasePathOptions) => RouterBridge;
+/**
+ * Tells you whether a bridge can move its mount.
+ *
+ * {@link PlayRouterBridgeConstructor} asks for a `RouterBridge`, the published
+ * contract, so a consumer bridge that never heard of `basePath` still compiles. Such a
+ * bridge ignores the prefix, exactly as it did before the option existed, so the probe
+ * runs at run time rather than in the type system.
+ */
+export declare function isMountableBridge(bridge: RouterBridge | null | undefined): bridge is MountableRouterBridge;
+/**
+ * A key that changes when the MOUNT changes, and never when its identity changes.
+ *
+ * The comparison is BY VALUE, because `basePathParams` is normally an inline object
+ * literal: its identity changes on every render while the prefix does not, and a
+ * provider that watched the identity would move the mount on each render.
+ *
+ * @returns A string to compare, or to give to the dependency list of an effect.
+ */
+export declare function mountKey(basePath?: BasePathOptions["basePath"], basePathParams?: BasePathOptions["basePathParams"]): string;
+/** What {@link openProviderBridge} needs to build and connect a bridge. */
+export interface OpenProviderBridgeArgs<TRouter, TActor extends PlayActor> extends BasePathOptions {
+    router: TRouter;
+    actor: TActor;
+    routeMap: RouteMap;
+}
+/**
+ * Builds a bridge, connects it, and hands back the way to close it.
+ *
+ * The order is the contract: the constructor applies the mount, `connect()` runs the
+ * first synchronization against it, and `close()` disconnects exactly the bridge that
+ * this call opened. A provider that closed "the current bridge" instead would
+ * disconnect a later one when two mounts overlap.
+ *
+ * @returns The bridge, and a `close` that disconnects it one time.
+ */
+export declare function openProviderBridge<TRouter, TActor extends PlayActor>(BridgeCtor: PlayRouterBridgeConstructor<TRouter>, { router, actor, routeMap, basePath, basePathParams }: OpenProviderBridgeArgs<TRouter, TActor>): {
+    bridge: RouterBridge;
+    close: () => void;
+};
+/**
+ * Moves the mount of a live bridge, and rebuilds nothing.
+ *
+ * The call is safe directly after the open: it resolves to the prefix that the
+ * constructor applied already, and `setBasePath` then returns at once. A `null` bridge,
+ * and a bridge with no mount API, are both no-ops.
+ */
+export declare function repointProviderBridge(bridge: RouterBridge | null | undefined, basePath?: BasePathOptions["basePath"], basePathParams?: BasePathOptions["basePathParams"]): void;
+/**
+ * What `connectRouter` of an adapter returns.
+ *
+ * The value is CALLABLE, so `const disconnect = connectRouter(…); disconnect();` keeps
+ * working exactly as it did. It also carries the mount API, because a host that gives a
+ * `basePath` needs the two things {@link MountableRouterBridge} promises: the resolved
+ * mount to read back, and a way to move it. The bridge itself lives inside
+ * `connectRouter`, so without this handle a host had to rebuild the actor and the bridge
+ * to move a mount — which throws away the LRU cache of the route map, the very thing
+ * `setBasePath` exists to keep.
+ *
+ * `basePath` and `basePathParams` are GETTERS on the live bridge, so they cannot go
+ * stale.
+ */
+export interface RouterConnection {
+    /** Stops the synchronization. The same call as {@link RouterConnection.disconnect}. */
+    (): void;
+    /** Stops the synchronization. */
+    disconnect(): void;
+    /**
+     * Stops the synchronization when the scope of a `using` declaration ends.
+     *
+     * This value IS the release of `connectRouter`, and all eight router adapters return
+     * it, so it carries the protocol of `@xmachines/play` like every other release of the
+     * ecosystem:
+     *
+     * ```ts
+     * {
+     *   using connection = connectRouter({ actor, router, routeMap });
+     *   // disconnect() runs at the end of the scope, and after an exception too
+     * }
+     * ```
+     *
+     * The release is {@link RouterConnection.disconnect}, which is idempotent.
+     */
+    [DISPOSE](): void;
+    /** The resolved prefix of the mount, or `""` when the machine owns the whole router. */
+    readonly basePath: string;
+    /** The values of the `:param` segments of the mount. They travel in no event. */
+    readonly basePathParams: Readonly<Record<string, string>>;
+    /** Moves the mount of the live bridge, with no teardown. */
+    setBasePath(basePath?: BasePathOptions["basePath"], basePathParams?: BasePathOptions["basePathParams"]): void;
+}
+/**
+ * Wraps a live bridge in the {@link RouterConnection} that `connectRouter` returns.
+ *
+ * @param bridge - The bridge that `connectRouter` built and connected.
+ */
+export declare function createRouterConnection(bridge: MountableRouterBridge): RouterConnection;
+//# sourceMappingURL=provider-lifecycle.d.ts.map

package/dist/provider-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-lifecycle.d.ts","sourceRoot":"","sources":["../src/provider-lifecycle.ts"],"names":[],"mappings":"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"}

package/dist/provider-lifecycle.js

@@ -0,0 +1,167 @@
+/**
+ * The framework-free half of a `PlayRouterProvider`.
+ *
+ * A provider of a framework is two things: the lifecycle of a bridge, and about fifteen
+ * lines that bind that lifecycle to the effects of the framework. The lifecycle carries
+ * every decision — when the bridge is built, in which order it connects and
+ * disconnects, when a mount moves rather than rebuilds, and how a bridge that never
+ * heard of `basePath` is detected — and none of those decisions is framework-specific.
+ * They therefore live here, in a module that imports no framework, and each adapter
+ * keeps only its own effects.
+ *
+ * Four adapters used to hold a copy of the whole provider: React Router beside TanStack
+ * React, Solid Router beside TanStack Solid. Neither member of a pair could import the
+ * other, because each declares its own router as a `peerDependency`. This module is the
+ * home they all already depend on, and it stays framework-agnostic, so a consumer of
+ * `@xmachines/play-router` gains no framework dependency of any kind.
+ *
+ * @see [Multi-router integration](../../docs/examples/multi-router-integration.md)
+ */
+import { asCleanup, DISPOSE } from "@xmachines/play";
+import { normalizeBasePath } from "./base-path.js";
+/**
+ * Tells you whether a bridge can move its mount.
+ *
+ * {@link PlayRouterBridgeConstructor} asks for a `RouterBridge`, the published
+ * contract, so a consumer bridge that never heard of `basePath` still compiles. Such a
+ * bridge ignores the prefix, exactly as it did before the option existed, so the probe
+ * runs at run time rather than in the type system.
+ */
+export function isMountableBridge(bridge) {
+    // `!= null`, and not `!== null`: a binding that has not opened its bridge yet holds
+    // `undefined` as readily as `null`, and a strict test then read the property of it and
+    // threw a TypeError out of an effect.
+    return bridge != null && typeof bridge.setBasePath === "function";
+}
+/**
+ * A key that changes when the MOUNT changes, and never when its identity changes.
+ *
+ * The comparison is BY VALUE, because `basePathParams` is normally an inline object
+ * literal: its identity changes on every render while the prefix does not, and a
+ * provider that watched the identity would move the mount on each render.
+ *
+ * @returns A string to compare, or to give to the dependency list of an effect.
+ */
+export function mountKey(basePath, basePathParams) {
+    // The entries are SORTED before they are joined, because `JSON.stringify` follows the
+    // order of the properties: a params object that a host rebuilds in another order —
+    // `{ ...defaults, machineId }`, or one derived from a Map — gave a different key for
+    // the same mount, and every render then re-resolved the prefix.
+    //
+    // Each name, each value AND the prefix are escaped, because a raw join ALIASES. With
+    // "=" and "&" as literal separators, `{ a: "1&b=2" }` and `{ a: "1", b: "2" }` gave
+    // one key for two different mounts: the provider then saw no change, never
+    // re-pointed, and the bridge kept writing and stripping the old prefix — so every
+    // location read as foreign and the machine went silent.
+    // An absent value counts as an absent ENTRY, exactly as `resolveBasePath` reads it: a
+    // host that spreads an optional value — `{ ...defaults, region }` with no region —
+    // hands over `{ region: undefined }`, and `String(undefined)` put the text
+    // "undefined" in the key. That key differed from the key of the same mount without
+    // the entry, so every render re-pointed a bridge that had not moved.
+    const entries = Object.entries(basePathParams ?? {})
+        .filter(([, value]) => value !== undefined && value !== null)
+        .map(([name, value]) => `${encodeURIComponent(name)}=${encodeURIComponent(String(value))}`)
+        .toSorted();
+    return `${encodeURIComponent(basePath ?? "")}|${entries.join("&")}`;
+}
+/**
+ * Builds a bridge, connects it, and hands back the way to close it.
+ *
+ * The order is the contract: the constructor applies the mount, `connect()` runs the
+ * first synchronization against it, and `close()` disconnects exactly the bridge that
+ * this call opened. A provider that closed "the current bridge" instead would
+ * disconnect a later one when two mounts overlap.
+ *
+ * @returns The bridge, and a `close` that disconnects it one time.
+ */
+export function openProviderBridge(BridgeCtor, { router, actor, routeMap, basePath, basePathParams }) {
+    const bridge = new BridgeCtor(router, actor, routeMap, { basePath, basePathParams });
+    // A bridge on the three-argument signature drops the options object, and
+    // `PlayRouterBridgeConstructor` accepts one: it asks for the published `RouterBridge`,
+    // so a consumer bridge that never heard of `basePath` still compiles. Such a bridge
+    // then claims the WHOLE router, and its correction of an unknown path drags the user
+    // off every page the host owns — which is the opposite of what a prefix was asked
+    // for. Say so, once, rather than let it fail silently.
+    // `normalizeBasePath` decides what "no prefix" means, and no list of literals here
+    // does: an absent value, `""`, `"/"`, and `"//"` all normalize to `""` — see
+    // `BasePathOptions.basePath`. A hand-written list warned that a prefix was ignored for
+    // a caller that asked for no prefix at all, and it had to be kept in step with that
+    // function by hand.
+    //
+    // The probe of the bridge runs FIRST, so the normalization reaches a mountable bridge
+    // never: the constructor of such a bridge has refused an invalid prefix already, and a
+    // second refusal here would replace its error with an identical one from another
+    // stack. For a bridge with no mount the normalization can still throw, and a prefix
+    // that it refuses is a prefix all the same — the warning is the answer, not the throw.
+    if (!isMountableBridge(bridge) && hasPrefix(basePath)) {
+        console.warn(`[@xmachines/play-router] The provider received basePath "${basePath}", and ${BridgeCtor.name || "the bridge"} takes no mount: it has no setBasePath(), so the prefix is ignored and the bridge claims the whole router. Extend RouterBridgeBase, or drop the basePath prop.`);
+    }
+    void bridge.connect();
+    return {
+        bridge,
+        close: () => {
+            void bridge.disconnect();
+        },
+    };
+}
+/**
+ * Tells you whether a `basePath` option asks for a prefix at all.
+ *
+ * An absent value, `""`, `"/"`, and `"//"` all mean "no prefix", and
+ * {@link normalizeBasePath} is the one place that says so. A prefix that the function
+ * REFUSES is still a prefix that the caller asked for, so the refusal counts as `true`
+ * here: the caller learns that its bridge ignores the option, which is the message that
+ * this test exists to raise.
+ */
+function hasPrefix(basePath) {
+    try {
+        return normalizeBasePath(basePath) !== "";
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Moves the mount of a live bridge, and rebuilds nothing.
+ *
+ * The call is safe directly after the open: it resolves to the prefix that the
+ * constructor applied already, and `setBasePath` then returns at once. A `null` bridge,
+ * and a bridge with no mount API, are both no-ops.
+ */
+export function repointProviderBridge(bridge, basePath, basePathParams) {
+    if (isMountableBridge(bridge))
+        bridge.setBasePath(basePath, basePathParams);
+}
+/**
+ * Wraps a live bridge in the {@link RouterConnection} that `connectRouter` returns.
+ *
+ * @param bridge - The bridge that `connectRouter` built and connected.
+ */
+export function createRouterConnection(bridge) {
+    const disconnect = () => {
+        bridge.disconnect();
+    };
+    // `asCleanup` publishes the release under the dispose key, so a scope may own the
+    // connection. It is the ONE place that knows how for a release that is a FUNCTION: it
+    // writes `DISPOSE` and, where a polyfill of Explicit Resource Management installed the
+    // well-known symbol after this module evaluated, `Symbol.dispose` beside it, and it
+    // gives both keys a descriptor that a test double, a wrapper, and a later `asCleanup`
+    // can still redefine. A second copy of that rule here would be a second chance to
+    // disagree with it.
+    //
+    // An object LITERAL writes the key itself — `createRouter` and `createBrowserHistory`
+    // of play-dom-router each do. `asCleanup` takes a callable, and those two values are
+    // no callables, so the note of `packages/play/src/disposable.ts` covers them instead:
+    // a literal carries the key that existed when it was defined, so a polyfill belongs
+    // before the first import of `@xmachines/play`.
+    return Object.defineProperties(asCleanup(disconnect), {
+        disconnect: { value: disconnect, enumerable: true },
+        basePath: { get: () => bridge.basePath, enumerable: true },
+        basePathParams: { get: () => bridge.basePathParams, enumerable: true },
+        setBasePath: {
+            value: (basePath, basePathParams) => bridge.setBasePath(basePath, basePathParams),
+            enumerable: true,
+        },
+    });
+}
+//# sourceMappingURL=provider-lifecycle.js.map

package/dist/provider-lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-lifecycle.js","sourceRoot":"","sources":["../src/provider-lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,EAAE,iBAAiB,EAAwB,MAAM,gBAAgB,CAAC;AAwFzE;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAChC,MAAuC;IAEvC,oFAAoF;IACpF,uFAAuF;IACvF,sCAAsC;IACtC,OAAO,MAAM,IAAI,IAAI,IAAI,OAAQ,MAAgC,CAAC,WAAW,KAAK,UAAU,CAAC;AAC9F,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,QAAQ,CACvB,QAAsC,EACtC,cAAkD;IAElD,sFAAsF;IACtF,mFAAmF;IACnF,qFAAqF;IACrF,gEAAgE;IAChE,EAAE;IACF,qFAAqF;IACrF,oFAAoF;IACpF,2EAA2E;IAC3E,kFAAkF;IAClF,wDAAwD;IACxD,sFAAsF;IACtF,mFAAmF;IACnF,2EAA2E;IAC3E,mFAAmF;IACnF,qEAAqE;IACrE,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,cAAc,IAAI,EAAE,CAAC;SAClD,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,CAAC;SAC5D,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,kBAAkB,CAAC,IAAI,CAAC,IAAI,kBAAkB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;SAC1F,QAAQ,EAAE,CAAC;IACb,OAAO,GAAG,kBAAkB,CAAC,QAAQ,IAAI,EAAE,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;AACrE,CAAC;AASD;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB,CACjC,UAAgD,EAChD,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAA2C;IAE9F,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC,CAAC;IAErF,yEAAyE;IACzE,uFAAuF;IACvF,oFAAoF;IACpF,qFAAqF;IACrF,kFAAkF;IAClF,uDAAuD;IACvD,mFAAmF;IACnF,6EAA6E;IAC7E,uFAAuF;IACvF,oFAAoF;IACpF,oBAAoB;IACpB,EAAE;IACF,sFAAsF;IACtF,uFAAuF;IACvF,iFAAiF;IACjF,oFAAoF;IACpF,uFAAuF;IACvF,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;QACvD,OAAO,CAAC,IAAI,CACX,4DAA4D,QAAQ,UACnE,UAAU,CAAC,IAAI,IAAI,YACpB,gKAAgK,CAChK,CAAC;IACH,CAAC;IAED,KAAK,MAAM,CAAC,OAAO,EAAE,CAAC;IACtB,OAAO;QACN,MAAM;QACN,KAAK,EAAE,GAAG,EAAE;YACX,KAAK,MAAM,CAAC,UAAU,EAAE,CAAC;QAC1B,CAAC;KACD,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,SAAS,CAAC,QAAqC;IACvD,IAAI,CAAC;QACJ,OAAO,iBAAiB,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;IAC3C,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,IAAI,CAAC;IACb,CAAC;AACF,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACpC,MAAuC,EACvC,QAAsC,EACtC,cAAkD;IAElD,IAAI,iBAAiB,CAAC,MAAM,CAAC;QAAE,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;AAC7E,CAAC;AAiDD;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,MAA6B;IACnE,MAAM,UAAU,GAAG,GAAS,EAAE;QAC7B,MAAM,CAAC,UAAU,EAAE,CAAC;IACrB,CAAC,CAAC;IAEF,kFAAkF;IAClF,sFAAsF;IACtF,uFAAuF;IACvF,oFAAoF;IACpF,sFAAsF;IACtF,kFAAkF;IAClF,oBAAoB;IACpB,EAAE;IACF,sFAAsF;IACtF,qFAAqF;IACrF,sFAAsF;IACtF,oFAAoF;IACpF,gDAAgD;IAChD,OAAO,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,UAAU,CAAqB,EAAE;QACzE,UAAU,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE;QACnD,QAAQ,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE;QAC1D,cAAc,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;QACtE,WAAW,EAAE;YACZ,KAAK,EAAE,CACN,QAAsC,EACtC,cAAkD,EACjD,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,cAAc,CAAC;YACjD,UAAU,EAAE,IAAI;SAChB;KACD,CAAC,CAAC;AACJ,CAAC"}

package/dist/query.d.ts

@@ -1,5 +1,7 @@
 import type { Graph } from "@statelyai/graph";
 import type { RouteTree, RouteNode, MachineNodeData, MachineEdgeData } from "./types.js";
+import type { RouteMapping } from "./base-route-map.js";
+import { type BasePathOptions } from "./base-path.js";
 /**
  * Returns every route of a navigation from the given state
  *
@@ -99,4 +101,51 @@ export declare const getTransitionReachableRoutes: (graph: Graph<MachineNodeData
  * ```
  */
 export declare const isRouteReachable: (graph: Graph<MachineNodeData, MachineEdgeData>, fromStateId: string, toStateId: string) => boolean;
+/**
+ * Returns the `{ stateId, path }` entries that a host router needs, so that it can
+ * register the routes of a machine under a base path, and remove them again later.
+ *
+ * This function makes the routes dynamic. `getStateIdByPath` and `getPathByStateId`
+ * answer the question "what is this URL?" at the moment of a navigation, but a host
+ * that declares real route objects — a route tree of TanStack, a `RouteObject[]`, an
+ * `addRoute` call of vue-router — needs the LIST in advance, and it needs that list
+ * with the prefix of the mount. A registration of these paths, and a removal of them
+ * when the machine unloads, keeps the route table of the host in step with the mount.
+ *
+ * `basePathParams` decides the form of each path, and both forms are useful:
+ * - **Given** → a concrete path (`/abc123/play/profile/:userId`), for a route that
+ *   the host adds at run time, after a loader resolved the mount.
+ * - **Absent** → the pattern stays (`/:machineId/play/profile/:userId`), for a static
+ *   route declaration of the host.
+ *
+ * The function ALWAYS keeps each `:param` segment that the machine declares itself:
+ * those are the params that the route of the host must match.
+ *
+ * @param tree - The route tree of extractMachineRoutes()
+ * @param options - The optional `{ basePath, basePathParams }`, the same option as the bridge takes.
+ * Each `stateId` comes from the route tree, so it carries NO `#` prefix. A host that
+ * keys its route table on the target of a `play.route` event adds the `#` itself,
+ * because the event always carries the prefixed form.
+ *
+ * @returns One entry for each state with a route, in the order of the route tree.
+ * @throws {InvalidBasePathError} For a base path that resolves to one concrete path never.
+ * @throws {MissingBasePathParamError} When `basePathParams` is present and it omits a `:param`.
+ *
+ * @example
+ * ```typescript
+ * const tree = extractMachineRoutes(machine);
+ *
+ * // Concrete, for a route that the host adds after a loader resolved the mount
+ * getRouteMappings(tree, { basePath: "/:machineId/play", basePathParams: { machineId: "abc123" } });
+ * // [
+ * //   { stateId: "app.home",    path: "/abc123/play" },
+ * //   { stateId: "app.profile", path: "/abc123/play/profile/:userId" },
+ * // ]
+ *
+ * // The pattern, for a static route declaration of the host
+ * getRouteMappings(tree, { basePath: "/:machineId/play" });
+ * // [{ stateId: "app.home", path: "/:machineId/play" }, ...]
+ * ```
+ */
+export declare const getRouteMappings: (tree: RouteTree, options?: BasePathOptions) => RouteMapping[];
 //# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAa,MAAM,kBAAkB,CAAC;AAEzD,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAqBzF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,SAAS,EAAE,SAAS,MAAM,KAAG,SAAS,EA0B9E,CAAC;AAkBF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,SAAS,KAAG,SAAS,EAW5D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,SAAS,EAAE,MAAM,MAAM,KAAG,OAE3D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,4BAA4B,GACxC,OAAO,KAAK,CAAC,eAAe,EAAE,eAAe,CAAC,EAC9C,SAAS,MAAM,KACb,MAAM,EAER,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,gBAAgB,GAC5B,OAAO,KAAK,CAAC,eAAe,EAAE,eAAe,CAAC,EAC9C,aAAa,MAAM,EACnB,WAAW,MAAM,KACf,OAKF,CAAC"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAa,MAAM,kBAAkB,CAAC;AAEzD,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAIN,KAAK,eAAe,EACpB,MAAM,gBAAgB,CAAC;AAqBxB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,SAAS,EAAE,SAAS,MAAM,KAAG,SAAS,EA0B9E,CAAC;AAkBF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,SAAS,KAAG,SAAS,EAW5D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,SAAS,EAAE,MAAM,MAAM,KAAG,OAE3D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,4BAA4B,GACxC,OAAO,KAAK,CAAC,eAAe,EAAE,eAAe,CAAC,EAC9C,SAAS,MAAM,KACb,MAAM,EAER,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,gBAAgB,GAC5B,OAAO,KAAK,CAAC,eAAe,EAAE,eAAe,CAAC,EAC9C,aAAa,MAAM,EACnB,WAAW,MAAM,KACf,OAKF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,SAAS,EAAE,UAAU,eAAe,KAAG,YAAY,EAazF,CAAC"}

package/dist/query.js

@@ -1,4 +1,5 @@
 import { getSuccessors, hasNode, hasPath } from "@statelyai/graph";
+import { joinBasePath, normalizeBasePath, resolveBasePath, } from "./base-path.js";
 /**
  * Returns the successor nodes of a state that have a route: the states of a direct
  * transition edge that hold a `meta.route` field.
@@ -166,4 +167,62 @@ export const isRouteReachable = (graph, fromStateId, toStateId) => {
         ? hasPath(graph, fromStateId, toStateId)
         : false;
 };
+/**
+ * Returns the `{ stateId, path }` entries that a host router needs, so that it can
+ * register the routes of a machine under a base path, and remove them again later.
+ *
+ * This function makes the routes dynamic. `getStateIdByPath` and `getPathByStateId`
+ * answer the question "what is this URL?" at the moment of a navigation, but a host
+ * that declares real route objects — a route tree of TanStack, a `RouteObject[]`, an
+ * `addRoute` call of vue-router — needs the LIST in advance, and it needs that list
+ * with the prefix of the mount. A registration of these paths, and a removal of them
+ * when the machine unloads, keeps the route table of the host in step with the mount.
+ *
+ * `basePathParams` decides the form of each path, and both forms are useful:
+ * - **Given** → a concrete path (`/abc123/play/profile/:userId`), for a route that
+ *   the host adds at run time, after a loader resolved the mount.
+ * - **Absent** → the pattern stays (`/:machineId/play/profile/:userId`), for a static
+ *   route declaration of the host.
+ *
+ * The function ALWAYS keeps each `:param` segment that the machine declares itself:
+ * those are the params that the route of the host must match.
+ *
+ * @param tree - The route tree of extractMachineRoutes()
+ * @param options - The optional `{ basePath, basePathParams }`, the same option as the bridge takes.
+ * Each `stateId` comes from the route tree, so it carries NO `#` prefix. A host that
+ * keys its route table on the target of a `play.route` event adds the `#` itself,
+ * because the event always carries the prefixed form.
+ *
+ * @returns One entry for each state with a route, in the order of the route tree.
+ * @throws {InvalidBasePathError} For a base path that resolves to one concrete path never.
+ * @throws {MissingBasePathParamError} When `basePathParams` is present and it omits a `:param`.
+ *
+ * @example
+ * ```typescript
+ * const tree = extractMachineRoutes(machine);
+ *
+ * // Concrete, for a route that the host adds after a loader resolved the mount
+ * getRouteMappings(tree, { basePath: "/:machineId/play", basePathParams: { machineId: "abc123" } });
+ * // [
+ * //   { stateId: "app.home",    path: "/abc123/play" },
+ * //   { stateId: "app.profile", path: "/abc123/play/profile/:userId" },
+ * // ]
+ *
+ * // The pattern, for a static route declaration of the host
+ * getRouteMappings(tree, { basePath: "/:machineId/play" });
+ * // [{ stateId: "app.home", path: "/:machineId/play" }, ...]
+ * ```
+ */
+export const getRouteMappings = (tree, options) => {
+    // With the params, resolve the prefix to a concrete path. Without them, keep the
+    // pattern, so that a host declares its routes statically and substitutes each param
+    // itself.
+    const basePath = options?.basePathParams === undefined
+        ? normalizeBasePath(options?.basePath)
+        : resolveBasePath(options.basePath, options.basePathParams).path;
+    return getRoutableRoutes(tree).map((node) => ({
+        stateId: node.stateId,
+        path: joinBasePath(basePath, node.fullPath),
+    }));
+};
 //# sourceMappingURL=query.js.map

package/dist/query.js.map

@@ -1 +1 @@
-{"version":3,"file":"query.js","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"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"}