@testivai/witness 1.0.1 → 1.0.3

package/dist/diff/diff.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * TestivAI Diff Engine — Core comparison loop
+ *
+ * Originally forked from pixel-buffer-diff (Pbd) by @p01, licensed under MIT.
+ * https://github.com/p01/pixel-buffer-diff
+ *
+ * The core pixel comparison algorithm is preserved exactly.
+ * Extended with: ignore regions, size mismatch handling, region detection,
+ * and enriched DiffResult.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diff = diff;
+const ignore_1 = require("./ignore");
+const resize_1 = require("./resize");
+const regions_1 = require("./regions");
+const minimap_1 = require("./minimap");
+// ── Pbd constants (unchanged) ───────────────────────────────────────────────
+const MINIMAP_SCALE = 128;
+const COLOR32_ADDED = 0x03f00cc00;
+const COLOR32_REMOVED = 0x03f0000ff;
+const COLOR32_MINIMAP = 0x0207f0000;
+const HASH_SPREAD = 0x0f0731337;
+// ── Default options ─────────────────────────────────────────────────────────
+const DEFAULT_OPTIONS = {
+    threshold: 0.1,
+    cumulatedThreshold: 0.5,
+    enableMinimap: false,
+    detectRegions: false,
+};
+/**
+ * Compare two pixel buffers and produce a diff image.
+ *
+ * Drop-in compatible with pixelmatch when called as:
+ *   diff(img1, img2, output, w, h) → returns DiffResult
+ *
+ * @param baseline8  - Baseline image pixel data (RGBA, 4 bytes per pixel)
+ * @param candidate8 - Candidate image pixel data (RGBA, 4 bytes per pixel)
+ * @param diff8      - Output buffer for the diff image (same size as inputs)
+ * @param width      - Width of the images in pixels
+ * @param height     - Height of the images in pixels
+ * @param options    - Comparison options
+ * @returns DiffResult with counts, percentages, and optional regions
+ */
+function diff(baseline8, candidate8, diff8, width, height, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    // ── Size mismatch handling ──────────────────────────────────────────────
+    let sizeMismatch;
+    let effectiveWidth = width;
+    let effectiveHeight = height;
+    let effectiveBaseline = baseline8;
+    let effectiveCandidate = candidate8;
+    // If caller provided handleSizeMismatch and dimensions were embedded,
+    // we need external width/height per buffer. For the simple API the caller
+    // is expected to have already normalized — but we expose normalizeDimensions
+    // as a public utility. Here we just validate.
+    const expectedLen = width * height * 4;
+    if (baseline8.length !== expectedLen || candidate8.length !== expectedLen) {
+        if (opts.handleSizeMismatch) {
+            // Infer baseline dimensions from baseline8.length and supplied width
+            const baselineHeight = baseline8.length / (width * 4);
+            const candidateHeight = candidate8.length / (width * 4);
+            // If widths differ, we need both dimensions — use normalizeDimensions
+            const bw = width;
+            const bh = Math.round(baselineHeight);
+            const cw = width;
+            const ch = Math.round(candidateHeight);
+            const normalized = (0, resize_1.normalizeDimensions)(baseline8, bw, bh, candidate8, cw, ch, opts.handleSizeMismatch);
+            effectiveBaseline = normalized.normalizedBaseline;
+            effectiveCandidate = normalized.normalizedCandidate;
+            effectiveWidth = normalized.width;
+            effectiveHeight = normalized.height;
+            sizeMismatch = normalized.sizeMismatch;
+            // Re-create diff buffer if size changed
+            if (diff8.length !== effectiveWidth * effectiveHeight * 4) {
+                diff8 = new Uint8ClampedArray(effectiveWidth * effectiveHeight * 4);
+            }
+        }
+        else {
+            throw new Error(`Buffer size mismatch: expected ${expectedLen} bytes (${width}×${height}×4), ` +
+                `got baseline=${baseline8.length}, candidate=${candidate8.length}. ` +
+                `Set handleSizeMismatch option to 'pad', 'crop', or 'error'.`);
+        }
+    }
+    // ── Ignore regions ──────────────────────────────────────────────────────
+    if (opts.ignoreRegions && opts.ignoreRegions.length > 0) {
+        // Clone buffers so we don't mutate originals
+        effectiveBaseline = new Uint8ClampedArray(effectiveBaseline);
+        effectiveCandidate = new Uint8ClampedArray(effectiveCandidate);
+        (0, ignore_1.applyIgnoreRegions)(effectiveBaseline, effectiveCandidate, effectiveWidth, effectiveHeight, opts.ignoreRegions);
+    }
+    // ── Core Pbd diff loop (basic mode — pixel-level YIQ comparison) ──────
+    const raw = pbdDiffCore(effectiveBaseline, effectiveCandidate, diff8, effectiveWidth, effectiveHeight, opts.threshold, opts.cumulatedThreshold, opts.enableMinimap);
+    // ── Compute extended result ─────────────────────────────────────────────
+    const totalPixels = effectiveWidth * effectiveHeight;
+    const diffPercent = totalPixels > 0 ? (raw.diff / totalPixels) * 100 : 0;
+    const isIdentical = raw.diff === 0;
+    const result = {
+        diffCount: raw.diff,
+        cumulatedDiff: raw.cumulatedDiff,
+        hash: raw.hash,
+        diffPercent,
+        totalPixels,
+        isIdentical,
+    };
+    if (sizeMismatch) {
+        result.sizeMismatch = sizeMismatch;
+    }
+    // ── Region detection ────────────────────────────────────────────────────
+    if (opts.detectRegions && !isIdentical) {
+        result.regions = (0, regions_1.detectRegions)(diff8, effectiveWidth, effectiveHeight);
+    }
+    return result;
+}
+/**
+ * Core Pbd diff loop — pixel-level YIQ comparison.
+ * Algorithm is preserved exactly from pixel-buffer-diff.
+ * @internal
+ */
+function pbdDiffCore(baseline8, candidate8, diff8, width, height, threshold, cumulatedThreshold, enableMinimap) {
+    const area = width * height;
+    const b8l = baseline8.length;
+    // Maximum acceptable square distance between two colors;
+    // 35215 is the maximum possible value for the YIQ difference metric
+    const deltaThreshold = threshold * threshold * 35215;
+    // Use ArrayBuffer views for 32-bit access
+    const bBuffer = baseline8.buffer;
+    const bOffset = baseline8.byteOffset;
+    const cBuffer = candidate8.buffer;
+    const cOffset = candidate8.byteOffset;
+    const dBuffer = diff8.buffer;
+    const dOffset = diff8.byteOffset;
+    const baseline32 = new Uint32Array(bBuffer, bOffset, area);
+    const candidate32 = new Uint32Array(cBuffer, cOffset, area);
+    const diff32 = new Uint32Array(dBuffer, dOffset, area);
+    let b8i = 0;
+    let b32i = 0;
+    let d32i = 0;
+    let diffCount = 0;
+    let hash = 0;
+    let hashStart = 0;
+    let cumulatedDiff = 0;
+    // Quick approx of color theme to figure if "new" pixels should be dark or light
+    let averageBrightness = 0;
+    const brightnessSamples = Math.ceil(Math.sqrt(area) / 128);
+    const b8iStep = (b8l / brightnessSamples) & -4;
+    let sampleIdx = 0;
+    for (let i = 0; i < brightnessSamples; i++) {
+        averageBrightness +=
+            (0.299 * (baseline8[sampleIdx] + candidate8[sampleIdx]) +
+                0.587 * (baseline8[sampleIdx + 1] + candidate8[sampleIdx + 1]) +
+                0.114 * (baseline8[sampleIdx + 2] + candidate8[sampleIdx + 2])) /
+                brightnessSamples /
+                2;
+        sampleIdx += b8iStep;
+    }
+    const isDarkTheme = averageBrightness < 128;
+    const color32Added = isDarkTheme ? COLOR32_ADDED : COLOR32_REMOVED;
+    const color32Removed = isDarkTheme ? COLOR32_REMOVED : COLOR32_ADDED;
+    // Minimap tracking
+    const miniHeight = Math.ceil(height / MINIMAP_SCALE);
+    const miniWidth = Math.ceil(width / MINIMAP_SCALE);
+    const miniMap = new Uint8ClampedArray(miniWidth * miniHeight);
+    const maxDimension = Math.max(width, height);
+    const maxMiniDimension = Math.max(miniWidth, miniHeight);
+    const axisMiniIndex = new Uint32Array(maxDimension);
+    let miniIndex = 0;
+    for (let i = 0; i < maxMiniDimension; i++) {
+        axisMiniIndex.fill(i, miniIndex, Math.min(miniIndex + MINIMAP_SCALE, maxDimension));
+        miniIndex += MINIMAP_SCALE;
+    }
+    // ── Per-pixel comparison ────────────────────────────────────────────────
+    for (let y = 0; y < height; y++) {
+        const miniIndexY = axisMiniIndex[y] * miniWidth;
+        let hashIndex = (y ^ HASH_SPREAD) * HASH_SPREAD;
+        for (let x = 0; x < width; x++, d32i++, b32i++, b8i += 4, hashIndex++) {
+            // Quick check against the Uint32
+            if (baseline32[b32i] === candidate32[b32i]) {
+                continue;
+            }
+            // Get the r,g,b -> y,i,q => YIQ square delta
+            const dr = candidate8[b8i] - baseline8[b8i];
+            const dg = candidate8[b8i + 1] - baseline8[b8i + 1];
+            const db = candidate8[b8i + 2] - baseline8[b8i + 2];
+            const dy = dr * 0.29889531 + dg * 0.58662247 + db * 0.11448223;
+            const di = dr * 0.59597799 - dg * 0.27417610 - db * 0.32180189;
+            const dq = dr * 0.21147017 - dg * 0.52261711 + db * 0.31114694;
+            const delta = dy * dy * 0.5053 + di * di * 0.299 + dq * dq * 0.1957;
+            if (delta > deltaThreshold) {
+                miniMap[miniIndexY + axisMiniIndex[x]]++;
+                diffCount++;
+                const dyAbs = Math.abs(dy);
+                cumulatedDiff += dyAbs;
+                diff32[d32i] =
+                    (dy > 0 ? color32Added : color32Removed) +
+                        (Math.min(192, dyAbs * 8) << 24);
+                if (hash === 0) {
+                    hashStart = hashIndex;
+                }
+                hash += hashIndex;
+            }
+        }
+    }
+    hash -= hashStart;
+    cumulatedDiff /= 256;
+    // Apply minimap overlay
+    if (enableMinimap) {
+        (0, minimap_1.applyMinimap)(diff32, miniMap, miniWidth, miniHeight, width, height, MINIMAP_SCALE, COLOR32_MINIMAP);
+    }
+    // If cumulated diff is within threshold, treat as identical
+    if (cumulatedDiff <= cumulatedThreshold) {
+        return { diff: 0, cumulatedDiff: 0, hash: 0 };
+    }
+    return { diff: diffCount, cumulatedDiff, hash };
+}
+//# sourceMappingURL=diff.js.map

package/dist/diff/diff.js.map

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

package/dist/diff/dom-diff.d.ts

@@ -0,0 +1,85 @@
+/**
+ * TestivAI DOM Diff — lightweight noise-hint comparison
+ *
+ * Compares two HTML strings (typically `document.documentElement.outerHTML`
+ * captured at snapshot time) and returns a small structural-change summary.
+ *
+ * This is intentionally NOT a full DOM tree differ — those bring 30 KB+ of
+ * dependencies and complex semantics we don't need. The job here is to
+ * answer one question per snapshot:
+ *
+ *   "When pixels differ, is the underlying DOM also different?"
+ *
+ * If pixels differ but DOM is unchanged, the difference is almost certainly
+ * render noise (font rendering, anti-aliasing, sub-pixel layout). The HTML
+ * report uses this as a noise hint.
+ *
+ * Approach (zero-dep, ~120 LOC of tokenizer):
+ *   1. Stream-tokenize each HTML into a flat list of open events
+ *      (`{ tag, attrs: Record<string, string> }`).
+ *   2. Compare via multiset operations:
+ *        - tags only in candidate → added
+ *        - tags only in baseline  → removed
+ *        - same tag pairs that differ in attributes → attributeChanges
+ *
+ * Tradeoffs:
+ *   - We treat element ORDER as soft. Two pages with the same elements in
+ *     a different order register as zero diff in tag counts but may show up
+ *     as attribute changes if reordering changes attributes (uncommon).
+ *     This is acceptable because the SAME page captured twice should
+ *     normally produce identical token lists.
+ *   - Text content is ignored. Visual regression on text wording is what
+ *     pixels are for — we don't want to flag every dynamic timestamp.
+ *   - Comments and processing instructions are ignored.
+ *
+ * Self-closing void elements per HTML spec are handled.
+ */
+/** Result of a DOM diff comparison. */
+export interface DomDiffResult {
+    /** True if the two HTML strings are structurally different. */
+    domChanged: boolean;
+    /** Per-bucket counts; null when domChanged is false. */
+    summary: DomDiffSummary | null;
+}
+export interface DomDiffSummary {
+    /** Tag occurrences present in candidate but not baseline. */
+    added: number;
+    /** Tag occurrences present in baseline but not candidate. */
+    removed: number;
+    /** Tag pairs present in both but with different attributes. */
+    attributeChanges: number;
+}
+interface OpenEvent {
+    tag: string;
+    /** Attributes serialized as `key=value` pairs, sorted, joined by '\0'. */
+    attrSig: string;
+}
+/**
+ * Compare two HTML strings.
+ *
+ * Returns `{ domChanged: false, summary: null }` for fast paths:
+ *   - Both inputs identical bytes
+ *   - Both inputs missing/empty (e.g., DOM capture wasn't enabled)
+ *
+ * Otherwise tokenizes both and produces a summary.
+ */
+export declare function domDiff(baselineHtml: string | null | undefined, candidateHtml: string | null | undefined): DomDiffResult;
+/**
+ * Stream-tokenize HTML into open events.
+ *
+ * Skips: doctype, comments, processing instructions, CDATA, text nodes,
+ * script/style content (handled as opaque). Close tags are dropped.
+ *
+ * Robust against malformed HTML — we never throw; on weird input we
+ * just stop emitting events. Worst case = false "no DOM signal".
+ */
+declare function tokenize(html: string): OpenEvent[];
+/**
+ * Internal export only used in tests; exposes the tokenizer for white-box
+ * verification. Not part of the package public API.
+ */
+export declare const __internals__: {
+    tokenize: typeof tokenize;
+};
+export {};
+//# sourceMappingURL=dom-diff.d.ts.map

package/dist/diff/dom-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom-diff.d.ts","sourceRoot":"","sources":["../../src/diff/dom-diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAOH,uCAAuC;AACvC,MAAM,WAAW,aAAa;IAC5B,+DAA+D;IAC/D,UAAU,EAAE,OAAO,CAAC;IACpB,wDAAwD;IACxD,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,cAAc;IAC7B,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,UAAU,SAAS;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,aAAa,CAyDxH;AAuBD;;;;;;;;GAQG;AACH,iBAAS,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,CAwE3C;AAsFD;;;GAGG;AACH,eAAO,MAAM,aAAa;;CAAe,CAAC"}

package/dist/diff/dom-diff.js

@@ -0,0 +1,291 @@
+"use strict";
+/**
+ * TestivAI DOM Diff — lightweight noise-hint comparison
+ *
+ * Compares two HTML strings (typically `document.documentElement.outerHTML`
+ * captured at snapshot time) and returns a small structural-change summary.
+ *
+ * This is intentionally NOT a full DOM tree differ — those bring 30 KB+ of
+ * dependencies and complex semantics we don't need. The job here is to
+ * answer one question per snapshot:
+ *
+ *   "When pixels differ, is the underlying DOM also different?"
+ *
+ * If pixels differ but DOM is unchanged, the difference is almost certainly
+ * render noise (font rendering, anti-aliasing, sub-pixel layout). The HTML
+ * report uses this as a noise hint.
+ *
+ * Approach (zero-dep, ~120 LOC of tokenizer):
+ *   1. Stream-tokenize each HTML into a flat list of open events
+ *      (`{ tag, attrs: Record<string, string> }`).
+ *   2. Compare via multiset operations:
+ *        - tags only in candidate → added
+ *        - tags only in baseline  → removed
+ *        - same tag pairs that differ in attributes → attributeChanges
+ *
+ * Tradeoffs:
+ *   - We treat element ORDER as soft. Two pages with the same elements in
+ *     a different order register as zero diff in tag counts but may show up
+ *     as attribute changes if reordering changes attributes (uncommon).
+ *     This is acceptable because the SAME page captured twice should
+ *     normally produce identical token lists.
+ *   - Text content is ignored. Visual regression on text wording is what
+ *     pixels are for — we don't want to flag every dynamic timestamp.
+ *   - Comments and processing instructions are ignored.
+ *
+ * Self-closing void elements per HTML spec are handled.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__internals__ = void 0;
+exports.domDiff = domDiff;
+const VOID_ELEMENTS = new Set([
+    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+    'link', 'meta', 'param', 'source', 'track', 'wbr',
+]);
+/**
+ * Compare two HTML strings.
+ *
+ * Returns `{ domChanged: false, summary: null }` for fast paths:
+ *   - Both inputs identical bytes
+ *   - Both inputs missing/empty (e.g., DOM capture wasn't enabled)
+ *
+ * Otherwise tokenizes both and produces a summary.
+ */
+function domDiff(baselineHtml, candidateHtml) {
+    // Fast path: missing data on either side → no signal
+    if (!baselineHtml || !candidateHtml) {
+        return { domChanged: false, summary: null };
+    }
+    // Fast path: byte-identical
+    if (baselineHtml === candidateHtml) {
+        return { domChanged: false, summary: null };
+    }
+    const baselineEvents = tokenize(baselineHtml);
+    const candidateEvents = tokenize(candidateHtml);
+    // Bucket by tag name; within each bucket, count attrSig multisets
+    const baselineBuckets = bucketize(baselineEvents);
+    const candidateBuckets = bucketize(candidateEvents);
+    let added = 0;
+    let removed = 0;
+    let attributeChanges = 0;
+    const allTags = new Set([...baselineBuckets.keys(), ...candidateBuckets.keys()]);
+    for (const tag of allTags) {
+        const baselineForTag = baselineBuckets.get(tag) ?? new Map();
+        const candidateForTag = candidateBuckets.get(tag) ?? new Map();
+        const baselineCount = sumValues(baselineForTag);
+        const candidateCount = sumValues(candidateForTag);
+        if (candidateCount > baselineCount) {
+            added += candidateCount - baselineCount;
+        }
+        else if (baselineCount > candidateCount) {
+            removed += baselineCount - candidateCount;
+        }
+        // Attribute changes = matching tag pairs whose attrSig differs.
+        // We compute by intersecting the two attrSig multisets and counting
+        // anything that doesn't match. Each unmatched-but-paired pair counts
+        // once toward attributeChanges; raw added/removed of the tag itself
+        // is already counted above, so we subtract that delta.
+        const overlap = Math.min(baselineCount, candidateCount);
+        let matchingPairs = 0;
+        for (const [sig, candCount] of candidateForTag) {
+            const baseCount = baselineForTag.get(sig) ?? 0;
+            matchingPairs += Math.min(baseCount, candCount);
+        }
+        attributeChanges += overlap - matchingPairs;
+    }
+    const domChanged = added > 0 || removed > 0 || attributeChanges > 0;
+    return {
+        domChanged,
+        summary: domChanged ? { added, removed, attributeChanges } : null,
+    };
+}
+// ── internals ──────────────────────────────────────────────────────────────
+function bucketize(events) {
+    const buckets = new Map();
+    for (const ev of events) {
+        let inner = buckets.get(ev.tag);
+        if (!inner) {
+            inner = new Map();
+            buckets.set(ev.tag, inner);
+        }
+        inner.set(ev.attrSig, (inner.get(ev.attrSig) ?? 0) + 1);
+    }
+    return buckets;
+}
+function sumValues(m) {
+    let total = 0;
+    for (const v of m.values())
+        total += v;
+    return total;
+}
+/**
+ * Stream-tokenize HTML into open events.
+ *
+ * Skips: doctype, comments, processing instructions, CDATA, text nodes,
+ * script/style content (handled as opaque). Close tags are dropped.
+ *
+ * Robust against malformed HTML — we never throw; on weird input we
+ * just stop emitting events. Worst case = false "no DOM signal".
+ */
+function tokenize(html) {
+    const events = [];
+    const len = html.length;
+    let i = 0;
+    while (i < len) {
+        // Find next '<'
+        const lt = html.indexOf('<', i);
+        if (lt < 0)
+            break;
+        i = lt + 1;
+        if (i >= len)
+            break;
+        const c = html[i];
+        // Comment <!-- ... -->
+        if (c === '!' && html.startsWith('!--', i)) {
+            const end = html.indexOf('-->', i + 3);
+            if (end < 0)
+                break;
+            i = end + 3;
+            continue;
+        }
+        // Doctype <!doctype ...>
+        if (c === '!') {
+            const end = html.indexOf('>', i + 1);
+            if (end < 0)
+                break;
+            i = end + 1;
+            continue;
+        }
+        // CDATA <![CDATA[ ... ]]>  (rare in HTML; skip)
+        // Already handled by the c === '!' branch above.
+        // Processing instruction <? ... ?>
+        if (c === '?') {
+            const end = html.indexOf('?>', i + 1);
+            if (end < 0)
+                break;
+            i = end + 2;
+            continue;
+        }
+        // Close tag </tagname>
+        if (c === '/') {
+            const end = html.indexOf('>', i + 1);
+            if (end < 0)
+                break;
+            i = end + 1;
+            continue;
+        }
+        // Open tag <tagname ...>
+        const tagEnd = findTagEnd(html, i);
+        if (tagEnd < 0)
+            break;
+        const raw = html.slice(i, tagEnd);
+        const ev = parseOpenTag(raw);
+        if (ev) {
+            events.push(ev);
+            // For script/style, skip body opaquely until matching close
+            if (ev.tag === 'script' || ev.tag === 'style') {
+                const closeNeedle = `</${ev.tag}`;
+                const closeIdx = indexOfCaseInsensitive(html, closeNeedle, tagEnd + 1);
+                if (closeIdx < 0)
+                    break;
+                const gtAfter = html.indexOf('>', closeIdx);
+                i = gtAfter < 0 ? len : gtAfter + 1;
+                continue;
+            }
+        }
+        i = tagEnd + 1;
+    }
+    return events;
+}
+/**
+ * Find the index of '>' that closes the open tag starting at `start`,
+ * handling quoted attribute values which may contain '>'.
+ */
+function findTagEnd(html, start) {
+    let i = start;
+    let inQuote = null;
+    const len = html.length;
+    while (i < len) {
+        const c = html[i];
+        if (inQuote) {
+            if (c === inQuote)
+                inQuote = null;
+        }
+        else {
+            if (c === '"' || c === "'")
+                inQuote = c;
+            else if (c === '>')
+                return i;
+        }
+        i++;
+    }
+    return -1;
+}
+/**
+ * Parse the raw inside of a `<...>` (excluding the angle brackets) into
+ * an OpenEvent. Returns null for the empty / malformed case.
+ */
+function parseOpenTag(raw) {
+    // Strip trailing '/' for self-closing forms <br/>
+    const trimmed = raw.trim().replace(/\/$/, '').trim();
+    if (!trimmed)
+        return null;
+    // First whitespace-or-end → tag name
+    const m = /^([a-zA-Z][a-zA-Z0-9-]*)/.exec(trimmed);
+    if (!m)
+        return null;
+    const tag = m[1].toLowerCase();
+    let rest = trimmed.slice(m[0].length).trim();
+    const attrs = {};
+    while (rest.length > 0) {
+        const am = /^([a-zA-Z_:][a-zA-Z0-9_:.-]*)/.exec(rest);
+        if (!am)
+            break;
+        const name = am[1].toLowerCase();
+        rest = rest.slice(am[0].length);
+        let value = '';
+        if (rest.startsWith('=')) {
+            rest = rest.slice(1).trimStart();
+            if (rest.startsWith('"') || rest.startsWith("'")) {
+                const quote = rest[0];
+                const end = rest.indexOf(quote, 1);
+                if (end < 0)
+                    break;
+                value = rest.slice(1, end);
+                rest = rest.slice(end + 1);
+            }
+            else {
+                const ws = rest.search(/\s/);
+                if (ws < 0) {
+                    value = rest;
+                    rest = '';
+                }
+                else {
+                    value = rest.slice(0, ws);
+                    rest = rest.slice(ws);
+                }
+            }
+        }
+        attrs[name] = value;
+        rest = rest.trimStart();
+    }
+    // Build a stable, sorted attribute signature.
+    // Some attributes are inherently dynamic (id like 'react-aria-:r1:'); we
+    // don't try to be smart about that here — the signature is stable across
+    // identical pages but flags any attr-value drift.
+    const keys = Object.keys(attrs).sort();
+    const attrSig = keys.map((k) => `${k}=${attrs[k]}`).join('\0');
+    return { tag, attrSig };
+}
+function indexOfCaseInsensitive(haystack, needle, fromIndex) {
+    // Cheap case-insensitive search; needle is short ('</script' or '</style')
+    const h = haystack.toLowerCase();
+    const n = needle.toLowerCase();
+    return h.indexOf(n, fromIndex);
+}
+/**
+ * Internal export only used in tests; exposes the tokenizer for white-box
+ * verification. Not part of the package public API.
+ */
+exports.__internals__ = { tokenize };
+//# sourceMappingURL=dom-diff.js.map

package/dist/diff/dom-diff.js.map

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

package/dist/diff/ignore.d.ts

@@ -0,0 +1,22 @@
+/**
+ * TestivAI Diff Engine — Ignore regions
+ *
+ * Before the diff loop runs, copy candidate pixel values into the
+ * baseline buffer for ignored regions. This makes ignored areas
+ * appear identical to the differ.
+ */
+import { IgnoreRegion } from './types';
+/**
+ * Mask ignored regions by copying candidate pixels into baseline.
+ * After this, the diff loop will see no difference in those areas.
+ *
+ * Mutates `baseline` in place.
+ *
+ * @param baseline - Baseline pixel buffer (will be mutated)
+ * @param candidate - Candidate pixel buffer
+ * @param width - Image width
+ * @param height - Image height
+ * @param regions - Regions to ignore
+ */
+export declare function applyIgnoreRegions(baseline: Uint8Array | Uint8ClampedArray, candidate: Uint8Array | Uint8ClampedArray, width: number, height: number, regions: IgnoreRegion[]): void;
+//# sourceMappingURL=ignore.d.ts.map

package/dist/diff/ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignore.d.ts","sourceRoot":"","sources":["../../src/diff/ignore.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,UAAU,GAAG,iBAAiB,EACxC,SAAS,EAAE,UAAU,GAAG,iBAAiB,EACzC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,YAAY,EAAE,GACtB,IAAI,CAoBN"}