@link-foundation/sensitive-data-sanitizer 0.20.0 → 0.21.1

package/src/sanitizer.js

@@ -1,14 +1,12 @@
-import { generatedValues } from './fake.js';
+import { generatedValues } from './fake-memory.js';
+import { feature, withFeature } from './features.js';
 import { isCompiledKnown, projectedKnown } from './compiled-known.js';
 import { detectSync, validateDetectors } from './sync-detectors.js';
 import { validatePolicyControls, builtInEnabled } from './policy.js';
 import { compiledVocabulary } from './vocabulary.js';
-import { validateProperNames } from './proper-names.js';
-import { prepareFakeText } from './fake-entities.js';
 import { alignEscapes } from './escape-spans.js';
 import { actionable } from './confidence.js';
 import { propagate, confirmationOptions } from './propagation.js';
-import { fakeDocumentSpans } from './specimens.js';
 import {
   failure,
   internalFailure,
@@ -26,10 +24,11 @@ import {
   hasCustomTransforms,
   renderCallbackAsync,
 } from './transforms.js';
-import { fakeIdentityValue, isIdentityType } from './identity.js';
+import { isIdentityType } from './identity-types.js';
 import { rejectRestoreMap } from './restore-map.js';
 import { allowListed, validateAllowList } from './allow-list.js';
 import { templatedCredential } from './credentials.js';
+import { exemptFindings, validateExempt } from './exempt.js';
 import { builtInRules } from './rule-catalog.js';
 import {
   initializePlaceholders,
@@ -39,6 +38,8 @@ import {
   hasPlaceholders,
   placeholderValues,
   placeholderNameFindings,
+  keptPlaceholderSpans,
+  keptPlaceholderFinding,
   coverAdjacentNames,
   nestedPlaceholderOptions,
 } from './placeholders.js';
@@ -105,6 +106,7 @@ const optionNames = new Set([
   'minConfidenceByType',
   'allowList',
   'inlineAllow',
+  'exempt',
 ]);
 
 export function applyProfile(options = {}) {
@@ -222,7 +224,9 @@ export function validateOptions(options = {}) {
     }
   }
   validateConfidence(options);
-  validateProperNames(options);
+  if (options.properNames !== undefined || options.scripts !== undefined) {
+    feature('validateProperNames')(options);
+  }
   validatePolicy(options);
   if (
     options.verifyPublic !== undefined &&
@@ -230,6 +234,7 @@ export function validateOptions(options = {}) {
   ) {
     throw failure('ERR_CONFIG');
   }
+  validateExempt(options.exempt);
   validateCollections(options);
   validateAllowList(options);
   validateDetectors(options.detectors);
@@ -329,6 +334,9 @@ export function sanitizeFinding(finding, length) {
     rule: finding.rule,
     confidence: validConfidence(finding),
     likelihood: finding.likelihood ?? likelihood(validConfidence(finding)),
+    ...(finding.type === 'JSON_VALUE' && validType(finding.valueType)
+      ? { valueType: finding.valueType }
+      : {}),
     ...(finding.kept === 'fake' ? { kept: 'fake' } : {}),
   };
 }
@@ -449,7 +457,14 @@ function locations(text, findings) {
 
 export function inspect(text, options = {}) {
   try {
-    return inspectText(text, options);
+    const exempt = options?.exempt;
+    if (!exempt) {
+      return inspectText(text, options);
+    }
+    // Nested views (structured values, decoded runs) are screened once, at
+    // the offsets of the text the caller sees.
+    const findings = inspectText(text, { ...options, exempt: undefined });
+    return exemptFindings(text, findings, exempt);
   } catch (error) {
     throw internalFailure(error);
   }
@@ -635,14 +650,41 @@ export function inspectFindingsOnly(text, findings, options) {
   );
 }
 
+// A whole JSON value that is already a token of this run, `"Sensitive-1"`.
+function generatedJsonValue(text, finding, options) {
+  const raw = text.slice(finding.start, finding.end);
+  return (
+    raw.startsWith('"') &&
+    placeholderValues(options).some(
+      (record) => JSON.stringify(record.value) === raw
+    )
+  );
+}
 function selectedFindings(findings, credentialsOnly) {
   return credentialsOnly
     ? findings.filter((finding) => finding.category === 'credential')
     : findings;
 }
 
+// Findings over the tokens of an earlier pass, recorded in `tokenKept`.
+function withKeptPlaceholders(text, findings, options, tokenKept) {
+  const tokens = keptPlaceholderSpans(text, findings, options);
+  if (!tokens.length) {
+    return findings;
+  }
+  return findings.map((f) => {
+    const next = keptPlaceholderFinding(text, f, tokens);
+    if (next.kept === 'fake' && next !== f) {
+      tokenKept.add(next);
+    }
+    return next;
+  });
+}
+
 export function markFake(text, findings, options) {
   findings = selectedFindings(findings, options.credentialsOnly);
+  const tokenKept = new Set();
+  findings = withKeptPlaceholders(text, findings, options, tokenKept);
   const generated = [
     ...generatedValues(options),
     ...placeholderValues(options),
@@ -652,9 +694,12 @@ export function markFake(text, findings, options) {
     !options.fakeValues?.length &&
     !generated.length
   ) {
-    return findings.map((f) => ({ ...f, kept: undefined }));
+    return findings.map((f) => ({
+      ...f,
+      kept: tokenKept.has(f) ? 'fake' : undefined,
+    }));
   }
-  const documents = fakeDocumentSpans(text, options);
+  const documents = withFeature('fakeDocumentSpans', [], text, options);
   const trusted = [];
   for (const record of generated) {
     for (const value of new Set([
@@ -689,7 +734,7 @@ export function markFake(text, findings, options) {
   const candidates = findings.filter(
     (f) =>
       f.category === 'personal' &&
-      fakeIdentityValue(text.slice(f.start, f.end), f.type, options)
+      feature('fakeIdentityValue')(text.slice(f.start, f.end), f.type, options)
   );
   // Tolerant MRZ matches can cross a line boundary. An automatic specimen
   // exemption must never cover an overlapping real identity value. Exact
@@ -713,8 +758,13 @@ export function markFake(text, findings, options) {
     ),
   ];
   return findings.map((f) => {
+    if (tokenKept.has(f)) {
+      return f;
+    }
     if (f.type === 'JSON_VALUE') {
-      return { ...f, kept: undefined };
+      return generatedJsonValue(text, f, options)
+        ? { ...f, kept: 'fake' }
+        : { ...f, kept: undefined };
     }
     if (
       trusted.some(
@@ -775,6 +825,7 @@ function validatedSpans(text, findings, options) {
         last.category = 'credential';
       }
       if (last.type === 'JSON_VALUE' || f.type === 'JSON_VALUE') {
+        last.valueType = jsonValueType(last, f);
         last.type = 'JSON_VALUE';
       } else if (credentialRun) {
         last.type = 'SECRET';
@@ -788,6 +839,15 @@ function validatedSpans(text, findings, options) {
   return spans;
 }
 
+// Two whole values merged into one keep a value type only when they agree.
+function jsonValueType(last, f) {
+  if (last.type !== 'JSON_VALUE') {
+    return f.valueType;
+  }
+  return f.type !== 'JSON_VALUE' || f.valueType === last.valueType
+    ? last.valueType
+    : undefined;
+}
 function preferredType(current, candidate, options) {
   if (current === 'JSON_VALUE') {
     return false;
@@ -810,11 +870,17 @@ function preferredType(current, candidate, options) {
   if (options.transformations?.[candidate] || candidate === 'PASSPORT_MRZ') {
     return true;
   }
+  return preferredSpecificType(current, candidate);
+}
+function preferredSpecificType(current, candidate) {
   const broad = (type) =>
     ['ID', 'PASSPORT'].includes(type) ||
     (/PASSPORT/.test(type) &&
       !['PASSPORT_MRZ', 'PASSPORT_NUMBER'].includes(type));
-  return broad(current) && isIdentityType(candidate) && !broad(candidate);
+  return (
+    (current === 'PROPER_NAME' && candidate === 'PERSONAL_ATTRIBUTE') ||
+    (broad(current) && isIdentityType(candidate) && !broad(candidate))
+  );
 }
 export function redactResult(
   text,
@@ -824,7 +890,8 @@ export function redactResult(
 ) {
   options = applyProfile(options);
   const spans = validatedSpans(text, findings, options);
-  options = prepareFakeText(text, findings, initializePlaceholders(options));
+  options = initializePlaceholders(options);
+  options = withFeature('prepareFakeText', options, text, findings, options);
   preparePlaceholderText(text, findings, options);
   const parts = [];
   const faked = [];
@@ -950,22 +1017,26 @@ export async function redactResultAsync(
         }
         continue;
       }
-      if (!run) {
-        if (options.preserveEncoding) {
-          throw failure('ERR_ENCODING');
-        }
-        continue;
-      }
-      if (!options.preserveEncoding && run.encoding !== 'json-content') {
+      if (
+        !run ||
+        (!options.preserveEncoding && run.encoding !== 'json-content')
+      ) {
         continue;
       }
       const result = await sanitizeDecoded(
         run.text,
         nestedPlaceholderOptions(confirmationOptions(text, findings, options))
       );
+      // Without a recognizable re-encoding, the encoded text itself is masked.
       replacements.set(
         `${span.start}:${span.end}`,
-        encodeRun(run, result.text === run.text ? REDACTED : result.text)
+        encodeRun(run, result.text === run.text ? REDACTED : result.text) ??
+          renderReplacement(
+            text,
+            span,
+            { ...options, preserveEncoding: false },
+            () => ({ text: REDACTED })
+          )
       );
     }
   }

package/src/stream-worker.js

@@ -1,4 +1,5 @@
 import { parentPort, workerData } from 'node:worker_threads';
+import './personal-features.js';
 import { sanitizeFileToFile } from './stream.js';
 import { compileKnown } from './compiled-known.js';
 try {

package/src/strict-attributes.js

@@ -1,4 +1,5 @@
 import { collectMatches } from './detection.js';
+import { compiledVocabulary } from './vocabulary.js';
 
 const attributes =
   /(?<![\p{L}\p{N}_])(?:женщин[аыуеой]{1,2}|мужчин[аыуеой]{1,2}|замужем|женат(?:а|ы)?|(?:один|одна|двое|трое|четверо|пятеро|\d{1,2})[ \t]+(?:детей|реб[её]нок|реб[её]нка)|русск(?:ая|ий|ого|ой|ие)|татар(?:ин|ка|ы)|православн(?:ый|ая|ого|ой)|мусульман(?:ин|ка)|инвалидност[ьи](?:[ \t]+\d[ \t]+группы)?|беременн(?:а|ая|ость)|судимость(?:[ \t]+погашена)?|член[ \t]+партии|woman|women|male|female|married|divorced|pregnant|pregnancy|disability|christian|muslim|jewish|orthodox|hispanic|criminal[ \t]+record|party[ \t]+member|(?:one|two|three|\d{1,2})[ \t]+children)(?![\p{L}\p{N}_])/giu;
@@ -10,10 +11,56 @@ const additionalAttributes =
 // unfamiliar diagnoses, nationalities and religions outside this lexicon.
 const categoryForms =
   /(?<![\p{L}\p{N}_])(?:(?:диабет|католик|католич|буддист|атеист|белорус|православн|беременн|судим)[\p{L}]{0,8}|татар(?:ин(?:а|у|ом|е)?|к[аиуе]|кой|ы|ам|ами|ах)?|мусульман(?:ин(?:а|у|ом|е)?|к[аиуе]|кой|е|ам|ами|ах)?|украин(?:ец|ца|цу|цем|це|цы|цев|цам|цами|цах|к[аиуе]|кой)|инвалид(?:а|у|ом|е|ы|ов|ам|ами|ах|к[аиу]|кой)?|армян(?:ин|ина|ину|ином|ине|е|ам|ами|ах|ка|ки|ке|ку|кой)|евре(?:й|я|ю|ем|и|ев|ям|ями|ях|йк[аиуе]|йкой)|казах(?:а|у|ом|е|и|ов|ам|ами|ах|к[аиуе]|кой)?|христиан(?:ин|ина|ину|ином|ине|е|ам|ами|ах|к[аиуе]|кой)|иуде(?:й|я|ю|ем|и|ев|ям|ями|ях|йк[аиуе]|йкой)|ислам[\p{L}]{0,5}|эпилепси[\p{L}]{1,5}|астм[\p{L}]{1,5}|онкологи[\p{L}]{1,5}|туберкул[её]з[\p{L}]{0,5}|психиатр[\p{L}]{0,6}|депресси[\p{L}]{1,5}|гепатит[\p{L}]{0,5}|гомосексуал[\p{L}]{0,7}|лесбиян[\p{L}]{1,5}|ге(?:й|я|ю|ем|и|ев|ям|ями|ях)|нетрадиционн[\p{L}]{2,3}[ \t]+ориентаци[\p{L}]{1,3}|отбыва(?:л[аи]?|ет|ют|вш[\p{L}]{2,3})[ \t]+наказани[\p{L}]{1,3}|ВИЧ-инфицирован[\p{L}]{0,4}|epilepsy|asthma|tuberculosis|hepatitis|depression|gay|lesbian|homosexual|bisexual|armenian)(?![\p{L}\p{N}_])/giu;
+// Nationality nouns with their case endings and feminine forms. Exact endings
+// keep country and region names (`Узбекистан`, `Чувашия`) out of the match.
+const hardNoun = '(?:а|у|ом|е|ы|ов|ам|ами|ах)?';
+const softNoun = '(?:а|у|ом|е|и|ей|ам|ами|ах)?';
+const ecNoun = '(?:ец|ц(?:а|у|ем|е|ы|ев|ам|ами|ах))';
+const femaleNoun = '(?:а|и|е|у|ой)';
+const nationalities = [
+  `кабардин${ecNoun}|кабардинк${femaleNoun}`,
+  `казашк${femaleNoun}`,
+  `мордвин${hardNoun}|мордовк${femaleNoun}`,
+  `удмурт${hardNoun}|удмуртк${femaleNoun}`,
+  `молдаванин(?:а|у|ом|е)?|молдаван${hardNoun}|молдаванк${femaleNoun}`,
+  `узбек${softNoun}|узбечк${femaleNoun}`,
+  `таджик${softNoun}|таджичк${femaleNoun}`,
+  `(?:киргиз|кыргыз)${hardNoun}|(?:киргиз|кыргыз)к${femaleNoun}`,
+  `туркмен${hardNoun}|туркменк${femaleNoun}`,
+  `чечен${ecNoun}|чеченк${femaleNoun}`,
+  `ингуш${softNoun}|ингушк${femaleNoun}`,
+  `осетин${hardNoun}|осетинк${femaleNoun}`,
+  `грузин${hardNoun}|грузинк${femaleNoun}`,
+  `азербайджан${ecNoun}|азербайджанк${femaleNoun}`,
+  `цыган${hardNoun}|цыганк${femaleNoun}`,
+  `коре(?:ец|йц(?:а|у|ем|е|ы|ев|ам|ами|ах))|кореянк${femaleNoun}`,
+  `кита(?:ец|йц(?:а|у|ем|е|ы|ев|ам|ами|ах))|китаянк${femaleNoun}`,
+  `башкир${hardNoun}|башкирк${femaleNoun}`,
+  `чуваш${softNoun}|чувашк${femaleNoun}`,
+  `якут${hardNoun}|якутк${femaleNoun}`,
+  `бурят${hardNoun}|бурятк${femaleNoun}`,
+  `калмык${softNoun}|калмычк${femaleNoun}`,
+  `лезгин${hardNoun}|лезгинк${femaleNoun}`,
+  `авар${ecNoun}|аварк${femaleNoun}`,
+  `дагестан${ecNoun}|дагестанк${femaleNoun}`,
+  `уйгур${hardNoun}|уйгурк${femaleNoun}`,
+].join('|');
+const believerNoun = `(?:а|у|ом|е|ы|ов|ам|ами|ах|к${femaleNoun}|кой)?`;
+// These terms are sensitive even without an adjacent personal cue. Keep
+// bounded endings and whole-word boundaries, as for the existing categories.
+const followUpVocabulary = new RegExp(
+  `(?<![\\p{L}\\p{N}_])(?:иудаизм${hardNoun}|старовер${believerNoun}|эпилептик${softNoun}|паралич${softNoun}|наркомани[\\p{L}]{1,4}|профсоюз${hardNoun}|коммунист${believerNoun}|uzbek|tajik|chechen|romani|gypsy|latino|latina|baptist|aids|bipolar|adhd|wheelchair|lgbt|convicted|felony|trade[ \\t]+union)(?![\\p{L}\\p{N}_])`,
+  'giu'
+);
+const specialVocabulary = new RegExp(
+  `(?<![\\p{L}\\p{N}_])(?:${nationalities}|(?:протестант|баптист|адвентист|индуист|кришнаит|иеговист|пятидесятник)${believerNoun}|лютеран(?:ин(?:а|у|ом|е)?|к${femaleNoun}|кой|е|ам|ами|ах)|старообряд${ecNoun}|старообрядк${femaleNoun}|свидетел[\\p{L}]{1,3}[ \\t]+иеговы|инсульт[\\p{L}]{0,3}|инфаркт[\\p{L}]{0,3}|шизофрени[\\p{L}]{1,4}|аутизм[\\p{L}]{0,3}|аутист(?:ка|ки|ке|ку|кой|а|у|ом|ы|ов)?|слабослышащ[\\p{L}]{1,4}|слабовидящ[\\p{L}]{1,4}|незряч[\\p{L}]{1,4}|дцп|колясочни(?:к${hardNoun}|ц${femaleNoun})|(?:передвига[\\p{L}]{1,5}|инвалидн[\\p{L}]{2,4})[ \\t]+(?:на[ \\t]+)?коляск[\\p{L}]{1,3}|болезн[\\p{L}]{1,3}[ \\t]+(?:паркинсона|альцгеймера)|деменци[\\p{L}]{1,3}|алкоголизм[\\p{L}]{0,2}|наркозависим[\\p{L}]{0,4}|биполярн[\\p{L}]{2,4}[ \\t]+расстройств[\\p{L}]{0,3}|(?:би|транс|пан|а)сексуал[\\p{L}]{0,6}|трансгендер[\\p{L}]{0,6}|(?:сидел[аи]?|отсидел[аи]?|осужд[её]н[аы]?|привлекал(?:ся|ась|ись)|отбывал[аи]?[ \\t]+срок)[ \\t]+(?:за|по)[ \\t]+(?:краж|грабе|разбо|убийств|мошенничеств|наркотик|хулиганств|изнасиловани|взятк|стать)[\\p{L}]{0,4}(?:[ \\t]+\\d{1,3}(?:\\.\\d)?)?|(?:сидел[аи]?|отсидел[аи]?)[ \\t]+(?:в[ \\t]+)?(?:тюрьм[\\p{L}]{1,2}|колони[\\p{L}]{1,2}|срок)|бывш[\\p{L}]{2,3}[ \\t]+заключ[её]нн[\\p{L}]{2,3}|член[\\p{L}]{0,3}[ \\t]+профсоюз[\\p{L}]{0,3}|состо(?:ит|ял[аи]?|ю|ят)[ \\t]+в[ \\t]+профсоюзе|профсоюзн(?:ый|ая|ого|ой)[ \\t]+(?:активист|деятел|лидер)[\\p{L}]{0,3}|autism|autistic|schizophreni[ac]|transgender|transsexual|pansexual|asexual|wheelchair[ \\t]+users?|uses[ \\t]+a[ \\t]+wheelchair|in[ \\t]+a[ \\t]+wheelchair|(?:hearing|visually)[ \\t-]+impaired|had[ \\t]+a[ \\t]+(?:stroke|heart[ \\t]+attack)|dementia|alzheimer'?s|parkinson'?s|bipolar[ \\t]+disorder|alcoholism|trade[ \\t]+union[ \\t]+member(?:ship)?|member[ \\t]+of[ \\t]+(?:a|the)[ \\t]+(?:trade|labou?r)[ \\t]+union|convicted[ \\t]+(?:of|for)[ \\t]+[\\p{L}]{3,32}|served[ \\t]+(?:time[ \\t]+(?:in|for)|a[ \\t]+(?:prison[ \\t]+)?sentence)|protestant|lutheran|mormon|hindu|sikh|jehovah'?s[ \\t]+witness)(?![\\p{L}\\p{N}_])`,
+  'giu'
+);
 const categoryCue =
-  /(?<![\p{L}\p{N}_])(?:по[ \t]+национальности|национальность|этничность|вероисповедание|религия|диагноз|исповеду(?:ет|ют|ю|ешь)|боле(?:ет|ют|ю|ешь)|страда(?:ет|ют|ю|ешь)[ \t]+от|на[ \t]+уч[её]те[ \t]+у|diagnosed[ \t]+with|suffers[ \t]+from|nationality|ethnicity|religion|diagnosis)(?:["']?[ \t]*[:=][ \t]*|[ \t]+)["']?([\p{L}][\p{L}\p{M}-]{0,63})(?![\p{L}\p{M}\p{N}_])/giu;
+  /(?<![\p{L}\p{N}_])(?:по[ \t]+(?:национальности|происхождению)|национальность|этничность|вероисповедание|религия|диагноз|исповеду(?:ет|ют|ю|ешь)|боле(?:ет|ют|ю|ешь)|страда(?:ет|ют|ю|ешь)[ \t]+от|на[ \t]+уч[её]те[ \t]+у|diagnosed[ \t]+with|suffers[ \t]+from|nationality|ethnicity|religion|diagnosis)(?:["']?[ \t]*[:=][ \t]*|[ \t]+)["']?([\p{L}][\p{L}\p{M}-]{0,63})(?![\p{L}\p{M}\p{N}_])/giu;
+// Words that are also languages, scripts or styles need a personal context.
 const ambiguous =
-  /(?<![\p{L}\p{N}_])(?:disabled|single|man|men|russian|asian)(?![\p{L}\p{N}_])/giu;
+  /(?<![\p{L}\p{N}_])(?:disabled|single|man|men|russian|asian|azerbaijani|korean|chinese|georgian|kazakh|kyrgyz|turkmen|uyghur|roma|union[ \t]+member)(?![\p{L}\p{N}_])/giu;
 
 function personalContext(text, match) {
   const prefix = text.slice(Math.max(0, match.index - 128), match.index);
@@ -56,8 +103,17 @@ export function detectStrictAttributes(text, emit, options) {
     detected++;
     emit(finding);
   };
-  for (const pattern of [attributes, additionalAttributes, categoryForms]) {
-    collectMatches(text, pattern, report, details);
+  for (const pattern of [
+    attributes,
+    additionalAttributes,
+    categoryForms,
+    specialVocabulary,
+    followUpVocabulary,
+    compiledVocabulary(options.vocabulary)?.attributes,
+  ]) {
+    if (pattern) {
+      collectMatches(text, pattern, report, details);
+    }
   }
   collectMatches(text, categoryCue, report, details, 1);
   collectMatches(text, ambiguous, report, details, 0, (_value, match) => {

package/src/strict.js

@@ -2,7 +2,7 @@ import { collectMatches } from './detection.js';
 import { months } from './personal-context.js';
 import { isDocumentTechnology } from './document-experience.js';
 import { placeholderValues } from './placeholders.js';
-import { generatedValues } from './fake.js';
+import { generatedValues } from './fake-memory.js';
 import { detectStrictAttributes } from './strict-attributes.js';
 
 const boundary = '[\\p{L}\\p{N}_]';

package/src/structured.js

@@ -171,6 +171,7 @@ export function structuredFieldFindings(batch, options) {
         start: entry.start + (denied ? 0 : 1),
         end: entry.start + entry.raw.length - (denied ? 0 : 1),
         type: denied ? 'JSON_VALUE' : type,
+        ...(denied && type ? { valueType: type } : {}),
         category: 'personal',
         rule: 'known-personal',
         confidence: 1,
@@ -516,6 +517,7 @@ function declaredValueFinding(text, token, options) {
     start,
     end,
     type: 'JSON_VALUE',
+    ...(type ? { valueType: type } : {}),
     category: 'personal',
     rule: 'known-personal',
     confidence: 1,

package/src/transforms.js

@@ -1,8 +1,8 @@
-import { realisticFake } from './fake.js';
+import { feature } from './features.js';
 import { createHmac } from 'node:crypto';
 import { failure, REDACTED } from './detection.js';
 import { encodedValue, encodeRun, decodedRuns } from './encoded.js';
-import { isIdentityType } from './identity.js';
+import { isIdentityType } from './identity-types.js';
 import { validatePlaceholder, placeholderReplacement } from './placeholders.js';
 import { projectText } from './projection.js';
 import { encryptValue } from './encrypt.js';
@@ -262,7 +262,7 @@ function transformed(value, finding, transform, options) {
       : REDACTED;
   }
   if (transform.mode === 'fake') {
-    return realisticFake(value, finding, transform, options);
+    return feature('realisticFake')(value, finding, transform, options);
   }
   if (finding.category === 'credential') {
     return REDACTED;
@@ -277,6 +277,32 @@ function transformed(value, finding, transform, options) {
   const lower = Math.floor(number / transform.size) * transform.size;
   return `${lower}–${lower + transform.size - 1}`;
 }
+function jsonValueText(raw) {
+  try {
+    const value = JSON.parse(raw);
+    return typeof value === 'string' && value ? value : raw;
+  } catch {
+    return raw;
+  }
+}
+// A whole JSON value becomes one JSON string. Placeholder mode types it by the
+// field it came from, so `{"age":34}` reads `{"age":"Age-1"}`.
+function jsonValueReplacement(text, finding, options) {
+  const transform =
+    options.transformations?.JSON_VALUE ?? options.transformation;
+  if (transform?.mode !== 'placeholder') {
+    return JSON.stringify(REDACTED);
+  }
+  const raw = text.slice(finding.start, finding.end);
+  return JSON.stringify(
+    placeholderReplacement(
+      jsonValueText(raw),
+      { ...finding, type: finding.valueType ?? 'SENSITIVE' },
+      transform,
+      options
+    )
+  );
+}
 export function renderReplacement(
   text,
   finding,
@@ -285,7 +311,7 @@ export function renderReplacement(
   jsonRanges
 ) {
   if (finding.type === 'JSON_VALUE') {
-    return JSON.stringify(REDACTED);
+    return jsonValueReplacement(text, finding, options);
   }
   const transform =
     options.transformations?.[finding.type] ??
@@ -300,11 +326,15 @@ export function renderReplacement(
       const sanitized = encodedSanitize(run.text).text;
       // Mapped escaped fragments can lose their detecting context on decode.
       // Redact the fragment if recursive scanning makes no progress.
-      return encodeRun(run, sanitized === run.text ? REDACTED : sanitized);
-    }
-    if (options.preserveEncoding) {
-      throw failure('ERR_ENCODING');
+      const encoded = encodeRun(
+        run,
+        sanitized === run.text ? REDACTED : sanitized
+      );
+      if (encoded !== undefined) {
+        return encoded;
+      }
     }
+    // Without a recognizable re-encoding, the encoded text itself is masked.
   }
   return renderValue(text, finding, transform, options, jsonRanges);
 }

package/src/vocabulary.js

@@ -1,4 +1,4 @@
-import { failure, collectMatches } from './detection.js';
+import { failure, collectMatches, escapePattern } from './detection.js';
 import { wordPattern } from './personal-variants.js';
 import { fieldSuffixes, normalizeFieldName } from './document-fields.js';
 
@@ -50,10 +50,12 @@ export const defaultVocabulary = Object.freeze(
         'fullname',
         'originalfilename',
       ],
+      personalAttributes: [],
     }).map(([key, values]) => [key, Object.freeze(values)])
   )
 );
 const cache = new Map();
+const identities = new WeakMap();
 const boundary = '[\\p{L}\\p{N}_]';
 const name =
   '[\\p{Lu}][\\p{L}\\p{M}.-]{1,47}(?:[ \\t]+[\\p{Lu}][\\p{L}\\p{M}.-]{1,47}){0,3}';
@@ -111,14 +113,44 @@ function normalizedList(input, defaults) {
     ),
   ];
 }
+// Caller stems for the strict special-category rule: each word matches at a
+// word start and takes at most eight more letters of ending, like the built-in
+// stems, so `узбеч` covers `узбечка` and `узбечкой`.
+function attributePattern(values) {
+  if (!values.length) {
+    return undefined;
+  }
+  const stems = values
+    .map((value) =>
+      value
+        .split(/\s+/u)
+        .map(
+          (word) =>
+            `${escapePattern(word).replace(/[её]/gu, '[её]')}[\\p{L}\\p{M}]{0,8}`
+        )
+        .join('[ \\t]+')
+    )
+    .sort((a, b) => b.length - a.length)
+    .join('|');
+  return new RegExp(
+    `(?<![\\p{L}\\p{N}_])(?:${stems})(?![\\p{L}\\p{N}_])`,
+    'giu'
+  );
+}
 export function compiledVocabulary(vocabulary) {
   if (vocabulary === undefined) {
     return undefined;
   }
+  const existing = identities.get(vocabulary);
+  if (existing) {
+    return existing;
+  }
   const lists = normalizedLists(vocabulary);
   const key = JSON.stringify(lists);
   if (cache.has(key)) {
-    return cache.get(key);
+    const result = cache.get(key);
+    identities.set(vocabulary, result);
+    return result;
   }
   const alternatives = (values) =>
     values.length
@@ -159,10 +191,15 @@ export function compiledVocabulary(vocabulary) {
     'giu'
   );
   result.fields = new Set(lists.personalFields.map(normalizeFieldName));
+  result.cues = new Set(
+    [...lists.roles, ...lists.personalLabels].map((s) => s.replaceAll('ё', 'е'))
+  );
+  result.attributes = attributePattern(lists.personalAttributes);
   if (cache.size >= 64) {
     cache.clear();
   }
   cache.set(key, result);
+  identities.set(vocabulary, result);
   return result;
 }
 export function vocabularyField(field, options) {

package/src/worker-options.js

@@ -3,6 +3,7 @@ export function hasWorkerCallbacks(options) {
   return Boolean(
     options.debug ||
     options.verifyPublic ||
+    options.exempt ||
     options.detectors?.length ||
     [
       options.transformation,