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

package/README.md

@@ -1,11 +1,8 @@
-<!-- generated-by: gsd-doc-writer -->
-
 # @xmachines/play-xstate
 
-> XState v6 adapter for the XMachines Play Architecture — bind state machines to the actor base with signal-driven reactivity and router integration.
+> XState v5 adapter for the XMachines Play Architecture — bind state machines to the actor base with signal-driven reactivity and router integration.
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-1.0.0--beta.51-blue)](https://www.npmjs.com/package/@xmachines/play-xstate)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-2.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-xstate)
 
 Part of the [XMachines Play](../../README.md) monorepo.
 
@@ -17,7 +14,7 @@ Part of the [XMachines Play](../../README.md) monorepo.
 pnpm add @xmachines/play-xstate xstate
 ```
 
-`xstate ^6.0.0-alpha.19` is a peer dependency and must be installed alongside this package.
+`xstate ^5.31.0` is a peer dependency and must be installed alongside this package.
 
 ---
 
@@ -25,18 +22,13 @@ pnpm add @xmachines/play-xstate xstate
 
 ```typescript
 import { setup } from "xstate";
-import { definePlayer, emptyEventSchema, playMetaSchema } from "@xmachines/play-xstate";
+import { definePlayer } from "@xmachines/play-xstate";
 
-// 1. Define your XState v6 machine
-const machine = setup({
-	schemas: {
-		events: { activate: emptyEventSchema },
-		meta: playMetaSchema, // types meta.route / meta.view on state nodes
-	},
-}).createMachine({
+// 1. Define your XState v5 machine
+const machine = setup({}).createMachine({
 	initial: "idle",
 	states: {
-		idle: { meta: { route: "/" }, on: { activate: { target: "active" } } },
+		idle: { meta: { route: "/" } },
 		active: { meta: { route: "/active" } },
 	},
 });
@@ -64,16 +56,16 @@ actor.stop();
 
 ### `definePlayer(config)`
 
-Creates a `PlayerFactory` from an XState v6 machine. The factory pattern enables multiple independent actor instances from a single configuration — useful for multi-user scenarios, SSR, or testing.
+Creates a `PlayerFactory` from an XState v5 machine. The factory pattern enables multiple independent actor instances from a single configuration — useful for multi-user scenarios, SSR, or testing.
 
 ```typescript
-import { setup, types } from "xstate";
+import { setup } from "xstate";
 import { definePlayer } from "@xmachines/play-xstate";
 
 const machine = setup({
-	schemas: {
-		context: types<{ userId: string }>(),
-		input: types<{ userId: string }>(),
+	types: {
+		context: {} as { userId: string },
+		input: {} as { userId: string },
 	},
 }).createMachine({
 	context: ({ input }) => ({ userId: input.userId }),
@@ -89,6 +81,7 @@ const createPlayer = definePlayer({
 		onTransition: (actor, prev, next) => console.log("transitioned"),
 		onStateChange: (actor, state) => console.log("state changed"),
 		onError: (actor, err) => console.error(err),
+		inspect: (event) => console.log(event.type), // handed to XState's actor constructor — enables @statelyai/inspect
 	},
 });
 
@@ -99,17 +92,27 @@ const bob = createPlayer({ userId: "bob" });
 
 #### `PlayerFactory` signature
 
+`input` requiredness mirrors XState's `createActor`: a machine whose input type
+cannot be `undefined` makes the factory's first argument required, so forgetting
+it is a compile error instead of an actor stuck in an error status.
+
 ```typescript
-type PlayerFactory<TMachine> = (
-	input?: InputFrom<TMachine>,
-	options?: PlayerFactoryResumeOptions<TMachine>,
-) => PlayerActor<TMachine>;
+type PlayerFactory<TMachine> =
+	undefined extends InputFrom<TMachine>
+		? (
+				input?: InputFrom<TMachine>,
+				options?: PlayerFactoryResumeOptions<TMachine>,
+			) => PlayerActor<TMachine>
+		: (
+				input: InputFrom<TMachine>,
+				options?: PlayerFactoryResumeOptions<TMachine>,
+			) => PlayerActor<TMachine>;
 ```
 
 #### Restoring from a snapshot
 
 ```typescript
-const snapshot = actor.getSnapshot();
+const snapshot = actor.getPersistedSnapshot();
 actor.stop();
 
 // Restore to the exact saved state
@@ -118,11 +121,15 @@ restored.start();
 console.log(restored.currentRoute.get()); // same route as when saved
 ```
 
+> **Note:** Persist with `getPersistedSnapshot()`, not `getSnapshot()` — it is
+> the form `createActor` accepts, and the only one that round-trips machines
+> with invoked or spawned children.
+
 ---
 
 ### `PlayerActor<TMachine>`
 
-Concrete actor class that wraps an XState v6 actor and exposes TC39 Signal-based reactive signals. Implements both `Routable` and `Viewable` interfaces from `@xmachines/play-actor`.
+Concrete actor class: an XState v5 actor that also exposes TC39 Signal-based reactive signals. Implements both `Routable` and `Viewable` interfaces from `@xmachines/play-actor`.
 
 #### Signals
 
@@ -163,7 +170,11 @@ actor.start();
 
 ### Guard utilities
 
-Composable guard helpers that combine predicates with AND, OR, and NOT logic. Each helper returns a plain predicate — call it inside a transition function with the transition arguments and return early to block the transition. String guard names are resolved against the named guards declared in `setup({ guards })`.
+> **Deprecated:** the guard helpers wrap XState's own `and()` / `or()` / `not()`
+> combinators without composing with `setup()`-typed guard slots. Use XState's
+> combinators directly; this module will be removed in the next major.
+
+Composable guard helpers that wrap XState's built-in `and()`, `or()`, and `not()` for use in machine `setup({ guards })` definitions.
 
 ```typescript
 import { setup } from "xstate";
@@ -176,24 +187,20 @@ import {
 	contextFieldMatches, // guard: context field equals a value
 } from "@xmachines/play-xstate";
 
-const canAccessAdmin = composeGuards(["isLoggedIn", "hasAdminRole"]);
-const isAuthenticated = negateGuard("isGuest");
-
 const machine = setup({
 	guards: {
 		isLoggedIn: ({ context }) => !!context.userId,
 		hasAdminRole: ({ context }) => context.role === "admin",
-		isGuest: ({ context }) => !context.userId,
 	},
 }).createMachine({
 	on: {
-		accessAdmin: (args) => {
-			if (!canAccessAdmin(args)) return;
-			return { target: "adminPanel" };
+		accessAdmin: {
+			guard: composeGuards(["isLoggedIn", "hasAdminRole"]),
+			target: "adminPanel",
 		},
-		accessDashboard: (args) => {
-			if (!isAuthenticated(args)) return;
-			return { target: "dashboard" };
+		accessDashboard: {
+			guard: negateGuard("isGuest"),
+			target: "dashboard",
 		},
 	},
 	// ...
@@ -206,42 +213,13 @@ const machine = setup({
 
 Helper functions for declarative route configuration in XState machines.
 
-#### `createRoutedMachine(setup)`
-
-The recommended entry point: returns a `createMachine` with the same signature as the setup's own — full contextual typing for the config — that wires routing up at runtime.
-
-```typescript
-import { setup } from "xstate";
-import { createRoutedMachine } from "@xmachines/play-xstate";
-
-const appSetup = setup({/* schemas, guards, ... */});
-
-const machine = createRoutedMachine(appSetup)({
-	id: "app",
-	states: {
-		home: {
-			id: "home",
-			meta: { route: "/home" },
-		},
-		profile: {
-			id: "profile",
-			meta: { route: "/users/:userId" },
-		},
-	},
-});
-```
-
 #### `formatPlayRouteTransitions(machineConfig)`
 
-The underlying transform. Crawls machine states with `meta.route` and wires them to XState v6's native routing: each routed state gets a native `route: {}` config (targetable via the built-in `xstate.route` event and visible to graph tooling), and one root `play.route` forwarder navigates those targets in a single atomic transition — patching `params`/`query` into context — while re-raising `xstate.route` only for states that declare their own `route` config. Unknown targets fall through to user-defined `play.route` fallbacks (e.g. a 404 route); one `play.route` send is one atomic transition, so exit actions see the old `params` and entry actions the new ones.
+Crawls machine states with `meta.route` and auto-generates `play.route` event handlers at the root level — eliminating boilerplate routing transitions.
 
 ```typescript
 import { setup } from "xstate";
-import {
-	formatPlayRouteTransitions,
-	playMetaSchema,
-	playRouteEventSchema,
-} from "@xmachines/play-xstate";
+import { formatPlayRouteTransitions } from "@xmachines/play-xstate";
 
 const config = formatPlayRouteTransitions({
 	id: "app",
@@ -257,47 +235,69 @@ const config = formatPlayRouteTransitions({
 	},
 });
 
-// config now carries native route configs plus the play.route forwarder:
-// states: { home: { ..., route: {} }, profile: { ..., route: {} } }
-// on: { "play.route": [forwarder, ...userFallbacks] }
-// The forwarder navigates injected-route targets directly (atomically);
-// xstate.route is raised only for states declaring their own route config.
-const machine = setup({
-	schemas: {
-		events: { "play.route": playRouteEventSchema },
-		meta: playMetaSchema,
-	},
-}).createMachine(config);
+// config now includes auto-generated play.route handlers:
+// on: { "play.route": [ { target: ".home", guard: e => e.to === "#home" }, ... ] }
+const machine = setup({}).createMachine(config);
 ```
 
-Because the injected `route` configs are static, route transitions keep statically-known targets — `machineToGraph()` sees real edges to every routed state, so reachability queries work.
-
 > **Note:** Every state with `meta.route` must also have an explicit `id` field; omitting it throws `MissingStateIdError` at machine-definition time.
 
 #### Other routing exports
 
 | Export                             | Description                                                               |
 | ---------------------------------- | ------------------------------------------------------------------------- |
-| `playMetaSchema`                   | Shared `schemas.meta` declaration for `meta.route` / `meta.view` metadata |
-| `playRouteEventSchema`             | Shared `schemas.events` entry for the `play.route` event payload          |
-| `emptyEventSchema`                 | Shared `schemas.events` entry for events that carry no payload            |
 | `deriveRoute(meta)`                | Extract the route template string from a state's metadata object          |
 | `isAbsoluteRoute(route)`           | Returns `true` if the route string is an absolute URL path                |
 | `buildRouteUrl(template, context)` | Substitute `:param` placeholders in a route template using context values |
 
 ---
 
+## Inspection
+
+`options.inspect` is forwarded verbatim to XState's `createActor`, so every XState
+inspection tool — [`@statelyai/inspect`](https://stately.ai/docs/inspector)
+included — works against a `PlayerActor` unchanged:
+
+```typescript
+import { createBrowserInspector } from "@statelyai/inspect";
+
+const { inspect } = createBrowserInspector();
+const createPlayer = definePlayer({ machine, options: { inspect } });
+```
+
+Three things are worth knowing:
+
+- **It is a factory option, not a per-instance one.** Every actor a factory creates
+  reports to the same observer. Demultiplex by root: `event.rootId === actor.sessionId`
+  covers an actor's whole tree, children included.
+- **It is the only route that sees construction.** `actor.system.inspect(fn)` attaches
+  later and only sees events from that point on — including missing the `@xstate.actor`
+  registration an inspector needs in order to draw the machine at all.
+- **A `PlayerActor` is the actor.** Its own events carry `actorRef === playerActor`, so a
+  player can be recognised by identity. The one caveat: `@xstate.actor` fires from inside
+  the constructor, where `state`, `currentRoute`, `currentView` and `initialRoute` do not
+  exist yet — reading them there throws.
+
+For an inspector created after the factory (a dev-tools toggle, say), pass a forwarding
+function: `inspect: (event) => currentInspector?.(event)`.
+
+See the [inspector guide](../docs/guides/inspector.md) for the full walkthrough —
+late attachment with replay, browser-free WebSocket inspection, and production
+considerations.
+
+---
+
 ## Exported Types
 
 ```typescript
 import type {
 	PlayerConfig, // definePlayer() config argument shape
-	PlayerOptions, // Lifecycle hooks (onStart, onStop, onTransition, onStateChange, onError)
+	PlayerOptions, // Lifecycle hooks (onStart, onStop, onTransition, onStateChange, onError) + inspect
 	PlayerFactory, // Factory function returned by definePlayer()
 	PlayerFactoryResumeOptions, // { snapshot? } for restoring actor state
-	Guard, // Single XState guard predicate
-	GuardArray, // Array of guards for compose helpers
-	ComposedGuard, // Return type of composeGuards / composeGuardsOr / negateGuard
+	Guard, // deprecated with the guard utilities — removed in the next major
+	GuardArray, // deprecated with the guard utilities — removed in the next major
+	ComposedGuard, // deprecated with the guard utilities — removed in the next major
 	RouteMachineConfig, // Minimal machine config accepted by formatPlayRouteTransitions
 	RouteStateNode, // Single state node shape used during route crawling
 	RouteContext, // Context shape expected by buildRouteUrl ({ params?, query?, basePath?, hash? })
@@ -315,14 +315,13 @@ Error classes are exported from the `@xmachines/play-xstate/errors` sub-path to
 ```typescript
 import {
 	MissingRouteParamError, // Required :param absent from context when resolving currentRoute
-	MissingQueryContextError, // context.params present but context.query missing
+	MissingQueryContextError, // deprecated: no longer thrown
 	MissingStateIdError, // meta.route declared without a state id field
 	InvalidMachineError, // PlayerActor constructed with a non-object machine
 	InvalidEventError, // actor.send() called with null/undefined/non-object
+	ActorThrewNonErrorError, // actor failed with a thrown value that is not an Error
 	InvalidRouteMetadataError, // meta.route is neither a string nor { path: string }
 	EmptyGuardArrayError, // composeGuards/composeGuardsOr called with empty array
-	UnresolvableGuardNameError, // string guard name could not be resolved at call time
-	InvalidGuardEntryError, // guard entry was neither a predicate nor a name (e.g. undefined)
 } from "@xmachines/play-xstate/errors";
 ```
 

package/dist/define-player.d.ts

@@ -3,15 +3,15 @@ import type { PlayerConfig, PlayerFactory } from "./types.js";
 /**
  * Create a player factory from an XState machine
  *
- * Factory pattern that accepts an XState v6 machine,
+ * Factory pattern that accepts an XState v5 machine,
  * returning a function that creates {@link PlayerActor} instances. This enables
  * creating multiple actor instances from a single configuration, useful for
  * testing, multi-instance scenarios, or server-side rendering.
  *
- * @typeParam TMachine - XState v6 state machine type
+ * @typeParam TMachine - XState v5 state machine type
  *
  * @param config - Player configuration object
- * @param config.machine - XState v6 state machine
+ * @param config.machine - XState v5 state machine
  * @param config.options - Optional lifecycle hooks (onStart, onTransition, etc.)
  *
  * @returns Factory function that creates actor instances with optional input context

package/dist/define-player.js

@@ -2,15 +2,15 @@ import { PlayerActor } from "./player-actor.js";
 /**
  * Create a player factory from an XState machine
  *
- * Factory pattern that accepts an XState v6 machine,
+ * Factory pattern that accepts an XState v5 machine,
  * returning a function that creates {@link PlayerActor} instances. This enables
  * creating multiple actor instances from a single configuration, useful for
  * testing, multi-instance scenarios, or server-side rendering.
  *
- * @typeParam TMachine - XState v6 state machine type
+ * @typeParam TMachine - XState v5 state machine type
  *
  * @param config - Player configuration object
- * @param config.machine - XState v6 state machine
+ * @param config.machine - XState v5 state machine
  * @param config.options - Optional lifecycle hooks (onStart, onTransition, etc.)
  *
  * @returns Factory function that creates actor instances with optional input context

package/dist/errors.d.ts

@@ -8,16 +8,17 @@ import { PlayError } from "@xmachines/play";
  *
  * **Error code:** `PLAY_XSTATE_ROUTE_PARAM_MISSING`
  *
+ * Note: `actor.currentRoute.get()` never surfaces this error — route
+ * derivation catches it and returns `null` for the transient mid-transition
+ * case. It only escapes direct `buildRouteUrl()` calls.
+ *
  * @example
  * ```typescript
+ * import { buildRouteUrl } from "@xmachines/play-xstate";
  * import { MissingRouteParamError } from "@xmachines/play-xstate/errors";
  *
- * // The route template "/profile/:userId" requires "userId" in context.
- * // If userId is absent, MissingRouteParamError is thrown when the
- * // actor.currentRoute signal is read.
- *
  * try {
- *   actor.currentRoute.get();
+ *   buildRouteUrl("/profile/:userId", { params: {}, query: {} });
  * } catch (err) {
  *   if (err instanceof MissingRouteParamError) {
  *     console.error(
@@ -35,36 +36,18 @@ export declare class MissingRouteParamError extends PlayError {
     constructor(param: string, template: string);
 }
 /**
- * Thrown by `buildRouteUrl()` when the context has a `params` field (indicating a
- * routing-aware machine context) but no `query` field.
- *
- * The `params` field signals the context was set up for routing (either manually or via
- * `formatPlayRouteTransitions`). A routing-aware context without `query` will silently
- * drop any query parameters carried by `play.route` events, producing incorrect URLs.
+ * @deprecated Never thrown any more. `buildRouteUrl` treats a missing `query`
+ * field as `query: {}` — the generated `play.route` transitions assign
+ * `query` on every navigation, so the loss this error guarded against cannot
+ * occur through route derivation. Machines that handle `play.route` by hand
+ * and want query forwarding must assign `event.query` to context themselves.
+ * Kept exported so existing `instanceof` handlers keep compiling; remove them
+ * at leisure.
  *
- * **Fix:** Ensure the machine context type includes `query: Record<string, string>`
- * and that the context initializer sets `query: {}` (or a populated value).
- * If using `formatPlayRouteTransitions`, the field is assigned automatically on each
- * `play.route` event — but the machine's initial context must still declare it.
+ * Formerly thrown by `buildRouteUrl()` when the context had a `params` field
+ * (a routing-aware machine context) but no `query` field.
  *
  * **Error code:** `PLAY_XSTATE_MISSING_QUERY_CONTEXT`
- *
- * @example
- * ```typescript
- * import { MissingQueryContextError } from "@xmachines/play-xstate/errors";
- *
- * try {
- *   // params present but no query field — throws
- *   buildRouteUrl("/profile/:userId", { params: { userId: "42" } });
- * } catch (err) {
- *   if (err instanceof MissingQueryContextError) {
- *     console.error("Machine context missing query field");
- *   }
- * }
- *
- * // Correct — both params and query declared
- * buildRouteUrl("/profile/:userId", { params: { userId: "42" }, query: {} });
- * ```
  */
 export declare class MissingQueryContextError extends PlayError {
     constructor();
@@ -137,44 +120,6 @@ export declare class EmptyGuardArrayError extends PlayError {
     readonly combinator: "and" | "or";
     constructor(combinator: "and" | "or");
 }
-/**
- * The guard-composition helper a composed guard was built by. Threaded into
- * guard errors so `PlayError.scope` names the actual origin.
- */
-export type GuardCombinator = "composeGuards" | "composeGuardsOr" | "negateGuard";
-/**
- * Thrown when a composed guard cannot resolve a string guard name at call time.
- *
- * String names in `composeGuards`/`composeGuardsOr`/`negateGuard` resolve
- * against `args.guards` — the named guards from `setup({ guards })` that
- * XState v6 provides to transition functions, `always`, entry/exit actions
- * (since 6.0.0-alpha.20), and function-form route resolvers. Resolution fails
- * when the name was never declared or when the composed guard is called
- * without transition arguments.
- *
- * **Error code:** `PLAY_XSTATE_UNRESOLVABLE_GUARD_NAME`
- */
-export declare class UnresolvableGuardNameError extends PlayError {
-    /** The guard name that could not be resolved. */
-    readonly guardName: string;
-    constructor(guardName: string, origin: GuardCombinator);
-}
-/**
- * Thrown when a composed guard evaluates an entry that is neither a predicate
- * function nor a guard name — typically `null`/`undefined` from a typo'd
- * import or an optional lookup.
- *
- * XState v5 failed loudly when evaluating such entries; silently treating them
- * as never-passing would turn `negateGuard(undefined)` into an always-allow.
- * Composition stays lazy (no throw at compose time); evaluation throws.
- *
- * **Error code:** `PLAY_XSTATE_INVALID_GUARD_ENTRY`
- */
-export declare class InvalidGuardEntryError extends PlayError {
-    /** `typeof` of the invalid entry (e.g. `"undefined"`, `"object"` for null). */
-    readonly entryType: string;
-    constructor(entryType: string, origin: GuardCombinator);
-}
 /**
  * Thrown by `PlayerActor.send()` when the event argument is not a plain object.
  *
@@ -205,4 +150,35 @@ export declare class InvalidEventError extends PlayError {
     readonly detail: unknown;
     constructor(detail: unknown);
 }
+/**
+ * Passed to `PlayerOptions.onError` when the actor failed with a value that is
+ * not an `Error` — e.g. a machine action ran `throw { code: 42 }`.
+ *
+ * An actor error that *is* an `Error` reaches `onError` untouched, keeping the
+ * identity the machine gave it. Only this case constructs a new error, so it
+ * carries a matchable code instead of a `String(value)` message such as
+ * `"[object Object]"`. The thrown value is preserved on `cause`.
+ *
+ * **Error code:** `PLAY_XSTATE_NON_ERROR_THROWN`
+ *
+ * @example
+ * ```typescript
+ * import { ActorThrewNonErrorError } from "@xmachines/play-xstate/errors";
+ *
+ * definePlayer({
+ *   machine,
+ *   options: {
+ *     onError: (actor, err) => {
+ *       if (err instanceof ActorThrewNonErrorError) {
+ *         // err.cause is the value the machine actually threw
+ *         console.error("Machine threw a non-Error:", err.cause);
+ *       }
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export declare class ActorThrewNonErrorError extends PlayError {
+    constructor(value: unknown);
+}
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACpD,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,0FAA0F;IAC1F,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAU3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,wBAAyB,SAAQ,SAAS;;CAWtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IACjD,oFAAoF;IACpF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAW3C;AAED;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;;CASjD;AAED;;;;;GAKG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;IACvD,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,KAAK,EAAE,OAAO,EAAE,MAAM,SAAgB;CAUlD;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IAClD,8EAA8E;IAC9E,QAAQ,CAAC,UAAU,EAAE,KAAK,GAAG,IAAI,CAAC;gBAEtB,UAAU,EAAE,KAAK,GAAG,IAAI;CASpC;AAED;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,eAAe,GAAG,iBAAiB,GAAG,aAAa,CAAC;AAElF;;;;;;;;;;;GAWG;AACH,qBAAa,0BAA2B,SAAQ,SAAS;IACxD,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe;CAWtD;AAED;;;;;;;;;;GAUG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACpD,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe;CAWtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC/C,8CAA8C;IAC9C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;gBAEb,MAAM,EAAE,OAAO;CAS3B"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAqB5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACpD,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,0FAA0F;IAC1F,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAU3C;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,wBAAyB,SAAQ,SAAS;;CAWtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IACjD,oFAAoF;IACpF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAW3C;AAED;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;;CASjD;AAED;;;;;GAKG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;IACvD,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,KAAK,EAAE,OAAO,EAAE,MAAM,SAAgB;CAUlD;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IAClD,8EAA8E;IAC9E,QAAQ,CAAC,UAAU,EAAE,KAAK,GAAG,IAAI,CAAC;gBAEtB,UAAU,EAAE,KAAK,GAAG,IAAI;CASpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC/C,8CAA8C;IAC9C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;gBAEb,MAAM,EAAE,OAAO;CAS3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;gBACzC,KAAK,EAAE,OAAO;CAS1B"}