n8n-nodes-redactor 4.0.0 → 4.1.0

package/README.md

@@ -110,7 +110,7 @@ Data source > Detect > Redact > LLM > Verify > Restore > Output > Purge
 | Deduplication | The same value gets the same token everywhere, so the model keeps relationships between fields |
 | Field targeting | Allowlist or denylist paths such as `user.email`, `*.phone` or `metadata.*` |
 | Vault | Workflow Storage by default, so Restore works in later production runs of the same workflow, or In-Memory. Sessions expire after 60 minutes by default |
-| Vault encryption | AES-256-GCM with scrypt key derivation, one passphrase per tenant |
+| Vault encryption | AES-256-GCM with scrypt key derivation, one passphrase per tenant, kept in a Redactor Vault credential. See [Vault encryption](#vault-encryption) |
 | Confidence threshold | Each match carries a 0.0 to 1.0 score. Checksum validated patterns score 0.95 |
 | Allow and deny lists | Values to never redact, such as your support address, and values to always redact, such as project codenames |
 | Prompt injection check | 25+ patterns, including instruction overrides, delimiter escapes, encoded payloads and zero width characters. Returns BLOCK, FLAG or CLEAN |
@@ -122,6 +122,20 @@ Data source > Detect > Redact > LLM > Verify > Restore > Output > Purge
 
 This node reduces what reaches a model. It is not legal advice and does not on its own make a workflow GDPR or HIPAA compliant.
 
+## Vault encryption
+
+Workflow Storage keeps sessions with the workflow. To encrypt them, create a **Redactor Vault** credential with a passphrase of at least 12 characters and attach it to both the Redact and the Restore node. n8n stores credentials encrypted and apart from the workflow, so the passphrase never sits next to the data it protects. Give each tenant its own credential.
+
+The older Vault Encryption Passphrase field still works so workflows saved with it keep restoring, but it is saved in plain text inside the workflow. When both are set, the credential wins.
+
+Restore needs the same passphrase that Redact used. If Redact meets a session ID that a different passphrase wrote, it stops with an error instead of overwriting it.
+
+### Concurrent runs
+
+n8n saves workflow storage as one block at the end of each production run and does not merge it. If two runs of the same workflow overlap, the one that finishes last wins. A session created by the other run can be lost, and a session purged by the other run can come back until its TTL expires. The node cannot prevent this from inside n8n. To stay safe, keep the Session TTL short, avoid overlapping runs of a workflow that uses Purge (for example by limiting production concurrency on your instance), or use In-Memory storage when Redact and Restore run in the same execution.
+
+In-Memory sessions are kept per workflow and are never visible to another workflow.
+
 ## For developers
 
 | Area | Detail |

package/dist/credentials/RedactorVaultApi.credentials.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedactorVaultApi = void 0;
+class RedactorVaultApi {
+    constructor() {
+        this.name = 'redactorVaultApi';
+        this.displayName = 'Redactor Vault API';
+        this.icon = { light: 'file:redactorVault.svg', dark: 'file:redactorVault.dark.svg' };
+        this.documentationUrl = 'https://github.com/mjmirza/n8n-nodes-redactor#vault-encryption';
+        this.properties = [
+            {
+                displayName: 'Vault Passphrase',
+                name: 'passphrase',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'Encrypts stored sessions with AES-256-GCM. Use at least 12 characters, and a different passphrase for each tenant. Sessions written with this passphrase cannot be read without it.',
+            },
+        ];
+    }
+}
+exports.RedactorVaultApi = RedactorVaultApi;

package/dist/credentials/redactorVault.dark.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="60" height="60" viewBox="16 15 370 370"><g transform="translate(0,400) scale(0.1,-0.1)"><path fill="#FF6B6B" d="M1880 3520 c-200 -204 -414 -321 -714 -390 l-99 -23 6 -171 c6 -183 24 -288 71 -431 55 -163 163 -360 258 -469 34 -40 34 -40 68 18 145 254 391 434 638 467 416 56 762 -273 883 -841 23 -108 34 -413 17 -485 -17 -70 105 200 146 325 116 350 145 599 146 1221 l0 346 -162 6 c-420 16 -743 151 -1016 424 -68 68 -124 123 -125 122 -1 0 -54 -54 -117 -119z"/><path fill="#FFA42E" d="M703 2628 c6 -546 24 -707 113 -1015 177 -610 573 -1066 1070 -1232 113 -38 115 -38 224 -1 193 64 391 184 472 285 339 421 307 1184 -66 1532 -157 147 -364 176 -528 72 -51 -33 -118 -109 -82 -94 101 42 155 43 241 5 254 -112 199 -491 -85 -601 -265 -103 -614 59 -864 401 -206 281 -312 593 -325 958 l-6 152 -84 0 -85 0 5 -462z"/></g></svg>

package/dist/credentials/redactorVault.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="60" height="60" viewBox="16 15 370 370"><g transform="translate(0,400) scale(0.1,-0.1)"><path fill="#FF5757" d="M1880 3520 c-200 -204 -414 -321 -714 -390 l-99 -23 6 -171 c6 -183 24 -288 71 -431 55 -163 163 -360 258 -469 34 -40 34 -40 68 18 145 254 391 434 638 467 416 56 762 -273 883 -841 23 -108 34 -413 17 -485 -17 -70 105 200 146 325 116 350 145 599 146 1221 l0 346 -162 6 c-420 16 -743 151 -1016 424 -68 68 -124 123 -125 122 -1 0 -54 -54 -117 -119z"/><path fill="#F79410" d="M703 2628 c6 -546 24 -707 113 -1015 177 -610 573 -1066 1070 -1232 113 -38 115 -38 224 -1 193 64 391 184 472 285 339 421 307 1184 -66 1532 -157 147 -364 176 -528 72 -51 -33 -118 -109 -82 -94 101 42 155 43 241 5 254 -112 199 -491 -85 -601 -265 -103 -614 59 -864 401 -206 281 -312 593 -325 958 l-6 152 -84 0 -85 0 5 -462z"/></g></svg>

package/dist/nodes/Redactor/Redactor.node.js

@@ -11,6 +11,7 @@ const audit_1 = require("./audit");
 const presidio_1 = require("./presidio");
 const profiles_1 = require("./profiles");
 const ropa_1 = require("./ropa");
+const runtime_1 = require("./runtime");
 const RECOMMENDED_PATTERNS = [
     'email', 'phone', 'phoneDE', 'phoneUK', 'phoneAT', 'phoneCH', 'phoneFR',
     'phoneNL', 'phoneES', 'phoneIT', 'phoneAU', 'phoneIN', 'phoneBR',
@@ -57,6 +58,19 @@ class Redactor {
                 name: 'Redactor',
             },
             inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [
+                {
+                    name: 'redactorVaultApi',
+                    required: false,
+                    testedBy: 'redactorVaultPassphrase',
+                    displayOptions: {
+                        show: {
+                            operation: ['redact', 'restore', 'stats', 'purge'],
+                            vaultStorage: ['workflow', 'file'],
+                        },
+                    },
+                },
+            ],
             outputs: `={{((parameters) => (parameters["includeReport"] || parameters["auditLog"]) ? [{ type: "main", displayName: "Data" }, { type: "main", displayName: "Report" }] : [{ type: "main", displayName: "Data" }])($parameter)}}`,
             properties: [
                 {
@@ -601,7 +615,7 @@ class Redactor {
                         },
                     },
                     default: '',
-                    description: 'Encrypt stored sessions at rest with AES-256-GCM. Leave empty for no encryption. When set, sessions cannot be read without this passphrase. Each tenant should use a different passphrase for complete isolation.',
+                    description: 'Deprecated. This field is saved in plain text inside the workflow. Attach a Redactor Vault credential instead, which n8n stores encrypted and which takes priority. Kept so workflows saved with it still restore.',
                 },
                 {
                     displayName: 'Session TTL (Minutes)',
@@ -739,6 +753,18 @@ class Redactor {
                 },
             ],
         };
+        this.methods = {
+            credentialTest: {
+                async redactorVaultPassphrase(credential) {
+                    var _a, _b;
+                    const passphrase = String((_b = (_a = credential.data) === null || _a === void 0 ? void 0 : _a.passphrase) !== null && _b !== void 0 ? _b : '');
+                    if (passphrase.length < 12) {
+                        return { status: 'Error', message: 'Use a passphrase of at least 12 characters.' };
+                    }
+                    return { status: 'OK', message: 'Passphrase accepted.' };
+                },
+            },
+        };
     }
     async execute() {
         var _a, _b, _c, _d, _e, _f, _g;
@@ -761,6 +787,7 @@ class Redactor {
                 fieldRules: [],
                 fieldMode: 'all',
                 skipSemantic: operation === 'verify',
+                scanNumbers: true,
             };
             const allHits = [];
             for (let i = 0; i < items.length; i++) {
@@ -859,14 +886,9 @@ class Redactor {
                     }]];
         }
         const vaultStorage = this.getNodeParameter('vaultStorage', 0, 'workflow');
-        let vaultPassphrase = '';
-        try {
-            vaultPassphrase = this.getNodeParameter('vaultPassphrase', 0, '');
-        }
-        catch { }
-        const vault = (0, vault_1.createVault)(vaultStorage, vaultStorage === 'memory' ? undefined : this.getWorkflowStaticData('global'), vaultPassphrase || undefined);
+        const vaultPassphrase = vaultStorage === 'memory' ? '' : await (0, runtime_1.resolvePassphrase)(this);
+        const vault = (0, vault_1.createVault)(vaultStorage, vaultStorage === 'memory' ? undefined : this.getWorkflowStaticData('global'), vaultPassphrase || undefined, (0, runtime_1.workflowNamespace)(this));
         if (operation === 'stats') {
-            vault.cleanup();
             const sessions = vault.listSessions();
             const totalEntries = sessions.reduce((sum, s) => sum + s.entryCount, 0);
             return [[
@@ -991,7 +1013,16 @@ class Redactor {
                 if (profile.auditLog !== undefined)
                     auditLog = profile.auditLog;
             }
-            vault.getOrCreateSession(sessionId, sessionTtl * 60 * 1000);
+            (0, runtime_1.assertUserRegexes)(this, customPatterns, [
+                { name: 'Allow list', entries: allowList },
+                { name: 'Deny list', entries: denyList },
+            ]);
+            try {
+                vault.getOrCreateSession(sessionId, sessionTtl * 60 * 1000);
+            }
+            catch (error) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error.message);
+            }
             const ctx = {
                 enabledPatterns,
                 customPatterns,
@@ -1030,7 +1061,7 @@ class Redactor {
                     for (let i = 0; i < items.length; i++) {
                         const result = (0, injection_1.scanForInjection)(items[i].json);
                         if (result.detected && (!injectionResult || result.score > injectionResult.score)) {
-                            injectionResult = result;
+                            injectionResult = (0, runtime_1.sanitizeInjection)(result);
                         }
                     }
                 }
@@ -1065,7 +1096,7 @@ class Redactor {
             const deleteAfterRestore = this.getNodeParameter('deleteAfterRestore', 0, true);
             const session = vault.getSession(sessionId);
             if (!session) {
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No vault found for session "${sessionId}". Ensure a Redact node ran first with the same Session ID and vault storage type.`, {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No vault found for session "${sessionId}" that this passphrase can open. Ensure a Redact node ran first with the same Session ID, vault storage type and passphrase.`, {
                     description: 'Testing step by step? Each "Execute step" gets a new execution ID, and n8n saves workflow storage only after production runs of an active workflow. Run the whole workflow, or set the same fixed Session ID (for example "test-1") on both nodes. Restore only works in the workflow that ran Redact.',
                 });
             }

package/dist/nodes/Redactor/engine.js

@@ -39,6 +39,7 @@ exports.enhanceWithPresidio = enhanceWithPresidio;
 exports.buildReport = buildReport;
 const crypto = __importStar(require("crypto"));
 const patterns_1 = require("./patterns");
+const regexSafety_1 = require("./regexSafety");
 const context_1 = require("./context");
 const names_1 = require("./names");
 const pseudonymize_1 = require("./pseudonymize");
@@ -95,55 +96,53 @@ function maskValue(value, label) {
 function hashValue(value) {
     return crypto.createHash('sha256').update(value).digest('hex').slice(0, 12);
 }
+function storeReversible(match, pattern, vault, sessionId, dedup, makeToken) {
+    if (dedup) {
+        const existing = vault.findByOriginal(sessionId, match);
+        if (existing)
+            return existing.token;
+    }
+    const token = makeToken();
+    vault.addEntry(sessionId, {
+        token,
+        original: match,
+        patternLabel: pattern.label,
+        category: ('category' in pattern ? pattern.category : 'identity'),
+        createdAt: new Date().toISOString(),
+    });
+    return token;
+}
+const IRREVERSIBLE = {
+    mask: (match, label) => maskValue(match, label),
+    hash: (match, label) => `[${label}:${hashValue(match)}]`,
+    redact: () => '[REDACTED]',
+    blackout: (match) => '\u2588'.repeat(match.length),
+    remove: () => '',
+};
 function applyRedaction(match, pattern, mode, vault, sessionId, dedup) {
-    switch (mode) {
-        case 'token': {
-            if (dedup) {
-                const existing = vault.findByOriginal(sessionId, match);
-                if (existing)
-                    return existing.token;
-            }
+    if (mode === 'token') {
+        return storeReversible(match, pattern, vault, sessionId, dedup, () => {
             const session = vault.getSession(sessionId);
-            const index = session ? Object.keys(session.entries).length : 0;
-            const token = generateToken(pattern.label, index);
-            vault.addEntry(sessionId, {
-                token,
-                original: match,
-                patternLabel: pattern.label,
-                category: ('category' in pattern ? pattern.category : 'identity'),
-                createdAt: new Date().toISOString(),
-            });
-            return token;
-        }
-        case 'mask':
-            return maskValue(match, pattern.label);
-        case 'hash':
-            return `[${pattern.label}:${hashValue(match)}]`;
-        case 'redact':
-            return `[REDACTED]`;
-        case 'blackout':
-            return '\u2588'.repeat(match.length);
-        case 'remove':
-            return '';
-        case 'pseudonymize': {
-            if (dedup) {
-                const existing = vault.findByOriginal(sessionId, match);
-                if (existing)
-                    return existing.token;
-            }
-            const pseudonym = (0, pseudonymize_1.generatePseudonym)(sessionId, match, pattern.label);
-            vault.addEntry(sessionId, {
-                token: pseudonym,
-                original: match,
-                patternLabel: pattern.label,
-                category: ('category' in pattern ? pattern.category : 'identity'),
-                createdAt: new Date().toISOString(),
-            });
-            return pseudonym;
-        }
-        default:
-            return match;
+            return generateToken(pattern.label, session ? Object.keys(session.entries).length : 0);
+        });
     }
+    if (mode === 'pseudonymize') {
+        return storeReversible(match, pattern, vault, sessionId, dedup, () => uniquePseudonym(vault, sessionId, match, pattern.label));
+    }
+    const irreversible = IRREVERSIBLE[mode];
+    return irreversible ? irreversible(match, pattern.label) : match;
+}
+function uniquePseudonym(vault, sessionId, original, label) {
+    var _a, _b;
+    const entries = (_b = (_a = vault.getSession(sessionId)) === null || _a === void 0 ? void 0 : _a.entries) !== null && _b !== void 0 ? _b : {};
+    for (let attempt = 0; attempt < 32; attempt++) {
+        const seed = attempt === 0 ? original : `${original}\u0000${attempt}`;
+        const candidate = (0, pseudonymize_1.generatePseudonym)(sessionId, seed, label);
+        const taken = entries[candidate];
+        if (!taken || taken.original === original)
+            return candidate;
+    }
+    return generateToken(label, Object.keys(entries).length);
 }
 function shouldProcessField(fieldPath, fieldMode, fieldRules) {
     if (fieldMode === 'all')
@@ -169,17 +168,7 @@ function fieldPathMatches(actual, pattern) {
     }
 }
 function isSafeRegex(regexStr) {
-    if (/(\+|\*|\?|\{[^}]+\})\s*(\+|\*|\?|\{)/.test(regexStr))
-        return false;
-    if (regexStr.length > 500)
-        return false;
-    try {
-        new RegExp(regexStr);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return (0, regexSafety_1.checkRegex)(regexStr) === null;
 }
 const SEMANTIC_FIELD_MAP = [
     {
@@ -386,70 +375,87 @@ function getSemanticLabel(fieldKey, siblingKeys) {
     }
     return null;
 }
-function redactValue(value, ctx, vault, sessionId, hits, itemIndex, currentPath = '', siblingKeys) {
-    var _a, _b;
+function redactSemantic(raw, ctx, vault, sessionId, hits, itemIndex, path, display, siblingKeys) {
+    var _a;
+    const semantic = getSemanticLabel(path, siblingKeys);
+    if (!semantic || !semantic.label || raw.trim().length === 0)
+        return null;
+    if (isAllowListed(raw, ctx.allowList))
+        return null;
+    const semConf = semantic.label === 'IDENTIFIER' ? context_1.AMBIGUOUS_FIELD_CONFIDENCE : context_1.SEMANTIC_CONFIDENCE;
+    if (semConf < ((_a = ctx.confidenceThreshold) !== null && _a !== void 0 ? _a : 0))
+        return null;
+    const replacement = applyRedaction(raw, { label: semantic.label, category: semantic.category }, ctx.mode, vault, sessionId, ctx.dedup);
+    hits.push({
+        token: replacement, original: '***',
+        patternName: `semantic_${semantic.label}`,
+        patternLabel: semantic.label,
+        category: semantic.category,
+        field: display, itemIndex,
+        confidence: semConf,
+    });
+    return replacement;
+}
+function redactNumber(value, ctx, vault, sessionId, hits, itemIndex, path, display, siblingKeys) {
+    const text = String(value);
+    if (!ctx.skipSemantic) {
+        const semantic = redactSemantic(text, ctx, vault, sessionId, hits, itemIndex, path, display, siblingKeys);
+        if (semantic !== null)
+            return semantic;
+    }
+    if (!ctx.scanNumbers)
+        return value;
+    const scanned = redactText(text, ctx, vault, sessionId, hits, itemIndex, display);
+    return scanned === text ? value : scanned;
+}
+function redactKey(key, taken, ctx, vault, sessionId, itemIndex, keyHits) {
+    let out = redactText(key, ctx, vault, sessionId, keyHits, itemIndex, '');
+    if (out === key)
+        return key;
+    const base = out;
+    for (let n = 1; out === '' || out in taken; n++)
+        out = `${base}_${n}`;
+    return out;
+}
+function redactObject(value, ctx, vault, sessionId, hits, itemIndex, path, display) {
+    const entries = Object.entries(value);
+    const siblingKeys = entries.map(([k]) => k);
+    const obj = {};
+    for (const [k, v] of entries) {
+        const fieldPath = path ? `${path}.${k}` : k;
+        const keyHits = [];
+        const outKey = shouldProcessField(fieldPath, ctx.fieldMode, ctx.fieldRules)
+            ? redactKey(k, obj, ctx, vault, sessionId, itemIndex, keyHits)
+            : k;
+        const childDisplay = display ? `${display}.${outKey}` : outKey;
+        for (const h of keyHits)
+            hits.push({ ...h, field: childDisplay });
+        obj[outKey] = redactValue(v, ctx, vault, sessionId, hits, itemIndex, fieldPath, siblingKeys, childDisplay);
+    }
+    return obj;
+}
+function redactValue(value, ctx, vault, sessionId, hits, itemIndex, currentPath = '', siblingKeys, displayPath = currentPath) {
+    const processed = shouldProcessField(currentPath, ctx.fieldMode, ctx.fieldRules);
     if (typeof value === 'string') {
-        if (!shouldProcessField(currentPath, ctx.fieldMode, ctx.fieldRules)) {
+        if (!processed)
             return value;
-        }
         if (!ctx.skipSemantic) {
-            const semantic = getSemanticLabel(currentPath, siblingKeys);
-            if (semantic && semantic.label && value.trim().length > 0) {
-                if (isAllowListed(value, ctx.allowList)) {
-                }
-                else {
-                    const semConf = semantic.label === 'IDENTIFIER' ? context_1.AMBIGUOUS_FIELD_CONFIDENCE : context_1.SEMANTIC_CONFIDENCE;
-                    if (semConf >= ((_a = ctx.confidenceThreshold) !== null && _a !== void 0 ? _a : 0)) {
-                        const replacement = applyRedaction(value, { label: semantic.label, category: semantic.category }, ctx.mode, vault, sessionId, ctx.dedup);
-                        hits.push({
-                            token: replacement, original: '***',
-                            patternName: `semantic_${semantic.label}`,
-                            patternLabel: semantic.label,
-                            category: semantic.category,
-                            field: currentPath, itemIndex,
-                            confidence: semConf,
-                        });
-                        return replacement;
-                    }
-                }
-            }
+            const semantic = redactSemantic(value, ctx, vault, sessionId, hits, itemIndex, currentPath, displayPath, siblingKeys);
+            if (semantic !== null)
+                return semantic;
         }
-        return redactText(value, ctx, vault, sessionId, hits, itemIndex, currentPath);
+        return redactText(value, ctx, vault, sessionId, hits, itemIndex, displayPath);
     }
-    if (typeof value === 'number' && !ctx.skipSemantic) {
-        if (!shouldProcessField(currentPath, ctx.fieldMode, ctx.fieldRules)) {
+    if (typeof value === 'number') {
+        if (!processed)
             return value;
-        }
-        const semantic = getSemanticLabel(currentPath, siblingKeys);
-        if (semantic && semantic.label) {
-            const semConf = semantic.label === 'IDENTIFIER' ? context_1.AMBIGUOUS_FIELD_CONFIDENCE : context_1.SEMANTIC_CONFIDENCE;
-            if (semConf >= ((_b = ctx.confidenceThreshold) !== null && _b !== void 0 ? _b : 0)) {
-                const strValue = String(value);
-                const replacement = applyRedaction(strValue, { label: semantic.label, category: semantic.category }, ctx.mode, vault, sessionId, ctx.dedup);
-                hits.push({
-                    token: replacement, original: '***',
-                    patternName: `semantic_${semantic.label}`,
-                    patternLabel: semantic.label,
-                    category: semantic.category,
-                    field: currentPath, itemIndex,
-                    confidence: semConf,
-                });
-                return replacement;
-            }
-        }
+        return redactNumber(value, ctx, vault, sessionId, hits, itemIndex, currentPath, displayPath, siblingKeys);
     }
     if (Array.isArray(value)) {
-        return value.map((v, i) => redactValue(v, ctx, vault, sessionId, hits, itemIndex, `${currentPath}[${i}]`));
+        return value.map((v, i) => redactValue(v, ctx, vault, sessionId, hits, itemIndex, `${currentPath}[${i}]`, undefined, `${displayPath}[${i}]`));
     }
     if (value !== null && typeof value === 'object') {
-        const entries = Object.entries(value);
-        const siblingKeys = entries.map(([k]) => k);
-        const obj = {};
-        for (const [k, v] of entries) {
-            const fieldPath = currentPath ? `${currentPath}.${k}` : k;
-            obj[k] = redactValue(v, ctx, vault, sessionId, hits, itemIndex, fieldPath, siblingKeys);
-        }
-        return obj;
+        return redactObject(value, ctx, vault, sessionId, hits, itemIndex, currentPath, displayPath);
     }
     return value;
 }
@@ -571,94 +577,106 @@ function redactText(text, ctx, vault, sessionId, hits, itemIndex, fieldPath) {
     }
     return result;
 }
+function makeRestorer(entries) {
+    const tokens = Object.keys(entries).filter((t) => t.length > 0).sort((a, b) => b.length - a.length);
+    if (tokens.length === 0)
+        return (text) => text;
+    const re = new RegExp(tokens.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g');
+    return (text) => text.replace(re, (token) => entries[token].original);
+}
+function restoreWith(value, restore) {
+    if (typeof value === 'string')
+        return restore(value);
+    if (Array.isArray(value))
+        return value.map((v) => restoreWith(v, restore));
+    if (value !== null && typeof value === 'object') {
+        const obj = {};
+        for (const [k, v] of Object.entries(value)) {
+            obj[restore(k)] = restoreWith(v, restore);
+        }
+        return obj;
+    }
+    return value;
+}
 function restoreValue(value, vault, sessionId) {
     const session = vault.getSession(sessionId);
     if (!session)
         return value;
+    return restoreWith(value, makeRestorer(session.entries));
+}
+function toUtf16Spans(text, entities) {
+    const offsets = [0];
+    for (const ch of text)
+        offsets.push(offsets[offsets.length - 1] + ch.length);
+    return entities
+        .filter((e) => Number.isInteger(e.start) && Number.isInteger(e.end) && e.start >= 0 && e.end > e.start && e.end < offsets.length)
+        .map((e) => ({ start: offsets[e.start], end: offsets[e.end], score: e.score, entityType: e.entity_type }));
+}
+function resolveOverlaps(spans) {
+    const ranked = [...spans].sort((a, b) => b.score - a.score || (b.end - b.start) - (a.end - a.start) || a.start - b.start);
+    const kept = [];
+    for (const span of ranked) {
+        if (!kept.some((k) => span.start < k.end && k.start < span.end))
+            kept.push(span);
+    }
+    return kept.sort((a, b) => b.start - a.start);
+}
+async function presidioRedactString(value, ctx, vault, sessionId, hits, itemIndex, path) {
+    var _a;
+    if (value.trim().length === 0 || TOKEN_RE.test(value))
+        return value;
+    const entities = await (0, presidio_1.analyzeWithPresidio)(ctx.presidioUrl, value, ctx.presidioLanguage || 'en', 0.4, 10000, ctx.presidioRequest);
+    const threshold = (_a = ctx.confidenceThreshold) !== null && _a !== void 0 ? _a : 0;
+    const spans = resolveOverlaps(toUtf16Spans(value, entities).filter((s) => s.score >= threshold));
+    let text = value;
+    for (const span of spans) {
+        const matchedText = value.slice(span.start, span.end);
+        if (TOKEN_RE.test(matchedText) || (matchedText.startsWith('[') && matchedText.endsWith(']')))
+            continue;
+        if (isAllowListed(matchedText, ctx.allowList))
+            continue;
+        const label = (0, presidio_1.getRedactorLabel)(span.entityType);
+        const category = (0, presidio_1.getRedactorCategory)(span.entityType);
+        const replacement = applyRedaction(matchedText, { label, category }, ctx.mode, vault, sessionId, ctx.dedup);
+        text = text.slice(0, span.start) + replacement + text.slice(span.end);
+        hits.push({
+            token: replacement, original: '***',
+            patternName: `presidio_${span.entityType}`, patternLabel: label,
+            category, field: path, itemIndex, confidence: span.score,
+        });
+    }
+    return text;
+}
+async function presidioWalk(value, ctx, vault, sessionId, hits, itemIndex, path) {
     if (typeof value === 'string') {
-        let result = value;
-        for (const [token, e] of Object.entries(session.entries)) {
-            result = result.split(token).join(e.original);
+        if (!shouldProcessField(path, ctx.fieldMode, ctx.fieldRules))
+            return value;
+        try {
+            return await presidioRedactString(value, ctx, vault, sessionId, hits, itemIndex, path);
+        }
+        catch {
+            return value;
         }
-        return result;
     }
     if (Array.isArray(value)) {
-        return value.map((v) => restoreValue(v, vault, sessionId));
+        const out = [];
+        for (let i = 0; i < value.length; i++)
+            out.push(await presidioWalk(value[i], ctx, vault, sessionId, hits, itemIndex, `${path}[${i}]`));
+        return out;
     }
     if (value !== null && typeof value === 'object') {
-        const obj = {};
+        const out = {};
         for (const [k, v] of Object.entries(value)) {
-            obj[k] = restoreValue(v, vault, sessionId);
+            out[k] = await presidioWalk(v, ctx, vault, sessionId, hits, itemIndex, path ? `${path}.${k}` : k);
         }
-        return obj;
+        return out;
     }
     return value;
 }
 async function enhanceWithPresidio(data, ctx, vault, sessionId, hits, itemIndex) {
-    var _a;
     if (!ctx.presidioUrl)
         return data;
-    const result = { ...data };
-    for (const [key, value] of Object.entries(result)) {
-        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-            result[key] = await enhanceWithPresidio(value, ctx, vault, sessionId, hits, itemIndex);
-            continue;
-        }
-        if (Array.isArray(value)) {
-            const arr = [];
-            for (const item of value) {
-                if (item !== null && typeof item === 'object') {
-                    arr.push(await enhanceWithPresidio(item, ctx, vault, sessionId, hits, itemIndex));
-                }
-                else {
-                    arr.push(item);
-                }
-            }
-            result[key] = arr;
-            continue;
-        }
-        if (typeof value !== 'string')
-            continue;
-        if (value.trim().length === 0)
-            continue;
-        if (TOKEN_RE.test(value))
-            continue;
-        try {
-            const entities = await (0, presidio_1.analyzeWithPresidio)(ctx.presidioUrl, value, ctx.presidioLanguage || 'en', 0.4, 10000, ctx.presidioRequest);
-            if (entities.length === 0)
-                continue;
-            const sorted = entities.sort((a, b) => b.start - a.start);
-            let text = value;
-            for (const entity of sorted) {
-                const matchedText = text.slice(entity.start, entity.end);
-                if (TOKEN_RE.test(matchedText) || (matchedText.startsWith('[') && matchedText.endsWith(']')))
-                    continue;
-                if (isAllowListed(matchedText, ctx.allowList))
-                    continue;
-                if (entity.score < ((_a = ctx.confidenceThreshold) !== null && _a !== void 0 ? _a : 0))
-                    continue;
-                const label = (0, presidio_1.getRedactorLabel)(entity.entity_type);
-                const category = (0, presidio_1.getRedactorCategory)(entity.entity_type);
-                const replacement = applyRedaction(matchedText, { label, category }, ctx.mode, vault, sessionId, ctx.dedup);
-                text = text.slice(0, entity.start) + replacement + text.slice(entity.end);
-                hits.push({
-                    token: replacement,
-                    original: '***',
-                    patternName: `presidio_${entity.entity_type}`,
-                    patternLabel: label,
-                    category,
-                    field: key,
-                    itemIndex,
-                    confidence: entity.score,
-                });
-            }
-            result[key] = text;
-        }
-        catch {
-            continue;
-        }
-    }
-    return result;
+    return (await presidioWalk(data, ctx, vault, sessionId, hits, itemIndex, ''));
 }
 function buildReport(sessionId, hits) {
     const hitsByCategory = {};

package/dist/nodes/Redactor/injection.js

@@ -258,7 +258,7 @@ function detectPromptInjection(text) {
                     matches.push({
                         category: 'encoded_payload',
                         pattern: 'Base64-encoded injection payload detected',
-                        matchedText: `Decoded: "${decoded.slice(0, 50)}..."`,
+                        matchedText: `(decoded payload of ${decoded.length} characters withheld)`,
                         severity: 'HIGH',
                         score: 0.35,
                     });