@variance-authority/core 0.1.0

package/dist/compare/diff/components.js

@@ -0,0 +1,76 @@
+import { aggregateImpact } from '../impact.js';
+import { impactTag } from './delta.js';
+/**
+ * The component roll-up: who caused this change set, and who merely renders it.
+ *
+ * Kept apart from attribution because it runs *after* it and asks a different
+ * question. Attribution decides what one sentence explains the deltas;
+ * this decides which components that sentence implicates, and in what capacity.
+ * The two share only the roots, which is exactly the argument for one being able
+ * to change without disturbing the other.
+ */
+/**
+ * Which components a change set implicates, and in what capacity.
+ *
+ * A component is a *root* when a root's own deltas name it innermost — the change
+ * originated there. It is *collateral* when it only ever appears further out in
+ * an owner chain, or under a token root: it renders something that changed, but
+ * nothing about it changed.
+ */
+export function componentsOf(deltas, roots) {
+    const rootNames = new Set();
+    for (const root of roots) {
+        if (root.kind !== 'component' && root.kind !== 'prop')
+            continue;
+        // The root's own `cause`, not the innermost owner of its deltas. For a
+        // `prop` root those are different components and the innermost is the wrong
+        // one: `Panel → Button` means `Panel` made the edit. Falling back to the
+        // innermost keeps the previous behaviour where no cause was recorded.
+        if (root.cause !== undefined) {
+            rootNames.add(root.cause);
+            continue;
+        }
+        for (const delta of root.deltas) {
+            const innermost = delta.owners?.[0]?.name;
+            if (innermost !== undefined)
+                rootNames.add(innermost);
+        }
+    }
+    const accumulator = new Map();
+    for (const delta of deltas) {
+        const owners = delta.owners ?? [];
+        for (const [index, owner] of owners.entries()) {
+            let entry = accumulator.get(owner.name);
+            if (!entry) {
+                entry = { deltas: 0, bands: new Set(), impacts: [], within: new Set() };
+                accumulator.set(owner.name, entry);
+            }
+            // Only the innermost owner is credited with the delta. Every enclosing
+            // component would otherwise accumulate every delta beneath it, and a page
+            // component would be the biggest change in every diff, every time.
+            if (index === 0) {
+                entry.deltas += 1;
+                entry.bands.add(delta.band);
+                entry.impacts.push(impactTag(delta));
+            }
+            // The chain is innermost-first, so the *next* frame out is what encloses
+            // this one. Recording the previous frame instead would answer "what does
+            // this component contain?" — which nobody asked, and which reads as an
+            // answer to "where does it show up?" until someone checks.
+            const enclosing = owners[index + 1];
+            if (enclosing)
+                entry.within.add(enclosing.name);
+        }
+    }
+    return [...accumulator.entries()]
+        .map(([name, entry]) => ({
+        name,
+        role: rootNames.has(name) ? 'root' : 'collateral',
+        deltaCount: entry.deltas,
+        bands: [...entry.bands],
+        impact: aggregateImpact(entry.impacts),
+        renderedIn: [...entry.within],
+    }))
+        .sort((a, b) => b.deltaCount - a.deltaCount || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+//# sourceMappingURL=components.js.map

package/dist/compare/diff/components.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.js","sourceRoot":"","sources":["../../../src/compare/diff/components.ts"],"names":[],"mappings":"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","sourcesContent":["import { aggregateImpact, type PropertyImpact } from '../impact.js';\nimport type { Band } from '../band.js';\nimport { impactTag, type ChangedComponent, type Delta, type Root } from './delta.js';\n\n/**\n * The component roll-up: who caused this change set, and who merely renders it.\n *\n * Kept apart from attribution because it runs *after* it and asks a different\n * question. Attribution decides what one sentence explains the deltas;\n * this decides which components that sentence implicates, and in what capacity.\n * The two share only the roots, which is exactly the argument for one being able\n * to change without disturbing the other.\n */\n\n/**\n * Which components a change set implicates, and in what capacity.\n *\n * A component is a *root* when a root's own deltas name it innermost — the change\n * originated there. It is *collateral* when it only ever appears further out in\n * an owner chain, or under a token root: it renders something that changed, but\n * nothing about it changed.\n */\nexport function componentsOf(\n  deltas: readonly Delta[],\n  roots: readonly Root[],\n): readonly ChangedComponent[] {\n  const rootNames = new Set<string>();\n  for (const root of roots) {\n    if (root.kind !== 'component' && root.kind !== 'prop') continue;\n\n    // The root's own `cause`, not the innermost owner of its deltas. For a\n    // `prop` root those are different components and the innermost is the wrong\n    // one: `Panel → Button` means `Panel` made the edit. Falling back to the\n    // innermost keeps the previous behaviour where no cause was recorded.\n    if (root.cause !== undefined) {\n      rootNames.add(root.cause);\n      continue;\n    }\n\n    for (const delta of root.deltas) {\n      const innermost = delta.owners?.[0]?.name;\n      if (innermost !== undefined) rootNames.add(innermost);\n    }\n  }\n\n  const accumulator = new Map<\n    string,\n    { deltas: number; bands: Set<Band>; impacts: (PropertyImpact | 'structural')[]; within: Set<string> }\n  >();\n\n  for (const delta of deltas) {\n    const owners = delta.owners ?? [];\n    for (const [index, owner] of owners.entries()) {\n      let entry = accumulator.get(owner.name);\n      if (!entry) {\n        entry = { deltas: 0, bands: new Set(), impacts: [], within: new Set() };\n        accumulator.set(owner.name, entry);\n      }\n\n      // Only the innermost owner is credited with the delta. Every enclosing\n      // component would otherwise accumulate every delta beneath it, and a page\n      // component would be the biggest change in every diff, every time.\n      if (index === 0) {\n        entry.deltas += 1;\n        entry.bands.add(delta.band);\n        entry.impacts.push(impactTag(delta));\n      }\n\n      // The chain is innermost-first, so the *next* frame out is what encloses\n      // this one. Recording the previous frame instead would answer \"what does\n      // this component contain?\" — which nobody asked, and which reads as an\n      // answer to \"where does it show up?\" until someone checks.\n      const enclosing = owners[index + 1];\n      if (enclosing) entry.within.add(enclosing.name);\n    }\n  }\n\n  return [...accumulator.entries()]\n    .map(([name, entry]) => ({\n      name,\n      role: rootNames.has(name) ? ('root' as const) : ('collateral' as const),\n      deltaCount: entry.deltas,\n      bands: [...entry.bands],\n      impact: aggregateImpact(entry.impacts),\n      renderedIn: [...entry.within],\n    }))\n    .sort(\n      (a, b) =>\n        b.deltaCount - a.deltaCount || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0),\n    );\n}\n"]}

package/dist/compare/diff/delta.d.ts

@@ -0,0 +1,165 @@
+import type { Band, DeltaKind } from '../band.js';
+import type { AggregateImpact, PropertyImpact } from '../impact.js';
+import type { Rect } from '../../format/capture.js';
+import type { NodePath } from '../../format/snapshot.js';
+import type { OwnerFrame } from '../../format/provenance.js';
+/**
+ * A single observed difference.
+ *
+ * Deltas are the atoms the docket is assembled from. Each one already knows its
+ * band and its owner chain when it is created — Principle 5 says causality flows
+ * forward, so a change must arrive carrying its name rather than having one
+ * reconstructed for it later.
+ */
+export interface Delta {
+    readonly kind: DeltaKind;
+    readonly band: Band;
+    /** Path in the *candidate* tree, or the baseline tree for a removal. */
+    readonly path: NodePath;
+    /** Which property, attribute, or ARIA state moved. Absent for whole-node deltas. */
+    readonly property?: string;
+    /**
+     * Explicitly `| undefined`, unlike most optional fields in this codebase.
+     *
+     * A delta routinely has a value on one side only — an attribute that appeared,
+     * a role that was removed — and "absent on this side" is the meaning being
+     * recorded, not a field the author forgot. Forcing callers to omit the key
+     * instead would make every comparison site build its object conditionally to
+     * express something the type can say directly.
+     */
+    readonly from?: string | undefined;
+    readonly to?: string | undefined;
+    /** Owner chain at the changed node, innermost first. */
+    readonly owners?: readonly OwnerFrame[];
+    /**
+     * The component whose JSX created this element.
+     *
+     * Distinct from `owners[0]`, which is the nearest *enclosing* component, and
+     * the two diverge exactly where structural attribution needs them to. When a
+     * list reorders, the nodes that moved are `Chip`s enclosed by a `Stack` — but
+     * neither decided the order. The component that wrote the JSX did, and this is
+     * the only field that names it.
+     */
+    readonly createdBy?: string;
+    /**
+     * Custom property the changed value resolved through.
+     *
+     * Present only when the token's own value moved. A node whose colour changed
+     * because `--color-primary` changed is collateral of one token edit; a node
+     * whose colour changed while every token held is a root in its own right.
+     * Distinguishing the two is the entire job of the docket.
+     */
+    readonly token?: string;
+    /** Nearest ARIA landmark, so location reads as "right panel", not coordinates. */
+    readonly region?: string;
+    /**
+     * Where this is, spoken outside-in: `main → region "Todos" → list item 2 of 3`.
+     *
+     * A path is an address and a rect is a coordinate; neither survives the next
+     * reflow or tells anyone where to look. See `locate.ts`.
+     */
+    readonly where?: string;
+    readonly rectFrom?: Rect;
+    readonly rectTo?: Rect;
+    /**
+     * How far this change can reach: reflow, repaint, or compositing.
+     *
+     * Absent for structural deltas, where the question does not apply. See
+     * `impact.ts` — the useful consequence is that a paint-only change has no
+     * geometric collateral, which lets a profile with no layout engine rule out
+     * movement rather than merely failing to observe it.
+     */
+    readonly impact?: PropertyImpact;
+    /**
+     * Set on a delta that is a *consequence* of another on the same node.
+     *
+     * A rect that moved because padding changed is not an independent finding —
+     * it is the padding change, observed a second way. Without this the docket
+     * reports one edit twice, once as `token` and once as `geometry`, and a
+     * reviewer has to work out that they are the same thing.
+     */
+    readonly derivedFrom?: string;
+}
+/**
+ * What explains a group of deltas.
+ *
+ * The docket presents one entry per root (spec §6.2): *root cause, band, count
+ * of collateral, sample subjects, owner chain* — and approving it MUST be one
+ * action. "1 token change, 300 collateral, structure intact" is one review item.
+ */
+export interface Root {
+    /** Stable across builds, so an approval recorded against it keeps applying. */
+    readonly id: string;
+    readonly kind: RootKind;
+    readonly label: string;
+    readonly band: Band;
+    /**
+     * Whether this root can move things, or only repaint them.
+     *
+     * The first question a reviewer asks about a design-system change, and the one
+     * that decides whether the blast radius needs looking at.
+     */
+    readonly impact: AggregateImpact;
+    /**
+     * The component responsible, when one can be named.
+     *
+     * Distinct from where the change was *observed*, and the two differ exactly on
+     * a `prop` root: `Panel → Button` means `Panel` passed something new and
+     * `Button` is where it shows. Naming `Button` sends a reviewer to a file
+     * nobody edited, which is the failure `prop-primary-variant/hero` exists to
+     * catch — and which `componentsOf` was committing, marking the innermost owner
+     * as `root` for every kind of root including this one.
+     */
+    readonly cause?: string;
+    readonly deltas: readonly Delta[];
+}
+/**
+ * A component implicated in a change set.
+ *
+ * `root` is the component the change originated in; `collateral` merely renders
+ * something the change reached. Separating them is the difference between "these
+ * eleven components changed" — which reads like eleven problems — and "`Button`
+ * changed, and ten components render it".
+ */
+export interface ChangedComponent {
+    readonly name: string;
+    readonly role: 'root' | 'collateral';
+    readonly deltaCount: number;
+    readonly bands: readonly Band[];
+    readonly impact: AggregateImpact;
+    /**
+     * Components that enclose this one where the change was observed.
+     *
+     * Answers "where does this show up?" — the propagation half of the spec's
+     * running sentence, *`Button` (variant prop change) → propagated to `NewHero`*.
+     */
+    readonly renderedIn: readonly string[];
+}
+export type RootKind = 
+/** A design token's value moved. Every affected node is collateral. */
+'token'
+/** A component changed internally, with its incoming props unchanged. */
+ | 'component'
+/** A component's incoming props changed; the root is upstream of it. */
+ | 'prop'
+/** A render input that is not code: engine, fonts, viewport, ruleset. */
+ | 'environment'
+/**
+ * No owner could be determined.
+ *
+ * Not a filler category. Provenance is supposed to make every change
+ * nameable, so an unattributed root means the chain broke — which is a defect
+ * in this tool, not a property of the change, and it is surfaced rather than
+ * quietly absorbed into a neighbouring root.
+ */
+ | 'unattributed';
+/**
+ * How a delta counts towards an aggregate impact.
+ *
+ * A structural delta has no `impact` because the question does not apply to it —
+ * a node that appeared did not reflow, it arrived. `'structural'` says that,
+ * rather than leaving every aggregation site to re-decide what a missing field
+ * means; there are three of them, and they must agree.
+ */
+export declare function impactTag(delta: Delta): PropertyImpact | 'structural';
+//# sourceMappingURL=delta.d.ts.map

package/dist/compare/diff/delta.js

@@ -0,0 +1,12 @@
+/**
+ * How a delta counts towards an aggregate impact.
+ *
+ * A structural delta has no `impact` because the question does not apply to it —
+ * a node that appeared did not reflow, it arrived. `'structural'` says that,
+ * rather than leaving every aggregation site to re-decide what a missing field
+ * means; there are three of them, and they must agree.
+ */
+export function impactTag(delta) {
+    return delta.impact ?? 'structural';
+}
+//# sourceMappingURL=delta.js.map

package/dist/compare/diff/delta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delta.js","sourceRoot":"","sources":["../../../src/compare/diff/delta.ts"],"names":[],"mappings":"AA8KA;;;;;;;GAOG;AACH,MAAM,UAAU,SAAS,CAAC,KAAY;IACpC,OAAO,KAAK,CAAC,MAAM,IAAI,YAAY,CAAC;AACtC,CAAC","sourcesContent":["import type { Band, DeltaKind } from '../band.js';\nimport type { AggregateImpact, PropertyImpact } from '../impact.js';\nimport type { Rect } from '../../format/capture.js';\nimport type { NodePath } from '../../format/snapshot.js';\nimport type { OwnerFrame } from '../../format/provenance.js';\n\n/**\n * A single observed difference.\n *\n * Deltas are the atoms the docket is assembled from. Each one already knows its\n * band and its owner chain when it is created — Principle 5 says causality flows\n * forward, so a change must arrive carrying its name rather than having one\n * reconstructed for it later.\n */\nexport interface Delta {\n  readonly kind: DeltaKind;\n  readonly band: Band;\n\n  /** Path in the *candidate* tree, or the baseline tree for a removal. */\n  readonly path: NodePath;\n\n  /** Which property, attribute, or ARIA state moved. Absent for whole-node deltas. */\n  readonly property?: string;\n\n  /**\n   * Explicitly `| undefined`, unlike most optional fields in this codebase.\n   *\n   * A delta routinely has a value on one side only — an attribute that appeared,\n   * a role that was removed — and \"absent on this side\" is the meaning being\n   * recorded, not a field the author forgot. Forcing callers to omit the key\n   * instead would make every comparison site build its object conditionally to\n   * express something the type can say directly.\n   */\n  readonly from?: string | undefined;\n  readonly to?: string | undefined;\n\n  /** Owner chain at the changed node, innermost first. */\n  readonly owners?: readonly OwnerFrame[];\n\n  /**\n   * The component whose JSX created this element.\n   *\n   * Distinct from `owners[0]`, which is the nearest *enclosing* component, and\n   * the two diverge exactly where structural attribution needs them to. When a\n   * list reorders, the nodes that moved are `Chip`s enclosed by a `Stack` — but\n   * neither decided the order. The component that wrote the JSX did, and this is\n   * the only field that names it.\n   */\n  readonly createdBy?: string;\n\n  /**\n   * Custom property the changed value resolved through.\n   *\n   * Present only when the token's own value moved. A node whose colour changed\n   * because `--color-primary` changed is collateral of one token edit; a node\n   * whose colour changed while every token held is a root in its own right.\n   * Distinguishing the two is the entire job of the docket.\n   */\n  readonly token?: string;\n\n  /** Nearest ARIA landmark, so location reads as \"right panel\", not coordinates. */\n  readonly region?: string;\n\n  /**\n   * Where this is, spoken outside-in: `main → region \"Todos\" → list item 2 of 3`.\n   *\n   * A path is an address and a rect is a coordinate; neither survives the next\n   * reflow or tells anyone where to look. See `locate.ts`.\n   */\n  readonly where?: string;\n\n  readonly rectFrom?: Rect;\n  readonly rectTo?: Rect;\n\n  /**\n   * How far this change can reach: reflow, repaint, or compositing.\n   *\n   * Absent for structural deltas, where the question does not apply. See\n   * `impact.ts` — the useful consequence is that a paint-only change has no\n   * geometric collateral, which lets a profile with no layout engine rule out\n   * movement rather than merely failing to observe it.\n   */\n  readonly impact?: PropertyImpact;\n\n  /**\n   * Set on a delta that is a *consequence* of another on the same node.\n   *\n   * A rect that moved because padding changed is not an independent finding —\n   * it is the padding change, observed a second way. Without this the docket\n   * reports one edit twice, once as `token` and once as `geometry`, and a\n   * reviewer has to work out that they are the same thing.\n   */\n  readonly derivedFrom?: string;\n}\n\n/**\n * What explains a group of deltas.\n *\n * The docket presents one entry per root (spec §6.2): *root cause, band, count\n * of collateral, sample subjects, owner chain* — and approving it MUST be one\n * action. \"1 token change, 300 collateral, structure intact\" is one review item.\n */\nexport interface Root {\n  /** Stable across builds, so an approval recorded against it keeps applying. */\n  readonly id: string;\n  readonly kind: RootKind;\n  readonly label: string;\n  readonly band: Band;\n\n  /**\n   * Whether this root can move things, or only repaint them.\n   *\n   * The first question a reviewer asks about a design-system change, and the one\n   * that decides whether the blast radius needs looking at.\n   */\n  readonly impact: AggregateImpact;\n\n  /**\n   * The component responsible, when one can be named.\n   *\n   * Distinct from where the change was *observed*, and the two differ exactly on\n   * a `prop` root: `Panel → Button` means `Panel` passed something new and\n   * `Button` is where it shows. Naming `Button` sends a reviewer to a file\n   * nobody edited, which is the failure `prop-primary-variant/hero` exists to\n   * catch — and which `componentsOf` was committing, marking the innermost owner\n   * as `root` for every kind of root including this one.\n   */\n  readonly cause?: string;\n\n  readonly deltas: readonly Delta[];\n}\n\n/**\n * A component implicated in a change set.\n *\n * `root` is the component the change originated in; `collateral` merely renders\n * something the change reached. Separating them is the difference between \"these\n * eleven components changed\" — which reads like eleven problems — and \"`Button`\n * changed, and ten components render it\".\n */\nexport interface ChangedComponent {\n  readonly name: string;\n  readonly role: 'root' | 'collateral';\n  readonly deltaCount: number;\n  readonly bands: readonly Band[];\n  readonly impact: AggregateImpact;\n  /**\n   * Components that enclose this one where the change was observed.\n   *\n   * Answers \"where does this show up?\" — the propagation half of the spec's\n   * running sentence, *`Button` (variant prop change) → propagated to `NewHero`*.\n   */\n  readonly renderedIn: readonly string[];\n}\n\nexport type RootKind =\n  /** A design token's value moved. Every affected node is collateral. */\n  | 'token'\n  /** A component changed internally, with its incoming props unchanged. */\n  | 'component'\n  /** A component's incoming props changed; the root is upstream of it. */\n  | 'prop'\n  /** A render input that is not code: engine, fonts, viewport, ruleset. */\n  | 'environment'\n  /**\n   * No owner could be determined.\n   *\n   * Not a filler category. Provenance is supposed to make every change\n   * nameable, so an unattributed root means the chain broke — which is a defect\n   * in this tool, not a property of the change, and it is surfaced rather than\n   * quietly absorbed into a neighbouring root.\n   */\n  | 'unattributed';\n\n/**\n * How a delta counts towards an aggregate impact.\n *\n * A structural delta has no `impact` because the question does not apply to it —\n * a node that appeared did not reflow, it arrived. `'structural'` says that,\n * rather than leaving every aggregation site to re-decide what a missing field\n * means; there are three of them, and they must agree.\n */\nexport function impactTag(delta: Delta): PropertyImpact | 'structural' {\n  return delta.impact ?? 'structural';\n}\n"]}

package/dist/compare/diff/index.d.ts

@@ -0,0 +1,69 @@
+import { type Band } from '../band.js';
+import { type AggregateImpact } from '../impact.js';
+import { type EnvironmentDelta } from '../../format/environment.js';
+import type { SemanticSnapshot } from '../../format/snapshot.js';
+import { type ChangedComponent, type Delta, type Root } from './delta.js';
+export type { ChangedComponent, Delta, Root, RootKind } from './delta.js';
+export { matchTrees } from './match.js';
+export type { Matching } from './match.js';
+export interface SemanticDiff {
+    readonly subjectId: string;
+    /** `true` when both render hashes agree — nothing below need be consulted. */
+    readonly identical: boolean;
+    readonly environmentDeltas: readonly EnvironmentDelta[];
+    readonly deltas: readonly Delta[];
+    /** One entry per explanation. This is what a docket renders and approves. */
+    readonly roots: readonly Root[];
+    /**
+     * Components implicated, separated into causes and collateral.
+     *
+     * "Eleven components changed" reads like eleven problems. "`Button` changed,
+     * and ten components render it" reads like one, which is what it is.
+     */
+    readonly components: readonly ChangedComponent[];
+    /**
+     * Whether anything in this change set can move a box.
+     *
+     * `paint` or `composite` means nothing reflowed and no geometric collateral is
+     * possible — a conclusion available without a layout engine, which is how a
+     * profile that cannot measure still rules movement out instead of merely
+     * failing to observe it.
+     */
+    readonly impact: AggregateImpact;
+    /**
+     * Bands this profile could not observe.
+     *
+     * Reported so that "no geometry deltas" is never mistaken for "geometry is
+     * fine" under a profile with no layout engine (ADR-0002).
+     */
+    readonly unobserved: readonly Band[];
+}
+/**
+ * Compare two snapshots of one subject.
+ *
+ * @throws {Error} when the snapshots come from different subjects or different
+ * observation profiles. Neither is a large diff — they are a category error, and
+ * returning deltas for them would let a JSDOM run appear to satisfy a Chromium
+ * baseline while blind to every geometry change in it.
+ */
+export declare function diffSnapshots(baseline: SemanticSnapshot, candidate: SemanticSnapshot): SemanticDiff;
+/** Everything a {@link SemanticDiff} is except the subject it is about. */
+export type TreeComparison = Omit<SemanticDiff, 'subjectId'>;
+/**
+ * The comparison itself, after whatever refusals the caller owes.
+ *
+ * Split out because two callers owe different refusals over the same arithmetic.
+ * `diffSnapshots` produces a **verdict** and must refuse two subjects, because a
+ * verdict that crossed them would let one subject's baseline stand in for
+ * another's. `deriveVariation` produces an **explanation** of a difference
+ * somebody declared on purpose — a dark story against its light parent — where
+ * two subject ids are the entire point and a refusal would be the bug.
+ *
+ * What is not negotiable either way is the observability rule: a band is
+ * `unobserved` unless **both** sides could decide it, so a difference that only
+ * one profile could have seen is never reported as no difference (ADR-0002).
+ * Under `diffSnapshots` the two profiles are already identical, so the union
+ * costs it nothing and changes none of its answers.
+ */
+export declare function compareTrees(baseline: SemanticSnapshot, candidate: SemanticSnapshot): TreeComparison;
+//# sourceMappingURL=index.d.ts.map

package/dist/compare/diff/index.js

@@ -0,0 +1,101 @@
+import { BANDS } from '../band.js';
+import { aggregateImpact } from '../impact.js';
+import { diffEnvironments } from '../../format/environment.js';
+import { decidesBand, observableBands } from '../observability.js';
+import { impactTag } from './delta.js';
+import { matchTrees } from './match.js';
+import { compareNodes, wholeNode } from './compare-nodes.js';
+import { attribute } from './attribution.js';
+import { componentsOf } from './components.js';
+import { locate } from '../../attribute/locate.js';
+export { matchTrees } from './match.js';
+/**
+ * Compare two snapshots of one subject.
+ *
+ * @throws {Error} when the snapshots come from different subjects or different
+ * observation profiles. Neither is a large diff — they are a category error, and
+ * returning deltas for them would let a JSDOM run appear to satisfy a Chromium
+ * baseline while blind to every geometry change in it.
+ */
+export function diffSnapshots(baseline, candidate) {
+    if (baseline.subject.id !== candidate.subject.id) {
+        throw new Error(`refusing to diff different subjects: ${baseline.subject.id} vs ${candidate.subject.id}`);
+    }
+    if (baseline.profile.id !== candidate.profile.id) {
+        throw new Error(`refusing to diff across observation profiles: ${baseline.profile.id} vs ${candidate.profile.id}`);
+    }
+    return { subjectId: candidate.subject.id, ...compareTrees(baseline, candidate) };
+}
+/**
+ * The comparison itself, after whatever refusals the caller owes.
+ *
+ * Split out because two callers owe different refusals over the same arithmetic.
+ * `diffSnapshots` produces a **verdict** and must refuse two subjects, because a
+ * verdict that crossed them would let one subject's baseline stand in for
+ * another's. `deriveVariation` produces an **explanation** of a difference
+ * somebody declared on purpose — a dark story against its light parent — where
+ * two subject ids are the entire point and a refusal would be the bug.
+ *
+ * What is not negotiable either way is the observability rule: a band is
+ * `unobserved` unless **both** sides could decide it, so a difference that only
+ * one profile could have seen is never reported as no difference (ADR-0002).
+ * Under `diffSnapshots` the two profiles are already identical, so the union
+ * costs it nothing and changes none of its answers.
+ */
+export function compareTrees(baseline, candidate) {
+    const here = observableBands(candidate.profile);
+    const there = observableBands(baseline.profile);
+    const unobserved = BANDS.filter((band) => !decidesBand(band, here[band]) || !decidesBand(band, there[band]));
+    const environmentDeltas = diffEnvironments(baseline.environment.inputs, candidate.environment.inputs);
+    if (baseline.renderHash === candidate.renderHash) {
+        return {
+            identical: true,
+            environmentDeltas,
+            deltas: [],
+            roots: [],
+            components: [],
+            impact: 'paint',
+            unobserved,
+        };
+    }
+    const matching = matchTrees(baseline.root, candidate.root);
+    const deltas = [];
+    for (const node of matching.added) {
+        deltas.push(wholeNode('node-added', node));
+    }
+    for (const node of matching.removed) {
+        deltas.push(wholeNode('node-removed', node));
+    }
+    for (const [before, after] of matching.pairs) {
+        if (matching.moved.has(before)) {
+            deltas.push(wholeNode('node-moved', after));
+        }
+        compareNodes(before, after, deltas, candidate.profile.layout && baseline.profile.layout);
+    }
+    // Orientation is attached after the deltas exist, in one pass over the
+    // candidate tree. Doing it during comparison would locate against whichever
+    // tree that comparison happened to be holding, and a removal must be located
+    // in the tree it was removed *from* — see below.
+    const located = deltas.map((delta) => {
+        const tree = delta.kind === 'node-removed' ? baseline.root : candidate.root;
+        const where = locate(tree, delta.path);
+        return where.where === ''
+            ? delta
+            : {
+                ...delta,
+                where: where.where,
+                ...(where.region !== undefined ? { region: where.region } : {}),
+            };
+    });
+    const roots = attribute(located, matching, environmentDeltas);
+    return {
+        identical: false,
+        environmentDeltas,
+        deltas: located,
+        roots,
+        components: componentsOf(located, roots),
+        impact: aggregateImpact(located.map(impactTag)),
+        unobserved,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/compare/diff/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/compare/diff/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { BANDS, type Band } from '../band.js';\nimport { aggregateImpact, type AggregateImpact } from '../impact.js';\nimport { diffEnvironments, type EnvironmentDelta } from '../../format/environment.js';\nimport type { SemanticSnapshot } from '../../format/snapshot.js';\nimport { decidesBand, observableBands } from '../observability.js';\nimport { impactTag, type ChangedComponent, type Delta, type Root } from './delta.js';\nimport { matchTrees } from './match.js';\nimport { compareNodes, wholeNode } from './compare-nodes.js';\nimport { attribute } from './attribution.js';\nimport { componentsOf } from './components.js';\nimport { locate } from '../../attribute/locate.js';\n\nexport type { ChangedComponent, Delta, Root, RootKind } from './delta.js';\nexport { matchTrees } from './match.js';\nexport type { Matching } from './match.js';\n\nexport interface SemanticDiff {\n  readonly subjectId: string;\n  /** `true` when both render hashes agree — nothing below need be consulted. */\n  readonly identical: boolean;\n\n  readonly environmentDeltas: readonly EnvironmentDelta[];\n  readonly deltas: readonly Delta[];\n\n  /** One entry per explanation. This is what a docket renders and approves. */\n  readonly roots: readonly Root[];\n\n  /**\n   * Components implicated, separated into causes and collateral.\n   *\n   * \"Eleven components changed\" reads like eleven problems. \"`Button` changed,\n   * and ten components render it\" reads like one, which is what it is.\n   */\n  readonly components: readonly ChangedComponent[];\n\n  /**\n   * Whether anything in this change set can move a box.\n   *\n   * `paint` or `composite` means nothing reflowed and no geometric collateral is\n   * possible — a conclusion available without a layout engine, which is how a\n   * profile that cannot measure still rules movement out instead of merely\n   * failing to observe it.\n   */\n  readonly impact: AggregateImpact;\n\n  /**\n   * Bands this profile could not observe.\n   *\n   * Reported so that \"no geometry deltas\" is never mistaken for \"geometry is\n   * fine\" under a profile with no layout engine (ADR-0002).\n   */\n  readonly unobserved: readonly Band[];\n}\n\n/**\n * Compare two snapshots of one subject.\n *\n * @throws {Error} when the snapshots come from different subjects or different\n * observation profiles. Neither is a large diff — they are a category error, and\n * returning deltas for them would let a JSDOM run appear to satisfy a Chromium\n * baseline while blind to every geometry change in it.\n */\nexport function diffSnapshots(\n  baseline: SemanticSnapshot,\n  candidate: SemanticSnapshot,\n): SemanticDiff {\n  if (baseline.subject.id !== candidate.subject.id) {\n    throw new Error(\n      `refusing to diff different subjects: ${baseline.subject.id} vs ${candidate.subject.id}`,\n    );\n  }\n\n  if (baseline.profile.id !== candidate.profile.id) {\n    throw new Error(\n      `refusing to diff across observation profiles: ${baseline.profile.id} vs ${candidate.profile.id}`,\n    );\n  }\n\n  return { subjectId: candidate.subject.id, ...compareTrees(baseline, candidate) };\n}\n\n/** Everything a {@link SemanticDiff} is except the subject it is about. */\nexport type TreeComparison = Omit<SemanticDiff, 'subjectId'>;\n\n/**\n * The comparison itself, after whatever refusals the caller owes.\n *\n * Split out because two callers owe different refusals over the same arithmetic.\n * `diffSnapshots` produces a **verdict** and must refuse two subjects, because a\n * verdict that crossed them would let one subject's baseline stand in for\n * another's. `deriveVariation` produces an **explanation** of a difference\n * somebody declared on purpose — a dark story against its light parent — where\n * two subject ids are the entire point and a refusal would be the bug.\n *\n * What is not negotiable either way is the observability rule: a band is\n * `unobserved` unless **both** sides could decide it, so a difference that only\n * one profile could have seen is never reported as no difference (ADR-0002).\n * Under `diffSnapshots` the two profiles are already identical, so the union\n * costs it nothing and changes none of its answers.\n */\nexport function compareTrees(\n  baseline: SemanticSnapshot,\n  candidate: SemanticSnapshot,\n): TreeComparison {\n  const here = observableBands(candidate.profile);\n  const there = observableBands(baseline.profile);\n  const unobserved: Band[] = BANDS.filter(\n    (band) => !decidesBand(band, here[band]) || !decidesBand(band, there[band]),\n  );\n\n  const environmentDeltas = diffEnvironments(\n    baseline.environment.inputs,\n    candidate.environment.inputs,\n  );\n\n  if (baseline.renderHash === candidate.renderHash) {\n    return {\n      identical: true,\n      environmentDeltas,\n      deltas: [],\n      roots: [],\n      components: [],\n      impact: 'paint',\n      unobserved,\n    };\n  }\n\n  const matching = matchTrees(baseline.root, candidate.root);\n  const deltas: Delta[] = [];\n\n  for (const node of matching.added) {\n    deltas.push(wholeNode('node-added', node));\n  }\n  for (const node of matching.removed) {\n    deltas.push(wholeNode('node-removed', node));\n  }\n\n  for (const [before, after] of matching.pairs) {\n    if (matching.moved.has(before)) {\n      deltas.push(wholeNode('node-moved', after));\n    }\n    compareNodes(before, after, deltas, candidate.profile.layout && baseline.profile.layout);\n  }\n\n  // Orientation is attached after the deltas exist, in one pass over the\n  // candidate tree. Doing it during comparison would locate against whichever\n  // tree that comparison happened to be holding, and a removal must be located\n  // in the tree it was removed *from* — see below.\n  const located = deltas.map((delta) => {\n    const tree = delta.kind === 'node-removed' ? baseline.root : candidate.root;\n    const where = locate(tree, delta.path);\n\n    return where.where === ''\n      ? delta\n      : {\n          ...delta,\n          where: where.where,\n          ...(where.region !== undefined ? { region: where.region } : {}),\n        };\n  });\n\n  const roots = attribute(located, matching, environmentDeltas);\n\n  return {\n    identical: false,\n    environmentDeltas,\n    deltas: located,\n    roots,\n    components: componentsOf(located, roots),\n    impact: aggregateImpact(located.map(impactTag)),\n    unobserved,\n  };\n}\n"]}

package/dist/compare/diff/match.d.ts

@@ -0,0 +1,37 @@
+import type { SemanticNode } from '../../format/snapshot.js';
+/**
+ * Node correspondence.
+ *
+ * Paths are positional, so inserting one sibling renumbers everything after it.
+ * Diffing by path alone would report a single insertion as "every following node
+ * changed" — the classic snapshot-test failure that trains people to stop
+ * reading diffs. Matching therefore happens by identity first, content second,
+ * and position last.
+ *
+ * The middle pass is the one that took three attempts to find. Identity keys
+ * collapse whenever a node has no alias, no accessible name and no provenance —
+ * five bare `<li>`s bucket together as `tag:li` — and pairing inside that bucket
+ * by position turns a rotation into "every item's text changed". The corpus case
+ * `reorder/list` was written to catch exactly that and could not: its assertions
+ * were the verdict and the root count, and both are correct while the report is
+ * useless. Scoring the *band* is what exposed it — five `text-changed` deltas
+ * band as `content` where a rotation bands as `geometry`.
+ */
+export interface Matching {
+    /** Baseline node → candidate node. */
+    readonly pairs: ReadonlyMap<SemanticNode, SemanticNode>;
+    readonly added: readonly SemanticNode[];
+    readonly removed: readonly SemanticNode[];
+    /**
+     * Pairs whose position among their siblings changed *relative to each other*.
+     *
+     * Not "whose index differs". Prepending one item shifts every index after it
+     * without reordering anything, and reporting three moves for one insertion is
+     * the same fatigue that positional diffing produces. The moved set is the
+     * complement of the longest run that stayed in order, which is the smallest
+     * set of nodes whose movement explains the new sequence.
+     */
+    readonly moved: ReadonlySet<SemanticNode>;
+}
+export declare function matchTrees(baseline: SemanticNode, candidate: SemanticNode): Matching;
+//# sourceMappingURL=match.d.ts.map