@privacyscrubber/mcp-server 1.7.2 → 1.7.6

package/ps-pii-engine.js

@@ -0,0 +1,823 @@
+/**
+ * PrivacyScrubber Shared PII Engine
+ * Shared between Website Worker, Chrome Extension, and MCP Server.
+ * Responsible for running Regex checks, overlap resolution, and reverse scrubbing.
+ */
+
+(function() {
+    if (typeof window !== 'undefined' && window.PrivacyScrubberEngine) return;
+
+    // --- START DEFAULT RULES ---
+/**
+ * PrivacyScrubber Unified PII Detection Rules
+ * Shared between Website Worker, Chrome Extension, and Build Pipeline.
+ */
+
+let DEVOPS_SECRETS = [
+    // Secrets & API Keys
+    { name: 'AWS Credentials', type: 'SECRET', regex: /\b(?:AKIA|ASIA|AGPA|AIDA|AROA|AIPA)[A-Z0-9]{16}\b/g },
+    { name: 'JSON Web Token (JWT)', type: 'SECRET', regex: /\beyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\b/g },
+    { name: 'API Token/Key (GitHub/Slack/NPM)', type: 'SECRET', regex: /\b(?:ghp|gho|ghu|ghs|ghr|glpat|npm|xox[baprs])[-_][A-Za-z0-9_]{10,}\b/g },
+    { name: 'Stripe API Key', type: 'SECRET', regex: /\b(?:[rs]k)_(?:test|live)_[a-zA-Z0-9]{24,}\b/g },
+    { name: 'Generic Secret/Key', type: 'SECRET', regex: /\b(sk|pk|secret|key|token|auth)(?:[-_][a-zA-Z0-9_-]{5,}|(?=[a-zA-Z0-9_-]{5,}\b)(?=[a-zA-Z_-]*[0-9])[a-zA-Z0-9_-]{5,})\b/gi },
+    { name: 'Hash / Hex Key (32-64 chars)', type: 'SECRET', regex: /\b[a-fA-F0-9]{32,64}\b/g },
+    { name: 'CVE Identifier', type: 'SECRET', regex: /\bCVE-\d{4}-\d{4,}\b/gi },
+    { name: 'Cryptographic Hash', type: 'SECRET', regex: /\b(MD5|SHA1|SHA256)[:\s][a-f0-9]{32,64}\b/gi },
+    { name: 'Database/API Secret', type: 'SECRET', regex: /\b(DB|POSTGRES|REDIS|MYSQL|AWS|SECRET|PASSWORD|TOKEN|API|KEY)[A-Z0-9_]*\s*[:=]\s*[^\s"']+\b/gi },
+    { name: 'Proprietary IP / Confidential', type: 'SECRET', regex: /\b(CONFIDENTIAL|PROPRIETARY|TRADE SECRET|DO NOT DISTRIBUTE|INTERNAL USE ONLY)\b/gi },
+    { name: 'Private Cryptographic Key', type: 'SECRET', regex: /-----BEGIN (?:RSA |EC |PGP |DSA )?PRIVATE KEY-----/g }
+];
+
+let REGEX_RULES = [
+    ...DEVOPS_SECRETS,
+    // Emails 
+    { type: 'EMAIL', regex: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g },
+
+    // Financial Data
+    { type: 'FINANCIAL', regex: /(?:[$€£¥₪₽₹]|(?:USD|EUR|GBP|CHF|ILS|RUB)\s?)[0-9,.]+\b/g },
+    { type: 'FINANCIAL', regex: /\b[A-Z]{4}(?:AD|AE|AF|AG|AI|AL|AM|AO|AQ|AR|AS|AT|AU|AW|AX|AZ|BA|BB|BD|BE|BF|BG|BH|BI|BJ|BL|BM|BN|BO|BQ|BR|BS|BT|BV|BW|BY|BZ|CA|CC|CD|CF|CG|CH|CI|CK|CL|CM|CN|CO|CR|CU|CV|CW|CX|CY|CZ|DE|DJ|DK|DM|DO|DZ|EC|EE|EG|EH|ER|ES|ET|FI|FJ|FK|FM|FO|FR|GA|GB|GD|GE|GF|GG|GH|GI|GL|GM|GN|GP|GQ|GR|GS|GT|GU|GW|GY|HK|HM|HN|HR|HT|HU|ID|IE|IL|IM|IN|IO|IQ|IR|IS|IT|JE|JM|JO|JP|KE|KG|KH|KI|KM|KN|KP|KR|KW|KY|KZ|LA|LB|LC|LI|LK|LR|LS|LT|LU|LV|LY|MA|MC|MD|ME|MF|MG|MH|MK|ML|MM|MN|MO|MP|MQ|MR|MS|MT|MU|MV|MW|MX|MY|MZ|NA|NC|NE|NF|NG|NI|NL|NO|NP|NR|NU|NZ|OM|PA|PE|PF|PG|PH|PK|PL|PM|PN|PR|PS|PT|PW|PY|QA|RE|RO|RS|RU|RW|SA|SB|SC|SD|SE|SG|SH|SI|SJ|SK|SL|SM|SN|SO|SR|SS|ST|SV|SX|SY|SZ|TC|TD|TF|TG|TJ|TK|TL|TM|TN|TO|TR|TT|TV|TW|TZ|UA|UG|UM|US|UY|UZ|VA|VC|VE|VG|VI|VN|VU|WF|WS|YE|YT|ZA|ZM|ZW)[A-Z2-9][A-NP-Z0-9]([A-Z0-9]{3})?\b/g },
+    { type: 'FINANCIAL', regex: /\b\d{9}\b/g },
+    { type: 'FINANCIAL', regex: /\b[A-Z]{2}[0-9]{2}[a-zA-Z0-9]{4}[0-9]{7}[a-zA-Z0-9]{0,16}\b/g },
+    { type: 'FINANCIAL', regex: /\bPORTFOLIO[-_][A-Z0-9]{5,}\b/gi },
+    { type: 'FINANCIAL', regex: /\b(?:\d[ -]?){13,19}\b/g },
+    { type: 'FINANCIAL', regex: /\b(?:1|3|bc1)[a-zA-HJ-NP-Z0-9]{25,39}\b/g },
+    { type: 'FINANCIAL', regex: /\b0x[a-fA-F0-9]{40}\b/g },
+
+    // Legal & Court
+    { type: 'LEGAL', regex: /\bCASE[-_][A-Z0-9]{4,}\b/gi },
+    { type: 'LEGAL', regex: /\bMATTER[-_][A-Z0-9]{4,}\b/gi },
+    { type: 'LEGAL', regex: /\b[A-Z]{2,4}[- ]?\d{2}[- ]?\d{4,}\b/g },
+    { type: 'PRIVILEGE', regex: /ATTORNEY[- ]CLIENT[- ]PRIVILEGE/gi },
+
+    // Professional IDs
+    { type: 'ID', regex: /\bEEID[ -]?\d{4,}\b/gi },
+    { type: 'ID', regex: /\bRESUME[-_]?[A-Z0-9]{4,}\b/gi },
+    { type: 'ID', regex: /\bLEAD[-_][A-Z0-9]{5,}\b/gi },
+    { type: 'ID', regex: /\bCAMPAIGN[-_][A-Z0-9]{4,}\b/gi },
+    { type: 'ID', regex: /\bDEAL[-_][A-Z0-9]{4,}\b/gi },
+    { type: 'ID', regex: /\bENTITY[-_][0-9]{4,}\b/gi },
+    { type: 'ID', regex: /\bOPPORTUNITY[-_][A-Z0-9]{5,}\b/gi },
+    { type: 'ID', regex: /\bPROSPECT[-_][A-Z0-9]{5,}\b/gi },
+    { type: 'ID', regex: /\bTICKET[-_][A-Z0-9]{5,}\b/gi },
+    { type: 'ID', regex: /\bZENDESK[-_][0-9]{4,}\b/gi },
+    { type: 'ID', regex: /\bEMP[-_]\d{3,}\b/gi },
+    { type: 'ID', regex: /\bLIS[-]?\d{6,}\b/gi },
+    { type: 'ID', regex: /\bPARCEL[-]?\d{5,}\b/gi },
+    { type: 'ID', regex: /\bAGENT[-_][A-Z0-9]{4,}\b/gi },
+    { type: 'ID', regex: /\bTASK[-_][A-Z0-9]{5,}\b/gi },
+    { type: 'ID', regex: /\bSTUDENT[-_][0-9]{5,}\b/gi },
+    { type: 'ID', regex: /\bCOURSE[-_][A-Z0-9]{4,}\b/gi },
+    { type: 'ID', regex: /\bINSTANCE[-_]ID[-_][a-z0-9-]{10,}\b/gi },
+    { type: 'ID', regex: /\bENV[-_][A-Z0-9]{3,}\b/gi },
+    { type: 'PRIVACY', regex: /\bTENANT[-_]ID[-_][0-9]{4,}\b/gi },
+
+    // Addresses & Locations
+    { type: 'ADDRESS', regex: /\b\d{1,6}\s+(?:[A-Z][a-zA-Z0-9.-]*\s+){1,3}(?:St|Street|Ave|Avenue|Blvd|Boulevard|Rd|Road|Ln|Lane|Dr|Drive|Way|Ct|Court|Pl|Place|Terrace|Pkwy|Parkway|Sq|Square)\b/gi },
+    { type: 'LOCATION', regex: /\b[A-Z][a-zA-Z\s.-]{2,25},\s*[A-Z]{2}\b/g },
+
+
+    // PHI & Medical
+    { type: 'PHI', regex: /\bMRN[ -]?\d{6,}\b/gi },
+    { type: 'PHI', regex: /\b[A-TV-Z]\d{2}[. ]?\d[A-Z0-9]?\b/g },
+    { type: 'PHI', regex: /\b[A-Z]{2,3}\d{6,8}\b/g },
+    { type: 'PHI', regex: /\bNHS[ -]?\d{3}[ -]?\d{3}[ -]?\d{4}\b/gi },
+
+
+    // Copyrights
+    { type: 'COPYRIGHT', regex: /\bPROJECT[-_][A-Z0-9]{5,}\b/gi },
+    { type: 'COPYRIGHT', regex: /\b(DRAFT|ASSET|SCRIPT)[-_][0-9]{4,}\b/gi },
+
+    // General Privacy & Dates
+    { type: 'PRIVACY', regex: /\b(GDPR|HIPAA|CCPA|SOC2)[-_]AUDIT[-_]\d{4}\b/gi },
+    { type: 'PRIVACY', regex: /\bPOLICY[-_][A-Z0-9]{5,}\b/gi },
+    { type: 'PRIVACY', regex: /\bGRADE[S]?\s*:\s*[A-DF][+-]?\b/gi },
+    { type: 'PRIVACY', regex: /\b(DOB|BIRTHDAY)[:\s]*[0-9./-]{6,10}\b/gi },
+    { type: 'PRIVACY', regex: /\b(PASSWORD|PWD|SECRET)[:\s]*[\S]{4,}\b/gi },
+
+    // Standard IDs (SSN, EIN, Passport, VAT)
+    { type: 'ID', regex: /\b\d{3}-\d{2}-\d{4}\b/g },
+    { type: 'ID', regex: /(?:\/|[A-Za-z]:\\)[\w\-. ]+(?:[\/\\][\w\-. ]+)+/g },
+    { type: 'ID', regex: /\b[A-CEGHJ-PR-TW-Z]{1}[A-CEGHJ-NPR-TW-Z]{1}[0-9]{6}[A-DFM]{1}\b/gi },
+    { type: 'ID', regex: /\b[A-Z]{2}[0-9]{6,12}\b/gi },
+    { type: 'ID', regex: /[A-Z0-9<]{30,44}/g },
+    
+    // IT / Technical IDs
+    { type: 'IP', regex: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g },
+    { type: 'IP', regex: /\b(?:[a-fA-F0-9]{1,4}:){7}[a-fA-F0-9]{1,4}\b/g },
+    { type: 'ID', regex: /\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b/g },
+    { type: 'ID', regex: /(?:\B\/|\b[a-zA-Z]:\\)(?:[\w.-]+[\/\\]?)+\b/g },
+    { type: 'ID', regex: /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}(?::\d{2})?)?\b/g },
+    { type: 'ID', regex: /\b\d{4}-\d{2}-\d{2}\b/g },
+    { type: 'ID', regex: /\b\d{2}\/\d{2}\/\d{4}\b/g },
+
+    // Phone Numbers — must come after IDs to avoid ID rules stealing phone matches
+    { type: 'PHONE', regex: /\b(?:\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g },
+    { type: 'PHONE', regex: /(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]\d{3}[-.\s]\d{4}/g },
+    { type: 'PHONE', regex: /\+?[1-9]\d{1,3}[\s.-]\(?\d{1,4}\)?[\s.-]\d{2,4}[\s.-]\d{4}/g },
+    { type: 'PHONE', regex: /(?:\+44\s?7\d{3}|\(?07\d{3}\)?)\s?\d{3}\s?\d{3}\b/g },
+    { type: 'PHONE', regex: /\b(?:\d{3}[-.\s]\d{4}|\(\d{3}\)\s??\d{3}[-.\s]??\d{4}|\d{3}[-.\s]??\d{3}[-.\s]??\d{4})\b/g },
+    
+    // Geolocation (Lat/Long)
+    { type: 'LOCATION', regex: /\b-?\d{1,3}\.\d{4,6}[° ]?[NSns],\s*-?\d{1,3}\.\d{4,6}[° ]?[EWew]\b/g },
+    { type: 'LOCATION', regex: /\b(LATITUDE|LONGITUDE)[:\s]-?\d{1,3}\.\d{4,10}\b/gi },
+
+    // Driver Licenses & State IDs
+    { type: 'ID', regex: /\bDL[ -]?\d{6,12}\b/gi },
+    { type: 'ID', regex: /\bDRIVER[S]?\s+LICENSE[ -]?\d{6,15}\b/gi },
+
+    // Generalized Name Detection (First [Middle] Last) — max 1 middle word to avoid grabbing job titles
+    // Middle word must be: a particle (van/de/etc.), a single initial (A.), or a capitalized word of ≥2 lowercase letters
+    { type: 'NAME', isAggressiveName: true, regex: /(?<=^|[^\p{L}\p{N}_])\p{Lu}[\p{Ll}'-]*(?:\p{Lu}[\p{Ll}'-]*)?\p{L}(?:[ \t\xA0]+(?:\p{Lu}[\p{Ll}'-]{1,}(?:\p{Lu}[\p{Ll}'-]*)?\p{L}|\p{Lu}\.?|van|von|de|di|da|la|le|del|du|der|van[ \t\xA0]+de)){0,1}[ \t\xA0]+\p{Lu}[\p{Ll}'-]*(?:\p{Lu}[\p{Ll}'-]*)?\p{L}(?:'s)?(?=[^\p{L}\p{N}_]|$)(?![ \t\xA0]*:)/gu },
+    // All-Caps Names (2–3 words, each ≥3 chars) — prevents acronym chains like "GPA ROI AUM" (Unicode-safe)
+    { type: 'NAME', regex: /(?<=^|[^\p{L}\p{N}_])\p{Lu}{3,}(?:[\p{Lu}'-]*\p{Lu})?(?:[ \t\xA0]+\p{Lu}{3,}(?:[\p{Lu}'-]*\p{Lu})?){1,2}(?:'s)?(?=[^\p{L}\p{N}_]|$)(?![ \t\xA0]*:)/gu },
+    // ALL-CAPS first + optional middle initial(s) with optional spaces + ALL-CAPS last name
+    // E.g. "KKKKK I. MMMMMM", "KKKKK I.MMMMMM", "KKKKKI.MMMMMM" (PDF extraction spacing anomalies)
+    { type: 'NAME', regex: /(?<=^|[^\p{L}\p{N}_])\p{Lu}{2,}(?:[\p{Lu}'-]*\p{Lu})?(?:(?:[ \t\xA0]*\p{Lu}\.)+[ \t\xA0]*|[ \t\xA0]+)\p{Lu}{2,}(?:[\p{Lu}'-]*\p{Lu})?(?:'s)?(?=[^\p{L}\p{N}_]|$)(?![ \t\xA0]*:)/gu },
+    // ALL-CAPS first name + optional middle initial(s) with optional spaces + Mixed-Case last name
+    // E.g. "JOSEPH I. Casalvieri", "JOSEPH I.Casalvieri", "JOSEPHI.Casalvieri" (PDF extraction spacing anomalies)
+    { type: 'NAME', regex: /(?<=^|[^\p{L}\p{N}_])\p{Lu}{2,}(?:[\p{Lu}'-]*\p{Lu})?(?:(?:[ \t\xA0]*\p{Lu}\.)+[ \t\xA0]*|[ \t\xA0]+)\p{Lu}\p{Ll}[\p{Ll}'-]*(?:\p{Lu}[\p{Ll}'-]*)?\p{L}(?:'s)?(?=[^\p{L}\p{N}_]|$)(?![ \t\xA0]*:)/gu },
+    // Single-Word Names with Honorifics (with or without period) (Unicode-safe)
+    { type: 'NAME', regex: /(?<=^|[^\p{L}\p{N}_])(?:Mr|Mrs|Ms|Dr|Prof|Hon|Mr\.|Mrs\.|Ms\.|Dr\.|Prof\.|Hon\.)[ \t\xA0]+\p{Lu}[\p{Ll}'-]*(?:\p{Lu}[\p{Ll}'-]*)?\p{L}(?=[^\p{L}\p{N}_]|$)(?![ \t\xA0]*:)/gu },
+    
+    // Contextual Names (Emergency Contacts, Spouses, Children, Tenants, etc.) - Uses capture group m[1]
+    { type: 'NAME', isContextName: true, regex: /(?:Emergency Contact|Contact(?: Name)?|Spouse|Child|Parent|Guardian|Relationship|Kin|Tenant|Landlord|Buyer|Seller|Plaintiff|Defendant|Testator)[\s:]+([A-Z][a-z]*(?:\s+[A-Z][a-z]*)?)/g }
+];
+
+let PROFILE_RULES = {
+    general: [],
+    legal: [
+        { type: 'LEGAL', regex: /\bCASE[-_][A-Z0-9]{4,}\b/gi },
+        { type: 'LEGAL', regex: /\bMATTER[-_][A-Z0-9]{4,}\b/gi },
+        { type: 'LEGAL', regex: /\b[A-Z]{2,4}[- ]?\d{2}[- ]?\d{4,}\b/g },
+        { type: 'PRIVILEGE', regex: /ATTORNEY[- ]CLIENT[- ]PRIVILEGE/gi }
+    ],
+    hr: [
+        { type: 'NAME', isContextName: true, regex: /(?:Candidate|Applicant|Employee|Reporting To|Manager)[\s:]+([A-Z][a-z]*(?:\s+[A-Z][a-z]*)?)/g },
+        
+        { type: 'ID', regex: /\bEEID[ -]?\d{4,}\b/gi },
+        { type: 'ID', regex: /\bEMP[-_]\d{3,}\b/gi },
+        { type: 'ID', regex: /\bRESUME[-_]?[A-Z0-9]{4,}\b/gi },
+        { type: 'PRIVACY', regex: /\\b(DOB|BIRTHDAY)[:\\s]*[0-9./-]{6,10}\\b/gi },
+        { type: 'ADDRESS', regex: /\\b\\d{1,6}\\s+(?:[A-Z][a-zA-Z0-9.-]*\\s+){1,3}(?:St|Street|Ave|Avenue|Blvd|Boulevard|Rd|Road|Ln|Lane|Dr|Drive|Way|Ct|Court|Pl|Place|Terrace|Pkwy|Parkway|Sq|Square)\\b/gi }
+    ],
+    finance: [
+        { type: 'FINANCIAL', regex: /\b[A-Z]{4}(?:AD|AE|AF|AG|AI|AL|AM|AO|AQ|AR|AS|AT|AU|AW|AX|AZ|BA|BB|BD|BE|BF|BG|BH|BI|BJ|BL|BM|BN|BO|BQ|BR|BS|BT|BV|BW|BY|BZ|CA|CC|CD|CF|CG|CH|CI|CK|CL|CM|CN|CO|CR|CU|CV|CW|CX|CY|CZ|DE|DJ|DK|DM|DO|DZ|EC|EE|EG|EH|ER|ES|ET|FI|FJ|FK|FM|FO|FR|GA|GB|GD|GE|GF|GG|GH|GI|GL|GM|GN|GP|GQ|GR|GS|GT|GU|GW|GY|HK|HM|HN|HR|HT|HU|ID|IE|IL|IM|IN|IO|IQ|IR|IS|IT|JE|JM|JO|JP|KE|KG|KH|KI|KM|KN|KP|KR|KW|KY|KZ|LA|LB|LC|LI|LK|LR|LS|LT|LU|LV|LY|MA|MC|MD|ME|MF|MG|MH|MK|ML|MM|MN|MO|MP|MQ|MR|MS|MT|MU|MV|MW|MX|MY|MZ|NA|NC|NE|NF|NG|NI|NL|NO|NP|NR|NU|NZ|OM|PA|PE|PF|PG|PH|PK|PL|PM|PN|PR|PS|PT|PW|PY|QA|RE|RO|RS|RU|RW|SA|SB|SC|SD|SE|SG|SH|SI|SJ|SK|SL|SM|SN|SO|SR|SS|ST|SV|SX|SY|SZ|TC|TD|TF|TG|TJ|TK|TL|TM|TN|TO|TR|TT|TV|TW|TZ|UA|UG|UM|US|UY|UZ|VA|VC|VE|VG|VI|VN|VU|WF|WS|YE|YT|ZA|ZM|ZW)[A-Z2-9][A-NP-Z0-9]([A-Z0-9]{3})?\b/g },
+        { type: 'FINANCIAL', regex: /\b[A-Z]{2}[0-9]{2}[a-zA-Z0-9]{4}[0-9]{7}[a-zA-Z0-9]{0,16}\b/g },
+        { type: 'FINANCIAL', regex: /\bPORTFOLIO[-_][A-Z0-9]{5,}\b/gi }
+    ],
+    medical: [
+        { type: 'PHI', regex: /\b(?:MRN|Patient ID|Medical Record No|Patient No)[\s:#]*([A-Za-z0-9-]+)/gi },
+        { type: 'PRIVACY', regex: /\b(DOB|Date of Birth)[:\s]*[0-9./-]{6,10}\b/gi },
+        
+        { type: 'PHI', regex: /\bMRN[ -]?\d{6,}\b/gi },
+        { type: 'PHI', regex: /\b[A-TV-Z]\d{2}[. ]?\d[A-Z0-9]?\b/g },
+        { type: 'PHI', regex: /\b[A-Z]{2,3}\d{6,8}\b/g },
+        { type: 'PHI', regex: /\bNHS[ -]?\d{3}[ -]?\d{3}[ -]?\d{4}\b/gi }
+    ],
+    security: [
+        { type: 'SECRET', regex: /\b(?:INCIDENT|BREACH)[-_: ]?ID[-_: ]?[0-9]{4,10}\b/gi }
+    ],
+    marketing: [
+        { type: 'ID', regex: /\b(?:LEAD|PROSPECT)[-_: ]*[A-Z0-9_-]*[0-9][A-Z0-9_-]*\b/gi },
+        { type: 'ID', regex: /\b(?:CAMPAIGN|CLID|GCLID|FBCLID)[-_:=]*[A-Za-z0-9_-]{10,}\b/gi },
+        { type: 'FINANCIAL', regex: /(?<=\b(?:LTV|CAC)[\s:]*)(?:[$€£¥₪₽₹]|(?:USD|EUR|GBP|CHF|ILS|RUB)\s?)[0-9,.]+\b/gi },
+        { type: 'ID', regex: /\b(?:SEGMENT|COHORT)[-_: ]*[0-9]{4,8}\b/gi }
+    ],
+    bizops: [
+        { type: 'ID', regex: /\b(?:DEAL|KPI|METRIC)[-_: ]?[A-Z0-9]{4,}\b/gi },
+        { type: 'ID', regex: /\b(?:ENTITY|VENDOR|PARTNER)[-_: ]?[0-9]{4,10}\b/gi },
+        { type: 'FINANCIAL', regex: /\b(?:REVENUE|EBITDA|PROFIT|MARGIN)[-_: ]?(?:[$€£¥₪₽₹]|(?:USD|EUR|GBP|CHF|ILS|RUB)\s?)?[0-9,.]+[KM]?\b/gi },
+        { type: 'SECRET', regex: /\b(?:NDA|M&A|MERGER)[-_: ]?[A-Z0-9]{4,}\b/gi }
+    ],
+    sales: [
+        { type: 'ID', regex: /\bOPPORTUNITY[-_: ]?[A-Z0-9]{5,}\b/gi },
+        { type: 'ID', regex: /\b(?:DOCUSIGN|CONTRACT)[-_: ]?[0-9A-F]{8,32}\b/gi },
+        { type: 'FINANCIAL', regex: /\b(?:ARR|MRR|QUOTA)[\s:]?(?:[$€£¥₪₽₹]|(?:USD|EUR|GBP|CHF|ILS|RUB)\s?)?[0-9,.]+[KM]?\b/gi },
+        { type: 'ID', regex: /\b(?:SFDC|HUBSPOT)[-_: ]?[0-9A-Z]{15,18}\b/gi }
+    ],
+    support: [
+        { type: 'ID', regex: /\bTICKET[-_:# ]?[A-Z0-9]{5,10}\b/gi },
+        { type: 'ID', regex: /\b(?:ZENDESK|INTERCOM|JIRA)[-_:# ]?[0-9]{4,10}\b/gi },
+        { type: 'ID', regex: /\b(?:REFUND|RETURN|RMA)[-_:# ]?[A-Z0-9]{6,12}\b/gi },
+        { type: 'ID', regex: /\b(?:LOYALTY|REWARDS)[-_:# ]?\d{8,12}\b/gi }
+    ],
+    realestate: [
+        { type: 'ID', regex: /\b(?:MLS|LIS)[- ]?\d{6,10}\b/gi },
+        { type: 'ID', regex: /\bPARCEL[- ]?\d{5,15}\b/gi },
+        { type: 'ID', regex: /\bTENANT[-_]ID[-_][0-9]{4,}\b/gi },
+        { type: 'FINANCIAL', regex: /\b(?:RENT|LEASE|ESCROW)[\s:]?(?:[$€£¥₪₽₹]|(?:USD|EUR|GBP|CHF|ILS|RUB)\s?)[0-9,]{3,}\b/gi },
+        { type: 'SECRET', regex: /\b(?:GATE|DOOR|LOBBY)[-_ ](?:CODE|PIN)[\s:]?\d{4,6}\b/gi }
+    ],
+    compliance: [
+        { type: 'SECRET', regex: /\b(?:GDPR|HIPAA|CCPA|SOC2|ISO27001)[-_: ]?AUDIT[-_: ]?\d{4}\b/gi },
+        { type: 'SECRET', regex: /\b(?:DPA|POLICY)[-_: ]?[A-Z0-9]{5,15}\b/gi },
+        { type: 'ID', regex: /\b(?:SAR|DSAR)[-_\/: ]?[A-Z0-9-/]+\b/gi }
+    ],
+    ccpa: [
+        { type: 'ID', regex: /\bDL[ -]?\d{6,12}\b/gi },
+        { type: 'LOCATION', regex: /\b-?\d{1,3}\.\d{4,6}[° ]?[NSns],\s*-?\d{1,3}\.\d{4,6}[° ]?[EWew]\b/g },
+        { type: 'PRIVACY', regex: /\b(?:CCPA|CPRA)[-_: ]?OPT[-_ ]OUT\b/gi },
+        { type: 'ID', regex: /\bACCOUNT[ -]?(?:ID|NUM|NUMBER)[:\s][A-Z0-9]{6,20}\b/gi }
+    ],
+    engineering: [
+        { type: 'SECRET', regex: /(?<=\b(?:DB|POSTGRES|REDIS|MYSQL|AWS|SECRET|PASSWORD|TOKEN|API|KEY)[A-Z0-9_]*\s*[:=]\s*["']?)[A-Za-z0-9_-]{10,}/gi },
+        { type: 'ID', regex: /\b[a-z0-9._-]+\/[a-z0-9._-]+:[a-z0-9._-]+\b/g },
+        { type: 'ID', regex: /\b[a-fA-F0-9]{40}\b/g },
+        { type: 'ID', regex: /\b[a-z0-9](?:[-a-z0-9]*[a-z0-9])?\.svc\.cluster\.local\b/g }
+    ],
+    agents: [
+        { type: 'ID', regex: /\b(?:AGENT|VECTOR|EMBEDDING)[-_: ]?[A-Z0-9]{8,}\b/gi },
+        { type: 'ID', regex: /\bTASK[-_: ]?[A-Z0-9]{5,15}\b/gi },
+        { type: 'SECRET', regex: /\b(?:SYS_PROMPT|SYSTEM_PROMPT|OPENAI_API_KEY)[-_: ]?[A-Za-z0-9_-]{10,}\b/gi }
+    ],
+    academic: [
+        { type: 'ID', regex: /\b(?:STUDENT|ALUMNI)[-_:# ]?[0-9]{5,10}\b/gi },
+        { type: 'ID', regex: /\bCOURSE[-_:# ]?[A-Z]{3,4}[ ]?[0-9]{3,4}\b/gi },
+        { type: 'ID', regex: /\b(?:FERPA|IRB)[-_:# ]?[A-Z0-9]{5,10}\b/gi },
+        { type: 'ID', regex: /\bGRADE[S]?[\s:][A-DF][+-]?\b/gi }
+    ],
+    creative: [
+        { type: 'SECRET', regex: /\b(?:PROJECT|DRAFT|ASSET|SCRIPT|IP)[-_: ]?[0-9]{4,10}\b/gi },
+        { type: 'SECRET', regex: /\b(?:SPOILER|UNRELEASED|EMBARGOED)\b/gi },
+        { type: 'NAME', regex: /\b(?:GHOSTWRITER|SOURCE)[:\s][A-Z][a-z]+ [A-Z][a-z]+\b/g }
+    ],
+    tech: [
+        { type: 'ID', regex: /\b(?:INSTANCE|NODE|CLUSTER)[-_]ID[-_][a-z0-9-]{10,}\b/gi },
+        { type: 'ID', regex: /\bENV[-_: ]?(?:PROD|STAGING|DEV|TEST|QA)\b/gi },
+        { type: 'SECRET', regex: /\b(?:CONFIG|KUBECONFIG|TFSTATE)[-_: ]?[A-Z0-9]{6,15}\b/gi }
+    ],
+    personal: [
+        { type: 'ID', regex: /\b(?:DOB|BIRTHDAY)[\s:]*[0-9./-]{6,10}\b/gi },
+        { type: 'SECRET', regex: /\b(?:PASSWORD|PWD|SECRET|PIN)[\s:]*[\S]{4,20}\b/gi },
+        { type: 'PHONE', regex: /\b(?:WIFE|HUSBAND|PARTNER|MOM|DAD)[\s:]+(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]\d{3}[-.\s]\d{4}\b/gi }
+    ],
+    wealthmgmt: [
+        { type: 'LEGAL', regex: /\b(?:THE\s+)?[A-Z][A-Z\s.'-]{4,}\s+(?:(?:REVOCABLE|IRREVOCABLE|LIVING|FAMILY|TESTAMENTARY|CHARITABLE|GENERATION-SKIPPING)\s+)*TRUST\b/g },
+        // Mixed-Caps name: All-Caps first name (3+ chars) + optional initials + Mixed-Case last name
+        // Handles PDF-rendered trust names where OCR/extraction produces e.g. "KKKKK I. Mmmmmmm"
+        { type: 'NAME', regex: /(?<=^|[^\p{L}\p{N}_])\p{Lu}{3,}(?:[\p{Lu}'-]*\p{Lu})?(?:[ \t\xA0]+\p{Lu}\.)*[ \t\xA0]+\p{Lu}\p{Ll}[\p{Ll}'-]*(?:\p{Lu}[\p{Ll}'-]*)?\p{L}(?:'s)?(?=[^\p{L}\p{N}_]|$)/gu },
+        { type: 'FINANCIAL', regex: /\b(?:ABA|Routing(?:\s+No)?|RTN)[:\s#]*\d{9}\b/gi },
+        { type: 'FINANCIAL', regex: /\b(?:Account|Acct\.?)[:\s#]*\d{4}[-\s]?\d{4}[-\s]?\d{2,6}\b/gi },
+        { type: 'FINANCIAL', regex: /\b(?:Policy|Contract)\s*(?:No\.?|Number|#)[:\s]+[A-Z0-9][A-Z0-9\-]{3,14}\b/gi },
+        { type: 'ID', regex: /\bCRD\s*#?\s*\d{4,8}\b/gi },
+        { type: 'FINANCIAL', regex: /\b(?:Annual\s+(?:Distribution|Withdrawal)|RMD|Required\s+Minimum\s+Distribution)[:\s]+(?:[$€£¥₪₽₹]|(?:USD|EUR|GBP|CHF|ILS|RUB)\s?)[\d,]+(?:[.][\d]{2})?\b/gi },
+        { type: 'FINANCIAL', regex: /\b(?:Portfolio|Market\s+Value|Net\s+Worth|AUM|Total\s+Assets)[:\s]+(?:[$€£¥₪₽₹]|(?:USD|EUR|GBP|CHF|ILS|RUB)\s?)[\d,.]+[KMB]?\b/gi },
+        { type: 'FINANCIAL', regex: /\b(?:Roth\s+)?(?:IRA|401k|401\(k\)|403b|403\(b\)|SEP|SIMPLE)\s*(?:Account|Acct|Plan)?\s*(?:No|Number|#)?[:\s#]*[A-Z0-9]{4,15}\b/gi }
+    ],
+    insurance: [
+        { type: 'ID', regex: /\b(?:Claim|CLM)[:\s#-]*[A-Z0-9]{6,15}\b/gi },
+        { type: 'ID', regex: /\b(?:Policy|POL)[:\s#-]*[A-Z]{0,4}[-]?\d{6,12}\b/gi },
+        { type: 'FINANCIAL', regex: /\b(?:Loss|Claim\s+Amount|Settlement|Reserve|Indemnity)[:\s]+(?:[$€£¥₪₽₹]|(?:USD|EUR|GBP|CHF|ILS|RUB)\s?)[\d,]+(?:[.]\d{2})?\b/gi },
+        { type: 'ID', regex: /\b(?:Adjuster\s+(?:ID|No)|Claim\s+Rep(?:\.|resentative)?)[:\s#]*[A-Z0-9]{4,12}\b/gi },
+        { type: 'ID', regex: /\bNAIC[:\s#]*\d{5}\b/gi },
+        { type: 'FINANCIAL', regex: /\b(?:Deductible|Premium|Coverage\s+Amount)[:\s]+(?:[$€£¥₪₽₹]|(?:USD|EUR|GBP|CHF|ILS|RUB)\s?)[\d,]+(?:[.]\d{2})?\b/gi },
+        { type: 'ID', regex: /\b[A-HJ-NPR-Z0-9]{17}\b/g },
+        { type: 'ID', regex: /\b(?:Insured|Named\s+Insured)[:\s]+[A-Z][a-z]+(?:\s+[A-Z][a-z]+)+/g },
+        { type: 'ID', regex: /\b(?:Agent|Producer)\s*(?:Code|No|ID)[:\s#]*[A-Z0-9]{4,12}\b/gi }
+    ],
+    accounting: [
+        { type: 'ID', regex: /\b(?:EIN|FEIN|Tax\s+ID)[:\s#]*\d{2}-\d{7}\b/gi },
+        { type: 'FINANCIAL', regex: /\b(?:AGI|Adjusted\s+Gross\s+Income|Taxable\s+Income|Total\s+Income)[:\s]+(?:[$€£¥₪₽₹]|(?:USD|EUR|GBP|CHF|ILS|RUB)\s?)[\d,]+(?:[.]\d{2})?\b/gi },
+        { type: 'FINANCIAL', regex: /\bBox\s+\d{1,2}[a-z]?[:\s]+(?:[$€£¥₪₽₹]|(?:USD|EUR|GBP|CHF|ILS|RUB)\s?)[\d,]+(?:[.]\d{2})?\b/gi },
+        { type: 'ID', regex: /\b(?:Form|Schedule)\s+(?:1040|1040-SR|W-2|W-4|1099-[A-Z]{1,4}|K-1|941|990|4562)\b/gi },
+        { type: 'FINANCIAL', regex: /\b(?:Federal|State)\s+(?:Tax\s+)?(?:Refund|Amount\s+Owed|Balance\s+Due)[:\s]+(?:[$€£¥₪₽₹]|(?:USD|EUR|GBP|CHF|ILS|RUB)\s?)[\d,]+(?:[.]\d{2})?\b/gi },
+        { type: 'ID', regex: /\b(?:State\s+Tax\s+ID|SUI|UI\s+Account\s+No)[:\s#]*[A-Z]{0,3}[-]?\d{4,15}\b/gi },
+        { type: 'FINANCIAL', regex: /\b(?:Net\s+Pay|Gross\s+Pay|Taxable\s+Wages)[:\s]+(?:[$€£¥₪₽₹]|(?:USD|EUR|GBP|CHF|ILS|RUB)\s?)[\d,]+(?:[.]\d{2})?\b/gi },
+        { type: 'ID', regex: /\b(?:CAF|Practitioner\s+(?:PIN|ID)|PTIN)[:\s#]*[A-Z]?\d{6,9}\b/gi }
+    ],
+    pharma: [
+        { type: 'ID', regex: /\b(?:Subject|Patient|Participant)\s+(?:ID|No)[:\s#]*[A-Z0-9]{3,12}\b/gi },
+        { type: 'ID', regex: /\b(?:Protocol|Study)\s*(?:No|Number|ID)[:\s#]*[A-Z0-9][-A-Z0-9]{3,15}\b/gi },
+        { type: 'ID', regex: /\b(?:IND|NDA|BLA|ANDA)\s*(?:No|Number|#)?[:\s]*\d{3,6}\b/gi },
+        { type: 'ID', regex: /\bIRB[:\s#]*[A-Z0-9]{4,12}\b/gi },
+        { type: 'ID', regex: /\b(?:Site\s+(?:No|ID)|Investigator\s+Site)[:\s#]*\d{3,6}\b/gi },
+        { type: 'ID', regex: /\b(?:Batch|Lot|Serial)\s*(?:No[.]?|Number|#)?[:\s#]*[A-Z0-9][A-Z0-9\-]{3,14}\b/gi },
+        { type: 'PHI', regex: /\b(?:Dose|Dosage)[:\s]+\d+(?:\.\d+)?\s*(?:mg|mcg|mL|IU|units?)\b/gi },
+        { type: 'ID', regex: /\b(?:CRF|eCRF|Case\s+Report\s+Form)\s*(?:No|Page|ID)?[:\s#]*[A-Z0-9]{2,10}\b/gi }
+    ]
+};
+
+let NAME_STOP_LIST = new Set([
+    'case no', 'account no', 'client no', 'ref no', 'matter no',
+    'affected user', 'incident date', 'incident type', 'incident report',
+    'review period', 'review date', 'salary band', 'salary range',
+    'personal email', 'work email', 'business email',
+    'lead source', 'account exec', 'account executive',
+    'next appt', 'next appointment', 'last appt', 'chief complaint',
+    'portfolio value', 'portfolio manager',
+    'tax id', 'account number', 'employee id', 'social security',
+    'date of', 'date of birth', 'place of birth',
+    'hiring manager', 'direct report', 'team lead', 'team leader',
+    'job title', 'job function', 'pay grade',
+    'review type', 'performance review', 'annual review',
+    'invoice number', 'purchase order', 'order number',
+    'oak street', 'main street', 'high street', 'park avenue',
+    'first street', 'second street', 'third street',
+    'north avenue', 'south avenue', 'east side', 'west side',
+    'soc team', 'hr team', 'it team', 'qa team', 'ux team',
+    'new york', 'los angeles', 'san francisco', 'las vegas',
+    'united states', 'united kingdom', 'north america', 'south america',
+    'senior analyst', 'senior engineer', 'senior manager', 'senior consultant',
+    'junior analyst', 'junior engineer', 'junior developer',
+    'vice president', 'chief executive', 'chief officer',
+    'account manager', 'project manager', 'product manager',
+    'security officer', 'compliance officer',
+    'general hospital', 'medical center', 'urgent care', 'primary care',
+    'read more', 'learn more', 'click here', 'sign up', 'log in',
+    'privacy policy', 'terms of', 'terms of service',
+    'true positive', 'false positive', 'open source',
+    'private identifiers', 'data privacy', 'system instruction', 'system instructions', 'critical', 'instruction',
+    'user data', 'protected user', 'privacy scrubber', 'end of',
+    'thank you', 'best regards', 'kind regards', 'warm regards', 'yours truly', 'sincerely yours', 'good morning', 'good afternoon', 'good evening', 'hello world', 'hello there',
+    'supreme court', 'high court', 'district court', 'civil court', 'non disclosure', 'data protection', 'intellectual property', 'trade secret', 'force majeure', 'habeas corpus', 'amicus curiae', 'board member', 'board meeting', 'general assembly',
+    'first name', 'last name', 'middle name', 'full name', 'email address', 'phone number', 'cell phone', 'home phone', 'zip code', 'postal code', 'page number', 'section one', 'table contents', 'table of', 'figure one',
+    'marketing department', 'sales department', 'engineering team', 'product team', 'customer support', 'human resources', 'public relations',
+    'artificial intelligence', 'machine learning', 'deep learning', 'large language', 'operating system', 'source code', 'user interface', 'web browser', 'pull request', 'merge request', 'commit message', 'code review', 'cloud computing', 'database schema',
+    'blood pressure', 'heart rate', 'chief physician', 'treating physician', 'health care', 'healthcare provider', 'medical record',
+    'grade a', 'grade b', 'grade c', 'grade d', 'grade f',
+    'version 1', 'version 2', 'version 3', 'version 4', 'version 5',
+    'step 1', 'step 2', 'step 3', 'step 4', 'step 5',
+    'page 1', 'page 2', 'page 3', 'page 4', 'page 5',
+    'cs101', 'course cs101',
+    // Expanded Stop List (Common nouns that look like names)
+    'january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december',
+    'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday',
+    'yesterday', 'tomorrow', 'today', 'last week', 'next month', 'early morning', 'late night',
+    'microsoft office', 'google workspace', 'slack channel', 'zoom meeting', 'teams call',
+    'amazon prime', 'netflix show', 'youtube video', 'twitter post', 'linkedin profile',
+    'central park', 'white house', 'grand canyon', 'mount everest', 'pacific ocean', 'atlantic ocean',
+    'silicon valley', 'wall street', 'fifth avenue', 'times square', 'golden gate', 'empire state',
+    'statue liberty', 'tower bridge', 'big ben', 'eiffel tower', 'great wall',
+    'london bridge', 'san jose', 'las vegas', 'mexico city', 'hong kong', 'san diego',
+    'software development', 'user experience', 'front end', 'back end', 'full stack',
+    'web application', 'mobile app', 'desktop app', 'cloud services', 'data analytics',
+    'cyber security', 'network security', 'information security', 'incident response',
+    'disaster recovery', 'business continuity', 'risk management', 'quality assurance',
+    'user acceptance', 'beta test', 'release candidate', 'version control', 'continuous integration',
+    'continuous deployment', 'agile scrum', 'kanban board', 'sprint planning', 'daily standup',
+    'product backlog', 'user story', 'acceptance criteria', 'technical debt', 'codebase',
+    'repository', 'branch name', 'tag version', 'hot fix', 'patch note',
+    'legal counsel', 'general counsel', 'human capital', 'talent acquisition',
+    'employee benefits', 'payroll services', 'stock options', 'health insurance',
+    'retirement plan', 'vacation time', 'sick leave', 'performance bonus',
+    'commission structure', 'sales target', 'market share', 'brand identity',
+    'marketing campaign', 'ad spend', 'click rate', 'conversion rate',
+    'customer lifetime', 'churn rate', 'user engagement', 'social media',
+    'content strategy', 'search engine', 'local search', 'organic traffic',
+    'paid search', 'email marketing', 'press release', 'case study',
+    'white paper', 'user guide', 'help center', 'frequently asked',
+    'support ticket', 'service level', 'response time', 'resolution time',
+    'customer satisfaction', 'net promoter', 'user feedback', 'product feature',
+    'roadmap item', 'beta program', 'early access', 'invite only',
+    'project status', 'meeting notes', 'call transcript', 'action items', 'follow up', 'best practices', 'success stories',
+    'class name', 'function name', 'variable name', 'database table', 'schema name', 'index name', 'query result', 'error message', 'warning message', 'log entry', 'debug log', 'stack trace',
+    'staff member', 'team member', 'board member', 'board meeting', 'committee member', 'executive board',
+    'email us', 'contact us', 'about us', 'sign in', 'sign out',
+    'lighting', 'keyboard', 'creating', 'building', 'training', 'planning', 'starting', 'painting', 'printing', 'returned', 'released', 'required', 'accepted', 'imported', 'services', 'products', 'accounts', 'settings', 'partners', 'keywords', 'keystone', 'keyspace', 'keynotes', 'keychain'
+, 'quarterly results', 'strategic planning', 'market research', 'customer base', 'privacy settings', 'account settings', 'security settings', 'download now', 'free trial', 'limited time', 'copyright protected', 'all rights', 'rights reserved', 'credit score', 'monthly rent', 'lease application', 'property address', 'reference number', 'additional identifier', 'lease agreement', 'hiring review', 'candidate name', 'privacy policy', 'terms of service', 'machine learning', 'artificial intelligence', 'generative ai', 'silicon valley', 'google cloud', 'amazon web', 'data science', 'operating system', 'software engineer', 'product manager', 'project manager', 'data analyst', 'gross margin', 'revenue growth', 'source code', 'version control', 'large language model']);
+
+let JARGON_WORDS = new Set(['step', 'page', 'grade', 'version', 'course', 'class', 'follow', 'chapter', 'lesson', 'unit', 'marketing', 'manager', 'specialist', 'science', 'administration', 'university', 'skills', 'leadership', 'communication', 'working', 'proficiency', 'decision', 'driven', 'experience', 'summary', 'bachelor', 'ads', 'solutions', 'positioning', 'acquisition', 'strategy', 'research', 'database', 'forecast', 'interest', 'prepared', 'merchant', 'document', 'feedback', 'template', 'campaign', 'partners', 'settings', 'keystone', 'llm', 'gpt', 'chatgpt', 'openai', 'anthropic', 'claude', 'gemini', 'api', 'json', 'xml', 'html', 'css', 'javascript', 'python', 'policy', 'terms', 'conditions', 'release', 'sprint', 'deployment', 'cluster', 'instance', 'package', 'module', 'revenue', 'margin', 'gross', 'quarter', 'system', 'code', 'data', 'cloud', 'server', 'database', 'artificial', 'intelligence', 'learning', 'generative']);
+
+let NOT_NAME_WORDS = new Set([
+    // Grammatical & Sentence Starters
+    'the', 'a', 'an', 'this', 'that', 'these', 'those', 'my', 'your', 'his', 'her', 'their', 'our', 'its', 'it', 'he', 'she', 'they', 'we', 'i', 'you', 'who', 'whom', 'which', 'what', 'whose', 'why', 'how', 'when', 'where', 'with', 'for', 'from', 'by', 'to', 'at', 'in', 'on', 'of', 'about', 'as', 'into', 'through', 'during', 'before', 'after', 'above', 'below', 'and', 'but', 'or', 'so', 'yet',
+    // Greetings & Salutations
+    'hello', 'hi', 'hey', 'dear', 'greetings',
+    // Document & Resume Structure
+    'summary', 'experience', 'education', 'skills', 'languages', 'project', 'history', 'background', 'objective', 'profile', 'awards', 'honors', 'certifications', 'publications', 'interests', 'references',
+    // Business & Job Roles
+    'manager', 'director', 'specialist', 'analyst', 'engineer', 'developer', 'consultant', 'officer', 'representative', 'agent', 'lead', 'leader', 'president', 'coordinator', 'admin', 'administrator', 'executive', 'founder', 'partner', 'intern', 'trainee', 'advisor', 'head', 'vp', 'chief',
+    // Departments & Fields
+    'marketing', 'sales', 'engineering', 'finance', 'accounting', 'legal', 'operations', 'support', 'recruiting', 'talent', 'acquisition', 'compliance', 'security', 'technical', 'development', 'product', 'design', 'creative', 'strategy', 'planning', 'analytics', 'science', 'business', 'administration',
+    // Tools & Tech Concepts
+    'google', 'ads', 'analytics', 'meta', 'hubspot', 'crm', 'salesforce', 'wordpress', 'mailchimp', 'adobe', 'figma', 'canva', 'slack', 'zoom', 'teams', 'microsoft', 'office', 'excel', 'word', 'powerpoint', 'notion', 'jira', 'confluence', 'github', 'gitlab', 'aws', 'azure', 'cloud', 'database', 'sql', 'python', 'java', 'javascript', 'html', 'css', 'react', 'node', 'api', 'saas', 'b2b', 'b2c', 'url', 'domain', 'website', 'app', 'application', 'software', 'email', 'phone', 'contact', 'address',
+
+    // General Academic & Professional vocabulary
+    'bachelor', 'master', 'doctor', 'associate', 'degree', 'university', 'college', 'school', 'institute', 'academy', 'graduated', 'major', 'minor', 'gpa', 'cum', 'laude', 'honors', 'deans', 'list', 'scholarship',
+    // Quality & Adjectives
+    'results', 'driven', 'oriented', 'expert', 'professional', 'proven', 'track', 'record', 'creative', 'excellent', 'communication', 'verbal', 'written', 'native', 'fluent', 'bilingual', 'working', 'proficiency', 'strategic', 'interpersonal', 'teamwork', 'organizational', 'detail', 'analytical',
+    // Common Resume / Business Phrases
+    'results-driven', 'data-driven', 'customer-centric', 'detail-oriented', 'cross-functional', 'self-motivated', 'time-management', 'problem-solving', 'fast-paced', 'year-over-year',
+    // Legal & Trust terms
+    'trust', 'trustee', 'co-trustee', 'settlor', 'grantor', 'beneficiary', 'agreement', 'will', 'estate', 'witness', 'declaration', 'signatory', 'testator', 'notary', 'commission', 'county', 'state', 'court', 'article', 'section', 'paragraph', 'schedule', 'exhibit', 'amendment', 'addendum', 'power', 'attorney', 'guardian', 'executor', 'administrator', 'survivor', 'predecessor', 'successor', 'whereof', 'hereby', 'thereby', 'herein', 'therein', 'witnesseth', 'whereas', 'therefore', 'now', 'dated', 'effective',
+    // US States
+    'california', 'texas', 'florida', 'york', 'illinois', 'pennsylvania', 'ohio', 'georgia', 'michigan', 'carolina', 'virginia', 'washington', 'arizona', 'massachusetts', 'tennessee', 'indiana', 'maryland', 'missouri', 'wisconsin', 'colorado', 'minnesota', 'alabama', 'louisiana', 'kentucky', 'oregon', 'oklahoma', 'connecticut', 'utah', 'iowa', 'nevada', 'arkansas', 'mississippi', 'kansas', 'new mexico', 'nebraska', 'idaho', 'hawaii', 'maine', 'new hampshire', 'rhode island', 'montana', 'delaware', 'south dakota', 'north dakota', 'alaska', 'vermont', 'wyoming'
+, 'f.3d', 'f.supp', 'u.s.c.', 'v.', 'plaintiff', 'defendant', 'v', 'u.s.', 'court', 'app.', 'reporter', 'cir.']);
+
+const PROFILE_JARGON = {
+    medical: ['sleep', 'apnea', 'symptom', 'symptoms', 'trauma', 'hypertension', 'health', 'disease', 'condition', 'diagnosis', 'treatment', 'medication', 'dose', 'patient', 'clinic', 'surgery', 'therapy', 'alcohol', 'cannabis', 'blood', 'pressure', 'heart', 'rate', 'emergency', 'contact', 'relationship'],
+    realestate: ['escrow', 'tenant', 'landlord', 'lease', 'mortgage', 'appraisal', 'broker', 'property', 'zoning', 'parcel', 'rent', 'buyer', 'seller', 'agent', 'listing'],
+    legal: ['testator', 'notary', 'commission', 'county', 'court', 'affidavit', 'plaintiff', 'defendant', 'litigation', 'jurisdiction', 'agreement', 'contract', 'settlement', 'clause', 'article', 'section'],
+    hr: ['candidate', 'employee', 'payroll', 'benefits', 'salary', 'vacation', 'supervisor', 'subordinate', 'performance', 'appraisal', 'interview', 'resume', 'applicant'],
+    sales: ['prospect', 'opportunity', 'quota', 'pipeline', 'deal', 'revenue', 'forecast', 'lead', 'churn', 'client', 'customer']
+};
+    // --- END DEFAULT RULES ---
+
+    function hydrateRegex(r) {
+        if (r && typeof r.regex === 'string') {
+            if (r.regex.startsWith('/')) {
+                try {
+                    const lastSlash = r.regex.lastIndexOf('/');
+                    const pattern = r.regex.substring(1, lastSlash);
+                    const flags = r.regex.substring(lastSlash + 1);
+                    return { ...r, regex: new RegExp(pattern, flags) };
+                } catch (e) {
+                    console.error('Failed to hydrate regex:', r.regex, e);
+                    return r;
+                }
+            } else {
+                return { ...r, regex: new RegExp(r.regex, 'gi') };
+            }
+        }
+        return r;
+    }
+
+    function init(config) {
+        if (!config) return;
+        if (config.regexes) {
+            REGEX_RULES = config.regexes.map(hydrateRegex);
+        }
+        if (config.profiles) {
+            PROFILE_RULES = {};
+            for (const [profile, rules] of Object.entries(config.profiles)) {
+                PROFILE_RULES[profile] = rules.map(hydrateRegex);
+            }
+        }
+        if (config.names) NAME_STOP_LIST = new Set(config.names);
+    }
+
+    const PROFILE_ALIAS_MAP = {
+        'medical': 'medical', 'healthcare': 'medical', 'health': 'medical', 'pharma': 'pharma',
+        'engineering': 'engineering', 'dev': 'engineering', 'tech': 'tech',
+        'finance': 'finance', 'bizops': 'bizops', 'sales': 'sales', 'wealthmgmt': 'wealthmgmt', 'insurance': 'insurance', 'accounting': 'accounting',
+        'legal': 'legal', 'compliance': 'compliance', 'ccpa': 'ccpa',
+        'hr': 'hr', 'security': 'security', 'marketing': 'marketing', 'support': 'support',
+    };
+
+    function getActiveRules(activeProfile) {
+        let activeRules = [...REGEX_RULES];
+        if (activeProfile && activeProfile.toLowerCase() !== 'general') {
+            const canonicalProfile = PROFILE_ALIAS_MAP[activeProfile.toLowerCase()] || 'general';
+            if (canonicalProfile !== 'general' && PROFILE_RULES[canonicalProfile]) {
+                activeRules = activeRules.concat(PROFILE_RULES[canonicalProfile]);
+            }
+        }
+        return activeRules;
+    }
+
+    function stitchOrphanedNameLines(text, profile) {
+        if (profile === 'medical') {
+            text = text.replace(/Patient Name:\s*\n+([A-Z][a-zA-Z]+\s[A-Z][a-zA-Z]+)/g, 'Patient Name: $1');
+        } else if (profile === 'legal') {
+            text = text.replace(/Defendant:\s*\n+([A-Z][a-zA-Z]+\s[A-Z][a-zA-Z]+)/g, 'Defendant: $1');
+        }
+        return text;
+    }
+
+    function detectMatches(text, activeProfile = 'general', customRules = [], nlpNames = [], enabledEntities = null, mlEntities = []) {
+        let textToProcess = text.replace(/[\u200b\u200c\u200d\ufeff]/g, '');
+        textToProcess = textToProcess.replace(/([a-zA-Z])(Email|Phone|Mobile|Tel|Address|IP|ID|URL|SSN|Date):/g, '$1 $2:');
+
+        let matches = [];
+        
+        if (customRules && customRules.length > 0) {
+            const sorted = [...customRules].sort((a, b) => {
+                const patternA = typeof a === 'string' ? a : a.pattern;
+                const patternB = typeof b === 'string' ? b : b.pattern;
+                return patternB.length - patternA.length;
+            });
+            
+            sorted.forEach(cr => {
+                const pattern = typeof cr === 'string' ? cr : cr.pattern;
+                const label = typeof cr === 'string' ? 'CUSTOM' : (cr.label || 'CUSTOM');
+                
+                let rx;
+                try {
+                    const isExact = !/(\^|\$|\\[bBdDwWsS]|\[|\(|\{|\*|\+|\|)/.test(pattern);
+                    if (isExact) {
+                        const safe = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                        rx = new RegExp(`(?:^|\\b)${safe}(?:\\b|$)`, 'gi');
+                    } else {
+                        rx = new RegExp(pattern, 'gi');
+                    }
+                } catch (e) {
+                    return;
+                }
+                if (rx.test('')) return;
+                rx.lastIndex = 0;
+                let m;
+                while ((m = rx.exec(textToProcess)) !== null) {
+                    matches.push({ start: m.index, end: m.index + m[0].length, value: m[0], type: 'CUSTOM', customLabel: label });
+                }
+            });
+        }
+
+        const activeRules = getActiveRules(activeProfile);
+        const currentJargon = PROFILE_JARGON[PROFILE_ALIAS_MAP[activeProfile?.toLowerCase()]] ? new Set([...JARGON_WORDS, ...PROFILE_JARGON[PROFILE_ALIAS_MAP[activeProfile?.toLowerCase()]]]) : JARGON_WORDS;
+
+        activeRules.forEach(rule => {
+            if (enabledEntities && enabledEntities.indexOf(rule.type) === -1) return;
+            if (!rule.regex) return;
+            
+            rule.regex.lastIndex = 0;
+            let m;
+            while ((m = rule.regex.exec(textToProcess)) !== null) {
+                let matchedText = m[0];
+                let start = m.index;
+                
+                if (rule.isContextName && m[1]) {
+                    matchedText = m[1];
+                    start = m.index + m[0].lastIndexOf(m[1]);
+                }
+                const end = start + matchedText.length;
+                
+                if (rule.type !== 'NAME' && rule.type !== 'ADDRESS') {
+                    matches.push({ start, end, value: matchedText, type: rule.type });
+                } else {
+                    let val = matchedText.toLowerCase().trim();
+                    if (NAME_STOP_LIST.has(val)) continue;
+                    
+                    if (!rule.isContextName && rule.type === 'NAME') {
+                        let words = val.split(/[ \t\xA0]+/);
+                        let origWords = matchedText.split(/[ \t\xA0]+/);
+                        while (words.length > 2 && (currentJargon.has(words[0]) || NOT_NAME_WORDS.has(words[0]))) {
+                            origWords.shift();
+                            words.shift();
+                            const nextStart = matchedText.indexOf(origWords[0]);
+                            start += nextStart;
+                            matchedText = matchedText.substring(nextStart);
+                            val = matchedText.toLowerCase().trim();
+                        }
+                        if (words.some(w => currentJargon.has(w) || NOT_NAME_WORDS.has(w))) continue;
+                    } else if (rule.type === 'ADDRESS') {
+                        const words = val.split(/\s+/);
+                        if (words.some(w => currentJargon.has(w))) continue;
+                    }
+                    
+                    matches.push({ start, end: start + matchedText.length, value: matchedText, type: rule.type });
+                }
+            }
+        });
+
+        if (nlpNames && nlpNames.length > 0) {
+            nlpNames.forEach(name => {
+                const safeName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const rx = new RegExp(`(?<=^|[^\\p{L}\\p{N}_])${safeName}(?=[^\\p{L}\\p{N}_]|$)`, 'gu');
+                let m;
+                while ((m = rx.exec(textToProcess)) !== null) {
+                    matches.push({ start: m.index, end: m.index + m[0].length, value: m[0], type: 'NAME' });
+                }
+            });
+        }
+        
+        if (mlEntities && mlEntities.length > 0) {
+            mlEntities.forEach(item => {
+                const safeName = item.word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const rx = new RegExp(`(?<=^|[^\\p{L}\\p{N}_])${safeName}(?=[^\\p{L}\\p{N}_]|$)`, 'giu');
+                let m;
+                while ((m = rx.exec(textToProcess)) !== null) {
+                    matches.push({ start: m.index, end: m.index + m[0].length, value: m[0], type: item.type });
+                }
+            });
+        }
+
+        const learnedNames = new Set();
+        matches.forEach(m => {
+            if (m.type === 'NAME') {
+                const nameWords = m.value.split(/[^\p{L}'-]+/u);
+                nameWords.forEach(w => {
+                    if (w && w.length >= 2 && /^\p{Lu}/u.test(w)) {
+                        const wl = w.toLowerCase();
+                        if (!NOT_NAME_WORDS.has(wl) && !JARGON_WORDS.has(wl) && !NAME_STOP_LIST.has(wl)) {
+                            learnedNames.add(w);
+                        }
+                    }
+                });
+            }
+        });
+
+        if (learnedNames.size > 0) {
+            learnedNames.forEach(name => {
+                const safeName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const rx = new RegExp(`(?<=^|[^\\p{L}\\p{N}_])${safeName}(?=[^\\p{L}\\p{N}_]|$)`, 'gu');
+                let m;
+                while ((m = rx.exec(textToProcess)) !== null) {
+                    matches.push({ start: m.index, end: m.index + m[0].length, value: m[0], type: 'NAME' });
+                }
+            });
+        }
+
+        matches.sort((a, b) => a.start - b.start || b.end - a.end);
+        let filtered = [];
+        let lastEnd = 0;
+        matches.forEach(m => {
+            if (m.start >= lastEnd) { filtered.push(m); lastEnd = m.end; }
+        });
+
+        return { filteredMatches: filtered, processedText: textToProcess };
+    }
+
+    const LABEL_ALIASES = {
+        NAME: ['NAME', 'NAMES', 'USERNAME', 'USER_NAME', 'CLIENTNAME', 'CLIENT_NAME', 'CANDIDATE_NAME', 'FULL_NAME', 'FIRSTNAME', 'FIRST_NAME', 'LASTNAME', 'LAST_NAME', 'SURNAME', 'ИМЯ', 'ИМЕНА', 'ПОЛЬЗОВАТЕЛЬ', 'ФИО', 'КЛИЕНТ', 'NOMBRE', 'NOMBRES', 'USUARIO', 'CLIENTE', 'NOM', 'NOMS', 'UTILISATEUR', 'NAME', 'NAMEN', 'BENUTZER', 'KUNDE', 'NOME', 'COGNOME', 'UTENTE', 'NAAM', 'GEBRUIKER', 'KLANT'],
+        EMAIL: ['EMAIL', 'EMAILS', 'EMAILADDR', 'EMAIL_ADDR', 'EMAILADDRESS', 'EMAIL_ADDRESS', 'EMAIL_ADR', 'MAIL', 'MAILS', 'ПОЧТА', 'ЭЛ_ПОЧТА', 'АДРЕС_ПОЧТЫ', 'МЕЙЛ', 'МАЙЛ', 'CORREO', 'COURRIEL', 'CORREO_ELECTRONICO', 'MEL'],
+        PHONE: ['PHONE', 'PHONES', 'PHONENUM', 'PHONE_NUM', 'PHONENUMBER', 'PHONE_NUMBER', 'TEL', 'TELS', 'TELEPHONE', 'TELEPHONES', 'MOBILE', 'CELL', 'ТЕЛЕФОН', 'ТЕЛЕФОНЫ', 'НОМЕР_ТЕЛЕФОНА', 'НОМЕР', 'MOVIL', 'PORTABLE', 'HANDY', 'TELEFONI', 'CELLULARE'],
+        ID: ['ID', 'IDS', 'IDNUM', 'ID_NUM', 'IDNUMBER', 'ID_NUMBER', 'IDENTIFIER', 'IDENTIFIERS', 'PASSPORT', 'SSN', 'EIN', 'TAXID', 'TAX_ID', 'LICENSE', 'LICENSE_PLATE', 'ИД', 'ИДЕНТИФИКАТОР', 'ПАСПОРТ', 'СНИЛС', 'ИНН', 'IDENTIFICADOR', 'PASAPORTE', 'IDENTIFIANT', 'PASSEPORT', 'IDENTIFIKATOR', 'PASS', 'IDENTIFICATORE', 'PASSAPORTO'],
+        FINANCIAL: ['FINANCIAL', 'FINANCIALS', 'MONEY', 'AMOUNT', 'PRICE', 'COST', 'CARD', 'CREDITCARD', 'DEBITCARD', 'ACCOUNT', 'IBAN', 'BIC', 'ДЕНЬГИ', 'СУММА', 'КАРТА', 'СЧЕТ', 'БАНК', 'DINERO', 'CANTIDAD', 'TARJETA', 'CUENTA', 'ARGENT', 'MONTANT', 'COMPTE', 'GELD', 'BETRAG', 'KONTO'],
+        ADDRESS: ['ADDRESS', 'ADDRESSES', 'STREET', 'STREET_ADDRESS', 'CITY', 'STATE', 'ZIP', 'ZIPCODE', 'ZIP_CODE', 'COUNTRY', 'LOCATION', 'АДРЕС', 'АДРЕСА', 'УЛИЦА', 'ГОРОД', 'СТРАНА', 'DIRECCION', 'DIRECCIONES', 'CALLE', 'CIUDAD', 'PAIS', 'ADRESSE', 'ADRESSES', 'RUE', 'VILLE', 'STRASSE', 'STADT', 'LAND'],
+        DATE: ['DATE', 'DATES', 'BIRTHDAY', 'DOB', 'ДАТА', 'ДАТЫ', 'ДЕНЬ_РОЖДЕНИЯ', 'FECHA', 'FECHAS', 'CUMPLEANOS', 'ANNIVERSAIRE', 'DATUM', 'DATEN', 'GEBURTSTAG'],
+        PHI: ['PHI', 'MRN', 'NHS', 'HEALTH', 'MEDICAL', 'PATIENT', 'МЕД', 'ПАЦИЕНТ', 'PACIENTE'],
+        SECRET: ['SECRET', 'SECRETS', 'KEY', 'KEYS', 'TOKEN', 'TOKENS', 'PASSWORD', 'PASSWORDS', 'AUTH', 'APIKEY', 'API_KEY', 'КЛЮЧ', 'КЛЮЧИ', 'ПАРОЛЬ', 'ПАРОЛИ', 'ТОКЕН', 'CLAVE', 'CONTRASENA', 'CLE', 'MOT_DE_PASSE', 'SCHLUESSEL', 'PASSWORT'],
+        CUSTOM: ['CUSTOM', 'CUSTOMS', 'RULE', 'RULES', 'КАСТОМ', 'ПРАВИЛО']
+    };
+
+    function getLabelAliases(label) {
+        const upper = label.toUpperCase();
+        if (LABEL_ALIASES[upper]) return LABEL_ALIASES[upper];
+        const aliases = new Set([label, upper, label.toLowerCase()]);
+        aliases.add(label.replace(/_/g, ' '));
+        aliases.add(label.replace(/_/g, '-'));
+        aliases.add(label.replace(/ /g, '_'));
+        aliases.add(label.replace(/-/g, '_'));
+        return Array.from(aliases);
+    }
+
+    function buildRestorationRegexAndRules(tokenMap) {
+        const ObjectKeys = Object.keys(tokenMap);
+        if (ObjectKeys.length === 0) return { compositeRegex: null, looseRules: [] };
+
+        const sortedKeys = [...ObjectKeys].sort((a, b) => {
+            const innerA = a.replace(/^\[|\]$/g, '');
+            const innerB = b.replace(/^\[|\]$/g, '');
+            const matchA = innerA.match(/^([A-Za-z_0-9]+?)[-_]?(\d+)$/);
+            const matchB = innerB.match(/^([A-Za-z_0-9]+?)[-_]?(\d+)$/);
+            if (matchA && matchB) {
+                const idxA = parseInt(matchA[2], 10);
+                const idxB = parseInt(matchB[2], 10);
+                const labelA = matchA[1];
+                const labelB = matchB[1];
+                if (idxA !== idxB) return idxB - idxA;
+                if (labelA.length !== labelB.length) return labelB.length - labelA.length;
+            }
+            return b.length - a.length;
+        });
+
+        const looseRules = [];
+        const regexParts = [];
+
+        sortedKeys.forEach(k => {
+            const inner = k.replace(/^\[|\]$/g, '');
+            const match = inner.match(/^([A-Za-z_0-9]+?)[-_]?(\d+)$/);
+            if (match) {
+                const label = match[1];
+                const baseIndex = parseInt(match[2], 10);
+                const aliases = getLabelAliases(label);
+                
+                const escapedAliases = aliases.map(a => a.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+                const loosePattern = `\\[\\s*(?:${escapedAliases.join('|')})[-_\\s]*0*${baseIndex}\\s*\\]|(?<![A-Za-z0-9\\u0400-\\u04FF_])(?:${escapedAliases.join('|')})[-_\\s]*0*${baseIndex}(?![A-Za-z0-9\\u0400-\\u04FF_])`;
+                looseRules.push({ token: k, pattern: loosePattern });
+            }
+            regexParts.push(k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+        });
+
+        let compositeRegex = null;
+        if (regexParts.length > 0) {
+            compositeRegex = new RegExp(`(?:\\b|\\[)?(?:(?:(?<!\\w)|(?<=\\s))(?:${regexParts.join('|')})(?:(?!\\w)|(?=\\s)))(?:\\b|\\])?`, 'g');
+        }
+
+        return { compositeRegex, looseRules };
+    }
+
+    function cleanAIPromptPrefix(text) {
+        if (!text) return "";
+        let cleaned = text.replace(/^\s*(?:Claude responded|Claude|ChatGPT|Gemini|Grok|DeepSeek|Kimi|Copilot|Assistant|User)\s*(?::|\bsaid\b|\bresponded\b|(?=\s))\s*/i, "");
+        cleaned = cleaned.replace(/^(?:Here (?:is|are) (?:the )?(?:redacted|scrubbed|sanitized|processed|clean|updated|modified) (?:text|output|version|data).*?[:\n]+|\*\*Scrubbed Text\*\*[:\n]+|### Scrubbed Text[:\n]+)/i, '');
+        cleaned = cleaned.replace(/^\s*Edit\s*\n+/i, "");
+        cleaned = cleaned.replace(/\s*\bEdit\s+in\s+a\s+page\b\s*$/i, "");
+        return cleaned.trim();
+    }
+
+    function unscrubText(text, sessionMap) {
+        let restoredCount = 0;
+        let result = text;
+        const tokens = Object.keys(sessionMap);
+        if (tokens.length === 0) return { text: result, count: 0 };
+        
+        result = cleanAIPromptPrefix(result);
+
+        const { compositeRegex, looseRules } = buildRestorationRegexAndRules(sessionMap);
+
+        if (compositeRegex) {
+            result = result.replace(compositeRegex, (match) => {
+                const cleanMatch = match.replace(/^\[|\]$/g, '').trim();
+                const token = `[${cleanMatch.replace(/^\[|\]$/g, '')}]`;
+                if (sessionMap[token]) {
+                    restoredCount++;
+                    return sessionMap[token];
+                }
+                if (sessionMap[cleanMatch]) {
+                    restoredCount++;
+                    return sessionMap[cleanMatch];
+                }
+                return match;
+            });
+        }
+
+        looseRules.forEach(rule => {
+            const rx = new RegExp(rule.pattern, 'gi');
+            result = result.replace(rx, (match) => {
+                restoredCount++;
+                return sessionMap[rule.token];
+            });
+        });
+
+        return { text: result, count: restoredCount };
+    }
+
+    function escapeHTML(str) {
+        if (!str) return '';
+        return String(str)
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#39;');
+    }
+
+    function unscrubTextAsHTML(text, sessionMap) {
+        let restoredCount = 0;
+        let cleaned = cleanAIPromptPrefix(text || '');
+        let result = escapeHTML(cleaned);
+        const tokens = Object.keys(sessionMap || {});
+        if (tokens.length === 0) return { text: result, count: 0 };
+
+        const { compositeRegex, looseRules } = buildRestorationRegexAndRules(sessionMap);
+
+        if (compositeRegex) {
+            result = result.replace(compositeRegex, (match) => {
+                const cleanMatch = match.replace(/^\[|\]$/g, '').trim();
+                const token = `[${cleanMatch.replace(/^\[|\]$/g, '')}]`;
+                if (sessionMap[token]) {
+                    restoredCount++;
+                    const escapedVal = escapeHTML(sessionMap[token]);
+                    return `<span class="ps-restored-data entity-tag entity-revealed" title="Original Token: ${escapeHTML(token)}">${escapedVal}</span>`;
+                }
+                if (sessionMap[cleanMatch]) {
+                    restoredCount++;
+                    const escapedVal = escapeHTML(sessionMap[cleanMatch]);
+                    return `<span class="ps-restored-data entity-tag entity-revealed" title="Original Token: ${escapeHTML(cleanMatch)}">${escapedVal}</span>`;
+                }
+                return match;
+            });
+        }
+
+        looseRules.forEach(rule => {
+            const rx = new RegExp(rule.pattern, 'gi');
+            result = result.replace(rx, (match, offset, fullStr) => {
+                const before = fullStr.substring(0, offset);
+                const lastOpen = before.lastIndexOf('<');
+                const lastClose = before.lastIndexOf('>');
+                if (lastOpen > lastClose) return match;
+
+                restoredCount++;
+                const escapedVal = escapeHTML(sessionMap[rule.token]);
+                return `<span class="ps-restored-data entity-tag entity-revealed" title="Original Token: ${escapeHTML(rule.token)} (Fuzzy Match)">${escapedVal}</span>`;
+            });
+        });
+
+        return { text: result, count: restoredCount };
+    }
+
+    const PrivacyScrubberEngine = {
+        init,
+        hydrateRegex,
+        getActiveRules,
+        stitchOrphanedNameLines,
+        detectMatches,
+        getRulesMap: () => ({ REGEX_RULES, PROFILE_RULES }),
+        getDevopsRules: () => DEVOPS_SECRETS,
+        LABEL_ALIASES,
+        getLabelAliases,
+        PROFILE_ALIAS_MAP,
+        buildRestorationRegexAndRules,
+        unscrubText,
+        unscrubTextAsHTML,
+        cleanAIPromptPrefix,
+        // Expose underlying constants for Node scripts & build pipeline proxy
+        REGEX_RULES,
+        PROFILE_RULES,
+        NAME_STOP_LIST,
+        JARGON_WORDS,
+        NOT_NAME_WORDS,
+        PROFILE_JARGON,
+    };
+
+    if (typeof exports !== 'undefined') {
+        module.exports = PrivacyScrubberEngine;
+    }
+    if (typeof self !== 'undefined') {
+        self.PrivacyScrubberEngine = PrivacyScrubberEngine;
+    }
+    if (typeof window !== 'undefined') {
+        window.PrivacyScrubberEngine = PrivacyScrubberEngine;
+    }
+})();