@detiq/crawler 1.1.7 → 1.1.9

package/dist/pdf-extractor.js

@@ -1,81 +1,99 @@
+/**
+ * PDF extraction — discovers and extracts text from PDF URLs found during crawl.
+ *
+ * When the HTTP engine or browser engine discovers a link to a .pdf file,
+ * this module fetches the PDF, extracts its text content, and returns it
+ * as a screen-compatible markdown string for test generation.
+ *
+ * Uses pdf-parse (already installed in API package, accessible via dynamic import).
+ */
 const PDF_EXT = /\.pdf(\?.*)?$/i;
-const PDF_MIME = "application/pdf";
-function isPdfUrl(url, contentType) {
-  return PDF_EXT.test(url) || (contentType?.includes(PDF_MIME) ?? false);
+const PDF_MIME = 'application/pdf';
+export function isPdfUrl(url, contentType) {
+    return PDF_EXT.test(url) || (contentType?.includes(PDF_MIME) ?? false);
 }
-async function extractPdfFromUrl(url, opts = {}) {
-  const { userAgent = "ZeTa-Crawler/1.0", timeoutMs = 3e4, maxSizeBytes = 50 * 1024 * 1024 } = opts;
-  let buffer;
-  let sizeBytes;
-  try {
-    const response = await fetch(url, {
-      headers: { "User-Agent": userAgent, "Accept": "application/pdf,*/*" },
-      signal: AbortSignal.timeout(timeoutMs)
-    });
-    if (!response.ok) return null;
-    const contentType = response.headers.get("content-type") ?? "";
-    if (!contentType.includes("pdf") && !PDF_EXT.test(url)) return null;
-    const arrayBuffer = await response.arrayBuffer();
-    sizeBytes = arrayBuffer.byteLength;
-    if (sizeBytes > maxSizeBytes) {
-      console.warn(`[pdf-extractor] PDF too large (${sizeBytes} bytes), skipping: ${url}`);
-      return null;
+export async function extractPdfFromUrl(url, opts = {}) {
+    const { userAgent = 'ZeTa-Crawler/1.0', timeoutMs = 30_000, maxSizeBytes = 50 * 1024 * 1024 } = opts;
+    let buffer;
+    let sizeBytes;
+    try {
+        const response = await fetch(url, {
+            headers: { 'User-Agent': userAgent, 'Accept': 'application/pdf,*/*' },
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok)
+            return null;
+        const contentType = response.headers.get('content-type') ?? '';
+        if (!contentType.includes('pdf') && !PDF_EXT.test(url))
+            return null;
+        const arrayBuffer = await response.arrayBuffer();
+        sizeBytes = arrayBuffer.byteLength;
+        if (sizeBytes > maxSizeBytes) {
+            console.warn(`[pdf-extractor] PDF too large (${sizeBytes} bytes), skipping: ${url}`);
+            return null;
+        }
+        buffer = Buffer.from(arrayBuffer);
+    }
+    catch (e) {
+        console.error(`[pdf-extractor] Failed to fetch PDF ${url}: ${e.message}`);
+        return null;
+    }
+    try {
+        // pdf-parse is installed in the API package — use dynamic import
+        // so this file compiles without adding pdf-parse to crawler's package.json
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore – no types for pdf-parse/lib/pdf-parse.js
+        const pdfParse = await import('pdf-parse/lib/pdf-parse.js').catch(() => import('pdf-parse'));
+        const parse = pdfParse.default ?? pdfParse;
+        const data = await parse(buffer, { max: 0 }); // max: 0 = all pages
+        const title = data.info?.Title || extractTitleFromUrl(url);
+        const markdown = pdfTextToMarkdown(data.text ?? '', title);
+        return {
+            url,
+            title,
+            markdown,
+            pageCount: data.numpages ?? 0,
+            info: {
+                author: data.info?.Author ?? '',
+                subject: data.info?.Subject ?? '',
+                keywords: data.info?.Keywords ?? '',
+                creator: data.info?.Creator ?? '',
+            },
+            sizeBytes,
+        };
+    }
+    catch (e) {
+        console.error(`[pdf-extractor] Failed to parse PDF ${url}: ${e.message}`);
+        return null;
     }
-    buffer = Buffer.from(arrayBuffer);
-  } catch (e) {
-    console.error(`[pdf-extractor] Failed to fetch PDF ${url}: ${e.message}`);
-    return null;
-  }
-  try {
-    const pdfParse = await import("pdf-parse/lib/pdf-parse.js").catch(
-      () => import("pdf-parse")
-    );
-    const parse = pdfParse.default ?? pdfParse;
-    const data = await parse(buffer, { max: 0 });
-    const title = data.info?.Title || extractTitleFromUrl(url);
-    const markdown = pdfTextToMarkdown(data.text ?? "", title);
-    return {
-      url,
-      title,
-      markdown,
-      pageCount: data.numpages ?? 0,
-      info: {
-        author: data.info?.Author ?? "",
-        subject: data.info?.Subject ?? "",
-        keywords: data.info?.Keywords ?? "",
-        creator: data.info?.Creator ?? ""
-      },
-      sizeBytes
-    };
-  } catch (e) {
-    console.error(`[pdf-extractor] Failed to parse PDF ${url}: ${e.message}`);
-    return null;
-  }
 }
 function extractTitleFromUrl(url) {
-  try {
-    const { pathname } = new URL(url);
-    const filename = pathname.split("/").pop() ?? "document";
-    return filename.replace(/\.pdf$/i, "").replace(/[-_]/g, " ").trim();
-  } catch {
-    return "PDF Document";
-  }
+    try {
+        const { pathname } = new URL(url);
+        const filename = pathname.split('/').pop() ?? 'document';
+        return filename.replace(/\.pdf$/i, '').replace(/[-_]/g, ' ').trim();
+    }
+    catch {
+        return 'PDF Document';
+    }
 }
 function pdfTextToMarkdown(text, title) {
-  if (!text.trim()) return `# ${title}
-
-*No extractable text content.*`;
-  const cleaned = text.replace(/\f/g, "\n\n---\n\n").replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n{3,}/g, "\n\n").replace(/[ \t]{2,}/g, " ").trim();
-  return `# ${title}
-
-${cleaned}`;
+    if (!text.trim())
+        return `# ${title}\n\n*No extractable text content.*`;
+    // Clean up common PDF extraction artifacts
+    const cleaned = text
+        .replace(/\f/g, '\n\n---\n\n') // form feed = page break
+        .replace(/\r\n/g, '\n')
+        .replace(/\r/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/[ \t]{2,}/g, ' ')
+        .trim();
+    return `# ${title}\n\n${cleaned}`;
 }
-function filterPdfUrls(urls) {
-  return urls.filter((u) => PDF_EXT.test(u));
+/**
+ * Filter a list of discovered URLs to find PDF links.
+ * Used by http-engine and browser crawler to decide which links to pass to extractPdfFromUrl.
+ */
+export function filterPdfUrls(urls) {
+    return urls.filter(u => PDF_EXT.test(u));
 }
-export {
-  extractPdfFromUrl,
-  filterPdfUrls,
-  isPdfUrl
-};
-//# sourceMappingURL=pdf-extractor.js.map

package/dist/performance-metrics.js

@@ -1,83 +1,105 @@
-async function collectPerfMetrics(page, url) {
-  const measuredAt = (/* @__PURE__ */ new Date()).toISOString();
-  let vitals = {};
-  try {
-    vitals = await page.evaluate(() => {
-      return new Promise((resolve) => {
-        const result = {};
-        const nav = performance.getEntriesByType("navigation")[0];
-        if (nav) {
-          result.ttfb = Math.round(nav.responseStart - nav.requestStart);
-          result.domContentLoaded = Math.round(nav.domContentLoadedEventEnd);
-          result.loadEventEnd = Math.round(nav.loadEventEnd);
-        }
-        let lcpDone = false;
-        let clsDone = false;
-        const tryResolve = () => {
-          if (lcpDone && clsDone) resolve(result);
-        };
-        try {
-          new PerformanceObserver((list) => {
-            const entries = list.getEntries();
-            if (entries.length > 0) result.lcp = Math.round(entries[entries.length - 1].startTime);
-            lcpDone = true;
-            tryResolve();
-          }).observe({ type: "largest-contentful-paint", buffered: true });
-        } catch {
-          lcpDone = true;
-        }
-        try {
-          let cls = 0;
-          new PerformanceObserver((list) => {
-            for (const e of list.getEntries()) {
-              if (!e.hadRecentInput) cls += e.value;
-            }
-            result.cls = Math.round(cls * 1e3) / 1e3;
-            clsDone = true;
-            tryResolve();
-          }).observe({ type: "layout-shift", buffered: true });
-        } catch {
-          clsDone = true;
-        }
-        try {
-          const fcp = performance.getEntriesByName("first-contentful-paint")[0];
-          if (fcp) result.fcp = Math.round(fcp.startTime);
-        } catch {
+/**
+ * Performance metrics collection via CDP + Playwright page.evaluate().
+ *
+ * Collects Core Web Vitals and resource timing after page navigation.
+ * Stored alongside screen data for test generation context and regression detection.
+ *
+ * Metrics:
+ * - LCP (Largest Contentful Paint) — via PerformanceObserver in page
+ * - CLS (Cumulative Layout Shift) — via PerformanceObserver in page
+ * - TTFB (Time to First Byte) — from navigation timing
+ * - DOMContentLoaded — from navigation timing
+ * - Resource count and size by type
+ */
+export async function collectPerfMetrics(page, url) {
+    const measuredAt = new Date().toISOString();
+    // Inject PerformanceObserver for LCP + CLS, wait up to 3s
+    let vitals = {};
+    try {
+        vitals = await page.evaluate(() => {
+            return new Promise((resolve) => {
+                const result = {};
+                // Navigation timing
+                const nav = performance.getEntriesByType('navigation')[0];
+                if (nav) {
+                    result.ttfb = Math.round(nav.responseStart - nav.requestStart);
+                    result.domContentLoaded = Math.round(nav.domContentLoadedEventEnd);
+                    result.loadEventEnd = Math.round(nav.loadEventEnd);
+                }
+                let lcpDone = false;
+                let clsDone = false;
+                const tryResolve = () => { if (lcpDone && clsDone)
+                    resolve(result); };
+                // LCP
+                try {
+                    new PerformanceObserver((list) => {
+                        const entries = list.getEntries();
+                        if (entries.length > 0)
+                            result.lcp = Math.round(entries[entries.length - 1].startTime);
+                        lcpDone = true;
+                        tryResolve();
+                    }).observe({ type: 'largest-contentful-paint', buffered: true });
+                }
+                catch {
+                    lcpDone = true;
+                }
+                // CLS
+                try {
+                    let cls = 0;
+                    new PerformanceObserver((list) => {
+                        for (const e of list.getEntries()) {
+                            if (!e.hadRecentInput)
+                                cls += e.value;
+                        }
+                        result.cls = Math.round(cls * 1000) / 1000;
+                        clsDone = true;
+                        tryResolve();
+                    }).observe({ type: 'layout-shift', buffered: true });
+                }
+                catch {
+                    clsDone = true;
+                }
+                // FCP
+                try {
+                    const fcp = performance.getEntriesByName('first-contentful-paint')[0];
+                    if (fcp)
+                        result.fcp = Math.round(fcp.startTime);
+                }
+                catch { }
+                // Fallback resolve after 3s
+                setTimeout(() => resolve(result), 3_000);
+            });
+        }).catch(() => ({}));
+    }
+    catch { /* page closed or navigate already */ }
+    // Resource timing
+    let resources = {
+        scripts: { count: 0, totalBytes: 0 },
+        styles: { count: 0, totalBytes: 0 },
+        images: { count: 0, totalBytes: 0 },
+        fonts: { count: 0, totalBytes: 0 },
+        other: { count: 0, totalBytes: 0 },
+    };
+    let totalTransferBytes = 0;
+    let requestCount = 0;
+    try {
+        const entries = await page.evaluate(() => performance.getEntriesByType('resource').map((e) => ({
+            name: e.name,
+            initiatorType: e.initiatorType,
+            transferSize: e.transferSize ?? 0,
+        }))).catch(() => []);
+        for (const e of entries) {
+            requestCount++;
+            totalTransferBytes += e.transferSize;
+            const cat = e.initiatorType === 'script' ? 'scripts'
+                : e.initiatorType === 'css' || e.name?.endsWith('.css') ? 'styles'
+                    : e.initiatorType === 'img' ? 'images'
+                        : e.name?.match(/\.(woff|woff2|ttf|otf|eot)/) ? 'fonts'
+                            : 'other';
+            resources[cat].count++;
+            resources[cat].totalBytes += e.transferSize;
         }
-        setTimeout(() => resolve(result), 3e3);
-      });
-    }).catch(() => ({}));
-  } catch {
-  }
-  let resources = {
-    scripts: { count: 0, totalBytes: 0 },
-    styles: { count: 0, totalBytes: 0 },
-    images: { count: 0, totalBytes: 0 },
-    fonts: { count: 0, totalBytes: 0 },
-    other: { count: 0, totalBytes: 0 }
-  };
-  let totalTransferBytes = 0;
-  let requestCount = 0;
-  try {
-    const entries = await page.evaluate(
-      () => performance.getEntriesByType("resource").map((e) => ({
-        name: e.name,
-        initiatorType: e.initiatorType,
-        transferSize: e.transferSize ?? 0
-      }))
-    ).catch(() => []);
-    for (const e of entries) {
-      requestCount++;
-      totalTransferBytes += e.transferSize;
-      const cat = e.initiatorType === "script" ? "scripts" : e.initiatorType === "css" || e.name?.endsWith(".css") ? "styles" : e.initiatorType === "img" ? "images" : e.name?.match(/\.(woff|woff2|ttf|otf|eot)/) ? "fonts" : "other";
-      resources[cat].count++;
-      resources[cat].totalBytes += e.transferSize;
     }
-  } catch {
-  }
-  return { url, vitals, resources, totalTransferBytes, requestCount, measuredAt };
+    catch { }
+    return { url, vitals, resources, totalTransferBytes, requestCount, measuredAt };
 }
-export {
-  collectPerfMetrics
-};
-//# sourceMappingURL=performance-metrics.js.map

package/dist/phash.js

@@ -1,136 +1,155 @@
-import sharp from "sharp";
-async function applyMask(imagePath, ignoredRegions) {
-  const meta = await sharp(imagePath).metadata();
-  const W = meta.width ?? 1200;
-  const H = meta.height ?? 800;
-  const overlays = await Promise.all(
-    ignoredRegions.map(async (r) => {
-      const rW = Math.max(1, Math.round(r.width * W));
-      const rH = Math.max(1, Math.round(r.height * H));
-      const buf = await sharp({
-        create: { width: rW, height: rH, channels: 3, background: { r: 128, g: 128, b: 128 } }
-      }).png().toBuffer();
-      return { input: buf, top: Math.round(r.y * H), left: Math.round(r.x * W) };
-    })
-  );
-  return sharp(imagePath).composite(overlays).png().toBuffer();
+import sharp from 'sharp';
+/**
+ * Composites neutral grey (128,128,128) over each ignoredRegion (fractional
+ * 0-1 coordinates) so masked content — timestamps, live counters, ads —
+ * contributes nothing to any downstream pixel comparison. Shared by every
+ * comparison path (whole-image hash, per-cell grid hash, AI vision) so a
+ * region masked once is actually ignored everywhere, not just in the
+ * cheapest check.
+ */
+export async function applyMask(imagePath, ignoredRegions) {
+    const meta = await sharp(imagePath).metadata();
+    const W = meta.width ?? 1200;
+    const H = meta.height ?? 800;
+    const overlays = await Promise.all(ignoredRegions.map(async (r) => {
+        const rW = Math.max(1, Math.round(r.width * W));
+        const rH = Math.max(1, Math.round(r.height * H));
+        const buf = await sharp({
+            create: { width: rW, height: rH, channels: 3, background: { r: 128, g: 128, b: 128 } },
+        }).png().toBuffer();
+        return { input: buf, top: Math.round(r.y * H), left: Math.round(r.x * W) };
+    }));
+    return sharp(imagePath).composite(overlays).png().toBuffer();
 }
+/**
+ * Compute an 8x8 average hash (aHash) of an image file, with optional mask overlays.
+ * ignoredRegions are fractional (0-1 range), converted to pixels here.
+ * Masked regions are filled with neutral grey (128,128,128) before hashing.
+ */
 async function hashWithMasks(imagePath, ignoredRegions = []) {
-  const pipeline = ignoredRegions.length > 0 ? sharp(await applyMask(imagePath, ignoredRegions)) : sharp(imagePath);
-  const buf = await pipeline.resize(8, 8, { fit: "fill" }).greyscale().raw().toBuffer();
-  const pixels = Array.from(buf);
-  const mean = pixels.reduce((s, p) => s + p, 0) / pixels.length;
-  return pixels.reduce((h, p, i) => p >= mean ? h | 1n << BigInt(63 - i) : h, 0n);
+    const pipeline = ignoredRegions.length > 0
+        ? sharp(await applyMask(imagePath, ignoredRegions))
+        : sharp(imagePath);
+    const buf = await pipeline.resize(8, 8, { fit: 'fill' }).greyscale().raw().toBuffer();
+    const pixels = Array.from(buf);
+    const mean = pixels.reduce((s, p) => s + p, 0) / pixels.length;
+    return pixels.reduce((h, p, i) => (p >= mean ? h | (1n << BigInt(63 - i)) : h), 0n);
 }
 function hammingDistance(a, b) {
-  let xor = a ^ b;
-  let count = 0;
-  while (xor !== 0n) {
-    count += Number(xor & 1n);
-    xor >>= 1n;
-  }
-  return count;
-}
-async function generatePixelmatchDiff(pathA, pathB, ignoredRegions = []) {
-  const metaA = await sharp(pathA).metadata();
-  const W = metaA.width ?? 1200;
-  const H = metaA.height ?? 800;
-  const toRawRGBA = async (path) => {
-    const base = ignoredRegions.length > 0 ? sharp(await applyMask(path, ignoredRegions)) : sharp(path);
-    const { data } = await base.resize(W, H, { fit: "fill" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-    return data;
-  };
-  const [rawA, rawB] = await Promise.all([toRawRGBA(pathA), toRawRGBA(pathB)]);
-  const { default: pixelmatch } = await import("pixelmatch");
-  const diffData = Buffer.alloc(W * H * 4);
-  pixelmatch(rawA, rawB, diffData, W, H, {
-    threshold: 0.1,
-    alpha: 0.3,
-    diffColor: [255, 0, 0],
-    aaColor: [255, 255, 0]
-  });
-  return sharp(diffData, { raw: { width: W, height: H, channels: 4 } }).png().toBuffer();
+    let xor = a ^ b;
+    let count = 0;
+    while (xor !== 0n) {
+        count += Number(xor & 1n);
+        xor >>= 1n;
+    }
+    return count;
 }
-async function screenshotDiffPercent(pathA, pathB, ignoredRegions = []) {
-  const [hashA, hashB] = await Promise.all([
-    hashWithMasks(pathA, ignoredRegions),
-    hashWithMasks(pathB, ignoredRegions)
-  ]);
-  let xor = hashA ^ hashB;
-  let dist = 0;
-  while (xor !== 0n) {
-    dist += Number(xor & 1n);
-    xor >>= 1n;
-  }
-  const pct = parseFloat((dist / 64 * 100).toFixed(1));
-  const changeLevel = pct === 0 ? "IDENTICAL" : pct < 10 ? "MINOR" : pct < 30 ? "MODERATE" : "SIGNIFICANT";
-  return { pHashDistance: pct, changeLevel };
+/**
+ * Generates a pixelmatch diff image highlighting changed pixels in red.
+ * Applies the same ignoredRegions mask as screenshotDiffPercent so masked
+ * zones don't show as "changed" in the visual output.
+ * Returns a PNG Buffer suitable for upload to S3.
+ */
+export async function generatePixelmatchDiff(pathA, pathB, ignoredRegions = []) {
+    const metaA = await sharp(pathA).metadata();
+    const W = metaA.width ?? 1200;
+    const H = metaA.height ?? 800;
+    const toRawRGBA = async (path) => {
+        const base = ignoredRegions.length > 0 ? sharp(await applyMask(path, ignoredRegions)) : sharp(path);
+        const { data } = await base.resize(W, H, { fit: 'fill' }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+        return data;
+    };
+    const [rawA, rawB] = await Promise.all([toRawRGBA(pathA), toRawRGBA(pathB)]);
+    const { default: pixelmatch } = await import('pixelmatch');
+    const diffData = Buffer.alloc(W * H * 4);
+    pixelmatch(rawA, rawB, diffData, W, H, {
+        threshold: 0.1,
+        alpha: 0.3,
+        diffColor: [255, 0, 0],
+        aaColor: [255, 255, 0],
+    });
+    return sharp(diffData, { raw: { width: W, height: H, channels: 4 } }).png().toBuffer();
 }
-async function gridLayoutDiff(pathA, pathB, ignoredRegions = []) {
-  const GRID_LABELS = [
-    "top-left",
-    "top-center",
-    "top-right",
-    "mid-left",
-    "mid-center",
-    "mid-right",
-    "bottom-left",
-    "bottom-center",
-    "bottom-right"
-  ];
-  try {
-    const [sourceA, sourceB] = ignoredRegions.length > 0 ? await Promise.all([applyMask(pathA, ignoredRegions), applyMask(pathB, ignoredRegions)]) : [pathA, pathB];
-    const [metaA, metaB] = await Promise.all([
-      sharp(sourceA).metadata(),
-      sharp(sourceB).metadata()
+export async function screenshotDiffPercent(pathA, pathB, ignoredRegions = []) {
+    const [hashA, hashB] = await Promise.all([
+        hashWithMasks(pathA, ignoredRegions),
+        hashWithMasks(pathB, ignoredRegions),
     ]);
-    const W = Math.min(metaA.width ?? 1200, metaB.width ?? 1200);
-    const H = Math.min(metaA.height ?? 800, metaB.height ?? 800);
-    const cW = Math.floor(W / 3);
-    const cH = Math.floor(H / 3);
-    const changes = [];
-    for (let row = 0; row < 3; row++) {
-      for (let col = 0; col < 3; col++) {
-        const region = { left: col * cW, top: row * cH, width: cW, height: cH };
-        const label = GRID_LABELS[row * 3 + col];
-        const [hashA, hashB] = await Promise.all([
-          sharp(sourceA).extract(region).resize(8, 8, { fit: "fill" }).greyscale().raw().toBuffer().then((buf) => {
-            const pixels = Array.from(buf);
-            const mean = pixels.reduce((s, p) => s + p, 0) / pixels.length;
-            return pixels.reduce((h, p, i) => p >= mean ? h | 1n << BigInt(63 - i) : h, 0n);
-          }),
-          sharp(sourceB).extract(region).resize(8, 8, { fit: "fill" }).greyscale().raw().toBuffer().then((buf) => {
-            const pixels = Array.from(buf);
-            const mean = pixels.reduce((s, p) => s + p, 0) / pixels.length;
-            return pixels.reduce((h, p, i) => p >= mean ? h | 1n << BigInt(63 - i) : h, 0n);
-          })
+    let xor = hashA ^ hashB;
+    let dist = 0;
+    while (xor !== 0n) {
+        dist += Number(xor & 1n);
+        xor >>= 1n;
+    }
+    const pct = parseFloat(((dist / 64) * 100).toFixed(1));
+    const changeLevel = pct === 0 ? 'IDENTICAL' : pct < 10 ? 'MINOR' : pct < 30 ? 'MODERATE' : 'SIGNIFICANT';
+    return { pHashDistance: pct, changeLevel };
+}
+/**
+ * Grid-based layout analysis: divides screenshots into a 3×3 grid and computes
+ * pHash per cell. Returns which regions changed and where, for the VisualDiff.changes field.
+ * Uses sharp's `extract` to crop each cell before hashing.
+ */
+export async function gridLayoutDiff(pathA, pathB, ignoredRegions = []) {
+    const GRID_LABELS = [
+        'top-left', 'top-center', 'top-right',
+        'mid-left', 'mid-center', 'mid-right',
+        'bottom-left', 'bottom-center', 'bottom-right',
+    ];
+    try {
+        // Mask before cropping into cells — a masked region (e.g. a timestamp)
+        // then contributes nothing to any cell's hash, instead of only being
+        // ignored by the separate whole-image hash in screenshotDiffPercent().
+        const [sourceA, sourceB] = ignoredRegions.length > 0
+            ? await Promise.all([applyMask(pathA, ignoredRegions), applyMask(pathB, ignoredRegions)])
+            : [pathA, pathB];
+        const [metaA, metaB] = await Promise.all([
+            sharp(sourceA).metadata(),
+            sharp(sourceB).metadata(),
         ]);
-        let xor = hashA ^ hashB;
-        let dist = 0;
-        while (xor !== 0n) {
-          dist += Number(xor & 1n);
-          xor >>= 1n;
-        }
-        const pct = dist / 64 * 100;
-        if (pct >= 5) {
-          const severity = pct >= 20 ? "HIGH" : pct >= 10 ? "MEDIUM" : "LOW";
-          changes.push({
-            location: label,
-            severity,
-            description: `${Math.round(pct)}% visual change in ${label.replace("-", " ")} region`
-          });
+        const W = Math.min(metaA.width ?? 1200, metaB.width ?? 1200);
+        const H = Math.min(metaA.height ?? 800, metaB.height ?? 800);
+        const cW = Math.floor(W / 3);
+        const cH = Math.floor(H / 3);
+        const changes = [];
+        for (let row = 0; row < 3; row++) {
+            for (let col = 0; col < 3; col++) {
+                const region = { left: col * cW, top: row * cH, width: cW, height: cH };
+                const label = GRID_LABELS[row * 3 + col];
+                const [hashA, hashB] = await Promise.all([
+                    sharp(sourceA).extract(region).resize(8, 8, { fit: 'fill' }).greyscale().raw().toBuffer()
+                        .then((buf) => {
+                        const pixels = Array.from(buf);
+                        const mean = pixels.reduce((s, p) => s + p, 0) / pixels.length;
+                        return pixels.reduce((h, p, i) => p >= mean ? h | (1n << BigInt(63 - i)) : h, 0n);
+                    }),
+                    sharp(sourceB).extract(region).resize(8, 8, { fit: 'fill' }).greyscale().raw().toBuffer()
+                        .then((buf) => {
+                        const pixels = Array.from(buf);
+                        const mean = pixels.reduce((s, p) => s + p, 0) / pixels.length;
+                        return pixels.reduce((h, p, i) => p >= mean ? h | (1n << BigInt(63 - i)) : h, 0n);
+                    }),
+                ]);
+                let xor = hashA ^ hashB;
+                let dist = 0;
+                while (xor !== 0n) {
+                    dist += Number(xor & 1n);
+                    xor >>= 1n;
+                }
+                const pct = (dist / 64) * 100;
+                if (pct >= 5) {
+                    const severity = pct >= 20 ? 'HIGH' : pct >= 10 ? 'MEDIUM' : 'LOW';
+                    changes.push({
+                        location: label,
+                        severity,
+                        description: `${Math.round(pct)}% visual change in ${label.replace('-', ' ')} region`,
+                    });
+                }
+            }
         }
-      }
+        return changes;
+    }
+    catch {
+        return [];
     }
-    return changes;
-  } catch {
-    return [];
-  }
 }
-export {
-  applyMask,
-  generatePixelmatchDiff,
-  gridLayoutDiff,
-  screenshotDiffPercent
-};
-//# sourceMappingURL=phash.js.map