@doccloak/core 0.11.0 → 0.12.0

package/dist/surrogates.js

@@ -82,36 +82,48 @@ export function generateSessionSalt() {
     return out;
 }
 // ── Name pools (EN + PL) ───────────────────────────────────
+//
+// Pool hygiene (T182, audit R3/R4): a surrogate becomes a restore KEY, so
+// every alphabetic pool excludes (a) names that are also everyday words
+// in English or, for capitalized-noun languages, in their own language
+// (White, Green, King, Young, Hill, Baker, Post, Wolf, Richter, Urban,
+// Martin the bird, ...) and (b) entries of three letters or fewer (Bo,
+// Per, Odd, Jan, Eva, Bos, Vos, Kok, ...), which fire inside ordinary
+// words even with boundaries around them. Replacements keep the pool
+// size and sit at the same index, so surrogate derivation is unchanged
+// for every original that never picked a removed entry. CJK pools are
+// exempt from (b): their names are one to three characters by design.
+// The pool-hygiene test in tests/surrogates.test.ts enforces both rules.
 const EN_FIRST_MALE = [
     'James', 'John', 'Robert', 'Michael', 'William', 'David', 'Richard', 'Joseph',
-    'Thomas', 'Charles', 'Daniel', 'Matthew', 'Anthony', 'Mark', 'Steven', 'Paul',
+    'Thomas', 'Charles', 'Daniel', 'Matthew', 'Anthony', 'Dennis', 'Steven', 'Paul',
     'Andrew', 'Joshua', 'Kevin', 'Brian', 'George', 'Timothy', 'Ronald', 'Edward',
     'Jason', 'Jeffrey', 'Ryan', 'Jacob', 'Gary', 'Nicholas', 'Eric', 'Jonathan',
-    'Stephen', 'Larry', 'Justin', 'Scott', 'Brandon', 'Benjamin', 'Samuel', 'Gregory',
+    'Stephen', 'Larry', 'Justin', 'Douglas', 'Brandon', 'Benjamin', 'Samuel', 'Gregory',
 ];
 const EN_FIRST_FEMALE = [
     'Mary', 'Patricia', 'Jennifer', 'Linda', 'Elizabeth', 'Barbara', 'Susan', 'Jessica',
     'Sarah', 'Karen', 'Lisa', 'Nancy', 'Betty', 'Margaret', 'Sandra', 'Ashley',
-    'Kimberly', 'Emily', 'Donna', 'Michelle', 'Carol', 'Amanda', 'Dorothy', 'Melissa',
-    'Deborah', 'Stephanie', 'Rebecca', 'Sharon', 'Laura', 'Cynthia', 'Kathleen', 'Amy',
+    'Kimberly', 'Emily', 'Donna', 'Michelle', 'Janet', 'Amanda', 'Dorothy', 'Melissa',
+    'Deborah', 'Stephanie', 'Rebecca', 'Sharon', 'Laura', 'Cynthia', 'Kathleen', 'Kathryn',
     'Angela', 'Shirley', 'Anna', 'Ruth', 'Brenda', 'Pamela', 'Emma', 'Nicole',
 ];
 const EN_SURNAMES = [
-    'Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller', 'Davis',
-    'Wilson', 'Anderson', 'Taylor', 'Thomas', 'Moore', 'Jackson', 'Martin', 'Lee',
-    'Thompson', 'White', 'Harris', 'Clark', 'Lewis', 'Robinson', 'Walker', 'Young',
-    'Allen', 'King', 'Wright', 'Scott', 'Green', 'Baker', 'Adams', 'Nelson',
-    'Hill', 'Campbell', 'Mitchell', 'Roberts', 'Carter', 'Phillips', 'Evans', 'Turner',
+    'Smith', 'Johnson', 'Williams', 'Collins', 'Jones', 'Garcia', 'Stewart', 'Davis',
+    'Wilson', 'Anderson', 'Taylor', 'Thomas', 'Moore', 'Jackson', 'Morgan', 'Murphy',
+    'Thompson', 'Rogers', 'Harris', 'Clark', 'Lewis', 'Robinson', 'Peterson', 'Sullivan',
+    'Allen', 'Bennett', 'Wright', 'Hughes', 'Howard', 'Richardson', 'Adams', 'Nelson',
+    'Morris', 'Campbell', 'Mitchell', 'Roberts', 'Carter', 'Phillips', 'Evans', 'Turner',
 ];
 const PL_FIRST_MALE = [
-    'Jan', 'Piotr', 'Krzysztof', 'Andrzej', 'Tomasz', 'Paweł', 'Michał', 'Marcin',
+    'Stanisław', 'Piotr', 'Krzysztof', 'Andrzej', 'Tomasz', 'Paweł', 'Michał', 'Marcin',
     'Marek', 'Grzegorz', 'Jerzy', 'Tadeusz', 'Adam', 'Łukasz', 'Zbigniew', 'Ryszard',
     'Dariusz', 'Henryk', 'Mariusz', 'Kazimierz', 'Wojciech', 'Robert', 'Mateusz', 'Marian',
     'Rafał', 'Jacek', 'Janusz', 'Mirosław', 'Maciej', 'Sławomir', 'Jarosław', 'Kamil',
-    'Wiesław', 'Roman', 'Władysław', 'Jakub', 'Artur', 'Zdzisław', 'Edward', 'Dawid',
+    'Wiesław', 'Bogdan', 'Władysław', 'Jakub', 'Artur', 'Zdzisław', 'Edward', 'Dawid',
 ];
 const PL_FIRST_FEMALE = [
-    'Anna', 'Maria', 'Katarzyna', 'Małgorzata', 'Agnieszka', 'Barbara', 'Krystyna', 'Ewa',
+    'Anna', 'Maria', 'Katarzyna', 'Małgorzata', 'Agnieszka', 'Barbara', 'Krystyna', 'Weronika',
     'Elżbieta', 'Zofia', 'Janina', 'Teresa', 'Joanna', 'Magdalena', 'Monika', 'Jadwiga',
     'Danuta', 'Irena', 'Halina', 'Helena', 'Beata', 'Aleksandra', 'Marta', 'Dorota',
     'Marianna', 'Grażyna', 'Jolanta', 'Stanisława', 'Iwona', 'Karolina', 'Bożena', 'Urszula',
@@ -121,8 +133,8 @@ const PL_FIRST_FEMALE = [
 const PL_SURNAMES = [
     'Nowak', 'Kowalski', 'Wiśniewski', 'Wójcik', 'Kowalczyk', 'Kamiński', 'Lewandowski', 'Zieliński',
     'Szymański', 'Woźniak', 'Dąbrowski', 'Kozłowski', 'Jankowski', 'Mazur', 'Kwiatkowski', 'Krawczyk',
-    'Piotrowski', 'Grabowski', 'Nowakowski', 'Pawłowski', 'Michalski', 'Nowicki', 'Adamczyk', 'Dudek',
-    'Zając', 'Wieczorek', 'Jabłoński', 'Król', 'Majewski', 'Olszewski', 'Jaworski', 'Wróbel',
+    'Piotrowski', 'Grabowski', 'Nowakowski', 'Pawłowski', 'Michalski', 'Nowicki', 'Adamczyk', 'Kaczmarek',
+    'Sobczak', 'Wieczorek', 'Jabłoński', 'Zalewski', 'Majewski', 'Olszewski', 'Jaworski', 'Zawadzki',
     'Malinowski', 'Pawlak', 'Witkowski', 'Walczak', 'Stępień', 'Górski', 'Rutkowski', 'Michalak',
 ];
 function feminizePlSurname(surname) {
@@ -143,7 +155,7 @@ function feminizePlSurname(surname) {
 // guaranteed by collision handling, not pool size.
 const DE_FIRST_MALE = [
     'Hans', 'Peter', 'Michael', 'Thomas', 'Andreas', 'Wolfgang', 'Klaus', 'Jürgen',
-    'Stefan', 'Christian', 'Markus', 'Alexander', 'Frank', 'Uwe', 'Martin', 'Werner',
+    'Stefan', 'Christian', 'Markus', 'Alexander', 'Dieter', 'Rainer', 'Holger', 'Werner',
     'Matthias', 'Bernd', 'Florian', 'Tobias', 'Sebastian', 'Lukas', 'Felix', 'Jonas',
 ];
 const DE_FIRST_FEMALE = [
@@ -152,8 +164,8 @@ const DE_FIRST_FEMALE = [
     'Christina', 'Birgit', 'Heike', 'Lena', 'Hannah', 'Laura', 'Lisa', 'Sophie',
 ];
 const DE_SURNAMES = [
-    'Müller', 'Schmidt', 'Schneider', 'Fischer', 'Weber', 'Meyer', 'Wagner', 'Becker',
-    'Schulz', 'Hoffmann', 'Schäfer', 'Koch', 'Bauer', 'Richter', 'Klein', 'Wolf',
+    'Müller', 'Schmidt', 'Schneider', 'Herrmann', 'Weber', 'Meyer', 'Wagner', 'Becker',
+    'Schulz', 'Hoffmann', 'Schäfer', 'Lehmann', 'Köhler', 'Schulze', 'Klein', 'Hartmann',
     'Schröder', 'Neumann', 'Schwarz', 'Zimmermann', 'Braun', 'Krüger', 'Hofmann', 'Lange',
 ];
 const FR_FIRST_MALE = [
@@ -163,13 +175,13 @@ const FR_FIRST_MALE = [
 ];
 const FR_FIRST_FEMALE = [
     'Marie', 'Nathalie', 'Isabelle', 'Sylvie', 'Catherine', 'Françoise', 'Christine', 'Monique',
-    'Sophie', 'Céline', 'Julie', 'Aurélie', 'Camille', 'Léa', 'Chloé', 'Manon',
+    'Sophie', 'Céline', 'Julie', 'Aurélie', 'Camille', 'Mathilde', 'Chloé', 'Manon',
     'Élise', 'Charlotte', 'Emma', 'Louise', 'Alice', 'Juliette', 'Margaux', 'Inès',
 ];
 const FR_SURNAMES = [
-    'Martin', 'Bernard', 'Dubois', 'Thomas', 'Robert', 'Richard', 'Petit', 'Durand',
+    'Mercier', 'Bernard', 'Dubois', 'Thomas', 'Robert', 'Richard', 'Rousseau', 'Durand',
     'Leroy', 'Moreau', 'Simon', 'Laurent', 'Lefebvre', 'Michel', 'Garcia', 'David',
-    'Bertrand', 'Roux', 'Vincent', 'Fournier', 'Morel', 'Girard', 'Lambert', 'Fontaine',
+    'Bertrand', 'Garnier', 'Vincent', 'Fournier', 'Morel', 'Girard', 'Lambert', 'Fontaine',
 ];
 const ES_FIRST_MALE = [
     'José', 'Antonio', 'Manuel', 'Francisco', 'Juan', 'David', 'Javier', 'Carlos',
@@ -177,7 +189,7 @@ const ES_FIRST_MALE = [
     'Jorge', 'Alberto', 'Diego', 'Adrián', 'Raúl', 'Iván', 'Rubén', 'Óscar',
 ];
 const ES_FIRST_FEMALE = [
-    'María', 'Carmen', 'Josefa', 'Isabel', 'Ana', 'Dolores', 'Pilar', 'Teresa',
+    'María', 'Carmen', 'Josefa', 'Isabel', 'Alicia', 'Dolores', 'Pilar', 'Teresa',
     'Rosa', 'Cristina', 'Laura', 'Marta', 'Elena', 'Lucía', 'Sara', 'Paula',
     'Raquel', 'Beatriz', 'Silvia', 'Patricia', 'Nuria', 'Alba', 'Andrea', 'Irene',
 ];
@@ -203,19 +215,19 @@ const IT_SURNAMES = [
 ];
 /** Masculine base forms; feminizeCsSurname derives -ová / -á endings. */
 const CS_FIRST_MALE = [
-    'Jiří', 'Jan', 'Petr', 'Josef', 'Pavel', 'Martin', 'Tomáš', 'Jaroslav',
+    'Jiří', 'Vojtěch', 'Petr', 'Josef', 'Pavel', 'Matěj', 'Tomáš', 'Jaroslav',
     'Miroslav', 'Zdeněk', 'František', 'Václav', 'Michal', 'Milan', 'Karel', 'Lukáš',
-    'David', 'Ladislav', 'Stanislav', 'Roman', 'Ondřej', 'Jakub', 'Vladimír', 'Radek',
+    'David', 'Ladislav', 'Stanislav', 'Libor', 'Ondřej', 'Jakub', 'Vladimír', 'Radek',
 ];
 const CS_FIRST_FEMALE = [
     'Marie', 'Jiřina', 'Anna', 'Věra', 'Alena', 'Lenka', 'Hana', 'Jaroslava',
-    'Kateřina', 'Lucie', 'Eva', 'Jana', 'Petra', 'Martina', 'Zuzana', 'Michaela',
+    'Kateřina', 'Lucie', 'Simona', 'Jana', 'Petra', 'Martina', 'Zuzana', 'Michaela',
     'Tereza', 'Barbora', 'Veronika', 'Kristýna', 'Markéta', 'Ivana', 'Monika', 'Klára',
 ];
 const CS_SURNAMES = [
     'Novák', 'Svoboda', 'Novotný', 'Dvořák', 'Černý', 'Procházka', 'Kučera', 'Veselý',
-    'Horák', 'Němec', 'Marek', 'Pokorný', 'Pospíšil', 'Hájek', 'Král', 'Jelínek',
-    'Růžička', 'Beneš', 'Fiala', 'Sedláček', 'Doležal', 'Zeman', 'Kolář', 'Urban',
+    'Horák', 'Němec', 'Marek', 'Pokorný', 'Pospíšil', 'Hájek', 'Bartoš', 'Jelínek',
+    'Růžička', 'Beneš', 'Fiala', 'Sedláček', 'Doležal', 'Zeman', 'Kolář', 'Šimek',
 ];
 function feminizeCsSurname(surname) {
     if (surname.endsWith('ý'))
@@ -241,31 +253,31 @@ const UK_SURNAMES = [
     'Мороз', 'Гончаренко', 'Левченко', 'Василенко', 'Кушнір', 'Романюк', 'Гаврилюк', 'Заєць',
 ];
 const NL_FIRST_MALE = [
-    'Daan', 'Sem', 'Bram', 'Lars', 'Thijs', 'Ruben', 'Kees', 'Joost',
-    'Maarten', 'Wouter', 'Jeroen', 'Sander', 'Bas', 'Niels', 'Floris', 'Gerrit',
+    'Daan', 'Luuk', 'Bram', 'Lars', 'Thijs', 'Ruben', 'Kees', 'Joost',
+    'Maarten', 'Wouter', 'Jeroen', 'Sander', 'Stijn', 'Niels', 'Floris', 'Gerrit',
     'Pieter', 'Willem', 'Hendrik', 'Cornelis', 'Dirk', 'Jaap', 'Sjoerd', 'Teun',
 ];
 const NL_FIRST_FEMALE = [
-    'Sanne', 'Lotte', 'Femke', 'Anouk', 'Fleur', 'Iris', 'Nienke', 'Marloes',
+    'Sanne', 'Lotte', 'Femke', 'Anouk', 'Fleur', 'Saskia', 'Nienke', 'Marloes',
     'Ilse', 'Esmee', 'Roos', 'Lieke', 'Johanna', 'Cornelia', 'Willemien', 'Truus',
-    'Marijke', 'Annemiek', 'Wilma', 'Jantine', 'Gerda', 'Hanneke', 'Mieke', 'Els',
+    'Marijke', 'Annemiek', 'Wilma', 'Jantine', 'Gerda', 'Hanneke', 'Mieke', 'Annelies',
 ];
 /** Single-token forms only: multi-token surnames (van der ...) would
  *  break the token-count preservation guarantee of generatePerson. */
 const NL_SURNAMES = [
-    'Jansen', 'Bakker', 'Visser', 'Smit', 'Meijer', 'Mulder', 'Bos', 'Vos',
-    'Peters', 'Hendriks', 'Dekker', 'Brouwer', 'Dijkstra', 'Smits', 'Kuipers', 'Post',
-    'Kok', 'Verhoeven', 'Willems', 'Maas', 'Hermans', 'Timmermans', 'Schouten', 'Jacobs',
+    'Jansen', 'Bakker', 'Visser', 'Smit', 'Meijer', 'Mulder', 'Vermeulen', 'Koster',
+    'Peters', 'Hendriks', 'Dekker', 'Brouwer', 'Dijkstra', 'Smits', 'Kuipers', 'Hoekstra',
+    'Scholten', 'Verhoeven', 'Willems', 'Maas', 'Hermans', 'Timmermans', 'Schouten', 'Jacobs',
 ];
 const PT_FIRST_MALE = [
-    'Jo\u00e3o', 'Lu\u00eds', 'Paulo', 'Rui', 'Nuno', 'Tiago', 'Ricardo', 'Andr\u00e9',
+    'Jo\u00e3o', 'Lu\u00eds', 'Paulo', 'Guilherme', 'Nuno', 'Tiago', 'Ricardo', 'Andr\u00e9',
     'Diogo', 'Gon\u00e7alo', 'Vasco', 'Duarte', 'Afonso', 'Bernardo', 'Rodrigo', 'Ant\u00f3nio',
     'Manuel', 'Francisco', 'Carlos', 'Pedro', 'Miguel', 'Jos\u00e9', 'Henrique', 'Sim\u00e3o',
 ];
 const PT_FIRST_FEMALE = [
     'Catarina', 'Margarida', 'Mariana', 'Joana', 'Rita', 'Carolina', 'Leonor', 'Matilde',
     'Francisca', 'Madalena', 'Const\u00e2ncia', 'Louren\u00e7a', 'Gra\u00e7a', 'Concei\u00e7\u00e3o', 'Lurdes', 'In\u00eas',
-    'Beatriz', 'Isabel', 'Teresa', 'Sofia', 'Ana', 'Maria', 'Manuela', 'Fernanda',
+    'Beatriz', 'Isabel', 'Teresa', 'Sofia', 'Filipa', 'Maria', 'Manuela', 'Fernanda',
 ];
 const PT_SURNAMES = [
     'Silva', 'Santos', 'Ferreira', 'Pereira', 'Oliveira', 'Rodrigues', 'Martins', 'Sousa',
@@ -279,11 +291,11 @@ function feminizeUkSurname(surname) {
     return surname; // -енко/-ук/-як and similar are invariant
 }
 const SV_FIRST_MALE = [
-    'Erik', 'Lars', 'Karl', 'Anders', 'Johan', 'Per', 'Nils', 'Sven',
-    'Gunnar', 'Bo', '\u00c5ke', 'G\u00f6ran', 'Henrik', 'Magnus', 'Fredrik', 'Oskar',
+    'Erik', 'Lars', 'Karl', 'Anders', 'Johan', 'Mats', 'Nils', 'Sven',
+    'Gunnar', 'Olof', 'Bengt', 'G\u00f6ran', 'Henrik', 'Magnus', 'Fredrik', 'Oskar',
 ];
 const SV_FIRST_FEMALE = [
-    'Anna', 'Eva', 'Maria', 'Karin', 'Ingrid', 'Kerstin', 'Lena', 'Helena',
+    'Anna', 'Kristina', 'Maria', 'Karin', 'Ingrid', 'Kerstin', 'Lena', 'Helena',
     'Marianne', 'Birgitta', 'Elin', 'Sara', 'Emma', 'Linnea', 'Astrid', 'Ebba',
 ];
 const SV_SURNAMES = [
@@ -291,23 +303,23 @@ const SV_SURNAMES = [
     'Svensson', 'Gustafsson', 'Pettersson', 'Jonsson', 'Lindberg', 'Lindqvist', 'Bergstr\u00f6m', 'Sandberg',
 ];
 const NO_FIRST_MALE = [
-    'Ole', 'Lars', 'Knut', 'Bj\u00f8rn', 'Arne', 'Odd', 'Geir', 'Tor',
+    'Olav', 'Lars', 'Knut', 'Bj\u00f8rn', 'Arne', 'Einar', 'Geir', 'Sverre',
     'Terje', 'Kjell', 'Espen', 'H\u00e5kon', 'Sindre', 'Eirik', 'Trygve', 'Leif',
 ];
 const NO_FIRST_FEMALE = [
-    'Anne', 'Inger', 'Kari', 'Marit', 'Ingrid', 'Liv', 'Astrid', 'Solveig',
-    'Randi', 'Bj\u00f8rg', 'Silje', 'Mari', 'Ingeborg', 'Tone', 'Gunn', 'Sigrid',
+    'Anne', 'Inger', 'Kari', 'Marit', 'Ingrid', 'Hilde', 'Astrid', 'Solveig',
+    'Randi', 'Bj\u00f8rg', 'Silje', 'Mari', 'Ingeborg', 'Berit', 'Gunn', 'Sigrid',
 ];
 const NO_SURNAMES = [
     'Hansen', 'Johansen', 'Olsen', 'Larsen', 'Andersen', 'Pedersen', 'Nilsen', 'Kristiansen',
-    'Jensen', 'Karlsen', 'Berg', 'Haugen', 'Hagen', 'Solberg', 'Moen', 'Lien',
+    'Jensen', 'Karlsen', 'Berg', 'Haugen', 'Hagen', 'Solberg', 'Moen', 'Eide',
 ];
 const DA_FIRST_MALE = [
-    'Jens', 'Peter', 'Lars', 'Henrik', 'S\u00f8ren', 'Niels', 'Ole', 'Erik',
-    'Mads', 'Rasmus', 'Bent', 'Kaj', 'Frederik', 'Mikkel', 'Emil', 'Bjarne',
+    'Jens', 'Peter', 'Lars', 'Henrik', 'S\u00f8ren', 'Niels', 'Torben', 'Erik',
+    'Mads', 'Rasmus', 'Jesper', 'Morten', 'Frederik', 'Mikkel', 'Emil', 'Bjarne',
 ];
 const DA_FIRST_FEMALE = [
-    'Kirsten', 'Mette', 'Hanne', 'Lone', 'Bente', 'Karen', 'Dorthe', 'Pia',
+    'Kirsten', 'Mette', 'Hanne', 'Trine', 'Bente', 'Karen', 'Dorthe', 'Helle',
     'Gitte', 'Ditte', 'Freja', 'Signe', 'Maja', 'Cecilie', 'Louise', 'Astrid',
 ];
 const DA_SURNAMES = [

package/dist/worker-protocol.d.ts

@@ -21,7 +21,7 @@
  */
 import type { DetectedEntity } from './types.js';
 import type { DocCloakEngine, EngineSettings, ProviderId } from './engine.js';
-import type { RegexRegionId } from './regex/index.js';
+import { type RegexRegionId } from './regex/index.js';
 /** Satisfied by Worker, MessagePort and chrome.runtime.Port wrappers. */
 export interface PortLike {
     postMessage(msg: unknown): void;
@@ -90,6 +90,18 @@ export type EngineResponse = {
 } | {
     type: 'released';
     requestId?: number;
+}
+/**
+ * Protocol-level failure (T185, R12): a message the host could not act on
+ * (unknown type, wrong payload shape) or an error outside the dedicated
+ * load/detect replies. `fatal` marks a host that can no longer serve; the
+ * client then rejects every pending request and closes.
+ */
+ | {
+    type: 'error';
+    requestId?: number;
+    error: string;
+    fatal?: boolean;
 };
 /**
  * Serve a real engine over a port. Returns a stop function that

package/dist/worker-protocol.js

@@ -19,10 +19,83 @@
  * is the client side: a DocCloakEngine that forwards over the port (web
  * main thread, extension side panel / service worker).
  */
-import { clampThreshold, defaultThresholdFor } from "./engine.js";
+import { PROVIDERS, clampThreshold, defaultThresholdFor } from "./engine.js";
+import { REGEX_REGIONS } from "./regex/index.js";
 function errorMessage(err) {
     return err instanceof Error ? err.message : String(err);
 }
+// ── Message validation (R12) ───────────────────────────────
+const REQUEST_TYPES = new Set([
+    'init', 'detect', 'switchProvider', 'setThreshold', 'setCustomLabels', 'setRegex', 'setRegexRegion', 'releaseModel',
+]);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isProviderId(value) {
+    return typeof value === 'string' && PROVIDERS.some((p) => p.id === value);
+}
+function isRegexRegionId(value) {
+    return typeof value === 'string' && REGEX_REGIONS.includes(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function optionalRequestId(value) {
+    return isFiniteNumber(value) ? value : undefined;
+}
+/**
+ * Field-level validation of a message whose `type` is known. Returns a
+ * description of the first problem, or null when the payload is usable.
+ */
+function requestProblem(msg) {
+    switch (msg.type) {
+        case 'init':
+            if (msg.providerId !== undefined && !isProviderId(msg.providerId))
+                return 'providerId must be a known provider id';
+            if (msg.customLabels !== undefined && !isStringArray(msg.customLabels))
+                return 'customLabels must be an array of strings';
+            if (msg.regexEnabled !== undefined && typeof msg.regexEnabled !== 'boolean')
+                return 'regexEnabled must be a boolean';
+            if (msg.regexRegion !== undefined && !isRegexRegionId(msg.regexRegion))
+                return 'regexRegion must be a known region id';
+            return null;
+        case 'detect':
+            if (!isFiniteNumber(msg.requestId))
+                return 'requestId must be a number';
+            if (typeof msg.text !== 'string')
+                return 'text must be a string';
+            return null;
+        case 'switchProvider':
+            if (!isProviderId(msg.providerId))
+                return 'providerId must be a known provider id';
+            if (msg.customLabels !== undefined && !isStringArray(msg.customLabels))
+                return 'customLabels must be an array of strings';
+            return null;
+        case 'setThreshold':
+            if (!isFiniteNumber(msg.value))
+                return 'value must be a finite number';
+            return null;
+        case 'setCustomLabels':
+            if (!isStringArray(msg.labels))
+                return 'labels must be an array of strings';
+            return null;
+        case 'setRegex':
+            if (typeof msg.enabled !== 'boolean')
+                return 'enabled must be a boolean';
+            if (msg.region !== undefined && !isRegexRegionId(msg.region))
+                return 'region must be a known region id';
+            return null;
+        case 'setRegexRegion':
+            if (!isRegexRegionId(msg.region))
+                return 'region must be a known region id';
+            return null;
+        case 'releaseModel':
+            return null;
+    }
+}
 // ── Host side ──────────────────────────────────────────────
 /**
  * Serve a real engine over a port. Returns a stop function that
@@ -46,8 +119,37 @@ export function serveEngine(engine, port) {
             post({ type: 'loadError', requestId, error: errorMessage(err) });
         }
     }
-    const unsubscribeMessages = port.onMessage(async (raw) => {
-        const msg = raw;
+    /** Fire-and-forget settings message: failures are reported, never thrown. */
+    async function handleSetting(run) {
+        try {
+            await run();
+        }
+        catch (err) {
+            post({ type: 'error', error: errorMessage(err) });
+        }
+    }
+    /**
+     * Reject a message the host cannot act on. Requests with a dedicated
+     * error reply (init/switchProvider -> loadError, detect -> detectError)
+     * use it so legacy senders matching by type keep working; everything
+     * else gets the generic protocol error.
+     */
+    function rejectRequest(raw, problem) {
+        const msg = isRecord(raw) ? raw : {};
+        const requestId = optionalRequestId(msg.requestId);
+        const type = typeof msg.type === 'string' ? msg.type : undefined;
+        const error = type ? `Invalid ${type} message: ${problem}` : problem;
+        if (type === 'init' || type === 'switchProvider') {
+            post({ type: 'loadError', requestId, error });
+        }
+        else if (type === 'detect' && requestId !== undefined) {
+            post({ type: 'detectError', requestId, error });
+        }
+        else {
+            post({ type: 'error', requestId, error });
+        }
+    }
+    async function dispatch(msg) {
         switch (msg.type) {
             case 'init': {
                 await handleLoad(msg.requestId, async () => {
@@ -87,30 +189,65 @@ export function serveEngine(engine, port) {
                 break;
             }
             case 'setThreshold': {
-                await engine.updateSettings({ threshold: msg.value });
+                await handleSetting(() => engine.updateSettings({ threshold: msg.value }));
                 break;
             }
             case 'setCustomLabels': {
-                await engine.updateSettings({ customLabels: msg.labels });
+                await handleSetting(() => engine.updateSettings({ customLabels: msg.labels }));
                 break;
             }
             case 'setRegex': {
-                const patch = { regexEnabled: msg.enabled };
-                if (msg.region !== undefined)
-                    patch.regexRegion = msg.region;
-                await engine.updateSettings(patch);
+                await handleSetting(async () => {
+                    const patch = { regexEnabled: msg.enabled };
+                    if (msg.region !== undefined)
+                        patch.regexRegion = msg.region;
+                    await engine.updateSettings(patch);
+                });
                 break;
             }
             case 'setRegexRegion': {
-                await engine.updateSettings({ regexRegion: msg.region });
+                await handleSetting(() => engine.updateSettings({ regexRegion: msg.region }));
                 break;
             }
             case 'releaseModel': {
-                await engine.release();
-                post({ type: 'released', requestId: msg.requestId });
+                try {
+                    await engine.release();
+                    post({ type: 'released', requestId: msg.requestId });
+                }
+                catch (err) {
+                    post({ type: 'error', requestId: msg.requestId, error: errorMessage(err) });
+                }
                 break;
             }
         }
+    }
+    const unsubscribeMessages = port.onMessage(async (raw) => {
+        // R12: the port is same-origin but not trusted with the message shape.
+        // Anything that is not a well-formed request gets an error reply and
+        // never reaches the engine; nothing here may throw into the transport.
+        try {
+            if (!isRecord(raw) || typeof raw.type !== 'string') {
+                rejectRequest(raw, 'message must be an object with a string type');
+                return;
+            }
+            if (!REQUEST_TYPES.has(raw.type)) {
+                post({ type: 'error', requestId: optionalRequestId(raw.requestId), error: `Unknown message type: ${raw.type}` });
+                return;
+            }
+            const problem = requestProblem(raw);
+            if (problem) {
+                rejectRequest(raw, problem);
+                return;
+            }
+            await dispatch(raw);
+        }
+        catch (err) {
+            // Only reachable if posting a reply itself failed; report best-effort.
+            try {
+                post({ type: 'error', requestId: isRecord(raw) ? optionalRequestId(raw.requestId) : undefined, error: errorMessage(err) });
+            }
+            catch { /* transport gone */ }
+        }
     });
     return () => {
         unsubscribeMessages();
@@ -146,6 +283,10 @@ export function connectEngine(port, initial) {
         return entry;
     }
     const unsubscribe = port.onMessage((raw) => {
+        // Ignore anything that is not an object with a string type: the host is
+        // the only expected sender, but a malformed frame must not throw here.
+        if (!isRecord(raw) || typeof raw.type !== 'string')
+            return;
         const msg = raw;
         switch (msg.type) {
             case 'downloadProgress': {
@@ -182,6 +323,17 @@ export function connectEngine(port, initial) {
                 takePending(msg.requestId)?.resolve(undefined);
                 break;
             }
+            case 'error': {
+                const err = new Error(msg.error);
+                if (msg.fatal) {
+                    // The host cannot serve any further request: fail everything
+                    // that is still waiting instead of leaving promises hanging.
+                    close(err);
+                    break;
+                }
+                takePending(msg.requestId)?.reject(err);
+                break;
+            }
         }
     });
     function request(kind, message, onProgress) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccloak/core",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Environment-agnostic document anonymization engine for the DocCloak ecosystem.",
   "license": "Apache-2.0",
   "author": "Witold Lojek",

package/rules/at.json

@@ -36,7 +36,7 @@
     {
       "id": "regex:at:postal",
       "entityType": "ADDRESS",
-      "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+      "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
       "flags": "gu",
       "confidence": 0.8,
       "domains": [

package/rules/be.json

@@ -36,7 +36,7 @@
     {
       "id": "regex:be:postal",
       "entityType": "ADDRESS",
-      "pattern": "\\b[1-9]\\d{3}\\s+[\\p{L}][\\p{L}\\s'-]+\\b",
+      "pattern": "\\b[1-9]\\d{3}\\s+[\\p{L}][\\p{L}\\s'-]*[\\p{L}](?![\\p{L}\\p{N}])",
       "flags": "gu",
       "confidence": 0.75,
       "domains": [

package/rules/ch.json

@@ -32,7 +32,7 @@
     {
       "id": "regex:ch:postal-city",
       "entityType": "ADDRESS",
-      "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+      "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
       "flags": "gu",
       "confidence": 0.8,
       "domains": [

package/rules/de.json

@@ -97,7 +97,7 @@
     {
       "id": "regex:de:postal",
       "entityType": "ADDRESS",
-      "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+      "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
       "flags": "gu",
       "confidence": 0.8,
       "domains": [

package/rules/dk.json

@@ -31,7 +31,7 @@
     {
       "id": "regex:dk:postal-city",
       "entityType": "ADDRESS",
-      "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+      "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
       "flags": "gu",
       "confidence": 0.8,
       "domains": [

package/rules/es.json

@@ -80,7 +80,7 @@
     {
       "id": "regex:es:postal",
       "entityType": "ADDRESS",
-      "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s'-]+\\b",
+      "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s'-]*[\\p{L}](?![\\p{L}\\p{N}])",
       "flags": "gu",
       "confidence": 0.75,
       "domains": [

package/rules/fi.json

@@ -31,7 +31,7 @@
     {
       "id": "regex:fi:postal-city",
       "entityType": "ADDRESS",
-      "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+      "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
       "flags": "gu",
       "confidence": 0.8,
       "domains": [

package/rules/fr.json

@@ -99,7 +99,7 @@
     {
       "id": "regex:fr:postal",
       "entityType": "ADDRESS",
-      "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s'-]+\\b",
+      "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s'-]*[\\p{L}](?![\\p{L}\\p{N}])",
       "flags": "gu",
       "confidence": 0.8,
       "domains": [

package/rules/it.json

@@ -83,7 +83,7 @@
     {
       "id": "regex:it:postal",
       "entityType": "ADDRESS",
-      "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+      "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
       "flags": "gu",
       "confidence": 0.8,
       "domains": [

package/rules/no.json

@@ -69,7 +69,7 @@
     {
       "id": "regex:no:postal",
       "entityType": "ADDRESS",
-      "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+      "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
       "flags": "gu",
       "confidence": 0.8,
       "domains": [

package/rules/pl.json

@@ -116,7 +116,7 @@
     {
       "id": "regex:pl:postal",
       "entityType": "ADDRESS",
-      "pattern": "\\b\\d{2}-\\d{3}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+      "pattern": "\\b\\d{2}-\\d{3}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
       "flags": "gu",
       "confidence": 0.8,
       "domains": [

package/rules/pt.json

@@ -50,7 +50,7 @@
     {
       "id": "regex:pt:postal",
       "entityType": "ADDRESS",
-      "pattern": "\\b\\d{4}-\\d{3}\\s+[\\p{L}][\\p{L}\\s'-]+\\b",
+      "pattern": "\\b\\d{4}-\\d{3}\\s+[\\p{L}][\\p{L}\\s'-]*[\\p{L}](?![\\p{L}\\p{N}])",
       "flags": "gu",
       "confidence": 0.85,
       "domains": [