@xmachines/docs 3.0.0 → 4.0.0

package/api/@xmachines/play-vue/type-aliases/ComponentsMap.md

@@ -6,7 +6,7 @@
 type ComponentsMap<C> = { [K in keyof InferCatalogComponents<C>]?: ComponentEntry<C, K> };
 ```
 
-Defined in: [packages/play-vue/src/define-registry.ts:115](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-vue/src/define-registry.ts#L115)
+Defined in: [packages/play-vue/src/define-registry.ts:115](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-vue/src/define-registry.ts#L115)
 
 ## Type Parameters
 

package/api/@xmachines/play-vue/type-aliases/DefineRegistryOptions.md

@@ -7,13 +7,13 @@ type DefineRegistryOptions<C> = Omit<Parameters<typeof defineRegistryBase>[1], "
 	object;
 ```
 
-Defined in: [packages/play-vue/src/define-registry.ts:119](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-vue/src/define-registry.ts#L119)
+Defined in: [packages/play-vue/src/define-registry.ts:119](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-vue/src/define-registry.ts#L119)
 
 ## Type Declaration
 
 | Name          | Type                                       | Defined in                                                                                                                                             |
 | ------------- | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `components?` | [`ComponentsMap`](ComponentsMap.md)\<`C`\> | [packages/play-vue/src/define-registry.ts:123](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-vue/src/define-registry.ts#L123) |
+| `components?` | [`ComponentsMap`](ComponentsMap.md)\<`C`\> | [packages/play-vue/src/define-registry.ts:123](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-vue/src/define-registry.ts#L123) |
 
 ## Type Parameters
 

package/api/@xmachines/play-vue/variables/PlayRenderer.md

@@ -6,4 +6,4 @@
 const PlayRenderer: DefineComponent<{}, {}, unknown>;
 ```
 
-Defined in: [packages/play-vue/src/vue-shim.d.ts:3](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-vue/src/vue-shim.d.ts#L3)
+Defined in: [packages/play-vue/src/vue-shim.d.ts:3](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-vue/src/vue-shim.d.ts#L3)

package/api/@xmachines/play-vue/variables/schema.md

@@ -0,0 +1,71 @@
+[API](../../../README.md) / [@xmachines/play-vue](../README.md) / schema
+
+# Variable: schema
+
+```ts
+const schema: _json_render_core.Schema<{
+	catalog: _json_render_core.SchemaType<
+		"object",
+		{
+			actions: _json_render_core.SchemaType<
+				"map",
+				{
+					description: _json_render_core.SchemaType<"string", unknown>;
+					params: _json_render_core.SchemaType<"zod", unknown>;
+				}
+			>;
+			components: _json_render_core.SchemaType<
+				"map",
+				{
+					description: _json_render_core.SchemaType<"string", unknown>;
+					example: _json_render_core.SchemaType<"any", unknown>;
+					props: _json_render_core.SchemaType<"zod", unknown>;
+					slots: _json_render_core.SchemaType<
+						"array",
+						_json_render_core.SchemaType<"string", unknown>
+					>;
+				}
+			>;
+		}
+	>;
+	spec: _json_render_core.SchemaType<
+		"object",
+		{
+			elements: _json_render_core.SchemaType<
+				"record",
+				_json_render_core.SchemaType<
+					"object",
+					{
+						children: _json_render_core.SchemaType<
+							"array",
+							_json_render_core.SchemaType<"string", unknown>
+						>;
+						props: _json_render_core.SchemaType<"propsOf", string>;
+						repeat: {
+							inner?: unknown;
+							kind: "any";
+							optional: true;
+						};
+						type: _json_render_core.SchemaType<"ref", string>;
+						visible: {
+							inner?: unknown;
+							kind: "any";
+							optional: true;
+						};
+					}
+				>
+			>;
+			root: _json_render_core.SchemaType<"string", unknown>;
+		}
+	>;
+}>;
+```
+
+Defined in: `@xmachines/json-render-vue`
+
+The schema for @xmachines/json-render-vue
+
+Defines:
+
+- Spec: A flat tree of elements with keys, types, props, and children references
+- Catalog: Components with props schemas, and optional actions

package/api/@xmachines/play-vue-router/README.md

@@ -2,14 +2,14 @@
 
 # @xmachines/play-vue-router
 
-Vue Router 4.x adapter for the XMachines Universal Player Architecture. It keeps Vue Router and an XMachines state machine in step, in both directions, with the reactive primitives of Vue.
+Vue Router 4/5 adapter for the XMachines Universal Player Architecture. It keeps Vue Router and an XMachines state machine in step, in both directions, with the reactive primitives of Vue.
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-3.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-vue-router)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-4.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-vue-router)
 
 ## Installation
 
 ```bash
-pnpm add @xmachines/play-vue-router
+pnpm add @xmachines/play-vue-router @xmachines/play-router
 ```
 
 **Peer dependencies:**
@@ -17,7 +17,6 @@ pnpm add @xmachines/play-vue-router
 - `vue` ^3.5.0 — Vue runtime
 - `@vue/reactivity` ^3.5.0 — Vue reactivity primitives
 - `vue-router` ^4.0.0 || ^5.0.0 — Vue Router library
-- `xstate` ^5.31.0 — XState v5 state machine runtime
 
 ## Usage
 
@@ -29,7 +28,8 @@ pnpm add @xmachines/play-vue-router
 import { createRouter, createWebHistory } from "vue-router";
 import { h } from "vue";
 import { VueRouterBridge, RouteMap } from "@xmachines/play-vue-router";
-import { definePlayer } from "@xmachines/play-xstate";
+import { definePlayer, compose, PlayerActor } from "@xmachines/play-xstate";
+import { withRouting } from "@xmachines/play-xstate/routing";
 import { machine } from "./machine.js"; // your routable machine (states carry meta.route)
 
 // 1. Define routes — a single catch-all with a stub host component;
@@ -48,16 +48,17 @@ const routeMap = new RouteMap([
 	{ stateId: "settings", path: "/settings/:section?" },
 ]);
 
-// 3. Start the actor, then the bridge after the router is ready
-const actor = definePlayer({ machine })();
+// 3. Start the actor, then the bridge after the router is ready.
+//    The bridge needs the routing capability.
+const actor = definePlayer({ machine, actor: compose(PlayerActor, withRouting) })();
 actor.start();
 
 await router.isReady();
 const bridge = new VueRouterBridge(router, actor, routeMap);
 bridge.connect();
 
-// 4. Dispose when tearing down (e.g. onUnmounted)
-bridge.dispose();
+// 4. Disconnect when tearing down (e.g. onUnmounted)
+bridge.disconnect();
 ```
 
 ### PlayRouterProvider — Vue component wrapper
@@ -69,7 +70,8 @@ bridge.dispose();
 import { h, markRaw } from "vue";
 import { useRouter } from "vue-router";
 import { PlayRouterProvider, RouteMap } from "@xmachines/play-vue-router";
-import { definePlayer } from "@xmachines/play-xstate";
+import { definePlayer, compose, PlayerActor } from "@xmachines/play-xstate";
+import { withRouting } from "@xmachines/play-xstate/routing";
 import { machine } from "./machine.js"; // your routable machine (states carry meta.route)
 // AppShell: your root component — a real app renders PlayUIProvider + PlayRenderer
 // from @xmachines/play-vue (see the workspace-only @xmachines/play-vue-demo Shell)
@@ -83,7 +85,8 @@ const routeMap = new RouteMap([
 
 // markRaw prevents Vue from wrapping the actor in a reactive proxy,
 // which would break TC39 Signal receivers.
-const actor = markRaw(definePlayer({ machine })());
+// PlayRouterProvider needs the routing capability
+const actor = markRaw(definePlayer({ machine, actor: compose(PlayerActor, withRouting) })());
 actor.start();
 </script>
 
@@ -127,7 +130,6 @@ class VueRouterBridge {
 	constructor(vueRouter: Router, actor: RoutableActor, routeMap: RouteMap);
 	connect(): void;
 	disconnect(): void;
-	dispose(): void; // alias for disconnect()
 }
 ```
 
@@ -143,34 +145,33 @@ class VueRouterBridge {
 
 - `connect()` — starts the work in both directions. It first sets the actor state from the current path of the router, which supports a cold load and a direct URL. It uses `watch(router.currentRoute, …)` from `@vue/reactivity`, not from `@vue/runtime-core`. Therefore a watcher error goes to the caller, and the global error handler of Vue does not hide it.
 - `disconnect()` — stops every watcher and stops the Vue effect scope.
-- `dispose()` — the alias of `disconnect()`. Use it in `onUnmounted(() => bridge.dispose())`.
 
 ### `PlayRouterProvider`
 
 This Vue component wraps `VueRouterBridge` in the component lifecycle hooks.
 
 ```typescript
-import type { PlayActor } from "@xmachines/play-vue-router";
+import type { RoutableActor } from "@xmachines/play-vue-router";
 
 defineComponent({
 	name: "PlayRouterProvider",
 	props: {
-		actor: { type: Object as PropType<PlayActor>, required: true },
+		actor: { type: Object as PropType<RoutableActor>, required: true },
 		routeMap: { type: Object as PropType<RouteMap>, required: true },
 		router: { type: Object as PropType<Router>, required: true },
 		renderer: {
-			type: Function as PropType<(actor: PlayActor, router: Router) => VNodeChild>,
+			type: Function as PropType<(actor: RoutableActor, router: Router) => VNodeChild>,
 			required: true,
 		},
 	},
 });
 ```
 
-The `actor` prop requires a `PlayActor` (`AbstractActor & Routable & Viewable`), because the provider renders the current view spec and also keeps the routes in step. The `renderer` callback receives the same concrete actor type.
+The `actor` prop requires a `RoutableActor`, which is `currentRoute`, `initialRoute` and `send`. It names the view NOWHERE: routing implies no rendering. The `renderer` callback receives the concrete actor type of the caller, so a callback that reads `currentView` still reports the exact spec of that actor.
 
-### `RouteMap` / `VueRouteMap`
+### `RouteMap`
 
-`RouteMap` comes from `@xmachines/play-router`. It is the bidirectional map between the state IDs and the paths, and the bridge uses it. `VueRouteMap` is a deprecated alias of `RouteMap`. The two names are identical, and the next major version removes the alias.
+`RouteMap` comes from `@xmachines/play-router`. It is the bidirectional map between the state IDs and the paths, and the bridge uses it.
 
 ```typescript
 import { RouteMap } from "@xmachines/play-vue-router";
@@ -184,29 +185,23 @@ const routeMap = new RouteMap([
 ```
 
 ```typescript
-import { createRouteMap } from "@xmachines/play-vue-router";
-
+import { createRouteMap } from "@xmachines/play-router/xstate";
 // Or derive from an XState machine
 const routeMap = createRouteMap(machine); // machine: your routable machine (states carry meta.route)
 ```
 
 ### Exported error classes (`@xmachines/play-vue-router/errors`)
 
-Every runtime error extends `PlayError` from `@xmachines/play`. The `./errors` subpath exports them:
+Every runtime error extends `PlayError` from `@xmachines/play/errors`. The `./errors` subpath exports them:
 
 ```typescript
-import {
-	VueRouterCorrectionError,
-	VueRouterNavigationError,
-	VueRouterSendError,
-} from "@xmachines/play-vue-router/errors";
+import { VueRouterNavigationError, VueRouterSendError } from "@xmachines/play-vue-router/errors";
 ```
 
-| Class                      | Error code                          | When thrown                                                                                      |
-| -------------------------- | ----------------------------------- | ------------------------------------------------------------------------------------------------ |
-| `VueRouterCorrectionError` | `PLAY_VUE_ROUTER_CORRECTION_FAILED` | Deprecated. No code throws it. A correction reports `VueRouterNavigationError`                   |
-| `VueRouterNavigationError` | `PLAY_VUE_ROUTER_NAV_FAILED`        | `router.push()` refused the navigation: a navigation guard stopped it, or a redirect replaced it |
-| `VueRouterSendError`       | `PLAY_VUE_ROUTER_SEND_FAILED`       | The Vue Router watcher callback cannot send `play.route` to the actor                            |
+| Class                      | Error code                    | When thrown                                                                                      |
+| -------------------------- | ----------------------------- | ------------------------------------------------------------------------------------------------ |
+| `VueRouterNavigationError` | `PLAY_VUE_ROUTER_NAV_FAILED`  | `router.push()` refused the navigation: a navigation guard stopped it, or a redirect replaced it |
+| `VueRouterSendError`       | `PLAY_VUE_ROUTER_SEND_FAILED` | The Vue Router watcher callback cannot send `play.route` to the actor                            |
 
 Each class holds the original Vue Router error in its `cause` property.
 
@@ -221,12 +216,11 @@ export type {
 	RoutableActor,
 } from "@xmachines/play-router";
 
-// Provider-level (routing + view rendering) — PlayActor re-exported from @xmachines/play-router:
-export type { PlayActor } from "@xmachines/play-vue-router";
-// RoutableActor is also exported as a deprecated alias for PlayActor
+// Provider-level (routing alone) — RoutableActor re-exported from @xmachines/play-router:
+export type { RoutableActor } from "@xmachines/play-vue-router";
 ```
 
-`PlayActor` is `AbstractActor<AnyActorLogic> & Routable & Viewable`. `PlayRouterProvider` requires this shape, because it renders the current view spec and also keeps the routes in step. Use `RoutableActor` from `@xmachines/play-router` when you need the routing alone, for example when you create a `VueRouterBridge` yourself.
+`RoutableActor` is `currentRoute`, `initialRoute` and `send`, and it names no view and no engine. `PlayRouterProvider` constrains its actor to this shape, and a constraint keeps the concrete type whole — so a `renderer` callback that reads `currentView` still reports the exact spec of that actor.
 
 ## Architecture
 
@@ -254,46 +248,9 @@ The bridge sets `lastSyncedPath` before every `router.push()` call. The Vue watc
 
 ### Vue effect scope
 
-The `watch` watcher runs inside its own `effectScope()`. `disconnect()` and `dispose()` call `scope.stop()`. This removes the watcher completely, and nothing stays in the global Vue effect scope.
-
-## Testing
-
-```bash
-# Run all tests for this package
-pnpm --filter @xmachines/play-vue-router test
-
-# Watch mode
-pnpm --filter @xmachines/play-vue-router run test:watch
-
-# With coverage (80 % threshold on lines/functions/branches/statements)
-pnpm --filter @xmachines/play-vue-router run test:coverage
-```
-
-The test files use Vitest with jsdom and `@vue/test-utils`. The integration tests (`test/integration.test.ts`) use a real Vue Router instance with an SFC fixture.
-
-## Classes
-
-- [RouteMap](classes/RouteMap.md)
-- [VueRouterBridge](classes/VueRouterBridge.md)
-
-## Interfaces
-
-- [PlayActor](interfaces/PlayActor.md)
-- [PlayRouteEvent](interfaces/PlayRouteEvent.md)
-- [RouteMapOptions](interfaces/RouteMapOptions.md)
-- [RouteMapping](interfaces/RouteMapping.md)
-- [RouterBridge](interfaces/RouterBridge.md)
-
-## Type Aliases
-
-- [~~RoutableActor~~](type-aliases/RoutableActor.md)
-- [~~VueRouteMap~~](type-aliases/VueRouteMap.md)
-
-## Variables
-
-- [PlayRouterProvider](variables/PlayRouterProvider.md)
-- [~~VueRouteMap~~](variables/VueRouteMap.md)
+The `watch` watcher runs inside its own `effectScope()`. `disconnect()` calls `scope.stop()`. This removes the watcher completely, and nothing stays in the global Vue effect scope.
 
-## Functions
+## Modules
 
-- [createRouteMap](functions/createRouteMap.md)
+- [errors](errors/README.md)
+- [index](index/README.md)

package/api/@xmachines/play-vue-router/errors/README.md

@@ -0,0 +1,8 @@
+[API](../../../README.md) / [@xmachines/play-vue-router](../README.md) / errors
+
+# errors
+
+## Classes
+
+- [VueRouterNavigationError](classes/VueRouterNavigationError.md)
+- [VueRouterSendError](classes/VueRouterSendError.md)

package/api/@xmachines/play-vue-router/errors/classes/VueRouterNavigationError.md

@@ -0,0 +1,193 @@
+[API](../../../../README.md) / [@xmachines/play-vue-router](../../README.md) / [errors](../README.md) / VueRouterNavigationError
+
+# Class: VueRouterNavigationError
+
+Defined in: [packages/play-vue-router/src/errors.ts:26](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-vue-router/src/errors.ts#L26)
+
+The bridge throws this error when Vue Router cannot navigate to the path or to
+the state ID that the actor requested.
+
+The error wraps a rejected `router.push()` promise. The `cause` property holds the
+original Vue Router error, for example the rejection of a navigation guard.
+
+**Error code:** `PLAY_VUE_ROUTER_NAV_FAILED`
+
+## Example
+
+```typescript
+import { VueRouterNavigationError } from "@xmachines/play-vue-router/errors";
+
+try {
+	actor.send({ type: "play.route", to: "#settings" });
+} catch (err) {
+	if (err instanceof VueRouterNavigationError) {
+		// Vue Router refused the push: a guard stopped it, a redirect replaced it, and so on.
+		console.error("Navigation rejected:", err.cause);
+	}
+}
+```
+
+## Extends
+
+- [`PlayError`](../../../play/errors/classes/PlayError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new VueRouterNavigationError(message, options?): VueRouterNavigationError;
+```
+
+Defined in: [packages/play-vue-router/src/errors.ts:27](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-vue-router/src/errors.ts#L27)
+
+#### Parameters
+
+| Parameter  | Type           |
+| ---------- | -------------- |
+| `message`  | `string`       |
+| `options?` | `ErrorOptions` |
+
+#### Returns
+
+`VueRouterNavigationError`
+
+#### Overrides
+
+[`PlayError`](../../../play/errors/classes/PlayError.md).[`constructor`](../../../play/errors/classes/PlayError.md#constructor)
+
+## Properties
+
+| Property                                                | Modifier   | Type      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                       | Inherited from                                                                                                                                   | Defined in                                                                                                                 |
+| ------------------------------------------------------- | ---------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-cause"></a> `cause?`                    | `public`   | `unknown` | -                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [`PlayError`](../../../play/errors/classes/PlayError.md).[`cause`](../../../play/errors/classes/PlayError.md#property-cause)                     | -                                                                                                                          |
+| <a id="property-code"></a> `code`                       | `readonly` | `string`  | A stable, machine-readable identifier of the error. An error code follows the naming convention `PLAY_<PACKAGE>_<DESCRIPTION>`. It stays the same across each patch release and each minor release of one major version. Never match on `.message`. Always match on `.code`, or on the subclass.                                                                                                                                                  | [`PlayError`](../../../play/errors/classes/PlayError.md).[`code`](../../../play/errors/classes/PlayError.md#property-code)                       | [packages/play/src/errors.ts:76](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play/src/errors.ts#L76) |
+| <a id="property-message"></a> `message`                 | `public`   | `string`  | -                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [`PlayError`](../../../play/errors/classes/PlayError.md).[`message`](../../../play/errors/classes/PlayError.md#property-message)                 | -                                                                                                                          |
+| <a id="property-name"></a> `name`                       | `public`   | `string`  | -                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [`PlayError`](../../../play/errors/classes/PlayError.md).[`name`](../../../play/errors/classes/PlayError.md#property-name)                       | -                                                                                                                          |
+| <a id="property-scope"></a> `scope`                     | `readonly` | `string`  | The class or the module that threw this error, for example `"RouterBridgeBase"`.                                                                                                                                                                                                                                                                                                                                                                  | [`PlayError`](../../../play/errors/classes/PlayError.md).[`scope`](../../../play/errors/classes/PlayError.md#property-scope)                     | [packages/play/src/errors.ts:66](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play/src/errors.ts#L66) |
+| <a id="property-stack"></a> `stack?`                    | `public`   | `string`  | -                                                                                                                                                                                                                                                                                                                                                                                                                                                 | [`PlayError`](../../../play/errors/classes/PlayError.md).[`stack`](../../../play/errors/classes/PlayError.md#property-stack)                     | -                                                                                                                          |
+| <a id="property-stacktracelimit"></a> `stackTraceLimit` | `static`   | `number`  | The `Error.stackTraceLimit` property specifies the number of stack frames collected by a stack trace (whether generated by `new Error().stack` or `Error.captureStackTrace(obj)`). The default value is `10` but may be set to any valid JavaScript number. Changes will affect any stack trace captured _after_ the value has been changed. If set to a non-number value, or set to a negative number, stack traces will not capture any frames. | [`PlayError`](../../../play/errors/classes/PlayError.md).[`stackTraceLimit`](../../../play/errors/classes/PlayError.md#property-stacktracelimit) | -                                                                                                                          |
+
+## Methods
+
+### captureStackTrace()
+
+```ts
+static captureStackTrace(targetObject, constructorOpt?): void;
+```
+
+Defined in: `@types/node`
+
+Creates a `.stack` property on `targetObject`, which when accessed returns
+a string representing the location in the code at which
+`Error.captureStackTrace()` was called.
+
+```js
+const myObject = {};
+Error.captureStackTrace(myObject);
+myObject.stack; // Similar to `new Error().stack`
+```
+
+The first line of the trace will be prefixed with
+`${myObject.name}: ${myObject.message}`.
+
+The optional `constructorOpt` argument accepts a function. If given, all frames
+above `constructorOpt`, including `constructorOpt`, will be omitted from the
+generated stack trace.
+
+The `constructorOpt` argument is useful for hiding implementation
+details of error generation from the user. For instance:
+
+```js
+function a() {
+	b();
+}
+
+function b() {
+	c();
+}
+
+function c() {
+	// Create an error without stack trace to avoid calculating the stack trace twice.
+	const { stackTraceLimit } = Error;
+	Error.stackTraceLimit = 0;
+	const error = new Error();
+	Error.stackTraceLimit = stackTraceLimit;
+
+	// Capture the stack trace above function b
+	Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+	throw error;
+}
+
+a();
+```
+
+#### Parameters
+
+| Parameter         | Type       |
+| ----------------- | ---------- |
+| `targetObject`    | `object`   |
+| `constructorOpt?` | `Function` |
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+[`PlayError`](../../../play/errors/classes/PlayError.md).[`captureStackTrace`](../../../play/errors/classes/PlayError.md#capturestacktrace)
+
+---
+
+### isError()
+
+```ts
+static isError(error): error is Error;
+```
+
+Defined in: `typescript`
+
+Indicates whether the argument provided is a built-in Error instance or not.
+
+#### Parameters
+
+| Parameter | Type      |
+| --------- | --------- |
+| `error`   | `unknown` |
+
+#### Returns
+
+`error is Error`
+
+#### Inherited from
+
+[`PlayError`](../../../play/errors/classes/PlayError.md).[`isError`](../../../play/errors/classes/PlayError.md#iserror)
+
+---
+
+### prepareStackTrace()
+
+```ts
+static prepareStackTrace(err, stackTraces): any;
+```
+
+Defined in: `@types/node`
+
+#### Parameters
+
+| Parameter     | Type         |
+| ------------- | ------------ |
+| `err`         | `Error`      |
+| `stackTraces` | `CallSite`[] |
+
+#### Returns
+
+`any`
+
+#### See
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+#### Inherited from
+
+[`PlayError`](../../../play/errors/classes/PlayError.md).[`prepareStackTrace`](../../../play/errors/classes/PlayError.md#preparestacktrace)