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

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

@@ -1,18 +1,26 @@
+import { assign } from "xstate";
+import { shallowEqualExcept } from "@xmachines/play-actor";
 import { MissingStateIdError } from "../errors.js";
 import { normalizeRoute } from "./derive-route.js";
 /**
- * Formats play.route routing from declarative route configs.
+ * Reuse the previous params/query container when the incoming one is
+ * shallow-equal.
  *
- * Crawls machine states looking for states with `meta.route` and wires them to
- * XState v6's **native routing machinery**:
+ * Route params/query arrive as a FRESH object on every `play.route` event —
+ * bridges rebuild them per URL parse, and `|| {}` allocates even for the
+ * empty case — while the view emit gate compares context per field with
+ * `Object.is`. Without reuse, a value-identical re-navigation (popstate to
+ * the current URL, a redundant programmatic send) would re-emit the view
+ * for nothing.
+ */
+const keepEqualContainer = (prev, next) => (prev !== undefined && shallowEqualExcept(prev, next) ? prev : next);
+/**
+ * Formats play.route transitions from declarative route configs
  *
- * - 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.
+ * Crawls machine states looking for states with meta.route and generates
+ * transitions that handle `play.route` events by matching event.to to state IDs.
+ *
+ * Inspired by XState's internal formatRouteTransitions (stateUtils.ts line 391).
  *
  * @example
  * ```typescript
@@ -27,58 +35,21 @@ import { normalizeRoute } from "./derive-route.js";
  * const machine = createMachine(formatPlayRouteTransitions(machineConfig));
  * ```
  *
- * 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).
+ * 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
  *
  * @param machineConfig - XState machine config (before createMachine). Must extend `RouteMachineConfig`.
- * @returns The machine config with native `route` configs and the `play.route` forwarder merged in, preserving the original type `T`.
+ * @returns The same machine config with auto-generated `play.route` handlers merged in, preserving the original type `T`.
  */
 export function formatPlayRouteTransitions(machineConfig) {
-    /**
-     * 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 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)
             const statePath = parentPath ? `${parentPath}.${key}` : key;
             // Validates the metadata (malformed object routes throw
             // InvalidRouteMetadataError) and normalizes to the path string. Both
@@ -90,79 +61,48 @@ export function formatPlayRouteTransitions(machineConfig) {
             if (routePath && !node.id) {
                 throw new MissingStateIdError(key, routePath);
             }
-            if (node.states) {
-                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);
-                }
+                const transition = {
+                    target: `.${statePath}`,
+                    guard: ({ event }) => event.to === `#${node.id}`,
+                    reenter: true,
+                    actions: assign({
+                        params: ({ context, event }) => keepEqualContainer(context.params, event.params || {}),
+                        query: ({ context, event }) => keepEqualContainer(context.query, event.query || {}),
+                    }),
+                };
+                routeTransitions.push(transition);
             }
-            next[key] = node;
-        }
-        return next;
+            if (node.states) {
+                collectRoutes(node.states, statePath);
+            }
+        });
     };
     const machineStates = machineConfig.states;
-    const injectedStates = machineStates ? injectRoutes(machineStates) : machineStates;
-    if (routeTargets.size === 0) {
-        return machineConfig;
+    if (machineStates) {
+        collectRoutes(machineStates);
     }
-    // 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 {};
-        }
+    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],
+        };
         return {
-            target,
-            reenter: true,
-            // Shallow context patch — v6's replacement for assign().
-            context: {
-                params: event.params || {},
-                query: event.query || {},
-            },
+            ...machineConfig,
+            on: updatedOn,
         };
-    };
-    // 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],
-        },
-    };
+    }
+    return machineConfig;
 }
 //# 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

@@ -7,14 +7,10 @@
  * @packageDocumentation
  */
 export { deriveRoute, isAbsoluteRoute } from "./derive-route.js";
-export { deriveCurrentRoute } from "./derive-current-route.js";
+export { activeStateMeta, deriveCurrentRoute, firstActiveBranchMeta, } 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,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"}
+{"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,EACN,eAAe,EACf,kBAAkB,EAClB,qBAAqB,GACrB,MAAM,2BAA2B,CAAC;AACnC,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"}

package/dist/routing/index.js

@@ -7,10 +7,8 @@
  * @packageDocumentation
  */
 export { deriveRoute, isAbsoluteRoute } from "./derive-route.js";
-export { deriveCurrentRoute } from "./derive-current-route.js";
+export { activeStateMeta, deriveCurrentRoute, firstActiveBranchMeta, } 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;AAChF,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAGpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,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,EACN,eAAe,EACf,kBAAkB,EAClB,qBAAqB,GACrB,MAAM,2BAA2B,CAAC;AACnC,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"}

package/dist/types.d.ts

@@ -1,30 +1,93 @@
-import type { AnyStateMachine, InputFrom, SnapshotFrom } from "xstate";
+import type { ActorOptions, AnyStateMachine, InputFrom, SnapshotFrom } from "xstate";
 import type { PlayerActor as PlayerActorClass } from "./player-actor.js";
 /**
  * Configuration for definePlayer()
  */
 export interface PlayerConfig<TMachine extends AnyStateMachine> {
-    /** XState v6 state machine */
+    /** XState v5 state machine */
     machine: TMachine;
     /** Lifecycle hooks and configuration */
     options?: PlayerOptions<TMachine>;
 }
 /**
- * Player lifecycle hooks
- *
- * Per CONTEXT.md: Rich set of hooks for observability
+ * Player lifecycle hooks — the observability surface around the actor.
  */
 export interface PlayerOptions<TMachine extends AnyStateMachine> {
-    /** Called when actor starts */
+    /**
+     * Called on each real start: every transition from not-running to running,
+     * including a start after a stop. A repeated `start()` while the actor is
+     * already running does not re-fire it.
+     */
     onStart?: (actor: PlayerActorClass<TMachine>) => void;
-    /** Called when actor stops */
+    /**
+     * Called on each real stop: only when a running actor was actually torn
+     * down. Repeated `stop()`/`dispose()` calls, and stopping an actor that
+     * never started, do not fire it.
+     */
     onStop?: (actor: PlayerActorClass<TMachine>) => void;
-    /** Called on every state transition */
+    /**
+     * Called after every event `send()` processes — including events the
+     * machine ignores, where `prevState` and `nextState` are the same
+     * snapshot. Compare the two when only real transitions matter.
+     */
     onTransition?: (actor: PlayerActorClass<TMachine>, prevState: SnapshotFrom<TMachine>, nextState: SnapshotFrom<TMachine>) => void;
     /** Called when state signal changes */
     onStateChange?: (actor: PlayerActorClass<TMachine>, state: SnapshotFrom<TMachine>) => void;
-    /** Called on actor errors */
+    /**
+     * Called on actor errors: a snapshot restore that fails at `start()`, a
+     * throwing action or guard, and view-derivation failures.
+     *
+     * Read when an error is delivered, not at construction: the options bag is
+     * shared by reference, so a handler attached to it later still receives
+     * actor errors, and removing the handler restores the loud default below.
+     *
+     * With a handler in place, the error is routed there and counts as
+     * handled. XState decides its global rethrow per observer, beyond this
+     * option's reach: a subscription of your own without an `error` listener
+     * still forces it, `onError` or not.
+     *
+     * Without `onError`, actor errors stay loud (an unhandled rethrow via
+     * `setTimeout`) so they are never silently swallowed — and your own
+     * `error` subscribers do not suppress that default; only `onError` does.
+     *
+     * An actor failure that is already an `Error` arrives unchanged, keeping the
+     * identity the machine gave it. A machine that throws a non-`Error` value
+     * arrives as `ActorThrewNonErrorError` with the thrown value on `cause`.
+     */
     onError?: (actor: PlayerActorClass<TMachine>, error: Error) => void;
+    /**
+     * Inspection observer forwarded verbatim to XState's `createActor`.
+     *
+     * This is the creation-time attachment route, and the only one that observes
+     * the actor's construction events. Attaching later via
+     * `actor.system.inspect(fn)` also works, but only sees events from that
+     * point on.
+     *
+     * A `PlayerActor` is itself the XState actor, so its own events carry
+     * `actorRef === playerActor` and can be recognised by identity. Each
+     * `PlayerActor` is also its own root system, so `event.rootId ===
+     * actor.sessionId` demultiplexes the whole tree — including events from
+     * invoked and spawned children, whose `actorRef` is the child.
+     *
+     * One caveat comes with that identity: the `@xstate.actor` event fires from
+     * inside the actor's constructor, so its `actorRef` is the instance
+     * mid-construction. `state`, `currentRoute`, `currentView` and
+     * `initialRoute` do not exist yet — reading them there throws. Capture the
+     * reference and read the signals from a later event, or from outside the
+     * observer.
+     *
+     * @example
+     * ```typescript
+     * import { createBrowserInspector } from "@statelyai/inspect";
+     *
+     * const { inspect } = createBrowserInspector();
+     * const createPlayer = definePlayer({ machine, options: { inspect } });
+     * ```
+     *
+     * For an inspector created after the factory (e.g. behind a dev-tools toggle),
+     * pass a forwarding function: `inspect: (event) => currentInspector?.(event)`.
+     */
+    inspect?: ActorOptions<TMachine>["inspect"];
 }
 /**
  * Optional restore arguments for the player factory.
@@ -33,13 +96,23 @@ export interface PlayerOptions<TMachine extends AnyStateMachine> {
  * `createPlayer(input?)` calling convention for fresh actors.
  */
 export interface PlayerFactoryResumeOptions<TMachine extends AnyStateMachine> {
-    /** Persisted XState snapshot used to restore actor state. */
-    snapshot?: SnapshotFrom<TMachine>;
+    /**
+     * Persisted XState snapshot used to restore actor state.
+     *
+     * Typed as XState's own `ActorOptions["snapshot"]` — the exact type
+     * `createActor` accepts and `getPersistedSnapshot()` returns — so restoring
+     * a stored snapshot never needs a cast.
+     */
+    snapshot?: ActorOptions<TMachine>["snapshot"];
 }
 /**
- * Factory function returned by definePlayer()
+ * Factory function returned by definePlayer() — each call creates an
+ * independent actor instance from the same configuration.
  *
- * Per CONTEXT.md: Factory supports creating multiple actor instances
+ * Input requiredness mirrors XState's `createActor`: a machine whose input
+ * cannot be `undefined` makes the factory's first argument required, so
+ * forgetting it is a compile error instead of an actor that starts in an
+ * error status with a `null` initial route.
  */
-export type PlayerFactory<TMachine extends AnyStateMachine> = (input?: InputFrom<TMachine>, options?: PlayerFactoryResumeOptions<TMachine>) => PlayerActorClass<TMachine>;
+export type PlayerFactory<TMachine extends AnyStateMachine> = undefined extends InputFrom<TMachine> ? (input?: InputFrom<TMachine>, options?: PlayerFactoryResumeOptions<TMachine>) => PlayerActorClass<TMachine> : (input: InputFrom<TMachine>, options?: PlayerFactoryResumeOptions<TMachine>) => PlayerActorClass<TMachine>;
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,IAAI,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,QAAQ,SAAS,eAAe;IAC7D,8BAA8B;IAC9B,OAAO,EAAE,QAAQ,CAAC;IAElB,wCAAwC;IACxC,OAAO,CAAC,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa,CAAC,QAAQ,SAAS,eAAe;IAC9D,+BAA+B;IAC/B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;IAEtD,8BAA8B;IAC9B,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;IAErD,uCAAuC;IACvC,YAAY,CAAC,EAAE,CACd,KAAK,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EACjC,SAAS,EAAE,YAAY,CAAC,QAAQ,CAAC,EACjC,SAAS,EAAE,YAAY,CAAC,QAAQ,CAAC,KAC7B,IAAI,CAAC;IAEV,uCAAuC;IACvC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;IAE3F,6BAA6B;IAC7B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACpE;AAED;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B,CAAC,QAAQ,SAAS,eAAe;IAC3E,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,QAAQ,SAAS,eAAe,IAAI,CAC7D,KAAK,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,EAC3B,OAAO,CAAC,EAAE,0BAA0B,CAAC,QAAQ,CAAC,KAC1C,gBAAgB,CAAC,QAAQ,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACrF,OAAO,KAAK,EAAE,WAAW,IAAI,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,QAAQ,SAAS,eAAe;IAC7D,8BAA8B;IAC9B,OAAO,EAAE,QAAQ,CAAC;IAElB,wCAAwC;IACxC,OAAO,CAAC,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,QAAQ,SAAS,eAAe;IAC9D;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;IAEtD;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;IAErD;;;;OAIG;IACH,YAAY,CAAC,EAAE,CACd,KAAK,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EACjC,SAAS,EAAE,YAAY,CAAC,QAAQ,CAAC,EACjC,SAAS,EAAE,YAAY,CAAC,QAAQ,CAAC,KAC7B,IAAI,CAAC;IAEV,uCAAuC;IACvC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;IAE3F;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,OAAO,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC;CAC5C;AAED;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B,CAAC,QAAQ,SAAS,eAAe;IAC3E;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,CAAC;CAC9C;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,CAAC,QAAQ,SAAS,eAAe,IACzD,SAAS,SAAS,SAAS,CAAC,QAAQ,CAAC,GAClC,CACA,KAAK,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,EAC3B,OAAO,CAAC,EAAE,0BAA0B,CAAC,QAAQ,CAAC,KAC1C,gBAAgB,CAAC,QAAQ,CAAC,GAC9B,CACA,KAAK,EAAE,SAAS,CAAC,QAAQ,CAAC,EAC1B,OAAO,CAAC,EAAE,0BAA0B,CAAC,QAAQ,CAAC,KAC1C,gBAAgB,CAAC,QAAQ,CAAC,CAAC"}

package/dist/view/derive-current-view.d.ts

@@ -0,0 +1,49 @@
+/**
+ * View derivation — the meta.view half of the player pipeline.
+ *
+ * Kept beside src/routing/ so player-actor.ts holds only the actor itself:
+ * signals, hooks, and lifecycle. The active-branch walk is shared with route
+ * derivation so a parallel machine's view always belongs to the region its
+ * URL points at.
+ */
+import type { AnyMachineSnapshot } from "xstate";
+import { type PlaySpec } from "@xmachines/play-actor";
+/**
+ * Derive the actor's current view from state metadata.
+ *
+ * Always returns a **fresh** `PlaySpec` object so a genuine view change is never
+ * suppressed by `Signal.State`'s `Object.is` equality check. Whether that fresh
+ * object is actually emitted is decided by `PlayerActor.validateAndCacheView`,
+ * which compares against the last emitted spec (reusing the composed `state`
+ * reference when the projection is value-unchanged) and skips emission when the
+ * rendered view is unchanged — preventing downstream providers from remounting
+ * the UI on every event.
+ *
+ * ### Context projection
+ *
+ * The machine's context is projected into the derived spec's `state` under the
+ * read-only `/context` subtree: `state: { ...meta.view.state, context: slice }`.
+ * The emitted spec is therefore **self-consistent** — its `state` honestly
+ * describes the store contents — so `repeat.statePath: "/context/tasks"`,
+ * `visible: { $state: "/context/…" }`, and `{ $state: "/context/…" }` props all
+ * resolve through the ordinary state grammar, and tools like `validateSpec`
+ * pass on derived views with no special-casing (validate the derived view, not
+ * the raw `meta.view`).
+ *
+ * The whole context is always projected; the authored `meta.view` object is
+ * never mutated.
+ *
+ * ### viewKey
+ *
+ * The derived spec carries `viewKey` — the meta record key (state node id) of
+ * the entry this derivation actually selected. Providers key their store
+ * lifecycle on it: changed → reseed, unchanged → refresh `/context` in place.
+ * It is taken from the selected entry rather than "the active state id"
+ * because for parallel machines the walked branch and the flat `getMeta()`
+ * fallback can select a view from a different region than the branch leaf.
+ *
+ * @param snapshot - Current XState machine snapshot.
+ * @returns Derived `PlaySpec`, or `null` if the current state has no view metadata.
+ */
+export declare const deriveCurrentView: (snapshot: AnyMachineSnapshot) => PlaySpec | null;
+//# sourceMappingURL=derive-current-view.d.ts.map

package/dist/view/derive-current-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive-current-view.d.ts","sourceRoot":"","sources":["../../src/view/derive-current-view.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAiC,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAsDrF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAU,kBAAkB,KAAG,QAAQ,GAAG,IA4C3E,CAAC"}

package/dist/view/derive-current-view.js

@@ -0,0 +1,115 @@
+import { composePlayState, toAtomState } from "@xmachines/play-actor";
+import { activeStateMeta } from "../routing/index.js";
+/**
+ * Once-per-spec migration warning for the removed 1.x `contextProps` field.
+ * Hand-written meta.view objects bypass `typedSpec`, so a spec still carrying
+ * the field compiles clean — but its meaning inverted (an allowlist, or an
+ * empty filter projecting nothing, is now the whole context). Keyed on the
+ * static meta.view object so the warning fires once, not per snapshot.
+ */
+const warnedContextProps = new WeakSet();
+const warnRemovedContextProps = (viewMeta) => {
+    if (warnedContextProps.has(viewMeta))
+        return;
+    warnedContextProps.add(viewMeta);
+    console.warn("[play-xstate] meta.view.contextProps has been removed: the whole machine context " +
+        "is always projected under /context. Delete the field — it no longer filters anything.");
+};
+const resolveViewMeta = (meta) => {
+    // Iterate last-to-first: snapshot.getMeta() orders keys ancestors-first, so
+    // scanning from the end makes the deepest active state's meta.view win over
+    // an ancestor's instead of being shadowed by it.
+    const entries = Object.entries(meta);
+    for (let i = entries.length - 1; i >= 0; i--) {
+        // Loop-bounded array index, not user-controlled property access.
+        const [key, stateMeta] = entries[i]; // nosemgrep: gitlab.eslint.detect-object-injection
+        const maybeView = stateMeta && typeof stateMeta === "object"
+            ? stateMeta.view
+            : undefined;
+        if (maybeView &&
+            typeof maybeView === "object" &&
+            "root" in maybeView &&
+            "elements" in maybeView) {
+            return { key, view: maybeView };
+        }
+    }
+    return null;
+};
+/**
+ * Derive the actor's current view from state metadata.
+ *
+ * Always returns a **fresh** `PlaySpec` object so a genuine view change is never
+ * suppressed by `Signal.State`'s `Object.is` equality check. Whether that fresh
+ * object is actually emitted is decided by `PlayerActor.validateAndCacheView`,
+ * which compares against the last emitted spec (reusing the composed `state`
+ * reference when the projection is value-unchanged) and skips emission when the
+ * rendered view is unchanged — preventing downstream providers from remounting
+ * the UI on every event.
+ *
+ * ### Context projection
+ *
+ * The machine's context is projected into the derived spec's `state` under the
+ * read-only `/context` subtree: `state: { ...meta.view.state, context: slice }`.
+ * The emitted spec is therefore **self-consistent** — its `state` honestly
+ * describes the store contents — so `repeat.statePath: "/context/tasks"`,
+ * `visible: { $state: "/context/…" }`, and `{ $state: "/context/…" }` props all
+ * resolve through the ordinary state grammar, and tools like `validateSpec`
+ * pass on derived views with no special-casing (validate the derived view, not
+ * the raw `meta.view`).
+ *
+ * The whole context is always projected; the authored `meta.view` object is
+ * never mutated.
+ *
+ * ### viewKey
+ *
+ * The derived spec carries `viewKey` — the meta record key (state node id) of
+ * the entry this derivation actually selected. Providers key their store
+ * lifecycle on it: changed → reseed, unchanged → refresh `/context` in place.
+ * It is taken from the selected entry rather than "the active state id"
+ * because for parallel machines the walked branch and the flat `getMeta()`
+ * fallback can select a view from a different region than the branch leaf.
+ *
+ * @param snapshot - Current XState machine snapshot.
+ * @returns Derived `PlaySpec`, or `null` if the current state has no view metadata.
+ */
+export const deriveCurrentView = (snapshot) => {
+    // Follow the SAME single active branch the route derivation walks, so that
+    // for a parallel machine the rendered view belongs to the region the URL
+    // points at whenever that region declares one.
+    const meta = activeStateMeta(snapshot);
+    if (!meta) {
+        return null;
+    }
+    // A parallel machine may keep routes and views in DIFFERENT regions (one
+    // region owns navigation, another owns the shell). When the walked branch
+    // declares no view, scan the flat record of every active region — deepest
+    // entry wins — before concluding there is no view at all.
+    let resolved = resolveViewMeta(meta);
+    if (!resolved) {
+        const flatMeta = snapshot.getMeta();
+        if (flatMeta && typeof flatMeta === "object") {
+            resolved = resolveViewMeta(flatMeta);
+        }
+    }
+    if (!resolved) {
+        return null;
+    }
+    const { key: viewKey, view: viewMeta } = resolved;
+    if ("contextProps" in viewMeta) {
+        warnRemovedContextProps(viewMeta);
+    }
+    // Project the whole context under /context. composePlayState skips the
+    // projection (authored state wins, with a dev warning) when spec.state
+    // already declares a top-level "context" key.
+    const slice = snapshot.context !== null && typeof snapshot.context === "object"
+        ? snapshot.context
+        : undefined;
+    const authoredState = viewMeta.state !== undefined ? toAtomState(viewMeta.state) : undefined;
+    const state = composePlayState(authoredState, slice);
+    return {
+        ...viewMeta,
+        viewKey,
+        ...(state !== undefined && { state }),
+    };
+};
+//# sourceMappingURL=derive-current-view.js.map

package/dist/view/derive-current-view.js.map

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