lit-ui-router-ssr 0.8.0 → 0.9.0

package/README.md

@@ -24,8 +24,9 @@ imports the pre-1.0 renderer or re-derives the incantation.
   on the page carries `defer-hydration` and renders nothing until the client's walk reaches it.
 - **The hydration signature.** A page rendered from a template opens on a JSON data block,
   `<script type="application/json" data-lit-ui-router-ssr>`, naming this package's version, the
-  state the router stood on, that state's url parameter values, and the resolved values
-  `dehydrate` or the `payload` hook draws. A page `renderShell` returns as a string is written as-is, without one.
+  state the router stood on, that state's url parameter values, the fully qualified name of each
+  `<ui-view>` it drew a routed component into, and the resolved values `dehydrate` or the
+  `payload` hook draws. A page `renderShell` returns as a string is written as-is, without one.
 - **The lit render inside the emit loop.** The loop itself — verdict to file name, redirect to
   rules line, the `_redirects` file, delegating states skipped, tally, warnings for paths that
   matched nothing — is
@@ -33,6 +34,8 @@ imports the pre-1.0 renderer or re-derives the incantation.
   supplies the lit one and takes the same options, plus `router`, `renderShell`, `document`,
   `root`, `elementRenderers`, `dehydrate`, `payload`, `responses` and `origin`. No SPA catch-all is ever written: one
   turns every 404 into a 200.
+- **One page for a host that owns the request.** `renderToString` is that render alone, for a
+  framework route or a worker that settles the router itself.
 - **Response states after settle.** `responder` runs the handler bound to a response state's name
   with the resolves its transition landed with.
 - **`<ui-view>` on both sides.** `UiViewRenderer` fills the element's light DOM on the server;
@@ -57,6 +60,9 @@ install it when you import `lit-ui-router-ssr/client`. `lit-ui-router-ssr/vite`
 The `lit-ui-router` peer is `^1.19.0`: the server renders a view through the helper `<ui-view>`
 renders through, and the client hands a served class element to the view it wakes.
 
+The `ui-router-server` peer is `^0.9.0`: `prerender` asks its `redirectedTo` whether a page's
+`redirectTo` fired, and reads the status from the redirecting state's `redirectStatusCode`.
+
 ## Quick Start
 
 ```typescript
@@ -95,7 +101,8 @@ virtual fs instead.
 `ui-router-server/vite`'s, with the DOM shim and `lit-ui-router-ssr/register` loaded before the
 prerender script, and its `definePrerender` calls this package's `prerender` with the options the
 script returns; [Prerender with Vite](https://lit-ui-router.dev/guides/prerender-with-vite) shows
-both files in full.
+both files in full. [Prerender with Eleventy](https://lit-ui-router.dev/guides/prerender-with-eleventy)
+calls `prerender` from an Eleventy data file instead, and lets Eleventy write the pages.
 
 ## Static hosts add a trailing slash
 
@@ -124,7 +131,7 @@ A server render reads the router only once its transition has landed, resolves i
 `settle(router, path)`, the `ui-router-server/ssr` step this package re-exports, sets the url, syncs
 the router to it, and resolves with the transition that landed, so the synchronous render after it
 reads every resolve. A `redirectTo` chain settles on its final state, and a path the router already
-stands on resolves at once.
+stands on resolves at once. `redirectedTo` reports where a redirected transition landed.
 
 A page fails to land in four ways, and each rejects rather than hangs:
 
@@ -140,6 +147,85 @@ A page fails to land in four ways, and each rejects rather than hangs:
 `settle()` never calls `router.start()`, which runs once per router: it drives `urlService`
 directly, so a page loop calls it once per path on the same router, started or not.
 
+## Page, response state or redirect: which decides when
+
+A url's answer is decided at one of two points:
+
+- **The verdict**, from the url alone, before any of the app's code runs. A pattern rule or a data
+  `redirectTo` answers a redirect, a state marked `response: true` a response state, a `delegate` a
+  host handler, and any other state a page.
+- **Settle**, once the page's transition runs its resolves, hooks and `redirectTo` functions. They
+  can change only a page's answer: a `redirectTo` function can move the transition elsewhere, and a
+  resolve that rejects fails `settle`, which the host maps to an error page.
+
+A response state suits a url whose pattern alone says it is not a page. When urls of one pattern
+are sometimes a page and sometimes a redirect, such as a compare page whose reversed pair redirects
+to the forward one, only a `redirectTo` function tells them apart.
+
+The state whose `redirectTo` fires, data or function, declares the status in `redirectStatusCode`:
+`301`, `302`, `303`, `307` or `308`, `302` by default. A redirect function often depends on data,
+and browsers cache a permanent redirect with no expiry, so a redirect that never changes opts into
+`308`. A pattern rule's redirect answers `302`.
+
+After `settle`, `redirectedTo(router, transition)` returns `{ url, status }` for a transition a
+redirect moved, a change of params alone included: the url it landed on, relative to the mount,
+query included, and the redirecting state's `redirectStatusCode`. A live host answers with it:
+
+```ts
+import { redirectedTo, settle } from 'lit-ui-router-ssr';
+
+// A shell verdict under /releases, on a router built for this request.
+const redirect = redirectedTo(router, await settle(router, subpath));
+
+if (redirect)
+  return new Response(null, {
+    status: redirect.status,
+    headers: { Location: `/releases${redirect.url}` },
+  });
+```
+
+`prerender` does the same after each `renderShell`: when the transition the hook landed was
+redirected, the path gets a rules line in place of a page, counted in `tally.redirect`. A url rule
+that rewrites the url, `when('/old', '/new')`, starts a new transition rather than redirecting one,
+so `redirectedTo` reports nothing for it; declare it in the mount's `redirects`. See
+[page, response state or redirect](https://lit-ui-router.dev/packages/ssr#page-response-state-or-redirect-which-decides-when).
+
+## Rendering one page per request
+
+A host that owns the request, such as a framework route or a worker, renders one page with
+`renderToString(template, { router })`. It is the render `prerender()` runs for each page, hydration
+signature and `deferHydration` included, so its markup is byte for byte what `prerender()` hands
+`document` for the same template and router. The host settles the router, decides the response and
+writes the document around the markup:
+
+```typescript
+import { redirectedTo, renderToString, settle } from 'lit-ui-router-ssr';
+
+// `router` serves the mount at /releases; `subpath` is the request's path within it.
+const redirect = redirectedTo(router, await settle(router, subpath));
+
+if (redirect)
+  return new Response(null, {
+    status: redirect.status,
+    headers: { Location: `/releases${redirect.url}` },
+  });
+
+const { html } = renderToString(page(router), { router, dehydrate: {} });
+
+return new Response(shell(html), {
+  status: router.globals.current.name === 'notFound' ? 404 : 200,
+  headers: { 'Content-Type': 'text/html; charset=utf-8' },
+});
+```
+
+The router must stand on the page before the call. It is provided on `root`, a fresh `EventTarget`
+unless one is passed, for the render alone. `elementRenderers` and `dehydrate` act as `prerender()`'s
+options of the same name, and `payload` takes a payload drawn by hand rather than a hook. The result's
+`payload` reports the bytes the resolve payload adds to the signature and, under `dehydrate`, the
+resolves left to re-run on the client.
+
+The markup is collected into one string, synchronously. A streamed render would be a separate export.
+
 ## Response states
 
 A [response state](https://lit-ui-router.dev/packages/server#response-states) answers with a
@@ -244,7 +330,9 @@ Post-processing of prerendered HTML keys on the [hydration signature](#the-clien
 The use site opts in with `uiViewSlot()`, which is what reaches the renderer's light-DOM render and
 commits nothing on the client:
 
-```typescript
+```typescript check
+import { html } from 'lit';
+import type { UIRouterLit } from 'lit-ui-router';
 import { uiViewSlot } from 'lit-ui-router-ssr/client';
 
 const page = (router: UIRouterLit) => html`
@@ -259,7 +347,7 @@ same strings with the hole empty and each `<ui-view>` fills itself.
 
 Take a card that receives a post by property and draws it in its own `render()`:
 
-```typescript
+```typescript check
 import { html, LitElement } from 'lit';
 
 type Post = { title: string; summary: string };
@@ -369,6 +457,13 @@ parses, and hydration adopts them there. `LitElementRenderer` does the same for
 on the page, whether or not it has anything to show on the server, which is the cost the default
 avoids.
 
+A shell element needs that list too: a shadow-DOM component that holds `<ui-view>` in its own
+template, such as an `<app-root>`. Under the default it renders as its bare tag, empty, and the
+views inside it are missing with it. With `LitElementRenderer` after `LightElementRenderer`, the
+`<ui-view>` in its shadow root renders, hydrates and adopts. In development, `prerender()` and
+`renderToString()` warn once per tag when a shadow-DOM `LitElement` reaches no renderer that draws
+it; `<ui-router>`, whose shadow root is a bare slot, is left out.
+
 ## Registering the elements
 
 A prerendered page needs the served `<ui-view>`, and `lit-ui-router-ssr/register` is the one import
@@ -442,7 +537,7 @@ registry holds no `<ui-view>`.
 It imports `lit-ui-router/pure`, which registers nothing, and defines the served class under a tag
 of its own:
 
-```typescript
+```typescript check
 import { UiView } from 'lit-ui-router/pure';
 import { withServedRender } from 'lit-ui-router-ssr/client';
 
@@ -470,12 +565,23 @@ const { outcome } = await bootstrap(router, root, page(router));
   signature, starts the router, waits for the boot transition to land — following redirects to the
   one that succeeds — then runs `hydrateRoot()`. The walk commits `.uiRouter` onto `<ui-router>` and
   each `<ui-view>` re-seeks the router before its own first render, so every view finds the settled
-  router rather than the placeholder it registered against. The call waits for every awake
-  `<ui-view>`, nested ones included, to finish updating, then releases the adopter. It resolves with
-  `outcome` — `adopted` or `cold` — and `signature` (`BootstrapSignature`): `matched` when the boot
-  landed on the state and url parameters the signature names, `elsewhere` when the document carried
-  a signature and the boot landed somewhere else or landed no transition, and `absent` when it
-  carried none. Nothing constrains when `lit-ui-router-ssr/register` is imported.
+  router rather than the placeholder it registered against. It resolves with `outcome` — `adopted`
+  or `cold`, what the root hydrate came to — `signature` (`BootstrapSignature`): `matched` when the
+  boot landed on the state and url parameters the signature names, `elsewhere` when the document
+  carried a signature and the boot landed somewhere else or landed no transition, and `absent` when
+  it carried none — and `views`, described next. Nothing constrains when
+  `lit-ui-router-ssr/register` is imported.
+- **`views` says what each view came to.** A read-only map keyed by a view's fully qualified name
+  (`$default`, `$default.$default`, `$default.aside`) to a `BootstrapViewReport`: `outcome`, an
+  `AdoptOutcome` or `pending`, with the reporting `view` and, on `fell-back`, its `error`. It lists
+  every view the signature says the document was drawn with, then any other view that woke and
+  requested the adopter. Views are tracked by what they report to the adopter, whose request is a
+  composed event, so a view in a shadow root counts like any other. The call
+  resolves once the views that woke have updated, nested ones and those in shadow roots their hosts
+  hydrated included, and lists a drawn view that has not woken as `pending`. The map is a snapshot:
+  the adopter stays installed until every drawn view has reported, so a view whose host hydrates
+  later still adopts and still reaches `onAdopt`. A document that booted where it was drawn and
+  adopted none of its drawn views warns once in development.
 - **The cold path is the same call.** A container with nothing to adopt is emptied and `value`
   rendered into it before the router starts. A boot transition that fails, a url that starts none,
   and a root `hydrate()` that throws over a mutated document all empty the container and render
@@ -543,7 +649,8 @@ const { outcome } = await bootstrap(router, root, page(router));
   served nodes are the live ones — `fell-back` — a mismatch or a lost pair, with `detail.error`
   carrying the cause — or `none`, nothing to adopt. It fires once per view, parent first, in
   production as in development. The `onAdopt(view, outcome, error)` option of `bootstrap()` and `hydrateRoot()` receives
-  the same reports for every view its walk reaches, a view the pin adopts after the release included.
+  the same reports for every view its walk reaches, a view the pin adopts after the release included,
+  and a view in a shadow root its host hydrates after the walk.
 - **A mutated document throws.** `hydrateRoot()` rethrows what `hydrate()` threw, over a container it
   first empties. The caller renders into it.
 
@@ -554,7 +661,7 @@ cycle with `LightDomHydrating(Base)` from `lit-ui-router-ssr/client`. `LightElem
 `lit-ui-router-ssr`, one of `prerender()`'s default renderers, draws it on the server, and
 `lightSlot()` marks the hole at the use site:
 
-```typescript
+```typescript check
 import { html, LitElement } from 'lit';
 import { property } from 'lit/decorators.js';
 import { LightDomHydrating, lightSlot } from 'lit-ui-router-ssr/client';

package/dist/adopt-context.d.ts

@@ -38,7 +38,13 @@ export type AdoptUiViewContext = Context<AdoptUiViewContextKey, (view: Adoptable
 * @example
 * ```ts
 * import { provideContext } from 'lit-ui-router/context';
-* import { adoptUiViewContext } from 'lit-ui-router-ssr/client';
+* import {
+*   adoptUiViewContext,
+*   type AdoptableView,
+* } from 'lit-ui-router-ssr/client';
+*
+* declare const container: HTMLElement;
+* declare function adopt(view: AdoptableView): void;
 *
 * const uninstall = provideContext(container, adoptUiViewContext, (view) =>
 *   adopt(view),

package/dist/adopt-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adopt-context.d.ts","mappings":"AACA,cAAc,qBAAqB;AACnC,cAAc,eAAe;;;;;AAM7B,iBAAiB,sBAAsB;;UAE5B,MAAM;AACjB;;;;;AAMA,iBAAiB,sBAAsB,YAAY;;CAGjD;;UAES,eAAe;AAC1B;;;;;;AAOA,YAAY,qBAAqB,QAC/B,wBACC,MAAM;;;;;;;;;;;;;;;;;;;;;;AAyBT,OAAO,cAAM,oBAAoB","names":[],"ignoreList":[],"sources":["../src/adopt-context.ts"]}
+{"version":3,"file":"adopt-context.d.ts","mappings":"AACA,cAAc,qBAAqB;AACnC,cAAc,eAAe;;;;;AAM7B,iBAAiB,sBAAsB;;UAE5B,MAAM;AACjB;;;;;AAMA,iBAAiB,sBAAsB,YAAY;;CAGjD;;UAES,eAAe;AAC1B;;;;;;AAOA,YAAY,qBAAqB,QAC/B,wBACC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BT,OAAO,cAAM,oBAAoB","names":[],"ignoreList":[],"sources":["../src/adopt-context.ts"]}

package/dist/adopt-context.js.map

@@ -1 +1 @@
-{"version":3,"file":"adopt-context.js","mappings":"AAyDA,OAAO,MAAM,qBAAyC,OAAO,OAAO,EAClE,MAAM,0CACR,CAAC","names":[],"ignoreList":[],"sources":["../src/adopt-context.ts"]}
+{"version":3,"file":"adopt-context.js","mappings":"AA+DA,OAAO,MAAM,qBAAyC,OAAO,OAAO,EAClE,MAAM,0CACR,CAAC","names":[],"ignoreList":[],"sources":["../src/adopt-context.ts"]}

package/dist/boot-pending.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from "lit-ui-router/context";
+/** The identity of {@link bootPendingContext}. */
+interface BootPendingContextKey {
+	/** Names the key for a debugger; identity, not this string, is what matches. */
+	readonly name: "lit-ui-router-ssr/context#boot-pending";
+}
+/**
+* The boot-pending key: a pending `bootstrap()` answers with a function that
+* takes the view's check and runs it again once its walk has settled.
+*
+* @internal
+*/
+export type BootPendingContext = Context<BootPendingContextKey, (recheck: () => void) => void>;
+/**
+* Answered under a container while a `bootstrap()` over it has yet to settle
+* its walk, in development only.
+*
+* @internal
+*/
+export declare const bootPendingContext: BootPendingContext;
+export {};
+//# sourceMappingURL=boot-pending.d.ts.map

package/dist/boot-pending.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot-pending.d.ts","mappings":"AACA,cAAc,eAAe;;UAGnB,sBAAsB;;UAErB,MAAM;AACjB;;;;;;;AAQA,YAAY,qBAAqB,QAC/B,wBACC;;;;;;;AAUH,OAAO,cAAM,oBAAoB","names":[],"ignoreList":[],"sources":["../src/boot-pending.ts"]}

package/dist/boot-pending.js

@@ -0,0 +1,2 @@
+export const bootPendingContext = Object.freeze({ name: "lit-ui-router-ssr/context#boot-pending" });
+//# sourceMappingURL=boot-pending.js.map

package/dist/boot-pending.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot-pending.js","mappings":"AA2BA,OAAO,MAAM,qBAAyC,OAAO,OAAO,EAClE,MAAM,yCACR,CAAC","names":[],"ignoreList":[],"sources":["../src/boot-pending.ts"]}

package/dist/client.d.ts

@@ -86,6 +86,12 @@ declare global {
 *
 * @example
 * ```ts
+* import { html } from 'lit';
+* import type { UIRouterLit } from 'lit-ui-router';
+* import { uiViewSlot } from 'lit-ui-router-ssr/client';
+*
+* declare const router: UIRouterLit;
+*
 * html`<ui-router .uiRouter=${router}><ui-view>${uiViewSlot()}</ui-view></ui-router>`;
 * ```
 */
@@ -101,6 +107,11 @@ export declare const uiViewSlot: typeof renderLight;
 *
 * @example
 * ```ts
+* import { html } from 'lit';
+* import { lightSlot } from 'lit-ui-router-ssr/client';
+*
+* declare const title: string;
+*
 * html`<app-card .title=${title}>${lightSlot()}</app-card>`;
 * ```
 */
@@ -123,6 +134,13 @@ export declare const lightSlot: typeof renderLight;
 * @example
 * ```ts
 * import { hydrateRoot, readHydrationSignature } from 'lit-ui-router-ssr/client';
+* import type { TemplateResult } from 'lit';
+* import type { UIRouterLit } from 'lit-ui-router';
+*
+* declare const booted: Promise<void>;
+* declare const root: HTMLElement;
+* declare const router: UIRouterLit;
+* declare function page(router: UIRouterLit): TemplateResult;
 *
 * await booted;
 * const { state } = readHydrationSignature(root) ?? {};
@@ -149,6 +167,10 @@ export declare function readHydrationSignature(container: ParentNode): Hydration
 * ```ts
 * import { readResolvePayload } from 'lit-ui-router-ssr/client';
 * import { seed } from 'ui-router-server/ssr/client';
+* import type { UIRouterLit } from 'lit-ui-router';
+*
+* declare const root: HTMLElement;
+* declare const router: UIRouterLit;
 *
 * seed(router, readResolvePayload(root));
 * router.start();
@@ -216,6 +238,13 @@ export declare function readResolvePayload(container: ParentNode): ResolvePayloa
 * @example
 * ```ts
 * import { hydrateRoot } from 'lit-ui-router-ssr/client';
+* import { render, type TemplateResult } from 'lit';
+* import type { UIRouterLit } from 'lit-ui-router';
+*
+* declare const booted: Promise<void>;
+* declare const root: HTMLElement;
+* declare const router: UIRouterLit;
+* declare function page(router: UIRouterLit): TemplateResult;
 *
 * await booted;
 * const release = hydrateRoot(root, page(router));
@@ -246,17 +275,45 @@ export type BootstrapOutcome = "adopted" | "cold";
 * still compared, though the container renders cold.
 */
 export type BootstrapSignature = "matched" | "elsewhere" | "absent";
+/**
+* What one view came to, as {@link BootstrapResult.views} reports it: its
+* {@link AdoptOutcome}, or `pending` for a view the document was drawn with
+* that had not woken when {@link bootstrap} resolved.
+*/
+export type BootstrapViewOutcome = AdoptOutcome | "pending";
+/** One view's entry in {@link BootstrapResult.views}. */
+export interface BootstrapViewReport {
+	/** What the view came to; see {@link BootstrapViewOutcome}. */
+	readonly outcome: BootstrapViewOutcome;
+	/** The view that reported; absent on a `pending` one. */
+	readonly view?: Element;
+	/** What `hydrate()` threw, or why the view did not adopt; present only on `fell-back`. */
+	readonly error?: unknown;
+}
 /** What {@link bootstrap} resolves with. */
 export interface BootstrapResult {
 	/**
-	* `adopted`: the served document was hydrated, and each served view reported
-	* its own {@link AdoptOutcome}. `cold`: the container was emptied and the
-	* template rendered into it.
+	* What the root hydrate came to, not each view. `adopted`: the served
+	* document was hydrated, and each served view reported its own {@link
+	* AdoptOutcome}, which {@link BootstrapResult.views} collects; a document
+	* whose views all rendered cold still reports `adopted` here. `cold`: the
+	* container was emptied and the template rendered into it.
 	*/
 	readonly outcome: BootstrapOutcome;
 	/** How the boot compares with the document's hydration signature; see {@link BootstrapSignature}. */
 	readonly signature: BootstrapSignature;
 	/**
+	* Each served view's outcome, keyed by the view's fully qualified name
+	* (`$default`, `$default.$default`, `$default.aside`): every view the
+	* signature says the document was drawn with, in the order it lists them,
+	* then any other view that woke and requested the adopter, such as one that
+	* woke with no served render. A drawn view not yet woken is `pending`; the
+	* first view to report under a name holds it. A snapshot taken as the call
+	* resolves: a view that adopts later still reports to `onAdopt` and its
+	* {@link UiViewAdoptEvent}. Empty on a cold boot.
+	*/
+	readonly views: ReadonlyMap<string, BootstrapViewReport>;
+	/**
 	* The boot transition's `Rejection`, or what the root `hydrate()` threw;
 	* present only on a cold boot that one of them caused.
 	*/
@@ -309,13 +366,31 @@ export interface BootstrapOptions extends HydrateRootOptions, SeedOptions {
 *   mutated document, does the same. The call resolves rather than rejects.
 *
 * Every served view still reports its own {@link AdoptOutcome}, as a {@link
-* UiViewAdoptEvent} and to `options.onAdopt`. The call waits for each awake
-* `<ui-view>` to finish updating, nested views included, then releases the
-* adopter `hydrateRoot()` provided; a view the app detached keeps its pin.
+* UiViewAdoptEvent} and to `options.onAdopt`, and the result collects them in
+* {@link BootstrapResult.views}. Views are tracked by what they report to the
+* adopter, whose request is a composed event, so a view in a shadow root is
+* reported like any other; nothing queries the document for views. The call
+* waits until the views awake under the boot have
+* updated, nested views and views in shadow roots their hosts hydrated
+* included, and resolves then, reporting a view the signature lists that has
+* not woken as `pending`. The adopter stays installed on `container` until
+* every view the signature lists has reported, so a view whose host hydrates
+* later still adopts and still reaches `onAdopt`; a view the app detached
+* keeps its pin. A signed document that booted where it was drawn and adopted
+* none of the views it was drawn with warns once in development.
+*
+* In development a sleeping view's "still asleep" warning stands down while
+* the boot transition runs, and is checked again once the walk has settled.
 *
 * @example
 * ```ts
 * import { bootstrap } from 'lit-ui-router-ssr/client';
+* import type { TemplateResult } from 'lit';
+* import type { UIRouterLit } from 'lit-ui-router';
+*
+* declare const root: HTMLElement;
+* declare const router: UIRouterLit;
+* declare function page(router: UIRouterLit): TemplateResult;
 *
 * const { outcome } = await bootstrap(router, root, page(router));
 * ```
@@ -324,7 +399,7 @@ export interface BootstrapOptions extends HydrateRootOptions, SeedOptions {
 * @param container - the element the server's markup was written into, or an empty one
 * @param value - the same template the server rendered, with every `<ui-view>` hole empty
 * @param options - lit render options, `onAdopt`, and the boot transition's `payload` and `transport`
-* @returns what the boot came to, once every awake view has updated
+* @returns what the boot came to, and what each view came to, once the awake views have updated
 * @throws what `router.start()` throws, as on a router already started
 * @throws the `TypeError` `seed` throws on a payload with no `resolves`, before the router starts
 */

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","mappings":"AAQA,SAAS,mBAAmB;AAK5B,cAAyB,qBAAqB;AAM9C,cAAc,mBAAmB;AAEjC,cAAc,gBAAgB,mBAAmB;AAYjD,cAAc,0BAA0B;AAExC,SACE,yBACK,oBACA,yBACA,6BACA;AAEP,SACE,wBACK,mBACA,yBACL,iBACA,wBACK;AAEP,SACE,wBACK,mCACA,+BACA,6BACA;AAEP,cAAc,0BAA0B;;;;;;;;;;;AAexC,YAAY,eAAe,YAAY,cAAc;;;;;AAMrD,OAAO,cAAM,sBAAuB;;;;AAKpC,iBAAiB,kBAAkB;;UAExB,SAAS;;UAET;AACX;;;;;AAMA,YAAY,mBAAmB,YAAY;;;;;;AAO3C,OAAO,cAAM,wBAAyB;;AAGtC,YAAY,qBAAqB,YAAY;;;;AAK7C,YAAY,iBACV,MAAM,SACN,SAAS,cAET;;;;;AAOF,iBAAiB,2BAA2B,cAAc;;;;;;CAMxD,UAAU;AACZ;eAEe;WACH,oBAAoB;;EAE5B,iBAAiB;;EAEjB,mBAAmB;CACrB;AACF;;;;;;;;;;;;;;;;;;;;;AAgEA,OAAO,cAAM,mBAAmB;;;;;;;;;;;;;;;AAgBhC,OAAO,cAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgZ/B,OAAO,iBAAS,uBACd,WAAW,aACV;;;;;;;;;;;;;;;;;;;;;;;;AA6BH,OAAO,iBAAS,mBACd,WAAW,aACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2JH,OAAO,iBAAS,YACd,WAAW,aAEX,gBACA,UAAS,qBACR;;AAsCH,YAAY,mBAAmB,YAAY;;;;;;;;;;;;;;;;AAiB3C,YAAY,qBAAqB,YAAY,cAAc;;AAG3D,iBAAiB,gBAAgB;;;;;;UAMtB,SAAS;;UAET,WAAW;;;;;UAKX;AACX;;;;;AAMA,iBAAiB,yBAAyB,oBAAoB,YAAY;;;;;;;UAO/D,UAAU;AACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6LA,OAAO,iBAAe,UACpB,QAAQ,aACR,WAAW,aAEX,gBACA,UAAS,mBACR,QAAQ","names":[],"ignoreList":[],"sources":["../src/client.ts"]}
+{"version":3,"file":"client.d.ts","mappings":"AAQA,SAAS,mBAAmB;AAK5B,cAAyB,qBAAqB;AAM9C,cAAc,mBAAmB;AAEjC,cAAc,gBAAgB,mBAAmB;AAajD,cAAc,0BAA0B;AAExC,SACE,yBACK,oBACA,yBACA,6BACA;AAEP,SACE,wBACK,mBACA,yBACL,iBACA,wBACK;AAEP,SACE,wBACK,mCACA,+BACA,6BACA;AAEP,cAAc,0BAA0B;;;;;;;;;;;AAexC,YAAY,eAAe,YAAY,cAAc;;;;;AAMrD,OAAO,cAAM,sBAAuB;;;;AAKpC,iBAAiB,kBAAkB;;UAExB,SAAS;;UAET;AACX;;;;;AAMA,YAAY,mBAAmB,YAAY;;;;;;AAO3C,OAAO,cAAM,wBAAyB;;AAGtC,YAAY,qBAAqB,YAAY;;;;AAK7C,YAAY,iBACV,MAAM,SACN,SAAS,cAET;;;;;AAOF,iBAAiB,2BAA2B,cAAc;;;;;;CAMxD,UAAU;AACZ;eAEe;WACH,oBAAoB;;EAE5B,iBAAiB;;EAEjB,mBAAmB;CACrB;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEA,OAAO,cAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;AAqBhC,OAAO,cAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAka/B,OAAO,iBAAS,uBACd,WAAW,aACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCH,OAAO,iBAAS,mBACd,WAAW,aACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkKH,OAAO,iBAAS,YACd,WAAW,aAEX,gBACA,UAAS,qBACR;;AAsCH,YAAY,mBAAmB,YAAY;;;;;;;;;;;;;;;;AAiB3C,YAAY,qBAAqB,YAAY,cAAc;;;;;;AAO3D,YAAY,uBAAuB,eAAe;;AAGlD,iBAAiB,oBAAoB;;UAE1B,SAAS;;UAET,OAAO;;UAEP;AACX;;AAGA,iBAAiB,gBAAgB;;;;;;;;UAQtB,SAAS;;UAET,WAAW;;;;;;;;;;;UAWX,OAAO,oBAAoB;;;;;UAK3B;AACX;;;;;AAMA,iBAAiB,yBAAyB,oBAAoB,YAAY;;;;;;;UAO/D,UAAU;AACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoUA,OAAO,iBAAe,UACpB,QAAQ,aACR,WAAW,aAEX,gBACA,UAAS,mBACR,QAAQ","names":[],"ignoreList":[],"sources":["../src/client.ts"]}

package/dist/client.js

@@ -1,13 +1,12 @@
 import { hydrate } from "@lit-labs/ssr-client";
 import { renderLight } from "@lit-labs/ssr-client/directives/render-light.js";
-import { isFunction, RejectType } from "@uirouter/core";
+import { isFunction, isString, RejectType } from "@uirouter/core";
 import { noChange, render } from "lit";
 import { directive } from "lit/directive.js";
 import { getDirectiveClass } from "lit/directive-helpers.js";
-import { provideContext } from "lit-ui-router/context";
+import { provideContext, requestContext } from "lit-ui-router/context";
 import { UiView } from "lit-ui-router/pure";
 import { seed } from "ui-router-server/ssr/client";
-import "#dev-gate";
 import { adoptUiViewContext } from "./adopt-context.js";
 import { isLightDomElement } from "./light-dom-brand.js";
 import { servedMarkerPrefix } from "./served-markers.js";
@@ -37,7 +36,7 @@ class UiViewSlotDirective extends RenderLightDirective {
 }
 export const uiViewSlot = directive(UiViewSlotDirective);
 export const lightSlot = uiViewSlot;
-let walkPolicy = {};
+let walkPolicy;
 const walkWith = (policy, walk) => {
 	const outer = walkPolicy;
 	walkPolicy = policy;
@@ -153,7 +152,10 @@ const pinAdopter = (view, policy) => {
 	let release = () => {};
 	release = provideContext(view, adoptUiViewContext, (woken) => {
 		if (woken === view) release();
-		adopt(woken, policy);
+		if (policy) return adopt(woken, policy);
+		const above = requestContext(view.parentNode, adoptUiViewContext);
+		if (above) return above(woken);
+		adopt(woken, {});
 	});
 };
 const isHydrationSignature = (value) => typeof value === "object" && value !== null && "version" in value && typeof value.version === "string";
@@ -257,15 +259,67 @@ const drawnView = (signature, router) => (view) => {
 	return Object.entries(urlParamsOf(state, router.globals.params)).every(([id, value]) => JSON.stringify(value) === JSON.stringify(drawnParams[id]));
 };
 const signatureMatches = (signature, router) => JSON.stringify([signature.state, signature.params]) === JSON.stringify(routeOf(router.globals));
-const settleViews = async (container) => {
-	const settled = new Set();
-	for (;;) {
-		const awake = [...container.querySelectorAll("*")].filter((element) => element instanceof UiView && element.isConnected && !element.hasAttribute(DEFER) && !settled.has(element));
-		if (awake.length === 0) return;
-		for (const view of awake) settled.add(view);
-		await Promise.all(awake.map((view) => view.updateComplete));
+const noneAdopted = (reports) => !reports.some(({ outcome }) => outcome === "adopted");
+const checkSomeAdopted = (tracker) => {
+	const reports = tracker.drawnReports();
+	if (reports.length === 0 || !noneAdopted(reports)) return;
+	if (reports.some(({ outcome }) => outcome !== "pending")) return tracker.snapshot(), void 0;
+	tracker.whenDrawnReported(() => {
+		if (noneAdopted(tracker.drawnReports())) tracker.snapshot();
+	});
+};
+const drawnViewsOf = (signature) => Array.isArray(signature.views) ? signature.views.filter(isString) : [];
+const trackViews = (drawn, onward) => {
+	const reports = new Map();
+	const waiting = new Set(drawn);
+	const awake = [];
+	const done = [];
+	const settle = () => {
+		if (waiting.size > 0) return;
+		for (const run of done.splice(0)) run();
+	};
+	const reporter = (view, outcome, error) => {
+		if (view instanceof UiView) awake.push(view);
+		const name = view instanceof UiView ? view.fqn : void 0;
+		if (name !== void 0 && !reports.has(name)) {
+			reports.set(name, outcome === "fell-back" ? {
+				outcome,
+				view,
+				error
+			} : {
+				outcome,
+				view
+			});
+			waiting.delete(name);
+			settle();
+		}
+		onward(view, outcome, error);
+	};
+	const drawnEntries = () => drawn.map((name) => [name, reports.get(name) ?? { outcome: "pending" }]);
+	return {
+		reporter,
+		awake: () => awake,
+		snapshot: () => new Map([...drawnEntries(), ...reports]),
+		drawnReports: () => drawnEntries().map(([, report]) => report),
+		whenDrawnReported: (run) => {
+			done.push(run);
+			settle();
+		}
+	};
+};
+const nextTask = () => new Promise((resolve) => {
+	setTimeout(resolve, 0);
+});
+const settleReports = async (tracker) => {
+	for (let seen = -1; seen !== tracker.awake().length;) {
+		seen = tracker.awake().length;
+		await nextTask();
+		await Promise.all(tracker.awake().map((view) => view.updateComplete));
 	}
 };
+const holdAsleepWarnings = (container) => {
+	return () => {};
+};
 const renderCold = (container, value, renderOptions) => {
 	makeCold(container);
 	render(value, container, renderOptions);
@@ -279,31 +333,46 @@ export async function bootstrap(router, container, value, options = {}) {
 		renderCold(container, value, renderOptions);
 		const landing = await startBoot(router);
 		disarm();
-		await settleViews(container);
+		await nextTask();
 		return {
 			outcome: "cold",
 			signature: compareSignature(served, landing, router),
+			views: new Map(),
 			...pickError(landing)
 		};
 	}
+	const rearm = holdAsleepWarnings(container);
+	try {
+		return await bootServed(router, container, value, signature, {
+			onAdopt,
+			renderOptions,
+			disarm
+		});
+	} finally {
+		rearm();
+	}
+}
+const bootServed = async (router, container, value, signature, { onAdopt, renderOptions, disarm }) => {
 	const landing = await startBoot(router);
 	disarm();
 	if (!("transition" in landing)) {
 		renderCold(container, value, renderOptions);
-		await settleViews(container);
+		await nextTask();
 		return {
 			outcome: "cold",
 			signature: "elsewhere",
+			views: new Map(),
 			...pickError(landing)
 		};
 	}
 	const compared = compareSignature(signature, landing, router);
 	const drawn = compared === "matched";
 	let fellBack = 0;
-	const reporter = (view, outcome, error) => {
+	const tracker = trackViews(drawnViewsOf(signature), (view, outcome, error) => {
 		if (outcome === "fell-back") fellBack += 1;
 		onAdopt?.(view, outcome, error);
-	};
+	});
+	const { reporter } = tracker;
 	let release;
 	try {
 		release = adoptRoot(container, value, renderOptions, drawn ? {
@@ -316,21 +385,25 @@ export async function bootstrap(router, container, value, options = {}) {
 		});
 	} catch (error) {
 		render(value, container, renderOptions);
-		await settleViews(container);
+		await nextTask();
 		return {
 			outcome: "cold",
 			signature: compared,
+			views: new Map(),
 			error
 		};
 	}
-	await settleViews(container);
-	release();
+	await settleReports(tracker);
+	tracker.whenDrawnReported(release);
+	const views = tracker.snapshot();
 	if (fellBack > 0 && signature.state !== router.globals.current.name);
+	if (drawn) checkSomeAdopted(tracker);
 	return {
 		outcome: "adopted",
-		signature: compared
+		signature: compared,
+		views
 	};
-}
+};
 const compareSignature = (signature, landing, router) => {
 	if (!signature) return "absent";
 	return "transition" in landing && signatureMatches(signature, router) ? "matched" : "elsewhere";