@alxia/react-router 0.10.0 → 0.12.0

package/README.md

@@ -95,7 +95,7 @@ client's files and the app's middlewares. So does React Router's prerendering.
 optional peer, for `/vite`; `react` 19 is an optional peer, for `/pwa/react`. The six `workbox-*`
 packages (`workbox-core`, `workbox-expiration`, `workbox-navigation-preload`,
 `workbox-precaching`, `workbox-routing`, `workbox-strategies`) are optional
-peers too, for `/pwa/worker` (the [PWA section](#installable-and-offline-pwa) has the install line). The package declares no dependency.
+peers too, for `/pwa/worker` (the [PWA section](#installable-and-offline-pwa) has the install line). `/errors` imports `react-router`, a required peer that is already installed. The package declares no dependency.
 
 Its `typescript` peer is 6 or 7. The template's TypeScript 5.9 typechecks,
 but `bun add` warns about it; `bun add -d typescript@^6` silences the
@@ -255,7 +255,7 @@ for the types.
 
 With `secureHeaders({ nonce: true })` from `@alxia/secure-headers` in
 `configure`, each request's policy names a fresh nonce, and the context
-carries it. `nonceOf(loadContext)` reads it in `entry.server.tsx`, and React
+carries it. `@alxia/react-router/entry` reads it with `nonceOf(loadContext)`, and React
 Router puts it on every script it renders, so `script-src` needs no
 `'unsafe-inline'`:
 
@@ -271,33 +271,185 @@ configure: (app) =>
 	),
 ```
 
-The template has no `entry.server.tsx`; reveal React Router's, then add
-three lines:
+The template has no `entry.server.tsx`; the package's own is one line:
 
-```sh
-bunx react-router reveal entry.server
+```ts
+// app/entry.server.tsx
+export { handleRequest as default, streamTimeout } from '@alxia/react-router/entry';
 ```
 
-```diff
- // app/entry.server.tsx, as reveal writes it
- import { PassThrough } from "node:stream";
-
-+import { nonceOf } from "@alxia/react-router";
- import type { EntryContext, RouterContextProvider } from "react-router";
- …
-     const { pipe, abort } = renderToPipeableStream(
--      <ServerRouter context={routerContext} url={request.url} />,
-+      <ServerRouter context={routerContext} url={request.url} nonce={nonceOf(loadContext)} />,
-       {
-+        nonce: nonceOf(loadContext),
-         [readyOption]() {
-```
+To customise the entry, reveal React Router's and add the nonce yourself
+([an entry of your own](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/csp-nonce.md#an-entry-of-your-own)).
 
 `nonceOf` returns `undefined` when no middleware set a nonce, so the entry works
 with or without secure-headers: neither package depends on the other. Any
 `derive` that returns a string `nonce` works the same.
 [More](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/csp-nonce.md#a-csp-nonce)
 
+## The document: nonce and boot scripts
+
+`@alxia/react-router/document` renders the CSP nonce in the root, on the
+server and in the browser, with `react` as its only import. The nonce comes
+from `secureHeaders({ nonce: true })` ([A CSP nonce](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/csp-nonce.md)).
+The server render provides it around the router; `useNonce()` reads it there,
+and in the browser reads the one the document's scripts carry, so hydration
+finds the attribute it rendered. `InlineScript` is an inline script with
+that nonce, for a theme's boot script, which must run before the first
+paint:
+
+```tsx
+// app/root.tsx
+import { Links, Meta, Outlet, Scripts, ScrollRestoration } from 'react-router';
+import { CspNonceMeta, InlineScript } from '@alxia/react-router/document';
+import { themeBootScript } from '<your theme library>';
+
+const THEME_BOOT = themeBootScript();
+
+export function Layout({ children }: { children: React.ReactNode }) {
+	return (
+		<html lang="en" suppressHydrationWarning>
+			<head>
+				<meta charSet="utf-8" />
+				<InlineScript code={THEME_BOOT} />
+				<CspNonceMeta />
+				<Meta />
+				<Links />
+			</head>
+			<body>
+				{children}
+				<ScrollRestoration />
+				<Scripts />
+			</body>
+		</html>
+	);
+}
+
+export default function App() {
+	return <Outlet />;
+}
+```
+
+`THEME_BOOT` is your theme library's own boot script. With `/entry`, `<Links>`,
+`<Scripts>` and `<ScrollRestoration>` take the nonce from `<ServerRouter nonce>`,
+so their `nonce` props are optional; `useNonce()` stays for `InlineScript`,
+`CspNonceMeta` and any script or style the app inserts. An entry of your own
+wraps the router:
+
+```tsx
+// app/entry.server.tsx (inside handleRequest)
+import { nonceOf } from '@alxia/react-router';
+import { DocumentNonce } from '@alxia/react-router/document';
+import { ServerRouter } from 'react-router';
+
+<DocumentNonce nonce={nonceOf(loadContext)}>
+	<ServerRouter context={routerContext} url={request.url} />
+</DocumentNonce>;
+```
+
+> The `InlineScript` code is written unescaped: keep it a constant of the
+> app, never user input. It throws a `TypeError` on `</script` or `<!--`
+> ([the message](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/troubleshooting.md#typeerror-inlinescript-the-code-contains-script-or----which-ends-or-confuses-the-script-element-escape-it-such-as-script-inside-a-string)).
+> A nonced page must never be made `public` by a route's `headers` export: a
+> shared cache would hand the same nonce to every visitor.
+
+### The page's language
+
+`createPageLanguage` gives the root the page's language for `<html lang>` and
+a route's `meta`, and `textDirection` the `dir` that goes with it. The server
+side, negotiating the request's language from a cookie and `Accept-Language`,
+is [`@alxia/language`](https://github.com/softistx/alxia/blob/develop/packages/language/README.md):
+
+```ts
+// app/server.ts
+import { language } from '@alxia/language';
+import { createServer } from '@alxia/react-router';
+
+const server = createServer({
+	configure: (app) =>
+		app.use(language({ supported: ['en', 'fr', 'ar'], fallback: 'en', order: ['cookie', 'header'] })),
+});
+export default server;
+declare module '@alxia/react-router' {
+	interface Register { server: typeof server }
+}
+```
+
+```ts
+// app/language.ts: one instance, imported by the root and the routes
+import { createPageLanguage } from '@alxia/react-router/document';
+
+export const { pageLanguage, metaLanguage, chooseLanguage, useChosenLanguage } =
+	createPageLanguage({ languages: ['en', 'fr', 'ar'], fallback: 'en' });
+```
+
+```tsx
+// app/root.tsx
+import { type AlxiaArgs, withAlxia } from '@alxia/react-router';
+import { textDirection } from '@alxia/react-router/document';
+import { useRouteLoaderData } from 'react-router';
+import { metaLanguage, pageLanguage, useChosenLanguage } from './language';
+import type { Route } from './+types/root';
+
+const titles = { en: 'Home', fr: 'Accueil', ar: 'الرئيسية' };
+
+// the root loader returns alxia.language, set by the middleware
+export const loader = withAlxia(({ alxia }: Route.LoaderArgs & AlxiaArgs) => ({ language: alxia.language }));
+
+export function Layout({ children }: { children: React.ReactNode }) {
+	const data = useRouteLoaderData<typeof loader>('root');
+	const language = pageLanguage(data?.language);
+	useChosenLanguage(); // re-renders the shell when the menu picks a language
+	return (
+		<html lang={language} dir={textDirection(language)} suppressHydrationWarning>
+			{/* … */}
+		</html>
+	);
+}
+
+export const meta: Route.MetaFunction = ({ matches }) => [
+	{ title: titles[metaLanguage(matches)] },
+];
+```
+
+- `pageLanguage(language)` is the supported language, else the fallback. In
+  the browser the one picked with `chooseLanguage(language)` wins, and the
+  last one seen stands in when the root's data is gone. On the server it
+  remembers nothing: one module serves every request.
+- `metaLanguage(matches)` reads `matches[0].loaderData.language`.
+- `useChosenLanguage()` is the picked language, or `undefined`; it
+  re-renders on a pick, and is `undefined` in the server render so
+  hydration matches.
+- `textDirection(tag)` is `'rtl'` for `ar`, `fa`, `he`, `ur`, `ps`, `yi`,
+  `dv`, `ckb`, `sd` and `ug` (and the legacy `iw` and `ji`), else `'ltr'`, reading the base tag whatever its
+  case (`ar-EG`, `AR`). A script subtag is not read: `az-Arab` is `'ltr'`.
+- A fallback outside `languages` throws
+  ([the message](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/troubleshooting.md#typeerror-createpagelanguage-the-fallback--is-not-one-of-the-languages-got-)).
+  An error page keeps the root's data, so it keeps the language, except
+  for a URL that matches no route or a root loader that threw: there it
+  shows the last language seen in the browser, or the fallback ([why](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/troubleshooting.md#the-error-page-shows-in-the-fallback-language)).
+
+[More](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/document.md)
+
+## The entry
+
+`@alxia/react-router/entry` is `entry.server.tsx` for an app on Bun, server
+only: it streams the shell, waits for the whole page for a bot and in SPA
+mode, answers HEAD with no body, and gives the router the response's CSP
+nonce (`nonceOf`) and `DocumentNonce`. It renders with the web stream
+renderer, so no `@react-router/node` and no `node:stream`. `react-dom` and
+`isbot` (needed only without an `isBot` option) are optional peers, which React Router's templates install.
+
+```tsx
+// app/entry.server.tsx
+export { handleRequest as default, streamTimeout } from '@alxia/react-router/entry';
+```
+
+To change `streamTimeout`, the nonce, the bot check or the error report,
+`createEntry({ streamTimeout, nonce, isBot, onError })` returns
+`{ handleRequest, streamTimeout }`.
+
+[More](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/document.md#the-entry)
+
 ## WebSockets
 
 A `ws` route in `configure` connects under `react-router dev`, under
@@ -410,6 +562,9 @@ build, it adds:
 - `build.target: 'esnext'`, where Vite's default targets browsers;
 - in the build only, `resolve.noExternal: true`: every package is bundled
   into `build/server/index.js`, so `build/` runs with no `node_modules`.
+- `/entry` and `/document` inlined, in dev by an alias and in the build, so
+  they share the app's `react-router`, even when the package is listed in
+  `ssr.external`.
 
 ```ts
 // app/server.ts: Bun's modules, bundled as they are
@@ -621,6 +776,155 @@ The [PWA guide](https://github.com/softistx/alxia/blob/develop/packages/react-ro
 has the worker's options, the offline page, the manifest route, the update
 banner and the rest.
 
+## An API's refusals, worded for the page
+
+`@alxia/react-router/errors` has no UI; its one runtime import is `react-router`, never `@alxia/core`. It
+holds the shape of a GraphQL API's refusal, declared structurally (no `@nxgt/graphql-client` at
+runtime), the request id an API echoes, the page a request is for, the
+catalogue of the API's messages an app keeps, the words of a form's checks,
+the provider that fills the catalogue in the browser, the wording of a refusal, the loaders and actions that answer with it, the JSON actions (CSRF check) with their fetcher hook, and what a failed call to the API becomes (`apiCallFailure`):
+
+```ts
+import { isApiErrorLike, nextOf, requestIdOf } from '@alxia/react-router/errors';
+
+export function describe(error: unknown, request: Request) {
+	return isApiErrorLike(error)
+		? { code: error.code, status: error.status, next: nextOf(request.url) }
+		: undefined;
+}
+
+export const idOf = (response: Response) => requestIdOf(response);
+```
+
+The catalogue is an instance made with the app's ICU formatter. A form's checks
+read it through `apiCodeResolver`, and the provider fills it from the root's data:
+
+```ts
+import {
+	ApiMessagesProvider,
+	apiCodeResolver,
+	createApiMessages,
+} from '@alxia/react-router/errors';
+
+type Language = 'en' | 'fr';
+
+export const apiMessages = createApiMessages<Language>({
+	format: (message) => message, // the app's ICU formatter goes here
+});
+
+export const resolver = apiCodeResolver(apiMessages, {
+	translate: (key) => key,
+	language: () => 'en',
+});
+
+// In the root: <ApiMessagesProvider messages={apiMessages} value={data.catalogue}>…
+export const provider = ApiMessagesProvider({
+	messages: apiMessages,
+	value: { en: {}, fr: {} },
+	children: null,
+});
+```
+
+A failed call is worded in the page's language by `createApiErrors`:
+
+```ts
+import { createApiErrors } from '@alxia/react-router/errors';
+import { apiMessages } from './api-messages';
+
+export const apiErrors = createApiErrors<'en' | 'fr'>({
+	messages: apiMessages,
+	unavailable: (language) => (language === 'en' ? 'Unavailable' : 'Indisponible'),
+});
+
+// In an action's catch: { message, status }, or undefined (rethrow it).
+export const refusal = (error: unknown) => apiErrors.apiRefusal(error, 'en');
+```
+
+A loader throws the API's error as a route error, with the call's request id
+for the error page; an action answers a refusal as data:
+
+```ts
+import { errorRequestId, routeError } from '@alxia/react-router/errors';
+import { apiErrors } from './api-errors';
+
+// In a loader's catch: a 401, 403, 404 or 503 ApiError becomes a route error.
+export const thrown = (error: unknown) => routeError(error);
+
+// In the root's ErrorBoundary: the reference the user can quote.
+export const reference = (error: unknown) => errorRequestId(error);
+
+// A fetcher's action: { ok: true, …value }, or { ok: false, error } with a status.
+export const rename = (run: () => Promise<{ title: string }>) =>
+	apiErrors.fetcherResult('en', { intent: 'rename' }, run);
+
+// A form's action: { ok: true, value }, or the form's errors with a status.
+export const create = (run: () => Promise<{ id: string }>) =>
+	apiErrors.submitForm('en', run, (path) =>
+		path === 'todo.title' ? 'title' : undefined,
+	);
+```
+
+JSON actions refuse a post from another site, and read a Standard Schema's input:
+
+```ts
+import { jsonActions, useJsonFetcher } from '@alxia/react-router/errors';
+import { z } from 'zod';
+
+// Behind a TLS proxy named with createServer({ proxy }), nothing to set; else: origin: () => process.env.APP_ORIGIN
+export const { readInput } = jsonActions();
+
+const schema = z.object({ title: z.string().min(1) });
+
+export async function action({ request }: { request: Request }) {
+	return readInput(request, schema); // 400 when the input is refused
+}
+
+// In the component: const { post, busy } = useJsonFetcher<typeof action>();
+```
+
+A call that failed is turned into what a loader throws, and logged with the API's request id, by `apiCallFailure(error, { api, operation: operationName(document), requestId })`
+(your own `execute` calls it in its `catch`):
+
+```ts
+import { apiCallFailure, operationName } from '@alxia/react-router/errors';
+import type { DocumentNode } from 'graphql';
+
+export function failed(error: unknown, document: DocumentNode, requestId?: string, signal?: AbortSignal) {
+	return apiCallFailure(error, { api: 'my-api', operation: operationName(document), requestId, signal });
+}
+// In execute(): catch (error) { throw failed(error, document, requestId, signal); }
+```
+
+The API's catalogue is read and kept fresh by `createErrorCatalogue`; the root's
+middleware awaits `freshAll()`, its loader returns `clientMessages()` and
+`server.ts` calls `warm()`:
+
+```ts
+import { createErrorCatalogue } from '@alxia/react-router/errors';
+import { apiMessages } from './api-messages';
+
+export const catalogue = createErrorCatalogue<'en' | 'fr'>({
+	messages: apiMessages,
+	languages: ['en', 'fr'],
+	read: async (language) => fetchCatalogue(language), // { version, messages }
+	versions: async () => fetchVersions(), // { en: '…', fr: '…' }
+	ttlMs: () => Number(process.env.CATALOGUE_TTL_MS ?? 60_000),
+	clientCodes: ['validation.errors.required'],
+});
+
+declare function fetchCatalogue(
+	language: string,
+): Promise<{ version: string; messages: { code: string; message: string; params: { name: string; kind: 'TEXT' }[] }[] }>;
+declare function fetchVersions(): Promise<{ en: string; fr: string }>;
+
+// The root's middleware: await catalogue.freshAll();
+// The root's loader: return { messages: catalogue.clientMessages() };
+// server.ts, at startup: catalogue.warm();
+```
+
+The [errors guide](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/errors.md)
+has the rest.
+
 ## Traps
 
 - **A context key made in `app/` reaches the loaders only through the
@@ -736,6 +1040,50 @@ From `@alxia/react-router/pwa/build` (Bun; Node's built-ins its only imports):
 | `BuildWorkerOptions` | `file` (required), `root`, `client`, `contract`, `offline`, `precacheAssets`, `minify` |
 | `WorkerBuild` | `{ file, precache, precacheBytes, bytes }` |
 
+From `@alxia/react-router/errors` (`react-router` is its only package import, and never `@alxia/core`):
+
+| export | |
+| --- | --- |
+| `isApiErrorLike(error)` | whether `error` is an `@nxgt/graphql-client` `ApiError`, like the client's `isApiError`, plus a numeric `status`, which `ApiErrorLike` promises; it holds across two copies of the client |
+| `ApiErrorLike`, `ApiErrorEntryLike`, `ApiErrorExtensionsLike`, `ApiErrorParamsLike`, `ApiFieldErrorLike` | the shape of the refusal: `errors`, `code`, `status`, `requestId?`, and each error's `extensions` (`code`, `params`, `fields`, `field`, `minutes`, `retryAfter`) |
+| `waitMinutes(extensions)` | the minutes of a throttle's wait: `minutes` (at least one), else `retryAfter` rounded up |
+| `REQUEST_ID_HEADER`, `requestIdOf(response)` | `x-request-id`, and the id a response carries, if the API sent one |
+| `nextOf(url)` | the path and search of the page a request is for, without React Router's `.data`, `/_.data`, `_routes` and empty `index`; it never starts with two slashes, but an app still validates `next` before redirecting to it |
+| `FormErrors` | what a form action answers when the API refused the input: `fieldErrors` by field and a `formError` (`undefined` when every message sits under a field), already translated; `submitForm` answers it |
+| `routeError(error, { statuses? }?)`, `RouteErrorOptions` | what a loader throws for the API's error: an `ApiError` of 401, 403, 404 or 503, or such a `Response` carrying a request id, becomes a route error of that status with the `code`, `message` and `requestId`; any other `ApiError` with an id becomes a 500 carrying the id; anything else is returned as it is |
+| `errorRequestId(error)`, `RouteErrorData` | the support reference an error page shows: the `requestId` a route error carries, else `undefined`; `RouteErrorData` is the data `routeError` carries (`code?`, `message?`, `requestId?`) |
+| `createApiMessages({ format })`, `ApiMessages`, `ApiMessagesOptions` | the catalogue store of an app, an instance (`set`, `add`, `clear` (for tests), `messageOf`, `format`, `apiMessage(code, values, language)`); `format` is the app's ICU formatter, such as `@nxgt/material`'s `formatMessage` |
+| `CatalogueMessage`, `CatalogueMessages`, `ParamKind`, `MessageFormat`, `MessageValues` | one API message with the kind of each argument (`TEXT`, `NUMBER`, `DATE`, `PLURAL`, `SELECT`), a language's messages by code, and the formatter's type |
+| `apiCodeResolver(messages, { translate, language, codeOf?, isApiCode? })`, `ApiCodeResolver`, `ApiCodeResolverOptions`, `CodeIssueLike` | the `{ translate, codeOf }` a form's `useCodeResolver(schema, resolver)` takes: a check's API code is worded as the API words it, any other key by the app's translator; `CodeIssueLike` is the issue a custom `codeOf` receives |
+| `ApiMessagesProvider({ messages, value, children })`, `ApiMessagesProviderProps` | `messages` is the store and `value` the root loader's data; fills the store in the browser from the root's data before the children render; a server render writes nothing. A function with no JSX, so no React import |
+| `createApiErrors({ messages, unavailable, refused?, byCode?, isApiCode? })`, `ApiErrors`, `ApiErrorsOptions` | what a page says of a refusal, in a language: `apiErrorMessage(error, language)` (the catalogue's text of the code, else the API's message; `refused` replaces it for an error with no API code and `byCode` words given codes, such as a query's limits), `fieldErrors(error, language)` by input path, `translateCode(code, fallback, language, values?)`, `unavailableMessage(language)` and `apiRefusal(error, language)`; for an action, `fetcherResult(language, about, run, route?)` (`{ ok: true, …about, …value }`, or `{ ok: false, …about, error }` with the refusal's status), `fetcherRefusal(error, language, route?)` (the refusal, or the thrown route error) and `submitForm(language, run, fieldOf, route?)` (`{ ok: true, value }`, or a `FormErrors` with the refusal's status); `route` is the `RouteErrorOptions` of the `routeError` they throw through |
+| `apiCallFailure(error, { api, operation?, requestId?, signal?, passedThrough?, log? })`, `CallFailureOptions` | what a failed call to the API becomes, for a loader or an action to throw, logged with the request id: an `ApiError` as it is (with `requestId`), a `Response` of its own status for a 401, 403 or 404 without a GraphQL body, a 503 `Response` with no body for an unreachable, slow, garbled or aborted call (the reason is in the log), any other error as it is; the log lines start with `api`, and a `log` that throws never replaces the outcome. It recognises `@nxgt/graphql-client`'s errors by `name`, not `instanceof` |
+| `operationName(document)`, `DocumentLike` | the name of the operation a document holds, for the log (else `query`, `mutation` or `subscription`); a structural `{ definitions }`, so `graphql`'s `DocumentNode` fits |
+| `createErrorCatalogue({ messages, languages, read, versions, ttlMs, clientCodes, retryMs?, firstReadWaitMs?, log? })`, `ErrorCatalogue`, `ErrorCatalogueOptions`, `CatalogueReply` | keeps the API's error catalogue in the store: `fresh(language, now?)` and `freshAll(now?)` (a cold language is awaited for `firstReadWaitMs`, 1500 by default, and read once however many requests ask; a held one is served, and its version checked in the background once per `ttlMs`, a number or a getter; only a language whose version moved is read again; a failure is retried after `retryMs`, 5000 by default), `warm()` for startup, `clientMessages()` (the `clientCodes` the browser words itself, by language, for the root's loader), and, for tests, `reset()`, `heldVersion(language)`, `settled()` and the `now` parameters. `read` and `versions` are the app's calls to its API |
+| `ApiRefusal` | `{ message, status }`: a failed call as a page says it; what `apiRefusal` returns for an API refusal (its status) or an unreachable API (503), else `undefined` |
+| `jsonActions({ origin? })`, `JsonActions`, `JsonActionsOptions` | the JSON helpers of the actions, bound to the app's origin (a string, or a getter read at each request; the request's own by default): `readJson(request)` (403 `Cross-site request refused` for another origin or a cross-site fetch, 415 `Expected a JSON body`, 400 `Malformed JSON body`), `requireJsonPost(request)` (a native post goes back to its page) and `readInput(request, schema)` (the body's `input` through a Standard Schema, async allowed; 400 `The form sent an input the API would refuse`) |
+| `useJsonFetcher(key?, action?)`, `JsonBody` | a fetcher that posts JSON: `{ fetcher, post(body, to?), busy }`; `to` is the action of one call |
+| `StandardSchemaV1` | the Standard Schema v1 type `readInput` takes, declared in `/errors` (type only, so no `@alxia/core`; `readInput`'s output is inferred from the schema's `~standard.types`); a Zod 4, Valibot or ArkType schema fits |
+
+From `@alxia/react-router/document`:
+
+| export | |
+| --- | --- |
+| `DocumentNonce({ nonce, children })`, `DocumentNonceProps` | the provider of this response's CSP nonce, for the server render: wrap the router with `nonceOf(loadContext)` in `entry.server.tsx` |
+| `useNonce()` | the page's CSP nonce: the provider's on the server, the first script or `csp-nonce` meta of the `<head>`'s (else the first `script[nonce]`'s) in the browser (read once and cached), `undefined` when there is none |
+| `InlineScript({ code, nonce? })`, `InlineScriptProps` | an inline `<script>` with `nonce ?? useNonce()`; the code is not escaped, so it is a constant of yours, and `</script` or `<!--` in it throws a `TypeError`; no `nonce` attribute when there is no nonce |
+| `CspNonceMeta()` | `<meta property="csp-nonce" nonce>`, the nonce for what a UI library adds at runtime |
+| `createPageLanguage({ languages, fallback, browser? })` | `PageLanguage`: `pageLanguage`, `metaLanguage`, `chooseLanguage`, `useChosenLanguage`, for `<html lang>`, a route's `meta` and a language menu |
+| `PageLanguage`, `PageLanguageOptions` | the types of the instance and of its options |
+| `textDirection(language)` | `'ltr'` or `'rtl'` for `<html dir>`, from the base language |
+
+From `@alxia/react-router/entry`:
+
+| export | |
+| --- | --- |
+| `createEntry({ streamTimeout?, nonce?, isBot?, onError? })`, `EntryOptions`, `Entry` | `/entry`: `{ handleRequest, streamTimeout }` (`Entry`), `entry.server.tsx` for Bun on the web stream renderer |
+| `handleRequest`, `streamTimeout`, `HandleRequest` | `/entry`: the default entry (`createEntry()`), its `5_000` and the type of `handleRequest` (assignable to React Router's `ServerEntryModule['default']`) |
+
 The `alxia-react-router` bin, run with `bunx`:
 
 | command | |
@@ -748,9 +1096,11 @@ The `alxia-react-router` bin, run with `bunx`:
 - [Getting started](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/getting-started.md): a new app, the official template or an existing app.
 - [How it works](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/how-it-works.md): dev, the build and `vite preview`, and what the build sets for Bun.
 - [Customising the server](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/customising-the-server.md): `createServer()`, and the escape hatches.
+- [The document](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/document.md): the CSP nonce in the root, `InlineScript` for a theme's boot script with no flash, `CspNonceMeta`, and the entry.
 - [Typing the loaders](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/typing-the-loaders.md): `Register`, and the app's own context keys.
 - [A CSP nonce](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/csp-nonce.md), [Beside the pages](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/beside-the-pages.md) (middlewares, routes, WebSockets, the client's files), [OpenAPI](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/openapi.md), [Testing](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/testing.md) and [Deploying](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/deploying.md), with Docker.
 - [Installable and offline](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/pwa.md): what the subpaths hold, the worker's contract, the worker, what it caches, the offline page, building the worker with `alxia()` or `buildWorker`, the hooks in React, registering the worker and offering an update, serving the worker's script, the web app manifest, and clearing at sign-out.
+- [An API's refusals](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/guide/errors.md): what `/errors` holds, recognising an API error, the request id, the page a request is for, the catalogue store, the form checks in the API's words, the provider, wording a refusal, loaders and the error page, actions, JSON actions and CSRF, and keeping the catalogue fresh.
 - [Troubleshooting](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/troubleshooting.md): each message, and the traps that print none.
 - [Roadmap](https://github.com/softistx/alxia/blob/develop/packages/react-router/docs/roadmap.md): what is coming, and what is not planned.
 - [Example](https://github.com/softistx/alxia/tree/develop/examples/react-router): the official template, these four changes, then an `app/server.ts` with a session, an `/api`, secure headers with a nonce and a streamed page.

package/dist/chunks/index-5rt6hnhn.js

@@ -0,0 +1,42 @@
+// src/context.ts
+import { createContext, RouterContextProvider } from "react-router";
+function singleton(name, make) {
+  const registry = globalThis;
+  const key = Symbol.for(`@alxia/react-router:${name}@1`);
+  registry[key] ??= make();
+  return registry[key];
+}
+var shared = singleton("context", () => {
+  const missing = Symbol("alxia context missing");
+  return { missing, context: createContext(missing) };
+});
+var MISSING = shared.missing;
+var alxiaContext2 = shared.context;
+function alxiaOf2(context) {
+  const value = context.get(alxiaContext2);
+  if (value === MISSING) {
+    throw new Error("alxiaOf(): this request has no alxia context. Serve the React Router app through alxia: add alxia() from @alxia/react-router/vite to vite.config.ts's plugins, or, with a server of your own, serve the build through reactRouter() from @alxia/react-router.");
+  }
+  return value;
+}
+Object.defineProperty(RouterContextProvider.prototype, "alxia", {
+  configurable: true,
+  enumerable: false,
+  get() {
+    return alxiaOf2(this);
+  }
+});
+
+// src/nonce.ts
+function nonceOf2(context) {
+  const value = context.get(alxiaContext2);
+  if (typeof value !== "object" || value === null || !("nonce" in value)) {
+    return;
+  }
+  return typeof value.nonce === "string" ? value.nonce : undefined;
+}
+
+export { alxiaContext2, alxiaOf2, nonceOf2 };
+
+//# debugId=BC95EB0B0221673364756E2164756E21
+//# sourceMappingURL=index-5rt6hnhn.js.map

package/dist/chunks/index-5rt6hnhn.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/context.ts", "../src/nonce.ts"],
+  "sourcesContent": [
+    "/**\n * The key under which `reactRouter()` hands every loader, action and\n * middleware the request's alxia context, and the typed way to read it.\n */\nimport type { Alxia, AnyAlxia, ContextOf, RegisteredBase } from '@alxia/core';\nimport { createContext, RouterContextProvider } from 'react-router';\nimport type { ReactRouterServer } from './server';\n\n/**\n * One value per process, whichever copy of this module asks: the server\n * build bundles `/entry` and the chunk it shares with `.` (see\n * `vite/inline.ts`), and the server imports `.` outside the bundle.\n *\n * The key is shared across versions of this package. Its name ends in a\n * shape version (`@1`): a version that changes what is stored under it bumps\n * the suffix, so two copies of different shapes never read each other's.\n */\nfunction singleton<T>(name: string, make: () => T): T {\n\tconst registry = globalThis as Record<symbol, unknown>;\n\tconst key = Symbol.for(`@alxia/react-router:${name}@1`);\n\tregistry[key] ??= make();\n\treturn registry[key] as T;\n}\n\n/**\n * The key `reactRouter()` sets on React Router's context provider, on every\n * request, to what alxia's middlewares built for it, and its default, the\n * \"missing\" sentinel no catch-all replaced. Both are one pair per process,\n * so that a second copy's `alxiaOf` compares with the sentinel the key holds.\n * It lives in this package, so it is one object whichever way the server was\n * built or loaded: a key made in the app's own `app/` folder is copied into\n * React Router's build, and the server that imports it separately sets a\n * different one.\n */\nconst shared = singleton('context', () => {\n\t// `as never` gives the `unique symbol` type without a `declare const`.\n\tconst missing: unique symbol = Symbol('alxia context missing') as never;\n\treturn { missing, context: createContext<unknown>(missing) };\n});\nconst MISSING = shared.missing;\nexport const alxiaContext = shared.context;\n\n/**\n * Names the server whose context `alxiaOf(context)` reads when given no\n * type argument. One React Router build has one server, so it may be\n * declared once, beside it:\n *\n * ```ts\n * // app/server.ts\n * const server = createServer({ configure: (app) => app.use(session) });\n * export default server;\n *\n * declare module '@alxia/react-router' {\n *   interface Register {\n *     server: typeof server;\n *   }\n * }\n * ```\n *\n * Unregistered here, `alxiaOf(context)` reads the app `@alxia/core`'s own\n * `Register` names as its `context`, and `BaseContext` when neither is\n * declared. When both are, this one wins: the server's app is the whole\n * app the pages run behind, the base's context and all `configure` adds.\n */\n// biome-ignore lint/suspicious/noEmptyInterface: an app augments it\nexport interface Register {}\n\n/** The app a server makes, or the app itself. */\nexport type AppOf<Server> =\n\tServer extends ReactRouterServer<infer App> ? App : Server;\n\n/**\n * What `Register` names when it is neither a server nor an app — the\n * module, say, rather than its default export: an app whose context has\n * nothing but this key, so that reading anything of it is a compile error.\n */\nexport type InvalidRegister = Alxia<\n\t{\n\t\treadonly 'Register.server must be typeof server, the default export of createServer()': never;\n\t},\n\t''\n>;\n\n/**\n * The app `alxiaOf` reads for a `Register` interface: its server's, or\n * `InvalidRegister`; with no server, `Core`, the app `@alxia/core`'s\n * `Register` names (a fresh one when it names none).\n */\nexport type RegisteredOf<\n\tR,\n\tCore extends AnyAlxia = RegisteredBase,\n> = R extends {\n\treadonly server: infer Server;\n}\n\t? Server extends AnyAlxia | ReactRouterServer<AnyAlxia>\n\t\t? AppOf<Server>\n\t\t: InvalidRegister\n\t: Core;\n\n/** What `alxiaOf` reads with no type argument: the registered server's app, else core's registered app, else a fresh one. */\nexport type RegisteredApp = RegisteredOf<Register>;\n\n/**\n * What alxia's middlewares built for this request, read in a loader, an action or\n * a middleware, typed by the app: the server `Register` names, or the one\n * given as the type argument — `typeof server`, or an app *before* the\n * catch-all. With neither, the app `@alxia/core`'s `Register` names, and\n * `BaseContext` when nothing is registered.\n *\n * ```ts\n * export async function loader({ context }: Route.LoaderArgs) {\n *   const { user, log } = alxiaOf(context);\n * }\n * ```\n *\n * Throws when the request did not come through `reactRouter()`: under\n * `react-router dev` without the plugin, or a test that calls a loader\n * directly.\n */\nexport function alxiaOf<\n\tApp extends AnyAlxia | ReactRouterServer<AnyAlxia> = RegisteredApp,\n>(context: ProviderLike): AlxiaContextOf<App> {\n\tconst value = context.get(alxiaContext);\n\tif (value === MISSING) {\n\t\tthrow new Error(\n\t\t\t\"alxiaOf(): this request has no alxia context. Serve the React Router app through alxia: add alxia() from @alxia/react-router/vite to vite.config.ts's plugins, or, with a server of your own, serve the build through reactRouter() from @alxia/react-router.\",\n\t\t);\n\t}\n\treturn value as AlxiaContextOf<App>;\n}\n\n/**\n * What `alxiaOf` and `nonceOf` read of a provider: its `get`. Not the whole\n * class, which this package gives an `alxia`: the generated route types'\n * `context` is another declaration of it, without one, and must still pass.\n */\nexport type ProviderLike = Pick<Readonly<RouterContextProvider>, 'get'>;\n\n/** What `alxiaOf<App>(context)` returns, and `context.alxia` is for the registered app. */\nexport type AlxiaContextOf<\n\tApp extends AnyAlxia | ReactRouterServer<AnyAlxia> = RegisteredApp,\n> = ContextOf<AppOf<App>> & {\n\t/** The catch-all's route, which every request reaching React Router matched. */\n\treadonly route: string;\n};\n\ndeclare module 'react-router' {\n\tinterface RouterContextProvider {\n\t\t/**\n\t\t * What alxia's middlewares built for this request — `alxiaOf(context)`,\n\t\t * typed by the app `Register` names (`BaseContext` with none):\n\t\t *\n\t\t * ```ts\n\t\t * export async function loader({ context }: LoaderFunctionArgs) {\n\t\t *   const { user, server } = context.alxia;\n\t\t * }\n\t\t * ```\n\t\t *\n\t\t * Typed with `react-router`'s own argument types. The generated\n\t\t * `Route.LoaderArgs` reads a second declaration of this class (its\n\t\t * `./internal` types point at react-router's development build), which\n\t\t * no augmentation reaches: read `alxiaOf(context)` there. Throws as\n\t\t * `alxiaOf` does on a request that did not come through\n\t\t * `reactRouter()`. Server-side only: a `clientLoader` has none.\n\t\t */\n\t\treadonly alxia: AlxiaContextOf;\n\t}\n}\n\n// A getter on the prototype rather than a value set on each provider: it\n// reads `alxiaContext`, so it holds exactly when that key is set — a\n// provider React Router copies keeps it — and on a provider no\n// `reactRouter()` filled, a test's, it throws `alxiaOf`'s error rather than\n// reading `undefined`.\nObject.defineProperty(RouterContextProvider.prototype, 'alxia', {\n\tconfigurable: true,\n\tenumerable: false,\n\tget(this: Readonly<RouterContextProvider>) {\n\t\treturn alxiaOf(this);\n\t},\n});\n",
+    "/** `nonceOf`: the request's CSP nonce, read from alxia's context if a middleware set one. */\nimport { alxiaContext, type ProviderLike } from './context';\n\n/**\n * This request's CSP nonce, for `entry.server.tsx`: the `nonce` alxia's\n * middlewares put on the context — `secureHeaders({ nonce: true })` from\n * `@alxia/secure-headers`, or a `derive` of your own — or `undefined` when\n * none did, or when the request did not come through alxia. It reads the\n * key if present: neither package depends on the other.\n *\n * ```tsx\n * const nonce = nonceOf(loadContext);\n * <ServerRouter context={routerContext} url={request.url} nonce={nonce} />\n * ```\n */\nexport function nonceOf(context: ProviderLike): string | undefined {\n\tconst value = context.get(alxiaContext);\n\tif (typeof value !== 'object' || value === null || !('nonce' in value)) {\n\t\treturn undefined;\n\t}\n\treturn typeof value.nonce === 'string' ? value.nonce : undefined;\n}\n"
+  ],
+  "mappings": ";AAKA;AAYA,SAAS,SAAY,CAAC,MAAc,MAAkB;AAAA,EACrD,MAAM,WAAW;AAAA,EACjB,MAAM,MAAM,OAAO,IAAI,uBAAuB,QAAQ;AAAA,EACtD,SAAS,SAAS,KAAK;AAAA,EACvB,OAAO,SAAS;AAAA;AAajB,IAAM,SAAS,UAAU,WAAW,MAAM;AAAA,EAEzC,MAAM,UAAyB,OAAO,uBAAuB;AAAA,EAC7D,OAAO,EAAE,SAAS,SAAS,cAAuB,OAAO,EAAE;AAAA,CAC3D;AACD,IAAM,UAAU,OAAO;AAChB,IAAM,gBAAe,OAAO;AA+E5B,SAAS,QAEf,CAAC,SAA4C;AAAA,EAC7C,MAAM,QAAQ,QAAQ,IAAI,aAAY;AAAA,EACtC,IAAI,UAAU,SAAS;AAAA,IACtB,MAAM,IAAI,MACT,+PACD;AAAA,EACD;AAAA,EACA,OAAO;AAAA;AA8CR,OAAO,eAAe,sBAAsB,WAAW,SAAS;AAAA,EAC/D,cAAc;AAAA,EACd,YAAY;AAAA,EACZ,GAAG,GAAwC;AAAA,IAC1C,OAAO,SAAQ,IAAI;AAAA;AAErB,CAAC;;;ACrKM,SAAS,QAAO,CAAC,SAA2C;AAAA,EAClE,MAAM,QAAQ,QAAQ,IAAI,aAAY;AAAA,EACtC,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,EAAE,WAAW,QAAQ;AAAA,IACvE;AAAA,EACD;AAAA,EACA,OAAO,OAAO,MAAM,UAAU,WAAW,MAAM,QAAQ;AAAA;",
+  "debugId": "BC95EB0B0221673364756E2164756E21",
+  "names": []
+}

package/dist/chunks/{index-mppz0806.js → index-6jf7zpxz.js}

@@ -1,11 +1,11 @@
+import {
+  PRECACHE_DEFINE
+} from "./index-59vhfj6n.js";
 import {
   parseBrowserManifest2,
   precacheList2,
   assetPrecache2
 } from "./index-5gqcpyyg.js";
-import {
-  PRECACHE_DEFINE
-} from "./index-59vhfj6n.js";
 import {
   SERVICE_WORKER_URL2,
   OFFLINE_URL2
@@ -115,5 +115,5 @@ ${result.logs.map(String).join(`
 }
 export { buildWorker2 };
 
-//# debugId=763F0D0F0869B4B964756E2164756E21
-//# sourceMappingURL=index-mppz0806.js.map
+//# debugId=705C996D7C991BF164756E2164756E21
+//# sourceMappingURL=index-6jf7zpxz.js.map

package/dist/chunks/{index-mppz0806.js.map → index-6jf7zpxz.js.map}

@@ -6,6 +6,6 @@
     "import { createHash } from 'node:crypto';\nimport {\n\tassetPrecache,\n\ttype PrecacheEntry,\n\tparseBrowserManifest,\n\tprecacheList,\n} from '../model/precache-list';\n\n/** The one React Router browser manifest among the names in build/client/assets. */\nexport function browserManifestFile(files: readonly string[]): string {\n\tconst found = files.filter((file) => /^manifest-[\\w-]+\\.js$/.test(file));\n\tconst [only] = found;\n\tif (found.length !== 1 || only === undefined) {\n\t\tthrow new Error(\n\t\t\t`buildWorker(): expected one React Router browser manifest, build/client/assets/manifest-*.js, found ${found.length}. Run react-router build first.`,\n\t\t);\n\t}\n\treturn only;\n}\n\n/** A file's revision: the first 16 hex characters of its sha256. */\nexport function revisionOf(bytes: Uint8Array): string {\n\treturn createHash('sha256').update(bytes).digest('hex').slice(0, 16);\n}\n\n/**\n * The worker's precache list: the offline page (revisioned by its content),\n * every route's code, then the asset files `include` matches. Each URL once,\n * the first kept.\n */\nexport function workerPrecache(input: {\n\tmanifestSource: string;\n\tassetFiles: readonly string[];\n\toffline?: PrecacheEntry | undefined;\n\tinclude?: RegExp | undefined;\n}): PrecacheEntry[] {\n\tconst all = [\n\t\t...(input.offline ? [input.offline] : []),\n\t\t...precacheList(parseBrowserManifest(input.manifestSource)),\n\t\t...(input.include ? assetPrecache(input.assetFiles, input.include) : []),\n\t];\n\tconst seen = new Set<string>();\n\treturn all.filter(({ url }) => !seen.has(url) && seen.add(url));\n}\n"
   ],
   "mappings": ";;;;;;;;;;;;;;AAAA;AACA;AACA;;;ACFA;AASO,SAAS,mBAAmB,CAAC,OAAkC;AAAA,EACrE,MAAM,QAAQ,MAAM,OAAO,CAAC,SAAS,wBAAwB,KAAK,IAAI,CAAC;AAAA,EACvE,OAAO,QAAQ;AAAA,EACf,IAAI,MAAM,WAAW,KAAK,SAAS,WAAW;AAAA,IAC7C,MAAM,IAAI,MACT,uGAAuG,MAAM,uCAC9G;AAAA,EACD;AAAA,EACA,OAAO;AAAA;AAID,SAAS,UAAU,CAAC,OAA2B;AAAA,EACrD,OAAO,WAAW,QAAQ,EAAE,OAAO,KAAK,EAAE,OAAO,KAAK,EAAE,MAAM,GAAG,EAAE;AAAA;AAQ7D,SAAS,cAAc,CAAC,OAKX;AAAA,EACnB,MAAM,MAAM;AAAA,IACX,GAAI,MAAM,UAAU,CAAC,MAAM,OAAO,IAAI,CAAC;AAAA,IACvC,GAAG,cAAa,sBAAqB,MAAM,cAAc,CAAC;AAAA,IAC1D,GAAI,MAAM,UAAU,eAAc,MAAM,YAAY,MAAM,OAAO,IAAI,CAAC;AAAA,EACvE;AAAA,EACA,MAAM,OAAO,IAAI;AAAA,EACjB,OAAO,IAAI,OAAO,GAAG,UAAU,CAAC,KAAK,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,CAAC;AAAA;;;ADCxD,SAAS,SAAS,CACxB,QAAS,WAAiC,QAAQ,WAC3C;AAAA,EACP,IAAI;AAAA,IAAO;AAAA,EACX,MAAM,IAAI,MACT,8GACD;AAAA;AAQD,SAAS,WAAW,CAAC,QAAgB,KAAqB;AAAA,EACzD,MAAM,OAAO,KAAK,QAAQ,GAAG;AAAA,EAC7B,IACC,CAAC,IAAI,WAAW,GAAG,KACnB,6BAA6B,KAAK,GAAG,KACrC,CAAC,KAAK,WAAW,SAAS,GAAG,KAC7B,KAAK,SAAS,GAAG,GAChB;AAAA,IACD,MAAM,IAAI,MAAM,kBAAkB,kBAAkB,SAAS;AAAA,EAC9D;AAAA,EACA,OAAO;AAAA;AAUR,eAAsB,YAAW,CAChC,SACuB;AAAA,EACvB,UAAU;AAAA,EACV,MAAM,OAAO,QAAQ,QAAQ,QAAQ,QAAQ,IAAI,CAAC;AAAA,EAClD,MAAM,SAAS,QAAQ,MAAM,QAAQ,UAAU,cAAc;AAAA,EAC7D,MAAM,SAAS,QAAQ,MAAM,QAAQ,IAAI;AAAA,EACzC,MAAM,YAAY,QAAQ,UAAU,oBAAoB;AAAA,EACxD,MAAM,aAAa,QAAQ,UAAU,cAAc;AAAA,EACnD,IAAI,CAAC,WAAW,MAAM,GAAG;AAAA,IACxB,MAAM,IAAI,MAAM,kBAAkB,QAAQ,sBAAsB;AAAA,EACjE;AAAA,EACA,MAAM,SAAS,KAAK,QAAQ,QAAQ;AAAA,EACpC,MAAM,QAAQ,MAAM,QAAQ,MAAM,EAAE,MAAM,MAAM,CAAC,CAAC;AAAA,EAClD,MAAM,WAAW,oBAAoB,KAAK;AAAA,EAC1C,IAAI;AAAA,EACJ,IAAI,QAAQ,YAAY,OAAO;AAAA,IAC9B,MAAM,OAAO,YAAY,QAAQ,UAAU;AAAA,IAC3C,IAAI,CAAC,WAAW,IAAI,GAAG;AAAA,MACtB,MAAM,IAAI,MACT,kBAAkB,QAAQ,UAAU,iBAAiB,wCAAwC,mJAC9F;AAAA,IACD;AAAA,IACA,UAAU,EAAE,KAAK,YAAY,UAAU,WAAW,MAAM,SAAS,IAAI,CAAC,EAAE;AAAA,EACzE;AAAA,EACA,MAAM,WAAW,eAAe;AAAA,IAC/B,gBAAgB,MAAM,SAAS,KAAK,QAAQ,QAAQ,GAAG,MAAM;AAAA,IAC7D,YAAY;AAAA,IACZ;AAAA,IACA,SAAS,QAAQ;AAAA,EAClB,CAAC;AAAA,EACD,MAAM,MAAM,YAAY,QAAQ,SAAS;AAAA,EACzC,MAAM,SAAS,MAAM,IAAI,MAAM;AAAA,IAC9B,aAAa,CAAC,MAAM;AAAA,IACpB,QAAQ,QAAQ,GAAG;AAAA,IACnB,QAAQ,SAAS,GAAG;AAAA,IACpB,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,QAAQ,QAAQ,UAAU;AAAA,IAC1B,QAAQ;AAAA,MAEP,wBAAwB;AAAA,OACvB,kBAAkB,KAAK,UAAU,QAAQ;AAAA,IAC3C;AAAA,EACD,CAAC,EAAE,MAAM,CAAC,UAAmB;AAAA,IAC5B,MAAM,SACL,iBAAiB,iBACd,MAAM,OAAO,IAAI,MAAM,EAAE,KAAK;AAAA,CAAI,IAClC,OAAO,KAAK;AAAA,IAChB,MAAM,IAAI,MAAM;AAAA,EAAqC,QAAQ;AAAA,GAC7D;AAAA,EACD,IAAI,CAAC,OAAO,SAAS;AAAA,IACpB,MAAM,IAAI,MACT;AAAA,EAAqC,OAAO,KAAK,IAAI,MAAM,EAAE,KAAK;AAAA,CAAI,GACvE;AAAA,EACD;AAAA,EACA,IAAI,gBAAgB;AAAA,EACpB,aAAa,SAAS,UAAU;AAAA,IAC/B,kBAAkB,MAAM,KAAK,KAAK,QAAQ,GAAG,CAAC,GAAG;AAAA,EAClD;AAAA,EACA,OAAO;AAAA,IACN,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA,QAAQ,MAAM,KAAK,GAAG,GAAG;AAAA,EAC1B;AAAA;",
-  "debugId": "763F0D0F0869B4B964756E2164756E21",
+  "debugId": "705C996D7C991BF164756E2164756E21",
   "names": []
 }