@jbrowse/capture 5.0.0-beta.13 → 5.0.0-beta.14

package/README.md

@@ -208,6 +208,37 @@ picture with the callout missing or parked in a corner.
 In a script, pass the same array as `annotations` to `captureJBrowse`, or call
 `drawAnnotations(page, annotations)` on the page `openJBrowse` returns.
 
+## Many screenshots from one browser
+
+`jb2capture batch` takes a JSON array with one object per image and draws them
+all from one browser. Each image gets a window of its own, closed after its
+screenshot, so no session state passes from one image to the next.
+
+```bash
+jb2capture batch captures.json --hub hg38 --track hg38-ncbiRefSeqCurated
+```
+
+```json
+[
+  { "loc": "BRCA1", "out": "brca1.png" },
+  { "loc": "TP53", "out": "tp53.png", "tracks": ["hg38-clinvarMain"] }
+]
+```
+
+An object names its `out` and may set `hub`, `config`, `assembly`, `loc`,
+`tracks`, `spec`, `session`, `width`, `height`, `dpr`, `fullPage` and
+`annotations`. The command-line flags are the defaults for what an object leaves
+out. `--concurrency` sets how many windows are open at once (default 4).
+
+Each image is reported on a line of its own with the time it took. A failed
+image is reported and the rest carry on, a browser that died is relaunched for
+the images left, and the exit code is 1 if any image failed. Chrome flags and
+`--headed` apply to the whole batch, so images that need different ones go in
+separate batches.
+
+In a script, `captureBatch(captures, { concurrency })` takes an array of
+`captureJBrowse` options and returns one result per capture, in order.
+
 ## CLI
 
 `jb2capture --help` for the full list. Also:

package/esm/annotationOverlay.js

@@ -534,7 +534,7 @@ export function drawAnnotationOverlay(items, overlayId) {
             rect.setAttribute('height', String(a.height ?? 0));
             rect.setAttribute('rx', '4');
             // a positive fillOpacity tints the box with a translucent wash of its
-            // own colour (a "light green/orange" highlight); otherwise hollow
+            // own color (a "light green/orange" highlight); otherwise hollow
             rect.setAttribute('fill', a.fillOpacity ? color : 'none');
             if (a.fillOpacity) {
                 rect.setAttribute('fill-opacity', String(a.fillOpacity));

package/esm/args.d.ts

@@ -1,5 +1,5 @@
 export interface ParsedArgs {
-    command: 'capture' | 'url' | 'list';
+    command: 'capture' | 'batch' | 'url' | 'list';
     hub?: string;
     config?: string;
     assembly?: string;
@@ -13,6 +13,7 @@ export interface ParsedArgs {
     height?: number;
     dpr?: number;
     timeout?: number;
+    concurrency?: number;
     fullPage: boolean;
     annotations?: string;
     headed: boolean;
@@ -20,7 +21,7 @@ export interface ParsedArgs {
     help: boolean;
     version: boolean;
     allowUnsettled: boolean;
-    /** `list`'s hub and filter. Empty for the other commands. */
+    /** `list`'s hub and filter, or `batch`'s manifest. Empty for the other commands. */
     positionals: string[];
 }
 /**

package/esm/args.js

@@ -15,6 +15,7 @@ const OPTIONS = {
     height: { type: 'string' },
     dpr: { type: 'string' },
     timeout: { type: 'string' },
+    concurrency: { type: 'string' },
     fullPage: { type: 'boolean', default: false },
     annotations: { type: 'string' },
     headed: { type: 'boolean', default: false },
@@ -25,6 +26,8 @@ const OPTIONS = {
 };
 const EVERY_COMMAND = ['help', 'version'];
 const SUBCOMMAND_FLAGS = {
+    capture: new Set(Object.keys(OPTIONS).filter(f => f !== 'concurrency')),
+    batch: new Set(Object.keys(OPTIONS).filter(f => f !== 'out')),
     url: new Set([
         'hub',
         'config',
@@ -69,26 +72,25 @@ function positive(name, raw) {
  */
 export function parseArgs(argv) {
     const [first, ...afterCommand] = argv;
-    const command = first === 'list' || first === 'url' ? first : 'capture';
+    const command = first === 'list' || first === 'url' || first === 'batch' ? first : 'capture';
     const { values, positionals, tokens } = parseNodeArgs({
         args: command === 'capture' ? argv : afterCommand,
         options: OPTIONS,
-        allowPositionals: command === 'list',
+        allowPositionals: command === 'list' || command === 'batch',
         tokens: true,
     });
-    if (command !== 'capture') {
-        for (const token of tokens) {
-            if (token.kind === 'option' &&
-                !SUBCOMMAND_FLAGS[command].has(token.name)) {
-                throw new Error(`${token.rawName} does not apply to \`jb2capture ${command}\``);
-            }
+    for (const token of tokens) {
+        if (token.kind === 'option' && !SUBCOMMAND_FLAGS[command].has(token.name)) {
+            throw new Error(command === 'capture'
+                ? `${token.rawName} applies only to \`jb2capture batch\``
+                : `${token.rawName} does not apply to \`jb2capture ${command}\``);
         }
     }
     const fromStdin = ['spec', 'session', 'annotations'].filter(flag => values[flag] === '-');
     if (fromStdin.length > 1) {
         throw new Error(`${fromStdin.map(f => `--${f}`).join(' and ')} cannot both read stdin (-)`);
     }
-    const { track, width, height, dpr, timeout, ...rest } = values;
+    const { track, width, height, dpr, timeout, concurrency, ...rest } = values;
     return {
         ...rest,
         command,
@@ -98,6 +100,7 @@ export function parseArgs(argv) {
         height: positiveInt('height', height),
         dpr: positive('dpr', dpr),
         timeout: positive('timeout', timeout),
+        concurrency: positiveInt('concurrency', concurrency),
         positionals,
     };
 }

package/esm/bin.js

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
 import { parseArgs } from './args.js';
-import { captureJBrowse } from './capture.js';
+import { captureBatch, captureJBrowse } from './capture.js';
 import { resolveAgainstConfig } from './catalog.js';
 import { listHubAssemblies, listHubTracks, trackName } from './hub.js';
-import { readAnnotations, readJson, readSpec } from './jsonArgs.js';
+import { readAnnotations, readBatch, readJson, readSpec } from './jsonArgs.js';
 import { PUBLIC_INSTANCE, jbrowseUrl } from './url.js';
 import { version } from './version.js';
 const HELP = `jb2capture — screenshot a live JBrowse 2 view, once it has finished drawing
 
 USAGE
   jb2capture [flags] --out <file.png>    open a view, wait for it, screenshot it
+  jb2capture batch <json|path|-> [flags] screenshot many views from one browser
   jb2capture url [flags]                 print the URL instead of launching a browser
   jb2capture list [hub] [filter]         list hosted assemblies, or one's trackIds
 
@@ -46,6 +47,16 @@ WAITING
 
   Either fails the run rather than writing a frame that is not the picture.
 
+BATCH
+  The manifest is a JSON array with one object per image. Each names its "out"
+  and may set hub, config, assembly, loc, tracks, spec, session, width, height,
+  dpr, fullPage and annotations; the flags above are the defaults for what an
+  object leaves out. Every image gets a page of its own in one shared browser.
+  A failed image is reported and the rest carry on; the exit code is 1 if any
+  failed.
+
+  --concurrency <n>     pages open at once (default 4)
+
 OTHER
   --headed              run with a visible browser window
   --verbose             print browser console output and uncaught errors
@@ -61,6 +72,10 @@ EXAMPLES
   ## find the trackIds first
   jb2capture list hg38 conservation
 
+  ## one image per locus, from one browser
+  jb2capture batch '[{"loc":"BRCA1","out":"brca1.png"},{"loc":"TP53","out":"tp53.png"}]' \\
+    --hub hg38 --track hg38-ncbiRefSeqCurated
+
   ## your own config, two loci side by side
   jb2capture --config https://example.org/config.json --assembly mydata \\
     --loc "chr3:25,325,000-25,361,000 chr10:58,716,500-58,718,500" -o two.png
@@ -77,6 +92,71 @@ function urlOptions(args) {
         instance: args.instance,
     };
 }
+async function runBatch(args) {
+    const [manifest, ...extra] = args.positionals;
+    if (!manifest || extra.length) {
+        throw new Error('`jb2capture batch` takes one manifest: JSON, a path or -');
+    }
+    const defaults = {
+        ...urlOptions(args),
+        width: args.width,
+        height: args.height,
+        dpr: args.dpr,
+        fullPage: args.fullPage,
+        annotations: args.annotations
+            ? readAnnotations(args.annotations)
+            : undefined,
+        timeout: args.timeout,
+        allowUnsettled: args.allowUnsettled,
+        onConsole: args.verbose
+            ? (text) => {
+                console.error(`  [page] ${text}`);
+            }
+            : undefined,
+    };
+    const captures = readBatch(manifest).map(({ spec, session, annotations, ...entry }) => ({
+        ...defaults,
+        // an entry that says what to open replaces the default session whole
+        ...(spec || session ? { spec: undefined, session: undefined } : {}),
+        ...entry,
+        ...(spec
+            ? { spec: typeof spec === 'string' ? readSpec(spec) : spec }
+            : {}),
+        ...(session
+            ? {
+                session: typeof session === 'string'
+                    ? readJson('session', session)
+                    : session,
+            }
+            : {}),
+        ...(annotations
+            ? {
+                annotations: typeof annotations === 'string'
+                    ? readAnnotations(annotations)
+                    : annotations,
+            }
+            : {}),
+    }));
+    const start = performance.now();
+    const results = await captureBatch(captures, {
+        headless: !args.headed,
+        concurrency: args.concurrency,
+        onResult: (result, index) => {
+            const label = `[${index + 1}/${captures.length}] ${result.out} ${(result.ms / 1000).toFixed(1)}s`;
+            if (result.ok) {
+                console.log(`wrote ${label}`);
+            }
+            else {
+                console.error(`FAILED ${label}: ${result.error.message}`);
+            }
+        },
+    });
+    const failed = results.filter(r => !r.ok).length;
+    console.log(`wrote ${results.length - failed}/${results.length} images in ${((performance.now() - start) / 1000).toFixed(1)}s`);
+    if (failed) {
+        process.exitCode = 1;
+    }
+}
 async function runList(positionals) {
     const [hub, filter] = positionals;
     if (!hub) {
@@ -117,6 +197,10 @@ async function main() {
         await runList(args.positionals);
         return;
     }
+    if (args.command === 'batch') {
+        await runBatch(args);
+        return;
+    }
     if (args.command === 'url') {
         console.log(jbrowseUrl(await resolveAgainstConfig(urlOptions(args))));
         return;

package/esm/capture.d.ts

@@ -50,3 +50,25 @@ export interface CaptureResult extends ReadyReport {
  * browser.
  */
 export declare function captureJBrowse(options?: CaptureOptions): Promise<CaptureResult>;
+export interface BatchOptions extends LaunchOptions {
+    /** Pages open at once. Default 4. */
+    concurrency?: number;
+    /** Called as each capture finishes, in completion order. */
+    onResult?: (result: BatchResult, index: number) => void;
+}
+export type BatchResult = {
+    out?: string;
+    ms: number;
+} & (({
+    ok: true;
+} & CaptureResult) | {
+    ok: false;
+    error: Error;
+});
+/**
+ * Screenshot many sessions from one browser, each on a page of its own that is
+ * closed after its screenshot. A failed capture is reported in its result and
+ * the rest carry on; a browser that died is relaunched for the captures left.
+ * Results come back in the order of `captures`.
+ */
+export declare function captureBatch(captures: CaptureOptions[], { concurrency, onResult, ...launch }?: BatchOptions): Promise<BatchResult[]>;

package/esm/capture.js

@@ -11,13 +11,7 @@ import { waitForFrame, waitForJBrowseReady } from './ready.js';
 import { assemblyFromSession, savedSnapshot, trackIdsFromSession, } from './session.js';
 import { sessionOverflowInPage } from './sessionOverflow.js';
 import { PUBLIC_INSTANCE, assertCoherentOptions, jbrowseUrl } from './url.js';
-/**
- * Launch a browser, open a JBrowse session, and wait until it has rendered.
- * The caller owns the returned browser and must close it. The assembly and
- * tracks asked for become the session gate's expectations unless `trackIds`
- * names others.
- */
-export async function openJBrowse(options = {}) {
+async function prepareOpen(options) {
     const { width = 1400, height = 900, dpr = 2, headless, executablePath, args, onConsole, timeout = DEFAULT_TIMEOUT, trackIds, ...given } = options;
     assertCoherentOptions(given);
     const [urlOptions] = await Promise.all([
@@ -36,10 +30,24 @@ export async function openJBrowse(options = {}) {
         ? sessionAssembly &&
             (await canonicalSessionAssembly(urlOptions, sessionAssembly))
         : (assembly ?? hub);
-    const browser = await launchBrowser({ headless, executablePath, args });
+    return {
+        url,
+        viewport: { width, height, deviceScaleFactor: dpr },
+        onConsole,
+        timeout,
+        ready: {
+            ...options,
+            assembly: expectedAssembly,
+            trackIds: trackIds ?? (opens ? trackIdsFromSession(opens) : tracks),
+        },
+    };
+}
+async function openPage(browser, { url, viewport, onConsole, timeout, ready, }) {
+    // a window each: a tab behind another stops painting, and a batch has
+    // several pages open
+    const page = await browser.newPage({ type: 'window' });
     try {
-        const page = await browser.newPage();
-        await page.setViewport({ width, height, deviceScaleFactor: dpr });
+        await page.setViewport(viewport);
         if (onConsole) {
             page.on('console', msg => {
                 const text = msg.text();
@@ -68,27 +76,36 @@ export async function openJBrowse(options = {}) {
             waitUntil: 'domcontentloaded',
             timeout,
         });
-        if (response && !response.ok()) {
+        // 304: a page after the first in a batch comes from the shared cache
+        if (response && !response.ok() && response.status() !== 304) {
             throw new Error(`${url} answered HTTP ${response.status()}. Check --instance.`);
         }
-        const report = await waitForJBrowseReady(page, {
-            ...options,
-            assembly: expectedAssembly,
-            trackIds: trackIds ?? (opens ? trackIdsFromSession(opens) : tracks),
-        });
-        return { browser, page, url, ...report };
+        const report = await waitForJBrowseReady(page, ready);
+        return { page, url, ...report };
     }
     catch (error) {
-        await browser.close().catch(() => { });
+        await page.close().catch(() => { });
         throw error;
     }
 }
 /**
- * Open a JBrowse session, wait for it to render, screenshot it, and close the
- * browser.
+ * Launch a browser, open a JBrowse session, and wait until it has rendered.
+ * The caller owns the returned browser and must close it. The assembly and
+ * tracks asked for become the session gate's expectations unless `trackIds`
+ * names others.
  */
-export async function captureJBrowse(options = {}) {
-    const { out, fullPage = false, annotations, ...openOptions } = options;
+export async function openJBrowse(options = {}) {
+    const prepared = await prepareOpen(options);
+    const browser = await launchBrowser(options);
+    try {
+        return { browser, ...(await openPage(browser, prepared)) };
+    }
+    catch (error) {
+        await browser.close().catch(() => { });
+        throw error;
+    }
+}
+function assertCapturable({ out, annotations }) {
     if (annotations) {
         assertValidAnnotations(annotations);
     }
@@ -96,25 +113,100 @@ export async function captureJBrowse(options = {}) {
         assertImagePath(out);
         mkdirSync(dirname(out), { recursive: true });
     }
-    const { browser, page, url, ...opened } = await openJBrowse(openOptions);
+}
+async function shoot(page, opened, { out, fullPage = false, annotations, ...openOptions }) {
+    let report = opened;
+    const overflow = fullPage ? await page.evaluate(sessionOverflowInPage) : 0;
+    const viewport = page.viewport();
+    if (viewport && overflow > 0) {
+        await page.setViewport({
+            ...viewport,
+            height: viewport.height + overflow,
+        });
+        report = await waitForFrame(page, openOptions);
+    }
+    if (annotations?.length) {
+        await drawAnnotations(page, annotations);
+    }
+    const image = await page.screenshot({ path: out });
+    return { image, ...report };
+}
+/**
+ * Open a JBrowse session, wait for it to render, screenshot it, and close the
+ * browser.
+ */
+export async function captureJBrowse(options = {}) {
+    assertCapturable(options);
+    const { browser, page, url, ...opened } = await openJBrowse(options);
     try {
-        let report = opened;
-        const overflow = fullPage ? await page.evaluate(sessionOverflowInPage) : 0;
-        const viewport = page.viewport();
-        if (viewport && overflow > 0) {
-            await page.setViewport({
-                ...viewport,
-                height: viewport.height + overflow,
-            });
-            report = await waitForFrame(page, openOptions);
-        }
-        if (annotations?.length) {
-            await drawAnnotations(page, annotations);
-        }
-        const image = await page.screenshot({ path: out });
-        return { url, image, ...report };
+        return { url, ...(await shoot(page, opened, options)) };
     }
     finally {
         await browser.close().catch(() => { });
     }
 }
+/**
+ * Screenshot many sessions from one browser, each on a page of its own that is
+ * closed after its screenshot. A failed capture is reported in its result and
+ * the rest carry on; a browser that died is relaunched for the captures left.
+ * Results come back in the order of `captures`.
+ */
+export async function captureBatch(captures, { concurrency = 4, onResult, ...launch } = {}) {
+    for (const capture of captures) {
+        assertCapturable(capture);
+    }
+    const results = [];
+    let browser;
+    // chained, so workers that find no live browser share one launch
+    const liveBrowser = () => {
+        const launched = () => launchBrowser(launch);
+        browser = browser
+            ? browser.then(b => (b.connected ? b : launched()), launched)
+            : launched();
+        return browser;
+    };
+    let next = 0;
+    const worker = async () => {
+        while (next < captures.length) {
+            const index = next++;
+            const capture = captures[index];
+            const start = performance.now();
+            let result;
+            let page;
+            try {
+                const prepared = await prepareOpen(capture);
+                const opened = await openPage(await liveBrowser(), prepared);
+                page = opened.page;
+                const { url } = opened;
+                result = {
+                    ok: true,
+                    out: capture.out,
+                    url,
+                    ...(await shoot(page, opened, capture)),
+                    ms: performance.now() - start,
+                };
+            }
+            catch (error) {
+                result = {
+                    ok: false,
+                    out: capture.out,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    ms: performance.now() - start,
+                };
+            }
+            finally {
+                await page?.close().catch(() => { });
+            }
+            results[index] = result;
+            onResult?.(result, index);
+        }
+    };
+    try {
+        await Promise.all(Array.from({ length: Math.min(concurrency, captures.length) }, worker));
+    }
+    finally {
+        const launched = await browser?.catch(() => undefined);
+        await launched?.close().catch(() => { });
+    }
+    return results;
+}

package/esm/index.d.ts

@@ -1,4 +1,4 @@
-export { captureJBrowse, openJBrowse } from './capture.ts';
+export { captureBatch, captureJBrowse, openJBrowse } from './capture.ts';
 export { clearAnnotations, drawAnnotations } from './annotations.ts';
 export { delay } from './poll.ts';
 export { waitForFrame, waitForJBrowseReady } from './ready.ts';
@@ -9,7 +9,8 @@ export { PENDING_DISPLAYS, displayPainted, displaySettled, waitForAppSettled, wa
 export { BASE_CHROME_ARGS, findChromeExecutable, isBrowserConsoleNoise, launchBrowser, } from './browser.ts';
 export type { Annotation, AnnotationAnchor } from './annotationOverlay.ts';
 export type { LaunchOptions } from './browser.ts';
-export type { CaptureOptions, CaptureResult, OpenOptions, OpenResult, } from './capture.ts';
+export type { BatchOptions, BatchResult, CaptureOptions, CaptureResult, OpenOptions, OpenResult, } from './capture.ts';
+export type { PageOrFrame } from './poll.ts';
 export type { ReadyOptions, ReadyReport } from './ready.ts';
 export type { DisplayState, SessionExpectations } from './sessionGate.ts';
 export type { JBrowseUrlOptions } from './url.ts';

package/esm/index.js

@@ -1,4 +1,4 @@
-export { captureJBrowse, openJBrowse } from './capture.js';
+export { captureBatch, captureJBrowse, openJBrowse } from './capture.js';
 export { clearAnnotations, drawAnnotations } from './annotations.js';
 export { delay } from './poll.js';
 export { waitForFrame, waitForJBrowseReady } from './ready.js';

package/esm/jsonArgs.d.ts

@@ -2,3 +2,22 @@ import type { Annotation } from './annotationOverlay.ts';
 export declare function readJson(flag: string, value: string): object;
 export declare function readAnnotations(value: string): Annotation[];
 export declare function readSpec(value: string): object;
+export interface BatchEntry {
+    out: string;
+    hub?: string;
+    config?: string;
+    assembly?: string;
+    loc?: string;
+    tracks?: string[];
+    /** A session spec inline, or a path to one. */
+    spec?: object | string;
+    /** A session saved with File → Export session inline, or a path to one. */
+    session?: object | string;
+    width?: number;
+    height?: number;
+    dpr?: number;
+    fullPage?: boolean;
+    /** Callouts inline, or a path to them. */
+    annotations?: Annotation[] | string;
+}
+export declare function readBatch(value: string): BatchEntry[];

package/esm/jsonArgs.js

@@ -10,7 +10,7 @@ function parseJson(flag, value) {
                 : readFileSync(value, 'utf8'));
     }
     catch (error) {
-        throw new Error(`--${flag}: ${error instanceof Error ? error.message : error}`, { cause: error });
+        throw new Error(`${flag.includes(' ') ? flag : `--${flag}`}: ${error instanceof Error ? error.message : error}`, { cause: error });
     }
 }
 export function readJson(flag, value) {
@@ -32,3 +32,15 @@ export function readSpec(value) {
     const spec = readJson('spec', value);
     return 'type' in spec && !('views' in spec) ? { views: [spec] } : spec;
 }
+export function readBatch(value) {
+    const parsed = parseJson('batch manifest', value);
+    if (!Array.isArray(parsed)) {
+        throw new Error('the batch manifest must be a JSON array of captures');
+    }
+    for (const [i, entry] of parsed.entries()) {
+        if (typeof entry?.out !== 'string') {
+            throw new Error(`batch capture ${i} has no "out" image path`);
+        }
+    }
+    return parsed;
+}

package/esm/poll.d.ts

@@ -1,4 +1,6 @@
-import type { Page } from 'puppeteer';
+import type { Frame, Page } from 'puppeteer';
+/** A page, or a frame inside one such as an embedded JBrowse's iframe. */
+export type PageOrFrame = Page | Frame;
 /** The budget each stage of the ready chain gets unless told otherwise. */
 export declare const DEFAULT_TIMEOUT = 60000;
 export declare const delay: (ms: number) => Promise<void>;
@@ -18,4 +20,4 @@ export declare function holdTrue(read: () => Promise<boolean>, { holdMs, timeout
  * poll can outlive, such as a navigation destroying the execution context. A
  * closed or crashed page throws, since no poll will recover it.
  */
-export declare function queryWhileOpen<T, F>(page: Page, query: Promise<T>, fallback: F): Promise<T | F>;
+export declare function queryWhileOpen<T, F>(target: PageOrFrame, query: Promise<T>, fallback: F): Promise<T | F>;

package/esm/poll.js

@@ -28,21 +28,24 @@ export async function holdTrue(read, { holdMs, timeout, pollMs, }) {
     }
     return false;
 }
+function isGone(target) {
+    return 'page' in target
+        ? target.detached || isGone(target.page())
+        : target.isClosed() || !target.browser().connected;
+}
 const PAGE_GONE = /crashed|Target closed|Session closed|Connection closed/i;
 /**
  * Await a page query, answering `fallback` when it failed for a reason a later
  * poll can outlive, such as a navigation destroying the execution context. A
  * closed or crashed page throws, since no poll will recover it.
  */
-export async function queryWhileOpen(page, query, fallback) {
+export async function queryWhileOpen(target, query, fallback) {
     try {
         return await query;
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        if (PAGE_GONE.test(message) ||
-            page.isClosed() ||
-            !page.browser().connected) {
+        if (PAGE_GONE.test(message) || isGone(target)) {
             throw new Error(`the page closed or crashed before it finished rendering (${message})`, { cause: error });
         }
         return fallback;

package/esm/ready.d.ts

@@ -1,5 +1,5 @@
+import type { PageOrFrame } from './poll.ts';
 import type { DisplayState, SessionExpectations } from './sessionGate.ts';
-import type { Page } from 'puppeteer';
 export interface ReadyOptions extends SessionExpectations {
     /** Budget for each wait stage. */
     timeout?: number;
@@ -21,9 +21,9 @@ export interface ReadyReport {
  * Wait until the session holds the assembly and tracks asked for, the app has
  * held itself ready, every display has painted, and no error is on screen.
  */
-export declare function waitForJBrowseReady(page: Page, options?: ReadyOptions): Promise<ReadyReport>;
+export declare function waitForJBrowseReady(page: PageOrFrame, options?: ReadyOptions): Promise<ReadyReport>;
 /**
  * `waitForJBrowseReady` without the session gate, for a frame that changed
  * while the session did not, such as after a viewport resize.
  */
-export declare function waitForFrame(page: Page, { timeout, allowUnsettled, }?: Omit<ReadyOptions, keyof SessionExpectations>): Promise<ReadyReport>;
+export declare function waitForFrame(page: PageOrFrame, { timeout, allowUnsettled, }?: Omit<ReadyOptions, keyof SessionExpectations>): Promise<ReadyReport>;

package/esm/sessionGate.d.ts

@@ -1,4 +1,4 @@
-import type { Page } from 'puppeteer';
+import type { PageOrFrame } from './poll.ts';
 export interface SessionExpectations {
     /** Assembly that must be open on some view. */
     assembly?: string;
@@ -30,7 +30,7 @@ export declare function readSessionInPage(): {
  * Throws at once with the app's message if it could not load, and on timeout
  * with what the census held instead.
  */
-export declare function waitForSession(page: Page, { assembly, trackIds, minViews, timeout, }?: SessionExpectations & {
+export declare function waitForSession(page: PageOrFrame, { assembly, trackIds, minViews, timeout, }?: SessionExpectations & {
     timeout?: number;
 }): Promise<void>;
 /** One display and the phase it publishes. */

package/esm/url.d.ts

@@ -1,4 +1,4 @@
-export declare const PUBLIC_INSTANCE = "https://jbrowse.org/code/jb2/v5.0.0-beta.13/";
+export declare const PUBLIC_INSTANCE = "https://jbrowse.org/code/jb2/v5.0.0-beta.14/";
 /**
  * The instance as the page that loads it sees it: a directory given without
  * its slash, which the host redirects, resolves relative URLs one level up.

package/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.0.0-beta.13";
+export declare const version = "5.0.0-beta.14";

package/esm/version.js

@@ -1 +1 @@
-export const version = '5.0.0-beta.13';
+export const version = '5.0.0-beta.14';

package/esm/waits.d.ts

@@ -1,4 +1,5 @@
-import type { ElementHandle, Page } from 'puppeteer';
+import type { PageOrFrame } from './poll.ts';
+import type { ElementHandle } from 'puppeteer';
 interface WaitOptions {
     timeout?: number;
 }
@@ -14,7 +15,7 @@ export declare const displaySettled: (testid: string) => string;
  * `page.waitForSelector`, whose timeout names each display that had not
  * painted and the phase it was in.
  */
-export declare function waitForSelectorAttributed(page: Page, selector: string, { timeout }?: WaitOptions): Promise<ElementHandle>;
+export declare function waitForSelectorAttributed(page: PageOrFrame, selector: string, { timeout }?: WaitOptions): Promise<ElementHandle>;
 type SettleOptions = WaitOptions & {
     holdMs?: number;
     pollMs?: number;
@@ -23,7 +24,7 @@ type SettleOptions = WaitOptions & {
  * `waitForAppSettled`, answering with what was still blocking at the timeout,
  * or undefined once the hold passed.
  */
-export declare function appSettledBlocker(page: Page, { timeout, holdMs, pollMs, }?: SettleOptions): Promise<string | undefined>;
+export declare function appSettledBlocker(page: PageOrFrame, { timeout, holdMs, pollMs, }?: SettleOptions): Promise<string | undefined>;
 /**
  * Wait until every app on the page has read ready, with nothing loading or
  * animating, for an unbroken `holdMs`. False on timeout. Right after a
@@ -31,5 +32,5 @@ export declare function appSettledBlocker(page: Page, { timeout, holdMs, pollMs,
  * publishes `[data-app-phase]` throws, since nothing positive exists to wait
  * for.
  */
-export declare function waitForAppSettled(page: Page, options?: SettleOptions): Promise<boolean>;
+export declare function waitForAppSettled(page: PageOrFrame, options?: SettleOptions): Promise<boolean>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/capture",
-  "version": "5.0.0-beta.13",
+  "version": "5.0.0-beta.14",
   "description": "Drive a JBrowse 2 instance with Puppeteer and screenshot it once it has actually finished rendering",
   "keywords": [
     "jbrowse",
@@ -33,10 +33,10 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "puppeteer": "^25.12.0"
+    "puppeteer": "^25.14.0"
   },
   "devDependencies": {
-    "@jbrowse/core": "^5.0.0-beta.13"
+    "@jbrowse/core": "^5.0.0-beta.14"
   },
   "publishConfig": {
     "access": "public"