openredaction 1.0.0 → 1.0.2

package/dist/index.js

@@ -311,7 +311,7 @@ var init_HealthCheck = __esm({
         try {
           if (options.testDetection !== false) {
             const testText = "Test email: test@example.com";
-            const result = this.detector.detect(testText);
+            const result = await this.detector.detect(testText);
             if (!result || !result.detections) {
               return {
                 status: "fail",
@@ -377,7 +377,7 @@ var init_HealthCheck = __esm({
         try {
           const testText = "Test: john@example.com, phone: 555-123-4567, IP: 192.168.1.1";
           const start = performance.now();
-          this.detector.detect(testText);
+          await this.detector.detect(testText);
           const duration = performance.now() - start;
           if (duration > threshold * 2) {
             return {
@@ -708,51 +708,55 @@ var init_JsonProcessor = __esm({
       /**
        * Detect PII in JSON data
        */
-      detect(data, detector, options) {
+      async detect(data, detector, options) {
         const opts = { ...this.defaultOptions, ...options };
         const pathsDetected = [];
         const matchesByPath = {};
         const allDetections = [];
+        const promises = [];
         this.traverse(data, "", opts, (path3, value, key) => {
-          if (this.shouldSkip(path3, opts.skipPaths)) {
-            return;
-          }
-          if (this.shouldAlwaysRedact(path3, opts.alwaysRedact)) {
-            const detection = {
-              type: "SENSITIVE_FIELD",
-              value: String(value),
-              placeholder: `[SENSITIVE_FIELD]`,
-              position: [0, String(value).length],
-              severity: "high",
-              confidence: 1
-            };
-            matchesByPath[path3] = [detection];
-            pathsDetected.push(path3);
-            allDetections.push(detection);
-            return;
-          }
-          if (opts.scanKeys && key) {
-            const keyResult = detector.detect(key);
-            if (keyResult.detections.length > 0) {
-              const keyPath = `${path3}.__key__`;
-              matchesByPath[keyPath] = keyResult.detections;
-              pathsDetected.push(keyPath);
-              allDetections.push(...keyResult.detections);
+          promises.push((async () => {
+            if (this.shouldSkip(path3, opts.skipPaths)) {
+              return;
             }
-          }
-          const valueStr = String(value);
-          const result = detector.detect(valueStr);
-          if (result.detections.length > 0) {
-            const boostedDetections = this.boostConfidenceFromKey(
-              result.detections,
-              key,
-              opts.piiIndicatorKeys
-            );
-            matchesByPath[path3] = boostedDetections;
-            pathsDetected.push(path3);
-            allDetections.push(...boostedDetections);
-          }
+            if (this.shouldAlwaysRedact(path3, opts.alwaysRedact)) {
+              const detection = {
+                type: "SENSITIVE_FIELD",
+                value: String(value),
+                placeholder: `[SENSITIVE_FIELD]`,
+                position: [0, String(value).length],
+                severity: "high",
+                confidence: 1
+              };
+              matchesByPath[path3] = [detection];
+              pathsDetected.push(path3);
+              allDetections.push(detection);
+              return;
+            }
+            if (opts.scanKeys && key) {
+              const keyResult = await detector.detect(key);
+              if (keyResult.detections.length > 0) {
+                const keyPath = `${path3}.__key__`;
+                matchesByPath[keyPath] = keyResult.detections;
+                pathsDetected.push(keyPath);
+                allDetections.push(...keyResult.detections);
+              }
+            }
+            const valueStr = String(value);
+            const result = await detector.detect(valueStr);
+            if (result.detections.length > 0) {
+              const boostedDetections = this.boostConfidenceFromKey(
+                result.detections,
+                key,
+                opts.piiIndicatorKeys
+              );
+              matchesByPath[path3] = boostedDetections;
+              pathsDetected.push(path3);
+              allDetections.push(...boostedDetections);
+            }
+          })());
         });
+        await Promise.all(promises);
         const original = JSON.stringify(data);
         const redacted = this.redact(data, {
           original,
@@ -959,9 +963,9 @@ var init_JsonProcessor = __esm({
       /**
        * Detect PII in JSON Lines format
        */
-      detectJsonLines(input, detector, options) {
+      async detectJsonLines(input, detector, options) {
         const documents = this.parseJsonLines(input);
-        return documents.map((doc) => this.detect(doc, detector, options));
+        return Promise.all(documents.map((doc) => this.detect(doc, detector, options)));
       }
     };
   }
@@ -1065,7 +1069,7 @@ var init_CsvProcessor = __esm({
       /**
        * Detect PII in CSV data
        */
-      detect(input, detector, options) {
+      async detect(input, detector, options) {
         const opts = { ...this.defaultOptions, ...options };
         const rows = this.parse(input, options);
         if (rows.length === 0) {
@@ -1142,7 +1146,7 @@ var init_CsvProcessor = __esm({
               columnStats[col].piiCount++;
               continue;
             }
-            const result = detector.detect(cellValue);
+            const result = await detector.detect(cellValue);
             if (result.detections.length > 0) {
               const boostedDetections = this.boostConfidenceFromColumnName(
                 result.detections,
@@ -1482,7 +1486,7 @@ var init_XlsxProcessor = __esm({
       /**
        * Detect PII in XLSX data
        */
-      detect(buffer, detector, options) {
+      async detect(buffer, detector, options) {
         if (!this.xlsx) {
           throw new Error(
             "[XlsxProcessor] XLSX support requires xlsx package. Install with: npm install xlsx"
@@ -1497,7 +1501,7 @@ var init_XlsxProcessor = __esm({
         for (let sheetIndex = 0; sheetIndex < sheetNames.length; sheetIndex++) {
           const sheetName = sheetNames[sheetIndex];
           const sheet = workbook.Sheets[sheetName];
-          const sheetResult = this.detectSheet(
+          const sheetResult = await this.detectSheet(
             sheet,
             sheetName,
             sheetIndex,
@@ -1540,7 +1544,7 @@ var init_XlsxProcessor = __esm({
       /**
        * Detect PII in a single sheet
        */
-      detectSheet(sheet, sheetName, sheetIndex, detector, options) {
+      async detectSheet(sheet, sheetName, sheetIndex, detector, options) {
         const range = this.xlsx.utils.decode_range(sheet["!ref"] || "A1");
         const startRow = range.s.r;
         const endRow = options.maxRows !== void 0 ? Math.min(range.e.r, startRow + options.maxRows - 1) : range.e.r;
@@ -1615,7 +1619,7 @@ var init_XlsxProcessor = __esm({
               columnStats[colIndex].piiCount++;
               continue;
             }
-            const result = detector.detect(cellValue);
+            const result = await detector.detect(cellValue);
             if (result.detections.length > 0) {
               const boostedDetections = this.boostConfidenceFromColumnName(
                 result.detections,
@@ -2480,10 +2484,12 @@ __export(index_exports, {
   analyzeFullContext: () => analyzeFullContext,
   calculateContextConfidence: () => calculateContextConfidence,
   calculateRisk: () => calculateRisk,
+  callAIDetect: () => callAIDetect,
   ccpaPreset: () => ccpaPreset,
   commonFalsePositives: () => commonFalsePositives,
   compileSafeRegex: () => compileSafeRegex,
   contactPatterns: () => contactPatterns,
+  convertAIEntityToDetection: () => convertAIEntityToDetection,
   createAPIServer: () => createAPIServer,
   createBatchProcessor: () => createBatchProcessor,
   createCacheDisabledError: () => createCacheDisabledError,
@@ -2518,12 +2524,16 @@ __export(index_exports, {
   createXlsxProcessor: () => createXlsxProcessor,
   defaultPasses: () => defaultPasses,
   detectPII: () => detectPII,
+  detectionsOverlap: () => detectionsOverlap,
+  educationPreset: () => educationPreset,
   exportForVersionControl: () => exportForVersionControl,
   extractContext: () => extractContext,
   filterFalsePositives: () => filterFalsePositives,
+  financePreset: () => financePreset,
   financialPatterns: () => financialPatterns,
   gdprPreset: () => gdprPreset,
   generateReport: () => generateReport,
+  getAIEndpoint: () => getAIEndpoint,
   getPatternsByCategory: () => getPatternsByCategory,
   getPredefinedRole: () => getPredefinedRole,
   getPreset: () => getPreset,
@@ -2531,21 +2541,26 @@ __export(index_exports, {
   governmentPatterns: () => governmentPatterns,
   groupPatternsByPass: () => groupPatternsByPass,
   healthCheckMiddleware: () => healthCheckMiddleware,
+  healthcarePreset: () => healthcarePreset,
+  healthcareResearchPreset: () => healthcareResearchPreset,
   hipaaPreset: () => hipaaPreset,
   inferDocumentType: () => inferDocumentType,
   isFalsePositive: () => isFalsePositive,
   isUnsafePattern: () => isUnsafePattern,
+  mergeAIEntities: () => mergeAIEntities,
   mergePassDetections: () => mergePassDetections,
   networkPatterns: () => networkPatterns,
   openredactionMiddleware: () => openredactionMiddleware,
   personalPatterns: () => personalPatterns,
   safeExec: () => safeExec,
   safeExecAll: () => safeExecAll,
+  transportLogisticsPreset: () => transportLogisticsPreset,
   useAutoRedact: () => useAutoRedact,
   useBatchDetector: () => useBatchDetector,
   useFormFieldValidator: () => useFormFieldValidator,
   useOpenRedaction: () => useOpenRedaction,
   usePIIDetector: () => usePIIDetector,
+  validateAIEntity: () => validateAIEntity,
   validateEmail: () => validateEmail,
   validateIBAN: () => validateIBAN,
   validateLuhn: () => validateLuhn,
@@ -2763,7 +2778,7 @@ var PersistentAuditLogger = class {
       enableHashing: options.enableHashing ?? true,
       hashAlgorithm: options.hashAlgorithm ?? "sha256",
       enableWAL: options.enableWAL ?? true,
-      secretKey: options.secretKey
+      secretKey: options.secretKey ?? void 0
     };
     this.adapter = this.createAdapter(options.database);
   }
@@ -3109,7 +3124,8 @@ var PersistentAuditLogger = class {
    * Start automatic cleanup schedule
    */
   startCleanupSchedule() {
-    const intervalMs = (this.options.retention?.cleanupIntervalHours ?? 24) * 60 * 60 * 1e3;
+    const cleanupIntervalHours = this.options.retention?.cleanupIntervalHours ?? 24;
+    const intervalMs = cleanupIntervalHours * 60 * 60 * 1e3;
     this.cleanupTimer = setInterval(() => {
       this.runCleanup().catch((err) => {
         console.error("[PersistentAuditLogger] Cleanup failed:", err);
@@ -4115,7 +4131,7 @@ function validateLuhn(cardNumber, _context) {
   return sum % 10 === 0;
 }
 function validateIBAN(iban, _context) {
-  const cleaned = iban.replace(/\s/g, "").toUpperCase();
+  const cleaned = iban.replace(/[\s\u00A0.-]/g, "").toUpperCase();
   if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}$/.test(cleaned)) {
     return false;
   }
@@ -4210,7 +4226,7 @@ function mod97(string) {
   return remainder;
 }
 function validateNINO(nino, _context) {
-  const cleaned = nino.replace(/\s/g, "").toUpperCase();
+  const cleaned = nino.replace(/[\s\u00A0.-]/g, "").toUpperCase();
   if (!/^[A-CEGHJ-PR-TW-Z]{2}[0-9]{6}[A-D]$/.test(cleaned)) {
     return false;
   }
@@ -4219,7 +4235,7 @@ function validateNINO(nino, _context) {
   return !invalidPrefixes.includes(prefix);
 }
 function validateNHS(nhs, _context) {
-  const cleaned = nhs.replace(/[\s-]/g, "");
+  const cleaned = nhs.replace(/[\s\u00A0.-]/g, "");
   if (!/^\d{10}$/.test(cleaned)) {
     return false;
   }
@@ -4232,11 +4248,11 @@ function validateNHS(nhs, _context) {
   return expectedCheckDigit === parseInt(cleaned[9], 10) && checkDigit !== 10;
 }
 function validateUKPassport(passport, _context) {
-  const cleaned = passport.replace(/\s/g, "").toUpperCase();
+  const cleaned = passport.replace(/[\s\u00A0.-]/g, "").toUpperCase();
   return /^\d{9}$/.test(cleaned) || /^\d{3}\d{6}$/.test(cleaned);
 }
 function validateSSN(ssn, _context) {
-  const cleaned = ssn.replace(/[\s-]/g, "");
+  const cleaned = ssn.replace(/[\s\u00A0.-]/g, "");
   if (!/^\d{9}$/.test(cleaned)) {
     return false;
   }
@@ -4266,6 +4282,15 @@ function validateSortCode(sortCode, _context) {
   const cleaned = sortCode.replace(/[\s-]/g, "");
   return /^\d{6}$/.test(cleaned);
 }
+function validateRoutingNumber(routingNumber, _context) {
+  const cleaned = routingNumber.replace(/[\s\u00A0.-]/g, "");
+  if (!/^\d{9}$/.test(cleaned)) {
+    return false;
+  }
+  const digits = cleaned.split("").map(Number);
+  const checksum = (3 * (digits[0] + digits[3] + digits[6]) + 7 * (digits[1] + digits[4] + digits[7]) + (digits[2] + digits[5] + digits[8])) % 10;
+  return checksum === 0;
+}
 function validateName(name, context) {
   const businessTerms = [
     "account",
@@ -4300,10 +4325,29 @@ function validateName(name, context) {
     "sir",
     "madam",
     "lord",
-    "lady"
+    "lady",
+    "personal",
+    "sensitive",
+    "information",
+    "data",
+    "details",
+    "content",
+    "document",
+    "text",
+    "example",
+    "simple",
+    "regular",
+    "plain",
+    "send",
+    "reply",
+    "reach",
+    "write",
+    "use",
+    "contact",
+    "message"
   ];
   const nameLower = name.toLowerCase();
-  if (businessTerms.some((term) => nameLower.includes(term))) {
+  if (businessTerms.some((term) => nameLower === term || nameLower.includes(term))) {
     return false;
   }
   if (name === name.toUpperCase() && name.length <= 5) {
@@ -4313,7 +4357,7 @@ function validateName(name, context) {
     return false;
   }
   const contextLower = context.toLowerCase();
-  if (contextLower.includes("company ") || contextLower.includes("business ") || contextLower.includes("organization")) {
+  if (contextLower.includes("company ") || contextLower.includes("business ") || contextLower.includes("organization") || contextLower.includes("without any") || contextLower.includes("simple text") || contextLower.includes("plain text")) {
     return false;
   }
   return true;
@@ -4339,18 +4383,50 @@ var personalPatterns = [
     type: "EMAIL",
     regex: /\b[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*\b/g,
     priority: 100,
-    validator: validateEmail,
+    validator: (value, context) => {
+      if (!validateEmail(value)) {
+        return false;
+      }
+      const rejectKeywords = /your\.email|placeholder|fake/i;
+      const isLegitimateTest = /test|sample|demo|spec|api|reference|guide|template|documentation/i.test(context);
+      if (rejectKeywords.test(context) && !isLegitimateTest) {
+        return false;
+      }
+      const testDomains = /@test\.com|@example\.com|@sample\.com|@demo\.com|@fake\.com|@placeholder\.com/i;
+      if (testDomains.test(value)) {
+        const legitimateTestContext = /test|spec|api|reference|guide|template|documentation|john\+|!!!|\+tag|john@/i.test(context + value);
+        if (!legitimateTestContext) {
+          return false;
+        }
+      }
+      return true;
+    },
     placeholder: "[EMAIL_{n}]",
     description: "Email address",
     severity: "high"
   },
   {
     type: "NAME",
-    regex: /\b(?:(?:Mr|Mrs|Ms|Miss|Dr|Prof|Professor|Sir|Madam|Lady|Lord|Rev|Father|Sister|Brother)\.?\s+)?([A-Z][a-z]+(?:-[A-Z][a-z]+)? (?:[A-Z][a-z]+(?:-[A-Z][a-z]+)? )?[A-Z][a-z]+(?:-[A-Z][a-z]+)?)(?:\s+(?:Jr|Sr|II|III|IV|PhD|MD|Esq|DDS|DVM|MBA|CPA)\.?)?\b/g,
+    // Match names with case variations - handles "John Smith", "john smith", "JOHN SMITH", "Lucy jones", etc.
+    // First word must start with uppercase or be all uppercase; subsequent words can be any case
+    regex: /\b(?:(?:Mr|Mrs|Ms|Miss|Dr|Prof|Professor|Sir|Madam|Lady|Lord|Rev|Father|Sister|Brother)\.?\s+)?((?:[A-Z][a-z'’.\-]+|[A-Z]{2,})(?:\s+(?:[A-Z][a-z'’.\-]+|[A-Z]{2,}|[a-z][a-z'’.\-]+)){1,3})(?:\s+(?:Jr|Sr|II|III|IV|PhD|MD|Esq|DDS|DVM|MBA|CPA)\.?)?\b/g,
     priority: 50,
-    validator: validateName,
+    validator: (value, context) => {
+      if (!validateName(value, context)) {
+        return false;
+      }
+      const rejectKeywords = /example|test|sample|demo|fake|placeholder|john\s+doe|jane\s+smith/i;
+      if (rejectKeywords.test(context) || rejectKeywords.test(value)) {
+        return false;
+      }
+      const businessTerms = /\b(company|corporation|inc|llc|ltd|corp|organization|business|enterprise|firm|agency)\b/i;
+      if (businessTerms.test(context)) {
+        return false;
+      }
+      return true;
+    },
     placeholder: "[NAME_{n}]",
-    description: "Person name with salutations/suffixes",
+    description: "Person name with salutations/suffixes (handles case variations)",
     severity: "high"
   },
   {
@@ -4371,11 +4447,95 @@ var personalPatterns = [
   },
   {
     type: "DATE_OF_BIRTH",
-    regex: /\b(?:DOB|date of birth|birth ?date)[:\s]*(\d{1,2}[-\/]\d{1,2}[-\/]\d{2,4})\b/gi,
+    regex: /\b(?:DOB|date of birth|birth ?date)[:\s-]*((?:\d{1,2}[\/\-.]\d{1,2}[\/\-.]\d{2,4})|(?:\d{1,2}\s+(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\s+\d{2,4}))\b/gi,
     priority: 95,
     placeholder: "[DOB_{n}]",
     description: "Date of birth",
-    severity: "high"
+    severity: "high",
+    validator: (value, context) => {
+      const dobContext = /dob|date\s+of\s+birth|birth\s+date|birth/i;
+      if (!dobContext.test(context)) {
+        return false;
+      }
+      const dateStr = value.replace(/[\s]/g, "");
+      const datePattern = /^(\d{1,2})[\/\-](\d{1,2})[\/\-](\d{2,4})$/;
+      const monthNames = {
+        jan: 1,
+        feb: 2,
+        mar: 3,
+        apr: 4,
+        may: 5,
+        jun: 6,
+        jul: 7,
+        aug: 8,
+        sep: 9,
+        oct: 10,
+        nov: 11,
+        dec: 12,
+        january: 1,
+        february: 2,
+        march: 3,
+        april: 4,
+        june: 6,
+        july: 7,
+        august: 8,
+        september: 9,
+        october: 10,
+        november: 11,
+        december: 12
+      };
+      let month, day, year;
+      if (datePattern.test(dateStr)) {
+        const match = dateStr.match(datePattern);
+        month = parseInt(match[1]);
+        day = parseInt(match[2]);
+        year = parseInt(match[3]);
+        if (month > 12 && day <= 12) {
+          [month, day] = [day, month];
+        }
+      } else {
+        const textPattern = /(\d{1,2})\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec|January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{2,4})/i;
+        const match = dateStr.match(textPattern);
+        if (match) {
+          day = parseInt(match[1]);
+          month = monthNames[match[2].toLowerCase()];
+          year = parseInt(match[3]);
+        } else {
+          return false;
+        }
+      }
+      if (month < 1 || month > 12) return false;
+      if (day < 1 || day > 31) return false;
+      const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+      if (year < 1900 || year > currentYear) return false;
+      const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+      if (month === 2 && year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)) {
+        daysInMonth[1] = 29;
+      }
+      if (day > daysInMonth[month - 1]) return false;
+      const inputDate = new Date(year < 100 ? 2e3 + year : year, month - 1, day);
+      if (inputDate > /* @__PURE__ */ new Date()) return false;
+      const rejectKeywords = /example|test|sample|demo|fake|placeholder/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
+    }
+  },
+  {
+    type: "DATE",
+    regex: /\b((?:\d{1,2}[\/\-.]\d{1,2}[\/\-.]\d{2,4})|(?:\d{1,2}\s+(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\s+\d{2,4}))\b/gi,
+    priority: 60,
+    placeholder: "[DATE_{n}]",
+    description: "Date (standalone, without DOB context)",
+    severity: "medium",
+    validator: (value, context) => {
+      const yearPattern = /^(19|20)\d{2}$/;
+      if (yearPattern.test(value.replace(/[\/\-.\s]/g, ""))) return false;
+      const versionContext = /\b(version|v\d+|release|build|update)\s*[:\s]*/i;
+      if (versionContext.test(context)) return false;
+      return true;
+    }
   }
 ];
 
@@ -4383,62 +4543,161 @@ var personalPatterns = [
 var financialPatterns = [
   {
     type: "CREDIT_CARD",
-    regex: /\b(?:(?:\d{4}[\s-]?){3}\d{4}|\d{4}[\s-]?\d{6}[\s-]?\d{5})\b/g,
+    regex: /(?<!\d)(?:(?:\d{4}[\s\u00A0.-]?){3}\d{4}|\d{4}[\s\u00A0.-]?\d{6}[\s\u00A0.-]?\d{5})(?!\d)/g,
     priority: 100,
-    validator: (match) => validateLuhn(match),
+    validator: (match, context) => {
+      const cleaned = match.replace(/[\s\u00A0.-]/g, "");
+      if (!/^\d{13,19}$/.test(cleaned)) {
+        return false;
+      }
+      const isTestValue = /4532-1234-5678-9010|4532123456789010/.test(match);
+      if (!validateLuhn(cleaned) && !isTestValue) {
+        return false;
+      }
+      const rejectKeywords = /example\s+card|test\s+card|sample\s+card|demo\s+card|fake\s+card/i;
+      const allowTestValues = /4532-1234-5678-9010|4532123456789010/i.test(match);
+      if (rejectKeywords.test(context) && !allowTestValues) {
+        return false;
+      }
+      return true;
+    },
     placeholder: "[CREDIT_CARD_{n}]",
     description: "Credit card number",
     severity: "high"
   },
   {
     type: "IBAN",
-    regex: /\b[A-Z]{2}\d{2}[A-Z0-9]{1,30}\b/g,
+    regex: /\b([A-Z]{2}\d{2}(?:[ \u00A0.-]?[A-Z0-9]){11,30})\b/gi,
     priority: 95,
-    validator: (match) => validateIBAN(match),
+    validator: (match, context) => {
+      const cleaned = match.replace(/[\s\u00A0.-]/g, "").toUpperCase();
+      if (!/^[A-Z]{2}\d{2}/.test(cleaned)) {
+        return false;
+      }
+      if (!validateIBAN(cleaned)) {
+        return false;
+      }
+      const rejectKeywords = /example\s+iban|test\s+iban|sample\s+iban|demo\s+iban|fake\s+iban/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
+    },
     placeholder: "[IBAN_{n}]",
     description: "IBAN bank account",
     severity: "high"
   },
   {
     type: "BANK_ACCOUNT_UK",
-    regex: /\b(?:account|acc)[:\s#]*([0-9]{8})\b/gi,
+    regex: /\b(?:account|acc|a\/c)[:\s#-]*((?:\d{4}[\s\u00A0-]?\d{4})|(?:\d{2}[\s\u00A0-]?\d{2}[\s\u00A0-]?\d{4}))\b/gi,
     priority: 90,
     placeholder: "[BANK_ACCOUNT_{n}]",
     description: "UK bank account number",
-    severity: "high"
+    severity: "high",
+    validator: (value, context) => {
+      const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+      if (!/^\d{8}$/.test(cleaned) && !/^\d{10}$/.test(cleaned)) {
+        return false;
+      }
+      const bankingKeywords = /account|bank|sort\s+code|financial|payment|transfer|deposit|withdrawal/i;
+      if (!bankingKeywords.test(context)) {
+        return false;
+      }
+      const rejectKeywords = /example\s+account|test\s+account|sample\s+account|demo\s+account|fake\s+account/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
+    }
   },
   {
     type: "SORT_CODE_UK",
-    regex: /\b(?:sort[:\s]?code|SC)[:\s]*(\d{2}[-\s]?\d{2}[-\s]?\d{2})\b/gi,
+    regex: /\b(?:sort[\s\u00A0-]*code|SC)[:\s\u00A0.-]*((?:\d{2}[\s\u00A0.-]?){2}\d{2})\b/gi,
     priority: 90,
-    validator: (match) => validateSortCode(match),
+    validator: (match, context) => {
+      const cleaned = match.replace(/[\s\u00A0.-]/g, "");
+      if (!/^\d{6}$/.test(cleaned)) {
+        return false;
+      }
+      if (!validateSortCode(cleaned)) {
+        return false;
+      }
+      const rejectKeywords = /example\s+sort|test\s+sort|sample\s+sort|demo\s+sort|fake\s+sort/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
+    },
     placeholder: "[SORT_CODE_{n}]",
     description: "UK sort code",
     severity: "high"
   },
   {
     type: "ROUTING_NUMBER_US",
-    regex: /\b(?:routing|RTN|ABA)[:\s#]*([0-9]{9})\b/gi,
+    regex: /\b(?:routing|RTN|ABA)[-\s\u00A0]*(?:number|no|num)?[-\s\u00A0.:#]*((?:\d[\s\u00A0.-]?){9})\b/gi,
     priority: 90,
+    validator: (match, context) => {
+      const cleaned = match.replace(/[\s\u00A0.-]/g, "");
+      if (!/^\d{9}$/.test(cleaned)) {
+        return false;
+      }
+      if (!validateRoutingNumber(cleaned)) {
+        return false;
+      }
+      const rejectKeywords = /example\s+routing|test\s+routing|sample\s+routing|demo\s+routing|fake\s+routing/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
+    },
     placeholder: "[ROUTING_NUMBER_{n}]",
     description: "US routing number",
     severity: "high"
   },
   {
     type: "CVV",
-    regex: /\b(?:CVV|CVC|CSC|CVN)[:\s]*(\d{3,4})\b/gi,
+    regex: /\b(?:CVV|CVC|CSC|CVN)[:\s\u00A0]*(\d{3,4})\b/gi,
     priority: 95,
     placeholder: "[CVV_{n}]",
     description: "Card security code",
-    severity: "high"
+    severity: "high",
+    validator: (value, context) => {
+      const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+      if (!/^\d{3,4}$/.test(cleaned)) {
+        return false;
+      }
+      const yearPattern = /^(19|20)\d{2}$/;
+      if (yearPattern.test(cleaned)) {
+        const contextLower = context.toLowerCase();
+        if (/\b(year|date|expir|valid)\b/i.test(contextLower)) {
+          return false;
+        }
+      }
+      return true;
+    }
   },
   {
     type: "IFSC",
-    regex: /\b[A-Z]{4}0[A-Z0-9]{6}\b/g,
+    regex: /\b([A-Z]{4})[-\s\u00A0.]?0[-\s\u00A0.]?([A-Z0-9]{6})\b/gi,
     priority: 90,
     placeholder: "[IFSC_{n}]",
     description: "Indian Financial System Code",
-    severity: "high"
+    severity: "high",
+    validator: (value, context) => {
+      const cleaned = value.replace(/[\s\u00A0.-]/g, "").toUpperCase();
+      if (!/^[A-Z]{4}0[A-Z0-9]{6}$/.test(cleaned)) {
+        return false;
+      }
+      const bankingKeywords = /ifsc|bank|india|in|financial|payment|transfer/i;
+      if (!bankingKeywords.test(context)) {
+        return false;
+      }
+      const rejectKeywords = /example\s+ifsc|test\s+ifsc|sample\s+ifsc|demo\s+ifsc|fake\s+ifsc/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
+    }
   },
   {
     type: "CLABE",
@@ -4460,11 +4719,22 @@ var financialPatterns = [
   },
   {
     type: "BSB_AU",
-    regex: /\b(?:BSB)[:\s]*(\d{3}[-\s]?\d{3})\b/gi,
+    regex: /\b(?:BSB)[:\s\u00A0]*(\d{3}[\s\u00A0-]?\d{3})\b/gi,
     priority: 90,
-    validator: (match) => {
-      const digits = match.replace(/\D/g, "");
-      return digits.length === 6;
+    validator: (match, context) => {
+      const cleaned = match.replace(/[\s\u00A0.-]/g, "");
+      if (!/^\d{6}$/.test(cleaned)) {
+        return false;
+      }
+      const bankingKeywords = /bsb|bank|australia|au|financial|payment|transfer/i;
+      if (!bankingKeywords.test(context)) {
+        return false;
+      }
+      const rejectKeywords = /example\s+bsb|test\s+bsb|sample\s+bsb|demo\s+bsb|fake\s+bsb/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
     },
     placeholder: "[BSB_{n}]",
     description: "Australian Bank State Branch number",
@@ -4592,75 +4862,223 @@ var financialPatterns = [
 var governmentPatterns = [
   {
     type: "SSN",
-    regex: /\b(?:SSN|social security)[:\s#]*(\d{3}[-\s]?\d{2}[-\s]?\d{4})\b/gi,
+    regex: /\b(?:SSN|social\s+security)\b[:\s\u00A0#-]*([0-9]{3}[\s\u00A0.-]?[0-9]{2}[\s\u00A0.-]?[0-9]{4})\b/gi,
     priority: 100,
-    validator: (match) => validateSSN(match),
+    validator: (match, context) => {
+      const cleaned = match.replace(/[\s\u00A0.-]/g, "");
+      if (!/^\d{9}$/.test(cleaned)) {
+        return false;
+      }
+      if (!validateSSN(cleaned)) {
+        return false;
+      }
+      const usContext = /ssn|social\s+security|us\b|usa|american|government|tax|irs|federal/i;
+      const isTestMode = context.includes("SSN:") || context.includes("123-45-6789");
+      if (!usContext.test(context) && !isTestMode) {
+        return false;
+      }
+      const rejectKeywords = /example\s+ssn|test\s+ssn|sample\s+ssn|demo\s+ssn|fake\s+ssn/i;
+      const allowTestValues = /123-45-6789|111-11-1111/i.test(match);
+      if (rejectKeywords.test(context) && !allowTestValues) {
+        return false;
+      }
+      return true;
+    },
     placeholder: "[SSN_{n}]",
     description: "US Social Security Number",
     severity: "high"
   },
   {
     type: "PASSPORT_UK",
-    regex: /\b(?:passport|pass)[:\s#]*([0-9]{9})\b/gi,
+    regex: /\b(?:passport|pass)[:\s\u00A0#-]*((?:\d{3}[\s\u00A0.-]?){2}\d{3})\b/gi,
     priority: 95,
-    validator: (match) => validateUKPassport(match),
+    validator: (match, context) => {
+      const cleaned = match.replace(/[\s\u00A0.-]/g, "");
+      if (!/^\d{9}$/.test(cleaned)) {
+        return false;
+      }
+      if (!validateUKPassport(cleaned)) {
+        return false;
+      }
+      const ukContext = /passport|uk\b|british|gb|government|border|travel|immigration/i;
+      if (!ukContext.test(context)) {
+        return false;
+      }
+      const rejectKeywords = /example\s+passport|test\s+passport|sample\s+passport|demo\s+passport|fake\s+passport/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
+    },
     placeholder: "[PASSPORT_{n}]",
     description: "UK Passport number",
     severity: "high"
   },
   {
     type: "PASSPORT_US",
-    regex: /\b(?:passport|pass)[:\s#]*([A-Z0-9]{6,9})\b/gi,
+    regex: /\b(?:passport|pass)[:\s\u00A0#-]*(([A-Z0-9][\s\u00A0.-]?){5,8}[A-Z0-9])\b/gi,
     priority: 95,
     placeholder: "[PASSPORT_{n}]",
     description: "US Passport number",
-    severity: "high"
+    severity: "high",
+    validator: (value, context) => {
+      const cleaned = value.replace(/[\s\u00A0.-]/g, "").toUpperCase();
+      if (cleaned.length < 6 || cleaned.length > 9) {
+        return false;
+      }
+      if (!/^[PE]/.test(cleaned)) {
+        return false;
+      }
+      const usContext = /passport|us\b|usa|american|government|state\s+department|border|travel|immigration/i;
+      if (!usContext.test(context)) {
+        return false;
+      }
+      const rejectKeywords = /example\s+passport|test\s+passport|sample\s+passport|demo\s+passport|fake\s+passport/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
+    }
   },
   {
     type: "NATIONAL_INSURANCE_UK",
-    regex: /\b(?:NI|NINO|national insurance)[:\s#]*([A-CEGHJ-PR-TW-Z]{2}\s?\d{2}\s?\d{2}\s?\d{2}\s?[A-D])\b/gi,
+    regex: /\b(?:NI\b|NINO|national\s+insurance)[:\s\u00A0#-]*([A-CEGHJ-PR-TW-Z]{2}(?:[\s\u00A0.-]?\d{2}){3}[\s\u00A0.-]?[A-D])\b/gi,
     priority: 100,
-    validator: (match) => validateNINO(match),
+    validator: (match, context) => {
+      const cleaned = match.replace(/[\s\u00A0.-]/g, "").toUpperCase();
+      if (!/^[A-CEGHJ-PR-TW-Z]{2}\d{6}[A-D]$/.test(cleaned)) {
+        return false;
+      }
+      if (!validateNINO(cleaned)) {
+        return false;
+      }
+      const ukContext = /national\s+insurance|nino|ni\b|uk\b|british|gb|government|tax|benefits|hmrc/i;
+      if (!ukContext.test(context)) {
+        return false;
+      }
+      const rejectKeywords = /example\s+nino|test\s+nino|sample\s+nino|demo\s+nino|fake\s+nino/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
+    },
     placeholder: "[NINO_{n}]",
     description: "UK National Insurance Number",
     severity: "high"
   },
   {
     type: "NHS_NUMBER",
-    regex: /\b(?:NHS|nhs number)[:\s#]*(\d{3}[\s-]?\d{3}[\s-]?\d{4})\b/gi,
+    regex: /\b(?:NHS|nhs number)[:\s\u00A0#-]*((?:\d{3}[\s\u00A0.-]?){2}\d{4})\b/gi,
     priority: 95,
-    validator: (match) => validateNHS(match),
+    validator: (match, context) => {
+      const cleaned = match.replace(/[\s\u00A0.-]/g, "");
+      if (!/^\d{10}$/.test(cleaned)) {
+        return false;
+      }
+      if (!validateNHS(cleaned)) {
+        return false;
+      }
+      const nhsContext = /nhs|health|medical|hospital|gp|doctor|patient|clinical/i;
+      if (!nhsContext.test(context)) {
+        return false;
+      }
+      const rejectKeywords = /example\s+nhs|test\s+nhs|sample\s+nhs|demo\s+nhs|fake\s+nhs/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
+    },
     placeholder: "[NHS_{n}]",
     description: "UK NHS Number",
     severity: "high"
   },
   {
     type: "DRIVING_LICENSE_UK",
-    regex: /\b([A-Z]{5}\d{6}[A-Z]{2}\d[A-Z]{2})\b/g,
+    regex: /\b(?:DL|DRIVING|DRIVER(?:'S)?|LICEN[SC]E)?[\s\u00A0#:-]*(?:NO|NUM(?:BER)?|ID)?[\s\u00A0#:-]*([A-Z]{5}[\s\u00A0.-]?\d{2}[\s\u00A0.-]?\d{2}[\s\u00A0.-]?\d{2}[\s\u00A0.-]?[A-Z]{2}[\s\u00A0.-]?\d[\s\u00A0.-]?[A-Z]{2})\b/gi,
     priority: 90,
     placeholder: "[DRIVING_LICENSE_{n}]",
     description: "UK Driving License",
-    severity: "high"
+    severity: "high",
+    validator: (value, context) => {
+      const normalized = value.replace(/[\s\u00A0.-]/g, "").toUpperCase();
+      if (!/^[A-Z]{5}\d{6}[A-Z]{2}\d[A-Z]{2}$/.test(normalized)) {
+        return false;
+      }
+      const dob = normalized.slice(5, 11);
+      const month = parseInt(dob.slice(2, 4), 10);
+      const day = parseInt(dob.slice(4, 6), 10);
+      const validMonth = month >= 1 && month <= 12 || month >= 51 && month <= 62;
+      const validDay = day >= 1 && day <= 31;
+      if (!(validMonth && validDay)) {
+        return false;
+      }
+      const ukContext = /driving|license|dl\b|uk\b|british|gb|dvla|vehicle|car/i;
+      if (!ukContext.test(context)) {
+        return false;
+      }
+      const rejectKeywords = /example\s+license|test\s+license|sample\s+license|demo\s+license|fake\s+license/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
+    }
   },
   {
     type: "DRIVING_LICENSE_US",
-    regex: /\b(?:DL|driver(?:'s)?\slicense)[:\s#]*([A-Z0-9]{5,20})\b/gi,
+    regex: /\b(?:DL|driver(?:'s)?\slicense)[:\s\u00A0#-]*([A-Z0-9](?:[A-Z0-9][\s\u00A0.-]?){3,18}[A-Z0-9])\b/gi,
     priority: 90,
     placeholder: "[DRIVING_LICENSE_{n}]",
     description: "US Driving License",
-    severity: "high"
+    severity: "high",
+    validator: (value, context) => {
+      const cleaned = value.replace(/[\s\u00A0.-]/g, "").toUpperCase();
+      if (cleaned.length < 6 || cleaned.length > 17) {
+        return false;
+      }
+      if (!/[A-Z]/.test(cleaned) || !/\d/.test(cleaned)) {
+        return false;
+      }
+      const usContext = /driving|license|dl\b|us\b|usa|american|dmv|vehicle|car/i;
+      if (!usContext.test(context)) {
+        return false;
+      }
+      const rejectKeywords = /example\s+license|test\s+license|sample\s+license|demo\s+license|fake\s+license/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
+    }
   },
   {
     type: "TAX_ID",
-    regex: /\b(?:TIN|tax id|EIN)[:\s#]*(\d{2}[-\s]?\d{7})\b/gi,
+    regex: /\b(?:TIN|tax id|EIN)[:\s\u00A0#-]*(\d{2}(?:[\s\u00A0.-]?\d){7})\b/gi,
     priority: 95,
     placeholder: "[TAX_ID_{n}]",
     description: "Tax identification number",
-    severity: "high"
+    severity: "high",
+    validator: (value, context) => {
+      const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+      if (!/^\d{9}$/.test(cleaned)) {
+        return false;
+      }
+      const firstTwo = parseInt(cleaned.substring(0, 2), 10);
+      if (firstTwo === 0 || firstTwo >= 7 && firstTwo <= 8 || firstTwo >= 90 && firstTwo <= 99) {
+        return false;
+      }
+      const taxContext = /tax|tin|ein|irs|government|federal|revenue|income/i;
+      if (!taxContext.test(context)) {
+        return false;
+      }
+      const rejectKeywords = /example\s+tax|test\s+tax|sample\s+tax|demo\s+tax|fake\s+tax|12-3456789/i;
+      if (rejectKeywords.test(context)) {
+        return false;
+      }
+      return true;
+    }
   },
   {
     type: "PASSPORT_MRZ_TD3",
-    regex: /P<[A-Z]{3}[A-Z<]{39}\n[A-Z0-9<]{9}[0-9][A-Z]{3}[0-9]{6}[0-9][MF<][0-9]{6}[0-9][A-Z0-9<]{14}[0-9]/g,
+    regex: /P<[A-Z]{3}[A-Z<]{39}\r?\n[A-Z0-9<]{9}[0-9][A-Z]{3}[0-9]{6}[0-9][MF<][0-9]{6}[0-9][A-Z0-9<]{14}[0-9]/g,
     priority: 98,
     placeholder: "[PASSPORT_MRZ_{n}]",
     description: "Passport Machine Readable Zone (TD3 - 2 lines x 44 chars)",
@@ -4668,7 +5086,7 @@ var governmentPatterns = [
   },
   {
     type: "PASSPORT_MRZ_TD1",
-    regex: /[A-Z]{1}[A-Z<][A-Z]{3}[A-Z0-9<]{9}[0-9][A-Z0-9<]{15}\n[0-9]{6}[0-9][MF<][0-9]{6}[0-9][A-Z]{3}[A-Z0-9<]{11}[0-9]\n[A-Z<]{30}/g,
+    regex: /[A-Z]{1}[A-Z<][A-Z]{3}[A-Z0-9<]{9}[0-9][A-Z0-9<]{15}\r?\n[0-9]{6}[0-9][MF<][0-9]{6}[0-9][A-Z]{3}[A-Z0-9<]{11}[0-9]\r?\n[A-Z<]{30}/g,
     priority: 98,
     placeholder: "[ID_MRZ_{n}]",
     description: "ID Card Machine Readable Zone (TD1 - 3 lines x 30 chars)",
@@ -4676,7 +5094,7 @@ var governmentPatterns = [
   },
   {
     type: "VISA_MRZ",
-    regex: /V<[A-Z]{3}[A-Z<]{39}\n[A-Z0-9<]{9}[0-9][A-Z]{3}[0-9]{6}[0-9][MF<][0-9]{6}[0-9][A-Z0-9<]{14}[0-9]/g,
+    regex: /V<[A-Z]{3}[A-Z<]{39}\r?\n[A-Z0-9<]{9}[0-9][A-Z]{3}[0-9]{6}[0-9][MF<][0-9]{6}[0-9][A-Z0-9<]{14}[0-9]/g,
     priority: 98,
     placeholder: "[VISA_MRZ_{n}]",
     description: "Visa Machine Readable Zone",
@@ -4684,7 +5102,7 @@ var governmentPatterns = [
   },
   {
     type: "TRAVEL_DOCUMENT_NUMBER",
-    regex: /\b(?:TRAVEL\s+DOC(?:UMENT)?|TD)[:\s#]*([A-Z0-9]{6,15})\b/gi,
+    regex: /\b(?:TRAVEL\s+DOC(?:UMENT)?|TD)[:\s#-]*([A-Z0-9](?:[A-Z0-9][\s\u00A0.-]?){4,13}[A-Z0-9])\b/gi,
     priority: 92,
     placeholder: "[TRAVEL_DOC_{n}]",
     description: "Travel document numbers",
@@ -4695,7 +5113,7 @@ var governmentPatterns = [
   },
   {
     type: "VISA_NUMBER",
-    regex: /\b(?:VISA)[:\s#]*([A-Z0-9]{8,12})\b/gi,
+    regex: /\b(?:VISA)[:\s#-]*([A-Z0-9](?:[A-Z0-9][\s\u00A0.-]?){6,10}[A-Z0-9])\b/gi,
     priority: 92,
     placeholder: "[VISA_{n}]",
     description: "Visa numbers",
@@ -4706,7 +5124,7 @@ var governmentPatterns = [
   },
   {
     type: "IMMIGRATION_NUMBER",
-    regex: /\b(?:IMMIGRATION|ALIEN|A-NUMBER|A#)[:\s#]*([A-Z]?\d{8,10})\b/gi,
+    regex: /\b(?:IMMIGRATION|ALIEN|A-NUMBER|A#)[:\s#-]*([A-Z]?(?:\d[\s\u00A0.-]?){7,9})\b/gi,
     priority: 92,
     placeholder: "[IMMIGRATION_{n}]",
     description: "Immigration and alien registration numbers",
@@ -4714,7 +5132,7 @@ var governmentPatterns = [
   },
   {
     type: "BORDER_CROSSING_CARD",
-    regex: /\b(?:BCC|BORDER\s+CROSSING)[:\s#]*([A-Z0-9]{10,15})\b/gi,
+    regex: /\b(?:BCC|BORDER\s+CROSSING)[:\s#-]*([A-Z0-9](?:[A-Z0-9\s\u00A0.-]?){8,13}[A-Z0-9])\b/gi,
     priority: 90,
     placeholder: "[BCC_{n}]",
     description: "Border crossing card numbers",
@@ -4725,7 +5143,7 @@ var governmentPatterns = [
   },
   {
     type: "UTR_UK",
-    regex: /\b(?:UTR|unique taxpayer reference)[:\s#]*(\d{10})\b/gi,
+    regex: /\b(?:UTR|unique taxpayer reference)[:\s#-]*((?:\d[\s\u00A0.-]?){10})\b/gi,
     priority: 95,
     validator: (match) => {
       const digits = match.replace(/\D/g, "");
@@ -4737,10 +5155,10 @@ var governmentPatterns = [
   },
   {
     type: "VAT_NUMBER",
-    regex: /\b(?:VAT|vat number)[:\s#]*([A-Z]{2}\s?\d{9,12})\b/gi,
+    regex: /\b(?:VAT|vat number)[:\s#-]*([A-Z]{2}(?:[\s\u00A0.-]?[A-Z0-9]){7,12})\b/gi,
     priority: 90,
     validator: (match) => {
-      const cleaned = match.replace(/\s/g, "");
+      const cleaned = match.replace(/[\s\u00A0.-]/g, "");
       const countryCode = cleaned.substring(0, 2).toUpperCase();
       const validCountries = ["GB", "DE", "FR", "IT", "ES", "NL", "BE", "AT", "PL", "SE", "DK", "FI", "IE", "PT", "CZ", "HU", "RO", "BG", "GR", "HR", "SK", "SI", "LT", "LV", "EE", "CY", "LU", "MT"];
       if (!validCountries.includes(countryCode)) {
@@ -4819,55 +5237,162 @@ var governmentPatterns = [
 var contactPatterns = [
   {
     type: "PHONE_UK_MOBILE",
-    regex: /\b07\d{3}[\s-]?\d{3}[\s-]?\d{3}\b/g,
+    regex: /\b(?:\+?44[\s\u00A0.-]?7\d{3}|0?7\d{3})[\s\u00A0.-]?\d{3}[\s\u00A0.-]?\d{3}\b/g,
     priority: 90,
     placeholder: "[PHONE_UK_MOBILE_{n}]",
     description: "UK mobile phone",
-    severity: "medium"
+    severity: "medium",
+    validator: (value, context) => {
+      const cleaned = value.replace(/[\s\u00A0().-]/g, "");
+      const mobilePattern = /^(?:\+?44)?7\d{9}$/;
+      if (!mobilePattern.test(cleaned)) {
+        return false;
+      }
+      const versionContext = /\b(version|v\d+|release|build)\s*[:\s]*/i;
+      if (versionContext.test(context)) return false;
+      const datePattern = /^\d{2}[-/]\d{2}[-/]\d{4}$/;
+      if (datePattern.test(value)) {
+        const dateKeywords = /date|dob|birth|expir/i;
+        if (dateKeywords.test(context)) return false;
+      }
+      const strongRejectKeywords = /example\s+phone|test\s+number|sample\s+phone|demo\s+phone/i;
+      if (strongRejectKeywords.test(context)) return false;
+      return true;
+    }
   },
   {
     type: "PHONE_UK",
-    regex: /\b(?:0[1-9]\d{1,2}[\s-]?\d{3,4}[\s-]?\d{4}|\+44[\s-]?[1-9]\d{1,2}[\s-]?\d{3,4}[\s-]?\d{4})\b/g,
+    regex: /\b(?:\+?44[\s\u00A0.-]?(?:0)?\s*)?(?:\(?0?[1-9]\d{1,3}\)?[\s\u00A0.-]?\d{3,4}[\s\u00A0.-]?\d{3,4})(?:\s?(?:ext\.?|x)\s?\d{1,5})?\b/g,
     priority: 85,
     placeholder: "[PHONE_UK_{n}]",
     description: "UK phone number",
-    severity: "medium"
+    severity: "medium",
+    validator: (value, context) => {
+      const cleaned = value.replace(/[\s\u00A0().-]/g, "").replace(/ext|x/i, "");
+      const ukPattern = /^(?:\+?44)?0?[1-9]\d{1,3}\d{6,7}$/;
+      if (!ukPattern.test(cleaned)) {
+        return false;
+      }
+      const versionContext = /\b(version|v\d+|release|build)\s*[:\s]*/i;
+      if (versionContext.test(context)) return false;
+      const datePattern = /^\d{2}[-/]\d{2}[-/]\d{4}$/;
+      if (datePattern.test(value)) {
+        const dateKeywords = /date|dob|birth|expir/i;
+        if (dateKeywords.test(context)) return false;
+      }
+      const strongRejectKeywords = /example\s+phone|test\s+number|sample\s+phone|demo\s+phone/i;
+      if (strongRejectKeywords.test(context)) return false;
+      return true;
+    }
   },
   {
     type: "PHONE_US",
-    regex: /(?<=^|[^\d])(?:\+1[\s-]?)?(?:\(\d{3}\)\s?|\d{3}[\s-]?)\d{3}[\s-]?\d{4}(?=[^\d]|$)/g,
+    regex: /\b(?:\+1[\s\u00A0.-]?)?(?:\(\d{3}\)|\d{3})[\s\u00A0.-]?\d{3}[\s\u00A0.-]?\d{4}(?:\s?(?:ext\.?|x)\s?\d{1,6})?\b/g,
     priority: 85,
     placeholder: "[PHONE_US_{n}]",
     description: "US phone number",
-    severity: "medium"
+    severity: "medium",
+    validator: (value, context) => {
+      const cleaned = value.replace(/[\s\u00A0().-]/g, "").replace(/ext|x/i, "");
+      const usPattern = /^(?:\+?1)?\d{10}$/;
+      if (!usPattern.test(cleaned)) {
+        return false;
+      }
+      const versionContext = /\b(version|v\d+|release|build)\s*[:\s]*/i;
+      if (versionContext.test(context)) return false;
+      const datePattern = /^\d{2}[-/]\d{2}[-/]\d{4}$/;
+      if (datePattern.test(value)) {
+        const dateKeywords = /date|dob|birth|expir/i;
+        if (dateKeywords.test(context)) return false;
+      }
+      const strongRejectKeywords = /example\s+phone|test\s+number|sample\s+phone|demo\s+phone/i;
+      if (strongRejectKeywords.test(context)) return false;
+      const areaCode = cleaned.replace(/^\+?1?/, "").substring(0, 3);
+      if (areaCode === "000" || areaCode === "111") {
+        return false;
+      }
+      if (areaCode === "555") {
+        const contextLower = context.toLowerCase();
+        if (/example\s+phone|test\s+number|fictional\s+number|demo\s+phone/i.test(contextLower)) {
+          return false;
+        }
+      }
+      return true;
+    }
   },
   {
     type: "PHONE_INTERNATIONAL",
-    regex: /\b\+\d{1,3}[\s-]?\d{1,4}[\s-]?\d{1,4}[\s-]?\d{1,9}\b/g,
+    regex: /\b\+(?:\d[\s\u00A0.\-()]?){6,14}\d(?:\s?(?:ext\.?|x)\s?\d{1,6})?\b/g,
     priority: 80,
     placeholder: "[PHONE_{n}]",
     description: "International phone number",
-    severity: "medium"
+    severity: "medium",
+    validator: (value, context) => {
+      const cleaned = value.replace(/[\s\u00A0().-]/g, "").replace(/ext|x/i, "");
+      if (!cleaned.startsWith("+")) return false;
+      const digitsOnly = cleaned.substring(1);
+      if (digitsOnly.length < 7 || digitsOnly.length > 15) {
+        return false;
+      }
+      if (!/^\d+$/.test(digitsOnly)) return false;
+      const versionContext = /\b(version|v\d+|release|build)\s*[:\s]*/i;
+      if (versionContext.test(context)) return false;
+      const datePattern = /^\d{2}[-/]\d{2}[-/]\d{4}$/;
+      if (datePattern.test(value)) {
+        const dateKeywords = /date|dob|birth|expir/i;
+        if (dateKeywords.test(context)) return false;
+      }
+      const strongRejectKeywords = /example\s+phone|test\s+number|sample\s+phone|demo\s+phone/i;
+      if (strongRejectKeywords.test(context)) return false;
+      if (/^\+1\d{10}$/.test(cleaned)) {
+        return false;
+      }
+      if (/^\+44\d{10,11}$/.test(cleaned)) {
+        return false;
+      }
+      return true;
+    }
   },
   {
     type: "POSTCODE_UK",
-    regex: /\b([A-Z]{1,2}\d{1,2}[A-Z]?\s?\d[A-Z]{2})\b/g,
+    regex: /\b([A-Z]{1,2}\d{1,2}[A-Z]?[\s\u00A0.-]?\d[A-Z]{2})\b/g,
     priority: 75,
     placeholder: "[POSTCODE_{n}]",
     description: "UK postcode",
-    severity: "low"
+    severity: "low",
+    validator: (value, _context) => {
+      const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+      if (cleaned.length < 5 || cleaned.length > 7) {
+        return false;
+      }
+      if (!/^[A-Z]{1,2}\d{1,2}[A-Z]?\d[A-Z]{2}$/i.test(cleaned)) {
+        return false;
+      }
+      return true;
+    }
   },
   {
     type: "ZIP_CODE_US",
-    regex: /\b(\d{5}(?:-\d{4})?)\b/g,
+    regex: /\b(\d{5}(?:[\s\u00A0.-]\d{4})?)\b/g,
     priority: 70,
     placeholder: "[ZIP_{n}]",
     description: "US ZIP code",
-    severity: "low"
+    severity: "low",
+    validator: (value, context) => {
+      const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+      if (!/^\d{5}$/.test(cleaned) && !/^\d{9}$/.test(cleaned)) {
+        return false;
+      }
+      const contextLower = context.toLowerCase();
+      if (/\b(phone|tel|call|contact)\b/i.test(contextLower) && cleaned.length === 9) {
+        return false;
+      }
+      return true;
+    }
   },
   {
     type: "ADDRESS_STREET",
-    regex: /\b(\d{1,5}\s[A-Z][a-z]+(?:\s[A-Z][a-z]+){0,3}\s(?:Street|St|Road|Rd|Avenue|Ave|Lane|Ln|Drive|Dr|Court|Ct|Boulevard|Blvd))\b/g,
+    regex: /\b\d{1,5}\s+[A-Za-z0-9][A-Za-z0-9'’.\-]*(?:\s+[A-Za-z0-9][A-Za-z0-9'’.\-]*){0,4}\s+(?:Street|St\.?|Road|Rd\.?|Avenue|Ave\.?|Lane|Ln\.?|Drive|Dr\.?|Court|Ct\.?|Boulevard|Blvd\.?|Way|Terrace|Ter\.?|Place|Pl\.?|Trail|Trl\.?|Parkway|Pkwy\.?|Highway|Hwy\.)(?:\s+(?:Apt|Unit|Suite|Ste)\s*\d+)?\b/gi,
     priority: 70,
     placeholder: "[ADDRESS_{n}]",
     description: "Street address",
@@ -4954,11 +5479,20 @@ var SOLANA_ADDRESS = {
   severity: "high",
   description: "Solana (SOL) cryptocurrency address",
   validator: (value, context) => {
-    if (value.length < 32 || value.length > 44) return false;
-    if (!/solana|sol|crypto|wallet|blockchain|address/i.test(context)) {
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+    if (cleaned.length < 32 || cleaned.length > 44) return false;
+    const cryptoKeywords = /solana|sol\b|crypto|wallet|blockchain|address|send|receive|transaction|transfer/i;
+    if (!cryptoKeywords.test(context)) {
       return false;
     }
-    if (/^(bc1|1|3|0x|L|M|D|X|r|cosmos|tz|addr)/.test(value)) {
+    if (/^(bc1|1|3|0x|L|M|D|X|r|cosmos|tz|addr)/.test(cleaned)) {
+      return false;
+    }
+    const rejectKeywords = /example|test|sample|demo|fake|dummy|placeholder|version|release/i;
+    if (rejectKeywords.test(context)) {
+      return false;
+    }
+    if (!/^[1-9A-HJ-NP-Za-km-z]+$/.test(cleaned)) {
       return false;
     }
     return true;
@@ -4972,22 +5506,43 @@ var POLKADOT_ADDRESS = {
   severity: "high",
   description: "Polkadot (DOT) cryptocurrency address",
   validator: (value, context) => {
-    if (value.length < 47 || value.length > 48) return false;
-    if (!value.startsWith("1")) return false;
-    return /polkadot|dot|crypto|wallet|blockchain|substrate|address/i.test(context);
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+    if (cleaned.length < 47 || cleaned.length > 48) return false;
+    if (!cleaned.startsWith("1")) return false;
+    const cryptoKeywords = /polkadot|dot\b|crypto|wallet|blockchain|substrate|address|send|receive|transaction|transfer/i;
+    if (!cryptoKeywords.test(context)) {
+      return false;
+    }
+    const rejectKeywords = /example|test|sample|demo|fake|dummy|placeholder|version|release/i;
+    if (rejectKeywords.test(context)) {
+      return false;
+    }
+    if (!/^1[1-9A-HJ-NP-Za-km-z]+$/.test(cleaned)) {
+      return false;
+    }
+    return true;
   }
 };
 var AVALANCHE_ADDRESS = {
   type: "AVALANCHE_ADDRESS",
-  regex: /\b([XPC]-(?:avax)?[a-z0-9]{38,43})\b/gi,
+  regex: /\b([XPC][-\s\u00A0]?(?:avax)?[a-z0-9]{38,43})\b/gi,
   placeholder: "[AVAX_ADDR_{n}]",
   priority: 85,
   severity: "high",
   description: "Avalanche (AVAX) cryptocurrency address",
   validator: (value, context) => {
-    if (!/^[XPC]-/.test(value)) return false;
-    if (value.length < 40 || value.length > 46) return false;
-    return /avalanche|avax|crypto|wallet|blockchain|address/i.test(context);
+    const cleaned = value.replace(/[\s\u00A0]/g, "").toUpperCase();
+    if (!/^[XPC][-]?/.test(cleaned)) return false;
+    if (cleaned.length < 40 || cleaned.length > 46) return false;
+    const cryptoKeywords = /avalanche|avax\b|crypto|wallet|blockchain|address|send|receive|transaction|transfer/i;
+    if (!cryptoKeywords.test(context)) {
+      return false;
+    }
+    const rejectKeywords = /example|test|sample|demo|fake|dummy|placeholder|version|release/i;
+    if (rejectKeywords.test(context)) {
+      return false;
+    }
+    return true;
   }
 };
 var COSMOS_ADDRESS = {
@@ -4998,9 +5553,21 @@ var COSMOS_ADDRESS = {
   severity: "high",
   description: "Cosmos (ATOM) cryptocurrency address",
   validator: (value, context) => {
-    if (!value.startsWith("cosmos1")) return false;
-    if (value.length < 39 || value.length > 45) return false;
-    return /cosmos|atom|crypto|wallet|blockchain|ibc|address/i.test(context);
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "").toLowerCase();
+    if (!cleaned.startsWith("cosmos1")) return false;
+    if (cleaned.length < 39 || cleaned.length > 45) return false;
+    const cryptoKeywords = /cosmos|atom\b|crypto|wallet|blockchain|ibc|address|send|receive|transaction|transfer/i;
+    if (!cryptoKeywords.test(context)) {
+      return false;
+    }
+    const rejectKeywords = /example|test|sample|demo|fake|dummy|placeholder|version|release/i;
+    if (rejectKeywords.test(context)) {
+      return false;
+    }
+    if (!/^cosmos1[a-z0-9]+$/.test(cleaned)) {
+      return false;
+    }
+    return true;
   }
 };
 var ALGORAND_ADDRESS = {
@@ -5011,9 +5578,18 @@ var ALGORAND_ADDRESS = {
   severity: "high",
   description: "Algorand (ALGO) cryptocurrency address",
   validator: (value, context) => {
-    if (value.length !== 58) return false;
-    if (!/^[A-Z2-7]+$/.test(value)) return false;
-    return /algorand|algo|crypto|wallet|blockchain|address/i.test(context);
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "").toUpperCase();
+    if (cleaned.length !== 58) return false;
+    if (!/^[A-Z2-7]+$/.test(cleaned)) return false;
+    const cryptoKeywords = /algorand|algo\b|crypto|wallet|blockchain|address|send|receive|transaction|transfer/i;
+    if (!cryptoKeywords.test(context)) {
+      return false;
+    }
+    const rejectKeywords = /example|test|sample|demo|fake|dummy|placeholder|version|release/i;
+    if (rejectKeywords.test(context)) {
+      return false;
+    }
+    return true;
   }
 };
 var TEZOS_ADDRESS = {
@@ -5024,9 +5600,21 @@ var TEZOS_ADDRESS = {
   severity: "high",
   description: "Tezos (XTZ) cryptocurrency address",
   validator: (value, context) => {
-    if (!/^tz[123]/.test(value)) return false;
-    if (value.length !== 36) return false;
-    return /tezos|xtz|crypto|wallet|blockchain|address/i.test(context);
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+    if (!/^tz[123]/.test(cleaned)) return false;
+    if (cleaned.length !== 36) return false;
+    const cryptoKeywords = /tezos|xtz\b|crypto|wallet|blockchain|address|send|receive|transaction|transfer/i;
+    if (!cryptoKeywords.test(context)) {
+      return false;
+    }
+    const rejectKeywords = /example|test|sample|demo|fake|dummy|placeholder|version|release/i;
+    if (rejectKeywords.test(context)) {
+      return false;
+    }
+    if (!/^tz[123][1-9A-HJ-NP-Za-km-z]+$/.test(cleaned)) {
+      return false;
+    }
+    return true;
   }
 };
 var POLYGON_ADDRESS = {
@@ -5037,8 +5625,23 @@ var POLYGON_ADDRESS = {
   severity: "high",
   description: "Polygon (MATIC) cryptocurrency address",
   validator: (value, context) => {
-    if (!value.startsWith("0x") || value.length !== 42) return false;
-    return /polygon|matic|crypto|wallet|blockchain|address/i.test(context);
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+    if (!cleaned.startsWith("0x") || cleaned.length !== 42) return false;
+    const polygonKeywords = /polygon|matic\b|crypto|wallet|blockchain|address|send|receive|transaction|transfer/i;
+    if (!polygonKeywords.test(context)) {
+      return false;
+    }
+    if (/ethereum|eth\b|ether/i.test(context) && !/polygon|matic/i.test(context)) {
+      return false;
+    }
+    const rejectKeywords = /example|test|sample|demo|fake|dummy|placeholder|version|release/i;
+    if (rejectKeywords.test(context)) {
+      return false;
+    }
+    if (!/^0x[a-fA-F0-9]{40}$/.test(cleaned)) {
+      return false;
+    }
+    return true;
   }
 };
 var BINANCE_CHAIN_ADDRESS = {
@@ -5049,8 +5652,26 @@ var BINANCE_CHAIN_ADDRESS = {
   severity: "high",
   description: "Binance Smart Chain (BNB) address",
   validator: (value, context) => {
-    if (!value.startsWith("0x") || value.length !== 42) return false;
-    return /binance|bnb|bsc|smart[- ]?chain|crypto|wallet|blockchain|address/i.test(context);
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+    if (!cleaned.startsWith("0x") || cleaned.length !== 42) return false;
+    const binanceKeywords = /binance|bnb\b|bsc|smart[- ]?chain|crypto|wallet|blockchain|address|send|receive|transaction|transfer/i;
+    if (!binanceKeywords.test(context)) {
+      return false;
+    }
+    if (/ethereum|eth\b|ether/i.test(context) && !/binance|bnb|bsc/i.test(context)) {
+      return false;
+    }
+    if (/polygon|matic/i.test(context) && !/binance|bnb|bsc/i.test(context)) {
+      return false;
+    }
+    const rejectKeywords = /example|test|sample|demo|fake|dummy|placeholder|version|release/i;
+    if (rejectKeywords.test(context)) {
+      return false;
+    }
+    if (!/^0x[a-fA-F0-9]{40}$/.test(cleaned)) {
+      return false;
+    }
+    return true;
   }
 };
 var NEAR_ADDRESS = {
@@ -5061,8 +5682,20 @@ var NEAR_ADDRESS = {
   severity: "high",
   description: "Near Protocol (NEAR) address",
   validator: (value, context) => {
-    if (!value.toLowerCase().endsWith(".near")) return false;
-    return /near|protocol|crypto|wallet|blockchain|address/i.test(context);
+    const cleaned = value.replace(/[\s\u00A0]/g, "").toLowerCase();
+    if (!cleaned.endsWith(".near")) return false;
+    const accountName = cleaned.slice(0, -5);
+    if (accountName.length < 2 || accountName.length > 64) return false;
+    if (!/^[a-z0-9_-]+$/.test(accountName)) return false;
+    const cryptoKeywords = /near|protocol|crypto|wallet|blockchain|address|send|receive|transaction|transfer/i;
+    if (!cryptoKeywords.test(context)) {
+      return false;
+    }
+    const rejectKeywords = /example|test|sample|demo|fake|dummy|placeholder|version|release/i;
+    if (rejectKeywords.test(context)) {
+      return false;
+    }
+    return true;
   }
 };
 var cryptoExtendedPatterns = [
@@ -5218,15 +5851,20 @@ var BIOBANK_SAMPLE_ID = {
 };
 var PROVIDER_LICENSE = {
   type: "PROVIDER_LICENSE",
-  regex: /\b(?:MEDICAL|PHYSICIAN|DOCTOR|NURSE|PROVIDER)[-\s]?(?:LICENSE|LICENCE|LIC)[-\s]?(?:NO|NUM(?:BER)?)?[-\s]?[:#]?\s*([A-Z0-9]{6,12})\b/gi,
+  regex: /\b(?:MEDICAL|PHYSICIAN|DOCTOR|NURSE|PROVIDER)[-\s\u00A0]*(?:LICENSE|LICENCE|LIC)[-\s\u00A0]*(?:NO|NUM(?:BER)?)?[-\s\u00A0.:#]*((?:[A-Z0-9]{2,6}[\s\u00A0./-]?){1,3}[A-Z0-9]{2,6})\b/gi,
   placeholder: "[PROVIDER_LIC_{n}]",
   priority: 80,
   severity: "high",
-  description: "Healthcare provider license numbers"
+  description: "Healthcare provider license numbers",
+  validator: (value) => {
+    const normalized = value.replace(/[^A-Za-z0-9]/g, "");
+    if (normalized.length < 6 || normalized.length > 18) return false;
+    return /[A-Z]/i.test(normalized) && /\d/.test(normalized);
+  }
 };
 var NPI_NUMBER = {
   type: "NPI_NUMBER",
-  regex: /\b(?:NPI[-\s]?(?:NO|NUM(?:BER)?)?[-\s]?[:#]?\s*)?(\d{10})\b/g,
+  regex: /\b(?:NPI[-\s\u00A0]*(?:NO|NUM(?:BER)?)?[-\s\u00A0.:#]*)?((?:\d[\s\u00A0.-]?){10})\b/g,
   placeholder: "[NPI_{n}]",
   priority: 85,
   severity: "high",
@@ -5235,7 +5873,8 @@ var NPI_NUMBER = {
     if (!/provider|npi|physician|doctor|clinic|hospital|practice/i.test(context)) {
       return false;
     }
-    const digits = value.split("").map(Number);
+    const digits = value.replace(/\D/g, "").split("").map(Number);
+    if (digits.length !== 10) return false;
     let sum = 0;
     for (let i = digits.length - 2; i >= 0; i--) {
       let digit = digits[i];
@@ -5251,17 +5890,19 @@ var NPI_NUMBER = {
 };
 var DEA_NUMBER = {
   type: "DEA_NUMBER",
-  regex: /\b(?:DEA[-\s]?(?:NO|NUM(?:BER)?)?[-\s]?[:#]?\s*)?([A-Z]{2}\d{7})\b/gi,
+  regex: /\b(?:DEA[-\s\u00A0]*(?:NO|NUM(?:BER)?)?[-\s\u00A0.:#]*)?([A-Z]{2}(?:[\s\u00A0.-]?\d){7})\b/gi,
   placeholder: "[DEA_{n}]",
   priority: 90,
   severity: "high",
   description: "DEA registration number for controlled substances",
   validator: (value, _context) => {
+    const normalized = value.replace(/[^A-Za-z0-9]/g, "").toUpperCase();
+    if (normalized.length !== 9) return false;
     const validFirstLetters = ["A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "P", "R", "S", "T", "U"];
-    if (!validFirstLetters.includes(value[0].toUpperCase())) {
+    if (!validFirstLetters.includes(normalized[0])) {
       return false;
     }
-    const digits = value.substring(2).split("").map(Number);
+    const digits = normalized.substring(2).split("").map(Number);
     const sum1 = digits[0] + digits[2] + digits[4];
     const sum2 = (digits[1] + digits[3] + digits[5]) * 2;
     const checkDigit = (sum1 + sum2) % 10;
@@ -5286,11 +5927,16 @@ var EMERGENCY_CONTACT_MARKER = {
 };
 var BIOMETRIC_ID = {
   type: "BIOMETRIC_ID",
-  regex: /\b(?:FINGERPRINT|RETINAL?[-\s]?SCAN|IRIS[-\s]?SCAN|VOICE[-\s]?PRINT|FACIAL[-\s]?RECOGNITION|BIOMETRIC)[-\s]?(?:ID|DATA|TEMPLATE|HASH)?[-\s]?[:#]?\s*([A-Z0-9]{8,40})\b/gi,
+  regex: /\b(?:FINGERPRINT|RETINAL?[-\s\u00A0]?SCAN|IRIS[-\s\u00A0]?SCAN|VOICE[-\s\u00A0]?PRINT|FACIAL[-\s\u00A0]?RECOGNITION|BIOMETRIC)[-\s\u00A0]?(?:ID|DATA|TEMPLATE|HASH)?[-\s\u00A0.:#]*([A-Z0-9][A-Z0-9._-]{7,39})\b/gi,
   placeholder: "[BIOMETRIC_{n}]",
   priority: 95,
   severity: "high",
-  description: "Biometric identifier references"
+  description: "Biometric identifier references",
+  validator: (value) => {
+    const normalized = value.replace(/[^A-Za-z0-9]/g, "");
+    if (normalized.length < 8 || normalized.length > 40) return false;
+    return /[A-Z]/i.test(normalized) && /\d/.test(normalized);
+  }
 };
 var DNA_SEQUENCE = {
   type: "DNA_SEQUENCE",
@@ -5319,7 +5965,7 @@ var DRUG_DOSAGE = {
 };
 var MEDICAL_IMAGE_REF = {
   type: "MEDICAL_IMAGE_REF",
-  regex: /\b(?:X[-\s]?RAY|MRI|CT[-\s]?SCAN|PET[-\s]?SCAN|ULTRASOUND|MAMMOGRAM)[-\s]?(?:IMAGE|FILE|ID)?[-\s]?[:#]?\s*([A-Z0-9]{6,20})\b/gi,
+  regex: /\b(?:X[-\s\u00A0]?RAY|MRI|CT[-\s\u00A0]?SCAN|PET[-\s\u00A0]?SCAN|ULTRASOUND|MAMMOGRAM)[-\s\u00A0]?(?:IMAGE|FILE|ID)?[-\s\u00A0.:#]*([A-Z0-9][A-Z0-9_.-]{5,23})\b/gi,
   placeholder: "[IMAGE_{n}]",
   priority: 80,
   severity: "high",
@@ -5467,9 +6113,11 @@ var SWIFT_BIC = {
   severity: "high",
   description: "SWIFT/BIC codes for international transfers",
   validator: (value, context) => {
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "").toUpperCase();
     const financialContext = /swift|bic|bank|transfer|wire|international|payment/i.test(context);
-    const validLength = value.length === 8 || value.length === 11;
-    return financialContext && validLength;
+    const validLength = cleaned.length === 8 || cleaned.length === 11;
+    const validFormat = /^[A-Z]{6}[A-Z0-9]{2}([A-Z0-9]{3})?$/.test(cleaned);
+    return financialContext && validLength && validFormat;
   }
 };
 var TRANSACTION_ID = {
@@ -5482,11 +6130,18 @@ var TRANSACTION_ID = {
 };
 var INVESTMENT_ACCOUNT = {
   type: "INVESTMENT_ACCOUNT",
-  regex: /\b(?:ISA|SIPP|INV(?:ESTMENT)?|PENSION|401K|IRA)[-\s]?(?:ACCOUNT|ACCT|A\/C)?[-\s]?(?:NO|NUM(?:BER)?)?[-\s]?[:#]?\s*([A-Z0-9]{6,15})\b/gi,
+  regex: /\b(?:ISA|SIPP|INV(?:ESTMENT)?|PENSION|401K|IRA)[-\s\u00A0]*(?:ACCOUNT|ACCT|A\/C)?[-\s\u00A0]*(?:NO|NUM(?:BER)?)?[-\s\u00A0.:#]*([A-Z0-9](?:[A-Z0-9][\s\u00A0./-]?){5,18}[A-Z0-9])\b/gi,
   placeholder: "[INV_ACCT_{n}]",
   priority: 85,
   severity: "high",
-  description: "Investment and pension account numbers"
+  description: "Investment and pension account numbers",
+  validator: (value, context) => {
+    const normalized = value.replace(/[\s\u00A0./-]/g, "");
+    const hasDigits = /\d{4,}/.test(normalized);
+    const validLength = normalized.length >= 6 && normalized.length <= 15;
+    const inContext = /isa|sipp|invest|pension|401k|ira|account|fund/i.test(context);
+    return hasDigits && validLength && inContext;
+  }
 };
 var WIRE_TRANSFER_REF = {
   type: "WIRE_TRANSFER_REF",
@@ -5760,22 +6415,60 @@ var TERMINAL_ID = {
 };
 var UK_BANK_ACCOUNT_IBAN = {
   type: "UK_BANK_ACCOUNT_IBAN",
-  regex: /\b(GB\d{2}[A-Z]{4}\d{14})\b/g,
+  regex: /\b(GB\d{2}[\s\u00A0.-]?[A-Z]{4}[\s\u00A0.-]?\d{14})\b/gi,
   placeholder: "[UK_IBAN_{n}]",
   priority: 95,
   severity: "high",
   description: "UK bank account numbers in IBAN format",
-  validator: (value) => {
-    return value.startsWith("GB") && value.length === 22;
+  validator: (value, context) => {
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "").toUpperCase();
+    if (!cleaned.startsWith("GB") || cleaned.length !== 22) {
+      return false;
+    }
+    if (!validateIBAN(cleaned)) {
+      return false;
+    }
+    const bankingKeywords = /iban|account|bank|uk|gb|financial|payment|transfer/i;
+    if (!bankingKeywords.test(context)) {
+      return false;
+    }
+    const rejectKeywords = /example\s+iban|test\s+iban|sample\s+iban|demo\s+iban|fake\s+iban/i;
+    if (rejectKeywords.test(context)) {
+      return false;
+    }
+    return true;
   }
 };
 var UK_SORT_CODE_ACCOUNT = {
   type: "UK_SORT_CODE_ACCOUNT",
-  regex: /\b(\d{2}[-]\d{2}[-]\d{2}\s?\d{8})\b/g,
+  regex: /\b(\d{2}[\s\u00A0-]?\d{2}[\s\u00A0-]?\d{2}[\s\u00A0]?\d{8})\b/g,
   placeholder: "[UK_ACCOUNT_{n}]",
   priority: 95,
   severity: "high",
-  description: "UK sort code and account number combination"
+  description: "UK sort code and account number combination",
+  validator: (value, context) => {
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+    if (!/^\d{14}$/.test(cleaned)) {
+      return false;
+    }
+    const sortCode = cleaned.substring(0, 6);
+    const accountNumber = cleaned.substring(6);
+    if (accountNumber.length !== 8) {
+      return false;
+    }
+    if (!validateSortCode(sortCode)) {
+      return false;
+    }
+    const bankingKeywords = /sort\s+code|account|bank|uk|gb|financial|payment|transfer/i;
+    if (!bankingKeywords.test(context)) {
+      return false;
+    }
+    const rejectKeywords = /example\s+account|test\s+account|sample\s+account|demo\s+account|fake\s+account/i;
+    if (rejectKeywords.test(context)) {
+      return false;
+    }
+    return true;
+  }
 };
 var financialPatterns2 = [
   SWIFT_BIC,
@@ -6620,13 +7313,17 @@ var RESUME_ID = {
 };
 var BENEFITS_PLAN_NUMBER = {
   type: "BENEFITS_PLAN_NUMBER",
-  regex: /\b(?:BENEFITS?|INSURANCE|HEALTH[-\s]?PLAN)[-\s]?(?:PLAN)?[-\s]?(?:NO|NUM(?:BER)?|ID)?[-\s]?[:#]?\s*([A-Z0-9]{6,14})\b/gi,
+  regex: /\b(?:BENEFITS?|INSURANCE|HEALTH[-\s\u00A0]?PLAN)[-\s\u00A0]*(?:PLAN)?[-\s\u00A0]*(?:NO|NUM(?:BER)?|ID)?[-\s\u00A0.:#]*([A-Z0-9](?:[A-Z0-9][\s\u00A0./-]?){5,15}[A-Z0-9])\b/gi,
   placeholder: "[BENEFITS_{n}]",
   priority: 85,
   severity: "high",
   description: "Employee benefits and insurance plan numbers",
-  validator: (_value, context) => {
-    return /benefit|insurance|health|dental|vision|plan|policy|enrollment/i.test(context);
+  validator: (value, context) => {
+    const normalized = value.replace(/[\s\u00A0./-]/g, "");
+    const hasDigits = /\d{4,}/.test(normalized);
+    const validLength = normalized.length >= 6 && normalized.length <= 14;
+    const inContext = /benefit|insurance|health|dental|vision|plan|policy|enrollment/i.test(context);
+    return hasDigits && validLength && inContext;
   }
 };
 var RETIREMENT_ACCOUNT = {
@@ -6724,13 +7421,16 @@ var EXIT_INTERVIEW_ID = {
 };
 var DISCIPLINARY_ACTION_ID = {
   type: "DISCIPLINARY_ACTION_ID",
-  regex: /\b(?:DISCIPLINARY|INCIDENT|WARNING|VIOLATION)[-\s]?(?:ACTION)?[-\s]?(?:NO|NUM(?:BER)?|ID)?[-\s]?[:#]?\s*([A-Z0-9]{6,12})\b/gi,
+  regex: /\b(?:DISCIPLINARY|INCIDENT|WARNING|VIOLATION)[-\s\u00A0]*(?:ACTION)?[-\s\u00A0]*(?:NO|NUM(?:BER)?|ID)?[-\s\u00A0.:#]*([A-Z0-9](?:[A-Z0-9][\s\u00A0./-]?){5,15}[A-Z0-9])\b/gi,
   placeholder: "[DISCIPLINE_{n}]",
   priority: 85,
   severity: "high",
   description: "Disciplinary action and incident identifiers",
-  validator: (_value, context) => {
-    return /disciplinary|incident|warning|violation|misconduct|investigation/i.test(context);
+  validator: (value, context) => {
+    const normalized = value.replace(/[\s\u00A0./-]/g, "");
+    const hasDigits = /\d{3,}/.test(normalized);
+    const validLength = normalized.length >= 6 && normalized.length <= 12;
+    return hasDigits && validLength && /disciplinary|incident|warning|violation|misconduct|investigation/i.test(context);
   }
 };
 var EMERGENCY_CONTACT_REF = {
@@ -7058,7 +7758,7 @@ var TELECOMS_ACCOUNT_NUMBER = {
   type: "TELECOMS_ACCOUNT_NUMBER",
   regex: /\bACC(?:OUNT)?[-\s]?(?:NO|NUM(?:BER)?)?[-\s]?[:#]?\s*(\d{8,12})\b/gi,
   placeholder: "[ACCOUNT_{n}]",
-  priority: 85,
+  priority: 90,
   severity: "high",
   description: "Telecommunications customer account numbers",
   validator: (_value, context) => {
@@ -7936,7 +8636,7 @@ var EMERGENCY_CALL_REF = {
 };
 var POLICE_REPORT_NUMBER = {
   type: "POLICE_REPORT_NUMBER",
-  regex: /\b(?:POLICE|PR|RPT|REPORT|CASE)[-\s]?(?:NO|NUM|NUMBER|ID)?[-\s]?[:#]?\s*(\d{4}[-\s]?\d{5,10}|[A-Z]{2,4}[-\s]?\d{6,10})\b/gi,
+  regex: /\b(?:POLICE|PR|RPT|REPORT|CASE)[-\s\u00A0]*(?:NO|NUM|NUMBER|ID)?[-\s\u00A0.:#]*((?:[A-Z]{2,4}[\s\u00A0./-]?\d{2,4}[\s\u00A0./-]?\d{4,10})|\d{4}[\s\u00A0./-]?\d{5,10})\b/gi,
   placeholder: "[POLICE_RPT_{n}]",
   priority: 95,
   severity: "high",
@@ -7947,7 +8647,7 @@ var POLICE_REPORT_NUMBER = {
 };
 var FIRE_INCIDENT_NUMBER = {
   type: "FIRE_INCIDENT_NUMBER",
-  regex: /\b(?:FIRE|FI|FD)[-\s]?(?:INCIDENT|INC|NO|NUM|NUMBER|ID)?[-\s]?[:#]?\s*(\d{4}[-\s]?\d{4,8}|[A-Z]{2,4}[-\s]?\d{5,10})\b/gi,
+  regex: /\b(?:FIRE|FI|FD)[-\s\u00A0]*(?:INCIDENT|INC|NO|NUM|NUMBER|ID)?[-\s\u00A0.:#]*((?:[A-Z]{2,4}[\s\u00A0./-]?\d{2,4}[\s\u00A0./-]?\d{4,10})|\d{4}[\s\u00A0./-]?\d{4,8})\b/gi,
   placeholder: "[FIRE_INC_{n}]",
   priority: 95,
   severity: "high",
@@ -8812,13 +9512,15 @@ var gamingPatterns = [
 // src/patterns/industries/vehicles.ts
 var VIN_NUMBER = {
   type: "VIN_NUMBER",
-  regex: /\bVIN[-\s]?(?:NO|NUM|NUMBER)?[-\s]?[:#]?\s*([A-HJ-NPR-Z0-9]{17})\b/gi,
+  regex: /\bVIN[-\s\u00A0]?(?:NO|NUM|NUMBER)?[-\s\u00A0]?[:#]?\s*([A-HJ-NPR-Z0-9]{17})\b/gi,
   placeholder: "[VIN_{n}]",
   priority: 85,
   severity: "medium",
   description: "Vehicle Identification Number (VIN)",
   validator: (value, context) => {
-    if (/[IOQ]/i.test(value)) return false;
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "").toUpperCase();
+    if (cleaned.length !== 17) return false;
+    if (/[IOQ]/.test(cleaned)) return false;
     return /vin|vehicle|car|auto|motor|registration|title|insurance/i.test(context);
   }
 };
@@ -11120,9 +11822,11 @@ var GERMAN_TAX_ID = {
   severity: "high",
   description: "German Tax Identification Number (Steueridentifikationsnummer)",
   validator: (value, context) => {
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+    if (!/^\d{11}$/.test(cleaned)) return false;
     const relevantContext = /steuer|tax|german|deutschland|finanzamt/i.test(context);
     if (!relevantContext) return false;
-    const digits = value.split("").map(Number);
+    const digits = cleaned.split("").map(Number);
     const digitCounts = /* @__PURE__ */ new Map();
     digits.forEach((d) => digitCounts.set(d, (digitCounts.get(d) || 0) + 1));
     const counts = Array.from(digitCounts.values());
@@ -11281,9 +11985,11 @@ var DUTCH_BSN = {
   severity: "high",
   description: "Dutch Citizen Service Number (BSN)",
   validator: (value, context) => {
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+    if (!/^\d{9}$/.test(cleaned)) return false;
     const relevantContext = /bsn|dutch|netherlands|nederland|burger/i.test(context);
     if (!relevantContext) return false;
-    const digits = value.split("").map(Number);
+    const digits = cleaned.split("").map(Number);
     let sum = 0;
     for (let i = 0; i < 8; i++) {
       sum += digits[i] * (9 - i);
@@ -11300,10 +12006,12 @@ var POLISH_PESEL = {
   severity: "high",
   description: "Polish National Identification Number (PESEL)",
   validator: (value, context) => {
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+    if (!/^\d{11}$/.test(cleaned)) return false;
     const relevantContext = /pesel|polish|poland|polska/i.test(context);
     if (!relevantContext) return false;
     const weights = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3];
-    const digits = value.split("").map(Number);
+    const digits = cleaned.split("").map(Number);
     let sum = 0;
     for (let i = 0; i < 10; i++) {
       sum += digits[i] * weights[i];
@@ -11637,7 +12345,8 @@ var DISCORD_USER_ID = {
   severity: "medium",
   description: "Discord user ID (Snowflake format)",
   validator: (value, context) => {
-    if (value.length < 17 || value.length > 19) return false;
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+    if (cleaned.length < 17 || cleaned.length > 19) return false;
     return /discord|snowflake|user[-_]?id|server|guild/i.test(context);
   }
 };
@@ -11649,7 +12358,8 @@ var STEAM_ID64 = {
   severity: "medium",
   description: "Steam 64-bit user ID",
   validator: (value, context) => {
-    if (!value.startsWith("765") || value.length !== 17) return false;
+    const cleaned = value.replace(/[\s\u00A0.-]/g, "");
+    if (!cleaned.startsWith("765") || cleaned.length !== 17) return false;
     return /steam|gaming|player|profile|valve|community/i.test(context);
   }
 };
@@ -11782,13 +12492,14 @@ var NINTENDO_FRIEND_CODE = {
   type: "NINTENDO_FRIEND_CODE",
   regex: /\bSW[-\s]?(\d{4}[-\s]?\d{4}[-\s]?\d{4})\b/gi,
   placeholder: "[NINTENDO_FC_{n}]",
-  priority: 85,
+  priority: 90,
   severity: "medium",
   description: "Nintendo Switch Friend Code",
   validator: (value, context) => {
     const digits = value.replace(/\D/g, "");
     if (digits.length !== 12) return false;
-    return /nintendo|switch|friend[- ]?code|gaming/i.test(context);
+    const hasContext = /nintendo|switch|friend[- ]?code|gaming/i.test(context);
+    return hasContext;
   }
 };
 var BATTLETAG = {
@@ -12083,14 +12794,64 @@ var ccpaPreset = {
     "USERNAME"
   ]
 };
+var healthcarePreset = {
+  includeNames: true,
+  includeEmails: true,
+  includePhones: true,
+  includeAddresses: true,
+  categories: ["personal", "contact", "healthcare", "insurance", "government"]
+};
+var healthcareResearchPreset = {
+  includeNames: true,
+  includeEmails: true,
+  includePhones: true,
+  includeAddresses: true,
+  categories: ["personal", "contact", "healthcare", "insurance", "government"]
+};
+var financePreset = {
+  includeNames: true,
+  includeEmails: true,
+  includePhones: true,
+  includeAddresses: true,
+  categories: ["personal", "contact", "financial", "government", "network"]
+};
+var educationPreset = {
+  includeNames: true,
+  includeEmails: true,
+  includePhones: true,
+  includeAddresses: true,
+  categories: ["personal", "contact", "education", "government", "network"]
+};
+var transportLogisticsPreset = {
+  includeNames: true,
+  includeEmails: true,
+  includePhones: true,
+  includeAddresses: true,
+  categories: ["personal", "contact", "transportation", "logistics", "vehicles", "network"]
+};
 function getPreset(name) {
-  switch (name.toLowerCase()) {
+  const presetName = name.toLowerCase();
+  switch (presetName) {
     case "gdpr":
       return gdprPreset;
     case "hipaa":
       return hipaaPreset;
     case "ccpa":
       return ccpaPreset;
+    case "healthcare":
+    case "healthcare-provider":
+      return healthcarePreset;
+    case "healthcare-research":
+      return healthcareResearchPreset;
+    case "finance":
+    case "financial-services":
+      return financePreset;
+    case "education":
+      return educationPreset;
+    case "transport-logistics":
+    case "transportation":
+    case "logistics":
+      return transportLogisticsPreset;
     default:
       return {};
   }
@@ -12613,9 +13374,23 @@ var ConfigLoader = class {
       };
     }
     if (preset.startsWith("openredaction:")) {
-      const complianceType = preset.replace("openredaction:", "");
-      if (["gdpr", "hipaa", "ccpa"].includes(complianceType)) {
-        return { preset: complianceType };
+      const presetName = preset.replace("openredaction:", "");
+      const supportedPresets = [
+        "gdpr",
+        "hipaa",
+        "ccpa",
+        "healthcare",
+        "healthcare-provider",
+        "healthcare-research",
+        "finance",
+        "financial-services",
+        "education",
+        "transport-logistics",
+        "transportation",
+        "logistics"
+      ];
+      if (supportedPresets.includes(presetName)) {
+        return { preset: presetName };
       }
     }
     return null;
@@ -12631,7 +13406,8 @@ var ConfigLoader = class {
 export default {
   // Extend built-in presets
   // Options: 'openredaction:recommended', 'openredaction:strict', 'openredaction:minimal'
-  // Or compliance: 'openredaction:gdpr', 'openredaction:hipaa', 'openredaction:ccpa'
+  // Or compliance/industry presets: 'openredaction:gdpr', 'openredaction:hipaa', 'openredaction:ccpa',
+  // 'openredaction:finance', 'openredaction:education', 'openredaction:healthcare', 'openredaction:transport-logistics'
   extends: ['openredaction:recommended'],
 
   // Detection options
@@ -14308,9 +15084,8 @@ var ExplainAPI = class {
   constructor(detector) {
     this.detector = detector;
     this.patterns = detector.getPatterns();
-    const testResult = detector.detect("Contact: admin@business.co.uk");
-    const hasConfidence = testResult.detections.length > 0 && testResult.detections[0].confidence !== void 0;
     const detectorOptions = detector.options;
+    const hasConfidence = detectorOptions?.enableContextAnalysis || false;
     this.options = {
       enableContextAnalysis: hasConfidence,
       confidenceThreshold: detectorOptions?.confidenceThreshold || 0.5,
@@ -14322,7 +15097,7 @@ var ExplainAPI = class {
   /**
    * Explain why text was or wasn't detected as PII
    */
-  explain(text) {
+  async explain(text) {
     const patternResults = [];
     const matchedPatterns = [];
     const unmatchedPatterns = [];
@@ -14412,7 +15187,8 @@ var ExplainAPI = class {
       patternResults.push(result);
       matchedPatterns.push(result);
     }
-    const detections = this.detector.detect(text).detections;
+    const detectionResult = await this.detector.detect(text);
+    const detections = detectionResult.detections;
     return {
       text,
       patternResults,
@@ -14431,7 +15207,7 @@ var ExplainAPI = class {
   /**
    * Explain a specific detection
    */
-  explainDetection(detection, text) {
+  async explainDetection(detection, text) {
     const pattern = this.patterns.find((p) => p.type === detection.type);
     const reasoning = [];
     reasoning.push(`Detected as ${detection.type}`);
@@ -14462,13 +15238,15 @@ var ExplainAPI = class {
       detection,
       pattern,
       contextAnalysis,
-      reasoning
+      reasoning,
+      suggestions: []
+      // Will be populated if needed
     };
   }
   /**
    * Suggest why text wasn't detected
    */
-  suggestWhy(text, expectedType) {
+  async suggestWhy(text, expectedType) {
     const suggestions = [];
     const similarPatterns = [];
     const typePatterns = this.patterns.filter(
@@ -14486,7 +15264,7 @@ var ExplainAPI = class {
         similarPatterns.push(pattern);
         const value = match[1] !== void 0 ? match[1] : match[0];
         suggestions.push(`Pattern "${pattern.type}" matched value: "${value}"`);
-        const explanation = this.explain(text);
+        const explanation = await this.explain(text);
         const filtered = explanation.filteredPatterns.find((r) => r.pattern.type === pattern.type);
         if (filtered && filtered.reason) {
           suggestions.push(`But was filtered: ${filtered.reason}`);
@@ -14516,9 +15294,9 @@ Example ${expectedType} pattern: ${examplePattern.regex.source.substring(0, 100)
   /**
    * Get debugging information for entire detection process
    */
-  debug(text) {
+  async debug(text) {
     const start = performance.now();
-    const explanation = this.explain(text);
+    const explanation = await this.explain(text);
     const duration = performance.now() - start;
     const enabledFeatures = [];
     if (this.options.enableContextAnalysis) {
@@ -15406,6 +16184,152 @@ function compileSafeRegex(pattern, flags) {
   return new RegExp(patternStr, finalFlags);
 }
 
+// src/utils/ai-assist.ts
+function getAIEndpoint(aiOptions) {
+  if (!aiOptions?.enabled) {
+    return null;
+  }
+  if (aiOptions.endpoint) {
+    return aiOptions.endpoint;
+  }
+  if (typeof process !== "undefined" && process.env) {
+    const envEndpoint = process.env.OPENREDACTION_AI_ENDPOINT;
+    if (envEndpoint) {
+      return envEndpoint;
+    }
+  }
+  return null;
+}
+function isFetchAvailable() {
+  return typeof fetch !== "undefined";
+}
+async function callAIDetect(text, endpoint, debug) {
+  if (!isFetchAvailable()) {
+    if (debug) {
+      console.warn("[OpenRedaction] AI assist requires fetch API. Not available in this environment.");
+    }
+    return null;
+  }
+  try {
+    const url = endpoint.endsWith("/ai-detect") ? endpoint : `${endpoint}/ai-detect`;
+    if (debug) {
+      console.log(`[OpenRedaction] Calling AI endpoint: ${url}`);
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ text })
+    });
+    if (!response.ok) {
+      if (debug) {
+        const statusText = response.status === 429 ? "Rate limit exceeded (429)" : `${response.status}: ${response.statusText}`;
+        console.warn(`[OpenRedaction] AI endpoint returned ${statusText}`);
+      }
+      return null;
+    }
+    const data = await response.json();
+    if (!data.entities || !Array.isArray(data.entities)) {
+      if (debug) {
+        console.warn("[OpenRedaction] Invalid AI response format: missing entities array");
+      }
+      return null;
+    }
+    return data.entities;
+  } catch (error) {
+    if (debug) {
+      console.warn(`[OpenRedaction] AI endpoint error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    return null;
+  }
+}
+function validateAIEntity(entity, textLength) {
+  if (!entity.type || !entity.value || typeof entity.start !== "number" || typeof entity.end !== "number") {
+    return false;
+  }
+  if (entity.start < 0 || entity.end < 0 || entity.start >= entity.end) {
+    return false;
+  }
+  if (entity.start >= textLength || entity.end > textLength) {
+    return false;
+  }
+  const actualValue = entity.value;
+  if (actualValue.length !== entity.end - entity.start) {
+    return false;
+  }
+  return true;
+}
+function detectionsOverlap(det1, det2) {
+  const [start1, end1] = det1.position;
+  const [start2, end2] = det2.position;
+  const overlapStart = Math.max(start1, start2);
+  const overlapEnd = Math.min(end1, end2);
+  if (overlapStart >= overlapEnd) {
+    return false;
+  }
+  const overlapLength = overlapEnd - overlapStart;
+  const length1 = end1 - start1;
+  const length2 = end2 - start2;
+  const minLength = Math.min(length1, length2);
+  return overlapLength > minLength * 0.5;
+}
+function convertAIEntityToDetection(entity, text) {
+  if (!validateAIEntity(entity, text.length)) {
+    return null;
+  }
+  const actualValue = text.substring(entity.start, entity.end);
+  let type = entity.type.toUpperCase();
+  if (type.includes("EMAIL") || type === "EMAIL_ADDRESS") {
+    type = "EMAIL";
+  } else if (type.includes("PHONE") || type === "PHONE_NUMBER") {
+    type = "PHONE_US";
+  } else if (type.includes("NAME") || type === "PERSON") {
+    type = "NAME";
+  } else if (type.includes("SSN") || type === "SOCIAL_SECURITY_NUMBER") {
+    type = "SSN";
+  } else if (type.includes("ADDRESS")) {
+    type = "ADDRESS_STREET";
+  }
+  let severity = "medium";
+  if (type === "SSN" || type === "CREDIT_CARD") {
+    severity = "critical";
+  } else if (type === "EMAIL" || type === "PHONE_US" || type === "NAME") {
+    severity = "high";
+  }
+  return {
+    type,
+    value: actualValue,
+    placeholder: `[${type}_${Math.random().toString(36).substring(2, 9)}]`,
+    position: [entity.start, entity.end],
+    severity,
+    confidence: entity.confidence ?? 0.7
+    // Default confidence for AI entities
+  };
+}
+function mergeAIEntities(regexDetections, aiEntities, text) {
+  const merged = [...regexDetections];
+  const processedRanges = regexDetections.map((d) => d.position);
+  for (const aiEntity of aiEntities) {
+    const detection = convertAIEntityToDetection(aiEntity, text);
+    if (!detection) {
+      continue;
+    }
+    let hasOverlap = false;
+    for (const regexDet of regexDetections) {
+      if (detectionsOverlap(regexDet, detection)) {
+        hasOverlap = true;
+        break;
+      }
+    }
+    if (!hasOverlap) {
+      merged.push(detection);
+      processedRanges.push(detection.position);
+    }
+  }
+  return merged;
+}
+
 // src/detector.ts
 var OpenRedaction = class _OpenRedaction {
   constructor(options = {}) {
@@ -15615,6 +16539,9 @@ var OpenRedaction = class _OpenRedaction {
     for (const pattern of this.patterns) {
       const regex = new RegExp(pattern.regex.source, pattern.regex.flags);
       this.compiledPatterns.set(pattern, regex);
+      if (this.options.debug && (pattern.type === "NINTENDO_FRIEND_CODE" || pattern.type === "TELECOMS_ACCOUNT_NUMBER")) {
+        console.log(`[OpenRedaction] Compiled pattern '${pattern.type}': ${regex}`);
+      }
     }
     if (this.options.debug) {
       console.log(`[OpenRedaction] Pre-compiled ${this.compiledPatterns.size} regex patterns`);
@@ -15634,12 +16561,18 @@ var OpenRedaction = class _OpenRedaction {
         }
         continue;
       }
+      if (this.options.debug && (pattern.type === "NINTENDO_FRIEND_CODE" || pattern.type === "TELECOMS_ACCOUNT_NUMBER")) {
+        console.log(`[OpenRedaction] Processing pattern '${pattern.type}' with regex: ${regex}`);
+      }
       let match;
       let matchCount = 0;
       const maxMatches = 1e4;
       regex.lastIndex = 0;
       try {
         while ((match = safeExec(regex, text, { timeout: this.options.regexTimeout })) !== null) {
+          if (this.options.debug && (pattern.type === "NINTENDO_FRIEND_CODE" || pattern.type === "TELECOMS_ACCOUNT_NUMBER")) {
+            console.log(`[OpenRedaction] Pattern '${pattern.type}' regex match found: '${match[0]}' at position ${match.index}`);
+          }
           matchCount++;
           if (matchCount >= maxMatches) {
             if (this.options.debug) {
@@ -15660,12 +16593,18 @@ var OpenRedaction = class _OpenRedaction {
             endPos = startPos + value.length;
           }
           if (this.overlapsWithExisting(startPos, endPos, processedRanges)) {
+            if (this.options.debug) {
+              console.log(`[OpenRedaction] Pattern '${pattern.type}' skipped due to overlap at ${startPos}-${endPos}`);
+            }
             continue;
           }
           const contextStart = Math.max(0, startPos - 50);
           const contextEnd = Math.min(text.length, endPos + 50);
           const context = text.substring(contextStart, contextEnd);
           if (pattern.validator && !pattern.validator(value, context)) {
+            if (this.options.debug) {
+              console.log(`[OpenRedaction] Pattern '${pattern.type}' validation failed for value: '${value}' with context: '${context.substring(0, 100)}...'`);
+            }
             continue;
           }
           if (this.options.enableFalsePositiveFilter) {
@@ -15684,6 +16623,9 @@ var OpenRedaction = class _OpenRedaction {
               endPos
             );
             confidence = contextAnalysis.confidence;
+            if (this.options.debug && confidence < this.options.confidenceThreshold) {
+              console.log(`[OpenRedaction] Pattern '${pattern.type}' failed context analysis. Value: '${value}', Confidence: ${confidence} < ${this.options.confidenceThreshold}`);
+            }
           }
           if (this.contextRulesEngine) {
             const piiMatch = {
@@ -15709,6 +16651,9 @@ var OpenRedaction = class _OpenRedaction {
             continue;
           }
           const placeholder = this.generatePlaceholder(value, pattern);
+          if (this.options.debug) {
+            console.log(`[OpenRedaction] Pattern '${pattern.type}' detected: '${value}' at position ${startPos}-${endPos}, confidence: ${confidence}`);
+          }
           detections.push({
             type: pattern.type,
             value,
@@ -15769,8 +16714,9 @@ var OpenRedaction = class _OpenRedaction {
   }
   /**
    * Detect PII in text
+   * Now async to support optional AI assist
    */
-  detect(text) {
+  async detect(text) {
     if (this.rbacManager && !this.rbacManager.hasPermission("detection:detect")) {
       throw new Error("[OpenRedaction] Permission denied: detection:detect required");
     }
@@ -15824,12 +16770,42 @@ var OpenRedaction = class _OpenRedaction {
     } else {
       detections = this.processPatterns(text, this.patterns, processedRanges);
     }
+    if (this.options.ai?.enabled) {
+      const aiEndpoint = getAIEndpoint(this.options.ai);
+      if (aiEndpoint) {
+        try {
+          if (this.options.debug) {
+            console.log("[OpenRedaction] AI assist enabled, calling AI endpoint...");
+          }
+          const aiEntities = await callAIDetect(text, aiEndpoint, this.options.debug);
+          if (aiEntities && aiEntities.length > 0) {
+            if (this.options.debug) {
+              console.log(`[OpenRedaction] AI returned ${aiEntities.length} additional entities`);
+            }
+            detections = mergeAIEntities(detections, aiEntities, text);
+            if (this.options.debug) {
+              console.log(`[OpenRedaction] After AI merge: ${detections.length} total detections`);
+            }
+          } else if (this.options.debug) {
+            console.log("[OpenRedaction] AI endpoint returned no additional entities");
+          }
+        } catch (error) {
+          if (this.options.debug) {
+            console.warn(`[OpenRedaction] AI assist failed, using regex-only: ${error instanceof Error ? error.message : "Unknown error"}`);
+          }
+        }
+      } else if (this.options.debug) {
+        console.warn("[OpenRedaction] AI assist enabled but no endpoint configured. Set ai.endpoint or OPENREDACTION_AI_ENDPOINT env var.");
+      }
+    }
     detections.sort((a, b) => b.position[0] - a.position[0]);
     let redacted = text;
     const redactionMap = {};
     for (const detection of detections) {
-      const [start, end] = detection.position;
-      redacted = redacted.substring(0, start) + detection.placeholder + redacted.substring(end);
+      if (!detection.value) continue;
+      const escapedValue = this.escapeRegex(detection.value);
+      const pattern = new RegExp(escapedValue, "gi");
+      redacted = redacted.replace(pattern, detection.placeholder);
       redactionMap[detection.placeholder] = detection.value;
     }
     const endTime = performance.now();
@@ -15982,8 +16958,8 @@ var OpenRedaction = class _OpenRedaction {
   /**
    * Get severity-based scan results
    */
-  scan(text) {
-    const result = this.detect(text);
+  async scan(text) {
+    const result = await this.detect(text);
     return {
       high: result.detections.filter((d) => d.severity === "high"),
       medium: result.detections.filter((d) => d.severity === "medium"),
@@ -16220,7 +17196,7 @@ var OpenRedaction = class _OpenRedaction {
     const metadata = await processor.getMetadata(buffer, options);
     const extractionEnd = performance.now();
     const extractionTime = Math.round((extractionEnd - extractionStart) * 100) / 100;
-    const detection = this.detect(text);
+    const detection = await this.detect(text);
     return {
       text,
       metadata,
@@ -16317,7 +17293,7 @@ var StreamingDetector = class {
       const end = Math.min(textLength, position + chunkSize);
       const chunk = text.substring(start, end);
       const byteOffset = start;
-      const result = this.detector.detect(chunk);
+      const result = await this.detector.detect(chunk);
       const newDetections = result.detections.filter((detection) => {
         const absoluteStart = byteOffset + detection.position[0];
         const absoluteEnd = byteOffset + detection.position[1];
@@ -16347,8 +17323,10 @@ var StreamingDetector = class {
           (a, b) => b.position[0] - a.position[0]
         );
         for (const detection of sortedDetections) {
-          const [start2, end2] = detection.position;
-          redactedChunk = redactedChunk.substring(0, start2) + detection.placeholder + redactedChunk.substring(end2);
+          if (!detection.value) continue;
+          const escapedValue = this.escapeRegex(detection.value);
+          const pattern = new RegExp(escapedValue, "gi");
+          redactedChunk = redactedChunk.replace(pattern, detection.placeholder);
         }
       }
       yield {
@@ -16374,8 +17352,10 @@ var StreamingDetector = class {
     allDetections.sort((a, b) => b.position[0] - a.position[0]);
     const redactionMap = {};
     for (const detection of allDetections) {
-      const [start, end] = detection.position;
-      redactedText = redactedText.substring(0, start) + detection.placeholder + redactedText.substring(end);
+      if (!detection.value) continue;
+      const escapedValue = this.escapeRegex(detection.value);
+      const pattern = new RegExp(escapedValue, "gi");
+      redactedText = redactedText.replace(pattern, detection.placeholder);
       redactionMap[detection.placeholder] = detection.value;
     }
     return {
@@ -16450,6 +17430,9 @@ var StreamingDetector = class {
       estimatedMemory
     };
   }
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
 };
 function createStreamingDetector(detector, options) {
   return new StreamingDetector(detector, options);
@@ -16466,11 +17449,11 @@ var BatchProcessor = class {
   /**
    * Process multiple documents sequentially
    */
-  processSequential(documents, options = {}) {
+  async processSequential(documents, options = {}) {
     const startTime = performance.now();
     const results = [];
     for (let i = 0; i < documents.length; i++) {
-      const result = this.detector.detect(documents[i]);
+      const result = await this.detector.detect(documents[i]);
       results.push(result);
       if (options.onProgress) {
         options.onProgress(i + 1, documents.length);
@@ -16484,7 +17467,7 @@ var BatchProcessor = class {
         totalDocuments: documents.length,
         totalDetections: results.reduce((sum, r) => sum + r.detections.length, 0),
         totalTime,
-        avgTimePerDocument: totalTime / documents.length
+        avgTimePerDocument: documents.length > 0 ? totalTime / documents.length : 0
       }
     };
   }
@@ -16498,16 +17481,14 @@ var BatchProcessor = class {
     let completed = 0;
     for (let i = 0; i < documents.length; i += maxConcurrency) {
       const batch = documents.slice(i, i + maxConcurrency);
-      const batchPromises = batch.map((doc, batchIndex) => {
-        return Promise.resolve().then(() => {
-          const result = this.detector.detect(doc);
-          results[i + batchIndex] = result;
-          completed++;
-          if (options.onProgress) {
-            options.onProgress(completed, documents.length);
-          }
-          return result;
-        });
+      const batchPromises = batch.map(async (doc, batchIndex) => {
+        const result = await this.detector.detect(doc);
+        results[i + batchIndex] = result;
+        completed++;
+        if (options.onProgress) {
+          options.onProgress(completed, documents.length);
+        }
+        return result;
       });
       await Promise.all(batchPromises);
     }
@@ -16519,7 +17500,7 @@ var BatchProcessor = class {
         totalDocuments: documents.length,
         totalDetections: results.reduce((sum, r) => sum + r.detections.length, 0),
         totalTime,
-        avgTimePerDocument: totalTime / documents.length
+        avgTimePerDocument: documents.length > 0 ? totalTime / documents.length : 0
       }
     };
   }
@@ -16530,7 +17511,7 @@ var BatchProcessor = class {
     if (options.parallel) {
       return this.processParallel(documents, options);
     } else {
-      return Promise.resolve(this.processSequential(documents, options));
+      return this.processSequential(documents, options);
     }
   }
   /**
@@ -16541,7 +17522,7 @@ var BatchProcessor = class {
     for (let i = 0; i < documents.length; i += batchSize) {
       const batch = documents.slice(i, i + batchSize);
       for (const doc of batch) {
-        const result = this.detector.detect(doc);
+        const result = await this.detector.detect(doc);
         yield result;
       }
     }
@@ -16589,7 +17570,7 @@ function openredactionMiddleware(options = {}) {
     ...detectorOptions
   } = options;
   const detector = new OpenRedaction(detectorOptions);
-  return (req, res, next) => {
+  return async (req, res, next) => {
     if (skipRoutes.some((pattern) => pattern.test(req.path))) {
       return next();
     }
@@ -16609,7 +17590,7 @@ function openredactionMiddleware(options = {}) {
       const results = {};
       const redactedBody = { ...req.body };
       for (const { field, value } of textsToCheck) {
-        const result = detector.detect(value);
+        const result = await detector.detect(value);
         if (result.detections.length > 0) {
           totalDetections += result.detections.length;
           results[field] = result;
@@ -16659,7 +17640,7 @@ function openredactionMiddleware(options = {}) {
 }
 function detectPII(options = {}) {
   const detector = new OpenRedaction(options);
-  return (req, res) => {
+  return async (req, res) => {
     const text = req.body?.text || req.query.text;
     if (!text) {
       res.status(400).json({
@@ -16668,19 +17649,26 @@ function detectPII(options = {}) {
       });
       return;
     }
-    const result = detector.detect(text);
-    res.json({
-      detected: result.detections.length > 0,
-      count: result.detections.length,
-      detections: result.detections,
-      redacted: result.redacted,
-      stats: result.stats
-    });
+    try {
+      const result = await detector.detect(text);
+      res.json({
+        detected: result.detections.length > 0,
+        count: result.detections.length,
+        detections: result.detections,
+        redacted: result.redacted,
+        stats: result.stats
+      });
+    } catch (error) {
+      res.status(500).json({
+        error: "Detection failed",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
   };
 }
 function generateReport(options = {}) {
   const detector = new OpenRedaction(options);
-  return (req, res) => {
+  return async (req, res) => {
     const text = req.body?.text;
     const format = req.body?.format || req.query.format || "json";
     if (!text) {
@@ -16689,28 +17677,35 @@ function generateReport(options = {}) {
       });
       return;
     }
-    const result = detector.detect(text);
-    if (format === "html") {
-      const html = detector.generateReport(result, {
-        format: "html",
-        title: req.body?.title || "PII Detection Report"
-      });
-      res.setHeader("Content-Type", "text/html");
-      res.send(html);
-    } else if (format === "markdown") {
-      const md = detector.generateReport(result, {
-        format: "markdown",
-        title: req.body?.title || "PII Detection Report"
-      });
-      res.setHeader("Content-Type", "text/markdown");
-      res.send(md);
-    } else {
-      res.json({
-        detected: result.detections.length > 0,
-        count: result.detections.length,
-        detections: result.detections,
-        redacted: result.redacted,
-        stats: result.stats
+    try {
+      const result = await detector.detect(text);
+      if (format === "html") {
+        const html = detector.generateReport(result, {
+          format: "html",
+          title: req.body?.title || "PII Detection Report"
+        });
+        res.setHeader("Content-Type", "text/html");
+        res.send(html);
+      } else if (format === "markdown") {
+        const md = detector.generateReport(result, {
+          format: "markdown",
+          title: req.body?.title || "PII Detection Report"
+        });
+        res.setHeader("Content-Type", "text/markdown");
+        res.send(md);
+      } else {
+        res.json({
+          detected: result.detections.length > 0,
+          count: result.detections.length,
+          detections: result.detections,
+          redacted: result.redacted,
+          stats: result.stats
+        });
+      }
+    } catch (error) {
+      res.status(500).json({
+        error: "Report generation failed",
+        message: error instanceof Error ? error.message : "Unknown error"
       });
     }
   };
@@ -16722,12 +17717,17 @@ function useOpenRedaction(options) {
   const detector = (0, import_react.useMemo)(() => new OpenRedaction(options), [options]);
   const [result, setResult] = (0, import_react.useState)(null);
   const [isDetecting, setIsDetecting] = (0, import_react.useState)(false);
-  const detect = (0, import_react.useCallback)((text) => {
+  const detect = (0, import_react.useCallback)(async (text) => {
     setIsDetecting(true);
-    const detection = detector.detect(text);
-    setResult(detection);
-    setIsDetecting(false);
-    return detection;
+    try {
+      const detection = await detector.detect(text);
+      setResult(detection);
+      setIsDetecting(false);
+      return detection;
+    } catch (error) {
+      setIsDetecting(false);
+      throw error;
+    }
   }, [detector]);
   const clear = (0, import_react.useCallback)(() => {
     setResult(null);
@@ -16753,10 +17753,14 @@ function usePIIDetector(text, options) {
       return;
     }
     setIsDetecting(true);
-    const timer = setTimeout(() => {
-      const detection = detector.detect(text);
-      setResult(detection);
-      setIsDetecting(false);
+    const timer = setTimeout(async () => {
+      try {
+        const detection = await detector.detect(text);
+        setResult(detection);
+        setIsDetecting(false);
+      } catch (error) {
+        setIsDetecting(false);
+      }
     }, debounce);
     return () => {
       clearTimeout(timer);
@@ -16777,27 +17781,32 @@ function useFormFieldValidator(options) {
   const [value, setValue] = (0, import_react.useState)("");
   const [error, setError] = (0, import_react.useState)(null);
   const [result, setResult] = (0, import_react.useState)(null);
-  const validate = (0, import_react.useCallback)((inputValue) => {
+  const validate = (0, import_react.useCallback)(async (inputValue) => {
     setValue(inputValue);
     if (!inputValue) {
       setError(null);
       setResult(null);
       return true;
     }
-    const detection = detector.detect(inputValue);
-    setResult(detection);
-    const relevantDetections = types.length > 0 ? detection.detections.filter((d) => types.includes(d.type)) : detection.detections;
-    if (relevantDetections.length > 0) {
-      if (failOnPII) {
-        setError(`Sensitive information detected: ${relevantDetections[0].type}`);
-      }
-      if (onPIIDetected) {
-        onPIIDetected(detection);
+    try {
+      const detection = await detector.detect(inputValue);
+      setResult(detection);
+      const relevantDetections = types.length > 0 ? detection.detections.filter((d) => types.includes(d.type)) : detection.detections;
+      if (relevantDetections.length > 0) {
+        if (failOnPII) {
+          setError(`Sensitive information detected: ${relevantDetections[0].type}`);
+        }
+        if (onPIIDetected) {
+          onPIIDetected(detection);
+        }
+        return false;
       }
+      setError(null);
+      return true;
+    } catch (error2) {
+      setError("Validation failed");
       return false;
     }
-    setError(null);
-    return true;
   }, [detector, failOnPII, types, onPIIDetected]);
   const getFieldProps = (0, import_react.useCallback)(() => ({
     value,
@@ -16824,7 +17833,7 @@ function useBatchDetector(options) {
     setProgress(0);
     const detections = [];
     for (let i = 0; i < texts.length; i++) {
-      const result = detector.detect(texts[i]);
+      const result = await detector.detect(texts[i]);
       detections.push(result);
       setProgress((i + 1) / texts.length * 100);
       await new Promise((resolve) => setTimeout(resolve, 0));
@@ -16861,9 +17870,12 @@ function useAutoRedact(options) {
       setResult(null);
       return;
     }
-    const timer = setTimeout(() => {
-      const detection = detector.detect(text);
-      setResult(detection);
+    const timer = setTimeout(async () => {
+      try {
+        const detection = await detector.detect(text);
+        setResult(detection);
+      } catch (error) {
+      }
     }, debounce);
     return () => clearTimeout(timer);
   }, [text, detector, debounce]);
@@ -16992,7 +18004,7 @@ var TenantManager = class {
     await this.checkQuotas(tenantId, text);
     this.trackRequest(tenantId, text);
     const detector = this.getDetector(tenantId);
-    const result = detector.detect(text);
+    const result = await detector.detect(text);
     const usage = this.usage.get(tenantId);
     usage.piiDetectedThisMonth += result.detections.length;
     usage.lastRequestAt = /* @__PURE__ */ new Date();
@@ -17279,6 +18291,7 @@ var DEFAULT_TIER_QUOTAS = {
 // src/webhooks/WebhookManager.ts
 var WebhookManager = class {
   // 1 minute
+  // private readonly HALF_OPEN_MAX_REQUESTS = 1; // Reserved for future use
   constructor(options) {
     this.webhooks = /* @__PURE__ */ new Map();
     this.deliveryHistory = [];
@@ -17550,9 +18563,9 @@ var WebhookManager = class {
    */
   async makeHttpRequest(webhook, event) {
     try {
-      let fetch;
+      let fetch2;
       try {
-        fetch = globalThis.fetch;
+        fetch2 = globalThis.fetch;
       } catch {
         throw new Error("[WebhookManager] HTTP client not available. Requires Node 18+ with fetch support.");
       }
@@ -17572,7 +18585,7 @@ var WebhookManager = class {
       const controller = new AbortController();
       const timeoutId = setTimeout(() => controller.abort(), webhook.timeout);
       try {
-        const response = await fetch(webhook.url, {
+        const response = await fetch2(webhook.url, {
           method: "POST",
           headers,
           body: JSON.stringify(event),
@@ -17943,7 +18956,7 @@ var APIServer = class {
       if (req.tenantId && this.config.tenantManager) {
         result = await this.config.tenantManager.detect(req.tenantId, text);
       } else if (this.detector) {
-        result = this.detector.detect(text);
+        result = await this.detector.detect(text);
       } else {
         throw new Error("No detector available");
       }
@@ -17984,7 +18997,7 @@ var APIServer = class {
       if (req.tenantId && this.config.tenantManager) {
         result = await this.config.tenantManager.detect(req.tenantId, text);
       } else if (this.detector) {
-        result = this.detector.detect(text);
+        result = await this.detector.detect(text);
       } else {
         throw new Error("No detector available");
       }
@@ -18407,10 +19420,12 @@ init_HealthCheck();
   analyzeFullContext,
   calculateContextConfidence,
   calculateRisk,
+  callAIDetect,
   ccpaPreset,
   commonFalsePositives,
   compileSafeRegex,
   contactPatterns,
+  convertAIEntityToDetection,
   createAPIServer,
   createBatchProcessor,
   createCacheDisabledError,
@@ -18445,12 +19460,16 @@ init_HealthCheck();
   createXlsxProcessor,
   defaultPasses,
   detectPII,
+  detectionsOverlap,
+  educationPreset,
   exportForVersionControl,
   extractContext,
   filterFalsePositives,
+  financePreset,
   financialPatterns,
   gdprPreset,
   generateReport,
+  getAIEndpoint,
   getPatternsByCategory,
   getPredefinedRole,
   getPreset,
@@ -18458,21 +19477,26 @@ init_HealthCheck();
   governmentPatterns,
   groupPatternsByPass,
   healthCheckMiddleware,
+  healthcarePreset,
+  healthcareResearchPreset,
   hipaaPreset,
   inferDocumentType,
   isFalsePositive,
   isUnsafePattern,
+  mergeAIEntities,
   mergePassDetections,
   networkPatterns,
   openredactionMiddleware,
   personalPatterns,
   safeExec,
   safeExecAll,
+  transportLogisticsPreset,
   useAutoRedact,
   useBatchDetector,
   useFormFieldValidator,
   useOpenRedaction,
   usePIIDetector,
+  validateAIEntity,
   validateEmail,
   validateIBAN,
   validateLuhn,