@variance-authority/core 0.1.0

package/dist/attribute/mask.js

@@ -0,0 +1,201 @@
+const DEFAULT_CELL = 8;
+const DEFAULT_LIMIT = 32;
+/**
+ * Cluster a change mask into regions.
+ *
+ * Connected components are computed on a coarse grid rather than on the pixels
+ * themselves. That is a performance decision and a semantic one at once: the
+ * coarse pass is one linear sweep instead of a merge over thousands of glyph-edge
+ * fragments, and it produces the grouping a reader would have produced by eye.
+ * Bounding boxes are then tightened back onto the actual changed pixels, so a
+ * region's coordinates are exact even though its *membership* was decided coarsely.
+ */
+export function isolateRegions(mask, options = {}) {
+    const cell = Math.max(1, Math.floor(options.cell ?? DEFAULT_CELL));
+    const limit = options.limit ?? DEFAULT_LIMIT;
+    const columns = Math.ceil(mask.width / cell);
+    const rows = Math.ceil(mask.height / cell);
+    const occupied = new Uint8Array(columns * rows);
+    for (let y = 0; y < mask.height; y += 1) {
+        const rowOffset = y * mask.width;
+        const gridRow = ((y / cell) | 0) * columns;
+        for (let x = 0; x < mask.width; x += 1) {
+            if (mask.data[rowOffset + x] !== 0)
+                occupied[gridRow + ((x / cell) | 0)] = 1;
+        }
+    }
+    const seen = new Uint8Array(occupied.length);
+    const found = [];
+    for (let index = 0; index < occupied.length; index += 1) {
+        if (occupied[index] === 0 || seen[index] !== 0)
+            continue;
+        // Explicit stack. A full-page change is a single component covering every
+        // cell, and recursion at that depth is a stack overflow rather than a slow path.
+        const stack = [index];
+        seen[index] = 1;
+        const cells = [];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            cells.push(current);
+            const cx = current % columns;
+            const cy = (current / columns) | 0;
+            for (let dy = -1; dy <= 1; dy += 1) {
+                for (let dx = -1; dx <= 1; dx += 1) {
+                    const nx = cx + dx;
+                    const ny = cy + dy;
+                    if (nx < 0 || ny < 0 || nx >= columns || ny >= rows)
+                        continue;
+                    const neighbour = ny * columns + nx;
+                    if (occupied[neighbour] === 0 || seen[neighbour] !== 0)
+                        continue;
+                    seen[neighbour] = 1;
+                    stack.push(neighbour);
+                }
+            }
+        }
+        found.push(tighten(mask, cells, cell, columns));
+    }
+    found.sort((a, b) => b.pixels - a.pixels || a.y - b.y || a.x - b.x);
+    const kept = found.slice(0, limit);
+    const dropped = found.slice(limit);
+    return {
+        regions: kept,
+        truncated: dropped.length,
+        truncatedPixels: dropped.reduce((sum, region) => sum + region.pixels, 0),
+    };
+}
+/**
+ * Clear excluded boxes out of a change mask, and say what that cost.
+ *
+ * The raster half of an ignore (spec 0024). The semantic half drops deltas under
+ * a subtree; this drops the pixels the same subtree occupied, so the two tiers
+ * cannot disagree about what the subject is — a region excluded semantically and
+ * still compared on pixels arrives as `unexplained`, the highest severity in the
+ * system, for something the operator already said was not the subject.
+ *
+ * Subtracting *before* isolation rather than filtering regions afterwards, which
+ * looks equivalent and is not: a region that straddles the boundary would
+ * otherwise be dropped whole or kept whole, and both answers are wrong. Clearing
+ * pixels lets the part outside the box cluster on its own and be reported.
+ *
+ * The count is returned rather than folded away. `changed` on the result is what
+ * the run compares against zero; `ignored` is what it owes the reader, because a
+ * comparison that discarded four thousand pixels and reported "no difference" is
+ * the failure this whole mechanism is written around.
+ */
+export function subtractRegions(mask, boxes) {
+    if (boxes.length === 0)
+        return { mask, ignored: 0, cleared: [], inert: [] };
+    const data = Uint8Array.from(mask.data);
+    const cleared = [];
+    const inert = [];
+    let ignored = 0;
+    for (const box of boxes) {
+        // Rounded outward. A box is a CSS rectangle and a mask is a pixel grid; the
+        // half-pixel at the edge belongs to the thing that was excluded, because the
+        // alternative is a one-pixel rim of permanent residue around every ignore.
+        const startX = Math.max(0, Math.floor(box.x));
+        const startY = Math.max(0, Math.floor(box.y));
+        const endX = Math.min(mask.width, Math.ceil(box.x + box.width));
+        const endY = Math.min(mask.height, Math.ceil(box.y + box.height));
+        let inside = 0;
+        for (let y = startY; y < endY; y += 1) {
+            const rowOffset = y * mask.width;
+            for (let x = startX; x < endX; x += 1) {
+                const index = rowOffset + x;
+                if (data[index] === 0)
+                    continue;
+                data[index] = 0;
+                inside += 1;
+            }
+        }
+        ignored += inside;
+        cleared.push(inside);
+        // Against the untouched mask. `inside` counts what *this* box cleared, which
+        // is zero for the second of two overlapping boxes however much it covers.
+        if (!coversAnyChange(mask, startX, startY, endX, endY))
+            inert.push(box);
+    }
+    return {
+        mask: { width: mask.width, height: mask.height, data, changed: mask.changed - ignored },
+        ignored,
+        cleared,
+        inert,
+    };
+}
+/** Whether the original mask had any changed pixel in this box. */
+function coversAnyChange(mask, startX, startY, endX, endY) {
+    for (let y = startY; y < endY; y += 1) {
+        const rowOffset = y * mask.width;
+        for (let x = startX; x < endX; x += 1) {
+            if (mask.data[rowOffset + x] !== 0)
+                return true;
+        }
+    }
+    return false;
+}
+/** Exact extent and count of the changed pixels inside one component's cells. */
+function tighten(mask, cells, cell, columns) {
+    let minX = mask.width;
+    let minY = mask.height;
+    let maxX = -1;
+    let maxY = -1;
+    let pixels = 0;
+    for (const index of cells) {
+        const startX = (index % columns) * cell;
+        const startY = ((index / columns) | 0) * cell;
+        const endX = Math.min(startX + cell, mask.width);
+        const endY = Math.min(startY + cell, mask.height);
+        for (let y = startY; y < endY; y += 1) {
+            const rowOffset = y * mask.width;
+            for (let x = startX; x < endX; x += 1) {
+                if (mask.data[rowOffset + x] === 0)
+                    continue;
+                pixels += 1;
+                if (x < minX)
+                    minX = x;
+                if (x > maxX)
+                    maxX = x;
+                if (y < minY)
+                    minY = y;
+                if (y > maxY)
+                    maxY = y;
+            }
+        }
+    }
+    const width = maxX - minX + 1;
+    const height = maxY - minY + 1;
+    return { x: minX, y: minY, width, height, pixels, density: pixels / (width * height) };
+}
+/**
+ * Excluded subtrees as device-pixel boxes on the raster's own canvas.
+ *
+ * The conversion that lets one declaration serve both tiers (spec 0024). A site
+ * is recorded in CSS pixels in page space, because that is what a document knows;
+ * a mask is device pixels in raster space, because that is what a screenshot is.
+ * Getting the transform wrong is not a small error — at the wrong scale every box
+ * lands in the top-left quadrant and silences whatever happens to be there — so
+ * it is inverted from exactly the expression `attributeRegions` uses in the other
+ * direction, in one place, rather than re-derived per caller.
+ *
+ * Sites with no `rect` are dropped: a profile with no layout engine observed no
+ * box, and a box that was never observed must never be inferred. The semantic
+ * half of the same rule still applies on that profile, which is the correct
+ * asymmetry — that profile decides no pixels either.
+ */
+export function excludedBoxes(snapshot, options) {
+    const sites = snapshot.ignoreSites ?? [];
+    if (sites.length === 0)
+        return [];
+    const origin = options.origin ?? snapshot.root.rect ?? { x: 0, y: 0 };
+    return sites
+        .filter((site) => site.rect !== undefined)
+        .map((site) => ({
+        rule: site.rule,
+        x: (site.rect.x - origin.x) * options.scale,
+        y: (site.rect.y - origin.y) * options.scale,
+        width: site.rect.width * options.scale,
+        height: site.rect.height * options.scale,
+    }));
+}
+//# sourceMappingURL=mask.js.map

package/dist/attribute/mask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mask.js","sourceRoot":"","sources":["../../src/attribute/mask.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rect } from '../format/capture.js';\nimport type { IgnoreSite, SemanticSnapshot } from '../format/snapshot.js';\n\n/**\n * A change as a bitmask: where on the canvas, and what was excluded from it.\n *\n * Arithmetic, and nothing else. No DOM, no snapshot, no notion of what a\n * component is — which is why it is the half of attribution that can be tested\n * with a hand-written mask and why it is a file of its own. Everything here\n * answers *where on the canvas*; `region.ts` joins those coordinates to a tree\n * and answers *what is there*, and the two fail differently enough that reading\n * one to understand the other was how they came to share 500 lines.\n *\n * The pixel count is what this exists to defeat. \"5482 pixels changed\" cannot be\n * read, cannot be assigned, and leaves opening the image as the only available\n * response — the expensive act the tool was supposed to replace.\n */\n\n/**\n * Per-pixel changed/unchanged, row-major, one byte per pixel.\n *\n * A mask rather than a diff image: an image is for looking at, and everything\n * downstream of here wants to compute. Producing one is the comparison phase's\n * job and involves PNG decoding; consuming one is pure.\n */\nexport interface ChangeMask {\n  readonly width: number;\n  readonly height: number;\n  /** `1` where the pixel differs. Length is `width * height`. */\n  readonly data: Uint8Array;\n  /** Count of set bytes, carried so callers need not rescan. */\n  readonly changed: number;\n}\n\nexport interface DiffRegion extends Rect {\n  /** Changed pixels inside the box. Always ≤ `width * height`. */\n  readonly pixels: number;\n  /** `pixels / (width * height)`. Low means scattered; high means a solid block. */\n  readonly density: number;\n}\n\nexport interface IsolationOptions {\n  /**\n   * Grid size, in pixels, at which neighbouring changes are considered one place.\n   *\n   * Not a tuning knob so much as a statement about what a region *is*. At cell 1\n   * every antialiased glyph edge is its own region and a paragraph of restyled\n   * text produces four hundred of them, which is the same unreadable output as a\n   * single number, only longer. At cell 8 a word is one region and a button is\n   * one region, which is the granularity a person names when they point at a\n   * screen.\n   */\n  readonly cell?: number;\n\n  /**\n   * Cap on regions returned, largest first.\n   *\n   * Truncation is reported in {@link Isolation.truncated} rather than applied\n   * silently. A capped list that does not say it was capped reads as complete\n   * coverage, and the reader has no way to know the difference.\n   */\n  readonly limit?: number;\n}\n\nexport interface Isolation {\n  readonly regions: readonly DiffRegion[];\n  /** Regions found but not returned, because of `limit`. `0` in the normal case. */\n  readonly truncated: number;\n  /** Changed pixels in the truncated tail. Nothing is lost silently. */\n  readonly truncatedPixels: number;\n}\n\nconst DEFAULT_CELL = 8;\nconst DEFAULT_LIMIT = 32;\n\n/**\n * Cluster a change mask into regions.\n *\n * Connected components are computed on a coarse grid rather than on the pixels\n * themselves. That is a performance decision and a semantic one at once: the\n * coarse pass is one linear sweep instead of a merge over thousands of glyph-edge\n * fragments, and it produces the grouping a reader would have produced by eye.\n * Bounding boxes are then tightened back onto the actual changed pixels, so a\n * region's coordinates are exact even though its *membership* was decided coarsely.\n */\nexport function isolateRegions(mask: ChangeMask, options: IsolationOptions = {}): Isolation {\n  const cell = Math.max(1, Math.floor(options.cell ?? DEFAULT_CELL));\n  const limit = options.limit ?? DEFAULT_LIMIT;\n\n  const columns = Math.ceil(mask.width / cell);\n  const rows = Math.ceil(mask.height / cell);\n  const occupied = new Uint8Array(columns * rows);\n\n  for (let y = 0; y < mask.height; y += 1) {\n    const rowOffset = y * mask.width;\n    const gridRow = ((y / cell) | 0) * columns;\n    for (let x = 0; x < mask.width; x += 1) {\n      if (mask.data[rowOffset + x] !== 0) occupied[gridRow + ((x / cell) | 0)] = 1;\n    }\n  }\n\n  const seen = new Uint8Array(occupied.length);\n  const found: DiffRegion[] = [];\n\n  for (let index = 0; index < occupied.length; index += 1) {\n    if (occupied[index] === 0 || seen[index] !== 0) continue;\n\n    // Explicit stack. A full-page change is a single component covering every\n    // cell, and recursion at that depth is a stack overflow rather than a slow path.\n    const stack = [index];\n    seen[index] = 1;\n    const cells: number[] = [];\n\n    while (stack.length > 0) {\n      const current = stack.pop()!;\n      cells.push(current);\n\n      const cx = current % columns;\n      const cy = (current / columns) | 0;\n\n      for (let dy = -1; dy <= 1; dy += 1) {\n        for (let dx = -1; dx <= 1; dx += 1) {\n          const nx = cx + dx;\n          const ny = cy + dy;\n          if (nx < 0 || ny < 0 || nx >= columns || ny >= rows) continue;\n\n          const neighbour = ny * columns + nx;\n          if (occupied[neighbour] === 0 || seen[neighbour] !== 0) continue;\n\n          seen[neighbour] = 1;\n          stack.push(neighbour);\n        }\n      }\n    }\n\n    found.push(tighten(mask, cells, cell, columns));\n  }\n\n  found.sort((a, b) => b.pixels - a.pixels || a.y - b.y || a.x - b.x);\n\n  const kept = found.slice(0, limit);\n  const dropped = found.slice(limit);\n\n  return {\n    regions: kept,\n    truncated: dropped.length,\n    truncatedPixels: dropped.reduce((sum, region) => sum + region.pixels, 0),\n  };\n}\n\nexport interface Subtraction {\n  /** The mask with the excluded boxes cleared. Never the same object. */\n  readonly mask: ChangeMask;\n\n  /** Changed pixels that fell inside an excluded box. */\n  readonly ignored: number;\n\n  /**\n   * Pixels each input box cleared, in the order the boxes were given.\n   *\n   * Positional rather than keyed, because this file knows nothing about ignore\n   * rules and should not start: a box is geometry. The caller that supplied the\n   * boxes knows which rule each came from and can attribute the counts, which is\n   * what a per-rule register is assembled from.\n   *\n   * Two boxes overlapping share their pixels on a first-come basis, so these sum\n   * to {@link Subtraction.ignored} exactly and never double-count.\n   */\n  readonly cleared: readonly number[];\n\n  /**\n   * Boxes that covered no changed pixel at all.\n   *\n   * The raster half of the dead-ignore register. A mask drawn around a carousel\n   * that has since been removed covers nothing, and an operator who cannot see\n   * that keeps a hole in the suite because deleting it feels risky.\n   *\n   * Judged against the *original* mask, not against what earlier boxes left. Two\n   * rules covering one element is ordinary — a selector and a marker attribute\n   * reaching the same node — and clearing is first-come, so the second box would\n   * otherwise clear zero and be reported as covering nothing at all. That reads\n   * as \"delete this rule\" about a rule that is working.\n   */\n  readonly inert: readonly Rect[];\n}\n\n/**\n * Clear excluded boxes out of a change mask, and say what that cost.\n *\n * The raster half of an ignore (spec 0024). The semantic half drops deltas under\n * a subtree; this drops the pixels the same subtree occupied, so the two tiers\n * cannot disagree about what the subject is — a region excluded semantically and\n * still compared on pixels arrives as `unexplained`, the highest severity in the\n * system, for something the operator already said was not the subject.\n *\n * Subtracting *before* isolation rather than filtering regions afterwards, which\n * looks equivalent and is not: a region that straddles the boundary would\n * otherwise be dropped whole or kept whole, and both answers are wrong. Clearing\n * pixels lets the part outside the box cluster on its own and be reported.\n *\n * The count is returned rather than folded away. `changed` on the result is what\n * the run compares against zero; `ignored` is what it owes the reader, because a\n * comparison that discarded four thousand pixels and reported \"no difference\" is\n * the failure this whole mechanism is written around.\n */\nexport function subtractRegions(mask: ChangeMask, boxes: readonly Rect[]): Subtraction {\n  if (boxes.length === 0) return { mask, ignored: 0, cleared: [], inert: [] };\n\n  const data = Uint8Array.from(mask.data);\n  const cleared: number[] = [];\n  const inert: Rect[] = [];\n  let ignored = 0;\n\n  for (const box of boxes) {\n    // Rounded outward. A box is a CSS rectangle and a mask is a pixel grid; the\n    // half-pixel at the edge belongs to the thing that was excluded, because the\n    // alternative is a one-pixel rim of permanent residue around every ignore.\n    const startX = Math.max(0, Math.floor(box.x));\n    const startY = Math.max(0, Math.floor(box.y));\n    const endX = Math.min(mask.width, Math.ceil(box.x + box.width));\n    const endY = Math.min(mask.height, Math.ceil(box.y + box.height));\n\n    let inside = 0;\n    for (let y = startY; y < endY; y += 1) {\n      const rowOffset = y * mask.width;\n      for (let x = startX; x < endX; x += 1) {\n        const index = rowOffset + x;\n        if (data[index] === 0) continue;\n        data[index] = 0;\n        inside += 1;\n      }\n    }\n\n    ignored += inside;\n    cleared.push(inside);\n    // Against the untouched mask. `inside` counts what *this* box cleared, which\n    // is zero for the second of two overlapping boxes however much it covers.\n    if (!coversAnyChange(mask, startX, startY, endX, endY)) inert.push(box);\n  }\n\n  return {\n    mask: { width: mask.width, height: mask.height, data, changed: mask.changed - ignored },\n    ignored,\n    cleared,\n    inert,\n  };\n}\n\n/** Whether the original mask had any changed pixel in this box. */\nfunction coversAnyChange(\n  mask: ChangeMask,\n  startX: number,\n  startY: number,\n  endX: number,\n  endY: number,\n): boolean {\n  for (let y = startY; y < endY; y += 1) {\n    const rowOffset = y * mask.width;\n    for (let x = startX; x < endX; x += 1) {\n      if (mask.data[rowOffset + x] !== 0) return true;\n    }\n  }\n  return false;\n}\n\n/** Exact extent and count of the changed pixels inside one component's cells. */\nfunction tighten(mask: ChangeMask, cells: readonly number[], cell: number, columns: number): DiffRegion {\n  let minX = mask.width;\n  let minY = mask.height;\n  let maxX = -1;\n  let maxY = -1;\n  let pixels = 0;\n\n  for (const index of cells) {\n    const startX = (index % columns) * cell;\n    const startY = ((index / columns) | 0) * cell;\n    const endX = Math.min(startX + cell, mask.width);\n    const endY = Math.min(startY + cell, mask.height);\n\n    for (let y = startY; y < endY; y += 1) {\n      const rowOffset = y * mask.width;\n      for (let x = startX; x < endX; x += 1) {\n        if (mask.data[rowOffset + x] === 0) continue;\n        pixels += 1;\n        if (x < minX) minX = x;\n        if (x > maxX) maxX = x;\n        if (y < minY) minY = y;\n        if (y > maxY) maxY = y;\n      }\n    }\n  }\n\n  const width = maxX - minX + 1;\n  const height = maxY - minY + 1;\n\n  return { x: minX, y: minY, width, height, pixels, density: pixels / (width * height) };\n}\n\n\n/**\n * Excluded subtrees as device-pixel boxes on the raster's own canvas.\n *\n * The conversion that lets one declaration serve both tiers (spec 0024). A site\n * is recorded in CSS pixels in page space, because that is what a document knows;\n * a mask is device pixels in raster space, because that is what a screenshot is.\n * Getting the transform wrong is not a small error — at the wrong scale every box\n * lands in the top-left quadrant and silences whatever happens to be there — so\n * it is inverted from exactly the expression `attributeRegions` uses in the other\n * direction, in one place, rather than re-derived per caller.\n *\n * Sites with no `rect` are dropped: a profile with no layout engine observed no\n * box, and a box that was never observed must never be inferred. The semantic\n * half of the same rule still applies on that profile, which is the correct\n * asymmetry — that profile decides no pixels either.\n */\nexport function excludedBoxes(\n  snapshot: SemanticSnapshot,\n  options: { readonly scale: number; readonly origin?: { readonly x: number; readonly y: number } },\n): readonly ExcludedBox[] {\n  const sites: readonly IgnoreSite[] = snapshot.ignoreSites ?? [];\n  if (sites.length === 0) return [];\n\n  const origin = options.origin ?? snapshot.root.rect ?? { x: 0, y: 0 };\n\n  return sites\n    .filter((site): site is IgnoreSite & { rect: Rect } => site.rect !== undefined)\n    .map((site) => ({\n      rule: site.rule,\n      x: (site.rect.x - origin.x) * options.scale,\n      y: (site.rect.y - origin.y) * options.scale,\n      width: site.rect.width * options.scale,\n      height: site.rect.height * options.scale,\n    }));\n}\n\n/** A box, carrying the rule that excluded it so absorption can be attributed. */\nexport interface ExcludedBox extends Rect {\n  readonly rule: string;\n}\n"]}

package/dist/attribute/movement.d.ts

@@ -0,0 +1,211 @@
+import type { Band } from '../compare/band.js';
+import type { Composition, Site } from './composition.js';
+/**
+ * Why a component moved — and what it means when nothing here can say.
+ *
+ * A run already knows *that* a component's own content differs from its
+ * baseline: that is `causesBetween`, and it is where every report starts. What it
+ * has never known is whether anybody edited the thing. Those are different
+ * questions, and the gap between them is where flakes live:
+ *
+ * > Detect a pixel change. Find the HTML area behind it. Find no related change.
+ * > That is a flake — or the beginning of one.
+ *
+ * The last step is the one that needs evidence, and the evidence has to be
+ * assembled rather than assumed. Four kinds are available to a run that has
+ * already done its work, in descending order of how much they explain:
+ *
+ * 1. **An edit.** A file declaring this component is in the change set. Nothing
+ *    further is interesting; somebody changed it and the run noticed.
+ * 2. **A token.** A custom property this component's own nodes resolve through
+ *    took a new value in this run. The component's code is untouched and its
+ *    output legitimately moved.
+ * 3. **An ancestor.** A component that reaches it was edited, and it is reached
+ *    by climbing — the caller that wrote the element, or, on a build where React
+ *    kept no owner, the enclosure graph of the subject it moved in until an
+ *    edited name appears. Its props are not recoverable in detail, but *this
+ *    moved on what it was given* is the sentence, and it names a real file.
+ * 4. **A contradiction.** The same component, with the same props, rendered
+ *    somewhere else in this same run and rendered *differently*. That is not an
+ *    explanation — it is proof the explanation is not in the component's own
+ *    code, because one commit produced two answers from one input.
+ *
+ * And then **unexplained**, which is the finding. A component whose content
+ * moved, whose file nobody touched, whose tokens held, whose ancestors held, and
+ * which rendered identically everywhere else in the suite at this commit. That
+ * last clause is the part no previous version of this could say, and it is what
+ * the cross-subject join bought: the *stable states to refer to* are the other
+ * sites of the same rendering, and the run already has them.
+ *
+ * ## What this refuses to conclude
+ *
+ * Unexplained is not a flake. This system's position on what establishes a flake
+ * has not moved: a subject is unstable when it fails to read the same way twice,
+ * and one reading can never prove instability
+ * ([`flakiness.md`](../../../../docs/flakiness.md)). What an unexplained movement
+ * is, exactly, is **the shortlist of subjects worth reading twice** — which is
+ * the scarce resource a sweep spends, and until now it was spent on `changed`
+ * subjects in whatever order the plan produced them.
+ */
+export type Cause = 'edited' | 'token' | 'upstream' | 'contradicted' | 'unexplained';
+/** One component the run found to have moved in one subject. */
+export interface Moved {
+    readonly subject: string;
+    readonly component: string;
+    /**
+     * Which bands moved, when the run could tell.
+     *
+     * Empty when the comparison produced names only — a baseline written before
+     * the bands were split carries no per-band digests, and an empty list here
+     * means *not known*, never *no band*.
+     */
+    readonly bands: readonly Band[];
+}
+/** What a run can put beside a movement to explain it. */
+export interface Evidence {
+    /**
+     * Files in the change set, from whichever flag read a diff. Absent when none did.
+     *
+     * Absent and empty are different answers and are kept different: a run with no
+     * `--since` has not established that nobody edited anything, and reading its
+     * silence as "no edits" would attribute every movement in the suite to nothing
+     * and call the result a flake list.
+     */
+    readonly changed?: readonly string[];
+    /** Component name → the files that declare it, from the source index. */
+    readonly declaredIn?: ReadonlyMap<string, readonly string[]>;
+    /** Tokens whose resolved value moved in this run. Absent when nothing asked. */
+    readonly tokens?: readonly string[];
+    /** Subjects that failed to read the same way twice in this run. */
+    readonly unstable?: ReadonlySet<string>;
+    /**
+     * Every component whose hashes moved, by subject — the whole reading, not the
+     * causes.
+     *
+     * The control group is read from this and not from the movements, because the
+     * movements are a *filtered* set: they come from regions the pixels named as
+     * causes, so a component whose hashes moved and whose box no region named is
+     * absent from them. Filtering the control group by the movements alone hands
+     * back exactly those renders as *held still*, which is the one claim that
+     * makes a control group worse than no control group.
+     *
+     * **Absent is not empty**, twice over. An absent map is a run that never
+     * compared hashes, and the control group falls back to the movements with a
+     * weaker guarantee. A subject *missing from* a present map had no hashes read
+     * there — nobody measured it, so it cannot be a control for anything.
+     */
+    readonly hashesMoved?: ReadonlyMap<string, ReadonlySet<string>>;
+}
+export interface Movement {
+    readonly subject: string;
+    readonly component: string;
+    readonly bands: readonly Band[];
+    readonly cause: Cause;
+    /** One sentence, naming the evidence rather than the category. */
+    readonly because: string;
+    readonly file?: string;
+    readonly tokens?: readonly string[];
+    readonly upstream?: string;
+    /**
+     * Components between `upstream` and this one, outermost first.
+     *
+     * Empty when the edited component draws it directly, and present only on the
+     * `upstream` rung. A reviewer sent to `ProductCard` for a `CardFooter` that
+     * moved has one question — *how does that reach this* — and the answer is two
+     * names the run already holds.
+     */
+    readonly through?: readonly string[];
+    /**
+     * Other subjects in which this same component moved in this run.
+     *
+     * The "one cause, N subjects" fold. A reviewer reading eleven changed subjects
+     * is often reading one edit, and the count is the difference between a
+     * frightening report and an accurate one.
+     */
+    readonly alsoIn: readonly string[];
+    /**
+     * Sites of this component, with the same props, whose hashes this run read and
+     * found unmoved.
+     *
+     * The control group, and the reason an unexplained movement is worth
+     * reporting rather than shrugging at. Empty means there was no control — the
+     * component appears nowhere else with these inputs, or it moved in every one
+     * of them — which weakens the finding and is why it is a list rather than a
+     * flag.
+     */
+    readonly held: readonly Site[];
+    /**
+     * Sites of this component with the same props, other than this one, that the
+     * run read — the pool `held` was drawn from.
+     *
+     * The denominator, and without it `held: []` is two opposite findings under one
+     * shape. Zero is *nothing to compare against*; four with an empty `held` is a
+     * comparison that was made, in four renders, and came back the same way in all
+     * of them — the statement that nothing rendered under those props escaped
+     * whatever moved here.
+     */
+    readonly compared: number;
+}
+export interface Attribution {
+    /** Every movement supplied, in the order supplied, each with a cause. */
+    readonly movements: readonly Movement[];
+    /**
+     * Unexplained movements in subjects that also failed to read the same way
+     * twice. A movement nothing explains, in a subject already proven unstable.
+     */
+    readonly flakes: readonly Movement[];
+    /**
+     * Unexplained movements in subjects nothing has read twice.
+     *
+     * Not a verdict. The shortlist a sweep should spend its second readings on,
+     * ordered by how much control the suite has over each — a component that
+     * rendered identically in six other places and moved here is a better use of a
+     * second reading than one that appears nowhere else.
+     */
+    readonly suspects: readonly Movement[];
+}
+/**
+ * Attribute every movement, given whatever evidence the run assembled.
+ *
+ * Degrades honestly. With no change set the `edited` rung is unreachable and
+ * every movement falls to a lower one, so a run that did not ask cannot produce
+ * a confident `unexplained` — which is checked here rather than trusted to the
+ * caller, because the shortlist this feeds is exactly the thing somebody will
+ * act on.
+ */
+export declare function attributeMovement(moved: readonly Moved[], composition: Composition, evidence?: Evidence): Attribution;
+/** Everything the run assembled, gathered so one movement can be asked about. */
+export interface Bench {
+    readonly movedIn: ReadonlyMap<string, readonly string[]>;
+    readonly edited: ReadonlySet<string>;
+    readonly evidence: Evidence;
+    readonly composition: Composition;
+    readonly graph: Graph;
+}
+/**
+ * Who encloses what and who wrote what, in each subject separately.
+ *
+ * Keyed on the pair because the constraint is the whole point. `ComponentEntry.within`
+ * and `ComponentEntry.createdBy` are both folded over the suite, so `Card` is enclosed by
+ * `CartCard` and by `ProductCard` at once, and a walk that reads either hands a
+ * reviewer the cart as the reason a product story moved. A site knows which
+ * subject it was read in, so the graph can be built the way the question is
+ * asked — and it has to be built that way for *both* edges, because the creator
+ * is consulted first and an unconstrained answer there is never reached by the
+ * constrained walk underneath it.
+ */
+type Enclosures = ReadonlyMap<string, readonly string[]>;
+interface Graph {
+    /** Who this component sits inside, per subject. */
+    readonly within: Enclosures;
+    /** Whose JSX wrote this component's element, per subject. */
+    readonly wrote: Enclosures;
+}
+/** An edited component above a moved one, and the components in between. */
+export interface Ancestor {
+    readonly name: string;
+    /** Outermost first, and empty when the edited component draws it directly. */
+    readonly through: readonly string[];
+}
+export {};
+//# sourceMappingURL=movement.d.ts.map

package/dist/attribute/movement.js

@@ -0,0 +1,181 @@
+import { becauseUpstream, unexplainedBecause } from './because.js';
+import { heldSites } from './control.js';
+/**
+ * Attribute every movement, given whatever evidence the run assembled.
+ *
+ * Degrades honestly. With no change set the `edited` rung is unreachable and
+ * every movement falls to a lower one, so a run that did not ask cannot produce
+ * a confident `unexplained` — which is checked here rather than trusted to the
+ * caller, because the shortlist this feeds is exactly the thing somebody will
+ * act on.
+ */
+export function attributeMovement(moved, composition, evidence = {}) {
+    const byComponent = new Map(composition.components.map((entry) => [entry.component, entry]));
+    const movedIn = new Map();
+    for (const each of moved) {
+        const subjects = movedIn.get(each.component) ?? [];
+        subjects.push(each.subject);
+        movedIn.set(each.component, subjects);
+    }
+    const edited = new Set([...(evidence.declaredIn ?? new Map())]
+        .filter(([, files]) => files.some((file) => (evidence.changed ?? []).includes(file)))
+        .map(([component]) => component));
+    const graph = graphOf(composition);
+    const movements = moved.map((each) => attributeOne(each, byComponent.get(each.component), {
+        movedIn,
+        edited,
+        evidence,
+        composition,
+        graph,
+    }));
+    const unexplained = movements.filter((movement) => movement.cause === 'unexplained');
+    return {
+        movements,
+        flakes: unexplained.filter((movement) => evidence.unstable?.has(movement.subject) === true),
+        suspects: unexplained
+            .filter((movement) => evidence.unstable?.has(movement.subject) !== true)
+            .sort((a, b) => b.held.length - a.held.length),
+    };
+}
+function attributeOne(moved, entry, bench) {
+    const { movedIn, edited, evidence, composition, graph } = bench;
+    const alsoIn = (movedIn.get(moved.component) ?? []).filter((subject) => subject !== moved.subject);
+    const { held, considered } = heldSites(moved, entry, bench);
+    const base = { ...moved, alsoIn, held, compared: considered };
+    const file = (evidence.declaredIn?.get(moved.component) ?? []).find((each) => (evidence.changed ?? []).includes(each));
+    if (file !== undefined) {
+        return { ...base, cause: 'edited', file, because: `\`${file}\` is in the change set` };
+    }
+    const tokens = movedTokens(moved.component, composition, evidence);
+    if (tokens.length > 0) {
+        return {
+            ...base,
+            cause: 'token',
+            tokens,
+            because: `it resolves through ${tokens.map((token) => `\`${token}\``).join(', ')}, which moved in this run`,
+        };
+    }
+    const ancestor = editedAncestor(moved, edited, graph);
+    if (ancestor !== undefined) {
+        return {
+            ...base,
+            cause: 'upstream',
+            upstream: ancestor.name,
+            ...(ancestor.through.length === 0 ? {} : { through: ancestor.through }),
+            because: becauseUpstream(ancestor),
+        };
+    }
+    const contradiction = composition.divergences.find((divergence) => divergence.component === moved.component &&
+        divergence.renderings.some((rendering) => rendering.sites.some((site) => site.subject === moved.subject)));
+    if (contradiction !== undefined) {
+        return {
+            ...base,
+            cause: 'contradicted',
+            because: `at this commit it renders ${contradiction.renderings.length} different ways from the same props ` +
+                `(${contradiction.bands.join(', ')}), so the change is not in its own code`,
+        };
+    }
+    return { ...base, cause: 'unexplained', because: unexplainedBecause(base, considered, evidence) };
+}
+const IN = '\u0000';
+function graphOf(composition) {
+    const within = new Map();
+    const wrote = new Map();
+    const add = (graph, key, name) => {
+        const names = graph.get(key);
+        if (names === undefined)
+            graph.set(key, [name]);
+        else if (!names.includes(name))
+            names.push(name);
+    };
+    for (const entry of composition.components) {
+        for (const group of entry.classes) {
+            for (const rendering of group.renderings) {
+                for (const site of rendering.sites) {
+                    const key = `${site.subject}${IN}${entry.component}`;
+                    if (site.within !== undefined)
+                        add(within, key, site.within);
+                    if (site.createdBy !== undefined)
+                        add(wrote, key, site.createdBy);
+                }
+            }
+        }
+    }
+    for (const names of within.values())
+        names.sort();
+    for (const names of wrote.values())
+        names.sort();
+    return { within, wrote };
+}
+/**
+ * The nearest edited component above this one, in the subject it moved in.
+ *
+ * The creator first, and it is not a tie-break. The component that *wrote the
+ * element* is the one whose edit changed this component's inputs; the one it
+ * happens to sit inside may be a presentational wrapper that knows nothing about
+ * it. On `examples/todomvc` every `Chip` sits within a `Stack` and is created by
+ * `TodoFooter`, so a run consulting only enclosure would fail to connect an edit
+ * to `TodoFooter` with the chips it moved — and report five unexplained movements
+ * instead of one caller. It is absent on a production build, which is why the
+ * enclosure walk is not a fallback but the other half.
+ *
+ * Read off the per-subject graph and not off the entry. The entry's `createdBy`
+ * is the suite's whole set, so an edit to whoever writes this component on one
+ * page answers for every page it appears on — the same unconstrained answer the
+ * walk below refuses, arriving one line earlier and winning.
+ *
+ * And that walk climbs rather than looking once. The rung has always said
+ * *ancestor* and checked a parent, and a React tree is mostly components that
+ * draw one wrapper each: `ProductCard` was edited, `ProductCard` draws `Card`,
+ * `Card` draws `CardFooter`, and one look up arrives at `Card`, whose file nobody
+ * touched. That is the shape of every unexplained movement this ladder used to
+ * produce over an edit it was holding the graph for.
+ */
+function editedAncestor(moved, edited, graph) {
+    const here = `${moved.subject}${IN}${moved.component}`;
+    const wrote = (graph.wrote.get(here) ?? []).find((name) => edited.has(name));
+    if (wrote !== undefined)
+        return { name: wrote, through: [] };
+    // Breadth-first, so the answer is the *nearest* edit and not whichever one the
+    // recursion reached first. `seen` is written as a rung is built: an enclosure
+    // graph folded over a suite can close a loop, and a component reached twice on
+    // one rung would otherwise queue twice.
+    const seen = new Set([moved.component]);
+    const step = (from) => {
+        const child = from === null ? moved.component : from.name;
+        const rung = [];
+        for (const holder of graph.within.get(`${moved.subject}${IN}${child}`) ?? []) {
+            if (seen.has(holder))
+                continue;
+            seen.add(holder);
+            rung.push({ name: holder, through: from === null ? [] : [from.name, ...from.through] });
+        }
+        return rung;
+    };
+    let rung = step(null);
+    while (rung.length > 0) {
+        const arrived = rung.find((each) => edited.has(each.name));
+        if (arrived !== undefined)
+            return arrived;
+        rung = rung.flatMap(step);
+    }
+    return undefined;
+}
+/**
+ * Tokens this component resolves through that moved in this run.
+ *
+ * Read off the instances rather than off the subject, which is the distinction
+ * that makes the answer worth anything: every subject on a themed page resolves
+ * through every token in the theme, so a subject-level intersection names them
+ * all and explains nothing.
+ */
+function movedTokens(component, composition, evidence) {
+    if (evidence.tokens === undefined || evidence.tokens.length === 0)
+        return [];
+    const entry = composition.components.find((each) => each.component === component);
+    if (entry === undefined)
+        return [];
+    const moved = new Set(evidence.tokens);
+    return [...entry.tokens].filter((token) => moved.has(token)).sort();
+}
+//# sourceMappingURL=movement.js.map