@testivai/witness 1.0.1 → 1.0.2

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/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"}

package/dist/diff/ignore.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyIgnoreRegions = applyIgnoreRegions;
+/**
+ * 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
+ */
+function applyIgnoreRegions(baseline, candidate, width, height, regions) {
+    for (const region of regions) {
+        // Clamp to image bounds
+        const x0 = Math.max(0, Math.min(region.x, width));
+        const y0 = Math.max(0, Math.min(region.y, height));
+        const x1 = Math.max(0, Math.min(region.x + region.width, width));
+        const y1 = Math.max(0, Math.min(region.y + region.height, height));
+        for (let y = y0; y < y1; y++) {
+            const rowOffset = y * width * 4;
+            for (let x = x0; x < x1; x++) {
+                const pixelOffset = rowOffset + x * 4;
+                // Copy RGBA from candidate to baseline
+                baseline[pixelOffset] = candidate[pixelOffset];
+                baseline[pixelOffset + 1] = candidate[pixelOffset + 1];
+                baseline[pixelOffset + 2] = candidate[pixelOffset + 2];
+                baseline[pixelOffset + 3] = candidate[pixelOffset + 3];
+            }
+        }
+    }
+}
+//# sourceMappingURL=ignore.js.map

package/dist/diff/ignore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignore.js","sourceRoot":"","sources":["../../src/diff/ignore.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AAgBH,gDA0BC;AAtCD;;;;;;;;;;;GAWG;AACH,SAAgB,kBAAkB,CAChC,QAAwC,EACxC,SAAyC,EACzC,KAAa,EACb,MAAc,EACd,OAAuB;IAEvB,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,wBAAwB;QACxB,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;QAClD,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;QACnD,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;QACjE,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QAEnE,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7B,MAAM,SAAS,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC;YAChC,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC7B,MAAM,WAAW,GAAG,SAAS,GAAG,CAAC,GAAG,CAAC,CAAC;gBACtC,uCAAuC;gBACvC,QAAQ,CAAC,WAAW,CAAC,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC;gBAC/C,QAAQ,CAAC,WAAW,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;gBACvD,QAAQ,CAAC,WAAW,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;gBACvD,QAAQ,CAAC,WAAW,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;YACzD,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/diff/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * TestivAI Diff Engine
+ *
+ * Pixel-level visual comparison engine forked from pixel-buffer-diff (Pbd)
+ * by @p01 (MIT license). Extended with ignore regions, size mismatch
+ * handling, region detection, and TypeScript support.
+ *
+ * @see https://github.com/p01/pixel-buffer-diff
+ */
+export { diff } from './diff';
+export { applyIgnoreRegions } from './ignore';
+export { applyMinimap } from './minimap';
+export { normalizeDimensions } from './resize';
+export { detectRegions } from './regions';
+export type { DiffOptions, DiffResult, DiffRegion, IgnoreRegion, SizeMismatch, PbdRawResult, } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/diff/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,YAAY,EACV,WAAW,EACX,UAAU,EACV,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,YAAY,GACb,MAAM,SAAS,CAAC"}

package/dist/diff/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * TestivAI Diff Engine
+ *
+ * Pixel-level visual comparison engine forked from pixel-buffer-diff (Pbd)
+ * by @p01 (MIT license). Extended with ignore regions, size mismatch
+ * handling, region detection, and TypeScript support.
+ *
+ * @see https://github.com/p01/pixel-buffer-diff
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectRegions = exports.normalizeDimensions = exports.applyMinimap = exports.applyIgnoreRegions = exports.diff = void 0;
+var diff_1 = require("./diff");
+Object.defineProperty(exports, "diff", { enumerable: true, get: function () { return diff_1.diff; } });
+var ignore_1 = require("./ignore");
+Object.defineProperty(exports, "applyIgnoreRegions", { enumerable: true, get: function () { return ignore_1.applyIgnoreRegions; } });
+var minimap_1 = require("./minimap");
+Object.defineProperty(exports, "applyMinimap", { enumerable: true, get: function () { return minimap_1.applyMinimap; } });
+var resize_1 = require("./resize");
+Object.defineProperty(exports, "normalizeDimensions", { enumerable: true, get: function () { return resize_1.normalizeDimensions; } });
+var regions_1 = require("./regions");
+Object.defineProperty(exports, "detectRegions", { enumerable: true, get: function () { return regions_1.detectRegions; } });
+//# sourceMappingURL=index.js.map

package/dist/diff/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/diff/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAEH,+BAA8B;AAArB,4FAAA,IAAI,OAAA;AACb,mCAA8C;AAArC,4GAAA,kBAAkB,OAAA;AAC3B,qCAAyC;AAAhC,uGAAA,YAAY,OAAA;AACrB,mCAA+C;AAAtC,6GAAA,mBAAmB,OAAA;AAC5B,qCAA0C;AAAjC,wGAAA,aAAa,OAAA"}

package/dist/diff/minimap.d.ts

@@ -0,0 +1,23 @@
+/**
+ * TestivAI Diff Engine — Minimap overlay
+ *
+ * Applies a low-resolution overlay on the diff buffer to help
+ * spot isolated pixel changes at a glance.
+ *
+ * Ported from pixel-buffer-diff by @p01, licensed under MIT.
+ */
+/**
+ * Apply minimap overlay to the diff buffer.
+ * Regions with any changed pixels get a colored tint.
+ *
+ * @param diff32     - Diff image as Uint32Array
+ * @param miniMap    - Minimap cell hit counts
+ * @param miniWidth  - Number of minimap columns
+ * @param miniHeight - Number of minimap rows
+ * @param width      - Full image width
+ * @param height     - Full image height
+ * @param scale      - Pixels per minimap cell (e.g. 128)
+ * @param color      - 32-bit ABGR color to OR into diff pixels
+ */
+export declare function applyMinimap(diff32: Uint32Array, miniMap: Uint8ClampedArray, miniWidth: number, miniHeight: number, width: number, height: number, scale: number, color: number): void;
+//# sourceMappingURL=minimap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"minimap.d.ts","sourceRoot":"","sources":["../../src/diff/minimap.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,iBAAiB,EAC1B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,IAAI,CAkBN"}

package/dist/diff/minimap.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * TestivAI Diff Engine — Minimap overlay
+ *
+ * Applies a low-resolution overlay on the diff buffer to help
+ * spot isolated pixel changes at a glance.
+ *
+ * Ported from pixel-buffer-diff by @p01, licensed under MIT.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyMinimap = applyMinimap;
+/**
+ * Apply minimap overlay to the diff buffer.
+ * Regions with any changed pixels get a colored tint.
+ *
+ * @param diff32     - Diff image as Uint32Array
+ * @param miniMap    - Minimap cell hit counts
+ * @param miniWidth  - Number of minimap columns
+ * @param miniHeight - Number of minimap rows
+ * @param width      - Full image width
+ * @param height     - Full image height
+ * @param scale      - Pixels per minimap cell (e.g. 128)
+ * @param color      - 32-bit ABGR color to OR into diff pixels
+ */
+function applyMinimap(diff32, miniMap, miniWidth, miniHeight, width, height, scale, color) {
+    for (let i = 0; i < miniWidth * miniHeight; i++) {
+        if (miniMap[i] > 0) {
+            const miniX = i % miniWidth;
+            const miniY = (i / miniWidth) | 0;
+            const x0 = miniX * scale;
+            const x1 = Math.min(x0 + scale, width);
+            const y0 = miniY * scale;
+            const y1 = Math.min(y0 + scale, height);
+            for (let y = y0; y < y1; y++) {
+                let d32i = x0 + y * width;
+                for (let x = x0; x < x1; x++) {
+                    diff32[d32i++] |= color;
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=minimap.js.map

package/dist/diff/minimap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimap.js","sourceRoot":"","sources":["../../src/diff/minimap.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;AAeH,oCA2BC;AAxCD;;;;;;;;;;;;GAYG;AACH,SAAgB,YAAY,CAC1B,MAAmB,EACnB,OAA0B,EAC1B,SAAiB,EACjB,UAAkB,EAClB,KAAa,EACb,MAAc,EACd,KAAa,EACb,KAAa;IAEb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,GAAG,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;QAChD,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;YACnB,MAAM,KAAK,GAAG,CAAC,GAAG,SAAS,CAAC;YAC5B,MAAM,KAAK,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;YAClC,MAAM,EAAE,GAAG,KAAK,GAAG,KAAK,CAAC;YACzB,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,KAAK,EAAE,KAAK,CAAC,CAAC;YACvC,MAAM,EAAE,GAAG,KAAK,GAAG,KAAK,CAAC;YACzB,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,KAAK,EAAE,MAAM,CAAC,CAAC;YAExC,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC7B,IAAI,IAAI,GAAG,EAAE,GAAG,CAAC,GAAG,KAAK,CAAC;gBAC1B,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC7B,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,CAAC;gBAC1B,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/diff/regions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * TestivAI Diff Engine — Region bounding box detection
+ *
+ * Scans the diff output buffer for non-zero (changed) pixels
+ * and groups them into rectangular bounding boxes using a simple
+ * connected-component labeling approach.
+ */
+import { DiffRegion } from './types';
+/**
+ * Detect regions of change in the diff buffer.
+ *
+ * Scans for non-transparent pixels (any pixel with alpha > 0 in
+ * the diff output), groups adjacent changed pixels into rectangular
+ * bounding boxes, and filters out regions smaller than minSize.
+ *
+ * @param diff8   - Diff image pixel buffer (RGBA)
+ * @param width   - Image width
+ * @param height  - Image height
+ * @param minSize - Minimum pixels to include a region (default: 10)
+ * @returns Array of DiffRegion bounding boxes
+ */
+export declare function detectRegions(diff8: Uint8Array | Uint8ClampedArray, width: number, height: number, minSize?: number): DiffRegion[];
+//# sourceMappingURL=regions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"regions.d.ts","sourceRoot":"","sources":["../../src/diff/regions.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,UAAU,GAAG,iBAAiB,EACrC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,MAAW,GACnB,UAAU,EAAE,CAkHd"}

package/dist/diff/regions.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * TestivAI Diff Engine — Region bounding box detection
+ *
+ * Scans the diff output buffer for non-zero (changed) pixels
+ * and groups them into rectangular bounding boxes using a simple
+ * connected-component labeling approach.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectRegions = detectRegions;
+/**
+ * Detect regions of change in the diff buffer.
+ *
+ * Scans for non-transparent pixels (any pixel with alpha > 0 in
+ * the diff output), groups adjacent changed pixels into rectangular
+ * bounding boxes, and filters out regions smaller than minSize.
+ *
+ * @param diff8   - Diff image pixel buffer (RGBA)
+ * @param width   - Image width
+ * @param height  - Image height
+ * @param minSize - Minimum pixels to include a region (default: 10)
+ * @returns Array of DiffRegion bounding boxes
+ */
+function detectRegions(diff8, width, height, minSize = 10) {
+    // Build a binary grid: 1 = changed pixel, 0 = unchanged
+    const changed = new Uint8Array(width * height);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const idx = (y * width + x) * 4;
+            // A pixel is considered "changed" if it has any non-zero alpha
+            // in the diff buffer (the diff engine writes colored pixels for changes)
+            if (diff8[idx + 3] > 0) {
+                changed[y * width + x] = 1;
+            }
+        }
+    }
+    // Connected-component labeling using union-find
+    const labels = new Int32Array(width * height).fill(-1);
+    const parent = [];
+    let nextLabel = 0;
+    function find(x) {
+        while (parent[x] !== x) {
+            parent[x] = parent[parent[x]]; // path compression
+            x = parent[x];
+        }
+        return x;
+    }
+    function union(a, b) {
+        const ra = find(a);
+        const rb = find(b);
+        if (ra !== rb) {
+            parent[rb] = ra;
+        }
+    }
+    // First pass: assign labels
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const idx = y * width + x;
+            if (!changed[idx])
+                continue;
+            const neighbors = [];
+            // Check left
+            if (x > 0 && labels[idx - 1] >= 0) {
+                neighbors.push(labels[idx - 1]);
+            }
+            // Check above
+            if (y > 0 && labels[idx - width] >= 0) {
+                neighbors.push(labels[idx - width]);
+            }
+            if (neighbors.length === 0) {
+                // New label
+                labels[idx] = nextLabel;
+                parent.push(nextLabel);
+                nextLabel++;
+            }
+            else {
+                // Use the smallest label
+                const minLabel = Math.min(...neighbors.map(find));
+                labels[idx] = minLabel;
+                // Union all neighbor labels
+                for (const n of neighbors) {
+                    union(minLabel, n);
+                }
+            }
+        }
+    }
+    // Second pass: collect bounding boxes per component
+    const boxes = new Map();
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const idx = y * width + x;
+            if (labels[idx] < 0)
+                continue;
+            const root = find(labels[idx]);
+            const box = boxes.get(root);
+            if (box) {
+                box.x0 = Math.min(box.x0, x);
+                box.y0 = Math.min(box.y0, y);
+                box.x1 = Math.max(box.x1, x);
+                box.y1 = Math.max(box.y1, y);
+                box.count++;
+            }
+            else {
+                boxes.set(root, { x0: x, y0: y, x1: x, y1: y, count: 1 });
+            }
+        }
+    }
+    // Convert to DiffRegion array, filtering by minSize
+    const regions = [];
+    for (const box of boxes.values()) {
+        if (box.count < minSize)
+            continue;
+        const regionWidth = box.x1 - box.x0 + 1;
+        const regionHeight = box.y1 - box.y0 + 1;
+        const regionArea = regionWidth * regionHeight;
+        regions.push({
+            x: box.x0,
+            y: box.y0,
+            width: regionWidth,
+            height: regionHeight,
+            diffPixels: box.count,
+            diffPercent: regionArea > 0 ? (box.count / regionArea) * 100 : 0,
+        });
+    }
+    // Sort by position (top-left first)
+    regions.sort((a, b) => a.y - b.y || a.x - b.x);
+    return regions;
+}
+//# sourceMappingURL=regions.js.map

package/dist/diff/regions.js.map

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

package/dist/diff/resize.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TestivAI Diff Engine — Size mismatch handling
+ *
+ * When baseline and candidate have different dimensions,
+ * normalize them before diffing.
+ */
+import { SizeMismatch } from './types';
+export interface NormalizeResult {
+    normalizedBaseline: Uint8ClampedArray;
+    normalizedCandidate: Uint8ClampedArray;
+    width: number;
+    height: number;
+    sizeMismatch: SizeMismatch;
+}
+/**
+ * Normalize two pixel buffers to the same dimensions.
+ *
+ * @param baseline - Baseline pixel buffer (RGBA)
+ * @param bw - Baseline width
+ * @param bh - Baseline height
+ * @param candidate - Candidate pixel buffer (RGBA)
+ * @param cw - Candidate width
+ * @param ch - Candidate height
+ * @param mode - 'pad' (fill with transparent), 'crop' (use min dims), or 'error'
+ */
+export declare function normalizeDimensions(baseline: Uint8Array | Uint8ClampedArray, bw: number, bh: number, candidate: Uint8Array | Uint8ClampedArray, cw: number, ch: number, mode: 'pad' | 'crop' | 'error'): NormalizeResult;
+//# sourceMappingURL=resize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resize.d.ts","sourceRoot":"","sources":["../../src/diff/resize.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,MAAM,WAAW,eAAe;IAC9B,kBAAkB,EAAE,iBAAiB,CAAC;IACtC,mBAAmB,EAAE,iBAAiB,CAAC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,UAAU,GAAG,iBAAiB,EACxC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,UAAU,GAAG,iBAAiB,EACzC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,GAC7B,eAAe,CA0EjB"}