@link-foundation/sensitive-data-sanitizer 0.16.2 → 0.17.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.17.1
+
+### Patch Changes
+
+- 8029dd8: Refresh dependencies and supported development tooling, and repair upgrade regressions in workflow validation, formatting and reproducible example installs.
+
+## 0.17.0
+
+### Minor Changes
+
+- Add synchronous sensitiveFields schema redaction and consistent document field aliases. Protect percent-encoded URL contacts, personal paths, opaque share links, CV employers and contextual company names; preserve multiline empty attributes and redact escaped fragments without losing structured records.
+
+  Install and verify a checksum-pinned GitHub CLI in the preview screenshot container, and exercise the same publishing tools on pull requests before generated images reach main.
+
+  Check maintained Python helpers with Ruff and CodeQL, and audit every tracked Python requirements file, including transitive benchmark dependencies, without installing NLP packages.
+
 ## 0.16.2
 
 ### Patch Changes

package/docs/API.md

@@ -176,6 +176,7 @@ new document recognizers; `documentEntities: false` turns them off explicitly.
 | `fakeIdentity`     | Off; `'specimen-and-synthetic'` retains explicitly fake identity values                                                                                     |
 | `fakeValues`       | `[]`; exact caller-reviewed identity values to retain, regardless of fakeIdentity                                                                           |
 | `structured`       | Off; `'json'` or `'jsonl'` validates and sanitizes string keys/values separately                                                                            |
+| `sensitiveFields`  | `[]`; exact JSON/JSONL property names whose complete values become a redaction string; supports synchronous calls                                           |
 | `structuralFields` | `[]`; declared property names suppress weak name/ID/entropy heuristics in their string values                                                               |
 
 Unknown options and invalid limits are errors. `knownSecretsFromEnv(env, names?)` discovers credential-named variables (excluding auth configuration names) when names are omitted, or uses an explicit selection, deduplicating nonempty values. It never invokes shell commands or reads auth files. `personalVariants(entries)` generates numeric and ISO/day-first date spellings; name case variants are already handled by detection. Neither helper invents transliterations.
@@ -474,3 +475,33 @@ restores IP detection; explicit `knownSecrets` and `knownPersonal` retain
 priority. No shell command or workflow expression is executed.
 
 Authorization headers (including Proxy-Authorization) redact the scheme and one credential token. Whitespace, C0 controls (including NUL), DEL, quotes, backslashes and commas end the value, preserving subsequent log text in shell and escaped JSON prompts. Matching brackets opened within a token are included in its redaction; unmatched closing brackets remain part of the surrounding log. Already-redacted tokens and known credential references remain exempt after an optional scheme, including `<token>` placeholders. The debug callback receives value-free `gitleaks-rule` events with rule ID, input length and elapsed milliseconds; tracing is off by default.
+
+## Caller-declared sensitive fields
+
+In structured JSON/JSONL, `sensitiveFields: string[]` matches exact,
+case-sensitive property names at any depth. The complete property value becomes
+`"[REDACTED]"`, including empty strings, numbers, booleans, null, arrays and
+objects. This deliberate schema policy can change value types. It takes
+priority over `structuralFields` and transformations, preserves property names
+and surrounding whitespace, and works in both `sanitize` and `createSanitizer`.
+It has no effect without `structured`. The personal-data switch
+`credentialsOnly` still suppresses personal findings.
+
+```js
+sanitize('{"privateNote":"arbitrary free text","count":2}', {
+  structured: 'json',
+  sensitiveFields: ['privateNote'],
+}).text;
+// {"privateNote":"[REDACTED]","count":2}
+
+sanitize('Lyutik работал', {
+  profile: 'documents',
+  knownPersonal: [{ type: 'ORGANIZATION', value: 'Lyutik' }],
+}).text;
+// [REDACTED] работал
+```
+
+`knownPersonal` is the synchronous custom-value list, including names without
+context. For computed synchronous detection, callers can supply validated
+`findings` for the exact input. `detectors` remains an asynchronous-engine
+option; `sanitize` does not invoke these callbacks.

package/docs/COVERAGE.md

@@ -337,3 +337,68 @@ further work. These numbers do not describe `createSanitizer` with Secretlint.
 
 The [complete issue 89 requirement inventory](case-studies/issue-89/README.md)
 records every row, root cause, alternative and regression mapping.
+
+## Document URL and field refinements (issues 91 and 94)
+
+The document profile detects `email=` and `phone=` query values in absolute and
+relative URLs and access-log text, retaining the label while percent-decoding.
+It replaces the same complete value for plain and percent-encoded contacts,
+without reserializing unaffected URL bytes. Invalid percent escapes do not
+qualify through this decoding rule. Personal `/u/`, `/in/`, `/user(s)/`,
+`/profile(s)/`, `/people/`, `/member(s)/` and `/home/` paths apply independently
+of the containing field label. These paths can also describe public accounts;
+the rule cannot establish identity or access permissions.
+
+An absolute HTTP(S) URL with a 24–128-character ASCII alphanumeric/underscore/
+hyphen path segment is treated as a possible share link and replaced, including
+Google Drive/Docs and generic `/s/<opaque-id>` links. This is a conservative
+shape rule, not a check of sharing permissions or entropy; public URLs with
+long segments may also match. Ordinary documentation paths and provider roots
+remain unchanged. Personal site roots such as
+`портфолио https://ivan-petrov.example.org/` remain a documented limit: a root
+alone cannot establish that the site belongs to a person.
+
+Structured document field aliases remove `_`/`-` and ignore case before matching
+this explicit vocabulary: `firstName`, `lastName`, `middleName`, `patronymic`,
+`birthday`, `birthDate`, `sex`, `citizenship`, `nationality`, `company`,
+`companyName`, `employer`, `university`, `school`, `contact`, `resumeUrl`,
+`alternateUrl`, `profileUrl`, `companyUrl`. Their nonempty string values are
+sensitive in full, including ISO birth timestamps. Thus `first_name` and
+`firstName`, or `birth_date` and `birthDate`, follow the same policy. These are
+schema assumptions: `contact` or `company` can hold operational data too.
+Existing native labels still apply. Unlisted URL-named fields have ordinary
+content detection; arbitrary names do not imply sensitivity. Declare them with
+[`sensitiveFields`](API.md#caller-declared-sensitive-fields) to replace complete
+values, including non-string values. Generic numeric primitives otherwise keep
+the existing type-preservation policy.
+
+Employer labels consume multi-word values to a comma or line/quote boundary.
+Dated CV entries additionally support compound titles, title parentheses/slashes,
+quoted group names, legal-form/location suffixes, empty/`null` range ends,
+multiple entries, employer-first role entries and pipe-separated entries.
+The supplemental grammar uses finite title cues and bounded entries. Undated
+`Менеджер, Ромашка Лютик`, `- Ромашка Лютик 5 лет` and
+`Последнее место работы Ромашка Лютик` remain explicit ambiguous limits, as
+permitted by #94. Use known values or schema declarations for them.
+
+Company prose recognizes `компании «…»`, `опыт в`, `Роль в`, `проекты для`,
+capitalized lists after those cues, `опыт (Company Name)`, and names followed
+by `(2 года)`/`(3 года)`-style durations. Arbitrary uncued company words remain
+ambiguous; synchronous callers can supply `knownPersonal` lists or precomputed
+`findings`. Custom `detectors` callbacks are still used by `createSanitizer`
+only. No model or network service is required for these native rules.
+
+`контакт:` and `пишите,` introduce domestic mobile numbers. A complete line
+consisting of an 11-digit `79…` or `89…` mobile shape is also sensitive. Arbitrary
+prose numbers such as `order 89161234567 shipped` and `id 79161234567` remain
+unchanged. This shape rule does not prove that a number is assigned.
+
+Additional forms cover Cyrillic acronyms after `Education:`, `учился в`,
+`Соискатель:`/`Сотрудник:` names and split-line `С уважением,` signatures.
+`Дети: нет` remains an empty attribute with later JSON string lines preserved.
+When mapped escaped fragments lose detecting context on recursive decoding,
+redaction replaces the fragment instead of repeating an unchanged result until
+`ERR_RESIDUAL`; the surrounding JSON remains parseable.
+
+The [requirement inventory and research](case-studies/issue-100/README.md)
+records the complete scope and regression evidence.

package/examples/presidio-bridge.py

@@ -5,28 +5,34 @@ Example: python -m pip install presidio-analyzer
 Configure NlpEngineProvider here for other installed language models.
 This script does not download models or contact a remote analysis service.
 """
+
 import argparse
 import json
 import sys
 
+import spacy
 from presidio_analyzer import AnalyzerEngine
 from presidio_analyzer.nlp_engine import NlpEngineProvider
-import spacy
 
 parser = argparse.ArgumentParser()
-parser.add_argument('--language', default='en')
-parser.add_argument('--model', default='en_core_web_lg')
+parser.add_argument("--language", default="en")
+parser.add_argument("--model", default="en_core_web_lg")
 options = parser.parse_args()
 if not spacy.util.is_package(options.model):
-    raise SystemExit('Install the selected model before running this offline bridge.')
+    raise SystemExit("Install the selected model before running this offline bridge.")
 
 text = sys.stdin.read(10 * 1024 * 1024 + 1)
 if len(text) > 10 * 1024 * 1024:
     raise SystemExit(2)
-nlp = NlpEngineProvider(nlp_configuration={
-    'nlp_engine_name': 'spacy',
-    'models': [{'lang_code': options.language, 'model_name': options.model}],
-}).create_engine()
+nlp = NlpEngineProvider(
+    nlp_configuration={
+        "nlp_engine_name": "spacy",
+        "models": [{"lang_code": options.language, "model_name": options.model}],
+    }
+).create_engine()
 analyzer = AnalyzerEngine(nlp_engine=nlp, supported_languages=[options.language])
 results = analyzer.analyze(text=text, language=options.language)
-json.dump([{"start":r.start,"end":r.end,"entity_type":r.entity_type} for r in results], sys.stdout)
+json.dump(
+    [{"start": r.start, "end": r.end, "entity_type": r.entity_type} for r in results],
+    sys.stdout,
+)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-foundation/sensitive-data-sanitizer",
-  "version": "0.16.2",
+  "version": "0.17.1",
   "description": "Offline sensitive-text sanitization with credential, multilingual personal-data and scanner union detection",
   "type": "module",
   "main": "src/index.js",
@@ -77,7 +77,9 @@
   "license": "Unlicense",
   "devEngines": {
     "packageManager": {
-      "name": "npm"
+      "name": "npm",
+      "version": ">=12.2.2",
+      "onFail": "error"
     }
   },
   "publishConfig": {
@@ -92,19 +94,23 @@
   },
   "devDependencies": {
     "@changesets/cli": "^3.0.3",
-    "eslint": "^10.13.0",
+    "@eslint/js": "^10.0.1",
+    "browser-commander": "0.34.1",
+    "cmd-shim": "^9.0.2",
+    "command-stream": "2.6.0",
+    "eslint": "^10.14.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-prettier": "^5.5.7",
     "husky": "^9.1.7",
-    "jscpd": "^5.4.0",
-    "lint-staged": "^16.4.0",
+    "jscpd": "^5.4.2",
+    "lino-arguments": "0.4.0",
+    "lint-staged": "^17.6.0",
     "mrz": "^5.0.2",
-    "prettier": "^3.6.2",
-    "secretlint": "13.0.7",
-    "test-anywhere": "^0.8.48",
-    "@eslint/js": "^10.0.1",
-    "command-stream": "2.4.0",
-    "lino-arguments": "0.4.0"
+    "playwright": "1.65.0",
+    "prettier": "^3.9.10",
+    "secretlint": "13.1.0",
+    "semver": "^7.8.6",
+    "test-anywhere": "^0.9.1"
   },
   "lint-staged": {
     "*.{js,mjs,cjs}": [
@@ -119,25 +125,30 @@
     "*.sh": [
       "pipx run --spec shellcheck-py==0.11.0.1 shellcheck"
     ],
+    "*.py": [
+      "pipx run --spec ruff==0.17.4 ruff check --fix --force-exclude",
+      "pipx run --spec ruff==0.17.4 ruff format --force-exclude",
+      "pipx run --spec ruff==0.17.4 ruff format --check --force-exclude"
+    ],
     ".husky/*": [
       "pipx run --spec shellcheck-py==0.11.0.1 shellcheck"
     ]
   },
   "dependencies": {
     "@faker-js/faker": "^10.6.0",
-    "@secretlint/core": "13.0.7",
-    "@secretlint/profiler": "13.0.7",
-    "@secretlint/secretlint-rule-preset-recommend": "13.0.7",
-    "libphonenumber-js": "1.13.14",
-    "links-notation": "0.30.0",
+    "@secretlint/core": "13.1.0",
+    "@secretlint/profiler": "13.1.0",
+    "@secretlint/secretlint-rule-preset-recommend": "13.1.0",
+    "libphonenumber-js": "1.13.15",
+    "links-notation": "0.31.0",
     "re2-wasm": "1.0.2",
-    "re2js": "^2.9.0",
+    "re2js": "^2.9.1",
     "yaml": "^2.9.1"
   },
   "allowScripts": {
     "node-pty": false
   },
   "overrides": {
-    "minimatch@>=7 <11": "^11.0.4"
+    "minimatch@>=7 <11": "^11.0.5"
   }
 }

package/src/context.js

@@ -421,7 +421,11 @@ function detectPersonalLabels(text, emit) {
       const range = valueRange(
         text,
         match.index + match[0].length + suffix.length,
-        identity ? 'token' : 'line',
+        /[?&]$/.test(text.slice(0, match.index))
+          ? 'query'
+          : identity
+            ? 'token'
+            : 'line',
         512
       );
       if (range && personalValueAllowed(text, range, type, match.index)) {

package/src/detection.js

@@ -273,7 +273,19 @@ function detectPersonalFormats(text, options, emit) {
   collectMatches(
     text,
     /(?<!\d)\+\d[\d ()-]{6,24}\d(?!\d)/g,
-    emit,
+    (finding) => {
+      if (
+        /[?&]phone=$/i.test(
+          text.slice(Math.max(0, finding.start - 8), finding.start)
+        )
+      ) {
+        const token = /^[^\s&#]+/.exec(
+          text.slice(finding.start, finding.end)
+        )[0];
+        finding.end = finding.start + token.length;
+      }
+      emit(finding);
+    },
     { type: 'PHONE', category: 'personal', rule: 'international-phone' },
     0,
     (v) => {

package/src/document-entities.js

@@ -3,6 +3,7 @@ import { firstNames } from './names.js';
 import { organizationCore, personalRegex } from './personal-variants.js';
 import { documentVocabulary } from './document-vocabulary.js';
 import { months } from './personal-context.js';
+import { detectDocumentExtras } from './document-extras.js';
 import { detectDocumentPatterns } from './document-patterns.js';
 
 const words = (column) =>
@@ -47,7 +48,7 @@ const ruAcronym =
 const ruResidence =
   /(?:[Гг]ород|[Пп]роживаю|[Пп]роживание|[Мм]есто жительства)[ \t]*:[ \t]*([А-ЯЁ][а-яё-]{2,47})|([А-ЯЁ][а-яё-]{2,47})(?=,[ \t]*(?:готов[а]?[ \t]+к[ \t]+переезду|Россия|Беларусь|Казахстан|Украина))/gu;
 const ruIntroduction = new RegExp(
-  `(?:[Мм]еня зовут|[Сс] уважением)[, \t]+(${firstNames.ru.split(' ').join('|')})(?!${boundary})`,
+  `(?:[Мм]еня зовут|[Сс] уважением)[, \t\r\n]+(${firstNames.ru.split(' ').join('|')})(?!${boundary})`,
   'gu'
 );
 const groupOrganization = new RegExp(
@@ -67,7 +68,7 @@ const rangeOpen = ['по настоящее время', 'настоящее в
   .flatMap((word) => [word, capitalized(word)])
   .map(escapePattern)
   .join('|');
-const range = `${rangeStart}(?:[ \\t]*[-–—][ \\t]*|[ \\t]+(?:по|to)[ \\t]+)(?:${rangeStart}|${rangeOpen})(?!${boundary})`;
+const range = `${rangeStart}(?:[ \\t]*[-–—][ \\t]*|[ \\t]+(?:по|to)[ \\t]+)(?:${rangeStart}|${rangeOpen}|null|(?=\\)))(?!${boundary})`;
 const titleWord = '[\\p{L}\\p{N}][\\p{L}\\p{N}/+#.&-]{0,39}';
 // A segment starts a line or follows `|`. `Опыт:` or `Опыт -` before the title
 // reads like a list marker: the date range remains the anchor of the rule.
@@ -89,6 +90,7 @@ export function detectDocumentEntities(text, emit, options) {
     return;
   }
   detectDocumentPatterns(text, emit);
+  detectDocumentExtras(text, emit, range);
   const found = [];
   const capture = (finding) => {
     found.push(finding);

package/src/document-extras.js

@@ -0,0 +1,170 @@
+import { collectMatches } from './detection.js';
+
+const boundary = '[\\p{L}\\p{N}_]';
+const proper = '[\\p{Lu}][\\p{L}\\p{M}\\p{N}.-]{0,46}[\\p{L}\\p{M}\\p{N}]';
+const name = `${proper}(?:[ \\t]+${proper}){0,5}`;
+const orgList = `(?:«[^«»\\r\\n]{1,160}»|${name})(?:[ \\t]*(?:,|и|and)[ \\t]+${name}){0,5}`;
+const cues = new RegExp(
+  `(?<!${boundary})(?:компании|опыт[ \\t]+в|проекты[ \\t]+для|[Рр]оль[ \\t]+в)[ \\t]+(${orgList})(?!${boundary})`,
+  'gu'
+);
+const duration = new RegExp(
+  `(?<!${boundary})(${name})(?=[ \\t]*\\(\\d{1,2}[ \\t]+(?:год|года|лет|years?)\\))`,
+  'gu'
+);
+// JavaScript's \b is ASCII-only; Cyrillic titles use a Unicode lookahead.
+const role =
+  /^(?:менеджер|директор|руководитель|инженер|аналитик|разработчик)(?![\p{L}])|^(?:manager|director|engineer|developer|senior|qa)\b/iu;
+
+export function detectDocumentExtras(text, emit, range) {
+  for (const [type, rule, pattern, group] of [
+    ['PHONE', 'document-mobile-bare', /^[78]9\d{9}$/gm, 0],
+    [
+      'PHONE',
+      'document-mobile-context',
+      /(?<![\p{L}\p{N}_])(?:пишите|контакт)[:,]?[ \t]+([78]9\d{9})(?!\d)/giu,
+      1,
+    ],
+    [
+      'ORGANIZATION',
+      'organization-experience-prose',
+      new RegExp(`опыт[ \\t]*\\((${name})\\)`, 'gu'),
+      1,
+    ],
+    ['ORGANIZATION', 'organization-duration', duration, 1],
+    [
+      'PERSON',
+      'document-role',
+      /(?<![\p{L}\p{N}_])(?:Соискатель|Сотрудник)[ \t]*:[ \t]*([\p{Lu}][\p{L}-]{1,47}(?:[ \t]+[\p{Lu}][\p{L}-]{1,47}){0,4})/gu,
+      1,
+    ],
+    [
+      'URL',
+      'document-personal-path',
+      /(?<![\p{L}\p{N}_])(?:https?:\/\/[^\s/"<>]+)?\/(?:u|in|users?|profiles?|people|members?|home)\/[^\s?&#"<>\\]{1,128}/giu,
+      0,
+    ],
+    [
+      'URL',
+      'document-share-link',
+      /https?:\/\/[^\s/"<>]+\/(?:[^\s/?#"<>]{1,64}\/){0,5}[A-Za-z0-9_-]{24,128}(?:\/[^\s?&#"<>\\]{0,64})?/gu,
+      0,
+    ],
+  ]) {
+    collectMatches(
+      text,
+      pattern,
+      emit,
+      { type, rule, category: 'personal', confidence: 0.85 },
+      group
+    );
+  }
+  for (const match of text.matchAll(cues)) {
+    const offset = match.index + match[0].lastIndexOf(match[1]);
+    for (const company of match[1].matchAll(
+      new RegExp(`«[^«»\\r\\n]{1,160}»|${name}`, 'gu')
+    )) {
+      emit({
+        start: offset + company.index,
+        end: offset + company.index + company[0].length,
+        type: 'ORGANIZATION',
+        category: 'personal',
+        rule: 'organization-cue',
+        confidence: 0.85,
+      });
+    }
+  }
+  detectQueryContacts(text, emit);
+  detectExperience(text, emit, range);
+}
+
+function detectQueryContacts(text, emit) {
+  // Retain query context while decoding; standalone contacts may be public specimens.
+  for (const match of text.matchAll(
+    /[?&](email|phone)=([^\s&#"<>\\]{1,512})/giu
+  )) {
+    let value;
+    try {
+      value = decodeURIComponent(match[2]);
+    } catch {
+      continue;
+    }
+    const email = match[1].toLowerCase() === 'email';
+    if (
+      !(
+        email ? /^[^\s@]+@[^\s@]+\.[\p{L}]{2,63}$/u : /^\+?[\d () .-]{7,40}$/
+      ).test(value)
+    ) {
+      continue;
+    }
+    if (value === '[REDACTED]') {
+      continue;
+    }
+    const start = match.index + match[0].length - match[2].length;
+    emit({
+      start,
+      end: start + match[2].length,
+      type: email ? 'EMAIL' : 'PHONE',
+      category: 'personal',
+      rule: 'label',
+      confidence: 0.95,
+    });
+  }
+}
+
+function detectExperience(text, emit, range) {
+  // Date anchors bound each entry; do not guess at undated employer/title fragments.
+  collectMatches(
+    text,
+    new RegExp(
+      `(?:^|[\\r\\n])[ \\t]*[^|\\r\\n]{1,120}\\|[ \\t]*(${name})[ \\t]*\\|[ \\t]*${range}`,
+      'gu'
+    ),
+    emit,
+    {
+      type: 'ORGANIZATION',
+      rule: 'organization-experience',
+      category: 'personal',
+      confidence: 0.85,
+    },
+    1
+  );
+  const dated = new RegExp(`([^\\r\\n;|]{1,320}?)\\((${range})\\)`, 'gu');
+  for (const match of text.matchAll(dated)) {
+    const prefix = match[1];
+    const content = prefix
+      .replace(/^.*\(\d[^)]*\)[, \t]*/, '')
+      .replace(/^[, \t]+/, '');
+    const chunks = [...content.matchAll(/[^,]+/g)];
+    const parts = chunks.map((part) => part[0].trim());
+    let value;
+    if (parts.length > 1 && role.test(parts[0])) {
+      let index = 1;
+      while (index < parts.length - 1 && /^[\p{Ll}]/u.test(parts[index])) {
+        index++;
+      }
+      value = content.slice(chunks[index].index).trim();
+    } else if (parts.length === 2 && role.test(parts[1])) {
+      value = parts[0].trim();
+    }
+    if (
+      !value ||
+      !/^[\p{Lu}«“"]/u.test(value) ||
+      value.includes('[REDACTED]')
+    ) {
+      continue;
+    }
+    const start = match.index + prefix.lastIndexOf(value);
+    if (start < match.index) {
+      continue;
+    }
+    emit({
+      start,
+      end: start + value.length,
+      type: 'ORGANIZATION',
+      category: 'personal',
+      rule: 'organization-experience',
+      confidence: 0.85,
+    });
+  }
+}

package/src/document-fields.js

@@ -0,0 +1,19 @@
+// One explicit field vocabulary; camelCase, snake_case and kebab-case normalize alike.
+const groups = {
+  PERSON: ['firstname', 'lastname', 'middlename', 'patronymic'],
+  DATE_OF_BIRTH: ['birthday', 'birthdate'],
+  GENDER: ['sex'],
+  PERSONAL_ATTRIBUTE: ['citizenship', 'nationality'],
+  ORGANIZATION: ['company', 'companyname', 'employer'],
+  EDUCATION: ['university', 'school'],
+  PHONE: ['contact'],
+  URL: ['resumeurl', 'alternateurl', 'profileurl', 'companyurl'],
+};
+const types = new Map(
+  Object.entries(groups).flatMap(([type, fields]) =>
+    fields.map((field) => [field, type])
+  )
+);
+export function documentFieldType(field) {
+  return types.get(field.replace(/[_-]/g, '').toLowerCase());
+}

package/src/document-patterns.js

@@ -30,7 +30,7 @@ const rules = [
   [
     'PHONE',
     'document-phone-label',
-    /(?<![\p{L}\p{N}_])(?:(?:контактный[ \t]+)?телефон|тел\.?|моб\.?|сот\.?|WhatsApp)(?:[ \t]*:[ \t]*|[ \t]+)((?:[78][ () .-]*)?9\d{2}[ () .-]*\d{3}[ .-]*\d{2}[ .-]*\d{2})(?!\d)/giu,
+    /(?<![\p{L}\p{N}_])(?:(?:контактный[ \t]+)?телефон|контакт|тел\.?|моб\.?|сот\.?|WhatsApp)(?:[ \t]*:[ \t]*|[ \t]+)((?:[78][ () .-]*)?9\d{2}[ () .-]*\d{3}[ .-]*\d{2}[ .-]*\d{2})(?!\d)/giu,
     1,
   ],
   [
@@ -78,13 +78,13 @@ const rules = [
   [
     'EDUCATION',
     'school-acronym-context',
-    /(?<![\p{L}\p{N}_])(?:образование|ВУЗ|университет|окончил[аи]?)(?:[ \t]*:[ \t]*|[ \t]+)([А-ЯЁ]{2,12}(?:[ \t]+им\.[ \t]+[А-ЯЁ][а-яё-]{2,40})?)(?![\p{L}\p{N}_])/giu,
+    /(?<![\p{L}\p{N}_])(?:образование|ВУЗ|университет|учил(?:ся|ась)[ \t]+в|окончил[аи]?)(?:[ \t]*:[ \t]*|[ \t]+)([А-ЯЁ]{2,12}(?:[ \t]+им\.[ \t]+[А-ЯЁ][а-яё-]{2,40})?)(?![\p{L}\p{N}_])/giu,
     1,
   ],
   [
     'EDUCATION',
     'education-label',
-    /(?<![\p{L}\p{N}_])Education[ \t]*:[ \t]*([A-Z][A-Za-z.-]{1,47})(?![\p{L}\p{N}_])/gu,
+    /(?<![\p{L}\p{N}_])Education[ \t]*:[ \t]*([\p{Lu}][\p{L}.-]{1,47})(?![\p{L}\p{N}_])/gu,
     1,
   ],
   [
@@ -124,16 +124,13 @@ const rules = [
   [
     'PERSONAL_ATTRIBUTE',
     'profile-attribute',
-    /(?<![\p{L}\p{N}_])(?:Гражданство|Citizenship|Семейное положение|Marital status|Дети|национальность|Вероисповедание|инвалидность|судимость)[ \t]*:[ \t]*([^\r\n";|]{1,160})/giu,
+    /(?<![\p{L}\p{N}_])(?:Гражданство|Citizenship|Семейное положение|Marital status|Дети|национальность|Вероисповедание|инвалидность|судимость)[ \t]*:[ \t]*([^\\\r\n";|]{1,160})/giu,
     1,
   ],
   [
     'ORGANIZATION',
     'employer-label',
-    new RegExp(
-      `(?<!${boundary})(?:[Кк]омпания|[Рр]аботодатель|[Мм]есто работы|[Cc]ompany|[Ee]mployer)[ \\t]*:[ \\t]*([\\p{Lu}][\\p{L}\\p{M}.-]{1,47})(?!${boundary})`,
-      'gu'
-    ),
+    /(?<![\p{L}\p{N}_])(?:Компания|Работодатель|Место работы|Company|Employer)[ \t]*:[ \t]*([\p{Lu}][^,;|\\\r\n":]{0,159})/giu,
     1,
   ],
   [

package/src/engines.js

@@ -24,6 +24,8 @@ import {
 } from './placeholders.js';
 import {
   structuredBatches,
+  structuredFieldFindings,
+  declaredFieldFindings,
   structuredValueViews,
   mapStructuredFindings,
   verifyStructured,
@@ -131,6 +133,7 @@ async function analyzeStructured(
 ) {
   const findings = [];
   for (const batch of structuredBatches(text, options)) {
+    findings.push(...structuredFieldFindings(batch, options));
     for (const finding of mapStructuredFindings(
       batch,
       await analyze(
@@ -162,10 +165,18 @@ async function analyzeStructured(
   }
   // Native structured inspection validates, locates and reapplies the
   // same fake-value/public policy to source offsets from all engines.
-  return inspectFindingsOnly(text, [...findings, ...(nativeFindings ?? [])], {
-    ...options,
-    findings: initial,
-  });
+  return inspectFindingsOnly(
+    text,
+    [
+      ...findings,
+      ...declaredFieldFindings(text, options),
+      ...(nativeFindings ?? []),
+    ],
+    {
+      ...options,
+      findings: initial,
+    }
+  );
 }
 
 export function createSanitizer(options = {}) {

package/src/index.d.ts

@@ -9,11 +9,7 @@ export interface Finding {
   /** Detector confidence, not a cross-engine probability calibration. */
   confidence?: number;
   likelihood?:
-    | 'VERY_UNLIKELY'
-    | 'UNLIKELY'
-    | 'POSSIBLE'
-    | 'LIKELY'
-    | 'VERY_LIKELY';
+    'VERY_UNLIKELY' | 'UNLIKELY' | 'POSSIBLE' | 'LIKELY' | 'VERY_LIKELY';
   /** One-based line and UTF-16 column, populated by inspect. */
   line?: number;
   column?: number;
@@ -67,6 +63,8 @@ export interface SanitizerOptions {
   structured?: 'json' | 'jsonl';
   /** Property names whose metadata heuristics may be suppressed. */
   structuralFields?: string[];
+  /** Exact, case-sensitive property names whose entire values are redacted in JSON/JSONL. */
+  sensitiveFields?: string[];
   /** Personal replacement threshold, default 0.5. Inspect retains lower scores. */
   minConfidence?: number;
   /** Alias for minConfidence; specifying both requires equal values. */

package/src/log-bytes.js

@@ -13,7 +13,7 @@ export function decodeLogBytes(input) {
   } catch {
     const parts = [];
     let start = 0;
-    for (let i = 0; i < bytes.length; ) {
+    for (let i = 0; i < bytes.length;) {
       const width = sequenceWidth(bytes[i]);
       if (validSequence(bytes, i, width)) {
         i += width;

package/src/sanitizer.js

@@ -31,6 +31,8 @@ import {
 } from './placeholders.js';
 import {
   structuredBatches,
+  structuredFieldFindings,
+  declaredFieldFindings,
   inspectStructuredValues,
   mapStructuredFindings,
   preserveIdentifierKeys,
@@ -71,6 +73,7 @@ const optionNames = new Set([
   'fakeValues',
   'structured',
   'structuralFields',
+  'sensitiveFields',
   'minConfidence',
   'threshold',
   'profile',
@@ -101,12 +104,18 @@ function validateCollections(options) {
     'detectors',
     'fakeValues',
     'structuralFields',
+    'sensitiveFields',
   ]) {
     if (options[key] !== undefined && !Array.isArray(options[key])) {
       throw failure('ERR_CONFIG');
     }
   }
-  for (const key of ['knownSecrets', 'fakeValues', 'structuralFields']) {
+  for (const key of [
+    'knownSecrets',
+    'fakeValues',
+    'structuralFields',
+    'sensitiveFields',
+  ]) {
     if (
       (options[key] ?? []).some((value) => typeof value !== 'string' || !value)
     ) {
@@ -394,6 +403,7 @@ function inspectText(text, options = {}) {
   validateInput(text, options);
   if (options.structured) {
     const findings = structuredBatches(text, options).flatMap((batch) => [
+      ...structuredFieldFindings(batch, options),
       ...mapStructuredFindings(
         batch,
         inspect(batch.text, {
@@ -407,7 +417,11 @@ function inspectText(text, options = {}) {
         inspect(value, { ...options, structured: undefined, findings: [] })
       ),
     ]);
-    return inspectFindingsOnly(text, findings, options);
+    return inspectFindingsOnly(
+      text,
+      [...findings, ...declaredFieldFindings(text, options)],
+      options
+    );
   }
   const findings = [];
   const emit = (f) => {
@@ -602,6 +616,9 @@ export function markFake(text, findings, options) {
     ),
   ];
   return findings.map((f) => {
+    if (f.type === 'JSON_VALUE') {
+      return { ...f, kept: undefined };
+    }
     if (
       trusted.some(
         (span) =>
@@ -660,7 +677,9 @@ function validatedSpans(text, findings, options) {
       if (f.category === 'credential') {
         last.category = 'credential';
       }
-      if (credentialRun) {
+      if (last.type === 'JSON_VALUE' || f.type === 'JSON_VALUE') {
+        last.type = 'JSON_VALUE';
+      } else if (credentialRun) {
         last.type = 'SECRET';
       } else if (preferredType(last.type, f.type, options)) {
         last.type = f.type;
@@ -673,6 +692,12 @@ function validatedSpans(text, findings, options) {
 }
 
 function preferredType(current, candidate, options) {
+  if (current === 'JSON_VALUE') {
+    return false;
+  }
+  if (candidate === 'JSON_VALUE') {
+    return true;
+  }
   if (current === 'ENCODED_SENSITIVE') {
     return false;
   }
@@ -810,7 +835,7 @@ export async function redactResultAsync(
       );
       replacements.set(
         `${span.start}:${span.end}`,
-        encodeRun(run, result.text)
+        encodeRun(run, result.text === run.text ? REDACTED : result.text)
       );
     }
   }

package/src/structured.js

@@ -1,4 +1,5 @@
 import { failure } from './detection.js';
+import { documentFieldType } from './document-fields.js';
 import { hasPlaceholders } from './placeholders.js';
 
 // Session metadata is opt-in at the CLI; library callers choose their own
@@ -114,6 +115,33 @@ export function structuredBatches(text, options) {
   return batches;
 }
 
+// Schema declarations take priority over metadata/public/fake heuristics.
+export function structuredFieldFindings(batch, options) {
+  return batch.entries.flatMap((entry) => {
+    const type = options.documentEntities
+      ? documentFieldType(entry.field)
+      : undefined;
+    if (
+      entry.key ||
+      !type ||
+      entry.raw.length <= 2 ||
+      JSON.parse(entry.raw) === '[REDACTED]'
+    ) {
+      return [];
+    }
+    return [
+      {
+        start: entry.start + 1,
+        end: entry.start + entry.raw.length - 1,
+        type,
+        category: 'personal',
+        rule: 'known-personal',
+        confidence: 1,
+      },
+    ];
+  });
+}
+
 export function structuredValueRanges(text, options) {
   return structuredBatches(text, options).flatMap((batch) =>
     batch.entries
@@ -356,7 +384,7 @@ function stringOffsets(raw) {
   }
   const starts = [],
     ends = [];
-  for (let i = 1; i < raw.length - 1; ) {
+  for (let i = 1; i < raw.length - 1;) {
     const start = i;
     i += raw[i] === '\\' ? (raw[i + 1] === 'u' ? 6 : 2) : 1;
     starts.push(start);
@@ -364,3 +392,70 @@ function stringOffsets(raw) {
   }
   return { starts, ends };
 }
+
+// A caller-declared property replaces its entire JSON value, including containers
+// and primitives. Source token offsets preserve the surrounding record.
+export function declaredFieldFindings(text, options) {
+  if (!options.sensitiveFields?.length) {
+    return [];
+  }
+  const fields = new Set(options.sensitiveFields);
+  const findings = [];
+  for (const token of lexemes(text)) {
+    if (
+      token.index < (findings.at(-1)?.end ?? 0) ||
+      !token.key ||
+      !fields.has(JSON.parse(token.raw))
+    ) {
+      continue;
+    }
+    let start = token.index + token.raw.length;
+    while (/[\s:]/.test(text[start] ?? '') && start < text.length) {
+      start++;
+    }
+    const end = jsonValueEnd(text, start);
+    if (text.slice(start, end) === '"[REDACTED]"') {
+      continue;
+    }
+    findings.push({
+      start,
+      end,
+      type: 'JSON_VALUE',
+      category: 'personal',
+      rule: 'known-personal',
+      confidence: 1,
+    });
+  }
+  return findings;
+}
+function jsonValueEnd(text, start) {
+  let depth = 0,
+    quoted = false;
+  for (let i = start; i < text.length; i++) {
+    const char = text[i];
+    if (quoted) {
+      if (char === '\\') {
+        i++;
+      } else if (char === '"') {
+        quoted = false;
+        if (!depth) {
+          return i + 1;
+        }
+      }
+    } else if (char === '"') {
+      quoted = true;
+    } else if (char === '[' || char === '{') {
+      depth++;
+    } else if (char === ']' || char === '}') {
+      if (!depth) {
+        return i;
+      }
+      if (!--depth) {
+        return i + 1;
+      }
+    } else if (!depth && /[\s,]/.test(char)) {
+      return i;
+    }
+  }
+  return text.length;
+}

package/src/transforms.js

@@ -183,6 +183,9 @@ function transformed(value, finding, transform, options) {
   return `${lower}–${lower + transform.size - 1}`;
 }
 export function renderReplacement(text, finding, options, encodedSanitize) {
+  if (finding.type === 'JSON_VALUE') {
+    return JSON.stringify(REDACTED);
+  }
   const transform =
     options.transformations?.[finding.type] ??
     options.transformation ??
@@ -193,7 +196,10 @@ export function renderReplacement(text, finding, options, encodedSanitize) {
     const raw = text.slice(finding.start, finding.end);
     const run = encodedValue(raw);
     if (run && (options.preserveEncoding || run.encoding === 'json-content')) {
-      return encodeRun(run, encodedSanitize(run.text).text);
+      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');