@llui/vike 0.0.15 → 0.0.17

package/README.md

@@ -57,6 +57,168 @@ export const onRenderClient = createOnRenderClient({
 })
 ```
 
+### Persistent Layouts
+
+Declare app chrome (header, sidebar, dialogs, session state) as a `Layout` component that stays mounted across client navigation. The route-scoped `Page` swaps in and out at the layout's `pageSlot()` position while the surrounding layout subtree — and every DOM node, focus trap, portal, and effect subscription inside it — is untouched.
+
+> **Do not name your layout file `+Layout.ts`.** Vike reserves the `+` prefix for its own framework-adapter config conventions, and `+Layout.ts` specifically is interpreted by `vike-react` / `vike-vue` / `vike-solid` as a framework-native layout config. `@llui/vike` isn't a framework adapter in that sense — it's a render adapter, and `createOnRenderClient({ Layout })` consumes the layout component directly. Name your file `Layout.ts`, `app-layout.ts`, or place it anywhere outside `/pages` that Vike won't scan, then import it from `+onRenderClient.ts` / `+onRenderHtml.ts` by path.
+
+```ts
+// pages/Layout.ts    ← not +Layout.ts
+import { component, div, header, main } from '@llui/dom'
+import { pageSlot } from '@llui/vike/client'
+
+export const AppLayout = component<LayoutState, LayoutMsg>({
+  name: 'AppLayout',
+  init: () => [{ session: null }, []],
+  update: layoutUpdate,
+  view: ({ send }) => [
+    div({ class: 'app-shell' }, [
+      header([
+        /* persistent chrome */
+      ]),
+      main([pageSlot()]), // ← where the route's Page renders
+    ]),
+  ],
+})
+```
+
+```ts
+// pages/+onRenderClient.ts
+import { createOnRenderClient } from '@llui/vike/client'
+import { AppLayout } from './Layout'
+
+export const onRenderClient = createOnRenderClient({
+  Layout: AppLayout,
+})
+```
+
+```ts
+// pages/+onRenderHtml.ts — server renders layout + page as one tree
+import { createOnRenderHtml } from '@llui/vike/server'
+import { AppLayout } from './Layout'
+
+export const onRenderHtml = createOnRenderHtml({
+  Layout: AppLayout,
+})
+```
+
+Call `pageSlot()` exactly once in each layout's view, at the position where nested content should render. It's an ordinary structural primitive — composes naturally inside `show()`, `branch()`, `provide()`, and any other view tree.
+
+#### Nested layouts
+
+Pass an array to stack layouts outer-to-inner. Each layout except the innermost calls its own `pageSlot()`. The innermost layer is always the route's `Page`.
+
+```ts
+createOnRenderClient({
+  Layout: [AppLayout, DashboardLayout],
+})
+```
+
+For per-route chains — e.g. `/dashboard/*` routes use `[AppLayout, DashboardLayout]` while `/settings` uses `[AppLayout]` — pass a resolver function instead:
+
+```ts
+createOnRenderClient({
+  Layout: (pageContext) =>
+    pageContext.urlPathname.startsWith('/dashboard') ? [AppLayout, DashboardLayout] : [AppLayout],
+})
+```
+
+The chain diff on each nav walks old and new chains in parallel and finds the first mismatch. Every layer before that mismatch stays mounted; every layer at or after it is torn down innermost-first and re-mounted outermost-first. Navigating from `/dashboard/reports` to `/dashboard/overview` only disposes the `Page` — `AppLayout` and `DashboardLayout` stay alive. Navigating to `/settings` disposes `DashboardLayout` and the `Page`, keeping only `AppLayout`.
+
+#### Layout ↔ Page communication
+
+Layouts and pages are independent component instances with their own state, update, and `send`. They share state and expose cross-cutting operations via **context**, not via direct messaging.
+
+The scope-tree integration makes this natural: `pageSlot()` creates its slot as a child of the layout's render scope, and the page's `rootScope` is parented inside that slot. `useContext` from within the page walks up through the slot and finds any providers the layout installed above it.
+
+Common pattern — a layout-owned toast system:
+
+```ts
+// pages/Layout.ts
+import { component, div, main, provide, createContext } from '@llui/dom'
+import { pageSlot } from '@llui/vike/client'
+
+interface ToastDispatchers {
+  show: (msg: string) => void
+  dismiss: (id: string) => void
+}
+export const ToastContext = createContext<ToastDispatchers>(undefined, 'Toast')
+
+// Note: import { provideValue, useContextValue } from '@llui/dom' for
+// the stable-dispatcher pattern below — they're the static-bag
+// companions to the reactive provide / useContext primitives.
+
+export const AppLayout = component<LayoutState, LayoutMsg>({
+  name: 'AppLayout',
+  init: () => [{ toasts: [] }, []],
+  update: layoutUpdate,
+  view: ({ send }) => [
+    div({ class: 'app-shell' }, [
+      ToastStack(), // reads from layout state
+      ...provideValue(
+        ToastContext,
+        {
+          show: (msg) => send({ type: 'toast/show', msg }),
+          dismiss: (id) => send({ type: 'toast/dismiss', id }),
+        },
+        () => [main([pageSlot()])],
+      ),
+    ]),
+  ],
+})
+```
+
+```ts
+// Any page below the layout can now use the toast dispatcher.
+// pages/studio/+Page.ts
+import { component, button, text, useContextValue } from '@llui/dom'
+import { ToastContext } from '../Layout'
+
+export const StudioPage = component<StudioState, StudioMsg>({
+  name: 'StudioPage',
+  init: () => [{ saved: false }, []],
+  update: (s, m) => {
+    if (m.type === 'saveSucceeded') {
+      // ...
+    }
+    return [s, []]
+  },
+  view: ({ send }) => {
+    const toast = useContextValue(ToastContext)
+    return [button({ onClick: () => toast.show('Saved') }, [text('Save')])]
+  },
+})
+```
+
+`provideValue` and `useContextValue` are companions to the reactive `provide` / `useContext` for the common case of publishing a stable dispatcher bag — anything that doesn't depend on the parent's state. Use them for toast queues, session managers, breadcrumb dispatchers, and any other pattern where a page calls into layout-owned operations through a closure-captured `send`. The reactive `provide(ctx, accessor, children)` and `useContext(ctx)` forms still exist for context values that DO depend on state (e.g. `provide(ThemeContext, (s) => s.theme, () => [...])`).
+
+Toast state machines, global progress indicators, breadcrumb/title bars, modal-takeover chrome toggles, and session-expired banners all fall out of this pattern naturally — the layout owns the state, provides a dispatcher via context, and any page can trigger layout operations without touching the layout's internals.
+
+For the rarer case where a layout needs to **probe a page** (e.g. "is your form dirty? can we navigate away?"), use **addressed effects** — the page registers an address on mount, the layout dispatches a targeted effect to it.
+
+#### Layout data
+
+Layouts can have their own server-fetched data alongside per-page `+data.ts` by populating `pageContext.lluiLayoutData` as an array matching the layout chain (outermost first). Each layout's `init(layoutData)` receives its slice.
+
+Wire this from Vike's config mechanism however you like — the adapter just reads `pageContext.lluiLayoutData` when present.
+
+#### Hydration envelope
+
+With a `Layout` configured, `window.__LLUI_STATE__` is chain-aware:
+
+```js
+window.__LLUI_STATE__ = {
+  layouts: [
+    { name: 'AppLayout', state: { session: 'alice' } },
+    { name: 'DashboardLayout', state: { active: 'reports' } },
+  ],
+  page: { name: 'ReportsPage', state: { view: 'summary' } },
+}
+```
+
+The client matches each layer by component `name` when hydrating — server/client chain mismatches throw with a clear error instead of silently binding the wrong state to the wrong instance. Pages written against the pre-layout flat envelope shape continue to hydrate correctly when no `Layout` is configured.
+
 ### Page Transitions
 
 `createOnRenderClient` accepts `onLeave` and `onEnter` hooks that fire around the dispose-and-remount cycle on client navigation. `onLeave` is awaited — return a promise to defer the swap until a leave animation finishes:
@@ -110,12 +272,13 @@ Hydrates the server-rendered HTML on the client. Attaches event listeners and re
 
 ## API
 
-| Export                 | Sub-path            | Description                                                      |
-| ---------------------- | ------------------- | ---------------------------------------------------------------- |
-| `onRenderHtml`         | `@llui/vike/server` | Default server hook — minimal HTML template                      |
-| `createOnRenderHtml`   | `@llui/vike/server` | Factory for custom document templates                            |
-| `onRenderClient`       | `@llui/vike/client` | Default client hook — hydrate or mount                           |
-| `createOnRenderClient` | `@llui/vike/client` | Factory for custom container + `onLeave` / `onEnter` / `onMount` |
-| `fromTransition`       | `@llui/vike/client` | Adapter: `TransitionOptions` → `{ onLeave, onEnter }` hook pair  |
+| Export                 | Sub-path            | Description                                                     |
+| ---------------------- | ------------------- | --------------------------------------------------------------- |
+| `onRenderHtml`         | `@llui/vike/server` | Default server hook — minimal HTML template                     |
+| `createOnRenderHtml`   | `@llui/vike/server` | Factory for custom document templates + persistent layouts      |
+| `onRenderClient`       | `@llui/vike/client` | Default client hook — hydrate or mount                          |
+| `createOnRenderClient` | `@llui/vike/client` | Factory for custom container + layouts + transition hooks       |
+| `pageSlot`             | `@llui/vike/client` | Structural primitive — declares where a layout renders its page |
+| `fromTransition`       | `@llui/vike/client` | Adapter: `TransitionOptions` → `{ onLeave, onEnter }` hook pair |
 
 The barrel export (`@llui/vike`) re-exports everything, but prefer sub-path imports to avoid bundling jsdom into the client.

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { onRenderHtml, createOnRenderHtml } from './on-render-html.js';
-export type { PageContext, DocumentContext, RenderHtmlResult } from './on-render-html.js';
+export type { PageContext, DocumentContext, RenderHtmlResult, RenderHtmlOptions, } from './on-render-html.js';
 export { onRenderClient, createOnRenderClient, fromTransition } from './on-render-client.js';
 export type { ClientPageContext, RenderClientOptions } from './on-render-client.js';
+export { pageSlot } from './page-slot.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACtE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAEzF,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC5F,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACtE,YAAY,EACV,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC5F,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEnF,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/index.js

@@ -1,3 +1,4 @@
 export { onRenderHtml, createOnRenderHtml } from './on-render-html.js';
 export { onRenderClient, createOnRenderClient, fromTransition } from './on-render-client.js';
+export { pageSlot } from './page-slot.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAGtE,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA","sourcesContent":["export { onRenderHtml, createOnRenderHtml } from './on-render-html.js'\nexport type { PageContext, DocumentContext, RenderHtmlResult } from './on-render-html.js'\n\nexport { onRenderClient, createOnRenderClient, fromTransition } from './on-render-client.js'\nexport type { ClientPageContext, RenderClientOptions } from './on-render-client.js'\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAQtE,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAG5F,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA","sourcesContent":["export { onRenderHtml, createOnRenderHtml } from './on-render-html.js'\nexport type {\n  PageContext,\n  DocumentContext,\n  RenderHtmlResult,\n  RenderHtmlOptions,\n} from './on-render-html.js'\n\nexport { onRenderClient, createOnRenderClient, fromTransition } from './on-render-client.js'\nexport type { ClientPageContext, RenderClientOptions } from './on-render-client.js'\n\nexport { pageSlot } from './page-slot.js'\n"]}

package/dist/on-render-client.d.ts

@@ -1,124 +1,178 @@
-import type { ComponentDef, TransitionOptions } from '@llui/dom';
+import type { AnyComponentDef, TransitionOptions } from '@llui/dom';
+export { pageSlot } from './page-slot.js';
 declare global {
     interface Window {
         __LLUI_STATE__?: unknown;
     }
 }
+/**
+ * Page context shape as seen by `@llui/vike`'s client-side hooks. The
+ * `Page` and `data` fields come from whichever `+Page.ts` and `+data.ts`
+ * Vike resolved for the current route.
+ *
+ * `lluiLayoutData` is optional and carries per-layer data for the layout
+ * chain configured via `createOnRenderClient({ Layout })`. It's indexed
+ * outermost-to-innermost, one entry per layout layer. Absent entries
+ * mean the corresponding layout's `init()` receives `undefined`. Users
+ * wire this from their Vike `+data.ts` files by merging layout-owned
+ * data under the `lluiLayoutData` key.
+ */
 export interface ClientPageContext {
-    Page: ComponentDef<unknown, unknown, unknown, unknown>;
+    Page: AnyComponentDef;
     data?: unknown;
+    lluiLayoutData?: readonly unknown[];
     isHydration?: boolean;
 }
+type LayoutChain = ReadonlyArray<AnyComponentDef>;
 /**
- * Page-lifecycle hooks that fire around the dispose → clear → mount
- * sequence on client navigation. Use these to animate page transitions,
- * save scroll state, emit analytics events, or defer the swap behind
- * any async work that must complete before the next page appears.
+ * Page-lifecycle hooks that fire around the dispose → mount cycle on
+ * client navigation. With persistent layouts in play the cycle only
+ * tears down the *divergent* suffix of the layout chain — any layers
+ * shared between the old and new routes stay mounted.
  *
- * The sequence is:
+ * Navigation sequence for an already-mounted app:
  *
  * ```
  *   client nav triggered
  *     │
  *     ▼
- *   onLeave(el)   ← awaited if it returns a promise
- *     │              (the outgoing page's DOM is still mounted here)
+ *   compare old chain to new chain → find first mismatch index K
+ *     │
  *     ▼
- *   currentHandle.dispose()
- *     │              (all scopes torn down — portals, focus traps,
- *     │               onMount cleanups all fire synchronously here)
+ *   onLeave(leaveTarget)   ← awaited; leaveTarget is the slot element
+ *     │                      at depth K-1 (or the root container if K=0)
+ *     │                      whose contents are about to be replaced
  *     ▼
- *   el.textContent = ''
- *     │              (old DOM removed)
+ *   dispose chainHandles[K..end] innermost first
+ *     │
  *     ▼
- *   mountApp(el, Page, data)
- *     │              (new page mounted)
+ *   leaveTarget.textContent = ''
+ *     │
+ *     ▼
+ *   mount newChain[K..end] into leaveTarget, outermost first
+ *     │
  *     ▼
- *   onEnter(el)   ← not awaited; animate in-place
+ *   onEnter(leaveTarget)   ← fire-and-forget; fresh DOM in place
  *     │
  *     ▼
- *   onMount()     ← legacy shim, still fires last
+ *   onMount()
  * ```
  *
- * On the initial render (hydration), `onLeave` and `onEnter` are NOT
+ * On the initial hydration render, `onLeave` and `onEnter` are NOT
  * called — there's no outgoing page to leave and no animation to enter.
- * If you need to run code after hydration, use `onMount`.
+ * Use `onMount` for code that should run on every render including the
+ * initial one.
  */
 export interface RenderClientOptions {
-    /** CSS selector for the mount container. Default: '#app' */
+    /** CSS selector for the mount container. Default: `'#app'`. */
     container?: string;
     /**
-     * Called on the outgoing page's container BEFORE dispose + clear + mount.
-     * Return a promise to defer the swap until the leave animation finishes.
-     * The container element is passed as the argument — its children are
-     * still the previous page's DOM at this point.
+     * Persistent layout chain. One of:
+     *
+     * - A single `ComponentDef` — becomes a one-layout chain.
+     * - An array of `ComponentDef`s — outermost layout first, innermost
+     *   layout last. Every layer except the innermost must call
+     *   `pageSlot()` in its view to declare where nested content renders.
+     * - A function that returns a chain from the current `pageContext` —
+     *   lets different routes use different chains, e.g. by reading
+     *   Vike's `pageContext.urlPathname` or `pageContext.config.Layout`.
+     *
+     * Layers that are shared between the previous and next navigation
+     * stay mounted. Only the divergent suffix is disposed and re-mounted.
+     * Dialogs, focus traps, and effect subscriptions rooted in a surviving
+     * layer are unaffected by the nav.
+     */
+    Layout?: AnyComponentDef | LayoutChain | ((pageContext: ClientPageContext) => LayoutChain);
+    /**
+     * Called on the slot element whose contents are about to be replaced,
+     * BEFORE the divergent suffix is disposed and re-mounted. The slot's
+     * current DOM is still attached when this runs — the only moment a
+     * leave animation can read/write it. Return a promise to defer the
+     * swap until the animation completes.
      *
+     * For a plain no-layout setup, the slot element is the root container.
      * Not called on the initial hydration render.
      */
     onLeave?: (el: HTMLElement) => void | Promise<void>;
     /**
-     * Called after the new page is mounted into the container. Use this to
-     * kick off an enter animation on the freshly-rendered content. Not
-     * awaited — if you return a promise, the resolution is ignored.
+     * Called after the new divergent suffix is mounted, on the same slot
+     * element that was passed to `onLeave`. Use this to kick off an enter
+     * animation. Fire-and-forget — promise returns are ignored.
      *
      * Not called on the initial hydration render.
      */
     onEnter?: (el: HTMLElement) => void;
     /**
      * Called after mount or hydration completes. Fires on every render
-     * including the initial hydration. Use this for per-render side
-     * effects that don't fit the animation hooks (analytics, focus
-     * management, etc.).
+     * including the initial hydration. Use for per-render side effects
+     * that don't fit the animation hooks.
      */
     onMount?: () => void;
 }
 /**
  * Adapt a `TransitionOptions` object (e.g. the output of
- * `routeTransition()` from `@llui/transitions`, or any preset like
- * `fade()` / `slide()`) into the `onLeave` / `onEnter` shape expected
- * by `createOnRenderClient`.
+ * `routeTransition()` from `@llui/transitions`, or a preset like `fade`
+ * / `slide`) into the `onLeave` / `onEnter` pair expected by
+ * `createOnRenderClient`.
  *
- * ```typescript
+ * ```ts
  * import { createOnRenderClient, fromTransition } from '@llui/vike/client'
  * import { routeTransition } from '@llui/transitions'
  *
  * export const onRenderClient = createOnRenderClient({
+ *   Layout: AppLayout,
  *   ...fromTransition(routeTransition({ duration: 200 })),
  * })
  * ```
  *
- * The transition operates on the container element itself — its
- * opacity / transform fades out the outgoing page, then the new page
- * fades in when it mounts. If the preset doesn't restore its starting
- * style on `leave`, the container may still carry leftover properties
- * when the new page mounts; use `enter` to reset them explicitly or
- * pick presets that self-clean.
+ * The transition operates on the slot element — in a no-layout setup,
+ * the root container; in a layout setup, the innermost surviving
+ * layer's `pageSlot()` element. Opacity / transform fades apply to the
+ * outgoing page content, then the new page fades in.
  */
 export declare function fromTransition(t: TransitionOptions): Pick<RenderClientOptions, 'onLeave' | 'onEnter'>;
 /**
- * @internal — test helper. Disposes the current handle (if any) and clears
- * the module-level state so subsequent calls behave as a first mount.
- * Not part of the public API; subject to change without notice.
+ * @internal — test helper. Disposes every layer in the current chain
+ * and clears the module state so subsequent calls behave as a first
+ * mount. Not part of the public API; subject to change without notice.
+ */
+export declare function _resetChainForTest(): void;
+/**
+ * Back-compat alias for the pre-layout test helper name.
+ * @internal
+ * @deprecated — use `_resetChainForTest` instead.
  */
 export declare function _resetCurrentHandleForTest(): void;
 /**
- * Default onRenderClient hook — no animation hooks. Hydrates if
- * `isHydration` is true, otherwise mounts fresh. Use `createOnRenderClient`
+ * Default onRenderClient hook — no layout, no animation hooks. Hydrates
+ * on first load, mounts fresh on subsequent navs. Use `createOnRenderClient`
  * for the customizable factory form.
  */
 export declare function onRenderClient(pageContext: ClientPageContext): Promise<void>;
 /**
- * Factory to create a customized onRenderClient hook.
+ * Factory to create a customized onRenderClient hook. See `RenderClientOptions`
+ * for the full option surface — this is the entry point for persistent
+ * layouts, route transitions, and lifecycle hooks.
  *
- * ```typescript
+ * **Do not name your layout file `+Layout.ts`.** Vike reserves the `+`
+ * prefix for its own framework config conventions, and `+Layout.ts` is
+ * interpreted by `vike-react` / `vike-vue` / `vike-solid` framework
+ * adapters as a native layout config. `@llui/vike` isn't a framework
+ * adapter in that sense — it's a render adapter, and `createOnRenderClient`
+ * consumes the layout component directly via the `Layout` option. Name
+ * the file `Layout.ts`, `app-layout.ts`, or anywhere outside `/pages`
+ * that Vike won't scan, and import it here by path.
+ *
+ * ```ts
  * // pages/+onRenderClient.ts
- * import { createOnRenderClient } from '@llui/vike/client'
+ * import { createOnRenderClient, fromTransition } from '@llui/vike/client'
+ * import { routeTransition } from '@llui/transitions'
+ * import { AppLayout } from './Layout' // ← NOT './+Layout'
  *
  * export const onRenderClient = createOnRenderClient({
- *   container: '#root',
- *   onLeave: (el) => el.animate({ opacity: [1, 0] }, 200).finished,
- *   onEnter: (el) => el.animate({ opacity: [0, 1] }, 200),
- *   onMount: () => console.log('Page ready'),
+ *   Layout: AppLayout,
+ *   ...fromTransition(routeTransition({ duration: 200 })),
+ *   onMount: () => console.log('page rendered'),
  * })
  * ```
  */

package/dist/on-render-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"on-render-client.d.ts","sourceRoot":"","sources":["../src/on-render-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAa,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAE3E,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,cAAc,CAAC,EAAE,OAAO,CAAA;KACzB;CACF;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAA;IACtD,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,mBAAmB;IAClC,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEnD;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,IAAI,CAAA;IAEnC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,iBAAiB,GACnB,IAAI,CAAC,mBAAmB,EAAE,SAAS,GAAG,SAAS,CAAC,CAgBlD;AAMD;;;;GAIG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAKjD;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,WAAW,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAElF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,mBAAmB,GAC3B,CAAC,WAAW,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAEnD"}
+{"version":3,"file":"on-render-client.d.ts","sourceRoot":"","sources":["../src/on-render-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAa,iBAAiB,EAAS,MAAM,WAAW,CAAA;AAKrF,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAEzC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,cAAc,CAAC,EAAE,OAAO,CAAA;KACzB;CACF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,eAAe,CAAA;IACrB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,cAAc,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;IACnC,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,KAAK,WAAW,GAAG,aAAa,CAAC,eAAe,CAAC,CAAA;AAoBjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,WAAW,mBAAmB;IAClC,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,EAAE,eAAe,GAAG,WAAW,GAAG,CAAC,CAAC,WAAW,EAAE,iBAAiB,KAAK,WAAW,CAAC,CAAA;IAE1F;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEnD;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,IAAI,CAAA;IAEnC;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;CACrB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,iBAAiB,GACnB,IAAI,CAAC,mBAAmB,EAAE,SAAS,GAAG,SAAS,CAAC,CAgBlD;AA2BD;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAOzC;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,WAAW,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAElF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,mBAAmB,GAC3B,CAAC,WAAW,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAEnD"}