@variance-authority/tribunal 0.1.0

package/dist/ui/run.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DeclarationsPanel } from './declarations.js';
+import { DivergenceOf } from './divergence.js';
+import { ReachPanel } from './reach.js';
+import { Settled } from './settled.js';
+import { Prose } from './shell.js';
+import { CoverageLine } from './builds.js';
+import { Variations } from './variations.js';
+export function RunPage({ client, build, crossing, }) {
+    return (_jsx("div", { className: "va-stage va-scroll", children: _jsxs("div", { className: "va-page", children: [_jsx("h1", { children: "What this run read" }), _jsx("p", { className: "va-subtitle", children: "The whole reading, in the order it was made: what the commit reaches, what has changed since the last run, what was compared without a baseline, and what nothing looked at. The decisions are on the changes." }), build.intent === undefined ? null : (_jsxs("p", { className: "va-intent", children: ["Declared intent: ", _jsx("em", { children: build.intent })] })), _jsx(CoverageLine, { build: build }), _jsx("section", { className: "va-card", children: _jsx(ReachPanel, { client: client, build: build }) }), _jsx("section", { className: "va-card", children: _jsx(DivergenceOf, { crossing: crossing }) }), build.variations.length === 0 ? null : (_jsx("section", { className: "va-card", children: _jsx(Variations, { variations: build.variations }) })), _jsxs("section", { className: "va-card", children: [_jsx("h2", { children: "Settled" }), _jsx(Settled, { subjects: build.subjects, ignores: build.declarations.ignores })] }), _jsxs("section", { className: "va-card", children: [_jsx("h2", { children: "Declarations" }), _jsx(DeclarationsPanel, { declarations: build.declarations })] }), build.notObserved.length === 0 ? null : (_jsxs("section", { className: "va-card", children: [_jsx("h2", { children: "Not observed" }), _jsx("ul", { className: "va-not-observed", children: build.notObserved.map((entry) => (_jsxs("li", { className: entry.kind === 'failed' ? 'va-failed' : '', children: [_jsx("strong", { children: entry.subject }), " \u2014 ", _jsx(Prose, { text: entry.because })] }, entry.subject))) })] }))] }) }));
+}
+//# sourceMappingURL=run.js.map

package/dist/ui/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../../src/ui/run.tsx"],"names":[],"mappings":";AAqBA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,MAAM,UAAU,OAAO,CAAC,EACtB,MAAM,EACN,KAAK,EACL,QAAQ,GAKT;IACC,OAAO,CACL,cAAK,SAAS,EAAC,oBAAoB,YACjC,eAAK,SAAS,EAAC,SAAS,aACtB,8CAA2B,EAC3B,YAAG,SAAS,EAAC,aAAa,+NAItB,EAEH,KAAK,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CACnC,aAAG,SAAS,EAAC,WAAW,kCACL,uBAAK,KAAK,CAAC,MAAM,GAAM,IACtC,CACL,EACD,KAAC,YAAY,IAAC,KAAK,EAAE,KAAK,GAAI,EAE9B,kBAAS,SAAS,EAAC,SAAS,YAC1B,KAAC,UAAU,IAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAI,GACpC,EAEV,kBAAS,SAAS,EAAC,SAAS,YAC1B,KAAC,YAAY,IAAC,QAAQ,EAAE,QAAQ,GAAI,GAC5B,EAET,KAAK,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CACtC,kBAAS,SAAS,EAAC,SAAS,YAC1B,KAAC,UAAU,IAAC,UAAU,EAAE,KAAK,CAAC,UAAU,GAAI,GACpC,CACX,EAED,mBAAS,SAAS,EAAC,SAAS,aAC1B,mCAAgB,EAChB,KAAC,OAAO,IAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,CAAC,YAAY,CAAC,OAAO,GAAI,IAClE,EAEV,mBAAS,SAAS,EAAC,SAAS,aAC1B,wCAAqB,EACrB,KAAC,iBAAiB,IAAC,YAAY,EAAE,KAAK,CAAC,YAAY,GAAI,IAC/C,EAET,KAAK,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CACvC,mBAAS,SAAS,EAAC,SAAS,aAC1B,wCAAqB,EACrB,aAAI,SAAS,EAAC,iBAAiB,YAC5B,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAChC,cAAwB,SAAS,EAAE,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,aAC3E,2BAAS,KAAK,CAAC,OAAO,GAAU,cAAG,KAAC,KAAK,IAAC,IAAI,EAAE,KAAK,CAAC,OAAO,GAAI,KAD1D,KAAK,CAAC,OAAO,CAEjB,CACN,CAAC,GACC,IACG,CACX,IACG,GACF,CACP,CAAC;AACJ,CAAC","sourcesContent":["/**\n * The run, in full — everything the report says that is not one change.\n *\n * This is the material that used to sit under the docket on the build page, and\n * moving it is the whole of the layout argument. Reach, the crossing against the\n * last run, the variation lattice, what a declaration settled, what was declared,\n * what was never observed: every one of those is worth reading, and none of them\n * is worth reading *while deciding whether to approve a restyle of `Button`*. On\n * one page they were four thousand pixels of scroll between a reviewer and the\n * second change in the build.\n *\n * So they have an address. A reviewer working a docket never opens it; a reviewer\n * asking *what did this run actually do* opens nothing else. The crossing is\n * handed down rather than fetched again — the build page has already asked, and\n * the two readings of one comparison must not be able to disagree.\n */\n\nimport type { ReactElement } from 'react';\nimport type { BuildDetail } from '../review-types.js';\nimport type { ReviewClient } from './client.js';\nimport type { Crossing } from './crossing.js';\nimport { DeclarationsPanel } from './declarations.js';\nimport { DivergenceOf } from './divergence.js';\nimport { ReachPanel } from './reach.js';\nimport { Settled } from './settled.js';\nimport { Prose } from './shell.js';\nimport { CoverageLine } from './builds.js';\nimport { Variations } from './variations.js';\n\nexport function RunPage({\n  client,\n  build,\n  crossing,\n}: {\n  readonly client: ReviewClient;\n  readonly build: BuildDetail;\n  readonly crossing: Crossing;\n}): ReactElement {\n  return (\n    <div className=\"va-stage va-scroll\">\n      <div className=\"va-page\">\n        <h1>What this run read</h1>\n        <p className=\"va-subtitle\">\n          The whole reading, in the order it was made: what the commit reaches, what has changed\n          since the last run, what was compared without a baseline, and what nothing looked at. The\n          decisions are on the changes.\n        </p>\n\n        {build.intent === undefined ? null : (\n          <p className=\"va-intent\">\n            Declared intent: <em>{build.intent}</em>\n          </p>\n        )}\n        <CoverageLine build={build} />\n\n        <section className=\"va-card\">\n          <ReachPanel client={client} build={build} />\n        </section>\n\n        <section className=\"va-card\">\n          <DivergenceOf crossing={crossing} />\n        </section>\n\n        {build.variations.length === 0 ? null : (\n          <section className=\"va-card\">\n            <Variations variations={build.variations} />\n          </section>\n        )}\n\n        <section className=\"va-card\">\n          <h2>Settled</h2>\n          <Settled subjects={build.subjects} ignores={build.declarations.ignores} />\n        </section>\n\n        <section className=\"va-card\">\n          <h2>Declarations</h2>\n          <DeclarationsPanel declarations={build.declarations} />\n        </section>\n\n        {build.notObserved.length === 0 ? null : (\n          <section className=\"va-card\">\n            <h2>Not observed</h2>\n            <ul className=\"va-not-observed\">\n              {build.notObserved.map((entry) => (\n                <li key={entry.subject} className={entry.kind === 'failed' ? 'va-failed' : ''}>\n                  <strong>{entry.subject}</strong> — <Prose text={entry.because} />\n                </li>\n              ))}\n            </ul>\n          </section>\n        )}\n      </div>\n    </div>\n  );\n}\n"]}

package/dist/ui/sense.d.ts

@@ -0,0 +1,187 @@
+/**
+ * What moved, in the sense the digests recorded rather than the area it covered.
+ *
+ * The page this exists for used to read *2 distinct differences, in 7 renders.
+ * 30,373 px in total* — three numbers, none of which is the change. A reviewer
+ * cannot approve what they have not been told, and every one of those figures
+ * describes the measurement instead of the edit.
+ *
+ * The run always knew better. A baseline carries a component's hashes split five
+ * ways, so a comparison of two sidecars can say *this component's declared style
+ * moved and its layout moved and its text did not* — without decoding a pixel,
+ * and without depending on the difference having landed somewhere a box could be
+ * drawn around. The report carries that list per subject; this turns it into the
+ * two things a surface needs from it.
+ *
+ * ## The two things
+ *
+ * **What each component moved in**, which is the sentence the page was missing.
+ *
+ * **What the picture lost**, which is the finding nobody was being shown. A
+ * region is named by resolving the box the pixels drew back to a component, so
+ * it fails precisely when a change matters most: an edit that reflows its
+ * neighbours merges into one blob, the blob fits no component, and the name that
+ * comes back is the document root. Held against the hashes, that subject stops
+ * being a mystery — `Button` moved in its layout and its declared style, and no
+ * region carries the name. The gap is reportable, and until it is reported the
+ * page is quietly confident about a component it never mentioned.
+ *
+ * The reverse pile is kept too, and it is not the same finding. A component a
+ * region names while its own hashes held still was *pushed* — it is collateral,
+ * and a page that called it a change would be doing the ranking this project
+ * exists to correct.
+ */
+import type { SubjectView } from '../review-types.js';
+import type { Appearance } from './grouping.js';
+/** One component the hashes say moved, held against what the picture found. */
+export interface Sensed {
+    readonly component: string;
+    readonly bands: readonly string[];
+    /** Its own content moved, rather than only its rect being pushed. */
+    readonly cause: boolean;
+    /** Present on one side only, which `bands` alone cannot say. */
+    readonly presence?: 'added' | 'removed';
+    /** A region in this subject resolved to this name. */
+    readonly drawn: boolean;
+}
+/** A subject read at the semantic tier, and the two tiers held against each other. */
+export interface Sense {
+    /**
+     * `false` when the baseline carried no hashes, so none of this was measured.
+     *
+     * The whole record collapses to *unknown* rather than to *nothing moved*, and
+     * a surface must print the difference. An empty `moved` on a measured subject
+     * with pixels in it is a real finding; the same emptiness unmeasured is a
+     * baseline written before the hashes existed.
+     */
+    readonly measured: boolean;
+    readonly moved: readonly Sensed[];
+    /** Caused the difference, and no region names it: what the picture lost. */
+    readonly missed: readonly Sensed[];
+    /** Named by a region while its own hashes held still — pushed, not edited. */
+    readonly pushed: readonly string[];
+}
+/**
+ * The band, in the words a reviewer thinks in.
+ *
+ * Not the band name. `token` is a word this project uses precisely and a reader
+ * arriving from a pull request does not, and a page that leads with it has spent
+ * its most important line on vocabulary. The mapping is deliberately flat — one
+ * phrase each, no qualifiers — because these are joined into a clause and a
+ * hedge repeated four times down a list is a hedge nobody reads.
+ *
+ * An unknown band is returned unchanged. A newer report carrying a band this
+ * deployment has never heard of should print the word it was given, not vanish.
+ */
+export declare function senseOf(band: string): string;
+/** `its layout and its style values` — the bands as one clause, loudest first. */
+export declare function senses(bands: readonly string[]): string;
+/**
+ * One subject, with the hashes and the regions read against each other.
+ *
+ * The join is on the component name and nothing else, which is the only key the
+ * two tiers share: a region carries the name its box resolved to, and a hash
+ * entry carries the name the boundary walk assigned. Both come from the same
+ * walk in the same run, so a name that appears in one and not the other is a
+ * real disagreement rather than a spelling.
+ */
+export declare function senseOfSubject(subject: SubjectView): Sense;
+/** One component's movement across the renders a change showed up in. */
+export interface Across {
+    /**
+     * Renders whose baseline carried hashes to compare — never their band count.
+     *
+     * Zero is the state every other field here is unreadable in: `bands: []` then
+     * means *nothing was measured*, and printed as *nothing moved* it is a claim
+     * made on the authority of something that never looked.
+     */
+    readonly measured: number;
+    /** Every band this component moved in, anywhere, loudest first. */
+    readonly bands: readonly string[];
+    /** Renders it moved in where no region carried its name. */
+    readonly missedIn: readonly string[];
+    /** Renders whose baseline had no hashes, so nothing was measured there. */
+    readonly unmeasured: readonly string[];
+    /**
+     * What else moved in the same renders, and in what sense.
+     *
+     * The answer to the complaint this page kept earning: a card whose price string
+     * changed reports the button, because the button is what the largest box
+     * resolved to. Naming the other movers with their own bands is what lets a
+     * reviewer see that the text moved in the parent and the button moved in its
+     * style — two edits, correctly separated, on one screen.
+     */
+    readonly alongside: readonly {
+        readonly component: string;
+        readonly bands: readonly string[];
+    }[];
+}
+/**
+ * The same reading, folded over every render one change appeared in.
+ *
+ * Union rather than intersection, and the difference is not cosmetic. A restyled
+ * button in a card that also grew moves in `token` everywhere and in `geometry`
+ * only where the row reflowed; an intersection would drop the second and report
+ * a size change as a repaint.
+ */
+export declare function senseAcross(component: string, appearances: readonly Appearance[]): Across;
+/**
+ * Loudest first, and held here rather than imported.
+ *
+ * `BANDS` is `core`'s, and this package reads reports rather than core's compare
+ * tier — a surface that pulled the ordering across would tie the words on a page
+ * to a library it does not otherwise need.
+ */
+export declare const ORDER: readonly string[];
+/**
+ * The known bands in their own order, then anything this build has not heard of.
+ *
+ * A newer report may carry a band added after this deployment shipped, and a
+ * filter over {@link ORDER} would drop it — the surface would report four bands
+ * where the run recorded five, and nothing on the page would say so. Unknown
+ * words go last because the order is a loudness claim this build cannot make
+ * about them, and alphabetically because that is an order rather than an
+ * accident of iteration.
+ */
+export declare function loudestFirst(bands: Iterable<string>): readonly string[];
+/** A render this component moved in that some other change owns. */
+export interface Elsewhere {
+    readonly subject: string;
+    /** The change the docket filed this render under, when a region named one. */
+    readonly filedUnder?: string;
+    /** A region here carries this component, so its picture is a picture of it. */
+    readonly drawn: boolean;
+}
+/**
+ * The renders a change moved in and does not appear on.
+ *
+ * A subject is filed under the component its **leading region** resolved to, and
+ * a render has exactly one of those — so a commit that edits a button and a
+ * price string files every card under whichever of the two happened to own the
+ * larger differing box. The button's page then lists seven renders of the twelve
+ * it moved in, and says nothing at all about the other five.
+ *
+ * That is the reviewer's problem and not a presentation detail: pressing approve
+ * on this page decides the renders on this page. The five it never mentioned
+ * stay open, under a name the person looking for this change would not think to
+ * open. Naming them is the difference between a docket and a docket that can be
+ * finished.
+ *
+ * `here` is the set already listed, passed in rather than derived, because the
+ * caller's list is the definition of *already shown* and re-deriving it here
+ * would be a second opinion about the same question.
+ */
+export declare function movedElsewhere(component: string, subjects: readonly SubjectView[], here: ReadonlySet<string>): readonly Elsewhere[];
+/**
+ * What each band is read from, for the reviewer who asks how the page knows.
+ *
+ * *What it announces moved* is a claim, and until this line existed the page made
+ * it with nothing behind it. It is a digest comparison: the run hashes the role,
+ * name and state of every node inside a component boundary, the baseline sidecar
+ * keeps that hash, and a later run's hash disagrees. Which is a real answer, and
+ * also a short one — the values are not stored, so the band says *these differ*
+ * and cannot say what the name became. Printing the first half without the second
+ * lets a reviewer read a precision into it that is not there.
+ */
+export declare const READS: Readonly<Record<string, string>>;
+//# sourceMappingURL=sense.d.ts.map

package/dist/ui/sense.js

@@ -0,0 +1,222 @@
+/**
+ * What moved, in the sense the digests recorded rather than the area it covered.
+ *
+ * The page this exists for used to read *2 distinct differences, in 7 renders.
+ * 30,373 px in total* — three numbers, none of which is the change. A reviewer
+ * cannot approve what they have not been told, and every one of those figures
+ * describes the measurement instead of the edit.
+ *
+ * The run always knew better. A baseline carries a component's hashes split five
+ * ways, so a comparison of two sidecars can say *this component's declared style
+ * moved and its layout moved and its text did not* — without decoding a pixel,
+ * and without depending on the difference having landed somewhere a box could be
+ * drawn around. The report carries that list per subject; this turns it into the
+ * two things a surface needs from it.
+ *
+ * ## The two things
+ *
+ * **What each component moved in**, which is the sentence the page was missing.
+ *
+ * **What the picture lost**, which is the finding nobody was being shown. A
+ * region is named by resolving the box the pixels drew back to a component, so
+ * it fails precisely when a change matters most: an edit that reflows its
+ * neighbours merges into one blob, the blob fits no component, and the name that
+ * comes back is the document root. Held against the hashes, that subject stops
+ * being a mystery — `Button` moved in its layout and its declared style, and no
+ * region carries the name. The gap is reportable, and until it is reported the
+ * page is quietly confident about a component it never mentioned.
+ *
+ * The reverse pile is kept too, and it is not the same finding. A component a
+ * region names while its own hashes held still was *pushed* — it is collateral,
+ * and a page that called it a change would be doing the ranking this project
+ * exists to correct.
+ */
+import { causeOf } from './lead.js';
+/**
+ * The band, in the words a reviewer thinks in.
+ *
+ * Not the band name. `token` is a word this project uses precisely and a reader
+ * arriving from a pull request does not, and a page that leads with it has spent
+ * its most important line on vocabulary. The mapping is deliberately flat — one
+ * phrase each, no qualifiers — because these are joined into a clause and a
+ * hedge repeated four times down a list is a hedge nobody reads.
+ *
+ * An unknown band is returned unchanged. A newer report carrying a band this
+ * deployment has never heard of should print the word it was given, not vanish.
+ */
+export function senseOf(band) {
+    return SENSES[band] ?? band;
+}
+const SENSES = {
+    // Role, accessible name, ARIA state: what a screen reader says out loud.
+    a11y: 'what it announces',
+    // Both the structure digest and the rect: tags, attributes, child boundaries,
+    // and where the boxes ended up. One phrase, because a reviewer asking "did the
+    // layout move" is not distinguishing the two and the digests cannot either.
+    geometry: 'its layout',
+    token: 'its style values',
+    content: 'its text',
+    // Never produced by a hash comparison — a component hash is built from a
+    // document. Here so a report that grows one is not printed as a bare slug.
+    texture: 'its texture',
+};
+/** `its layout and its style values` — the bands as one clause, loudest first. */
+export function senses(bands) {
+    const words = bands.map(senseOf);
+    if (words.length <= 1)
+        return words[0] ?? '';
+    return `${words.slice(0, -1).join(', ')} and ${words[words.length - 1] ?? ''}`;
+}
+/**
+ * One subject, with the hashes and the regions read against each other.
+ *
+ * The join is on the component name and nothing else, which is the only key the
+ * two tiers share: a region carries the name its box resolved to, and a hash
+ * entry carries the name the boundary walk assigned. Both come from the same
+ * walk in the same run, so a name that appears in one and not the other is a
+ * real disagreement rather than a spelling.
+ */
+export function senseOfSubject(subject) {
+    const drawn = new Set(subject.regions
+        .map((region) => region.component)
+        .filter((name) => name !== undefined));
+    const moved = (subject.moved ?? []).map((entry) => ({ ...entry, drawn: drawn.has(entry.component) }));
+    const stirred = new Set(moved.map((entry) => entry.component));
+    return {
+        measured: subject.moved !== undefined,
+        moved,
+        missed: moved.filter((entry) => entry.cause && !entry.drawn),
+        // Only when the hashes were read. Without them every named region would land
+        // here, and the page would report the whole build as collateral.
+        pushed: subject.moved === undefined
+            ? []
+            : [...drawn].filter((name) => !stirred.has(name)).sort(),
+    };
+}
+/**
+ * The same reading, folded over every render one change appeared in.
+ *
+ * Union rather than intersection, and the difference is not cosmetic. A restyled
+ * button in a card that also grew moves in `token` everywhere and in `geometry`
+ * only where the row reflowed; an intersection would drop the second and report
+ * a size change as a repaint.
+ */
+export function senseAcross(component, appearances) {
+    const bands = new Set();
+    const missedIn = [];
+    const unmeasured = [];
+    const others = new Map();
+    for (const { subject } of appearances) {
+        const sense = senseOfSubject(subject);
+        if (!sense.measured) {
+            unmeasured.push(subject.subject);
+            continue;
+        }
+        for (const entry of sense.moved) {
+            if (entry.component === component) {
+                for (const band of entry.bands)
+                    bands.add(band);
+                if (!entry.drawn)
+                    missedIn.push(subject.subject);
+                continue;
+            }
+            const seen = others.get(entry.component) ?? new Set();
+            for (const band of entry.bands)
+                seen.add(band);
+            others.set(entry.component, seen);
+        }
+    }
+    return {
+        measured: appearances.length - unmeasured.length,
+        bands: loudestFirst(bands),
+        missedIn,
+        unmeasured,
+        alongside: [...others.entries()]
+            .map(([name, seen]) => ({ component: name, bands: loudestFirst(seen) }))
+            .sort((left, right) => left.component.localeCompare(right.component)),
+    };
+}
+/**
+ * Loudest first, and held here rather than imported.
+ *
+ * `BANDS` is `core`'s, and this package reads reports rather than core's compare
+ * tier — a surface that pulled the ordering across would tie the words on a page
+ * to a library it does not otherwise need.
+ */
+export const ORDER = ['a11y', 'geometry', 'token', 'content', 'texture'];
+/**
+ * The known bands in their own order, then anything this build has not heard of.
+ *
+ * A newer report may carry a band added after this deployment shipped, and a
+ * filter over {@link ORDER} would drop it — the surface would report four bands
+ * where the run recorded five, and nothing on the page would say so. Unknown
+ * words go last because the order is a loudness claim this build cannot make
+ * about them, and alphabetically because that is an order rather than an
+ * accident of iteration.
+ */
+export function loudestFirst(bands) {
+    const present = new Set(bands);
+    const known = ORDER.filter((band) => present.has(band));
+    const rest = [...present].filter((band) => !ORDER.includes(band)).sort();
+    return [...known, ...rest];
+}
+/**
+ * The renders a change moved in and does not appear on.
+ *
+ * A subject is filed under the component its **leading region** resolved to, and
+ * a render has exactly one of those — so a commit that edits a button and a
+ * price string files every card under whichever of the two happened to own the
+ * larger differing box. The button's page then lists seven renders of the twelve
+ * it moved in, and says nothing at all about the other five.
+ *
+ * That is the reviewer's problem and not a presentation detail: pressing approve
+ * on this page decides the renders on this page. The five it never mentioned
+ * stay open, under a name the person looking for this change would not think to
+ * open. Naming them is the difference between a docket and a docket that can be
+ * finished.
+ *
+ * `here` is the set already listed, passed in rather than derived, because the
+ * caller's list is the definition of *already shown* and re-deriving it here
+ * would be a second opinion about the same question.
+ */
+export function movedElsewhere(component, subjects, here) {
+    const found = [];
+    for (const subject of subjects) {
+        if (subject.verdict !== 'changed')
+            continue;
+        if (here.has(subject.subject))
+            continue;
+        // Caused, not merely moved. A render where this component's box was pushed
+        // by somebody else's edit is not a render of this change, and listing it
+        // would put the collateral the ranking exists to demote back on the page.
+        const moved = (subject.moved ?? []).some((entry) => entry.component === component && entry.cause);
+        if (!moved)
+            continue;
+        const under = causeOf(subject);
+        found.push({
+            subject: subject.subject,
+            ...(under === undefined ? {} : { filedUnder: under }),
+            drawn: subject.regions.some((region) => region.component === component),
+        });
+    }
+    return found;
+}
+/**
+ * What each band is read from, for the reviewer who asks how the page knows.
+ *
+ * *What it announces moved* is a claim, and until this line existed the page made
+ * it with nothing behind it. It is a digest comparison: the run hashes the role,
+ * name and state of every node inside a component boundary, the baseline sidecar
+ * keeps that hash, and a later run's hash disagrees. Which is a real answer, and
+ * also a short one — the values are not stored, so the band says *these differ*
+ * and cannot say what the name became. Printing the first half without the second
+ * lets a reviewer read a precision into it that is not there.
+ */
+export const READS = {
+    a11y: 'the role, name and state of every node in it',
+    geometry: 'its nodes’ boxes, and the layout properties they compute to',
+    token: 'the style properties it declares, and the tokens behind them',
+    content: 'the text its nodes carry',
+    texture: 'the pixels themselves, after the other four agreed',
+};
+//# sourceMappingURL=sense.js.map

package/dist/ui/sense.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sense.js","sourceRoot":"","sources":["../../src/ui/sense.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * What moved, in the sense the digests recorded rather than the area it covered.\n *\n * The page this exists for used to read *2 distinct differences, in 7 renders.\n * 30,373 px in total* — three numbers, none of which is the change. A reviewer\n * cannot approve what they have not been told, and every one of those figures\n * describes the measurement instead of the edit.\n *\n * The run always knew better. A baseline carries a component's hashes split five\n * ways, so a comparison of two sidecars can say *this component's declared style\n * moved and its layout moved and its text did not* — without decoding a pixel,\n * and without depending on the difference having landed somewhere a box could be\n * drawn around. The report carries that list per subject; this turns it into the\n * two things a surface needs from it.\n *\n * ## The two things\n *\n * **What each component moved in**, which is the sentence the page was missing.\n *\n * **What the picture lost**, which is the finding nobody was being shown. A\n * region is named by resolving the box the pixels drew back to a component, so\n * it fails precisely when a change matters most: an edit that reflows its\n * neighbours merges into one blob, the blob fits no component, and the name that\n * comes back is the document root. Held against the hashes, that subject stops\n * being a mystery — `Button` moved in its layout and its declared style, and no\n * region carries the name. The gap is reportable, and until it is reported the\n * page is quietly confident about a component it never mentioned.\n *\n * The reverse pile is kept too, and it is not the same finding. A component a\n * region names while its own hashes held still was *pushed* — it is collateral,\n * and a page that called it a change would be doing the ranking this project\n * exists to correct.\n */\n\nimport type { SubjectView } from '../review-types.js';\nimport type { Appearance } from './grouping.js';\nimport { causeOf } from './lead.js';\n\n/** One component the hashes say moved, held against what the picture found. */\nexport interface Sensed {\n  readonly component: string;\n  readonly bands: readonly string[];\n  /** Its own content moved, rather than only its rect being pushed. */\n  readonly cause: boolean;\n  /** Present on one side only, which `bands` alone cannot say. */\n  readonly presence?: 'added' | 'removed';\n  /** A region in this subject resolved to this name. */\n  readonly drawn: boolean;\n}\n\n/** A subject read at the semantic tier, and the two tiers held against each other. */\nexport interface Sense {\n  /**\n   * `false` when the baseline carried no hashes, so none of this was measured.\n   *\n   * The whole record collapses to *unknown* rather than to *nothing moved*, and\n   * a surface must print the difference. An empty `moved` on a measured subject\n   * with pixels in it is a real finding; the same emptiness unmeasured is a\n   * baseline written before the hashes existed.\n   */\n  readonly measured: boolean;\n  readonly moved: readonly Sensed[];\n  /** Caused the difference, and no region names it: what the picture lost. */\n  readonly missed: readonly Sensed[];\n  /** Named by a region while its own hashes held still — pushed, not edited. */\n  readonly pushed: readonly string[];\n}\n\n/**\n * The band, in the words a reviewer thinks in.\n *\n * Not the band name. `token` is a word this project uses precisely and a reader\n * arriving from a pull request does not, and a page that leads with it has spent\n * its most important line on vocabulary. The mapping is deliberately flat — one\n * phrase each, no qualifiers — because these are joined into a clause and a\n * hedge repeated four times down a list is a hedge nobody reads.\n *\n * An unknown band is returned unchanged. A newer report carrying a band this\n * deployment has never heard of should print the word it was given, not vanish.\n */\nexport function senseOf(band: string): string {\n  return SENSES[band] ?? band;\n}\n\nconst SENSES: Readonly<Record<string, string>> = {\n  // Role, accessible name, ARIA state: what a screen reader says out loud.\n  a11y: 'what it announces',\n  // Both the structure digest and the rect: tags, attributes, child boundaries,\n  // and where the boxes ended up. One phrase, because a reviewer asking \"did the\n  // layout move\" is not distinguishing the two and the digests cannot either.\n  geometry: 'its layout',\n  token: 'its style values',\n  content: 'its text',\n  // Never produced by a hash comparison — a component hash is built from a\n  // document. Here so a report that grows one is not printed as a bare slug.\n  texture: 'its texture',\n};\n\n/** `its layout and its style values` — the bands as one clause, loudest first. */\nexport function senses(bands: readonly string[]): string {\n  const words = bands.map(senseOf);\n  if (words.length <= 1) return words[0] ?? '';\n  return `${words.slice(0, -1).join(', ')} and ${words[words.length - 1] ?? ''}`;\n}\n\n/**\n * One subject, with the hashes and the regions read against each other.\n *\n * The join is on the component name and nothing else, which is the only key the\n * two tiers share: a region carries the name its box resolved to, and a hash\n * entry carries the name the boundary walk assigned. Both come from the same\n * walk in the same run, so a name that appears in one and not the other is a\n * real disagreement rather than a spelling.\n */\nexport function senseOfSubject(subject: SubjectView): Sense {\n  const drawn = new Set(\n    subject.regions\n      .map((region) => region.component)\n      .filter((name): name is string => name !== undefined),\n  );\n\n  const moved = (subject.moved ?? []).map(\n    (entry): Sensed => ({ ...entry, drawn: drawn.has(entry.component) }),\n  );\n  const stirred = new Set(moved.map((entry) => entry.component));\n\n  return {\n    measured: subject.moved !== undefined,\n    moved,\n    missed: moved.filter((entry) => entry.cause && !entry.drawn),\n    // Only when the hashes were read. Without them every named region would land\n    // here, and the page would report the whole build as collateral.\n    pushed:\n      subject.moved === undefined\n        ? []\n        : [...drawn].filter((name) => !stirred.has(name)).sort(),\n  };\n}\n\n/** One component's movement across the renders a change showed up in. */\nexport interface Across {\n  /**\n   * Renders whose baseline carried hashes to compare — never their band count.\n   *\n   * Zero is the state every other field here is unreadable in: `bands: []` then\n   * means *nothing was measured*, and printed as *nothing moved* it is a claim\n   * made on the authority of something that never looked.\n   */\n  readonly measured: number;\n  /** Every band this component moved in, anywhere, loudest first. */\n  readonly bands: readonly string[];\n  /** Renders it moved in where no region carried its name. */\n  readonly missedIn: readonly string[];\n  /** Renders whose baseline had no hashes, so nothing was measured there. */\n  readonly unmeasured: readonly string[];\n  /**\n   * What else moved in the same renders, and in what sense.\n   *\n   * The answer to the complaint this page kept earning: a card whose price string\n   * changed reports the button, because the button is what the largest box\n   * resolved to. Naming the other movers with their own bands is what lets a\n   * reviewer see that the text moved in the parent and the button moved in its\n   * style — two edits, correctly separated, on one screen.\n   */\n  readonly alongside: readonly { readonly component: string; readonly bands: readonly string[] }[];\n}\n\n/**\n * The same reading, folded over every render one change appeared in.\n *\n * Union rather than intersection, and the difference is not cosmetic. A restyled\n * button in a card that also grew moves in `token` everywhere and in `geometry`\n * only where the row reflowed; an intersection would drop the second and report\n * a size change as a repaint.\n */\nexport function senseAcross(component: string, appearances: readonly Appearance[]): Across {\n  const bands = new Set<string>();\n  const missedIn: string[] = [];\n  const unmeasured: string[] = [];\n  const others = new Map<string, Set<string>>();\n\n  for (const { subject } of appearances) {\n    const sense = senseOfSubject(subject);\n    if (!sense.measured) {\n      unmeasured.push(subject.subject);\n      continue;\n    }\n\n    for (const entry of sense.moved) {\n      if (entry.component === component) {\n        for (const band of entry.bands) bands.add(band);\n        if (!entry.drawn) missedIn.push(subject.subject);\n        continue;\n      }\n      const seen = others.get(entry.component) ?? new Set<string>();\n      for (const band of entry.bands) seen.add(band);\n      others.set(entry.component, seen);\n    }\n  }\n\n  return {\n    measured: appearances.length - unmeasured.length,\n    bands: loudestFirst(bands),\n    missedIn,\n    unmeasured,\n    alongside: [...others.entries()]\n      .map(([name, seen]) => ({ component: name, bands: loudestFirst(seen) }))\n      .sort((left, right) => left.component.localeCompare(right.component)),\n  };\n}\n\n/**\n * Loudest first, and held here rather than imported.\n *\n * `BANDS` is `core`'s, and this package reads reports rather than core's compare\n * tier — a surface that pulled the ordering across would tie the words on a page\n * to a library it does not otherwise need.\n */\nexport const ORDER: readonly string[] = ['a11y', 'geometry', 'token', 'content', 'texture'];\n\n/**\n * The known bands in their own order, then anything this build has not heard of.\n *\n * A newer report may carry a band added after this deployment shipped, and a\n * filter over {@link ORDER} would drop it — the surface would report four bands\n * where the run recorded five, and nothing on the page would say so. Unknown\n * words go last because the order is a loudness claim this build cannot make\n * about them, and alphabetically because that is an order rather than an\n * accident of iteration.\n */\nexport function loudestFirst(bands: Iterable<string>): readonly string[] {\n  const present = new Set(bands);\n  const known = ORDER.filter((band) => present.has(band));\n  const rest = [...present].filter((band) => !ORDER.includes(band)).sort();\n  return [...known, ...rest];\n}\n\n/** A render this component moved in that some other change owns. */\nexport interface Elsewhere {\n  readonly subject: string;\n  /** The change the docket filed this render under, when a region named one. */\n  readonly filedUnder?: string;\n  /** A region here carries this component, so its picture is a picture of it. */\n  readonly drawn: boolean;\n}\n\n/**\n * The renders a change moved in and does not appear on.\n *\n * A subject is filed under the component its **leading region** resolved to, and\n * a render has exactly one of those — so a commit that edits a button and a\n * price string files every card under whichever of the two happened to own the\n * larger differing box. The button's page then lists seven renders of the twelve\n * it moved in, and says nothing at all about the other five.\n *\n * That is the reviewer's problem and not a presentation detail: pressing approve\n * on this page decides the renders on this page. The five it never mentioned\n * stay open, under a name the person looking for this change would not think to\n * open. Naming them is the difference between a docket and a docket that can be\n * finished.\n *\n * `here` is the set already listed, passed in rather than derived, because the\n * caller's list is the definition of *already shown* and re-deriving it here\n * would be a second opinion about the same question.\n */\nexport function movedElsewhere(\n  component: string,\n  subjects: readonly SubjectView[],\n  here: ReadonlySet<string>,\n): readonly Elsewhere[] {\n  const found: Elsewhere[] = [];\n\n  for (const subject of subjects) {\n    if (subject.verdict !== 'changed') continue;\n    if (here.has(subject.subject)) continue;\n    // Caused, not merely moved. A render where this component's box was pushed\n    // by somebody else's edit is not a render of this change, and listing it\n    // would put the collateral the ranking exists to demote back on the page.\n    const moved = (subject.moved ?? []).some(\n      (entry) => entry.component === component && entry.cause,\n    );\n    if (!moved) continue;\n\n    const under = causeOf(subject);\n    found.push({\n      subject: subject.subject,\n      ...(under === undefined ? {} : { filedUnder: under }),\n      drawn: subject.regions.some((region) => region.component === component),\n    });\n  }\n\n  return found;\n}\n\n/**\n * What each band is read from, for the reviewer who asks how the page knows.\n *\n * *What it announces moved* is a claim, and until this line existed the page made\n * it with nothing behind it. It is a digest comparison: the run hashes the role,\n * name and state of every node inside a component boundary, the baseline sidecar\n * keeps that hash, and a later run's hash disagrees. Which is a real answer, and\n * also a short one — the values are not stored, so the band says *these differ*\n * and cannot say what the name became. Printing the first half without the second\n * lets a reviewer read a precision into it that is not there.\n */\nexport const READS: Readonly<Record<string, string>> = {\n  a11y: 'the role, name and state of every node in it',\n  geometry: 'its nodes’ boxes, and the layout properties they compute to',\n  token: 'the style properties it declares, and the tokens behind them',\n  content: 'the text its nodes carry',\n  texture: 'the pixels themselves, after the other four agreed',\n};\n"]}

package/dist/ui/settled.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The subjects that came back green, and which kind of green each one is.
+ *
+ * The rail carries what needs a decision, and a subject that was absorbed by an
+ * ignore does not — the rule already made the decision, on a day somebody wrote
+ * it into the config. But green by measurement and green by declaration are not
+ * the same fact, and the second is the one that goes wrong silently: a rule that
+ * has grown over a real regression reports `ignored` every run and reads exactly
+ * like a subject nothing happened to.
+ *
+ * So they are kept, folded. Behind a `<details>` because on a run of three
+ * hundred stories this is three hundred lines of nothing, and open in one click
+ * because the moment a reviewer wants it is the moment they are asking *what did
+ * this build not tell me*.
+ *
+ * The sentence under each name is the observer's own, unedited. This surface did
+ * not measure anything and has nothing to add — and where the record does not say
+ * which rule absorbed a subject, the note says that rather than leaving a reader
+ * to conclude the difference was small.
+ *
+ * Which rule that was is read by `greenBecause` in the report package, the same
+ * call the HTML report makes over the same block. The report and this page are
+ * two renderings of one run and are read by one person, often minutes apart; a
+ * second derivation here is a second answer waiting to happen.
+ */
+import type { ReactElement } from 'react';
+import { type IgnoreLedger } from '@variance-authority/report';
+import type { SubjectView } from '../review-types.js';
+/**
+ * Whether a subject is one the rail carries.
+ *
+ * The report's own predicate, word for word, and it is shared by copy rather than
+ * import because the two live in different packages. Both green verdicts are out:
+ * `unchanged` because nothing moved, and `ignored` because a declaration already
+ * decided it. A rail that carried `ignored` would put a subject nobody can act on
+ * in the queue, under a header that says how many are awaiting review.
+ */
+export declare function needsReview(verdict: SubjectView['verdict']): boolean;
+export declare function Settled({ subjects, ignores, }: {
+    readonly subjects: readonly SubjectView[];
+    readonly ignores: IgnoreLedger | null;
+}): ReactElement | null;
+//# sourceMappingURL=settled.d.ts.map

package/dist/ui/settled.js

@@ -0,0 +1,59 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { greenBecause } from '@variance-authority/report';
+import { count, number } from './text.js';
+/** The two green verdicts, in the order they are worth reading. */
+const GREEN = ['ignored', 'unchanged'];
+/**
+ * Whether a subject is one the rail carries.
+ *
+ * The report's own predicate, word for word, and it is shared by copy rather than
+ * import because the two live in different packages. Both green verdicts are out:
+ * `unchanged` because nothing moved, and `ignored` because a declaration already
+ * decided it. A rail that carried `ignored` would put a subject nobody can act on
+ * in the queue, under a header that says how many are awaiting review.
+ */
+export function needsReview(verdict) {
+    return verdict !== 'unchanged' && verdict !== 'ignored';
+}
+export function Settled({ subjects, ignores, }) {
+    const green = subjects.filter((subject) => !needsReview(subject.verdict));
+    if (green.length === 0)
+        return null;
+    const absorbed = green.filter((subject) => subject.verdict === 'ignored');
+    return (_jsxs("details", { className: "va-settled", children: [_jsxs("summary", { children: [count(green.length - absorbed.length, 'subject'), " unchanged", absorbed.length === 0
+                        ? ''
+                        : ` · ${count(absorbed.length, 'subject')} green because a rule absorbed the difference`] }), GREEN.map((verdict) => {
+                const rows = green.filter((subject) => subject.verdict === verdict);
+                if (rows.length === 0)
+                    return null;
+                return (_jsx("ul", { className: "va-settled-list", children: rows.map((subject) => (_jsxs("li", { children: [_jsx("span", { className: `va-dot va-${subject.verdict}` }), _jsx("strong", { children: subject.subject }), _jsx("span", { className: "va-note", children: subject.because }), _jsx(Because, { subject: subject })] }, subject.subject))) }, verdict));
+            }), absorbed.length > 0 && ignores === null ? (_jsx("p", { className: "va-note", children: "This build carried no ignore ledger, so which rule absorbed each of these \u2014 and whether it absorbed anything anywhere else \u2014 is not recorded here." })) : null] }));
+}
+/**
+ * Which declaration decided this subject, when the record says.
+ *
+ * `unsaid` is rendered rather than skipped. A green-by-declaration row with no
+ * rule beside it reads as a subject whose difference was too small to name, and
+ * the difference between *nobody wrote it down* and *nothing happened* is the
+ * whole reason `ignored` is a word of its own.
+ *
+ * `masked` is the row worth the most and belongs to `unchanged`: a rule stood
+ * over this subject and caught nothing. One run of that is ordinary; it is the
+ * count in the ledger below, run after run, that turns it into a finding.
+ */
+function Because({ subject }) {
+    const green = greenBecause(subject);
+    switch (green.kind) {
+        case 'measured':
+            return null;
+        case 'masked':
+            return (_jsxs("span", { className: "va-note", children: ["masked in ", count(green.boxes, 'place'), ", and nothing differed under them"] }));
+        case 'relaxed':
+            return (_jsxs("span", { className: "va-mark va-ignored", children: ["asserted on ", green.level, " \u00B7 ", _jsx("code", { children: green.rule }), " absorbed ", green.bands.join(', ')] }));
+        case 'unsaid':
+            return (_jsx("span", { className: "va-note", children: "this build does not record which rule absorbed it" }));
+        default:
+            return (_jsxs("span", { className: "va-mark va-ignored", children: ["absorbed by ", _jsx("code", { children: green.rules.join(', ') }), " \u00B7 ", number(green.pixels), " px"] }));
+    }
+}
+//# sourceMappingURL=settled.js.map

package/dist/ui/settled.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settled.js","sourceRoot":"","sources":["../../src/ui/settled.tsx"],"names":[],"mappings":"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","sourcesContent":["/**\n * The subjects that came back green, and which kind of green each one is.\n *\n * The rail carries what needs a decision, and a subject that was absorbed by an\n * ignore does not — the rule already made the decision, on a day somebody wrote\n * it into the config. But green by measurement and green by declaration are not\n * the same fact, and the second is the one that goes wrong silently: a rule that\n * has grown over a real regression reports `ignored` every run and reads exactly\n * like a subject nothing happened to.\n *\n * So they are kept, folded. Behind a `<details>` because on a run of three\n * hundred stories this is three hundred lines of nothing, and open in one click\n * because the moment a reviewer wants it is the moment they are asking *what did\n * this build not tell me*.\n *\n * The sentence under each name is the observer's own, unedited. This surface did\n * not measure anything and has nothing to add — and where the record does not say\n * which rule absorbed a subject, the note says that rather than leaving a reader\n * to conclude the difference was small.\n *\n * Which rule that was is read by `greenBecause` in the report package, the same\n * call the HTML report makes over the same block. The report and this page are\n * two renderings of one run and are read by one person, often minutes apart; a\n * second derivation here is a second answer waiting to happen.\n */\n\nimport type { ReactElement } from 'react';\nimport { greenBecause, type Green, type IgnoreLedger } from '@variance-authority/report';\nimport type { SubjectView } from '../review-types.js';\nimport { count, number } from './text.js';\n\n/** The two green verdicts, in the order they are worth reading. */\nconst GREEN: readonly SubjectView['verdict'][] = ['ignored', 'unchanged'];\n\n/**\n * Whether a subject is one the rail carries.\n *\n * The report's own predicate, word for word, and it is shared by copy rather than\n * import because the two live in different packages. Both green verdicts are out:\n * `unchanged` because nothing moved, and `ignored` because a declaration already\n * decided it. A rail that carried `ignored` would put a subject nobody can act on\n * in the queue, under a header that says how many are awaiting review.\n */\nexport function needsReview(verdict: SubjectView['verdict']): boolean {\n  return verdict !== 'unchanged' && verdict !== 'ignored';\n}\n\nexport function Settled({\n  subjects,\n  ignores,\n}: {\n  readonly subjects: readonly SubjectView[];\n  readonly ignores: IgnoreLedger | null;\n}): ReactElement | null {\n  const green = subjects.filter((subject) => !needsReview(subject.verdict));\n  if (green.length === 0) return null;\n\n  const absorbed = green.filter((subject) => subject.verdict === 'ignored');\n\n  return (\n    <details className=\"va-settled\">\n      <summary>\n        {count(green.length - absorbed.length, 'subject')} unchanged\n        {absorbed.length === 0\n          ? ''\n          : ` · ${count(absorbed.length, 'subject')} green because a rule absorbed the difference`}\n      </summary>\n\n      {GREEN.map((verdict) => {\n        const rows = green.filter((subject) => subject.verdict === verdict);\n        if (rows.length === 0) return null;\n        return (\n          <ul key={verdict} className=\"va-settled-list\">\n            {rows.map((subject) => (\n              <li key={subject.subject}>\n                <span className={`va-dot va-${subject.verdict}`} />\n                <strong>{subject.subject}</strong>\n                <span className=\"va-note\">{subject.because}</span>\n                <Because subject={subject} />\n              </li>\n            ))}\n          </ul>\n        );\n      })}\n\n      {absorbed.length > 0 && ignores === null ? (\n        <p className=\"va-note\">\n          This build carried no ignore ledger, so which rule absorbed each of these — and whether\n          it absorbed anything anywhere else — is not recorded here.\n        </p>\n      ) : null}\n    </details>\n  );\n}\n\n/**\n * Which declaration decided this subject, when the record says.\n *\n * `unsaid` is rendered rather than skipped. A green-by-declaration row with no\n * rule beside it reads as a subject whose difference was too small to name, and\n * the difference between *nobody wrote it down* and *nothing happened* is the\n * whole reason `ignored` is a word of its own.\n *\n * `masked` is the row worth the most and belongs to `unchanged`: a rule stood\n * over this subject and caught nothing. One run of that is ordinary; it is the\n * count in the ledger below, run after run, that turns it into a finding.\n */\nfunction Because({ subject }: { readonly subject: SubjectView }): ReactElement | null {\n  const green: Green = greenBecause(subject);\n\n  switch (green.kind) {\n    case 'measured':\n      return null;\n    case 'masked':\n      return (\n        <span className=\"va-note\">\n          masked in {count(green.boxes, 'place')}, and nothing differed under them\n        </span>\n      );\n    case 'relaxed':\n      return (\n        <span className=\"va-mark va-ignored\">\n          asserted on {green.level} · <code>{green.rule}</code> absorbed {green.bands.join(', ')}\n        </span>\n      );\n    case 'unsaid':\n      return (\n        <span className=\"va-note\">\n          this build does not record which rule absorbed it\n        </span>\n      );\n    default:\n      return (\n        <span className=\"va-mark va-ignored\">\n          absorbed by <code>{green.rules.join(', ')}</code> · {number(green.pixels)} px\n        </span>\n      );\n  }\n}\n"]}