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

package/esm/sessionGate.js

@@ -1,73 +1,46 @@
-// `window.JBrowseSession` is jbrowse-web's own devtools/automation handle
-// (products/jbrowse-web/src/components/JBrowse.tsx). It is declared `unknown`
-// there and is a live MST node here, so a cast at the page boundary is
-// unavoidable. It is repeated in each function below rather than shared: every
-// one of them is serialized into the page by puppeteer, so it can only call what
-// it declares inside itself.
 /**
  * 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). On a build that has it, the session
- * gate and the summary are a read of ONE element — no walk of the session
- * model, so nothing here has to know which property a container view keeps its
- * children on. The session walk below each census read is the fallback for a
- * deployed build older than the census, and goes when the legacy chain does.
+ * (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 const APP_CENSUS = '[data-app-tracks]';
-/** What the page currently has open, or undefined if there is no session yet. */
+/** 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 — hence the
-// inlined copy of readViews rather than a shared import.
-//
-// Exported for its test: it reads `globalThis.JBrowseSession` and nothing else,
-// so calling it in node against a stubbed global exercises the very function
-// puppeteer serializes, rather than a copy of it that can drift.
+// 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() {
-    // census first: one element, no walk (see APP_CENSUS)
     const marker = document.querySelector('[data-app-tracks]');
-    if (marker) {
-        try {
-            return {
-                views: Number(marker.dataset.appViews) || 0,
-                assemblies: JSON.parse(marker.dataset.appAssemblies ?? '[]'),
-                trackIds: JSON.parse(marker.dataset.appTracks ?? '[]'),
-            };
-        }
-        catch {
-            // a malformed census falls through to the walk rather than failing the read
-        }
-    }
-    const session = globalThis.JBrowseSession;
-    const views = session?.views;
-    if (!views) {
+    if (!marker) {
         return undefined;
     }
-    // Inlined rather than shared with the gate below for the same reason as the
-    // readViews copy: both are serialized into the page.
-    function collect(v) {
-        return [
-            ...(v.tracks ?? []),
-            ...(v.trackContainers ?? v.levels ?? []).flatMap(l => l.tracks ?? []),
-            ...(v.views ?? []).flatMap(collect),
-        ];
+    try {
+        return {
+            views: Number(marker.dataset.appViews) || 0,
+            assemblies: JSON.parse(marker.dataset.appAssemblies ?? '[]'),
+            trackIds: JSON.parse(marker.dataset.appTracks ?? '[]'),
+        };
+    }
+    catch {
+        return undefined;
     }
-    return {
-        views: views.length,
-        assemblies: [
-            ...new Set(views.flatMap(function asm(v) {
-                return [...(v.assemblyNames ?? []), ...(v.views ?? []).flatMap(asm)];
-            })),
-        ],
-        trackIds: views.flatMap(v => collect(v).map(t => t.configuration?.trackId ?? '(unnamed)')),
-    };
 }
 /**
- * Wait until the session exists, every view reports itself initialized, and the
- * assembly and tracks that were asked for are actually open.
+ * 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
@@ -79,53 +52,21 @@ export async function waitForSession(page, { assembly, trackIds = [], timeout =
     try {
         // #region session-gate
         await page.waitForFunction((wantAssembly, wantTracks) => {
-            // The census the app publishes on its ready marker (see APP_CENSUS):
-            // on a build that has it, the whole gate is a read of one element.
             const marker = document.querySelector('[data-app-tracks]');
-            if (marker) {
-                try {
-                    const openViews = Number(marker.dataset.appViews);
-                    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;
-                }
-            }
-            // No census: a deployed build older than the marker's attributes, so
-            // walk the session model it publishes instead.
-            const session = globalThis.JBrowseSession;
-            const views = session?.views;
-            if (!views?.length) {
+            if (!marker) {
                 return false;
             }
-            // `initialized` is an LGV getter; a view type without one is mounted
-            // content the moment it exists, so absent counts as initialized and
-            // only an explicit false is pending.
-            if (views.some(v => v.initialized === false)) {
-                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)));
             }
-            // A container view (synteny, dotplot) keeps its assemblies on the rows
-            // and its tracks on the levels, so both walks descend into sub-views
-            // and levels rather than reading the top view only.
-            const asmOf = (v) => [
-                ...(v.assemblyNames ?? []),
-                ...(v.views ?? []).flatMap(asmOf),
-            ];
-            if (wantAssembly !== null &&
-                !views.some(v => asmOf(v).includes(wantAssembly))) {
+            catch {
                 return false;
             }
-            const tracksOf = (v) => [
-                ...(v.tracks ?? []),
-                ...(v.trackContainers ?? v.levels ?? []).flatMap(l => l.tracks ?? []),
-                ...(v.views ?? []).flatMap(tracksOf),
-            ];
-            const open = new Set(views.flatMap(v => tracksOf(v).map(t => t.configuration?.trackId)));
-            return wantTracks.every(id => open.has(id));
         }, { timeout, polling: 250 }, assembly ?? null, trackIds);
         // #endregion session-gate
     }
@@ -136,7 +77,9 @@ export async function waitForSession(page, { assembly, trackIds = [], timeout =
         const summary = await readSessionSummary(page).catch(() => undefined);
         const found = summary
             ? `${summary.views} view(s), assemblies [${summary.assemblies.join(', ')}], tracks [${summary.trackIds.join(', ')}]`
-            : 'no session on the page at all (is this a jbrowse-web instance?)';
+            : '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))
             : trackIds;
@@ -147,61 +90,16 @@ 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 initialized view'}; found ${found}. ` +
+            `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.');
     }
 }
-export const PAINT_CONTRACT_NOTE = 'this JBrowse build publishes no data-display-drawn attributes, so "every ' +
-    'display has painted" cannot be checked — only that nothing is still ' +
-    'loading. Raise --settle if the image looks half-drawn.';
-/**
- * Whether every open display's paint state was actually measurable.
- *
- * The per-display paint attributes are not universal. Measured on 2026-08-07:
- * jbrowse.org/code/jb2/main publishes `data-view-phase`, `data-display-phase`
- * and `data-display-drawn`; jbrowse.org/code/jb2/latest — the released build,
- * which is what every genomes.jbrowse.org link and every docs figure link opens
- * — publishes none of them and exposes only the loading overlay. Against that
- * instance the display-level waits are unfalsifiable rather than satisfied, so a
- * caller has to be told which of the two it got instead of reading "0 displays
- * pending" as good news.
- *
- * The absence of the attribute is NOT on its own the answer, which is the trap
- * here: a page with no tracks open — an import form, a menu shot, a bare view —
- * publishes none of it either, and reporting that as "this build cannot measure
- * paint" is both wrong and alarming. So this asks the question only when there
- * is something to measure, and answers true when there is not.
- *
- * Call it AFTER the session gate, so "no tracks open" means the page genuinely
- * has none rather than not having got there yet.
- */
-export async function hasPaintContract(page) {
-    const summary = await readSessionSummary(page);
-    if (summary && summary.trackIds.length === 0) {
-        return true;
-    }
-    return page.evaluate(() => document.querySelector('[data-display-drawn]') !== null);
-}
-/** Serialized into the page; exported so a test can call the real function. */
-export function readInstrumentationInPage() {
-    return {
-        viewPhase: document.querySelector('[data-view-phase]') !== null,
-        displayPhase: document.querySelector('[data-display-phase]') !== null,
-        displayDrawn: document.querySelector('[data-display-drawn]') !== null,
-    };
-}
-export function readInstrumentation(page) {
-    return page.evaluate(readInstrumentationInPage);
-}
 /**
  * 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, and the two do not imply each
- * other: a display can go back to pending after its stage passed. An empty
- * result means nothing at all on a build with no paint contract — check
- * `paintContract` before reading it as good news.
+ * the page looked like when the shutter fired.
  */
 export async function pendingDisplays(page) {
     return (await pendingDisplayStates(page)).map(d => d.name);
@@ -218,14 +116,12 @@ export async function pendingDisplays(page) {
  *   `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.
- *   absent      the element publishes no phase: a build older than the
- *               attribute, or a surface that never grew one.
  *
  * 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 to an element that has since re-rendered throws
- * `Node is detached from document`, which is how the previous attempt at this
- * turned four diagnosable timeouts into nine opaque puppeteer errors (reverted
- * in 28c6ee6d90).
+ * from the DOM at report time rather than from handles the waits held. A handle
+ * to an element that has since re-rendered throws `Node is detached from
+ * document`, which is how the previous attempt at this turned four diagnosable
+ * timeouts into nine opaque puppeteer errors (reverted in 28c6ee6d90).
  */
 export function pendingDisplayStatesInPage() {
     return [

package/esm/waits.d.ts

@@ -115,11 +115,15 @@ export declare const BUSY_SELECTOR: string;
  * Is the app doing anything right now?
  *
  * Serialized into the page, so it declares everything it uses and takes
- * `BUSY_SELECTOR` as an argument rather than importing it. Two sources: that
- * selector, and the live session model's own per-display status, which is the
- * only PER-DISPLAY signal a build with no readiness attributes has left. Both
- * are contracts rather than renderings — a model field and a set of data
- * attributes — so neither moves when the UI is restyled.
+ * `BUSY_SELECTOR` as an argument rather than importing it. Every signal is a
+ * data attribute a component sets deliberately, so restyling or rewording the
+ * UI cannot move the answer.
+ *
+ * It used to also walk `window.JBrowseSession` for each display's own status
+ * message — the only PER-DISPLAY signal a build with no readiness attributes
+ * had. That walk was a duck-typed copy of the session gate's, drifted onto a
+ * different container spelling (ADR-103), and it went with the builds that
+ * needed it: `data-display-phase="loading"` covers the same fetch directly.
  *
  * Exported so a test can call the real function rather than a copy of it.
  */
@@ -127,49 +131,25 @@ export declare function isPageBusyInPage(busySelector: string): boolean;
 /**
  * Wait until the app has been idle for an unbroken stretch.
  *
- * The gate for a build that publishes no readiness attributes, where every
- * other wait in this module is an assertion about an absent selector and so
- * cannot fail. Absence answers "is it working NOW"; a capture needs "has it
- * finished", and the two differ in both directions:
- *
- *   BEFORE the work starts. Measured on jbrowse.org/code/jb2/latest with two
- *   remote tracks: the session reports both tracks open at ~2.5s and the
- *   loading overlay does not go up until ~3.5s. Every absence-based gate passes
- *   during that second, over an app that has drawn nothing.
+ * Idle answers "is it working NOW"; a page is finished only if it stays that
+ * way, because a track that ends one fetch and starts the next is momentarily
+ * idle and a single-sample read takes that gap for the end. Requiring the idle
+ * to HOLD closes it.
  *
- *   BETWEEN two pieces of work. A track that finishes one fetch and starts the
- *   next is momentarily idle, and a single-sample gate takes it.
+ * NOT a readiness gate on its own — idle is an absence, equally true of an app
+ * that has not started. `waitForAppSettled` is the gate; this is the tool for
+ * "nothing is in flight right now", which is what a probe or a benchmark wants
+ * between two measured actions.
  *
- * Requiring the idle to HOLD closes both without needing to know which signals
- * a given build has. 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.
+ * 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 — the
- * caller decides whether a page that never went quiet is a failure or a slow
- * page worth capturing anyway.
+ * Returns false on timeout rather than throwing, like its neighbours.
  */
-export declare function waitForQuietPeriod(page: Page, { quietMs, timeout, pollMs, busyWindowMs, }?: {
+export declare function waitForQuietPeriod(page: Page, { quietMs, timeout, pollMs, }?: {
     quietMs?: number;
     timeout?: number;
     pollMs?: number;
-    /**
-     * Wait for the app to be seen BUSY before any idle counts, giving up on
-     * that after this long. Zero (the default) accepts idle immediately.
-     *
-     * This is what turns the wait positive. Idle is still an absence, so an app
-     * that has not begun looks exactly like one that has finished — measured on
-     * jbrowse.org/code/jb2/latest, where a chain starting at the session gate
-     * saw an idle page at 1.6s and the tracks did not draw until past 10s.
-     * Seeing the transition INTO work and back out of it is an observation of
-     * the work itself.
-     *
-     * The window is bounded because a page with nothing to fetch never goes
-     * busy at all, and hanging on that would be worse than the race it closes.
-     * Size it above the gap between the session gate passing and the first
-     * indicator appearing, measured at ~1s on that instance.
-     */
-    busyWindowMs?: number;
 }): Promise<boolean>;
 /**
  * Wait for the FIRST frame the app says it has finished.
@@ -180,8 +160,7 @@ export declare function waitForQuietPeriod(page: Page, { quietMs, timeout, pollM
  * debounced next one starting. `waitForAppSettled` requires it to HOLD, and is
  * what both the chain here and `jb.waitReady` use.
  *
- * Returns false if the page never publishes it, which is how a caller tells "not
- * ready yet" from "a build too old to have the marker" and falls back.
+ * Returns false if it never appears within the timeout.
  */
 export declare function waitForAppReady(page: Page, { timeout }?: {
     timeout?: number;
@@ -216,9 +195,8 @@ export declare function hasAppReadyMarker(page: Page): Promise<boolean>;
  * `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.
  *
- * Falls back to the quiet period on a build too old for the marker, rather than
- * passing instantly. A no-op that reports success is how a spec that dropped its
- * sleep for this ends up capturing the frame the sleep was there to avoid.
+ * Throws on a build too old for the marker rather than falling back — see the
+ * body.
  */
 export declare function waitForAppSettled(page: Page, { timeout, holdMs, pollMs, }?: {
     timeout?: number;

package/esm/waits.js

@@ -55,7 +55,7 @@ const APP_SETTLED_HOLD_MS = 1000;
  * finished, and there is no content behind it to fall through to.
  */
 export async function waitForLoadingComplete(page, { timeout = 30000, waitForDownloads = false, } = {}) {
-    await page.waitForFunction((selector) => document.querySelectorAll(selector).length === 0, { timeout, polling: 'mutation' }, LOADING_OVERLAY);
+    await page.waitForFunction((selector) => document.querySelector(selector) === null, { timeout, polling: 'mutation' }, LOADING_OVERLAY);
     // `quietMs: 0` because this is the "nothing is in flight right now" question;
     // the one that needs the idle to hold is waitForQuietPeriod's own caller.
     return waitForDownloads
@@ -257,7 +257,7 @@ export function waitForViewPhases(page, timeoutMs) {
  *   `data-view-phase`      a view still resolving its assembly, newer builds
  */
 export const BUSY_SELECTOR = [
-    '[data-testid="loading-overlay"]',
+    LOADING_OVERLAY,
     '[data-busy="true"]',
     '[data-display-phase="loading"]',
     '[data-view-phase="loading"]',
@@ -266,60 +266,42 @@ export const BUSY_SELECTOR = [
  * Is the app doing anything right now?
  *
  * Serialized into the page, so it declares everything it uses and takes
- * `BUSY_SELECTOR` as an argument rather than importing it. Two sources: that
- * selector, and the live session model's own per-display status, which is the
- * only PER-DISPLAY signal a build with no readiness attributes has left. Both
- * are contracts rather than renderings — a model field and a set of data
- * attributes — so neither moves when the UI is restyled.
+ * `BUSY_SELECTOR` as an argument rather than importing it. Every signal is a
+ * data attribute a component sets deliberately, so restyling or rewording the
+ * UI cannot move the answer.
+ *
+ * It used to also walk `window.JBrowseSession` for each display's own status
+ * message — the only PER-DISPLAY signal a build with no readiness attributes
+ * had. That walk was a duck-typed copy of the session gate's, drifted onto a
+ * different container spelling (ADR-103), and it went with the builds that
+ * needed it: `data-display-phase="loading"` covers the same fetch directly.
  *
  * Exported so a test can call the real function rather than a copy of it.
  */
 export function isPageBusyInPage(busySelector) {
-    if (document.querySelector(busySelector)) {
-        return true;
-    }
-    const session = globalThis
-        .JBrowseSession;
-    const tracksOf = (c) => (c.tracks ?? []).flatMap(t => t.displays ?? []);
-    const displaysOf = (v) => [
-        ...tracksOf(v),
-        ...(v.trackContainers ?? v.levels ?? []).flatMap(tracksOf),
-        ...(v.views ?? []).flatMap(displaysOf),
-    ];
-    return (session?.views ?? [])
-        .flatMap(displaysOf)
-        .some(d => (d.message ?? d.statusMessage ?? '').trim() !== '');
+    return document.querySelector(busySelector) !== null;
 }
 /**
  * Wait until the app has been idle for an unbroken stretch.
  *
- * The gate for a build that publishes no readiness attributes, where every
- * other wait in this module is an assertion about an absent selector and so
- * cannot fail. Absence answers "is it working NOW"; a capture needs "has it
- * finished", and the two differ in both directions:
- *
- *   BEFORE the work starts. Measured on jbrowse.org/code/jb2/latest with two
- *   remote tracks: the session reports both tracks open at ~2.5s and the
- *   loading overlay does not go up until ~3.5s. Every absence-based gate passes
- *   during that second, over an app that has drawn nothing.
+ * Idle answers "is it working NOW"; a page is finished only if it stays that
+ * way, because a track that ends one fetch and starts the next is momentarily
+ * idle and a single-sample read takes that gap for the end. Requiring the idle
+ * to HOLD closes it.
  *
- *   BETWEEN two pieces of work. A track that finishes one fetch and starts the
- *   next is momentarily idle, and a single-sample gate takes it.
+ * NOT a readiness gate on its own — idle is an absence, equally true of an app
+ * that has not started. `waitForAppSettled` is the gate; this is the tool for
+ * "nothing is in flight right now", which is what a probe or a benchmark wants
+ * between two measured actions.
  *
- * Requiring the idle to HOLD closes both without needing to know which signals
- * a given build has. 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.
+ * 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 — the
- * caller decides whether a page that never went quiet is a failure or a slow
- * page worth capturing anyway.
+ * Returns false on timeout rather than throwing, like its neighbours.
  */
-export async function waitForQuietPeriod(page, { quietMs = 1500, timeout = 30000, pollMs = 250, busyWindowMs = 0, } = {}) {
-    const start = Date.now();
-    const deadline = start + timeout;
+export async function waitForQuietPeriod(page, { quietMs = 1500, timeout = 30000, pollMs = 250, } = {}) {
+    const deadline = Date.now() + timeout;
     let quietSince;
-    let seenBusy = busyWindowMs === 0;
     while (Date.now() < deadline) {
         // A page that navigates or closes under us fails the evaluate; treat that
         // as busy and let the deadline decide, rather than reporting quiet.
@@ -328,22 +310,12 @@ export async function waitForQuietPeriod(page, { quietMs = 1500, timeout = 30000
             .catch(() => true);
         const now = Date.now();
         if (busy) {
-            seenBusy = true;
             quietSince = undefined;
         }
         else {
-            if (!seenBusy && now - start >= busyWindowMs) {
-                // Never went busy within the window: nothing to wait out, and the idle
-                // that already ran the length of the window counts towards the hold —
-                // every sample in it was idle, since a failed evaluate reads as busy.
-                seenBusy = true;
-                quietSince = start;
-            }
-            if (seenBusy) {
-                quietSince ??= now;
-                if (now - quietSince >= quietMs) {
-                    return true;
-                }
+            quietSince ??= now;
+            if (now - quietSince >= quietMs) {
+                return true;
             }
         }
         await delay(pollMs);
@@ -359,8 +331,7 @@ export async function waitForQuietPeriod(page, { quietMs = 1500, timeout = 30000
  * debounced next one starting. `waitForAppSettled` requires it to HOLD, and is
  * what both the chain here and `jb.waitReady` use.
  *
- * Returns false if the page never publishes it, which is how a caller tells "not
- * ready yet" from "a build too old to have the marker" and falls back.
+ * Returns false if it never appears within the timeout.
  */
 export function waitForAppReady(page, { timeout = 30000 } = {}) {
     return settled(page.waitForSelector(APP_READY, { timeout, visible: false }));
@@ -397,13 +368,19 @@ export function hasAppReadyMarker(page) {
  * `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.
  *
- * Falls back to the quiet period on a build too old for the marker, rather than
- * passing instantly. A no-op that reports success is how a spec that dropped its
- * sleep for this ends up capturing the frame the sleep was there to avoid.
+ * Throws on a build too old for the marker rather than falling back — see the
+ * body.
  */
 export async function waitForAppSettled(page, { timeout = 30000, holdMs = APP_SETTLED_HOLD_MS, pollMs = 250, } = {}) {
     if (!(await hasAppReadyMarker(page))) {
-        return waitForQuietPeriod(page, { quietMs: holdMs, timeout, pollMs });
+        // Throws rather than falling back to the quiet period. The fallback was a
+        // no-op that reported success on a build with no attributes at all, which
+        // is how a spec that dropped its fixed sleep for this ended up capturing
+        // the frame the sleep was there to avoid. A build without the marker needs
+        // a newer build, not a wait that cannot fail.
+        throw new Error('this page publishes no [data-app-phase], so there is nothing positive ' +
+            'to wait for — every other readiness attribute is an absence an app ' +
+            'that has not started also satisfies.');
     }
     const deadline = Date.now() + timeout;
     let readySince;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/capture",
-  "version": "5.0.0-beta.4",
+  "version": "5.0.0-beta.8",
   "description": "Drive a JBrowse 2 instance with Puppeteer and screenshot it once it has actually finished rendering",
   "keywords": [
     "jbrowse",
@@ -34,7 +34,7 @@
     "puppeteer": "^25.10.0"
   },
   "devDependencies": {
-    "@jbrowse/core": "^5.0.0-beta.4"
+    "@jbrowse/core": "^5.0.0-beta.8"
   },
   "publishConfig": {
     "access": "public"