@fusion.dev/helix-diagnostics 0.136.0 → 0.138.0

package/dist/collect.js

@@ -23,7 +23,7 @@ const rules = (list, sheet, into, depth = 0, reads) => {
         if ('selectorText' in rule) {
             into.push({ index, rule: rule, sheet });
             if (reads) {
-                for (const match of (rule.cssText ?? '').matchAll(/var\(\s*(--[a-zA-Z0-9-]+)/g)) {
+                for (const match of (rule.cssText ?? '').matchAll(/var\(\s*(--[\w-]+)/g)) {
                     if (match[1]) {
                         reads.add(match[1]);
                     }
@@ -80,20 +80,38 @@ export const collect = (from = document) => {
     const seen = new Set();
     const labels = new Map();
     const answered = new Map();
+    const used = new Set();
+    const readers = new Map();
     let readable = 0;
     const take = (sheet, host) => {
         if (!sheet || seen.has(sheet)) {
             return;
         }
         seen.add(sheet);
-        let reads;
+        let reads = used;
         if (host) {
             reads = answered.get(host.localName) ?? new Set();
             answered.set(host.localName, reads);
         }
+        const before = located.length;
         if (read(sheet, located, unreadable, labels, 0, host, reads)) {
             readable += 1;
         }
+        const scope = host ? (host.shadowRoot ?? undefined) : from;
+        const ours = !host?.localName.startsWith('helix-');
+        for (let at = before; at < located.length; at += 1) {
+            const one = located[at];
+            one.scope = scope;
+            if (ours && one.rule.selectorText) {
+                for (const match of (one.rule.cssText ?? '').matchAll(/var\(\s*(--[\w-]+)/g)) {
+                    const property = match[1];
+                    readers.set(property, [
+                        ...(readers.get(property) ?? []),
+                        { scope, selector: one.rule.selectorText },
+                    ]);
+                }
+            }
+        }
     };
     for (const sheet of Array.from(from.styleSheets)) {
         take(sheet);
@@ -114,9 +132,18 @@ export const collect = (from = document) => {
             take(owner.sheet, root.host);
         }
     }
+    for (const [tag, reads] of answered) {
+        if (!tag.startsWith('helix-')) {
+            for (const property of reads) {
+                used.add(property);
+            }
+        }
+    }
     return {
         answered,
         coverage: { read: readable, roots: shadows.length, sheets: seen.size, unreadable },
+        readers,
         rules: located,
+        used,
     };
 };

package/dist/config.d.ts

@@ -0,0 +1,71 @@
+import { type Category, type Configuration, type Layer, type Report } from './report.js';
+import { type Rules } from './rules.js';
+/** Everything a project can set. Every field is optional; see `DEFAULTS`. */
+export interface Config {
+    /** The lowest level each category prints at in the console, or `off`. */
+    console?: Partial<Configuration['console']>;
+    /** How much detail goes with what is sent. */
+    detail?: Partial<Configuration['detail']>;
+    /** Where sending happens. Production takes `{ sample }`, from 0 to 1. */
+    environments?: Partial<Configuration['environments']>;
+    /**
+     * The project: its key, which opts it in to sending, and its own name and
+     * labels. `tags` are free, and `fusion` marks Fusion's own projects.
+     */
+    project?: {
+        key?: string;
+        name?: string;
+        tags?: string[];
+    };
+    /** Severities by kind; see `Rules`. */
+    rules?: Rules;
+    /** Each category, sent or withheld. Nothing is sent without a key. */
+    send?: Partial<Record<Category, boolean>>;
+}
+/** The shipped defaults. */
+export declare const DEFAULTS: {
+    readonly console: {
+        readonly coverage: 'info';
+        readonly findings: 'info';
+        readonly usage: 'debug';
+    };
+    readonly detail: {
+        readonly evidence: 'full';
+        readonly hookValues: true;
+        readonly pages: 'patterns';
+    };
+    readonly environments: {
+        readonly ci: true;
+        readonly development: true;
+        readonly production: false;
+    };
+    readonly send: {
+        readonly assist: true;
+        readonly configuration: true;
+        readonly coverage: true;
+        readonly findings: true;
+        readonly performance: false;
+        readonly runtime: true;
+        readonly usage: true;
+    };
+};
+/** 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. */
+export interface Resolved {
+    configuration: Omit<Configuration, 'overrides' | 'silenced'>;
+    project: Report['project'];
+    /** Each category's sending, and which place decided it. */
+    send: Record<Category, {
+        decidedBy: Layer;
+        on: boolean;
+    }>;
+}
+/** The three places, merged, with a later one winning field by field. */
+export declare const resolveConfig: (file: Config | undefined, call: Config | undefined) => Resolved;
+/**
+ * A page's path as a pattern: each segment that names one record, a number,
+ * a UUID, or a long run of hex or mixed letters and digits, becomes `:id`.
+ * `/orders/1042/items/9f8e7d6c5b4a` reads `/orders/:id/items/:id`.
+ */
+export declare const pagePattern: (path: string) => string;

package/dist/config.js

@@ -0,0 +1,126 @@
+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' },
+    detail: { evidence: 'full', hookValues: true, pages: 'patterns' },
+    environments: { ci: true, development: true, production: false },
+    send: {
+        assist: true,
+        configuration: true,
+        coverage: true,
+        findings: true,
+        performance: false,
+        runtime: true,
+        usage: true,
+    },
+};
+const ALLOWED = {
+    console: {
+        coverage: ['info', 'off'],
+        findings: ['error', 'warn', 'info', 'off'],
+        usage: ['debug', 'off'],
+    },
+    detail: {
+        evidence: ['full', 'selector', 'none'],
+        hookValues: [true, false],
+        pages: ['patterns', 'full', 'none'],
+    },
+    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]])),
+};
+const shown = (value) => typeof value === 'string' ? `\`${value}\`` : String(value);
+export const checkConfig = (config, layer) => {
+    if (config === undefined) {
+        return;
+    }
+    if (typeof config !== 'object' || config === null || Array.isArray(config)) {
+        throw new Error(`The ${layer} is not a configuration object.`);
+    }
+    for (const [section, value] of Object.entries(config)) {
+        if (section === 'rules') {
+            checkRules(value, layer);
+            continue;
+        }
+        const allowed = ALLOWED[section];
+        if (!allowed) {
+            const close = nearest(section, [...Object.keys(ALLOWED), 'rules']);
+            throw new Error(`The ${layer} sets \`${section}\`, which is no setting.` +
+                (close ? ` The closest is \`${close}\`.` : ''));
+        }
+        for (const [name, one] of Object.entries(value)) {
+            const takes = allowed[name];
+            if (takes === undefined) {
+                const close = nearest(name, Object.keys(allowed));
+                throw new Error(`The ${layer} sets \`${section}.${name}\`, which is no setting.` +
+                    (close ? ` The closest is \`${section}.${close}\`.` : ''));
+            }
+            const fits = takes === 'string'
+                ? 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);
+            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(', ');
+                throw new Error(`The ${layer} sets \`${section}.${name}\` to \`${JSON.stringify(one)}\`. It takes ${expected}.`);
+            }
+        }
+    }
+};
+export const resolveConfig = (file, call) => {
+    checkConfig(file, 'file');
+    checkConfig(call, 'argument');
+    const merged = (section, base) => ({
+        ...base,
+        ...(file?.[section] ?? {}),
+        ...(call?.[section] ?? {}),
+    });
+    const send = Object.fromEntries(CATEGORIES.map((category) => {
+        const fromCall = call?.send?.[category];
+        const fromFile = file?.send?.[category];
+        return [
+            category,
+            fromCall !== undefined
+                ? { decidedBy: 'argument', on: fromCall }
+                : fromFile !== undefined
+                    ? { decidedBy: 'file', on: fromFile }
+                    : { decidedBy: 'shipped', on: DEFAULTS.send[category] },
+        ];
+    }));
+    const project = { ...(file?.project ?? {}), ...(call?.project ?? {}) };
+    return {
+        configuration: {
+            console: merged('console', { ...DEFAULTS.console }),
+            detail: merged('detail', { ...DEFAULTS.detail }),
+            environments: merged('environments', { ...DEFAULTS.environments }),
+        },
+        project: {
+            ...(project.name === undefined ? {} : { name: project.name }),
+            tags: project.tags ?? [],
+        },
+        send,
+    };
+};
+export const pagePattern = (path) => path
+    .split('/')
+    .map((segment) => /^\d+$/.test(segment) ||
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(segment) ||
+    /^[0-9a-f]{8,}$/i.test(segment) ||
+    (segment.length >= 12 && /\d/.test(segment) && /^[A-Za-z0-9_-]+$/.test(segment))
+    ? ':id'
+    : segment)
+    .join('/');

package/dist/console.d.ts

@@ -27,5 +27,12 @@
 import type { Report } from './report.js';
 /** The console methods this sink calls. A test hands in its own. */
 export type ConsoleSink = Pick<Console, 'debug' | 'error' | 'group' | 'groupCollapsed' | 'groupEnd' | 'info' | 'warn'>;
-/** Writes a report and hands it back, so a caller can chain a second sink. */
+/**
+ * Writes a report and hands it back, so a caller can chain a second sink.
+ *
+ * **Each category prints as the project's `console` setting says**: findings
+ * at or above a severity, coverage and usage on or off. The heading counts
+ * 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;

package/dist/console.js

@@ -7,41 +7,63 @@ const entry = (finding) => {
     return lines.join('\n');
 };
 const counted = (count, noun) => `${count} ${noun}${count === 1 ? '' : 's'}`;
+const RANK = { error: 3, info: 1, warn: 2 };
 export const report = (result, to = console) => {
-    const { coverage, findings } = result;
+    const { configuration, coverage, findings } = result;
+    const levels = configuration.console;
     const bySeverity = (severity) => findings.filter((finding) => finding.severity === severity).length;
     const errors = bySeverity('error');
     const warnings = bySeverity('warn');
+    const off = configuration.silenced.reduce((total, one) => total + one.count, 0);
     const missed = coverage.sheets - coverage.read;
-    const heading = findings.length === 0
+    const counts = [
+        counted(errors, 'error'),
+        counted(warnings, 'warning'),
+        `${bySeverity('info')} info`,
+        ...(off > 0 ? [`${off} turned off`] : []),
+    ];
+    const heading = findings.length === 0 && off === 0
         ? 'helix diagnostics: no findings'
-        : `helix diagnostics: ${counted(errors, 'error')}, ${counted(warnings, 'warning')}, ${bySeverity('info')} info`;
+        : `helix diagnostics: ${counts.join(', ')}`;
     if (errors + warnings > 0 || missed > 0) {
         to.group(heading);
     }
     else {
         to.groupCollapsed(heading);
     }
-    to.info(`read ${coverage.read} of ${counted(coverage.sheets, 'stylesheet')} across ${counted(coverage.roots, 'shadow root')}`);
+    if (levels.coverage !== 'off') {
+        to.info(`read ${coverage.read} of ${counted(coverage.sheets, 'stylesheet')} across ${counted(coverage.roots, 'shadow root')}` +
+            (result.run.page ? ` on ${result.run.page}` : ''));
+    }
     if (missed > 0) {
         to.warn([
             `${counted(missed, 'stylesheet')} could not be read, so ${missed === 1 ? 'it was' : 'they were'} not checked:`,
             ...coverage.unreadable.map((sheet) => `${sheet.sheet} (${sheet.reason})`),
         ].join('\n'));
     }
-    const { argument, file } = result.silenced;
-    if (argument + file > 0) {
-        to.info(`${counted(argument + file, 'finding')} turned off: ${file} by the file, ${argument} by the argument`);
+    if (off > 0 && levels.coverage !== 'off') {
+        to.info(configuration.silenced
+            .map((one) => `${counted(one.count, one.kind)} turned off by the ${one.layer}`)
+            .join('\n'));
+    }
+    if (levels.findings !== 'off') {
+        const floor = RANK[levels.findings];
+        for (const finding of findings) {
+            if (RANK[finding.severity] >= floor) {
+                to[finding.severity](entry(finding));
+            }
+        }
     }
-    for (const finding of findings) {
-        to[finding.severity](entry(finding));
+    if (levels.usage !== 'off') {
+        const { counted: how, hooks, parts, tags, unlisted } = result.usage;
+        const sum = (counts) => Object.values(counts).reduce((total, one) => total + Object.keys(one).length, 0);
+        const elements = Object.values(tags).reduce((total, one) => total + one, 0);
+        const others = Object.keys(unlisted).length;
+        const versions = result.versions.helix;
+        to.debug(`usage (${how}): ${counted(Object.keys(tags).length, 'tag')} in ${counted(elements, 'element')}, ${counted(sum(parts), 'part')} styled, ${counted(sum(hooks), 'hook')} set` +
+            (others > 0 ? `, and ${counted(others, 'helix- tag')} no manifest lists` : '') +
+            (versions.length > 0 ? `; Helix ${versions.join(' and ')}` : ''));
     }
-    const { counted: how, hooks, parts, tags, unlisted } = result.usage;
-    const sum = (counts) => Object.values(counts).reduce((total, one) => total + Object.keys(one).length, 0);
-    const elements = Object.values(tags).reduce((total, one) => total + one, 0);
-    const others = Object.keys(unlisted).length;
-    to.debug(`usage (${how}): ${counted(Object.keys(tags).length, 'tag')} in ${counted(elements, 'element')}, ${counted(sum(parts), 'part')} styled, ${counted(sum(hooks), 'hook')} set` +
-        (others > 0 ? `, and ${counted(others, 'helix- tag')} no manifest lists` : ''));
     to.groupEnd();
     return result;
 };

package/dist/identity.d.ts

@@ -0,0 +1,34 @@
+/**
+ * What a finding is about, who fixes it, and which finding it is from one run
+ * to the next.
+ *
+ * **The fingerprint is what turns findings into issues.** Without it, a
+ * dashboard can count findings per run and cannot say whether the one in this
+ * run is the one from last week, fixed, or back again.
+ */
+import type { Published } from './manifest.js';
+import type { Identified, Raw } from './report.js';
+/**
+ * A selector with what a build changes taken out, so the same rule in the
+ * next build reads the same.
+ *
+ * **Hashed class names**, which CSS Modules write and every bundler hashes its
+ * own way:
+ *
+ * - Next.js: `trace-graph-module__lFhy0q__traceFrame`, to `trace-graph-module__traceFrame`.
+ * - webpack's default: `card__title___3xYz1`, to `card__title`.
+ * - Vite's default: `_title_1a2b3_7`, to `_title`.
+ *
+ * webpack's is taken out first: its `___` would otherwise read as the end of
+ * a Next.js hash. And spacing, which a minifier rewrites.
+ */
+export declare const normalize: (subject: string) => string;
+/**
+ * A finding's identity across runs: its kind, its tag, and its normalized
+ * subject. **The stylesheet is left out**, since a bundler puts a content
+ * hash in a file's name, so the same mistake in two stylesheets is one issue
+ * seen twice, which is how a reader thinks of it.
+ */
+export declare const fingerprintOf: (finding: Pick<Raw, 'kind' | 'subject' | 'tag'>) => 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

@@ -0,0 +1,46 @@
+const CATEGORY = {
+    'dead-hook': 'styling',
+    'dead-part': 'styling',
+    'duplicate-registration': 'integrity',
+    'invalid-value': 'markup',
+    'manifest-skew': 'integrity',
+    'unforwarded-part': 'styling',
+    'unknown-attribute': 'markup',
+    'unknown-tag': 'integrity',
+};
+const OWNER = {
+    'dead-hook': 'consumer',
+    'dead-part': 'consumer',
+    'duplicate-registration': 'consumer',
+    'invalid-value': 'consumer',
+    'manifest-skew': 'consumer',
+    'unforwarded-part': 'helix',
+    'unknown-attribute': 'consumer',
+    'unknown-tag': 'consumer',
+};
+export const normalize = (subject) => subject
+    .replace(/___[A-Za-z0-9_-]{5}\b/g, '')
+    .replace(/__[A-Za-z0-9_-]{6}__/g, '__')
+    .replace(/\b(_[A-Za-z][A-Za-z0-9-]*)_[a-z0-9]{5}_\d+\b/g, '$1')
+    .replace(/\s+/g, ' ')
+    .trim();
+const hash = (text) => {
+    let one = 0xdeadbeef;
+    let two = 0x41c6ce57;
+    for (let at = 0; at < text.length; at += 1) {
+        const code = text.charCodeAt(at);
+        one = Math.imul(one ^ code, 2654435761);
+        two = Math.imul(two ^ code, 1597334677);
+    }
+    one = Math.imul(one ^ (one >>> 16), 2246822507) ^ Math.imul(two ^ (two >>> 13), 3266489909);
+    two = Math.imul(two ^ (two >>> 16), 2246822507) ^ Math.imul(one ^ (one >>> 13), 3266489909);
+    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 identify = (finding, tags) => ({
+    ...finding,
+    category: CATEGORY[finding.kind],
+    family: tags.get(finding.tag)?.family,
+    fingerprint: fingerprintOf(finding),
+    owner: OWNER[finding.kind],
+});

package/dist/index.d.ts

@@ -28,19 +28,25 @@
  * stylesheet in the page and has no business in a production bundle.
  */
 export { collect } from './collect.js';
+export { type Config, DEFAULTS, pagePattern } from './config.js';
 export { report } from './console.js';
+export { fingerprintOf, normalize } from './identity.js';
 export type { ManifestSource, Published, Tier } from './manifest.js';
 export { index, nearest } from './manifest.js';
-export type { Coverage, Finding, Kind, Layer, Origin, Report, Severity, Unreadable, Usage, } from './report.js';
-export { KINDS } from './report.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 { 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 { Report } from './report.js';
-import { type Rules } from './rules.js';
+import type { Environment, Report } from './report.js';
 import { type Watcher } from './usage.js';
-/** What to look at, and what to compare it against. */
-export interface Options {
+/**
+ * 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.
      *
@@ -53,10 +59,16 @@ export interface Options {
      */
     duplicates?: () => string[];
     /**
-     * The project's own overrides, parsed from its file. The build reads the
-     * file, since the page cannot: import the JSON and pass it here.
+     * 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.
      */
-    file?: Rules | undefined;
+    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.
      *
@@ -65,14 +77,11 @@ export interface Options {
      */
     from?: Document;
     /**
-     * Overrides for this run, which win over `file`. Each says a severity,
-     * `off`, or either for some tags only:
-     *
-     * ```ts
-     * diagnose({ tiers, rules: { 'unforwarded-part': 'off', 'dead-hook': { severity: 'warn', tags: ['helix-card'] } } })
-     * ```
+     * 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.
      */
-    rules?: Rules | undefined;
+    page?: string | undefined;
     /**
      * The manifests to check against, one per installed tier.
      *
@@ -88,7 +97,7 @@ export interface Options {
     watcher?: Watcher | undefined;
 }
 /**
- * One pass over the page.
+ * 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
@@ -100,6 +109,7 @@ export interface Options {
  * 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: see `skew`.
+ * 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: ({ duplicates, file, from, rules, tiers, watcher }: Options) => Report;
+export declare const diagnose: (options: Options) => Report;

package/dist/index.js

@@ -1,38 +1,82 @@
 export { collect } from './collect.js';
+export { DEFAULTS, pagePattern } from './config.js';
 export { report } from './console.js';
+export { fingerprintOf, normalize } from './identity.js';
 export { index, nearest } from './manifest.js';
-export { KINDS } from './report.js';
+export { CATEGORIES, KINDS } from './report.js';
 export { SHIPPED_RULES } from './rules.js';
 export { watch } from './usage.js';
-import { analyze, registrations, skew } from './analyze.js';
+export { VERSION } from './version.js';
+import { analyze, markup, registrations, skew, versionSkew } from './analyze.js';
 import { collect } from './collect.js';
-import { index } from './manifest.js';
-import { applyRules, checkRules } from './rules.js';
-import { listed, styled, walk } from './usage.js';
-export const diagnose = ({ duplicates, file, from, rules, tiers, watcher }) => {
+import { pagePattern, resolveConfig } from './config.js';
+import { identify } from './identity.js';
+import { index, versionsOf } from './manifest.js';
+import { applyRules, overridesOf } from './rules.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.');
     }
-    checkRules(file, 'file');
-    checkRules(rules, 'argument');
+    const resolved = resolveConfig(file, call);
+    const { detail } = resolved.configuration;
     const document_ = from ?? globalThis.document;
-    const { answered, coverage, rules: located } = collect(document_);
+    const { answered, coverage, readers, rules: located, used } = collect(document_);
     const tags = index(tiers);
-    const skewed = applyRules(skew(tags, document_), file, rules);
+    const counted = watcher ? watcher.counts() : walk(document_);
+    const seen = loadedVersions();
+    const manifests = versionsOf(tiers);
+    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_)).map((one) => identify(one, tags)), file?.rules, call.rules);
     const judged = skewed.findings.length > 0
-        ? { findings: [], silenced: { argument: 0, file: 0 } }
-        : applyRules([...analyze(located, tags, document_, answered), ...registrations(document_, duplicates)], file, rules);
+        ? { findings: [], silenced: [] }
+        : applyRules([
+            ...analyze(located, tags, document_, answered, used, readers),
+            ...markup(tags, document_),
+            ...registrations(document_, duplicates),
+        ].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],
-        silenced: {
-            argument: skewed.silenced.argument + judged.silenced.argument,
-            file: skewed.silenced.file + judged.silenced.file,
+        project: resolved.project,
+        run: {
+            at,
+            duration: Math.round(performance.now() - started),
+            id: runId(),
+            source: 'page',
+            ...(environment === undefined ? {} : { environment }),
+            ...(shownPage === undefined ? {} : { page: shownPage }),
         },
+        schema: 1,
         usage: {
-            ...listed(watcher ? watcher.counts() : walk(document_), tags),
-            ...styled(located, tags, answered),
+            ...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,
+        })),
     };
 };