@privacyscrubber/sdk 2.3.1 → 2.3.4

package/README.md

@@ -6,7 +6,7 @@
 [![Air-Gapped](https://img.shields.io/badge/network_calls-0-blueviolet.svg)](https://privacyscrubber.com)
 [![TypeScript Typings](https://img.shields.io/badge/types-TypeScript-blue.svg)](https://www.npmjs.com/package/@privacyscrubber/sdk)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[![Patent Pending](https://img.shields.io/badge/Patent-Pending%20(ILPO%20331905)-06b6d4.svg)](https://privacyscrubber.com/patents/)
+[![Patent Pending](https://img.shields.io/badge/Patent-Pending%20(US%20%26%20Intl)-06b6d4.svg)](https://privacyscrubber.com/patents/)
 [![IETF Specification](https://img.shields.io/badge/IETF-ZTDS--Protocol-0284c7.svg)](https://datatracker.ietf.org/doc/draft-sibiryakov-ztds-protocol/)
 [![ZTDS Verified](https://ztds.ai/badge/privacyscrubber-sdk.svg)](https://ztds.ai/registry/#privacyscrubber-sdk)
 [![GitHub Stars](https://img.shields.io/github/stars/moxno/privacyscrubber-mcp?style=social)](https://github.com/moxno/privacyscrubber-mcp)
@@ -71,7 +71,7 @@ Backend engineering and InfoSec review boards consistently ask four core archite
 > - **CERN / Zenodo Foundation**: [DOI 10.5281/zenodo.22058770](https://doi.org/10.5281/zenodo.22058770)
 > - **Center for Open Science (OSF) Benchmark**: [DOI 10.17605/OSF.IO/5BYJF](https://doi.org/10.17605/OSF.IO/5BYJF)
 > - **Law Archive Treatise**: [osf.io/preprints/lawarchive/4wc86/](https://osf.io/preprints/lawarchive/4wc86/)
-> - **Patent Pending**: Israel Patent Office Application `IL 331905` (WIPO DAS Code: `B17B`)
+> - **Patent Pending**: U.S. & International Patents Pending (Paris Convention / PCT Priority)
 
 ---
 
@@ -700,16 +700,15 @@ MIT License © 2026 PrivacyScrubber. Commercial production usage without quota l
 
 ---
 
-## 🏛️ Intellectual Property & Virtual Patent Marking
+## 🏛️ Intellectual Property & Patent Disclosures
 
 The Zero-Trust Data Sanitization (ZTDS) architecture, in-memory deterministic tokenization, cryptographic session handoff, and headless execution methods implemented in this SDK are proprietary technology of Ilya Sibiryakov (BrandMeWeb) and are protected under **Patent Pending** status:
 
-- **Patent Office:** State of Israel Ministry of Justice, Patent Office (ILPO)
-- **Application Number:** `331905` (Tracking ID: `94221`)
-- **WIPO DAS Access Control Code:** `B17B` (World Intellectual Property Organization Digital Access Service electronic priority document exchange for USPTO, EPO, CNIPA, and PCT receiving offices)
-- **Filing / Priority Date:** September 14, 2026 (Paris Convention Art. 4 & 35 U.S.C. § 119 Priority locked through September 14, 2027)
+- **Legal Status:** U.S. & International Patents Pending
+- **Priority Framework:** Paris Convention Art. 4 & 35 U.S.C. § 119 Priority (locked through September 14, 2027)
+- **Filing / Priority Date:** September 14, 2026
 - **Official Title:** *SYSTEM AND METHOD FOR CLIENT-SIDE ZERO-TRUST DATA SANITIZATION AND CRYPTOGRAPHIC SESSION HANDOFF IN ARTIFICIAL INTELLIGENCE WORKFLOWS*
-- **Virtual Patent Marking:** [privacyscrubber.com/patents/](https://privacyscrubber.com/patents/) in accordance with 35 U.S.C. § 287(a).
+- **Patent Disclosures Hub:** [privacyscrubber.com/patents/](https://privacyscrubber.com/patents/) (formal verification via counsel NDA).
 
 ### 🌐 Internet Engineering Task Force (IETF) Specification
 - **Specification Title:** *The Zero-Trust Data Sanitization (ZTDS) Protocol for Frontier Artificial Intelligence Ingestion*

package/browser.js

@@ -549,84 +549,230 @@ export class PrivacyScrubberEngine {
 }
 
 /**
- * Browser & Web Worker Streaming Detokenizer.
+ * Helper to escape special regex characters.
  */
-export class StreamingDetokenizer {
-    constructor(tokenMap = {}, options = {}) {
-        this.tokenMap = { ...tokenMap };
-        this.buffer = '';
-        this.onTokenRestored = typeof options.onTokenRestored === 'function' ? options.onTokenRestored : null;
-        this.maxTokenLength = Math.max(
-            32,
-            ...Object.keys(this.tokenMap).map(k => k.length + 8)
-        );
-    }
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 
-    updateTokenMap(newTokenMap) {
-        Object.assign(this.tokenMap, newTokenMap);
-        this.maxTokenLength = Math.max(
-            this.maxTokenLength,
-            ...Object.keys(this.tokenMap).map(k => k.length + 8)
-        );
+/**
+ * Builds an ultra-fast streaming token replacement function.
+ * Preserves all whitespace, indentation, newlines, and code blocks (does NOT trim).
+ * Handles descending key ordering (e.g. [NAME_10] before [NAME_1]), case insensitivity,
+ * alternative delimiters (<...>, {{...}}, __...__), and possessive suffixes.
+ *
+ * @param {Record<string, string>} tokenMap
+ * @param {Object} [options]
+ * @returns {(text: string) => string}
+ */
+export function buildStreamReplacer(tokenMap = {}, options = {}) {
+    if (!tokenMap || typeof tokenMap !== 'object' || Object.keys(tokenMap).length === 0) {
+        return (text) => text || '';
+    }
+
+    const onTokenRestored = typeof options?.onTokenRestored === 'function' ? options.onTokenRestored : null;
+    const lookup = new Map();
+    const patterns = [];
+    const sortedKeys = Object.keys(tokenMap).sort((a, b) => b.length - a.length);
+
+    for (const k of sortedKeys) {
+        const val = tokenMap[k];
+        const inner = k.replace(/^\[|<|\{\{|__|\]|>|\}\}|__/g, '');
+        const match = inner.match(/^([A-Za-z_0-9]+?)[-_ ]?(\d+)$/);
+
+        if (match) {
+            const label = escapeRegex(match[1]);
+            const idx = match[2];
+            const patternStr = '(?:\\[\\s*' + label + '[-_\\s]*0*' + idx + '\\s*\\]|<\\s*' + label + '[-_\\s]*0*' + idx + '\\s*>|\\{\\{\\s*' + label + '[-_\\s]*0*' + idx + '\\s*\\}\\}|__\\s*' + label + '[-_\\s]*0*' + idx + '\\s*__|\\b' + label + '[-_\\s]+0*' + idx + '\\b)';
+            patterns.push(patternStr);
+            const normKey = (match[1] + '_' + parseInt(idx, 10)).toUpperCase();
+            lookup.set(normKey, val);
+            lookup.set(k, val);
+            lookup.set(k.toUpperCase(), val);
+        } else {
+            const safe = escapeRegex(k);
+            patterns.push(safe);
+            lookup.set(k, val);
+            lookup.set(k.toUpperCase(), val);
+        }
     }
 
-    process(chunk) {
-        if (!chunk) return '';
-        this.buffer += chunk;
-        let output = '';
-
-        while (true) {
-            const openIdx = this.buffer.search(/\[|\<|\{\{|\_\_/);
-            if (openIdx === -1) {
-                output += this.buffer;
-                this.buffer = '';
-                break;
-            }
+    const unifiedRegex = new RegExp('(?:' + patterns.join('|') + ')(\'s|’s|s)?', 'gi');
 
-            output += this.buffer.slice(0, openIdx);
-            this.buffer = this.buffer.slice(openIdx);
+    return function replaceTokens(text) {
+        if (!text) return '';
+        unifiedRegex.lastIndex = 0;
+        return text.replace(unifiedRegex, (match, suffix) => {
+            const isPossessive = suffix && /('s|’s)$/i.test(suffix);
+            const coreMatch = suffix ? match.slice(0, match.length - suffix.length) : match;
+            let restored = null;
 
-            const closeIdx = this.buffer.search(/\]|\>|\}\}|\_\_/);
-            if (closeIdx === -1) {
-                if (this.buffer.length > this.maxTokenLength) {
-                    output += this.buffer.slice(0, this.maxTokenLength);
-                    this.buffer = this.buffer.slice(this.maxTokenLength);
-                    continue;
+            if (lookup.has(coreMatch)) {
+                restored = lookup.get(coreMatch);
+            } else if (lookup.has(coreMatch.toUpperCase())) {
+                restored = lookup.get(coreMatch.toUpperCase());
+            } else {
+                const inner = coreMatch.replace(/^\[|<|\{\{|__|\]|>|\}\}|__/g, '').trim();
+                const m = inner.match(/^([A-Za-z_0-9]+?)[-_ ]?(\d+)$/);
+                if (m) {
+                    const normKey = (m[1] + '_' + parseInt(m[2], 10)).toUpperCase();
+                    if (lookup.has(normKey)) {
+                        restored = lookup.get(normKey);
+                    }
                 }
-                break;
             }
 
-            const candidateToken = this.buffer.slice(0, closeIdx + 1);
-            const originalValue = this.tokenMap[candidateToken];
+            if (restored !== null) {
+                if (onTokenRestored) {
+                    try { onTokenRestored({ token: match, originalValue: restored }); } catch (_) {}
+                }
+                return restored + (isPossessive ? "'s" : '');
+            }
 
-            if (originalValue !== undefined) {
-                output += originalValue;
-                if (this.onTokenRestored) {
-                    this.onTokenRestored({ token: candidateToken, originalValue });
+            if (lookup.has(match)) {
+                restored = lookup.get(match);
+                if (onTokenRestored) {
+                    try { onTokenRestored({ token: match, originalValue: restored }); } catch (_) {}
                 }
-                this.buffer = this.buffer.slice(closeIdx + 1);
-            } else {
-                output += candidateToken[0];
-                this.buffer = this.buffer.slice(1);
+                return restored;
             }
+
+            return match;
+        });
+    };
+}
+
+/**
+ * Browser & Web Worker Streaming Detokenizer with sliding window buffer for LLM chunk boundary splits.
+ * Seamlessly restores split tokens (e.g. [EM + AIL_1]), preserves multi-byte UTF-8,
+ * and maintains zero-latency streaming throughput.
+ */
+export class StreamingDetokenizer {
+    constructor(tokenMap = {}, options = {}) {
+        this.tokenMap = tokenMap && typeof tokenMap === 'object' ? tokenMap : {};
+        this.options = options || {};
+        this.replacer = buildStreamReplacer(this.tokenMap, this.options);
+        this.pendingBuffer = '';
+        this.hasTokens = Object.keys(this.tokenMap).length > 0;
+        this._lastTokenCount = Object.keys(this.tokenMap).length;
+        this.decoder = new TextDecoder('utf-8', { fatal: false });
+    }
+
+    /**
+     * Backward-compatible buffer property getter/setter.
+     */
+    get buffer() {
+        return this.pendingBuffer;
+    }
+
+    set buffer(val) {
+        this.pendingBuffer = typeof val === 'string' ? val : '';
+    }
+
+    /**
+     * Dynamically updates the active token map for this streaming session.
+     * @param {Record<string, string>} newMap
+     */
+    updateTokenMap(newMap) {
+        if (newMap && typeof newMap === 'object') {
+            this.tokenMap = newMap;
+            this.replacer = buildStreamReplacer(this.tokenMap, this.options);
+            this.hasTokens = Object.keys(this.tokenMap).length > 0;
+            this._lastTokenCount = Object.keys(this.tokenMap).length;
+        }
+    }
+
+    /**
+     * Resets the internal sliding window buffer.
+     */
+    reset() {
+        this.pendingBuffer = '';
+    }
+
+    /**
+     * Feeds an incoming chunk (string, Uint8Array, or Buffer) and returns de-tokenized text.
+     * Buffers any unclosed token candidates at chunk boundaries until closed or flushed.
+     * @param {string | Uint8Array | Buffer} chunk
+     * @returns {string}
+     */
+    feed(chunk) {
+        if (chunk === undefined || chunk === null) return '';
+        let text = '';
+        if (typeof chunk === 'string') {
+            text = chunk;
+        } else if (chunk instanceof Uint8Array || (typeof Buffer !== 'undefined' && Buffer.isBuffer(chunk))) {
+            text = this.decoder.decode(chunk, { stream: true });
+        } else {
+            text = String(chunk);
+        }
+
+        if (!text) return '';
+
+        // Dynamically recompile if tokens were added to the referenced map
+        const currentTokenCount = Object.keys(this.tokenMap).length;
+        if (currentTokenCount !== this._lastTokenCount) {
+            this.replacer = buildStreamReplacer(this.tokenMap, this.options);
+            this.hasTokens = currentTokenCount > 0;
+            this._lastTokenCount = currentTokenCount;
+        }
+
+        if (!this.hasTokens) return text;
+
+        this.pendingBuffer += text;
+
+        // Candidate unclosed token at tail of buffer (inspect tail window up to 160 chars)
+        // Matches incomplete tokens starting with [, <, {{, or __, plus single delimiter prefixes { and _
+        const tailLen = 160;
+        const tail = this.pendingBuffer.length > tailLen ? this.pendingBuffer.slice(-tailLen) : this.pendingBuffer;
+        const offset = this.pendingBuffer.length > tailLen ? this.pendingBuffer.length - tailLen : 0;
+        const m = tail.match(/(?:\[|<|\{\{?|__?)[A-Za-z0-9_\-А-Яа-яЁё ]{0,128}$/);
+
+        if (m) {
+            const candidate = m[0];
+            // Only closed double-underscore tokens (e.g. __NAME_1__) could match m since '_' is in character class.
+            // Bracketed tokens ([, <, {{) cannot end with their closing delimiter here and must be buffered.
+            const isClosedUnderscoreToken = candidate.length >= 4 && candidate.startsWith('__') && candidate.endsWith('__');
+            if (isClosedUnderscoreToken && this.replacer(candidate) !== candidate) {
+                const toEmit = this.pendingBuffer;
+                this.pendingBuffer = '';
+                return this.replacer(toEmit);
+            }
+            const splitIdx = offset + m.index;
+            const safeToEmit = this.pendingBuffer.slice(0, splitIdx);
+            this.pendingBuffer = this.pendingBuffer.slice(splitIdx);
+            return safeToEmit ? this.replacer(safeToEmit) : '';
         }
 
-        return output;
+        const toEmit = this.pendingBuffer;
+        this.pendingBuffer = '';
+        return this.replacer(toEmit);
     }
 
+    /**
+     * Alias for feed() to maintain backwards compatibility with process() callers.
+     */
+    process(chunk) {
+        return this.feed(chunk);
+    }
+
+    /**
+     * Flushes remaining buffered tokens and finalizes UTF-8 stream decoder.
+     * @returns {string}
+     */
     flush() {
-        let output = '';
-        if (this.buffer) {
-            let flushed = this.buffer;
-            for (const [token, original] of Object.entries(this.tokenMap)) {
-                if (flushed.includes(token)) {
-                    flushed = flushed.split(token).join(original);
-                }
-            }
-            output = flushed;
-            this.buffer = '';
+        let text = '';
+        try {
+            text = this.decoder.decode(new Uint8Array(), { stream: false });
+        } catch (_) {}
+
+        if (text) {
+            this.pendingBuffer += text;
         }
-        return output;
+
+        if (!this.pendingBuffer) return '';
+        const remaining = this.pendingBuffer;
+        this.pendingBuffer = '';
+        return this.replacer(remaining);
     }
 }
 
@@ -682,11 +828,6 @@ export function createStreamTokenRestorer(tokenMap = {}, options = {}) {
     };
 }
 
-export function buildStreamReplacer(tokenMap = {}) {
-    const detok = new StreamingDetokenizer(tokenMap);
-    return (chunk) => detok.process(chunk);
-}
-
 export const scrubText = scrubberPkg ? scrubberPkg.scrubText : null;
 export const unscrubText = scrubberPkg ? scrubberPkg.unscrubText : null;
 

package/cli.js

@@ -14,6 +14,8 @@ import path from 'node:path';
 import crypto from 'node:crypto';
 import http from 'node:http';
 import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
 import { sanitize, restore, validateLicense, generateProcurementMemo, StreamingDetokenizer } from './index.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -54,6 +56,28 @@ if (args.includes('memo') || args.includes('--memo') || args.includes('--procure
   process.exit(0);
 }
 
+// ── MCP Mode: Launch Standard Model Context Protocol Server over stdio ──
+if (args.includes('mcp') || args.includes('--stdio-mcp') || args.includes('--mcp')) {
+  const candidateMcpPaths = [
+    path.resolve(__dirname, '../mcp-server/index.js'),
+    path.resolve(__dirname, './mcp-server/index.js'),
+    path.resolve(process.cwd(), 'mcp-server/index.js')
+  ];
+  const mcpServerPath = candidateMcpPaths.find(p => fs.existsSync(p));
+  if (mcpServerPath) {
+    const { spawn } = await import('node:child_process');
+    const forwardedArgs = args.filter(a => !['mcp', '--stdio-mcp', '--mcp'].includes(a));
+    const child = spawn(process.execPath, [mcpServerPath, ...forwardedArgs], {
+      stdio: 'inherit'
+    });
+    child.on('exit', code => process.exit(code || 0));
+    await new Promise(() => {});
+  } else {
+    console.error('[PrivacyScrubber CLI Error] MCP Server runtime not found in local workspace.');
+    process.exit(1);
+  }
+}
+
 // ── Sidecar / Server Mode: Lightweight Local HTTP & Unix Socket Daemon ──
 if (args.includes('sidecar') || args.includes('--sidecar') || args.includes('serve') || args.includes('--serve')) {
   let port = 3100;
@@ -279,9 +303,12 @@ Commands:
   memo                 Generate executive CISO & DPO procurement memo
   demo                 Run live in-memory benchmark (<0.1ms latency check)
   sidecar, serve       Run zero-dependency local HTTP/Unix daemon (<1ms in-memory)
+  mcp, --stdio-mcp     Launch standard Model Context Protocol (MCP) server over stdio
 
 Options:
   --verify-ci          Generate CI/CD PR verification stamp (audit receipt)
+  --format <fmt>       Output format: text, json, sarif (OASIS SARIF 2.1.0 for GitHub/GitLab)
+  --config, -c <file>  Load configuration file (.privacyscrubber.json / ztds.config.json)
   --json               Output structured JSON (scrubbedText, tokenMap, telemetry)
   --restore, --unscrub Restore masked tokens in text back to original values
   --stream             Stream de-tokenization chunks in real-time from stdin
@@ -308,20 +335,53 @@ Commercial Licensing:
   process.exit(0);
 }
 
+// Config file discovery: --config, -c, or auto-discovery (.privacyscrubber.json / ztds.config.json)
+let configFile = null;
+const configIdx = args.indexOf('--config') !== -1 ? args.indexOf('--config') : args.indexOf('-c');
+if (configIdx !== -1 && args[configIdx + 1]) {
+  configFile = args[configIdx + 1];
+} else if (fs.existsSync(path.resolve(process.cwd(), '.privacyscrubber.json'))) {
+  configFile = path.resolve(process.cwd(), '.privacyscrubber.json');
+} else if (fs.existsSync(path.resolve(process.cwd(), 'ztds.config.json'))) {
+  configFile = path.resolve(process.cwd(), 'ztds.config.json');
+}
+
+let loadedConfig = {};
+if (configFile) {
+  try {
+    if (fs.existsSync(configFile)) {
+      loadedConfig = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    } else {
+      console.error(`[PrivacyScrubber CLI Error] Config file not found: ${configFile}`);
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(`[PrivacyScrubber CLI Error] Failed to parse config file ${configFile}: ${err.message}`);
+    process.exit(1);
+  }
+}
+
 // Parse command-line options
-let profile = 'Dev';
 const profIdx = args.indexOf('--profile');
-if (profIdx !== -1 && args[profIdx + 1]) {
-  profile = args[profIdx + 1];
-}
+let profile = profIdx !== -1 ? args[profIdx + 1] : (loadedConfig.profile || 'Dev');
 
 const keyIdx = args.indexOf('--key');
 if (keyIdx !== -1 && args[keyIdx + 1]) {
   process.env.PRIVACYSCRUBBER_KEY = args[keyIdx + 1];
+} else if (loadedConfig.licenseKey || loadedConfig.key) {
+  process.env.PRIVACYSCRUBBER_KEY = loadedConfig.licenseKey || loadedConfig.key;
 }
 
+const formatIdx = args.indexOf('--format');
+let outputFormat = 'text';
+if (formatIdx !== -1 && args[formatIdx + 1]) {
+  outputFormat = args[formatIdx + 1].toLowerCase();
+} else if (loadedConfig.format) {
+  outputFormat = String(loadedConfig.format).toLowerCase();
+}
+const isSarif = outputFormat === 'sarif' || args.includes('--sarif');
 const isVerifyCi = args.includes('--verify-ci');
-const isJson = args.includes('--json');
+const isJson = args.includes('--json') || outputFormat === 'json';
 const isRestore = args.includes('--restore') || args.includes('--unscrub');
 const isStream = args.includes('--stream');
 
@@ -343,14 +403,16 @@ if (mapIdx !== -1 && args[mapIdx + 1]) {
 
 // Locate input argument (first positional parameter that is not a flag or flag value)
 const skipIndices = new Set();
+if (configIdx !== -1) { skipIndices.add(configIdx); skipIndices.add(configIdx + 1); }
 if (profIdx !== -1) { skipIndices.add(profIdx); skipIndices.add(profIdx + 1); }
 if (keyIdx !== -1) { skipIndices.add(keyIdx); skipIndices.add(keyIdx + 1); }
 if (mapIdx !== -1) { skipIndices.add(mapIdx); skipIndices.add(mapIdx + 1); }
+if (formatIdx !== -1) { skipIndices.add(formatIdx); skipIndices.add(formatIdx + 1); }
 
 let inputArg = null;
 for (let i = 0; i < args.length; i++) {
   if (skipIndices.has(i)) continue;
-  if (args[i] === '--verify-ci' || args[i] === '--json' || args[i] === '--restore' || args[i] === '--unscrub') continue;
+  if (args[i] === '--verify-ci' || args[i] === '--json' || args[i] === '--sarif' || args[i] === '--restore' || args[i] === '--unscrub') continue;
   if (args[i].startsWith('-')) continue;
   inputArg = args[i];
   break;
@@ -373,7 +435,11 @@ function handleExecution(text) {
       process.exit(0);
     }
 
-    const { scrubbedText, tokenMap: resMap, telemetry } = sanitize(text, { profile, detectSecrets: true });
+    const { scrubbedText, tokenMap: resMap, telemetry } = sanitize(text, {
+      profile,
+      detectSecrets: loadedConfig.detectSecrets !== false,
+      customRules: loadedConfig.customRules || []
+    });
     const maskedCount = Object.keys(resMap || {}).length;
     const hash = crypto.createHash('sha256').update(scrubbedText).digest('hex').slice(0, 16);
 
@@ -389,14 +455,26 @@ function handleExecution(text) {
   }
 
   if (!text) {
-    if (isJson) {
+    if (isSarif) {
+      const { emitSarif } = require('./sarif.js');
+      console.log(emitSarif([], { pretty: true }));
+    } else if (isJson) {
       console.log(JSON.stringify({ scrubbedText: '', tokenMap: {}, count: 0 }, null, 2));
     }
     process.exit(0);
   }
 
-  const res = sanitize(text, { profile, detectSecrets: true });
-  if (isJson) {
+  const res = sanitize(text, {
+    profile,
+    detectSecrets: loadedConfig.detectSecrets !== false,
+    customRules: loadedConfig.customRules || []
+  });
+  if (isSarif) {
+    const { emitSarif, sanitizeResultToFindings } = require('./sarif.js');
+    const findings = sanitizeResultToFindings(res, text, inputArg || 'stdin');
+    const sarifOutput = emitSarif(findings, { pretty: true });
+    process.stdout.write(sarifOutput + '\n');
+  } else if (isJson) {
     console.log(JSON.stringify({
       scrubbedText: res.scrubbedText,
       tokenMap: res.tokenMap,

package/index.d.ts

@@ -26,6 +26,8 @@ export type PiiProfile =
     | 'Compliance'
     | 'CCPA'
     | 'Engineering'
+    | 'Manufacturing'
+    | 'Industrial'
     | 'Agents'
     | 'Academic'
     | 'Creative'