@govtechsg/oobee 0.10.91 → 0.10.93

package/dist/mergeAxeResults/itemsStore.js

@@ -1,9 +1,11 @@
 import fs from 'fs-extra';
 import path from 'path';
 import readline from 'readline';
+import { consoleLogger } from '../logs.js';
 export class ItemsStore {
     constructor(storagePath) {
         this.ensuredDirs = new Set();
+        this.fileWriteQueues = new Map();
         this.basePath = path.join(storagePath, 'tmp-items');
     }
     sanitizeRuleId(ruleId) {
@@ -22,8 +24,25 @@ export class ItemsStore {
     async appendPageItems(category, ruleId, entry) {
         await this.ensureDir(category);
         const filePath = this.getRuleFilePath(category, ruleId);
-        const line = JSON.stringify(entry) + '\n';
-        await fs.appendFile(filePath, line, 'utf8');
+        let line = JSON.stringify(entry);
+        // JSON.stringify should never produce literal newlines inside strings, but HTML content
+        // from page evaluation may contain edge-case characters (e.g. unescaped control chars in
+        // non-spec-compliant innerHTML). Strip any embedded \r or \n that would break JSONL format readline parsing.
+        line = line.replace(/[\n\r]/g, (match) => {
+            if (match === '\n')
+                return '\\n';
+            if (match === '\r')
+                return '\\r';
+            return match;
+        });
+        line += '\n';
+        // Serialize writes per rule file to avoid concurrent append interleaving/truncation.
+        const previous = this.fileWriteQueues.get(filePath) ?? Promise.resolve();
+        const next = previous.then(() => fs.appendFile(filePath, line, 'utf8'));
+        this.fileWriteQueues.set(filePath, next.catch(() => {
+            // Keep queue alive for subsequent writes.
+        }));
+        await next;
     }
     async *readRuleItems(category, ruleId) {
         const filePath = this.getRuleFilePath(category, ruleId);
@@ -31,10 +50,19 @@ export class ItemsStore {
             return;
         const fileStream = fs.createReadStream(filePath, { encoding: 'utf8' });
         const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
+        let lineNumber = 0;
         for await (const line of rl) {
-            if (line.trim()) {
+            lineNumber += 1;
+            if (!line.trim())
+                continue;
+            try {
                 yield JSON.parse(line);
             }
+            catch (error) {
+                // Tolerate malformed/truncated JSONL lines (e.g. interrupted append) so report generation can continue.
+                const preview = line.slice(0, 200);
+                consoleLogger.warn(`Skipping malformed itemsStore JSONL line ${lineNumber} in ${filePath}: ${error.message}. Content preview: ${preview}`);
+            }
         }
     }
     async readRuleItemsMap(category, ruleId) {
@@ -46,6 +74,7 @@ export class ItemsStore {
         return map;
     }
     async cleanup() {
+        await Promise.all(this.fileWriteQueues.values());
         await fs.rm(this.basePath, { recursive: true, force: true });
     }
 }

package/dist/mergeAxeResults/sentryTelemetry.js

@@ -114,6 +114,9 @@ const sendWcagBreakdownToSentry = async (appVersion, wcagBreakdown, ruleIdJson,
                 ...(process.env.OOBEE_SCAN_PRODUCT && {
                     scanProduct: process.env.OOBEE_SCAN_PRODUCT,
                 }),
+                ...(process.env.OOBEE_TAGGED_WEBSITE && {
+                    websiteTag: process.env.OOBEE_TAGGED_WEBSITE,
+                }),
             },
             user: {
                 ...(scanInfo.email && scanInfo.name

package/dist/mergeAxeResults.js

@@ -5,6 +5,7 @@ import printMessage from 'print-message';
 import path from 'path';
 import ejs from 'ejs';
 import { fileURLToPath } from 'url';
+import { Dataset, RequestQueue, Configuration } from 'crawlee';
 import constants, { BrowserTypes, ScannerTypes, WCAGclauses, a11yRuleShortDescriptionMap, disabilityBadgesMap, a11yRuleLongDescriptionMap, a11yRuleStepByStepGuide, } from './constants/constants.js';
 import { getBrowserToRun, getPlaywrightLaunchOptions } from './constants/common.js';
 import { createScreenshotsFolder, getStoragePath, getVersion, getWcagPassPercentage, getProgressPercentage, retryFunction, zipResults, getIssuesPercentage, register, } from './utils.js';
@@ -255,54 +256,84 @@ const cleanUpJsonFiles = async (filesToDelete) => {
     });
 };
 const writeSummaryPdf = async (storagePath, pagesScanned, filename = 'summary', browser, _userDataDirectory) => {
-    let browserInstance;
-    let context;
-    let page;
-    try {
-        const htmlFilePath = path.join(storagePath, `${filename}.html`);
-        const fileDestinationPath = path.join(storagePath, `${filename}.pdf`);
-        const htmlFileUrl = `file://${htmlFilePath}`;
-        const launchOptions = getPlaywrightLaunchOptions(browser);
-        browserInstance = await constants.launcher.launch({
-            ...launchOptions,
-            headless: true,
-        });
-        register(browserInstance);
-        context = await browserInstance.newContext();
-        page = await context.newPage();
-        await page.goto(htmlFileUrl, {
-            waitUntil: 'domcontentloaded',
-            timeout: 120000,
-        });
-        await page.emulateMedia({ media: 'print' });
-        await page.pdf({
-            margin: { bottom: '32px' },
-            path: fileDestinationPath,
-            format: 'A4',
-            displayHeaderFooter: true,
-            footerTemplate: `
+    const renderPdfWithBrowser = async (browserToUse) => {
+        let browserInstance;
+        let context;
+        let page;
+        try {
+            const htmlFilePath = path.join(storagePath, `${filename}.html`);
+            const fileDestinationPath = path.join(storagePath, `${filename}.pdf`);
+            const htmlFileUrl = `file://${htmlFilePath}`;
+            const launchOptions = getPlaywrightLaunchOptions(browserToUse);
+            browserInstance = await constants.launcher.launch({
+                ...launchOptions,
+                headless: true,
+            });
+            register(browserInstance);
+            context = await browserInstance.newContext();
+            page = await context.newPage();
+            await page.goto(htmlFileUrl, {
+                waitUntil: 'domcontentloaded',
+                timeout: 120000,
+            });
+            await page.emulateMedia({ media: 'print' });
+            await page.pdf({
+                margin: { bottom: '32px' },
+                path: fileDestinationPath,
+                format: 'A4',
+                displayHeaderFooter: true,
+                footerTemplate: `
     <div style="margin-top:50px;color:#26241b;font-family:Open Sans;text-align: center;width: 100%;font-weight:400">
       <span style="color:#26241b;font-size: 14px;font-weight:400">Page <span class="pageNumber"></span> of <span class="totalPages"></span></span>
     </div>
   `,
-        });
-        if (pagesScanned < 2000) {
+            });
             fs.unlinkSync(htmlFilePath);
         }
+        finally {
+            try {
+                await page?.close();
+            }
+            catch (err) {
+                consoleLogger.info(`Error at page close writeSummaryPDF ${err}`);
+            }
+            try {
+                await context?.close();
+            }
+            catch (err) {
+                consoleLogger.info(`Error at context close writeSummaryPDF ${err}`);
+            }
+            try {
+                await browserInstance?.close();
+            }
+            catch (err) {
+                consoleLogger.info(`Error at browserInstance close writeSummaryPDF ${err}`);
+            }
+        }
+    };
+    const browserAttempts = [browser];
+    // Runtime fallback: if Chrome launch fails on Windows, try Edge once for PDF generation.
+    if (process.platform === 'win32' && browser === BrowserTypes.CHROME) {
+        browserAttempts.push(BrowserTypes.EDGE);
     }
-    catch (err) {
-        consoleLogger.info(`Error at writeSummaryPDF ${err instanceof Error ? err.stack : err}`);
-    }
-    finally {
-        await page?.close().catch(err => {
-            consoleLogger.info(`Error at page close writeSummaryPDF ${err}`);
-        });
-        await context?.close().catch(err => {
-            consoleLogger.info(`Error at context close writeSummaryPDF ${err}`);
-        });
-        await browserInstance?.close().catch(err => {
-            consoleLogger.info(`Error at browserInstance close writeSummaryPDF ${err}`);
-        });
+    for (let i = 0; i < browserAttempts.length; i++) {
+        const currentBrowser = browserAttempts[i];
+        try {
+            await renderPdfWithBrowser(currentBrowser);
+            if (i > 0) {
+                consoleLogger.warn(`writeSummaryPDF succeeded with fallback browser '${currentBrowser}' after '${browser}' failed.`);
+            }
+            return;
+        }
+        catch (err) {
+            const isLastAttempt = i === browserAttempts.length - 1;
+            consoleLogger.info(`Error at writeSummaryPDF using browser '${currentBrowser}': ${err instanceof Error ? err.stack : err}`);
+            if (isLastAttempt) {
+                return;
+            }
+            const nextBrowser = browserAttempts[i + 1];
+            consoleLogger.warn(`writeSummaryPDF failed using browser '${currentBrowser}', retrying with '${nextBrowser}'.`);
+        }
     }
 };
 // Tracking WCAG occurrences
@@ -489,6 +520,7 @@ const extractRuleAiData = (ruleId, totalItems, items, callback) => {
 export const createRuleIdJson = async (allIssues, itemsStore) => {
     const compiledRuleJson = {};
     for (const category of ['mustFix', 'goodToFix', 'needsReview']) {
+        compiledRuleJson[category] = {};
         for (const rule of allIssues.items[category].rules) {
             let allItems = [];
             if (itemsStore) {
@@ -499,7 +531,7 @@ export const createRuleIdJson = async (allIssues, itemsStore) => {
             else {
                 allItems = rule.pagesAffected.flatMap(page => page.items || []);
             }
-            compiledRuleJson[rule.rule] = extractRuleAiData(rule.rule, rule.totalItems, allItems);
+            compiledRuleJson[category][rule.rule] = extractRuleAiData(rule.rule, rule.totalItems, allItems);
         }
     }
     return compiledRuleJson;
@@ -508,9 +540,10 @@ export const createRuleIdJson = async (allIssues, itemsStore) => {
 export const createBasicFormHTMLSnippet = filteredResults => {
     const compiledRuleJson = {};
     ['mustFix', 'goodToFix', 'needsReview'].forEach(category => {
+        compiledRuleJson[category] = {};
         if (filteredResults[category] && filteredResults[category].rules) {
             Object.entries(filteredResults[category].rules).forEach(([ruleId, ruleVal]) => {
-                compiledRuleJson[ruleId] = extractRuleAiData(ruleId, ruleVal.totalItems, ruleVal.items);
+                compiledRuleJson[category][ruleId] = extractRuleAiData(ruleId, ruleVal.totalItems, ruleVal.items);
             });
         }
     });
@@ -547,7 +580,7 @@ const formatAboutStartTime = (dateString) => {
     return htmlFormattedStartTime;
 };
 const generateArtifacts = async (randomToken, urlScanned, scanType, viewport, pagesScanned, pagesNotScanned, customFlowLabel, cypressScanAboutMetadata, scanDetails, zip = undefined, // optional
-generateJsonFiles = false) => {
+generateJsonFiles = false, preferredBrowser) => {
     consoleLogger.info('Generating report artifacts');
     const storagePath = getStoragePath(randomToken);
     const intermediateDatasetsPath = `${storagePath}/crawlee`;
@@ -564,6 +597,8 @@ generateJsonFiles = false) => {
         endTime: scanDetails.endTime ? scanDetails.endTime : new Date(),
         urlScanned,
         scanType,
+        totalLinksFetchedFromSitemaps: constants.sitemapFetchedLinks?.totalLinksFetchedFromSitemaps ?? 0,
+        fetchedSitemaps: constants.sitemapFetchedLinks?.fetchedSitemaps ?? [],
         deviceChosen: scanDetails.deviceChosen || 'Desktop',
         formatAboutStartTime,
         isCustomFlow,
@@ -752,39 +787,37 @@ generateJsonFiles = false) => {
             scanPagesSummaryBase64FilePath,
         ]);
     }
-    const browserChannel = getBrowserToRun(randomToken, BrowserTypes.CHROME, false).browserToRun;
+    const browserChannel = getBrowserToRun(randomToken, preferredBrowser || BrowserTypes.CHROME, false).browserToRun;
     // Should consider refactor constants.userDataDirectory to be a parameter in future
     await retryFunction(() => writeSummaryPdf(storagePath, pagesScanned.length, 'summary', browserChannel, constants.userDataDirectory), 1);
-    // Suppress uncaught EPERM errors from lingering Crawlee async lock-file operations
-    // (Windows holds mandatory file locks; Crawlee may still attempt mkdir on .json.lock
-    // files after the crawl has finished). Without this, Node crashes with uncaughtException.
-    const crawleeEpermHandler = (err) => {
-        if (err.code === 'EPERM' && err.message?.includes('crawlee')) {
-            consoleLogger.info(`Suppressed lingering Crawlee storage error: ${err.message}`);
-            return;
-        }
-        // Re-throw non-crawlee EPERM errors so they aren't silently swallowed
-        throw err;
-    };
-    process.on('uncaughtException', crawleeEpermHandler);
-    process.on('unhandledRejection', crawleeEpermHandler);
-    // Brief delay to allow lingering async crawlee storage operations to flush
-    await new Promise(resolve => setTimeout(resolve, process.platform === 'win32' ? 5000 : 3000));
+    // Flush pending background storage operations (metadata writes, lock-file ops)
+    const storageClient = Configuration.getStorageClient();
+    if (storageClient.teardown) {
+        await storageClient.teardown();
+    }
+    // Gracefully drop Dataset and RequestQueue — releases locks and removes files
+    const crawleeDir = path.join(storagePath, 'crawlee');
+    try {
+        const dataset = await Dataset.open(crawleeDir);
+        await dataset.drop();
+    }
+    catch (error) {
+        consoleLogger.info(`Dataset drop: ${error.message}`);
+    }
+    try {
+        const requestQueue = await RequestQueue.open(crawleeDir);
+        await requestQueue.drop();
+    }
+    catch (error) {
+        consoleLogger.info(`RequestQueue drop: ${error.message}`);
+    }
+    // Fallback rm for any leftover files not managed by Crawlee's storage API
     const crawleePath = path.join(storagePath, 'crawlee');
     try {
         await fs.promises.rm(crawleePath, { recursive: true, force: true });
     }
-    catch (error) {
-        // On Windows, retry once after a delay if the folder is still locked
-        if (process.platform === 'win32') {
-            await new Promise(resolve => setTimeout(resolve, 3000));
-            try {
-                await fs.promises.rm(crawleePath, { recursive: true, force: true });
-            }
-            catch {
-                // Best-effort cleanup — leave the folder; report generation continues
-            }
-        }
+    catch {
+        // Best-effort; storage was already dropped via API
     }
     try {
         await fs.promises.rm(path.join(storagePath, 'pdfs'), { recursive: true, force: true });
@@ -792,6 +825,22 @@ generateJsonFiles = false) => {
     catch (error) {
         consoleLogger.warn(`Unable to force remove pdfs folder: ${error.message}`);
     }
+    // Generate scrubbed HTML Code Snippets
+    const ruleIdJson = await createRuleIdJson(allIssues, itemsStore);
+    // Clean up intermediate items files before zipping
+    await itemsStore.cleanup();
+    try {
+        await sendWcagBreakdownToSentry(oobeeAppVersion, 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);
+    }
     // Take option if set
     if (typeof zip === 'string') {
         constants.cliZipFileName = zip;
@@ -827,29 +876,8 @@ generateJsonFiles = false) => {
     catch (error) {
         printMessage([`Error in zipping results: ${error}`]);
     }
-    // Generate scrubbed HTML Code Snippets
-    const ruleIdJson = await createRuleIdJson(allIssues, itemsStore);
-    // Clean up intermediate items files
-    await itemsStore.cleanup();
-    // 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(oobeeAppVersion, 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);
-    }
     if (process.env.RUNNING_FROM_PH_GUI || process.env.OOBEE_VERBOSE)
         console.log('Report generated successfully');
-    process.removeListener('uncaughtException', crawleeEpermHandler);
-    process.removeListener('unhandledRejection', crawleeEpermHandler);
     return ruleIdJson;
 };
 export { writeHTML, compressJsonFileStreaming, convertItemsToReferences, flattenAndSortResults, populateScanPagesDetail, sendWcagBreakdownToSentry, getWcagPassPercentage, getProgressPercentage, getIssuesPercentage, itemTypeDescription, oobeeAiHtmlETL, oobeeAiRules, formatAboutStartTime, };

package/dist/npmIndex.js

@@ -290,6 +290,7 @@ thresholds = { mustFix: undefined, goodToFix: undefined }, scanAboutMetadata = u
     // max numbers of mustFix/goodToFix occurrences before test returns a fail
     const { mustFix: mustFixThreshold, goodToFix: goodToFixThreshold } = thresholds;
     process.env.CRAWLEE_STORAGE_DIR = randomToken;
+    constants.sitemapFetchedLinks = null;
     const scanDetails = {
         startTime: new Date(),
         endTime: new Date(),

package/dist/utils.js

@@ -5,6 +5,7 @@ import axe from 'axe-core';
 import { v4 as uuidv4 } from 'uuid';
 import { getDomain } from 'tldts';
 import { normalizeUrl } from '@apify/utilities';
+import { Dataset, RequestQueue, Configuration } from 'crawlee';
 import constants, { destinationPath, getIntermediateScreenshotsPath, } from './constants/constants.js';
 import { consoleLogger, errorsTxtPath } from './logs.js';
 import { getAxeConfiguration } from './crawlers/custom/getAxeConfiguration.js';
@@ -346,6 +347,20 @@ export const cleanUp = async (randomToken, isError = false) => {
         }
     if (randomToken !== undefined) {
         const storagePath = getStoragePath(randomToken);
+        try {
+            const storageClient = Configuration.getStorageClient();
+            if (storageClient.teardown) {
+                await storageClient.teardown();
+            }
+            const crawleeDir = path.join(storagePath, 'crawlee');
+            const dataset = await Dataset.open(crawleeDir);
+            await dataset.drop();
+            const requestQueue = await RequestQueue.open(crawleeDir);
+            await requestQueue.drop();
+        }
+        catch (error) {
+            consoleLogger.info(`Crawlee storage drop in cleanUp: ${error.message}`);
+        }
         try {
             fs.rmSync(path.join(storagePath, 'crawlee'), { recursive: true, force: true });
         }
@@ -358,32 +373,8 @@ export const cleanUp = async (randomToken, isError = false) => {
         catch (error) {
             consoleLogger.warn(`Unable to force remove pdfs folder: ${error.message}`);
         }
-        let deleteErrorLogFile = true;
-        if (isError) {
-            let logsPath = storagePath;
-            if (process.env.OOBEE_LOGS_PATH) {
-                logsPath = process.env.OOBEE_LOGS_PATH;
-            }
-            if (fs.existsSync(errorsTxtPath)) {
-                try {
-                    const logFilePath = path.join(logsPath, `logs-${randomToken}.txt`);
-                    fs.copyFileSync(errorsTxtPath, logFilePath);
-                    console.log(`An error occured. Log file is located at: ${logFilePath}`);
-                }
-                catch (copyError) {
-                    consoleLogger.error(`Error copying errors file during cleanup: ${copyError.message}`);
-                    console.log(`An error occured. Log file is located at: ${errorsTxtPath}`);
-                    deleteErrorLogFile = false; // Do not delete the log file if copy failed
-                }
-                if (deleteErrorLogFile && fs.existsSync(errorsTxtPath)) {
-                    try {
-                        fs.unlinkSync(errorsTxtPath);
-                    }
-                    catch (error) {
-                        consoleLogger.warn(`Unable to delete log file ${errorsTxtPath}: ${error.message}`);
-                    }
-                }
-            }
+        if (isError && fs.existsSync(errorsTxtPath)) {
+            console.log(`An error occured. Log file is located at: ${errorsTxtPath}`);
         }
         if (fs.existsSync(storagePath) && fs.readdirSync(storagePath).length === 0) {
             try {
@@ -854,6 +845,8 @@ export const randomThreeDigitNumberString = () => {
     return String(threeDigitNumber);
 };
 export const normUrl = (u) => (u ? normalizeUrl(u) || u : '');
+export const stripWwwPrefix = (hostname) => hostname.replace(/^www\./, '');
+export const isSameHostname = (hostname1, hostname2) => stripWwwPrefix(hostname1) === stripWwwPrefix(hostname2);
 export const isFollowStrategy = (link1, link2, rule) => {
     if (rule === 'all')
         return true;
@@ -861,7 +854,9 @@ export const isFollowStrategy = (link1, link2, rule) => {
         const parsedLink1 = new URL(link1);
         const parsedLink2 = new URL(link2);
         if (rule === 'same-origin') {
-            return parsedLink1.origin === parsedLink2.origin;
+            return parsedLink1.protocol === parsedLink2.protocol &&
+                isSameHostname(parsedLink1.hostname, parsedLink2.hostname) &&
+                parsedLink1.port === parsedLink2.port;
         }
         if (rule === 'same-domain') {
             const link1Domain = getDomain(parsedLink1.hostname, { allowPrivateDomains: true }) || parsedLink1.hostname;
@@ -869,7 +864,7 @@ export const isFollowStrategy = (link1, link2, rule) => {
             return link1Domain.toLowerCase() === link2Domain.toLowerCase();
         }
         // default: same-hostname
-        return parsedLink1.hostname === parsedLink2.hostname;
+        return isSameHostname(parsedLink1.hostname, parsedLink2.hostname);
     }
     catch {
         return false;

package/oobee-client-scanner.js

@@ -3,9 +3,9 @@
  * DO NOT EDIT MANUALLY. Re-generate with: node dist/generateOobeeClientScanner.js
  *
  * Embedded at generation time:
- *   App version : 0.10.91
+ *   App version : 0.10.93
  *   Sentry DSN  : (from OOBEE_SENTRY_DSN env var or constants.ts default)
- *   Sentry SDK  : @sentry/browser 9.47.1 (loaded from CDN at runtime)
+ *   Sentry SDK  : @sentry/browser 10.58.0 (loaded from CDN at runtime)
  *
  * Usage:
  *   <script src="oobee-client-scanner.js"></script>
@@ -34883,8 +34883,8 @@
   // ── Sentry browser telemetry (Sentry JS SDK, loaded from CDN) ────────────
   
   var _oobeeSentryDsn          = "https://3b8c7ee46b06f33815a1301b6713ebc3@o4509047624761344.ingest.us.sentry.io/4509327783559168";
-  var _oobeeAppVersion         = "0.10.91";
-  var _oobeeSentryVersion      = "9.47.1";
+  var _oobeeAppVersion         = "0.10.93";
+  var _oobeeSentryVersion      = "10.58.0";
   var _oobeeSentryInitialized  = false;
   var _oobeeSentryLoadPromise  = null;
 
@@ -35091,6 +35091,37 @@
       // Run axe-core + oobee custom checks
       var scanResult = await window.runA11yScan(elementsToScan, '');
 
+      // Re-verify aria-hidden-focus violations against the live DOM to handle
+      // race conditions with JS that sets tabindex="-1" after aria-hidden
+      var axeViolations = scanResult.axeScanResults.violations || [];
+      var ariaHiddenViolation = axeViolations.find(function(v) { return v.id === 'aria-hidden-focus'; });
+      if (ariaHiddenViolation) {
+        await new Promise(function(resolve) { setTimeout(resolve, 0); });
+        ariaHiddenViolation.nodes = ariaHiddenViolation.nodes.filter(function(node) {
+          var selector = node.target && node.target[0];
+          if (typeof selector !== 'string') return true;
+          try {
+            var el = document.querySelector(selector);
+            if (!el) return true;
+            var focusables = el.querySelectorAll(
+              'a[href], area[href], button:not([disabled]), input:not([disabled]):not([type="hidden"]), select:not([disabled]), textarea:not([disabled]), [tabindex]'
+            );
+            if (focusables.length === 0) return false;
+            return Array.from(focusables).some(function(child) {
+              var tabindex = child.getAttribute('tabindex');
+              if (tabindex === null) return true;
+              var parsed = parseInt(tabindex, 10);
+              return isNaN(parsed) || parsed >= 0;
+            });
+          } catch (e) { return true; }
+        });
+        if (ariaHiddenViolation.nodes.length === 0) {
+          scanResult.axeScanResults.violations = axeViolations.filter(function(v) {
+            return v.id !== 'aria-hidden-focus';
+          });
+        }
+      }
+
       // Convert raw axe results into oobee category structure
       var filtered = _oobeeFilterAxeResults(scanResult.axeScanResults, scanResult.pageTitle);
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@govtechsg/oobee",
   "main": "dist/npmIndex.js",
-  "version": "0.10.91",
+  "version": "0.10.93",
   "type": "module",
   "author": "Government Technology Agency <info@tech.gov.sg>",
   "bin": {
@@ -11,7 +11,7 @@
     "@aws-sdk/client-s3": "^3.1049.0",
     "@json2csv/node": "^7.0.3",
     "@napi-rs/canvas": "^0.1.53",
-    "@sentry/node": "^9.13.0",
+    "@sentry/node": "^10.58.0",
     "@types/aws-sdk": "^0.0.42",
     "axe-core": "^4.11.4",
     "axios": "^1.8.2",
@@ -26,7 +26,7 @@
     "inquirer": "^9.2.12",
     "jsdom": "^29.0.0",
     "jszip": "^3.10.1",
-    "lodash": "^4.17.21",
+    "lodash": "^4.18.1",
     "mime": "^4.0.7",
     "mime-types": "^2.1.35",
     "minimatch": "^10.2.4",

package/src/cli.ts

@@ -228,6 +228,10 @@ if (!options.strategy) {
   options.strategy = options.scanner === ScannerTypes.SITEMAP ? 'ignore' : 'same-domain';
 }
 
+if (options.websiteTag) {
+  process.env.OOBEE_TAGGED_WEBSITE = options.websiteTag;
+}
+
 const scanInit = async (argvs: Answers): Promise<string> => {
   const updatedArgvs = { ...argvs };
 

package/src/combine.ts

@@ -6,7 +6,7 @@ import crawlLocalFile from './crawlers/crawlLocalFile.js';
 import crawlIntelligentSitemap from './crawlers/crawlIntelligentSitemap.js';
 import generateArtifacts from './mergeAxeResults.js';
 import { getHost, createAndUpdateResultsFolders, cleanUpAndExit, getStoragePath } from './utils.js';
-import { ScannerTypes, UrlsCrawled } from './constants/constants.js';
+import constants, { ScannerTypes, UrlsCrawled } from './constants/constants.js';
 import { getBlackListedPatterns, submitForm } from './constants/common.js';
 import { consoleLogger, silentLogger } from './logs.js';
 import runCustom from './crawlers/runCustom.js';
@@ -72,6 +72,7 @@ const combineRun = async (details: Data, deviceToScan: string) => {
 
   process.env.CRAWLEE_LOG_LEVEL = 'ERROR';
   process.env.CRAWLEE_STORAGE_DIR = randomToken;
+  constants.sitemapFetchedLinks = null;
 
   if (process.env.CRAWLEE_SYSTEM_INFO_V2 === undefined) {
     // Set the environment variable to enable system info v2
@@ -79,6 +80,18 @@ const combineRun = async (details: Data, deviceToScan: string) => {
     process.env.CRAWLEE_SYSTEM_INFO_V2 = '1';
   }
 
+  // Suppress non-fatal Crawlee ps-tree errors on Windows with non-English locales.
+  // The system info module tries to parse process listing headers and crashes when
+  // headers are in a different language (e.g. "Wo" instead of "PID").
+  const psTreeHandler = (err: Error) => {
+    if (err.message?.includes('Unknown process listing header')) {
+      consoleLogger.info(`Suppressed Crawlee ps-tree locale error: ${err.message}`);
+      return;
+    }
+    throw err;
+  };
+  process.on('uncaughtException', psTreeHandler);
+
   const host = type === ScannerTypes.SITEMAP || type === ScannerTypes.LOCALFILE ? '' : getHost(url);
 
   let blacklistedPatterns: string[] | null = null;
@@ -141,6 +154,7 @@ const combineRun = async (details: Data, deviceToScan: string) => {
         blacklistedPatterns,
         includeScreenshots,
         customFlowLabel && customFlowLabel !== 'None' ? customFlowLabel : '',
+        extraHTTPHeaders,
       );
 
       urlsCrawledObj = res.urlsCrawled;
@@ -274,6 +288,7 @@ const combineRun = async (details: Data, deviceToScan: string) => {
         scanDetails,
         zip,
         generateJsonFiles,
+        browser,
       );
       const [name, email] = nameEmail.split(':');
 

package/src/constants/cliFunctions.ts

@@ -341,5 +341,12 @@ To obtain the JSON files, you need to base64-decode the file followed by gunzip.
     demandOption: false,
     coerce: val => Number(val),
   },
+  z: {
+    alias: 'websiteTag',
+    describe: 'Tag to identify the website in telemetry. Overrides OOBEE_TAGGED_WEBSITE env var.',
+    type: 'string',
+    requiresArg: true,
+    demandOption: false,
+  },
 };