@fusion.dev/helix-diagnostics 0.138.0 → 0.140.0

package/dist/collect.js

@@ -1,3 +1,4 @@
+import { OVERLAY, pageOf } from './page.js';
 const name = (sheet, seen, host) => {
     if (sheet.href) {
         return sheet.href;
@@ -62,19 +63,7 @@ const read = (sheet, into, unreadable, labels, depth = 0, host, reads) => {
     rules(list, label, into, depth, reads);
     return true;
 };
-const roots = (from, found, depth = 0) => {
-    if (depth > 32) {
-        return;
-    }
-    for (const element of from.querySelectorAll('*')) {
-        const root = element.shadowRoot;
-        if (root) {
-            found.push(root);
-            roots(root, found, depth + 1);
-        }
-    }
-};
-export const collect = (from = document) => {
+export const collect = (from = document, page = pageOf(from)) => {
     const located = [];
     const unreadable = [];
     const seen = new Set();
@@ -119,8 +108,7 @@ export const collect = (from = document) => {
     for (const sheet of from.adoptedStyleSheets ?? []) {
         take(sheet);
     }
-    const shadows = [];
-    roots(from, shadows);
+    const shadows = page.roots.filter((root) => root.host.localName !== OVERLAY);
     for (const root of shadows) {
         for (const sheet of Array.from(root.styleSheets ?? [])) {
             take(sheet, root.host);

package/dist/config.d.ts

@@ -4,6 +4,8 @@ import { type Rules } from './rules.js';
 export interface Config {
     /** The lowest level each category prints at in the console, or `off`. */
     console?: Partial<Configuration['console']>;
+    /** What `@fusion.dev/helix-core` does itself: whether it prints its runtime warnings. */
+    core?: Partial<Configuration['core']>;
     /** How much detail goes with what is sent. */
     detail?: Partial<Configuration['detail']>;
     /** Where sending happens. Production takes `{ sample }`, from 0 to 1. */
@@ -21,14 +23,25 @@ export interface Config {
     rules?: Rules;
     /** Each category, sent or withheld. Nothing is sent without a key. */
     send?: Partial<Record<Category, boolean>>;
+    /**
+     * Where `initDiagnostics()` hands each run, beside the console: the
+     * `overlay` on the page, and the `relay`, `helix diagnostics`, on or off or
+     * at an address of its own.
+     */
+    sinks?: Partial<Configuration['sinks']>;
 }
 /** The shipped defaults. */
 export declare const DEFAULTS: {
     readonly console: {
         readonly coverage: 'info';
         readonly findings: 'info';
+        readonly performance: 'off';
+        readonly runtime: 'warn';
         readonly usage: 'debug';
     };
+    readonly core: {
+        readonly warnings: true;
+    };
     readonly detail: {
         readonly evidence: 'full';
         readonly hookValues: true;
@@ -48,7 +61,18 @@ export declare const DEFAULTS: {
         readonly runtime: true;
         readonly usage: true;
     };
+    readonly sinks: {
+        readonly overlay: true;
+        readonly relay: false;
+    };
 };
+/**
+ * A local host: `localhost`, `127.0.0.1`, `[::1]`, `*.localhost`, and `*.test`.
+ * A page with no declared environment runs only on one, and the relay is only
+ * ever at one, as `helix diagnostics` takes runs only from one: a relay at
+ * another address would be a second way to send, with no key and no `send`.
+ */
+export declare const LOCAL: RegExp;
 /** Throws on a setting that names nothing, or a value it cannot take. */
 export declare const checkConfig: (config: Config | undefined, layer: Exclude<Layer, 'shipped'>) => void;
 /** The settings in effect, from the defaults, the file, and the call. */

package/dist/config.js

@@ -2,7 +2,14 @@ import { nearest } from './manifest.js';
 import { CATEGORIES } from './report.js';
 import { checkRules } from './rules.js';
 export const DEFAULTS = {
-    console: { coverage: 'info', findings: 'info', usage: 'debug' },
+    console: {
+        coverage: 'info',
+        findings: 'info',
+        performance: 'off',
+        runtime: 'warn',
+        usage: 'debug',
+    },
+    core: { warnings: true },
     detail: { evidence: 'full', hookValues: true, pages: 'patterns' },
     environments: { ci: true, development: true, production: false },
     send: {
@@ -14,13 +21,29 @@ export const DEFAULTS = {
         runtime: true,
         usage: true,
     },
+    sinks: { overlay: true, relay: false },
+};
+export const LOCAL = /^(localhost|127\.0\.0\.1|\[::1\]|.+\.localhost|.+\.test)$/;
+const local = (address) => {
+    if (!/^https?:\/\/[^/?#@]+$/.test(address)) {
+        return false;
+    }
+    try {
+        return LOCAL.test(new URL(address).hostname);
+    }
+    catch {
+        return false;
+    }
 };
 const ALLOWED = {
     console: {
         coverage: ['info', 'off'],
         findings: ['error', 'warn', 'info', 'off'],
+        performance: ['info', 'off'],
+        runtime: ['warn', 'off'],
         usage: ['debug', 'off'],
     },
+    core: { warnings: [true, false] },
     detail: {
         evidence: ['full', 'selector', 'none'],
         hookValues: [true, false],
@@ -29,6 +52,7 @@ const ALLOWED = {
     environments: { ci: [true, false], development: [true, false], production: 'sample' },
     project: { key: 'string', name: 'string', tags: 'tags' },
     send: Object.fromEntries(CATEGORIES.map((category) => [category, [true, false]])),
+    sinks: { overlay: [true, false], relay: 'address' },
 };
 const shown = (value) => typeof value === 'string' ? `\`${value}\`` : String(value);
 export const checkConfig = (config, layer) => {
@@ -60,22 +84,26 @@ export const checkConfig = (config, layer) => {
                 ? typeof one === 'string'
                 : takes === 'tags'
                     ? Array.isArray(one) && one.every((tag) => typeof tag === 'string')
-                    : takes === 'sample'
-                        ? one === false ||
-                            (typeof one === 'object' &&
-                                one !== null &&
-                                typeof one.sample === 'number' &&
-                                one.sample >= 0 &&
-                                one.sample <= 1)
-                        : takes.includes(one);
+                    : takes === 'address'
+                        ? typeof one === 'boolean' || (typeof one === 'string' && local(one))
+                        : takes === 'sample'
+                            ? one === false ||
+                                (typeof one === 'object' &&
+                                    one !== null &&
+                                    typeof one.sample === 'number' &&
+                                    one.sample >= 0 &&
+                                    one.sample <= 1)
+                            : takes.includes(one);
             if (!fits) {
                 const expected = takes === 'string'
                     ? 'a string'
                     : takes === 'tags'
                         ? 'a list of strings'
-                        : takes === 'sample'
-                            ? '`false`, or `{ sample }` from 0 to 1'
-                            : takes.map(shown).join(', ');
+                        : takes === 'address'
+                            ? '`true`, `false`, or an address on a local host, such as `http://127.0.0.1:7417`'
+                            : takes === 'sample'
+                                ? '`false`, or `{ sample }` from 0 to 1'
+                                : takes.map(shown).join(', ');
                 throw new Error(`The ${layer} sets \`${section}.${name}\` to \`${JSON.stringify(one)}\`. It takes ${expected}.`);
             }
         }
@@ -105,8 +133,10 @@ export const resolveConfig = (file, call) => {
     return {
         configuration: {
             console: merged('console', { ...DEFAULTS.console }),
+            core: merged('core', { ...DEFAULTS.core }),
             detail: merged('detail', { ...DEFAULTS.detail }),
             environments: merged('environments', { ...DEFAULTS.environments }),
+            sinks: merged('sinks', { ...DEFAULTS.sinks }),
         },
         project: {
             ...(project.name === undefined ? {} : { name: project.name }),

package/dist/console.d.ts

@@ -9,9 +9,11 @@
  * | A finding at `error` | `console.error` | The CSS does nothing where it was written |
  * | A finding at `warn` | `console.warn` | Worth fixing, and the page works |
  * | A finding at `info` | `console.info` | Advice |
+ * | A runtime event core left to diagnostics | `console.warn`, or `console.error` for a failure | The library was used wrong as it ran |
  * | Unreadable stylesheets | `console.warn` | The run could not see part of the page |
  * | Coverage, overrides, a clean run | `console.info` | What the run looked at |
  * | Usage | `console.debug` | For whoever studies usage, hidden at the default level |
+ * | Performance, where asked for | `console.info` | What the components cost, by tag |
  *
  * **All of it in one group**, headed by the counts, so a page with other logs
  * keeps a run together and a clean run collapses to one line.
@@ -35,4 +37,12 @@ export type ConsoleSink = Pick<Console, 'debug' | 'error' | 'group' | 'groupColl
  * every finding whatever is printed under it, and the ones the rules turned
  * off, so a quiet console never reads as a clean page.
  */
-export declare const report: (result: Report, to?: ConsoleSink) => Report;
+export declare const report: (result: Report, to?: ConsoleSink, { shown, }?: {
+    /**
+     * The fingerprints already printed for this page. Given, a finding prints
+     * only the first time its fingerprint is seen, and is added; the heading
+     * still counts every finding. `initDiagnostics()` keeps one per page, so
+     * a run after every change does not repeat itself.
+     */
+    shown?: Set<string> | undefined;
+}) => Report;

package/dist/console.js

@@ -1,3 +1,4 @@
+import { shownRuntime } from './runtime.js';
 const entry = (finding) => {
     const by = finding.decidedBy === 'shipped' ? '' : ` (${finding.severity}, set by the ${finding.decidedBy})`;
     const lines = [`${finding.kind}${by}: ${finding.subject}`, finding.message];
@@ -8,7 +9,7 @@ const entry = (finding) => {
 };
 const counted = (count, noun) => `${count} ${noun}${count === 1 ? '' : 's'}`;
 const RANK = { error: 3, info: 1, warn: 2 };
-export const report = (result, to = console) => {
+export const report = (result, to = console, { shown, } = {}) => {
     const { configuration, coverage, findings } = result;
     const levels = configuration.console;
     const bySeverity = (severity) => findings.filter((finding) => finding.severity === severity).length;
@@ -16,16 +17,18 @@ export const report = (result, to = console) => {
     const warnings = bySeverity('warn');
     const off = configuration.silenced.reduce((total, one) => total + one.count, 0);
     const missed = coverage.sheets - coverage.read;
+    const runtime = shownRuntime(result.runtime);
     const counts = [
         counted(errors, 'error'),
         counted(warnings, 'warning'),
         `${bySeverity('info')} info`,
+        ...(runtime.length > 0 ? [`${runtime.length} runtime`] : []),
         ...(off > 0 ? [`${off} turned off`] : []),
     ];
-    const heading = findings.length === 0 && off === 0
+    const heading = findings.length === 0 && off === 0 && runtime.length === 0
         ? 'helix diagnostics: no findings'
         : `helix diagnostics: ${counts.join(', ')}`;
-    if (errors + warnings > 0 || missed > 0) {
+    if (errors + warnings + runtime.length > 0 || missed > 0) {
         to.group(heading);
     }
     else {
@@ -48,10 +51,48 @@ export const report = (result, to = console) => {
     }
     if (levels.findings !== 'off') {
         const floor = RANK[levels.findings];
+        let before = 0;
         for (const finding of findings) {
-            if (RANK[finding.severity] >= floor) {
-                to[finding.severity](entry(finding));
+            if (RANK[finding.severity] < floor) {
+                continue;
             }
+            if (shown?.has(finding.fingerprint)) {
+                before += 1;
+                continue;
+            }
+            shown?.add(finding.fingerprint);
+            to[finding.severity](entry(finding));
+        }
+        if (before > 0) {
+            to.info(`${counted(before, 'finding')} printed before, on this page, and not again`);
+        }
+    }
+    if (levels.runtime !== 'off') {
+        for (const one of runtime) {
+            if (one.printed || shown?.has(one.fingerprint)) {
+                continue;
+            }
+            shown?.add(one.fingerprint);
+            to[one.level](`${one.kind}${one.tag ? ` <${one.tag}>` : ''}: ${one.message}`);
+        }
+    }
+    if (levels.performance !== 'off' && result.performance) {
+        const { measured, tags } = result.performance;
+        const rows = Object.entries(tags)
+            .sort(([, a], [, b]) => b.render.p95 - a.render.p95)
+            .slice(0, 10);
+        const lines = rows.map(([tag, one]) => `${tag}: ${one.render.p50} ms median, ${one.render.p95} ms p95, ${one.render.max} ms slowest, of ${counted(one.render.count, 'first update')}` +
+            (measured.layoutShift && one.shift > 0 ? `; ${one.shift} layout shift` : '') +
+            (measured.longTasks && one.longTasks > 0 ? `; ${counted(one.longTasks, 'long task')}` : ''));
+        const key = `performance ${result.run.page ?? ''} ${lines.join('|')}`;
+        if (rows.length > 0 && !shown?.has(key)) {
+            shown?.add(key);
+            to.info([
+                `performance: ${counted(Object.keys(tags).length, 'tag')} measured, slowest first` +
+                    (measured.layoutShift ? '' : '. Layout shift is not measured in this browser') +
+                    (measured.longTasks ? '' : '. Long tasks are not measured in this browser'),
+                ...lines,
+            ].join('\n'));
         }
     }
     if (levels.usage !== 'off') {

package/dist/diagnose.d.ts

@@ -0,0 +1,75 @@
+import { type Config } from './config.js';
+import type { Tier } from './manifest.js';
+import type { Environment, Report } from './report.js';
+import { type Watcher } from './usage.js';
+/**
+ * What to look at, what to compare it against, and the settings for this
+ * call, which win over the project's file field by field.
+ */
+export interface Options extends Config {
+    /**
+     * `duplicateRegistrations` from `@fusion.dev/helix-core`, when it is installed.
+     *
+     * **Passed in rather than imported**, so this package does not depend on the
+     * library it diagnoses. A diagnostics release would otherwise have to follow
+     * every core release, and a consumer on an older core could not run a newer
+     * collector at all. Omitted, the duplicate check falls back to comparing a
+     * live element against its own registered class, which finds the same fault
+     * from outside and cannot name the losing class.
+     */
+    duplicates?: (() => string[]) | undefined;
+    /**
+     * Where this run happens, as the project declares it. **Never inferred**:
+     * a bundler's `development` condition misfires both ways, and a run whose
+     * environment nobody declared is never sent.
+     */
+    environment?: Environment | undefined;
+    /**
+     * The project's own file, `helix-diagnostics.json`, parsed. The build reads
+     * the file, since the page cannot: import the JSON and pass it here.
+     */
+    file?: Config | undefined;
+    /**
+     * The document to scan. Defaults to the ambient one.
+     *
+     * Present so a test can hand over a constructed document, and so a page with
+     * an iframe it owns can scan that too.
+     */
+    from?: Document | undefined;
+    /**
+     * The page's path, for a router that knows its own pattern, such as
+     * `/products/[id]`. Otherwise read from the location and made a pattern, as
+     * `detail.pages` says.
+     */
+    page?: string | undefined;
+    /**
+     * The manifests to check against, one per installed tier.
+     *
+     * **Pass both tiers when both are installed.** A part `@fusion.dev/helix-headless`
+     * publishes and `@fusion.dev/helix` never forwarded is a real fault and is
+     * invisible to either manifest alone.
+     */
+    tiers: Tier[];
+    /**
+     * A watcher from `watch()`, so usage counts every element that rendered
+     * since it began. Without one, usage counts the elements in the page now.
+     */
+    watcher?: Watcher | undefined;
+}
+/**
+ * One run over the page.
+ *
+ * **It returns coverage and findings together and offers no way to have one
+ * without the other.** A collector that cannot read cross-origin sheets reports
+ * the same empty array whether it read everything or nothing. An empty
+ * `findings` is only meaningful beside the `coverage` that says what was looked
+ * at.
+ *
+ * Cheap enough to call on a route change. There is no observer and no polling
+ * loop: sheets that arrive later are found by calling it again.
+ *
+ * **A manifest from another version is refused**, with one finding that says
+ * so in place of every other: by version where both sides carry one, and
+ * otherwise by a part the manifest does not list rendering in the page.
+ */
+export declare const diagnose: (options: Options) => Report;

package/dist/diagnose.js

@@ -0,0 +1,93 @@
+import { analyze, markup, registrations, skew, versionSkew } from './analyze.js';
+import { collect } from './collect.js';
+import { pagePattern, resolveConfig } from './config.js';
+import { identify } from './identity.js';
+import { index, lintFor, versionsOf } from './manifest.js';
+import { pageOf } from './page.js';
+import { applyRules, overridesOf } from './rules.js';
+import { logged, tally } from './runtime.js';
+import { listed, loadedVersions, styled, walk } from './usage.js';
+import { VERSION } from './version.js';
+const runId = () => globalThis.crypto?.randomUUID?.() ??
+    `${Date.now().toString(16)}-${Math.random().toString(16).slice(2)}`;
+export const diagnose = (options) => {
+    const started = performance.now();
+    const at = new Date().toISOString();
+    const { duplicates, environment, file, from, page, tiers, watcher, ...call } = options;
+    if (tiers.length === 0) {
+        throw new Error('diagnose() needs at least one manifest. Without one every part name is unknown and every finding would be noise.');
+    }
+    const resolved = resolveConfig(file, call);
+    const { detail } = resolved.configuration;
+    const document_ = from ?? globalThis.document;
+    const walked = pageOf(document_);
+    const { answered, coverage, readers, rules: located, used } = collect(document_, walked);
+    const lints = tiers.map((tier) => ({ lint: lintFor(tier) }));
+    const tags = index(lints);
+    const counted = watcher ? watcher.counts() : walk(document_, walked);
+    const runtime = watcher
+        ? watcher.runtime()
+        : (() => {
+            const kept = tally();
+            for (const event of logged()) {
+                kept.add(event, true);
+            }
+            return kept.entries();
+        })();
+    const reported = runtime
+        .filter((one) => one.kind === 'duplicate-registration' && one.tag !== undefined)
+        .map((one) => one.tag);
+    const twice = duplicates ?? (reported.length > 0 ? () => reported : undefined);
+    const measured = watcher?.performance();
+    const seen = loadedVersions();
+    const manifests = versionsOf(lints);
+    const byVersion = versionSkew(manifests, seen);
+    const known = seen.length > 0 && Object.keys(manifests).length > 0;
+    const skewed = applyRules((byVersion.length > 0 ? byVersion : known ? [] : skew(tags, document_, walked)).map((one) => identify(one, tags)), file?.rules, call.rules);
+    const judged = skewed.findings.length > 0
+        ? { findings: [], silenced: [] }
+        : applyRules([
+            ...analyze(located, tags, document_, answered, used, readers),
+            ...markup(tags, document_, walked),
+            ...registrations(document_, twice, walked),
+        ].map((one) => identify(one, tags)), file?.rules, call.rules);
+    const path = page ?? globalThis.location?.pathname;
+    const shownPage = path === undefined || detail.pages === 'none'
+        ? undefined
+        : detail.pages === 'patterns'
+            ? pagePattern(path)
+            : path;
+    return {
+        configuration: {
+            ...resolved.configuration,
+            overrides: overridesOf(file?.rules, call.rules),
+            silenced: [...skewed.silenced, ...judged.silenced],
+        },
+        coverage,
+        findings: [...skewed.findings, ...judged.findings],
+        project: resolved.project,
+        run: {
+            at,
+            duration: Math.round(performance.now() - started),
+            id: runId(),
+            source: 'page',
+            ...(environment === undefined ? {} : { environment }),
+            ...(shownPage === undefined ? {} : { page: shownPage }),
+        },
+        ...(measured === undefined ? {} : { performance: measured }),
+        runtime,
+        schema: 1,
+        usage: {
+            ...listed(counted, tags),
+            ...styled(located, tags, answered, detail.hookValues),
+            counted: watcher ? 'watched' : 'walked',
+        },
+        versions: { collector: VERSION, helix: seen, manifests, rules: VERSION },
+        withheld: Object.entries(resolved.send)
+            .filter(([, sent]) => !sent.on)
+            .map(([category, sent]) => ({
+            category: category,
+            decidedBy: sent.decidedBy,
+        })),
+    };
+};

package/dist/identity.d.ts

@@ -30,5 +30,11 @@ export declare const normalize: (subject: string) => string;
  * seen twice, which is how a reader thinks of it.
  */
 export declare const fingerprintOf: (finding: Pick<Raw, 'kind' | 'subject' | 'tag'>) => string;
+/**
+ * A runtime event's identity across runs: its kind, its tag, and its sentence
+ * with each run of digits read as one, so a count in the sentence is not part
+ * of what the event is.
+ */
+export declare const runtimeFingerprint: (kind: string, tag: string | undefined, message: string) => string;
 /** A finding with its category, owner, family, and fingerprint. */
 export declare const identify: (finding: Raw, tags: Map<string, Published>) => Identified;

package/dist/identity.js

@@ -37,6 +37,7 @@ const hash = (text) => {
     return (4294967296 * (2097151 & two) + (one >>> 0)).toString(16).padStart(14, '0');
 };
 export const fingerprintOf = (finding) => hash(`${finding.kind}\u0000${finding.tag}\u0000${normalize(finding.subject)}`);
+export const runtimeFingerprint = (kind, tag, message) => hash(`runtime\u0000${kind}\u0000${tag ?? ''}\u0000${message.replace(/\d[\d,.]*/g, '#')}`);
 export const identify = (finding, tags) => ({
     ...finding,
     category: CATEGORY[finding.kind],

package/dist/index.d.ts

@@ -30,86 +30,14 @@
 export { collect } from './collect.js';
 export { type Config, DEFAULTS, pagePattern } from './config.js';
 export { report } from './console.js';
+export { diagnose, type Options } from './diagnose.js';
 export { fingerprintOf, normalize } from './identity.js';
-export type { ManifestSource, Published, Tier } from './manifest.js';
-export { index, nearest } from './manifest.js';
+export { type Diagnostics, INSTANCE, type InitOptions, initDiagnostics } from './init.js';
+export type { LintData, LintTag, ManifestSource, Published, Tier } from './manifest.js';
+export { index, lintOf, nearest } from './manifest.js';
 export type { Category, Configuration, Coverage, Environment, Finding, FindingCategory, Kind, Layer, Origin, Owner, Report, Severity, Unreadable, Usage, } from './report.js';
 export { CATEGORIES, KINDS } from './report.js';
 export { type Override, type Rules, SHIPPED_RULES } from './rules.js';
+export { TIMING, type Timing } from './schedule.js';
 export { type Watcher, watch } from './usage.js';
 export { VERSION } from './version.js';
-import { type Config } from './config.js';
-import type { Tier } from './manifest.js';
-import type { Environment, Report } from './report.js';
-import { type Watcher } from './usage.js';
-/**
- * What to look at, what to compare it against, and the settings for this
- * call, which win over the project's file field by field.
- */
-export interface Options extends Config {
-    /**
-     * `duplicateRegistrations` from `@fusion.dev/helix-core`, when it is installed.
-     *
-     * **Passed in rather than imported**, so this package does not depend on the
-     * library it diagnoses. A diagnostics release would otherwise have to follow
-     * every core release, and a consumer on an older core could not run a newer
-     * collector at all. Omitted, the duplicate check falls back to comparing a
-     * live element against its own registered class, which finds the same fault
-     * from outside and cannot name the losing class.
-     */
-    duplicates?: () => string[];
-    /**
-     * Where this run happens, as the project declares it. **Never inferred**:
-     * a bundler's `development` condition misfires both ways, and a run whose
-     * environment nobody declared is never sent.
-     */
-    environment?: Environment | undefined;
-    /**
-     * The project's own file, `helix-diagnostics.json`, parsed. The build reads
-     * the file, since the page cannot: import the JSON and pass it here.
-     */
-    file?: Config | undefined;
-    /**
-     * The document to scan. Defaults to the ambient one.
-     *
-     * Present so a test can hand over a constructed document, and so a page with
-     * an iframe it owns can scan that too.
-     */
-    from?: Document;
-    /**
-     * The page's path, for a router that knows its own pattern, such as
-     * `/products/[id]`. Otherwise read from the location and made a pattern, as
-     * `detail.pages` says.
-     */
-    page?: string | undefined;
-    /**
-     * The manifests to check against, one per installed tier.
-     *
-     * **Pass both tiers when both are installed.** A part `@fusion.dev/helix-headless`
-     * publishes and `@fusion.dev/helix` never forwarded is a real fault and is
-     * invisible to either manifest alone.
-     */
-    tiers: Tier[];
-    /**
-     * A watcher from `watch()`, so usage counts every element that rendered
-     * since it began. Without one, usage counts the elements in the page now.
-     */
-    watcher?: Watcher | undefined;
-}
-/**
- * One run over the page.
- *
- * **It returns coverage and findings together and offers no way to have one
- * without the other.** A collector that cannot read cross-origin sheets reports
- * the same empty array whether it read everything or nothing. An empty
- * `findings` is only meaningful beside the `coverage` that says what was looked
- * at.
- *
- * Cheap enough to call on a route change. There is no observer and no polling
- * loop: sheets that arrive later are found by calling it again.
- *
- * **A manifest from another version is refused**, with one finding that says
- * so in place of every other: by version where both sides carry one, and
- * otherwise by a part the manifest does not list rendering in the page.
- */
-export declare const diagnose: (options: Options) => Report;