@xmachines/play-xstate 1.0.0 → 2.0.0-alpha.1

package/dist/routing/create-routed-machine.js

@@ -0,0 +1,71 @@
+import { formatPlayRouteTransitions, } from "./format-play-route-transitions.js";
+/**
+ * Returns a `createMachine` that routes: identical signature to the setup's
+ * own `createMachine`, with {@link formatPlayRouteTransitions} applied to the
+ * config at runtime.
+ *
+ * ### Why this exists
+ *
+ * `formatPlayRouteTransitions(config)` accepts a loosely-typed config. A config
+ * authored as a standalone value loses inline transition-function parameter
+ * inference entirely (implicit-any under strict mode), and even the inline
+ * `setup().createMachine(formatPlayRouteTransitions({ ... }))` form depends on
+ * TypeScript threading contextual typing through two generic calls.
+ *
+ * This wrapper removes the question: it is typed as the setup's own
+ * `createMachine`, so the config is contextually typed exactly as if passed to
+ * `setup().createMachine(...)` directly — transition-function args infer from
+ * the setup's schemas, sibling targets are validated, and the returned machine
+ * keeps its full literal state-value typing.
+ *
+ * Typing is *identical to native* — including its current gaps: as of xstate
+ * 6.0.0-alpha.20, `event` and `context` reads in transition args are fully
+ * typed, while returned context patches are property-typed but still carry a
+ * loose index signature in the alpha itself. Expect that to tighten upstream
+ * without changes here.
+ *
+ * @example
+ * ```typescript
+ * import { setup, types } from "xstate";
+ * import { createRoutedMachine, playMetaSchema, playRouteEventSchema } from "@xmachines/play-xstate";
+ *
+ * const authSetup = setup({
+ *   schemas: {
+ *     context: types<{ isAuthenticated: boolean }>(),
+ *     events: { "play.route": playRouteEventSchema },
+ *     meta: playMetaSchema,
+ *   },
+ * });
+ *
+ * const machine = createRoutedMachine(authSetup)({
+ *   initial: "home",
+ *   context: { isAuthenticated: false },
+ *   states: {
+ *     home: { id: "home", meta: { route: "/" } },
+ *     login: { id: "login", meta: { route: "/login" } },
+ *   },
+ * });
+ * // ({ context }) params in transitions infer from the setup schemas —
+ * // no explicit annotations needed.
+ * ```
+ *
+ * Note: routes are injected at runtime, so the machine's static type does not
+ * gain an `xstate.route` event for them — `play.route` (declared in the
+ * setup's event schemas) remains the typed public API; native `xstate.route`
+ * interop is runtime-only.
+ *
+ * @param s - A `setup(...)` return value (anything with `createMachine`).
+ * @returns A function with the same signature as `s.createMachine` that
+ *   applies {@link formatPlayRouteTransitions} before creating the machine.
+ *
+ * @see {@link formatPlayRouteTransitions} for the routing transform itself
+ */
+export const createRoutedMachine = (s) => 
+// The runtime transform only ADDS behavior (native route configs + the
+// play.route forwarder) and preserves the config's own shape, so exposing
+// the setup's exact createMachine signature keeps native config typing.
+((config) => 
+// One internal widening cast: the `never[]` constraint that keeps
+// SetupLike any-free also makes the parameter uncallable directly.
+s.createMachine(formatPlayRouteTransitions(config)));
+//# sourceMappingURL=create-routed-machine.js.map

package/dist/routing/create-routed-machine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-routed-machine.js","sourceRoot":"","sources":["../../src/routing/create-routed-machine.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,0BAA0B,GAE1B,MAAM,oCAAoC,CAAC;AAa5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAA2B,CAAS,EAA2B,EAAE;AACnG,uEAAuE;AACvE,0EAA0E;AAC1E,wEAAwE;AACxE,CAAC,CAAC,MAA0B,EAAE,EAAE;AAC/B,kEAAkE;AAClE,mEAAmE;AAClE,CAAC,CAAC,aAA8C,CAChD,0BAA0B,CAAC,MAAM,CAAC,CAClC,CAA4B,CAAC"}

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

@@ -17,7 +17,7 @@ import { type AnyStateMachine } from "xstate";
  * a different restored route → actor wins). Because the derivation never consults a
  * restored snapshot, it always yields the machine's **default** initial route.
  *
- * @param machine - XState v5 state machine definition.
+ * @param machine - XState v6 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

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

@@ -18,7 +18,7 @@ import { deriveCurrentRoute } from "./derive-current-route.js";
  * a different restored route → actor wins). Because the derivation never consults a
  * restored snapshot, it always yields the machine's **default** initial route.
  *
- * @param machine - XState v5 state machine definition.
+ * @param machine - XState v6 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

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

@@ -18,6 +18,8 @@ export type RouteStateNode = {
          */
         route?: RouteMetadata;
     };
+    /** XState v6 native route config; injected as `{}` when absent. */
+    route?: unknown;
     /** Nested child states, recursively crawled for additional route declarations. */
     states?: Record<string, RouteStateNode>;
     [key: string]: unknown;
@@ -30,8 +32,15 @@ export type RouteStateNode = {
  * 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()`.
+ * of the RETURN value, so it remains directly usable by `setup().createMachine()`.
+ *
+ * Known limitation: a config authored as a STANDALONE value
+ * (`const config = formatPlayRouteTransitions({...})`) is typed against this
+ * loose shape only, so inline transition functions lose parameter inference
+ * (implicit-any under strict mode). Written inline inside a
+ * `setup().createMachine(formatPlayRouteTransitions({...}))` call, contextual
+ * typing still flows. {@link createRoutedMachine} is the recommended entry
+ * point either way — it keeps the setup's exact `createMachine` signature.
  */
 export type RouteMachineConfig = {
     context?: unknown;
@@ -40,12 +49,18 @@ export type RouteMachineConfig = {
     [key: string]: unknown;
 };
 /**
- * Formats play.route transitions from declarative route configs
+ * Formats play.route routing from 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.
+ * Crawls machine states looking for states with `meta.route` and wires them to
+ * XState v6's **native routing machinery**:
  *
- * Inspired by XState's internal formatRouteTransitions (stateUtils.ts line 391).
+ * - every routed state gets a native `route: {}` config (unless it already
+ *   declares its own `route`), making it targetable via the built-in
+ *   `{ type: "xstate.route", to: "#id" }` event (Stately tooling interop and
+ *   statically-known graph edges), and
+ * - one root-level `play.route` forwarder performs the navigation for those
+ *   targets as ONE atomic transition: target + re-entry + a shallow
+ *   `params`/`query` context patch.
  *
  * @example
  * ```typescript
@@ -60,13 +75,41 @@ 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
+ * Because the injected `route` configs are static (object form), the machine's
+ * route transitions keep **statically-known targets** — `toDirectedGraph()` /
+ * `machineToGraph()` edges point at the actual routed states, so graph
+ * reachability queries work. (Function-form transition candidates would have
+ * dynamic targets, opaque to static analysis.)
+ *
+ * The `play.route` public API and its v5 semantics are preserved:
+ * - `send({ type: "play.route", to: "#home", params, query })` navigates and
+ *   patches `context.params`/`context.query` in the SAME transition — exit
+ *   actions of the departing state observe the OLD params, entry actions of
+ *   the target observe the NEW ones, `always` transitions never see a
+ *   half-navigated intermediate state, and entry/exit actions receive the
+ *   original `play.route` event;
+ * - user-defined `play.route` transitions (e.g. a hand-written 404 fallback)
+ *   are preserved AFTER the forwarder: for unknown targets the forwarder
+ *   returns `undefined`, so evaluation falls through to them;
+ * - `params`/`query` are only patched when the forwarder navigates — unknown
+ *   and blocked targets leave context untouched.
+ *
+ * When a state declares its OWN `route` config (which wins over the injected
+ * default), the forwarder re-raises the event as `xstate.route` instead of
+ * navigating, so the user's resolver decides — including blocking. The
+ * forwarder does NOT patch `params`/`query` for such targets (a blocking
+ * resolver would otherwise leave context describing a route that was never
+ * entered); the user's function-form resolver owns any context patch, and
+ * that navigation microstep runs under the `xstate.route` event.
+ *
+ * Native `xstate.route` events also work directly (Stately ecosystem tooling),
+ * but bypass the forwarder — no `params`/`query` context patch is applied, so
+ * stale values from earlier `play.route` events linger in context (and a
+ * router bridge deriving the URL from context would interpolate those stale
+ * params).
  *
  * @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`.
+ * @returns The machine config with native `route` configs and the `play.route` forwarder merged in, preserving the original type `T`.
  */
 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":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;;;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,CA0E5F"}
+{"version":3,"file":"format-play-route-transitions.d.ts","sourceRoot":"","sources":["../../src/routing/format-play-route-transitions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;;;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,mEAAmE;IACnE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACxC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB,CAAC;AA4BF;;;;;;;;;;;;;;;;;GAiBG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,kBAAkB,EAAE,aAAa,EAAE,CAAC,GAAG,CAAC,CAyH5F"}

package/dist/routing/format-play-route-transitions.js

@@ -1,13 +1,18 @@
-import { assign } from "xstate";
 import { MissingStateIdError } from "../errors.js";
 import { normalizeRoute } from "./derive-route.js";
 /**
- * Formats play.route transitions from declarative route configs
+ * Formats play.route routing from 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.
+ * Crawls machine states looking for states with `meta.route` and wires them to
+ * XState v6's **native routing machinery**:
  *
- * Inspired by XState's internal formatRouteTransitions (stateUtils.ts line 391).
+ * - every routed state gets a native `route: {}` config (unless it already
+ *   declares its own `route`), making it targetable via the built-in
+ *   `{ type: "xstate.route", to: "#id" }` event (Stately tooling interop and
+ *   statically-known graph edges), and
+ * - one root-level `play.route` forwarder performs the navigation for those
+ *   targets as ONE atomic transition: target + re-entry + a shallow
+ *   `params`/`query` context patch.
  *
  * @example
  * ```typescript
@@ -22,21 +27,58 @@ import { normalizeRoute } from "./derive-route.js";
  * 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
+ * Because the injected `route` configs are static (object form), the machine's
+ * route transitions keep **statically-known targets** — `toDirectedGraph()` /
+ * `machineToGraph()` edges point at the actual routed states, so graph
+ * reachability queries work. (Function-form transition candidates would have
+ * dynamic targets, opaque to static analysis.)
+ *
+ * The `play.route` public API and its v5 semantics are preserved:
+ * - `send({ type: "play.route", to: "#home", params, query })` navigates and
+ *   patches `context.params`/`context.query` in the SAME transition — exit
+ *   actions of the departing state observe the OLD params, entry actions of
+ *   the target observe the NEW ones, `always` transitions never see a
+ *   half-navigated intermediate state, and entry/exit actions receive the
+ *   original `play.route` event;
+ * - user-defined `play.route` transitions (e.g. a hand-written 404 fallback)
+ *   are preserved AFTER the forwarder: for unknown targets the forwarder
+ *   returns `undefined`, so evaluation falls through to them;
+ * - `params`/`query` are only patched when the forwarder navigates — unknown
+ *   and blocked targets leave context untouched.
+ *
+ * When a state declares its OWN `route` config (which wins over the injected
+ * default), the forwarder re-raises the event as `xstate.route` instead of
+ * navigating, so the user's resolver decides — including blocking. The
+ * forwarder does NOT patch `params`/`query` for such targets (a blocking
+ * resolver would otherwise leave context describing a route that was never
+ * entered); the user's function-form resolver owns any context patch, and
+ * that navigation microstep runs under the `xstate.route` event.
+ *
+ * Native `xstate.route` events also work directly (Stately ecosystem tooling),
+ * but bypass the forwarder — no `params`/`query` context patch is applied, so
+ * stale values from earlier `play.route` events linger in context (and a
+ * router bridge deriving the URL from context would interpolate those stale
+ * params).
  *
  * @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`.
+ * @returns The machine config with native `route` configs and the `play.route` forwarder merged in, preserving the original type `T`.
  */
 export function formatPlayRouteTransitions(machineConfig) {
-    const routeTransitions = [];
-    const collectRoutes = (states, parentPath = "") => {
-        Object.entries(states).forEach(([key, stateConfig]) => {
-            const node = stateConfig;
-            // Build the full key-based path from the root for the transition target
-            // (XState targets use the state key hierarchy, not explicit IDs)
+    /**
+     * Routing table: `#id` -> the state's key path (e.g. `.dashboard.stats`)
+     * for targets whose `route` config was injected by this transform, or
+     * `null` for targets with a USER-declared `route` config (the user's
+     * resolver decides those — the forwarder re-raises instead of navigating).
+     */
+    const routeTargets = new Map();
+    /**
+     * Rebuild the states tree, injecting a native `route` config into routed
+     * nodes. The input config is never mutated — every node is shallow-copied.
+     */
+    const injectRoutes = (states, parentPath = "") => {
+        const next = {};
+        for (const [key, stateConfig] of Object.entries(states)) {
+            const node = { ...stateConfig };
             const statePath = parentPath ? `${parentPath}.${key}` : key;
             // Validates the metadata (malformed object routes throw
             // InvalidRouteMetadataError) and normalizes to the path string. Both
@@ -48,48 +90,79 @@ export function formatPlayRouteTransitions(machineConfig) {
             if (routePath && !node.id) {
                 throw new MissingStateIdError(key, routePath);
             }
-            if (routePath && node.id) {
-                const transition = {
-                    target: `.${statePath}`,
-                    guard: ({ event }) => event.to === `#${node.id}`,
-                    reenter: true,
-                    actions: assign({
-                        params: ({ event }) => event.params || {},
-                        query: ({ event }) => event.query || {},
-                    }),
-                };
-                routeTransitions.push(transition);
-            }
             if (node.states) {
-                collectRoutes(node.states, statePath);
+                node.states = injectRoutes(node.states, statePath);
+            }
+            if (routePath && node.id) {
+                if (node.route === undefined) {
+                    // Native object-form route config: statically-targeted transition,
+                    // visible to graph tooling. The play.route forwarder navigates these
+                    // targets DIRECTLY (atomically); the native config exists for
+                    // xstate.route interop (Stately tooling, devtools).
+                    node.route = {};
+                    routeTargets.set(`#${node.id}`, `.${statePath}`);
+                }
+                else {
+                    // A user-declared route config wins: the forwarder re-raises
+                    // xstate.route so the user's resolver decides (and owns any
+                    // context patch).
+                    routeTargets.set(`#${node.id}`, null);
+                }
             }
-        });
+            next[key] = node;
+        }
+        return next;
     };
     const machineStates = machineConfig.states;
-    if (machineStates) {
-        collectRoutes(machineStates);
+    const injectedStates = machineStates ? injectRoutes(machineStates) : machineStates;
+    if (routeTargets.size === 0) {
+        return machineConfig;
     }
-    if (routeTransitions.length > 0) {
-        const existingOn = machineConfig.on || {};
-        // Preserve user-defined play.route transitions (e.g. a hand-written 404
-        // fallback) by appending them AFTER the generated ones: XState evaluates
-        // candidate transitions in order, so generated guards win when they match
-        // and the user's transitions act as fallbacks otherwise.
-        const userRouteTransitions = existingOn["play.route"];
-        const normalizedUserTransitions = userRouteTransitions === undefined
-            ? []
-            : Array.isArray(userRouteTransitions)
-                ? userRouteTransitions
-                : [userRouteTransitions];
-        const updatedOn = {
-            ...existingOn,
-            "play.route": [...routeTransitions, ...normalizedUserTransitions],
-        };
+    // Root play.route forwarder. For injected-route targets it returns ONE
+    // atomic transition (target + reenter + params/query patch): exit actions
+    // see the OLD params, `always` transitions never observe a half-navigated
+    // intermediate state, and entry/exit actions receive the original
+    // play.route event. For user-routed targets it re-raises xstate.route
+    // WITHOUT patching (the user's resolver owns the patch — otherwise a
+    // blocking resolver would leave context describing a route that was never
+    // entered). Unknown targets return undefined so user fallback candidates
+    // below are evaluated.
+    const forwarder = ({ event }, enq) => {
+        const target = routeTargets.get(event.to);
+        if (target === undefined)
+            return undefined;
+        if (target === null) {
+            enq.raise({ ...event, type: "xstate.route" });
+            return {};
+        }
         return {
-            ...machineConfig,
-            on: updatedOn,
+            target,
+            reenter: true,
+            // Shallow context patch — v6's replacement for assign().
+            context: {
+                params: event.params || {},
+                query: event.query || {},
+            },
         };
-    }
-    return machineConfig;
+    };
+    // Preserve user-defined play.route transitions (e.g. a hand-written 404
+    // fallback) by appending them AFTER the forwarder: XState evaluates
+    // candidate transitions in order, so the forwarder wins for known targets
+    // and the user's transitions act as fallbacks otherwise.
+    const existingOn = machineConfig.on || {};
+    const userRouteTransitions = existingOn["play.route"];
+    const normalizedUserTransitions = userRouteTransitions === undefined
+        ? []
+        : Array.isArray(userRouteTransitions)
+            ? userRouteTransitions
+            : [userRouteTransitions];
+    return {
+        ...machineConfig,
+        states: injectedStates,
+        on: {
+            ...existingOn,
+            "play.route": [forwarder, ...normalizedUserTransitions],
+        },
+    };
 }
 //# sourceMappingURL=format-play-route-transitions.js.map

package/dist/routing/format-play-route-transitions.js.map

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

package/dist/routing/index.d.ts

@@ -11,6 +11,10 @@ export { deriveCurrentRoute } from "./derive-current-route.js";
 export { deriveInitialRoute } from "./derive-initial-route.js";
 export { buildRouteUrl } from "./build-url.js";
 export { formatPlayRouteTransitions } from "./format-play-route-transitions.js";
+export { playMetaSchema, playRouteEventSchema } from "./schemas.js";
+export type { PlayRoutePayload, WithOptional } from "./schemas.js";
+export type { SetupLike } from "./create-routed-machine.js";
+export { createRoutedMachine } from "./create-routed-machine.js";
 export type { RouteMachineConfig, RouteStateNode } from "./format-play-route-transitions.js";
 export type { RouteContext, RouteObject, RouteMetadata } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/routing/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/routing/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAChF,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAC7F,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/routing/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpE,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACnE,YAAY,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAC7F,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}

package/dist/routing/index.js

@@ -11,4 +11,6 @@ export { deriveCurrentRoute } from "./derive-current-route.js";
 export { deriveInitialRoute } from "./derive-initial-route.js";
 export { buildRouteUrl } from "./build-url.js";
 export { formatPlayRouteTransitions } from "./format-play-route-transitions.js";
+export { playMetaSchema, playRouteEventSchema } from "./schemas.js";
+export { createRoutedMachine } from "./create-routed-machine.js";
 //# sourceMappingURL=index.js.map

package/dist/routing/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/routing/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/routing/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAGpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/routing/play-route-event.typecheck.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=play-route-event.typecheck.d.ts.map

package/dist/routing/play-route-event.typecheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"play-route-event.typecheck.d.ts","sourceRoot":"","sources":["../../src/routing/play-route-event.typecheck.ts"],"names":[],"mappings":""}

package/dist/routing/play-route-event.typecheck.js

@@ -0,0 +1,43 @@
+/**
+ * Type-level contract for the play.route event payload as machines receive it
+ * through playRouteEventSchema. Pins the requirements the hand-written v5
+ * union enforced: `to` is required and string-typed; params/query/match are
+ * omittable; values constructed as PlayRouteEvent (router bridges) remain
+ * assignable.
+ */
+import { setup } from "xstate";
+import { playRouteEventSchema } from "./schemas.js";
+const s = setup({
+    schemas: {
+        events: { "play.route": playRouteEventSchema },
+    },
+});
+const m = s.createMachine({ initial: "a", states: { a: {} } });
+// Minimal send: optional payload fields are omittable.
+const minimal = { type: "play.route", to: "#home" };
+// Full send: every documented field accepted.
+const full = {
+    type: "play.route",
+    to: "#profile",
+    params: { username: "alice" },
+    query: { tab: "posts" },
+    match: {},
+};
+// @ts-expect-error `to` is required — a routeless play.route must not compile
+const missingTo = { type: "play.route" };
+// @ts-expect-error `to` must be a string
+const badTo = { type: "play.route", to: 123 };
+const badParams = {
+    type: "play.route",
+    to: "#p",
+    // @ts-expect-error `params` values must be strings
+    params: { n: 42 },
+};
+const fromBridge = bridgeEvent;
+void fromBridge;
+void minimal;
+void full;
+void missingTo;
+void badTo;
+void badParams;
+//# sourceMappingURL=play-route-event.typecheck.js.map

package/dist/routing/play-route-event.typecheck.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"play-route-event.typecheck.js","sourceRoot":"","sources":["../../src/routing/play-route-event.typecheck.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,KAAK,EAAuB,MAAM,QAAQ,CAAC;AAEpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEpD,MAAM,CAAC,GAAG,KAAK,CAAC;IACf,OAAO,EAAE;QACR,MAAM,EAAE,EAAE,YAAY,EAAE,oBAAoB,EAAE;KAC9C;CACD,CAAC,CAAC;AACH,MAAM,CAAC,GAAG,CAAC,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;AAG/D,uDAAuD;AACvD,MAAM,OAAO,GAAyB,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC;AAE1E,8CAA8C;AAC9C,MAAM,IAAI,GAAyB;IAClC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,UAAU;IACd,MAAM,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE;IAC7B,KAAK,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE;IACvB,KAAK,EAAE,EAAE;CACT,CAAC;AAEF,8EAA8E;AAC9E,MAAM,SAAS,GAAyB,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC;AAE/D,yCAAyC;AACzC,MAAM,KAAK,GAAyB,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC;AAEpE,MAAM,SAAS,GAAyB;IACvC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,IAAI;IACR,mDAAmD;IACnD,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;CACjB,CAAC;AAKF,MAAM,UAAU,GAAyB,WAAW,CAAC;AAErD,KAAK,UAAU,CAAC;AAChB,KAAK,OAAO,CAAC;AACb,KAAK,IAAI,CAAC;AACV,KAAK,SAAS,CAAC;AACf,KAAK,KAAK,CAAC;AACX,KAAK,SAAS,CAAC"}

package/dist/routing/schemas.d.ts

@@ -0,0 +1,99 @@
+import type { PlayRouteEvent } from "@xmachines/play-router";
+import type { PlaySpec } from "@xmachines/play-actor";
+import type { RouteMetadata } from "./types.js";
+/**
+ * Event schema for the `play.route` navigation event, for use in an XState v6
+ * `schemas.events` map.
+ *
+ * XState v6 declares machine events as a map of event type to payload schema
+ * (payloads exclude the `type` field). Every Play machine handles `play.route`,
+ * so this constant is the single source of truth for its payload shape —
+ * declare it instead of re-deriving the payload shape per machine. The payload
+ * is authored explicitly (not `Omit<PlayRouteEvent, "type">`): `Omit` over
+ * PlayRouteEvent's index signature collapses the named props and would erase
+ * all payload checking.
+ *
+ * @example
+ * ```typescript
+ * import { setup } from "xstate";
+ * import {
+ *   emptyEventSchema,
+ *   playMetaSchema,
+ *   playRouteEventSchema,
+ * } from "@xmachines/play-xstate";
+ *
+ * const authSetup = setup({
+ *   schemas: {
+ *     events: {
+ *       "play.route": playRouteEventSchema,
+ *       "auth.logout": emptyEventSchema,
+ *     },
+ *     meta: playMetaSchema,
+ *   },
+ * });
+ * ```
+ *
+ * @see {@link playMetaSchema} for the companion state-meta schema
+ */
+/**
+ * Adds `TExtra` as an optional-by-union extension of `TBase`.
+ *
+ * XState v6's `InferEvents` wraps every event payload in `Required<>` (to
+ * undo Zod-style optional inference), which would make `?`-marked fields
+ * mandatory on every send. Encoding optionality as a union sidesteps that:
+ * `Required<>` distributes over the members, each of which is already fully
+ * required. Use it for your own event payload schemas with optional fields.
+ *
+ * @example
+ * ```typescript
+ * type SavePayload = WithOptional<{ id: string }, { draft: boolean }>;
+ * // accepts { id } and { id, draft } — and survives InferEvents' Required<>
+ * ```
+ */
+export type WithOptional<TBase, TExtra> = TBase | (TBase & TExtra);
+/**
+ * The `play.route` event payload as machines receive it: `to` required;
+ * `params`/`query`/`match` encoded as optional-by-union so they stay omittable
+ * through XState v6's `Required<>` event inference.
+ */
+export type PlayRoutePayload = WithOptional<WithOptional<WithOptional<{
+    to: PlayRouteEvent["to"];
+}, {
+    params: Record<string, string>;
+}>, {
+    query: Record<string, string>;
+}>, {
+    match: unknown;
+}>;
+export declare const playRouteEventSchema: import("xstate").TypeSchema<PlayRoutePayload>;
+/**
+ * State meta schema for Play's routing/view metadata, for use as an XState v6
+ * `schemas.meta` declaration.
+ *
+ * XState v6 types state `meta` as `never` unless a meta schema is declared, so
+ * every machine that carries `meta.route` templates or `meta.view` specs needs
+ * this schema. `route` accepts both the string template form
+ * (`"/profile/:username"`) and the object form (`{ path, title }` — see
+ * {@link RouteMetadata}); `view` is a Play view {@link PlaySpec}.
+ *
+ * @example
+ * ```typescript
+ * import { createMachine } from "xstate";
+ * import { playMetaSchema } from "@xmachines/play-xstate";
+ *
+ * const machine = createMachine({
+ *   schemas: { meta: playMetaSchema },
+ *   initial: "home",
+ *   states: {
+ *     home: { id: "home", meta: { route: "/" } },
+ *   },
+ * });
+ * ```
+ *
+ * @see {@link playRouteEventSchema} for the companion `play.route` event schema
+ */
+export declare const playMetaSchema: import("xstate").TypeSchema<{
+    route?: RouteMetadata;
+    view?: PlaySpec;
+}>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/routing/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/routing/schemas.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,YAAY,CAAC,KAAK,EAAE,MAAM,IAAI,KAAK,GAAG,CAAC,KAAK,GAAG,MAAM,CAAC,CAAC;AAEnE;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,YAAY,CAC1C,YAAY,CACX,YAAY,CAAC;IAAE,EAAE,EAAE,cAAc,CAAC,IAAI,CAAC,CAAA;CAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAC,EAC9E;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CACjC,EACD;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,CAClB,CAAC;AAEF,eAAO,MAAM,oBAAoB,+CAA4B,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,cAAc;YAAmB,aAAa;WAAS,QAAQ;EAAK,CAAC"}