@privacyscrubber/sdk 2.2.0 → 2.2.1

package/README.md

@@ -6,6 +6,8 @@
 [![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/)
+[![GitHub Stars](https://img.shields.io/github/stars/moxno/privacyscrubber-mcp?style=social)](https://github.com/moxno/privacyscrubber-mcp)
 
 > **Zero-Trust Data Sanitization (ZTDS) & PII Redaction Engine**  
 > 100% In-Memory Execution. Zero Remote Network Calls. Zero Disk Writes. Sub-millisecond Latency.
@@ -92,6 +94,7 @@ console.log(auditReceipt);
 // > * **Risk Level:** 🟡 MODERATE EXPOSURE
 // > * **Compliance Enforced:** ZTDS Standard, GDPR (Art. 4), CCPA/CPRA
 // > * **Tokens Masked:** 2 (1 NAME, 1 PHONE)
+// > * ⭐ **Star on GitHub:** [moxno/privacyscrubber-mcp](https://github.com/moxno/privacyscrubber-mcp) | **SDK & Enterprise:** [privacyscrubber.com/pricing](https://privacyscrubber.com/pricing)
 
 // 2. Deterministically restore LLM response
 const aiResponse = "I have queued an SMS notification for [NAME_1] at [PHONE_1].";
@@ -103,7 +106,99 @@ console.log(restoredText);
 
 ---
 
-### 3. RAG & Vector Database Ingestion (Pinecone, Chroma, pgvector)
+### 3. Vercel AI SDK Integration (`generateText` & `streamText`)
+
+Drop-in sanitization for Next.js and Node.js applications built with the Vercel AI SDK (`ai`):
+
+```typescript
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { sanitize, restore } from '@privacyscrubber/sdk';
+
+export async function POST(req: Request) {
+    const { prompt } = await req.json();
+
+    // 1. Sanitize user prompt in local RAM (<1ms)
+    const { scrubbedText, tokenMap } = sanitize(prompt, {
+        profile: 'General',
+        detectSecrets: true
+    });
+
+    // 2. Outbound call to LLM contains zero PII or credentials
+    const { text } = await generateText({
+        model: openai('gpt-4o'),
+        prompt: scrubbedText,
+    });
+
+    // 3. Deterministically restore authentic tokens locally
+    const { restoredText } = restore(text, tokenMap);
+
+    return Response.json({ response: restoredText });
+}
+```
+
+---
+
+### 4. LangChain (LCEL Pipelines & `createLangChainTransform`)
+
+Use the official middleware helper or compose inside LangChain Expression Language (LCEL) chains:
+
+```typescript
+import { ChatOpenAI } from '@langchain/openai';
+import { createLangChainTransform, PrivacyScrubberEngine } from '@privacyscrubber/sdk';
+
+// Option A: 1-line middleware helper
+const transform = createLangChainTransform({ defaultProfile: 'Healthcare' });
+const { scrubbedText, tokenMap } = transform.preprocess("Patient John Doe MRN-99120 prescribed Lipitor.");
+// ... invoke LLM with scrubbedText ...
+const restoredOutput = transform.postprocess(llmOutput, tokenMap);
+
+// Option B: Composable LCEL Runnable chain
+const engine = new PrivacyScrubberEngine({ defaultProfile: 'Dev' });
+const model = new ChatOpenAI({ model: 'gpt-4o', temperature: 0 });
+
+const secureChain = async (rawQuestion: string) => {
+    const { scrubbedText, tokenMap } = engine.sanitize(rawQuestion);
+    const response = await model.invoke(scrubbedText);
+    return engine.restore(response.content as string, tokenMap);
+};
+
+const result = await secureChain("Debug AWS_KEY=AKIAIOSFODNN7EXAMPLE for user alice@acme.com");
+```
+
+---
+
+### 5. LlamaIndex.TS (RAG Node Sanitizer)
+
+Prevent PII poisoning in vector stores by sanitizing documents prior to indexing:
+
+```typescript
+import { Document } from 'llamaindex';
+import { sanitize } from '@privacyscrubber/sdk';
+
+// Sanitize documents before vector index ingestion (HIPAA & GDPR safe)
+export function sanitizeDocumentsForIndex(docs: Document[]): Document[] {
+    return docs.map(doc => {
+        const { scrubbedText, telemetry } = sanitize(doc.text, {
+            profile: 'Healthcare', // Masks 18 HIPAA identifiers
+            detectSecrets: true
+        });
+        
+        return new Document({
+            text: scrubbedText,
+            metadata: {
+                ...doc.metadata,
+                psRiskLevel: telemetry.riskLevel,
+                psCompliant: telemetry.frameworksList.join(',')
+            }
+        });
+    });
+}
+```
+
+---
+
+### 6. RAG & Vector Database Ingestion (Pinecone, Chroma, pgvector)
 
 Storing raw PII inside vector embeddings is irreversible and violates GDPR Article 17 (Right to be Forgotten). Sanitize document chunks prior to vectorization:
 
@@ -127,7 +222,7 @@ function prepareVectorChunk(rawDocumentChunk) {
 
 ---
 
-### 4. Stateful Multi-Turn Agent Engine (`PrivacyScrubberEngine`)
+### 7. Stateful Multi-Turn Agent Engine (`PrivacyScrubberEngine`)
 
 Maintain token bindings across multi-step autonomous agent loops (LangChain, AutoGen, CrewAI):
 
@@ -149,7 +244,7 @@ const restored = engine.restore(agentOutputText);
 
 ---
 
-### 5. High-Throughput Stream Sanitization (`createSanitizeStream`)
+### 8. High-Throughput Stream Sanitization (`createSanitizeStream`)
 
 Sanitize massive log files, database dumps, and SSE payloads on-the-fly with <1MB heap memory. Automatically handles split chunk boundaries:
 
@@ -173,7 +268,7 @@ sanitizeStream.on('finish', () => {
 
 ---
 
-### 6. AI Agent Guard & Function Calling (`createGuardedTools`, `applyPatch`)
+### 9. AI Agent Guard & Function Calling (`createGuardedTools`, `applyPatch`)
 
 Equip autonomous agents (Cursor, Vercel AI SDK, OpenAI, LangChain) with safe tools that intercept secrets and restore authentic data on disk:
 
@@ -202,7 +297,7 @@ const patchResult = await guardApplyPatch.execute({
 
 ---
 
-### 7. Automated PR Security Verification Stamp (CI/CD)
+### 10. Automated PR Security Verification Stamp (CI/CD)
 
 Enforce zero plaintext PII and credential leaks in your CI/CD pipeline (GitHub Actions, GitLab CI, Jenkins) before pull requests are merged into production.
 
@@ -312,10 +407,29 @@ To acquire a commercial Developer SDK license:
 - 🔌 **MCP Server**: [@privacyscrubber/mcp-server](https://www.npmjs.com/package/@privacyscrubber/mcp-server)
 - 🧩 **Chrome Extension**: [Chrome Web Store](https://chromewebstore.google.com/detail/privacyscrubber-%E2%80%94-zero-tr/pimoejgefeilajmmbpghifdmhdlkgjol)
 - 📖 **Developer SDK Specs**: [https://privacyscrubber.com/features/developer-sdk/](https://privacyscrubber.com/features/developer-sdk/)
+- ⭐ **GitHub Repository**: [moxno/privacyscrubber-mcp](https://github.com/moxno/privacyscrubber-mcp) (Star us on GitHub!)
 - 🧪 **DLP Latency Benchmark**: [https://privacyscrubber.com/dlp-speed-test/](https://privacyscrubber.com/dlp-speed-test/)
 
+### 📚 Production Architecture Guides
+- 🛡️ **RAG & Vector Databases**: [Sanitizing PII Before Vector DB Ingestion (Pinecone, Chroma, Qdrant)](https://privacyscrubber.com/solutions/dev/rag-vector-database-pii-masking/)
+- 🤖 **LangChain & LlamaIndex**: [In-Memory PII Middleware for AI Agent Pipelines](https://privacyscrubber.com/solutions/agents/langchain-llamaindex-pii-anonymizer/)
+- ⚡ **AWS Comprehend Alternative**: [In-Memory Redaction Without Egress or Cloud Overhead](https://privacyscrubber.com/solutions/dev/aws-comprehend-pii-alternative/)
+
 ---
 
 ## ⚖️ License
 
 MIT License © 2026 PrivacyScrubber. Commercial production usage without quota limits requires an active Developer SDK or Enterprise license.
+
+---
+
+## 🏛️ Intellectual Property & Virtual Patent Marking
+
+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`)
+- **Filing / Priority Date:** September 14, 2026 (Paris Convention Art. 4 & 35 U.S.C. § 119 Priority)
+- **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).
+

package/index.d.ts

@@ -287,6 +287,61 @@ export function restoreToFile(filePath: string, content: string, tokenMapOrOptio
  */
 export function createGuardedTools(engineOrOptions?: PrivacyScrubberEngine | SanitizeOptions, toolConfig?: { cwd?: string; profile?: PiiProfile }): GuardedTools;
 
+/**
+ * Stream token restorer interface for zero-latency SSE chunk processing.
+ */
+export interface StreamTokenRestorer {
+    /** Pushes an incoming streaming chunk and returns immediately rehydrated text. */
+    push(chunk: string): string;
+    /** Flushes any buffered incomplete tokens at the end of the stream. */
+    flush(): string;
+    /** Returns a standard Web W3C TransformStream for piping Response streams. */
+    asTransformStream(): any;
+}
+
+/**
+ * Ergonomic 1-liner: string-in, sanitized string-out without metadata ceremonies.
+ * @param text - Plaintext prompt containing potential PII/secrets.
+ * @param profile - Compliance profile (Default: 'General').
+ * @returns Scrubbed string ready to send to LLM.
+ */
+export function clean(text: string, profile?: PiiProfile): string;
+
+/**
+ * Creates a stream token restorer that rehydrates masked tokens across chunk boundaries in real-time.
+ * @param tokenMap - Map of token bindings returned from sanitize().
+ */
+export function createStreamTokenRestorer(tokenMap?: Record<string, string>): StreamTokenRestorer;
+
+/**
+ * Wraps an AI streaming response (e.g. OpenAI stream, Vercel AI SDK textStream)
+ * and yields real-time plain chunks with all tokens restored on the fly.
+ * @param stream - AsyncIterable or ReadableStream of string chunks or delta objects.
+ * @param tokenMap - Map of token bindings returned from sanitize().
+ */
+export function wrapAiStream<T = any>(
+    stream: AsyncIterable<T> | any,
+    tokenMap: Record<string, string>
+): AsyncGenerator<string, void, unknown>;
+
+/**
+ * Zero-Trust wrapper for Next.js App Router Route Handlers (route.js / route.ts).
+ * Automatically intercepts incoming Request JSON body, sanitizes PII in RAM,
+ * and passes scrubbed body along with tokenMap and stream restorer factory.
+ */
+export function withPrivacyScrubber(
+    handler: (req: Request, context?: any, psContext?: { tokenMap: Record<string, string>; telemetry: AuditTelemetry; createStreamRestorer: () => StreamTokenRestorer }) => any,
+    options?: SanitizeOptions
+): (req: Request, context?: any) => Promise<any>;
+
+/**
+ * Express.js / Connect middleware for automatic zero-trust PII sanitization.
+ * Sanitizes req.body in local RAM and attaches req.psTokenMap, req.restore(), and req.createStreamRestorer().
+ */
+export function createExpressMiddleware(
+    options?: SanitizeOptions
+): (req: any, res: any, next: (err?: any) => void) => void;
+
 // Legacy exports
 export function scrubText(
     text: string,
@@ -311,10 +366,15 @@ export function unscrubText(
 };
 
 declare const defaultExport: {
+    clean: typeof clean;
     sanitize: typeof sanitize;
     scrub: typeof scrub;
     restore: typeof restore;
     unscrub: typeof unscrub;
+    createStreamTokenRestorer: typeof createStreamTokenRestorer;
+    wrapAiStream: typeof wrapAiStream;
+    withPrivacyScrubber: typeof withPrivacyScrubber;
+    createExpressMiddleware: typeof createExpressMiddleware;
     validateLicense: typeof validateLicense;
     validateLicenseKey: typeof validateLicenseKey;
     buildAuditTelemetry: typeof buildAuditTelemetry;
@@ -332,3 +392,4 @@ declare const defaultExport: {
 };
 
 export default defaultExport;
+

package/index.js

@@ -164,7 +164,8 @@ export function buildAuditTelemetry(currentTokenMap = {}) {
  */
 export function formatAuditReceipt(telemetry) {
     if (!telemetry || telemetry.totalCount === 0) {
-        return "> 🛡️ **PrivacyScrubber Audit Receipt**: CLEAN (ZERO PII DETECTED)\n";
+        return "> 🛡️ **PrivacyScrubber Audit Receipt**: CLEAN (ZERO PII DETECTED)\n" +
+               "> * ⭐ **Star on GitHub:** [moxno/privacyscrubber-mcp](https://github.com/moxno/privacyscrubber-mcp) | **SDK & Enterprise:** [privacyscrubber.com/pricing](https://privacyscrubber.com/pricing)\n";
     }
     const entitiesList = Object.entries(telemetry.entities)
         .map(([type, count]) => `${count} ${type}`)
@@ -175,22 +176,42 @@ export function formatAuditReceipt(telemetry) {
     return `> 🛡️ **PrivacyScrubber Audit Receipt**\n` +
            `> * **Risk Level:** ${icon} ${telemetry.riskLevel}\n` +
            `> * **Compliance Enforced:** ${telemetry.frameworksList.join(', ')}\n` +
-           `> * **Tokens Masked:** ${telemetry.totalCount} (${entitiesList})\n`;
+           `> * **Tokens Masked:** ${telemetry.totalCount} (${entitiesList})\n` +
+           `> * ⭐ **Star on GitHub:** [moxno/privacyscrubber-mcp](https://github.com/moxno/privacyscrubber-mcp) | **SDK & Enterprise:** [privacyscrubber.com/pricing](https://privacyscrubber.com/pricing)\n`;
+}
+
+let communityNoticeLogged = false;
+
+function emitCommunityNoticeIfNeeded(isPro) {
+    if (communityNoticeLogged || isPro) return;
+    if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'production') {
+        communityNoticeLogged = true;
+        console.info('[@privacyscrubber/sdk] Running Community Edition (Core PII).\nTo unlock 25 Enterprise Profiles & DevOps Secrets in production: https://privacyscrubber.com/pricing/?tier=sdk');
+    }
+}
+
+/**
+ * Resets the community notice state for testing purposes.
+ * @private
+ */
+export function _resetCommunityNoticeForTesting() {
+    communityNoticeLogged = false;
 }
 
 /**
- * Primary High-Level Function: Sanitize / Scrub text of PII and secrets.
+ * Sanitizes input text, masking detected PII & secrets with reversible tokens.
  * 
- * @param {string} text - Raw input text containing potential PII/secrets.
- * @param {object} [options={}] - Configuration options.
- * @param {string} [options.profile='General'] - PII Profile (General, Dev, Medical, Financial, Legal, HR, etc.).
+ * @param {string} text - Raw input text.
+ * @param {object} [options={}] - Sanitization options.
+ * @param {string} [options.profile='General'] - Compliance detection profile.
  * @param {string} [options.licenseKey] - Optional license key. Falls back to process.env.PRIVACYSCRUBBER_KEY.
- * @param {Array} [options.customRules=[]] - Custom regex rules array.
- * @param {Record<string, string>} [options.tokenLabelMap={}] - Custom label overrides.
- * @param {Record<string, string>} [options.existingSessionMap={}] - Session map to maintain consistency across turns.
- * @param {boolean} [options.generateReceipt=true] - Whether to generate Markdown audit receipt.
+ * @param {Array<{name: string, pattern: string, regex: RegExp, label?: string}>} [options.customRules=[]] - Custom regex rules.
+ * @param {Record<string, string>} [options.tokenLabelMap={}] - Custom label mapping.
+ * @param {Record<string, string>} [options.existingSessionMap={}] - In-memory session map to preserve token IDs across turns.
+ * @param {boolean} [options.generateReceipt=true] - Generate a CISO Markdown audit receipt.
  * @param {boolean} [options.throwOnLimit=true] - Throw PrivacyScrubberLicenseError when free tier limit is hit.
- * @param {boolean} [options.detectSecrets=false] - Auto-inject DevOps & Cloud secrets detection rules.
+ * @param {boolean} [options.detectSecrets=false] - Auto-detect cloud credentials and API keys.
+ * @param {Set<string>|Array<string>} [options.ignoreList=null] - Values to preserve in cleartext.
  * @returns {{
  *   scrubbedText: string,
  *   tokenMap: Record<string, string>,
@@ -230,6 +251,8 @@ export function sanitize(text, options = {}) {
     const isPro = licenseCheck.valid;
     const tier = isPro ? licenseCheck.tier : 'FREE';
 
+    emitCommunityNoticeIfNeeded(isPro);
+
     const isSpecialized = profile && profile.toLowerCase() !== 'general';
     const limit = isPro ? Infinity : (isSpecialized ? 5000 : 15000);
 
@@ -306,6 +329,18 @@ export function sanitize(text, options = {}) {
  */
 export const scrub = sanitize;
 
+/**
+ * Ergonomic 1-liner: Sanitizes text and returns the scrubbed string directly.
+ * @param {string} text - Input text.
+ * @param {string} [profile='General'] - Target compliance profile.
+ * @returns {string} - Scrubbed string.
+ */
+export function clean(text, profile = 'General') {
+    if (!text || typeof text !== 'string') return '';
+    const { scrubbedText } = sanitize(text, { profile });
+    return scrubbedText;
+}
+
 /**
  * Primary High-Level Function: Restore / Unscrub AI response back to original entities in-memory.
  * 
@@ -490,6 +525,198 @@ export function createLangChainTransform(options = {}) {
     };
 }
 
+/**
+ * Creates a zero-latency streaming token restorer for LLM Server-Sent Events (SSE) and Web Streams.
+ * Solves the broken chunk boundary problem where tokens like [EMAIL_1] are split across multiple chunks.
+ * 
+ * Works with:
+ * - Vercel AI SDK (streamText / createDataStreamResponse)
+ * - OpenAI streaming (chat.completions.create({ stream: true }))
+ * - LangChain streaming
+ * - Native Web Streams (ReadableStream.pipeThrough)
+ * - Async generators (for await ... of)
+ * 
+ * @param {Record<string, string>} tokenMap - Volatile token mapping object.
+ * @param {object} [options] - Configuration options.
+ * @returns {TransformStream & { process: (chunk: string) => string, flush: () => string, wrapStream: (asyncIterable: AsyncIterable<string>) => AsyncGenerator<string> }}
+ */
+export function createStreamTokenRestorer(tokenMap = {}, options = {}) {
+    let pendingBuffer = '';
+    const map = tokenMap && typeof tokenMap === 'object' ? tokenMap : {};
+
+    function directRestore(text) {
+        if (!text) return '';
+        let result = text;
+        for (const token in map) {
+            if (result.includes(token)) {
+                result = result.split(token).join(map[token]);
+            }
+        }
+        return result;
+    }
+
+    function processChunk(chunk) {
+        if (!chunk || typeof chunk !== 'string') return '';
+        pendingBuffer += chunk;
+
+        // Check if there is an unclosed potential token bracket at the tail of the buffer.
+        // Token format: [TYPE_INDEX] or [CUSTOM_NAME] e.g. [EMAIL_1], [NAME_2], [SECRET_1]
+        const lastOpenIdx = pendingBuffer.lastIndexOf('[');
+        const lastCloseIdx = pendingBuffer.lastIndexOf(']');
+
+        if (lastOpenIdx !== -1 && lastOpenIdx > lastCloseIdx) {
+            const partial = pendingBuffer.slice(lastOpenIdx);
+            if (/^\[[A-Za-z0-9_]*$/.test(partial) && partial.length <= 64) {
+                const safeToEmit = pendingBuffer.slice(0, lastOpenIdx);
+                pendingBuffer = partial;
+                if (safeToEmit) {
+                    return directRestore(safeToEmit);
+                }
+                return '';
+            }
+        }
+
+        const textToRestore = pendingBuffer;
+        pendingBuffer = '';
+        return directRestore(textToRestore);
+    }
+
+    function flushBuffer() {
+        if (!pendingBuffer) return '';
+        const remaining = pendingBuffer;
+        pendingBuffer = '';
+        return directRestore(remaining);
+    }
+
+    async function* wrapStream(asyncIterable) {
+        for await (const chunk of asyncIterable) {
+            const text = typeof chunk === 'string' ? chunk : (chunk?.text || chunk?.content || '');
+            const emitted = processChunk(text);
+            if (emitted) yield emitted;
+        }
+        const finalChunk = flushBuffer();
+        if (finalChunk) yield finalChunk;
+    }
+
+    let stream;
+    if (typeof TransformStream !== 'undefined') {
+        stream = new TransformStream({
+            transform(chunk, controller) {
+                const text = typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk);
+                const out = processChunk(text);
+                if (out) controller.enqueue(out);
+            },
+            flush(controller) {
+                const out = flushBuffer();
+                if (out) controller.enqueue(out);
+            }
+        });
+    } else {
+        stream = {};
+    }
+
+    stream.process = processChunk;
+    stream.flush = flushBuffer;
+    stream.wrapStream = wrapStream;
+
+    return stream;
+}
+
+/**
+ * Wraps an async iterable LLM stream (e.g. from Vercel AI SDK textStream or OpenAI stream)
+ * and yields de-tokenized text chunks in real-time, seamlessly stitching split tokens across chunks.
+ * 
+ * @param {AsyncIterable<string|object>} stream - The incoming LLM stream.
+ * @param {Record<string, string>} tokenMap - Volatile token map.
+ * @returns {AsyncGenerator<string>}
+ */
+export async function* wrapAiStream(stream, tokenMap = {}) {
+    const restorer = createStreamTokenRestorer(tokenMap);
+    yield* restorer.wrapStream(stream);
+}
+
+/**
+ * Middleware wrapper for Next.js App Router Route Handlers (POST/PUT).
+ * Automatically sanitizes incoming prompt payloads in RAM (<1ms) before the handler runs,
+ * and attaches sanitized text, tokenMap, and helper restoration functions.
+ * 
+ * @param {Function} handler - The async Next.js route handler (req, context) => Response
+ * @param {object} [options] - Sanitization options (profile, detectSecrets, etc.)
+ * @returns {Function} Wrapped Next.js route handler
+ */
+export function withPrivacyScrubber(handler, options = {}) {
+    return async function privacyScrubberHandler(req, context = {}) {
+        if (!req || typeof req.json !== 'function') {
+            return handler(req, context);
+        }
+
+        let rawBody;
+        try {
+            rawBody = await req.json();
+        } catch (_) {
+            return handler(req, context);
+        }
+
+        let scrubbedBody = rawBody;
+        let tokenMap = {};
+        let telemetry = null;
+
+        if (typeof rawBody === 'string') {
+            const res = sanitize(rawBody, options);
+            scrubbedBody = res.scrubbedText;
+            tokenMap = res.tokenMap;
+            telemetry = res.telemetry;
+        } else if (rawBody && typeof rawBody === 'object') {
+            const serialized = JSON.stringify(rawBody);
+            const res = sanitize(serialized, options);
+            try {
+                scrubbedBody = JSON.parse(res.scrubbedText);
+            } catch (_) {
+                scrubbedBody = rawBody;
+            }
+            tokenMap = res.tokenMap;
+            telemetry = res.telemetry;
+        }
+
+        const psContext = {
+            ...context,
+            rawBody,
+            scrubbedBody,
+            tokenMap,
+            telemetry,
+            restore: (text) => restore(text, tokenMap),
+            createStreamRestorer: () => createStreamTokenRestorer(tokenMap)
+        };
+
+        return handler(req, psContext);
+    };
+}
+
+/**
+ * Express.js / Connect middleware for automatic zero-trust PII sanitization.
+ * Sanitizes req.body in local RAM and attaches req.psTokenMap and req.restore(aiResponse).
+ * 
+ * @param {object} [options] - Sanitization options.
+ * @returns {Function} Express middleware (req, res, next)
+ */
+export function createExpressMiddleware(options = {}) {
+    return function privacyScrubberExpress(req, res, next) {
+        if (req && req.body && typeof req.body === 'object') {
+            const serialized = JSON.stringify(req.body);
+            const { scrubbedText, tokenMap, telemetry } = sanitize(serialized, options);
+            req.rawBody = req.body;
+            try {
+                req.body = JSON.parse(scrubbedText);
+            } catch (_) {}
+            req.psTokenMap = tokenMap;
+            req.psTelemetry = telemetry;
+            req.restore = (aiResponse) => restore(aiResponse, tokenMap);
+            req.createStreamRestorer = () => createStreamTokenRestorer(tokenMap);
+        }
+        if (typeof next === 'function') next();
+    };
+}
+
 /**
  * Generates an official Zero-Trust Compliance Audit Report.
  * @param {Record<string, string>} sessionMap - Map of token bindings.
@@ -921,6 +1148,7 @@ export const unscrubText = scrubberPkg.unscrubText;
 export default {
     sanitize,
     scrub,
+    clean,
     restore,
     unscrub,
     validateLicense,
@@ -932,6 +1160,10 @@ export default {
     PrivacyScrubberLicenseError,
     wrapOpenAI,
     createLangChainTransform,
+    createStreamTokenRestorer,
+    wrapAiStream,
+    withPrivacyScrubber,
+    createExpressMiddleware,
     createSanitizeStream,
     applyPatch,
     restoreToFile,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@privacyscrubber/sdk",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Zero-dependency, in-memory PII & secrets redaction SDK for Node.js, Next.js, OpenAI, and LangChain. 100% client-side & server-side zero-trust prompt anonymization under 1ms.",
   "main": "index.js",
   "types": "index.d.ts",