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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-xstate",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0",
   "description": "XState v5 adapter for Play Architecture",
   "keywords": [
     "actor-model",
@@ -13,7 +13,7 @@
   "author": "",
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@gitlab.com/xmachin-es/xmachines-js.git",
+    "url": "git+https://gitlab.com/xmachin-es/xmachines-js.git",
     "directory": "packages/play-xstate"
   },
   "files": [
@@ -22,53 +22,53 @@
     "LICENSE"
   ],
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "source": "./src/index.ts",
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "default": "./dist/index.js"
     },
     "./errors": {
-      "source": "./src/errors.ts",
       "types": "./dist/errors.d.ts",
-      "import": "./dist/errors.js"
-    }
+      "default": "./dist/errors.js"
+    },
+    "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc --build",
+    "build": "vite build && tsc --build",
     "clean": "rm -rf dist *.tsbuildinfo coverage node_modules/.svelte2tsx-* node_modules/.vite*",
     "lint": "oxlint .",
     "format": "oxfmt .",
-    "test": "vitest",
-    "prepublishOnly": "npm run build"
+    "test": "vitest"
   },
   "dependencies": {
-    "@xmachines/play": "2.0.0-alpha.1",
-    "@xmachines/play-actor": "2.0.0-alpha.1",
-    "@xmachines/play-signals": "2.0.0-alpha.1",
+    "@xmachines/play": "2.0.0",
+    "@xmachines/play-actor": "2.0.0",
+    "@xmachines/play-signals": "2.0.0",
     "dequal": "^2.0.3"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.9.1",
-    "@types/node": "^26.1.1",
-    "@xmachines/play-router": "2.0.0-alpha.1",
-    "@xmachines/shared": "2.0.0-alpha.1",
-    "oxfmt": "^0.58.0",
-    "oxlint": "^1.73.0",
+    "@types/node": "^26.2.0",
+    "@xmachines/json-render-core": "^0.20.0-xm.2",
+    "@xmachines/play-router": "2.0.0",
+    "oxfmt": "^0.64.0",
+    "oxlint": "^1.79.0",
     "typescript": "^5.9.3 || ^6.0.3",
-    "vitest": "^4.1.10",
-    "xstate": "^6.0.0-alpha.20"
+    "vite": "^8.0.10",
+    "vitest": "^4.1.11",
+    "xstate": "^5.31.0"
   },
   "peerDependencies": {
-    "xstate": "^6.0.0-alpha.20"
+    "xstate": "^5.31.0"
   },
   "engines": {
     "node": ">=22.0.0"
   },
-  "_devDependencies_note": "xstate appears in both peerDependencies and devDependencies intentionally. devDependencies provides workspace resolution for local builds, tests, and typechecking. peerDependencies declares the consumer version constraint. Both are pinned to ^6.0.0-alpha.20 to prevent drift."
+  "_devDependencies_note": "xstate appears in both peerDependencies and devDependencies intentionally. devDependencies provides workspace resolution for local builds, tests, and typechecking. peerDependencies declares the consumer version constraint. Both are pinned to ^5.30.0 to prevent drift."
 }

package/dist/define-player.typecheck.d.ts

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

package/dist/define-player.typecheck.d.ts.map

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

package/dist/define-player.typecheck.js

@@ -1,48 +0,0 @@
-import { setup, types } from "xstate";
-import { emptyEventSchema } from "./schemas.js";
-import { definePlayer } from "./define-player.js";
-const machine = setup({
-    schemas: {
-        context: types(),
-        input: types(),
-        events: {
-            inc: emptyEventSchema,
-        },
-    },
-}).createMachine({
-    context: ({ input }) => ({ count: input.count }),
-    initial: "active",
-    states: {
-        active: {
-            on: {
-                // XState v6: transitions are functions returning a context patch.
-                inc: ({ context }) => ({ context: { count: context.count + 1 } }),
-            },
-        },
-    },
-});
-const createPlayer = definePlayer({
-    machine,
-    options: {
-        onTransition: (actor, prevState, nextState) => {
-            const actorNotAny = false;
-            const prevNotAny = false;
-            const nextNotAny = false;
-            void actorNotAny;
-            void prevNotAny;
-            void nextNotAny;
-        },
-    },
-});
-const actor = createPlayer({ count: 1 });
-const snapshot = actor.getSnapshot();
-const restoredActor = createPlayer({ count: 1 }, { snapshot });
-const returnNotAny = false;
-const restoredReturnNotAny = false;
-void returnNotAny;
-void restoredReturnNotAny;
-// @ts-expect-error factory input must match machine input shape
-createPlayer("invalid");
-// @ts-expect-error snapshot must be nested under the `snapshot` key
-createPlayer({ count: 1 }, { persisted: snapshot });
-//# sourceMappingURL=define-player.typecheck.js.map

package/dist/define-player.typecheck.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"define-player.typecheck.js","sourceRoot":"","sources":["../src/define-player.typecheck.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKlD,MAAM,OAAO,GAAG,KAAK,CAAC;IACrB,OAAO,EAAE;QACR,OAAO,EAAE,KAAK,EAAqB;QACnC,KAAK,EAAE,KAAK,EAAqB;QACjC,MAAM,EAAE;YACP,GAAG,EAAE,gBAAgB;SACrB;KACD;CACD,CAAC,CAAC,aAAa,CAAC;IAChB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IAChD,OAAO,EAAE,QAAQ;IACjB,MAAM,EAAE;QACP,MAAM,EAAE;YACP,EAAE,EAAE;gBACH,kEAAkE;gBAClE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,GAAG,CAAC,EAAE,EAAE,CAAC;aACjE;SACD;KACD;CACD,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,YAAY,CAAC;IACjC,OAAO;IACP,OAAO,EAAE;QACR,YAAY,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE;YAK7C,MAAM,WAAW,GAA4B,KAAK,CAAC;YACnD,MAAM,UAAU,GAA2B,KAAK,CAAC;YACjD,MAAM,UAAU,GAA2B,KAAK,CAAC;YAEjD,KAAK,WAAW,CAAC;YACjB,KAAK,UAAU,CAAC;YAChB,KAAK,UAAU,CAAC;QACjB,CAAC;KACD;CACD,CAAC,CAAC;AAEH,MAAM,KAAK,GAAG,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;AACzC,MAAM,QAAQ,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;AACrC,MAAM,aAAa,GAAG,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;AAI/D,MAAM,YAAY,GAA6B,KAAK,CAAC;AACrD,MAAM,oBAAoB,GAAqC,KAAK,CAAC;AACrE,KAAK,YAAY,CAAC;AAClB,KAAK,oBAAoB,CAAC;AAE1B,gEAAgE;AAChE,YAAY,CAAC,SAAS,CAAC,CAAC;AAExB,oEAAoE;AACpE,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC"}

package/dist/guards/compose.typecheck.d.ts

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

package/dist/guards/compose.typecheck.d.ts.map

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

package/dist/guards/compose.typecheck.js

@@ -1,22 +0,0 @@
-/**
- * Type-level contract for guard composition: declared Guard<TContext> values
- * and inline predicates must compose without casts, exactly as the JSDoc
- * examples show.
- */
-import { composeGuards, composeGuardsOr, negateGuard } from "./compose.js";
-const isAdult = ({ context }) => context.age >= 18;
-// Declared typed guards compose without casts.
-const both = composeGuards([isAdult, ({ context }) => context.verified]);
-// The documented inline-predicate example compiles as written (no annotations).
-const isEligible = composeGuards([
-    ({ context }) => context.age >= 18,
-    ({ context }) => context.verified,
-]);
-// OR and NOT accept typed guards too.
-const either = composeGuardsOr([isAdult, "isVerified"]);
-const notAdult = negateGuard(isAdult);
-void both;
-void isEligible;
-void either;
-void notAdult;
-//# sourceMappingURL=compose.typecheck.js.map

package/dist/guards/compose.typecheck.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"compose.typecheck.js","sourceRoot":"","sources":["../../src/guards/compose.typecheck.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAK3E,MAAM,OAAO,GAAe,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE,CAAC;AAE/D,+CAA+C;AAC/C,MAAM,IAAI,GAAG,aAAa,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,OAAO,EAAoB,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;AAE3F,gFAAgF;AAChF,MAAM,UAAU,GAAG,aAAa,CAAC;IAChC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE;IAClC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ;CACjC,CAAC,CAAC;AAEH,sCAAsC;AACtC,MAAM,MAAM,GAAG,eAAe,CAAC,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;AACxD,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AAEtC,KAAK,IAAI,CAAC;AACV,KAAK,UAAU,CAAC;AAChB,KAAK,MAAM,CAAC;AACZ,KAAK,QAAQ,CAAC"}

package/dist/player-actor.typecheck.d.ts

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

package/dist/player-actor.typecheck.d.ts.map

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

package/dist/player-actor.typecheck.js

@@ -1,30 +0,0 @@
-import { setup, types } from "xstate";
-import { emptyEventSchema } from "./schemas.js";
-import { definePlayer } from "./define-player.js";
-const machine = setup({
-    schemas: {
-        context: types(),
-        input: types(),
-        events: {
-            noop: emptyEventSchema,
-        },
-    },
-}).createMachine({
-    context: ({ input }) => ({ value: input.value }),
-    initial: "idle",
-    states: {
-        idle: {},
-    },
-});
-const createPlayer = definePlayer({ machine });
-const actor = createPlayer({ value: 1 });
-const restoredActor = createPlayer({ value: 1 }, { snapshot: actor.getSnapshot() });
-// Verify actor instances are created successfully
-void actor;
-void restoredActor;
-// CONS-16: [key: string]: unknown index signature removed.
-// Accessing unknown properties on PlayerActor is now a type error (correct behavior).
-// @ts-expect-error — unknown fields no longer accessible via index signature
-const unknownField = actor["custom-extension-field"];
-void unknownField;
-//# sourceMappingURL=player-actor.typecheck.js.map

package/dist/player-actor.typecheck.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"player-actor.typecheck.js","sourceRoot":"","sources":["../src/player-actor.typecheck.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,OAAO,GAAG,KAAK,CAAC;IACrB,OAAO,EAAE;QACR,OAAO,EAAE,KAAK,EAAqB;QACnC,KAAK,EAAE,KAAK,EAAqB;QACjC,MAAM,EAAE;YACP,IAAI,EAAE,gBAAgB;SACtB;KACD;CACD,CAAC,CAAC,aAAa,CAAC;IAChB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IAChD,OAAO,EAAE,MAAM;IACf,MAAM,EAAE;QACP,IAAI,EAAE,EAAE;KACR;CACD,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,YAAY,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;AAC/C,MAAM,KAAK,GAAG,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;AACzC,MAAM,aAAa,GAAG,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;AAEpF,kDAAkD;AAClD,KAAK,KAAK,CAAC;AACX,KAAK,aAAa,CAAC;AAEnB,2DAA2D;AAC3D,sFAAsF;AACtF,6EAA6E;AAC7E,MAAM,YAAY,GAAG,KAAK,CAAC,wBAAwB,CAAC,CAAC;AACrD,KAAK,YAAY,CAAC"}

package/dist/routing/create-routed-machine.d.ts

@@ -1,71 +0,0 @@
-/**
- * Structural constraint for `setup(...)` return values: anything exposing a
- * `createMachine` function. Kept structural (rather than importing XState's
- * `SetupReturn`) so the wrapper stays agnostic to that type's many generics.
- */
-export type SetupLike = {
-    createMachine: (...args: never[]) => unknown;
-};
-/**
- * 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 declare const createRoutedMachine: <TSetup extends SetupLike>(s: TSetup) => TSetup["createMachine"];
-//# sourceMappingURL=create-routed-machine.d.ts.map

package/dist/routing/create-routed-machine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-routed-machine.d.ts","sourceRoot":"","sources":["../../src/routing/create-routed-machine.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG;IAGvB,aAAa,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC;CAC7C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,SAAS,SAAS,EAAE,GAAG,MAAM,KAAG,MAAM,CAAC,eAAe,CASjE,CAAC"}

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

@@ -1,71 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/play-route-event.typecheck.d.ts

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

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

@@ -1 +0,0 @@
-{"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

@@ -1,43 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,99 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}

package/dist/routing/schemas.js

@@ -1,30 +0,0 @@
-import { types } from "xstate";
-export const playRouteEventSchema = types();
-/**
- * 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 const playMetaSchema = types();
-//# sourceMappingURL=schemas.js.map

package/dist/routing/schemas.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../src/routing/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAqE/B,MAAM,CAAC,MAAM,oBAAoB,GAAG,KAAK,EAAoB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,EAA8C,CAAC"}

package/dist/schemas.d.ts

@@ -1,28 +0,0 @@
-/**
- * Event schema for a payload-less event, for use in an XState v6
- * `schemas.events` map.
- *
- * Most Play machines carry events with no payload (`auth.logout`, `timer`,
- * …) — declare them with this constant instead of re-spelling
- * `types<Record<string, never>>()` per event.
- *
- * @example
- * ```typescript
- * import { setup } from "xstate";
- * import { emptyEventSchema, playRouteEventSchema } from "@xmachines/play-xstate";
- *
- * setup({
- *   schemas: {
- *     events: {
- *       "play.route": playRouteEventSchema,
- *       "auth.logout": emptyEventSchema,
- *     },
- *   },
- * });
- * ```
- *
- * @see {@link playRouteEventSchema} and {@link playMetaSchema} for the routing
- *   schema constants
- */
-export declare const emptyEventSchema: import("xstate").TypeSchema<Record<string, never>>;
-//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,gBAAgB,oDAAiC,CAAC"}

package/dist/schemas.js

@@ -1,29 +0,0 @@
-import { types } from "xstate";
-/**
- * Event schema for a payload-less event, for use in an XState v6
- * `schemas.events` map.
- *
- * Most Play machines carry events with no payload (`auth.logout`, `timer`,
- * …) — declare them with this constant instead of re-spelling
- * `types<Record<string, never>>()` per event.
- *
- * @example
- * ```typescript
- * import { setup } from "xstate";
- * import { emptyEventSchema, playRouteEventSchema } from "@xmachines/play-xstate";
- *
- * setup({
- *   schemas: {
- *     events: {
- *       "play.route": playRouteEventSchema,
- *       "auth.logout": emptyEventSchema,
- *     },
- *   },
- * });
- * ```
- *
- * @see {@link playRouteEventSchema} and {@link playMetaSchema} for the routing
- *   schema constants
- */
-export const emptyEventSchema = types();
-//# sourceMappingURL=schemas.js.map

package/dist/schemas.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,KAAK,EAAyB,CAAC"}