@privacyscrubber/sdk 2.3.1 → 2.3.3

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/index.d.ts

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

package/index.js

@@ -621,6 +621,7 @@ export function restore(aiResponse, tokenMap = {}) {
  * Alias for restore.
  */
 export const unscrub = restore;
+export const desanitize = restore;
 
 /**
  * Recursively sanitizes all string values within an object or array.
@@ -1346,11 +1347,12 @@ function escapeRegex(s) {
  * @param {Record<string, string>} tokenMap
  * @returns {(text: string) => string}
  */
-export function buildStreamReplacer(tokenMap = {}) {
+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);
@@ -1385,24 +1387,39 @@ export function buildStreamReplacer(tokenMap = {}) {
         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;
 
             if (lookup.has(coreMatch)) {
-                return lookup.get(coreMatch) + (isPossessive ? "'s" : '');
+                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);
+                    }
+                }
             }
-            if (lookup.has(coreMatch.toUpperCase())) {
-                return lookup.get(coreMatch.toUpperCase()) + (isPossessive ? "'s" : '');
+
+            if (restored !== null) {
+                if (onTokenRestored) {
+                    try { onTokenRestored({ token: match, originalValue: restored }); } catch (_) {}
+                }
+                return restored + (isPossessive ? "'s" : '');
             }
 
-            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)) {
-                    return lookup.get(normKey) + (isPossessive ? "'s" : '');
+            if (lookup.has(match)) {
+                restored = lookup.get(match);
+                if (onTokenRestored) {
+                    try { onTokenRestored({ token: match, originalValue: restored }); } catch (_) {}
                 }
+                return restored;
             }
 
-            return lookup.has(match) ? lookup.get(match) : match;
+            return match;
         });
     };
 }
@@ -1416,13 +1433,24 @@ export class StreamingDetokenizer {
     constructor(tokenMap = {}, options = {}) {
         this.tokenMap = tokenMap && typeof tokenMap === 'object' ? tokenMap : {};
         this.options = options || {};
-        this.replacer = buildStreamReplacer(this.tokenMap);
+        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
@@ -1430,7 +1458,7 @@ export class StreamingDetokenizer {
     updateTokenMap(newMap) {
         if (newMap && typeof newMap === 'object') {
             this.tokenMap = newMap;
-            this.replacer = buildStreamReplacer(this.tokenMap);
+            this.replacer = buildStreamReplacer(this.tokenMap, this.options);
             this.hasTokens = Object.keys(this.tokenMap).length > 0;
             this._lastTokenCount = Object.keys(this.tokenMap).length;
         }
@@ -1465,7 +1493,7 @@ export class StreamingDetokenizer {
         // 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.replacer = buildStreamReplacer(this.tokenMap, this.options);
             this.hasTokens = currentTokenCount > 0;
             this._lastTokenCount = currentTokenCount;
         }
@@ -1474,12 +1502,26 @@ export class StreamingDetokenizer {
 
         this.pendingBuffer += text;
 
-        // Candidate unclosed token at tail of buffer (up to 64 chars)
-        // Matches incomplete tokens starting with [, <, {{, or __
-        const m = this.pendingBuffer.match(/(?:\[|<|\{\{|__)[A-Za-z0-9_\-А-Яа-яЁё ]{0,64}$/);
+        // 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 safeToEmit = this.pendingBuffer.slice(0, m.index);
-            this.pendingBuffer = this.pendingBuffer.slice(m.index);
+            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) : '';
         }
 
@@ -2489,6 +2531,7 @@ export default {
     restore,
     restoreObject,
     unscrub,
+    desanitize,
     validateLicense,
     validateLicenseKey,
     buildAuditTelemetry,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@privacyscrubber/sdk",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "In-process consumer privacy defense and pre-emptive PII interception SDK for Node.js, Next.js, and AI pipelines. Zero data loss, zero third parties, sub-millisecond in-memory execution.",
   "main": "index.js",
   "browser": "browser.js",