2.0.3: values cut or preceded by a placeholder

CHANGELOG.md

@@ -8,6 +8,24 @@ Semver for this island:
 
 Accuracy is 841-dev, union at 0.95. Through 1.1.2 the gold has 354 spans; from 1.2.0 it is restated to phone policy v3 (315 spans), and the two are not comparable. A version that changes those numbers must update `hybrid.json` `eval` and the tables below.
 
+## 2.0.3
+
+Same NERGAL weights, threshold, union and API. Rules SHA `4d054723…`: input that already holds a `[PII]`, `[PHONE]` or `[Telefon]` placeholder.
+
+- **A NIP or REGON label reaches past one placeholder.** `NIP [PII] 526-000-12-46`, `NIP: [PII], 526-000-12-46.` and `REGON [PII] 123456785` now mask the number; in 2.0.2 the placeholder ended the label, and a bare NIP or REGON is never masked. The value still needs a valid checksum, and a second placeholder ends the reach. PESEL, account and email need no label, so they were already masked. The placeholder can also be one this scrub made: a second checksum-valid NIP or REGON after a comma or space is masked too (`NIP 526-000-12-46, 5213017228` → `NIP [PII], [PII]`); after `i` or `/` it is not.
+- **A labelled value cut by a placeholder is masked.** A run of digit groups and placeholders joined by single spaces, tabs or hyphens, with 5+ digits and a `PESEL`, `NIP` or `REGON` label up to 64 characters before it, has every digit fragment masked `[PII]`: `PESEL 8503[PII]1212343` → `PESEL [PII][PII][PII]`, `NIP 526-000-[PII]-46` → `NIP [PII]-[PII]-[PII]`. A fragment has no checksum to test, so the label is required.
+- **A phone cut by a placeholder is masked only after a phone cue.** The same run after a contact or phone label gives `[PHONE]` fragments: `tel. 601 [PII] 200 300` → `tel. [PHONE] [PII] [PHONE]`, `tel. 601 200 [PHONE]` → `tel. [PHONE] [PHONE]`. Spaced digit groups next to a placeholder are also pages, amounts and counts, so without a cue `601 [PII] 200 300` is left as is; a postcode, date or amount fragment never counts as a phone.
+- **Existing placeholders and offsets are kept.** Only digits are replaced; placeholders and separators stay, and span offsets refer to the input text. This pass runs before every other rule, so every placeholder it sees came with the input.
+
+Still missed: an unlabelled split value without a cue (`8503[PII]1212343`, `601 [PII] 200 300`); a run that starts with a placeholder (`tel. [PHONE] 200 300`); a run with fewer than 5 digits (`PESEL 1234 [PII]`).
+
+841-dev, names off: unchanged from 2.0.2 (no 841-dev passage holds a placeholder). Release gates (`artifacts/nergal_2_0_3_placeholder/`, frozen before scoring, stored spans): the 1,837 bench rows, the 1,000-document Dynaword runtime sample (names off and on) and 41,204 FineWeb miss-hunt passages, rule spans and output identical, 0 masked characters lost; every on-disk Dynaword source, full text, rule spans identical in all 3,378,438 documents, the 997 with a `[PII]` or `[Telefon]` placeholder included. No labelled set or corpus document changes, so the new behaviour is exercised only by the invented cases in `test_nergal.py`.
+
+| Version | Whole /315 | Residual | Rules FP | Union FP | Char P | Char R | What changed |
+|---|---:|---:|---:|---:|---:|---:|---|
+| 2.0.2, names off | 303 | 9 | 24 | 80 | 98.59% | 97.83% | A rule's label wins on its characters |
+| 2.0.3, names off | 303 | 9 | 24 | 80 | 98.59% | 97.83% | Values cut or preceded by a placeholder |
+
 ## 2.0.2
 
 Same NERGAL weights, threshold and API. Rules SHA `205a253b…`: an unlabelled PESEL span is marked `bare`; every rule span keeps its start, end and label. With one union change in `nergal.py`, a labelled identifier keeps `[PII]`.

README.md

@@ -16,7 +16,7 @@ tags:
 - hybrid
 ---
 
-# NERGAL 2.0.2
+# NERGAL 2.0.3
 
 **Named Entity Recognition with Grounded Additive Labels**
 
@@ -66,9 +66,9 @@ NERGAL is not designed to remove:
 
 These are intended exclusions; false positives can still mask some of this content.
 
-### Known gaps in 2.0.2
+### Known gaps in 2.0.3
 
-Unlabelled phones and identifiers (the rules take a bare phone only in the grouped national forms `601 234 567` and `22 123 45 67`; a plain `601234567` needs a label or the model), unusual formatting and damaged text can escape detection. **VINs and obfuscated emails** (such as `name (at) domain.pl`) are approved annotation targets, but that approval alone does not establish reliable support in the released 2.0.2 model. Do not rely on it to remove them consistently. An email with a lowercase word glued onto its domain (`jan@firma.plkontakt`) is masked together with that word, and text glued before an address can be masked with it. A phone written as short parts joined by two slashes (`12 / 345 / 678`) is left as text. An identifier with a `[PII]` / `[PHONE]` / `[Telefon]` placeholder inside it or right before it can be missed. Names-on gaps are under [Names](#names).
+Unlabelled phones and identifiers (the rules take a bare phone only in the grouped national forms `601 234 567` and `22 123 45 67`; a plain `601234567` needs a label or the model), unusual formatting and damaged text can escape detection. **VINs and obfuscated emails** (such as `name (at) domain.pl`) are approved annotation targets, but that approval alone does not establish reliable support in the released 2.0.3 model. Do not rely on it to remove them consistently. An email with a lowercase word glued onto its domain (`jan@firma.plkontakt`) is masked together with that word, and text glued before an address can be masked with it. A phone written as short parts joined by two slashes (`12 / 345 / 678`) is left as text. Input that already holds a `[PII]` / `[PHONE]` / `[Telefon]` placeholder: a NIP or REGON label reaches past one placeholder to a checksum-valid value, and a value cut by a placeholder is masked digit group by digit group only after a `PESEL` / `NIP` / `REGON` label (`[PII]`) or a phone cue (`[PHONE]`). Without either (`8503[PII]1212343`, `601 [PII] 200 300`), with fewer than 5 digits, or when the run starts with a placeholder (`tel. [PHONE] 200 300`), the fragments stay. Names-on gaps are under [Names](#names).
 
 ## Versions
 
@@ -80,7 +80,8 @@ Unlabelled phones and identifiers (the rules take a bare phone only in the group
 | 1.2.0 | 303 | 9 | 24 | 80 | 98.59% | 97.83% | Phone policy v3 at mask time, rules and model spans |
 | 2.0.0, names off | 303 | 9 | 24 | 80 | 98.59% | 97.83% | `[PHONE]` replaces `[Telefon]`; opt-in `[PERSON]` names |
 | 2.0.1, names off | 303 | 9 | 24 | 80 | 98.59% | 97.83% | A `[PERSON]` placeholder ends an other-number label |
-| **2.0.2, names off** | **303** | **9** | **24** | **80** | **98.59%** | **97.83%** | A rule's label wins on its characters |
+| 2.0.2, names off | 303 | 9 | 24 | 80 | 98.59% | 97.83% | A rule's label wins on its characters |
+| **2.0.3, names off** | **303** | **9** | **24** | **80** | **98.59%** | **97.83%** | Values cut or preceded by a placeholder |
 
 1.0.0–1.1.2 were scored on the earlier 354-span gold (whole 323 → 326, union FP 133 → 80); per-version numbers are in `CHANGELOG.md`.
 
@@ -111,7 +112,7 @@ Names off hides no name. A component is the independent unit, covered when every
 
 ## Compared with other systems
 
-Same split and gold. Every model runs through the NERGAL recipe with names off: its spans at 0.95, phone spans cut by phone policy v3, unioned with the rules. The rows were scored with the 1.2.0 rules; 2.0.0, 2.0.1 and 2.0.2 give the same rule spans on this split. **Naked** is the model alone. **Residual** is passages with any gold character left unmasked. Character scores are gold vs masked characters.
+Same split and gold. Every model runs through the NERGAL recipe with names off: its spans at 0.95, phone spans cut by phone policy v3, unioned with the rules. The rows were scored with the 1.2.0 rules; 2.0.0 through 2.0.3 give the same rule spans on this split. **Naked** is the model alone. **Residual** is passages with any gold character left unmasked. Character scores are gold vs masked characters.
 
 | System | Mode | Whole /315 | Residual | False chars | Char P | Char R |
 |---|---|---:|---:|---:|---:|---:|
@@ -121,9 +122,9 @@ Same split and gold. Every model runs through the NERGAL recipe with names off:
 | Fine-tuned GLiNER (previous incumbent) | naked | 263 | 28 | 15 | 99.70% | 88.80% |
 | Fine-tuned GLiNER (previous incumbent) | ∪ regex | 299 | 12 | 39 | 99.30% | 97.18% |
 | XLM-R epoch 5 | naked | 275 | 28 | 67 | 98.72% | 90.25% |
-| **NERGAL 2.0.2, names off** | **∪ regex** | **303** | **9** | **80** | **98.59%** | **97.83%** |
+| **NERGAL 2.0.3, names off** | **∪ regex** | **303** | **9** | **80** | **98.59%** | **97.83%** |
 
-Zero-shot [GLiNER 2.5](https://huggingface.co/fastino/gliner2.5-multi-v1) is not competitive, especially on non-phone PII (7/185 whole, naked). The fine-tuned GLiNER that NERGAL replaced is the more precise union (39 false characters vs 80) and the stronger phone model (128/130 whole, naked, vs 115), but it masks 4 fewer values whole and leaves 12 residual passages vs 9; XLM-R is the stronger model on other PII (160/185 vs 135). NERGAL 2.0.2 wholly masks 124/130 phones and 179/185 other PII, each under its own placeholder (`[PHONE]` / `[PII]`); exact-span precision 91.05%, recall 93.65%, F1 92.33%.
+Zero-shot [GLiNER 2.5](https://huggingface.co/fastino/gliner2.5-multi-v1) is not competitive, especially on non-phone PII (7/185 whole, naked). The fine-tuned GLiNER that NERGAL replaced is the more precise union (39 false characters vs 80) and the stronger phone model (128/130 whole, naked, vs 115), but it masks 4 fewer values whole and leaves 12 residual passages vs 9; XLM-R is the stronger model on other PII (160/185 vs 135). NERGAL 2.0.3 wholly masks 124/130 phones and 179/185 other PII, each under its own placeholder (`[PHONE]` / `[PII]`); exact-span precision 91.05%, recall 93.65%, F1 92.33%.
 
 XLM-R and epoch 5 were chosen in September 2026, on the earlier gold and before the phone-policy cut. Fine-tuned GLiNER, HerBERT-large and XLM-R-large were trained on the same split; only XLM-R passed the content-preservation gate, and epoch 5 at 0.95 (seed `202609160`) was the only one of 133 epoch/threshold points that covered more than the fine-tuned GLiNER union of that time while adding no false-mask characters it did not already make. Under the 1.2.0 rules, gold and phone cut, that no longer holds: the GLiNER union makes fewer false masks (table above).
 

hybrid.json

@@ -1,12 +1,12 @@
 {
   "full_name": "Named Entity Recognition with Grounded Additive Labels",
   "hub_id": "SlayerLab/NERGAL",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "mode": "rules_union",
   "epoch": 5,
   "seed": 202609160,
   "threshold": 0.95,
-  "rules_sha256": "205a253b7f496b00a3a7644b9588b6c22d94d8ebb223d2d9d8a4d6326bdcccdb",
+  "rules_sha256": "4d0547238131908ca498a23607a7877512b2fb6022c484171334af1e604fc95a",
   "eval": {
     "split": "841-dev",
     "gold_amendments": [

nergal.py

@@ -17,13 +17,13 @@ import scrub_pii
 from scrub_pii import LEGACY_PHONE_TAG, PERSON_TAG, PHONE_TAG, PII_TAG
 
 HUB_ID = 'SlayerLab/NERGAL'
-VERSION = '2.0.2'
+VERSION = '2.0.3'
 GAPS = ['[PII_SPACE]', '[PII_BREAK]']
 GAP_IDS = [250002, 250003]
 BIO_LABELS = ['O', 'B-phone', 'I-phone', 'B-pii', 'I-pii']
 LABELS = ['phone', 'pii']
 THRESHOLD = 0.95
-RULES_SHA = '205a253b7f496b00a3a7644b9588b6c22d94d8ebb223d2d9d8a4d6326bdcccdb'
+RULES_SHA = '4d0547238131908ca498a23607a7877512b2fb6022c484171334af1e604fc95a'
 DTYPES = ('float32', 'float16')
 MARKERS = (PHONE_TAG, PII_TAG, PERSON_TAG, LEGACY_PHONE_TAG)
 TAGS = {'person': PERSON_TAG, 'pii': PII_TAG, 'phone': PHONE_TAG}  # ascending rank; a non-bare rule span outranks every model and person span

scrub_pii.py

@@ -121,10 +121,12 @@ _DOCUMENT_RE = re.compile(
     r"[:=-]?[ \t]*)"
     r"(?P<number>[A-Z]{3}[ \t-]?[0-9OIl]{6}|[A-Z]{2}[ \t-]?[0-9OIl]{7}|[A-Z][ \t-]?[0-9]{6,9}|[0-9]{4,12})\b", re.I,
 )
-_LABELLED_ID_RE = re.compile(
-    r"\b(?P<label>(?P<kind>PESEL|NIP|REGON)\b"
+_LABELLED_ID_LABEL = (
+    r"\b(?P<kind>PESEL|NIP|REGON)\b"
     r"(?:[ \t]+(?:Gminy|Powiatu|Miasta|firmy)(?:[ \t]+[^\W\d_][^\W\d_-]*){0,4})?[ \t]{0,8}"
-    r"(?:(?:nr\.?|numer)[ \t]{0,8})?[:=.\-]?[ \t]{0,8}(?:\r?\n[ \t]{0,8})?)"
+    r"(?:(?:nr\.?|numer)[ \t]{0,8})?[:=.\-]?[ \t]{0,8}(?:\r?\n[ \t]{0,8})?")
+_LABELLED_ID_RE = re.compile(
+    r"(?P<label>" + _LABELLED_ID_LABEL + r")"
     r"(?P<number>(?:PL[ \t]*)?(?:[0-9OIl]{9,14}|\d(?:[ \t-]?\d){8,13}))"
     r"(?!\w|[ \t-]*\d)", re.I,
 )
@@ -140,8 +142,18 @@ _ID_LABEL_END = r"[ \t]{0,8}(?:(?:nr\.?|numer)[ \t]{0,8})?[:=.\-]?[ \t]{0,8}(?:\
 # Form labels may carry footnote asterisks and one short digit-free gloss: "NIP (Wykonawcy)**:".
 # Only checksum-gated NIP/REGON take it; KRS has no checksum.
 _ID_LABEL_NOTE = r"(?:[ \t]{0,8}\*{1,3})?(?:[ \t]{0,8}\([^()\d\n]{1,40}\))?(?:[ \t]{0,8}\*{1,3})?"
-_NIP_LABEL_RE = re.compile(r"\bNIP\b" + _ID_LABEL_NOTE + _ID_LABEL_END, re.I)
-_REGON_LABEL_RE = re.compile(r"\bREGON\b" + _ID_LABEL_NOTE + _ID_LABEL_END, re.I)
+# One placeholder on the same line does not end their reach (2.0.3): "NIP [PII] 526-000-12-46", "NIP: [PII], 526…".
+_ID_LABEL_SKIP = r"(?:[ \t]{0,8}[:=.\-]?[ \t]{0,8}(?:" + _BOUNDARY + r")[ \t]{0,3}[,;]?)?"
+_NIP_LABEL_RE = re.compile(r"\bNIP\b" + _ID_LABEL_NOTE + _ID_LABEL_SKIP + _ID_LABEL_END, re.I)
+_REGON_LABEL_RE = re.compile(r"\bREGON\b" + _ID_LABEL_NOTE + _ID_LABEL_SKIP + _ID_LABEL_END, re.I)
+# A value cut by a placeholder (2.0.3): digit groups and placeholders joined by single spaces, tabs or hyphens,
+# starting with a digit ("8503[PII]1212343", "601 [PII] 200 300", "526-000-[PII]-46"). A fragment has no checksum, so
+# it is masked only after a PESEL/NIP/REGON label ([PII]) or a phone cue ([PHONE]), and only with 5+ digits in all.
+_SPLIT_RE = re.compile(r"(?<![\w\]])(?:\+[ \t]?)?\d+(?:[ \t-]?(?:\d+|" + _BOUNDARY + r"))++(?!\w|[.,:/]\d)")
+_SPLIT_FRAGMENT_RE = re.compile(r"(?:\+[ \t]?)?\d+(?:[ \t-]\d+)*")
+_SPLIT_LABEL_RE = re.compile(_LABELLED_ID_LABEL + r"\Z", re.I)
+_SPLIT_NOT_PHONE_RE = re.compile(r"\d{2}-\d{3}|\d{4}-\d{2}-\d{2}|\d{2}-\d{2}-\d{4}")  # postcode, dates
+_SPLIT_MIN_DIGITS = 5
 _KRS_RE = re.compile(r"\b\d{6,10}(?!\w|[ \t-]*\d)")
 # Abbreviation or written-out register name, optionally "pod nr/numerem".
 _KRS_LABEL_RE = re.compile(
@@ -920,6 +932,30 @@ def scrub_pii(text: str, *, spans: list | None = None) -> tuple[str, dict[str, i
             counts['pin'] += 1
             return m['label'] + mask(m.start('number'), m.end('number'), PII_TAG)
         return _PIN_RE.sub(replace, value), None
+    # First, so every placeholder it sees came with the input, not from this run's own masks.
+    def split_values(value, *, mask):
+        def replace(m):
+            run, start = m[0], m.start()
+            fragments = list(_SPLIT_FRAGMENT_RE.finditer(run))
+            if (not re.search(_BOUNDARY, run) or len(_digits(run)) < _SPLIT_MIN_DIGITS
+                    or _is_amount(value, start, m.end())):
+                return run
+            label = _SPLIT_LABEL_RE.search(value, max(0, start - 64), start)
+            if label:
+                tag, kind = PII_TAG, label['kind'].lower()
+            elif (_phone_context(value, start, run)
+                  and not any(_SPLIT_NOT_PHONE_RE.fullmatch(f[0]) for f in fragments)):
+                tag, kind = PHONE_TAG, 'phone'
+            else:
+                return run
+            counts[kind] += 1
+            out, pos = [], 0
+            for f in fragments:
+                out += [run[pos:f.start()], mask(start + f.start(), start + f.end(), tag)]
+                pos = f.end()
+            return ''.join(out) + run[pos:]
+        return _SPLIT_RE.sub(replace, value), None
+    apply(split_values)
     apply(pins)
     foreign = apply(_replace_checked, _IBAN_RE, PII_TAG, _iban_ok)
     bare = apply(_replace_checked, _ACCOUNT_RE, PII_TAG, _iban_ok)
@@ -951,7 +987,7 @@ def scrub_pii(text: str, *, spans: list | None = None) -> tuple[str, dict[str, i
     counts["email"] += apply(_replace_checked, _EMAIL_RE, PII_TAG, lambda _: True)
     counts["email"] += apply(_replace_checked, _EMAIL_FRAGMENT_RE, PII_TAG,
                              lambda _: True, _EMAIL_LABEL_RE)
-    counts["phone"] = apply(_replace_phones)
+    counts["phone"] += apply(_replace_phones)
     # Contact context takes precedence over coincidental PESEL checksums in
     # foreign phone numbers; explicitly labelled identifiers were handled first.
     first = len(spans) if spans is not None else 0

test_nergal.py

@@ -7,7 +7,7 @@ import unittest
 from pathlib import Path
 
 HERE = Path(__file__).resolve().parent
-RULES_SHA = '205a253b7f496b00a3a7644b9588b6c22d94d8ebb223d2d9d8a4d6326bdcccdb'
+RULES_SHA = '4d0547238131908ca498a23607a7877512b2fb6022c484171334af1e604fc95a'
 
 
 class NergalTests(unittest.TestCase):
@@ -15,7 +15,7 @@ class NergalTests(unittest.TestCase):
         from nergal import GAP_IDS, GAPS, HUB_ID, RULES_SHA as PINNED, THRESHOLD, VERSION
         card = json.loads((HERE / 'hybrid.json').read_text())
         self.assertEqual(HUB_ID, 'SlayerLab/NERGAL')
-        self.assertEqual(VERSION, '2.0.2')
+        self.assertEqual(VERSION, '2.0.3')
         self.assertEqual(card['version'], VERSION)
         self.assertEqual(card['eval']['union_fp'], 80)
         self.assertEqual(card['eval']['rules_fp'], 24)
@@ -95,6 +95,43 @@ class NergalTests(unittest.TestCase):
             with self.subTest(text=text):
                 self.assertEqual([text[s['start']:s['end']] for s in rules(text) if s['label'] == 'phone'], masked)
 
+    def test_a_placeholder_between_a_label_and_its_value_or_inside_a_value(self):
+        from nergal import apply_union, rules
+        from scrub_pii import scrub_pii
+        for text, masked in (  # invented; 5260001246 and 123456785 are checksum-valid
+                ('NIP [PII] 526-000-12-46', 'NIP [PII] [PII]'),          # the label reaches past one placeholder
+                ('NIP: [PII], 526-000-12-46.', 'NIP: [PII], [PII].'),
+                ('REGON [PII] 123456785', 'REGON [PII] [PII]'),
+                ('NIP [PII]\n5260001246', 'NIP [PII]\n[PII]'),
+                ('NIP [PII] 526-000-12-47', None),                      # still checksum-gated
+                ('NIP [PII] [PII] 5260001246', None),                    # one placeholder only
+                ('NIP 526-000-12-46, 5260001246', 'NIP [PII], [PII]'),   # this scrub's own placeholder counts too
+                ('NIP 526-000-12-46 i 5260001246', 'NIP [PII] i 5260001246'),
+                ('PESEL 8503[PII]1212343', 'PESEL [PII][PII][PII]'),     # labelled fragments are masked
+                ('NIP 526-000-[PII]-46', 'NIP [PII]-[PII]-[PII]'),
+                ('PESEL: 85031[PII]', 'PESEL: [PII][PII]'),
+                ('PESEL 1234 [PII]', None),                              # under 5 digits in all
+                ('tel. 601 [PII] 200 300', 'tel. [PHONE] [PII] [PHONE]'),  # a phone cue: fragments are [PHONE]
+                ('tel. 601 200 [PHONE]', 'tel. [PHONE] [PHONE]'),
+                ('tel. +48 601 [PII] 300', 'tel. [PHONE] [PII] [PHONE]'),
+                ('Kontakt: 22 123 [PHONE] 67', 'Kontakt: [PHONE] [PHONE] [PHONE]'),
+                ('8503[PII]1212343', None),                              # no label, no cue: known gap
+                ('601 [PII] 200 300', None), ('601 [PHONE] 200 300', None),
+                ('tel. 601 200 [PHONE]abc', None),                       # glued to a word
+                ('tel. 00-950 [PHONE]', None), ('tel. 2023-10-16 [PHONE]', None),  # postcode, date
+                ('tel. 12 345 [PII] zł', None),                          # amount
+                ('Strona [PII] 12 z 40', None), ('[PII] 2019 r.', None), ('art. [PII] ust. 2', None),
+                ('tel. [PHONE], godz. 8–16', None), ('[PHONE] 123 osób', None),
+                ('Kontakt: [PHONE], 2 000 000 zł', None), ('NIP [PII], rok 2023', None),
+                ('tel. [PHONE], pok. 101', None), ('tel. [PHONE], kod 00-950', None), ('[PII] 12 345 678 zł', None),
+                ('tel. [PHONE] w godz. 10–18, sala 204', None)):
+            with self.subTest(text=text):
+                spans = rules(text)
+                self.assertEqual(apply_union(text, spans)[0], masked or text)
+                self.assertTrue(all('[' not in text[s['start']:s['end']] for s in spans))  # placeholders stay as they are
+        self.assertEqual(scrub_pii('PESEL 8503[PII]1212343')[1]['pesel'], 1)
+        self.assertEqual(scrub_pii('tel. 601 [PII] 200 300')[1]['phone'], 1)
+
     def test_grouped_national_phones_mask_without_a_cue(self):
         from nergal import rules
         for text, masked in (('Sklep Ala, 601 234 567, czynne 9-17', ['601 234 567']),
@@ -257,6 +294,21 @@ class NergalTests(unittest.TestCase):
         }
         self.assertEqual({t: m for t, (m, _) in zip(cases, nergal.scrub_many(list(cases)))}, cases)
 
+    def test_published_weights_mask_values_split_by_a_placeholder(self):
+        from nergal import Nergal
+        nergal = Nergal(HERE, device='cpu')
+        cases = {  # invented; the model adds nothing to the rules here, and the gaps stay unmasked
+            'NIP [PII] 526-000-12-46': 'NIP [PII] [PII]', 'NIP: [PII], 526-000-12-46.': 'NIP: [PII], [PII].',
+            'REGON [PII] 123456785': 'REGON [PII] [PII]', 'PESEL 8503[PII]1212343': 'PESEL [PII][PII][PII]',
+            'NIP 526-000-[PII]-46': 'NIP [PII]-[PII]-[PII]', 'tel. 601 [PII] 200 300': 'tel. [PHONE] [PII] [PHONE]',
+            'tel. 601 200 [PHONE]': 'tel. [PHONE] [PHONE]', 'tel. [Telefon], 601 200 300': 'tel. [Telefon], [PHONE]',
+            **{t: t for t in ('8503[PII]1212343', '601 [PII] 200 300', '601 [PHONE] 200 300', 'Strona [PII] 12 z 40',
+                              '[PII] 2019 r.', 'art. [PII] ust. 2', 'tel. [PHONE], godz. 8–16', '[PHONE] 123 osób',
+                              'Kontakt: [PHONE], 2 000 000 zł', 'NIP [PII], rok 2023', 'tel. [PHONE], pok. 101',
+                              'tel. [PHONE], kod 00-950', '[PII] 12 345 678 zł', 'tel. [PHONE] w godz. 10–18, sala 204')},
+        }
+        self.assertEqual({t: m for t, (m, _) in zip(cases, nergal.scrub_many(list(cases)))}, cases)
+
     def _names(self):
         from nergal import Names
         return Names(HERE, json.loads((HERE / 'hybrid.json').read_text())['names'])