@jbrowse/capture 4.3.0 → 5.0.0-beta.10

package/README.md

@@ -10,7 +10,10 @@ npx @jbrowse/capture --hub hg38 --loc BRCA1 \
 
 `--hub` names an assembly on [genomes.jbrowse.org](https://genomes.jbrowse.org),
 which hosts a ready-made JBrowse config per UCSC and GenArk genome, and `--loc`
-takes a gene name because those configs ship a text index.
+takes a gene name because those configs ship a text index. `--track` takes a
+trackId, the id without its assembly prefix (`clinvarMain`) or the track's
+display name; capture checks each one and the assembly against the config before
+launching a browser, and a miss fails at once with suggestions.
 
 ## Knowing when JBrowse has finished rendering
 
@@ -19,10 +22,10 @@ config, builds a session, resolves an assembly, fetches each track, and then
 draws to a canvas — and a screenshot taken at any point before the last step is
 a picture of an empty browser that looks like a successful run.
 
-Every readiness signal JBrowse publishes is **negative**: no loading overlay, no
-display in its loading phase, no unpainted canvas. All of them therefore pass on
-a page whose JavaScript has not started yet. Measured against
-`jbrowse.org/code/jb2/latest`:
+Nearly every signal a browser publishes is **negative** — no loading overlay, no
+display in its loading phase, no unpainted canvas — and an absence is equally
+true of a page whose JavaScript has not started. Measured against a released
+build with two remote tracks:
 
 - `networkidle2` resolves at ~350ms
 - the session appears at ~880ms
@@ -32,44 +35,92 @@ a page whose JavaScript has not started yet. Measured against
 A wait chain built from those signals alone finishes in under a second and
 reports success.
 
-So this package puts a **positive gate** in front of them, read off the live MST
-session model that jbrowse-web publishes as `window.JBrowseSession`: the session
-exists, its views are initialized, and the assembly and trackIds you asked for
-are the ones actually open. A config URL that 404s, a trackId the config does
-not define, and an assembly name that does not match all fail there, loudly.
+So this package waits on the two **positive** signals instead, and nothing else
+decides the answer:
+
+1. **The census.** `AppReadyMarker` publishes what is open as `data-app-views`,
+   `data-app-assemblies` and `data-app-tracks`, and the gate reads that one
+   element: at least one view, your assembly among them, every trackId you named
+   actually open. A trackId or assembly that capture could not check against the
+   config before launching (a session spec's, or a config it could not fetch)
+   fails here if it never opens. A config, session or plugin the app cannot load
+   fails here at once, with the app's own message, which it publishes as
+   `data-app-error`.
+2. **`[data-app-phase="ready"]`, held.** The session renders it when no view is
+   resolving an assembly and no display is fetching. It has to hold for a beat,
+   not merely be true once: a display drops to `ready` in the gap between one
+   fetch finishing and the debounced next one starting. The hold also waits out
+   a view body still loading its code and a display drawing a morph between two
+   layouts (`data-display-animating="true"`), neither of which the marker can
+   see.
+
+Then one check on what the frame shows, which the marker does not answer. The
+marker is about WORK, so it reads `ready` over a display whose fetch failed or
+that the user canceled. Capture names every display that is unpainted, canceled
+or showing an error banner, and fails.
+
+**The instance has to be JBrowse v5 or later**, the first release to publish the
+marker. Capture reads the instance's `version.txt` before launching a browser
+and refuses an older build there, rather than waiting out a timeout on a page
+that will never say it has finished.
 
 ## Library
 
 ```js
-import { captureJBrowse, openJBrowse } from '@jbrowse/capture'
+import {
+  captureJBrowse,
+  launchBrowser,
+  openJBrowse,
+  waitForJBrowseReady,
+} from '@jbrowse/capture'
 
 // one call: launch, wait, shoot, close
-const { pending, paintContract } = await captureJBrowse({
+const { pending, unsettled } = await captureJBrowse({
   hub: 'hg38',
   loc: 'BRCA1',
   tracks: ['hg38-ncbiRefSeqCurated'],
   out: 'brca1.png',
 })
 
-// or keep the page, to click things and read state back
+// or keep the page, to click things, read state back, or shoot one element
 const { browser, page } = await openJBrowse({ hub: 'mm39', loc: 'Sox2' })
 const tracks = await page.evaluate(
   () => window.JBrowseSession.views[0].tracks.length,
 )
+const view = await page.$('[data-testid^="view-container-"]')
+await view.screenshot({ path: 'view-only.png' })
 await browser.close()
+
+// or a page of your own that embeds a JBrowse component
+const own = await launchBrowser()
+const ownPage = await own.newPage()
+await ownPage.goto('http://localhost:8000/my-widget.html')
+await waitForJBrowseReady(ownPage)
+await ownPage.screenshot({ path: 'embedded.png' })
+await own.close()
 ```
 
+The CLI covers the common capture and has no flag for the rest. A crop, a click
+before the shot or a hidden element is a line of Puppeteer on the page
+`openJBrowse` returns, and a view or display setting goes in a `--spec`.
+
 Two waits, depending on what you did:
 
 - **`waitForJBrowseReady(page)`** is the wait on its own, for a page you
-  navigated yourself. The individual stages (`waitForSession`,
-  `waitForLoadingComplete`, `waitForDisplaysDone`, `waitForQuiescent`, ...) are
-  exported too, and each one documents what it can and cannot tell you.
+  navigated yourself. `waitForFrame(page)` is its second half alone, for a page
+  whose session you already gated, after a resize or a click. `waitForSession`,
+  the first half, is exported too.
 - **`waitForAppSettled(page)`** is the wait after you CLICK something. A page
   that is loading starts out `loading` and the transition into `ready` is it
   finishing; a page you just clicked is already `ready` and stays that way until
   the click's work registers, so waiting for `ready` there returns on the
-  pre-click frame. `waitForAppSettled` requires it to hold.
+  pre-click frame. `waitForAppSettled` requires it to hold, and throws on a
+  build with no marker rather than falling back to a wait that cannot fail.
+
+`openJBrowse` opens a JBrowse Web instance. A page of your own that embeds a
+JBrowse component, such as an htmlwidget or a notebook widget, publishes the
+same marker: `launchBrowser`, navigate, then `waitForJBrowseReady(page)`, as the
+last example above does.
 
 ## Timeouts and unsettled waits
 
@@ -81,11 +132,11 @@ way, which is the vacuous-gate problem again, one step later.
 Here every stage reports its outcome, and an unsettled one throws by default,
 naming the gate:
 
-```
-gave up waiting after 2000ms: the loading overlay never cleared (a track fetch
-never finished). Raise the timeout if the page is merely slow; if it never
-finishes, open the same URL in a browser — this gate has no content to fall
-through to.
+```text
+gave up waiting after 60000ms: the app never held itself ready; display(s)
+never painted: LinearAlignmentsDisplay (volvox_cram-LinearAlignmentsDisplay) is
+loading. Raise the timeout, or pass allowUnsettled (--allowUnsettled) to capture
+the frame as it stands.
 ```
 
 `allowUnsettled` (`--allowUnsettled`) takes the frame as it stands instead, and
@@ -97,14 +148,15 @@ Three fields on a successful capture:
 
 - **`unsettled`** — stages that hit their timeout. Empty unless you asked to
   proceed anyway.
-- **`pending`** — displays still reporting unpainted when the shutter fired. A
-  display can return to pending after its stage passed, so this is a separate
-  question from `unsettled`.
-- **`paintContract`** — whether this JBrowse build publishes the per-display
-  paint attributes at all. It does not on the current released build, which is
-  what every genomes.jbrowse.org link opens; there, `pending: []` means "cannot
-  tell", not "all done", and the CLI says so. A page with no tracks open reports
-  true — there is nothing to measure, which is not the same as being unable to.
+- **`pending`** — displays not showing their data when the shutter fired, each
+  with its own phase: `loading` is a slow fetch, `error` and `renderError` a
+  banner, `canceled` a user's stop, and `ready` a display claiming it finished
+  without drawing. Each one lands in `unsettled` too, so a capture returns them
+  only under `allowUnsettled`.
+- **`tooLarge`** — displays showing "Requested too much data" instead of their
+  features, because the region is wider than the track fetches without being
+  asked. The capture still succeeds, since that is the app working as designed,
+  and the CLI prints a warning naming them. Narrow the location to draw them.
 
 ## CLI
 

package/esm/args.d.ts

@@ -1,30 +1,30 @@
 export interface ParsedArgs {
+    command: 'capture' | 'url' | 'list';
     hub?: string;
     config?: string;
     assembly?: string;
     loc?: string;
     tracks: string[];
+    spec?: string;
     session?: string;
-    sessionName?: string;
     instance?: string;
     out?: string;
     width?: number;
     height?: number;
     scale?: number;
     timeout?: number;
-    settle?: number;
     fullPage: boolean;
     headed: boolean;
     verbose: boolean;
     help: boolean;
+    version: boolean;
     allowUnsettled: boolean;
+    /** `list`'s hub and filter. Empty for the other commands. */
+    positionals: string[];
 }
 /**
- * Parse `jb2capture` flags. Split from the binary so the accepted shapes are
- * unit-testable without launching a browser.
- *
- * Unknown flags throw rather than being ignored: a mistyped `--tracks` on a tool
- * whose whole job is to produce a plausible-looking image would otherwise be
- * reported by nothing at all.
+ * Parse a `jb2capture` command line. Strict: an unknown flag, a flag the
+ * command does not use, and a bare word anywhere but after `list` are errors
+ * rather than silently ignored.
  */
 export declare function parseArgs(argv: string[]): ParsedArgs;

package/esm/args.js

@@ -1,79 +1,91 @@
-const NUMERIC = new Set(['width', 'height', 'scale', 'timeout', 'settle']);
-const FLAGS = new Set([
-    'fullPage',
-    'headed',
-    'verbose',
-    'help',
-    'allowUnsettled',
-]);
-const REPEATABLE = new Set(['track']);
-const STRINGS = new Set([
-    'hub',
-    'config',
-    'assembly',
-    'loc',
-    'session',
-    'sessionName',
-    'instance',
-    'out',
-]);
-// `--fullPage`, not `--full-page`: the flags match the option names in the
-// library API one for one, so a script and a command line say the same thing.
-// Aliases are the two abbreviations that are hard not to type.
-const ALIASES = { o: 'out', h: 'help' };
-function known(name) {
-    return (NUMERIC.has(name) ||
-        FLAGS.has(name) ||
-        REPEATABLE.has(name) ||
-        STRINGS.has(name));
+import { parseArgs as parseNodeArgs } from 'node:util';
+// flags spelled as the library's option names, so a script and a command line
+// say the same thing
+const OPTIONS = {
+    hub: { type: 'string' },
+    config: { type: 'string' },
+    assembly: { type: 'string' },
+    loc: { type: 'string' },
+    spec: { type: 'string' },
+    session: { type: 'string' },
+    instance: { type: 'string' },
+    out: { type: 'string', short: 'o' },
+    track: { type: 'string', multiple: true, default: [] },
+    width: { type: 'string' },
+    height: { type: 'string' },
+    scale: { type: 'string' },
+    timeout: { type: 'string' },
+    fullPage: { type: 'boolean', default: false },
+    headed: { type: 'boolean', default: false },
+    verbose: { type: 'boolean', default: false },
+    help: { type: 'boolean', short: 'h', default: false },
+    version: { type: 'boolean', short: 'v', default: false },
+    allowUnsettled: { type: 'boolean', default: false },
+};
+const EVERY_COMMAND = ['help', 'version'];
+const SUBCOMMAND_FLAGS = {
+    url: new Set([
+        'hub',
+        'config',
+        'assembly',
+        'loc',
+        'track',
+        'spec',
+        'session',
+        'instance',
+        ...EVERY_COMMAND,
+    ]),
+    list: new Set(EVERY_COMMAND),
+};
+function finite(name, raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    const n = Number(raw);
+    if (!Number.isFinite(n)) {
+        throw new Error(`--${name} needs a number, got "${raw}"`);
+    }
+    return n;
+}
+function positive(name, raw) {
+    const n = finite(name, raw);
+    if (n !== undefined && n <= 0) {
+        throw new Error(`--${name} needs a positive number, got "${raw}"`);
+    }
+    return n;
 }
 /**
- * Parse `jb2capture` flags. Split from the binary so the accepted shapes are
- * unit-testable without launching a browser.
- *
- * Unknown flags throw rather than being ignored: a mistyped `--tracks` on a tool
- * whose whole job is to produce a plausible-looking image would otherwise be
- * reported by nothing at all.
+ * Parse a `jb2capture` command line. Strict: an unknown flag, a flag the
+ * command does not use, and a bare word anywhere but after `list` are errors
+ * rather than silently ignored.
  */
 export function parseArgs(argv) {
-    const out = { tracks: [] };
-    for (const flag of FLAGS) {
-        out[flag] = false;
-    }
-    for (let i = 0; i < argv.length; i++) {
-        const arg = argv[i];
-        if (!arg.startsWith('-')) {
-            throw new Error(`unexpected argument "${arg}"`);
-        }
-        const bare = arg.replace(/^--?/, '');
-        const eq = bare.indexOf('=');
-        const rawName = eq === -1 ? bare : bare.slice(0, eq);
-        const name = ALIASES[rawName] ?? rawName;
-        if (!known(name)) {
-            throw new Error(`unknown flag "${arg}"`);
-        }
-        if (FLAGS.has(name)) {
-            out[name] = true;
-            continue;
-        }
-        const value = eq === -1 ? argv[++i] : bare.slice(eq + 1);
-        if (value === undefined) {
-            throw new Error(`--${name} needs a value`);
-        }
-        if (REPEATABLE.has(name)) {
-            ;
-            out.tracks.push(value);
-        }
-        else if (NUMERIC.has(name)) {
-            const n = Number(value);
-            if (!Number.isFinite(n)) {
-                throw new Error(`--${name} needs a number, got "${value}"`);
+    const [first, ...afterCommand] = argv;
+    const command = first === 'list' || first === 'url' ? first : 'capture';
+    const { values, positionals, tokens } = parseNodeArgs({
+        args: command === 'capture' ? argv : afterCommand,
+        options: OPTIONS,
+        allowPositionals: command === 'list',
+        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}\``);
             }
-            out[name] = n;
-        }
-        else {
-            out[name] = value;
         }
     }
-    return out;
+    const { track, width, height, scale, timeout, ...rest } = values;
+    return {
+        ...rest,
+        command,
+        // copied, since node hands back the option table's own default array
+        tracks: [...track],
+        width: positive('width', width),
+        height: positive('height', height),
+        scale: positive('scale', scale),
+        timeout: positive('timeout', timeout),
+        positionals,
+    };
 }

package/esm/bin.js

@@ -2,53 +2,51 @@
 import { readFileSync } from 'node:fs';
 import { parseArgs } from './args.js';
 import { captureJBrowse } from './capture.js';
-import { listHubTracks } from './hub.js';
-import { PAINT_CONTRACT_NOTE } from './sessionGate.js';
-import { jbrowseUrl } from './url.js';
+import { resolveAgainstConfig } from './catalog.js';
+import { listHubAssemblies, listHubTracks, trackName } from './hub.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 url [flags]                 print the URL instead of launching a browser
-  jb2capture list <hub> [filter]         list a hosted assembly's trackIds
+  jb2capture list [hub] [filter]         list hosted assemblies, or one's trackIds
 
 WHAT TO SHOW
   --hub <name>          a genomes.jbrowse.org assembly: a UCSC db name (hg38, mm39)
                         or a GenArk accession (GCA_.../GCF_...)
   --config <url>        a config.json URL, for data that is not hosted there
   --assembly <name>     assembly to open (defaults to --hub)
-  --loc <locstring>     where to go: chr1:1,000-2,000, or several space-separated
-                        for a discontinuous view. On a config with a text index —
-                        every UCSC assembly on genomes.jbrowse.org has one — a
-                        gene name such as BRCA1 also works.
-  --track <trackId>     a track to open; repeat for several
-  --session <json|path> a full session spec, for several views or per-display
-                        settings. Replaces --assembly/--loc/--track.
+  --loc <locstring>     chr1:1,000-2,000, several space-separated, or a gene name
+                        where the config has a text index (hosted ones do)
+  --track <trackId>     a track to open, by trackId or name; repeat for several
+  --spec <json|path|->  a session spec, for several views or per-display settings
+  --session <path|->    a session saved with File → Export session
   --instance <url>      JBrowse Web deployment to drive
-                        (default https://jbrowse.org/code/jb2/latest/)
-  --sessionName <name>  name the opened session carries
+                        (default ${PUBLIC_INSTANCE})
 
 THE IMAGE
-  --out, -o <file>      PNG to write (required unless using a subcommand)
+  --out, -o <file>      .png, .jpg or .webp to write (required unless using a
+                        subcommand)
   --width <px>          viewport width (default 1400)
   --height <px>         viewport height (default 900)
   --scale <n>           device pixel ratio (default 2)
-  --fullPage            capture the whole scrollable page, not just the viewport
+  --fullPage            grow the image until every view fits, not just the
+                        --height of the viewport
 
 WAITING
   --timeout <ms>        budget per wait stage (default 60000)
-  --settle <ms>         extra pause after everything reports drawn (default 0)
-  --allowUnsettled      write the image anyway when a stage times out
+  --allowUnsettled      write the image anyway when a stage times out or a
+                        display is showing an error or a cancel
 
-  Every stage is waited on for you: the session holding the assembly and tracks
-  you asked for, the view resolving, tracks fetching, displays painting, and any
-  leftover "Loading…" text. A stage that times out FAILS the run rather than
-  quietly handing back a half-drawn frame — raise --timeout, or pass
-  --allowUnsettled if you want the frame as it stands.
+  Either fails the run rather than writing a frame that is not the picture.
 
 OTHER
   --headed              run with a visible browser window
-  --verbose             print browser console output (GPU noise filtered)
+  --verbose             print browser console output and uncaught errors
+                        (GPU noise filtered)
+  --version, -v         the package version
   --help, -h            this text
 
 EXAMPLES
@@ -63,16 +61,24 @@ EXAMPLES
   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
 `;
-function readSession(value) {
-    const text = value.trimStart().startsWith('{')
-        ? value
-        : readFileSync(value, 'utf8');
+// inline JSON, `-` for stdin, or a path: the forms `jb2export --spec` reads
+function readJson(flag, value) {
+    const text = value === '-'
+        ? readFileSync(0, 'utf8')
+        : value.trimStart().startsWith('{')
+            ? value
+            : readFileSync(value, 'utf8');
     const parsed = JSON.parse(text);
     if (typeof parsed !== 'object' || parsed === null) {
-        throw new Error('--session must be a JSON object');
+        throw new Error(`--${flag} must be a JSON object`);
     }
     return parsed;
 }
+// a bare view object is the one-view spec it would be wrapped in
+function readSpec(value) {
+    const spec = readJson('spec', value);
+    return 'type' in spec && !('views' in spec) ? { views: [spec] } : spec;
+}
 function urlOptions(args) {
     return {
         hub: args.hub,
@@ -80,16 +86,24 @@ function urlOptions(args) {
         assembly: args.assembly,
         loc: args.loc,
         tracks: args.tracks.length ? args.tracks : undefined,
-        session: args.session ? readSession(args.session) : undefined,
-        sessionName: args.sessionName,
+        spec: args.spec ? readSpec(args.spec) : undefined,
+        session: args.session ? readJson('session', args.session) : undefined,
         instance: args.instance,
     };
 }
-async function runList(rest) {
-    const [hub, filter] = rest;
+async function runList(positionals) {
+    const [hub, filter] = positionals;
     if (!hub) {
-        throw new Error('list needs an assembly, e.g. `jb2capture list hg38`. ' +
-            'Browse them at https://genomes.jbrowse.org.');
+        const assemblies = await listHubAssemblies();
+        const pad = Math.max(...assemblies.map(a => a.name.length));
+        for (const a of assemblies) {
+            const about = [a.organism, a.description].filter(Boolean).join(' — ');
+            console.log(`  ${a.name.padEnd(pad)}  ${about}`);
+        }
+        console.log('\nGenArk accessions (GCA_…/GCF_…) work as --hub too; browse them at ' +
+            "https://genomes.jbrowse.org. List one assembly's tracks with " +
+            '`jb2capture list <name> [filter]`.');
+        return;
     }
     const tracks = await listHubTracks(hub, filter);
     if (!tracks.length) {
@@ -99,30 +113,32 @@ async function runList(rest) {
     }
     const pad = Math.min(60, Math.max(...tracks.map(t => t.trackId.length)));
     for (const t of tracks) {
-        console.log(`  ${t.trackId.padEnd(pad)}  ${(t.type ?? '').padEnd(18)}  ${t.name ?? ''}`);
+        console.log(`  ${t.trackId.padEnd(pad)}  ${(t.type ?? '').padEnd(18)}  ${trackName(t)}`);
     }
 }
 async function main() {
     const argv = process.argv.slice(2);
-    const [first, ...rest] = argv;
-    if (first === 'list') {
-        await runList(rest);
-        return;
-    }
-    const isUrlOnly = first === 'url';
-    const args = parseArgs(isUrlOnly ? rest : argv);
+    const args = parseArgs(argv);
     if (args.help || argv.length === 0) {
         console.log(HELP);
         return;
     }
-    if (isUrlOnly) {
-        console.log(jbrowseUrl(urlOptions(args)));
+    if (args.version) {
+        console.log(version);
+        return;
+    }
+    if (args.command === 'list') {
+        await runList(args.positionals);
+        return;
+    }
+    if (args.command === 'url') {
+        console.log(jbrowseUrl(await resolveAgainstConfig(urlOptions(args))));
         return;
     }
     if (!args.out) {
         throw new Error('--out <file.png> is required (or use `jb2capture url`)');
     }
-    const { url, pending, paintContract, unsettled } = await captureJBrowse({
+    const { url, tooLarge, unsettled } = await captureJBrowse({
         ...urlOptions(args),
         out: args.out,
         width: args.width,
@@ -131,7 +147,6 @@ async function main() {
         fullPage: args.fullPage,
         headless: !args.headed,
         timeout: args.timeout,
-        settleMs: args.settle,
         allowUnsettled: args.allowUnsettled,
         onConsole: args.verbose
             ? text => {
@@ -141,19 +156,12 @@ async function main() {
     });
     console.log(`wrote ${args.out}`);
     console.log(`from  ${url}`);
-    // Reached only when the wait either succeeded or was explicitly overridden, so
-    // these are notes on an image that exists rather than failures. They still get
-    // said out loud: "everything painted", "we stopped waiting" and "paint could
-    // not be measured here" all look identical in a PNG.
     if (unsettled.length) {
         console.error(`warning: --allowUnsettled: ${unsettled.join('; ')}`);
     }
-    if (pending.length) {
-        console.error(`warning: ${pending.length} display(s) had not finished drawing at capture time ` +
-            `(${pending.join(', ')}). Raise --timeout, or --settle for a slow remote file.`);
-    }
-    else if (!paintContract) {
-        console.error(`note: ${PAINT_CONTRACT_NOTE}`);
+    if (tooLarge.length) {
+        console.error(`warning: ${tooLarge.length} display(s) show "too much data" instead of their features ` +
+            `(${tooLarge.map(d => d.name).join(', ')}). Narrow --loc to draw them.`);
     }
 }
 try {

package/esm/browser.d.ts

@@ -1,4 +1,16 @@
-export declare const SANDBOX_CHROME_ARGS: string[];
 export declare const BASE_CHROME_ARGS: string[];
 export declare function findChromeExecutable(): string | undefined;
+export interface LaunchOptions {
+    headless?: boolean;
+    /** Chrome binary. Defaults to $CHROME_PATH, a system Chrome, then Puppeteer's own. */
+    executablePath?: string;
+    /** Extra Chrome flags, appended to the defaults. */
+    args?: string[];
+}
+/**
+ * The browser `openJBrowse` drives, for a page it cannot open itself: an
+ * embedded view on your own host page, navigated and then waited on with
+ * `waitForJBrowseReady`.
+ */
+export declare function launchBrowser({ headless, executablePath, args, }?: LaunchOptions): Promise<import("puppeteer").Browser>;
 export declare function isBrowserConsoleNoise(text: string): boolean;