@xmachines/docs 3.0.0 → 5.0.0

package/api/@xmachines/play-url/index/interfaces/ParsedPattern.md

@@ -0,0 +1,23 @@
+[API](../../../../README.md) / [@xmachines/play-url](../../README.md) / [index](../README.md) / ParsedPattern
+
+# Interface: ParsedPattern
+
+Defined in: [packages/play-pattern/src/pattern-grammar.ts:117](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L117)
+
+Everything that this library reads from one route pattern.
+
+## Properties
+
+| Property                                            | Modifier   | Type                                                       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Defined in                                                                                                                                                     |
+| --------------------------------------------------- | ---------- | ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-bareform"></a> `bareForm`           | `readonly` | `string` \| `null`                                         | The path that the pattern matches when every optional part is absent, or `null` when the pattern holds a part that a path must fill. `/settings/:section?` gives `/settings`, `/a/{b}?/c` gives `/a//c`, and `/profile/:userId` gives `null`.                                                                                                                                                                                                                                           | [packages/play-pattern/src/pattern-grammar.ts:154](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L154) |
+| <a id="property-declarednames"></a> `declaredNames` | `readonly` | `ReadonlyMap`\<`string`, `string`\>                        | The map from each rewritten group name back to the name that the pattern declares, for example `cat_id` to `cat-id`. The map holds an entry only for a name that the rewrite changed. It is empty for most patterns, and a caller that reads a group name falls back to the name itself.                                                                                                                                                                                                | [packages/play-pattern/src/pattern-grammar.ts:184](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L184) |
+| <a id="property-indexkey"></a> `indexKey`           | `readonly` | `string`                                                   | The key of the bucket index: the first path segment, or `"*"` when a param can stand in the first segment.                                                                                                                                                                                                                                                                                                                                                                              | [packages/play-pattern/src/pattern-grammar.ts:171](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L171) |
+| <a id="property-literalpath"></a> `literalPath`     | `readonly` | `string` \| `null`                                         | The ONE path that the pattern matches, with each escape resolved, or `null` when the pattern describes a SET of paths. `/users` gives `/users`, `/tags/c\+\+` gives `/tags/c++`, `/x{y}z` gives `/xyz`, and `/profile/:userId` gives `null`. A bridge writes a real browser URL from this field. The SOURCE of the pattern is no substitute for it: `/tags/c\+\+` carries two backslashes that the address bar must not hold, and a location that carries them matches the route never. | [packages/play-pattern/src/pattern-grammar.ts:166](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L166) |
+| <a id="property-names"></a> `names`                 | `readonly` | readonly `string`[]                                        | The name of every param of [params](#property-params), in the same order. `resolveFrameworkParams` runs on EVERY navigation and it needs this list each time. The parse holds it, so a navigation allocates none. A caller that hands the array to somebody else copies it: the cache holds this one.                                                                                                                                                                                   | [packages/play-pattern/src/pattern-grammar.ts:131](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L131) |
+| <a id="property-normalized"></a> `normalized`       | `readonly` | `string`                                                   | The pattern in the form that URLPattern compiles: each param name that holds a hyphen carries an underscore instead.                                                                                                                                                                                                                                                                                                                                                                    | [packages/play-pattern/src/pattern-grammar.ts:176](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L176) |
+| <a id="property-parameterized"></a> `parameterized` | `readonly` | `boolean`                                                  | True when the pattern needs a URLPattern match, and false when it is a literal path. A malformed pattern reports `true`, so that it reaches the URLPattern constructor and fails there with the error of the API. A parser that called it static would send it to the exact-match map instead, where it matches nothing and reports no fault.                                                                                                                                           | [packages/play-pattern/src/pattern-grammar.ts:146](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L146) |
+| <a id="property-params"></a> `params`               | `readonly` | readonly [`PatternParam`](PatternParam.md)[]               | The NAMED params, in the order that the pattern declares them.                                                                                                                                                                                                                                                                                                                                                                                                                          | [packages/play-pattern/src/pattern-grammar.ts:123](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L123) |
+| <a id="property-parts"></a> `parts`                 | `readonly` | readonly [`PatternPart`](../type-aliases/PatternPart.md)[] | The parts, in the order that the pattern declares them.                                                                                                                                                                                                                                                                                                                                                                                                                                 | [packages/play-pattern/src/pattern-grammar.ts:121](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L121) |
+| <a id="property-requirednames"></a> `requiredNames` | `readonly` | readonly `string`[]                                        | The name of every param that a path must fill, in the order of [params](#property-params). The same rule as [names](#property-names): the parse holds the array, and a navigation reads it.                                                                                                                                                                                                                                                                                             | [packages/play-pattern/src/pattern-grammar.ts:137](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L137) |
+| <a id="property-source"></a> `source`               | `readonly` | `string`                                                   | The pattern as the caller wrote it.                                                                                                                                                                                                                                                                                                                                                                                                                                                     | [packages/play-pattern/src/pattern-grammar.ts:119](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L119) |

package/api/@xmachines/play-url/index/interfaces/PatternCache.md

@@ -0,0 +1,65 @@
+[API](../../../../README.md) / [@xmachines/play-url](../../README.md) / [index](../README.md) / PatternCache
+
+# Interface: PatternCache\<V\>
+
+Defined in: [packages/play-pattern/src/cache.ts:53](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/cache.ts#L53)
+
+What this package needs from a cache: a read and a write, both by a string key.
+
+The contract is this small on purpose. 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 this package needs to know nothing about it.
+
+A cache may forget an entry at any time, and it may forget none. Both are correct: the
+parser runs again for an entry that is absent.
+
+## Type Parameters
+
+| Type Parameter |
+| -------------- |
+| `V`            |
+
+## Methods
+
+### get()
+
+```ts
+get(key): V | undefined;
+```
+
+Defined in: [packages/play-pattern/src/cache.ts:55](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/cache.ts#L55)
+
+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/play-pattern/src/cache.ts:57](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/cache.ts#L57)
+
+Writes one entry.
+
+#### Parameters
+
+| Parameter | Type     |
+| --------- | -------- |
+| `key`     | `string` |
+| `value`   | `V`      |
+
+#### Returns
+
+`void`

package/api/@xmachines/play-url/index/interfaces/PatternParam.md

@@ -0,0 +1,15 @@
+[API](../../../../README.md) / [@xmachines/play-url](../../README.md) / [index](../README.md) / PatternParam
+
+# Interface: PatternParam
+
+Defined in: [packages/play-pattern/src/pattern-grammar.ts:101](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L101)
+
+One named param of a pattern, with the question that every caller asks about it.
+
+## Properties
+
+| Property                                    | Modifier   | Type      | Description                                                                                                                                                                                                                                                           | Defined in                                                                                                                                                     |
+| ------------------------------------------- | ---------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-groupname"></a> `groupName` | `readonly` | `string`  | The name that URLPattern compiles, for example `cat_id`.                                                                                                                                                                                                              | [packages/play-pattern/src/pattern-grammar.ts:105](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L105) |
+| <a id="property-name"></a> `name`           | `readonly` | `string`  | The name as the pattern declares it, for example `cat-id`.                                                                                                                                                                                                            | [packages/play-pattern/src/pattern-grammar.ts:103](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L103) |
+| <a id="property-optional"></a> `optional`   | `readonly` | `boolean` | True when a matching path can carry no value for this param. The modifier `?` and the modifier `*` make a param optional, and so does EVERY group above it that carries one of the two. The modifier `+` does not: it repeats a param that one value must still fill. | [packages/play-pattern/src/pattern-grammar.ts:113](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L113) |

package/api/@xmachines/{play-router → play-url/index}/interfaces/ResolvedBasePath.md

@@ -1,14 +1,14 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / ResolvedBasePath
+[API](../../../../README.md) / [@xmachines/play-url](../../README.md) / [index](../README.md) / ResolvedBasePath
 
 # Interface: ResolvedBasePath
 
-Defined in: [play-router/src/base-path.ts:78](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/base-path.ts#L78)
+Defined in: [packages/play-url/src/base-path.ts:82](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/base-path.ts#L82)
 
 A base path that is ready for a use in both directions.
 
 ## Properties
 
-| Property                              | Modifier   | Type                           | Description                                                                                                                                                                     | Defined in                                                                                                                            |
-| ------------------------------------- | ---------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-params"></a> `params` | `readonly` | `Record`\<`string`, `string`\> | The values of each `:param` of the prefix, for the `params` of a `play.route` event. The object is empty for a prefix without a param, and for a pattern that nothing resolved. | [play-router/src/base-path.ts:89](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/base-path.ts#L89) |
-| <a id="property-path"></a> `path`     | `readonly` | `string`                       | The normalized prefix: it starts with `/`, it carries no trailing `/`, and it holds no duplicate slash. The empty string means "no prefix".                                     | [play-router/src/base-path.ts:83](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/base-path.ts#L83) |
+| Property                              | Modifier   | Type                           | Description                                                                                                                                                                     | Defined in                                                                                                                               |
+| ------------------------------------- | ---------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-params"></a> `params` | `readonly` | `Record`\<`string`, `string`\> | The values of each `:param` of the prefix, for the `params` of a `play.route` event. The object is empty for a prefix without a param, and for a pattern that nothing resolved. | [packages/play-url/src/base-path.ts:93](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/base-path.ts#L93) |
+| <a id="property-path"></a> `path`     | `readonly` | `string`                       | The normalized prefix: it starts with `/`, it carries no trailing `/`, and it holds no duplicate slash. The empty string means "no prefix".                                     | [packages/play-url/src/base-path.ts:87](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/base-path.ts#L87) |

package/api/@xmachines/play-url/index/interfaces/SplitLocation.md

@@ -0,0 +1,16 @@
+[API](../../../../README.md) / [@xmachines/play-url](../../README.md) / [index](../README.md) / SplitLocation
+
+# Interface: SplitLocation
+
+Defined in: [packages/play-url/src/location.ts:17](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/location.ts#L17)
+
+The parts of one location string.
+
+## Properties
+
+| Property                                  | Modifier   | Type     | Description                                                                                                                                                                                                                       | Defined in                                                                                                                             |
+| ----------------------------------------- | ---------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-fragment"></a> `fragment` | `readonly` | `string` | The fragment, WITH its leading `#`. It is `""` when the location carries none.                                                                                                                                                    | [packages/play-url/src/location.ts:23](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/location.ts#L23) |
+| <a id="property-pathname"></a> `pathname` | `readonly` | `string` | The pathname, with no query and no fragment.                                                                                                                                                                                      | [packages/play-url/src/location.ts:19](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/location.ts#L19) |
+| <a id="property-query"></a> `query`       | `readonly` | `string` | The query, with no leading `?`. It is `""` when the location carries none.                                                                                                                                                        | [packages/play-url/src/location.ts:21](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/location.ts#L21) |
+| <a id="property-suffix"></a> `suffix`     | `readonly` | `string` | Every character behind the pathname, as the location wrote them. A caller that rebuilds a location keeps this string rather than the two parts above, because it carries the `?` and the order of the two marks without a change. | [packages/play-url/src/location.ts:30](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/location.ts#L30) |

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

@@ -0,0 +1,74 @@
+[API](../../../../README.md) / [@xmachines/play-url](../../README.md) / [index](../README.md) / PathBuildResult
+
+# Type Alias: PathBuildResult
+
+```ts
+type PathBuildResult =
+	| {
+			ok: true;
+			path: string;
+	  }
+	| {
+			missing: string;
+			ok: false;
+			reason: "missing";
+	  }
+	| {
+			ok: false;
+			param: string;
+			reason: "unresolvable";
+			value: string;
+	  };
+```
+
+Defined in: [packages/play-pattern/src/pattern-grammar.ts:651](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L651)
+
+The answer of [buildPath](../functions/buildPath.md).
+
+## Union Members
+
+### Type Literal
+
+```ts
+{
+	ok: true;
+	path: string;
+}
+```
+
+The pattern built a path, and every part that needs a value has one.
+
+---
+
+### Type Literal
+
+```ts
+{
+	missing: string;
+	ok: false;
+	reason: "missing";
+}
+```
+
+A part needs a value that the caller did not give.
+
+`missing` names the param as the PATTERN declares it, with each hyphen kept, so a
+caller reports the name that its author wrote.
+
+---
+
+### Type Literal
+
+```ts
+{
+	ok: false;
+	param: string;
+	reason: "unresolvable";
+	value: string;
+}
+```
+
+A param carries a value that no path can hold, so the pattern matches the result
+back never. `param` names the param, and `value` holds what the caller gave.
+
+A dot segment is the one such value today: see [isDotSegment](../functions/isDotSegment.md).

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

@@ -0,0 +1,15 @@
+[API](../../../../README.md) / [@xmachines/play-url](../../README.md) / [index](../README.md) / PathParams
+
+# Type Alias: PathParams
+
+```ts
+type PathParams = Readonly<Record<string, unknown>>;
+```
+
+Defined in: [packages/play-pattern/src/pattern-grammar.ts:681](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L681)
+
+The values that a caller gives, keyed by the declared name of the param.
+
+The value is `unknown`, because a caller reads it from the context of an actor and that
+context carries whatever the machine put there. [buildPath](../functions/buildPath.md) calls `String` on a
+value that is neither `undefined` nor `null`.

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

@@ -0,0 +1,11 @@
+[API](../../../../README.md) / [@xmachines/play-url](../../README.md) / [index](../README.md) / PatternModifier
+
+# Type Alias: PatternModifier
+
+```ts
+type PatternModifier = "" | "?" | "+" | "*";
+```
+
+Defined in: [packages/play-pattern/src/pattern-grammar.ts:56](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L56)
+
+The modifier of a part. `""` means that the part carries none.

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-pattern/src/pattern-grammar.ts:98](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-pattern/src/pattern-grammar.ts#L98)

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:59](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/url-pattern-utils.ts#L59)
+
+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:51](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/url-pattern-utils.ts#L51)
+
+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:52](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/url-pattern-utils.ts#L52)
+
+#### 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:55](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/url-pattern-utils.ts#L55)
+
+#### 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:106](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/base-path.ts#L106)
 
 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:74](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.0/packages/play-url/src/url-pattern-utils.ts#L74)
+
+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,176 @@
+[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-5.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 @xmachines/play @xmachines/play-atom
+```
+
+- [`@xmachines/play`](../play/README.md) — the core protocol. This package reads `shallowEqualExcept` from it.
+- [`@xmachines/play-atom`](../play-atom/README.md) — the atom primitives. The view store holds the spec in a `ReadonlyAtom`.
+- `@xmachines/json-render-core` — the spec type that `PlaySpec` extends.
+
+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` atom        |
+| `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 atom.
+
+`currentView` is a `ReadonlyAtom`, because an actor DERIVES the view from its state. Only
+the actor decides what the view is, and that rule is in the type rather than in prose. A
+writable `Atom` still satisfies the interface structurally, so a test double drives a
+renderer by holding its own writable reference:
+
+```ts
+import type { Viewable } from "@xmachines/play-view";
+import type { PlaySpec } from "@xmachines/play-view";
+import { createAtom } from "@xmachines/play-atom";
+
+// The real actor derives this atom. A double writes its own.
+const atom = createAtom<PlaySpec | null>(null);
+const viewable: Viewable = { currentView: atom };
+
+atom.set(spec); // the double drives the renderer through ITS reference
+```
+
+### `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)