@jbrowse/capture 5.0.0-beta.8 → 5.0.0-beta.9

package/esm/sessionGate.d.ts

@@ -9,54 +9,54 @@ export interface SessionExpectations {
      * the default set alone when the id you passed does not exist at all.
      */
     trackIds?: string[];
+    /**
+     * The fewest open views that count. Default 1; 0 accepts a session that
+     * opened none, such as one loaded to show a dialog.
+     */
+    views?: number;
 }
-/**
- * The census the app publishes beside its phase: `AppReadyMarker` renders
- * `data-app-views` (a count), and `data-app-assemblies` / `data-app-tracks`
- * (JSON string arrays of what is open).
- *
- * One element answers the whole gate. Each view declares what it holds and
- * `openViews`/`openTracks` reduce over those declarations (ADR-103), so nothing
- * here has to know that a synteny view keeps its tracks on levels and its rows
- * on sub-views — the duck-typed walk of `window.JBrowseSession` that used to
- * live here, and drifted against the copy in `isPageBusyInPage`, is gone with
- * the builds that needed it.
- *
- * `scripts/readinessContract.test.ts` pins the attribute names against the
- * marker, since neither package may import the other.
- */
-export declare const APP_CENSUS = "[data-app-tracks]";
 export interface SessionSummary {
     views: number;
     assemblies: string[];
     trackIds: string[];
 }
-/** What the page currently has open, or undefined if there is no census yet. */
-export declare function readSessionSummary(page: Page): Promise<SessionSummary | undefined>;
+/**
+ * The census the app publishes beside its phase: `AppReadyMarker` renders
+ * `data-app-views` (a count), and `data-app-assemblies` / `data-app-tracks`
+ * (JSON string arrays of what is open). Each view declares what it holds and
+ * `openViews`/`openTracks` reduce over those declarations (ADR-103), so
+ * nothing here has to know which property a container view keeps its children
+ * on. `scripts/readinessContract.test.ts` pins the attribute names against the
+ * marker, since neither package may import the other.
+ *
+ * Serialized into the page, so it can only call what it declares.
+ */
 export declare function readSessionSummaryInPage(): SessionSummary | undefined;
+/**
+ * The message the app shows in place of itself when its config, session or
+ * plugins fail to load. Serialized into the page.
+ */
+export declare function readLoadFailureInPage(): string | undefined;
 /**
  * Wait until the census exists and the assembly and tracks that were asked for
  * are actually open.
  *
- * Throws on timeout rather than proceeding. A config URL that 404s, a trackId
- * that does not exist in the config, and an assembly name that does not match
- * the one the config declares all fail here, which is the only place they fail
- * at all — each of them otherwise produces a browser that loads, paints its
- * chrome, and photographs beautifully with nothing in it.
+ * A config, session or plugin that fails to load fails here at once, with the
+ * app's own message. A trackId that does not exist in the config, and an
+ * assembly name that does not match the one the config declares, fail here on
+ * timeout, which is the only place they fail at all — each of them otherwise
+ * produces a browser that loads, paints its chrome, and photographs beautifully
+ * with nothing in it.
  */
-export declare function waitForSession(page: Page, { assembly, trackIds, timeout, }?: SessionExpectations & {
+export declare function waitForSession(page: Page, { assembly, trackIds, views, timeout, }?: SessionExpectations & {
     timeout?: number;
 }): Promise<void>;
-/**
- * Displays that were still reporting unpainted at the moment of the call.
- *
- * Distinct from `unsettled`, which says a wait ran out of time. This says what
- * the page looked like when the shutter fired.
- */
-export declare function pendingDisplays(page: Page): Promise<string[]>;
-/** One unpainted display and what it says about itself. */
+/** One display and what it says about itself. */
 export interface PendingDisplay {
-    /** the display TYPE, shared by every instance of it */
+    /**
+     * the display TYPE, shared by every instance of it, or its id where a banner
+     * has replaced the display and no type is on the page
+     */
     name: string;
     /** which instance, where the display publishes `data-display-id` */
     id?: string;
@@ -68,17 +68,19 @@ export interface PendingDisplay {
     phase?: string;
 }
 /**
- * The same census, with each display's own account of itself.
+ * Displays still reporting unpainted, canceled, or failed to render, each with
+ * its own account of itself. The phase separates the cases a bare name runs
+ * together —
  *
- * `pendingDisplays` above answers WHICH, and that was the whole report: every
- * timeout read the same however it was caused. The phase separates the cases a
- * bare name runs together —
- *
- *   `loading`   still fetching. A slow page or a fetch that never returns.
- *   `error`     finished, badly. Nothing is coming; the picture is a banner.
- *   `ready`     it says it is done and reports no paint. That is the display's
- *               bug, not the wait's, and it is the one a longer timeout will
- *               never fix.
+ *   `loading`      still fetching. A slow page or a fetch that never returns.
+ *   `error`        finished, badly. Nothing is coming; the picture is a banner.
+ *   `canceled`     stopped by the user, and it stays stopped until Retry. It is
+ *                  in the census painted or not, since the picture is the
+ *                  Retry overlay whatever was drawn before.
+ *   `renderError`  its renderer failed; the picture is a Retry banner.
+ *   `ready`        it says it is done and reports no paint. That is the
+ *                  display's bug, not the wait's, and it is the one a longer
+ *                  timeout will never fix.
  *
  * Serialized into the page, so a test can call the real function. Read fresh
  * from the DOM at report time rather than from handles the waits held. A handle
@@ -87,6 +89,13 @@ export interface PendingDisplay {
  * timeouts into nine opaque puppeteer errors (reverted in 28c6ee6d90).
  */
 export declare function pendingDisplayStatesInPage(): PendingDisplay[];
+/**
+ * Displays showing the "too much data" banner in place of their features: the
+ * region is wider than the track fetches without being asked. Not a failure,
+ * since that is the app working as designed, but not the picture either.
+ * Serialized into the page.
+ */
+export declare function tooLargeDisplaysInPage(): PendingDisplay[];
 export declare function pendingDisplayStates(page: Page): Promise<PendingDisplay[]>;
 /** `pendingDisplayStates` as one line for an error message. */
 export declare function describePendingDisplays(pending: PendingDisplay[]): string;

package/esm/sessionGate.js

@@ -1,27 +1,15 @@
+import { holdTrue } from './poll.js';
 /**
  * The census the app publishes beside its phase: `AppReadyMarker` renders
  * `data-app-views` (a count), and `data-app-assemblies` / `data-app-tracks`
- * (JSON string arrays of what is open).
- *
- * One element answers the whole gate. Each view declares what it holds and
- * `openViews`/`openTracks` reduce over those declarations (ADR-103), so nothing
- * here has to know that a synteny view keeps its tracks on levels and its rows
- * on sub-views — the duck-typed walk of `window.JBrowseSession` that used to
- * live here, and drifted against the copy in `isPageBusyInPage`, is gone with
- * the builds that needed it.
- *
- * `scripts/readinessContract.test.ts` pins the attribute names against the
+ * (JSON string arrays of what is open). Each view declares what it holds and
+ * `openViews`/`openTracks` reduce over those declarations (ADR-103), so
+ * nothing here has to know which property a container view keeps its children
+ * on. `scripts/readinessContract.test.ts` pins the attribute names against the
  * marker, since neither package may import the other.
+ *
+ * Serialized into the page, so it can only call what it declares.
  */
-export const APP_CENSUS = '[data-app-tracks]';
-/** What the page currently has open, or undefined if there is no census yet. */
-export function readSessionSummary(page) {
-    return page.evaluate(readSessionSummaryInPage);
-}
-// Serialized into the page, so it can only call what it declares. Exported for
-// its test: it reads the document and nothing else, so calling it in node
-// against a staged DOM exercises the very function puppeteer serializes, rather
-// than a copy of it that can drift.
 export function readSessionSummaryInPage() {
     const marker = document.querySelector('[data-app-tracks]');
     if (!marker) {
@@ -38,50 +26,53 @@ export function readSessionSummaryInPage() {
         return undefined;
     }
 }
+/**
+ * The message the app shows in place of itself when its config, session or
+ * plugins fail to load. Serialized into the page.
+ */
+export function readLoadFailureInPage() {
+    return document.querySelector('[data-app-error]')?.dataset
+        .appError;
+}
 /**
  * Wait until the census exists and the assembly and tracks that were asked for
  * are actually open.
  *
- * Throws on timeout rather than proceeding. A config URL that 404s, a trackId
- * that does not exist in the config, and an assembly name that does not match
- * the one the config declares all fail here, which is the only place they fail
- * at all — each of them otherwise produces a browser that loads, paints its
- * chrome, and photographs beautifully with nothing in it.
+ * A config, session or plugin that fails to load fails here at once, with the
+ * app's own message. A trackId that does not exist in the config, and an
+ * assembly name that does not match the one the config declares, fail here on
+ * timeout, which is the only place they fail at all — each of them otherwise
+ * produces a browser that loads, paints its chrome, and photographs beautifully
+ * with nothing in it.
  */
-export async function waitForSession(page, { assembly, trackIds = [], timeout = 60000, } = {}) {
-    try {
-        // #region session-gate
-        await page.waitForFunction((wantAssembly, wantTracks) => {
-            const marker = document.querySelector('[data-app-tracks]');
-            if (!marker) {
-                return false;
-            }
-            try {
-                const openViews = Number(marker.dataset.appViews) || 0;
-                const assemblies = JSON.parse(marker.dataset.appAssemblies ?? '[]');
-                const openTracks = JSON.parse(marker.dataset.appTracks ?? '[]');
-                return (openViews > 0 &&
-                    (wantAssembly === null || assemblies.includes(wantAssembly)) &&
-                    wantTracks.every(id => openTracks.includes(id)));
-            }
-            catch {
-                return false;
-            }
-        }, { timeout, polling: 250 }, assembly ?? null, trackIds);
-        // #endregion session-gate
-    }
-    catch {
-        // Best-effort: the wait may have failed because the page crashed or
-        // navigated, and an unguarded evaluate here would replace the diagnostic
-        // below with its own opaque error.
-        const summary = await readSessionSummary(page).catch(() => undefined);
-        const found = summary
-            ? `${summary.views} view(s), assemblies [${summary.assemblies.join(', ')}], tracks [${summary.trackIds.join(', ')}]`
-            : 'no census on the page at all — either this is not a JBrowse app, or ' +
-                'it predates the readiness marker, in which case point --instance at a ' +
-                'build that publishes one';
-        const missing = summary
-            ? trackIds.filter(id => !summary.trackIds.includes(id))
+export async function waitForSession(page, { assembly, trackIds = [], views = 1, timeout = 60000, } = {}) {
+    // a page that navigates or closes under us fails the evaluate, which reads as
+    // nothing there yet and leaves the deadline to decide
+    let summary;
+    const reached = await holdTrue(async () => {
+        const failure = await page
+            .evaluate(readLoadFailureInPage)
+            .catch(() => undefined);
+        if (failure) {
+            throw new Error(`JBrowse could not load: ${failure}`);
+        }
+        const now = await page
+            .evaluate(readSessionSummaryInPage)
+            .catch(() => undefined);
+        summary = now;
+        return (!!now &&
+            now.views >= views &&
+            (assembly === undefined || now.assemblies.includes(assembly)) &&
+            trackIds.every(id => now.trackIds.includes(id)));
+    }, { holdMs: 0, timeout, pollMs: 250 });
+    if (!reached) {
+        const last = summary;
+        const found = last
+            ? `${last.views} view(s), assemblies [${last.assemblies.join(', ')}], tracks [${last.trackIds.join(', ')}]`
+            : 'no census on the page at all, so either this is not a JBrowse app or ' +
+                'it is older than v5, the first release to publish one';
+        const missing = last
+            ? trackIds.filter(id => !last.trackIds.includes(id))
             : trackIds;
         const wanted = [
             assembly ? `assembly "${assembly}"` : undefined,
@@ -90,32 +81,25 @@ export async function waitForSession(page, { assembly, trackIds = [], timeout =
             .filter(Boolean)
             .join(' and ');
         throw new Error(`the session never reached the requested state after ${timeout}ms. ` +
-            `Wanted ${wanted || 'an open view'}; found ${found}. ` +
-            'A config URL that 404s, a trackId the config does not define, or an ' +
-            'assembly name that does not match the config all look like this.');
+            `Wanted ${wanted || (views > 0 ? 'an open view' : 'a session')}; found ${found}. ` +
+            'A trackId the config does not define, or an assembly name that does ' +
+            'not match the config, looks like this.');
     }
 }
 /**
- * Displays that were still reporting unpainted at the moment of the call.
- *
- * Distinct from `unsettled`, which says a wait ran out of time. This says what
- * the page looked like when the shutter fired.
- */
-export async function pendingDisplays(page) {
-    return (await pendingDisplayStates(page)).map(d => d.name);
-}
-/**
- * The same census, with each display's own account of itself.
+ * Displays still reporting unpainted, canceled, or failed to render, each with
+ * its own account of itself. The phase separates the cases a bare name runs
+ * together —
  *
- * `pendingDisplays` above answers WHICH, and that was the whole report: every
- * timeout read the same however it was caused. The phase separates the cases a
- * bare name runs together —
- *
- *   `loading`   still fetching. A slow page or a fetch that never returns.
- *   `error`     finished, badly. Nothing is coming; the picture is a banner.
- *   `ready`     it says it is done and reports no paint. That is the display's
- *               bug, not the wait's, and it is the one a longer timeout will
- *               never fix.
+ *   `loading`      still fetching. A slow page or a fetch that never returns.
+ *   `error`        finished, badly. Nothing is coming; the picture is a banner.
+ *   `canceled`     stopped by the user, and it stays stopped until Retry. It is
+ *                  in the census painted or not, since the picture is the
+ *                  Retry overlay whatever was drawn before.
+ *   `renderError`  its renderer failed; the picture is a Retry banner.
+ *   `ready`        it says it is done and reports no paint. That is the
+ *                  display's bug, not the wait's, and it is the one a longer
+ *                  timeout will never fix.
  *
  * Serialized into the page, so a test can call the real function. Read fresh
  * from the DOM at report time rather than from handles the waits held. A handle
@@ -125,19 +109,34 @@ export async function pendingDisplays(page) {
  */
 export function pendingDisplayStatesInPage() {
     return [
-        ...document.querySelectorAll('[data-display-drawn="false"]'),
+        ...document.querySelectorAll('[data-display-drawn="false"], [data-display-phase="canceled"], [data-display-phase="renderError"]'),
     ].map(el => ({
-        name: el.dataset.testid ?? (el.id || 'unnamed display'),
+        name: el.dataset.testid ?? el.dataset.displayId ?? 'unnamed display',
         id: el.dataset.displayId,
         phase: el.dataset.displayPhase,
     }));
 }
+/**
+ * Displays showing the "too much data" banner in place of their features: the
+ * region is wider than the track fetches without being asked. Not a failure,
+ * since that is the app working as designed, but not the picture either.
+ * Serialized into the page.
+ */
+export function tooLargeDisplaysInPage() {
+    return [
+        ...document.querySelectorAll('[data-display-phase="tooLarge"]'),
+    ].map(el => ({
+        name: el.dataset.displayId ?? 'unnamed display',
+        id: el.dataset.displayId,
+        phase: 'tooLarge',
+    }));
+}
 export function pendingDisplayStates(page) {
     return page.evaluate(pendingDisplayStatesInPage);
 }
 /** `pendingDisplayStates` as one line for an error message. */
 export function describePendingDisplays(pending) {
     return pending
-        .map(d => `${d.name}${d.id ? ` (${d.id})` : ''} is ${d.phase ?? 'in an unpublished phase'}`)
+        .map(d => `${d.name}${d.id && d.id !== d.name ? ` (${d.id})` : ''} is ${d.phase ?? 'in an unpublished phase'}`)
         .join('; ');
 }

package/esm/sessionOverflow.d.ts

@@ -0,0 +1,11 @@
+/**
+ * How many CSS pixels of the session lie below the window.
+ *
+ * JBrowse scrolls a column inside the app rather than the document, so the
+ * document is always exactly the window's height. The overflow is that column's,
+ * found as `overflow` in jbApi finds it, less the trailing room `ViewStack`
+ * leaves for scrolling the last view up, which is space rather than content.
+ *
+ * Serialized into the page, so it declares everything it uses.
+ */
+export declare function sessionOverflowInPage(): number;

package/esm/sessionOverflow.js

@@ -0,0 +1,24 @@
+/**
+ * How many CSS pixels of the session lie below the window.
+ *
+ * JBrowse scrolls a column inside the app rather than the document, so the
+ * document is always exactly the window's height. The overflow is that column's,
+ * found as `overflow` in jbApi finds it, less the trailing room `ViewStack`
+ * leaves for scrolling the last view up, which is space rather than content.
+ *
+ * Serialized into the page, so it declares everything it uses.
+ */
+export function sessionOverflowInPage() {
+    const container = document.querySelector('[data-testid^="view-container-"]');
+    for (let el = container?.parentElement; el; el = el.parentElement) {
+        const { overflowY } = getComputedStyle(el);
+        if ((overflowY === 'auto' || overflowY === 'scroll') &&
+            el.scrollHeight > el.clientHeight) {
+            const room = el
+                .querySelector('[data-testid="view-stack-overscroll"]')
+                ?.getBoundingClientRect().height ?? 0;
+            return Math.max(0, Math.ceil(el.scrollHeight - room - el.clientHeight));
+        }
+    }
+    return Math.max(0, document.documentElement.scrollHeight - window.innerHeight);
+}

package/esm/url.d.ts

@@ -14,13 +14,23 @@ export interface JBrowseUrlOptions {
     loc?: string;
     /** trackIds from the config to open. */
     tracks?: string[];
-    /** The full session spec, for anything the three fields above cannot say. */
+    /** A session spec, for anything the three fields above cannot say. */
+    spec?: object;
+    /**
+     * A session saved with "Export session...": the `{ session: {...} }`
+     * document, or the snapshot inside it.
+     */
     session?: object;
     /** Name the session carries once opened. */
     sessionName?: string;
     /** JBrowse Web deployment to load. Defaults to the public one. */
     instance?: string;
 }
+/**
+ * A spec or a saved session says which assembly, locations and tracks to open,
+ * and the URL can carry one of the three ways of saying so, never two.
+ */
+export declare function assertSessionStandsAlone({ spec, session, assembly, loc, tracks, }: JBrowseUrlOptions): void;
 /**
  * The URL that opens a JBrowse Web instance onto a described view. Useful on its
  * own: an agent can hand this to a human, or paste it into a report, without
@@ -29,11 +39,11 @@ export interface JBrowseUrlOptions {
  * Two ways to say where to go, and they are not interchangeable. `assembly` /
  * `loc` / `tracks` become the [URL parameters](https://jbrowse.org/jb2/docs/urlparams/),
  * which route `loc` through the config's text-search index, so a **gene name**
- * works there. `session` becomes a
+ * works there. `spec` becomes a
  * [session spec](https://jbrowse.org/jb2/docs/urlparams/#session-spec), which
  * can describe several views and per-display settings but whose `init.loc` is
- * parsed as a locstring only and throws on a gene name. Pass one or the other;
- * `session` wins, and the URL params are dropped rather than silently starting
- * the fresh session that `&loc=` otherwise forces.
+ * parsed as a locstring only and throws on a gene name, and `session` opens a
+ * saved session as it was exported. Pass one of the three: `&loc=` starts a
+ * fresh session, so the URL cannot carry two.
  */
-export declare function jbrowseUrl({ hub, config, assembly, loc, tracks, session, sessionName, instance, }: JBrowseUrlOptions): string;
+export declare function jbrowseUrl({ hub, config, assembly, loc, tracks, spec, session, sessionName, instance, }: JBrowseUrlOptions): string;

package/esm/url.js

@@ -1,8 +1,22 @@
 import { hubUrl } from './hub.js';
-import { sessionSpecParam } from './session.js';
+import { savedSessionParam, sessionSpecParam } from './session.js';
 // The public JBrowse Web build the docs' own figure links point at. Any other
 // deployment works the same way, including a local `npx serve` of a build.
 export const PUBLIC_INSTANCE = 'https://jbrowse.org/code/jb2/latest/';
+/**
+ * A spec or a saved session says which assembly, locations and tracks to open,
+ * and the URL can carry one of the three ways of saying so, never two.
+ */
+export function assertSessionStandsAlone({ spec, session, assembly, loc, tracks, }) {
+    if (spec && session) {
+        throw new Error('pass a session spec or a saved session, not both');
+    }
+    if ((spec || session) && (assembly || loc || tracks?.length)) {
+        throw new Error('a session spec or saved session says which assembly, locations and ' +
+            'tracks to open, so it cannot be combined with assembly, loc or tracks ' +
+            '(--assembly, --loc, --track): put them in the session');
+    }
+}
 /**
  * The URL that opens a JBrowse Web instance onto a described view. Useful on its
  * own: an agent can hand this to a human, or paste it into a report, without
@@ -11,34 +25,37 @@ export const PUBLIC_INSTANCE = 'https://jbrowse.org/code/jb2/latest/';
  * Two ways to say where to go, and they are not interchangeable. `assembly` /
  * `loc` / `tracks` become the [URL parameters](https://jbrowse.org/jb2/docs/urlparams/),
  * which route `loc` through the config's text-search index, so a **gene name**
- * works there. `session` becomes a
+ * works there. `spec` becomes a
  * [session spec](https://jbrowse.org/jb2/docs/urlparams/#session-spec), which
  * can describe several views and per-display settings but whose `init.loc` is
- * parsed as a locstring only and throws on a gene name. Pass one or the other;
- * `session` wins, and the URL params are dropped rather than silently starting
- * the fresh session that `&loc=` otherwise forces.
+ * parsed as a locstring only and throws on a gene name, and `session` opens a
+ * saved session as it was exported. Pass one of the three: `&loc=` starts a
+ * fresh session, so the URL cannot carry two.
  */
-export function jbrowseUrl({ hub, config, assembly = hub, loc, tracks, session, sessionName, instance = PUBLIC_INSTANCE, }) {
-    const configUrl = config ?? (hub ? hubUrl(hub) : undefined);
-    const url = new URL(instance);
-    // URL's own encoder, not a hand-built query string: a config URL contains
-    // `://` and `?`, and a session spec is a whole JSON document, so appending
-    // either raw produces a link that loads a truncated config and reports
-    // nothing.
+export function jbrowseUrl({ hub, config, assembly, loc, tracks, spec, session, sessionName, instance = PUBLIC_INSTANCE, }) {
+    assertSessionStandsAlone({ spec, session, assembly, loc, tracks });
+    // In the fragment, which never reaches a server: a whole session spec in the
+    // query string can exceed the request-line limit and come back HTTP 414.
+    const params = new URLSearchParams();
     const set = (key, value) => {
         if (value) {
-            url.searchParams.set(key, value);
+            params.set(key, value);
         }
     };
-    set('config', configUrl);
-    if (session) {
-        set('session', sessionSpecParam(session));
+    set('config', config ?? (hub ? hubUrl(hub) : undefined));
+    if (spec) {
+        set('session', sessionSpecParam(spec));
+    }
+    else if (session) {
+        set('session', savedSessionParam(session));
     }
     else {
-        set('assembly', assembly);
+        set('assembly', assembly ?? hub);
         set('loc', loc);
         set('tracks', tracks?.join(','));
     }
     set('sessionName', sessionName);
+    const url = new URL(instance);
+    url.hash = params.toString();
     return url.href;
 }

package/esm/waits.d.ts

@@ -1,5 +1,4 @@
 import type { ElementHandle, Page } from 'puppeteer';
-export declare const delay: (ms: number) => Promise<void>;
 export declare const LOADING_OVERLAY = "[data-testid=\"loading-overlay\"]";
 /**
  * The whole readiness contract, in one selector.
@@ -17,6 +16,14 @@ export declare const LOADING_OVERLAY = "[data-testid=\"loading-overlay\"]";
  * capture taken in it is a picture of an empty browser.
  */
 export declare const APP_READY = "[data-app-phase=\"ready\"]";
+/**
+ * A display drawing a transition between two settled pictures: canvas's row
+ * morph, a multi-way lane re-aligning. The app is finished working and every
+ * display reads `ready`, so neither the marker nor the phase can say so; the
+ * display publishes it itself, and a frame taken while it reads `true` is a
+ * picture no settled state ever shows.
+ */
+export declare const ANIMATING_DISPLAYS = "[data-display-animating=\"true\"]";
 /**
  * Wait until the loading overlay is gone, and with `waitForDownloads` until
  * nothing else reports itself busy either — a remote fetch can outlive the
@@ -72,11 +79,8 @@ export declare const PENDING_DISPLAYS = "[data-display-drawn=\"false\"]";
  * finished badly and is showing a banner, and `ready` is a display claiming it
  * finished without drawing — a bug in the display rather than in the wait.
  *
- * An EMPTY census is the other answer, and `tooLarge` / `renderError` are why it
- * is not good news. Those two replace the display's subtree outright, so they
- * publish neither attribute and appear here as nothing at all: a wait on such a
- * display can never resolve and can never be reported. Nothing pending means
- * either that, or a selector that was never a display's.
+ * A display showing "too much data" is not pending, and a wait on its body
+ * can never resolve, so the census names those too.
  */
 export declare function waitForSelectorAttributed(page: Page, selector: string, timeoutMs: number): Promise<ElementHandle>;
 /**
@@ -91,8 +95,6 @@ export declare const displayPainted: (testid: string) => string;
  * on the phase instead.
  */
 export declare const displaySettled: (testid: string) => string;
-/** One display, by its config's `displayId` rather than by type. */
-export declare const displayById: (displayId: string) => string;
 export declare function waitForDisplaysDone(page: Page, timeoutMs: number): Promise<boolean>;
 export declare function waitForDisplayPhases(page: Page, timeoutMs: number): Promise<boolean>;
 export declare function waitForViewPhases(page: Page, timeoutMs: number): Promise<import("puppeteer").JSHandle<false> | import("puppeteer").JSHandle<true>>;
@@ -109,6 +111,7 @@ export declare function waitForViewPhases(page: Page, timeoutMs: number): Promis
  *                          wherever it tells a user it is working
  *   `data-display-phase`   one display's own fetch, newer builds
  *   `data-view-phase`      a view still resolving its assembly, newer builds
+ *   `data-display-animating`  a display drawing a morph, newer builds
  */
 export declare const BUSY_SELECTOR: string;
 /**
@@ -141,9 +144,6 @@ export declare function isPageBusyInPage(busySelector: string): boolean;
  * "nothing is in flight right now", which is what a probe or a benchmark wants
  * between two measured actions.
  *
- * Polled from node rather than in-page: chrome throttles in-page timers and rAF
- * once the tab is not visible, which is the state a headless capture sits in.
- *
  * Returns false on timeout rather than throwing, like its neighbours.
  */
 export declare function waitForQuietPeriod(page: Page, { quietMs, timeout, pollMs, }?: {
@@ -165,8 +165,6 @@ export declare function waitForQuietPeriod(page: Page, { quietMs, timeout, pollM
 export declare function waitForAppReady(page: Page, { timeout }?: {
     timeout?: number;
 }): Promise<boolean>;
-/** Whether this build publishes the app-level readiness marker at all. */
-export declare function hasAppReadyMarker(page: Page): Promise<boolean>;
 /**
  * Wait out work an INTERACTION started: `ready`, and still ready a beat later.
  *
@@ -191,9 +189,8 @@ export declare function hasAppReadyMarker(page: Page): Promise<boolean>;
  * replaced. Requiring the idle to HOLD costs the hold and no more, and catches
  * the same late-starting work.
  *
- * Polled from Node rather than by `page.waitForSelector`, for the reason
- * `waitForQuietPeriod` is: chrome throttles in-page timers and rAF once the tab
- * is not visible, which is exactly the state a headless capture sits in.
+ * The hold also requires no view body to be waiting on its lazy component and
+ * no display to be animating, neither of which the marker can see.
  *
  * Throws on a build too old for the marker rather than falling back — see the
  * body.