@stll/anonymize-wasm 1.2.0 → 1.3.0

package/dist/wasm.mjs

@@ -1,5 +1,5 @@
 import { TextSearch } from "@stll/text-search-wasm";
-import { at, be, bg, cy, cz, de, dk, ee, es, fi, fr, gb, gr, hr, hu, ie, it, lt, lu, lv, mt, nl, pl, pt, ro, se, si, sk } from "@stll/stdnum";
+import { at, be, bg, br, cy, cz, de, dk, ee, es, fi, fr, gb, gr, hr, hu, ie, it, lt, lu, lv, mt, nl, pl, pt, ro, se, si, sk } from "@stll/stdnum";
 import { toRegex } from "@stll/stdnum/patterns";
 //#region src/search-engine.ts
 let _TextSearch;
@@ -66,11 +66,15 @@ const DEFAULT_ENTITY_LABELS = [
 	"iban",
 	"tax identification number",
 	"identity card number",
+	"birth number",
+	"national identification number",
+	"social security number",
 	"registration number",
 	"credit card number",
 	"passport number",
 	"monetary amount",
-	"land parcel"
+	"land parcel",
+	"misc"
 ];
 const isLegalFormsEnabled = (config) => config.enableLegalForms !== false;
 //#endregion
@@ -95,6 +99,8 @@ const createPipelineContext = () => ({
 	allowListPromise: null,
 	personStopwords: null,
 	personStopwordsPromise: null,
+	addressStopwords: null,
+	addressStopwordsPromise: null,
 	firstNameExclusions: null,
 	firstNameExclusionCorpusLen: 0,
 	genericRoles: null,
@@ -151,6 +157,7 @@ const LOADER_REGISTRIES = {
 		hu: () => import("./triggers.hu.mjs"),
 		it: () => import("./triggers.it.mjs"),
 		pl: () => import("./triggers.pl.mjs"),
+		"pt-br": () => import("./triggers.pt-br.mjs"),
 		ro: () => import("./triggers.ro.mjs"),
 		sk: () => import("./triggers.sk.mjs"),
 		sv: () => import("./triggers.sv.mjs")
@@ -159,7 +166,23 @@ const LOADER_REGISTRIES = {
 		cs: () => import("./coreference.cs.mjs"),
 		de: () => import("./coreference.de.mjs"),
 		en: () => import("./coreference.en.mjs"),
+		es: () => import("./coreference.es.mjs"),
+		fr: () => import("./coreference.fr.mjs"),
+		it: () => import("./coreference.it.mjs"),
+		pl: () => import("./coreference.pl.mjs"),
+		"pt-br": () => import("./coreference.pt-br.mjs"),
 		sk: () => import("./coreference.sk.mjs")
+	},
+	legalRoleHeads: {
+		cs: () => import("./legal-role-heads.cs.mjs"),
+		de: () => import("./legal-role-heads.de.mjs"),
+		en: () => import("./legal-role-heads.en.mjs"),
+		es: () => import("./legal-role-heads.es.mjs"),
+		fr: () => import("./legal-role-heads.fr.mjs"),
+		it: () => import("./legal-role-heads.it.mjs"),
+		pl: () => import("./legal-role-heads.pl.mjs"),
+		"pt-br": () => import("./legal-role-heads.pt-br.mjs"),
+		sk: () => import("./legal-role-heads.sk.mjs")
 	}
 };
 const FALLBACK_LANGUAGES = {
@@ -172,6 +195,7 @@ const FALLBACK_LANGUAGES = {
 		"hu",
 		"it",
 		"pl",
+		"pt-br",
 		"ro",
 		"sk",
 		"sv"
@@ -180,6 +204,22 @@ const FALLBACK_LANGUAGES = {
 		"cs",
 		"de",
 		"en",
+		"es",
+		"fr",
+		"it",
+		"pl",
+		"pt-br",
+		"sk"
+	],
+	legalRoleHeads: [
+		"cs",
+		"de",
+		"en",
+		"es",
+		"fr",
+		"it",
+		"pl",
+		"pt-br",
 		"sk"
 	]
 };
@@ -226,838 +266,64 @@ const loadLanguageConfigs = async (configType, mapFn) => {
 	await Promise.all(loads);
 	return results.filter((r) => r !== void 0);
 };
-//#endregion
-//#region src/detectors/coreference.ts
-/**
-* Load coreference definition patterns from per-language
-* JSON configs in src/data/. Uses the
-* language manifest for auto-discovery.
-*/
-const loadDefinitionPatterns = async () => {
-	const patterns = [];
-	const allRows = await loadLanguageConfigs("coreference", (mod) => {
-		return mod.default ?? mod;
-	});
-	for (const rows of allRows) {
-		if (!Array.isArray(rows)) {
-			console.warn("[anonymize] coreference: unexpected config shape, skipping");
-			continue;
-		}
-		for (const row of rows) try {
-			patterns.push({ pattern: new RegExp(row.pattern, row.flags) });
-		} catch (err) {
-			console.warn(`[anonymize] coreference: invalid regex "${row.pattern}":`, err);
-		}
-	}
-	return patterns;
-};
-/**
-* Load generic role terms that should NOT be treated
-* as PII coreferences. "Prodávající" (Seller),
-* "Kupující" (Buyer), etc. are legal roles, not
-* identifying information.
-*/
-const getRoleStopSet = async (ctx) => {
-	if (ctx.roleStopSet) return ctx.roleStopSet;
-	if (ctx.roleStopSetPromise) return ctx.roleStopSetPromise;
-	const promise = (async () => {
-		let result;
-		try {
-			const mod = await import("./generic-roles.mjs");
-			const data = mod.default ?? mod;
-			result = new Set(data.roles.map((r) => r.toLowerCase()));
-		} catch {
-			result = /* @__PURE__ */ new Set();
-		}
-		ctx.roleStopSet = result;
-		return result;
-	})();
-	ctx.roleStopSetPromise = promise;
-	return promise;
-};
-const getDefinitionPatterns = async (ctx) => {
-	if (ctx.corefPatterns) return ctx.corefPatterns;
-	if (ctx.corefPatternsPromise) return ctx.corefPatternsPromise;
-	ctx.corefPatternsPromise = loadDefinitionPatterns();
-	const patterns = await ctx.corefPatternsPromise;
-	if (patterns.length === 0) {
-		ctx.corefPatterns = patterns;
-		if (!ctx.corefLoadAttempted) {
-			ctx.corefLoadAttempted = true;
-			console.warn("[anonymize] coreference: no definition patterns loaded; coreference detection will be inactive");
-		}
-		return patterns;
-	}
-	ctx.corefPatterns = patterns;
-	return patterns;
-};
-const SEARCH_WINDOW = 200;
-/**
-* Check whether an alias has textual similarity to
-* the source entity. Prevents roles and structural
-* terms from being treated as name aliases.
-*
-* Three checks (any passes → similar):
-* 1. Word overlap: a word in the alias appears in the
-*    entity (case-insensitive, min 2 chars)
-* 2. Initials: alias letters match first letters of
-*    entity words ("TB" ↔ "Tomas Bata")
-* 3. Substring: alias is a substring of the entity
-*    or vice versa (min 3 chars)
-*/
-const hasEntitySimilarity = (alias, entityText) => {
-	const aliasLower = alias.toLowerCase();
-	const entityLower = entityText.toLowerCase();
-	if (aliasLower.length >= 3 && entityLower.includes(aliasLower)) return true;
-	if (entityLower.length >= 3 && aliasLower.includes(entityLower)) return true;
-	const aliasWords = aliasLower.split(/[\s.,;:'"()/-]+/).filter((w) => w.length >= 2);
-	const entityWords = entityLower.split(/[\s.,;:'"()/-]+/).filter((w) => w.length >= 2);
-	const entityWordSet = new Set(entityWords);
-	for (const word of aliasWords) if (entityWordSet.has(word)) return true;
-	if (/^[\p{Lu}]+$/u.test(alias) && alias.length >= 2 && alias.length <= entityWords.length) {
-		for (let start = 0; start <= entityWords.length - alias.length; start++) if (entityWords.slice(start, start + alias.length).map((w) => w.charAt(0)).join("") === aliasLower) return true;
-	}
-	return false;
-};
-/**
-* Scan for defined-term patterns near known entities.
-*
-* Legal documents universally follow:
-*   "Dr. Heinrich Muller (hereinafter 'the Seller')..."
-*
-* After NER detects the entity, this function scans for
-* definitional patterns within +/-200 chars and extracts
-* the alias. Returns alias + label pairs that can be added
-* to the gazetteer for a full-text re-scan.
-*/
-/**
-* Labels that can be the source of a coreference alias.
-* Only parties (person, organization) have defined-term
-* aliases in legal text. Dates, addresses, IDs do not.
-*/
-const COREF_SOURCE_LABELS = new Set(["person", "organization"]);
-const extractDefinedTerms = async (fullText, entities, ctx = defaultContext) => {
-	const [definitionPatterns, roleStops] = await Promise.all([getDefinitionPatterns(ctx), getRoleStopSet(ctx)]);
-	const terms = [];
-	const seen = /* @__PURE__ */ new Set();
-	const sorted = [...entities].sort((a, b) => a.start - b.start);
-	for (const { pattern } of definitionPatterns) {
-		pattern.lastIndex = 0;
-		for (let match = pattern.exec(fullText); match !== null; match = pattern.exec(fullText)) {
-			const alias = match[1]?.trim();
-			if (!alias || alias.length < 2) continue;
-			if (roleStops.has(alias.toLowerCase())) continue;
-			const defPos = match.index;
-			let bestEntity = null;
-			for (let i = sorted.length - 1; i >= 0; i--) {
-				const e = sorted[i];
-				if (e === void 0) continue;
-				if (e.end > defPos) continue;
-				if (defPos - e.end > SEARCH_WINDOW) break;
-				if (!COREF_SOURCE_LABELS.has(e.label)) continue;
-				bestEntity = e;
-				break;
-			}
-			if (bestEntity === null) continue;
-			const gapText = fullText.slice(bestEntity.end, defPos);
-			if (/(?:;|\.(?=\s*(?:["'„‚(]*\p{Lu}|$)))/u.test(gapText)) continue;
-			if (!hasEntitySimilarity(alias, bestEntity.text)) continue;
-			const key = `${alias.toLowerCase()}::${bestEntity.label}`;
-			if (seen.has(key)) continue;
-			seen.add(key);
-			terms.push({
-				alias,
-				label: bestEntity.label,
-				definitionStart: defPos,
-				sourceText: bestEntity.text
-			});
-		}
-	}
-	return terms;
-};
-/**
-* Check if a character is a Unicode word character
-* (letter, digit, or combining mark). Used for word
-* boundary checks in coreference matching.
-*/
-const isWordChar = (ch) => {
-	if (ch === void 0) return false;
-	return /[\p{L}\p{M}\p{N}]/u.test(ch);
-};
-/**
-* Find all occurrences of defined-term aliases in the
-* full text. Returns Entity spans for each match.
-*
-* Respects word boundaries: "Kupující" must not match
-* inside "Kupujícímu". A match is valid only if the
-* character before the start and after the end are NOT
-* word characters (letter/digit).
-*
-* Populates `ctx.corefSourceMap` with entries linking
-* each coref entity to its source entity text, for
-* consistent placeholder numbering.
-*/
-const findCoreferenceSpans = (fullText, terms, ctx = defaultContext) => {
-	const results = [];
-	for (const term of terms) {
-		let searchFrom = 0;
-		while (searchFrom < fullText.length) {
-			const idx = fullText.indexOf(term.alias, searchFrom);
-			if (idx === -1) break;
-			const matchEnd = idx + term.alias.length;
-			const charBefore = idx > 0 ? fullText[idx - 1] : void 0;
-			const charAfter = fullText[matchEnd];
-			if (isWordChar(charBefore) || isWordChar(charAfter)) {
-				searchFrom = idx + 1;
-				continue;
-			}
-			const entity = {
-				start: idx,
-				end: matchEnd,
-				label: term.label,
-				text: term.alias,
-				score: .95,
-				source: DETECTION_SOURCES.COREFERENCE
-			};
-			ctx.corefSourceMap.set(corefKey(entity), term.sourceText);
-			results.push(entity);
-			searchFrom = matchEnd;
-		}
-	}
-	return results;
-};
-//#endregion
-//#region src/detectors/gazetteer.ts
-const MAX_EDIT_DISTANCE = 2;
-const MIN_FUZZY_LENGTH = 4;
-const MAX_PREFIX_OVERSHOOT = 7;
-/**
-* Collect all searchable strings (canonical + variants)
-* from gazetteer entries, mapped to their labels and
-* entry IDs.
-*/
-const buildSearchTerms = (entries) => {
-	const terms = /* @__PURE__ */ new Map();
-	for (const entry of entries) {
-		const meta = {
-			label: entry.label,
-			entryId: entry.id
-		};
-		terms.set(entry.canonical, meta);
-		for (const variant of entry.variants) terms.set(variant, meta);
-	}
-	return terms;
-};
-/**
-* Build TextSearch-compatible patterns from gazetteer
-* entries. Returns:
-* - Exact literal patterns for all terms
-* - Fuzzy patterns (distance: 2) for terms >= 4 chars
-* - Parallel metadata arrays for post-processing
-*
-* Patterns are ordered: all exact first, then all
-* fuzzy. The isFuzzy array marks which are which.
-*/
-const buildGazetteerPatterns = (entries) => {
-	const terms = buildSearchTerms(entries);
-	const patterns = [];
-	const labels = [];
-	const isFuzzy = [];
-	for (const [term, meta] of terms) {
-		patterns.push({
-			pattern: term,
-			literal: true,
-			wholeWords: false
-		});
-		labels.push(meta.label);
-		isFuzzy.push(false);
-	}
-	for (const [term, meta] of terms) {
-		if (term.length < MIN_FUZZY_LENGTH) continue;
-		patterns.push({
-			pattern: term,
-			distance: MAX_EDIT_DISTANCE
-		});
-		labels.push(meta.label);
-		isFuzzy.push(true);
-	}
-	return {
-		patterns,
-		data: {
-			labels,
-			isFuzzy
-		}
-	};
-};
-/**
-* Process gazetteer matches from the unified literal
-* search. Receives all matches; filters to the
-* gazetteer slice via sliceStart/sliceEnd.
-*
-* Exact matches get score 0.9; fuzzy matches get
-* 0.85. Fuzzy matches that overlap an exact match
-* are dropped.
-*
-* For exact matches, attempts prefix extension for
-* legal suffixes ("a.s.", "GmbH", "s.r.o." after
-* the matched term).
-*/
-const processGazetteerMatches = (allMatches, sliceStart, sliceEnd, fullText, data) => {
-	const results = [];
-	const exactSpans = [];
-	for (const match of allMatches) {
-		const idx = match.pattern;
-		if (idx < sliceStart || idx >= sliceEnd) continue;
-		const localIdx = idx - sliceStart;
-		if (data.isFuzzy[localIdx]) continue;
-		const label = data.labels[localIdx];
-		if (!label) continue;
-		const extended = tryPrefixExtension(fullText, match.start, match.end);
-		const end = extended?.end ?? match.end;
-		const text = extended?.text ?? fullText.slice(match.start, match.end);
-		exactSpans.push({
-			start: match.start,
-			end
-		});
-		results.push({
-			start: match.start,
-			end,
-			label,
-			text,
-			score: .9,
-			source: DETECTION_SOURCES.GAZETTEER
-		});
-	}
-	for (const match of allMatches) {
-		const idx = match.pattern;
-		if (idx < sliceStart || idx >= sliceEnd) continue;
-		const localIdx = idx - sliceStart;
-		if (!data.isFuzzy[localIdx]) continue;
-		if (match.distance === 0) continue;
-		const label = data.labels[localIdx];
-		if (!label) continue;
-		if (exactSpans.some((e) => match.start < e.end && match.end > e.start)) continue;
-		const matchText = fullText.slice(match.start, match.end);
-		results.push({
-			start: match.start,
-			end: match.end,
-			label,
-			text: matchText,
-			score: .85,
-			source: DETECTION_SOURCES.GAZETTEER
-		});
-	}
-	return results;
-};
-/**
-* Try to extend an exact match to capture one
-* trailing token (max 6 chars) that may be a legal
-* entity suffix (e.g., "a.s.", "GmbH", "s.r.o.").
-*
-* Does not validate the token against a legal-forms
-* list; false extensions are filtered by mergeAndDedup
-* when a legal-form detector produces a competing
-* entity with the correct span.
-*/
-const tryPrefixExtension = (fullText, start, end) => {
-	const maxEnd = Math.min(end + MAX_PREFIX_OVERSHOOT, fullText.length);
-	if (maxEnd <= end + 1) return null;
-	const after = fullText.slice(end, maxEnd);
-	if (!after.startsWith(" ")) return null;
-	const nextSpace = after.indexOf(" ", 1);
-	const suffixEnd = nextSpace !== -1 ? nextSpace : after.length;
-	if (suffixEnd <= 1) return null;
-	const newEnd = end + suffixEnd;
-	return {
-		end: newEnd,
-		text: fullText.slice(start, newEnd)
-	};
-};
-//#endregion
-//#region src/util/text.ts
-/**
-* Shared text utilities for detectors.
-*
-* Extracted from names.ts and deny-list.ts to avoid
-* duplicating regex constants and helper functions.
-*/
-/** Matches a string that starts with an uppercase letter. */
-const UPPER_START_RE = /^\p{Lu}/u;
-/** Matches a string consisting entirely of uppercase letters. */
-const ALL_UPPER_RE = /^\p{Lu}+$/u;
-const SENTENCE_END_RE = /[.!?]/;
-/**
-* Detect whether a position is at the start of a sentence.
-* Looks backward past whitespace for sentence-ending
-* punctuation (.!?). Position 0 and positions preceded
-* only by whitespace are considered sentence starts.
-*/
-const isSentenceStart = (text, pos) => {
-	if (pos === 0) return true;
-	let i = pos - 1;
-	while (i >= 0 && /\s/.test(text[i] ?? "")) i--;
-	if (i < 0) return true;
-	return SENTENCE_END_RE.test(text[i] ?? "");
-};
-//#endregion
-//#region src/detectors/names.ts
-const getCorpus = (ctx) => ctx.nameCorpus;
-const getNameCorpusFirstNames = (ctx = defaultContext) => ctx.nameCorpus?.firstNamesList ?? [];
-const getNameCorpusSurnames = (ctx = defaultContext) => ctx.nameCorpus?.surnamesList ?? [];
-const getNameCorpusTitles = (ctx = defaultContext) => ctx.nameCorpus?.titlesList ?? [];
-/**
-* Load name corpus data from injected dictionaries
-* and legacy config files. Merges all sources.
-*
-* Safe to call multiple times; only loads once per
-* context. Must be called before detectNameCorpus or
-* the getNameCorpus*() accessors are used.
-*
-* @param dictionaries Optional pre-loaded dictionaries
-*   with per-language first names and surnames. When
-*   omitted, only legacy config files are used.
-*/
-const initNameCorpus = (ctx = defaultContext, dictionaries) => {
-	if (ctx.nameCorpusPromise) return ctx.nameCorpusPromise;
-	const promise = (async () => {
-		try {
-			const [legacyFirstMod, legacySurnameMod, titleMod, exclusionMod] = await Promise.all([
-				import("./names-first.mjs"),
-				import("./names-surnames.mjs"),
-				import("./names-title-tokens.mjs"),
-				import("./names-exclusions.mjs")
-			]);
-			const firstNames = [...legacyFirstMod.default.names];
-			if (dictionaries?.firstNames) for (const names of Object.values(dictionaries.firstNames)) for (const name of names) firstNames.push(name);
-			const surnames = [...legacySurnameMod.default.names];
-			if (dictionaries?.surnames) for (const names of Object.values(dictionaries.surnames)) for (const name of names) surnames.push(name);
-			const dedup = (arr) => {
-				const seen = /* @__PURE__ */ new Set();
-				const result = [];
-				for (const item of arr) {
-					if (seen.has(item)) continue;
-					seen.add(item);
-					result.push(item);
-				}
-				return result;
-			};
-			const dedupFirst = dedup(firstNames);
-			const dedupSurnames = dedup(surnames);
-			const titles = titleMod.default.tokens;
-			const exclusions = exclusionMod.default.words;
-			ctx.nameCorpus = {
-				firstNames: Object.freeze(new Set(dedupFirst)),
-				surnames: Object.freeze(new Set(dedupSurnames)),
-				titleTokens: Object.freeze(new Set(titles)),
-				excludedWords: Object.freeze(new Set(exclusions)),
-				firstNamesList: Object.freeze(dedupFirst),
-				surnamesList: Object.freeze(dedupSurnames),
-				titlesList: Object.freeze(titles),
-				excludedList: Object.freeze(exclusions)
-			};
-		} catch (err) {
-			ctx.nameCorpusPromise = null;
-			console.warn("[anonymize] Failed to load name corpus JSON — name detection disabled:", err);
-		}
-	})();
-	ctx.nameCorpusPromise = promise;
-	return promise;
-};
-const INFLECTION_SUFFIXES = [
-	"ovi",
-	"em",
-	"om",
-	"ou",
-	"é",
-	"a",
-	"u"
-];
-/**
-* Strip common Czech/Slovak case suffixes from a token.
-* Returns candidate base forms if stripping produces a
-* plausible name (capitalised, length >= 3).
-*
-* For the "-ou" instrumental feminine suffix, also yields
-* base + "a" (e.g., "Editou" → "Edit" and "Edita")
-* because Czech feminine names decline -a → -ou.
-*/
-const stripInflection = (token) => {
-	const candidates = [];
-	for (const suffix of INFLECTION_SUFFIXES) if (token.length > suffix.length + 2 && token.endsWith(suffix)) {
-		const base = token.slice(0, -suffix.length);
-		if (/^\p{Lu}/u.test(base)) {
-			candidates.push(base);
-			if (suffix === "ou" || suffix === "é" || suffix === "u") candidates.push(`${base}a`);
-		}
-	}
-	return candidates;
-};
-const TOKEN_TYPE = {
-	NAME: "name",
-	SURNAME: "surname",
-	TITLE: "title",
-	ABBREVIATION: "abbreviation",
-	CAPITALIZED: "capitalized",
-	OTHER: "other"
-};
-const PERSON_CHAIN_BREAK_RE$1 = /[!?;:]/u;
-const isInitialContinuationGap$1 = (text, gap) => /^\p{Lu}$/u.test(text) && /^\.[^\S\n]{1,2}$/u.test(gap) || /^[^\S\n]{1,2}(?:\p{Lu}\.[^\S\n]{1,2})+$/u.test(gap);
-/**
-* Check if a token is in the first-name set, either
-* directly or after stripping Czech/Slovak inflection.
-*/
-const isFirstNameToken = (token, corpus) => {
-	if (corpus.firstNames.has(token)) return true;
-	return stripInflection(token).some((b) => corpus.firstNames.has(b));
-};
-/**
-* Check if a token is in the surname set, either
-* directly or after stripping Czech/Slovak inflection.
-*/
-const isSurnameToken = (token, corpus) => {
-	if (corpus.surnames.has(token)) return true;
-	return stripInflection(token).some((b) => corpus.surnames.has(b));
-};
-/**
-* Check if a token looks like a single-letter
-* abbreviation: "J.", "M.", etc.
-*/
-const isAbbreviation = (token) => token.length === 2 && /^\p{Lu}$/u.test(token[0] ?? "") && token[1] === ".";
-const segmenter$1 = new Intl.Segmenter(void 0, { granularity: "word" });
-/**
-* Split text into word segments using Intl.Segmenter.
-* Only returns segments flagged as words.
-*/
-const segmentWords = (fullText) => {
-	const words = [];
-	for (const seg of segmenter$1.segment(fullText)) if (seg.isWordLike) words.push({
-		text: seg.segment,
-		start: seg.index,
-		end: seg.index + seg.segment.length
-	});
-	return words;
-};
-/** NAME or SURNAME — both represent corpus-matched tokens */
-const isCorpusMatch = (type) => type === TOKEN_TYPE.NAME || type === TOKEN_TYPE.SURNAME;
-const classifyToken = (word, corpus) => {
-	const { text, start, end } = word;
-	const lower = text.toLowerCase();
-	const stripped = text.endsWith(".") ? text.slice(0, -1).toLowerCase() : lower;
-	if (corpus.titleTokens.has(stripped)) return {
-		text,
-		type: TOKEN_TYPE.TITLE,
-		start,
-		end
-	};
-	if (isAbbreviation(text)) return {
-		text,
-		type: TOKEN_TYPE.ABBREVIATION,
-		start,
-		end
-	};
-	if (corpus.excludedWords.has(lower)) return {
-		text,
-		type: TOKEN_TYPE.OTHER,
-		start,
-		end
-	};
-	if (text.length < 3) return {
-		text,
-		type: TOKEN_TYPE.OTHER,
-		start,
-		end
-	};
-	if (text.length > 3 && ALL_UPPER_RE.test(text)) return {
-		text,
-		type: TOKEN_TYPE.OTHER,
-		start,
-		end
-	};
-	if (!UPPER_START_RE.test(text)) return {
-		text,
-		type: TOKEN_TYPE.OTHER,
-		start,
-		end
-	};
-	if (isFirstNameToken(text, corpus)) return {
-		text,
-		type: TOKEN_TYPE.NAME,
-		start,
-		end
-	};
-	if (isSurnameToken(text, corpus)) return {
-		text,
-		type: TOKEN_TYPE.SURNAME,
-		start,
-		end
-	};
-	return {
-		text,
-		type: TOKEN_TYPE.CAPITALIZED,
-		start,
-		end
-	};
-};
-/**
-* Detect person names by looking up tokens against the
-* name corpus, then chaining adjacent name-like tokens.
-*
-* Requires initNameCorpus() to have been called first.
-* If not initialized, returns an empty array.
-*
-* Scoring:
-*   TITLE + NAME/SURNAME       → 0.95
-*   NAME + NAME/SURNAME        → 0.9
-*   SURNAME + NAME/SURNAME     → 0.9
-*   NAME + CAPITALIZED         → 0.7
-*   ABBREVIATION + NAME        → 0.7
-*   Standalone NAME            → 0.5 (low confidence)
-*   Standalone SURNAME         → skip (too ambiguous)
-*/
-const detectNameCorpus = (fullText, ctx = defaultContext) => {
-	const corpus = getCorpus(ctx);
-	if (!corpus) return [];
-	const tokens = segmentWords(fullText).map((w) => classifyToken(w, corpus));
-	const entities = [];
-	const consumed = /* @__PURE__ */ new Set();
-	for (let i = 0; i < tokens.length; i++) {
-		if (consumed.has(i)) continue;
-		const token = tokens[i];
-		if (!token) continue;
-		if (token.type !== TOKEN_TYPE.TITLE && token.type !== TOKEN_TYPE.NAME && token.type !== TOKEN_TYPE.SURNAME && token.type !== TOKEN_TYPE.ABBREVIATION) continue;
-		const MAX_CHAIN = 5;
-		const chain = [token];
-		let j = i + 1;
-		while (j < tokens.length && chain.length < MAX_CHAIN) {
-			const next = tokens[j];
-			if (!next) break;
-			const prev = chain.at(-1);
-			if (prev) {
-				const gap = fullText.slice(prev.end, next.start);
-				const breaksOnPeriod = gap.includes(".") && !isInitialContinuationGap$1(prev.text, gap);
-				if (gap.includes("\n") || PERSON_CHAIN_BREAK_RE$1.test(gap) || breaksOnPeriod) break;
-			}
-			if (next.type === TOKEN_TYPE.NAME || next.type === TOKEN_TYPE.SURNAME || next.type === TOKEN_TYPE.TITLE || next.type === TOKEN_TYPE.ABBREVIATION || next.type === TOKEN_TYPE.CAPITALIZED) {
-				chain.push(next);
-				j++;
-			} else break;
-		}
-		const hasTitle = chain.some((t) => t.type === TOKEN_TYPE.TITLE);
-		const hasCorpusName = chain.some((t) => isCorpusMatch(t.type));
-		const hasFirstName = chain.some((t) => t.type === TOKEN_TYPE.NAME);
-		const hasAbbreviation = chain.some((t) => t.type === TOKEN_TYPE.ABBREVIATION);
-		const corpusCount = chain.filter((t) => isCorpusMatch(t.type)).length;
-		const capitalizedCount = chain.filter((t) => t.type === TOKEN_TYPE.CAPITALIZED).length;
-		let score = 0;
-		if (hasTitle && hasCorpusName) score = .95;
-		else if (corpusCount >= 2) score = .9;
-		else if (hasCorpusName && capitalizedCount > 0) score = .7;
-		else if (hasAbbreviation && hasCorpusName) score = .7;
-		else if (hasFirstName && chain.length === 1) {
-			if (isSentenceStart(fullText, token.start)) continue;
-			score = .5;
-		} else if (!hasFirstName && chain.length === 1 && chain[0]?.type === TOKEN_TYPE.SURNAME) continue;
-		else if (hasTitle && chain.length === 1) continue;
-		else {
-			if (!hasCorpusName) continue;
-			score = .5;
-		}
-		const first = chain.at(0);
-		const last = chain.at(-1);
-		if (!first || !last) continue;
-		const start = first.start;
-		const end = last.end;
-		const text = fullText.slice(start, end);
-		for (let k = i; k < i + chain.length; k++) consumed.add(k);
-		entities.push({
-			start,
-			end,
-			label: "person",
-			text,
-			score,
-			source: DETECTION_SOURCES.REGEX
-		});
-	}
-	return entities;
-};
-//#endregion
-//#region src/config/titles.ts
-/**
-* Academic and professional title prefixes.
-* Plain text; the detector auto-escapes for regex.
-* Sorted longest-first at build time.
-*/
-const TITLE_PREFIXES = [
-	"Ing.",
-	"Mgr.",
-	"MgA.",
-	"Bc.",
-	"BcA.",
-	"JUDr.",
-	"MUDr.",
-	"MVDr.",
-	"MDDr.",
-	"PhDr.",
-	"RNDr.",
-	"PaedDr.",
-	"ThDr.",
-	"ThLic.",
-	"ICDr.",
-	"RSDr.",
-	"PharmDr.",
-	"artD.",
-	"akad.",
-	"doc.",
-	"prof.",
-	"ao. Univ.-Prof.",
-	"o. Univ.-Prof.",
-	"Univ.-Prof.",
-	"Hon.-Prof.",
-	"em. Prof.",
-	"Dr. med. dent.",
-	"Dr. med. vet.",
-	"Dr. med.",
-	"Dr. rer. nat.",
-	"Dr. rer. soc.",
-	"Dr. rer. pol.",
-	"Dr. sc. tech.",
-	"Dr. sc. nat.",
-	"Dr. sc. hum.",
-	"Dr. iur.",
-	"Dr. jur.",
-	"Dr. theol.",
-	"Dr. oec.",
-	"Dr. techn.",
-	"Dr. h. c.",
-	"Dr. phil.",
-	"Dr.-Ing.",
-	"Dr. Ing.",
-	"Dr.",
-	"Dipl.-Wirt.-Ing.",
-	"Dipl.-Betriebsw.",
-	"Dipl.-Inform.",
-	"Dipl.-Volksw.",
-	"Dipl.-Psych.",
-	"Dipl.-Phys.",
-	"Dipl.-Chem.",
-	"Dipl.-Biol.",
-	"Dipl.-Math.",
-	"Dipl.-Päd.",
-	"Dipl.-Soz.",
-	"Dipl.-Kfm.",
-	"Dipl.-Jur.",
-	"Dipl. Ing.",
-	"Dipl.-Ing.",
-	"Mag. rer. soc. oec.",
-	"Mag. rer. nat.",
-	"Mag. phil.",
-	"Mag. iur.",
-	"Mag. arch.",
-	"Mag. pharm.",
-	"Mag. (FH)",
-	"Mag.",
-	"Bakk. rer. nat.",
-	"Bakk. techn.",
-	"Bakk. phil.",
-	"Bakk.",
-	"Lic. phil.",
-	"Lic. iur.",
-	"Lic. oec.",
-	"Lic. theol.",
-	"Lic.",
-	"Priv.-Doz.",
-	"PD",
-	"RA"
-];
-/**
-* Courtesy/honorific titles that precede a person's
-* name. Sorted alphabetically. The detector escapes
-* dots and adds \b for entries in HONORIFIC_BOUNDARY.
-*/
-const HONORIFICS = [
-	"Avv.",
-	"Dame",
-	"Doamna",
-	"Domnul",
-	"Don",
-	"Doña",
-	"Dott.",
-	"Judge",
-	"Justice",
-	"Lady",
-	"Lord",
-	"M.",
-	"Madame",
-	"Mademoiselle",
-	"Maître",
-	"Me",
-	"Messrs",
-	"Miss",
-	"Mlle",
-	"Mme",
-	"Monsieur",
-	"Mr",
-	"Mrs",
-	"Ms",
-	"President",
-	"Señor",
-	"Señora",
-	"Sig.",
-	"Sig.ra",
-	"Signor",
-	"Signora",
-	"Signorina",
-	"Sir",
-	"Sr.",
-	"Sra."
-];
-/**
-* Honorifics that need \b word-boundary anchors
-* (short or common words that could match mid-word).
-*/
-const HONORIFIC_BOUNDARY = new Set([
-	"Don",
-	"Doña",
-	"M.",
-	"Me",
-	"Señor",
-	"Señora"
-]);
-/**
-* Post-nominal degrees (comma or space separated after name).
-* Plain text; the detector auto-escapes for regex.
-*/
-const POST_NOMINALS = [
-	"Ph.D.",
-	"Ph.D",
-	"CSc.",
-	"DrSc.",
-	"ArtD.",
-	"D.Phil.",
-	"DPhil.",
-	"MPhil.",
-	"MBA",
-	"MPA",
-	"LL.M.",
-	"LL.B.",
-	"M.Sc.",
-	"B.Sc.",
-	"MSc.",
-	"BSc.",
-	"M.Eng.",
-	"B.Eng.",
-	"M.A.",
-	"B.A.",
-	"JCD",
-	"JD",
-	"DiS.",
-	"ACCA",
-	"FCCA",
-	"CIPM",
-	"CIPT",
-	"CIPP/E",
-	"CIPP"
-];
+const LEGAL_SUFFIXES = [...[
+	"spol. s r.o.",
+	"s.r.o.",
+	"s. r. o.",
+	"a.s.",
+	"a. s.",
+	"v.o.s.",
+	"v. o. s.",
+	"k.s.",
+	"k. s.",
+	"z.s.",
+	"z. s.",
+	"z.ú.",
+	"z. ú.",
+	"o.p.s.",
+	"o. p. s.",
+	"s.p.",
+	"s. p.",
+	"GmbH",
+	"AG",
+	"SE",
+	"KG",
+	"OHG",
+	"Ltd.",
+	"Ltd",
+	"LLC",
+	"LLP",
+	"Inc.",
+	"Corp.",
+	"Corporation",
+	"Co.",
+	"LP",
+	"L.P.",
+	"PLC",
+	"plc",
+	"N.A.",
+	"N.V.",
+	"B.V.",
+	"Pty Ltd.",
+	"Pty Ltd",
+	"S.A.",
+	"SA",
+	"SAS",
+	"SARL",
+	"S.p.A.",
+	"Sp. z o.o.",
+	"Sp. k.",
+	"Sp. j.",
+	"Ltda.",
+	"LTDA.",
+	"Ltda",
+	"LTDA",
+	"S/A",
+	"EIRELI",
+	"EPP",
+	"ME",
+	"MEI"
+]].sort((a, b) => b.length - a.length);
 //#endregion
 //#region src/data/char-groups.json
 var char_groups_default = {
@@ -1432,220 +698,1501 @@ var char_groups_default = {
 					"code": "U+060C"
 				},
 				{
-					"char": "、",
-					"name": "ideographic comma",
-					"code": "U+3001"
+					"char": "、",
+					"name": "ideographic comma",
+					"code": "U+3001"
+				},
+				{
+					"char": "，",
+					"name": "full-width comma",
+					"code": "U+FF0C"
+				},
+				{
+					"char": "﹐",
+					"name": "small comma",
+					"code": "U+FE50"
+				},
+				{
+					"char": "՝",
+					"name": "Armenian comma",
+					"code": "U+055D"
+				}
+			]
+		},
+		"ellipsis": {
+			"description": "Ellipsis characters",
+			"chars": [{
+				"char": "…",
+				"name": "horizontal ellipsis",
+				"code": "U+2026"
+			}]
+		},
+		"question-mark": {
+			"description": "Question mark variants",
+			"chars": [
+				{
+					"char": "?",
+					"name": "question mark",
+					"code": "U+003F"
+				},
+				{
+					"char": "？",
+					"name": "full-width question mark",
+					"code": "U+FF1F"
+				},
+				{
+					"char": "⁇",
+					"name": "double question mark",
+					"code": "U+2047"
+				},
+				{
+					"char": "⁈",
+					"name": "question exclamation mark",
+					"code": "U+2048"
+				},
+				{
+					"char": "؟",
+					"name": "Arabic question mark",
+					"code": "U+061F"
+				},
+				{
+					"char": "‽",
+					"name": "interrobang",
+					"code": "U+203D"
+				}
+			]
+		},
+		"exclamation-mark": {
+			"description": "Exclamation mark variants",
+			"chars": [
+				{
+					"char": "!",
+					"name": "exclamation mark",
+					"code": "U+0021"
+				},
+				{
+					"char": "！",
+					"name": "full-width exclamation mark",
+					"code": "U+FF01"
+				},
+				{
+					"char": "‼",
+					"name": "double exclamation mark",
+					"code": "U+203C"
+				},
+				{
+					"char": "¡",
+					"name": "inverted exclamation mark",
+					"code": "U+00A1"
+				}
+			]
+		},
+		"semicolon": {
+			"description": "Semicolon variants",
+			"chars": [
+				{
+					"char": ";",
+					"name": "semicolon",
+					"code": "U+003B"
 				},
 				{
-					"char": "，",
-					"name": "full-width comma",
-					"code": "U+FF0C"
+					"char": "؛",
+					"name": "Arabic semicolon",
+					"code": "U+061B"
 				},
 				{
-					"char": "﹐",
-					"name": "small comma",
-					"code": "U+FE50"
+					"char": "；",
+					"name": "full-width semicolon",
+					"code": "U+FF1B"
 				},
 				{
-					"char": "՝",
-					"name": "Armenian comma",
-					"code": "U+055D"
+					"char": "፤",
+					"name": "Ethiopic semicolon",
+					"code": "U+1364"
+				}
+			]
+		},
+		"underscore": {
+			"description": "Underscore variants",
+			"chars": [{
+				"char": "_",
+				"name": "low line",
+				"code": "U+005F"
+			}, {
+				"char": "＿",
+				"name": "full-width low line",
+				"code": "U+FF3F"
+			}]
+		}
+	}
+};
+//#endregion
+//#region src/util/char-groups.ts
+/**
+* Centralized Unicode character equivalence groups.
+*
+* Centralized Unicode character equivalence groups.
+*
+* Provides helpers to build regex character classes that
+* match all typographic variants of a character type
+* (dashes, spaces, quotes, etc.).
+*
+* The JSON is statically imported so the bundler inlines
+* it, avoiding a runtime require() that breaks browsers.
+*/
+/** Chars that need escaping inside a regex char class. */
+const REGEX_CLASS_SPECIAL = /[\\\]^-]/;
+const escapeForCharClass = (ch) => REGEX_CLASS_SPECIAL.test(ch) ? `\\${ch}` : ch;
+const config = char_groups_default;
+/**
+* Get the raw characters for a named group.
+* Throws if the group does not exist.
+*/
+const charSet = (group) => {
+	const g = config.groups[group];
+	if (!g) throw new Error(`Unknown char group: "${group}"`);
+	return g.chars.map((entry) => entry.char);
+};
+/**
+* Build a regex character class string for a named
+* group. E.g., charClass("dash") returns a string
+* like "[-\u2013\u2014\u2010\u2011\u2212\u2043]".
+*
+* The hyphen-minus is placed first so it is treated
+* as a literal, not a range indicator.
+*/
+const charClass = (group) => {
+	return `[${[...charSet(group)].sort((a, b) => {
+		if (a === "-") return -1;
+		if (b === "-") return 1;
+		return a.localeCompare(b);
+	}).map(escapeForCharClass).join("")}]`;
+};
+/**
+* Return the inner content of a character class (without
+* the surrounding brackets). Useful for embedding a group
+* inside a larger character class, e.g.:
+*   `[\\s&,.${charClassInner("dash")}]`
+*/
+const charClassInner = (group) => {
+	return [...charSet(group)].sort((a, b) => {
+		if (a === "-") return -1;
+		if (b === "-") return 1;
+		return a.localeCompare(b);
+	}).map(escapeForCharClass).join("");
+};
+/** Regex char class matching all dash variants. */
+const DASH = charClass("dash");
+/**
+* Inner content of the dash char class (no brackets).
+* For embedding inside a larger character class:
+*   `[\\s&,.${DASH_INNER}]`
+*/
+const DASH_INNER = charClassInner("dash");
+charClass("space");
+charClass("quote-double");
+/** Inner content of the double-quote char class (no brackets). */
+const QUOTE_DOUBLE_INNER = charClassInner("quote-double");
+charClass("quote-single");
+/** Inner content of the single-quote char class (no brackets). */
+const QUOTE_SINGLE_INNER = charClassInner("quote-single");
+/**
+* Inline opening-bracket characters that frequently introduce
+* a defined-term parenthetical immediately after an address or
+* organization span (e.g. `…GA 30326, USA (the "Premises")`).
+* Hardcoded rather than data-driven because the set is tiny,
+* regex-special, and not language-dependent.
+*/
+const OPENING_BRACKETS_INNER = "(\\[{";
+charClass("slash");
+charClass("dot");
+charClass("colon");
+//#endregion
+//#region src/detectors/legal-forms.ts
+const SENTENCE_VERB_INDICATORS_SEED = new Set([
+	"je",
+	"jsou",
+	"is",
+	"are",
+	"ist",
+	"sind"
+]);
+let sentenceVerbIndicatorsCache = null;
+let sentenceVerbIndicatorsPromise = null;
+const loadSentenceVerbIndicators = async () => {
+	if (sentenceVerbIndicatorsCache) return sentenceVerbIndicatorsCache;
+	if (sentenceVerbIndicatorsPromise) return sentenceVerbIndicatorsPromise;
+	sentenceVerbIndicatorsPromise = (async () => {
+		let data = {};
+		try {
+			const mod = await import("./sentence-verb-indicators.mjs");
+			data = mod.default ?? mod;
+		} catch (err) {
+			console.warn("[anonymize] legal-forms: failed to load sentence-verb-indicators.json, falling back to seed list:", err);
+		}
+		const all = new Set(SENTENCE_VERB_INDICATORS_SEED);
+		for (const [key, value] of Object.entries(data)) {
+			if (key.startsWith("_")) continue;
+			if (!Array.isArray(value)) continue;
+			for (const verb of value) {
+				if (typeof verb !== "string" || verb.length === 0) continue;
+				all.add(verb.toLowerCase());
+			}
+		}
+		sentenceVerbIndicatorsCache = all;
+		return all;
+	})();
+	return sentenceVerbIndicatorsPromise;
+};
+const getSentenceVerbIndicatorsSync = () => sentenceVerbIndicatorsCache ?? SENTENCE_VERB_INDICATORS_SEED;
+const UPPER = "A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽÄÖÜÀÂÆÇÈÊËÎÏÔÙÛŸÑĄĆĘŁŃŚŹŻ\\u0130";
+const LOWER = "a-záčďéěíňóřšťúůýžäöüßàâæçèêëîïôùûÿñąćęłńśźż\\u0131";
+const CAP_WORD = `(?:[${UPPER}]{2,}|[${UPPER}][${LOWER}${UPPER}]+)`;
+const ALLCAP_WORD = `[${UPPER}]{2,}`;
+const ROMAN_NUMERAL_RE = /^(?=[IVXLCDM])M{0,3}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3})$/;
+let legalRoleHeadsCache = null;
+let legalRoleHeadsPromise = null;
+const loadLegalRoleHeads = async () => {
+	if (legalRoleHeadsCache) return legalRoleHeadsCache;
+	if (legalRoleHeadsPromise) return legalRoleHeadsPromise;
+	legalRoleHeadsPromise = (async () => {
+		const sets = await loadLanguageConfigs("legalRoleHeads", (mod) => {
+			return mod.default ?? mod;
+		});
+		const all = /* @__PURE__ */ new Set();
+		for (const entry of sets) {
+			if (!entry || !Array.isArray(entry.words)) continue;
+			for (const word of entry.words) if (typeof word === "string" && word.length > 0) all.add(word.toLowerCase());
+		}
+		legalRoleHeadsCache = all;
+		return all;
+	})();
+	return legalRoleHeadsPromise;
+};
+const getLegalRoleHeadsSync = () => legalRoleHeadsCache ?? /* @__PURE__ */ new Set();
+const warmLegalRoleHeads = async () => {
+	await Promise.all([
+		loadLegalRoleHeads(),
+		loadAllLegalSuffixes(),
+		loadSentenceVerbIndicators(),
+		loadClauseNounHeads()
+	]);
+};
+let allLegalSuffixesCache = null;
+let allLegalSuffixesPromise = null;
+const loadAllLegalSuffixes = async () => {
+	if (allLegalSuffixesCache) return allLegalSuffixesCache;
+	if (allLegalSuffixesPromise) return allLegalSuffixesPromise;
+	allLegalSuffixesPromise = (async () => {
+		let data = {};
+		try {
+			data = (await import("./legal-forms.mjs")).default;
+		} catch {
+			data = {};
+		}
+		const seen = /* @__PURE__ */ new Set();
+		const out = [];
+		for (const list of Object.values(data)) for (const form of list) {
+			if (typeof form !== "string" || form.length === 0) continue;
+			if (seen.has(form)) continue;
+			seen.add(form);
+			out.push(form);
+		}
+		for (const form of LEGAL_SUFFIXES) if (!seen.has(form)) {
+			seen.add(form);
+			out.push(form);
+		}
+		out.sort((a, b) => b.length - a.length);
+		allLegalSuffixesCache = out;
+		return out;
+	})();
+	return allLegalSuffixesPromise;
+};
+const getAllLegalSuffixesSync = () => allLegalSuffixesCache ?? LEGAL_SUFFIXES;
+/**
+* Sync accessor for the full legal-form vocabulary
+* (`data/legal-forms.json` plus `LEGAL_SUFFIXES`,
+* longest-first). Falls back to `LEGAL_SUFFIXES` when
+* `warmLegalRoleHeads()` has not run yet. Exposed so the
+* trailing-period strip in `sanitizeEntities` can keep
+* pace with the detector vocabulary rather than only the
+* smaller `LEGAL_SUFFIXES` propagation list.
+*/
+const getKnownLegalSuffixes = getAllLegalSuffixesSync;
+const CLAUSE_NOUN_HEADS_SEED = new Set(["agreement", "contract"]);
+let clauseNounHeadsCache = null;
+let clauseNounHeadsPromise = null;
+const loadClauseNounHeads = async () => {
+	if (clauseNounHeadsCache) return clauseNounHeadsCache;
+	if (clauseNounHeadsPromise) return clauseNounHeadsPromise;
+	clauseNounHeadsPromise = (async () => {
+		let data = {};
+		try {
+			const mod = await import("./clause-noun-heads.mjs");
+			data = mod.default ?? mod;
+		} catch (err) {
+			console.warn("[anonymize] legal-forms: failed to load clause-noun-heads.json, falling back to seed list:", err);
+		}
+		const all = new Set(CLAUSE_NOUN_HEADS_SEED);
+		for (const [key, value] of Object.entries(data)) {
+			if (key.startsWith("_")) continue;
+			if (!Array.isArray(value)) continue;
+			for (const noun of value) {
+				if (typeof noun !== "string" || noun.length === 0) continue;
+				all.add(noun.toLowerCase());
+			}
+		}
+		clauseNounHeadsCache = all;
+		return all;
+	})();
+	return clauseNounHeadsPromise;
+};
+const getClauseNounHeadsSync = () => clauseNounHeadsCache ?? CLAUSE_NOUN_HEADS_SEED;
+const escapeForRegex = (form) => form.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\s+/g, "\\s+").replace(/\\\./g, "\\.[^\\S\\n]?");
+const isShortForm = (form) => form.replace(/[.\s]/g, "").length <= 3 && !form.includes(" ");
+const buildPatternString = (forms) => {
+	if (forms.length === 0) return null;
+	const alt = forms.toSorted((a, b) => b.length - a.length).map(escapeForRegex).join("|");
+	const HSPACE = "[^\\S\\n]";
+	const LOWER_CONNECTOR = `${HSPACE}+(?:a|and|und|et|e|y|i)${HSPACE}+(?=[${LOWER}])`;
+	const SIMPLE_SEP = `(?:${HSPACE}|[&,.${DASH_INNER}]){1,4}`;
+	const CAP_OR_NUM_WORD = `(?:${CAP_WORD}|\\d{1,4})`;
+	const LOWER_WORD = `(?:(?!(?:and|und|et)(?![${UPPER}${LOWER}]))[${LOWER}][${LOWER}${UPPER}]+)`;
+	const ANY_WORD_TAIL = `(?:(?!(?:and|und|et)(?![${UPPER}${LOWER}]))[${UPPER}${LOWER}][${LOWER}${UPPER}]+|[${UPPER}]{2,3}|\\d{1,4})`;
+	return `${`(?:${`(?:${CAP_WORD})(?:${SIMPLE_SEP}(?:${CAP_OR_NUM_WORD})){0,10}`})(?:${`${SIMPLE_SEP}(?:${LOWER_WORD})(?:(?:${LOWER_CONNECTOR}|${SIMPLE_SEP})(?:${ANY_WORD_TAIL})){0,10}`})?`}(?:\\s+|,\\s*)(?:${alt})(?![${LOWER}])`;
+};
+/**
+* Build legal form regex pattern strings.
+* Returns an array of regex strings for the unified
+* TextSearch builder. Empty if data package is not
+* installed.
+*/
+const buildLegalFormPatterns = async () => {
+	let data = {};
+	try {
+		data = (await import("./legal-forms.mjs")).default;
+	} catch {
+		return [];
+	}
+	const allForms = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const forms of Object.values(data)) for (const form of forms) if (!seen.has(form)) {
+		seen.add(form);
+		allForms.push(form);
+	}
+	for (const form of LEGAL_SUFFIXES) if (!seen.has(form)) {
+		seen.add(form);
+		allForms.push(form);
+	}
+	const patterns = [];
+	const longPattern = buildPatternString(allForms.filter((f) => !isShortForm(f)));
+	if (longPattern) patterns.push(longPattern);
+	const shortPattern = buildPatternString(allForms.filter(isShortForm));
+	if (shortPattern) patterns.push(shortPattern);
+	const allcapPrefix = `(?:${ALLCAP_WORD})(?:[ \\t&,.${DASH_INNER}]{1,4}(?:${ALLCAP_WORD})){0,2}`;
+	const allcapAlt = allForms.toSorted((a, b) => b.length - a.length).map(escapeForRegex).join("|");
+	patterns.push(`${allcapPrefix}(?:[ \\t]+|,[ \\t]*)(?:${allcapAlt})(?![${LOWER}])`);
+	return patterns;
+};
+const CONNECTOR_RE = /^(?:a|and|und|et|e|y|i|&)$/i;
+const AND_TYPE_CONNECTOR_RE = /^(?:and|und|et)$/i;
+const UPPER_LETTER_RE = /^\p{Lu}/u;
+const COMPANY_SUFFIX_WORDS_RE = /^(?:Company|Co|Bank|Brothers|Bros|Sons|Group|Holdings|Trust|Partners|Associates|Corporation|Industries|Enterprises|Solutions|Systems|Services|Foundation|Institute)$/;
+const IN_NAME_PREPOSITION_RE = /^(?:of|the)$/i;
+const ENTITY_HEAD_WORD_RE = /^[\p{L}\p{M}&]+/u;
+const LEADING_CLAUSE_RE = /(?:^|\s)(?:by\s+and\s+between|is\s+between)\s+/giu;
+/**
+* Find the word ending just before `pos` in `text`,
+* skipping any whitespace (not newlines).
+* Returns null if no word is found (e.g., at start
+* of text, or preceded by non-word chars like ".").
+*/
+const findWordBefore = (text, pos) => {
+	let scan = pos - 1;
+	while (scan >= 0) {
+		const ch = text.charAt(scan);
+		if (ch === "\n" || !/\s/.test(ch)) break;
+		scan--;
+	}
+	if (scan < 0 || text.charAt(scan) === "\n") return null;
+	const wordEnd = scan + 1;
+	while (scan >= 0 && /[\p{L}\p{M}&]/u.test(text.charAt(scan))) scan--;
+	const wordStart = scan + 1;
+	const word = text.slice(wordStart, wordEnd);
+	if (word.length === 0) return null;
+	return {
+		word,
+		start: wordStart
+	};
+};
+/**
+* Count consecutive uppercase-starting words immediately
+* before `pos`. Stops at the first non-upper word or at
+* text/line start. Used to disambiguate "<First> <Last>
+* and <ORG>" from "<Multi-word Org> and <Continuation>".
+*/
+const countUpperWordsBefore = (fullText, pos) => {
+	let count = 0;
+	let scan = pos;
+	while (scan > 0) {
+		const found = findWordBefore(fullText, scan);
+		if (!found) break;
+		if (!UPPER_LETTER_RE.test(found.word)) break;
+		count++;
+		scan = found.start;
+	}
+	return count;
+};
+/**
+* Extend a match backward through uppercase words and
+* lowercase connectors. Stops at start of text,
+* newline, or a word that doesn't qualify.
+*
+* Connectors (a, and, und, et, ...) are only consumed
+* when there is a valid word before them — a trailing
+* connector at an entity boundary is not consumed.
+* For multi-char "and"-type connectors we additionally
+* refuse to cross when exactly two uppercase words
+* precede them ("First Last and ORG, Inc." shape) —
+* unless the match itself begins with a known company-
+* suffix word ("…and Company, Inc."), in which case
+* the chain belongs to one organisation. In that
+* suffix-mode we also cross in-name prepositions
+* ("Bank of America and Trust Company, Inc.").
+*/
+const extendBackward = (fullText, matchStart, options = {}) => {
+	const headWord = ENTITY_HEAD_WORD_RE.exec(fullText.slice(matchStart))?.[0] ?? "";
+	const suffixMode = options.forceSuffixMode === true || COMPANY_SUFFIX_WORDS_RE.test(headWord);
+	let pos = matchStart;
+	while (pos > 0) {
+		const found = findWordBefore(fullText, pos);
+		if (!found) break;
+		const { word, start: wordStart } = found;
+		const isUpper = UPPER_LETTER_RE.test(word);
+		const isConnector = CONNECTOR_RE.test(word);
+		const isInNamePrep = suffixMode && IN_NAME_PREPOSITION_RE.test(word);
+		if (isUpper) pos = wordStart;
+		else if (isConnector) {
+			if (!suffixMode && AND_TYPE_CONNECTOR_RE.test(word) && countUpperWordsBefore(fullText, wordStart) === 2) break;
+			const prev = findWordBefore(fullText, wordStart);
+			if (!prev) break;
+			if (!UPPER_LETTER_RE.test(prev.word)) break;
+			pos = prev.start;
+		} else if (isInNamePrep) {
+			const prev = findWordBefore(fullText, wordStart);
+			if (!prev) break;
+			if (!UPPER_LETTER_RE.test(prev.word)) break;
+			pos = prev.start;
+		} else break;
+	}
+	return pos;
+};
+const trimLeadingClause = (text) => {
+	let cut = -1;
+	for (const match of text.matchAll(LEADING_CLAUSE_RE)) cut = match.index + match[0].length;
+	if (cut <= 0) return {
+		offset: 0,
+		text
+	};
+	const trimmed = text.slice(cut);
+	const leadingWs = trimmed.match(/^\s*/u)?.[0].length ?? 0;
+	return {
+		offset: cut + leadingWs,
+		text: trimmed.slice(leadingWs)
+	};
+};
+/**
+* Process legal form matches from the unified search.
+* Receives all matches; filters to the legal forms
+* slice via sliceStart/sliceEnd.
+*
+* The role-head trimming step reads per-language data from
+* a cache that `runPipeline` warms via `warmLegalRoleHeads()`
+* before calling this. Callers that invoke
+* `processLegalFormMatches` directly (without going through
+* `runPipeline`) must `await warmLegalRoleHeads()` first;
+* otherwise the trim falls back to a no-op and sentence-
+* fragment fixes do not apply.
+*/
+const processLegalFormMatches = (allMatches, sliceStart, sliceEnd, fullText) => {
+	const results = [];
+	for (const match of allMatches) {
+		const idx = match.pattern;
+		if (idx < sliceStart || idx >= sliceEnd) continue;
+		const text = match.text.trimEnd();
+		if (text.length < 5) continue;
+		const roleHeads = getLegalRoleHeadsSync();
+		const firstWordMatch = /^[\p{L}\p{M}]+(?:-[\p{L}\p{M}]+)*/u.exec(text);
+		let processedStart = match.start;
+		let processedText = text;
+		let trimmed = false;
+		const firstWordText = firstWordMatch?.[0] ?? "";
+		const firstWordLeading = /^[\p{L}\p{M}]+/u.exec(firstWordText)?.[0] ?? "";
+		if (firstWordMatch !== null && (roleHeads.has(firstWordText.toLowerCase()) || firstWordLeading.length > 0 && roleHeads.has(firstWordLeading.toLowerCase()))) {
+			let suffixOffset = -1;
+			for (const suffix of getAllLegalSuffixesSync()) {
+				const idx = text.lastIndexOf(suffix);
+				if (idx !== -1 && idx + suffix.length >= text.length - 1) {
+					suffixOffset = idx;
+					break;
 				}
-			]
-		},
-		"ellipsis": {
-			"description": "Ellipsis characters",
-			"chars": [{
-				"char": "…",
-				"name": "horizontal ellipsis",
-				"code": "U+2026"
-			}]
-		},
-		"question-mark": {
-			"description": "Question mark variants",
-			"chars": [
-				{
-					"char": "?",
-					"name": "question mark",
-					"code": "U+003F"
-				},
-				{
-					"char": "？",
-					"name": "full-width question mark",
-					"code": "U+FF1F"
-				},
-				{
-					"char": "⁇",
-					"name": "double question mark",
-					"code": "U+2047"
-				},
-				{
-					"char": "⁈",
-					"name": "question exclamation mark",
-					"code": "U+2048"
-				},
-				{
-					"char": "؟",
-					"name": "Arabic question mark",
-					"code": "U+061F"
-				},
-				{
-					"char": "‽",
-					"name": "interrobang",
-					"code": "U+203D"
+			}
+			if (suffixOffset < 0) {} else {
+				const midStart = firstWordMatch[0].length;
+				const midEnd = suffixOffset;
+				const midSection = text.slice(midStart, midEnd);
+				const verbIndicators = getSentenceVerbIndicatorsSync();
+				let lastVerbEndInMid = -1;
+				for (const match of midSection.matchAll(/(?<![\p{L}\p{N}])[\p{L}\p{M}]+/gu)) if (match[0] !== void 0 && match.index !== void 0 && verbIndicators.has(match[0].toLowerCase())) lastVerbEndInMid = match.index + match[0].length;
+				const digitAfterRole = /^\s+\d+(?:\.|\b)/u.test(midSection);
+				let appositiveRoleHead = false;
+				if (!digitAfterRole && lastVerbEndInMid === -1 && fullText) {
+					const before = fullText.slice(Math.max(0, match.start - 40), match.start);
+					const prevWord = /(?<![\p{L}\p{N}])(\p{L}[\p{L}\p{M}]*)\s*$/u.exec(before);
+					if (prevWord !== null && getSentenceVerbIndicatorsSync().has(prevWord[1].toLowerCase())) appositiveRoleHead = true;
 				}
-			]
-		},
-		"exclamation-mark": {
-			"description": "Exclamation mark variants",
-			"chars": [
-				{
-					"char": "!",
-					"name": "exclamation mark",
-					"code": "U+0021"
-				},
-				{
-					"char": "！",
-					"name": "full-width exclamation mark",
-					"code": "U+FF01"
-				},
-				{
-					"char": "‼",
-					"name": "double exclamation mark",
-					"code": "U+203C"
-				},
-				{
-					"char": "¡",
-					"name": "inverted exclamation mark",
-					"code": "U+00A1"
+				if (lastVerbEndInMid !== -1 || digitAfterRole || appositiveRoleHead) {
+					const scanStart = lastVerbEndInMid !== -1 ? midStart + lastVerbEndInMid : midStart;
+					const capRe = /(?<![\p{L}\p{N}])\p{Lu}[\p{L}\p{M}\p{N}]*/gu;
+					capRe.lastIndex = scanStart;
+					const clauseNouns = getClauseNounHeadsSync();
+					let capMatch = null;
+					for (let next = capRe.exec(text); next !== null; next = capRe.exec(text)) {
+						if (next.index >= suffixOffset) break;
+						const lc = next[0].toLowerCase();
+						if (roleHeads.has(lc) || clauseNouns.has(lc)) continue;
+						capMatch = next;
+						break;
+					}
+					if (capMatch === null) continue;
+					processedStart = match.start + capMatch.index;
+					processedText = text.slice(capMatch.index);
+					trimmed = true;
 				}
-			]
-		},
-		"semicolon": {
-			"description": "Semicolon variants",
-			"chars": [
-				{
-					"char": ";",
-					"name": "semicolon",
-					"code": "U+003B"
-				},
-				{
-					"char": "؛",
-					"name": "Arabic semicolon",
-					"code": "U+061B"
-				},
-				{
-					"char": "；",
-					"name": "full-width semicolon",
-					"code": "U+FF1B"
-				},
-				{
-					"char": "፤",
-					"name": "Ethiopic semicolon",
-					"code": "U+1364"
+			}
+		}
+		if (processedText.includes("\n")) continue;
+		let entityStart = processedStart;
+		let entityText = processedText;
+		if (fullText && !trimmed) {
+			const extended = extendBackward(fullText, processedStart);
+			if (extended < processedStart) {
+				entityStart = extended;
+				entityText = fullText.slice(extended, processedStart + processedText.length).trimEnd();
+			}
+		}
+		const clauseTrim = trimLeadingClause(entityText);
+		if (clauseTrim.offset > 0) {
+			entityStart += clauseTrim.offset;
+			entityText = clauseTrim.text;
+		}
+		const getPrefixInfo = (value) => {
+			const prefixEnd = value.lastIndexOf(",") !== -1 ? value.lastIndexOf(",") : value.lastIndexOf(" ");
+			return {
+				prefixEnd,
+				prefixPart: prefixEnd > 0 ? value.slice(0, prefixEnd).replace(/[^a-zA-ZÀ-ž]/g, "") : value.replace(/[^a-zA-ZÀ-ž]/g, "")
+			};
+		};
+		let { prefixEnd, prefixPart } = getPrefixInfo(entityText);
+		let isAllCapsMatch = prefixPart.length > 2 && prefixPart === prefixPart.toUpperCase();
+		if (isAllCapsMatch && fullText) {
+			const lineStart = fullText.lastIndexOf("\n", entityStart);
+			const lineEnd = fullText.indexOf("\n", entityStart + entityText.length);
+			const lineLetters = fullText.slice(lineStart + 1, lineEnd === -1 ? fullText.length : lineEnd).replace(/[^a-zA-ZÀ-ž]/g, "");
+			const upperCount = [...lineLetters].filter((c) => c === c.toUpperCase()).length;
+			if (lineLetters.length > 5 && upperCount / lineLetters.length >= .95) continue;
+			if ((prefixPart.length > 0 ? entityText.slice(0, prefixEnd > 0 ? prefixEnd : entityText.length).trim().split(/\s+/).length : 0) > 3) {
+				entityStart = match.start;
+				entityText = text;
+				({prefixEnd, prefixPart} = getPrefixInfo(entityText));
+				isAllCapsMatch = prefixPart.length > 2 && prefixPart === prefixPart.toUpperCase();
+			}
+		} else if (isAllCapsMatch) continue;
+		const lastSpace = entityText.lastIndexOf(" ");
+		const rawSuffix = lastSpace !== -1 ? entityText.slice(lastSpace + 1) : "";
+		const suffixClean = rawSuffix.replace(/[.,]/g, "");
+		if (suffixClean.length > 0 && ROMAN_NUMERAL_RE.test(suffixClean)) continue;
+		if (suffixClean.length <= 2 && !/\./.test(rawSuffix) && /[^\x00-\x7F]/.test(entityText.slice(0, lastSpace !== -1 ? lastSpace : entityText.length))) continue;
+		results.push({
+			start: entityStart,
+			end: entityStart + entityText.length,
+			label: "organization",
+			text: entityText,
+			score: .95,
+			source: DETECTION_SOURCES.LEGAL_FORM
+		});
+	}
+	return results;
+};
+//#endregion
+//#region src/detectors/coreference.ts
+/**
+* Case-insensitive set of every known legal-form suffix
+* with whitespace normalized away. Used by the
+* coreference scan to reject parenthetical define-term
+* captures whose alias is only a legal-form
+* abbreviation (e.g. "(« SAS »)" after "ACME SAS"),
+* which would otherwise propagate generic suffix
+* mentions as document-wide org aliases.
+*/
+const isLegalFormAlias = (alias) => {
+	const normalized = alias.replace(/\s+/g, "").toLowerCase();
+	if (normalized.length === 0) return false;
+	for (const suffix of getKnownLegalSuffixes()) if (suffix.replace(/\s+/g, "").toLowerCase() === normalized) return true;
+	return false;
+};
+/**
+* Load coreference definition patterns from per-language
+* JSON configs in src/data/. Uses the
+* language manifest for auto-discovery.
+*/
+const loadDefinitionPatterns = async () => {
+	const patterns = [];
+	const allRows = await loadLanguageConfigs("coreference", (mod) => {
+		return mod.default ?? mod;
+	});
+	for (const rows of allRows) {
+		if (!Array.isArray(rows)) {
+			console.warn("[anonymize] coreference: unexpected config shape, skipping");
+			continue;
+		}
+		for (const row of rows) try {
+			patterns.push({ pattern: new RegExp(row.pattern, row.flags) });
+		} catch (err) {
+			console.warn(`[anonymize] coreference: invalid regex "${row.pattern}":`, err);
+		}
+	}
+	return patterns;
+};
+/**
+* Load generic role terms that should NOT be treated
+* as PII coreferences. "Prodávající" (Seller),
+* "Kupující" (Buyer), etc. are legal roles, not
+* identifying information.
+*/
+const getRoleStopSet = async (ctx) => {
+	if (ctx.roleStopSet) return ctx.roleStopSet;
+	if (ctx.roleStopSetPromise) return ctx.roleStopSetPromise;
+	const promise = (async () => {
+		let result;
+		try {
+			const mod = await import("./generic-roles.mjs");
+			const data = mod.default ?? mod;
+			result = new Set(data.roles.map((r) => r.toLowerCase()));
+		} catch {
+			result = /* @__PURE__ */ new Set();
+		}
+		ctx.roleStopSet = result;
+		return result;
+	})();
+	ctx.roleStopSetPromise = promise;
+	return promise;
+};
+const getDefinitionPatterns = async (ctx) => {
+	if (ctx.corefPatterns) return ctx.corefPatterns;
+	if (ctx.corefPatternsPromise) return ctx.corefPatternsPromise;
+	ctx.corefPatternsPromise = loadDefinitionPatterns();
+	const patterns = await ctx.corefPatternsPromise;
+	if (patterns.length === 0) {
+		ctx.corefPatterns = patterns;
+		if (!ctx.corefLoadAttempted) {
+			ctx.corefLoadAttempted = true;
+			console.warn("[anonymize] coreference: no definition patterns loaded; coreference detection will be inactive");
+		}
+		return patterns;
+	}
+	ctx.corefPatterns = patterns;
+	return patterns;
+};
+const SEARCH_WINDOW = 200;
+/**
+* Check whether an alias has textual similarity to
+* the source entity. Prevents roles and structural
+* terms from being treated as name aliases.
+*
+* Three checks (any passes → similar):
+* 1. Word overlap: a word in the alias appears in the
+*    entity (case-insensitive, min 2 chars)
+* 2. Initials: alias letters match first letters of
+*    entity words ("TB" ↔ "Tomas Bata")
+* 3. Substring: alias is a substring of the entity
+*    or vice versa (min 3 chars)
+*/
+const hasEntitySimilarity = (alias, entityText) => {
+	const aliasLower = alias.toLowerCase();
+	const entityLower = entityText.toLowerCase();
+	if (aliasLower.length >= 3 && entityLower.includes(aliasLower)) return true;
+	if (entityLower.length >= 3 && aliasLower.includes(entityLower)) return true;
+	const aliasWords = aliasLower.split(/[\s.,;:'"()/-]+/).filter((w) => w.length >= 2);
+	const entityWords = entityLower.split(/[\s.,;:'"()/-]+/).filter((w) => w.length >= 2);
+	const entityWordSet = new Set(entityWords);
+	for (const word of aliasWords) if (entityWordSet.has(word)) return true;
+	if (/^[\p{Lu}]+$/u.test(alias) && alias.length >= 2 && alias.length <= entityWords.length) {
+		for (let start = 0; start <= entityWords.length - alias.length; start++) if (entityWords.slice(start, start + alias.length).map((w) => w.charAt(0)).join("") === aliasLower) return true;
+	}
+	return false;
+};
+/**
+* Scan for defined-term patterns near known entities.
+*
+* Legal documents universally follow:
+*   "Dr. Heinrich Muller (hereinafter 'the Seller')..."
+*
+* After NER detects the entity, this function scans for
+* definitional patterns within +/-200 chars and extracts
+* the alias. Returns alias + label pairs that can be added
+* to the gazetteer for a full-text re-scan.
+*/
+/**
+* Labels that can be the source of a coreference alias.
+* Only parties (person, organization) have defined-term
+* aliases in legal text. Dates, addresses, IDs do not.
+*/
+const COREF_SOURCE_LABELS = new Set(["person", "organization"]);
+const extractDefinedTerms = async (fullText, entities, ctx = defaultContext) => {
+	const [definitionPatterns, roleStops] = await Promise.all([getDefinitionPatterns(ctx), getRoleStopSet(ctx)]);
+	const terms = [];
+	const seen = /* @__PURE__ */ new Set();
+	const sorted = [...entities].sort((a, b) => a.start - b.start);
+	for (const { pattern } of definitionPatterns) {
+		pattern.lastIndex = 0;
+		for (let match = pattern.exec(fullText); match !== null; match = pattern.exec(fullText)) {
+			const alias = match[1]?.trim();
+			if (!alias || alias.length < 2) continue;
+			if (roleStops.has(alias.toLowerCase())) continue;
+			if (isLegalFormAlias(alias)) continue;
+			const defPos = match.index;
+			let bestEntity = null;
+			for (let i = sorted.length - 1; i >= 0; i--) {
+				const e = sorted[i];
+				if (e === void 0) continue;
+				if (e.end > defPos) continue;
+				if (defPos - e.end > SEARCH_WINDOW) break;
+				if (!COREF_SOURCE_LABELS.has(e.label)) continue;
+				bestEntity = e;
+				break;
+			}
+			if (bestEntity === null) continue;
+			const gapText = fullText.slice(bestEntity.end, defPos);
+			if (/(?:;|\.(?=\s*(?:["'„‚(]*\p{Lu}|$)))/u.test(gapText)) continue;
+			if (!hasEntitySimilarity(alias, bestEntity.text)) continue;
+			const key = `${alias.toLowerCase()}::${bestEntity.label}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			terms.push({
+				alias,
+				label: bestEntity.label,
+				definitionStart: defPos,
+				sourceText: bestEntity.text
+			});
+		}
+	}
+	return terms;
+};
+/**
+* Check if a character is a Unicode word character
+* (letter, digit, or combining mark). Used for word
+* boundary checks in coreference matching.
+*/
+const isWordChar = (ch) => {
+	if (ch === void 0) return false;
+	return /[\p{L}\p{M}\p{N}]/u.test(ch);
+};
+/**
+* Find all occurrences of defined-term aliases in the
+* full text. Returns Entity spans for each match.
+*
+* Respects word boundaries: "Kupující" must not match
+* inside "Kupujícímu". A match is valid only if the
+* character before the start and after the end are NOT
+* word characters (letter/digit).
+*
+* Populates `ctx.corefSourceMap` with entries linking
+* each coref entity to its source entity text, for
+* consistent placeholder numbering.
+*/
+const findCoreferenceSpans = (fullText, terms, ctx = defaultContext) => {
+	const results = [];
+	for (const term of terms) {
+		let searchFrom = 0;
+		while (searchFrom < fullText.length) {
+			const idx = fullText.indexOf(term.alias, searchFrom);
+			if (idx === -1) break;
+			const matchEnd = idx + term.alias.length;
+			const charBefore = idx > 0 ? fullText[idx - 1] : void 0;
+			const charAfter = fullText[matchEnd];
+			if (isWordChar(charBefore) || isWordChar(charAfter)) {
+				searchFrom = idx + 1;
+				continue;
+			}
+			const entity = {
+				start: idx,
+				end: matchEnd,
+				label: term.label,
+				text: term.alias,
+				score: .95,
+				source: DETECTION_SOURCES.COREFERENCE
+			};
+			ctx.corefSourceMap.set(corefKey(entity), term.sourceText);
+			results.push(entity);
+			searchFrom = matchEnd;
+		}
+	}
+	return results;
+};
+//#endregion
+//#region src/detectors/gazetteer.ts
+const MAX_EDIT_DISTANCE = 2;
+const MIN_FUZZY_LENGTH = 4;
+const MAX_PREFIX_OVERSHOOT = 7;
+/**
+* Collect all searchable strings (canonical + variants)
+* from gazetteer entries, mapped to their labels and
+* entry IDs.
+*/
+const buildSearchTerms = (entries) => {
+	const terms = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const meta = {
+			label: entry.label,
+			entryId: entry.id
+		};
+		terms.set(entry.canonical, meta);
+		for (const variant of entry.variants) terms.set(variant, meta);
+	}
+	return terms;
+};
+/**
+* Build TextSearch-compatible patterns from gazetteer
+* entries. Returns:
+* - Exact literal patterns for all terms
+* - Fuzzy patterns (distance: 2) for terms >= 4 chars
+* - Parallel metadata arrays for post-processing
+*
+* Patterns are ordered: all exact first, then all
+* fuzzy. The isFuzzy array marks which are which.
+*/
+const buildGazetteerPatterns = (entries) => {
+	const terms = buildSearchTerms(entries);
+	const patterns = [];
+	const labels = [];
+	const isFuzzy = [];
+	for (const [term, meta] of terms) {
+		patterns.push({
+			pattern: term,
+			literal: true,
+			wholeWords: false
+		});
+		labels.push(meta.label);
+		isFuzzy.push(false);
+	}
+	for (const [term, meta] of terms) {
+		if (term.length < MIN_FUZZY_LENGTH) continue;
+		patterns.push({
+			pattern: term,
+			distance: MAX_EDIT_DISTANCE
+		});
+		labels.push(meta.label);
+		isFuzzy.push(true);
+	}
+	return {
+		patterns,
+		data: {
+			labels,
+			isFuzzy
+		}
+	};
+};
+/**
+* Process gazetteer matches from the unified literal
+* search. Receives all matches; filters to the
+* gazetteer slice via sliceStart/sliceEnd.
+*
+* Exact matches get score 0.9; fuzzy matches get
+* 0.85. Fuzzy matches that overlap an exact match
+* are dropped.
+*
+* For exact matches, attempts prefix extension for
+* legal suffixes ("a.s.", "GmbH", "s.r.o." after
+* the matched term).
+*/
+const processGazetteerMatches = (allMatches, sliceStart, sliceEnd, fullText, data) => {
+	const results = [];
+	const exactSpans = [];
+	for (const match of allMatches) {
+		const idx = match.pattern;
+		if (idx < sliceStart || idx >= sliceEnd) continue;
+		const localIdx = idx - sliceStart;
+		if (data.isFuzzy[localIdx]) continue;
+		const label = data.labels[localIdx];
+		if (!label) continue;
+		const extended = tryPrefixExtension(fullText, match.start, match.end);
+		const end = extended?.end ?? match.end;
+		const text = extended?.text ?? fullText.slice(match.start, match.end);
+		exactSpans.push({
+			start: match.start,
+			end
+		});
+		results.push({
+			start: match.start,
+			end,
+			label,
+			text,
+			score: .9,
+			source: DETECTION_SOURCES.GAZETTEER
+		});
+	}
+	for (const match of allMatches) {
+		const idx = match.pattern;
+		if (idx < sliceStart || idx >= sliceEnd) continue;
+		const localIdx = idx - sliceStart;
+		if (!data.isFuzzy[localIdx]) continue;
+		if (match.distance === 0) continue;
+		const label = data.labels[localIdx];
+		if (!label) continue;
+		if (exactSpans.some((e) => match.start < e.end && match.end > e.start)) continue;
+		const matchText = fullText.slice(match.start, match.end);
+		results.push({
+			start: match.start,
+			end: match.end,
+			label,
+			text: matchText,
+			score: .85,
+			source: DETECTION_SOURCES.GAZETTEER
+		});
+	}
+	return results;
+};
+/**
+* Try to extend an exact match to capture one
+* trailing token (max 6 chars) that may be a legal
+* entity suffix (e.g., "a.s.", "GmbH", "s.r.o.").
+*
+* Does not validate the token against a legal-forms
+* list; false extensions are filtered by mergeAndDedup
+* when a legal-form detector produces a competing
+* entity with the correct span.
+*/
+const tryPrefixExtension = (fullText, start, end) => {
+	const maxEnd = Math.min(end + MAX_PREFIX_OVERSHOOT, fullText.length);
+	if (maxEnd <= end + 1) return null;
+	const after = fullText.slice(end, maxEnd);
+	if (!after.startsWith(" ")) return null;
+	const nextSpace = after.indexOf(" ", 1);
+	const suffixEnd = nextSpace !== -1 ? nextSpace : after.length;
+	if (suffixEnd <= 1) return null;
+	const newEnd = end + suffixEnd;
+	return {
+		end: newEnd,
+		text: fullText.slice(start, newEnd)
+	};
+};
+//#endregion
+//#region src/util/text.ts
+/**
+* Shared text utilities for detectors.
+*
+* Extracted from names.ts and deny-list.ts to avoid
+* duplicating regex constants and helper functions.
+*/
+/** Matches a string that starts with an uppercase letter. */
+const UPPER_START_RE = /^\p{Lu}/u;
+/** Matches a string consisting entirely of uppercase letters. */
+const ALL_UPPER_RE = /^\p{Lu}+$/u;
+const SENTENCE_END_RE = /[.!?]/;
+/**
+* Detect whether a position is at the start of a sentence.
+* Looks backward past whitespace for sentence-ending
+* punctuation (.!?). Position 0 and positions preceded
+* only by whitespace are considered sentence starts.
+*/
+const isSentenceStart = (text, pos) => {
+	if (pos === 0) return true;
+	let i = pos - 1;
+	while (i >= 0 && /\s/.test(text[i] ?? "")) i--;
+	if (i < 0) return true;
+	return SENTENCE_END_RE.test(text[i] ?? "");
+};
+//#endregion
+//#region src/detectors/names.ts
+const getCorpus = (ctx) => ctx.nameCorpus;
+const getNameCorpusFirstNames = (ctx = defaultContext) => ctx.nameCorpus?.firstNamesList ?? [];
+const getNameCorpusSurnames = (ctx = defaultContext) => ctx.nameCorpus?.surnamesList ?? [];
+const getNameCorpusTitles = (ctx = defaultContext) => ctx.nameCorpus?.titlesList ?? [];
+/**
+* Load name corpus data from injected dictionaries
+* and legacy config files. Merges all sources.
+*
+* Safe to call multiple times; only loads once per
+* context. Must be called before detectNameCorpus or
+* the getNameCorpus*() accessors are used.
+*
+* @param dictionaries Optional pre-loaded dictionaries
+*   with per-language first names and surnames. When
+*   omitted, only legacy config files are used.
+*/
+const initNameCorpus = (ctx = defaultContext, dictionaries) => {
+	if (ctx.nameCorpusPromise) return ctx.nameCorpusPromise;
+	const promise = (async () => {
+		try {
+			const [legacyFirstMod, legacySurnameMod, titleMod, exclusionMod] = await Promise.all([
+				import("./names-first.mjs"),
+				import("./names-surnames.mjs"),
+				import("./names-title-tokens.mjs"),
+				import("./names-exclusions.mjs")
+			]);
+			const firstNames = [...legacyFirstMod.default.names];
+			if (dictionaries?.firstNames) for (const names of Object.values(dictionaries.firstNames)) for (const name of names) firstNames.push(name);
+			const surnames = [...legacySurnameMod.default.names];
+			if (dictionaries?.surnames) for (const names of Object.values(dictionaries.surnames)) for (const name of names) surnames.push(name);
+			const dedup = (arr) => {
+				const seen = /* @__PURE__ */ new Set();
+				const result = [];
+				for (const item of arr) {
+					if (seen.has(item)) continue;
+					seen.add(item);
+					result.push(item);
 				}
-			]
-		},
-		"underscore": {
-			"description": "Underscore variants",
-			"chars": [{
-				"char": "_",
-				"name": "low line",
-				"code": "U+005F"
-			}, {
-				"char": "＿",
-				"name": "full-width low line",
-				"code": "U+FF3F"
-			}]
+				return result;
+			};
+			const dedupFirst = dedup(firstNames);
+			const dedupSurnames = dedup(surnames);
+			const titles = titleMod.default.tokens;
+			const exclusions = exclusionMod.default.words;
+			ctx.nameCorpus = {
+				firstNames: Object.freeze(new Set(dedupFirst)),
+				surnames: Object.freeze(new Set(dedupSurnames)),
+				titleTokens: Object.freeze(new Set(titles)),
+				excludedWords: Object.freeze(new Set(exclusions)),
+				firstNamesList: Object.freeze(dedupFirst),
+				surnamesList: Object.freeze(dedupSurnames),
+				titlesList: Object.freeze(titles),
+				excludedList: Object.freeze(exclusions)
+			};
+		} catch (err) {
+			ctx.nameCorpusPromise = null;
+			console.warn("[anonymize] Failed to load name corpus JSON — name detection disabled:", err);
+		}
+	})();
+	ctx.nameCorpusPromise = promise;
+	return promise;
+};
+const INFLECTION_SUFFIXES = [
+	"ovi",
+	"em",
+	"om",
+	"ou",
+	"é",
+	"a",
+	"u"
+];
+/**
+* Strip common Czech/Slovak case suffixes from a token.
+* Returns candidate base forms if stripping produces a
+* plausible name (capitalised, length >= 3).
+*
+* For the "-ou" instrumental feminine suffix, also yields
+* base + "a" (e.g., "Editou" → "Edit" and "Edita")
+* because Czech feminine names decline -a → -ou.
+*/
+const stripInflection = (token) => {
+	const candidates = [];
+	for (const suffix of INFLECTION_SUFFIXES) if (token.length > suffix.length + 2 && token.endsWith(suffix)) {
+		const base = token.slice(0, -suffix.length);
+		if (/^\p{Lu}/u.test(base)) {
+			candidates.push(base);
+			if (suffix === "ou" || suffix === "é" || suffix === "u") candidates.push(`${base}a`);
+		}
+	}
+	return candidates;
+};
+const TOKEN_TYPE = {
+	NAME: "name",
+	SURNAME: "surname",
+	TITLE: "title",
+	ABBREVIATION: "abbreviation",
+	CAPITALIZED: "capitalized",
+	OTHER: "other"
+};
+const PERSON_CHAIN_BREAK_RE$1 = /[!?;:]/u;
+const isInitialContinuationGap$1 = (text, gap) => /^\p{Lu}$/u.test(text) && /^\.[^\S\n]{1,2}$/u.test(gap) || /^[^\S\n]{1,2}(?:\p{Lu}\.[^\S\n]{1,2})+$/u.test(gap);
+/**
+* Check if a token is in the first-name set, either
+* directly or after stripping Czech/Slovak inflection.
+*/
+const isFirstNameToken = (token, corpus) => {
+	if (corpus.firstNames.has(token)) return true;
+	return stripInflection(token).some((b) => corpus.firstNames.has(b));
+};
+/**
+* Check if a token is in the surname set, either
+* directly or after stripping Czech/Slovak inflection.
+*/
+const isSurnameToken = (token, corpus) => {
+	if (corpus.surnames.has(token)) return true;
+	return stripInflection(token).some((b) => corpus.surnames.has(b));
+};
+/**
+* Check if a token looks like a single-letter
+* abbreviation: "J.", "M.", etc.
+*/
+const isAbbreviation = (token) => token.length === 2 && /^\p{Lu}$/u.test(token[0] ?? "") && token[1] === ".";
+const segmenter$1 = new Intl.Segmenter(void 0, { granularity: "word" });
+/**
+* Split text into word segments using Intl.Segmenter.
+* Only returns segments flagged as words.
+*/
+const segmentWords = (fullText) => {
+	const words = [];
+	for (const seg of segmenter$1.segment(fullText)) if (seg.isWordLike) words.push({
+		text: seg.segment,
+		start: seg.index,
+		end: seg.index + seg.segment.length
+	});
+	return words;
+};
+/** NAME or SURNAME — both represent corpus-matched tokens */
+const isCorpusMatch = (type) => type === TOKEN_TYPE.NAME || type === TOKEN_TYPE.SURNAME;
+const classifyToken = (word, corpus) => {
+	const { text, start, end } = word;
+	const lower = text.toLowerCase();
+	const stripped = text.endsWith(".") ? text.slice(0, -1).toLowerCase() : lower;
+	if (corpus.titleTokens.has(stripped)) return {
+		text,
+		type: TOKEN_TYPE.TITLE,
+		start,
+		end
+	};
+	if (isAbbreviation(text)) return {
+		text,
+		type: TOKEN_TYPE.ABBREVIATION,
+		start,
+		end
+	};
+	if (corpus.excludedWords.has(lower)) return {
+		text,
+		type: TOKEN_TYPE.OTHER,
+		start,
+		end
+	};
+	if (text.length < 3) return {
+		text,
+		type: TOKEN_TYPE.OTHER,
+		start,
+		end
+	};
+	if (text.length > 3 && ALL_UPPER_RE.test(text)) return {
+		text,
+		type: TOKEN_TYPE.OTHER,
+		start,
+		end
+	};
+	if (!UPPER_START_RE.test(text)) return {
+		text,
+		type: TOKEN_TYPE.OTHER,
+		start,
+		end
+	};
+	if (isFirstNameToken(text, corpus)) return {
+		text,
+		type: TOKEN_TYPE.NAME,
+		start,
+		end
+	};
+	if (isSurnameToken(text, corpus)) return {
+		text,
+		type: TOKEN_TYPE.SURNAME,
+		start,
+		end
+	};
+	return {
+		text,
+		type: TOKEN_TYPE.CAPITALIZED,
+		start,
+		end
+	};
+};
+/**
+* Detect person names by looking up tokens against the
+* name corpus, then chaining adjacent name-like tokens.
+*
+* Requires initNameCorpus() to have been called first.
+* If not initialized, returns an empty array.
+*
+* Scoring:
+*   TITLE + NAME/SURNAME       → 0.95
+*   NAME + NAME/SURNAME        → 0.9
+*   SURNAME + NAME/SURNAME     → 0.9
+*   NAME + CAPITALIZED         → 0.7
+*   ABBREVIATION + NAME        → 0.7
+*   Standalone NAME            → 0.5 (low confidence)
+*   Standalone SURNAME         → skip (too ambiguous)
+*/
+const detectNameCorpus = (fullText, ctx = defaultContext) => {
+	const corpus = getCorpus(ctx);
+	if (!corpus) return [];
+	const tokens = segmentWords(fullText).map((w) => classifyToken(w, corpus));
+	const entities = [];
+	const consumed = /* @__PURE__ */ new Set();
+	for (let i = 0; i < tokens.length; i++) {
+		if (consumed.has(i)) continue;
+		const token = tokens[i];
+		if (!token) continue;
+		if (token.type !== TOKEN_TYPE.TITLE && token.type !== TOKEN_TYPE.NAME && token.type !== TOKEN_TYPE.SURNAME && token.type !== TOKEN_TYPE.ABBREVIATION) continue;
+		const MAX_CHAIN = 5;
+		const chain = [token];
+		let j = i + 1;
+		while (j < tokens.length && chain.length < MAX_CHAIN) {
+			const next = tokens[j];
+			if (!next) break;
+			const prev = chain.at(-1);
+			if (prev) {
+				const gap = fullText.slice(prev.end, next.start);
+				const breaksOnPeriod = gap.includes(".") && !isInitialContinuationGap$1(prev.text, gap);
+				if (gap.includes("\n") || PERSON_CHAIN_BREAK_RE$1.test(gap) || breaksOnPeriod) break;
+			}
+			if (next.type === TOKEN_TYPE.NAME || next.type === TOKEN_TYPE.SURNAME || next.type === TOKEN_TYPE.TITLE || next.type === TOKEN_TYPE.ABBREVIATION || next.type === TOKEN_TYPE.CAPITALIZED) {
+				chain.push(next);
+				j++;
+			} else break;
+		}
+		const hasTitle = chain.some((t) => t.type === TOKEN_TYPE.TITLE);
+		const hasCorpusName = chain.some((t) => isCorpusMatch(t.type));
+		const hasFirstName = chain.some((t) => t.type === TOKEN_TYPE.NAME);
+		const hasAbbreviation = chain.some((t) => t.type === TOKEN_TYPE.ABBREVIATION);
+		const corpusCount = chain.filter((t) => isCorpusMatch(t.type)).length;
+		const capitalizedCount = chain.filter((t) => t.type === TOKEN_TYPE.CAPITALIZED).length;
+		let score = 0;
+		if (hasTitle && hasCorpusName) score = .95;
+		else if (corpusCount >= 2) score = .9;
+		else if (hasCorpusName && capitalizedCount > 0) score = .7;
+		else if (hasAbbreviation && hasCorpusName) score = .7;
+		else if (hasFirstName && chain.length === 1) {
+			if (isSentenceStart(fullText, token.start)) continue;
+			score = .5;
+		} else if (!hasFirstName && chain.length === 1 && chain[0]?.type === TOKEN_TYPE.SURNAME) continue;
+		else if (hasTitle && chain.length === 1) continue;
+		else {
+			if (!hasCorpusName) continue;
+			score = .5;
 		}
+		const first = chain.at(0);
+		const last = chain.at(-1);
+		if (!first || !last) continue;
+		const start = first.start;
+		const end = last.end;
+		const text = fullText.slice(start, end);
+		for (let k = i; k < i + chain.length; k++) consumed.add(k);
+		entities.push({
+			start,
+			end,
+			label: "person",
+			text,
+			score,
+			source: DETECTION_SOURCES.REGEX
+		});
 	}
+	return entities;
 };
 //#endregion
-//#region src/util/char-groups.ts
-/**
-* Centralized Unicode character equivalence groups.
-*
-* Centralized Unicode character equivalence groups.
-*
-* Provides helpers to build regex character classes that
-* match all typographic variants of a character type
-* (dashes, spaces, quotes, etc.).
-*
-* The JSON is statically imported so the bundler inlines
-* it, avoiding a runtime require() that breaks browsers.
-*/
-/** Chars that need escaping inside a regex char class. */
-const REGEX_CLASS_SPECIAL = /[\\\]^-]/;
-const escapeForCharClass = (ch) => REGEX_CLASS_SPECIAL.test(ch) ? `\\${ch}` : ch;
-const config = char_groups_default;
+//#region src/config/titles.ts
 /**
-* Get the raw characters for a named group.
-* Throws if the group does not exist.
+* Academic and professional title prefixes.
+* Plain text; the detector auto-escapes for regex.
+* Sorted longest-first at build time.
 */
-const charSet = (group) => {
-	const g = config.groups[group];
-	if (!g) throw new Error(`Unknown char group: "${group}"`);
-	return g.chars.map((entry) => entry.char);
-};
+const TITLE_PREFIXES = [
+	"Ing.",
+	"Mgr.",
+	"MgA.",
+	"Bc.",
+	"BcA.",
+	"JUDr.",
+	"MUDr.",
+	"MVDr.",
+	"MDDr.",
+	"PhDr.",
+	"RNDr.",
+	"PaedDr.",
+	"ThDr.",
+	"ThLic.",
+	"ICDr.",
+	"RSDr.",
+	"PharmDr.",
+	"artD.",
+	"akad.",
+	"doc.",
+	"prof.",
+	"ao. Univ.-Prof.",
+	"o. Univ.-Prof.",
+	"Univ.-Prof.",
+	"Hon.-Prof.",
+	"em. Prof.",
+	"Dr. med. dent.",
+	"Dr. med. vet.",
+	"Dr. med.",
+	"Dr. rer. nat.",
+	"Dr. rer. soc.",
+	"Dr. rer. pol.",
+	"Dr. sc. tech.",
+	"Dr. sc. nat.",
+	"Dr. sc. hum.",
+	"Dr. iur.",
+	"Dr. jur.",
+	"Dr. theol.",
+	"Dr. oec.",
+	"Dr. techn.",
+	"Dr. h. c.",
+	"Dr. phil.",
+	"Dr.-Ing.",
+	"Dr. Ing.",
+	"Dr.",
+	"Dipl.-Wirt.-Ing.",
+	"Dipl.-Betriebsw.",
+	"Dipl.-Inform.",
+	"Dipl.-Volksw.",
+	"Dipl.-Psych.",
+	"Dipl.-Phys.",
+	"Dipl.-Chem.",
+	"Dipl.-Biol.",
+	"Dipl.-Math.",
+	"Dipl.-Päd.",
+	"Dipl.-Soz.",
+	"Dipl.-Kfm.",
+	"Dipl.-Jur.",
+	"Dipl. Ing.",
+	"Dipl.-Ing.",
+	"Mag. rer. soc. oec.",
+	"Mag. rer. nat.",
+	"Mag. phil.",
+	"Mag. iur.",
+	"Mag. arch.",
+	"Mag. pharm.",
+	"Mag. (FH)",
+	"Mag.",
+	"Bakk. rer. nat.",
+	"Bakk. techn.",
+	"Bakk. phil.",
+	"Bakk.",
+	"Lic. phil.",
+	"Lic. iur.",
+	"Lic. oec.",
+	"Lic. theol.",
+	"Lic.",
+	"Priv.-Doz.",
+	"PD",
+	"RA"
+];
 /**
-* Build a regex character class string for a named
-* group. E.g., charClass("dash") returns a string
-* like "[-\u2013\u2014\u2010\u2011\u2212\u2043]".
-*
-* The hyphen-minus is placed first so it is treated
-* as a literal, not a range indicator.
+* Courtesy/honorific titles that precede a person's
+* name. Sorted alphabetically. The detector escapes
+* dots and adds \b for entries in HONORIFIC_BOUNDARY.
 */
-const charClass = (group) => {
-	return `[${[...charSet(group)].sort((a, b) => {
-		if (a === "-") return -1;
-		if (b === "-") return 1;
-		return a.localeCompare(b);
-	}).map(escapeForCharClass).join("")}]`;
-};
+const HONORIFICS = [
+	"Avv.",
+	"Dame",
+	"Doamna",
+	"Domnul",
+	"Don",
+	"Doña",
+	"Dott.",
+	"Judge",
+	"Justice",
+	"Lady",
+	"Lord",
+	"M.",
+	"Madame",
+	"Mademoiselle",
+	"Maître",
+	"Me",
+	"Messrs",
+	"Miss",
+	"Mlle",
+	"Mme",
+	"Monsieur",
+	"Mr",
+	"Mrs",
+	"Ms",
+	"Pr",
+	"Pr.",
+	"President",
+	"Señor",
+	"Señora",
+	"Sig.",
+	"Sig.ra",
+	"Signor",
+	"Signora",
+	"Signorina",
+	"Sir",
+	"Sr.",
+	"Sra."
+];
 /**
-* Return the inner content of a character class (without
-* the surrounding brackets). Useful for embedding a group
-* inside a larger character class, e.g.:
-*   `[\\s&,.${charClassInner("dash")}]`
+* Honorifics that need \b word-boundary anchors
+* (short or common words that could match mid-word).
 */
-const charClassInner = (group) => {
-	return [...charSet(group)].sort((a, b) => {
-		if (a === "-") return -1;
-		if (b === "-") return 1;
-		return a.localeCompare(b);
-	}).map(escapeForCharClass).join("");
-};
-/** Regex char class matching all dash variants. */
-const DASH = charClass("dash");
+const HONORIFIC_BOUNDARY = new Set([
+	"Don",
+	"Doña",
+	"M.",
+	"Me",
+	"Pr",
+	"Pr.",
+	"Señor",
+	"Señora"
+]);
 /**
-* Inner content of the dash char class (no brackets).
-* For embedding inside a larger character class:
-*   `[\\s&,.${DASH_INNER}]`
-*/
-const DASH_INNER = charClassInner("dash");
-charClass("space");
-charClass("quote-double");
-charClass("quote-single");
-charClass("slash");
-charClass("dot");
-charClass("colon");
+* Post-nominal degrees (comma or space separated after name).
+* Plain text; the detector auto-escapes for regex.
+*/
+const POST_NOMINALS = [
+	"Ph.D.",
+	"Ph.D",
+	"CSc.",
+	"DrSc.",
+	"ArtD.",
+	"D.Phil.",
+	"DPhil.",
+	"MPhil.",
+	"MBA",
+	"MPA",
+	"LL.M.",
+	"LL.B.",
+	"M.Sc.",
+	"B.Sc.",
+	"MSc.",
+	"BSc.",
+	"M.Eng.",
+	"B.Eng.",
+	"M.A.",
+	"B.A.",
+	"JCD",
+	"JD",
+	"DiS.",
+	"ACCA",
+	"FCCA",
+	"CIPM",
+	"CIPT",
+	"CIPP/E",
+	"CIPP"
+];
 //#endregion
 //#region src/detectors/regex.ts
 const MIN_PHONE_LENGTH = 7;
 const MIN_MONTH_NAME_LENGTH = 3;
 const escapeTitle = (title) => title.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\s+/g, "\\s*");
 /** Escape for use inside a regex alternation. */
-const escapeRegex$1 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const escapeRegex$2 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 /** Escape for use inside a regex character class. */
 const escapeCharClass = (s) => s.replace(/[\]\\^-]/g, "\\$&");
 const TITLE_PREFIX = TITLE_PREFIXES.toSorted((a, b) => b.length - a.length).map(escapeTitle).join("|");
 const POST_NOMINAL = POST_NOMINALS.toSorted((a, b) => b.length - a.length).map(escapeTitle).join("|");
-const NAME_WORD = `[A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ][a-záčďéěíňóřšťúůýžäöüß]+`;
+const NAME_WORD = `\\p{Lu}\\p{Ll}+`;
 const PARTICLE = "(?:van der|van den|de la|della|von|van|dos|ibn|ben|bin|del|zum|zur|ten|ter|da|de|di|al|el|le|la|zu|af|av)";
 const SP = "[^\\S\\n\\t]";
 /** Honorific alternation built from titles.ts config. */
 const HONORIFIC_ALT = [...HONORIFICS].toSorted((a, b) => b.length - a.length).map((h) => {
-	const escaped = escapeRegex$1(h);
+	const escaped = escapeRegex$2(h);
 	return HONORIFIC_BOUNDARY.has(h) ? `\\b${escaped}` : escaped;
 }).join("|");
 const toEntry = (validator, label, score) => {
@@ -1670,8 +2217,6 @@ const toEntry = (validator, label, score) => {
 const STDNUM_ENTRIES = [
 	toEntry(hu.vat, "tax identification number", .95),
 	toEntry(it.codiceFiscale, "national identification number", .95),
-	toEntry(es.dni, "national identification number", .9),
-	toEntry(es.nie, "national identification number", .95),
 	toEntry(se.personnummer, "national identification number", .9),
 	toEntry(ro.cnp, "national identification number", .95),
 	toEntry(fr.nir, "social security number", .9),
@@ -1697,7 +2242,6 @@ const STDNUM_ENTRIES = [
 	toEntry(fi.ytunnus, "registration number", .9),
 	toEntry(bg.vat, "tax identification number", .95),
 	toEntry(sk.dic, "tax identification number", .95),
-	toEntry(es.cif, "registration number", .95),
 	toEntry(es.vat, "tax identification number", .95),
 	toEntry(es.nss, "social security number", .9),
 	toEntry(fr.tva, "tax identification number", .95),
@@ -1719,7 +2263,9 @@ const STDNUM_ENTRIES = [
 	toEntry(ee.ik, "national identification number", .9),
 	toEntry(cy.vat, "tax identification number", .95),
 	toEntry(mt.vat, "tax identification number", .95),
-	toEntry(lu.vat, "tax identification number", .95)
+	toEntry(lu.vat, "tax identification number", .95),
+	toEntry(br.cpf, "tax identification number", .95),
+	toEntry(br.cnpj, "tax identification number", .95)
 ].filter((e) => e !== null);
 const TITLED_PERSON = {
 	pattern: `(?:${TITLE_PREFIX})(?:${SP}+(?:${TITLE_PREFIX}))*${SP}+(?:${NAME_WORD})(?:${SP}{1,4}(?:${PARTICLE}${SP}+)?${NAME_WORD}){1,3}(?:,?${SP}+(?:${POST_NOMINAL})(?:,?${SP}+(?:${POST_NOMINAL}))*)?`,
@@ -1768,7 +2314,7 @@ const CREDIT_CARD = {
 };
 const CZ_BIRTH_NUMBER = {
 	pattern: `\\b\\d{6}/\\d{3,4}\\b`,
-	label: "czech birth number",
+	label: "birth number",
 	score: 1,
 	validator: cz.rc
 };
@@ -1802,6 +2348,51 @@ const CZ_POSTAL = {
 	label: "address",
 	score: .7
 };
+const ES_POSTAL = {
+	pattern: "\\b(?:C\\.?P\\.?|[Cc][óo]digo[^\\S\\n]+postal)[^\\S\\n]{0,3}:?[^\\S\\n]{0,3}\\d{5}\\b",
+	label: "address",
+	score: .7
+};
+const ES_DNI = {
+	pattern: `\\b\\d{8}-?[A-Za-z]\\b`,
+	label: "national identification number",
+	score: .9,
+	validator: es.dni
+};
+const ES_NIE = {
+	pattern: `\\b[XYZxyz]-?\\d{7}-?[A-Za-z]\\b`,
+	label: "national identification number",
+	score: .95,
+	validator: es.nie
+};
+const ES_CIF = {
+	pattern: `\\b[A-HJNP-SUVWa-hjnp-suvw]-?\\d{7}-?[0-9A-Ja-j]\\b`,
+	label: "registration number",
+	score: .95,
+	validator: es.cif
+};
+const BR_CPF_FORMATTED = {
+	pattern: `\\b\\d{3}\\.\\d{3}\\.\\d{3}${DASH}\\d{2}\\b`,
+	label: "tax identification number",
+	score: .95,
+	validator: br.cpf
+};
+const BR_CNPJ_FORMATTED = {
+	pattern: `\\b\\d{2}\\.\\d{3}\\.\\d{3}/\\d{4}${DASH}\\d{2}\\b`,
+	label: "tax identification number",
+	score: .95,
+	validator: br.cnpj
+};
+const BR_RG_WITH_SSP = {
+	pattern: `\\b\\d{1,3}\\.?\\d{3}\\.?\\d{3}(?:${DASH}[0-9A-Za-z])?[^\\S\\n]+SSP(?:/[A-Z]{2})?\\b`,
+	label: "national identification number",
+	score: .95
+};
+const BR_OAB = {
+	pattern: "\\bOAB/[A-Z]{2}[^\\S\\n]+(?:n[º°.][^\\S\\n]*)?(?:\\d{1,3}(?:\\.\\d{3})+|\\d{4,6})\\b",
+	label: "registration number",
+	score: .95
+};
 const URL = {
 	pattern: "(?:https?://|https?:(?=[^\\s])|www\\.)[\\w\\-]+(?:\\.[\\w\\-]+)+(?::\\d+)?(?:[/?#][^\\s)\\]>]*[^\\s.,;:!?)\\]>])?",
 	label: "url",
@@ -1843,6 +2434,14 @@ const ALL_REGEX_DEFS = [
 	CZ_BANK_ACCOUNT,
 	HU_LANDLINE,
 	CZ_POSTAL,
+	ES_POSTAL,
+	ES_DNI,
+	ES_NIE,
+	ES_CIF,
+	BR_CPF_FORMATTED,
+	BR_CNPJ_FORMATTED,
+	BR_RG_WITH_SSP,
+	BR_OAB,
 	URL,
 	{
 		pattern: "\\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\\b|\\b(?:[0-9a-fA-F]{1,4}:){1,7}:\\b|::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}",
@@ -1894,7 +2493,7 @@ const buildMonthAlternation = (months) => {
 			if (clean.length >= MIN_MONTH_NAME_LENGTH) seen.add(clean);
 		}
 	}
-	return [...seen].toSorted((a, b) => b.length - a.length).map(escapeRegex$1).join("|");
+	return [...seen].toSorted((a, b) => b.length - a.length).map(escapeRegex$2).join("|");
 };
 /**
 * Build date patterns from a month-name alternation.
@@ -1951,11 +2550,11 @@ const buildCurrencyPatterns = (data) => {
 	const isAsciiAlpha = /^[a-zA-Z\s]+$/;
 	const parts = data.codes.map((code) => ({
 		len: code.length,
-		alt: escapeRegex$1(code)
+		alt: escapeRegex$2(code)
 	}));
 	const MIN_CI_LENGTH = 3;
 	if (data.localNames) for (const name of data.localNames) {
-		const escaped = escapeRegex$1(name);
+		const escaped = escapeRegex$2(name);
 		if (isAsciiAlpha.test(name) && name.length >= MIN_CI_LENGTH) parts.push({
 			len: name.length,
 			alt: `(?i:${escaped})`
@@ -1967,7 +2566,7 @@ const buildCurrencyPatterns = (data) => {
 	}
 	if (symbols) for (const ch of data.symbols) parts.push({
 		len: ch.length,
-		alt: escapeRegex$1(ch)
+		alt: escapeRegex$2(ch)
 	});
 	const trailingAlt = parts.toSorted((a, b) => b.len - a.len).map((p) => p.alt).join("|");
 	if (!symbols && !trailingAlt) return [];
@@ -2019,290 +2618,70 @@ const processRegexMatches = (allMatches, sliceStart, sliceEnd, meta_) => {
 	for (const match of allMatches) {
 		const idx = match.pattern;
 		if (idx < sliceStart || idx >= sliceEnd) continue;
-		const meta = meta_[idx - sliceStart];
-		if (!meta) continue;
-		if (meta.sourceDetail !== "custom-regex" && meta.label === "phone number" && match.text.length < MIN_PHONE_LENGTH) continue;
-		if (meta.validator) {
-			const compacted = meta.validator.compact(match.text);
-			if (!meta.validator.validate(compacted).valid) continue;
-		}
-		const entity = {
-			start: match.start,
-			end: match.end,
-			label: meta.label,
-			text: match.text,
-			score: meta.score,
-			source: DETECTION_SOURCES.REGEX
-		};
-		if (meta.sourceDetail) entity.sourceDetail = meta.sourceDetail;
-		results.push(entity);
-	}
-	return results;
-};
-/**
-* Build signing clause place-name patterns from
-* signing-clauses.json. Each pattern captures the
-* city/place name from contract signing locations.
-*
-* The place name sub-pattern:
-*   \p{Lu}\p{Ll}+ (capitalized word)
-*   optionally followed by preposition + capitalized
-*   word (for "nad Nisou", "am Main", etc.)
-*   optionally followed by more capitalized words
-*   (for "Hradec Králové", "New York", etc.)
-*/
-const buildSigningClausePatterns = (data) => {
-	const patterns = [];
-	for (const entry of data.patterns) {
-		const prepAlt = entry.prepositions.length > 0 ? entry.prepositions.join("|") : null;
-		const place = prepAlt ? `(\\p{Lu}\\p{Ll}+(?:\\s+(?:${prepAlt})\\s+\\p{Lu}\\p{Ll}+)*(?:\\s+\\p{Lu}\\p{Ll}+)*)` : `(\\p{Lu}\\p{Ll}+(?:[- ]\\p{Lu}\\p{Ll}+)*)`;
-		const full = `(?:^|\\n|[^\\S\\n])` + entry.prefix + place + (entry.suffix ? `(?:${entry.suffix})` : "");
-		patterns.push(full);
-	}
-	return patterns;
-};
-const SIGNING_CLAUSE_META = {
-	label: "address",
-	score: .9
-};
-let signingPatternPromise = null;
-const loadSigningPatterns = async () => {
-	const mod = await import("./signing-clauses.mjs");
-	return buildSigningClausePatterns(mod.default ?? mod);
-};
-const getSigningClausePatterns = () => {
-	if (!signingPatternPromise) signingPatternPromise = loadSigningPatterns().catch((err) => {
-		signingPatternPromise = null;
-		throw err;
-	});
-	return signingPatternPromise;
-};
-//#endregion
-//#region src/detectors/legal-forms.ts
-const UPPER = "A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽÄÖÜÀÂÆÇÈÊËÎÏÔÙÛŸÑ\\u0130";
-const LOWER = "a-záčďéěíňóřšťúůýžäöüßàâæçèêëîïôùûÿñ\\u0131";
-const CAP_WORD = `(?:[${UPPER}]{2,}|[${UPPER}][${LOWER}${UPPER}]+)`;
-const ANY_WORD = `(?:[${UPPER}${LOWER}][${LOWER}${UPPER}]+|[${UPPER}]{2,3}|\\d{1,4})`;
-const ALLCAP_WORD = `[${UPPER}]{2,}`;
-const ROMAN_NUMERAL_RE = /^(?=[IVXLCDM])M{0,3}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3})$/;
-const escapeForRegex = (form) => form.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\s+/g, "\\s+").replace(/\\\./g, "\\.[^\\S\\n]?");
-const isShortForm = (form) => form.replace(/[.\s]/g, "").length <= 3 && !form.includes(" ");
-const buildPatternString = (forms) => {
-	if (forms.length === 0) return null;
-	const alt = forms.toSorted((a, b) => b.length - a.length).map(escapeForRegex).join("|");
-	return `${`(?:${CAP_WORD})(?:${`(?:[\\s&,.${DASH_INNER}]{1,4}|${`\\s+(?:a|and|und|et|e|y|i)\\s+(?=[${LOWER}])`})`}(?:${ANY_WORD})){0,10}`}(?:\\s+|,\\s*)(?:${alt})(?![${LOWER}])`;
-};
-/**
-* Build legal form regex pattern strings.
-* Returns an array of regex strings for the unified
-* TextSearch builder. Empty if data package is not
-* installed.
-*/
-const buildLegalFormPatterns = async () => {
-	let data = {};
-	try {
-		data = (await import("./legal-forms.mjs")).default;
-	} catch {
-		return [];
-	}
-	const allForms = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const forms of Object.values(data)) for (const form of forms) {
-		const key = form.toLowerCase();
-		if (!seen.has(key)) {
-			seen.add(key);
-			allForms.push(form);
-		}
-	}
-	const patterns = [];
-	const longPattern = buildPatternString(allForms.filter((f) => !isShortForm(f)));
-	if (longPattern) patterns.push(longPattern);
-	const shortPattern = buildPatternString(allForms.filter(isShortForm));
-	if (shortPattern) patterns.push(shortPattern);
-	const allcapPrefix = `(?:${ALLCAP_WORD})(?:[\\s&,.${DASH_INNER}]{1,4}(?:${ALLCAP_WORD})){0,2}`;
-	const allcapAlt = allForms.toSorted((a, b) => b.length - a.length).map(escapeForRegex).join("|");
-	patterns.push(`${allcapPrefix}(?:\\s+|,\\s*)(?:${allcapAlt})(?![${LOWER}])`);
-	return patterns;
-};
-const CONNECTOR_RE = /^(?:a|and|und|et|e|y|i|&)$/i;
-const LEADING_CLAUSE_RE = /(?:^|\s)(?:by\s+and\s+between|is\s+between)\s+/giu;
-/**
-* Find the word ending just before `pos` in `text`,
-* skipping any whitespace (not newlines).
-* Returns null if no word is found (e.g., at start
-* of text, or preceded by non-word chars like ".").
-*/
-const findWordBefore = (text, pos) => {
-	let scan = pos - 1;
-	while (scan >= 0) {
-		const ch = text.charAt(scan);
-		if (ch === "\n" || !/\s/.test(ch)) break;
-		scan--;
-	}
-	if (scan < 0 || text.charAt(scan) === "\n") return null;
-	const wordEnd = scan + 1;
-	while (scan >= 0 && /[\p{L}\p{M}&]/u.test(text.charAt(scan))) scan--;
-	const wordStart = scan + 1;
-	const word = text.slice(wordStart, wordEnd);
-	if (word.length === 0) return null;
-	return {
-		word,
-		start: wordStart
-	};
-};
-/**
-* Extend a match backward through uppercase words and
-* lowercase connectors. Stops at start of text,
-* newline, or a word that doesn't qualify.
-*
-* Connectors (a, and, und, et, ...) are only consumed
-* when there is a valid word before them — a trailing
-* connector at an entity boundary is not consumed.
-*/
-const extendBackward = (fullText, matchStart) => {
-	let pos = matchStart;
-	while (pos > 0) {
-		const found = findWordBefore(fullText, pos);
-		if (!found) break;
-		const { word, start: wordStart } = found;
-		const isUpper = /^\p{Lu}/u.test(word);
-		const isConnector = CONNECTOR_RE.test(word);
-		if (isUpper) pos = wordStart;
-		else if (isConnector) {
-			const prev = findWordBefore(fullText, wordStart);
-			if (!prev) break;
-			if (!/^\p{Lu}/u.test(prev.word)) break;
-			pos = prev.start;
-		} else break;
-	}
-	return pos;
-};
-const trimLeadingClause = (text) => {
-	let cut = -1;
-	for (const match of text.matchAll(LEADING_CLAUSE_RE)) cut = match.index + match[0].length;
-	if (cut <= 0) return {
-		offset: 0,
-		text
-	};
-	const trimmed = text.slice(cut);
-	const leadingWs = trimmed.match(/^\s*/u)?.[0].length ?? 0;
-	return {
-		offset: cut + leadingWs,
-		text: trimmed.slice(leadingWs)
-	};
-};
-/**
-* Process legal form matches from the unified search.
-* Receives all matches; filters to the legal forms
-* slice via sliceStart/sliceEnd.
-*/
-const processLegalFormMatches = (allMatches, sliceStart, sliceEnd, fullText) => {
-	const results = [];
-	for (const match of allMatches) {
-		const idx = match.pattern;
-		if (idx < sliceStart || idx >= sliceEnd) continue;
-		const text = match.text.trimEnd();
-		if (text.length < 5) continue;
-		if (text.includes("\n")) continue;
-		let entityStart = match.start;
-		let entityText = text;
-		if (fullText) {
-			const extended = extendBackward(fullText, match.start);
-			if (extended < match.start) {
-				entityStart = extended;
-				entityText = fullText.slice(extended, match.start + text.length).trimEnd();
-			}
-		}
-		const clauseTrim = trimLeadingClause(entityText);
-		if (clauseTrim.offset > 0) {
-			entityStart += clauseTrim.offset;
-			entityText = clauseTrim.text;
-		}
-		const getPrefixInfo = (value) => {
-			const prefixEnd = value.lastIndexOf(",") !== -1 ? value.lastIndexOf(",") : value.lastIndexOf(" ");
-			return {
-				prefixEnd,
-				prefixPart: prefixEnd > 0 ? value.slice(0, prefixEnd).replace(/[^a-zA-ZÀ-ž]/g, "") : value.replace(/[^a-zA-ZÀ-ž]/g, "")
-			};
-		};
-		let { prefixEnd, prefixPart } = getPrefixInfo(entityText);
-		let isAllCapsMatch = prefixPart.length > 2 && prefixPart === prefixPart.toUpperCase();
-		if (isAllCapsMatch && fullText) {
-			const lineStart = fullText.lastIndexOf("\n", entityStart);
-			const lineEnd = fullText.indexOf("\n", entityStart + entityText.length);
-			const lineLetters = fullText.slice(lineStart + 1, lineEnd === -1 ? fullText.length : lineEnd).replace(/[^a-zA-ZÀ-ž]/g, "");
-			const upperCount = [...lineLetters].filter((c) => c === c.toUpperCase()).length;
-			if (lineLetters.length > 5 && upperCount / lineLetters.length >= .95) continue;
-			if ((prefixPart.length > 0 ? entityText.slice(0, prefixEnd > 0 ? prefixEnd : entityText.length).trim().split(/\s+/).length : 0) > 3) {
-				entityStart = match.start;
-				entityText = text;
-				({prefixEnd, prefixPart} = getPrefixInfo(entityText));
-				isAllCapsMatch = prefixPart.length > 2 && prefixPart === prefixPart.toUpperCase();
-			}
-		} else if (isAllCapsMatch) continue;
-		const lastSpace = entityText.lastIndexOf(" ");
-		const rawSuffix = lastSpace !== -1 ? entityText.slice(lastSpace + 1) : "";
-		const suffixClean = rawSuffix.replace(/[.,]/g, "");
-		if (suffixClean.length > 0 && ROMAN_NUMERAL_RE.test(suffixClean)) continue;
-		if (suffixClean.length <= 2 && !/\./.test(rawSuffix) && /[^\x00-\x7F]/.test(entityText.slice(0, lastSpace !== -1 ? lastSpace : entityText.length))) continue;
-		results.push({
-			start: entityStart,
-			end: entityStart + entityText.length,
-			label: "organization",
-			text: entityText,
-			score: .95,
-			source: DETECTION_SOURCES.LEGAL_FORM
-		});
+		const meta = meta_[idx - sliceStart];
+		if (!meta) continue;
+		if (meta.sourceDetail !== "custom-regex" && meta.label === "phone number" && match.text.length < MIN_PHONE_LENGTH) continue;
+		if (meta.validator) {
+			const compacted = meta.validator.compact(match.text);
+			if (!meta.validator.validate(compacted).valid) continue;
+		}
+		const entity = {
+			start: match.start,
+			end: match.end,
+			label: meta.label,
+			text: match.text,
+			score: meta.score,
+			source: DETECTION_SOURCES.REGEX
+		};
+		if (meta.sourceDetail) entity.sourceDetail = meta.sourceDetail;
+		results.push(entity);
 	}
 	return results;
 };
-//#endregion
-//#region src/config/legal-forms.ts
 /**
-* Known legal form suffixes. Shared between trigger
-* detection (reclassification) and org-propagation
-* (suffix stripping). Within each family of related
-* forms, longer variants come first so that
-* "spol. s r.o." matches before "s.r.o." and
-* "s. r. o." matches before "s.r.o.".
+* Build signing clause place-name patterns from
+* signing-clauses.json. Each pattern captures the
+* city/place name from contract signing locations.
+*
+* The place name sub-pattern:
+*   \p{Lu}\p{Ll}+ (capitalized word)
+*   optionally followed by preposition + capitalized
+*   word (for "nad Nisou", "am Main", etc.)
+*   optionally followed by more capitalized words
+*   (for "Hradec Králové", "New York", etc.)
 */
-const LEGAL_SUFFIXES = [
-	"spol. s r.o.",
-	"s.r.o.",
-	"s. r. o.",
-	"a.s.",
-	"a. s.",
-	"v.o.s.",
-	"v. o. s.",
-	"k.s.",
-	"k. s.",
-	"z.s.",
-	"z. s.",
-	"z.ú.",
-	"z. ú.",
-	"o.p.s.",
-	"o. p. s.",
-	"s.p.",
-	"s. p.",
-	"GmbH",
-	"AG",
-	"SE",
-	"KG",
-	"OHG",
-	"Ltd.",
-	"Ltd",
-	"LLC",
-	"LLP",
-	"Inc.",
-	"S.A.",
-	"SA",
-	"SAS",
-	"SARL",
-	"Sp. z o.o.",
-	"S.p.A."
-];
+const buildSigningClausePatterns = (data) => {
+	const patterns = [];
+	for (const entry of data.patterns) {
+		const prepAlt = entry.prepositions.length > 0 ? entry.prepositions.join("|") : null;
+		const place = prepAlt ? `(\\p{Lu}\\p{Ll}+(?:\\s+(?:${prepAlt})\\s+\\p{Lu}\\p{Ll}+)*(?:\\s+\\p{Lu}\\p{Ll}+)*)` : `(\\p{Lu}\\p{Ll}+(?:[- ]\\p{Lu}\\p{Ll}+)*)`;
+		const full = `(?:^|\\n|[^\\S\\n])` + entry.prefix + place + (entry.suffix ? `(?:${entry.suffix})` : "");
+		patterns.push(full);
+	}
+	return patterns;
+};
+const SIGNING_CLAUSE_META = {
+	label: "address",
+	score: .9
+};
+let signingPatternPromise = null;
+const loadSigningPatterns = async () => {
+	const mod = await import("./signing-clauses.mjs");
+	return buildSigningClausePatterns(mod.default ?? mod);
+};
+const getSigningClausePatterns = () => {
+	if (!signingPatternPromise) signingPatternPromise = loadSigningPatterns().catch((err) => {
+		signingPatternPromise = null;
+		throw err;
+	});
+	return signingPatternPromise;
+};
 //#endregion
 //#region src/detectors/triggers.ts
+const VALID_ID_VALIDATORS = {
+	"br.cpf": br.cpf,
+	"br.cnpj": br.cnpj
+};
 const TRIGGER_SCORE = .95;
 const WHITESPACE_RE$1 = /\s+/;
 const LETTER_RE = /\p{L}/u;
@@ -2317,12 +2696,23 @@ const DECIMAL_COMMA_RE = new RegExp(`^,(?:\\d|${DASH}{1,2})`);
 * etc.), skip the comma and degree, then continue.
 */
 const POST_NOMINAL_RE = new RegExp(`^,\\s*(?:${POST_NOMINALS.toSorted((a, b) => b.length - a.length).map((d) => d.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\./g, "\\.\\s*")).join("|")})\\.?`, "i");
-const LEGAL_FORM_CHECK_RE = new RegExp(LEGAL_SUFFIXES.map((f) => {
-	const escaped = f.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\./g, "\\.\\s*");
-	const isDotFree = !f.includes(".");
-	const isShort = f.length <= 4;
-	return isDotFree && isShort ? `\\b${escaped}\\b` : escaped;
-}).join("|"));
+const buildLegalFormCheckRe = (forms) => {
+	const parts = forms.map((f) => {
+		const escaped = f.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\./g, "\\.\\s*");
+		return /^[\p{L}\p{M}]+$/u.test(f) ? `(?<![\\p{L}\\p{N}])${escaped}(?![\\p{L}\\p{N}])` : escaped;
+	});
+	return new RegExp(parts.join("|"), "u");
+};
+let cachedLegalFormCheckRe = null;
+let cachedLegalFormCheckSource = null;
+const getLegalFormCheckRe = () => {
+	const source = getKnownLegalSuffixes();
+	if (cachedLegalFormCheckSource !== source || cachedLegalFormCheckRe === null) {
+		cachedLegalFormCheckSource = source;
+		cachedLegalFormCheckRe = buildLegalFormCheckRe(source);
+	}
+	return cachedLegalFormCheckRe;
+};
 const compileValidations = (validations) => validations.map((v) => {
 	switch (v.type) {
 		case "starts-uppercase": return {
@@ -2349,6 +2739,17 @@ const compileValidations = (validations) => validations.map((v) => {
 			type: "matches-pattern",
 			re: new RegExp(v.pattern, (v.flags ?? "").replace(/[gy]/g, ""))
 		};
+		case "valid-id": {
+			const validator = VALID_ID_VALIDATORS[v.validator];
+			if (!validator) throw new Error(`Unknown valid-id validator: ${JSON.stringify(v.validator)}`);
+			return {
+				type: "valid-id",
+				check: (value) => {
+					const compact = value.replace(/[\s.\-/]/g, "");
+					return validator.validate(compact).valid;
+				}
+			};
+		}
 		default: throw new Error(`Unknown validation type: ${JSON.stringify(v)}`);
 	}
 });
@@ -2372,6 +2773,9 @@ const applyValidations = (text, validations) => {
 		case "matches-pattern":
 			if (!v.re.test(text)) return false;
 			break;
+		case "valid-id":
+			if (!v.check(text)) return false;
+			break;
 		default: throw new Error(`Unknown compiled validation type: ${JSON.stringify(v)}`);
 	}
 	return true;
@@ -2466,8 +2870,10 @@ const buildTriggerPatterns = async () => {
 			strategy: rule.strategy.type
 		});
 	}
+	const patterns = rules.map((r) => r.trigger.toLowerCase());
+	await loadAddressStopKeywords();
 	return {
-		patterns: rules.map((r) => r.trigger.toLowerCase()),
+		patterns,
 		rules
 	};
 };
@@ -2488,14 +2894,103 @@ const stripQuotes = (value) => {
 const COMMA_STOP_CHARS = new Set([
 	"\n",
 	"(",
-	"	"
+	"	",
+	";"
 ]);
 /**
+* Sentence-terminator detection: a period that genuinely ends
+* one clause and starts another. Used by `to-next-comma` so
+* governing-law clauses ("…State of New York. SECTION 2…")
+* don't sweep across the period.
+*
+* Three positive signals (any one terminates):
+*   1. Long lowercase tail before the dot (>= 5 letters) —
+*      catches "…construction. SECTION 2…", "…vykonává.".
+*   2. Currency/amount tail (zł, Kč, USD, €) — catches
+*      "…w kwocie 1000 zł. Termin płatności…".
+*   3. Proper-noun head: a capitalized word of >= 4 letters
+*      ending in lowercase, with no internal uppercase, AND
+*      a substantial next clause (Capital + >= 2 lowercase).
+*      Catches short city names that the lowercase-tail rule
+*      misses: "…z siedzibą w Łódź. Kapitał zakładowy…",
+*      "…seat in Brno. Section 2…".
+*
+* The rule must NOT fire on:
+*   - title abbreviations: "Mr.", "Mrs.", "Dr.", "Hon.",
+*     "Sr.", "Jr." (head <= 3 chars or insufficient Ll tail)
+*   - degree abbreviations: "Ph.D.", "RNDr.", "MUDr.",
+*     "Ing." (internal periods or internal uppercase block
+*      the proper-noun pattern)
+*   - street-type abbreviations: "Ste.", "Ave.", "Inc.",
+*     "ul.", "al.", "nábř." (lowercase initials or
+*     insufficient Ll tail)
+*   - small-word lowercase abbreviations: "prof.", "inż.",
+*     "hab." (no leading uppercase, so the proper-noun rule
+*     can't fire)
+*/
+const NEXT_IS_SENTENCE_START_RE = /^\.(?:\s+\p{Lu}|\s*$)/u;
+const SENTENCE_TAIL_RE = /\p{Ll}{5,}$/u;
+/**
+* Proper-noun tail: capital letter + >= 3 lowercase letters,
+* preceded by a non-letter and non-period (so we don't slice
+* into the middle of an acronym or a multi-dot abbreviation).
+* The 4-character minimum excludes 2–3-char titles ("Mr",
+* "Mrs", "Dr", "Inc", "Ste"); the all-lowercase tail
+* excludes mixed-case degrees ("RNDr", "MUDr").
+*/
+const PROPER_NOUN_HEAD_RE = /(?:^|[^\p{L}.])\p{Lu}\p{Ll}{3,}$/u;
+/**
+* Next clause begins with a real word: capital + >= 2
+* lowercase letters. Filters cases where a capitalized
+* abbreviation (e.g., "Smith Inc.") follows a proper noun,
+* which would otherwise look sentence-like.
+*/
+const NEXT_IS_REAL_SENTENCE_RE = /^\.\s+\p{Lu}\p{Ll}{2,}/u;
+/**
+* Short currency-abbreviation tail (zł, Kč, gr, Ft, kr,
+* лв, USD, PLN, EUR, …). When a period follows one of
+* these and the next token starts uppercase, treat it as
+* a sentence boundary even though the tail is too short
+* to satisfy `SENTENCE_TAIL_RE`. Without this, amount
+* triggers using `to-next-comma` swallow the following
+* clause: `"w kwocie 1000 zł. Termin płatności…"`.
+*
+* Currency codes are typically uppercase (`USD`, `PLN`)
+* but appear lowercased in informal writing (`pln`, `eur`);
+* local names mix case (`zł`, `Kč`, `Ft`); symbols
+* (`€`, `$`, `£`) appear after the amount as well. The
+* negative lookbehind on a letter ensures the abbreviation
+* is matched only as a standalone token; symbols are
+* matched unconditionally since they are not letters.
+*/
+const CURRENCY_TAIL_RE = /(?:(?<![\p{L}])(?:zł|Kč|gr|Ft|kr|лв|USD|PLN|EUR|CZK|GBP|CHF|HUF|RON|SEK|NOK|DKK)|[€$£])$/iu;
+const NUMERIC_SENTENCE_TAIL_RE = /\d$/;
+const isSentenceTerminator = (text, periodIndex) => {
+	const tail = text.slice(periodIndex);
+	if (!NEXT_IS_SENTENCE_START_RE.test(tail)) return false;
+	const head = text.slice(0, periodIndex);
+	if (SENTENCE_TAIL_RE.test(head) || CURRENCY_TAIL_RE.test(head) || NUMERIC_SENTENCE_TAIL_RE.test(head)) return true;
+	return PROPER_NOUN_HEAD_RE.test(head) && NEXT_IS_REAL_SENTENCE_RE.test(tail);
+};
+/**
 * Field-label keywords that terminate address scanning.
 * When a comma in the address strategy is followed by
 * one of these, the address stops before the keyword.
+*
+* The list is sourced from
+* `data/address-stop-keywords.json` (per-language so new
+* languages can drop in their own labels without
+* touching this file). `loadAddressStopKeywords` unions
+* every language into a single longest-first array;
+* `getAddressStopKeywordsSync` returns the cached union
+* and falls back to a seed list so the strategy keeps
+* working before the warmup promise resolves.
+*
+* The address strategy doesn't know the document
+* language, so a flat union is intentional: any
+* language's labels can appear in any address.
 */
-const ADDRESS_STOP_KEYWORDS = [
+const ADDRESS_STOP_KEYWORDS_SEED = [
 	"číslo účtu",
 	"registrační",
 	"zastoupen",
@@ -2518,6 +3013,52 @@ const ADDRESS_STOP_KEYWORDS = [
 	"bic",
 	"ič"
 ];
+let addressStopKeywordsCache = null;
+let addressStopKeywordsPromise = null;
+const loadAddressStopKeywords = async () => {
+	if (addressStopKeywordsCache) return addressStopKeywordsCache;
+	if (addressStopKeywordsPromise) return addressStopKeywordsPromise;
+	addressStopKeywordsPromise = (async () => {
+		let data = {};
+		try {
+			const mod = await import("./address-stop-keywords.mjs");
+			data = mod.default ?? mod;
+		} catch (err) {
+			console.warn("[anonymize] triggers: failed to load address-stop-keywords.json, falling back to seed list:", err);
+		}
+		const seen = /* @__PURE__ */ new Set();
+		const out = [];
+		const addAll = (list) => {
+			for (const kw of list) {
+				if (typeof kw !== "string" || kw.length === 0) continue;
+				const lower = kw.toLowerCase();
+				if (seen.has(lower)) continue;
+				seen.add(lower);
+				out.push(lower);
+			}
+		};
+		for (const [key, value] of Object.entries(data)) {
+			if (key.startsWith("_")) continue;
+			if (!Array.isArray(value)) continue;
+			addAll(value);
+		}
+		addAll(ADDRESS_STOP_KEYWORDS_SEED);
+		out.sort((a, b) => b.length - a.length);
+		addressStopKeywordsCache = out;
+		return out;
+	})();
+	return addressStopKeywordsPromise;
+};
+const getAddressStopKeywordsSync = () => addressStopKeywordsCache ?? ADDRESS_STOP_KEYWORDS_SEED;
+/**
+* Warm the address-stop-keywords cache. Pipeline callers
+* await this before invoking trigger detection so the
+* synchronous `extractValue` path uses the merged list
+* instead of the seed fallback.
+*/
+const warmAddressStopKeywords = async () => {
+	await loadAddressStopKeywords();
+};
 const extractValue = (text, triggerEnd, strategy, label) => {
 	const remaining = text.slice(triggerEnd);
 	const stripped = remaining.replace(/^[\s:;]+/, "");
@@ -2526,6 +3067,8 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 	if (valueText.length === 0) return null;
 	switch (strategy.type) {
 		case "to-next-comma": {
+			const stopWords = strategy.stopWords ?? [];
+			const stopWordRe = stopWords.length > 0 ? new RegExp(`^(?:${stopWords.map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})(?![\\p{L}\\p{N}])`, "iu") : null;
 			let end = 0;
 			let foundStop = false;
 			while (end < valueText.length) {
@@ -2534,6 +3077,14 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 					foundStop = true;
 					break;
 				}
+				if (ch === "." && isSentenceTerminator(valueText, end)) {
+					foundStop = true;
+					break;
+				}
+				if (stopWordRe !== null && (end === 0 || !/[\p{L}\p{N}]/u.test(valueText[end - 1] ?? "")) && stopWordRe.test(valueText.slice(end))) {
+					foundStop = true;
+					break;
+				}
 				if (ch === ",") {
 					const afterComma = valueText.slice(end);
 					if (DECIMAL_COMMA_RE.test(afterComma)) {
@@ -2562,6 +3113,8 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 			};
 		}
 		case "to-end-of-line": {
+			const consumed = remaining.length - valueText.length;
+			if (consumed > 0 && remaining.slice(0, consumed).includes("\n")) return null;
 			const LINE_STOPS = ["\n"];
 			let end = valueText.length;
 			for (const ch of LINE_STOPS) {
@@ -2582,7 +3135,8 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 			const tabIdx = valueText.indexOf("	");
 			const cellText = tabIdx !== -1 ? valueText.slice(0, tabIdx) : valueText;
 			const PUNCT_ONLY = /^[\p{P}\p{S}]+$/u;
-			const words = cellText.split(WHITESPACE_RE$1).filter((w) => !PUNCT_ONLY.test(w)).slice(0, strategy.count);
+			const NUMBER_MARKER = /^(?:n[ºo°.]|№)$/i;
+			const words = cellText.split(WHITESPACE_RE$1).filter((w) => !PUNCT_ONLY.test(w) && !NUMBER_MARKER.test(w)).slice(0, strategy.count);
 			if (words.length === 0) return null;
 			const firstWord = words[0];
 			if (firstWord === void 0) return null;
@@ -2605,14 +3159,22 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 		}
 		case "company-id-value": {
 			const raw = text.slice(triggerEnd);
-			const sepMatch = /^(?:\s*:\s*|\s+)/.exec(raw);
+			const triggerLastChar = text[triggerEnd - 1] ?? "";
+			const sepMatch = (triggerLastChar === "°" || triggerLastChar === "º" || triggerLastChar === "№" || triggerLastChar === "#" ? /^(?:\s*:\s*|\s+|)/ : /^(?:\s*:\s*|\s+)/).exec(raw);
 			if (!sepMatch) return null;
-			const afterSep = raw.slice(sepMatch[0].length);
-			const idMatch = /^[A-Z]{0,6}\s?\d[\d\s\-/]{4,}/i.exec(afterSep);
+			let afterSep = raw.slice(sepMatch[0].length);
+			const labelMatch = /^(?:nr\.?|numer|n[ºo°.]|№|no\.?)(?:\s*:\s*|\s+)/i.exec(afterSep);
+			let labelOffset = 0;
+			if (labelMatch) {
+				labelOffset = labelMatch[0].length;
+				afterSep = afterSep.slice(labelOffset);
+			}
+			const idMatch = /^[A-Z]{0,6}\s?(?:[A-Z0-9]{2}\s?)?\d{2}(?:(?<=\d)[A-Z]|[\d\s.\-/]){3,}/i.exec(afterSep);
 			if (!idMatch) return null;
-			const idText = idMatch[0].trim();
+			const trailingLetterMatch = /\d$/.test(idMatch[0]) ? /^[A-Z]/i.exec(afterSep.slice(idMatch[0].length)) : null;
+			const idText = (trailingLetterMatch ? idMatch[0] + trailingLetterMatch[0] : idMatch[0]).trim();
 			const leadingSpaces = idMatch[0].length - idMatch[0].trimStart().length;
-			const idStart = triggerEnd + sepMatch[0].length + leadingSpaces;
+			const idStart = triggerEnd + sepMatch[0].length + labelOffset + leadingSpaces;
 			return {
 				start: idStart,
 				end: idStart + idText.length,
@@ -2622,18 +3184,36 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 		case "address": {
 			const maxLen = strategy.maxChars ?? 120;
 			const UPPER_RE = /\p{Lu}/u;
+			const stopKeywords = getAddressStopKeywordsSync();
 			let end = 0;
 			while (end < valueText.length && end < maxLen) {
 				const ch = valueText[end];
 				if (ch === "\n" || ch === "(") break;
+				if (ch === " " || ch === "	") {
+					const afterWs = valueText.slice(end).trimStart().toLowerCase();
+					if (stopKeywords.some((kw) => {
+						if (!afterWs.startsWith(kw)) return false;
+						const next = afterWs[kw.length];
+						return next === void 0 || /[\s:;.,!?()\d]/.test(next);
+					})) break;
+				}
 				if (ch === ".") {
 					const next = valueText[end + 1];
 					const afterNext = valueText[end + 2];
+					const afterPeriod = valueText.slice(end + 1).replace(/^\s+/, "").toLowerCase();
+					if (afterPeriod.length > 0) {
+						if (getAddressStopKeywordsSync().some((kw) => {
+							if (!afterPeriod.startsWith(kw)) return false;
+							const afterKw = afterPeriod[kw.length];
+							return afterKw === void 0 || /[\s:;.,!?()\d]/.test(afterKw);
+						})) break;
+					}
 					if (next !== void 0 && (/\p{L}/u.test(next) || /\d/.test(next))) {
 						end++;
 						continue;
 					}
 					if (next === " " && afterNext !== void 0 && (/\p{L}/u.test(afterNext) || /\d/.test(afterNext))) {
+						if (isSentenceTerminator(valueText, end)) break;
 						end++;
 						continue;
 					}
@@ -2645,7 +3225,7 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 					const peekCh = valueText[peek];
 					if (peekCh === void 0) break;
 					const afterComma = valueText.slice(end + 1).trimStart().toLowerCase();
-					if (ADDRESS_STOP_KEYWORDS.some((kw) => {
+					if (getAddressStopKeywordsSync().some((kw) => {
 						if (!afterComma.startsWith(kw)) return false;
 						const next = afterComma[kw.length];
 						return next === void 0 || /[\s:;.,!?()\d]/.test(next);
@@ -2672,6 +3252,28 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 				text: extracted
 			};
 		}
+		case "match-pattern": {
+			const nlIdx = valueText.indexOf("\n");
+			const searchText = nlIdx === -1 ? valueText : valueText.slice(0, nlIdx);
+			if (searchText.length === 0) return null;
+			const flags = (strategy.flags ?? "").replace(/[gy]/g, "");
+			const anchoredSource = `^(?:${strategy.pattern})`;
+			let re;
+			try {
+				re = new RegExp(anchoredSource, flags);
+			} catch {
+				return null;
+			}
+			const m = re.exec(searchText);
+			if (!m || m[0].length === 0) return null;
+			const matchStart = m.index;
+			const matchEnd = matchStart + m[0].length;
+			return {
+				start: valueStart + matchStart,
+				end: valueStart + matchEnd,
+				text: m[0]
+			};
+		}
 		default: return null;
 	}
 };
@@ -2691,7 +3293,8 @@ const processTriggerMatches = (allMatches, sliceStart, sliceEnd, fullText, rules
 		if (match.start > 0 && LETTER_RE.test(fullText[match.start - 1] ?? "")) continue;
 		const rule = rules[localIdx];
 		if (!rule) continue;
-		if (!rule.trigger.endsWith(" ") && LETTER_RE.test(fullText[match.end] ?? "")) continue;
+		const triggerLastChar = rule.trigger.at(-1) ?? "";
+		if (LETTER_RE.test(triggerLastChar) && LETTER_RE.test(fullText[match.end] ?? "")) continue;
 		const triggerEnd = match.end;
 		const rawValue = extractValue(fullText, triggerEnd, rule.strategy, rule.label);
 		const value = rawValue ? stripQuotes(rawValue) : null;
@@ -2700,7 +3303,7 @@ const processTriggerMatches = (allMatches, sliceStart, sliceEnd, fullText, rules
 			const entityStart = rule.includeTrigger ? match.start : value.start;
 			const entityEnd = value.end;
 			const entityText = fullText.slice(entityStart, entityEnd);
-			const effectiveLabel = rule.label === "person" && LEGAL_FORM_CHECK_RE.test(entityText) ? "organization" : rule.label;
+			const effectiveLabel = rule.label === "person" && getLegalFormCheckRe().test(entityText) ? "organization" : rule.label;
 			results.push({
 				start: entityStart,
 				end: entityEnd,
@@ -2970,11 +3573,82 @@ const resolveCountries = (regions, countries) => {
 	return result;
 };
 //#endregion
+//#region src/util/homoglyphs.ts
+const CHAR_MAP$1 = new Map([
+	[1040, 65],
+	[1042, 66],
+	[1045, 69],
+	[1050, 75],
+	[1052, 77],
+	[1053, 72],
+	[1054, 79],
+	[1056, 80],
+	[1057, 67],
+	[1058, 84],
+	[1061, 88],
+	[1072, 97],
+	[1077, 101],
+	[1086, 111],
+	[1088, 112],
+	[1089, 99],
+	[1091, 121],
+	[1093, 120],
+	[1110, 105],
+	[1112, 106],
+	[913, 65],
+	[914, 66],
+	[917, 69],
+	[919, 72],
+	[921, 73],
+	[922, 75],
+	[924, 77],
+	[925, 78],
+	[927, 79],
+	[929, 80],
+	[932, 84],
+	[933, 89],
+	[935, 88],
+	[918, 90],
+	[945, 97],
+	[954, 107],
+	[959, 111],
+	[961, 112]
+]);
+/** Chunk size for `String.fromCharCode` to avoid hitting
+*  the call-stack limit on very large strings. */
+const CHUNK_SIZE$1 = 8192;
+const normalizeHomoglyphs = (text) => {
+	let hasSpecial = false;
+	for (let i = 0; i < text.length; i++) if (CHAR_MAP$1.has(text.charCodeAt(i))) {
+		hasSpecial = true;
+		break;
+	}
+	if (!hasSpecial) return text;
+	const len = text.length;
+	const codes = new Uint16Array(len);
+	for (let i = 0; i < len; i++) {
+		const code = text.charCodeAt(i);
+		codes[i] = CHAR_MAP$1.get(code) ?? code;
+	}
+	if (len <= CHUNK_SIZE$1) return String.fromCharCode(...codes);
+	let result = "";
+	for (let offset = 0; offset < len; offset += CHUNK_SIZE$1) {
+		const end = Math.min(offset + CHUNK_SIZE$1, len);
+		result += String.fromCharCode(...codes.subarray(offset, end));
+	}
+	return result;
+};
+//#endregion
 //#region src/filters/false-positives.ts
 const TEMPLATE_PLACEHOLDER_RE = /^(?:\.{3,}|_{3,}|\[[\w\s]+\]|\{[\w\s]+\})$/;
 const POSTAL_CODE_RE = /\d{3}\s?\d{2}/;
 const HAS_DIGIT_RE = /\d/;
-const ADDRESS_COMPONENTS_RE = /(?:^|\s)(?:ul\.|ulice|nám\.|náměstí|tř\.|třída|nábř\.|nábřeží|č\.p\.|č\.ev\.|č\.|sídliště|bulvár)(?=[\s,./]|$)/i;
+const ADDRESS_COMPONENT_EXTRA_RE = /(?:^|\s)(?:č\.p\.|č\.ev\.|č\.|sídliště)(?=[\s,./]|$)/i;
+const BARE_COURS_PROSE_RE = /(?:^|\s)cours(?!\s+\p{Lu})(?=[\s,./]|$)/u;
+const isOnlyAmbiguousCours = (text) => {
+	if (!BARE_COURS_PROSE_RE.test(text)) return false;
+	return !hasAddressComponent(text.replace(/(?:^|\s)cours(?=[\s,./]|$)/gi, " "));
+};
 const JURISDICTION_RE = /^(?:state|commonwealth|district|territory)\s+of\s+/i;
 const MAX_ENTITY_LENGTH = {
 	organization: 80,
@@ -3057,6 +3731,41 @@ const loadGenericRoles = (ctx = defaultContext) => {
 };
 /** Sync accessor — returns empty set before init. */
 const getGenericRoles = (ctx) => ctx.genericRoles ?? EMPTY_GENERIC_ROLES;
+const STREET_TYPES_SEED_RE = /(?:^|\s)(?:ul\.|ulice|nám\.|náměstí|tř\.|třída|nábř\.|nábřeží|bulvár)(?=[\s,./]|$)/i;
+let _streetTypesRe = STREET_TYPES_SEED_RE;
+let _streetTypesPromise = null;
+const escapeRegex$1 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const loadStreetTypeRegex = async () => {
+	try {
+		const data = (await import("./address-street-types.mjs")).default ?? {};
+		const words = /* @__PURE__ */ new Set();
+		for (const [key, val] of Object.entries(data)) {
+			if (key.startsWith("_")) continue;
+			if (!Array.isArray(val)) continue;
+			for (const w of val) if (typeof w === "string" && w.length > 0) words.add(w.toLowerCase());
+		}
+		if (words.size === 0) {
+			_streetTypesRe = STREET_TYPES_SEED_RE;
+			return;
+		}
+		const alternation = [...words].sort((a, b) => b.length - a.length).map(escapeRegex$1).join("|");
+		_streetTypesRe = new RegExp(`(?:^|\\s)(?:${alternation})(?=[\\s,./]|$)`, "iu");
+	} catch {
+		_streetTypesRe = STREET_TYPES_SEED_RE;
+	}
+};
+/** Ensure street-type vocabulary is loaded. */
+const initAddressComponents = () => {
+	if (!_streetTypesPromise) _streetTypesPromise = loadStreetTypeRegex();
+	return _streetTypesPromise;
+};
+/**
+* True when `text` contains a recognised address
+* component: either a per-language street word (loaded
+* from JSON) or a language-agnostic anchor such as a
+* Czech house number form.
+*/
+const hasAddressComponent = (text) => _streetTypesRe.test(text) || ADDRESS_COMPONENT_EXTRA_RE.test(text);
 const isCallerOwnedEntity$3 = (entity) => entity.sourceDetail === "custom-deny-list" || entity.sourceDetail === "custom-regex";
 /**
 * Filter out entities that are likely false positives:
@@ -3091,13 +3800,15 @@ const filterFalsePositives = (entities, ctx = defaultContext, fullText) => {
 		if (normalized.label === "person" && HAS_DIGIT_RE.test(trimmed)) continue;
 		if (normalized.label === "person") {
 			const tokens = trimmed.split(/\s+/u);
-			const last = tokens.at(-1)?.replace(/[.,;:!?]+$/u, "").toLowerCase();
-			if (tokens.length > 1 && last && PERSON_TRAILING_NOUNS.has(last)) continue;
+			const last = tokens.at(-1)?.replace(/[.,;:!?]+$/u, "");
+			const lastFolded = last ? normalizeHomoglyphs(last).toLowerCase() : void 0;
+			if (tokens.length > 1 && lastFolded && PERSON_TRAILING_NOUNS.has(lastFolded)) continue;
 		}
-		if ((normalized.label === "person" || normalized.label === "organization") && roles.has(trimmed.toLowerCase())) continue;
+		if ((normalized.label === "person" || normalized.label === "organization") && roles.has(normalizeHomoglyphs(trimmed).toLowerCase())) continue;
 		if (normalized.label === "organization" && normalized.source === "legal-form" && trimmed === trimmed.toUpperCase() && LEGAL_FORM_HEADING_RE.test(trimmed)) continue;
-		if (normalized.label === "address" && trimmed.length > 40 && !POSTAL_CODE_RE.test(trimmed) && !HAS_DIGIT_RE.test(trimmed) && !ADDRESS_COMPONENTS_RE.test(trimmed) && !JURISDICTION_RE.test(trimmed)) continue;
-		if (normalized.label === "address" && normalized.source === "trigger" && !HAS_DIGIT_RE.test(trimmed) && !ADDRESS_COMPONENTS_RE.test(trimmed) && !JURISDICTION_RE.test(trimmed)) continue;
+		if (normalized.label === "address" && trimmed.length > 40 && !POSTAL_CODE_RE.test(trimmed) && !HAS_DIGIT_RE.test(trimmed) && !hasAddressComponent(trimmed) && !JURISDICTION_RE.test(trimmed)) continue;
+		if (normalized.label === "address" && normalized.source === "trigger" && !HAS_DIGIT_RE.test(trimmed) && !hasAddressComponent(trimmed) && !JURISDICTION_RE.test(trimmed)) continue;
+		if (normalized.label === "address" && normalized.source === "trigger" && !HAS_DIGIT_RE.test(trimmed) && isOnlyAmbiguousCours(trimmed)) continue;
 		if (normalized.label === "address" && SIGNING_CLAUSE_ADDRESS_RE.test(trimmed)) continue;
 		filtered.push(normalized);
 	}
@@ -3254,6 +3965,122 @@ const loadPersonStopwords = (ctx) => {
 const EMPTY_PERSON_STOPWORDS = /* @__PURE__ */ new Set();
 /** Sync accessor — returns empty set before init. */
 const getPersonStopwords = (ctx) => ctx.personStopwords ?? EMPTY_PERSON_STOPWORDS;
+const loadAddressStopwords = (ctx) => {
+	if (ctx.addressStopwordsPromise) return ctx.addressStopwordsPromise;
+	ctx.addressStopwordsPromise = (async () => {
+		try {
+			const mod = await import("./address-stopwords.mjs");
+			const set = new Set(mod.default?.words ?? []);
+			ctx.addressStopwords = set;
+			return set;
+		} catch {
+			const empty = /* @__PURE__ */ new Set();
+			ctx.addressStopwords = empty;
+			return empty;
+		}
+	})();
+	return ctx.addressStopwordsPromise;
+};
+const EMPTY_ADDRESS_STOPWORDS = /* @__PURE__ */ new Set();
+const getAddressStopwords = (ctx) => ctx.addressStopwords ?? EMPTY_ADDRESS_STOPWORDS;
+/**
+* Word characters in unicode property notation. The check is
+* "single-token" — no internal whitespace — and we keep dashes
+* tokens like "K-12" out by requiring the surface to be a single
+* uninterrupted run of letters or marks.
+*/
+const SINGLE_WORD_RE = /^\p{L}+$/u;
+/**
+* Format-level address signals — structurally numeric or
+* 2-letter-state patterns, language-agnostic. The street-type
+* vocabulary is loaded from `address-street-types.json` so new
+* languages contribute via data, not code.
+*   - `,\s*[A-Z]{2}\b` → US state abbreviation after a comma
+*   - `\b\d{5}(?:-\d{4})?\b` → US ZIP / ZIP+4
+*   - `\b\d{3}\s\d{2}\b` → Czech/Slovak postal block (140 00)
+*   - `\b\d{2}-\d{3}\b` → Polish postal code (00-950)
+*/
+const ADDRESS_FORMAT_RE = /,\s*\p{Lu}{2}\b|\b\d{5}(?:-\d{4})?\b|\b\d{3}\s\d{2}\b|\b\d{2}-\d{3}\b/u;
+let cachedStreetTypeRe = null;
+let streetTypeReLoaded = false;
+const loadStreetTypeRe = async () => {
+	if (streetTypeReLoaded) return cachedStreetTypeRe;
+	try {
+		const config = (await import("./address-street-types.mjs")).default ?? {};
+		const words = [];
+		for (const value of Object.values(config)) {
+			if (!Array.isArray(value)) continue;
+			for (const word of value) if (typeof word === "string" && word.length > 0) words.push(word);
+		}
+		if (words.length === 0) cachedStreetTypeRe = null;
+		else {
+			words.sort((a, b) => b.length - a.length);
+			const isLetterDigit = (c) => /[\p{L}\p{N}]/u.test(c);
+			const wordLikeTail = [];
+			const punctTail = [];
+			for (const w of words) {
+				const escaped = w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+				if (isLetterDigit(w.at(-1) ?? "")) wordLikeTail.push(escaped);
+				else punctTail.push(escaped);
+			}
+			const branches = [];
+			if (wordLikeTail.length > 0) branches.push(`(?:${wordLikeTail.join("|")})(?![\\p{L}\\p{N}])`);
+			if (punctTail.length > 0) branches.push(`(?:${punctTail.join("|")})`);
+			cachedStreetTypeRe = new RegExp(`(?<![\\p{L}\\p{N}])(?:${branches.join("|")})`, "iu");
+		}
+	} catch {
+		cachedStreetTypeRe = null;
+	}
+	streetTypeReLoaded = true;
+	return cachedStreetTypeRe;
+};
+const getStreetTypeRe = () => streetTypeReLoaded ? cachedStreetTypeRe : null;
+const hasAdjacentAddressEvidence = (fullText, start, end) => {
+	const window = fullText.slice(Math.max(0, start - 40), Math.min(fullText.length, end + 40));
+	if (ADDRESS_FORMAT_RE.test(window)) return true;
+	const streetRe = getStreetTypeRe();
+	return streetRe !== null && streetRe.test(window);
+};
+/**
+* Capitalised words that almost never start a person name. When a
+* single-token surname candidate is immediately followed by one of
+* these, the "next-word is uppercase" promotion heuristic would
+* otherwise turn section headings ("Purchase Price↵The Purchaser
+* undertakes…") into spurious person hits. Kept narrow on purpose;
+* the surrounding pipeline still chains real names via the deny-list
+* cascade when both halves are surnames.
+*/
+const SENTENCE_STARTER_WORDS = new Set([
+	"The",
+	"This",
+	"These",
+	"Those",
+	"An",
+	"Any",
+	"All",
+	"Each",
+	"Every",
+	"No",
+	"Now",
+	"Whereas",
+	"Whereby",
+	"Wherein",
+	"Whereof",
+	"Notwithstanding",
+	"Subject",
+	"In",
+	"On",
+	"At",
+	"By",
+	"For",
+	"If",
+	"Upon",
+	"Unless",
+	"Until",
+	"Provided",
+	"Pursuant",
+	"Such"
+]);
 const PERSON_CHAIN_BREAK_RE = /[!?;:]|,/u;
 const WORD_CHAR_RE$1 = /[\p{L}\p{N}]/u;
 const isInitialContinuationGap = (text, gap) => /^\p{Lu}$/u.test(text) && /^\.[^\S\n]{1,2}$/u.test(gap) || /^[^\S\n]{1,2}(?:\p{Lu}\.[^\S\n]{1,2})+$/u.test(gap);
@@ -3273,6 +4100,8 @@ const buildDenyList = async (config, ctx = defaultContext) => {
 		loadStopwords(ctx),
 		loadAllowList(ctx),
 		loadPersonStopwords(ctx),
+		loadAddressStopwords(ctx),
+		loadStreetTypeRe(),
 		loadGenericRoles(ctx)
 	]);
 	const dictionaries = config.dictionaries;
@@ -3419,6 +4248,8 @@ const ensureDenyListData = async (ctx = defaultContext, dictionaries) => {
 		loadStopwords(ctx),
 		loadAllowList(ctx),
 		loadPersonStopwords(ctx),
+		loadAddressStopwords(ctx),
+		loadStreetTypeRe(),
 		loadGenericRoles(ctx)
 	]);
 };
@@ -3486,14 +4317,18 @@ const processDenyListMatches = (allMatches, sliceStart, sliceEnd, fullText, data
 				if (!getPersonStopwords(ctx).has(keyword)) nameHits.push(m);
 			}
 			const nonPersonLabels = m.labels.filter((l) => l !== "person");
-			for (const label of nonPersonLabels) results.push({
-				start: m.start,
-				end: m.end,
-				label,
-				text: m.text,
-				score: .9,
-				source: DETECTION_SOURCES.DENY_LIST
-			});
+			const suppressAddress = SINGLE_WORD_RE.test(m.text) && getAddressStopwords(ctx).has(m.text.toLowerCase()) && !hasAdjacentAddressEvidence(fullText, m.start, m.end);
+			for (const label of nonPersonLabels) {
+				if (label === "address" && suppressAddress) continue;
+				results.push({
+					start: m.start,
+					end: m.end,
+					label,
+					text: m.text,
+					score: .9,
+					source: DETECTION_SOURCES.DENY_LIST
+				});
+			}
 		}
 	}
 	nameHits.sort((a, b) => a.start - b.start);
@@ -3525,6 +4360,8 @@ const processDenyListMatches = (allMatches, sliceStart, sliceEnd, fullText, data
 			const afterEnd = last.end;
 			const rest = fullText.slice(afterEnd).trimStart();
 			if (!(rest.length > 1 && /^\p{Lu}\p{Ll}/u.test(rest))) continue;
+			const nextWord = /^\p{L}+/u.exec(rest)?.[0] ?? "";
+			if (SENTENCE_STARTER_WORDS.has(nextWord)) continue;
 		}
 		results.push({
 			start: first.start,
@@ -3636,6 +4473,15 @@ const extendPersonName = (text, start, end, ctx) => {
 };
 //#endregion
 //#region src/detectors/address-seeds.ts
+/**
+* Trailing chars that should never end an address span. Combines
+* structural separators, opening brackets, and typographic quote
+* variants so a span like `… GA 30326, USA (the "Premises")`
+* does not pull the parenthetical opener into the address.
+* The prime (`′`) catches measurement tails (`5′`) that the
+* cluster occasionally absorbs.
+*/
+const ADDRESS_TRAILING_TRIM_RE = new RegExp(`[,;:\\s${OPENING_BRACKETS_INNER}${QUOTE_DOUBLE_INNER}${QUOTE_SINGLE_INNER}′]`, "u");
 let cachedBoundaryRe = null;
 const loadBoundaryWords = async () => {
 	try {
@@ -3644,6 +4490,56 @@ const loadBoundaryWords = async () => {
 		return {};
 	}
 };
+const BR_CEP_CONTEXT_WINDOW = 200;
+let cachedBrCepContextRe = null;
+let cachedBrCepContextPromise = null;
+const loadBrCueWords = async () => {
+	const sources = await Promise.all([(async () => {
+		try {
+			return (await import("./address-street-types.mjs")).default["pt-br"];
+		} catch {
+			return;
+		}
+	})(), (async () => {
+		try {
+			return (await import("./address-boundaries.mjs")).default["pt-br"];
+		} catch {
+			return;
+		}
+	})()]);
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of sources) {
+		if (!Array.isArray(entry)) continue;
+		for (const word of entry) {
+			if (typeof word !== "string" || word.length === 0) continue;
+			const key = word.toLowerCase();
+			if (seen.has(key)) continue;
+			seen.add(key);
+			out.push(word);
+		}
+	}
+	return out;
+};
+const getBrCepContextRe = async () => {
+	if (cachedBrCepContextRe !== null) return cachedBrCepContextRe;
+	if (cachedBrCepContextPromise) return cachedBrCepContextPromise;
+	cachedBrCepContextPromise = (async () => {
+		const words = await loadBrCueWords();
+		if (words.length === 0) return null;
+		const escaped = words.toSorted((a, b) => b.length - a.length).map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+		const re = new RegExp(`(?<![\\p{L}\\p{N}])(?:${escaped.join("|")})(?![\\p{L}\\p{N}])`, "iu");
+		cachedBrCepContextRe = re;
+		return re;
+	})();
+	return cachedBrCepContextPromise;
+};
+const hasBrCueNearby = (fullText, start, end, re) => {
+	const windowStart = Math.max(0, start - BR_CEP_CONTEXT_WINDOW);
+	const windowEnd = Math.min(fullText.length, end + BR_CEP_CONTEXT_WINDOW);
+	const window = fullText.slice(windowStart, windowEnd);
+	return new RegExp(re.source, re.flags.replace("g", "")).test(window);
+};
 /**
 * Build regex for boundary words. Matches any
 * boundary word preceded by a word boundary.
@@ -3657,7 +4553,7 @@ const getBoundaryRe = async () => {
 		for (const word of entries) words.push(word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
 	}
 	words.sort((a, b) => b.length - a.length);
-	cachedBoundaryRe = words.length > 0 ? new RegExp(`\\b(?:${words.join("|")})\\b`, "i") : /(?!)/;
+	cachedBoundaryRe = words.length > 0 ? new RegExp(`(?<![\\p{L}\\p{N}])(?:${words.join("|")})(?![\\p{L}\\p{N}])`, "iu") : /(?!)/;
 	return cachedBoundaryRe;
 };
 /**
@@ -3679,7 +4575,7 @@ const buildStreetTypePatterns = async () => {
 	}
 	return words;
 };
-const collectSeeds = (allMatches, sliceStart, sliceEnd, fullText, existingEntities) => {
+const collectSeeds = (allMatches, sliceStart, sliceEnd, fullText, existingEntities, brCepContextRe) => {
 	const seeds = [];
 	for (const match of allMatches) {
 		const idx = match.pattern;
@@ -3713,18 +4609,41 @@ const collectSeeds = (allMatches, sliceStart, sliceEnd, fullText, existingEntiti
 			text: e.text
 		});
 	}
-	const postalRe = /\b(?:\d{3}\s\d{2}|\d{2}-\d{3})\b/g;
+	const postalRe = /\b(?:\d{3}\s\d{2}|\d{2}-\d{3}|\d{5}-\d{3})\b/g;
 	let postalMatch;
 	while ((postalMatch = postalRe.exec(fullText)) !== null) {
 		const start = postalMatch.index;
 		const end = start + postalMatch[0].length;
-		if (!seeds.some((s) => s.start <= start && s.end >= end)) seeds.push({
+		if (seeds.some((s) => s.start <= start && s.end >= end)) continue;
+		if (/^\d{5}-\d{3}$/.test(postalMatch[0]) && (brCepContextRe === null || !hasBrCueNearby(fullText, start, end, brCepContextRe))) continue;
+		seeds.push({
 			type: "postal-code",
 			start,
 			end,
 			text: postalMatch[0]
 		});
 	}
+	const itCapRe = /\b\d{5}(?=\s+\p{Lu}\p{L}+)/gu;
+	let itCapMatch;
+	while ((itCapMatch = itCapRe.exec(fullText)) !== null) {
+		const start = itCapMatch.index;
+		const end = start + itCapMatch[0].length;
+		if (seeds.some((s) => s.start <= start && s.end >= end)) continue;
+		if (!seeds.some((s) => {
+			if (Math.abs(s.start - start) > 80) return false;
+			if (s.type === "address-trigger") return true;
+			if (s.type === "city") return true;
+			if (s.type === "postal-code") return true;
+			if (s.type === "street-word") return s.text.toLowerCase() !== "via";
+			return false;
+		})) continue;
+		seeds.push({
+			type: "postal-code",
+			start,
+			end,
+			text: itCapMatch[0]
+		});
+	}
 	const streetNumRe = /\b(\p{Lu}\p{Ll}{2,})\s+(\d{1,5}(?:\/\d{1,5})?)\s*[,\n]/gu;
 	let streetMatch;
 	while ((streetMatch = streetNumRe.exec(fullText)) !== null) {
@@ -3782,6 +4701,10 @@ const scoreCluster = (cluster) => {
 const NON_ADDRESS_LABELS = new Set([
 	"registration number",
 	"tax identification number",
+	"national identification number",
+	"social security number",
+	"birth number",
+	"identity card number",
 	"person",
 	"bank account number",
 	"email address",
@@ -3818,7 +4741,7 @@ const expandCluster = async (fullText, cluster, existingEntities) => {
 	const doubleNewline = remaining.indexOf("\n\n");
 	if (doubleNewline !== -1 && doubleNewline < nearestBoundary) nearestBoundary = doubleNewline;
 	rightPos = end + remaining.slice(0, nearestBoundary).trimEnd().length;
-	while (rightPos > end && /[,;:\s]/.test(fullText[rightPos - 1] ?? "")) rightPos--;
+	while (rightPos > end && ADDRESS_TRAILING_TRIM_RE.test(fullText[rightPos - 1] ?? "")) rightPos--;
 	return {
 		start: Math.min(leftPos, start),
 		end: Math.max(rightPos, end)
@@ -3835,7 +4758,7 @@ const expandCluster = async (fullText, cluster, existingEntities) => {
 * using their output as seed sources.
 */
 const processAddressSeeds = async (allMatches, sliceStart, sliceEnd, fullText, existingEntities) => {
-	const clusters = clusterSeeds(collectSeeds(allMatches, sliceStart, sliceEnd, fullText, existingEntities), 150);
+	const clusters = clusterSeeds(collectSeeds(allMatches, sliceStart, sliceEnd, fullText, existingEntities, await getBrCepContextRe()), 150);
 	const results = [];
 	for (const cluster of clusters) {
 		const score = scoreCluster(cluster);
@@ -3860,6 +4783,7 @@ const processAddressSeeds = async (allMatches, sliceStart, sliceEnd, fullText, e
 const TRAILING_SEP = /[,\s]+$/;
 const WORD_CHAR_RE = /[\p{L}\p{N}]/u;
 const ORG_PROPAGATION_SCORE = .9;
+const ORG_DETERMINER_RE = /(?<![\p{L}\p{N}])(společnost(?:i|í|em|u)?|spolecnost(?:i|em|u)?|the\s+(?:company|corporation|firm)|die\s+(?:gesellschaft|firma)|la\s+(?:société|empresa|sociedad)|el\s+(?:empresa|sociedad))\s+$/iu;
 const isCallerOwnedEntity$2 = (entity) => entity.sourceDetail === "custom-deny-list" || entity.sourceDetail === "custom-regex";
 /**
 * After the main detection pass, collect organization
@@ -3903,16 +4827,25 @@ const propagateOrgNames = (entities, fullText) => {
 				searchFrom = idx + 1;
 				continue;
 			}
-			if (!isOverlapping(idx, matchEnd)) {
+			let spanStart = idx;
+			const lookbackStart = Math.max(0, idx - 40);
+			const lookback = fullText.slice(lookbackStart, idx);
+			const determinerMatch = ORG_DETERMINER_RE.exec(lookback);
+			if (determinerMatch !== null) {
+				const determiner = determinerMatch[1] ?? "";
+				const offsetInMatch = determinerMatch[0].indexOf(determiner);
+				spanStart = lookbackStart + determinerMatch.index + offsetInMatch;
+			}
+			if (!isOverlapping(spanStart, matchEnd)) {
 				results.push({
-					start: idx,
+					start: spanStart,
 					end: matchEnd,
 					label,
-					text: baseName,
+					text: fullText.slice(spanStart, matchEnd),
 					score: ORG_PROPAGATION_SCORE,
 					source: DETECTION_SOURCES.COREFERENCE
 				});
-				covered.push([idx, matchEnd]);
+				covered.push([spanStart, matchEnd]);
 			}
 			searchFrom = matchEnd;
 		}
@@ -5077,13 +6010,89 @@ const shouldReplace = (a, b) => {
 };
 /** Labels where colons are structurally significant. */
 const COLON_LABELS = new Set(["ip address", "mac address"]);
+/**
+* Labels whose detectors emit precise, evidence-backed spans. When
+* one of these fires at the exact same offsets as a fuzzier
+* `address` hit (city dictionary lookup, address-seed cluster), the
+* `address` label is almost always a dictionary collision — "March
+* 15" the date getting tagged as an address because "March" appears
+* in a city corpus, or "Brent Phillips" emitted as both `person`
+* and `address` because "Brent" is a UK city. The precise detector
+* wins.
+*/
+const PRECISE_OVER_ADDRESS = new Set([
+	"person",
+	"date",
+	"date of birth",
+	"phone number",
+	"email address",
+	"monetary amount",
+	"iban",
+	"bank account number",
+	"tax identification number",
+	"registration number",
+	"identity card number",
+	"national identification number",
+	"passport number",
+	"credit card number"
+]);
+/**
+* Labels the `person` chain wins against at identical offsets. The
+* chain carries adjacent-name evidence (deny-list surname plus a
+* capitalised follow-up) a single-token dictionary collision does
+* not. Kept narrow: organizations are NOT here — "Morgan Stanley"
+* legitimately appears in both the org and name dictionaries, and
+* the existing detector priority is the right tie-breaker there.
+*/
+const PERSON_PREFERRED_OVER = new Set(["address", "land parcel"]);
+const resolveSameSpanLabelConflicts = (entities) => {
+	if (entities.length < 2) return entities;
+	const byOffsets = /* @__PURE__ */ new Map();
+	for (const entity of entities) {
+		const key = `${entity.start}:${entity.end}`;
+		const list = byOffsets.get(key);
+		if (list) list.push(entity);
+		else byOffsets.set(key, [entity]);
+	}
+	const dropped = /* @__PURE__ */ new Set();
+	for (const [, group] of byOffsets) {
+		if (group.length < 2) continue;
+		const labels = new Set(group.map((e) => e.label));
+		if (labels.size < 2) continue;
+		const hasPerson = labels.has("person");
+		const hasPreciseNonAddress = [...labels].some((l) => l !== "address" && PRECISE_OVER_ADDRESS.has(l));
+		let maxPriority = -1;
+		for (const e of group) {
+			if (hasLockedBoundary(e)) continue;
+			const pri = DETECTOR_PRIORITY[e.source] ?? 0;
+			if (pri > maxPriority) maxPriority = pri;
+		}
+		for (const e of group) {
+			if (hasLockedBoundary(e)) continue;
+			if ((DETECTOR_PRIORITY[e.source] ?? 0) < maxPriority) {
+				dropped.add(e);
+				continue;
+			}
+			if (hasPerson && PERSON_PREFERRED_OVER.has(e.label)) {
+				dropped.add(e);
+				continue;
+			}
+			if (hasPreciseNonAddress && e.label === "address") dropped.add(e);
+		}
+	}
+	if (dropped.size === 0) return entities;
+	return entities.filter((e) => !dropped.has(e));
+};
 /** Strip leading/trailing whitespace and punctuation. */
 const sanitizeEntities = (entities) => entities.flatMap((e) => {
 	if (hasLockedBoundary(e)) return [e];
 	const strip = COLON_LABELS.has(e.label) ? /[\s,;]+/ : /[\s:,;]+/;
 	const leadTrimmed = e.text.replace(/^(?:\.\s)+/, "").replace(new RegExp(`^${strip.source}`, strip.flags), "");
 	const lead = e.text.length - leadTrimmed.length;
-	const cleaned = leadTrimmed.replace(new RegExp(`${strip.source}$`, strip.flags), "");
+	let cleaned = leadTrimmed.replace(new RegExp(`${strip.source}$`, strip.flags), "");
+	if (e.label === "organization" && cleaned.endsWith(".") && !LITERAL_SOURCES.has(e.source)) {
+		if (!getKnownLegalSuffixes().some((suffix) => cleaned.endsWith(suffix))) cleaned = cleaned.slice(0, -1).trimEnd();
+	}
 	if (cleaned.length === 0) return [];
 	if (!/[\p{L}\p{N}]/u.test(cleaned)) return [];
 	const collapsed = cleaned.replace(/\s*\n\s*/g, " ").replace(/\s{2,}/g, " ");
@@ -5132,7 +6141,7 @@ const mergeAndDedup = (...layers) => {
 		}
 		if (overlaps.every((existing) => shouldReplace(entity, existing))) merged.splice(overlapStart, overlaps.length, { ...entity });
 	}
-	return sanitizeEntities(merged);
+	return resolveSameSpanLabelConflicts(sanitizeEntities(merged));
 };
 const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 let amountWordsRe = null;
@@ -5168,9 +6177,10 @@ const filterAllowedLabels = (entities, allowedLabels) => {
 	return entities.filter((e) => allowedLabels.has(e.label));
 };
 const labelIsAllowed = (label, allowedLabels) => !allowedLabels || allowedLabels.has(label);
+const NON_NER_LABELS = new Set(["misc"]);
 const getRequestedNerLabels = (config, expandForHotwords = false) => {
 	const labels = config.labels.length > 0 ? config.labels : DEFAULT_ENTITY_LABELS;
-	return expandForHotwords ? expandLabelsForHotwordRules(labels) : labels;
+	return (expandForHotwords ? expandLabelsForHotwordRules(labels) : labels).filter((label) => !NON_NER_LABELS.has(label));
 };
 const checkAbort = (signal) => {
 	if (signal?.aborted) throw new DOMException("Pipeline aborted", "AbortError");
@@ -5251,6 +6261,8 @@ const runPipeline = async (options) => {
 			loadGenericRoles(ctx),
 			initPrepositions(),
 			initStreetAbbrevs(),
+			initAddressComponents(),
+			warmAddressStopKeywords(),
 			zoneInit,
 			hotwordInit
 		]);
@@ -5258,6 +6270,8 @@ const runPipeline = async (options) => {
 		loadGenericRoles(ctx),
 		initPrepositions(),
 		initStreetAbbrevs(),
+		initAddressComponents(),
+		warmAddressStopKeywords(),
 		hotwordInit
 	]);
 	if (cachedSearch && config.enableDenyList) await ensureDenyListData(ctx, config.dictionaries);
@@ -5277,9 +6291,11 @@ const runPipeline = async (options) => {
 	const customRegexEntities = filterAllowedLabels(config.enableRegex ? processRegexMatches(customRegexMatches, slices.customRegex.start, slices.customRegex.end, search.customRegexMeta) : [], preHotwordAllowedLabels);
 	const regexEntities = filterAllowedLabels([...rawRegexEntities, ...customRegexEntities], preHotwordAllowedLabels);
 	if (regexEntities.length > 0) log("regex", `${regexEntities.length} matches`);
+	if (legalFormsEnabled || config.enableTriggerPhrases) await warmLegalRoleHeads();
 	const rawLegalFormEntities = legalFormsEnabled ? processLegalFormMatches(regexMatches, slices.legalForms.start, slices.legalForms.end, fullText) : [];
 	const legalFormEntities = filterAllowedLabels(rawLegalFormEntities, preHotwordAllowedLabels);
 	if (legalFormEntities.length > 0) log("legal-forms", `${legalFormEntities.length} matches`);
+	if (config.enableTriggerPhrases) await warmAddressStopKeywords();
 	const rawTriggerEntities = config.enableTriggerPhrases ? processTriggerMatches(regexMatches, slices.triggers.start, slices.triggers.end, fullText, search.triggerRules) : [];
 	const triggerEntities = filterAllowedLabels(rawTriggerEntities, preHotwordAllowedLabels);
 	if (triggerEntities.length > 0) log("trigger-phrases", `${triggerEntities.length} matches`);
@@ -5325,10 +6341,11 @@ const runPipeline = async (options) => {
 	];
 	let rawNerEntities = [];
 	let nerEntities = [];
-	if (config.enableNer && nerInference) {
+	const requestedNerLabels = getRequestedNerLabels(config, hotwordsActive);
+	if (config.enableNer && nerInference && requestedNerLabels.length > 0) {
 		const maskResult = maskDetectedSpans(fullText, nerMaskEntities);
 		log("ner", "running inference...");
-		const rawNer = await nerInference(maskResult.maskedText, [...getRequestedNerLabels(config, hotwordsActive)], config.threshold, signal);
+		const rawNer = await nerInference(maskResult.maskedText, [...requestedNerLabels], config.threshold, signal);
 		rawNerEntities = unmaskNerEntities(rawNer, maskResult, fullText);
 		nerEntities = filterAllowedLabels(rawNerEntities, preHotwordAllowedLabels);
 		const masked = rawNer.length - rawNerEntities.length;
@@ -5389,6 +6406,7 @@ const runPipeline = async (options) => {
 	checkAbort(signal);
 	ctx.corefSourceMap.clear();
 	if (config.enableCoreference) {
+		if (!legalFormsEnabled) await warmLegalRoleHeads();
 		const terms = await extractDefinedTerms(fullText, merged.filter((entity) => !isCallerOwnedEntity(entity)), ctx);
 		if (terms.length > 0) {
 			log("coreference", `${terms.length} defined terms`);
@@ -5429,7 +6447,7 @@ const resolveOperator = (config, label) => config.operators[label] ?? "replace";
 //#region src/redact.ts
 const WHITESPACE_RE = /\s+/g;
 const PHONE_NOISE_RE = /[()\s-]/g;
-const SPACE_DASH_RE = /[\s-]/g;
+const ID_SEPARATOR_RE = /[\s\-/.]/g;
 /**
 * Normalize entity text so that surface-form variations
 * of the same real-world value map to a single canonical
@@ -5439,8 +6457,8 @@ const normalizeEntityText = (label, text) => {
 	const upper = label.toUpperCase().replace(WHITESPACE_RE, "_");
 	if (upper === "EMAIL_ADDRESS" || upper === "EMAIL") return text.toLowerCase().trim();
 	if (upper === "PHONE_NUMBER" || upper === "PHONE") return text.replace(PHONE_NOISE_RE, "");
-	if (upper === "IBAN" || upper === "BANK_ACCOUNT_NUMBER" || upper === "TAX_IDENTIFICATION_NUMBER" || upper === "REGISTRATION_NUMBER") return text.replace(SPACE_DASH_RE, "").toUpperCase();
-	if (upper === "PERSON" || upper === "ORGANIZATION" || upper === "ADDRESS" || upper === "LAND_PARCEL") return text.replace(WHITESPACE_RE, " ").toLowerCase().trim();
+	if (upper === "IBAN" || upper === "BANK_ACCOUNT_NUMBER" || upper === "TAX_IDENTIFICATION_NUMBER" || upper === "REGISTRATION_NUMBER" || upper === "NATIONAL_IDENTIFICATION_NUMBER" || upper === "SOCIAL_SECURITY_NUMBER" || upper === "BIRTH_NUMBER" || upper === "IDENTITY_CARD_NUMBER" || upper === "PASSPORT_NUMBER" || upper === "CREDIT_CARD_NUMBER") return text.replace(ID_SEPARATOR_RE, "").toUpperCase();
+	if (upper === "PERSON" || upper === "ORGANIZATION" || upper === "ADDRESS" || upper === "LAND_PARCEL" || upper === "MISC") return text.replace(WHITESPACE_RE, " ").toLowerCase().trim();
 	return text.trim();
 };
 /**
@@ -5984,6 +7002,6 @@ const levenshtein = (rawA, rawB) => {
 //#region src/wasm.ts
 initTextSearch(TextSearch);
 //#endregion
-export { CURRENCY_PATTERN_META, DATE_PATTERN_META, DEFAULT_ENTITY_LABELS, DEFAULT_OPERATOR_CONFIG, DETECTION_SOURCES, DETECTOR_PRIORITY, OPERATOR_REGISTRY, OPERATOR_TYPES, REGEX_META, REGEX_PATTERNS, REGIONS, ZONE_SCORE_ADJUSTMENTS, applyHotwordRules, applyZoneAdjustments, boostNearMissEntities, buildDenyList, buildGazetteerPatterns, buildLegalFormPatterns, buildPlaceholderMap, buildStreetTypePatterns, buildTriggerPatterns, buildUnifiedSearch, chunkText, classifyZones, computeChunkOffsets, corefKey, createPipelineContext, deanonymise, decodeSpans, decodeTokenSpans, detectNameCorpus, ensureDenyListData, exportRedactionKey, extractDefinedTerms, filterFalsePositives, findCoreferenceSpans, getCurrencyPatterns, getDatePatterns, initHotwordRules, initNameCorpus, initZoneClassifier, levenshtein, mergeAndDedup, mergeChunkEntities, normalizeForSearch, prepareBatch, processAddressSeeds, processDenyListMatches, processGazetteerMatches, processLegalFormMatches, processRegexMatches, processTriggerMatches, propagateOrgNames, redactText, resolveCountries, resolveOperator, runPipeline, runUnifiedSearch, sanitizeEntities, tokenizeText };
+export { CURRENCY_PATTERN_META, DATE_PATTERN_META, DEFAULT_ENTITY_LABELS, DEFAULT_OPERATOR_CONFIG, DETECTION_SOURCES, DETECTOR_PRIORITY, OPERATOR_REGISTRY, OPERATOR_TYPES, REGEX_META, REGEX_PATTERNS, REGIONS, ZONE_SCORE_ADJUSTMENTS, applyHotwordRules, applyZoneAdjustments, boostNearMissEntities, buildDenyList, buildGazetteerPatterns, buildLegalFormPatterns, buildPlaceholderMap, buildStreetTypePatterns, buildTriggerPatterns, buildUnifiedSearch, chunkText, classifyZones, computeChunkOffsets, corefKey, createPipelineContext, deanonymise, decodeSpans, decodeTokenSpans, detectNameCorpus, ensureDenyListData, exportRedactionKey, extractDefinedTerms, filterFalsePositives, findCoreferenceSpans, getCurrencyPatterns, getDatePatterns, initAddressComponents, initHotwordRules, initNameCorpus, initZoneClassifier, levenshtein, mergeAndDedup, mergeChunkEntities, normalizeForSearch, prepareBatch, processAddressSeeds, processDenyListMatches, processGazetteerMatches, processLegalFormMatches, processRegexMatches, processTriggerMatches, propagateOrgNames, redactText, resolveCountries, resolveOperator, runPipeline, runUnifiedSearch, sanitizeEntities, tokenizeText, warmLegalRoleHeads };
 
 //# sourceMappingURL=wasm.mjs.map