@ambitresearch/genie 1.3.1

package/dist/validate/phash.d.ts

@@ -0,0 +1,135 @@
+/** Decoded RGBA pixel buffer — what a PNG decoder (`pngjs`) hands back, and
+ * what {@link computePHash} (via `blockhash-core`'s `bmvbhash`) consumes. */
+export interface RGBAImage {
+    /** Raw pixel bytes, 4 per pixel (R,G,B,A), row-major. */
+    data: Uint8Array;
+    width: number;
+    height: number;
+}
+/**
+ * Perceptual hashes within this many bits (out of 256, i.e. ~1.5%) are
+ * treated as "the same rendered card" for AC5's `variantsIdentical` check.
+ * See the module doc above for the empirical calibration behind this number.
+ */
+export declare const DEFAULT_TOLERANCE_BITS = 4;
+/**
+ * Perceptual-hash an already-decoded RGBA image via the blockhash algorithm
+ * (AC5). Returns a hex string; two structurally-identical images always hash
+ * identically (verified deterministic), and the hash space is the fixed
+ * `HASH_BITS²` bits `bmvbhash` always emits for a given `bits` argument, so
+ * every hash this module produces is directly comparable via {@link
+ * hammingDistance}.
+ */
+export declare function computePHash(image: RGBAImage): string;
+/**
+ * A card's mean "ink" color (DRO-717) — the second signal the color veto in
+ * {@link findDuplicateClusters} compares alongside the blockhash. Mean R/G/B
+ * over the saturated, non-background pixels of a render (see {@link
+ * computeColorSignature} for the exclusion rule). `undefined` when a render has
+ * no ink pixels at all (a blank/near-empty card), in which case the veto
+ * abstains and the pairing falls back to blockhash alone.
+ */
+export interface ColorSignature {
+    r: number;
+    g: number;
+    b: number;
+}
+/**
+ * L1 (Manhattan) distance below which two {@link ColorSignature}s are treated
+ * as "the same fill color" for the hue-veto in {@link findDuplicateClusters}
+ * (DRO-717). Calibrated on real DRO-717 renders (see the module doc's
+ * "Hue-aware color veto" section): label variants of a single fill drift ≤ ~4.5,
+ * every genuinely-distinct hue pair measured ≥ ~33 — a threshold of 20 sits
+ * centered in that gap, ~4× above label-variant noise and comfortably below the
+ * tightest real hue difference.
+ */
+export declare const DEFAULT_COLOR_TOLERANCE_L1 = 20;
+/**
+ * Compute a render's mean "ink" color (DRO-717) — the hue signal the color veto
+ * in {@link findDuplicateClusters} pairs with the blockhash. Averages R/G/B over
+ * only the saturated, non-background pixels (see {@link INK_ALPHA_MIN} et al.
+ * for the exclusion rule and the module doc for why background + white text are
+ * dropped rather than averaged in). Returns `undefined` when NO pixel qualifies
+ * as ink (a fully blank or near-white card) — the caller then compares such a
+ * card on blockhash alone, since it has no hue to veto on.
+ *
+ * Pure arithmetic over the same decoded RGBA buffer {@link computePHash}
+ * consumes — no I/O, one linear pass, so it adds negligibly to AC7's per-render
+ * budget.
+ */
+export declare function computeColorSignature(image: RGBAImage): ColorSignature | undefined;
+/**
+ * L1 (Manhattan) distance between two {@link ColorSignature}s — the metric the
+ * color veto thresholds against {@link DEFAULT_COLOR_TOLERANCE_L1}. Manhattan,
+ * not Euclidean, because the calibration gap is wide (≤4.5 vs ≥33) so the
+ * cheaper sum-of-abs-differences is more than discriminating enough, and it
+ * keeps the whole comparison integer-friendly.
+ */
+export declare function colorDistanceL1(a: ColorSignature, b: ColorSignature): number;
+/**
+ * Count differing BITS (not hex characters) between two equal-length hex hash
+ * strings (AC5). Both {@link computePHash}'s output and this function operate
+ * over the same fixed-width hash space, so a caller never mixes hashes from a
+ * different `HASH_BITS` setting — but the length check below still guards the
+ * case defensively rather than silently truncating.
+ *
+ * Hex, not raw bit-strings, because that's the wire/storage-friendly form
+ * `computePHash` returns; comparing correctly still requires decoding to bits
+ * per nibble (a naive per-CHARACTER diff would undercount — e.g. `0x0` vs
+ * `0xf` differ in ALL 4 bits of that nibble but are only "1 character" apart).
+ */
+export declare function hammingDistance(hexA: string, hexB: string): number;
+/** One kit file's path plus its precomputed perceptual hash — the input
+ * {@link findDuplicateClusters} clusters. `color` is the DRO-717 hue-veto
+ * signal ({@link computeColorSignature}); OPTIONAL and backward-compatible — an
+ * entry without it is compared on blockhash alone, exactly as before the veto
+ * existed. Production (`full-scan.ts`) always supplies it; arithmetic-only tests
+ * may omit it. */
+export interface HashedEntry {
+    path: string;
+    hash: string;
+    color?: ColorSignature;
+}
+/**
+ * Group `entries` into near-duplicate clusters (AC5: pairs — generalized here
+ * to clusters, since 3+ near-identical renders is exactly the failure mode
+ * the AC's own example describes) and return the FLAT, deduplicated,
+ * sorted list of every path that landed in a cluster of size >= 2. A path
+ * with no near-duplicate (a singleton) is omitted entirely — `variantsIdentical`
+ * is "these paths render the same as some other path", not a roster of every
+ * file scanned.
+ *
+ * Clustering is transitive (union-find): if A is within tolerance of B, and B
+ * is within tolerance of C, all three land in ONE cluster even if A and C
+ * alone exceed tolerance — the natural reading of "these components all look
+ * the same" when three-plus near-duplicates form a chain rather than every
+ * pair being mutually within tolerance.
+ *
+ * ── Two-signal near-duplicate test (DRO-717) ─────────────────────────────────
+ * Two entries are unioned only when they are near-duplicates on BOTH signals:
+ *   1. blockhash Hamming distance <= `toleranceBits` (layout/luminance), AND
+ *   2. `colorDistanceL1` <= `colorToleranceL1` (hue) — the DRO-717 veto that
+ *      stops the hue-blind blockhash from clustering a primary/danger/success
+ *      button set (identical layout, distinct fills) as identical.
+ * The color check is a pure VETO: it can only PREVENT a union the blockhash
+ * would have made, never create one. It abstains (does not veto) when EITHER
+ * entry lacks a color signature — so a caller that supplies no colors (e.g. an
+ * arithmetic-only test) gets the exact pre-DRO-717 blockhash-only behavior.
+ *
+ * Why the veto doesn't cause false NEGATIVES (dropping a real duplicate): for a
+ * SAME-fill pair, the ink-color distance co-varies with the button's coverage,
+ * which co-varies with the blockhash. Two same-fill cards only drift apart in
+ * ink color once their rendered widths differ enough — and by then their
+ * blockhash has ALREADY diverged past `toleranceBits`, so the union was never on
+ * the table for the veto to remove (measured on real dark- and light-background
+ * renders: a same-fill pair reaching colorL1 ≈ 39 was already ~35 blockhash bits
+ * apart). The veto therefore only ever bites the case it targets — blockhash
+ * says "close" while hue says "different", i.e. the hue-blind false positive.
+ *
+ * O(n²) pairwise comparisons — acceptable for AC7's ~50-component budget (at
+ * most ~1225 comparisons, each a cheap XOR+popcount over a 256-bit BigInt plus
+ * a three-term color subtraction); would need a smarter index (e.g. an LSH
+ * bucket) at kit sizes multiple orders of magnitude larger than genie's target.
+ */
+export declare function findDuplicateClusters(entries: HashedEntry[], toleranceBits?: number, colorToleranceL1?: number): string[];
+//# sourceMappingURL=phash.d.ts.map

package/dist/validate/phash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phash.d.ts","sourceRoot":"","sources":["../../src/validate/phash.ts"],"names":[],"mappings":"AAmFA;6EAC6E;AAC7E,MAAM,WAAW,SAAS;IACxB,yDAAyD;IACzD,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAUD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAErD;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAmB7C;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,GAAG,cAAc,GAAG,SAAS,CAsBlF;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,cAAc,GAAG,MAAM,CAE5E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAelE;AAED;;;;;kBAKkB;AAClB,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,WAAW,EAAE,EACtB,aAAa,GAAE,MAA+B,EAC9C,gBAAgB,GAAE,MAAmC,GACpD,MAAM,EAAE,CAuDV"}

package/dist/validate/phash.js

@@ -0,0 +1,307 @@
+/**
+ * Perceptual-hash helpers for the M3-04 (DRO-260) `validate` full-scan facet's
+ * `variantsIdentical` check (AC5) — "the model generated 3 buttons that all
+ * look the same".
+ *
+ * Pure arithmetic, no I/O: {@link computePHash} takes decoded RGBA pixels (the
+ * caller renders + decodes the PNG — see `render.ts`), and {@link
+ * findDuplicateClusters} takes already-computed hashes. Kept pure/offline so
+ * this module — and its test suite — never touches Playwright, a browser, or
+ * the filesystem, mirroring `validate/marker.ts`'s own "pure and offline" design
+ * note.
+ *
+ * ── Algorithm choice: blockhash, not a DCT pHash ──────────────────────────────
+ * `bmvbhash` (the `blockhash-core` package, the reference implementation of
+ * blockhash.io's algorithm) divides the image into an NxN grid of blocks,
+ * takes each block's average brightness, and bits the result against the
+ * per-quadrant median. It is simpler and faster than a DCT-based pHash and
+ * needs no native build step (no `sharp`/libvips) — genie's server stays a
+ * pure-JS install, matching the rest of `dependencies` in package.json. The
+ * accuracy tradeoff is fine for this AC: the goal is "flag near-identical
+ * card renders", not general-purpose reverse image search.
+ *
+ * ── Tolerance calibration ─────────────────────────────────────────────────────
+ * `DEFAULT_TOLERANCE_BITS` was calibrated empirically (real Chromium renders +
+ * `bmvbhash(…, 16)`, i.e. a 256-bit hash), most recently re-measured post-#154
+ * WITH fonts loaded (DRO-717 — an early fontless run misleadingly showed every
+ * label variant at distance 0, because a browser with no font renders every
+ * button at the same zero-glyph-advance width; the numbers below are the real,
+ * font-loaded measurements):
+ *   - Byte-identical HTML (the model re-emitting the exact same card twice)
+ *     hashes to a Hamming distance of **0**.
+ *   - A legitimately distinct restyle of the same component — an outline vs.
+ *     filled button, a secondary size/radius variant — produces **~11–27 bits**.
+ *   - Two cards differing ONLY in their label TEXT ("Save" vs "Delete account")
+ *     also produce **~8–34 bits** — because a wider label lays the whole button
+ *     out at a different width, which genuinely changes the block-grid
+ *     structure. (This corrects an earlier version of this comment, which
+ *     claimed label-only differences hash to distance 0 / cluster together —
+ *     true only in the degenerate fontless render; false under real text.)
+ * Those last two ranges OVERLAP, so no single `DEFAULT_TOLERANCE_BITS` can both
+ * cluster every label variant AND avoid clustering every genuine restyle. We
+ * therefore keep the tolerance TIGHT (**4 bits out of 256**, just above pure
+ * render noise — antialiasing jitter, sub-pixel rounding — and far below the
+ * smallest genuinely-different pair), and treat `variantsIdentical` as its
+ * literal name: renders that are STRUCTURALLY identical (a true duplicate card
+ * — same markup, or whitespace-only differences), not merely two buttons of the
+ * same shape wearing different words. This preserves the doc's own long-standing
+ * bias — a false negative just means a human's eyes catch it in the rendered
+ * grid, while a false positive makes `validate` cry wolf on a legitimate
+ * "Save"/"Cancel" pair.
+ *
+ * ── Hue-aware color veto (DRO-717, fixes finding 1) ───────────────────────────
+ * blockhash is a LUMINANCE-structure hash: `bmvbhash` reduces each block to a
+ * single brightness value (the `R+G+B` sum), with no hue term at all. Three
+ * buttons of identical layout but visually distinct fills — clay `#c87c5e`,
+ * blue `#345197`, red `#c5372f` — therefore hash to Hamming distance **0**
+ * (confirmed on real renders), which would falsely cluster a primary/danger/
+ * success button SET as `variantsIdentical`. This is structural, not a
+ * tolerance-tuning problem: no `DEFAULT_TOLERANCE_BITS` recovers hue the hash
+ * never encoded.
+ *
+ * The fix is an ADDITIVE second signal, not a different hash: alongside each
+ * card's blockhash we carry a cheap {@link computeColorSignature} — the mean
+ * RGB of its "ink" pixels (saturated, non-background — see the function doc for
+ * why page background and white glyph fill are excluded). Two cards are treated
+ * as near-duplicates only when they are BOTH blockhash-close AND color-close
+ * (L1 within {@link DEFAULT_COLOR_TOLERANCE_L1}). The color signature was
+ * calibrated on the same DRO-717 real renders: label variants of one fill drift
+ * at most **~4.5** (blank space and white text excluded, so a growing button
+ * doesn't move it), while every genuinely-different hue pair measured — the
+ * issue trio included — sits at **≥33** (the tightest real pair, teal/green,
+ * was 33.5; the issue trio spanned 115–269). A threshold of **20** sits
+ * centered in that gap. The veto is strictly SUBTRACTIVE — it can only DROP a
+ * pairing the blockhash alone would have made, never add one — so an entry
+ * carrying no color signature falls back to the exact pre-DRO-717 behavior.
+ *
+ * `blockhash-core` ships its own `index.d.ts` (a small, pure-JS package, no
+ * native build step — genie's server stays a pure-JS install, matching the
+ * rest of `dependencies` in package.json), so the named import below needs no
+ * ambient shim.
+ */
+import { bmvbhash } from "blockhash-core";
+/**
+ * Grid resolution `bmvbhash` divides the image into (an N×N block grid,
+ * yielding an N²-bit hash). 16 → a 256-bit hash — fine-grained enough to
+ * distinguish real layout differences while staying cheap to compute for a
+ * batch of dozens of components (AC7's < 5 s / 50-component budget).
+ */
+const HASH_BITS = 16;
+/**
+ * Perceptual hashes within this many bits (out of 256, i.e. ~1.5%) are
+ * treated as "the same rendered card" for AC5's `variantsIdentical` check.
+ * See the module doc above for the empirical calibration behind this number.
+ */
+export const DEFAULT_TOLERANCE_BITS = 4;
+/**
+ * Perceptual-hash an already-decoded RGBA image via the blockhash algorithm
+ * (AC5). Returns a hex string; two structurally-identical images always hash
+ * identically (verified deterministic), and the hash space is the fixed
+ * `HASH_BITS²` bits `bmvbhash` always emits for a given `bits` argument, so
+ * every hash this module produces is directly comparable via {@link
+ * hammingDistance}.
+ */
+export function computePHash(image) {
+    return bmvbhash({ data: image.data, width: image.width, height: image.height }, HASH_BITS);
+}
+/**
+ * L1 (Manhattan) distance below which two {@link ColorSignature}s are treated
+ * as "the same fill color" for the hue-veto in {@link findDuplicateClusters}
+ * (DRO-717). Calibrated on real DRO-717 renders (see the module doc's
+ * "Hue-aware color veto" section): label variants of a single fill drift ≤ ~4.5,
+ * every genuinely-distinct hue pair measured ≥ ~33 — a threshold of 20 sits
+ * centered in that gap, ~4× above label-variant noise and comfortably below the
+ * tightest real hue difference.
+ */
+export const DEFAULT_COLOR_TOLERANCE_L1 = 20;
+/**
+ * Thresholds (DRO-717) for {@link computeColorSignature}'s "is this pixel ink?"
+ * test. A pixel is EXCLUDED from the mean when it is either barely-opaque
+ * (`alpha < ALPHA_MIN` — antialiased edges, transparent margin) or
+ * bright-and-low-chroma (`min(R,G,B) > BRIGHT_MIN` AND `max−min < CHROMA_MAX`).
+ * The second clause drops both the light page background a preview renders
+ * against AND the white glyph fill of the label text — the two things that,
+ * left in, would (a) dominate a small button's mean and (b) shift it as the
+ * label grows, which is exactly the width-sensitivity that disqualifies a
+ * whole-canvas mean as a hue signal. What survives is the saturated button
+ * fill, whose mean is stable across label-length changes (measured drift ≤ ~4.5)
+ * yet cleanly separates distinct hues (≥ ~33).
+ */
+const INK_ALPHA_MIN = 128;
+const INK_BRIGHT_MIN = 200;
+const INK_CHROMA_MAX = 24;
+/**
+ * Compute a render's mean "ink" color (DRO-717) — the hue signal the color veto
+ * in {@link findDuplicateClusters} pairs with the blockhash. Averages R/G/B over
+ * only the saturated, non-background pixels (see {@link INK_ALPHA_MIN} et al.
+ * for the exclusion rule and the module doc for why background + white text are
+ * dropped rather than averaged in). Returns `undefined` when NO pixel qualifies
+ * as ink (a fully blank or near-white card) — the caller then compares such a
+ * card on blockhash alone, since it has no hue to veto on.
+ *
+ * Pure arithmetic over the same decoded RGBA buffer {@link computePHash}
+ * consumes — no I/O, one linear pass, so it adds negligibly to AC7's per-render
+ * budget.
+ */
+export function computeColorSignature(image) {
+    const d = image.data;
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let n = 0;
+    for (let i = 0; i + 3 < d.length; i += 4) {
+        const R = d[i];
+        const G = d[i + 1];
+        const B = d[i + 2];
+        const A = d[i + 3];
+        if (A < INK_ALPHA_MIN)
+            continue;
+        const mn = Math.min(R, G, B);
+        const mx = Math.max(R, G, B);
+        if (mn > INK_BRIGHT_MIN && mx - mn < INK_CHROMA_MAX)
+            continue; // background / white text
+        r += R;
+        g += G;
+        b += B;
+        n += 1;
+    }
+    if (n === 0)
+        return undefined;
+    return { r: r / n, g: g / n, b: b / n };
+}
+/**
+ * L1 (Manhattan) distance between two {@link ColorSignature}s — the metric the
+ * color veto thresholds against {@link DEFAULT_COLOR_TOLERANCE_L1}. Manhattan,
+ * not Euclidean, because the calibration gap is wide (≤4.5 vs ≥33) so the
+ * cheaper sum-of-abs-differences is more than discriminating enough, and it
+ * keeps the whole comparison integer-friendly.
+ */
+export function colorDistanceL1(a, b) {
+    return Math.abs(a.r - b.r) + Math.abs(a.g - b.g) + Math.abs(a.b - b.b);
+}
+/**
+ * Count differing BITS (not hex characters) between two equal-length hex hash
+ * strings (AC5). Both {@link computePHash}'s output and this function operate
+ * over the same fixed-width hash space, so a caller never mixes hashes from a
+ * different `HASH_BITS` setting — but the length check below still guards the
+ * case defensively rather than silently truncating.
+ *
+ * Hex, not raw bit-strings, because that's the wire/storage-friendly form
+ * `computePHash` returns; comparing correctly still requires decoding to bits
+ * per nibble (a naive per-CHARACTER diff would undercount — e.g. `0x0` vs
+ * `0xf` differ in ALL 4 bits of that nibble but are only "1 character" apart).
+ */
+export function hammingDistance(hexA, hexB) {
+    if (hexA.length !== hexB.length) {
+        throw new Error(`hammingDistance: hash length mismatch (${hexA.length} vs ${hexB.length}) — hashes must come from the same hash configuration.`);
+    }
+    const a = BigInt(`0x${hexA}`);
+    const b = BigInt(`0x${hexB}`);
+    let xor = a ^ b;
+    let count = 0;
+    while (xor > 0n) {
+        count += Number(xor & 1n);
+        xor >>= 1n;
+    }
+    return count;
+}
+/**
+ * Group `entries` into near-duplicate clusters (AC5: pairs — generalized here
+ * to clusters, since 3+ near-identical renders is exactly the failure mode
+ * the AC's own example describes) and return the FLAT, deduplicated,
+ * sorted list of every path that landed in a cluster of size >= 2. A path
+ * with no near-duplicate (a singleton) is omitted entirely — `variantsIdentical`
+ * is "these paths render the same as some other path", not a roster of every
+ * file scanned.
+ *
+ * Clustering is transitive (union-find): if A is within tolerance of B, and B
+ * is within tolerance of C, all three land in ONE cluster even if A and C
+ * alone exceed tolerance — the natural reading of "these components all look
+ * the same" when three-plus near-duplicates form a chain rather than every
+ * pair being mutually within tolerance.
+ *
+ * ── Two-signal near-duplicate test (DRO-717) ─────────────────────────────────
+ * Two entries are unioned only when they are near-duplicates on BOTH signals:
+ *   1. blockhash Hamming distance <= `toleranceBits` (layout/luminance), AND
+ *   2. `colorDistanceL1` <= `colorToleranceL1` (hue) — the DRO-717 veto that
+ *      stops the hue-blind blockhash from clustering a primary/danger/success
+ *      button set (identical layout, distinct fills) as identical.
+ * The color check is a pure VETO: it can only PREVENT a union the blockhash
+ * would have made, never create one. It abstains (does not veto) when EITHER
+ * entry lacks a color signature — so a caller that supplies no colors (e.g. an
+ * arithmetic-only test) gets the exact pre-DRO-717 blockhash-only behavior.
+ *
+ * Why the veto doesn't cause false NEGATIVES (dropping a real duplicate): for a
+ * SAME-fill pair, the ink-color distance co-varies with the button's coverage,
+ * which co-varies with the blockhash. Two same-fill cards only drift apart in
+ * ink color once their rendered widths differ enough — and by then their
+ * blockhash has ALREADY diverged past `toleranceBits`, so the union was never on
+ * the table for the veto to remove (measured on real dark- and light-background
+ * renders: a same-fill pair reaching colorL1 ≈ 39 was already ~35 blockhash bits
+ * apart). The veto therefore only ever bites the case it targets — blockhash
+ * says "close" while hue says "different", i.e. the hue-blind false positive.
+ *
+ * O(n²) pairwise comparisons — acceptable for AC7's ~50-component budget (at
+ * most ~1225 comparisons, each a cheap XOR+popcount over a 256-bit BigInt plus
+ * a three-term color subtraction); would need a smarter index (e.g. an LSH
+ * bucket) at kit sizes multiple orders of magnitude larger than genie's target.
+ */
+export function findDuplicateClusters(entries, toleranceBits = DEFAULT_TOLERANCE_BITS, colorToleranceL1 = DEFAULT_COLOR_TOLERANCE_L1) {
+    const n = entries.length;
+    if (n < 2)
+        return [];
+    /**
+     * The DRO-717 hue veto: `true` when the two entries' fills are close enough
+     * to be "the same color". Abstains (returns `true`) when either entry has no
+     * color signature, so a color-less caller keeps blockhash-only behavior.
+     */
+    function colorAgrees(a, b) {
+        if (!a.color || !b.color)
+            return true;
+        return colorDistanceL1(a.color, b.color) <= colorToleranceL1;
+    }
+    // Union-find over entry INDICES (not paths) so duplicate paths in the input
+    // can never collide as map keys.
+    const parent = Array.from({ length: n }, (_, i) => i);
+    function find(i) {
+        while (parent[i] !== i) {
+            parent[i] = parent[parent[i]]; // path-halving
+            i = parent[i];
+        }
+        return i;
+    }
+    function union(i, j) {
+        const ri = find(i);
+        const rj = find(j);
+        if (ri !== rj)
+            parent[ri] = rj;
+    }
+    for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+            const a = entries[i];
+            const b = entries[j];
+            if (hammingDistance(a.hash, b.hash) <= toleranceBits && colorAgrees(a, b)) {
+                union(i, j);
+            }
+        }
+    }
+    // Group entry indices by cluster root; keep only clusters with >= 2 members.
+    const clusters = new Map();
+    for (let i = 0; i < n; i++) {
+        const root = find(i);
+        const members = clusters.get(root);
+        if (members)
+            members.push(i);
+        else
+            clusters.set(root, [i]);
+    }
+    const result = [];
+    for (const members of clusters.values()) {
+        if (members.length < 2)
+            continue;
+        for (const idx of members)
+            result.push(entries[idx].path);
+    }
+    return result.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}
+//# sourceMappingURL=phash.js.map

package/dist/validate/phash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phash.js","sourceRoot":"","sources":["../../src/validate/phash.ts"],"names":[],"mappings":"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"}

package/dist/validate/render.d.ts

@@ -0,0 +1,38 @@
+/** One render's measurements: content height (AC4) + a decoded screenshot for
+ * perceptual hashing (AC5). */
+export interface RenderedCard {
+    /** Union bounding-box height, in CSS px, of `document.body`'s direct
+     * children — the rendered content's real vertical extent. */
+    contentHeight: number;
+    /** Decoded RGBA screenshot, ready for `validate/phash.ts`'s `computePHash`. */
+    image: {
+        data: Uint8Array;
+        width: number;
+        height: number;
+    };
+}
+/**
+ * The render seam `full-scan.ts` depends on (DI, same pattern as `refine.ts`'s
+ * `RegionCropper`) — tests inject a stub so no browser is ever launched in the
+ * unit suite; production gets {@link createDefaultRenderer}'s real Playwright
+ * instance.
+ */
+export interface Renderer {
+    /** Render `html` at `viewport` and return its measurements. */
+    render(html: string, viewport: {
+        width: number;
+        height: number;
+    }): Promise<RenderedCard>;
+    /** Shut down the underlying browser. Idempotent-safe to call once per scan. */
+    close(): Promise<void>;
+}
+/**
+ * Create the default (production) {@link Renderer}: one headless Chromium
+ * instance (via lazy Playwright), reused across every `render()` call until
+ * `close()`. Returns `null` when Playwright cannot be loaded — the caller
+ * (`full-scan.ts`) degrades AC4/AC5 gracefully rather than failing the whole
+ * `validate` call over an environment gap (same posture as `refine.ts`'s AC7
+ * region crop).
+ */
+export declare function createDefaultRenderer(): Promise<Renderer | null>;
+//# sourceMappingURL=render.d.ts.map

package/dist/validate/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/validate/render.ts"],"names":[],"mappings":"AAkDA;+BAC+B;AAC/B,MAAM,WAAW,YAAY;IAC3B;iEAC6D;IAC7D,aAAa,EAAE,MAAM,CAAC;IACtB,+EAA+E;IAC/E,KAAK,EAAE;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5D;AAED;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB,+DAA+D;IAC/D,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IACzF,+EAA+E;IAC/E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AA8ED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAgDtE"}

package/dist/validate/render.js

@@ -0,0 +1,155 @@
+/**
+ * Lazy-Playwright renderer for the M3-04 (DRO-260) `validate` full-scan facet.
+ *
+ * Renders a component preview's raw HTML in headless Chromium and reports two
+ * things per render: the rendered content's bounding-box height (AC4's "thin"
+ * check) and a decoded RGBA screenshot buffer (AC5's perceptual-hash input,
+ * via `validate/phash.ts`). One {@link Renderer} instance owns ONE browser
+ * process reused across every file in a scan — launching a fresh browser per
+ * file would blow AC7's < 5 s / 50-component budget on launch overhead alone.
+ *
+ * ── Playwright is an OPTIONAL peer dependency, same precedent as `refine.ts` ──
+ * `refine.ts`'s AC7 region-crop already established this pattern for genie:
+ * Playwright is not in `dependencies` (a real browser download is too heavy to
+ * force on every install), so it is resolved via a runtime, non-literal
+ * `import()` that degrades to `null` (never throws) when the package isn't
+ * installed. `createDefaultRenderer` here follows the exact same contract —
+ * `packages/server/package.json` DOES declare it this time (M3-04's own issue
+ * asks for it: "Reuse Playwright instance from M2-04's region cropper"), but
+ * the caller (`full-scan.ts`) still must not assume it is always resolvable
+ * (a stripped install, an offline `npm ci --omit=optional`-style environment,
+ * or a sandboxed CI runner missing the OS-level shared libraries Chromium
+ * itself needs — independent of whether the npm package is present).
+ *
+ * ── Degradation is logged, not silent (PR #152 review) ────────────────────────
+ * A `null` renderer makes the full-scan facet skip `thin`/`variantsIdentical`
+ * entirely, so its `{ thin: [], variantsIdentical: [] }` would otherwise be
+ * indistinguishable from a genuinely clean kit — neither an operator nor the
+ * model consuming `validate` could tell the checks were skipped for an
+ * environment reason rather than a real "nothing wrong" result. Both
+ * degradation paths below (import-missing, launch-failure) emit a structured
+ * stderr line via the same `logStderr` (`llm/component-response.ts`) `refine.ts`
+ * uses for its own region-cropper degradation — stderr, never stdout, since
+ * stdout is the stdio transport's JSON-RPC framing.
+ *
+ * ── Bare-fragment previews render in quirks mode — measure children, not body ──
+ * A genie `<Name>.html` preview is a bare fragment: `<!-- @genie … -->`
+ * followed directly by markup, with NO `<!DOCTYPE html>`/`<html>`/`<body>`
+ * wrapper (confirmed against `validate/marker.test.ts`'s own fixtures and
+ * `refine.test.ts`'s component fixtures). Loaded via `page.setContent`, that
+ * makes the page quirks-mode, where `document.body` stretches to fill the
+ * viewport regardless of content (`document.body.scrollHeight` reports the
+ * VIEWPORT height, not the content's real extent — verified empirically).
+ * `measureContentHeight` instead unions the bounding boxes of `body`'s direct
+ * children (skipping any zero-area element, e.g. a `display:none` node) —
+ * this reports the actual rendered content extent independent of quirks-mode
+ * body stretching, and needs no synthetic doctype/wrapper injection that
+ * could itself perturb the very layout AC4 is trying to measure.
+ */
+import { logStderr } from "../llm/component-response.js";
+/** Load Playwright at runtime, or `null` if it is not installed / its OS-level
+ * dependencies are missing. The non-literal specifier keeps `tsc` from trying
+ * to resolve types for it at build time (mirrors `refine.ts`'s
+ * `importPlaywright`, kept as a separate copy here rather than a shared
+ * export — the two call sites have no other coupling, and duplicating one
+ * seven-line try/catch is cheaper than introducing a cross-tool dependency
+ * for it). */
+async function importPlaywright() {
+    const specifier = "playwright";
+    try {
+        return (await import(specifier));
+    }
+    catch (error) {
+        // Logged (not silent, PR #152 review) — see the module doc's "Degradation
+        // is logged, not silent" section for why an operator/model needs this
+        // signal. Same event-naming convention as `refine.ts`'s own
+        // `refine.region.unavailable` for the identical Playwright-absent case.
+        logStderr({
+            event: "validate.render.unavailable",
+            reason: "playwright-not-installed",
+            error: String(error),
+        });
+        return null;
+    }
+}
+/**
+ * The script `measureContentHeight` evaluates in-page (AC4). Returns the union
+ * bounding-box height of `document.body`'s direct children, skipping any
+ * zero-area element (`display:none`, a collapsed empty node, …) — see the
+ * module doc for why this measures real content instead of quirks-mode body
+ * stretch. A `<Name>.html` with literally no rendered content (a marker line
+ * with nothing after it) correctly yields `0`.
+ */
+const MEASURE_CONTENT_HEIGHT_SCRIPT = `(() => {
+  const children = Array.from(document.body.children);
+  if (children.length === 0) return 0;
+  let top = Infinity;
+  let bottom = -Infinity;
+  for (const el of children) {
+    const rect = el.getBoundingClientRect();
+    if (rect.width === 0 && rect.height === 0) continue;
+    top = Math.min(top, rect.top);
+    bottom = Math.max(bottom, rect.bottom);
+  }
+  if (!isFinite(top)) return 0;
+  return bottom - top;
+})()`;
+/**
+ * Create the default (production) {@link Renderer}: one headless Chromium
+ * instance (via lazy Playwright), reused across every `render()` call until
+ * `close()`. Returns `null` when Playwright cannot be loaded — the caller
+ * (`full-scan.ts`) degrades AC4/AC5 gracefully rather than failing the whole
+ * `validate` call over an environment gap (same posture as `refine.ts`'s AC7
+ * region crop).
+ */
+export async function createDefaultRenderer() {
+    const pw = await importPlaywright();
+    if (!pw)
+        return null;
+    let browser;
+    try {
+        // `--no-sandbox` so this runs in restricted CI/container environments —
+        // the same flag `refine.ts`'s `defaultRegionCropper` launches with.
+        browser = await pw.chromium.launch({ args: ["--no-sandbox"] });
+    }
+    catch (error) {
+        // A Chromium binary that fails to LAUNCH (missing OS-level shared
+        // libraries, no downloaded browser, …) is the same "can't render" signal
+        // as Playwright not being installed at all — degrade the same way rather
+        // than letting a launch failure crash the whole `validate` call. Logged
+        // (not silent, PR #152 review) — same reasoning as `importPlaywright`'s
+        // catch above.
+        logStderr({
+            event: "validate.render.unavailable",
+            reason: "chromium-launch-failed",
+            error: String(error),
+        });
+        return null;
+    }
+    return {
+        async render(html, viewport) {
+            const page = await browser.newPage({ viewport });
+            try {
+                // `load`, not `networkidle`: an embedded-CSP preview
+                // (`default-src 'none'`) has no network to go idle on — see
+                // `refine.ts`'s identical reasoning for its own `setContent` call.
+                await page.setContent(html, { waitUntil: "load" });
+                const contentHeight = (await page.evaluate(MEASURE_CONTENT_HEIGHT_SCRIPT));
+                const buffer = await page.screenshot({ type: "png" });
+                const { PNG } = await import("pngjs");
+                const png = PNG.sync.read(buffer);
+                return {
+                    contentHeight,
+                    image: { data: new Uint8Array(png.data), width: png.width, height: png.height },
+                };
+            }
+            finally {
+                await page.close();
+            }
+        },
+        async close() {
+            await browser.close();
+        },
+    };
+}
+//# sourceMappingURL=render.js.map

package/dist/validate/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","sourceRoot":"","sources":["../../src/validate/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAqDzD;;;;;;cAMc;AACd,KAAK,UAAU,gBAAgB;IAC7B,MAAM,SAAS,GAAG,YAAY,CAAC;IAC/B,IAAI,CAAC;QACH,OAAO,CAAC,MAAM,MAAM,CAAC,SAAS,CAAC,CAAqB,CAAC;IACvD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,0EAA0E;QAC1E,sEAAsE;QACtE,4DAA4D;QAC5D,wEAAwE;QACxE,SAAS,CAAC;YACR,KAAK,EAAE,6BAA6B;YACpC,MAAM,EAAE,0BAA0B;YAClC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC;SACrB,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,6BAA6B,GAAG;;;;;;;;;;;;;KAajC,CAAC;AAEN;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB;IACzC,MAAM,EAAE,GAAG,MAAM,gBAAgB,EAAE,CAAC;IACpC,IAAI,CAAC,EAAE;QAAE,OAAO,IAAI,CAAC;IAErB,IAAI,OAAkB,CAAC;IACvB,IAAI,CAAC;QACH,wEAAwE;QACxE,oEAAoE;QACpE,OAAO,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;IACjE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,kEAAkE;QAClE,yEAAyE;QACzE,yEAAyE;QACzE,wEAAwE;QACxE,wEAAwE;QACxE,eAAe;QACf,SAAS,CAAC;YACR,KAAK,EAAE,6BAA6B;YACpC,MAAM,EAAE,wBAAwB;YAChC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC;SACrB,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ;YACzB,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;YACjD,IAAI,CAAC;gBACH,qDAAqD;gBACrD,4DAA4D;gBAC5D,mEAAmE;gBACnE,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;gBACnD,MAAM,aAAa,GAAG,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,6BAA6B,CAAC,CAAW,CAAC;gBACrF,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;gBACtD,MAAM,EAAE,GAAG,EAAE,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,CAAC;gBACtC,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAClC,OAAO;oBACL,aAAa;oBACb,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE;iBAChF,CAAC;YACJ,CAAC;oBAAS,CAAC;gBACT,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;YACrB,CAAC;QACH,CAAC;QACD,KAAK,CAAC,KAAK;YACT,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC;QACxB,CAAC;KACF,CAAC;AACJ,CAAC"}