@xmachines/docs 3.0.0 → 4.0.0

package/api/@xmachines/play-url/index/type-aliases/PatternPart.md

@@ -0,0 +1,9 @@
+[API](../../../../README.md) / [@xmachines/play-url](../../README.md) / [index](../README.md) / PatternPart
+
+# Type Alias: PatternPart
+
+```ts
+type PatternPart = LiteralPart | ParamPart | GroupPart;
+```
+
+Defined in: [packages/play-url/src/pattern-grammar.ts:96](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-url/src/pattern-grammar.ts#L96)

package/api/@xmachines/play-url/index/type-aliases/URLPatternCtor.md

@@ -0,0 +1,22 @@
+[API](../../../../README.md) / [@xmachines/play-url](../../README.md) / [index](../README.md) / URLPatternCtor
+
+# Type Alias: URLPatternCtor
+
+```ts
+type URLPatternCtor = (init) => URLPatternLike;
+```
+
+Defined in: [packages/play-url/src/url-pattern-utils.ts:60](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-url/src/url-pattern-utils.ts#L60)
+
+The constructor type of a URLPatternLike instance.
+
+## Parameters
+
+| Parameter       | Type                        |
+| --------------- | --------------------------- |
+| `init`          | \{ `pathname`: `string`; \} |
+| `init.pathname` | `string`                    |
+
+## Returns
+
+[`URLPatternLike`](URLPatternLike.md)

package/api/@xmachines/play-url/index/type-aliases/URLPatternLike.md

@@ -0,0 +1,68 @@
+[API](../../../../README.md) / [@xmachines/play-url](../../README.md) / [index](../README.md) / URLPatternLike
+
+# Type Alias: URLPatternLike
+
+```ts
+type URLPatternLike = object;
+```
+
+Defined in: [packages/play-url/src/url-pattern-utils.ts:52](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-url/src/url-pattern-utils.ts#L52)
+
+The minimal structural type of the part of URLPattern that this package uses.
+
+The type is the published contract of this module, and it names the native API and the
+polyfill both. It also keeps the global declarations of `urlpattern-polyfill` out of
+the emitted `.d.ts` of this package.
+
+## Methods
+
+### exec()
+
+```ts
+exec(input):
+  | {
+  pathname: {
+     groups: Record<string, string | undefined>;
+  };
+}
+  | null;
+```
+
+Defined in: [packages/play-url/src/url-pattern-utils.ts:53](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-url/src/url-pattern-utils.ts#L53)
+
+#### Parameters
+
+| Parameter        | Type                        |
+| ---------------- | --------------------------- |
+| `input`          | \{ `pathname`: `string`; \} |
+| `input.pathname` | `string`                    |
+
+#### Returns
+
+\| \{
+`pathname`: \{
+`groups`: `Record`\<`string`, `string` \| `undefined`\>;
+\};
+\}
+\| `null`
+
+---
+
+### test()
+
+```ts
+test(input): boolean;
+```
+
+Defined in: [packages/play-url/src/url-pattern-utils.ts:56](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-url/src/url-pattern-utils.ts#L56)
+
+#### Parameters
+
+| Parameter        | Type                        |
+| ---------------- | --------------------------- |
+| `input`          | \{ `pathname`: `string`; \} |
+| `input.pathname` | `string`                    |
+
+#### Returns
+
+`boolean`

package/api/@xmachines/{play-router → play-url/index}/variables/NO_BASE_PATH.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / NO\_BASE\_PATH
+[API](../../../../README.md) / [@xmachines/play-url](../../README.md) / [index](../README.md) / NO\_BASE\_PATH
 
 # Variable: NO\_BASE\_PATH
 
@@ -6,7 +6,7 @@
 const NO_BASE_PATH: ResolvedBasePath;
 ```
 
-Defined in: [play-router/src/base-path.ts:102](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/base-path.ts#L102)
+Defined in: [packages/play-url/src/base-path.ts:102](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-url/src/base-path.ts#L102)
 
 The base path of a bridge that has no `basePath` option.
 

package/api/@xmachines/play-url/index/variables/URLPattern.md

@@ -0,0 +1,21 @@
+[API](../../../../README.md) / [@xmachines/play-url](../../README.md) / [index](../README.md) / URLPattern
+
+# Variable: URLPattern
+
+```ts
+const URLPattern: URLPatternCtor;
+```
+
+Defined in: [packages/play-url/src/url-pattern-utils.ts:75](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-url/src/url-pattern-utils.ts#L75)
+
+The URLPattern constructor that this library uses: the native API when the runtime
+carries one, and the polyfill when it does not.
+
+The native API comes first for two reasons. It is faster, because the engine compiles
+the pattern itself. And it is the API that the REST of the page already uses, so a
+pattern that the application builds and a pattern that this library builds behave the
+same way.
+
+The read of `globalThis` happens ONE time, when the module loads. A test that replaces
+`globalThis.URLPattern` afterwards therefore changes nothing here, which is what makes
+the compiled-pattern cache below safe to keep for the life of the process.

package/api/@xmachines/play-view/README.md

@@ -0,0 +1,165 @@
+[API](../../README.md) / @xmachines/play-view
+
+# @xmachines/play-view
+
+The shared view half of every renderer of the XMachines Play Architecture.
+
+[![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-view)
+
+## Installation
+
+```bash
+pnpm add @xmachines/play-view
+```
+
+**Peer dependencies.** Install them with the package:
+
+```bash
+pnpm add @xmachines/json-render-core
+```
+
+A renderer of a framework depends on this package already. Install it directly when you write a renderer of your own.
+
+## Overview
+
+A renderer of a framework is two things: the view lifecycle, and the code that binds that lifecycle to the effects of the framework. This package holds the first one. [`@xmachines/play-react`](../play-react/README.md), [`@xmachines/play-vue`](../play-vue/README.md), [`@xmachines/play-solid`](../play-solid/README.md), [`@xmachines/play-svelte`](../play-svelte/README.md) and [`@xmachines/play-dom`](../play-dom/README.md) hold the second one.
+
+It also holds `Viewable` and `PlaySpec`. Every type here names a type of `@xmachines/json-render-core`, and that is the reason they are here and not in [`@xmachines/play-actor`](../play-actor/README.md): an application that routes and renders no view installs this package never, and json-render never.
+
+| Export                                           | Description                                                           |
+| ------------------------------------------------ | --------------------------------------------------------------------- |
+| `Viewable`                                       | The capability of an actor that publishes a `currentView` signal      |
+| `PlaySpec`, `typedSpec`                          | The spec that an actor publishes, and its identity helper             |
+| `BaseActorProviderProps`, `BaseViewContextValue` | The framework-free half of the props and of the context of a provider |
+| `createViewStoreLifecycle`                       | The lifecycle of the state store of one view                          |
+| `createFailureLatch`, `createReportGuard`        | The report of a render failure, one time for each view                |
+| `toAtomState`, `attachRenderErrorHandler`        | The guards that a provider puts around a registry                     |
+| `composePlayState`, `refreshContextSubtree`, …   | The projection of the machine context into the store                  |
+
+## API Summary
+
+### `typedSpec(spec)`
+
+This identity helper gives a view-spec literal the type `PlaySpec` at the definition site. The
+XState `meta` field has the type `Record<string, unknown>`. Therefore this helper is the place
+where the spec shape receives the compile-time check and the IDE autocomplete. The helper has no
+cost at run time.
+
+```ts
+import { typedSpec } from "@xmachines/play-view";
+
+// In an XState machine meta block:
+meta: {
+  view: typedSpec({
+    root: "root",
+    elements: {
+      root: {
+        type: "Dashboard",
+        props: { username: { $state: "/context/username" } },
+        children: [],
+      },
+    },
+  }),
+}
+```
+
+### `PlaySpec`
+
+This type extends the `Spec` type of `@xmachines/json-render-core`. Each derived view receives
+the complete machine context in its state store, under the read-only **`/context` subtree**. A
+spec therefore reads the context through the ordinary `{ $state: "/context/…" }` grammar: in a
+prop, in a `visible` condition, and in `repeat.statePath`.
+
+`/context` is read-only by design. Nothing can write to it. The machine context changes through
+an event only. A `$bindState` write or a `setState` write under `/context` throws an error, and
+the error names the event to send. This is the model: the bindable ephemeral state is at the
+root of the store, from `spec.state`; the domain state is in the machine, and it changes through
+events that are meaningful and easy to inspect.
+
+The path shows the origin of each value. `/context/params/username` comes from the URL.
+`/context/username` belongs to the machine. One value can never hide the other.
+
+The model projects everything, and this has two consequences. The first consequence is
+**exposure**. The complete context is visible to the client in the view store, which includes a
+debug panel, an inspector, and a validator. The context is a client-side value in each case, so
+keep a secret out of it.
+
+The second consequence is **emission granularity**. The emit gate compares the context field by
+field, at the top level only. Therefore an event that changes any field emits the view again
+with the same `viewKey`. A provider refreshes `/context` in the live store, and it does not seed
+the store again. The component does not remount, and the ephemeral view state and the focus
+stay. However, a new emission is still a render pass in the framework layer. Keep
+high-frequency ephemeral data, such as a draft for each keystroke or a timer, in the view store
+(`spec.state` with `$bindState`) or in a child actor. The domain state belongs in the context. A
+keystroke does not.
+
+```ts
+import type { PlaySpec } from "@xmachines/play-view";
+
+const spec: PlaySpec = {
+	root: "root",
+	elements: {
+		root: {
+			type: "Profile",
+			props: { username: { $state: "/context/username" } },
+			children: [],
+		},
+	},
+};
+```
+
+> Historical note: an earlier version had a `contextProps` field. At first the field drove an
+> implicit prop-enrichment pass. That pass merged the allowlisted context fields and the URL
+> params into the props of every element. We removed it, because it put values into components
+> that never asked for them, and it let URL data from the user hide machine-owned state. The
+> field was then a projection filter for a short time. We removed that filter too, because a
+> limit on what a view can read added machinery without a real problem to solve. Always
+> validate the **derived** view (`actor.currentView.get()`), not the raw `meta.view`. The
+> `state` of the derived spec carries the projection, so a tool such as `validateSpec` sees a
+> spec that is consistent with itself.
+
+### `Viewable`
+
+Interface for actors that expose a renderable view signal.
+
+```ts
+import type { Viewable } from "@xmachines/play-view";
+import type { PlaySpec } from "@xmachines/play-view";
+import { Signal } from "@xmachines/play-signals";
+
+// currentView carries PlaySpec | null
+const signal = new Signal.State<PlaySpec | null>(null);
+const viewable: Viewable = { currentView: signal };
+```
+
+### `BaseActorProviderProps<TRegistry>`
+
+The framework-agnostic base props. Every `ActorProvider` implementation shares them: React, Vue, Solid, and Svelte. Each framework renderer package extends this interface.
+
+```ts
+import type { BaseActorProviderProps } from "@xmachines/play-view";
+import type { DefineRegistryResult } from "@xmachines/json-render-react";
+
+interface ActorProviderProps extends BaseActorProviderProps<DefineRegistryResult> {
+	fallback?: React.ReactNode;
+	children: React.ReactNode;
+}
+```
+
+### `BaseViewContextValue<TRegistry>`
+
+The framework-agnostic base of the `ViewContextValue` type in each framework. It holds the `spec`, `handlers`, `registry`, and `store` fields. These fields are identical in React, Vue, Solid, and Svelte.
+
+## Documentation
+
+- [Architecture](../../../contributing/architecture.md)
+- [Play RFC](../../../rfc/play.md)
+
+## License
+
+MIT
+
+## Modules
+
+- [errors](errors/README.md)
+- [index](index/README.md)

package/api/@xmachines/play-view/errors/README.md

@@ -0,0 +1,17 @@
+[API](../../../README.md) / [@xmachines/play-view](../README.md) / errors
+
+# errors
+
+The errors of the view half.
+
+Every error of this workspace extends `PlayError` of `@xmachines/play`, and it carries
+a `scope` and a `code` that stay the same across a patch release and a minor release.
+Match on the `code`, or on the class. Match on the `message` never.
+
+## See
+
+[Architecture](../../../../contributing/architecture.md)
+
+## Classes
+
+- [ReadOnlyContextError](classes/ReadOnlyContextError.md)

package/api/@xmachines/play-view/errors/classes/ReadOnlyContextError.md

@@ -0,0 +1,192 @@
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [errors](../README.md) / ReadOnlyContextError
+
+# Class: ReadOnlyContextError
+
+Defined in: [packages/play-view/src/errors.ts:34](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/errors.ts#L34)
+
+A write reached the context projection of the view store.
+
+The `/context` subtree of a view mirrors the context of the machine, and it is a
+READ of that context. A write there would hold a value that the next snapshot of the
+machine throws away, so the store refuses it. Send the actor an event instead: the
+context changes in the machine, and the projection follows.
+
+## Example
+
+```typescript
+import { ReadOnlyContextError } from "@xmachines/play-view/errors";
+
+try {
+	store.set("/context/user/name", "Alice");
+} catch (error) {
+	if (error instanceof ReadOnlyContextError) {
+		actor.send({ type: "user.rename", name: "Alice" });
+	}
+}
+```
+
+## Extends
+
+- [`PlayError`](../../../play/errors/classes/PlayError.md)
+
+## Constructors
+
+### Constructor
+
+```ts
+new ReadOnlyContextError(path, stateKey): ReadOnlyContextError;
+```
+
+Defined in: [packages/play-view/src/errors.ts:42](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/errors.ts#L42)
+
+#### Parameters
+
+| Parameter  | Type     | Description                                      |
+| ---------- | -------- | ------------------------------------------------ |
+| `path`     | `string` | The path of the refused write.                   |
+| `stateKey` | `string` | The key of the context subtree, for the message. |
+
+#### Returns
+
+`ReadOnlyContextError`
+
+#### 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-path"></a> `path`                       | `readonly` | `string`  | The JSON pointer of the write that the store refused, as the caller gave it.                                                                                                                                                                                                                                                                                                                                                                      | -                                                                                                                                                | [packages/play-view/src/errors.ts:36](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/errors.ts#L36) |
+| <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)

package/api/@xmachines/play-view/index/README.md

@@ -0,0 +1,55 @@
+[API](../../../README.md) / [@xmachines/play-view](../README.md) / index
+
+# index
+
+@xmachines/play-view - the shared view half of every renderer of the Play Architecture
+
+A renderer of a framework is two things: the view lifecycle, and the code that binds
+that lifecycle to the effects of the framework. This package holds the first one, and
+`@xmachines/play-react`, `@xmachines/play-vue`, `@xmachines/play-solid`,
+`@xmachines/play-svelte` and `@xmachines/play-dom` hold the second one.
+
+It also holds `Viewable` and `PlaySpec`. Every type here names a type of
+`@xmachines/json-render-core`, and that is why they are here and not in
+`@xmachines/play-actor`: an application that routes and renders no view installs this
+package never, and json-render never.
+
+## See
+
+[Play RFC](../../../../rfc/play.md)
+
+## Interfaces
+
+- [BaseActorProviderProps](interfaces/BaseActorProviderProps.md)
+- [BaseViewContextValue](interfaces/BaseViewContextValue.md)
+- [FailureLatch](interfaces/FailureLatch.md)
+- [PlaySpec](interfaces/PlaySpec.md)
+- [ReportGuard](interfaces/ReportGuard.md)
+- [ReportGuardMessages](interfaces/ReportGuardMessages.md)
+- [ResolveViewStoreOptions](interfaces/ResolveViewStoreOptions.md)
+- [Viewable](interfaces/Viewable.md)
+- [ViewInputs](interfaces/ViewInputs.md)
+- [ViewStoreLifecycle](interfaces/ViewStoreLifecycle.md)
+- [ViewStoreResolution](interfaces/ViewStoreResolution.md)
+
+## Type Aliases
+
+- [ViewActor](type-aliases/ViewActor.md)
+
+## Variables
+
+- [CONTEXT\_STATE\_KEY](variables/CONTEXT_STATE_KEY.md)
+
+## Functions
+
+- [attachRenderErrorHandler](functions/attachRenderErrorHandler.md)
+- [composePlayState](functions/composePlayState.md)
+- [createFailureLatch](functions/createFailureLatch.md)
+- [createReportGuard](functions/createReportGuard.md)
+- [createViewStoreLifecycle](functions/createViewStoreLifecycle.md)
+- [guardContextWrites](functions/guardContextWrites.md)
+- [refreshContextSubtree](functions/refreshContextSubtree.md)
+- [reuseComposedState](functions/reuseComposedState.md)
+- [sameViewInputs](functions/sameViewInputs.md)
+- [toAtomState](functions/toAtomState.md)
+- [typedSpec](functions/typedSpec.md)

package/api/@xmachines/{play-actor → play-view/index}/functions/attachRenderErrorHandler.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-actor](../README.md) / attachRenderErrorHandler
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / attachRenderErrorHandler
 
 # Function: attachRenderErrorHandler()
 
@@ -6,7 +6,7 @@
 function attachRenderErrorHandler<TRegistry>(registry, handler): TRegistry;
 ```
 
-Defined in: [packages/play-actor/src/provider-guards.ts:68](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-actor/src/provider-guards.ts#L68)
+Defined in: [packages/play-view/src/provider-guards.ts:68](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/provider-guards.ts#L68)
 
 Copies a component registry, and puts an `onRenderError` handler into the copy.
 
@@ -29,10 +29,10 @@ between the providers in a safe way.
 
 ## Parameters
 
-| Parameter  | Type                                                                      | Description                                                                                          |
-| ---------- | ------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
-| `registry` | `TRegistry`                                                               | The component registry from `defineRegistry().registry`.                                             |
-| `handler`  | [`RenderErrorHandler`](../../play-dom/type-aliases/RenderErrorHandler.md) | The renderer calls it with `(error, componentName)` when a catalog component throws during a render. |
+| Parameter  | Type                                                                         | Description                                                                                          |
+| ---------- | ---------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| `registry` | `TRegistry`                                                                  | The component registry from `defineRegistry().registry`.                                             |
+| `handler`  | [`RenderErrorHandler`](../../../play-dom/type-aliases/RenderErrorHandler.md) | The renderer calls it with `(error, componentName)` when a catalog component throws during a render. |
 
 ## Returns
 

package/api/@xmachines/{play-actor → play-view/index}/functions/composePlayState.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-actor](../README.md) / composePlayState
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / composePlayState
 
 # Function: composePlayState()
 
@@ -6,7 +6,7 @@
 function composePlayState(authoredState, slice): Record<string, unknown> | undefined;
 ```
 
-Defined in: [packages/play-actor/src/context-projection.ts:228](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-actor/src/context-projection.ts#L228)
+Defined in: [packages/play-view/src/context-projection.ts:206](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/context-projection.ts#L206)
 
 Composes the effective state of a view: the authored `spec.state` and the
 `/context` slice.

package/api/@xmachines/{play-actor → play-view/index}/functions/createFailureLatch.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-actor](../README.md) / createFailureLatch
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / createFailureLatch
 
 # Function: createFailureLatch()
 
@@ -6,7 +6,7 @@
 function createFailureLatch(): FailureLatch;
 ```
 
-Defined in: [packages/play-actor/src/failure-latch.ts:202](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-actor/src/failure-latch.ts#L202)
+Defined in: [packages/play-view/src/failure-latch.ts:202](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L202)
 
 Makes a [FailureLatch](../interfaces/FailureLatch.md).
 

package/api/@xmachines/{play-actor → play-view/index}/functions/createReportGuard.md

@@ -1,4 +1,4 @@
-[API](../../../README.md) / [@xmachines/play-actor](../README.md) / createReportGuard
+[API](../../../../README.md) / [@xmachines/play-view](../../README.md) / [index](../README.md) / createReportGuard
 
 # Function: createReportGuard()
 
@@ -6,7 +6,7 @@
 function createReportGuard(messages): ReportGuard;
 ```
 
-Defined in: [packages/play-actor/src/failure-latch.ts:134](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-actor/src/failure-latch.ts#L134)
+Defined in: [packages/play-view/src/failure-latch.ts:134](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v4.0.0/packages/play-view/src/failure-latch.ts#L134)
 
 Makes a [ReportGuard](../interfaces/ReportGuard.md).