euredact 0.5.1 → 0.7.0

package/dist/esm/rules/engine.js

@@ -242,12 +242,20 @@ export class RuleEngine {
             if (this.matcher.validate(m)) {
                 validated.push({ match: m, hasValidValidator: m.patternDef.validator !== null });
             }
-            else if (m.patternDef.validator !== null && !m.patternDef.requiresContext) {
-                failedSpans.push({ start: m.start, end: m.end, code: m.countryCode,
-                    etype: String(m.patternDef.entityType) });
-                if (RESCUE_TARGETS.has(String(m.patternDef.entityType))
-                    && cuedType(text, m.start) === m.patternDef.entityType)
+            else if (m.patternDef.validator !== null) {
+                const cued = RESCUE_TARGETS.has(String(m.patternDef.entityType))
+                    && cuedType(text, m.start) === m.patternDef.entityType;
+                if (!m.patternDef.requiresContext) {
+                    failedSpans.push({ start: m.start, end: m.end, code: m.countryCode,
+                        etype: String(m.patternDef.entityType) });
+                    if (cued)
+                        rescued.push(m);
+                }
+                else if (cued) {
+                    // A label-gated pattern is rescued too, but only by a cue touching the
+                    // value; it casts no demotion zone (rules-engine#75).
                     rescued.push(m);
+                }
             }
         }
         // Evidence pass: work out which countries this document belongs to, from
@@ -457,7 +465,7 @@ export class RuleEngine {
             // the value is filed as a Cypriot identity number. Dropping it also clears
             // outOfScope, which would otherwise claim the detection belongs to a
             // country the caller did not declare while naming no country at all.
-            const retyped = retypedBy(text, match.start, entityType, countryScores.get(match.countryCode) ?? 0);
+            const retyped = retypedBy(text, match.start, entityType, countryScores.get(match.countryCode) ?? 0, match.countryCode);
             if (retyped !== null) {
                 entityType = retyped;
                 country = null;

package/dist/esm/rules/suppressors.d.ts

@@ -6,6 +6,7 @@ export interface RawMatch {
     patternDef: PatternDef;
     countryCode: string;
 }
+export declare const MONTH_NAMES: string;
 /**
  * Per-document scratch space for suppressors that would otherwise re-derive the
  * same whole-document facts for every candidate.

package/dist/esm/rules/suppressors.js

@@ -1,5 +1,5 @@
 import { EntityType } from "../types.js";
-import { isRegisteredBic } from "./bicRegistry.js";
+import { isKnownInstitution, isRegisteredBic } from "./bicRegistry.js";
 import { DE_DISTRICT_CODES } from "./deDistricts.js";
 const CONTEXT_CHARS = 150;
 function getContext(text, start, end) {
@@ -21,10 +21,11 @@ const CURRENCY_WORD = "EUR|USD|GBP|CHF|ISK|SEK|NOK|DKK|PLN|CZK|HUF|RON|BGN|HRK|"
 const CURRENCY_AFTER = new RegExp(`^\\s*(?:(?:${CURRENCY_SYMBOL})|(?:${CURRENCY_WORD})${_UWB})`, "i");
 const CURRENCY_COMMA_AFTER = new RegExp(`^[.,]\\d{1,2}\\s*(?:(?:${CURRENCY_SYMBOL})|(?:${CURRENCY_WORD})${_UWB})`, "i");
 const CURRENCY_BEFORE = new RegExp(`(?:(?:${CURRENCY_SYMBOL})|\\b(?:${CURRENCY_WORD}))\\s*$`, "i");
-const AMOUNT_LABEL_BEFORE = /\b(?:Montant|Beløb|Summa|Summe|Bedrag|Amount|Total|TTC|inkl|Upphæð|Importe|Importo|Valore|Wartość|Kwota|Částka|Összeg|Sum|Beloop|Prix|Preis|Price|Loyer|Miete|Huur|Rent|Betrag)\s*(?:\w+\s*)?:?\s*$/i;
+const AMOUNT_LABEL_BEFORE = /\b(?:Montant|Beløb|Summa|Summe|Bedrag|Amount|Total|TTC|inkl|Upphæð|Importe|Importo|Valore|Wartość|Kwota|Částka|Összeg|Sum|Beloop|Prix|Preis|Price|Loyer|Miete|Huur|Rent|Betrag)(?:\s+\w+)?\s*:?\s*$/i; // second word separate: not "Rent"+"enversicherungsnummer" (rules-engine#111)
 // Use Unicode-aware word boundary via \p{L} negative lookahead instead of \b
 // because JS \b is ASCII-only and fails on Unicode letters (e.g. "München" → \bm\b matches M before ü)
-const UNIT_AFTER = /^\s*(?:kg|km|cm|mm|m[²³]|ml|mg|GB|MB|KB|TB|%|jaar|maanden|weken|dagen|uur|minuten|seconden|stuks|pcs|pieces|ans|mois|semaines|jours|heures|Jahre|Monate|Wochen|Tage|Stunden)(?![a-zA-Z\u00C0-\u024F\u0400-\u04FF])/i;
+// Horizontal space only: a unit is on the number's own line (rules-engine#51).
+const UNIT_AFTER = /^[ \t]*(?:kg|km|cm|mm|m[²³]|ml|mg|GB|MB|KB|TB|%|jaar|maanden|weken|dagen|uur|minuten|seconden|stuks|pcs|pieces|ans|mois|semaines|jours|heures|Jahre|Monate|Wochen|Tage|Stunden)(?![a-zA-Z\u00C0-\u024F\u0400-\u04FF])/i;
 // Same missing-boundary flaw: "ref" matched the tail of "kortref".
 const REFERENCE_BEFORE = /\b(?:dossier|ref\.?|referentie|reference|référence|factuurnummer|invoice\s*(?:nr|number|no)?|bestelnummer|order\s*(?:nr|number|no)?|kenmerk|ordernummer|Aktenzeichen|numéro\s*de\s*(?:dossier|facture|commande)|bestellnummer|Rechnungsnummer|artikelnr|article\s*no|contract\s*(?:nr|number|no)?|pagina|page|Seite|blz\.?|Facture\s*n[°o]?|Faktura\s*n[°or]\.?|Lasku\s*n[°or]o?\.?|Rechnung\s*(?:Nr|n[°o])?|faktura\s*(?:nr|n[°o])?|bestilling\s*(?:nr|n[°o])?|bestelling\s*n[°or]\.?|Reikningur\s*nr|ticket|incident\s*(?:report|nr|no)?|case\s*(?:nr|no|id)?|zaaknummer|meldingsnummer|Vorgangsnummer|Vorgang|Störungsmeldung|saksnummer|ärendenummer|sagsnummer|asianumero|Factuur\s*n[ro]?\.?|Nota\s*n[ro]?\.?)\s*[:.#]?\s*$/i;
 // "#" before a number marks a reference in every language in scope — a ticket,
@@ -32,9 +33,19 @@ const REFERENCE_BEFORE = /\b(?:dossier|ref\.?|referentie|reference|référence|f
 const HASH_BEFORE = /#\s*$/;
 // A short uppercase tag hyphenated to the number: "IR-43433", "INC-2024".
 const REF_PREFIX_BEFORE = /(?:^|[\s([])[A-Z]{2,5}-$/;
+// The cross-border address form, "CH-8004 Zürich": a country code hyphenated to
+// a postal code, told apart from a reference tag by position -- it opens an
+// address line and a place name follows (rules-engine#58).
+const COUNTRY_PREFIX_OPENS_LINE = /(?:^|\n|,)[ \t]*([A-Z]{2})-$/;
+const POSTAL_PREFIX_COUNTRIES = new Set([
+    "AT", "BE", "BG", "CH", "CY", "CZ", "DE", "DK", "EE", "EL", "ES", "FI",
+    "FR", "GB", "GR", "HR", "HU", "IE", "IS", "IT", "LI", "LT", "LU", "LV",
+    "MT", "NL", "NO", "PL", "PT", "RO", "SE", "SI", "SK", "UK",
+]);
 const LEGAL_BEFORE = /(?:Art(?:ikel|icle|\.)|§|Artikel|Section|Sectie|Afdeling|paragraaf|Absatz|alinéa|punt|point|Punkt|lid)\s*$/i;
-const MATH_BEFORE = /[=+\-×÷*/]\s*$/;
-const MATH_AFTER = /^\s*[=+\-×÷*/]/;
+// An operator on the same line only: a bullet or "---" on the next line is not a minus sign (rules-engine#91).
+const MATH_BEFORE = /[=+\-×÷*/][^\S\r\n]*$/;
+const MATH_AFTER = /^[^\S\r\n]*[=+\-×÷*/]/;
 // "A-1010", "B-2000", "L-1234", "CH-8000", "D-10115": a country prefix on a
 // postal code, not a minus sign.
 const COUNTRY_PREFIX_HYPHEN = /(?:^|[^A-Za-z0-9])[A-Z]{1,2}-\s*$/;
@@ -60,10 +71,11 @@ const NUMERIC_TYPES = new Set([EntityType.PHONE, EntityType.NATIONAL_ID, EntityT
 // Month names in the languages this engine covers. Long, but it is data: the
 // alternative is a proximity heuristic, and proximity is what caused the defect
 // this guards against. Kept in sync with the Python SDK's suppressors.py.
-const MONTH_NAMES = "january|february|march|april|may|june|july|august|september|october|november|december" +
+export const MONTH_NAMES = "january|february|march|april|may|june|july|august|september|october|november|december" +
     "|jan|feb|mar|apr|jun|jul|aug|sep|sept|oct|nov|dec" +
     "|januar|jänner|februar|märz|mai|juni|juli|oktober|dezember|dez|okt|mrz" +
     "|janvier|février|mars|avril|juin|juillet|août|aout|septembre|octobre|novembre|décembre|decembre" +
+    "|janv|févr|fevr|avr|juil|déc" +
     "|januari|februari|maart|mei|augustus|mrt" +
     "|gennaio|febbraio|marzo|aprile|maggio|giugno|luglio|agosto|settembre|ottobre|dicembre" +
     "|enero|febrero|abril|mayo|junio|julio|septiembre|octubre|noviembre|diciembre" +
@@ -285,7 +297,19 @@ function suppressReference(text, match) {
     if (REFERENCE_BEFORE.test(before))
         return true;
     const adjacent = text.slice(Math.max(0, match.start - 8), match.start);
-    return HASH_BEFORE.test(adjacent) || REF_PREFIX_BEFORE.test(adjacent);
+    if (HASH_BEFORE.test(adjacent))
+        return true;
+    if (!REF_PREFIX_BEFORE.test(adjacent))
+        return false;
+    return !(match.patternDef.entityType === EntityType.POSTAL_CODE &&
+        isCountryPrefixedAddress(text, match.start, match.end));
+}
+/** "CH-8004 Zürich" on an address line, not the reference "IT-20431". */
+function isCountryPrefixedAddress(text, start, end) {
+    const found = COUNTRY_PREFIX_OPENS_LINE.exec(text.slice(Math.max(0, start - 12), start));
+    return (found !== null &&
+        POSTAL_PREFIX_COUNTRIES.has(found[1]) &&
+        CITY_AFTER.test(text.slice(end, end + 24)));
 }
 function suppressLegal(text, match) {
     const applicable = LEGAL_TYPES;
@@ -309,14 +333,105 @@ function suppressSequential(_text, match) {
     const clean = match.text.replace(/[\s.\-]/g, "");
     return SEQUENTIAL_PATTERNS.test(clean);
 }
+// ── The engine's own output ───────────────────────────────────────────────
+//
+// Redaction has to be idempotent: running it over a document it already
+// produced must leave the placeholders it wrote alone. It did not.
+// `[POSTAL_CODE]` is thirteen characters of mixed case with an underscore, so
+// the entropy-based SECRET rule read it as a credential and a second pass
+// replaced it with `[SECRET]` (rules-engine#33).
+//
+// All three emitted forms are guarded, because all three come back as input in
+// a re-processing pipeline: `[TYPE]`, `TYPE_1` (referentialIntegrity) and
+// `TYPE_K7Q2` (tokenize -- where a false detection breaks restore()).
+//
+// Only real entity-type names count. Guarding any bracketed upper-case token
+// would be simpler and wrong: `[AKIAIOSFODNN7EXAMPLE]` is one, and also a live
+// AWS key. A placeholder for a *custom* pattern is therefore not covered.
+// The closing bracket is optional: another pattern's span need not agree with
+// this one about where the marker ends. The assigned-secret rule stops before
+// sentence punctuation (rules-engine#35), so it claims "[POSTAL_CODE" without
+// the "]". The opening bracket is still required.
+const PLACEHOLDER = /^(?:\[([A-Z][A-Z0-9_]*)\]?|([A-Z][A-Z0-9_]*?)_(?:\d+|[A-HJ-NP-Z2-9]{4}))$/;
+const KNOWN_TYPE_NAMES = new Set(Object.values(EntityType));
+function suppressRedactionPlaceholder(_text, match) {
+    const found = PLACEHOLDER.exec(match.text);
+    if (found === null)
+        return false;
+    const name = found[1] ?? found[2];
+    return KNOWN_TYPE_NAMES.has(name);
+}
 const RECENT_YEAR = /^(?:19[5-9]\d|20[0-3]\d)$/;
+// Any year a written date can carry: the date-construction test applies to all of them (rules-engine#111).
+const DATE_YEAR = /^(?:1[89]\d\d|20\d\d)$/;
 const POSTAL_CONTEXT_NEAR = /(?:postcode|postal|code\s*postal|PLZ|Postleitzahl|postnummer|postinumero|póstnúmer|zip|straat|straße|strasse|rue\s|via\s|calle\s|rua\s|ulica|utca|street|avenue|laan\s|weg\s|plein|adres|adresse|address|woonplaats|wonende|woonachtig|gevestigd|domicili|demeurant|résidant|residant|bosatt|bopæl|wohnhaft|ansässig|stad\b|ville\b|city\b|Stadt|città|ciudad|cidade|miasto|město|város)/i;
 const DATE_KEYWORD_NEAR = /(?:født|fødselsdato|fødsel|Fødselsdato|född|födelsedatum|födelsedag|syntynyt|syntymäaika|fæddur|fæðingardagur|geboren|geboortedatum|Geburtsdatum|nascido|nacido|data di nascita|nato il|nata il|Tiltr[æa]delsesdato|Tiltredelsesdato|datum|date\b|Datum|jaar|year|année|Jahr|since|sinds|depuis|seit|\d{2}\.\d{2}\.|(?:januar|februar|marts|april|maj|juni|juli|august|september|oktober|november|december|januari|februari|mars|mei|juin|juillet|août))/i;
+// A sentence boundary: a full stop, question or exclamation mark followed by
+// space, or a line break. Written so it cannot fire inside "11.03.1970", where
+// the periods are not followed by whitespace -- that date is one of the false
+// positives this gate has to reject.
+const SENTENCE_BREAK = /[.!?][ \t\n]|\n/;
+const SENTENCE_BREAK_G = /[.!?][ \t\n]|\n/g;
+// The value's own sentence, bounded either side.
+function sentenceAround(text, start, end, reach = 160) {
+    let before = text.slice(Math.max(0, start - reach), start);
+    let after = text.slice(end, end + reach);
+    let lastEnd = -1;
+    SENTENCE_BREAK_G.lastIndex = 0;
+    for (let m = SENTENCE_BREAK_G.exec(before); m !== null; m = SENTENCE_BREAK_G.exec(before)) {
+        lastEnd = m.index + m[0].length;
+    }
+    if (lastEnd >= 0)
+        before = before.slice(lastEnd);
+    const found = SENTENCE_BREAK.exec(after);
+    if (found !== null)
+        after = after.slice(0, found.index);
+    return before + after;
+}
+// A postal label whose only distance from the value is punctuation:
+// "PLZ: 2011", "code postal : 2011", "Woonplaats: 1950".
+const POSTAL_LABEL_TOUCHING = new RegExp(`(?:${POSTAL_CONTEXT_NEAR.source})[\\s:.\\-]{0,4}$`, "i");
+// A capitalised place name after the code: "2000 Antwerpen". A following label
+// ("1970 Fødselsnummer:") is excluded by the colon.
+// `\p{L}\p{N}_` rather than `\w`: JS `\w` is ASCII-only, so "8004 Zürich" failed
+// at the ü here while Python's Unicode `\w` accepted it (rules-engine#58).
+const CITY_AFTER = /^[ \t](?![\p{L}\p{N}_]+\s*:)[A-ZÀ-ÞŁŠŽ][\p{L}\p{N}_\-']{2,}/u;
+// Every position is local to the value or inside its own sentence. Proximity to
+// an address *word* anywhere in a 300-character window is what the old rescue
+// asked, and that is a neighbourhood rather than a position (rules-engine#32).
+/**
+ * The comma of an address line: the word before it is a place name or a number.
+ * "myocardial infarction, 2016" is a year in a list (rules-engine#111).
+ */
+const ADDRESS_COMMA = /(?<!\S)(?:[A-ZÀ-Þ\d][^\s,]*|[^\s,]*\]),[ \t]*$/;
+/**
+ * A redaction placeholder: "[POSTAL_CODE]" holds the words the address test
+ * looks for, so on masked text it made every year in its sentence a postcode
+ * (rules-engine#111). A masked value is no address word.
+ */
+const MASKED_VALUE = /\[[A-Z][A-Z_]*\]/g;
+function yearSitsInAddressStructure(text, start, end) {
+    const before = text.slice(Math.max(0, start - 28), start);
+    // "Amsterdam, 2026" -- the comma of an address line.
+    if (ADDRESS_COMMA.test(before))
+        return true;
+    // "PLZ: 2011" -- a postal label with nothing but punctuation between.
+    if (POSTAL_LABEL_TOUCHING.test(before))
+        return true;
+    // A capitalised place name immediately after.
+    if (CITY_AFTER.test(text.slice(end, end + 24)))
+        return true;
+    // An address word in the value's own sentence. "Te huur: Lange Nieuwstraat
+    // 12, rustige ligging in 2018, vlakbij openbaar vervoer." is an Antwerp
+    // postal code in prose; the false positives put the year and the address in
+    // different sentences.
+    return POSTAL_CONTEXT_NEAR.test(sentenceAround(text, start, end).replace(MASKED_VALUE, " "));
+}
 function suppressYearAsPostal(text, match) {
     if (match.patternDef.entityType !== EntityType.POSTAL_CODE)
         return false;
     const clean = match.text.trim();
-    if (!RECENT_YEAR.test(clean))
+    if (!DATE_YEAR.test(clean))
         return false;
     // A date construction *touching* the candidate settles it, whatever the rest
     // of the document says. Without this, the postal-context test below rescued
@@ -328,14 +443,14 @@ function suppressYearAsPostal(text, match) {
         return true;
     if (DATE_AFTER.test(text.slice(match.end, match.end + 8)))
         return true;
+    if (!RECENT_YEAR.test(clean))
+        return false;
     const [before, after] = getContext(text, match.start, match.end);
     const context = before + after;
-    // Keep as postal code if postal/address context nearby
-    if (POSTAL_CONTEXT_NEAR.test(context))
-        return false;
-    // Keep if preceded by comma+space (address pattern: "Amsterdam, 2026")
-    const immediateBefore = text.slice(Math.max(0, match.start - 3), match.start);
-    if (/,\s*$/.test(immediateBefore))
+    // Keep as postal code only when the value sits in address *structure* --
+    // see yearSitsInAddressStructure for why a 300-character window of address
+    // words was the defect rather than the keyword list.
+    if (yearSitsInAddressStructure(text, match.start, match.end))
         return false;
     // Suppress if date keyword nearby (birth date, employment date, etc.)
     if (DATE_KEYWORD_NEAR.test(context))
@@ -379,12 +494,26 @@ const TOWN_AFTER = /^\s*[A-ZÀ-ÞĀ-Ž]/;
  * between the marker and the number, so allow exactly one.
  */
 const EXTENSION_BEFORE = /(?<![A-Za-z0-9_])(?:toest(?:el)?|ext|extension|poste|durchwahl|doorkiesnummer|tst|nebenstelle)\.?\s*(?:[a-zà-ÿ]{2,10}\s*)?[:.]?\s*$/i;
+/**
+ * What else a bare digit run after these is (rules-engine#111): a head count
+ * ("Employees: 214"), a standard ("ISO/IEC 27001"), a product model with an
+ * inner capital ("Dell OptiPlex 7090"). Not the digits after "[PHONE]": the
+ * rest of a number an earlier pass cut short, safer masked as a postcode.
+ */
+const COUNT_LABEL_BEFORE = /(?<![A-Za-z0-9_])(?:employees|headcount|staff|mitarbeiter(?:innen)?|beschäftigte|werknemers|medewerkers|employés|salariés|effectifs?|dipendenti|empleados|pracowników|zaměstnanců)\s*[:=]?\s*$/i;
+const NOT_POSTAL_BEFORE = /(?<![A-Za-z0-9_])(?:(?:ISO(?:\/IEC)?|IEC|EN|DIN(?:\s+EN)?|NEN(?:-EN)?|NF\s+EN|BS(?:\s+EN)?|PN-EN|ÖNORM)[\s\-]*|[A-Za-z]*[a-z][A-Z][A-Za-z]*\s+)$/;
+/** A thousands group of an amount: the "750" of "£28,750,000". */
+const GROUP_BEFORE = /\d[,.]$/;
+const GROUP_AFTER = /^[,.]\d{3}(?!\d)/;
 /** Suppress a postal code the word in front of it rules out. */
 function suppressPostalAfterDisqualifyingWord(text, match) {
     if (match.patternDef.entityType !== EntityType.POSTAL_CODE)
         return false;
     const before = text.slice(Math.max(0, match.start - 24), match.start);
-    if (EXTENSION_BEFORE.test(before))
+    if (EXTENSION_BEFORE.test(before) || COUNT_LABEL_BEFORE.test(before)
+        || NOT_POSTAL_BEFORE.test(before))
+        return true;
+    if (GROUP_BEFORE.test(before) && GROUP_AFTER.test(text.slice(match.end, match.end + 5)))
         return true;
     return RECENT_YEAR.test(match.text.trim())
         && (YEAR_WORD_BEFORE.test(before) || YEAR_VERB_BEFORE.test(before))
@@ -395,10 +524,18 @@ function suppressPhoneServiceNumber(_text, match) {
         return false;
     return SERVICE_NUMBER.test(match.text);
 }
-function suppressPhoneDateOverlap(_text, match) {
+// A date and the hour of a time, "07.10.2026 08" out of "07.10.2026 08:42":
+// the French phone pattern took it as five pairs (rules-engine#101). Only when
+// the minutes follow, so the stamp is certain.
+const DATE_THEN_HOUR = /^\d{2}([-/.])\d{2}\1\d{4}\s+\d{1,2}$/;
+const MINUTES_AFTER = /^:\d{2}(?!\d)/;
+function suppressPhoneDateOverlap(text, match) {
     if (match.patternDef.entityType !== EntityType.PHONE)
         return false;
-    return DATE_PATTERN_FULL.test(match.text.trim());
+    const candidate = match.text.trim();
+    if (DATE_PATTERN_FULL.test(candidate))
+        return true;
+    return DATE_THEN_HOUR.test(candidate) && MINUTES_AFTER.test(text.slice(match.end, match.end + 3));
 }
 // Standards and classification prefixes that are plate-shaped once a letter and
 // digits follow: "ATC-N06", "ICD-O3". None is a German district code, but the
@@ -411,6 +548,16 @@ const NOT_CITY_CODES = new Set([
     "BE", "DE", "EU", "NL", "LU", "WS", "SS", "IP",
 ]);
 const CURRENCY_PLATE = /^(?:EUR|USD|GBP|CHF|SEK|NOK|DKK|ISK|CZK|PLN|HUF|RON|BGN|HRK)\s/i;
+const ALNUM = /[\p{L}\p{N}]/u;
+/** Characters that join a token to more of an identifier (rules-engine#50, #81). */
+const ID_CONNECTORS = "-/._+";
+/** A reference marker directly before the token: "#FR-S2", "№ …", "n° …". */
+const REFERENCE_MARK_BEFORE = /(?:#|№|(?<![A-Za-z])[nN][°º])\s?$/;
+/** A connector glues [start, end) to a letter or digit outside it. */
+function joinedToMore(text, start, end) {
+    return ((end + 1 < text.length && ID_CONNECTORS.includes(text[end]) && ALNUM.test(text[end + 1])) ||
+        (start >= 2 && ID_CONNECTORS.includes(text[start - 1]) && ALNUM.test(text[start - 2])));
+}
 function suppressPlateInCompound(text, match) {
     if (match.patternDef.entityType !== EntityType.LICENSE_PLATE)
         return false;
@@ -422,6 +569,18 @@ function suppressPlateInCompound(text, match) {
         if (/[A-Za-zÄÖÜäöüß]{2,}-$/.test(before))
             return true;
     }
+    // A plate is a token of its own: joined by a connector to more of an
+    // identifier ("TF-284-KL-00874", "FR-S2/2026") it is a segment of a reference
+    // (rules-engine#50, #81). A spaced dash or slash does not join.
+    if (joinedToMore(text, match.start, match.end))
+        return true;
+    // After a reference marker ("Ref #FR-S2") it is a reference, unless a plate
+    // cue says otherwise (rules-engine#81).
+    if (REFERENCE_MARK_BEFORE.test(text.slice(Math.max(0, match.start - 4), match.start))) {
+        const [b, a] = getContext(text, match.start, match.end);
+        if (!PLATE_CUE_NEAR.test(b + a))
+            return true;
+    }
     const matched = match.text.trim();
     const parts = matched.split(/[\s\-]+/);
     // A standards or classification reference, not a plate — unless a plate cue
@@ -506,6 +665,35 @@ function suppressPostalInsideIban(text, match) {
     }
     return false;
 }
+// An IBAN-shaped run: two letters, two check digits, then grouped
+// alphanumerics. Deliberately not checksum-gated -- the point is to describe the
+// run a human wrote as one account number, including the ones that fail their
+// checksum, because those are exactly the ones no structured detector claims.
+const ACCOUNT_RUN = /\b[A-Z]{2}\d{2}(?:[ ]?[A-Z0-9]{2,4}){2,8}\b/g;
+// "Compte: FR76 3000 4008 0300 0109 5374" fails the IBAN checksum, so no
+// BANK_ACCOUNT candidate survives and the Danish eight-digit phone pattern took
+// "3000 4008" out of the middle of it, leaving the rest in the clear
+// (rules-engine#30). POSTAL_CODE has carried its own version of this guard
+// since 0.3.3, in suppressPostalInsideIban.
+function suppressPhoneInsideAccountRun(text, match) {
+    if (match.patternDef.entityType !== EntityType.PHONE)
+        return false;
+    const lineStart = text.lastIndexOf("\n", match.start) + 1;
+    let lineEnd = text.indexOf("\n", match.end);
+    if (lineEnd < 0)
+        lineEnd = text.length;
+    const line = text.slice(lineStart, lineEnd);
+    ACCOUNT_RUN.lastIndex = 0;
+    for (let m = ACCOUNT_RUN.exec(line); m !== null; m = ACCOUNT_RUN.exec(line)) {
+        const runStart = lineStart + m.index;
+        const runEnd = runStart + m[0].length;
+        if (runStart <= match.start && match.end <= runEnd
+            && runEnd - runStart > match.end - match.start) {
+            return true;
+        }
+    }
+    return false;
+}
 function suppressPostalAsHouseNumber(text, match) {
     if (match.patternDef.entityType !== EntityType.POSTAL_CODE)
         return false;
@@ -722,10 +910,34 @@ function suppressBicWithoutEvidence(text, match, scratch) {
     // The token itself is blanked out so it cannot vouch for itself.
     const unit = structuralUnit(text, match.start, match.end).split(token).join(" ".repeat(token.length));
     if (BIC_KEYWORD.test(unit) || IBAN_SHAPE.test(unit) || BANK_BLOCK.test(unit)) {
+        if (bicShapedWord(text, match.start, match.end, token))
+            return true;
         return occursAsLowercaseWord(text, token, scratch);
     }
     return true;
 }
+/** A personal title right before the token: "Dr. HOFFMANN", "Mme JANSSENS". */
+const TITLE_BEFORE = /(?<![A-Za-z])(?:dr|prof|mr|mrs|ms|mme|mlle|m|herr|frau|dhr|mevr|sig|sra?)\.?\s+$/i;
+const LETTER = /\p{L}/u;
+/** A BIC/SWIFT label touching the token: "BIC: ", "SWIFT-Code:\n", "Code SWIFT : ", "BIC Bank A: ". */
+const BIC_LABEL_BEFORE = /(?<![A-Za-z])(?:bic|swift)(?:[\s/\-]*(?:code|swift|bic))?(?:\s+bank\s+\w{1,3})?[\s:.\-()]*$/i;
+/**
+ * A registry miss sitting where only a word or a name can (rules-engine#57):
+ * joined to a word by a hyphen ("NGUYEN-HOFFMANN"), right after a personal
+ * title ("Dr. HOFFMANN"), or letters only (eight, or eleven without an `XXX`
+ * branch: "BETALING", "MAANDELIJKS") that the GLEIF mapping does not know and
+ * no BIC/SWIFT label touches.
+ */
+function bicShapedWord(text, start, end, token) {
+    if ((start >= 2 && text[start - 1] === "-" && LETTER.test(text[start - 2])) ||
+        (text[end] === "-" && end + 1 < text.length && LETTER.test(text[end + 1])))
+        return true;
+    if (TITLE_BEFORE.test(text.slice(Math.max(0, start - 8), start)))
+        return true;
+    return /^[A-Za-z]+$/.test(token) && !(token.length === 11 && token.endsWith("XXX"))
+        && !isKnownInstitution(token)
+        && !BIC_LABEL_BEFORE.test(text.slice(Math.max(0, start - 30), start));
+}
 // ── Postal code: digits belonging to a longer identifier ────────────────
 // An identifier label immediately before the digits. A postal code is never
 // introduced this way; an SVNr, policy number or service number always is.
@@ -733,12 +945,26 @@ function suppressBicWithoutEvidence(text, match, scratch) {
 // Repeated per alternative, the engine retried the same unbounded prefix five
 // times per starting position — the most expensive single regex in the engine
 // at 197 ms per 1 MB document. Same language, 8x faster on the worst case.
+// An identifier cue that is really a postal label -- see the use below.
+const POSTAL_LABEL_CUE = /^post/i;
 const ID_CUE_BEFORE = /(?:[\w\-]*(?:Nr|N[°ºo]|Nummer|Numero|Numéro)|No|number|num|Kennzahl|Aktenzeichen|Az|e-?card|Polizze|Police|Policen)\.?\s*:?\s*$/i;
 // An international dialling prefix earlier on the same line, with nothing but
 // number punctuation in between: these digits belong to the phone detector.
 const DIALLING_PREFIX_BEFORE = /\+\d{1,3}[\d\s\-().]*$/;
 // A country prefix on a postal code — "A-1010 Wien", "B-2000", "L-1234".
-const COUNTRY_PREFIXED = /(?:^|[^A-Za-z0-9])[A-Z]{1,2}$/;
+// The boundary excludes a hyphen, which is what makes this a *prefix* rather
+// than a segment. It did not, so any `XX-NNNNN` tail of a hyphenated reference
+// read as a country-prefixed address: in "PV-2026-LU-09143" the `LU` is
+// preceded by `-` and the German five-digit postal pattern kept `09143`
+// (rules-engine#31).
+const COUNTRY_PREFIXED = /(?:^|[^A-Za-z0-9\-])([A-Z]{1,3})$/;
+// Postal country prefixes and the length of that country's postcode: any one or two capitals
+// used to pass, so "K-40817" and "B-51823" were country-prefixed postcodes (rules-engine#111).
+const POSTAL_PREFIX_DIGITS = { A: 4, AT: 4, B: 4, BE: 4, BG: 4, CH: 4, CY: 4, CZ: 5, D: 5, DE: 5, DK: 4, E: 5, EE: 5, ES: 5, F: 5, FI: 5, FIN: 5, FR: 5, GR: 5, H: 4, HR: 5, I: 5, IT: 5, L: 4, LT: 5, LU: 4, LV: 4, N: 4, NL: 4, NO: 4, P: 4, PL: 5, PT: 4, RO: 6, S: 5, SE: 5, SI: 4, SK: 5, SLO: 4 };
+function countryPrefixed(before, digits) {
+    const m = COUNTRY_PREFIXED.exec(before);
+    return m !== null && POSTAL_PREFIX_DIGITS[m[1]] === digits.length;
+}
 /**
  * Suppress bare digit runs that belong to a longer number, not an address.
  *
@@ -754,8 +980,15 @@ function suppressPostalInLongerIdentifier(text, match) {
     if (match.patternDef.entityType !== EntityType.POSTAL_CODE)
         return false;
     const clean = match.text.trim();
-    if (!/^\d+$/.test(clean))
+    if (!/^\d+$/.test(clean)) {
+        // A structured form glued on by a hyphen is the tail of a reference: "CPS-HR-2026-019" (#111).
+        const glued = text.slice(Math.max(0, match.start - 2), match.start);
+        if (glued.length === 2 && glued[1] === "-" && /[A-Za-z0-9]/.test(glued[0])) {
+            const m = COUNTRY_PREFIXED.exec(text.slice(0, match.start - 1));
+            return !(m && m[1] in POSTAL_PREFIX_DIGITS);
+        }
         return false;
+    }
     const beforeChar = match.start > 0 ? text[match.start - 1] : "";
     const afterChar = match.end < text.length ? text[match.end] : "";
     const prevPrev = match.start >= 2 ? text[match.start - 2] : "";
@@ -774,7 +1007,10 @@ function suppressPostalInLongerIdentifier(text, match) {
         return true;
     if (afterChar === "-" && /\d/.test(nextNext))
         return true;
-    if (beforeChar === "-" && !COUNTRY_PREFIXED.test(text.slice(0, match.start - 1)))
+    // A hyphenated chain goes on after it: "réf. : L-2025-HD-0412" is a reference (#111).
+    if (/^-[A-Za-z0-9]+-/.test(text.slice(match.end, match.end + 12)))
+        return true;
+    if (beforeChar === "-" && !countryPrefixed(text.slice(0, match.start - 1), clean))
         return true;
     // A further digit group on the same line: "1268 040390", "1234 5678 925",
     // "+43 664 8213 907". Horizontal whitespace only — a digit on the *next*
@@ -782,7 +1018,16 @@ function suppressPostalInLongerIdentifier(text, match) {
     if (/^[ \t]+\d/.test(text.slice(match.end, match.end + 4)))
         return true;
     // An identifier label introduces the digits: "DiNr. 4471", "Policen-Nr."
-    if (ID_CUE_BEFORE.test(text.slice(Math.max(0, match.start - 40), match.start)))
+    // Unless the label is a *postal* one. ID_CUE_BEFORE matches any word ending
+    // in "Nummer", "Nr", "Numero" or "Numéro" -- the wildcard is `[\w\-]*` -- so
+    // it matches `postnummer`, `postnr` and `postinumero`, the canonical postal
+    // labels of Norway, Denmark and Finland. Those countries write a bare
+    // four- or five-digit code, so the isdigit() guard above lets this run and
+    // the code was suppressed by its own label: `postnummer: 5020 Bergen`
+    // produced nothing at all (rules-engine#41).
+    const before = text.slice(Math.max(0, match.start - 40), match.start);
+    const cue = ID_CUE_BEFORE.exec(before);
+    if (cue !== null && !POSTAL_LABEL_CUE.test(cue[0].trimStart()))
         return true;
     // Digits after an international dialling prefix belong to PHONE
     const [lineStart] = enclosingLine(text, match.start, match.end);
@@ -829,12 +1074,158 @@ function suppressRequiresContext(text, match) {
     if (DELIMITED_FIELD_TYPES.has(match.patternDef.entityType) &&
         fillsADelimitedField(text, match.start, match.end))
         return false;
+    if (DATE_LABEL_TYPES.has(match.patternDef.entityType)) {
+        return !labelsThisDate(text, match.start, match.end, match.patternDef.contextKeywords, match.patternDef.entityType);
+    }
     const [before, after] = getContext(text, match.start, match.end);
     const context = (before + " " + after).toLowerCase();
     return !match.patternDef.contextKeywords.some(kw => context.includes(kw.toLowerCase()));
 }
+/** Date types decided by a label: DOB and DATE_OF_DEATH share one date shape. */
+const DATE_LABEL_TYPES = new Set([EntityType.DOB, EntityType.DATE_OF_DEATH]);
+/** Any common numeric date, to tell whether a label belongs to another date. */
+// A masked date counts as one: the gateway's rules pass reads SDK-masked text (rules-engine#111).
+// ... and a written-month date, now a DOB shape of its own (rules-engine#115).
+const ANY_DATE = new RegExp(String.raw `\d{1,4}[/.\-]\d{1,2}[/.\-]\d{2,4}|\[(?:dob|date_of_death)\]|(?<![A-Za-z0-9_])\d{1,2}\.?\s+(?:` + MONTH_NAMES + String.raw `)\.?\s+\d{4}(?![A-Za-z0-9_])`, "i");
+/**
+ * True when one of `keywords` is this date's own label: before the date with no
+ * other date between, or after it inside the date's own sentence. Anywhere in
+ * the window typed every date from whichever date label the document carried
+ * (rules-engine#52).
+ */
+/** A date followed by a list separator: an item of the list a label introduces. */
+const LIST_ITEM = /\d{1,4}[/.\-]\d{1,2}[/.\-]\d{2,4}\s*(?:,|;|–|&|\band\b|\ben\b|\bet\b|\bund\b|\bor\b|\bof\b|\bou\b|\boder\b|\brespectievelijk\b|\bbzw\.?)\s*/g;
+/** Punctuation and at most two short words ("e.g.", "bv.", "op") between label and date. */
+const LABEL_TAIL = /^[\s:.,()\-]*(?:\p{L}{1,4}(?:\.\p{L}{1,2})*\.?(?:[\s:.,()\-]+|$)){0,2}$/u;
+/** The birth sign "°" directly before the date, but not the number sign "n°". */
+const BIRTH_SIGN = /(?<![a-z])°\s?$/;
+/** No other date between a label and the date, except items of its list. */
+function nothingButAListBetween(gap) {
+    if (!ANY_DATE.test(gap))
+        return true;
+    const rest = gap.replace(LIST_ITEM, " ");
+    return !ANY_DATE.test(rest) && LABEL_TAIL.test(rest);
+}
+/**
+ * Where `keyword` occurs in the lower-cased `haystack`, or -1. An all-capitals
+ * keyword is an abbreviation and counts only as a word of its own: "DOB" is a
+ * label, the "dob" in Polish "dobrowolnej" is not (rules-engine#100); a plural
+ * "s" may follow ("DOBs e.g. …"). Other
+ * keywords still match inside a longer word, which inflected forms need.
+ */
+function keywordAt(haystack, keyword, last) {
+    const kw = keyword.toLowerCase();
+    if (keyword !== keyword.toUpperCase() || keyword === kw) {
+        return last ? haystack.lastIndexOf(kw) : haystack.indexOf(kw);
+    }
+    const isLetter = (c) => c !== "" && c.toLowerCase() !== c.toUpperCase();
+    const hits = [];
+    for (let i = haystack.indexOf(kw); i !== -1; i = haystack.indexOf(kw, i + 1)) {
+        let next = i + kw.length;
+        if (haystack[i - 1] === "[" && haystack[next] === "]")
+            continue; // a placeholder ("[DOB]"), not a label (#111)
+        if (haystack[next] === "s")
+            next++;
+        if (!isLetter(haystack.slice(i - 1, i)) && !isLetter(haystack.slice(next, next + 1))) {
+            hits.push(i);
+        }
+    }
+    if (hits.length === 0)
+        return -1;
+    return last ? hits[hits.length - 1] : hits[0];
+}
+function labelsThisDate(text, start, end, keywords, entityType) {
+    const [before, after] = getContext(text, start, end);
+    const lowerBefore = before.toLowerCase();
+    const lowerAfter = after.toLowerCase();
+    // A label on an earlier line counts only when the date opens its own line or
+    // the label was asked as a question (a call transcript's answer turn);
+    // a column header is a fallback and never overrules a label of the date's own.
+    const lineStart = lowerBefore.lastIndexOf("\n") + 1;
+    const opensLine = lowerBefore.slice(lineStart).replace(/[ \t:|;*\-•(\[]/g, "") === "";
+    if (entityType === EntityType.DOB && BIRTH_SIGN.test(lowerBefore))
+        return true;
+    for (const keyword of keywords) {
+        const kw = keyword.toLowerCase();
+        const i = keywordAt(lowerBefore, keyword, true);
+        if (i >= 0 && nothingButAListBetween(lowerBefore.slice(i + kw.length))
+            && (i >= lineStart || opensLine
+                || lowerBefore.slice(i + kw.length, lineStart).includes("?")))
+            return true;
+        const j = keywordAt(lowerAfter, keyword, false);
+        if (j >= 0) {
+            const gap = lowerAfter.slice(0, j);
+            if (!ANY_DATE.test(gap) && !SENTENCE_BREAK.test(gap)
+                && !LEADS_TO_A_DATE.test(lowerAfter.slice(j + kw.length)))
+                return true;
+        }
+    }
+    const header = columnHeader(text, start);
+    return header !== null && keywords.some(kw => keywordAt(header, kw, false) >= 0);
+}
+/**
+ * A label running straight into a date of its own introduces that date, not the
+ * one before it ("Verstorben am 01.02.2020, geboren am 12.03.1940").
+ */
+// ... or into a value already masked ("né le [DOB]"): the label is that value's (rules-engine#111).
+const LEADS_TO_A_DATE = new RegExp(String.raw `^[\s:.\-]*(?:[a-zà-ÿ]{1,3}[\s:.]+)?(?:\d{1,4}[/.\-]\d{1,2}[/.\-]\d{2,4}|\[[a-z_]+\]|\d{1,2}\.?\s+(?:` + MONTH_NAMES + String.raw `)\.?\s+\d{4})`, "i");
+/** Field separators a table row may use. */
+const COLUMN_SEPARATORS = [";", "|", "\t", ","];
+/**
+ * The lower-cased header cell above the value, if it sits in a table: in a table
+ * the column decides the label, not proximity. A header is one of the three
+ * lines above, split by the row's separator into the same number of cells.
+ */
+function columnHeader(text, start) {
+    const lineStart = text.lastIndexOf("\n", start - 1) + 1;
+    const lineEndAt = text.indexOf("\n", start);
+    const line = text.slice(lineStart, lineEndAt >= 0 ? lineEndAt : text.length);
+    // The three lines above, by lastIndexOf: splitting the whole prefix was
+    // quadratic in the document, once per date candidate.
+    let aboveStart = lineStart - 1;
+    for (let k = 0; k < 3 && aboveStart >= 0; k++) {
+        aboveStart = aboveStart === 0 ? -1 : text.lastIndexOf("\n", aboveStart - 1);
+    }
+    const above = lineStart ? text.slice(aboveStart + 1, Math.max(0, lineStart - 1)).split("\n") : [];
+    for (const sep of COLUMN_SEPARATORS) {
+        if (!line.includes(sep))
+            continue;
+        const cells = line.split(sep);
+        const column = text.slice(lineStart, start).split(sep).length - 1;
+        for (const header of [...above].reverse()) {
+            // A "label : value" field with a comma in its value is not a header (#111).
+            if (header.includes(":"))
+                continue;
+            const heads = header.split(sep);
+            if (heads.length === cells.length && !ANY_DATE.test(header))
+                return heads[column].toLowerCase();
+        }
+    }
+    return null;
+}
+/** A dotted MAC shape glued to more of a reference is part of it: the tail of
+ *  "WSO-II.6151.4471.2025" (rules-engine#105). Dotted form only. */
+function suppressMacInReference(text, match) {
+    if (match.patternDef.entityType !== EntityType.MAC_ADDRESS || !match.text.includes("."))
+        return false;
+    return joinedToMore(text, match.start, match.end);
+}
+/** A card number is never carved out of a longer run of digit groups: a
+ *  four-digit group joined by the card's own separator on either side means the
+ *  run is longer, e.g. a Polish account number (rules-engine#106). */
+function suppressCardInsideDigitRun(text, match) {
+    if (match.patternDef.entityType !== EntityType.CREDIT_CARD)
+        return false;
+    const sep = [...match.text].find(c => !/\d/.test(c)) ?? "";
+    if (!sep)
+        return false;
+    const s = sep.replace(/[-\\^$.*+?()[\]{}|]/g, "\\$&");
+    const before = text.slice(Math.max(0, match.start - 6), match.start);
+    const after = text.slice(match.end, match.end + 6);
+    return new RegExp(`(?<!\\d)\\d{4}${s}$`).test(before) || new RegExp(`^${s}\\d{4}(?!\\d)`).test(after);
+}
 const TYPE_SUPPRESSORS = {
-    [EntityType.PHONE]: [suppressCurrency, suppressUnits, suppressReference, suppressMath, suppressPhoneServiceNumber, suppressPhoneDateOverlap, suppressPhoneAsNumberRange],
+    [EntityType.PHONE]: [suppressCurrency, suppressUnits, suppressReference, suppressMath, suppressPhoneServiceNumber, suppressPhoneInsideAccountRun, suppressPhoneDateOverlap, suppressPhoneAsNumberRange],
     [EntityType.NATIONAL_ID]: [suppressCurrency, suppressUnits, suppressReference, suppressLegal, suppressMath, suppressNatidAsPassport, suppressSeNatidAsOrg],
     [EntityType.SSN]: [suppressCurrency, suppressUnits, suppressReference, suppressMath],
     [EntityType.TAX_ID]: [suppressCurrency, suppressUnits, suppressReference, suppressMath, suppressTaxidAsIpAddress],
@@ -844,10 +1235,14 @@ const TYPE_SUPPRESSORS = {
     [EntityType.LICENSE_PLATE]: [suppressPlateInCompound, suppressDePlateUnknownDistrict, suppressPlateAsCurrencyAmount],
     [EntityType.SECRET]: [suppressSecretOverStructured, suppressSecretNotASecret],
     [EntityType.CHAMBER_OF_COMMERCE]: [suppressReference],
+    [EntityType.MAC_ADDRESS]: [suppressMacInReference],
+    [EntityType.CREDIT_CARD]: [suppressCardInsideDigitRun],
 };
 export function shouldSuppress(text, match, scratch) {
     if (suppressSequential(text, match))
         return true;
+    if (suppressRedactionPlaceholder(text, match))
+        return true;
     const typeSups = TYPE_SUPPRESSORS[match.patternDef.entityType];
     if (typeSups) {
         for (const s of typeSups) {