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

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.18.0
+
+### Minor Changes
+
+- f0016ea: Add opt-in structural proper-name redaction with per-string activation and
+  configurable Unicode scripts. Broaden dated document employers, group and school
+  cues, comma-separated mobiles and short share links; preserve operational paths
+  and technology controls. Normalize caller-sensitive fields like built-in names.
+
 ## 0.17.1
 
 ### Patch Changes

package/README.md

@@ -22,6 +22,23 @@ sensitive-data-sanitizer redact session.jsonl --stream --jsonl --two-pass --outp
 
 ## Quick Start
 
+For stored prose that can tolerate extra redaction, opt into structural proper
+names independently for each string value:
+
+```js
+sanitize('Работал в Ромашке менеджером по продажам.', {
+  profile: 'documents',
+  properNames: 'capitalized',
+}).text;
+// [REDACTED] в [REDACTED] менеджером по продажам.
+```
+
+The rule defaults to Cyrillic or structural data triggers, keeps JSON keys and
+numbers, and supports caller-selected Unicode `scripts`. It is off by default.
+See [activation rules and limits](docs/API.md#structural-prose-redaction) and the
+[prose-log example](examples/prose-logs.mjs). CLI:
+`redact input.jsonl --jsonl --proper-names capitalized --profile documents`.
+
 ### Readable placeholders and document profiles
 
 Use the opt-in `documents` profile for CVs and similar prose. It adds bounded

package/bin/sensitive-data-sanitizer.js

@@ -60,6 +60,8 @@ history rewrite SOURCE --output DIRECTORY [--apply]
 --jsonl             Sanitize JSONL records; combine with --stream for sessions
 --identity-mask     First/last 2 identity mask (publication profile default)
 --profile NAME      publication (redact default) or documents (CV/entity rules)
+--proper-names MODE Structural prose rule: capitalized (off by default)
+--scripts LIST      Comma-separated Unicode Script names (default Cyrillic)
 --placeholder       Typed numbered placeholders; requires --map or --no-map
 --map PATH          Private JSON/.lino restore map; reuse it across files/runs
 --no-map            Discard placeholder mapping after full anonymization
@@ -122,6 +124,8 @@ function parseArgs(argv) {
     ['--worker-timeout-ms', 'workerTimeoutMs'],
     ['--filter-repo', 'filterRepo'],
     ['--profile', 'profile'],
+    ['--proper-names', 'properNames'],
+    ['--scripts', 'scripts'],
     ['--map', 'map'],
     ['--map-format', 'mapFormat'],
     ['--placeholder-format', 'placeholderFormat'],
@@ -341,6 +345,10 @@ async function loadOptions(config) {
 
 async function featureOptions(config, options) {
   await localCredentials(config, options);
+  options.properNames = config.properNames ?? options.properNames;
+  if (config.scripts !== undefined) {
+    options.scripts = config.scripts.split(',');
+  }
   if (config.knownOnly) {
     options.knownOnly = true;
   }

package/docs/API.md

@@ -140,7 +140,9 @@ and a shared map; such conflicting occurrence metadata is refused. Choose
 separate maps for those documents if exact independent restoration is needed.
 
 JSON/JSONL keys and values participate equally in placeholder mode, including
-ordinary identifier keys and declared structural fields. Parseability and
+ordinary identifier keys and declared structural fields. With `properNames`,
+JSON keys remain unchanged by automatic personal detection in all transformation
+modes. Explicit known values and credentials retain priority. Parseability and
 duplicate-key checks remain enforced. Plain redact/fake policies retain their
 existing metadata/key behavior. Use `structured` for valid structured input.
 The normal encoding limits and credential redaction policy continue to apply.
@@ -157,6 +159,8 @@ new document recognizers; `documentEntities: false` turns them off explicitly.
 | Option             | Default / meaning                                                                                                                                           |
 | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `documentEntities` | Off; bounded organization, education and location rules; enabled by the documents profile                                                                   |
+| `properNames`      | Off; `'capitalized'` enables structural name redaction in activated prose strings                                                                           |
+| `scripts`          | `['Cyrillic']`; Unicode Script aliases that activate the prose rule; `[]` disables only script activation                                                   |
 | `profile`          | Off; `'publication'` sets a 0.3 threshold and identity masking; `'documents'` enables document entities                                                     |
 | `knownOnly`        | `false`; disable all automatic detection (including credentials, Secretlint and custom detectors); use only explicit known values and reused map identities |
 | `knownSecrets`     | `[]`; exact literal credential values, regardless of length or format                                                                                       |
@@ -176,7 +180,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                                           |
+| `sensitiveFields`  | `[]`; JSON/JSONL names normalized for case and `_`/`-`; 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.
@@ -478,8 +482,9 @@ Authorization headers (including Proxy-Authorization) redact the scheme and one
 
 ## Caller-declared sensitive fields
 
-In structured JSON/JSONL, `sensitiveFields: string[]` matches exact,
-case-sensitive property names at any depth. The complete property value becomes
+In structured JSON/JSONL, `sensitiveFields: string[]` ignores case and removes
+underscores and hyphens at any depth, like built-in document fields. For example,
+`fooBar` also matches `foo_bar`, `FooBar` and `foo-bar`. 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
@@ -505,3 +510,58 @@ sanitize('Lyutik работал', {
 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.
+
+## Structural prose redaction
+
+`properNames: 'capitalized'` is an optional, deliberately aggressive native rule
+for stored prose. It works with any profile; the examples use `documents` for
+its other document rules. It is off by default.
+
+```js
+sanitize('Работал в Ромашке менеджером по продажам.', {
+  profile: 'documents',
+  properNames: 'capitalized',
+}).text;
+// [REDACTED] в [REDACTED] менеджером по продажам.
+```
+
+Each string activates independently if it contains a letter from `scripts`, a
+parenthesized document date range, a comma followed by an 11-digit `79…`/`89…`
+mobile shape, or an HTTP(S)/bare-domain link with a `/d/<id>` path. `scripts`
+defaults to `['Cyrillic']`, suitable for English operational logs; choose Unicode
+Script aliases such as `['Greek', 'Cyrillic']` for your workload. Script names
+are case-sensitive runtime Unicode property aliases, not language codes.
+`scripts: []` disables script activation while retaining the other triggers.
+
+Inside activated values, the rule replaces words containing an uppercase letter
+anywhere (`iPhone`, `A.B`, `Санкт-Петербург`), typographic quoted spans (including
+lowercase `«ромашка лютик»`), links including `example.org/path`, and bare domestic
+mobile shapes. Labels immediately before a colon (also `Label :`), lowercase
+words, numbers, date ranges and path tokens stay. A path can still match existing
+personal-path or credential rules. Numeric primitives and JSON keys stay; string
+escapes and surrounding source formatting are retained. JSON/JSONL activation
+also applies independently within serialized JSON strings, to the existing
+bounded decoding depth. Findings do not seed document-wide name propagation.
+Repeated redaction is stable. Reusing a placeholder map for the same original
+produces stable tokens and exact restoration; the existing placeholder-namespace
+collision checks still reject input that already contains typed placeholders.
+
+This is a structural heuristic, so capitalized ordinary words also disappear.
+Lowercase organizations and `Ромашка: менеджер` stay. English prose without a
+trigger (`Worked at Romashka for three years.`), isolated neutral-key values
+`{"note":"Romashka"}` / `{"note":"1991-03-12"}`, and a personal website root
+without a trigger stay under this rule. The existing detectors and explicit
+known/sensitive-field policies still run: an unactivated value is byte-for-byte
+unchanged by this additional rule, not exempt from credential detection.
+`credentialsOnly` and `knownOnly` suppress automatic prose detection.
+
+The new scanner uses a fixed number of forward passes over maximal tokens,
+including long tokens without spaces. This does not impose a linear-time bound
+on optional external engines or every preexisting detection rule. Debugging is
+off by default; `debug` receives value-free `proper-name-prose` and
+`document-experience` hit counts when those scans run.
+
+CLI equivalents: `--proper-names capitalized --scripts Cyrillic,Greek`.
+Configuration files accept the same `properNames` and `scripts` API options;
+use a configuration file for `scripts: []`. See the runnable
+[prose-log example](../examples/prose-logs.mjs).

package/docs/COVERAGE.md

@@ -60,7 +60,7 @@ The `documents` profile also reads employers from CV experience lines anchored o
 a date range: `Title, Employer (2019-05 – 2021-03)`, `Title — Employer, 2019–2021`
 and `Title (Employer), 2019–2021`. Ranges use years, `YYYY-MM`, `MM.YYYY`, full
 dates or `month YYYY`, with `по настоящее время`, `н.в.`, `по н.в.`, `present` and
-similar open ends. Titles have one to nine words. A label of one or two words
+similar open ends. For the non-parenthesized layouts, titles have one to nine words. A label of one or two words
 before the title (`Опыт: `, `Опыт работы - `, `Опыт — `) is read like a list marker,
 and a segment after `|` is read like a line start, so
 `Должность: Менеджер | Опыт: Аналитик, Ромашка (2018 – 2020)` also yields the
@@ -68,9 +68,9 @@ employer. The date range stays the anchor and the employer must still start with
 capital letter, a digit or a quote. Confidence is 0.60, and the employer then
 propagates through the document like other organizations. The default profile
 ignores these lines. Lines
-with more fields (`Title, Employer, City (dates)`) and titles containing a comma
-are not targeted and can leave the employer in place; date-anchored prose with
-the same shape can be flagged.
+with parenthesized ranges additionally support arbitrary title prefixes,
+comma-containing employers and titles, as described below. Date-anchored prose
+with the same shape can be flagged.
 
 The gazetteer has only the cities/regions explicitly listed in that module,
 including Springfield and Riverton. It is not a worldwide geocoder. Location
@@ -376,7 +376,8 @@ 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
+The parenthesized date-anchor scanner accepts arbitrary forward titles and
+lead-ins. The reversed `Company, manager` layout retains finite role cues. Undated
 `Менеджер, Ромашка Лютик`, `- Ромашка Лютик 5 лет` and
 `Последнее место работы Ромашка Лютик` remain explicit ambiguous limits, as
 permitted by #94. Use known values or schema declarations for them.
@@ -402,3 +403,48 @@ redaction replaces the fragment instead of repeating an unchanged result until
 
 The [requirement inventory and research](case-studies/issue-100/README.md)
 records the complete scope and regression evidence.
+
+## Dated entries and optional prose (issues 104–106)
+
+Parenthesized date anchors now delimit successive entries on the same line,
+including arbitrary title words and lead-ins (`Стаж = 5 лет:`, `= 3 года,`).
+Employers can contain comma suffixes, nested parentheses, slash-separated names,
+legal forms and multiple words. A pipe after the employer preserves the industry
+suffix. `Founder, consultant, Romashka (2019–2021)` and equivalent Russian entries
+share the parser. The employer must start with a capital letter, a quote, or a
+company-style digit/letter combination. **Lowercase employers remain a limit**:
+`Менеджер, romashka (2019–2021)` / `Менеджер, ромашка (2019–2021)` stay, preserving
+ambiguous controls such as `Встреча, понедельник (2019–2021)`.
+
+`ГК` and `группа компаний` introduce quoted or unquoted group names. Employment
+lists continue through repeated `, потом в` and `, затем в` items. Domestic
+`79…`/`89…` mobile shapes after a comma work in Russian and English text; plain
+`order`/`id` numbers stay. School detection also covers `(МГУ, 2012)`,
+`Образование (МГУ)`, `в МГТУ им. Баумана` and `Обучение: Skillbox, 2020`.
+The acronym vocabulary remains finite.
+
+Weak organization experience/duration cues preserve a small explicit technology
+set: Python, Go, SQL, Excel, Power BI, Kubernetes, PostgreSQL, Telegram and Scrum.
+This is an ambiguity policy, not general recognition of every product; a real
+employer with one of those names needs `knownPersonal` or a declared sensitive
+field. Explicit private values/fields and stronger legal-form cues still win.
+
+Document share-link detection also recognizes HTTP(S) URLs containing `/d/<id>`
+for any host and nonempty id length. Ordinary website roots remain a limit.
+Relative operational paths such as `{"location":"apps/api"}` stay; explicit
+personal paths and credential rules remain active. Caller-sensitive field names
+now use the same case/underscore/hyphen normalization as built-in document names.
+
+For no-cue prose, enable [`properNames: 'capitalized'`](API.md#structural-prose-redaction).
+It activates per value, defaults to Cyrillic script letters or structural data
+triggers, and supports configurable Unicode scripts. It intentionally loses
+capitalized ordinary words. Labels, lowercase words, dates, paths, JSON keys and
+untriggered values are outside this additional rule. English untriggered prose,
+lowercase names and a name immediately before a colon remain documented limits.
+The API describes the interaction with existing detectors and placeholder modes.
+
+The date-anchor scan visits each preceding entry once; the optional prose scanner
+classifies maximal tokens in fixed passes, avoiding repeated suffix searches on
+long unspaced input. This is not a latency guarantee for the whole pipeline.
+[The requirement inventory](case-studies/issue-106/README.md) records alternatives,
+research, regression evidence and reproducible bounded performance measurements.

package/examples/prose-logs.mjs

@@ -0,0 +1,16 @@
+import { sanitize } from '../src/index.js';
+
+// Synthetic mixed records: only the prose string activates the extra rule.
+const source = JSON.stringify({
+  note: 'Работал в Ромашке менеджером по продажам.',
+  operational: 'Connection to Postgres lost, retrying',
+  count: 42,
+});
+console.log(
+  sanitize(source, {
+    profile: 'documents',
+    properNames: 'capitalized',
+    scripts: ['Cyrillic'],
+    structured: 'json',
+  }).text
+);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-foundation/sensitive-data-sanitizer",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "description": "Offline sensitive-text sanitization with credential, multilingual personal-data and scanner union detection",
   "type": "module",
   "main": "src/index.js",
@@ -24,7 +24,8 @@
     "LICENSE",
     "README.md",
     "examples/shared-tool-logs.mjs",
-    "examples/reversible-placeholders.mjs"
+    "examples/reversible-placeholders.mjs",
+    "examples/prose-logs.mjs"
   ],
   "exports": {
     ".": {

package/src/context.js

@@ -257,6 +257,11 @@ function operationalValue(value, type) {
   );
 }
 
+function operationalLocationPath(value) {
+  return (
+    servicePath(value) || /^(?:\.?\.?\/)?[\w.-]+(?:\/[\w.-]+)+\/?$/.test(value)
+  );
+}
 // Shared by native labels and the vendor catalogs. Code expressions and
 // line escapes are not personal field values, even when a key is familiar.
 export function personalValueAllowed(text, range, type, labelStart) {
@@ -264,7 +269,10 @@ export function personalValueAllowed(text, range, type, labelStart) {
   if (!plausibleLabel(value, type)) {
     return false;
   }
-  if (['LOCATION', 'ADDRESS'].includes(type) && servicePath(value)) {
+  if (
+    ['LOCATION', 'ADDRESS'].includes(type) &&
+    operationalLocationPath(value)
+  ) {
     return false;
   }
   if (type === 'PHONE') {

package/src/detection.js

@@ -15,6 +15,7 @@ import {
 import { localAddress } from './public.js';
 import { detectKnownPersonal } from './personal-variants.js';
 import { detectDocumentEntities } from './document-entities.js';
+import { detectProseAndDocuments } from './proper-names.js';
 
 export const REDACTED = '[REDACTED]';
 export const failure = (code = 'ERR_SANITIZATION', location = {}) =>
@@ -173,7 +174,7 @@ export function nativeDetect(text, options, emit) {
   detectContext(text, emit, options.credentialsOnly);
   if (!options.credentialsOnly) {
     detectPersonal(text, emit);
-    detectDocumentEntities(text, emit, options);
+    detectProseAndDocuments(text, emit, options, detectDocumentEntities);
     detectCatalog(text, emit);
     detectIdentity(text, emit);
     detectNational(text, emit);

package/src/document-dates.js

@@ -0,0 +1,15 @@
+import { escapePattern } from './detection.js';
+import { months } from './personal-context.js';
+
+const boundary = '[\\p{L}\\p{M}\\p{N}_]';
+const capitalized = (word) => word[0].toUpperCase() + word.slice(1);
+const month = [
+  ...new Set(months.split('|').flatMap((word) => [word, capitalized(word)])),
+].join('|');
+const rangeStart = `(?:(?:19|20)\\d{2}(?:-\\d{2}){0,2}|\\d{2}[./](?:\\d{2}\\.)?\\d{4}|(?:${month})\\.?[ \\t]+(?:19|20)\\d{2})`;
+const rangeOpen = ['по настоящее время', 'настоящее время', 'сейчас', 'по н.в.']
+  .concat(['н.в.', 'по н/в', 'н/в', 'present', 'now', 'current'])
+  .flatMap((word) => [word, capitalized(word)])
+  .map(escapePattern)
+  .join('|');
+export const documentDateRange = `${rangeStart}(?:[ \\t]*[-–—][ \\t]*|[ \\t]+(?:по|to)[ \\t]+)(?:${rangeStart}|${rangeOpen}|null|(?=\\)))(?!${boundary})`;

package/src/document-entities.js

@@ -2,9 +2,10 @@ import { collectMatches, escapePattern } from './detection.js';
 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 { documentDateRange as range } from './document-dates.js';
 import { detectDocumentExtras } from './document-extras.js';
 import { detectDocumentPatterns } from './document-patterns.js';
+import { isDocumentTechnology } from './document-experience.js';
 
 const words = (column) =>
   [...new Set(documentVocabulary.flatMap((row) => row[column].split('|')))]
@@ -58,17 +59,6 @@ const groupOrganization = new RegExp(
 // CV experience lines: the date range anchors the employer slot, so prose with
 // a comma is untouched. Titles are not required to be lowercase because English
 // ones are often title case (`Senior QA Engineer`).
-const capitalized = (word) => word[0].toUpperCase() + word.slice(1);
-const month = [
-  ...new Set(months.split('|').flatMap((word) => [word, capitalized(word)])),
-].join('|');
-const rangeStart = `(?:(?:19|20)\\d{2}(?:-\\d{2}){0,2}|\\d{2}[./](?:\\d{2}\\.)?\\d{4}|(?:${month})\\.?[ \\t]+(?:19|20)\\d{2})`;
-const rangeOpen = ['по настоящее время', 'настоящее время', 'сейчас', 'по н.в.']
-  .concat(['н.в.', 'по н/в', 'н/в', 'present', 'now', 'current'])
-  .flatMap((word) => [word, capitalized(word)])
-  .map(escapePattern)
-  .join('|');
-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.
@@ -90,7 +80,23 @@ export function detectDocumentEntities(text, emit, options) {
     return;
   }
   detectDocumentPatterns(text, emit);
-  detectDocumentExtras(text, emit, range);
+  detectDocumentExtras(text, emit, range, options.debug);
+  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,
+    (value) => !isDocumentTechnology(value)
+  );
   const found = [];
   const capture = (finding) => {
     found.push(finding);
@@ -113,7 +119,8 @@ export function detectDocumentEntities(text, emit, options) {
       pattern,
       capture,
       { type, rule, category: 'personal', confidence },
-      group
+      group,
+      (value) => type !== 'ORGANIZATION' || !isDocumentTechnology(value)
     );
   }
   for (const match of text.matchAll(ruResidence)) {

package/src/document-experience.js

@@ -0,0 +1,110 @@
+const technology = new Set(
+  [
+    'Python',
+    'Go',
+    'SQL',
+    'Excel',
+    'Power BI',
+    'Kubernetes',
+    'PostgreSQL',
+    'Telegram',
+    'Scrum',
+  ].map((s) => s.toLowerCase())
+);
+export const isDocumentTechnology = (value) =>
+  technology.has(value.trim().toLowerCase());
+
+// Used only to disambiguate the reversed `Company, manager` layout. Forward
+// entries deliberately accept any title, without a title vocabulary.
+const reversedRole =
+  /^(?:менеджер|директор|руководитель|инженер|аналитик|разработчик|manager|director|engineer|developer|senior|qa)(?!\p{L})/iu;
+
+function commaParts(text) {
+  const parts = [];
+  let start = 0,
+    depth = 0,
+    quote;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (quote) {
+      if (char === quote) {
+        quote = undefined;
+      }
+    } else if ('«“"'.includes(char)) {
+      quote = { '«': '»', '“': '”', '"': '"' }[char];
+    } else if (char === '(') {
+      depth++;
+    } else if (char === ')') {
+      depth = Math.max(0, depth - 1);
+    } else if (char === ',' && !depth) {
+      parts.push({ start, text: text.slice(start, i).trim() });
+      start = i + 1;
+    }
+  }
+  parts.push({ start, text: text.slice(start).trim() });
+  return parts;
+}
+
+function employerSpan(prefix) {
+  // An industry suffix belongs to the entry, but is not an employer. A pipe
+  // before the title remains a section separator, as in `Опыт | Менеджер, ...`.
+  const comma = prefix.indexOf(',');
+  const pipe = comma < 0 ? -1 : prefix.indexOf('|', comma);
+  const content = pipe < 0 ? prefix : prefix.slice(0, pipe);
+  const parts = commaParts(content);
+  let index = 1;
+  if (parts.length === 1) {
+    return undefined;
+  }
+  if (/^[=\s\d]/u.test(parts[0].text)) {
+    index++;
+  }
+  if (parts.length === 2 && reversedRole.test(parts[1].text)) {
+    index = 0;
+  } else {
+    while (index < parts.length - 1 && /^\p{Ll}/u.test(parts[index].text)) {
+      index++;
+    }
+  }
+  const part = parts[index];
+  if (!part || !/^(?:[\p{Lu}«“"]|\d{1,4}-?\p{L})/u.test(part.text)) {
+    return undefined;
+  }
+  const end = index === 0 ? content.indexOf(',') : content.trimEnd().length;
+  const start = part.start + content.slice(part.start).search(/\S/u);
+  return isDocumentTechnology(content.slice(start, end))
+    ? undefined
+    : { start, end };
+}
+
+export function detectDatedEmployers(text, emit, range, debug) {
+  let cursor = 0,
+    count = 0;
+  // Match only the anchor, then visit each preceding segment once. No lazy
+  // prefix search restarts at every position on a long nonmatching line.
+  for (const match of text.matchAll(new RegExp(`\\(${range}\\)`, 'gu'))) {
+    const segment = text.slice(cursor, match.index);
+    const boundary =
+      Math.max(
+        segment.lastIndexOf('\n'),
+        segment.lastIndexOf('\r'),
+        segment.lastIndexOf(';')
+      ) + 1;
+    const prefix = segment.slice(boundary).replace(/^[., \t]+/u, '');
+    const span = employerSpan(prefix);
+    if (span) {
+      const offset = match.index - prefix.length;
+      emit({
+        start: offset + span.start,
+        end: offset + span.end,
+        type: 'ORGANIZATION',
+        category: 'personal',
+        rule: 'organization-experience',
+        confidence: 0.85,
+      });
+      count++;
+    }
+    cursor = match.index + match[0].length;
+  }
+  debug?.({ event: 'document-experience', count });
+}

package/src/document-extras.js

@@ -1,8 +1,14 @@
 import { collectMatches } from './detection.js';
+import {
+  detectDatedEmployers,
+  isDocumentTechnology,
+} from './document-experience.js';
+import { isDocumentShareLink } from './proper-names.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 employerName = `(?:«[^«»\\r\\n]{1,160}»|“[^“”\\r\\n]{1,160}”|"[^"\\r\\n]{1,160}"|${name})`;
 const orgList = `(?:«[^«»\\r\\n]{1,160}»|${name})(?:[ \\t]*(?:,|и|and)[ \\t]+${name}){0,5}`;
 const cues = new RegExp(
   `(?<!${boundary})(?:компании|опыт[ \\t]+в|проекты[ \\t]+для|[Рр]оль[ \\t]+в)[ \\t]+(${orgList})(?!${boundary})`,
@@ -12,13 +18,42 @@ 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) {
+export function detectDocumentExtras(text, emit, range, debug) {
   for (const [type, rule, pattern, group] of [
     ['PHONE', 'document-mobile-bare', /^[78]9\d{9}$/gm, 0],
+    [
+      'PHONE',
+      'document-mobile-comma',
+      /,[ \t]*([78]9\d{9})(?![\p{L}\p{N}_])/gu,
+      1,
+    ],
+    [
+      'ORGANIZATION',
+      'organization-group-cue',
+      new RegExp(
+        `(?<!${boundary})(?:ГК|[Гг]руппа компаний)[ \\t]+${employerName}`,
+        'gu'
+      ),
+      0,
+    ],
+    [
+      'EDUCATION',
+      'education-bracket',
+      /(?<=\()(МГУ|СПбГУ|МГТУ|РГГУ|ВШЭ)(?=[,)])/gu,
+      1,
+    ],
+    [
+      'EDUCATION',
+      'education-named-acronym',
+      /(?<![\p{L}\p{N}_])(?:МГУ|СПбГУ|МГТУ|РГГУ|ВШЭ)[ \t]+им\.[ \t]+[А-ЯЁ][а-яё-]{2,40}/gu,
+      0,
+    ],
+    [
+      'EDUCATION',
+      'education-training',
+      /(?<![\p{L}\p{N}_])(?:Обучение|Training)[ \t]*:[ \t]*([\p{Lu}][\p{L}\p{M}.-]{1,47})/gu,
+      1,
+    ],
     [
       'PHONE',
       'document-mobile-context',
@@ -56,7 +91,8 @@ export function detectDocumentExtras(text, emit, range) {
       pattern,
       emit,
       { type, rule, category: 'personal', confidence: 0.85 },
-      group
+      group,
+      (value) => type !== 'ORGANIZATION' || !isDocumentTechnology(value)
     );
   }
   for (const match of text.matchAll(cues)) {
@@ -64,6 +100,9 @@ export function detectDocumentExtras(text, emit, range) {
     for (const company of match[1].matchAll(
       new RegExp(`«[^«»\\r\\n]{1,160}»|${name}`, 'gu')
     )) {
+      if (isDocumentTechnology(company[0])) {
+        continue;
+      }
       emit({
         start: offset + company.index,
         end: offset + company.index + company[0].length,
@@ -75,7 +114,57 @@ export function detectDocumentExtras(text, emit, range) {
     }
   }
   detectQueryContacts(text, emit);
-  detectExperience(text, emit, range);
+  collectMatches(
+    text,
+    /https?:\/\/[^\s"<>\\]+/gu,
+    emit,
+    {
+      type: 'URL',
+      category: 'personal',
+      rule: 'document-share-path',
+      confidence: 0.85,
+    },
+    0,
+    isDocumentShareLink
+  );
+  detectEmployerContinuation(text, emit);
+  detectDatedEmployers(text, emit, range, debug);
+}
+
+function detectEmployerContinuation(text, emit) {
+  const continuation = new RegExp(
+    `,[ \\t]*(?:потом|затем)[ \\t]+в[ \\t]+(${employerName})`,
+    'uy'
+  );
+  for (const match of text.matchAll(
+    new RegExp(
+      `(?<!${boundary})[Рр]аботал[аи]?[ \\t]+в[ \\t]+(${employerName})`,
+      'gu'
+    )
+  )) {
+    continuation.lastIndex = match.index + match[0].length;
+    let next = continuation.exec(text);
+    if (next) {
+      emitEmployer(match);
+    }
+    while (next) {
+      emitEmployer(next);
+      next = continuation.exec(text);
+    }
+  }
+  function emitEmployer(match) {
+    const end = match.index + match[0].length;
+    if (!isDocumentTechnology(match[1])) {
+      emit({
+        start: end - match[1].length,
+        end,
+        type: 'ORGANIZATION',
+        category: 'personal',
+        rule: 'organization-continuation',
+        confidence: 0.85,
+      });
+    }
+  }
 }
 
 function detectQueryContacts(text, emit) {
@@ -111,60 +200,3 @@ function detectQueryContacts(text, emit) {
     });
   }
 }
-
-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

@@ -15,5 +15,7 @@ const types = new Map(
   )
 );
 export function documentFieldType(field) {
-  return types.get(field.replace(/[_-]/g, '').toLowerCase());
+  return types.get(normalizeFieldName(field));
 }
+export const normalizeFieldName = (field) =>
+  field.replace(/[_-]/g, '').toLowerCase();

package/src/engines.js

@@ -140,7 +140,13 @@ async function analyzeStructured(
         batch.text,
         [],
         true,
-        options,
+        {
+          ...options,
+          properNames: undefined,
+          documentEntities: options.properNames
+            ? false
+            : options.documentEntities,
+        },
         nativeFindings === undefined ? undefined : []
       ),
       options
@@ -152,7 +158,11 @@ async function analyzeStructured(
         view.text,
         [],
         true,
-        { ...options, structured: undefined },
+        {
+          ...options,
+          structured: undefined,
+          properNames: view.prose ? options.properNames : undefined,
+        },
         nativeFindings === undefined ? undefined : []
       );
       for (const finding of detected) {

package/src/index.d.ts

@@ -43,6 +43,10 @@ export interface SanitizerOptions {
   profile?: 'publication' | 'documents';
   /** Opt in to bounded employer, school, city/region heuristics. */
   documentEntities?: boolean;
+  /** Aggressive structural proper names in prose values; opt-in, off by default. */
+  properNames?: 'capitalized';
+  /** Unicode Script aliases that activate prose detection; default ['Cyrillic']. */
+  scripts?: string[];
   confirmedPersonal?: Array<{ value: string; type: string }>;
   knownSecrets?: string[];
   knownPersonal?: PersonalValue[];
@@ -63,7 +67,7 @@ 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. */
+  /** Property names normalized across case/underscores/hyphens; entire JSON/JSONL values redact. */
   sensitiveFields?: string[];
   /** Personal replacement threshold, default 0.5. Inspect retains lower scores. */
   minConfidence?: number;
@@ -88,6 +92,7 @@ export interface SanitizerOptions {
 /** Value-free diagnostics; enabled only when a debug callback is supplied. */
 export type DebugEvent =
   | { event: 'detected'; count: number }
+  | { event: 'document-experience' | 'proper-name-prose'; count: number }
   | { event: 'residual-redaction'; round: number }
   | { event: 'two-pass-confirmation'; type: string }
   | { event: 'propagation-skipped'; reason: 'length'; type: string }

package/src/placeholder-types.js

@@ -22,6 +22,7 @@ export const reservedPlaceholderTypes = () => [
   'PASSPORT_MRZ',
   'PASSPORT_NUMBER',
   'PERSON',
+  'PROPER_NAME',
   'PHONE',
   'PL_PESEL',
   'RU_INN',

package/src/propagation.js

@@ -36,7 +36,11 @@ function eligibleSeed(finding, options) {
     !options.knownOnly &&
     finding.category === 'personal' &&
     finding.type !== 'ENCODED_SENSITIVE' &&
-    !['confirmed-personal', 'document-propagation'].includes(finding.rule) &&
+    ![
+      'confirmed-personal',
+      'document-propagation',
+      'proper-name-prose',
+    ].includes(finding.rule) &&
     actionable(finding, options) &&
     ((options.documentEntities && finding.type === 'ORGANIZATION') ||
       finding.confidence >= 0.85 ||

package/src/proper-names.js

@@ -0,0 +1,222 @@
+import { failure } from './detection.js';
+import { documentDateRange } from './document-dates.js';
+
+const scriptPatterns = new Map();
+const dateRange = new RegExp(`\\(${documentDateRange}\\)`, 'u');
+const commaMobile = /,[ \t]*[78]9\d{9}(?![\p{L}\p{N}_])/u;
+const mobile = /^[78]9\d{9}$/u;
+const tokenPattern = /[\p{L}\p{M}\p{N}_./:\\?&#%=@+'’~+-]+/gu;
+const upper = /[\p{Lu}\p{Lt}]/u;
+const quotePairs = new Map([
+  ['«', '»'],
+  ['“', '”'],
+  ['„', '“'],
+  ['‘', '’'],
+  ['「', '」'],
+  ['『', '』'],
+]);
+
+function scriptPattern(scripts = ['Cyrillic']) {
+  if (
+    scripts.some(
+      (script) => typeof script !== 'string' || !/^[A-Za-z_]+$/.test(script)
+    )
+  ) {
+    throw failure('ERR_CONFIG');
+  }
+  const key = scripts.join('|');
+  let pattern = scriptPatterns.get(key);
+  if (!pattern) {
+    // The alias grammar prevents regexp injection; constructing the Unicode
+    // property also validates aliases supported by this runtime.
+    try {
+      pattern = new RegExp(
+        scripts.length
+          ? `(?=\\p{L})(?:${scripts.map((s) => `\\p{Script=${s}}`).join('|')})`
+          : '(?!)',
+        'u'
+      );
+    } catch {
+      throw failure('ERR_CONFIG');
+    }
+    // Bound cache growth when callers submit many different configurations.
+    if (scriptPatterns.size >= 64) {
+      scriptPatterns.clear();
+    }
+    scriptPatterns.set(key, pattern);
+  }
+  return pattern;
+}
+export function validateProperNames(options) {
+  if (
+    (options.properNames !== undefined &&
+      options.properNames !== 'capitalized') ||
+    (options.scripts !== undefined && !Array.isArray(options.scripts))
+  ) {
+    throw failure('ERR_CONFIG');
+  }
+  scriptPattern(options.scripts);
+}
+
+export function isProseLink(token) {
+  return (
+    /^https?:\/\/[^/]+/iu.test(token) ||
+    /^[\p{L}\p{N}](?:[\p{L}\p{N}-]*\.)+[\p{L}]{2,63}(?:[/:?#]|$)/u.test(token)
+  );
+}
+export function isDocumentShareLink(token) {
+  return isProseLink(token) && /\/d\/[^/?#]+/u.test(token);
+}
+function proseData(text, options) {
+  if (
+    scriptPattern(options.scripts).test(text) ||
+    dateRange.test(text) ||
+    commaMobile.test(text)
+  ) {
+    return true;
+  }
+  for (const match of text.matchAll(tokenPattern)) {
+    if (isDocumentShareLink(match[0])) {
+      return true;
+    }
+  }
+  return false;
+}
+function quotedSpans(text, emit) {
+  let start = -1,
+    closing;
+  for (let i = 0; i < text.length; i++) {
+    if (start >= 0) {
+      if (text[i] === closing) {
+        emit(start, i + 1, 'PROPER_NAME');
+        start = -1;
+      }
+    } else if (quotePairs.has(text[i])) {
+      start = i;
+      closing = quotePairs.get(text[i]);
+    }
+  }
+}
+function pathToken(value) {
+  return value.includes('/') || value.includes('\\');
+}
+// Keep existing document coverage outside the new replacements. Two naturally
+// ordered runs (quotes, then tokens) provide an interval index without sorting.
+// Overlapping broad document spans must not merge separate prose replacements.
+export function detectProseAndDocuments(text, emit, options, detectDocuments) {
+  if (options.properNames !== 'capitalized') {
+    detectDocuments(text, emit, options);
+    return;
+  }
+  const runs = [[]];
+  detectProperNames(
+    text,
+    (finding) => {
+      if (runs.at(-1).at(-1)?.end > finding.start) {
+        runs.push([]);
+      }
+      runs.at(-1).push(finding);
+      emit(finding);
+    },
+    options
+  );
+  detectDocuments(
+    text,
+    (finding) => {
+      if (!runs.some((run) => overlapsRun(run, finding))) {
+        emit(finding);
+      }
+    },
+    options
+  );
+}
+function overlapsRun(run, finding) {
+  let low = 0,
+    high = run.length;
+  while (low < high) {
+    const mid = (low + high) >>> 1;
+    if (run[mid].end <= finding.start) {
+      low = mid + 1;
+    } else {
+      high = mid;
+    }
+  }
+  return low < run.length && run[low].start < finding.end;
+}
+export function detectProperNames(text, emit, options) {
+  if (options.properNames !== 'capitalized' || !proseData(text, options)) {
+    return false;
+  }
+  let count = 0;
+  const found = (start, end, type) => {
+    emit({
+      start,
+      end,
+      type,
+      rule: 'proper-name-prose',
+      category: 'personal',
+      confidence: 0.85,
+    });
+    count++;
+  };
+  quotedSpans(text, found);
+  const ranges = text.matchAll(new RegExp(dateRange, 'gu'));
+  let range = ranges.next().value;
+  for (const match of text.matchAll(tokenPattern)) {
+    const raw = match[0];
+    // Leave sentence punctuation outside the replacement. Classification runs
+    // once on a maximal token, including hostile tokens without spaces.
+    let length = raw.length;
+    while (length && (raw[length - 1] === '.' || raw[length - 1] === ':')) {
+      length--;
+    }
+    const value = raw.slice(0, length);
+    const start = match.index,
+      end = start + value.length;
+    while (range && range.index + range[0].length <= start) {
+      range = ranges.next().value;
+    }
+    if (preserveToken(text, raw, value, start, end, range)) {
+      continue;
+    }
+    const type = tokenType(value);
+    if (type) {
+      found(start, end, type);
+    }
+  }
+  options.debug?.({ event: 'proper-name-prose', count });
+  return true;
+}
+
+function preserveToken(text, raw, value, start, end, range) {
+  let next = start + raw.length;
+  while (text[next] === ' ' || text[next] === '\t') {
+    next++;
+  }
+  return (
+    !value ||
+    (range && start >= range.index && end <= range.index + range[0].length) ||
+    (value === 'REDACTED' && text[start - 1] === '[' && text[end] === ']') ||
+    raw.endsWith(':') ||
+    text[next] === ':'
+  );
+}
+function tokenType(value) {
+  if (isProseLink(value)) {
+    return 'URL';
+  }
+  if (pathToken(value)) {
+    return undefined;
+  }
+  if (mobile.test(value)) {
+    return 'PHONE';
+  }
+  if (
+    upper.test(value) &&
+    /\p{L}/u.test(value) &&
+    !/^\d{4}-\d{2}-\d{2}/u.test(value)
+  ) {
+    return 'PROPER_NAME';
+  }
+  return undefined;
+}

package/src/sanitizer.js

@@ -1,4 +1,5 @@
 import { generatedValues } from './fake.js';
+import { validateProperNames } from './proper-names.js';
 import { prepareFakeText } from './fake-entities.js';
 import { alignEscapes } from './escape-spans.js';
 import { actionable } from './confidence.js';
@@ -78,6 +79,8 @@ const optionNames = new Set([
   'threshold',
   'profile',
   'documentEntities',
+  'properNames',
+  'scripts',
 ]);
 
 export function applyProfile(options = {}) {
@@ -191,6 +194,7 @@ export function validateOptions(options = {}) {
     }
   }
   validateConfidence(options);
+  validateProperNames(options);
   validatePolicy(options);
   if (
     options.verifyPublic !== undefined &&
@@ -410,11 +414,20 @@ function inspectText(text, options = {}) {
           ...options,
           structured: undefined,
           findings: [],
+          properNames: undefined,
+          documentEntities: options.properNames
+            ? false
+            : options.documentEntities,
         }),
         options
       ),
-      ...inspectStructuredValues(batch, options, (value) =>
-        inspect(value, { ...options, structured: undefined, findings: [] })
+      ...inspectStructuredValues(batch, options, (value, prose) =>
+        inspect(value, {
+          ...options,
+          structured: undefined,
+          findings: [],
+          properNames: prose ? options.properNames : undefined,
+        })
       ),
     ]);
     return inspectFindingsOnly(

package/src/structured.js

@@ -1,5 +1,5 @@
 import { failure } from './detection.js';
-import { documentFieldType } from './document-fields.js';
+import { documentFieldType, normalizeFieldName } from './document-fields.js';
 import { hasPlaceholders } from './placeholders.js';
 
 // Session metadata is opt-in at the CLI; library callers choose their own
@@ -182,10 +182,10 @@ function weakStructuralFinding(finding, entry, batchText) {
   }
   return false;
 }
-function ordinaryPersonalKey(entry, finding) {
+function ordinaryPersonalKey(entry, finding, options = {}) {
   return (
     entry.key &&
-    /^[A-Za-z_$][\w$]*$/.test(JSON.parse(entry.raw)) &&
+    (options.properNames || /^[A-Za-z_$][\w$]*$/.test(JSON.parse(entry.raw))) &&
     finding.category === 'personal' &&
     finding.rule !== 'known-personal'
   );
@@ -193,12 +193,17 @@ function ordinaryPersonalKey(entry, finding) {
 // Propagation runs again at source offsets. Apply the same key policy after it
 // so a name confirmed in a value cannot rename an ordinary identifier key.
 export function preserveIdentifierKeys(text, findings, options) {
-  if (!options.structured || hasPlaceholders(options)) {
+  if (
+    !options.structured ||
+    (hasPlaceholders(options) && !options.properNames)
+  ) {
     return findings;
   }
   const keys = structuredBatches(text, options).flatMap((batch) =>
     batch.entries
-      .filter((entry) => ordinaryPersonalKey(entry, { category: 'personal' }))
+      .filter((entry) =>
+        ordinaryPersonalKey(entry, { category: 'personal' }, options)
+      )
       .map((entry) => ({
         start: entry.start,
         end: entry.start + entry.raw.length,
@@ -222,13 +227,16 @@ export function preserveIdentifierKeys(text, findings, options) {
   });
 }
 function preserveStructuredEntry(entry, finding, text, options) {
+  if (options.properNames && ordinaryPersonalKey(entry, finding, options)) {
+    return true;
+  }
   if (hasPlaceholders(options)) {
     return false;
   }
   return (
     (entry.key &&
       ['confirmed-personal', 'document-propagation'].includes(finding.rule)) ||
-    ordinaryPersonalKey(entry, finding) ||
+    ordinaryPersonalKey(entry, finding, options) ||
     (!entry.key &&
       options.structuralFields?.includes(entry.field) &&
       weakStructuralFinding(finding, entry, text))
@@ -346,28 +354,28 @@ export function* structuredValueViews(
         end: entry.start + raw.end,
       });
     };
-    yield { text: value, map };
-    // Match the encoded detector's finite depth; arbitrary nesting is a limit.
+    // A serialized container is a transport envelope, not one prose value.
+    // Activate the optional scanner only in its independently decoded leaves.
+    let batches = [];
     if (depth < 2 && /^[ \t\r\n]*[[{]/.test(value)) {
-      let batches;
       try {
         batches = structuredBatches(value, { ...options, structured: 'json' });
       } catch (error) {
         if (error.code !== 'ERR_JSON') {
           throw error;
         }
-        batches = [];
-      }
-      for (const nested of batches) {
-        yield* structuredValueViews(nested, options, depth + 1, map);
       }
     }
+    yield { text: value, map, prose: !entry.key && batches.length === 0 };
+    for (const nested of batches) {
+      yield* structuredValueViews(nested, options, depth + 1, map);
+    }
   }
 }
 export function inspectStructuredValues(batch, options, inspectValue) {
   const result = [];
   for (const view of structuredValueViews(batch, options)) {
-    const findings = inspectValue(view.text);
+    const findings = inspectValue(view.text, view.prose);
     options.debug?.({ event: 'structured-value', count: findings.length });
     for (const finding of findings) {
       const mapped = view.map(finding);
@@ -399,13 +407,13 @@ export function declaredFieldFindings(text, options) {
   if (!options.sensitiveFields?.length) {
     return [];
   }
-  const fields = new Set(options.sensitiveFields);
+  const fields = new Set(options.sensitiveFields.map(normalizeFieldName));
   const findings = [];
   for (const token of lexemes(text)) {
     if (
       token.index < (findings.at(-1)?.end ?? 0) ||
       !token.key ||
-      !fields.has(JSON.parse(token.raw))
+      !fields.has(normalizeFieldName(JSON.parse(token.raw)))
     ) {
       continue;
     }