@xmachines/docs 5.0.1 → 6.0.0

package/README.md

@@ -2,7 +2,7 @@
 
 > Documentation, guides, RFCs, and generated API reference for XMachines.
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-5.0.1-blue)](https://www.npmjs.com/package/@xmachines/docs)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-6.0.0-blue)](https://www.npmjs.com/package/@xmachines/docs)
 
 ## Overview
 
@@ -70,6 +70,8 @@ Architectural specifications that define the XMachines system:
 | [`rfc/rest.md`](rfc/rest.md)       | REST    | REST adapter specification                                           |
 | [`rfc/mcp.md`](rfc/mcp.md)         | MCP     | Model Context Protocol adapter                                       |
 
+An RFC that describes work with no published package carries `status: planned` in its frontmatter. The documentation site reads the key and shows a "Planned" badge on the page and in the menu. Remove the key from the RFC in the change that publishes the package. The `**Status:**` line in the body gives the state of the specification, and not the state of the implementation.
+
 ### Guides
 
 Concept guides and tutorials that show how to use XMachines:
@@ -117,6 +119,7 @@ The documented packages:
 - [`@xmachines/play-actor`](../play-actor/README.md) — `PlayActor`
 - [`@xmachines/play-view`](../play-view/README.md) — `Viewable`, `PlaySpec`, the view store lifecycle
 - [`@xmachines/play-atom`](../play-atom/README.md) — the atom primitives, `watchAtom`
+- [`@xmachines/core`](../core/README.md) — `BaseError` on `/errors`, the release protocol (`asDisposable`, `DISPOSE`) and helpers on `/utils`, a key-value cache on `/cache`
 - [`@xmachines/play-router`](../play-router/README.md) — `RouterBridgeBase`, `RouteMap`, `Routable`
 - [`@xmachines/play-router/xstate`](../play-router/README.md) — `extractMachineRoutes`, `createRouteMap`
 - [`@xmachines/play-pattern`](../play-pattern/README.md) — the route pattern language: one parse, and the path that `buildPath` writes back

package/api/@xmachines/core/README.md

@@ -0,0 +1,209 @@
+[API](../../README.md) / @xmachines/core
+
+# @xmachines/core
+
+The base of the XMachines packages: the error base class, the release protocol, and a cache.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-6.0.0-blue)](https://www.npmjs.com/package/@xmachines/core)
+
+Code that more than one `@xmachines/*` package can use, and that belongs to no layer of the Play Architecture. The package reads no workspace package. [`@xmachines/play`](../play/README.md) reads it, and so can every package above the protocol layer.
+
+## What this package is
+
+The package has no root entry. It has three subpaths:
+
+- **`@xmachines/core/errors`** — `BaseError`, the base class of every typed error of the workspace, and `DisposeConflictError`.
+- **`@xmachines/core/utils`** — the release protocol, and small helpers for values and errors.
+- **`@xmachines/core/cache`** — a key-value cache contract, and an LRU cache.
+
+A subscription of the XMachines packages hands back a plain release: a function, or an object with a release method. A caller that wants a `using` scope publishes the release with `asDisposable`. A caller that does not pays nothing.
+
+- **`asDisposable(release)`** — makes a release function a `Disposable`. The function is its own release.
+- **`asDisposable(target, release)`** — makes an object a `Disposable`, with the release that the caller names.
+- **`DISPOSE`** — the symbol key that a release sits under.
+- **`DisposeKey`** and **`DisposeMember`** — the types of that key and of the member.
+
+The package keeps no module state, so `DISPOSE` resolves to the same symbol in each copy. It must still exist one time in an install, because `err instanceof BaseError` answers `false` for an error of a second copy. Each package that reads it therefore names it as a peer.
+
+## Installation
+
+```bash
+pnpm add @xmachines/core
+```
+
+## Errors
+
+`BaseError` gives each error two stable fields: `scope`, the class or the module that threw it, and `code`, a machine-readable identifier. `PlayError` of [`@xmachines/play`](../play/README.md) extends it, so `err instanceof BaseError` matches every typed error of the workspace. Branch on the class or on `code`, and never on `message`.
+
+```ts
+import { BaseError } from "@xmachines/core/errors";
+
+try {
+	start();
+} catch (err) {
+	if (err instanceof BaseError) {
+		console.error(`[${err.scope}:${err.code}] ${err.message}`);
+	} else {
+		throw err;
+	}
+}
+```
+
+A package below the Play protocol extends `BaseError` directly. This package throws one such error: `DisposeConflictError`, with the code `CORE_DISPOSE_CONFLICT`.
+
+## Usage
+
+### A release function
+
+`asDisposable` gives the SAME function back with the dispose key added. Nothing wraps it, so a caller that runs the release keeps that code:
+
+```ts
+import { watchAtom } from "@xmachines/play-atom";
+import { asDisposable } from "@xmachines/core/utils";
+
+// The explicit form.
+const stop = watchAtom(count, render);
+stop();
+
+// The scoped form. The scope releases it, and an exception releases it too.
+{
+	using stop = asDisposable(watchAtom(count, render));
+	render(count.get());
+}
+```
+
+### An object
+
+An object names its release. The object comes back as itself, and it keeps every member that it had:
+
+```ts
+import { createBrowserHistory } from "@xmachines/play-dom-router";
+import { asDisposable } from "@xmachines/core/utils";
+
+{
+	const plain = createBrowserHistory({ window });
+	using history = asDisposable(plain, () => plain.destroy());
+	history.push("/first");
+} // destroy() runs here
+```
+
+### A value that is a `Disposable` already
+
+`asDisposable` adds the key only where it is absent. `asDisposable(release)` gives a value that carries a dispose member already, own or inherited, back unchanged, and a second call changes nothing. A Vitest mock is such a value: its dispose restores the mock.
+
+A named release does not replace that member. `asDisposable(target, release)` throws a `DisposeConflictError` when the target has a dispose member already, because the scope would run that member and never the release. A second call with the same release is not a conflict, and it returns the target. Each form fills a well-known key that a polyfill installed after the first call.
+
+### The rules of a release
+
+- **Idempotent.** A caller that runs the release AND lets the scope end runs it two times.
+- **Synchronous.** The type rejects a release that returns a value, a promise above all. A `Disposable` serves `using` and `await using`, while an `AsyncDisposable` raises a TypeError under a plain `using`.
+
+The key is not enumerable, so a spread of the value does not copy it.
+
+Use `DISPOSE` and not a bare `Symbol.dispose` when a class implements the protocol itself. A bundler that downlevels `using` for a target below Chrome 134 emits a helper that reads `object[Symbol.dispose || Symbol.for("Symbol.dispose")]`, and `DISPOSE` is that same pair:
+
+```ts
+import { DISPOSE } from "@xmachines/core/utils";
+
+class Session {
+	close(): void {}
+	[DISPOSE](): void {
+		this.close();
+	}
+}
+```
+
+> **The `using` form needs `"lib": ["ESNext"]`.** A consumer on a lower `lib` reads `DisposeMember` as an empty type, and every call site keeps compiling.
+
+### `releaseQuietly(release, onFailure)`
+
+Runs one release, and gives a throw of it to `onFailure`. A teardown that runs several releases in a row runs each one through it, so a throw of the first release skips none of the others. `null` and `undefined` do nothing.
+
+## Value helpers
+
+### `isError(value)`
+
+Tells if a value is an `Error` of any realm. The function tries `instanceof` first, so an object that inherits from `Error.prototype` answers `true`. `instanceof` misses an error from an iframe or from `node:vm`, so for such a value the function uses `Error.isError` where the runtime has it, and it tests the brand elsewhere. It can throw for a revoked Proxy, so wrap it in `try` inside an error path.
+
+### `safeString(value)` and `describeValue(value)`
+
+Two ways to put an unknown value in the message of an error, and neither one throws. `safeString` gives the `String()` of the value, and it falls back to the brand for an object with a null prototype or a conversion that throws. `describeValue` gives the JSON text, and it names the type for a value that JSON drops or cannot write, such as `[function]`.
+
+### `isThenable(value)`
+
+Tells if a value has a callable `then`, which is the test that `await` applies. Use it where a declared `void | Promise<void>` says nothing at run time.
+
+### `createNullRecord()`
+
+Builds an empty record with no prototype. A record that collects keys from outside the program — the params of a URL, the query of a location — takes any key that the outside sends. In an ordinary `{}`, a key such as `__proto__` writes the prototype and not an entry.
+
+### `rethrowLater(error)`
+
+Throws an error again from a microtask of its own, and returns at once. The throw reaches the global handler of the runtime, and it touches the current stack not. A host escalates a failure this way from the `onError` handler of a renderer: each renderer contains a handler that throws, so a plain `throw` there reaches no caller.
+
+### `createWarnOnce()`
+
+Builds a function of `(anchor, message)` that writes one `console.warn` for each anchor object. A diagnostic that a hot path finds — a stale field of a static config, read on every event — reports one time for that config, and not at the rate of the path. Each function keeps a memory of its own, so the package keeps no module state.
+
+### `shallowEqualExcept(a, b, except?)`
+
+Compares the own keys of two objects with `Object.is`, and it can ignore one key on both sides. A key that one side carries and the other lacks makes the two unequal. The emission dedup of the Play packages reads it.
+
+## The cache, on `@xmachines/core/cache`
+
+The cache has a subpath of its own, because it is cache code alone.
+
+- **`KeyValueCache<V>`** — a read and a write by a string key. A `Map` satisfies it, and so does an LRU of any library. A cache may forget an entry at any time.
+- **`createLruCache<V>(maxSize = 500)`** — a cache that forgets its least recently used entries. It holds two generations, so it holds `2 * maxSize + 1` entries at most. A size below `1` reads as `1`, a fraction rounds down, and a size that is not a finite number reads as the default.
+
+```ts
+import { createLruCache } from "@xmachines/core/cache";
+
+const pathCache = createLruCache<string | null>(5000);
+```
+
+The route map of [`@xmachines/play-router`](../play-router/README.md) and the parse of [`@xmachines/play-pattern`](../play-pattern/README.md) take such a cache, and those packages re-export both names.
+
+## API Summary
+
+### Exported from `@xmachines/core/errors`
+
+| Export                 | Kind    | Description                                                         |
+| ---------------------- | ------- | ------------------------------------------------------------------- |
+| `BaseError`            | `class` | The base of every typed error: a `scope` and a `code`               |
+| `DisposeConflictError` | `class` | `asDisposable` refuses a named release that the scope would not run |
+
+### Exported from `@xmachines/core/utils`
+
+| Export               | Kind       | Description                                                              |
+| -------------------- | ---------- | ------------------------------------------------------------------------ |
+| `asDisposable`       | `function` | Makes one function or object a `Disposable`. It changes the value itself |
+| `DISPOSE`            | `const`    | The symbol key that a release sits under                                 |
+| `DisposeKey`         | `type`     | The type of that key, and `never` where the consumer omits the lib       |
+| `DisposeMember`      | `type`     | The dispose member of a `Disposable`, and none where the lib is absent   |
+| `releaseQuietly`     | `function` | Runs one release, and gives a throw of it to `onFailure`                 |
+| `rethrowLater`       | `function` | Throws an error again from a microtask of its own                        |
+| `createWarnOnce`     | `function` | Builds a function that warns one time for each anchor object             |
+| `isError`            | `function` | Tells if a value is an `Error` of any realm                              |
+| `safeString`         | `function` | The `String()` of a value, and it throws never                           |
+| `describeValue`      | `function` | The JSON text of a value, or its type in brackets                        |
+| `isThenable`         | `function` | Tells if a value has a callable `then`                                   |
+| `createNullRecord`   | `function` | An empty record with no prototype                                        |
+| `shallowEqualExcept` | `function` | The shallow equality of the own keys, and it can ignore one key          |
+
+### Exported from `@xmachines/core/cache`
+
+| Export             | Kind        | Description                                          |
+| ------------------ | ----------- | ---------------------------------------------------- |
+| `KeyValueCache<V>` | `interface` | A read and a write by a string key                   |
+| `createLruCache`   | `function`  | A cache that forgets its least recently used entries |
+
+## License
+
+MIT
+
+## Modules
+
+- [cache](cache/README.md)
+- [errors](errors/README.md)
+- [utils](utils/README.md)

package/api/@xmachines/core/cache/README.md

@@ -0,0 +1,17 @@
+[API](../../../README.md) / [@xmachines/core](../README.md) / cache
+
+# cache
+
+A cache contract by a string key, and a default implementation of it.
+
+The contract is two methods, so a `Map` satisfies it, and so does an LRU of any
+library. A caller that wants a time to live or an eviction callback brings the module
+that has one, and the code that reads the cache needs to know nothing about it.
+
+## Interfaces
+
+- [KeyValueCache](interfaces/KeyValueCache.md)
+
+## Functions
+
+- [createLruCache](functions/createLruCache.md)

package/api/@xmachines/core/cache/functions/createLruCache.md

@@ -0,0 +1,52 @@
+[API](../../../../README.md) / [@xmachines/core](../../README.md) / [cache](../README.md) / createLruCache
+
+# Function: createLruCache()
+
+```ts
+function createLruCache<V>(maxSize?): KeyValueCache<V>;
+```
+
+Defined in: [packages/core/src/cache.ts:54](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/core/src/cache.ts#L54)
+
+Builds a cache that forgets its least recently used entries.
+
+## The algorithm
+
+Two maps, and no list. `recent` takes every write. When a write takes `recent` past
+`maxSize` entries, it becomes `old` and a new `recent` opens, which drops the previous
+`old` whole. A read of a key of `old` moves the entry into `recent`, and THAT is what
+makes the eviction an LRU one rather than a FIFO one: an entry that every lookup reads
+moves forward, and an entry that nothing reads falls out with the map that holds it.
+
+The cache therefore holds `2 * maxSize + 1` entries at most: `old` holds `maxSize + 1`,
+and `recent` holds `maxSize`. It does no bookkeeping for a read that hits `recent`.
+
+A stored `undefined` reads as a miss. Store `null` for "no value".
+
+## Type Parameters
+
+| Type Parameter |
+| -------------- |
+| `V`            |
+
+## Parameters
+
+| Parameter | Type     | Default value | Description                                                                                                                                                                                                          |
+| --------- | -------- | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `maxSize` | `number` | `500`         | The number of entries that `recent` holds. It is `1` at the least, and the default is `500`. A value that is not a finite number reads as the default, so a cache with no eviction at all cannot happen by accident. |
+
+## Returns
+
+[`KeyValueCache`](../interfaces/KeyValueCache.md)\<`V`\>
+
+A cache. It is not shared: each call builds one.
+
+## Example
+
+```typescript
+import { createLruCache } from "@xmachines/core/cache";
+
+const cache = createLruCache<string>(50);
+cache.set("/profile/:userId", "profile");
+cache.get("/profile/:userId"); // "profile"
+```

package/api/@xmachines/core/cache/interfaces/KeyValueCache.md

@@ -0,0 +1,61 @@
+[API](../../../../README.md) / [@xmachines/core](../../README.md) / [cache](../README.md) / KeyValueCache
+
+# Interface: KeyValueCache\<V\>
+
+Defined in: [packages/core/src/cache.ts:17](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/core/src/cache.ts#L17)
+
+What a reader needs from a cache: a read and a write, both by a string key.
+
+A cache may forget an entry at any time, and it may forget none. Both are correct for a
+reader that computes the value again for an entry that is absent.
+
+## Type Parameters
+
+| Type Parameter |
+| -------------- |
+| `V`            |
+
+## Methods
+
+### get()
+
+```ts
+get(key): V | undefined;
+```
+
+Defined in: [packages/core/src/cache.ts:19](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/core/src/cache.ts#L19)
+
+Reads one entry, or `undefined` when the cache holds none for the key.
+
+#### Parameters
+
+| Parameter | Type     |
+| --------- | -------- |
+| `key`     | `string` |
+
+#### Returns
+
+`V` \| `undefined`
+
+---
+
+### set()
+
+```ts
+set(key, value): void;
+```
+
+Defined in: [packages/core/src/cache.ts:21](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/core/src/cache.ts#L21)
+
+Writes one entry.
+
+#### Parameters
+
+| Parameter | Type     |
+| --------- | -------- |
+| `key`     | `string` |
+| `value`   | `V`      |
+
+#### Returns
+
+`void`

package/api/@xmachines/core/errors/README.md

@@ -0,0 +1,11 @@
+[API](../../../README.md) / [@xmachines/core](../README.md) / errors
+
+# errors
+
+The error base of the XMachines packages: [BaseError](classes/BaseError.md), and
+[DisposeConflictError](classes/DisposeConflictError.md), the one error that `@xmachines/core` throws.
+
+## Classes
+
+- [BaseError](classes/BaseError.md)
+- [DisposeConflictError](classes/DisposeConflictError.md)

package/api/@xmachines/core/errors/classes/BaseError.md

@@ -0,0 +1,226 @@
+[API](../../../../README.md) / [@xmachines/core](../../README.md) / [errors](../README.md) / BaseError
+
+# Class: BaseError
+
+Defined in: [packages/core/src/errors.ts:44](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/core/src/errors.ts#L44)
+
+The base class of every typed runtime error of an `@xmachines/*` package.
+
+`BaseError` gives each error two structured fields:
+
+- `scope` — the class or the module that threw the error, for example `"asDisposable"`
+- `code` — a stable, machine-readable identifier, for example `"CORE_DISPOSE_CONFLICT"`
+
+Your application code therefore branches on the type of an error, and it does not
+parse the `.message` string. A message changes between releases.
+
+`PlayError` of `@xmachines/play/errors` extends this class, and every error of a Play
+package extends `PlayError`. A package below the Play protocol, such as this one,
+extends `BaseError` directly. `err instanceof BaseError` therefore matches every
+typed error of the workspace.
+
+## How to catch an error by its type
+
+```typescript
+import { BaseError, DisposeConflictError } from "@xmachines/core/errors";
+import { asDisposable } from "@xmachines/core/utils";
+
+try {
+	using handle = asDisposable(target, release);
+} catch (err) {
+	if (err instanceof DisposeConflictError) {
+		// err.scope === "asDisposable"
+		// err.code  === "CORE_DISPOSE_CONFLICT"
+	} else if (err instanceof BaseError) {
+		// Every other @xmachines/* error
+		console.error(`[${err.scope}:${err.code}] ${err.message}`);
+	} else {
+		throw err; // Throw an unknown error again
+	}
+}
+```
+
+## Extends
+
+- `Error`
+
+## Extended by
+
+- [`DisposeConflictError`](DisposeConflictError.md)
+- [`PlayError`](../../../play/errors/classes/PlayError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new BaseError(
+   scope,
+   code,
+   message,
+   options?
+): BaseError;
+```
+
+Defined in: [packages/core/src/errors.ts:64](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/core/src/errors.ts#L64)
+
+#### Parameters
+
+| Parameter  | Type           | Description                                                                             |
+| ---------- | -------------- | --------------------------------------------------------------------------------------- |
+| `scope`    | `string`       | The class or the module that throws this error.                                         |
+| `code`     | `string`       | The machine-readable identifier of the error, for example `"CORE_DISPOSE_CONFLICT"`.    |
+| `message`  | `string`       | The description for a person. Never match on it in your code.                           |
+| `options?` | `ErrorOptions` | The standard `ErrorOptions`. Give `{ cause: originalError }` to make a chain of errors. |
+
+#### Returns
+
+`BaseError`
+
+#### Overrides
+
+```ts
+Error.constructor;
+```
+
+## Properties
+
+| Property                                                | Modifier   | Type      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                       | Inherited from          | Defined in                                                                                                                 |
+| ------------------------------------------------------- | ---------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-cause"></a> `cause?`                    | `public`   | `unknown` | -                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `Error.cause`           | -                                                                                                                          |
+| <a id="property-code"></a> `code`                       | `readonly` | `string`  | A stable, machine-readable identifier of the error. An error code follows the naming convention `<PACKAGE>_<DESCRIPTION>`, and a Play package writes `PLAY_<PACKAGE>_<DESCRIPTION>`. A code 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.                                                                                         | -                       | [packages/core/src/errors.ts:56](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/core/src/errors.ts#L56) |
+| <a id="property-message"></a> `message`                 | `public`   | `string`  | -                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `Error.message`         | -                                                                                                                          |
+| <a id="property-name"></a> `name`                       | `public`   | `string`  | -                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `Error.name`            | -                                                                                                                          |
+| <a id="property-scope"></a> `scope`                     | `readonly` | `string`  | The class or the module that threw this error, for example `"asDisposable"`.                                                                                                                                                                                                                                                                                                                                                                      | -                       | [packages/core/src/errors.ts:46](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v6.0.0/packages/core/src/errors.ts#L46) |
+| <a id="property-stack"></a> `stack?`                    | `public`   | `string`  | -                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `Error.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. | `Error.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
+
+```ts
+Error.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
+
+```ts
+Error.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
+
+```ts
+Error.prepareStackTrace;
+```