diff --git a/__tests__/mergeAxeResults.test.ts b/__tests__/mergeAxeResults.test.ts
index 5f1110a6..19a19311 100644
--- a/__tests__/mergeAxeResults.test.ts
+++ b/__tests__/mergeAxeResults.test.ts
@@ -34,7 +34,7 @@ const {
   createFilenames,
   createFinalResultsInJson,
 } = require('../__mocks__/mockFunctions');
-const { getCurrentDate, getFormattedTime } = require('../utils');
+const { getCurrentDate, getFormattedTime } = require('../src/utils/index.js');
 const { consoleLogger, silentLogger } = require('../logs');
 
 let randomToken;
diff --git a/__tests__/utils.test.ts b/__tests__/utils.test.ts
index d64a5817..db505088 100644
--- a/__tests__/utils.test.ts
+++ b/__tests__/utils.test.ts
@@ -7,7 +7,7 @@ import {
   validateUrl,
   getStoragePath,
   setHeadlessMode,
-} from '../utils.js';
+} from '../src/utils/index.js';
 
 describe('test setting of threshold warn level', () => {
   const OLD_ENV = process.env;
diff --git a/src/cli.ts b/src/cli.ts
index 00219933..ad08c0a6 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -5,7 +5,13 @@ import printMessage from 'print-message';
 import { devices } from 'playwright';
 import { fileURLToPath } from 'url';
 import path from 'path';
-import { setHeadlessMode, getVersion, getStoragePath, listenForCleanUp, cleanUpAndExit } from './utils.js';
+import {
+  listenForCleanUp,
+  cleanUpAndExit,
+  getStoragePath,
+  getVersion,
+  setHeadlessMode,
+} from './utils/index.js';
 import {
   checkUrl,
   prepareData,
diff --git a/src/combine.ts b/src/combine.ts
index 1ff7958d..4c7a4249 100644
--- a/src/combine.ts
+++ b/src/combine.ts
@@ -5,7 +5,12 @@ import crawlDomain from './crawlers/crawlDomain.js';
 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 {
+  cleanUpAndExit,
+  createAndUpdateResultsFolders,
+  getHost,
+  getStoragePath,
+} from './utils/index.js';
 import { ScannerTypes, UrlsCrawled } from './constants/constants.js';
 import { getBlackListedPatterns, submitForm } from './constants/common.js';
 import { consoleLogger, silentLogger } from './logs.js';
@@ -328,4 +333,4 @@ const combineRun = async (details: Data, deviceToScan: string) => {
   }
 };
 
-export default combineRun;
\ No newline at end of file
+export default combineRun;
diff --git a/src/constants/cliFunctions.ts b/src/constants/cliFunctions.ts
index e85f6f1e..69113399 100644
--- a/src/constants/cliFunctions.ts
+++ b/src/constants/cliFunctions.ts
@@ -1,7 +1,7 @@
 import { Options } from 'yargs';
 import printMessage from 'print-message';
 import { BrowserTypes, RuleFlags, ScannerTypes } from './constants.js';
-import { cleanUpAndExit } from '../utils.js';
+import { cleanUpAndExit } from '../utils/index.js';
 
 export const messageOptions = {
   border: false,
@@ -342,4 +342,3 @@ To obtain the JSON files, you need to base64-decode the file followed by gunzip.
     coerce: val => Number(val),
   },
 };
-
diff --git a/src/constants/common.ts b/src/constants/common.ts
index d21609b8..51e7ff49 100644
--- a/src/constants/common.ts
+++ b/src/constants/common.ts
@@ -33,7 +33,8 @@ import constants, {
 } from './constants.js';
 import { consoleLogger } from '../logs.js';
 import { isUrlPdf } from '../crawlers/commonCrawlerFunc.js';
-import { cleanUpAndExit, randomThreeDigitNumberString, register } from '../utils.js';
+import { randomThreeDigitNumberString } from '../utils/index.js';
+import { cleanUpAndExit, register } from '../utils/index.js';
 import { Answers, Data } from '../index.js';
 import { DeviceDescriptor } from '../types/types.js';
 import { getProxyInfo, proxyInfoToResolution, ProxySettings } from '../proxyService.js';
diff --git a/src/constants/constants.ts b/src/constants/constants.ts
index 4d084bf3..ca8959e5 100644
--- a/src/constants/constants.ts
+++ b/src/constants/constants.ts
@@ -361,7 +361,7 @@ export const sitemapPaths = [
   '/sitemap_index.xml.xz',
 ];
 
-// Remember to update getWcagPassPercentage() in src/utils/utils.ts if you change this
+// Remember to update getWcagPassPercentage() in src/utils/wcagProgress.ts if you change this
 const wcagLinks = {
   'WCAG 1.1.1': 'https://www.w3.org/TR/WCAG22/#non-text-content',
   'WCAG 1.2.2': 'https://www.w3.org/TR/WCAG22/#captions-prerecorded',
diff --git a/src/constants/questions.ts b/src/constants/questions.ts
index 134fa84d..dc33b31f 100644
--- a/src/constants/questions.ts
+++ b/src/constants/questions.ts
@@ -1,6 +1,6 @@
 import { Question } from 'inquirer';
 import { Answers } from '../index.js';
-import { getUserDataTxt, randomThreeDigitNumberString, setHeadlessMode } from '../utils.js';
+import { getUserDataTxt, randomThreeDigitNumberString, setHeadlessMode } from '../utils/index.js';
 import {
   checkUrl,
   getBrowserToRun,
diff --git a/src/crawlers/commonCrawlerFunc.ts b/src/crawlers/commonCrawlerFunc.ts
index c93780b5..dd32abc8 100644
--- a/src/crawlers/commonCrawlerFunc.ts
+++ b/src/crawlers/commonCrawlerFunc.ts
@@ -22,7 +22,7 @@ import { flagUnlabelledClickableElements } from './custom/flagUnlabelledClickabl
 import xPathToCss from './custom/xPathToCss.js';
 import type { Response as PlaywrightResponse } from 'playwright';
 import fs from 'fs';
-import { getStoragePath } from '../utils.js';
+import { getStoragePath } from '../utils/index.js';
 import path from 'path';
 
 // types
diff --git a/src/crawlers/crawlDomain.ts b/src/crawlers/crawlDomain.ts
index 065d43b2..09fa0971 100644
--- a/src/crawlers/crawlDomain.ts
+++ b/src/crawlers/crawlDomain.ts
@@ -32,7 +32,7 @@ import {
   getUrlsFromRobotsTxt,
   waitForPageLoaded,
 } from '../constants/common.js';
-import { areLinksEqual, isFollowStrategy, register } from '../utils.js';
+import { areLinksEqual, isFollowStrategy, register } from '../utils/index.js';
 import {
   handlePdfDownload,
   runPdfScan,
diff --git a/src/crawlers/crawlIntelligentSitemap.ts b/src/crawlers/crawlIntelligentSitemap.ts
index 9bc4d3a9..df259683 100644
--- a/src/crawlers/crawlIntelligentSitemap.ts
+++ b/src/crawlers/crawlIntelligentSitemap.ts
@@ -8,7 +8,7 @@ import crawlDomain from './crawlDomain.js';
 import crawlSitemap from './crawlSitemap.js';
 import { ViewportSettingsClass } from '../combine.js';
 import { getPlaywrightLaunchOptions } from '../constants/common.js';
-import { register } from '../utils.js';
+import { register } from '../utils/index.js';
 
 const crawlIntelligentSitemap = async (
   url: string,
diff --git a/src/crawlers/crawlLocalFile.ts b/src/crawlers/crawlLocalFile.ts
index b00e7f5b..af0bda54 100644
--- a/src/crawlers/crawlLocalFile.ts
+++ b/src/crawlers/crawlLocalFile.ts
@@ -19,7 +19,7 @@ import {
 import { runPdfScan, mapPdfScanResults, doPdfScreenshots } from './pdfScanFunc.js';
 import { guiInfoLog } from '../logs.js';
 import crawlSitemap from './crawlSitemap.js';
-import { getPdfStoragePath, getStoragePath, register } from '../utils.js';
+import { getPdfStoragePath, register } from '../utils/index.js';
 
 export const crawlLocalFile = async ({
   url,
diff --git a/src/crawlers/crawlSitemap.ts b/src/crawlers/crawlSitemap.ts
index 3f5c3fae..64f0c375 100644
--- a/src/crawlers/crawlSitemap.ts
+++ b/src/crawlers/crawlSitemap.ts
@@ -23,7 +23,7 @@ import {
   waitForPageLoaded,
   isFilePath,
 } from '../constants/common.js';
-import { areLinksEqual, isWhitelistedContentType, register } from '../utils.js';
+import { areLinksEqual, isWhitelistedContentType, register } from '../utils/index.js';
 import {
   handlePdfDownload,
   runPdfScan,
@@ -447,4 +447,4 @@ const crawlSitemap = async ({
   return { urlsCrawled, durationExceeded };
 };
 
-export default crawlSitemap;
\ No newline at end of file
+export default crawlSitemap;
diff --git a/src/crawlers/pdfScanFunc.ts b/src/crawlers/pdfScanFunc.ts
index 66fe86b8..a29279a0 100644
--- a/src/crawlers/pdfScanFunc.ts
+++ b/src/crawlers/pdfScanFunc.ts
@@ -15,7 +15,7 @@ import constants, {
   STATUS_CODE_METADATA,
   UrlsCrawled,
 } from '../constants/constants.js';
-import { cleanUpAndExit, getPdfStoragePath, getStoragePath } from '../utils.js';
+import { cleanUpAndExit, getPdfStoragePath, getStoragePath } from '../utils/index.js';
 import { error } from 'console';
 
 const require = createRequire(import.meta.url);
diff --git a/src/crawlers/runCustom.ts b/src/crawlers/runCustom.ts
index 0a08d006..81cff149 100644
--- a/src/crawlers/runCustom.ts
+++ b/src/crawlers/runCustom.ts
@@ -1,7 +1,7 @@
 /* eslint-env browser */
 import { chromium } from 'playwright';
 import { createCrawleeSubFolders } from './commonCrawlerFunc.js';
-import { cleanUpAndExit, register, registerSoftClose } from '../utils.js';
+import { cleanUpAndExit, register, registerSoftClose } from '../utils/index.js';
 import constants, {
   getIntermediateScreenshotsPath,
   guiInfoStatusTypes,
diff --git a/src/index.ts b/src/index.ts
index 76529731..8c0bcf6f 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -3,12 +3,12 @@ import printMessage from 'print-message';
 import inquirer from 'inquirer';
 import { EnqueueStrategy } from 'crawlee';
 import {
-  getVersion,
-  getUserDataTxt,
-  writeToUserDataTxt,
   listenForCleanUp,
   cleanUpAndExit,
-} from './utils.js';
+  getUserDataTxt,
+  getVersion,
+  writeToUserDataTxt,
+} from './utils/index.js';
 import {
   prepareData,
   messageOptions,
diff --git a/src/mergeAxeResults.ts b/src/mergeAxeResults.ts
index d7575898..607c68db 100644
--- a/src/mergeAxeResults.ts
+++ b/src/mergeAxeResults.ts
@@ -26,19 +26,19 @@ import constants, {
 import { getBrowserToRun, getPlaywrightLaunchOptions } from './constants/common.js';
 
 import {
+  categorizeWcagCriteria,
   createScreenshotsFolder,
   getStoragePath,
+  getUserDataTxt,
   getVersion,
+  getWcagCriteriaMap,
   getWcagPassPercentage,
   getProgressPercentage,
-  retryFunction,
-  zipResults,
   getIssuesPercentage,
-  getWcagCriteriaMap,
-  categorizeWcagCriteria,
-  getUserDataTxt,
   register,
-} from './utils.js';
+  retryFunction,
+  zipResults,
+} from './utils/index.js';
 import { consoleLogger, silentLogger } from './logs.js';
 import itemTypeDescription from './constants/itemTypeDescription.js';
 import { oobeeAiHtmlETL, oobeeAiRules } from './constants/oobeeAi.js';
@@ -182,7 +182,9 @@ const parseContentToJson = async (rPath: string) => {
     }
 
     consoleLogger.error(`[parseContentToJson] Failed to parse file: ${rPath}`);
-    consoleLogger.error(`[parseContentToJson] ${parseError?.name || 'Error'}: ${parseError?.message || parseError}`);
+    consoleLogger.error(
+      `[parseContentToJson] ${parseError?.name || 'Error'}: ${parseError?.message || parseError}`,
+    );
     if (position !== null) {
       consoleLogger.error(`[parseContentToJson] JSON parse position: ${position}`);
     }
@@ -416,12 +418,14 @@ const writeHTML = async (
   const scanItemsWithHtmlGroupRefs = convertItemsToReferences(allIssues);
 
   // Write the lighter items to a file and get the base64 path
-  const {  jsonFilePath: scanItemsWithHtmlGroupRefsJsonFilePath, base64FilePath: scanItemsWithHtmlGroupRefsBase64FilePath } =
-    await writeJsonFileAndCompressedJsonFile(
-      scanItemsWithHtmlGroupRefs.items,
-      storagePath,
-      'scanItems-light',
-    );
+  const {
+    jsonFilePath: scanItemsWithHtmlGroupRefsJsonFilePath,
+    base64FilePath: scanItemsWithHtmlGroupRefsBase64FilePath,
+  } = await writeJsonFileAndCompressedJsonFile(
+    scanItemsWithHtmlGroupRefs.items,
+    storagePath,
+    'scanItems-light',
+  );
 
   return new Promise<void>((resolve, reject) => {
     const scanDetailsReadStream = fs.createReadStream(scanDetailsFilePath, {
@@ -448,7 +452,7 @@ const writeHTML = async (
     outputStream.write(prefixData);
 
     // For Proxied AI environments only
-    outputStream.write(`let proxyUrl = "${process.env.PROXY_API_BASE_URL || ""}"\n`);
+    outputStream.write(`let proxyUrl = "${process.env.PROXY_API_BASE_URL || ''}"\n`);
 
     // Initialize GenAI feature flag
     outputStream.write(`
@@ -478,17 +482,15 @@ const writeHTML = async (
   }
   \n`);
 
-    outputStream.write(
-      "</script>\n<script type=\"text/plain\" id=\"scanDataRaw\">"
-    );
+    outputStream.write('</script>\n<script type="text/plain" id="scanDataRaw">');
     scanDetailsReadStream.pipe(outputStream, { end: false });
 
     scanDetailsReadStream.on('end', async () => {
-      outputStream.write("</script>\n<script>\n");
+      outputStream.write('</script>\n<script>\n');
       outputStream.write(
-        "var scanDataPromise = (async () => { console.log('Loading scanData...'); scanData = await decodeUnzipParse(document.getElementById('scanDataRaw').textContent); })();\n"
+        "var scanDataPromise = (async () => { console.log('Loading scanData...'); scanData = await decodeUnzipParse(document.getElementById('scanDataRaw').textContent); })();\n",
       );
-      outputStream.write("</script>\n");
+      outputStream.write('</script>\n');
 
       // Write scanItems in 2MB chunks using a stream to avoid loading entire file into memory
       try {
@@ -499,11 +501,13 @@ const writeHTML = async (
         });
 
         for await (const chunk of scanItemsStream) {
-          outputStream.write(`<script type="text/plain" id="scanItemsRaw${chunkIndex}">${chunk}</script>\n`);
+          outputStream.write(
+            `<script type="text/plain" id="scanItemsRaw${chunkIndex}">${chunk}</script>\n`,
+          );
           chunkIndex++;
         }
 
-        outputStream.write("<script>\n");
+        outputStream.write('<script>\n');
         outputStream.write(`
 var scanItemsPromise = (async () => {
   console.log('Loading scanItems...');
@@ -918,7 +922,6 @@ const writeJsonAndBase64Files = async (
 
   // Refactor scanIssuesSummary to reuse the structure by stripping out pagesAffected
   const scanIssuesSummary = {
-
     // Replace rule descriptions with short descriptions from the map
     mustFix: items.mustFix.rules.map(({ pagesAffected, ...ruleInfo }) => ({
       ...ruleInfo,
@@ -1206,10 +1209,10 @@ const pushResults = async (pageResults, allIssues, isCustomFlow) => {
       const currRuleFromAllIssues = currCategoryFromAllIssues.rules[rule];
 
       currRuleFromAllIssues.totalItems += count;
-      
+
       // Build htmlGroups for pre-computed Group by HTML Element
       buildHtmlGroups(currRuleFromAllIssues, items, url);
-        
+
       if (isCustomFlow) {
         const { pageIndex, pageImagePath, metadata } = pageResults;
         currRuleFromAllIssues.pagesAffected[pageIndex] = {
@@ -1219,15 +1222,12 @@ const pushResults = async (pageResults, allIssues, isCustomFlow) => {
           metadata,
           items: [...items],
         };
-      } else {
-        if (!(url in currRuleFromAllIssues.pagesAffected)) {
-          currRuleFromAllIssues.pagesAffected[url] = {
-            pageTitle,
-            items: [...items],
-            ...(filePath && { filePath }),
-          };
-        }
-
+      } else if (!(url in currRuleFromAllIssues.pagesAffected)) {
+        currRuleFromAllIssues.pagesAffected[url] = {
+          pageTitle,
+          items: [...items],
+          ...(filePath && { filePath }),
+        };
       }
     });
   });
@@ -1237,11 +1237,7 @@ const pushResults = async (pageResults, allIssues, isCustomFlow) => {
  * Builds pre-computed HTML groups to optimize Group by HTML Element functionality.
  * Keys are composite "html\x00xpath" strings to ensure unique matching per element instance.
  */
-const buildHtmlGroups = (
-  rule: RuleInfo,
-  items: ItemsInfo[],
-  pageUrl: string
-) => {
+const buildHtmlGroups = (rule: RuleInfo, items: ItemsInfo[], pageUrl: string) => {
   if (!rule.htmlGroups) {
     rule.htmlGroups = {};
   }
@@ -1401,7 +1397,12 @@ function updateIssuesWithOccurrences(issuesList: any[], urlOccurrencesMap: Map<s
   });
 }
 
-const extractRuleAiData = (ruleId: string, totalItems: number, items: any[], callback?: () => void) => {
+const extractRuleAiData = (
+  ruleId: string,
+  totalItems: number,
+  items: any[],
+  callback?: () => void,
+) => {
   let snippets = [];
 
   if (oobeeAiRules.includes(ruleId)) {
@@ -1421,8 +1422,7 @@ const extractRuleAiData = (ruleId: string, totalItems: number, items: any[], cal
 };
 
 // This is for telemetry purposes called within mergeAxeResults.ts
-export
-const createRuleIdJson = allIssues => {
+export const createRuleIdJson = allIssues => {
   const compiledRuleJson = {};
 
   ['mustFix', 'goodToFix', 'needsReview'].forEach(category => {
@@ -1445,9 +1445,11 @@ export const createBasicFormHTMLSnippet = filteredResults => {
 
   ['mustFix', 'goodToFix', 'needsReview'].forEach(category => {
     if (filteredResults[category] && filteredResults[category].rules) {
-      Object.entries(filteredResults[category].rules).forEach(([ruleId, ruleVal]: [string, any]) => {
-        compiledRuleJson[ruleId] = extractRuleAiData(ruleId, ruleVal.totalItems, ruleVal.items);
-      });
+      Object.entries(filteredResults[category].rules).forEach(
+        ([ruleId, ruleVal]: [string, any]) => {
+          compiledRuleJson[ruleId] = extractRuleAiData(ruleId, ruleVal.totalItems, ruleVal.items);
+        },
+      );
     }
   });
 
@@ -1939,7 +1941,6 @@ const generateArtifacts = async (
   zip: string = undefined, // optional
   generateJsonFiles = false,
 ) => {
-
   consoleLogger.info('Generating report artifacts');
 
   const storagePath = getStoragePath(randomToken);
@@ -2037,7 +2038,7 @@ const generateArtifacts = async (
       await pushResults(pageResults, allIssues, isCustomFlow);
     }),
   ).catch(flattenIssuesError => {
-        consoleLogger.error(
+    consoleLogger.error(
       `[generateArtifacts] Error flattening issues: ${flattenIssuesError?.stack || flattenIssuesError}`,
     );
   });
@@ -2176,22 +2177,22 @@ const generateArtifacts = async (
     scanItemsBase64FilePath,
   );
 
-if (!generateJsonFiles) {
-  await cleanUpJsonFiles([
-    scanDataJsonFilePath,
-    scanDataBase64FilePath,
-    scanItemsJsonFilePath,
-    scanItemsBase64FilePath,
-    scanItemsSummaryJsonFilePath,
-    scanItemsSummaryBase64FilePath,
-    scanIssuesSummaryJsonFilePath,
-    scanIssuesSummaryBase64FilePath,
-    scanPagesDetailJsonFilePath,
-    scanPagesDetailBase64FilePath,
-    scanPagesSummaryJsonFilePath,
-    scanPagesSummaryBase64FilePath,
-  ]);
-}
+  if (!generateJsonFiles) {
+    await cleanUpJsonFiles([
+      scanDataJsonFilePath,
+      scanDataBase64FilePath,
+      scanItemsJsonFilePath,
+      scanItemsBase64FilePath,
+      scanItemsSummaryJsonFilePath,
+      scanItemsSummaryBase64FilePath,
+      scanIssuesSummaryJsonFilePath,
+      scanIssuesSummaryBase64FilePath,
+      scanPagesDetailJsonFilePath,
+      scanPagesDetailBase64FilePath,
+      scanPagesSummaryJsonFilePath,
+      scanPagesSummaryBase64FilePath,
+    ]);
+  }
 
   const browserChannel = getBrowserToRun(randomToken, BrowserTypes.CHROME, false).browserToRun;
 
@@ -2311,4 +2312,4 @@ export {
   formatAboutStartTime,
 };
 
-export default generateArtifacts;
\ No newline at end of file
+export default generateArtifacts;
diff --git a/src/npmIndex.ts b/src/npmIndex.ts
index 44a113ca..6c853d5e 100644
--- a/src/npmIndex.ts
+++ b/src/npmIndex.ts
@@ -13,7 +13,7 @@ import {
   submitForm,
 } from './constants/common.js';
 import { createCrawleeSubFolders, filterAxeResults } from './crawlers/commonCrawlerFunc.js';
-import { createAndUpdateResultsFolders, getVersion } from './utils.js';
+import { createAndUpdateResultsFolders, getVersion } from './utils/index.js';
 import generateArtifacts, { createBasicFormHTMLSnippet, sendWcagBreakdownToSentry } from './mergeAxeResults.js';
 import { takeScreenshotForHTMLElements } from './screenshotFunc/htmlScreenshotFunc.js';
 import { consoleLogger, silentLogger } from './logs.js';
@@ -878,4 +878,3 @@ export const scanPage = async (
 };
 
 export { RuleFlags };
-
diff --git a/src/utils.ts b/src/utils.ts
deleted file mode 100644
index dbd0447b..00000000
--- a/src/utils.ts
+++ /dev/null
@@ -1,1332 +0,0 @@
-import { execSync, spawnSync } from 'child_process';
-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,
-  getIntermediateScreenshotsPath,
-} from './constants/constants.js';
-import { consoleLogger, errorsTxtPath, silentLogger } from './logs.js';
-import { getAxeConfiguration } from './crawlers/custom/getAxeConfiguration.js';
-import JSZip from 'jszip';
-import { createReadStream, createWriteStream } from 'fs';
-
-export const getVersion = () => {
-  const loadJSON = (filePath: string): { version: string } =>
-    JSON.parse(fs.readFileSync(new URL(filePath, import.meta.url)).toString());
-  const versionNum = loadJSON('../package.json').version;
-
-  return versionNum;
-};
-
-export const getHost = (url: string): string => new URL(url).host;
-
-export const getCurrentDate = () => {
-  const date = new Date();
-  return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
-};
-
-export const isWhitelistedContentType = (contentType: string): boolean => {
-  const whitelist = ['text/html'];
-  return whitelist.filter(type => contentType.trim().startsWith(type)).length === 1;
-};
-
-export const getPdfStoragePath = (randomToken: string): string => {
-  const storagePath = getStoragePath(randomToken);
-  const pdfStoragePath = path.join(storagePath, 'pdfs');
-  if (!fs.existsSync(pdfStoragePath)) {
-    fs.mkdirSync(pdfStoragePath, { recursive: true });
-  }
-  return pdfStoragePath;
-};
-
-export const getStoragePath = (randomToken: string): string => {
-  // If exportDirectory is set, use it
-  if (constants.exportDirectory) {
-    return constants.exportDirectory;
-  }
-
-  // Otherwise, use the current working directory
-  let storagePath = path.join(process.cwd(), 'results', randomToken);
-
-  // Ensure storagePath is writable; if directory doesn't exist, try to create it in Documents or home directory
-  const isWritable = (() => {
-    try {
-      if (!fs.existsSync(storagePath)) {
-        fs.mkdirSync(storagePath, { recursive: true });
-      }
-      fs.accessSync(storagePath, fs.constants.W_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-
-  if (!isWritable) {
-    if (os.platform() === 'win32') {
-      // Use Documents folder on Windows
-      const documentsPath = path.join(process.env.USERPROFILE || process.env.HOMEPATH || '', 'Documents');
-      storagePath = path.join(documentsPath, 'Oobee', randomToken);
-    } else if (os.platform() === 'darwin') {
-      // Use Documents folder on Mac
-      const documentsPath = path.join(process.env.HOME || '', 'Documents');
-      storagePath = path.join(documentsPath, 'Oobee', randomToken);
-    } else {
-      // Use home directory for Linux/other
-      const homePath = process.env.HOME || '';
-      storagePath = path.join(homePath, 'Oobee', randomToken);
-    }
-    consoleLogger.warn(`Warning: Cannot write to cwd, writing to ${storagePath}`);
-
-  }
-
-  if (!fs.existsSync(storagePath)) {
-    fs.mkdirSync(storagePath, { recursive: true });
-  }
-
-  constants.exportDirectory = storagePath;
-  return storagePath;
-
-};
-
-export const getUserDataFilePath = () => {
-  const platform = os.platform();
-  if (platform === 'win32') {
-    return path.join(process.env.APPDATA, 'Oobee', 'userData.txt');
-  }
-  if (platform === 'darwin') {
-    return path.join(process.env.HOME, 'Library', 'Application Support', 'Oobee', 'userData.txt');
-  }
-  // linux and other OS
-  return path.join(process.env.HOME, '.config', 'oobee', 'userData.txt');
-};
-
-export const getUserDataTxt = () => {
-  const textFilePath = getUserDataFilePath();
-
-  // 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;
-};
-
-export const writeToUserDataTxt = async (key: string, value: string): Promise<void> => {
-  const textFilePath = getUserDataFilePath();
-
-  // Create file if it doesn't exist
-  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 });
-    }
-    // Initialize with userId
-    fs.appendFileSync(textFilePath, JSON.stringify({ [key]: value, userId: uuidv4() }, null, 2));
-  }
-};
-
-export const createAndUpdateResultsFolders = async (randomToken: string): Promise<void> => {
-  const storagePath = getStoragePath(randomToken);
-  await fs.ensureDir(`${storagePath}`);
-
-  const intermediatePdfResultsPath = `${randomToken}/${constants.pdfScanResultFileName}`;
-
-  const transferResults = async (intermPath: string, resultFile: string): Promise<void> => {
-    try {
-      if (fs.existsSync(intermPath)) {
-        await fs.copy(intermPath, `${storagePath}/${resultFile}`);
-      }
-    } catch (error) {
-      if (error.code === 'EBUSY') {
-        consoleLogger.error(
-          `Unable to copy the file from ${intermPath} to ${storagePath}/${resultFile} because it is currently in use.`,
-        );
-        consoleLogger.error(
-          'Please close any applications that might be using this file and try again.',
-        );
-      } else {
-        consoleLogger.error(
-          `An unexpected error occurred while copying the file from ${intermPath} to ${storagePath}/${resultFile}: ${error.message}`,
-        );
-      }
-    }
-  };
-
-  await Promise.all([transferResults(intermediatePdfResultsPath, constants.pdfScanResultFileName)]);
-};
-
-export const createScreenshotsFolder = (randomToken: string): void => {
-  const storagePath = getStoragePath(randomToken);
-  const intermediateScreenshotsPath = getIntermediateScreenshotsPath(randomToken);
-  if (fs.existsSync(intermediateScreenshotsPath)) {
-    fs.readdir(intermediateScreenshotsPath, (err, files) => {
-      if (err) {
-        consoleLogger.error(`Screenshots were not moved successfully: ${err.message}`);
-      }
-
-      if (!fs.existsSync(destinationPath(storagePath))) {
-        try {
-          fs.mkdirSync(destinationPath(storagePath), { recursive: true });
-        } catch (error) {
-          consoleLogger.error('Screenshots folder was not created successfully:', error);
-        }
-      }
-
-      files.forEach(file => {
-        fs.renameSync(
-          `${intermediateScreenshotsPath}/${file}`,
-          `${destinationPath(storagePath)}/${file}`,
-        );
-      });
-
-      fs.rmdir(intermediateScreenshotsPath, rmdirErr => {
-        if (rmdirErr) {
-          consoleLogger.error(rmdirErr);
-        }
-      });
-    });
-  }
-};
-
-
-let __shuttingDown = false;
-let __stopAllLock: Promise<void> | null = null;
-let __softCloseHandler: (() => Promise<void>) | null = null;
-
-export function registerSoftClose(handler: () => Promise<void>) {
-  __softCloseHandler = handler;
-}
-
-export async function softCloseBrowserAndContext() {
-  if (!__softCloseHandler) {
-    consoleLogger.info('softCloseBrowserAndContext: no handler registered (probably not a custom-flow scan)');
-    return;
-  }
-
-  try {
-    consoleLogger.info('softCloseBrowserAndContext: calling registered handler...');
-    await __softCloseHandler();
-  } catch (e: any) {
-    consoleLogger.warn(`softCloseBrowserAndContext error: ${e?.message || e}`);
-  }
-}
-
-/**
- * Register a resource so it can be stopped later.
- * Supports Crawlee crawlers, Playwright BrowserContexts, and Browsers.
- */
-export function register(resource: any) {
-  const name = resource?.constructor?.name;
-
-  if (name?.endsWith('Crawler')) {
-    constants.resources.crawlers.add(resource);
-  } else if (name === 'BrowserContext') {
-    constants.resources.browserContexts.add(resource);
-  } else if (name === 'Browser') {
-    constants.resources.browsers.add(resource);
-  }
-
-  return resource;
-}
-
-/**
- * Stops or tears down all tracked resources.
- * @param mode "graceful" (finish in-flight), "abort" (drop in-flight), or "teardown" (close immediately)
- * @param timeoutMs Max time to wait before forcing shutdown
- */
-export async function stopAll({ mode = 'graceful', timeoutMs = 10_000 } = {}) {
-  if (__stopAllLock) return __stopAllLock; // prevent overlap
-  __stopAllLock = (async () => {
-    const timeout = (ms: number) => new Promise(res => setTimeout(res, ms));
-    consoleLogger.info(`Stop browsers starting, mode=${mode}, timeoutMs=${timeoutMs}`);
-
-    // --- Crawlers ---
-    for (const c of [...constants.resources.crawlers]) {
-      try {
-        const pool = (c as any).autoscaledPool;
-        if (pool && typeof pool.isRunning !== 'undefined' && !pool.isRunning) {
-          consoleLogger.info('Skipping crawler (already stopped)');
-          continue;
-        }
-
-        consoleLogger.info(`Closing crawler (${mode})...`);
-        if (mode === 'graceful') {
-          if (typeof c.stop === 'function') {
-            await Promise.race([c.stop(), timeout(timeoutMs)]);
-          }
-        } else if (mode === 'abort') {
-          pool?.abort?.();
-        } else {
-          if (typeof c.teardown === 'function') {
-            await Promise.race([c.teardown(), timeout(timeoutMs)]);
-          }
-        }
-        consoleLogger.info(`Crawler closed (${mode})`);
-      } catch (err) {
-        consoleLogger.warn(`Error stopping crawler: ${(err as Error).message}`);
-      } finally {
-        constants.resources.crawlers.delete(c);
-      }
-    }
-
-    // --- BrowserContexts ---
-    for (const ctx of [...constants.resources.browserContexts]) {
-      // compute once so we can also use in finally
-      const pagesArr = typeof ctx.pages === 'function' ? ctx.pages() : [];
-      const hasOpenPages = Array.isArray(pagesArr) && pagesArr.length > 0;
-
-      try {
-        const browser = typeof ctx.browser === 'function' ? ctx.browser() : null;
-        if (browser && (browser as any).isClosed?.()) {
-          consoleLogger.info('Skipping BrowserContext (browser already closed)');
-          continue;
-        }
-
-        // ➜ Graceful: don't kill contexts that are still doing work
-        if (mode === 'graceful' && hasOpenPages) {
-          consoleLogger.info(`Skipping BrowserContext in graceful (has ${pagesArr.length} open page(s))`);
-          continue; // leave it for the teardown pass
-        }
-
-        // (Optional speed-up) close pages first if any
-        if (hasOpenPages) {
-          consoleLogger.info(`Closing ${pagesArr.length} page(s) before context close...`);
-          for (const p of pagesArr) {
-            try { await Promise.race([p.close(), timeout(1500)]); } catch {}
-          }
-        }
-
-        consoleLogger.info('Closing BrowserContext...');
-        if (typeof ctx.close === 'function') {
-          await Promise.race([ctx.close(), timeout(timeoutMs)]);
-        }
-        consoleLogger.info('BrowserContext closed');
-
-        // also close its browser (persistent contexts)
-        const b = browser;
-        if (b && !(b as any).isClosed?.()) {
-          consoleLogger.info('Closing Browser (from context.browser())...');
-          if (typeof b.close === 'function') {
-            await Promise.race([b.close(), timeout(timeoutMs)]);
-          }
-          consoleLogger.info('Browser closed (from context.browser())');
-        }
-      } catch (err) {
-        consoleLogger.warn(`Error closing BrowserContext: ${(err as Error).message}`);
-      } finally {
-        // only delete from the set if we actually closed it (or tried to)
-        if (!(mode === 'graceful' && hasOpenPages)) {
-          constants.resources.browserContexts.delete(ctx);
-        }
-      }
-    }
-
-    // --- Browsers ---
-    for (const b of [...constants.resources.browsers]) {
-      try {
-        if ((b as any).isClosed?.()) {
-          consoleLogger.info('Skipping Browser (already closed)');
-          continue;
-        }
-
-        consoleLogger.info('Closing Browser...');
-        if (typeof b.close === 'function') {
-          await Promise.race([b.close(), timeout(timeoutMs)]);
-        }
-        consoleLogger.info('Browser closed');
-      } catch (err) {
-        consoleLogger.warn(`Error closing Browser: ${(err as Error).message}`);
-      } finally {
-        constants.resources.browsers.delete(b);
-      }
-    }
-
-    consoleLogger.info(`Stop browsers finished for mode=${mode}`);
-  })();
-
-  try {
-    await __stopAllLock;
-  } finally {
-    __stopAllLock = null;
-  }
-}
-
-export const cleanUp = async (randomToken?: string, isError: boolean = false): Promise<void> => {
-
-  if (isError) {
-    await stopAll({ mode: 'graceful', timeoutMs: 8000 });
-    await stopAll({ mode: 'teardown', timeoutMs: 4000 });
-  }
-  
-  if (randomToken === undefined && constants.randomToken) {
-    randomToken = constants.randomToken;
-  }
-
-  if (constants.userDataDirectory) try {
-    fs.rmSync(constants.userDataDirectory, { recursive: true, force: true });
-  } catch (error) {
-    consoleLogger.warn(`Unable to force remove userDataDirectory: ${error.message}`);
-  }
-
-  if (randomToken !== undefined) {
-    const storagePath = getStoragePath(randomToken);
-
-    try {
-      fs.rmSync(path.join(storagePath, 'crawlee'), { recursive: true, force: true });
-    } catch (error) {
-      consoleLogger.warn(`Unable to force remove crawlee folder: ${error.message}`);
-    }
-
-    try {
-      fs.rmSync(path.join(storagePath, 'pdfs'), { recursive: true, force: true });
-    } 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 (fs.existsSync(storagePath) && fs.readdirSync(storagePath).length === 0) {
-      try {
-        fs.rmdirSync(storagePath);
-        consoleLogger.info(`Deleted empty storage path: ${storagePath}`);
-    
-      } catch (error) {
-        consoleLogger.warn(`Error deleting empty storage path ${storagePath}: ${error.message}`);
-      }
-    }
-
-    consoleLogger.info(`Clean up completed for: ${randomToken}`);
-  } 
-
-};
-
-export const cleanUpAndExit = async (
-  exitCode: number,
-  randomToken?: string,
-  isError: boolean = false,
-): Promise<void> => {
-  if (__shuttingDown) {
-    consoleLogger.info('Cleanup already in progress; ignoring duplicate exit request.');
-    return;
-  }
-  __shuttingDown = true;
-
-  try {
-    await cleanUp(randomToken, isError);   // runs stopAll inside cleanUp
-  } catch (e: any) {
-    consoleLogger.warn(`Cleanup error: ${e?.message || e}`);
-  }
-
-  consoleLogger.info(`Exiting with code: ${exitCode}`);
-  process.exit(exitCode); // explicit exit after cleanup completes
-};
-
-// Clean up listeners for process signals (e.g. parent process wants to stop Oobee scan mid-point)
-// Necessary to remove residual userDataDirectory and crawlee files generated by Chrome/Edge browser on each run, so that storage does not baloon up on the server
-export const listenForCleanUp = (randomToken: string): void => {
-  consoleLogger.info(`PID: ${process.pid}`);
-
-  // SIGINT signal happens when the user presses Ctrl+C in the terminal
-  process.on('SIGINT', async () => {   // ← keep handler installed
-    consoleLogger.info('SIGINT received. Cleaning up and exiting.');
-    await cleanUpAndExit(130, randomToken, true);
-  });
-
-  // SIGTERM signal happens when the process is terminated (by another process or system shutdown)
-  process.on('SIGTERM', async () => {  // ← keep handler installed
-    consoleLogger.info('SIGTERM received. Cleaning up and exiting.');
-    await cleanUpAndExit(143, randomToken, true);
-  });
-
-  // Note: user-defined signal reserved for application-specific use.
-  // SIGUSR1 for handling closing playwright browser and continue generate artifacts etc
-  process.on('SIGUSR1', async () => {
-    consoleLogger.info('SIGUSR1 received. Soft-closing browser/context only.');
-    await softCloseBrowserAndContext();
-  });
-};
-
-export const getWcagPassPercentage = (
-  wcagViolations: string[],
-  showEnableWcagAaa: boolean,
-): {
-  passPercentageAA: string;
-  totalWcagChecksAA: number;
-  totalWcagViolationsAA: number;
-  passPercentageAAandAAA: string;
-  totalWcagChecksAAandAAA: number;
-  totalWcagViolationsAAandAAA: number;
-} => {
-  // These AAA rules should not be counted as WCAG Pass Percentage only contains A and AA
-  const wcagAAALinks = ['WCAG 1.4.6', 'WCAG 2.2.4', 'WCAG 2.4.9', 'WCAG 3.1.5', 'WCAG 3.2.5', 'WCAG 2.1.3'];
-  const wcagAAA = ['wcag146', 'wcag224', 'wcag249', 'wcag315', 'wcag325', 'wcag213'];
-
-  const wcagLinksAAandAAA = constants.wcagLinks;
-
-  const wcagViolationsAAandAAA = showEnableWcagAaa ? wcagViolations.length : null;
-  const totalChecksAAandAAA = showEnableWcagAaa ? Object.keys(wcagLinksAAandAAA).length : null;
-  const passedChecksAAandAAA = showEnableWcagAaa
-    ? totalChecksAAandAAA - wcagViolationsAAandAAA
-    : null;
-  // eslint-disable-next-line no-nested-ternary
-  const passPercentageAAandAAA = showEnableWcagAaa
-    ? totalChecksAAandAAA === 0
-      ? 0
-      : (passedChecksAAandAAA / totalChecksAAandAAA) * 100
-    : null;
-
-  const wcagViolationsAA = wcagViolations.filter(violation => !wcagAAA.includes(violation)).length;
-  const totalChecksAA = Object.keys(wcagLinksAAandAAA).filter(
-    key => !wcagAAALinks.includes(key),
-  ).length;
-  const passedChecksAA = totalChecksAA - wcagViolationsAA;
-  const passPercentageAA = totalChecksAA === 0 ? 0 : (passedChecksAA / totalChecksAA) * 100;
-
-  return {
-    passPercentageAA: passPercentageAA.toFixed(2), // toFixed returns a string, which is correct here
-    totalWcagChecksAA: totalChecksAA,
-    totalWcagViolationsAA: wcagViolationsAA,
-    passPercentageAAandAAA: passPercentageAAandAAA ? passPercentageAAandAAA.toFixed(2) : null, // toFixed returns a string, which is correct here
-    totalWcagChecksAAandAAA: totalChecksAAandAAA,
-    totalWcagViolationsAAandAAA: wcagViolationsAAandAAA,
-  };
-};
-
-export type IssueCategory = 'mustFix' | 'goodToFix' | 'needsReview' | 'passed';
-
-export interface IssueDetail {
-  ruleId: string;
-  wcagConformance: string[];
-  occurrencesMustFix?: number;
-  occurrencesGoodToFix?: number;
-  occurrencesNeedsReview?: number;
-  occurrencesPassed: number;
-}
-
-export interface PageDetail {
-  pageTitle: string;
-  url: string;
-  totalOccurrencesFailedIncludingNeedsReview: number;
-  totalOccurrencesFailedExcludingNeedsReview: number;
-  totalOccurrencesMustFix?: number;
-  totalOccurrencesGoodToFix?: number;
-  totalOccurrencesNeedsReview: number;
-  totalOccurrencesPassed: number;
-  occurrencesExclusiveToNeedsReview: boolean;
-  typesOfIssuesCount: number;
-  typesOfIssuesExcludingNeedsReviewCount: number;
-  categoriesPresent: IssueCategory[];
-  conformance?: string[]; // WCAG levels as flexible strings
-  typesOfIssues: IssueDetail[];
-}
-
-export interface ScanPagesDetail {
-  oobeeAppVersion?: string;
-  pagesAffected: PageDetail[];
-  pagesNotAffected: PageDetail[];
-  scannedPagesCount: number;
-  pagesNotScanned: PageDetail[];
-  pagesNotScannedCount: number;
-}
-
-export const getProgressPercentage = (
-  scanPagesDetail: ScanPagesDetail,
-  showEnableWcagAaa: boolean,
-): {
-  averageProgressPercentageAA: string;
-  averageProgressPercentageAAandAAA: string;
-} => {
-  const pages = scanPagesDetail.pagesAffected || [];
-
-  const progressPercentagesAA = pages.map((page: PageDetail) => {
-    const violations: string[] = page.conformance;
-    return getWcagPassPercentage(violations, showEnableWcagAaa).passPercentageAA;
-  });
-
-  const progressPercentagesAAandAAA = pages.map((page: PageDetail) => {
-    const violations: string[] = page.conformance;
-    return getWcagPassPercentage(violations, showEnableWcagAaa).passPercentageAAandAAA;
-  });
-
-  const totalAA = progressPercentagesAA.reduce((sum, p) => sum + parseFloat(p), 0);
-  const avgAA = progressPercentagesAA.length ? totalAA / progressPercentagesAA.length : 0;
-
-  const totalAAandAAA = progressPercentagesAAandAAA.reduce((sum, p) => sum + parseFloat(p), 0);
-  const avgAAandAAA = progressPercentagesAAandAAA.length
-    ? totalAAandAAA / progressPercentagesAAandAAA.length
-    : 0;
-
-  return {
-    averageProgressPercentageAA: avgAA.toFixed(2),
-    averageProgressPercentageAAandAAA: avgAAandAAA.toFixed(2),
-  };
-};
-
-export const getTotalRulesCount = async (
-  enableWcagAaa: boolean,
-  disableOobee: boolean,
-): Promise<{
-  totalRulesMustFix: number;
-  totalRulesGoodToFix: number;
-  totalRulesMustFixAndGoodToFix: number;
-}> => {
-  const axeConfig = getAxeConfiguration({
-    enableWcagAaa,
-    gradingReadabilityFlag: '',
-    disableOobee,
-  });
-
-  // Get default rules from axe-core
-  const defaultRules = axe.getRules();
-
-  // Merge custom rules with default rules, converting RuleMetadata to Rule
-  const mergedRules: Rule[] = defaultRules.map(defaultRule => {
-    const customRule = axeConfig.rules.find(r => r.id === defaultRule.ruleId);
-    if (customRule) {
-      // Merge properties from customRule into defaultRule (RuleMetadata) to create a Rule
-      return {
-        id: defaultRule.ruleId,
-        enabled: customRule.enabled,
-        selector: customRule.selector,
-        any: customRule.any,
-        tags: defaultRule.tags,
-        metadata: customRule.metadata, // Use custom metadata if it exists
-      };
-    }
-    // Convert defaultRule (RuleMetadata) to Rule
-    return {
-      id: defaultRule.ruleId,
-      enabled: true, // Default to true if not overridden
-      tags: defaultRule.tags,
-      // No metadata here, since defaultRule.metadata might not exist
-    };
-  });
-
-  // Add any custom rules that don't override the default rules
-  axeConfig.rules.forEach(customRule => {
-    if (!mergedRules.some(mergedRule => mergedRule.id === customRule.id)) {
-      // Ensure customRule is of type Rule
-      const rule: Rule = {
-        id: customRule.id,
-        enabled: customRule.enabled,
-        selector: customRule.selector,
-        any: customRule.any,
-        tags: customRule.tags,
-        metadata: customRule.metadata,
-        // Add other properties if needed
-      };
-      mergedRules.push(rule);
-    }
-  });
-
-  // Apply the merged configuration to axe-core
-  axe.configure({ ...axeConfig, rules: mergedRules });
-
-  // ... (rest of your logic)
-  let totalRulesMustFix = 0;
-  let totalRulesGoodToFix = 0;
-
-  const wcagRegex = /^wcag\d+a+$/;
-
-  // Use mergedRules instead of rules to check enabled property
-  mergedRules.forEach(rule => {
-    if (!rule.enabled) {
-      return;
-    }
-
-    if (rule.id === 'frame-tested') return; // Ignore 'frame-tested' rule
-
-    const tags = rule.tags || [];
-
-    // Skip experimental and deprecated rules
-    if (tags.includes('experimental') || tags.includes('deprecated')) {
-      return;
-    }
-
-    const conformance = tags.filter(tag => tag.startsWith('wcag') || tag === 'best-practice');
-
-    // Ensure conformance level is sorted correctly
-    if (
-      conformance.length > 0 &&
-      conformance[0] !== 'best-practice' &&
-      !wcagRegex.test(conformance[0])
-    ) {
-      conformance.sort((a, b) => {
-        if (wcagRegex.test(a) && !wcagRegex.test(b)) {
-          return -1;
-        }
-        if (!wcagRegex.test(a) && wcagRegex.test(b)) {
-          return 1;
-        }
-        return 0;
-      });
-    }
-
-    if (conformance.includes('best-practice')) {
-      // console.log(`${totalRulesMustFix} Good To Fix: ${rule.id}`);
-
-      totalRulesGoodToFix += 1; // Categorized as "Good to Fix"
-    } else {
-      // console.log(`${totalRulesMustFix} Must Fix: ${rule.id}`);
-
-      totalRulesMustFix += 1; // Otherwise, it's "Must Fix"
-    }
-  });
-
-  return {
-    totalRulesMustFix,
-    totalRulesGoodToFix,
-    totalRulesMustFixAndGoodToFix: totalRulesMustFix + totalRulesGoodToFix,
-  };
-};
-
-/**
- * Dynamically generates a map of WCAG criteria IDs to their details (name and level)
- * Reuses the rule processing logic from getTotalRulesCount
- */
-export const getWcagCriteriaMap = async (
-  enableWcagAaa: boolean = true,
-  disableOobee: boolean = false
-): Promise<Record<string, { name: string; level: string }>> => {
-  // Reuse the configuration setup from getTotalRulesCount
-  const axeConfig = getAxeConfiguration({
-    enableWcagAaa,
-    gradingReadabilityFlag: '',
-    disableOobee,
-  });
-
-  // Get default rules from axe-core
-  const defaultRules = axe.getRules();
-
-  // Merge custom rules with default rules
-  const mergedRules: Rule[] = defaultRules.map(defaultRule => {
-    const customRule = axeConfig.rules.find(r => r.id === defaultRule.ruleId);
-    if (customRule) {
-      return {
-        id: defaultRule.ruleId,
-        enabled: customRule.enabled,
-        selector: customRule.selector,
-        any: customRule.any,
-        tags: defaultRule.tags,
-        metadata: customRule.metadata,
-      };
-    }
-    return {
-      id: defaultRule.ruleId,
-      enabled: true,
-      tags: defaultRule.tags,
-    };
-  });
-
-  // Add custom rules that don't override default rules
-  axeConfig.rules.forEach(customRule => {
-    if (!mergedRules.some(rule => rule.id === customRule.id)) {
-      mergedRules.push({
-        id: customRule.id,
-        enabled: customRule.enabled,
-        selector: customRule.selector,
-        any: customRule.any,
-        tags: customRule.tags,
-        metadata: customRule.metadata,
-      });
-    }
-  });
-
-  // Apply configuration
-  axe.configure({ ...axeConfig, rules: mergedRules });
-
-  // Build WCAG criteria map
-  const wcagCriteriaMap: Record<string, { name: string; level: string }> = {};
-  
-  // Process rules to extract WCAG information
-  mergedRules.forEach(rule => {
-    if (!rule.enabled) return;
-    if (rule.id === 'frame-tested') return;
-    
-    const tags = rule.tags || [];
-    if (tags.includes('experimental') || tags.includes('deprecated')) return;
-    
-    // Look for WCAG criteria tags (format: wcag111, wcag143, etc.)
-    tags.forEach(tag => {
-      const wcagMatch = tag.match(/^wcag(\d+)$/);
-      if (wcagMatch) {
-        const wcagId = tag;
-        
-        // Default values
-        let level = 'a';
-        let name = '';
-        
-        // Try to extract better info from metadata if available
-        const metadata = rule.metadata as any;
-        if (metadata && metadata.wcag) {
-          const wcagInfo = metadata.wcag as any;
-          
-          // Find matching criterion in metadata
-          for (const key in wcagInfo) {
-            const criterion = wcagInfo[key];
-            if (criterion && 
-                criterion.num && 
-                `wcag${criterion.num.replace(/\./g, '')}` === wcagId) {
-              
-              // Extract level
-              if (criterion.level) {
-                level = String(criterion.level).toLowerCase();
-              }
-              
-              // Extract name
-              if (criterion.handle) {
-                name = String(criterion.handle);
-              } else if (criterion.id) {
-                name = String(criterion.id);
-              } else if (criterion.num) {
-                name = `wcag-${String(criterion.num).replace(/\./g, '-')}`;
-              }
-              
-              break;
-            }
-          }
-        }
-        
-        // Generate fallback name if none found
-        if (!name) {
-          const numStr = wcagMatch[1];
-          const formattedNum = numStr.replace(/(\d)(\d)(\d+)?/, '$1.$2.$3');
-          name = `wcag-${formattedNum.replace(/\./g, '-')}`;
-        }
-        
-        // Store in map
-        wcagCriteriaMap[wcagId] = { 
-          name: name.toLowerCase().replace(/_/g, '-'),
-          level
-        };
-      }
-    });
-  });
-  
-  return wcagCriteriaMap;
-};
-
-export const getIssuesPercentage = async (
-  scanPagesDetail: ScanPagesDetail,
-  enableWcagAaa: boolean,
-  disableOobee: boolean,
-): Promise<{
-  avgTypesOfIssuesPercentageOfTotalRulesAtMustFix: string;
-  avgTypesOfIssuesPercentageOfTotalRulesAtGoodToFix: string;
-  avgTypesOfIssuesPercentageOfTotalRulesAtMustFixAndGoodToFix: string;
-  totalRulesMustFix: number;
-  totalRulesGoodToFix: number;
-  totalRulesMustFixAndGoodToFix: number;
-  avgTypesOfIssuesCountAtMustFix: string;
-  avgTypesOfIssuesCountAtGoodToFix: string;
-  avgTypesOfIssuesCountAtMustFixAndGoodToFix: string;
-  pagesAffectedPerRule: Record<string, number>;
-  pagesPercentageAffectedPerRule: Record<string, string>;
-}> => {
-  const pages = scanPagesDetail.pagesAffected || [];
-  const totalPages = pages.length;
-
-  const pagesAffectedPerRule: Record<string, number> = {};
-
-  pages.forEach(page => {
-    page.typesOfIssues.forEach(issue => {
-      if ((issue.occurrencesMustFix || issue.occurrencesGoodToFix) > 0) {
-        pagesAffectedPerRule[issue.ruleId] = (pagesAffectedPerRule[issue.ruleId] || 0) + 1;
-      }
-    });
-  });
-
-  const pagesPercentageAffectedPerRule: Record<string, string> = {};
-  Object.entries(pagesAffectedPerRule).forEach(([ruleId, count]) => {
-    pagesPercentageAffectedPerRule[ruleId] =
-      totalPages > 0 ? ((count / totalPages) * 100).toFixed(2) : '0.00';
-  });
-
-  const typesOfIssuesCountAtMustFix = pages.map(
-    page => page.typesOfIssues.filter(issue => (issue.occurrencesMustFix || 0) > 0).length,
-  );
-
-  const typesOfIssuesCountAtGoodToFix = pages.map(
-    page => page.typesOfIssues.filter(issue => (issue.occurrencesGoodToFix || 0) > 0).length,
-  );
-
-  const typesOfIssuesCountSumMustFixAndGoodToFix = pages.map(
-    (_, index) =>
-      (typesOfIssuesCountAtMustFix[index] || 0) + (typesOfIssuesCountAtGoodToFix[index] || 0),
-  );
-
-  const { totalRulesMustFix, totalRulesGoodToFix, totalRulesMustFixAndGoodToFix } =
-    await getTotalRulesCount(enableWcagAaa, disableOobee);
-
-  const avgMustFixPerPage =
-    totalPages > 0
-      ? typesOfIssuesCountAtMustFix.reduce((sum, count) => sum + count, 0) / totalPages
-      : 0;
-
-  const avgGoodToFixPerPage =
-    totalPages > 0
-      ? typesOfIssuesCountAtGoodToFix.reduce((sum, count) => sum + count, 0) / totalPages
-      : 0;
-
-  const avgMustFixAndGoodToFixPerPage =
-    totalPages > 0
-      ? typesOfIssuesCountSumMustFixAndGoodToFix.reduce((sum, count) => sum + count, 0) / totalPages
-      : 0;
-
-  const avgTypesOfIssuesPercentageOfTotalRulesAtMustFix =
-    totalRulesMustFix > 0 ? ((avgMustFixPerPage / totalRulesMustFix) * 100).toFixed(2) : '0.00';
-
-  const avgTypesOfIssuesPercentageOfTotalRulesAtGoodToFix =
-    totalRulesGoodToFix > 0
-      ? ((avgGoodToFixPerPage / totalRulesGoodToFix) * 100).toFixed(2)
-      : '0.00';
-
-  const avgTypesOfIssuesPercentageOfTotalRulesAtMustFixAndGoodToFix =
-    totalRulesMustFixAndGoodToFix > 0
-      ? ((avgMustFixAndGoodToFixPerPage / totalRulesMustFixAndGoodToFix) * 100).toFixed(2)
-      : '0.00';
-
-  const avgTypesOfIssuesCountAtMustFix = avgMustFixPerPage.toFixed(2);
-  const avgTypesOfIssuesCountAtGoodToFix = avgGoodToFixPerPage.toFixed(2);
-  const avgTypesOfIssuesCountAtMustFixAndGoodToFix = avgMustFixAndGoodToFixPerPage.toFixed(2);
-
-  return {
-    avgTypesOfIssuesCountAtMustFix,
-    avgTypesOfIssuesCountAtGoodToFix,
-    avgTypesOfIssuesCountAtMustFixAndGoodToFix,
-    avgTypesOfIssuesPercentageOfTotalRulesAtMustFix,
-    avgTypesOfIssuesPercentageOfTotalRulesAtGoodToFix,
-    avgTypesOfIssuesPercentageOfTotalRulesAtMustFixAndGoodToFix,
-    totalRulesMustFix,
-    totalRulesGoodToFix,
-    totalRulesMustFixAndGoodToFix,
-    pagesAffectedPerRule,
-    pagesPercentageAffectedPerRule,
-  };
-};
-
-export const getFormattedTime = (inputDate: Date): string => {
-  if (inputDate) {
-    return inputDate.toLocaleTimeString('en-GB', {
-      year: 'numeric',
-      month: 'short',
-      day: 'numeric',
-      hour12: false,
-      hour: 'numeric',
-      minute: '2-digit',
-    });
-  }
-  return new Date().toLocaleTimeString('en-GB', {
-    year: 'numeric',
-    month: 'short',
-    day: 'numeric',
-    hour12: false,
-    hour: 'numeric',
-    minute: '2-digit',
-    timeZoneName: 'longGeneric',
-  });
-};
-
-export const formatDateTimeForMassScanner = (date: Date): string => {
-  // Format date and time parts separately
-  const year = date.getFullYear().toString().slice(-2); // Get the last two digits of the year
-  const month = `0${date.getMonth() + 1}`.slice(-2); // Month is zero-indexed
-  const day = `0${date.getDate()}`.slice(-2);
-  const hour = `0${date.getHours()}`.slice(-2);
-  const minute = `0${date.getMinutes()}`.slice(-2);
-
-  // Combine formatted date and time with a slash
-  const formattedDateTime = `${day}/${month}/${year} ${hour}:${minute}`;
-
-  return formattedDateTime;
-};
-
-export const setHeadlessMode = (browser: string, isHeadless: boolean): void => {
-  if (isHeadless) {
-    process.env.CRAWLEE_HEADLESS = '1';
-  } else {
-    process.env.CRAWLEE_HEADLESS = '0';
-  }
-};
-
-export const setThresholdLimits = (setWarnLevel: string): void => {
-  process.env.WARN_LEVEL = setWarnLevel;
-};
-
-export const zipResults = async (zipName: string, resultsPath: string): Promise<void> => {
-  // Resolve and validate the output path
-  const zipFilePath = path.isAbsolute(zipName) ? zipName : path.join(resultsPath, zipName);
-
-  // Ensure parent dir exists
-  fs.mkdirSync(path.dirname(zipFilePath), { recursive: true });
-
-  // Remove any prior file atomically
-  try { fs.unlinkSync(zipFilePath); } catch { /* ignore if not exists */ }
-
-  // CWD must exist and be a directory
-  const stats = fs.statSync(resultsPath);
-  if (!stats.isDirectory()) {
-    throw new Error(`resultsPath is not a directory: ${resultsPath}`);
-  }
-  async function addFolderToZip(folderPath: string, zipFolder: JSZip): Promise<void> {
-    const items = await fs.readdir(folderPath);
-    for (const item of items) {
-      const fullPath = path.join(folderPath, item);
-      const stats = await fs.stat(fullPath);
-      if (stats.isDirectory()) {
-        const folder = zipFolder.folder(item);
-        await addFolderToZip(fullPath, folder);
-      } else {
-        // Add file as a stream so that it doesn't load the entire file into memory
-        zipFolder.file(item, createReadStream(fullPath));
-      }
-    }
-  }
-
-  const zip = new JSZip();
-  await addFolderToZip(resultsPath, zip);
-
-  const zipStream = zip.generateNodeStream({
-    type: 'nodebuffer',
-    streamFiles: true,
-    compression: 'DEFLATE',
-  });
-
-  await new Promise((resolve, reject) => {
-    const outStream = createWriteStream(zipFilePath);
-    zipStream.pipe(outStream)
-      .on('finish', () => resolve(undefined))
-      .on('error', reject);
-  });
-};
-
-// areLinksEqual compares 2 string URLs and ignores comparison of 'www.' and url protocol
-// i.e. 'http://google.com' and 'https://www.google.com' returns true
-export const areLinksEqual = (link1: string, link2: string): boolean => {
-  try {
-    const format = (link: string): URL => {
-      return new URL(link.replace(/www\./, ''));
-    };
-    const l1 = format(link1);
-    const l2 = format(link2);
-
-    const areHostEqual = l1.host === l2.host;
-    const arePathEqual = l1.pathname === l2.pathname;
-
-    return areHostEqual && arePathEqual;
-  } catch {
-    return link1 === link2;
-  }
-};
-
-export const randomThreeDigitNumberString = () => {
-  // Generate a random decimal between 0 (inclusive) and 1 (exclusive)
-  const randomDecimal = Math.random();
-  // Multiply by 900 to get a decimal between 0 (inclusive) and 900 (exclusive)
-  const scaledDecimal = randomDecimal * 900;
-  // Add 100 to ensure the result is between 100 (inclusive) and 1000 (exclusive)
-  const threeDigitNumber = Math.floor(scaledDecimal) + 100;
-  return String(threeDigitNumber);
-};
-
-export const isFollowStrategy = (link1: string, link2: string, rule: string): boolean => {
-  const parsedLink1 = new URL(link1);
-  const parsedLink2 = new URL(link2);
-  if (rule === 'same-domain') {
-    const link1Domain = parsedLink1.hostname.split('.').slice(-2).join('.');
-    const link2Domain = parsedLink2.hostname.split('.').slice(-2).join('.');
-    return link1Domain === link2Domain;
-  }
-  return parsedLink1.hostname === parsedLink2.hostname;
-};
-
-export const retryFunction = async <T>(func: () => Promise<T>, maxAttempt: number): Promise<T> => {
-  let attemptCount = 0;
-  while (attemptCount < maxAttempt) {
-    attemptCount += 1;
-    try {
-      // eslint-disable-next-line no-await-in-loop
-      const result = await func();
-      return result;
-    } catch (error) {
-      // do nothing, just retry  
-    }
-  }
-  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;
-};
diff --git a/src/utils/dateTimeFormatting.ts b/src/utils/dateTimeFormatting.ts
new file mode 100644
index 00000000..eeb97718
--- /dev/null
+++ b/src/utils/dateTimeFormatting.ts
@@ -0,0 +1,35 @@
+export const getFormattedTime = (inputDate: Date): string => {
+  if (inputDate) {
+    return inputDate.toLocaleTimeString('en-GB', {
+      year: 'numeric',
+      month: 'short',
+      day: 'numeric',
+      hour12: false,
+      hour: 'numeric',
+      minute: '2-digit',
+    });
+  }
+  return new Date().toLocaleTimeString('en-GB', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour12: false,
+    hour: 'numeric',
+    minute: '2-digit',
+    timeZoneName: 'longGeneric',
+  });
+};
+
+export const formatDateTimeForMassScanner = (date: Date): string => {
+  // Format date and time parts separately
+  const year = date.getFullYear().toString().slice(-2); // Get the last two digits of the year
+  const month = `0${date.getMonth() + 1}`.slice(-2); // Month is zero-indexed
+  const day = `0${date.getDate()}`.slice(-2);
+  const hour = `0${date.getHours()}`.slice(-2);
+  const minute = `0${date.getMinutes()}`.slice(-2);
+
+  // Combine formatted date and time with a slash
+  const formattedDateTime = `${day}/${month}/${year} ${hour}:${minute}`;
+
+  return formattedDateTime;
+};
diff --git a/src/utils/getCurrentDate.ts b/src/utils/getCurrentDate.ts
new file mode 100644
index 00000000..c2b9c21a
--- /dev/null
+++ b/src/utils/getCurrentDate.ts
@@ -0,0 +1,6 @@
+const getCurrentDate = (): string => {
+  const date = new Date();
+  return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
+};
+
+export default getCurrentDate;
diff --git a/src/utils/getHost.ts b/src/utils/getHost.ts
new file mode 100644
index 00000000..80f33415
--- /dev/null
+++ b/src/utils/getHost.ts
@@ -0,0 +1,3 @@
+const getHost = (url: string): string => new URL(url).host;
+
+export default getHost;
diff --git a/src/utils/getPdfStoragePath.ts b/src/utils/getPdfStoragePath.ts
new file mode 100644
index 00000000..e1130e32
--- /dev/null
+++ b/src/utils/getPdfStoragePath.ts
@@ -0,0 +1,14 @@
+import path from 'path';
+import fs from 'fs-extra';
+import getStoragePath from './getStoragePath.js';
+
+const getPdfStoragePath = (randomToken: string): string => {
+  const storagePath = getStoragePath(randomToken);
+  const pdfStoragePath = path.join(storagePath, 'pdfs');
+  if (!fs.existsSync(pdfStoragePath)) {
+    fs.mkdirSync(pdfStoragePath, { recursive: true });
+  }
+  return pdfStoragePath;
+};
+
+export default getPdfStoragePath;
diff --git a/src/utils/getStoragePath.ts b/src/utils/getStoragePath.ts
new file mode 100644
index 00000000..da955147
--- /dev/null
+++ b/src/utils/getStoragePath.ts
@@ -0,0 +1,57 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import constants from '../constants/constants.js';
+import { consoleLogger } from '../logs.js';
+
+const getStoragePath = (randomToken: string): string => {
+  // If exportDirectory is set, use it
+  if (constants.exportDirectory) {
+    return constants.exportDirectory;
+  }
+
+  // Otherwise, use the current working directory
+  let storagePath = path.join(process.cwd(), 'results', randomToken);
+
+  // Ensure storagePath is writable; if directory doesn't exist, try to create it in Documents or home directory
+  const isWritable = (() => {
+    try {
+      if (!fs.existsSync(storagePath)) {
+        fs.mkdirSync(storagePath, { recursive: true });
+      }
+      fs.accessSync(storagePath, fs.constants.W_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+
+  if (!isWritable) {
+    if (os.platform() === 'win32') {
+      // Use Documents folder on Windows
+      const documentsPath = path.join(
+        process.env.USERPROFILE || process.env.HOMEPATH || '',
+        'Documents',
+      );
+      storagePath = path.join(documentsPath, 'Oobee', randomToken);
+    } else if (os.platform() === 'darwin') {
+      // Use Documents folder on Mac
+      const documentsPath = path.join(process.env.HOME || '', 'Documents');
+      storagePath = path.join(documentsPath, 'Oobee', randomToken);
+    } else {
+      // Use home directory for Linux/other
+      const homePath = process.env.HOME || '';
+      storagePath = path.join(homePath, 'Oobee', randomToken);
+    }
+    consoleLogger.warn(`Warning: Cannot write to cwd, writing to ${storagePath}`);
+  }
+
+  if (!fs.existsSync(storagePath)) {
+    fs.mkdirSync(storagePath, { recursive: true });
+  }
+
+  constants.exportDirectory = storagePath;
+  return storagePath;
+};
+
+export default getStoragePath;
diff --git a/src/utils/getVersion.ts b/src/utils/getVersion.ts
new file mode 100644
index 00000000..39e815b6
--- /dev/null
+++ b/src/utils/getVersion.ts
@@ -0,0 +1,9 @@
+import fs from 'fs-extra';
+
+const getVersion = (): string => {
+  const loadJSON = (filePath: string): { version: string } =>
+    JSON.parse(fs.readFileSync(new URL(filePath, import.meta.url)).toString());
+  return loadJSON('../../package.json').version;
+};
+
+export default getVersion;
diff --git a/src/utils/index.ts b/src/utils/index.ts
new file mode 100644
index 00000000..754e1033
--- /dev/null
+++ b/src/utils/index.ts
@@ -0,0 +1,38 @@
+export { default as getVersion } from './getVersion.js';
+export { default as getHost } from './getHost.js';
+export { default as getCurrentDate } from './getCurrentDate.js';
+export { getFormattedTime, formatDateTimeForMassScanner } from './dateTimeFormatting.js';
+export {
+  registerSoftClose,
+  softCloseBrowserAndContext,
+  register,
+  stopAll,
+  cleanUp,
+  cleanUpAndExit,
+  listenForCleanUp,
+} from './lifecycle.js';
+export {
+  getWcagPassPercentage,
+  getProgressPercentage,
+  type IssueCategory,
+  type IssueDetail,
+  type PageDetail,
+  type ScanPagesDetail,
+} from './wcagProgress.js';
+export { getTotalRulesCount, getIssuesPercentage } from './issuesPercentage.js';
+export {
+  getWcagCriteriaMap,
+  getPotentialNeedsReviewWcagCriteria,
+  categorizeWcagCriterion,
+  categorizeWcagCriteria,
+} from './wcagClassification.js';
+export { default as getStoragePath } from './getStoragePath.js';
+export { default as getPdfStoragePath } from './getPdfStoragePath.js';
+export { default as isWhitelistedContentType } from './isWhitelistedContentType.js';
+export { default as retryFunction } from './retryFunction.js';
+export { default as zipResults } from './zipResults.js';
+export { default as randomThreeDigitNumberString } from './randomThreeDigitNumberString.js';
+export { areLinksEqual, isFollowStrategy } from './linkStrategy.js';
+export { setHeadlessMode, setThresholdLimits } from './runtimeFlags.js';
+export { getUserDataFilePath, getUserDataTxt, writeToUserDataTxt } from './userData.js';
+export { createAndUpdateResultsFolders, createScreenshotsFolder } from './resultsFolders.js';
diff --git a/src/utils/isWhitelistedContentType.ts b/src/utils/isWhitelistedContentType.ts
new file mode 100644
index 00000000..8b09547b
--- /dev/null
+++ b/src/utils/isWhitelistedContentType.ts
@@ -0,0 +1,6 @@
+const isWhitelistedContentType = (contentType: string): boolean => {
+  const whitelist = ['text/html'];
+  return whitelist.filter(type => contentType.trim().startsWith(type)).length === 1;
+};
+
+export default isWhitelistedContentType;
diff --git a/src/utils/issuesPercentage.ts b/src/utils/issuesPercentage.ts
new file mode 100644
index 00000000..78350c76
--- /dev/null
+++ b/src/utils/issuesPercentage.ts
@@ -0,0 +1,220 @@
+import axe, { Rule } from 'axe-core';
+import { getAxeConfiguration } from '../crawlers/custom/getAxeConfiguration.js';
+import type { ScanPagesDetail } from './wcagProgress.js';
+
+export const getTotalRulesCount = async (
+  enableWcagAaa: boolean,
+  disableOobee: boolean,
+): Promise<{
+  totalRulesMustFix: number;
+  totalRulesGoodToFix: number;
+  totalRulesMustFixAndGoodToFix: number;
+}> => {
+  const axeConfig = getAxeConfiguration({
+    enableWcagAaa,
+    gradingReadabilityFlag: '',
+    disableOobee,
+  });
+
+  // Get default rules from axe-core
+  const defaultRules = axe.getRules();
+
+  // Merge custom rules with default rules, converting RuleMetadata to Rule
+  const mergedRules: Rule[] = defaultRules.map(defaultRule => {
+    const customRule = axeConfig.rules.find(r => r.id === defaultRule.ruleId);
+    if (customRule) {
+      // Merge properties from customRule into defaultRule (RuleMetadata) to create a Rule
+      return {
+        id: defaultRule.ruleId,
+        enabled: customRule.enabled,
+        selector: customRule.selector,
+        any: customRule.any,
+        tags: defaultRule.tags,
+        metadata: customRule.metadata, // Use custom metadata if it exists
+      };
+    }
+    // Convert defaultRule (RuleMetadata) to Rule
+    return {
+      id: defaultRule.ruleId,
+      enabled: true, // Default to true if not overridden
+      tags: defaultRule.tags,
+      // No metadata here, since defaultRule.metadata might not exist
+    };
+  });
+
+  // Add any custom rules that don't override the default rules
+  axeConfig.rules.forEach(customRule => {
+    if (!mergedRules.some(mergedRule => mergedRule.id === customRule.id)) {
+      // Ensure customRule is of type Rule
+      const rule: Rule = {
+        id: customRule.id,
+        enabled: customRule.enabled,
+        selector: customRule.selector,
+        any: customRule.any,
+        tags: customRule.tags,
+        metadata: customRule.metadata,
+        // Add other properties if needed
+      };
+      mergedRules.push(rule);
+    }
+  });
+
+  // Apply the merged configuration to axe-core
+  axe.configure({ ...axeConfig, rules: mergedRules });
+
+  // ... (rest of your logic)
+  let totalRulesMustFix = 0;
+  let totalRulesGoodToFix = 0;
+
+  const wcagRegex = /^wcag\d+a+$/;
+
+  // Use mergedRules instead of rules to check enabled property
+  mergedRules.forEach(rule => {
+    if (!rule.enabled) {
+      return;
+    }
+
+    if (rule.id === 'frame-tested') return; // Ignore 'frame-tested' rule
+
+    const tags = rule.tags || [];
+
+    // Skip experimental and deprecated rules
+    if (tags.includes('experimental') || tags.includes('deprecated')) {
+      return;
+    }
+
+    const conformance = tags.filter(tag => tag.startsWith('wcag') || tag === 'best-practice');
+
+    // Ensure conformance level is sorted correctly
+    if (
+      conformance.length > 0 &&
+      conformance[0] !== 'best-practice' &&
+      !wcagRegex.test(conformance[0])
+    ) {
+      conformance.sort((a, b) => {
+        if (wcagRegex.test(a) && !wcagRegex.test(b)) {
+          return -1;
+        }
+        if (!wcagRegex.test(a) && wcagRegex.test(b)) {
+          return 1;
+        }
+        return 0;
+      });
+    }
+
+    if (conformance.includes('best-practice')) {
+      // console.log(`${totalRulesMustFix} Good To Fix: ${rule.id}`);
+
+      totalRulesGoodToFix += 1; // Categorized as "Good to Fix"
+    } else {
+      // console.log(`${totalRulesMustFix} Must Fix: ${rule.id}`);
+
+      totalRulesMustFix += 1; // Otherwise, it's "Must Fix"
+    }
+  });
+
+  return {
+    totalRulesMustFix,
+    totalRulesGoodToFix,
+    totalRulesMustFixAndGoodToFix: totalRulesMustFix + totalRulesGoodToFix,
+  };
+};
+
+export const getIssuesPercentage = async (
+  scanPagesDetail: ScanPagesDetail,
+  enableWcagAaa: boolean,
+  disableOobee: boolean,
+): Promise<{
+  avgTypesOfIssuesPercentageOfTotalRulesAtMustFix: string;
+  avgTypesOfIssuesPercentageOfTotalRulesAtGoodToFix: string;
+  avgTypesOfIssuesPercentageOfTotalRulesAtMustFixAndGoodToFix: string;
+  totalRulesMustFix: number;
+  totalRulesGoodToFix: number;
+  totalRulesMustFixAndGoodToFix: number;
+  avgTypesOfIssuesCountAtMustFix: string;
+  avgTypesOfIssuesCountAtGoodToFix: string;
+  avgTypesOfIssuesCountAtMustFixAndGoodToFix: string;
+  pagesAffectedPerRule: Record<string, number>;
+  pagesPercentageAffectedPerRule: Record<string, string>;
+}> => {
+  const pages = scanPagesDetail.pagesAffected || [];
+  const totalPages = pages.length;
+
+  const pagesAffectedPerRule: Record<string, number> = {};
+
+  pages.forEach(page => {
+    page.typesOfIssues.forEach(issue => {
+      if ((issue.occurrencesMustFix || issue.occurrencesGoodToFix) > 0) {
+        pagesAffectedPerRule[issue.ruleId] = (pagesAffectedPerRule[issue.ruleId] || 0) + 1;
+      }
+    });
+  });
+
+  const pagesPercentageAffectedPerRule: Record<string, string> = {};
+  Object.entries(pagesAffectedPerRule).forEach(([ruleId, count]) => {
+    pagesPercentageAffectedPerRule[ruleId] =
+      totalPages > 0 ? ((count / totalPages) * 100).toFixed(2) : '0.00';
+  });
+
+  const typesOfIssuesCountAtMustFix = pages.map(
+    page => page.typesOfIssues.filter(issue => (issue.occurrencesMustFix || 0) > 0).length,
+  );
+
+  const typesOfIssuesCountAtGoodToFix = pages.map(
+    page => page.typesOfIssues.filter(issue => (issue.occurrencesGoodToFix || 0) > 0).length,
+  );
+
+  const typesOfIssuesCountSumMustFixAndGoodToFix = pages.map(
+    (_, index) =>
+      (typesOfIssuesCountAtMustFix[index] || 0) + (typesOfIssuesCountAtGoodToFix[index] || 0),
+  );
+
+  const { totalRulesMustFix, totalRulesGoodToFix, totalRulesMustFixAndGoodToFix } =
+    await getTotalRulesCount(enableWcagAaa, disableOobee);
+
+  const avgMustFixPerPage =
+    totalPages > 0
+      ? typesOfIssuesCountAtMustFix.reduce((sum, count) => sum + count, 0) / totalPages
+      : 0;
+
+  const avgGoodToFixPerPage =
+    totalPages > 0
+      ? typesOfIssuesCountAtGoodToFix.reduce((sum, count) => sum + count, 0) / totalPages
+      : 0;
+
+  const avgMustFixAndGoodToFixPerPage =
+    totalPages > 0
+      ? typesOfIssuesCountSumMustFixAndGoodToFix.reduce((sum, count) => sum + count, 0) / totalPages
+      : 0;
+
+  const avgTypesOfIssuesPercentageOfTotalRulesAtMustFix =
+    totalRulesMustFix > 0 ? ((avgMustFixPerPage / totalRulesMustFix) * 100).toFixed(2) : '0.00';
+
+  const avgTypesOfIssuesPercentageOfTotalRulesAtGoodToFix =
+    totalRulesGoodToFix > 0
+      ? ((avgGoodToFixPerPage / totalRulesGoodToFix) * 100).toFixed(2)
+      : '0.00';
+
+  const avgTypesOfIssuesPercentageOfTotalRulesAtMustFixAndGoodToFix =
+    totalRulesMustFixAndGoodToFix > 0
+      ? ((avgMustFixAndGoodToFixPerPage / totalRulesMustFixAndGoodToFix) * 100).toFixed(2)
+      : '0.00';
+
+  const avgTypesOfIssuesCountAtMustFix = avgMustFixPerPage.toFixed(2);
+  const avgTypesOfIssuesCountAtGoodToFix = avgGoodToFixPerPage.toFixed(2);
+  const avgTypesOfIssuesCountAtMustFixAndGoodToFix = avgMustFixAndGoodToFixPerPage.toFixed(2);
+
+  return {
+    avgTypesOfIssuesCountAtMustFix,
+    avgTypesOfIssuesCountAtGoodToFix,
+    avgTypesOfIssuesCountAtMustFixAndGoodToFix,
+    avgTypesOfIssuesPercentageOfTotalRulesAtMustFix,
+    avgTypesOfIssuesPercentageOfTotalRulesAtGoodToFix,
+    avgTypesOfIssuesPercentageOfTotalRulesAtMustFixAndGoodToFix,
+    totalRulesMustFix,
+    totalRulesGoodToFix,
+    totalRulesMustFixAndGoodToFix,
+    pagesAffectedPerRule,
+    pagesPercentageAffectedPerRule,
+  };
+};
diff --git a/src/utils/lifecycle.ts b/src/utils/lifecycle.ts
new file mode 100644
index 00000000..3d31ce42
--- /dev/null
+++ b/src/utils/lifecycle.ts
@@ -0,0 +1,294 @@
+import path from 'path';
+import fs from 'fs-extra';
+import constants from '../constants/constants.js';
+import { consoleLogger, errorsTxtPath } from '../logs.js';
+import getStoragePath from './getStoragePath.js';
+
+let __shuttingDown = false;
+let __stopAllLock: Promise<void> | null = null;
+let __softCloseHandler: (() => Promise<void>) | null = null;
+
+export function registerSoftClose(handler: () => Promise<void>) {
+  __softCloseHandler = handler;
+}
+
+export async function softCloseBrowserAndContext() {
+  if (!__softCloseHandler) {
+    consoleLogger.info(
+      'softCloseBrowserAndContext: no handler registered (probably not a custom-flow scan)',
+    );
+    return;
+  }
+
+  try {
+    consoleLogger.info('softCloseBrowserAndContext: calling registered handler...');
+    await __softCloseHandler();
+  } catch (e: any) {
+    consoleLogger.warn(`softCloseBrowserAndContext error: ${e?.message || e}`);
+  }
+}
+
+/**
+ * Register a resource so it can be stopped later.
+ * Supports Crawlee crawlers, Playwright BrowserContexts, and Browsers.
+ */
+export function register(resource: any) {
+  const name = resource?.constructor?.name;
+
+  if (name?.endsWith('Crawler')) {
+    constants.resources.crawlers.add(resource);
+  } else if (name === 'BrowserContext') {
+    constants.resources.browserContexts.add(resource);
+  } else if (name === 'Browser') {
+    constants.resources.browsers.add(resource);
+  }
+
+  return resource;
+}
+
+/**
+ * Stops or tears down all tracked resources.
+ * @param mode "graceful" (finish in-flight), "abort" (drop in-flight), or "teardown" (close immediately)
+ * @param timeoutMs Max time to wait before forcing shutdown
+ */
+export async function stopAll({ mode = 'graceful', timeoutMs = 10_000 } = {}) {
+  if (__stopAllLock) return __stopAllLock; // prevent overlap
+  __stopAllLock = (async () => {
+    const timeout = (ms: number) => new Promise(res => setTimeout(res, ms));
+    consoleLogger.info(`Stop browsers starting, mode=${mode}, timeoutMs=${timeoutMs}`);
+
+    // --- Crawlers ---
+    for (const c of [...constants.resources.crawlers]) {
+      try {
+        const pool = (c as any).autoscaledPool;
+        if (pool && typeof pool.isRunning !== 'undefined' && !pool.isRunning) {
+          consoleLogger.info('Skipping crawler (already stopped)');
+          continue;
+        }
+
+        consoleLogger.info(`Closing crawler (${mode})...`);
+        if (mode === 'graceful') {
+          if (typeof c.stop === 'function') {
+            await Promise.race([c.stop(), timeout(timeoutMs)]);
+          }
+        } else if (mode === 'abort') {
+          pool?.abort?.();
+        } else if (typeof c.teardown === 'function') {
+          await Promise.race([c.teardown(), timeout(timeoutMs)]);
+        }
+        consoleLogger.info(`Crawler closed (${mode})`);
+      } catch (err) {
+        consoleLogger.warn(`Error stopping crawler: ${(err as Error).message}`);
+      } finally {
+        constants.resources.crawlers.delete(c);
+      }
+    }
+
+    // --- BrowserContexts ---
+    for (const ctx of [...constants.resources.browserContexts]) {
+      // compute once so we can also use in finally
+      const pagesArr = typeof ctx.pages === 'function' ? ctx.pages() : [];
+      const hasOpenPages = Array.isArray(pagesArr) && pagesArr.length > 0;
+
+      try {
+        const browser = typeof ctx.browser === 'function' ? ctx.browser() : null;
+        if (browser && (browser as any).isClosed?.()) {
+          consoleLogger.info('Skipping BrowserContext (browser already closed)');
+          continue;
+        }
+
+        // ➜ Graceful: don't kill contexts that are still doing work
+        if (mode === 'graceful' && hasOpenPages) {
+          consoleLogger.info(
+            `Skipping BrowserContext in graceful (has ${pagesArr.length} open page(s))`,
+          );
+          continue; // leave it for the teardown pass
+        }
+
+        // (Optional speed-up) close pages first if any
+        if (hasOpenPages) {
+          consoleLogger.info(`Closing ${pagesArr.length} page(s) before context close...`);
+          for (const p of pagesArr) {
+            try {
+              await Promise.race([p.close(), timeout(1500)]);
+            } catch {}
+          }
+        }
+
+        consoleLogger.info('Closing BrowserContext...');
+        if (typeof ctx.close === 'function') {
+          await Promise.race([ctx.close(), timeout(timeoutMs)]);
+        }
+        consoleLogger.info('BrowserContext closed');
+
+        // also close its browser (persistent contexts)
+        const b = browser;
+        if (b && !(b as any).isClosed?.()) {
+          consoleLogger.info('Closing Browser (from context.browser())...');
+          if (typeof b.close === 'function') {
+            await Promise.race([b.close(), timeout(timeoutMs)]);
+          }
+          consoleLogger.info('Browser closed (from context.browser())');
+        }
+      } catch (err) {
+        consoleLogger.warn(`Error closing BrowserContext: ${(err as Error).message}`);
+      } finally {
+        // only delete from the set if we actually closed it (or tried to)
+        if (!(mode === 'graceful' && hasOpenPages)) {
+          constants.resources.browserContexts.delete(ctx);
+        }
+      }
+    }
+
+    // --- Browsers ---
+    for (const b of [...constants.resources.browsers]) {
+      try {
+        if ((b as any).isClosed?.()) {
+          consoleLogger.info('Skipping Browser (already closed)');
+          continue;
+        }
+
+        consoleLogger.info('Closing Browser...');
+        if (typeof b.close === 'function') {
+          await Promise.race([b.close(), timeout(timeoutMs)]);
+        }
+        consoleLogger.info('Browser closed');
+      } catch (err) {
+        consoleLogger.warn(`Error closing Browser: ${(err as Error).message}`);
+      } finally {
+        constants.resources.browsers.delete(b);
+      }
+    }
+
+    consoleLogger.info(`Stop browsers finished for mode=${mode}`);
+  })();
+
+  try {
+    await __stopAllLock;
+  } finally {
+    __stopAllLock = null;
+  }
+}
+
+export const cleanUp = async (randomToken?: string, isError: boolean = false): Promise<void> => {
+  if (isError) {
+    await stopAll({ mode: 'graceful', timeoutMs: 8000 });
+    await stopAll({ mode: 'teardown', timeoutMs: 4000 });
+  }
+
+  if (randomToken === undefined && constants.randomToken) {
+    randomToken = constants.randomToken;
+  }
+
+  if (constants.userDataDirectory)
+    try {
+      fs.rmSync(constants.userDataDirectory, { recursive: true, force: true });
+    } catch (error) {
+      consoleLogger.warn(`Unable to force remove userDataDirectory: ${error.message}`);
+    }
+
+  if (randomToken !== undefined) {
+    const storagePath = getStoragePath(randomToken);
+
+    try {
+      fs.rmSync(path.join(storagePath, 'crawlee'), { recursive: true, force: true });
+    } catch (error) {
+      consoleLogger.warn(`Unable to force remove crawlee folder: ${error.message}`);
+    }
+
+    try {
+      fs.rmSync(path.join(storagePath, 'pdfs'), { recursive: true, force: true });
+    } 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 (fs.existsSync(storagePath) && fs.readdirSync(storagePath).length === 0) {
+      try {
+        fs.rmdirSync(storagePath);
+        consoleLogger.info(`Deleted empty storage path: ${storagePath}`);
+      } catch (error) {
+        consoleLogger.warn(`Error deleting empty storage path ${storagePath}: ${error.message}`);
+      }
+    }
+
+    consoleLogger.info(`Clean up completed for: ${randomToken}`);
+  }
+};
+
+export const cleanUpAndExit = async (
+  exitCode: number,
+  randomToken?: string,
+  isError: boolean = false,
+): Promise<void> => {
+  if (__shuttingDown) {
+    consoleLogger.info('Cleanup already in progress; ignoring duplicate exit request.');
+    return;
+  }
+  __shuttingDown = true;
+
+  try {
+    await cleanUp(randomToken, isError); // runs stopAll inside cleanUp
+  } catch (e: any) {
+    consoleLogger.warn(`Cleanup error: ${e?.message || e}`);
+  }
+
+  consoleLogger.info(`Exiting with code: ${exitCode}`);
+  process.exit(exitCode); // explicit exit after cleanup completes
+};
+
+// Clean up listeners for process signals (e.g. parent process wants to stop Oobee scan mid-point)
+// Necessary to remove residual userDataDirectory and crawlee files generated by Chrome/Edge browser on each run, so that storage does not baloon up on the server
+export const listenForCleanUp = (randomToken: string): void => {
+  consoleLogger.info(`PID: ${process.pid}`);
+
+  // SIGINT signal happens when the user presses Ctrl+C in the terminal
+  process.on('SIGINT', async () => {
+    // ← keep handler installed
+    consoleLogger.info('SIGINT received. Cleaning up and exiting.');
+    await cleanUpAndExit(130, randomToken, true);
+  });
+
+  // SIGTERM signal happens when the process is terminated (by another process or system shutdown)
+  process.on('SIGTERM', async () => {
+    // ← keep handler installed
+    consoleLogger.info('SIGTERM received. Cleaning up and exiting.');
+    await cleanUpAndExit(143, randomToken, true);
+  });
+
+  // Note: user-defined signal reserved for application-specific use.
+  // SIGUSR1 for handling closing playwright browser and continue generate artifacts etc
+  process.on('SIGUSR1', async () => {
+    consoleLogger.info('SIGUSR1 received. Soft-closing browser/context only.');
+    await softCloseBrowserAndContext();
+  });
+};
diff --git a/src/utils/linkStrategy.ts b/src/utils/linkStrategy.ts
new file mode 100644
index 00000000..e35b6f6a
--- /dev/null
+++ b/src/utils/linkStrategy.ts
@@ -0,0 +1,29 @@
+// areLinksEqual compares 2 string URLs and ignores comparison of 'www.' and url protocol
+// i.e. 'http://google.com' and 'https://www.google.com' returns true
+export const areLinksEqual = (link1: string, link2: string): boolean => {
+  try {
+    const format = (link: string): URL => {
+      return new URL(link.replace(/www\./, ''));
+    };
+    const l1 = format(link1);
+    const l2 = format(link2);
+
+    const areHostEqual = l1.host === l2.host;
+    const arePathEqual = l1.pathname === l2.pathname;
+
+    return areHostEqual && arePathEqual;
+  } catch {
+    return link1 === link2;
+  }
+};
+
+export const isFollowStrategy = (link1: string, link2: string, rule: string): boolean => {
+  const parsedLink1 = new URL(link1);
+  const parsedLink2 = new URL(link2);
+  if (rule === 'same-domain') {
+    const link1Domain = parsedLink1.hostname.split('.').slice(-2).join('.');
+    const link2Domain = parsedLink2.hostname.split('.').slice(-2).join('.');
+    return link1Domain === link2Domain;
+  }
+  return parsedLink1.hostname === parsedLink2.hostname;
+};
diff --git a/src/utils/randomThreeDigitNumberString.ts b/src/utils/randomThreeDigitNumberString.ts
new file mode 100644
index 00000000..583d54d3
--- /dev/null
+++ b/src/utils/randomThreeDigitNumberString.ts
@@ -0,0 +1,11 @@
+const randomThreeDigitNumberString = () => {
+  // Generate a random decimal between 0 (inclusive) and 1 (exclusive)
+  const randomDecimal = Math.random();
+  // Multiply by 900 to get a decimal between 0 (inclusive) and 900 (exclusive)
+  const scaledDecimal = randomDecimal * 900;
+  // Add 100 to ensure the result is between 100 (inclusive) and 1000 (exclusive)
+  const threeDigitNumber = Math.floor(scaledDecimal) + 100;
+  return String(threeDigitNumber);
+};
+
+export default randomThreeDigitNumberString;
diff --git a/src/utils/resultsFolders.ts b/src/utils/resultsFolders.ts
new file mode 100644
index 00000000..31bb01c2
--- /dev/null
+++ b/src/utils/resultsFolders.ts
@@ -0,0 +1,70 @@
+import fs from 'fs-extra';
+import constants, {
+  destinationPath,
+  getIntermediateScreenshotsPath,
+} from '../constants/constants.js';
+import { consoleLogger } from '../logs.js';
+import getStoragePath from './getStoragePath.js';
+
+export const createAndUpdateResultsFolders = async (randomToken: string): Promise<void> => {
+  const storagePath = getStoragePath(randomToken);
+  await fs.ensureDir(`${storagePath}`);
+
+  const intermediatePdfResultsPath = `${randomToken}/${constants.pdfScanResultFileName}`;
+
+  const transferResults = async (intermPath: string, resultFile: string): Promise<void> => {
+    try {
+      if (fs.existsSync(intermPath)) {
+        await fs.copy(intermPath, `${storagePath}/${resultFile}`);
+      }
+    } catch (error) {
+      if (error.code === 'EBUSY') {
+        consoleLogger.error(
+          `Unable to copy the file from ${intermPath} to ${storagePath}/${resultFile} because it is currently in use.`,
+        );
+        consoleLogger.error(
+          'Please close any applications that might be using this file and try again.',
+        );
+      } else {
+        consoleLogger.error(
+          `An unexpected error occurred while copying the file from ${intermPath} to ${storagePath}/${resultFile}: ${error.message}`,
+        );
+      }
+    }
+  };
+
+  await Promise.all([transferResults(intermediatePdfResultsPath, constants.pdfScanResultFileName)]);
+};
+
+export const createScreenshotsFolder = (randomToken: string): void => {
+  const storagePath = getStoragePath(randomToken);
+  const intermediateScreenshotsPath = getIntermediateScreenshotsPath(randomToken);
+  if (fs.existsSync(intermediateScreenshotsPath)) {
+    fs.readdir(intermediateScreenshotsPath, (err, files) => {
+      if (err) {
+        consoleLogger.error(`Screenshots were not moved successfully: ${err.message}`);
+      }
+
+      if (!fs.existsSync(destinationPath(storagePath))) {
+        try {
+          fs.mkdirSync(destinationPath(storagePath), { recursive: true });
+        } catch (error) {
+          consoleLogger.error('Screenshots folder was not created successfully:', error);
+        }
+      }
+
+      files.forEach(file => {
+        fs.renameSync(
+          `${intermediateScreenshotsPath}/${file}`,
+          `${destinationPath(storagePath)}/${file}`,
+        );
+      });
+
+      fs.rmdir(intermediateScreenshotsPath, rmdirErr => {
+        if (rmdirErr) {
+          consoleLogger.error(rmdirErr);
+        }
+      });
+    });
+  }
+};
diff --git a/src/utils/retryFunction.ts b/src/utils/retryFunction.ts
new file mode 100644
index 00000000..3e720a02
--- /dev/null
+++ b/src/utils/retryFunction.ts
@@ -0,0 +1,16 @@
+const retryFunction = async <T>(func: () => Promise<T>, maxAttempt: number): Promise<T> => {
+  let attemptCount = 0;
+  while (attemptCount < maxAttempt) {
+    attemptCount += 1;
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      const result = await func();
+      return result;
+    } catch (error) {
+      // do nothing, just retry
+    }
+  }
+  throw new Error('Maximum number of attempts reached');
+};
+
+export default retryFunction;
diff --git a/src/utils/runtimeFlags.ts b/src/utils/runtimeFlags.ts
new file mode 100644
index 00000000..bd8cf6e0
--- /dev/null
+++ b/src/utils/runtimeFlags.ts
@@ -0,0 +1,11 @@
+export const setHeadlessMode = (browser: string, isHeadless: boolean): void => {
+  if (isHeadless) {
+    process.env.CRAWLEE_HEADLESS = '1';
+  } else {
+    process.env.CRAWLEE_HEADLESS = '0';
+  }
+};
+
+export const setThresholdLimits = (setWarnLevel: string): void => {
+  process.env.WARN_LEVEL = setWarnLevel;
+};
diff --git a/src/utils/userData.ts b/src/utils/userData.ts
new file mode 100644
index 00000000..7b55184c
--- /dev/null
+++ b/src/utils/userData.ts
@@ -0,0 +1,54 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import { v4 as uuidv4 } from 'uuid';
+
+export const getUserDataFilePath = () => {
+  const platform = os.platform();
+  if (platform === 'win32') {
+    return path.join(process.env.APPDATA, 'Oobee', 'userData.txt');
+  }
+  if (platform === 'darwin') {
+    return path.join(process.env.HOME, 'Library', 'Application Support', 'Oobee', 'userData.txt');
+  }
+  // linux and other OS
+  return path.join(process.env.HOME, '.config', 'oobee', 'userData.txt');
+};
+
+export const getUserDataTxt = () => {
+  const textFilePath = getUserDataFilePath();
+
+  // 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;
+};
+
+export const writeToUserDataTxt = async (key: string, value: string): Promise<void> => {
+  const textFilePath = getUserDataFilePath();
+
+  // Create file if it doesn't exist
+  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 });
+    }
+    // Initialize with userId
+    fs.appendFileSync(textFilePath, JSON.stringify({ [key]: value, userId: uuidv4() }, null, 2));
+  }
+};
diff --git a/src/utils/wcagClassification.ts b/src/utils/wcagClassification.ts
new file mode 100644
index 00000000..cad5dfec
--- /dev/null
+++ b/src/utils/wcagClassification.ts
@@ -0,0 +1,354 @@
+import axe, { Rule } from 'axe-core';
+import { getAxeConfiguration } from '../crawlers/custom/getAxeConfiguration.js';
+
+/**
+ * Dynamically generates a map of WCAG criteria IDs to their details (name and level)
+ * Reuses the rule processing logic from getTotalRulesCount
+ */
+export const getWcagCriteriaMap = async (
+  enableWcagAaa: boolean = true,
+  disableOobee: boolean = false,
+): Promise<Record<string, { name: string; level: string }>> => {
+  // Reuse the configuration setup from getTotalRulesCount
+  const axeConfig = getAxeConfiguration({
+    enableWcagAaa,
+    gradingReadabilityFlag: '',
+    disableOobee,
+  });
+
+  // Get default rules from axe-core
+  const defaultRules = axe.getRules();
+
+  // Merge custom rules with default rules
+  const mergedRules: Rule[] = defaultRules.map(defaultRule => {
+    const customRule = axeConfig.rules.find(r => r.id === defaultRule.ruleId);
+    if (customRule) {
+      return {
+        id: defaultRule.ruleId,
+        enabled: customRule.enabled,
+        selector: customRule.selector,
+        any: customRule.any,
+        tags: defaultRule.tags,
+        metadata: customRule.metadata,
+      };
+    }
+    return {
+      id: defaultRule.ruleId,
+      enabled: true,
+      tags: defaultRule.tags,
+    };
+  });
+
+  // Add custom rules that don't override default rules
+  axeConfig.rules.forEach(customRule => {
+    if (!mergedRules.some(rule => rule.id === customRule.id)) {
+      mergedRules.push({
+        id: customRule.id,
+        enabled: customRule.enabled,
+        selector: customRule.selector,
+        any: customRule.any,
+        tags: customRule.tags,
+        metadata: customRule.metadata,
+      });
+    }
+  });
+
+  // Apply configuration
+  axe.configure({ ...axeConfig, rules: mergedRules });
+
+  // Build WCAG criteria map
+  const wcagCriteriaMap: Record<string, { name: string; level: string }> = {};
+
+  // Process rules to extract WCAG information
+  mergedRules.forEach(rule => {
+    if (!rule.enabled) return;
+    if (rule.id === 'frame-tested') return;
+
+    const tags = rule.tags || [];
+    if (tags.includes('experimental') || tags.includes('deprecated')) return;
+
+    // Look for WCAG criteria tags (format: wcag111, wcag143, etc.)
+    tags.forEach(tag => {
+      const wcagMatch = tag.match(/^wcag(\d+)$/);
+      if (wcagMatch) {
+        const wcagId = tag;
+
+        // Default values
+        let level = 'a';
+        let name = '';
+
+        // Try to extract better info from metadata if available
+        const metadata = rule.metadata as any;
+        if (metadata && metadata.wcag) {
+          const wcagInfo = metadata.wcag as any;
+
+          // Find matching criterion in metadata
+          for (const key in wcagInfo) {
+            const criterion = wcagInfo[key];
+            if (
+              criterion &&
+              criterion.num &&
+              `wcag${criterion.num.replace(/\./g, '')}` === wcagId
+            ) {
+              // Extract level
+              if (criterion.level) {
+                level = String(criterion.level).toLowerCase();
+              }
+
+              // Extract name
+              if (criterion.handle) {
+                name = String(criterion.handle);
+              } else if (criterion.id) {
+                name = String(criterion.id);
+              } else if (criterion.num) {
+                name = `wcag-${String(criterion.num).replace(/\./g, '-')}`;
+              }
+
+              break;
+            }
+          }
+        }
+
+        // Generate fallback name if none found
+        if (!name) {
+          const numStr = wcagMatch[1];
+          const formattedNum = numStr.replace(/(\d)(\d)(\d+)?/, '$1.$2.$3');
+          name = `wcag-${formattedNum.replace(/\./g, '-')}`;
+        }
+
+        // Store in map
+        wcagCriteriaMap[wcagId] = {
+          name: name.toLowerCase().replace(/_/g, '-'),
+          level,
+        };
+      }
+    });
+  });
+
+  return wcagCriteriaMap;
+};
+
+/**
+ * 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';
+  }
+  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;
+};
diff --git a/src/utils/wcagProgress.ts b/src/utils/wcagProgress.ts
new file mode 100644
index 00000000..2c4b21f0
--- /dev/null
+++ b/src/utils/wcagProgress.ts
@@ -0,0 +1,124 @@
+import constants from '../constants/constants.js';
+
+export type IssueCategory = 'mustFix' | 'goodToFix' | 'needsReview' | 'passed';
+
+export interface IssueDetail {
+  ruleId: string;
+  wcagConformance: string[];
+  occurrencesMustFix?: number;
+  occurrencesGoodToFix?: number;
+  occurrencesNeedsReview?: number;
+  occurrencesPassed: number;
+}
+
+export interface PageDetail {
+  pageTitle: string;
+  url: string;
+  totalOccurrencesFailedIncludingNeedsReview: number;
+  totalOccurrencesFailedExcludingNeedsReview: number;
+  totalOccurrencesMustFix?: number;
+  totalOccurrencesGoodToFix?: number;
+  totalOccurrencesNeedsReview: number;
+  totalOccurrencesPassed: number;
+  occurrencesExclusiveToNeedsReview: boolean;
+  typesOfIssuesCount: number;
+  typesOfIssuesExcludingNeedsReviewCount: number;
+  categoriesPresent: IssueCategory[];
+  conformance?: string[]; // WCAG levels as flexible strings
+  typesOfIssues: IssueDetail[];
+}
+
+export interface ScanPagesDetail {
+  oobeeAppVersion?: string;
+  pagesAffected: PageDetail[];
+  pagesNotAffected: PageDetail[];
+  scannedPagesCount: number;
+  pagesNotScanned: PageDetail[];
+  pagesNotScannedCount: number;
+}
+
+export const getWcagPassPercentage = (
+  wcagViolations: string[],
+  showEnableWcagAaa: boolean,
+): {
+  passPercentageAA: string;
+  totalWcagChecksAA: number;
+  totalWcagViolationsAA: number;
+  passPercentageAAandAAA: string;
+  totalWcagChecksAAandAAA: number;
+  totalWcagViolationsAAandAAA: number;
+} => {
+  // These AAA rules should not be counted as WCAG Pass Percentage only contains A and AA
+  const wcagAAALinks = [
+    'WCAG 1.4.6',
+    'WCAG 2.2.4',
+    'WCAG 2.4.9',
+    'WCAG 3.1.5',
+    'WCAG 3.2.5',
+    'WCAG 2.1.3',
+  ];
+  const wcagAAA = ['wcag146', 'wcag224', 'wcag249', 'wcag315', 'wcag325', 'wcag213'];
+
+  const wcagLinksAAandAAA = constants.wcagLinks;
+
+  const wcagViolationsAAandAAA = showEnableWcagAaa ? wcagViolations.length : null;
+  const totalChecksAAandAAA = showEnableWcagAaa ? Object.keys(wcagLinksAAandAAA).length : null;
+  const passedChecksAAandAAA = showEnableWcagAaa
+    ? totalChecksAAandAAA - wcagViolationsAAandAAA
+    : null;
+  // eslint-disable-next-line no-nested-ternary
+  const passPercentageAAandAAA = showEnableWcagAaa
+    ? totalChecksAAandAAA === 0
+      ? 0
+      : (passedChecksAAandAAA / totalChecksAAandAAA) * 100
+    : null;
+
+  const wcagViolationsAA = wcagViolations.filter(violation => !wcagAAA.includes(violation)).length;
+  const totalChecksAA = Object.keys(wcagLinksAAandAAA).filter(
+    key => !wcagAAALinks.includes(key),
+  ).length;
+  const passedChecksAA = totalChecksAA - wcagViolationsAA;
+  const passPercentageAA = totalChecksAA === 0 ? 0 : (passedChecksAA / totalChecksAA) * 100;
+
+  return {
+    passPercentageAA: passPercentageAA.toFixed(2), // toFixed returns a string, which is correct here
+    totalWcagChecksAA: totalChecksAA,
+    totalWcagViolationsAA: wcagViolationsAA,
+    passPercentageAAandAAA: passPercentageAAandAAA ? passPercentageAAandAAA.toFixed(2) : null, // toFixed returns a string, which is correct here
+    totalWcagChecksAAandAAA: totalChecksAAandAAA,
+    totalWcagViolationsAAandAAA: wcagViolationsAAandAAA,
+  };
+};
+
+export const getProgressPercentage = (
+  scanPagesDetail: ScanPagesDetail,
+  showEnableWcagAaa: boolean,
+): {
+  averageProgressPercentageAA: string;
+  averageProgressPercentageAAandAAA: string;
+} => {
+  const pages = scanPagesDetail.pagesAffected || [];
+
+  const progressPercentagesAA = pages.map((page: PageDetail) => {
+    const violations: string[] = page.conformance;
+    return getWcagPassPercentage(violations, showEnableWcagAaa).passPercentageAA;
+  });
+
+  const progressPercentagesAAandAAA = pages.map((page: PageDetail) => {
+    const violations: string[] = page.conformance;
+    return getWcagPassPercentage(violations, showEnableWcagAaa).passPercentageAAandAAA;
+  });
+
+  const totalAA = progressPercentagesAA.reduce((sum, p) => sum + parseFloat(p), 0);
+  const avgAA = progressPercentagesAA.length ? totalAA / progressPercentagesAA.length : 0;
+
+  const totalAAandAAA = progressPercentagesAAandAAA.reduce((sum, p) => sum + parseFloat(p), 0);
+  const avgAAandAAA = progressPercentagesAAandAAA.length
+    ? totalAAandAAA / progressPercentagesAAandAAA.length
+    : 0;
+
+  return {
+    averageProgressPercentageAA: avgAA.toFixed(2),
+    averageProgressPercentageAAandAAA: avgAAandAAA.toFixed(2),
+  };
+};
diff --git a/src/utils/zipResults.ts b/src/utils/zipResults.ts
new file mode 100644
index 00000000..6f3e50f6
--- /dev/null
+++ b/src/utils/zipResults.ts
@@ -0,0 +1,58 @@
+import path from 'path';
+import fs from 'fs-extra';
+import JSZip from 'jszip';
+import { createReadStream, createWriteStream } from 'fs';
+
+const zipResults = async (zipName: string, resultsPath: string): Promise<void> => {
+  // Resolve and validate the output path
+  const zipFilePath = path.isAbsolute(zipName) ? zipName : path.join(resultsPath, zipName);
+
+  // Ensure parent dir exists
+  fs.mkdirSync(path.dirname(zipFilePath), { recursive: true });
+
+  // Remove any prior file atomically
+  try {
+    fs.unlinkSync(zipFilePath);
+  } catch {
+    /* ignore if not exists */
+  }
+
+  // CWD must exist and be a directory
+  const stats = fs.statSync(resultsPath);
+  if (!stats.isDirectory()) {
+    throw new Error(`resultsPath is not a directory: ${resultsPath}`);
+  }
+  async function addFolderToZip(folderPath: string, zipFolder: JSZip): Promise<void> {
+    const items = await fs.readdir(folderPath);
+    for (const item of items) {
+      const fullPath = path.join(folderPath, item);
+      const stats = await fs.stat(fullPath);
+      if (stats.isDirectory()) {
+        const folder = zipFolder.folder(item);
+        await addFolderToZip(fullPath, folder);
+      } else {
+        // Add file as a stream so that it doesn't load the entire file into memory
+        zipFolder.file(item, createReadStream(fullPath));
+      }
+    }
+  }
+
+  const zip = new JSZip();
+  await addFolderToZip(resultsPath, zip);
+
+  const zipStream = zip.generateNodeStream({
+    type: 'nodebuffer',
+    streamFiles: true,
+    compression: 'DEFLATE',
+  });
+
+  await new Promise((resolve, reject) => {
+    const outStream = createWriteStream(zipFilePath);
+    zipStream
+      .pipe(outStream)
+      .on('finish', () => resolve(undefined))
+      .on('error', reject);
+  });
+};
+
+export default zipResults;