@govtechsg/oobee 0.10.45 → 0.10.49

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@govtechsg/oobee",
   "main": "dist/npmIndex.js",
-  "version": "0.10.45",
+  "version": "0.10.49",
   "type": "module",
   "author": "Government Technology Agency <info@tech.gov.sg>",
   "dependencies": {

package/src/combine.ts

@@ -98,8 +98,15 @@ const combineRun = async (details: Data, deviceToScan: string) => {
     isSlowScanMode: envDetails.specifiedMaxConcurrency,
     isAdhereRobots: envDetails.followRobots,
     deviceChosen: deviceToScan,
+    nameEmail: undefined as { name: string; email: string } | undefined,
   };
 
+  // Parse nameEmail and add it to scanDetails for use in generateArtifacts
+  if (nameEmail) {
+    const [name, email] = nameEmail.split(':');
+    scanDetails.nameEmail = { name, email };
+  }
+
   const viewportSettings: ViewportSettingsClass = new ViewportSettingsClass(
     deviceChosen,
     customDevice,

package/src/constants/common.ts

@@ -18,17 +18,14 @@ import { minimatch } from 'minimatch';
 import { globSync, GlobOptionsWithFileTypesFalse } from 'glob';
 import { LaunchOptions, Locator, Page, devices, webkit } from 'playwright';
 import printMessage from 'print-message';
-// @ts-ignore
-import * as Sentry from '@sentry/node';
 import constants, {
   getDefaultChromeDataDir,
   getDefaultEdgeDataDir,
   getDefaultChromiumDataDir,
   proxy,
-  sentryConfig,
-    // Legacy code start - Google Sheets submission
+  // Legacy code start - Google Sheets submission
   formDataFields,
-    // Legacy code end - Google Sheets submission
+  // Legacy code end - Google Sheets submission
   ScannerTypes,
   BrowserTypes,
 } from './constants.js';
@@ -1758,159 +1755,42 @@ export const submitForm = async (
   numberOfPagesNotScanned: number,
   metadata: string,
 ) => {
-  // Initialize Sentry
-  Sentry.init(sentryConfig);
-
-  // Format the data as you want it to appear in Sentry
-  const additionalPageData = {
+  // Legacy code start - Google Sheets submission
+  const additionalPageDataJson = JSON.stringify({
+    redirectsScanned: numberOfRedirectsScanned,
     pagesNotScanned: numberOfPagesNotScanned,
-    redirectsScanned: numberOfRedirectsScanned
-  };
+  });
 
-  // Extract issue occurrences from scan results if possible
-  const issueOccurrences = extractIssueOccurrences(scanResultsJson);
-  
-  // Determine if it's a government website
-  const isGov = entryUrl.includes('.gov');
-  
-  // Get email domain/tag
-  const emailTag = email.split('@')[1] || '';
-  
-  // Format timestamp 
-  const timestamp = new Date().toISOString();
-  
-  // Prepare redirect URL if different from entry URL
-  const redirectUrl = scannedUrl !== entryUrl ? scannedUrl : null;
-  
-  try {
-    // Capture the scan data as a Sentry event with each field as a separate entry
-    Sentry.captureEvent({
-      message: `Accessibility scan completed for ${entryUrl}`,
-      level: 'info',
-      tags: {
-        scanType: scanType,
-        browser: browserToRun,
-        isGov: isGov,
-        emailDomain: emailTag,
-      },
-      user: {
-        email: email,
-        username: name,
-      },
-      extra: {
-        // Top-level fields as shown in your screenshot
-        entryUrl: entryUrl,
-        websiteUrl: scannedUrl,
-        scanType: scanType,
-        numberOfPagesScanned: numberOfPagesScanned,
-        metadata: metadata ? JSON.parse(metadata) : {},
-        scanResults: scanResultsJson.length > 8000 ? 
-          scanResultsJson.substring(0, 8000) + '...[truncated]' : 
-          scanResultsJson,
-        
-        // Additional fields you requested
-        additionalPageData: additionalPageData,
-        additionalScan: additionalPageData,
-        additionalPagesData: additionalPageData,
-        
-        // Individual fields as requested
-        timestamp: timestamp,
-        redirectUrl: redirectUrl,
-        isGov: isGov,
-        emailTag: emailTag,
-        consolidatedScanType: scanType.toLowerCase(),
-        email: email,
-        name: name,
-        filledNoPagesScanned: numberOfPagesScanned > 0,
-        redirectsScanned: numberOfRedirectsScanned,
-        pagesNotScanned: numberOfPagesNotScanned,
-        issueOccurrences: issueOccurrences
-      }
-    });
+  let finalUrl =
+    `${formDataFields.formUrl}?` +
+    `${formDataFields.entryUrlField}=${entryUrl}&` +
+    `${formDataFields.scanTypeField}=${scanType}&` +
+    `${formDataFields.emailField}=${email}&` +
+    `${formDataFields.nameField}=${name}&` +
+    `${formDataFields.resultsField}=${encodeURIComponent(scanResultsJson)}&` +
+    `${formDataFields.numberOfPagesScannedField}=${numberOfPagesScanned}&` +
+    `${formDataFields.additionalPageDataField}=${encodeURIComponent(additionalPageDataJson)}&` +
+    `${formDataFields.metadataField}=${encodeURIComponent(metadata)}`;
 
-    // IMPORTANT: Wait for the event to be sent
-    await Sentry.flush(2000); // Wait up to 2 seconds for the event to be sent
-    
-  } catch (error) {
-    console.error('Error sending data to Sentry:', error);
+  if (scannedUrl !== entryUrl) {
+    finalUrl += `&${formDataFields.redirectUrlField}=${scannedUrl}`;
   }
 
-  // Legacy code start - Google Sheets submission
-  try {
-    const additionalPageDataJson = JSON.stringify({
-      redirectsScanned: numberOfRedirectsScanned,
-      pagesNotScanned: numberOfPagesNotScanned,
-    });
-
-    let finalUrl =
-      `${formDataFields.formUrl}?` +
-      `${formDataFields.entryUrlField}=${entryUrl}&` +
-      `${formDataFields.scanTypeField}=${scanType}&` +
-      `${formDataFields.emailField}=${email}&` +
-      `${formDataFields.nameField}=${name}&` +
-      `${formDataFields.resultsField}=${encodeURIComponent(scanResultsJson)}&` +
-      `${formDataFields.numberOfPagesScannedField}=${numberOfPagesScanned}&` +
-      `${formDataFields.additionalPageDataField}=${encodeURIComponent(additionalPageDataJson)}&` +
-      `${formDataFields.metadataField}=${encodeURIComponent(metadata)}`;
-
-    if (scannedUrl !== entryUrl) {
-      finalUrl += `&${formDataFields.redirectUrlField}=${scannedUrl}`;
-    }
-
-    if (proxy) {
-      await submitFormViaPlaywright(browserToRun, userDataDirectory, finalUrl);
-    } else {
-      try {
-        await axios.get(finalUrl, { timeout: 2000 });
-      } catch (error) {
-        if (error.code === 'ECONNABORTED') {
-          if (browserToRun || constants.launcher === webkit) {
-            await submitFormViaPlaywright(browserToRun, userDataDirectory, finalUrl);
-          }
+  if (proxy) {
+    await submitFormViaPlaywright(browserToRun, userDataDirectory, finalUrl);
+  } else {
+    try {
+      await axios.get(finalUrl, { timeout: 2000 });
+    } catch (error) {
+      if (error.code === 'ECONNABORTED') {
+        if (browserToRun || constants.launcher === webkit) {
+          await submitFormViaPlaywright(browserToRun, userDataDirectory, finalUrl);
         }
       }
     }
-    console.log('Legacy Google Sheets form submitted successfully');
-  } catch (legacyError) {
-    console.error('Error submitting legacy Google Sheets form:', legacyError);
   }
-  // Legacy code end - Google Sheets submission
 };
-
-// Helper function to extract issue occurrences from scan results
-function extractIssueOccurrences(scanResultsJson: string): number {
-  try {
-    const results = JSON.parse(scanResultsJson);
-    // Count total occurrences from all issues in the scan results
-    // This may need adjustment based on your specific JSON structure
-    let totalOccurrences = 0;
-    
-    // Try to parse the format shown in your screenshot
-    if (typeof results === 'object') {
-      // Loop through all keys that have "occurrences" properties
-      Object.keys(results).forEach(key => {
-        if (results[key] && typeof results[key] === 'object' && 'occurrences' in results[key]) {
-          totalOccurrences += parseInt(results[key].occurrences, 10) || 0;
-        }
-      });
-      
-      // If we found any occurrences, return the total
-      if (totalOccurrences > 0) {
-        return totalOccurrences;
-      }
-    }
-    
-    // Fallback to direct occurrences property if available
-    if (results && results.occurrences) {
-      return parseInt(results.occurrences, 10) || 0;
-    }
-    
-    return 0;
-  } catch (e) {
-    console.error('Error extracting issue occurrences:', e);
-    return 0;
-  }
-}
+// Legacy code end - Google Sheets submission
 
 export async function initModifiedUserAgent(
   browser?: string,
@@ -2001,21 +1881,27 @@ export const waitForPageLoaded = async (page: Page, timeout = 10000) => {
     page.waitForLoadState('networkidle'), // Wait for network requests to settle
     new Promise(resolve => setTimeout(resolve, timeout)), // Hard timeout as a fallback
     page.evaluate(OBSERVER_TIMEOUT => {
-      return new Promise(resolve => {
+      return new Promise<string>(resolve => {
         // Skip mutation check for PDFs
         if (document.contentType === 'application/pdf') {
           resolve('Skipping DOM mutation check for PDF.');
           return;
         }
 
+        const root = document.documentElement || document.body;
+        if (!(root instanceof Node)) {
+          // Not a valid DOM root—treat as loaded
+          resolve('No valid root to observe; treating as loaded.');
+          return;
+        }
+
         let timeout: NodeJS.Timeout;
         let mutationCount = 0;
-        const MAX_MUTATIONS = 250; // Limit max mutations
+        const MAX_MUTATIONS = 250;
         const mutationHash: Record<string, number> = {};
 
         const observer = new MutationObserver(mutationsList => {
           clearTimeout(timeout);
-
           mutationCount++;
           if (mutationCount > MAX_MUTATIONS) {
             observer.disconnect();
@@ -2023,24 +1909,20 @@ export const waitForPageLoaded = async (page: Page, timeout = 10000) => {
             return;
           }
 
-          mutationsList.forEach(mutation => {
+          for (const mutation of mutationsList) {
             if (mutation.target instanceof Element) {
-              Array.from(mutation.target.attributes).forEach(attr => {
-                const mutationKey = `${mutation.target.nodeName}-${attr.name}`;
-
-                if (mutationKey) {
-                  mutationHash[mutationKey] = (mutationHash[mutationKey] || 0) + 1;
-
-                  if (mutationHash[mutationKey] >= 10) {
-                    observer.disconnect();
-                    resolve(`Repeated mutation detected for ${mutationKey}, exiting.`);
-                  }
+              for (const attr of Array.from(mutation.target.attributes)) {
+                const key = `${mutation.target.nodeName}-${attr.name}`;
+                mutationHash[key] = (mutationHash[key] || 0) + 1;
+                if (mutationHash[key] >= 10) {
+                  observer.disconnect();
+                  resolve(`Repeated mutation detected for ${key}, exiting.`);
+                  return;
                 }
-              });
+              }
             }
-          });
+          }
 
-          // If no mutations occur for 1 second, resolve
           timeout = setTimeout(() => {
             observer.disconnect();
             resolve('DOM stabilized after mutations.');
@@ -2053,9 +1935,10 @@ export const waitForPageLoaded = async (page: Page, timeout = 10000) => {
           resolve('Observer timeout reached, exiting.');
         }, OBSERVER_TIMEOUT);
 
-        observer.observe(document.documentElement, {
+        // Only observe if root is a Node
+        observer.observe(root, {
           childList: true,
-          subtree: true,
+          subtree:   true,
           attributes: true,
         });
       });

package/src/constants/constants.ts

@@ -275,11 +275,43 @@ export const impactOrder = {
   critical: 3,
 };
 
+/**
+ * Suppresses the "Setting the NODE_TLS_REJECT_UNAUTHORIZED 
+ * environment variable to '0' is insecure" warning,
+ * then disables TLS validation globally.
+ */
+export function suppressTlsRejectWarning(): void {
+  // Monkey-patch process.emitWarning
+  const originalEmitWarning = process.emitWarning;
+  process.emitWarning = (warning: string | Error, ...args: any[]) => {
+    const msg = typeof warning === 'string' ? warning : warning.message;
+    if (msg.includes('NODE_TLS_REJECT_UNAUTHORIZED')) {
+      // swallow only that one warning
+      return;
+    }
+    // forward everything else
+    originalEmitWarning.call(process, warning, ...args);
+  };
+
+  // Now turn off cert validation
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+}
+
+suppressTlsRejectWarning();
+
 export const sentryConfig = {
-  dsn: "https://e4ab99e457c531e7bde4a8dc3dd2b1ab@o4509047624761344.ingest.us.sentry.io/4509192349548544",
+  dsn: process.env.OOBEE_SENTRY_DSN || "https://3b8c7ee46b06f33815a1301b6713ebc3@o4509047624761344.ingest.us.sentry.io/4509327783559168",
   tracesSampleRate: 1.0, // Capture 100% of transactions for performance monitoring
   profilesSampleRate: 1.0, // Capture 100% of profiles
 };
+
+// Function to set Sentry user ID from userData.txt
+export const setSentryUser = (userId: string) => {
+  if (userId) {
+    Sentry.setUser({ id: userId });
+  }
+};
+
   // Legacy code start - Google Sheets submission
 export const formDataFields = {
   formUrl: `https://docs.google.com/forms/d/e/1FAIpQLSem5C8fyNs5TiU5Vv2Y63-SH7CHN86f-LEPxeN_1u_ldUbgUA/formResponse`, // prod

package/src/crawlers/crawlDomain.ts

@@ -482,8 +482,6 @@ const crawlDomain = async ({
       async crawlingContext => {
         const { page, request } = crawlingContext;
 
-        request.skipNavigation = true;
-
         await page.evaluate(() => {
           return new Promise(resolve => {
             let timeout;
@@ -514,9 +512,11 @@ const crawlDomain = async ({
               resolve('Observer timeout reached.');
             }, OBSERVER_TIMEOUT);
     
-            // **HERE**: select the real DOM node inside evaluate
-            const root = document.documentElement;
-            observer.observe(root, { childList: true, subtree: true });
+            const root = document.documentElement || document.body || document;
+            if (!root || typeof observer.observe !== 'function') {
+              resolve('No root node to observe.');
+              return;
+            }
           });
         });
 

package/src/crawlers/crawlSitemap.ts

@@ -199,9 +199,11 @@ const crawlSitemap = async (
                 resolve('Observer timeout reached.');
               }, OBSERVER_TIMEOUT);
       
-              // **HERE**: select the real DOM node inside evaluate
-              const root = document.documentElement;
-              observer.observe(root, { childList: true, subtree: true });
+              const root = document.documentElement || document.body || document;
+              if (!root || typeof observer.observe !== 'function') {
+                resolve('No root node to observe.');
+                return;
+              }
             });
           });
         } catch (err) {

package/src/mergeAxeResults.ts

@@ -12,10 +12,11 @@ import { AsyncParser, ParserOptions } from '@json2csv/node';
 import zlib from 'zlib';
 import { Base64Encode } from 'base64-stream';
 import { pipeline } from 'stream/promises';
-import constants, { ScannerTypes, sentryConfig } from './constants/constants.js';
-import { urlWithoutAuth } from './constants/common.js';
 // @ts-ignore
 import * as Sentry from '@sentry/node';
+import constants, { ScannerTypes, sentryConfig, setSentryUser } from './constants/constants.js';
+import { urlWithoutAuth } from './constants/common.js';
+
 import {
   createScreenshotsFolder,
   getStoragePath,
@@ -26,6 +27,8 @@ import {
   zipResults,
   getIssuesPercentage,
   getWcagCriteriaMap,
+  categorizeWcagCriteria,
+  getUserDataTxt,
 } from './utils.js';
 import { consoleLogger, silentLogger } from './logs.js';
 import itemTypeDescription from './constants/itemTypeDescription.js';
@@ -252,7 +255,9 @@ const writeCsv = async (allIssues, storagePath) => {
           scanCompletedAt: allIssues.endTime ? allIssues.endTime.toISOString() : '',
           severity: 'error',
           issueId: 'error-pages-skipped',
-          issueDescription: page.metadata ? page.metadata : 'An unknown error caused the page to be skipped',
+          issueDescription: page.metadata
+            ? page.metadata
+            : 'An unknown error caused the page to be skipped',
           wcagConformance: '',
           url: page.url || page || '',
           pageTitle: 'Error',
@@ -564,15 +569,15 @@ const writeLargeScanItemsJsonToFile = async (obj: object, filePath: string) => {
           queueWrite(`  "${key}": ${JSON.stringify(value)}`);
         } else {
           queueWrite(`  "${key}": {\n`);
-        
+
           const { rules, ...otherProperties } = value;
-        
+
           // Write other properties
           Object.entries(otherProperties).forEach(([propKey, propValue], j) => {
             const propValueString =
               propValue === null ||
-                typeof propValue === 'function' ||
-                typeof propValue === 'undefined'
+              typeof propValue === 'function' ||
+              typeof propValue === 'undefined'
                 ? 'null'
                 : JSON.stringify(propValue);
             queueWrite(`    "${propKey}": ${propValueString}`);
@@ -593,8 +598,8 @@ const writeLargeScanItemsJsonToFile = async (obj: object, filePath: string) => {
               Object.entries(otherRuleProperties).forEach(([ruleKey, ruleValue], k) => {
                 const ruleValueString =
                   ruleValue === null ||
-                    typeof ruleValue === 'function' ||
-                    typeof ruleValue === 'undefined'
+                  typeof ruleValue === 'function' ||
+                  typeof ruleValue === 'undefined'
                     ? 'null'
                     : JSON.stringify(ruleValue);
                 queueWrite(`        "${ruleKey}": ${ruleValueString}`);
@@ -637,15 +642,13 @@ const writeLargeScanItemsJsonToFile = async (obj: object, filePath: string) => {
             queueWrite('    ]');
           }
           queueWrite('\n  }');
-      }
-
-      if (i < keys.length - 1) {
-        queueWrite(',\n');
-      } else {
-        queueWrite('\n');
-      }
-
+        }
 
+        if (i < keys.length - 1) {
+          queueWrite(',\n');
+        } else {
+          queueWrite('\n');
+        }
       });
 
       queueWrite('}\n');
@@ -762,33 +765,43 @@ const writeJsonAndBase64Files = async (
   const { jsonFilePath: scanDataJsonFilePath, base64FilePath: scanDataBase64FilePath } =
     await writeJsonFileAndCompressedJsonFile(rest, storagePath, 'scanData');
   const { jsonFilePath: scanItemsJsonFilePath, base64FilePath: scanItemsBase64FilePath } =
-    await writeJsonFileAndCompressedJsonFile({ oobeeAppVersion: allIssues.oobeeAppVersion, ...items }, storagePath, 'scanItems');
-
-    // Add pagesAffectedCount to each rule in scanItemsMiniReport (items) and sort them in descending order of pagesAffectedCount
-    ['mustFix', 'goodToFix', 'needsReview', 'passed'].forEach((category) => {
-      if (items[category].rules && Array.isArray(items[category].rules)) {
-        items[category].rules.forEach((rule) => {
-          rule.pagesAffectedCount = Array.isArray(rule.pagesAffected)
-            ? rule.pagesAffected.length
-            : 0;
-        });
+    await writeJsonFileAndCompressedJsonFile(
+      { oobeeAppVersion: allIssues.oobeeAppVersion, ...items },
+      storagePath,
+      'scanItems',
+    );
 
-        // Sort in descending order of pagesAffectedCount
-        items[category].rules.sort((a, b) => (b.pagesAffectedCount || 0) - (a.pagesAffectedCount || 0));
-      }
-    });
+  // Add pagesAffectedCount to each rule in scanItemsMiniReport (items) and sort them in descending order of pagesAffectedCount
+  ['mustFix', 'goodToFix', 'needsReview', 'passed'].forEach(category => {
+    if (items[category].rules && Array.isArray(items[category].rules)) {
+      items[category].rules.forEach(rule => {
+        rule.pagesAffectedCount = Array.isArray(rule.pagesAffected) ? rule.pagesAffected.length : 0;
+      });
 
-    // Refactor scanIssuesSummary to reuse the scanItemsMiniReport structure by stripping out pagesAffected
-    const scanIssuesSummary = {
-      mustFix: items.mustFix.rules.map(({ pagesAffected, ...ruleInfo }) => ruleInfo),
-      goodToFix: items.goodToFix.rules.map(({ pagesAffected, ...ruleInfo }) => ruleInfo),
-      needsReview: items.needsReview.rules.map(({ pagesAffected, ...ruleInfo }) => ruleInfo),
-      passed: items.passed.rules.map(({ pagesAffected, ...ruleInfo }) => ruleInfo),
-    };
+      // Sort in descending order of pagesAffectedCount
+      items[category].rules.sort(
+        (a, b) => (b.pagesAffectedCount || 0) - (a.pagesAffectedCount || 0),
+      );
+    }
+  });
+
+  // Refactor scanIssuesSummary to reuse the scanItemsMiniReport structure by stripping out pagesAffected
+  const scanIssuesSummary = {
+    mustFix: items.mustFix.rules.map(({ pagesAffected, ...ruleInfo }) => ruleInfo),
+    goodToFix: items.goodToFix.rules.map(({ pagesAffected, ...ruleInfo }) => ruleInfo),
+    needsReview: items.needsReview.rules.map(({ pagesAffected, ...ruleInfo }) => ruleInfo),
+    passed: items.passed.rules.map(({ pagesAffected, ...ruleInfo }) => ruleInfo),
+  };
 
-    // Write out the scanIssuesSummary JSON using the new structure
-    const { jsonFilePath: scanIssuesSummaryJsonFilePath, base64FilePath: scanIssuesSummaryBase64FilePath } =
-    await writeJsonFileAndCompressedJsonFile({ oobeeAppVersion: allIssues.oobeeAppVersion, ...scanIssuesSummary }, storagePath, 'scanIssuesSummary');
+  // Write out the scanIssuesSummary JSON using the new structure
+  const {
+    jsonFilePath: scanIssuesSummaryJsonFilePath,
+    base64FilePath: scanIssuesSummaryBase64FilePath,
+  } = await writeJsonFileAndCompressedJsonFile(
+    { oobeeAppVersion: allIssues.oobeeAppVersion, ...scanIssuesSummary },
+    storagePath,
+    'scanIssuesSummary',
+  );
 
   // scanItemsSummary
   // the below mutates the original items object, since it is expensive to clone
@@ -848,8 +861,12 @@ const writeJsonAndBase64Files = async (
   const {
     jsonFilePath: scanItemsMiniReportJsonFilePath,
     base64FilePath: scanItemsMiniReportBase64FilePath,
-  } = await writeJsonFileAndCompressedJsonFile({ oobeeAppVersion: allIssues.oobeeAppVersion, ...summaryItemsMini }, storagePath, 'scanItemsSummaryMiniReport');
-  
+  } = await writeJsonFileAndCompressedJsonFile(
+    { oobeeAppVersion: allIssues.oobeeAppVersion, ...summaryItemsMini },
+    storagePath,
+    'scanItemsSummaryMiniReport',
+  );
+
   const summaryItems = {
     mustFix: {
       totalItems: items.mustFix?.totalItems || 0,
@@ -876,17 +893,29 @@ const writeJsonAndBase64Files = async (
   const {
     jsonFilePath: scanItemsSummaryJsonFilePath,
     base64FilePath: scanItemsSummaryBase64FilePath,
-  } = await writeJsonFileAndCompressedJsonFile({ oobeeAppVersion: allIssues.oobeeAppVersion, ...summaryItems }, storagePath, 'scanItemsSummary');
+  } = await writeJsonFileAndCompressedJsonFile(
+    { oobeeAppVersion: allIssues.oobeeAppVersion, ...summaryItems },
+    storagePath,
+    'scanItemsSummary',
+  );
 
   const {
     jsonFilePath: scanPagesDetailJsonFilePath,
-    base64FilePath: scanPagesDetailBase64FilePath
-  } = await writeJsonFileAndCompressedJsonFile({ oobeeAppVersion: allIssues.oobeeAppVersion, ...allIssues.scanPagesDetail }, storagePath, 'scanPagesDetail');
+    base64FilePath: scanPagesDetailBase64FilePath,
+  } = await writeJsonFileAndCompressedJsonFile(
+    { oobeeAppVersion: allIssues.oobeeAppVersion, ...allIssues.scanPagesDetail },
+    storagePath,
+    'scanPagesDetail',
+  );
 
   const {
     jsonFilePath: scanPagesSummaryJsonFilePath,
-    base64FilePath: scanPagesSummaryBase64FilePath
-  } = await writeJsonFileAndCompressedJsonFile({ oobeeAppVersion: allIssues.oobeeAppVersion, ...allIssues.scanPagesSummary }, storagePath, 'scanPagesSummary');
+    base64FilePath: scanPagesSummaryBase64FilePath,
+  } = await writeJsonFileAndCompressedJsonFile(
+    { oobeeAppVersion: allIssues.oobeeAppVersion, ...allIssues.scanPagesSummary },
+    storagePath,
+    'scanPagesSummary',
+  );
 
   return {
     scanDataJsonFilePath,
@@ -988,14 +1017,14 @@ const writeSummaryPdf = async (storagePath: string, pagesScanned: number, filena
   }
 };
 
-// Tracking WCAG occurrences 
+// Tracking WCAG occurrences
 const wcagOccurrencesMap = new Map<string, number>();
 
 // Format WCAG tag in requested format: wcag111a_Occurrences
 const formatWcagTag = async (wcagId: string): Promise<string | null> => {
   // Get dynamic WCAG criteria map
   const wcagCriteriaMap = await getWcagCriteriaMap();
-  
+
   if (wcagCriteriaMap[wcagId]) {
     const { level } = wcagCriteriaMap[wcagId];
     return `${wcagId}${level}_Occurrences`;
@@ -1054,7 +1083,7 @@ const pushResults = async (pageResults, allIssues, isCustomFlow) => {
             if (!allIssues.wcagViolations.includes(c)) {
               allIssues.wcagViolations.push(c);
             }
-            
+
             // Track WCAG criteria occurrences for Sentry
             const currentCount = wcagOccurrencesMap.get(c) || 0;
             wcagOccurrencesMap.set(c, currentCount + count);
@@ -1148,35 +1177,31 @@ const flattenAndSortResults = (allIssues: AllIssues, isCustomFlow: boolean) => {
   const urlOccurrencesMap = new Map<string, number>();
 
   // Iterate over all categories; update the map only if the category is not "passed"
-  ['mustFix', 'goodToFix', 'needsReview', 'passed'].forEach((category) => {
+  ['mustFix', 'goodToFix', 'needsReview', 'passed'].forEach(category => {
     // Accumulate totalItems regardless of category.
     allIssues.totalItems += allIssues.items[category].totalItems;
 
     allIssues.items[category].rules = Object.entries(allIssues.items[category].rules)
-      .map((ruleEntry) => {
+      .map(ruleEntry => {
         const [rule, ruleInfo] = ruleEntry as [string, RuleInfo];
         ruleInfo.pagesAffected = Object.entries(ruleInfo.pagesAffected)
-          .map((pageEntry) => {
+          .map(pageEntry => {
             if (isCustomFlow) {
               const [pageIndex, pageInfo] = pageEntry as unknown as [number, PageInfo];
               // Only update the occurrences map if not passed.
               if (category !== 'passed') {
                 urlOccurrencesMap.set(
                   pageInfo.url!,
-                  (urlOccurrencesMap.get(pageInfo.url!) || 0) + pageInfo.items.length
+                  (urlOccurrencesMap.get(pageInfo.url!) || 0) + pageInfo.items.length,
                 );
               }
               return { pageIndex, ...pageInfo };
-            } else {
-              const [url, pageInfo] = pageEntry as unknown as [string, PageInfo];
-              if (category !== 'passed') {
-                urlOccurrencesMap.set(
-                  url,
-                  (urlOccurrencesMap.get(url) || 0) + pageInfo.items.length
-                );
-              }
-              return { url, ...pageInfo };
             }
+            const [url, pageInfo] = pageEntry as unknown as [string, PageInfo];
+            if (category !== 'passed') {
+              urlOccurrencesMap.set(url, (urlOccurrencesMap.get(url) || 0) + pageInfo.items.length);
+            }
+            return { url, ...pageInfo };
           })
           // Sort pages so that those with the most items come first
           .sort((page1, page2) => page2.items.length - page1.items.length);
@@ -1203,12 +1228,11 @@ const flattenAndSortResults = (allIssues: AllIssues, isCustomFlow: boolean) => {
 // Helper: Update totalOccurrences for each issue using our urlOccurrencesMap.
 // For pages that have only passed items, the map will return undefined, so default to 0.
 function updateIssuesWithOccurrences(issuesList: any[], urlOccurrencesMap: Map<string, number>) {
-  issuesList.forEach((issue) => {
+  issuesList.forEach(issue => {
     issue.totalOccurrences = urlOccurrencesMap.get(issue.url) || 0;
   });
 }
 
-
 const createRuleIdJson = allIssues => {
   const compiledRuleJson = {};
 
@@ -1224,7 +1248,9 @@ const createRuleIdJson = allIssues => {
         });
       });
       snippets = [...snippetsSet];
-      rule.pagesAffected.forEach(p => { delete p.items; });
+      rule.pagesAffected.forEach(p => {
+        delete p.items;
+      });
     }
     compiledRuleJson[ruleId] = {
       snippets,
@@ -1254,17 +1280,15 @@ function populateScanPagesDetail(allIssues: AllIssues): void {
   // --------------------------------------------
   // 1) Gather your "scanned" pages from allIssues
   // --------------------------------------------
-  const allScannedPages = Array.isArray(allIssues.pagesScanned)
-    ? allIssues.pagesScanned
-    : [];
+  const allScannedPages = Array.isArray(allIssues.pagesScanned) ? allIssues.pagesScanned : [];
 
   // --------------------------------------------
   // 2) Define category constants (optional, just for clarity)
   // --------------------------------------------
-  const mustFixCategory = "mustFix";      
-  const goodToFixCategory = "goodToFix";  
-  const needsReviewCategory = "needsReview"; 
-  const passedCategory = "passed";           
+  const mustFixCategory = 'mustFix';
+  const goodToFixCategory = 'goodToFix';
+  const needsReviewCategory = 'needsReview';
+  const passedCategory = 'passed';
 
   // --------------------------------------------
   // 3) Set up type declarations (if you want them local to this function)
@@ -1284,8 +1308,8 @@ function populateScanPagesDetail(allIssues: AllIssues): void {
     // Summaries
     totalOccurrencesFailedIncludingNeedsReview: number; // mustFix + goodToFix + needsReview
     totalOccurrencesFailedExcludingNeedsReview: number; // mustFix + goodToFix
-    totalOccurrencesNeedsReview: number;                // needsReview
-    totalOccurrencesPassed: number;                     // passed only
+    totalOccurrencesNeedsReview: number; // needsReview
+    totalOccurrencesPassed: number; // passed only
     typesOfIssues: Record<string, RuleData>;
   };
 
@@ -1360,9 +1384,7 @@ function populateScanPagesDetail(allIssues: AllIssues): void {
   const pagesInMapUrls = new Set(Object.keys(pagesMap));
 
   // (a) Pages with only passed (no mustFix/goodToFix/needsReview)
-  const pagesAllPassed = pagesInMap.filter(
-    p => p.totalOccurrencesFailedIncludingNeedsReview === 0
-  );
+  const pagesAllPassed = pagesInMap.filter(p => p.totalOccurrencesFailedIncludingNeedsReview === 0);
 
   // (b) Pages that do NOT appear in pagesMap at all => scanned but no items found
   const pagesNoEntries = allScannedPages
@@ -1381,9 +1403,7 @@ function populateScanPagesDetail(allIssues: AllIssues): void {
   const pagesNotAffectedRaw = [...pagesAllPassed, ...pagesNoEntries];
 
   // "affected" pages => have at least 1 mustFix/goodToFix/needsReview
-  const pagesAffectedRaw = pagesInMap.filter(
-    p => p.totalOccurrencesFailedIncludingNeedsReview > 0
-  );
+  const pagesAffectedRaw = pagesInMap.filter(p => p.totalOccurrencesFailedIncludingNeedsReview > 0);
 
   // --------------------------------------------
   // 7) Transform both arrays to the final shape
@@ -1398,16 +1418,18 @@ function populateScanPagesDetail(allIssues: AllIssues): void {
 
     // Build categoriesPresent based on nonzero failing counts
     const categoriesPresent: string[] = [];
-    if (mustFixSum > 0) categoriesPresent.push("mustFix");
-    if (goodToFixSum > 0) categoriesPresent.push("goodToFix");
-    if (needsReviewSum > 0) categoriesPresent.push("needsReview");
+    if (mustFixSum > 0) categoriesPresent.push('mustFix');
+    if (goodToFixSum > 0) categoriesPresent.push('goodToFix');
+    if (needsReviewSum > 0) categoriesPresent.push('needsReview');
 
     // Count how many rules have failing issues
     const failedRuleIds = new Set<string>();
     typesOfIssuesArray.forEach(r => {
-      if ((r.occurrencesMustFix || 0) > 0 ||
-          (r.occurrencesGoodToFix || 0) > 0 ||
-          (r.occurrencesNeedsReview || 0) > 0) {
+      if (
+        (r.occurrencesMustFix || 0) > 0 ||
+        (r.occurrencesGoodToFix || 0) > 0 ||
+        (r.occurrencesNeedsReview || 0) > 0
+      ) {
         failedRuleIds.add(r.ruleId); // Ensure ruleId is unique
       }
     });
@@ -1415,16 +1437,16 @@ function populateScanPagesDetail(allIssues: AllIssues): void {
 
     // Possibly these two for future convenience
     const typesOfIssuesExcludingNeedsReviewCount = typesOfIssuesArray.filter(
-      r => (r.occurrencesMustFix || 0) + (r.occurrencesGoodToFix || 0) > 0
+      r => (r.occurrencesMustFix || 0) + (r.occurrencesGoodToFix || 0) > 0,
     ).length;
 
     const typesOfIssuesExclusiveToNeedsReviewCount = typesOfIssuesArray.filter(
       r =>
         (r.occurrencesNeedsReview || 0) > 0 &&
         (r.occurrencesMustFix || 0) === 0 &&
-        (r.occurrencesGoodToFix || 0) === 0
+        (r.occurrencesGoodToFix || 0) === 0,
     ).length;
-    
+
     // Aggregate wcagConformance for rules that actually fail
     const allConformance = typesOfIssuesArray.reduce((acc, curr) => {
       const nonPassedCount =
@@ -1484,9 +1506,7 @@ function populateScanPagesDetail(allIssues: AllIssues): void {
     pagesAffected,
     pagesNotAffected,
     scannedPagesCount,
-    pagesNotScanned: Array.isArray(allIssues.pagesNotScanned)
-      ? allIssues.pagesNotScanned
-      : [],
+    pagesNotScanned: Array.isArray(allIssues.pagesNotScanned) ? allIssues.pagesNotScanned : [],
     pagesNotScannedCount,
   };
 
@@ -1505,9 +1525,7 @@ function populateScanPagesDetail(allIssues: AllIssues): void {
     pagesAffected: summaryPagesAffected,
     pagesNotAffected: summaryPagesNotAffected,
     scannedPagesCount,
-    pagesNotScanned: Array.isArray(allIssues.pagesNotScanned)
-      ? allIssues.pagesNotScanned
-      : [],
+    pagesNotScanned: Array.isArray(allIssues.pagesNotScanned) ? allIssues.pagesNotScanned : [],
     pagesNotScannedCount,
   };
 }
@@ -1515,25 +1533,39 @@ function populateScanPagesDetail(allIssues: AllIssues): void {
 // Send WCAG criteria breakdown to Sentry
 const sendWcagBreakdownToSentry = async (
   wcagBreakdown: Map<string, number>,
+  ruleIdJson: any,
   scanInfo: {
     entryUrl: string;
     scanType: string;
     browser: string;
     email?: string;
     name?: string;
-  }
+  },
+  allIssues?: AllIssues,
+  pagesScannedCount: number = 0,
 ) => {
   try {
     // Initialize Sentry
     Sentry.init(sentryConfig);
+    // Set user ID for Sentry tracking
+    const userData = getUserDataTxt();
+    if (userData && userData.userId) {
+      setSentryUser(userData.userId);
+    }
 
     // Prepare tags for the event
     const tags: Record<string, string> = {};
-    const wcagCriteriaBreakdown: Record<string, number> = {};
-    
+    const wcagCriteriaBreakdown: Record<string, any> = {};
+
     // Get dynamic WCAG criteria map once
     const wcagCriteriaMap = await getWcagCriteriaMap();
-    
+
+    // Categorize all WCAG criteria for reporting
+    const wcagIds = Array.from(
+      new Set([...Object.keys(wcagCriteriaMap), ...Array.from(wcagBreakdown.keys())]),
+    );
+    const categorizedWcag = await categorizeWcagCriteria(wcagIds);
+
     // First ensure all WCAG criteria are included in the tags with a value of 0
     // This ensures criteria with no violations are still reported
     for (const [wcagId, info] of Object.entries(wcagCriteriaMap)) {
@@ -1541,51 +1573,117 @@ const sendWcagBreakdownToSentry = async (
       if (formattedTag) {
         // Initialize with zero
         tags[formattedTag] = '0';
-        wcagCriteriaBreakdown[formattedTag] = 0;
+
+        // Store in breakdown object with category information
+        wcagCriteriaBreakdown[formattedTag] = {
+          count: 0,
+          category: categorizedWcag[wcagId] || 'mustFix', // Default to mustFix if not found
+        };
       }
     }
-    
+
     // Now override with actual counts from the scan
     for (const [wcagId, count] of wcagBreakdown.entries()) {
       const formattedTag = await formatWcagTag(wcagId);
       if (formattedTag) {
         // Add as a tag with the count as value
         tags[formattedTag] = String(count);
-        
-        // Store in breakdown object for the extra data
-        wcagCriteriaBreakdown[formattedTag] = count;
+
+        // Update count in breakdown object
+        if (wcagCriteriaBreakdown[formattedTag]) {
+          wcagCriteriaBreakdown[formattedTag].count = count;
+        } else {
+          // If somehow this wasn't in our initial map
+          wcagCriteriaBreakdown[formattedTag] = {
+            count,
+            category: categorizedWcag[wcagId] || 'mustFix',
+          };
+        }
       }
     }
-    
-    // Calculate the WCAG passing percentage
-    const totalCriteria = Object.keys(wcagCriteriaMap).length;
-    const violatedCriteria = wcagBreakdown.size;
-    const passingPercentage = Math.round(((totalCriteria - violatedCriteria) / totalCriteria) * 100);
-    
-    // Add the percentage as a tag
-    tags['WCAG-Percentage-Passed'] = String(passingPercentage);
-    
+
+    // Calculate category counts based on actual issue counts from the report
+    // rather than occurrence counts from wcagBreakdown
+    const categoryCounts = {
+      mustFix: 0,
+      goodToFix: 0,
+      needsReview: 0,
+    };
+
+    if (allIssues) {
+      // Use the actual report data for the counts
+      categoryCounts.mustFix = allIssues.items.mustFix.rules.length;
+      categoryCounts.goodToFix = allIssues.items.goodToFix.rules.length;
+      categoryCounts.needsReview = allIssues.items.needsReview.rules.length;
+    } else {
+      // Fallback to the old way if allIssues not provided
+      Object.values(wcagCriteriaBreakdown).forEach(item => {
+        if (item.count > 0 && categoryCounts[item.category] !== undefined) {
+          categoryCounts[item.category] += 1; // Count rules, not occurrences
+        }
+      });
+    }
+
+    // Add category counts as tags
+    tags['WCAG-MustFix-Count'] = String(categoryCounts.mustFix);
+    tags['WCAG-GoodToFix-Count'] = String(categoryCounts.goodToFix);
+    tags['WCAG-NeedsReview-Count'] = String(categoryCounts.needsReview);
+
+    // Also add occurrence counts for reference
+    if (allIssues) {
+      tags['WCAG-MustFix-Occurrences'] = String(allIssues.items.mustFix.totalItems);
+      tags['WCAG-GoodToFix-Occurrences'] = String(allIssues.items.goodToFix.totalItems);
+      tags['WCAG-NeedsReview-Occurrences'] = String(allIssues.items.needsReview.totalItems);
+      
+      // Add number of pages scanned tag
+      tags['Pages-Scanned-Count'] = String(allIssues.totalPagesScanned);
+    } else if (pagesScannedCount > 0) {
+      // Still add the pages scanned count even if we don't have allIssues
+      tags['Pages-Scanned-Count'] = String(pagesScannedCount);
+    }
+
     // Send the event to Sentry
     await Sentry.captureEvent({
-      message: `WCAG Accessibility Scan Results for ${scanInfo.entryUrl}`,
+      message: 'Accessibility Scan Completed',
       level: 'info',
       tags: {
         ...tags,
         event_type: 'accessibility_scan',
         scanType: scanInfo.scanType,
         browser: scanInfo.browser,
+        entryUrl: scanInfo.entryUrl,
+      },
+      user: {
+        ...(scanInfo.email && scanInfo.name
+          ? {
+              email: scanInfo.email,
+              username: scanInfo.name,
+            }
+          : {}),
+        ...(userData && userData.userId ? { id: userData.userId } : {}),
       },
-      user: scanInfo.email && scanInfo.name ? {
-        email: scanInfo.email,
-        username: scanInfo.name
-      } : undefined,
       extra: {
-        entryUrl: scanInfo.entryUrl,
+        additionalScanMetadata: ruleIdJson != null ? JSON.stringify(ruleIdJson)  : "{}",
         wcagBreakdown: wcagCriteriaBreakdown,
-        wcagPassPercentage: passingPercentage
-      }
+        reportCounts: allIssues
+          ? {
+              mustFix: {
+                issues: allIssues.items.mustFix.rules?.length ?? 0,
+                occurrences: allIssues.items.mustFix.totalItems ?? 0,
+              },
+              goodToFix: {
+                issues: allIssues.items.goodToFix.rules?.length ?? 0,
+                occurrences: allIssues.items.goodToFix.totalItems ?? 0,
+              },
+              needsReview: {
+                issues: allIssues.items.needsReview.rules?.length ?? 0,
+                occurrences: allIssues.items.needsReview.totalItems ?? 0,
+              },
+            }
+          : undefined,
+      },
     });
-    
+
     // Wait for events to be sent
     await Sentry.flush(2000);
   } catch (error) {
@@ -1765,13 +1863,20 @@ const generateArtifacts = async (
 
   populateScanPagesDetail(allIssues);
 
-  allIssues.wcagPassPercentage = getWcagPassPercentage(allIssues.wcagViolations, allIssues.advancedScanOptionsSummaryItems.showEnableWcagAaa);
-  allIssues.progressPercentage = getProgressPercentage(allIssues.scanPagesDetail, allIssues.advancedScanOptionsSummaryItems.showEnableWcagAaa);
-  
+  allIssues.wcagPassPercentage = getWcagPassPercentage(
+    allIssues.wcagViolations,
+    allIssues.advancedScanOptionsSummaryItems.showEnableWcagAaa,
+  );
+  allIssues.progressPercentage = getProgressPercentage(
+    allIssues.scanPagesDetail,
+    allIssues.advancedScanOptionsSummaryItems.showEnableWcagAaa,
+  );
+
   allIssues.issuesPercentage = await getIssuesPercentage(
-    allIssues.scanPagesDetail, 
-    allIssues.advancedScanOptionsSummaryItems.showEnableWcagAaa, 
-    allIssues.advancedScanOptionsSummaryItems.disableOobee);
+    allIssues.scanPagesDetail,
+    allIssues.advancedScanOptionsSummaryItems.showEnableWcagAaa,
+    allIssues.advancedScanOptionsSummaryItems.disableOobee,
+  );
 
   // console.log(allIssues.progressPercentage);
   // console.log(allIssues.issuesPercentage);
@@ -1910,24 +2015,31 @@ const generateArtifacts = async (
       printMessage([`Error in zipping results: ${error}`]);
     });
 
+  // Generate scrubbed HTML Code Snippets
+  const ruleIdJson = createRuleIdJson(allIssues);
+
   // At the end of the function where results are generated, add:
   try {
     // Always send WCAG breakdown to Sentry, even if no violations were found
     // This ensures that all criteria are reported, including those with 0 occurrences
-    await sendWcagBreakdownToSentry(wcagOccurrencesMap, {
-      entryUrl: urlScanned,
-      scanType: scanType,
-      browser: scanDetails.deviceChosen,
-      ...(scanDetails.nameEmail && {
-        email: scanDetails.nameEmail.email,
-        name: scanDetails.nameEmail.name
-      })
-    });
+    await sendWcagBreakdownToSentry(
+      wcagOccurrencesMap,
+      ruleIdJson,
+      {
+        entryUrl: urlScanned,
+        scanType,
+        browser: scanDetails.deviceChosen,
+        email: scanDetails.nameEmail?.email,
+        name: scanDetails.nameEmail?.name,
+      },
+      allIssues,
+      pagesScanned.length,
+    );
   } catch (error) {
     console.error('Error sending WCAG data to Sentry:', error);
   }
 
-  return createRuleIdJson(allIssues);
+  return ruleIdJson;
 };
 
 export default generateArtifacts;

package/src/utils.ts

@@ -3,6 +3,7 @@ import path from 'path';
 import os from 'os';
 import fs from 'fs-extra';
 import axe, { Rule } from 'axe-core';
+import { v4 as uuidv4 } from 'uuid';
 import constants, {
   BrowserTypes,
   destinationPath,
@@ -97,6 +98,11 @@ export const getUserDataTxt = () => {
   // check if textFilePath exists
   if (fs.existsSync(textFilePath)) {
     const userData = JSON.parse(fs.readFileSync(textFilePath, 'utf8'));
+    // If userId doesn't exist, generate one and save it
+    if (!userData.userId) {
+      userData.userId = uuidv4();
+      fs.writeFileSync(textFilePath, JSON.stringify(userData, null, 2));
+    }
     return userData;
   }
   return null;
@@ -109,13 +115,18 @@ export const writeToUserDataTxt = async (key: string, value: string): Promise<vo
   if (fs.existsSync(textFilePath)) {
     const userData = JSON.parse(fs.readFileSync(textFilePath, 'utf8'));
     userData[key] = value;
+    // Ensure userId exists
+    if (!userData.userId) {
+      userData.userId = uuidv4();
+    }
     fs.writeFileSync(textFilePath, JSON.stringify(userData, null, 2));
   } else {
     const textFilePathDir = path.dirname(textFilePath);
     if (!fs.existsSync(textFilePathDir)) {
       fs.mkdirSync(textFilePathDir, { recursive: true });
     }
-    fs.appendFileSync(textFilePath, JSON.stringify({ [key]: value }, null, 2));
+    // Initialize with userId
+    fs.appendFileSync(textFilePath, JSON.stringify({ [key]: value, userId: uuidv4() }, null, 2));
   }
 };
 
@@ -777,3 +788,231 @@ export const retryFunction = async <T>(func: () => Promise<T>, maxAttempt: numbe
   }
   throw new Error('Maximum number of attempts reached');
 };
+
+/**
+ * Determines which WCAG criteria might appear in the "needsReview" category
+ * based on axe-core's rule configuration.
+ * 
+ * This dynamically analyzes the rules that might produce "incomplete" results which
+ * get categorized as "needsReview" during scans.
+ * 
+ * @param enableWcagAaa Whether to include WCAG AAA criteria
+ * @param disableOobee Whether to disable custom Oobee rules
+ * @returns A map of WCAG criteria IDs to whether they may produce needsReview results
+ */
+export const getPotentialNeedsReviewWcagCriteria = async (
+  enableWcagAaa: boolean = true,
+  disableOobee: boolean = false
+): Promise<Record<string, boolean>> => {
+  // Reuse configuration setup from other functions
+  const axeConfig = getAxeConfiguration({
+    enableWcagAaa,
+    gradingReadabilityFlag: '',
+    disableOobee,
+  });
+
+  // Configure axe-core with our settings
+  axe.configure(axeConfig);
+  
+  // Get all rules from axe-core
+  const allRules = axe.getRules();
+  
+  // Set to store rule IDs that might produce incomplete results
+  const rulesLikelyToProduceIncomplete = new Set<string>();
+  
+  // Dynamically analyze each rule and its checks to determine if it might produce incomplete results
+  for (const rule of allRules) {
+    try {
+      // Skip disabled rules
+      const customRule = axeConfig.rules.find(r => r.id === rule.ruleId);
+      if (customRule && customRule.enabled === false) continue;
+      
+      // Skip frame-tested rule as it's handled specially
+      if (rule.ruleId === 'frame-tested') continue;
+      
+      // Get the rule object from axe-core's internal data
+      const ruleObj = (axe as any)._audit?.rules?.find(r => r.id === rule.ruleId);
+      if (!ruleObj) continue;
+      
+      // For each check in the rule, determine if it might produce an "incomplete" result
+      const checks = [
+        ...(ruleObj.any || []),
+        ...(ruleObj.all || []),
+        ...(ruleObj.none || [])
+      ];
+      
+      // Get check details from axe-core's internal data
+      for (const checkId of checks) {
+        const check = (axe as any)._audit?.checks?.[checkId];
+        if (!check) continue;
+        
+        // A check can produce incomplete results if:
+        // 1. It has an "incomplete" message
+        // 2. Its evaluate function explicitly returns undefined
+        // 3. It is known to need human verification (accessibility issues that are context-dependent)
+        const hasIncompleteMessage = check.messages && 'incomplete' in check.messages;
+        
+        // Many checks are implemented as strings that are later evaluated to functions
+        const evaluateCode = check.evaluate ? check.evaluate.toString() : '';
+        const explicitlyReturnsUndefined = evaluateCode.includes('return undefined') || 
+                                          evaluateCode.includes('return;');
+        
+        // Some checks use specific patterns that indicate potential for incomplete results
+        const indicatesManualVerification = 
+          evaluateCode.includes('return undefined') ||
+          evaluateCode.includes('this.data(') ||
+          evaluateCode.includes('options.reviewOnFail') ||
+          evaluateCode.includes('incomplete') ||
+          (check.metadata && check.metadata.incomplete === true);
+        
+        if (hasIncompleteMessage || explicitlyReturnsUndefined || indicatesManualVerification) {
+          rulesLikelyToProduceIncomplete.add(rule.ruleId);
+          break; // One check is enough to mark the rule
+        }
+      }
+      
+      // Also check rule-level metadata for indicators of potential incomplete results
+      if (ruleObj.metadata) {
+        if (ruleObj.metadata.incomplete === true ||
+            (ruleObj.metadata.messages && 'incomplete' in ruleObj.metadata.messages)) {
+          rulesLikelyToProduceIncomplete.add(rule.ruleId);
+        }
+      }
+    } catch (e) {
+      // Silently continue if we encounter errors analyzing a rule
+      // This is a safeguard against unexpected changes in axe-core's internal structure
+    }
+  }
+  
+  // Also check custom Oobee rules if they're enabled
+  if (!disableOobee) {
+    for (const rule of axeConfig.rules || []) {
+      if (!rule.enabled) continue;
+      
+      // Check if the rule's metadata indicates it might produce incomplete results
+      try {
+        const hasIncompleteMessage = 
+          ((rule as any)?.metadata?.messages?.incomplete !== undefined) ||
+          (axeConfig.checks || []).some(check => 
+            check.id === rule.id && 
+            (check.metadata?.messages?.incomplete !== undefined));
+        
+        if (hasIncompleteMessage) {
+          rulesLikelyToProduceIncomplete.add(rule.id);
+        }
+      } catch (e) {
+        // Continue if we encounter errors
+      }
+    }
+  }
+  
+  // Map from WCAG criteria IDs to whether they might produce needsReview results
+  const potentialNeedsReviewCriteria: Record<string, boolean> = {};
+  
+  // Process each rule to map to WCAG criteria
+  for (const rule of allRules) {
+    if (rule.ruleId === 'frame-tested') continue;
+    
+    const tags = rule.tags || [];
+    if (tags.includes('experimental') || tags.includes('deprecated')) continue;
+    
+    // Map rule to WCAG criteria
+    for (const tag of tags) {
+      if (/^wcag\d+$/.test(tag)) {
+        const mightNeedReview = rulesLikelyToProduceIncomplete.has(rule.ruleId);
+        
+        // If we haven't seen this criterion before or we're updating it to true
+        if (mightNeedReview || !potentialNeedsReviewCriteria[tag]) {
+          potentialNeedsReviewCriteria[tag] = mightNeedReview;
+        }
+      }
+    }
+  }
+  
+  return potentialNeedsReviewCriteria;
+};
+
+/**
+ * Categorizes a WCAG criterion into one of: "mustFix", "goodToFix", or "needsReview"
+ * for use in Sentry reporting
+ * 
+ * @param wcagId The WCAG criterion ID (e.g., "wcag144")
+ * @param enableWcagAaa Whether WCAG AAA criteria are enabled
+ * @param disableOobee Whether Oobee custom rules are disabled
+ * @returns The category: "mustFix", "goodToFix", or "needsReview"
+ */
+export const categorizeWcagCriterion = async (
+  wcagId: string,
+  enableWcagAaa: boolean = true,
+  disableOobee: boolean = false
+): Promise<'mustFix' | 'goodToFix' | 'needsReview'> => {
+  // First check if this criterion might produce "needsReview" results
+  const needsReviewMap = await getPotentialNeedsReviewWcagCriteria(enableWcagAaa, disableOobee);
+  if (needsReviewMap[wcagId]) {
+    return 'needsReview';
+  }
+  
+  // Get the WCAG criteria map to check the level
+  const wcagCriteriaMap = await getWcagCriteriaMap(enableWcagAaa, disableOobee);
+  const criterionInfo = wcagCriteriaMap[wcagId];
+  
+  if (!criterionInfo) {
+    // If we can't find info, default to mustFix for safety
+    return 'mustFix';
+  }
+  
+  // Check if it's a level A or AA criterion (mustFix) or AAA (goodToFix)
+  if (criterionInfo.level === 'a' || criterionInfo.level === 'aa') {
+    return 'mustFix';
+  } else {
+    return 'goodToFix';
+  }
+};
+
+/**
+ * Batch categorizes multiple WCAG criteria for Sentry reporting
+ * 
+ * @param wcagIds Array of WCAG criterion IDs (e.g., ["wcag144", "wcag143"])
+ * @param enableWcagAaa Whether WCAG AAA criteria are enabled
+ * @param disableOobee Whether Oobee custom rules are disabled
+ * @returns Object mapping each criterion to its category
+ */
+export const categorizeWcagCriteria = async (
+  wcagIds: string[],
+  enableWcagAaa: boolean = true,
+  disableOobee: boolean = false
+): Promise<Record<string, 'mustFix' | 'goodToFix' | 'needsReview'>> => {
+  // Get both maps once to avoid repeated expensive calls
+  const [needsReviewMap, wcagCriteriaMap] = await Promise.all([
+    getPotentialNeedsReviewWcagCriteria(enableWcagAaa, disableOobee),
+    getWcagCriteriaMap(enableWcagAaa, disableOobee)
+  ]);
+  
+  const result: Record<string, 'mustFix' | 'goodToFix' | 'needsReview'> = {};
+  
+  wcagIds.forEach(wcagId => {
+    // First check if this criterion might produce "needsReview" results
+    if (needsReviewMap[wcagId]) {
+      result[wcagId] = 'needsReview';
+      return;
+    }
+    
+    // Get criterion info
+    const criterionInfo = wcagCriteriaMap[wcagId];
+    
+    if (!criterionInfo) {
+      // If we can't find info, default to mustFix for safety
+      result[wcagId] = 'mustFix';
+      return;
+    }
+    
+    // Check if it's a level A or AA criterion (mustFix) or AAA (goodToFix)
+    if (criterionInfo.level === 'a' || criterionInfo.level === 'aa') {
+      result[wcagId] = 'mustFix';
+    } else {
+      result[wcagId] = 'goodToFix';
+    }
+  });
+  
+  return result;
+};