@stll/anonymize 0.0.2

package/dist/index.js

@@ -0,0 +1,4969 @@
+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 { toRegex } from "@stll/stdnum/patterns";
+import { TextSearch } from "@stll/text-search";
+//#region src/types.ts
+/**
+* Source of a detected entity span.
+* Ordered by detection layer in the pipeline.
+*/
+const DETECTION_SOURCES = {
+	TRIGGER: "trigger",
+	REGEX: "regex",
+	DENY_LIST: "deny-list",
+	LEGAL_FORM: "legal-form",
+	GAZETTEER: "gazetteer",
+	NER: "ner",
+	COREFERENCE: "coreference"
+};
+/**
+* Priority levels for detection sources.
+* Higher = more structurally reliable. Used during
+* overlap resolution so deterministic detectors beat
+* probabilistic ones regardless of raw score.
+*/
+const DETECTOR_PRIORITY = {
+	gazetteer: 5,
+	trigger: 4,
+	"legal-form": 3,
+	regex: 3,
+	"deny-list": 2,
+	coreference: 2,
+	ner: 1
+};
+/**
+* Anonymisation operator types. Each operator defines
+* how a confirmed entity is replaced in the output.
+*/
+const OPERATOR_TYPES = ["replace", "redact"];
+/**
+* Canonical entity labels used across the pipeline.
+* NER models may use different native labels; the bench
+* NER wrapper maps model output to these canonical names.
+*
+* These labels are ephemeral: entities are regenerated on
+* every pipeline run and never persisted to the database.
+* Renaming a label here requires no migration.
+*/
+const DEFAULT_ENTITY_LABELS = [
+	"person",
+	"organization",
+	"phone number",
+	"address",
+	"email address",
+	"date",
+	"date of birth",
+	"bank account number",
+	"iban",
+	"tax identification number",
+	"identity card number",
+	"registration number",
+	"credit card number",
+	"passport number",
+	"monetary amount"
+];
+//#endregion
+//#region src/context.ts
+/**
+* Build a stable cache key for an entity that survives
+* shallow copies (spread). Uses position + label so the
+* key is identical for the original object and any
+* `{ ...entity }` copy produced by mergeAndDedup.
+*/
+const corefKey = (e) => `${e.start}:${e.end}:${e.label}`;
+/** Create a fresh, empty pipeline context. */
+const createPipelineContext = () => ({
+	search: null,
+	searchKey: "",
+	searchPromise: null,
+	nameCorpus: null,
+	nameCorpusPromise: null,
+	stopwords: null,
+	stopwordsPromise: null,
+	allowList: null,
+	allowListPromise: null,
+	personStopwords: null,
+	personStopwordsPromise: null,
+	firstNameExclusions: null,
+	firstNameExclusionCorpusLen: 0,
+	genericRoles: null,
+	genericRolesPromise: null,
+	corefPatterns: null,
+	corefPatternsPromise: null,
+	corefLoadAttempted: false,
+	roleStopSet: null,
+	roleStopSetPromise: null,
+	zoneHeadingPatterns: null,
+	zoneSigningPatterns: null,
+	zoneInitPromise: null,
+	corefSourceMap: /* @__PURE__ */ new Map()
+});
+/**
+* Module-level default context. Used when callers
+* don't provide an explicit context, preserving full
+* backward compatibility with the existing API.
+*/
+const defaultContext = createPipelineContext();
+//#endregion
+//#region src/util/lang-loader.ts
+let _manifest = null;
+let _manifestPromise = null;
+const loadManifest = () => {
+	if (_manifest) return Promise.resolve(_manifest);
+	if (_manifestPromise) return _manifestPromise;
+	_manifestPromise = (async () => {
+		try {
+			const mod = await import("@stll/anonymize-data/config/manifest.json");
+			const parsed = mod.default ?? mod;
+			if (!parsed || typeof parsed.languages !== "object" || parsed.languages === null || Array.isArray(parsed.languages)) {
+				console.warn("[anonymize] lang-loader: manifest has unexpected structure, falling back to hardcoded list");
+				_manifest = { languages: {} };
+				return _manifest;
+			}
+			_manifest = parsed;
+			return _manifest;
+		} catch (err) {
+			console.warn("[anonymize] lang-loader: manifest not available, falling back to hardcoded language list:", err);
+			_manifest = { languages: {} };
+			return _manifest;
+		}
+	})();
+	return _manifestPromise;
+};
+const LOADER_REGISTRIES = {
+	triggers: {
+		cs: () => import("@stll/anonymize-data/config/triggers.cs.json"),
+		de: () => import("@stll/anonymize-data/config/triggers.de.json"),
+		en: () => import("@stll/anonymize-data/config/triggers.en.json"),
+		es: () => import("@stll/anonymize-data/config/triggers.es.json"),
+		fr: () => import("@stll/anonymize-data/config/triggers.fr.json"),
+		hu: () => import("@stll/anonymize-data/config/triggers.hu.json"),
+		it: () => import("@stll/anonymize-data/config/triggers.it.json"),
+		pl: () => import("@stll/anonymize-data/config/triggers.pl.json"),
+		ro: () => import("@stll/anonymize-data/config/triggers.ro.json"),
+		sv: () => import("@stll/anonymize-data/config/triggers.sv.json")
+	},
+	coreference: {
+		cs: () => import("@stll/anonymize-data/config/coreference.cs.json"),
+		de: () => import("@stll/anonymize-data/config/coreference.de.json"),
+		en: () => import("@stll/anonymize-data/config/coreference.en.json"),
+		sk: () => import("@stll/anonymize-data/config/coreference.sk.json")
+	}
+};
+const FALLBACK_LANGUAGES = {
+	triggers: [
+		"cs",
+		"de",
+		"en",
+		"es",
+		"fr",
+		"hu",
+		"it",
+		"pl",
+		"ro",
+		"sv"
+	],
+	coreference: [
+		"cs",
+		"de",
+		"en",
+		"sk"
+	]
+};
+/**
+* Load all config files of a given type for all
+* languages enabled in the manifest.
+*
+* Falls back to the hardcoded language list when the
+* manifest is unavailable (backward compatibility).
+*/
+const loadLanguageConfigs = async (configType, mapFn) => {
+	const manifest = await loadManifest();
+	const registry = LOADER_REGISTRIES[configType];
+	const codes = Object.keys(manifest.languages).length > 0 ? Object.entries(manifest.languages).filter(([code, lang]) => {
+		if (!lang || typeof lang !== "object") {
+			console.warn(`[anonymize] lang-loader: manifest entry for "${code}" is not an object, skipping`);
+			return false;
+		}
+		return lang[configType] === true;
+	}).map(([code]) => code) : [...FALLBACK_LANGUAGES[configType]];
+	const results = new Array(codes.length);
+	const loads = codes.map(async (code, i) => {
+		const loader = registry[code];
+		if (!loader) {
+			console.warn(`[anonymize] lang-loader: language "${code}" is enabled in the manifest for "${configType}" but has no loader in the static registry`);
+			return;
+		}
+		let mod;
+		try {
+			mod = await loader();
+		} catch (err) {
+			console.warn(`[anonymize] lang-loader: failed to import "${configType}" config for "${code}":`, err);
+			return;
+		}
+		let result;
+		try {
+			result = mapFn(mod);
+		} catch (err) {
+			console.warn(`[anonymize] lang-loader: mapFn failed for "${code}" (${configType}):`, err);
+			return;
+		}
+		results[i] = result;
+	});
+	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 @stll/anonymize-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("@stll/anonymize-data/config/generic-roles.json");
+			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;
+/**
+* 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 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 JSON config files.
+* Safe to call multiple times; only loads once per
+* context. Must be called before detectNameCorpus or
+* the getNameCorpus*() accessors are used.
+*/
+const initNameCorpus = (ctx = defaultContext) => {
+	if (ctx.nameCorpusPromise) return ctx.nameCorpusPromise;
+	const promise = (async () => {
+		try {
+			const [firstMod, surnameMod, titleMod, exclusionMod] = await Promise.all([
+				import("@stll/anonymize-data/config/names-first.json"),
+				import("@stll/anonymize-data/config/names-surnames.json"),
+				import("@stll/anonymize-data/config/names-title-tokens.json"),
+				import("@stll/anonymize-data/config/names-exclusions.json")
+			]);
+			const firstNames = firstMod.default.names;
+			const surnames = surnameMod.default.names;
+			const titles = titleMod.default.tokens;
+			const exclusions = exclusionMod.default.words;
+			ctx.nameCorpus = {
+				firstNames: Object.freeze(new Set(firstNames)),
+				surnames: Object.freeze(new Set(surnames)),
+				titleTokens: Object.freeze(new Set(titles)),
+				excludedWords: Object.freeze(new Set(exclusions)),
+				firstNamesList: Object.freeze(firstNames),
+				surnamesList: Object.freeze(surnames),
+				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"
+};
+/**
+* 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) {
+				if (fullText.slice(prev.end, next.start).includes("\n")) 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"
+];
+//#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, "\\$&");
+/** 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 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);
+	return HONORIFIC_BOUNDARY.has(h) ? `\\b${escaped}` : escaped;
+}).join("|");
+const toEntry = (validator, label, score) => {
+	const pattern = toRegex(validator).source;
+	if (!pattern) return null;
+	return {
+		validator,
+		label,
+		score,
+		pattern
+	};
+};
+/**
+* Stdnum validators for national/company IDs.
+*
+* Selection criteria: only patterns specific enough
+* to avoid excessive false positives (country-prefixed
+* VAT numbers, structured personal IDs). Generic
+* digit-only patterns (e.g. \d{8}) are excluded unless
+* the validator's checksum is strong enough to filter.
+*/
+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),
+	toEntry(cz.dic, "tax identification number", .95),
+	toEntry(de.vat, "tax identification number", .95),
+	toEntry(de.idnr, "tax identification number", .9),
+	toEntry(de.stnr, "tax identification number", .9),
+	toEntry(de.svnr, "social security number", .9),
+	toEntry(pl.nip, "tax identification number", .95),
+	toEntry(pl.pesel, "national identification number", .9),
+	toEntry(gb.vat, "tax identification number", .95),
+	toEntry(gb.nino, "social security number", .95),
+	toEntry(at.uid, "tax identification number", .95),
+	toEntry(at.tin, "tax identification number", .9),
+	toEntry(at.businessid, "registration number", .95),
+	toEntry(be.vat, "tax identification number", .95),
+	toEntry(be.nn, "national identification number", .9),
+	toEntry(nl.vat, "tax identification number", .95),
+	toEntry(dk.vat, "tax identification number", .95),
+	toEntry(dk.cpr, "national identification number", .9),
+	toEntry(fi.vat, "tax identification number", .95),
+	toEntry(fi.hetu, "national identification number", .95),
+	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),
+	toEntry(fr.siren, "registration number", .9),
+	toEntry(fr.siret, "registration number", .9),
+	toEntry(it.iva, "tax identification number", .95),
+	toEntry(ie.vat, "tax identification number", .95),
+	toEntry(ie.pps, "national identification number", .9),
+	toEntry(pt.vat, "tax identification number", .95),
+	toEntry(pt.cc, "national identification number", .9),
+	toEntry(ro.vat, "tax identification number", .95),
+	toEntry(gr.vat, "tax identification number", .95),
+	toEntry(hr.vat, "tax identification number", .95),
+	toEntry(si.vat, "tax identification number", .95),
+	toEntry(lt.vat, "tax identification number", .95),
+	toEntry(lt.asmens, "national identification number", .9),
+	toEntry(lv.vat, "tax identification number", .95),
+	toEntry(ee.vat, "tax identification number", .95),
+	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)
+].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}))*)?`,
+	label: "person",
+	score: .95
+};
+const HONORIFIC_PERSON = {
+	pattern: `(?:${HONORIFIC_ALT})\\.?${SP}+${NAME_WORD}(?:(?:${SP}|-){1,2}(?:${PARTICLE}${SP}+)?${NAME_WORD}){0,3}(?:${SP}+(?:QC|KC|SC|LJ|AG))?`,
+	label: "person",
+	score: .95
+};
+const IBAN = {
+	pattern: "\\b[A-Z]{2}\\d{2}\\s?[\\dA-Z]{4}\\s?[\\dA-Z]{4}\\s?[\\dA-Z]{4}\\s?[\\dA-Z]{4}\\s?[\\dA-Z]{0,14}\\b",
+	label: "iban",
+	score: 1
+};
+const EMAIL = {
+	pattern: `\\b[\\w.+\\-]+@[\\w\\-]+(?:\\.[\\w\\-]+)+\\b`,
+	label: "email address",
+	score: 1
+};
+const INTL_PHONE = {
+	pattern: "\\+\\d{1,3}(?:[^\\S\\n]|[.\\-])?\\(?\\d{2,4}\\)?(?:[^\\S\\n]|[.\\-])?\\d{3}(?:[^\\S\\n]|[.\\-])?\\d{2,4}(?:[^\\S\\n]|[.\\-])?\\d{0,4}\\b",
+	label: "phone number",
+	score: 1
+};
+const CZ_PHONE = {
+	pattern: "\\b[2-7]\\d{2}(?:[^\\S\\n]|[.\\-])?\\d{3}(?:[^\\S\\n]|[.\\-])?\\d{3}(?!(?:[^\\S\\n]|[.\\-])?\\d*/\\d)(?![^\\S\\n]*(?:Kč|,-|korun|EUR|USD|€|\\$))\\b",
+	label: "phone number",
+	score: .85
+};
+/**
+* Phone numbers prefixed with "tel.:" or "telefon:".
+* Captures the number after the prefix, including
+* optional international code (+420).
+*/
+const TEL_PREFIX_PHONE = {
+	pattern: "(?:\\b[Tt]el(?:efon)?\\.?\\s*:?\\s*)(?:\\+?\\d{1,3}[^\\S\\n]?)?\\d{3}(?:[^\\S\\n]|[.\\-])?\\d{3}(?:[^\\S\\n]|[.\\-])?\\d{3}\\b",
+	label: "phone number",
+	score: .95
+};
+const CREDIT_CARD = {
+	pattern: "\\b(?:4\\d{3}|5[1-5]\\d{2}|3[47]\\d{2})(?:[^\\S\\n]|[.\\-])?\\d{4}(?:[^\\S\\n]|[.\\-])?\\d{4}(?:[^\\S\\n]|[.\\-])?\\d{2,4}\\b",
+	label: "credit card number",
+	score: 1
+};
+const CZ_BIRTH_NUMBER = {
+	pattern: `\\b\\d{6}/\\d{3,4}\\b`,
+	label: "czech birth number",
+	score: 1,
+	validator: cz.rc
+};
+const DATE_NUMERIC = {
+	pattern: "\\b(?:\\d{1,2}[./]\\d{1,2}[./]\\d{2,4}|\\d{4}-\\d{2}-\\d{2})\\b",
+	label: "date",
+	score: 1
+};
+const DATE_CZ_SPACED = {
+	pattern: `\\b\\d{1,2}\\.[^\\S\\n]+\\d{1,2}\\.[^\\S\\n]+\\d{4}\\b`,
+	label: "date",
+	score: 1
+};
+const IP_ADDRESS = {
+	pattern: "\\b(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\b",
+	label: "ip address",
+	score: 1
+};
+const CZ_BANK_ACCOUNT = {
+	pattern: `\\b(?:\\d{1,6}-)?\\d{6,10}/\\d{4}(?!\\d)`,
+	label: "bank account number",
+	score: .95
+};
+const HU_LANDLINE = {
+	pattern: "\\+36(?:[^\\S\\n]|[.\\-])?1(?:[^\\S\\n]|[.\\-])?\\d{3}(?:[^\\S\\n]|[.\\-])?\\d{4}\\b",
+	label: "phone number",
+	score: .9
+};
+const CZ_POSTAL = {
+	pattern: `\\b\\d{3}[^\\S\\n]\\d{2}\\b`,
+	label: "address",
+	score: .7
+};
+const URL = {
+	pattern: "(?:https?://|https?:(?=[^\\s])|www\\.)[\\w\\-]+(?:\\.[\\w\\-]+)+(?::\\d+)?(?:[/?#][^\\s)\\]>]*[^\\s.,;:!?)\\]>])?",
+	label: "url",
+	score: 1
+};
+const LONG_TLDS = "com|org|net|eu|cz|sk|pl|hu|ro|fr|es|co\\.uk|nl|ch|info|io|dev";
+const SHORT_TLDS = "de|at|be|se|fi|dk|no|it|uk";
+const HOST_LABEL = `[a-zA-Z0-9](?:[a-zA-Z0-9\\-]*[a-zA-Z0-9])?`;
+const BARE_HOST = `\\b[a-zA-Z0-9][a-zA-Z0-9\\-]+[a-zA-Z0-9]`;
+const PATH_SUFFIX = `(?:[/?#][^\\s)\\]>]*[^\\s.,;:!?)\\]>])?`;
+/**
+* All static PII regex definitions. Scanned in a
+* single pass by @stll/regex-set (Rust DFA).
+*
+* Hand-written patterns (0-17) followed by
+* stdnum-derived patterns (18+). Each stdnum entry
+* has a post-match validator for confirmation.
+*
+* Monetary amount patterns are built dynamically from
+* currencies.json via `getCurrencyPatterns()`.
+*
+* Date patterns using written month names are built
+* dynamically from date-months.json via
+* `getDatePatterns()`.
+*/
+const ALL_REGEX_DEFS = [
+	TITLED_PERSON,
+	HONORIFIC_PERSON,
+	IBAN,
+	EMAIL,
+	INTL_PHONE,
+	CZ_PHONE,
+	TEL_PREFIX_PHONE,
+	CREDIT_CARD,
+	CZ_BIRTH_NUMBER,
+	DATE_NUMERIC,
+	DATE_CZ_SPACED,
+	IP_ADDRESS,
+	CZ_BANK_ACCOUNT,
+	HU_LANDLINE,
+	CZ_POSTAL,
+	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}",
+		label: "ip address",
+		score: 1
+	},
+	{
+		pattern: "\\b(?:[0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}\\b|\\b(?:[0-9a-fA-F]{2}-){5}[0-9a-fA-F]{2}\\b",
+		label: "mac address",
+		score: 1
+	},
+	{
+		pattern: `${BARE_HOST}(?:\\.${HOST_LABEL})*\\.(?:${LONG_TLDS})\\b${PATH_SUFFIX}|${BARE_HOST}(?:\\.${HOST_LABEL})+\\.(?:${SHORT_TLDS})\\b${PATH_SUFFIX}`,
+		label: "url",
+		score: .9
+	},
+	...STDNUM_ENTRIES
+];
+/** Flat pattern array for text-search. */
+const REGEX_PATTERNS = ALL_REGEX_DEFS.map((d) => d.pattern);
+/** Parallel metadata. Index = pattern index. */
+const REGEX_META = ALL_REGEX_DEFS.map((d) => {
+	const meta = {
+		label: d.label,
+		score: d.score
+	};
+	if (d.validator) meta.validator = d.validator;
+	return meta;
+});
+/**
+* Build month-name alternation from date-months.json.
+* Deduplicates across all 22 languages, filters names
+* shorter than 3 chars (too many false positives), and
+* sorts longest-first so the regex engine prefers the
+* longest match.
+*/
+const buildMonthAlternation = (months) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const [key, value] of Object.entries(months)) {
+		if (key.startsWith("_")) continue;
+		const names = Array.isArray(value) ? value : [value];
+		for (const name of names) {
+			const clean = name.replace(/\.$/, "").toLowerCase();
+			if (clean.length >= MIN_MONTH_NAME_LENGTH) seen.add(clean);
+		}
+	}
+	return [...seen].toSorted((a, b) => b.length - a.length).map(escapeRegex$1).join("|");
+};
+/**
+* Build date patterns from a month-name alternation.
+* Returns 6 patterns covering the major written-date
+* formats across all supported languages.
+*/
+const buildDatePatternsFromMonths = (alt) => {
+	if (!alt) return [];
+	return [
+		`(?i)\\b\\d{1,2}\\.?\\s+(?:${alt})\\.?\\s+\\d{4}(?:\\s+\\d{1,2}:\\d{2}(?::\\d{2})?)?\\b`,
+		`(?i)\\b(?:${alt})\\.?\\s+\\d{1,2},?\\s+\\d{4}\\b`,
+		`(?i)\\b\\d{1,2}(?:st|nd|rd|th)\\s+(?:${alt})\\.?(?:\\s+\\d{4})?(?=\\s|[.,;!?)]|$)`,
+		`(?i)\\b(?:${alt})\\.?\\s+\\d{4}\\b`,
+		`(?i)\\b\\d{4}\\.\\s+(?:${alt})\\.?\\s+\\d{1,2}\\.?(?=\\s|[.,;!?)]|$)`,
+		`(?i)\\b\\d{1,2}\\s+de\\s+(?:${alt})\\.?(?:\\s+de)?\\s+\\d{4}\\b`
+	];
+};
+/** Cached promise for date patterns. Loaded once. */
+let datePatternPromise = null;
+const loadDatePatterns = async () => {
+	const mod = await import("@stll/anonymize-data/config/date-months.json");
+	return buildDatePatternsFromMonths(buildMonthAlternation(mod.default ?? mod));
+};
+/**
+* Get dynamically built date patterns from
+* date-months.json. Returns a cached promise; the JSON
+* is loaded only once.
+*/
+const getDatePatterns = () => {
+	if (!datePatternPromise) datePatternPromise = loadDatePatterns().catch((err) => {
+		datePatternPromise = null;
+		throw err;
+	});
+	return datePatternPromise;
+};
+/** Date pattern metadata (all are score 1 dates). */
+const DATE_PATTERN_META = Object.freeze({
+	label: "date",
+	score: 1
+});
+/**
+* Build symbol character class, code alternation,
+* and local-name alternation from currencies.json,
+* then return two monetary amount patterns: leading
+* symbol and trailing code/name.
+*
+* The number sub-pattern accepts both grouped
+* thousands (1,000) and plain integers (100000)
+* via `\d{1,9}` to catch unformatted amounts.
+*/
+const buildCurrencyPatterns = (data) => {
+	const symbols = data.symbols.map(escapeCharClass).join("");
+	const isAsciiAlpha = /^[a-zA-Z\s]+$/;
+	const parts = data.codes.map((code) => ({
+		len: code.length,
+		alt: escapeRegex$1(code)
+	}));
+	const MIN_CI_LENGTH = 3;
+	if (data.localNames) for (const name of data.localNames) {
+		const escaped = escapeRegex$1(name);
+		if (isAsciiAlpha.test(name) && name.length >= MIN_CI_LENGTH) parts.push({
+			len: name.length,
+			alt: `(?i:${escaped})`
+		});
+		else parts.push({
+			len: name.length,
+			alt: escaped
+		});
+	}
+	if (symbols) for (const ch of data.symbols) parts.push({
+		len: ch.length,
+		alt: escapeRegex$1(ch)
+	});
+	const trailingAlt = parts.toSorted((a, b) => b.len - a.len).map((p) => p.alt).join("|");
+	if (!symbols && !trailingAlt) return [];
+	const NUM = "(?:\\d{1,3}(?:[,.'[^\\S\\n\\t]]\\d{3})+|\\d{1,9})";
+	const patterns = [];
+	if (symbols) patterns.push(`(?:[${symbols}])[^\\S\\n\\t]?${NUM}(?:[.,](?:\\d{1,2}[-–—]?|[-–—]{1,2})?)?\\b`);
+	if (trailingAlt) patterns.push(`\\b(?:${trailingAlt})[^\\S\\n\\t]{0,2}${NUM}(?:[.,](?:\\d{1,2}[-–—]?|[-–—]{1,2})?)?\\b`);
+	if (trailingAlt) patterns.push(`\\b${NUM}(?:[.,](?:\\d{1,2}[-–—]?|[-–—]{1,2})?)?[^\\S\\n\\t]{0,4}(?:${trailingAlt})(?:\\b|(?=\\s|[.,;!?)]|$))`);
+	return patterns;
+};
+/** Cached promise for currency patterns. Loaded once. */
+let currencyPatternPromise = null;
+const loadCurrencyPatterns = async () => {
+	const mod = await import("@stll/anonymize-data/config/currencies.json");
+	return buildCurrencyPatterns(mod.default ?? mod);
+};
+/**
+* Get dynamically built monetary amount patterns from
+* currencies.json. Returns a cached promise; the JSON
+* is loaded only once.
+*/
+const getCurrencyPatterns = () => {
+	if (!currencyPatternPromise) currencyPatternPromise = loadCurrencyPatterns().catch((err) => {
+		currencyPatternPromise = null;
+		throw err;
+	});
+	return currencyPatternPromise;
+};
+/** Currency pattern metadata (score 0.9). */
+const CURRENCY_PATTERN_META = Object.freeze({
+	label: "monetary amount",
+	score: .9
+});
+/**
+* Process regex matches from the unified search.
+* Receives all matches; filters to the regex slice
+* via sliceStart/sliceEnd. Local index into META is
+* match.pattern - sliceStart.
+*
+* For stdnum-derived patterns (those with a validator
+* in META), the matched text is passed through the
+* validator's validate() method. If validation fails,
+* the match is discarded as a false positive.
+*/
+const processRegexMatches = (allMatches, sliceStart, sliceEnd, meta_) => {
+	const results = [];
+	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.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;
+		}
+		results.push({
+			start: match.start,
+			end: match.end,
+			label: meta.label,
+			text: match.text,
+			score: meta.score,
+			source: DETECTION_SOURCES.REGEX
+		});
+	}
+	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("@stll/anonymize-data/config/signing-clauses.json");
+	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, requireCapBefore) => {
+	if (forms.length === 0) return null;
+	const alt = forms.toSorted((a, b) => b.length - a.length).map(escapeForRegex).join("|");
+	return `${`(?:${CAP_WORD})(?:(?:[\\s&,.\\-–—]{1,4}|\\s+(?:a|and|und|et|e|y|i)\\s+)(?:${ANY_WORD})){0,10}`}${requireCapBefore ? `(?:\\s+|,\\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("@stll/anonymize-data/config/legal-forms.json")).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)), false);
+	if (longPattern) patterns.push(longPattern);
+	const shortPattern = buildPatternString(allForms.filter(isShortForm), true);
+	if (shortPattern) patterns.push(shortPattern);
+	const allcapPrefix = `(?:${ALLCAP_WORD})(?:[\\s&,.\\-–—]{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;
+};
+/**
+* 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;
+		const prefixEnd = text.lastIndexOf(",") !== -1 ? text.lastIndexOf(",") : text.lastIndexOf(" ");
+		const prefixPart = prefixEnd > 0 ? text.slice(0, prefixEnd).replace(/[^a-zA-ZÀ-ž]/g, "") : text.replace(/[^a-zA-ZÀ-ž]/g, "");
+		const isAllCapsMatch = prefixPart.length > 2 && prefixPart === prefixPart.toUpperCase();
+		if (isAllCapsMatch && fullText) {
+			const lineStart = fullText.lastIndexOf("\n", match.start);
+			const lineEnd = fullText.indexOf("\n", match.end);
+			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 ? text.slice(0, prefixEnd > 0 ? prefixEnd : text.length).trim().split(/\s+/).length : 0) > 3) continue;
+		} else if (isAllCapsMatch) continue;
+		const lastSpace = text.lastIndexOf(" ");
+		const rawSuffix = lastSpace !== -1 ? text.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(text.slice(0, lastSpace !== -1 ? lastSpace : text.length))) continue;
+		results.push({
+			start: match.start,
+			end: match.start + text.length,
+			label: "organization",
+			text,
+			score: .95,
+			source: DETECTION_SOURCES.LEGAL_FORM
+		});
+	}
+	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.".
+*/
+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."
+];
+//#endregion
+//#region src/detectors/triggers.ts
+const TRIGGER_SCORE = .95;
+const WHITESPACE_RE$1 = /\s+/;
+const LETTER_RE = /\p{L}/u;
+/**
+* Post-nominal degree regex. When a comma-stop is
+* followed by a known post-nominal (Ph.D., CSc., MBA
+* 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 compileValidations = (validations) => validations.map((v) => {
+	switch (v.type) {
+		case "starts-uppercase": return {
+			type: "starts-uppercase",
+			re: /^\p{Lu}/u
+		};
+		case "min-length": return {
+			type: "min-length",
+			min: v.min
+		};
+		case "max-length": return {
+			type: "max-length",
+			max: v.max
+		};
+		case "no-digits": return {
+			type: "no-digits",
+			re: /\d/
+		};
+		case "has-digits": return {
+			type: "has-digits",
+			re: /\d/
+		};
+		case "matches-pattern": return {
+			type: "matches-pattern",
+			re: new RegExp(v.pattern, (v.flags ?? "").replace(/[gy]/g, ""))
+		};
+		default: throw new Error(`Unknown validation type: ${JSON.stringify(v)}`);
+	}
+});
+const applyValidations = (text, validations) => {
+	for (const v of validations) switch (v.type) {
+		case "starts-uppercase":
+			if (!v.re.test(text)) return false;
+			break;
+		case "min-length":
+			if (text.length < v.min) return false;
+			break;
+		case "max-length":
+			if (text.length > v.max) return false;
+			break;
+		case "no-digits":
+			if (v.re.test(text)) return false;
+			break;
+		case "has-digits":
+			if (!v.re.test(text)) return false;
+			break;
+		case "matches-pattern":
+			if (!v.re.test(text)) return false;
+			break;
+		default: throw new Error(`Unknown compiled validation type: ${JSON.stringify(v)}`);
+	}
+	return true;
+};
+const expandTriggerGroups = (groups) => {
+	const rules = [];
+	for (const group of groups) {
+		const extensions = group.extensions ?? [];
+		const compiled = compileValidations(group.validations ?? []);
+		const allTriggers = new Set(group.triggers);
+		for (const trigger of group.triggers) {
+			if (extensions.includes("add-colon") && !trigger.endsWith(":")) allTriggers.add(`${trigger}:`);
+			if (extensions.includes("add-trailing-space") && !trigger.endsWith(" ")) allTriggers.add(`${trigger} `);
+			if (extensions.includes("add-colon-space") && !trigger.endsWith(": ") && !trigger.endsWith(":")) allTriggers.add(`${trigger}: `);
+			if (extensions.includes("normalize-spaces")) {
+				if (trigger.includes(" ")) allTriggers.add(trigger.replace(/ /g, "\xA0"));
+			}
+		}
+		const includeTrigger = group.includeTrigger ?? false;
+		for (const trigger of allTriggers) rules.push({
+			trigger,
+			label: group.label,
+			strategy: group.strategy,
+			validations: compiled,
+			includeTrigger
+		});
+	}
+	return rules;
+};
+/**
+* Build trigger patterns and rules from data configs.
+* Returns string[] for the unified TextSearch
+* builder and the parallel rules array.
+*/
+const buildTriggerPatterns = async () => {
+	const rules = [];
+	const allGroups = await loadLanguageConfigs("triggers", (mod) => {
+		return mod.default ?? mod;
+	});
+	for (const groups of allGroups) {
+		if (!Array.isArray(groups)) {
+			console.warn("[anonymize] triggers: unexpected config shape, skipping");
+			continue;
+		}
+		rules.push(...expandTriggerGroups(groups));
+	}
+	try {
+		const globalMod = await import("@stll/anonymize-data/config/triggers.global.json");
+		const globalGroups = globalMod.default ?? globalMod;
+		if (Array.isArray(globalGroups)) rules.push(...expandTriggerGroups(globalGroups));
+	} catch (err) {
+		if (!(err instanceof Error) || !err.message.includes("Cannot find module")) throw err;
+	}
+	const seen = /* @__PURE__ */ new Map();
+	for (const rule of rules) {
+		const key = rule.trigger.toLowerCase();
+		const prev = seen.get(key);
+		if (prev !== void 0) {
+			const labelDiff = prev.label !== rule.label;
+			const stratDiff = prev.strategy !== rule.strategy.type;
+			if (labelDiff || stratDiff) console.warn(`[anonymize] duplicate trigger "${rule.trigger}":` + (labelDiff ? ` labels "${prev.label}" vs "${rule.label}"` : "") + (stratDiff ? ` strategies "${prev.strategy}" vs "${rule.strategy.type}"` : ""));
+		}
+		seen.set(key, {
+			label: rule.label,
+			strategy: rule.strategy.type
+		});
+	}
+	return {
+		patterns: rules.map((r) => r.trigger.toLowerCase()),
+		rules
+	};
+};
+const LEADING_PUNCT = /^[„""»«'"()\s]+/;
+const TRAILING_PUNCT = /[""»«'"()\s]+$/;
+const stripQuotes = (value) => {
+	const leadingMatch = LEADING_PUNCT.exec(value.text);
+	const leadingLen = leadingMatch ? leadingMatch[0].length : 0;
+	const stripped = value.text.slice(leadingLen).replace(TRAILING_PUNCT, "");
+	if (stripped.length === 0) return null;
+	return {
+		start: value.start + leadingLen,
+		end: value.start + leadingLen + stripped.length,
+		text: stripped
+	};
+};
+/** Hard stop characters for to-next-comma scanning. */
+const COMMA_STOP_CHARS = new Set(["\n", "("]);
+/**
+* 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.
+*/
+const ADDRESS_STOP_KEYWORDS = [
+	"číslo účtu",
+	"registrační",
+	"zastoupen",
+	"bankovní",
+	"e-mail",
+	"telefon",
+	"jednatel",
+	"ředitel",
+	"datová",
+	"vložka",
+	"sp.zn.",
+	"oddíl",
+	"swift",
+	"email",
+	"iban",
+	"dič",
+	"ičo",
+	"tel",
+	"č.ú.",
+	"bic",
+	"ič"
+];
+const extractValue = (text, triggerEnd, strategy, label) => {
+	const remaining = text.slice(triggerEnd);
+	const stripped = remaining.replace(/^[\s:;]+/, "");
+	const valueStart = triggerEnd + (remaining.length - stripped.length);
+	const valueText = stripped;
+	if (valueText.length === 0) return null;
+	switch (strategy.type) {
+		case "to-next-comma": {
+			let end = 0;
+			let foundStop = false;
+			while (end < valueText.length) {
+				const ch = valueText[end];
+				if (ch !== void 0 && COMMA_STOP_CHARS.has(ch)) {
+					foundStop = true;
+					break;
+				}
+				if (ch === ",") {
+					const afterComma = valueText.slice(end);
+					const degreeMatch = label === "person" ? POST_NOMINAL_RE.exec(afterComma) : null;
+					if (degreeMatch) {
+						end += degreeMatch[0].length;
+						continue;
+					}
+					foundStop = true;
+					break;
+				}
+				end++;
+			}
+			if (!foundStop) end = Math.min(end, 100);
+			const rawSlice = valueText.slice(0, end);
+			const extracted = rawSlice.trim();
+			if (extracted.length === 0) return null;
+			const trailingSpaces = rawSlice.length - rawSlice.trimEnd().length;
+			return {
+				start: valueStart,
+				end: valueStart + end - trailingSpaces,
+				text: extracted
+			};
+		}
+		case "to-end-of-line": {
+			const LINE_STOPS = ["\n"];
+			let end = valueText.length;
+			for (const ch of LINE_STOPS) {
+				const idx = valueText.indexOf(ch);
+				if (idx !== -1 && idx < end) end = idx;
+			}
+			const rawSlice = valueText.slice(0, end);
+			const extracted = rawSlice.trim();
+			if (extracted.length === 0) return null;
+			const trailingSpaces = rawSlice.length - rawSlice.trimEnd().length;
+			return {
+				start: valueStart,
+				end: valueStart + end - trailingSpaces,
+				text: extracted
+			};
+		}
+		case "n-words": {
+			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);
+			if (words.length === 0) return null;
+			const firstWord = words[0];
+			if (firstWord === void 0) return null;
+			const firstIdx = cellText.indexOf(firstWord);
+			let actualEnd = firstIdx + firstWord.length;
+			let searchPos = actualEnd;
+			for (let wi = 1; wi < words.length; wi++) {
+				const w = words[wi];
+				if (w === void 0) break;
+				const wIdx = cellText.indexOf(w, searchPos);
+				if (wIdx === -1) break;
+				actualEnd = wIdx + w.length;
+				searchPos = actualEnd;
+			}
+			return {
+				start: valueStart + firstIdx,
+				end: valueStart + actualEnd,
+				text: cellText.slice(firstIdx, actualEnd)
+			};
+		}
+		case "company-id-value": {
+			const raw = text.slice(triggerEnd);
+			const sepMatch = /^(?:\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);
+			if (!idMatch) return null;
+			const idText = idMatch[0].trim();
+			const leadingSpaces = idMatch[0].length - idMatch[0].trimStart().length;
+			const idStart = triggerEnd + sepMatch[0].length + leadingSpaces;
+			return {
+				start: idStart,
+				end: idStart + idText.length,
+				text: idText
+			};
+		}
+		case "address": {
+			const maxLen = strategy.maxChars ?? 120;
+			const UPPER_RE = /\p{Lu}/u;
+			let end = 0;
+			while (end < valueText.length && end < maxLen) {
+				const ch = valueText[end];
+				if (ch === "\n" || ch === "(") break;
+				if (ch === ".") {
+					const next = valueText[end + 1];
+					const afterNext = valueText[end + 2];
+					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))) {
+						end++;
+						continue;
+					}
+					break;
+				}
+				if (ch === ",") {
+					let peek = end + 1;
+					while (peek < valueText.length && (valueText[peek] === " " || valueText[peek] === "	")) peek++;
+					const peekCh = valueText[peek];
+					if (peekCh === void 0) break;
+					const afterComma = valueText.slice(end + 1).trimStart().toLowerCase();
+					if (ADDRESS_STOP_KEYWORDS.some((kw) => {
+						if (!afterComma.startsWith(kw)) return false;
+						const next = afterComma[kw.length];
+						return next === void 0 || /[\s:;.,!?()\d]/.test(next);
+					})) break;
+					if (/\d/.test(peekCh) || UPPER_RE.test(peekCh)) {
+						end++;
+						continue;
+					}
+					break;
+				}
+				end++;
+			}
+			if (end >= maxLen) {
+				const lastSpace = valueText.lastIndexOf(" ", end - 1);
+				if (lastSpace > 0) end = lastSpace;
+			}
+			const rawSlice = valueText.slice(0, end);
+			const extracted = rawSlice.trim();
+			if (extracted.length === 0) return null;
+			const trailingSpaces = rawSlice.length - rawSlice.trimEnd().length;
+			return {
+				start: valueStart,
+				end: valueStart + end - trailingSpaces,
+				text: extracted
+			};
+		}
+		default: return null;
+	}
+};
+/**
+* Process trigger matches from the unified search.
+* Receives all matches; filters to the trigger slice
+* via sliceStart/sliceEnd. Uses fullText for value
+* extraction (the unified search runs on lowercased
+* text, but extraction needs original casing).
+*/
+const processTriggerMatches = (allMatches, sliceStart, sliceEnd, fullText, rules) => {
+	const results = [];
+	for (const match of allMatches) {
+		const idx = match.pattern;
+		if (idx < sliceStart || idx >= sliceEnd) continue;
+		const localIdx = idx - sliceStart;
+		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 triggerEnd = match.end;
+		const rawValue = extractValue(fullText, triggerEnd, rule.strategy, rule.label);
+		const value = rawValue ? stripQuotes(rawValue) : null;
+		if (value) {
+			if (!applyValidations(value.text, rule.validations)) continue;
+			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;
+			results.push({
+				start: entityStart,
+				end: entityEnd,
+				label: effectiveLabel,
+				text: entityText,
+				score: TRIGGER_SCORE,
+				source: DETECTION_SOURCES.TRIGGER
+			});
+		}
+	}
+	return results;
+};
+//#endregion
+//#region src/regions.ts
+/**
+* Geographic regions and country code mappings for
+* scoping deny list dictionaries.
+*/
+const REGIONS = {
+	Global: null,
+	International: null,
+	Europe: [
+		"AL",
+		"AD",
+		"AT",
+		"BE",
+		"BA",
+		"BG",
+		"HR",
+		"CY",
+		"CZ",
+		"DK",
+		"EE",
+		"FI",
+		"FR",
+		"DE",
+		"GR",
+		"HU",
+		"IS",
+		"IE",
+		"IT",
+		"XK",
+		"LV",
+		"LI",
+		"LT",
+		"LU",
+		"MD",
+		"ME",
+		"MK",
+		"MT",
+		"MC",
+		"NL",
+		"NO",
+		"PL",
+		"PT",
+		"RO",
+		"RS",
+		"SK",
+		"SI",
+		"ES",
+		"SE",
+		"CH",
+		"UA",
+		"GB"
+	],
+	Americas: [
+		"US",
+		"CA",
+		"MX",
+		"BR",
+		"AR",
+		"CL",
+		"CO",
+		"PE",
+		"EC",
+		"VE",
+		"UY",
+		"PY",
+		"BO",
+		"CR",
+		"PA",
+		"DO",
+		"GT",
+		"HN",
+		"SV",
+		"NI",
+		"CU"
+	],
+	AsiaPacific: [
+		"AU",
+		"NZ",
+		"JP",
+		"KR",
+		"CN",
+		"TW",
+		"SG",
+		"MY",
+		"TH",
+		"VN",
+		"PH",
+		"ID",
+		"IN",
+		"PK",
+		"BD",
+		"LK",
+		"NP",
+		"HK",
+		"MO"
+	],
+	MENA: [
+		"AE",
+		"SA",
+		"IL",
+		"TR",
+		"EG",
+		"JO",
+		"LB",
+		"IQ",
+		"IR",
+		"QA",
+		"KW",
+		"BH",
+		"OM",
+		"MA",
+		"TN",
+		"DZ",
+		"LY",
+		"SY",
+		"YE",
+		"PS"
+	],
+	SubSaharanAfrica: [
+		"ZA",
+		"NG",
+		"KE",
+		"GH",
+		"TZ",
+		"ET",
+		"SN",
+		"CI",
+		"CM",
+		"UG",
+		"RW",
+		"MZ",
+		"AO",
+		"ZW",
+		"BW",
+		"NA",
+		"MU"
+	],
+	EU: [
+		"AT",
+		"BE",
+		"BG",
+		"HR",
+		"CY",
+		"CZ",
+		"DK",
+		"EE",
+		"FI",
+		"FR",
+		"DE",
+		"GR",
+		"HU",
+		"IE",
+		"IT",
+		"LV",
+		"LT",
+		"LU",
+		"MT",
+		"NL",
+		"PL",
+		"PT",
+		"RO",
+		"SK",
+		"SI",
+		"ES",
+		"SE"
+	],
+	DACH: [
+		"DE",
+		"AT",
+		"CH"
+	],
+	Nordics: [
+		"DK",
+		"SE",
+		"NO",
+		"FI",
+		"IS"
+	],
+	CEE: [
+		"CZ",
+		"SK",
+		"PL",
+		"HU",
+		"RO",
+		"BG",
+		"HR",
+		"SI",
+		"LT",
+		"LV",
+		"EE"
+	],
+	Anglosphere: [
+		"GB",
+		"US",
+		"CA",
+		"AU",
+		"NZ",
+		"IE"
+	],
+	Benelux: [
+		"BE",
+		"NL",
+		"LU"
+	],
+	GulfStates: [
+		"AE",
+		"SA",
+		"QA",
+		"KW",
+		"BH",
+		"OM"
+	],
+	SouthAsia: [
+		"IN",
+		"PK",
+		"BD",
+		"LK",
+		"NP"
+	],
+	EastAsia: [
+		"CN",
+		"JP",
+		"KR",
+		"TW"
+	],
+	SoutheastAsia: [
+		"SG",
+		"MY",
+		"TH",
+		"VN",
+		"PH",
+		"ID"
+	],
+	Oceania: ["AU", "NZ"]
+};
+/**
+* Expand region names to country codes and merge with
+* explicit country codes. Returns null when both inputs
+* are empty/undefined (meaning "match all countries").
+*/
+const resolveCountries = (regions, countries) => {
+	const hasRegions = regions && regions.length > 0;
+	const hasCountries = countries && countries.length > 0;
+	if (!hasRegions && !hasCountries) return null;
+	const result = /* @__PURE__ */ new Set();
+	const isRegion = (name) => name in REGIONS;
+	if (hasRegions) for (const name of regions) {
+		if (!isRegion(name)) continue;
+		const codes = REGIONS[name];
+		if (codes === null) return null;
+		for (const code of codes) result.add(code);
+	}
+	if (hasCountries) for (const code of countries) result.add(code);
+	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 MAX_ENTITY_LENGTH = {
+	organization: 80,
+	person: 60
+};
+const SECTION_NUMBER_RE = /^(?:§\s*)?\d{1,3}(?:\.\d{1,3}){0,4}\.?$/;
+const STANDALONE_YEAR_RE = /^(?:19|20)\d{2}$/;
+const EMPTY_GENERIC_ROLES = /* @__PURE__ */ new Set();
+/**
+* Load generic-roles.json and cache the result on the
+* given context. Must be awaited during pipeline init
+* so the sync accessor is populated before
+* filterFalsePositives runs.
+*/
+const loadGenericRoles = (ctx = defaultContext) => {
+	if (ctx.genericRolesPromise) return ctx.genericRolesPromise;
+	ctx.genericRolesPromise = (async () => {
+		try {
+			const mod = await import("@stll/anonymize-data/config/generic-roles.json");
+			const set = new Set(mod.default?.roles ?? []);
+			ctx.genericRoles = set;
+			return set;
+		} catch {
+			const empty = /* @__PURE__ */ new Set();
+			ctx.genericRoles = empty;
+			return empty;
+		}
+	})();
+	return ctx.genericRolesPromise;
+};
+/** Sync accessor — returns empty set before init. */
+const getGenericRoles = (ctx) => ctx.genericRoles ?? EMPTY_GENERIC_ROLES;
+/**
+* Filter out entities that are likely false positives:
+* template placeholders, clause/section numbers,
+* standalone years, and generic legal role terms.
+*
+* Runs as a post-processing step after all detection
+* layers have merged.
+*/
+const filterFalsePositives = (entities, ctx = defaultContext) => {
+	const filtered = [];
+	const roles = getGenericRoles(ctx);
+	for (const entity of entities) {
+		const trimmed = entity.text.trim();
+		if (TEMPLATE_PLACEHOLDER_RE.test(trimmed)) continue;
+		const maxLen = MAX_ENTITY_LENGTH[entity.label];
+		if (maxLen && trimmed.length > maxLen && entity.source !== "legal-form") continue;
+		if (SECTION_NUMBER_RE.test(trimmed) && entity.source !== "trigger") continue;
+		if (STANDALONE_YEAR_RE.test(trimmed)) continue;
+		if ((entity.label === "person" || entity.label === "organization") && roles.has(trimmed.toLowerCase())) continue;
+		if (entity.label === "address" && trimmed.length > 40 && !POSTAL_CODE_RE.test(trimmed) && !HAS_DIGIT_RE.test(trimmed) && !ADDRESS_COMPONENTS_RE.test(trimmed)) continue;
+		if (entity.label === "address" && entity.source === "trigger" && !HAS_DIGIT_RE.test(trimmed) && !ADDRESS_COMPONENTS_RE.test(trimmed)) continue;
+		filtered.push(entity);
+	}
+	return filtered;
+};
+//#endregion
+//#region src/util/normalize.ts
+const CHAR_MAP = new Map([
+	[160, 32],
+	[8199, 32],
+	[8239, 32],
+	[8211, 45],
+	[8212, 45],
+	[8220, 34],
+	[8221, 34]
+]);
+/** Chunk size for `String.fromCharCode` to avoid
+*  hitting the call-stack limit on very large strings. */
+const CHUNK_SIZE = 8192;
+const normalizeForSearch = (text) => {
+	let hasSpecial = false;
+	for (let i = 0; i < text.length; i++) if (CHAR_MAP.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.get(code) ?? code;
+	}
+	if (len <= CHUNK_SIZE) return String.fromCharCode(...codes);
+	let result = "";
+	for (let offset = 0; offset < len; offset += CHUNK_SIZE) {
+		const end = Math.min(offset + CHUNK_SIZE, len);
+		result += String.fromCharCode(...codes.subarray(offset, end));
+	}
+	return result;
+};
+//#endregion
+//#region src/detectors/deny-list.ts
+/**
+* Try to load the optional @stll/anonymize-data package.
+* Returns null if not installed.
+*/
+const loadDataModule = async () => {
+	try {
+		return await import("@stll/anonymize-data");
+	} catch {
+		return null;
+	}
+};
+const loadAllowList = (ctx) => {
+	if (ctx.allowListPromise) return ctx.allowListPromise;
+	ctx.allowListPromise = (async () => {
+		try {
+			const mod = await import("@stll/anonymize-data/config/allow-list.json");
+			const set = new Set(mod.default?.words ?? []);
+			ctx.allowList = set;
+			return set;
+		} catch {
+			const empty = /* @__PURE__ */ new Set();
+			ctx.allowList = empty;
+			return empty;
+		}
+	})();
+	return ctx.allowListPromise;
+};
+const EMPTY_ALLOW_LIST = /* @__PURE__ */ new Set();
+/** Sync accessor — returns empty set before init. */
+const getAllowList = (ctx) => ctx.allowList ?? EMPTY_ALLOW_LIST;
+/**
+* Common EU given names present in the stopwords-iso dataset
+* but absent from the first-name corpus. Without this
+* supplementary set, these names would pass through the
+* corpus-based filter and remain in the stopwords, silently
+* suppressing person detection.
+*
+* Sourced from EU member state birth registries (top-100
+* names) cross-referenced with stopwords.json.
+*/
+const SUPPLEMENTARY_NAME_EXCLUSIONS = new Set([
+	"ana",
+	"ben",
+	"dan",
+	"eden",
+	"ella",
+	"ina",
+	"jo",
+	"kai",
+	"lena",
+	"may",
+	"mia",
+	"sam",
+	"sara",
+	"sue",
+	"tim",
+	"tom"
+]);
+/**
+* Names from the first-name corpus (lowercased) that also
+* appear in the stopwords-iso dataset, plus supplementary
+* common EU given names not in the corpus. These must be
+* kept out of global STOPWORDS so that person detection is
+* not silently suppressed for real given names.
+*
+* Computed lazily after initNameCorpus() has populated
+* the first-name corpus. Re-builds if corpus size changes.
+*/
+const getFirstNameExclusions = (ctx) => {
+	const corpus = getNameCorpusFirstNames(ctx);
+	if (ctx.firstNameExclusions && corpus.length === ctx.firstNameExclusionCorpusLen) return ctx.firstNameExclusions;
+	ctx.firstNameExclusionCorpusLen = corpus.length;
+	const set = new Set([...corpus.map((n) => n.toLowerCase()), ...SUPPLEMENTARY_NAME_EXCLUSIONS]);
+	ctx.firstNameExclusions = set;
+	return set;
+};
+/**
+* Global stopwords: common words across 23 EU languages
+* sourced from the stopwords-iso dataset (MIT license).
+* Checked case-insensitively against matches.
+*
+* Entries that collide with the first-name corpus are
+* excluded so they can still be detected as person names.
+*
+* Regenerate: bun packages/data/scripts/generate-stopwords.ts
+*/
+const loadStopwords = (ctx) => {
+	if (ctx.stopwordsPromise) return ctx.stopwordsPromise;
+	ctx.stopwordsPromise = (async () => {
+		try {
+			const list = ((await import("@stll/anonymize-data/config/stopwords.json")).default ?? []).filter((w) => !getFirstNameExclusions(ctx).has(w));
+			const set = new Set(list);
+			ctx.stopwords = set;
+			return set;
+		} catch (err) {
+			console.warn("[anonymize] Failed to load stopwords.json — stopword filtering disabled:", err);
+			const empty = /* @__PURE__ */ new Set();
+			ctx.stopwords = empty;
+			return empty;
+		}
+	})();
+	return ctx.stopwordsPromise;
+};
+const EMPTY_STOPWORDS = /* @__PURE__ */ new Set();
+/** Sync accessor — returns empty set before init. */
+const getStopwords = (ctx) => ctx.stopwords ?? EMPTY_STOPWORDS;
+const loadPersonStopwords = (ctx) => {
+	if (ctx.personStopwordsPromise) return ctx.personStopwordsPromise;
+	ctx.personStopwordsPromise = (async () => {
+		try {
+			const mod = await import("@stll/anonymize-data/config/person-stopwords.json");
+			const set = new Set(mod.default?.words ?? []);
+			ctx.personStopwords = set;
+			return set;
+		} catch {
+			const empty = /* @__PURE__ */ new Set();
+			ctx.personStopwords = empty;
+			return empty;
+		}
+	})();
+	return ctx.personStopwordsPromise;
+};
+const EMPTY_PERSON_STOPWORDS = /* @__PURE__ */ new Set();
+/** Sync accessor — returns empty set before init. */
+const getPersonStopwords = (ctx) => ctx.personStopwords ?? EMPTY_PERSON_STOPWORDS;
+/**
+* Resolve which dictionaries to load based on country
+* and category filters, load them, and build the deny
+* list data. The returned data provides PatternEntry[]
+* for the unified builder and parallel arrays for
+* post-processing.
+*
+* Requires `@stll/anonymize-data` to be installed.
+* Returns null if the data package is not available.
+*/
+const buildDenyList = async (config, ctx = defaultContext) => {
+	await initNameCorpus(ctx);
+	await Promise.all([
+		loadStopwords(ctx),
+		loadAllowList(ctx),
+		loadPersonStopwords(ctx),
+		loadGenericRoles(ctx)
+	]);
+	const dataModule = await loadDataModule();
+	if (!dataModule) return null;
+	const allowedCountries = resolveCountries(config.denyListRegions, config.denyListCountries);
+	const excluded = config.denyListExcludeCategories;
+	const excludeCategories = excluded ? new Set(excluded) : /* @__PURE__ */ new Set();
+	const ids = [...dataModule.ALL_DICTIONARY_IDS].filter((id) => {
+		const meta = dataModule.DICTIONARY_META[id];
+		if (!meta) return false;
+		if (excludeCategories.has(meta.category)) return false;
+		if (allowedCountries === null) return true;
+		if (meta.country === null) return true;
+		return allowedCountries.has(meta.country);
+	});
+	const patternList = [];
+	const labelList = [];
+	const sourceList = [];
+	const patternIndex = /* @__PURE__ */ new Map();
+	const results = await Promise.all(ids.map(async (id) => {
+		return {
+			id,
+			entries: await dataModule.loadDictionary(id)
+		};
+	}));
+	const addDenyListEntry = (entry, label) => {
+		const normalized = normalizeForSearch(entry).replace(/[|\\]/g, "");
+		if (normalized.length === 0) return;
+		const lower = normalized.toLowerCase();
+		const existing = patternIndex.get(lower);
+		if (existing !== void 0) {
+			if (!labelList[existing].includes(label)) labelList[existing].push(label);
+			if (!sourceList[existing].includes("deny-list")) sourceList[existing].push("deny-list");
+		} else {
+			patternIndex.set(lower, patternList.length);
+			patternList.push(normalized);
+			labelList.push([label]);
+			sourceList.push(["deny-list"]);
+		}
+	};
+	for (const { id, entries } of results) {
+		const meta = dataModule.DICTIONARY_META[id];
+		if (!meta) continue;
+		for (const entry of entries) addDenyListEntry(entry, meta.label);
+	}
+	if (!excludeCategories.has("Places")) {
+		const cityCountries = allowedCountries !== null ? [...allowedCountries] : [
+			"AT",
+			"AU",
+			"BE",
+			"BG",
+			"BR",
+			"CA",
+			"CH",
+			"CZ",
+			"DE",
+			"DK",
+			"ES",
+			"FI",
+			"FR",
+			"GB",
+			"GR",
+			"HR",
+			"HU",
+			"IE",
+			"IT",
+			"LU",
+			"NL",
+			"NO",
+			"NZ",
+			"PL",
+			"PT",
+			"RO",
+			"SE",
+			"SI",
+			"SK",
+			"US"
+		];
+		const cityEntries = await dataModule.loadCityDictionaries(cityCountries);
+		for (const entry of cityEntries) addDenyListEntry(entry, "address");
+	}
+	const addNameEntry = (name, source) => {
+		const normalized = normalizeForSearch(name).replace(/[|\\]/g, "");
+		if (normalized.length === 0) return;
+		const lower = normalized.toLowerCase();
+		const existing = patternIndex.get(lower);
+		if (existing !== void 0) {
+			if (!labelList[existing].includes("person")) labelList[existing].push("person");
+			if (!sourceList[existing].includes(source)) sourceList[existing].push(source);
+		} else {
+			patternIndex.set(lower, patternList.length);
+			patternList.push(normalized);
+			labelList.push(["person"]);
+			sourceList.push([source]);
+		}
+	};
+	for (const name of getNameCorpusFirstNames(ctx)) addNameEntry(name, "first-name");
+	for (const name of getNameCorpusSurnames(ctx)) addNameEntry(name, "surname");
+	for (const title of getNameCorpusTitles(ctx)) {
+		const norm = normalizeForSearch(title).replace(/[|\\]/g, "");
+		if (norm.length === 0) continue;
+		const lower = norm.toLowerCase();
+		const existing = patternIndex.get(lower);
+		if (existing !== void 0) {
+			if (!sourceList[existing].includes("title")) sourceList[existing].push("title");
+		} else {
+			patternIndex.set(lower, patternList.length);
+			patternList.push(norm);
+			labelList.push(["person"]);
+			sourceList.push(["title"]);
+		}
+	}
+	if (patternList.length === 0) return null;
+	return {
+		labels: labelList,
+		originals: patternList,
+		sources: sourceList
+	};
+};
+/**
+* Ensure all deny-list support data (stopwords, allow
+* list, person stopwords, generic roles) is loaded on
+* the given context. Call this before
+* processDenyListMatches / filterFalsePositives when
+* the search instance was built on a different context
+* (e.g. cachedSearch).
+*/
+const ensureDenyListData = async (ctx = defaultContext) => {
+	await initNameCorpus(ctx);
+	await Promise.all([
+		loadStopwords(ctx),
+		loadAllowList(ctx),
+		loadPersonStopwords(ctx),
+		loadGenericRoles(ctx)
+	]);
+};
+/**
+* Process deny list matches from the unified search.
+* Receives all matches; filters to the deny list slice
+* via sliceStart/sliceEnd. Local index into data.labels,
+* data.originals, data.sources is match.pattern - sliceStart.
+*
+* Two-pass approach to reduce false positives:
+* 1. Collect all matches (case-insensitive,
+*    whole-word via Rust automaton)
+* 2. Require uppercase start in source text
+* 3. For person names, require at least one
+*    mid-sentence occurrence to prove proper noun
+* 4. Return all occurrences of validated terms
+*/
+const processDenyListMatches = (allMatches, sliceStart, sliceEnd, fullText, data, ctx = defaultContext) => {
+	const matchesByPattern = /* @__PURE__ */ new Map();
+	for (const match of allMatches) {
+		const idx = match.pattern;
+		if (idx < sliceStart || idx >= sliceEnd) continue;
+		const localIdx = idx - sliceStart;
+		const sourceChar = fullText[match.start] ?? "";
+		if (!UPPER_START_RE.test(sourceChar)) continue;
+		const matchText = fullText.slice(match.start, match.end);
+		const keyword = matchText.toLowerCase();
+		if (getStopwords(ctx).has(keyword) || getAllowList(ctx).has(keyword)) continue;
+		if (ALL_UPPER_RE.test(matchText)) continue;
+		const labels = data.labels[localIdx];
+		if (!labels || labels.length === 0) continue;
+		const entry = {
+			start: match.start,
+			end: match.end,
+			labels,
+			text: matchText,
+			patternIdx: localIdx
+		};
+		const existing = matchesByPattern.get(localIdx);
+		if (existing) existing.push(entry);
+		else matchesByPattern.set(localIdx, [entry]);
+	}
+	const results = [];
+	const nameHits = [];
+	for (const [, matches] of Array.from(matchesByPattern)) {
+		const first = matches[0];
+		if (!first) continue;
+		const hasPerson = first.labels.includes("person");
+		const nonPersonLabels = first.labels.filter((l) => l !== "person");
+		if (hasPerson) {
+			const keyword = first.text.toLowerCase();
+			if (!getPersonStopwords(ctx).has(keyword)) for (const m of matches) nameHits.push(m);
+		}
+		for (const m of matches) for (const label of nonPersonLabels) 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);
+	const nameConsumed = /* @__PURE__ */ new Set();
+	for (let i = 0; i < nameHits.length; i++) {
+		if (nameConsumed.has(i)) continue;
+		const hit = nameHits[i];
+		if (!hit) continue;
+		const chain = [hit];
+		let j = i + 1;
+		while (j < nameHits.length && chain.length < 5) {
+			const next = nameHits[j];
+			if (!next) break;
+			const prev = chain.at(-1);
+			if (!prev) break;
+			const gap = fullText.slice(prev.end, next.start);
+			if (gap.length > 4 || gap.length === 0 || gap.includes("\n") || gap.includes("	")) break;
+			chain.push(next);
+			j++;
+		}
+		for (let k = i; k < i + chain.length; k++) nameConsumed.add(k);
+		const first = chain.at(0);
+		const last = chain.at(-1);
+		if (!first || !last) continue;
+		const extended = extendPersonName(fullText, first.start, last.end, ctx);
+		const score = chain.length >= 2 ? .9 : .5;
+		if (chain.length === 1 && isSentenceStart(fullText, first.start)) continue;
+		results.push({
+			start: first.start,
+			end: extended.end,
+			label: "person",
+			text: extended.text,
+			score,
+			source: DETECTION_SOURCES.DENY_LIST
+		});
+	}
+	extendCityDistricts(results, fullText);
+	return results;
+};
+const DISTRICT_SUFFIX_RE = new RegExp(`^ (\\d{1,2}(?!\\d)|(?:XXX|XXIX|XXVIII|XXVII|XXVI|XXV|XXIV|XXIII|XXII|XXI|XX|XIX|XVIII|XVII|XVI|XV|XIV|XIII|XII|XI|X|IX|VIII|VII|VI|IV|III|II))(?=[\\s,;.)"\\n]|$)`);
+const POSTAL_PREFIX_RE = /(?:\d{5}|\d{3}\s\d{2})\s+$/;
+const TRAILING_WORD_EXCLUSIONS = new Set([
+	"nájemce",
+	"pronajímatel",
+	"kupující",
+	"prodávající",
+	"objednatel",
+	"zhotovitel",
+	"dodavatel",
+	"odběratel",
+	"věřitel",
+	"dlužník",
+	"zadavatel",
+	"uchazeč",
+	"příjemce",
+	"plátce",
+	"správa",
+	"sekretariát",
+	"kancelář",
+	"odbor",
+	"oddělení",
+	"úřad",
+	"inspekce",
+	"agentura",
+	"článek",
+	"smlouva",
+	"dodatek",
+	"příloha",
+	"předmět",
+	"podmínky",
+	"ustanovení"
+]);
+const extendCityDistricts = (entities, fullText) => {
+	for (const entity of entities) {
+		if (entity.label !== "address") continue;
+		const afterMatch = fullText.slice(entity.end);
+		const suffixM = DISTRICT_SUFFIX_RE.exec(afterMatch);
+		if (suffixM) {
+			entity.end += suffixM[0].length;
+			entity.text = fullText.slice(entity.start, entity.end);
+		}
+		const afterDistrict = fullText.slice(entity.end);
+		const dashDistrictM = /^[\s]*[-–][\s]*(\p{Lu}\p{Ll}+)/u.exec(afterDistrict);
+		if (dashDistrictM && !dashDistrictM[0].includes("\n")) {
+			entity.end += dashDistrictM[0].length;
+			entity.text = fullText.slice(entity.start, entity.end);
+		}
+		const beforeMatch = fullText.slice(Math.max(0, entity.start - 10), entity.start);
+		const prefixM = POSTAL_PREFIX_RE.exec(beforeMatch);
+		if (prefixM) {
+			entity.start -= prefixM[0].length;
+			entity.text = fullText.slice(entity.start, entity.end);
+		}
+		const afterExt = fullText.slice(entity.end);
+		const trailingWordM = /^[\s]+(\p{Lu}\p{Ll}+)/u.exec(afterExt);
+		if (trailingWordM && !trailingWordM[0].includes("\n")) {
+			const candidate = (trailingWordM[1] ?? "").toLowerCase();
+			if (!TRAILING_WORD_EXCLUSIONS.has(candidate)) {
+				entity.end += trailingWordM[0].length;
+				entity.text = fullText.slice(entity.start, entity.end);
+			}
+		}
+	}
+};
+/**
+* Extend a person name match to include subsequent
+* capitalized words. "Pavel" + " Heřmánek" → "Pavel
+* Heřmánek". Stops at lowercase words, punctuation,
+* or end of text. Also extends backward if preceded
+* by a capitalized word (for "Miroslav Braňka" when
+* only "Braňka" matched).
+*/
+const extendPersonName = (text, start, end, ctx) => {
+	let newEnd = end;
+	let pos = newEnd;
+	while (pos < text.length) if (pos < text.length && text[pos] === " ") {
+		const wordStart = pos + 1;
+		if (wordStart >= text.length) break;
+		const char = text[wordStart] ?? "";
+		if (!UPPER_START_RE.test(char)) break;
+		let wordEnd = wordStart;
+		while (wordEnd < text.length && !/\s/.test(text[wordEnd] ?? "")) wordEnd++;
+		const stripped = text.slice(wordStart, wordEnd).replace(/[,;.]+$/, "");
+		if (stripped.length < 2) break;
+		const lower = stripped.toLowerCase();
+		if (getStopwords(ctx).has(lower) || getPersonStopwords(ctx).has(lower)) break;
+		newEnd = wordStart + stripped.length;
+		pos = newEnd;
+	} else break;
+	return {
+		end: newEnd,
+		text: text.slice(start, newEnd)
+	};
+};
+//#endregion
+//#region src/detectors/address-seeds.ts
+let cachedBoundaryRe = null;
+const loadBoundaryWords = async () => {
+	try {
+		return (await import("@stll/anonymize-data/config/address-boundaries.json")).default;
+	} catch {
+		return {};
+	}
+};
+/**
+* Build regex for boundary words. Matches any
+* boundary word preceded by a word boundary.
+*/
+const getBoundaryRe = async () => {
+	if (cachedBoundaryRe) return cachedBoundaryRe;
+	const config = await loadBoundaryWords();
+	const words = [];
+	for (const entries of Object.values(config)) {
+		if (!Array.isArray(entries)) continue;
+		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") : /(?!)/;
+	return cachedBoundaryRe;
+};
+/**
+* Build street type patterns for the unified search.
+* Returns string[] for the unified TextSearch
+* builder. Empty if data package is not installed.
+*/
+const buildStreetTypePatterns = async () => {
+	let config = {};
+	try {
+		config = (await import("@stll/anonymize-data/config/address-street-types.json")).default;
+	} catch {
+		return [];
+	}
+	const words = [];
+	for (const values of Object.values(config)) {
+		if (!Array.isArray(values)) continue;
+		for (const word of values) words.push(word);
+	}
+	return words;
+};
+const collectSeeds = (allMatches, sliceStart, sliceEnd, fullText, existingEntities) => {
+	const seeds = [];
+	for (const match of allMatches) {
+		const idx = match.pattern;
+		if (idx < sliceStart || idx >= sliceEnd) continue;
+		seeds.push({
+			type: "street-word",
+			start: match.start,
+			end: match.end,
+			text: match.text
+		});
+	}
+	for (const e of existingEntities) {
+		if (e.label !== "address") continue;
+		if (e.source === "deny-list") seeds.push({
+			type: "city",
+			start: e.start,
+			end: e.end,
+			text: e.text
+		});
+		else if (e.source === "trigger" && /^\d/.test(e.text)) seeds.push({
+			type: "postal-code",
+			start: e.start,
+			end: e.end,
+			text: e.text
+		});
+		else if (e.source === "trigger") seeds.push({
+			type: "address-trigger",
+			start: e.start,
+			end: e.end,
+			text: e.text
+		});
+	}
+	const postalRe = /\b(?:\d{3}\s\d{2}|\d{2}-\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({
+			type: "postal-code",
+			start,
+			end,
+			text: postalMatch[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) {
+		const matchedStreet = streetMatch[1];
+		const matchedNum = streetMatch[2];
+		if (!matchedStreet || !matchedNum) continue;
+		const start = streetMatch.index;
+		const end = start + matchedStreet.length + 1 + matchedNum.length;
+		seeds.push({
+			type: "street-word",
+			start,
+			end,
+			text: fullText.slice(start, end)
+		});
+	}
+	return seeds.sort((a, b) => a.start - b.start);
+};
+const clusterSeeds = (seeds, maxGap) => {
+	const first = seeds[0];
+	if (!first) return [];
+	const clusters = [];
+	let current = {
+		seeds: [first],
+		start: first.start,
+		end: first.end
+	};
+	for (let i = 1; i < seeds.length; i++) {
+		const seed = seeds.at(i);
+		if (!seed) continue;
+		if (seed.start - current.end <= maxGap) {
+			current.seeds.push(seed);
+			current.end = Math.max(current.end, seed.end);
+		} else {
+			clusters.push(current);
+			current = {
+				seeds: [seed],
+				start: seed.start,
+				end: seed.end
+			};
+		}
+	}
+	clusters.push(current);
+	return clusters;
+};
+const scoreCluster = (cluster) => {
+	const types = new Set(cluster.seeds.map((s) => s.type));
+	if (types.size < 2) return 0;
+	let score = .5;
+	if (types.has("postal-code")) score += .15;
+	if (types.has("city")) score += .15;
+	if (types.has("street-word")) score += .15;
+	if (types.has("address-trigger")) score += .1;
+	return Math.min(score, .95);
+};
+const NON_ADDRESS_LABELS = new Set([
+	"registration number",
+	"tax identification number",
+	"person",
+	"bank account number",
+	"email address",
+	"phone number",
+	"organization",
+	"iban"
+]);
+const expandCluster = async (fullText, cluster, existingEntities) => {
+	const { start, end } = cluster;
+	let leftBound = 0;
+	for (const e of existingEntities) if (NON_ADDRESS_LABELS.has(e.label) && e.end <= start && e.end > leftBound) leftBound = e.end;
+	let leftPos = start;
+	while (leftPos > leftBound) {
+		let p = leftPos - 1;
+		while (p >= 0 && (fullText[p] === " " || fullText[p] === ",")) p--;
+		if (p < 0) break;
+		let wordEnd = p + 1;
+		while (p >= 0 && /\S/.test(fullText[p] ?? "")) p--;
+		const word = fullText.slice(p + 1, wordEnd);
+		if (word.length < 2 || !/^\p{Lu}/u.test(word) && !/^\d/.test(word)) break;
+		if (fullText.slice(p + 1, leftPos).includes("\n")) break;
+		leftPos = p + 1;
+	}
+	let rightPos = end;
+	const remaining = fullText.slice(rightPos);
+	let nearestBoundary = Math.min(remaining.length, 200);
+	const boundaryMatch = (await getBoundaryRe()).exec(remaining);
+	if (boundaryMatch && boundaryMatch.index < nearestBoundary) nearestBoundary = boundaryMatch.index;
+	for (const e of existingEntities) {
+		if (!NON_ADDRESS_LABELS.has(e.label)) continue;
+		const offset = e.start - rightPos;
+		if (offset > 0 && offset < nearestBoundary) nearestBoundary = offset;
+	}
+	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--;
+	return {
+		start: Math.min(leftPos, start),
+		end: Math.max(rightPos, end)
+	};
+};
+/**
+* Process address seeds from the unified search.
+* Receives all matches; filters to the street types
+* slice via sliceStart/sliceEnd. Uses fullText and
+* existingEntities for seed collection, clustering,
+* expansion, and scoring.
+*
+* Runs as a post-processor after all other detectors,
+* 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 results = [];
+	for (const cluster of clusters) {
+		const score = scoreCluster(cluster);
+		if (score < .6) continue;
+		const { start, end } = await expandCluster(fullText, cluster, existingEntities);
+		const text = fullText.slice(start, end).trim();
+		if (text.length < 5 || text.length > 300) continue;
+		if (text.includes("\n")) continue;
+		results.push({
+			start,
+			end: start + text.length,
+			label: "address",
+			text,
+			score,
+			source: DETECTION_SOURCES.REGEX
+		});
+	}
+	return results;
+};
+//#endregion
+//#region src/detectors/org-propagation.ts
+const TRAILING_SEP = /[,\s]+$/;
+const WORD_CHAR_RE = /[\p{L}\p{N}]/u;
+const ORG_PROPAGATION_SCORE = .9;
+/**
+* After the main detection pass, collect organization
+* entities with a legal form suffix, strip the suffix
+* to get the base name, and re-scan the full text for
+* bare mentions of that base name. Returns new entities
+* for occurrences not already covered.
+*/
+const propagateOrgNames = (entities, fullText) => {
+	const seeds = [];
+	const seenBases = /* @__PURE__ */ new Set();
+	for (const e of entities) {
+		if (e.label !== "organization") continue;
+		for (const suffix of LEGAL_SUFFIXES) if (e.text.endsWith(suffix)) {
+			const base = e.text.slice(0, -suffix.length).replace(TRAILING_SEP, "").trim();
+			if (base.length >= 3 && !seenBases.has(base)) {
+				seenBases.add(base);
+				seeds.push({
+					baseName: base,
+					label: e.label
+				});
+			}
+			break;
+		}
+	}
+	if (seeds.length === 0) return [];
+	const covered = entities.map((e) => [e.start, e.end]);
+	const isOverlapping = (start, end) => covered.some(([cs, ce]) => start < ce && end > cs);
+	const results = [];
+	for (const seed of seeds) {
+		const { baseName, label } = seed;
+		let searchFrom = 0;
+		while (searchFrom < fullText.length) {
+			const idx = fullText.indexOf(baseName, searchFrom);
+			if (idx === -1) break;
+			const matchEnd = idx + baseName.length;
+			const prevCh = fullText[idx - 1] ?? "";
+			const nextCh = fullText[matchEnd] ?? "";
+			if (WORD_CHAR_RE.test(prevCh) || WORD_CHAR_RE.test(nextCh)) {
+				searchFrom = idx + 1;
+				continue;
+			}
+			if (!isOverlapping(idx, matchEnd)) {
+				results.push({
+					start: idx,
+					end: matchEnd,
+					label,
+					text: baseName,
+					score: ORG_PROPAGATION_SCORE,
+					source: DETECTION_SOURCES.COREFERENCE
+				});
+				covered.push([idx, matchEnd]);
+			}
+			searchFrom = matchEnd;
+		}
+	}
+	return results;
+};
+//#endregion
+//#region src/filters/confidence-boost.ts
+const BARE_STOPWORDS = new Set([
+	"Příloha",
+	"Smlouva",
+	"Článek",
+	"Dodatek",
+	"Celkem",
+	"Strana",
+	"Faktura",
+	"Částka",
+	"Položka",
+	"Kapitola",
+	"Zákon",
+	"Vyhláška",
+	"Nařízení",
+	"Usnesení",
+	"Rozsudek",
+	"Bod",
+	"Odstavec",
+	"Záloha",
+	"Zbývá",
+	"Dne",
+	"Platba",
+	"Datum",
+	"Splatnost",
+	"Variabilní",
+	"Konstantní",
+	"Specifický"
+]);
+const NEAR_MISS_BAND = .15;
+const BOOST_PER_NEIGHBOUR = .05;
+const CONTEXT_WINDOW_CHARS = 150;
+const HIGH_CONFIDENCE_FLOOR = .9;
+/**
+* Boost confidence of near-miss NER entities that appear
+* near high-confidence detections (regex, trigger phrase).
+*
+* If an NER entity scored between (threshold - 0.15) and
+* threshold, count how many confirmed entities exist within
+* a 150-char window. Add +0.05 per co-located entity.
+* If the boosted score crosses the threshold, include it.
+*
+* Only mutates score on near-miss entities; high-confidence
+* entities pass through unchanged.
+*/
+const boostNearMissEntities = (entities, threshold) => {
+	const nearMissBand = Math.max(0, threshold - NEAR_MISS_BAND);
+	const confirmed = entities.filter((e) => e.score >= HIGH_CONFIDENCE_FLOOR);
+	const boosted = [];
+	for (const entity of entities) {
+		if (entity.score >= threshold) {
+			boosted.push(entity);
+			continue;
+		}
+		if (entity.score < nearMissBand) continue;
+		const midpoint = (entity.start + entity.end) / 2;
+		let neighbourCount = 0;
+		for (const anchor of confirmed) {
+			const anchorMid = (anchor.start + anchor.end) / 2;
+			if (Math.abs(midpoint - anchorMid) <= CONTEXT_WINDOW_CHARS) neighbourCount++;
+		}
+		const boostedScore = entity.score + neighbourCount * BOOST_PER_NEIGHBOUR;
+		if (boostedScore >= threshold) boosted.push({
+			...entity,
+			score: boostedScore
+		});
+	}
+	return boosted;
+};
+const UPPER_WORD_RE = /\p{Lu}/u;
+/** Header zone: top 15% of document */
+const HEADER_ZONE_FRACTION = .15;
+/** Context window for address adjacency */
+const STREET_CONTEXT_WINDOW = 200;
+let _addressPreps = null;
+let _temporalPreps = null;
+let _prepsPromise = null;
+const loadPrepositions = async () => {
+	try {
+		const mod = await import("@stll/anonymize-data/config/address-prepositions.json");
+		const data = mod.default ?? mod;
+		const addr = /* @__PURE__ */ new Set();
+		const temp = /* @__PURE__ */ new Set();
+		for (const words of Object.values(data.address)) if (Array.isArray(words)) for (const w of words) addr.add(w.toLowerCase());
+		for (const words of Object.values(data.temporal)) if (Array.isArray(words)) for (const w of words) temp.add(w.toLowerCase());
+		_addressPreps = addr;
+		_temporalPreps = temp;
+	} catch {
+		_addressPreps = /* @__PURE__ */ new Set();
+		_temporalPreps = /* @__PURE__ */ new Set();
+	}
+};
+/** Ensure preposition data is loaded. */
+const initPrepositions = () => {
+	if (!_prepsPromise) _prepsPromise = loadPrepositions();
+	return _prepsPromise;
+};
+const getAddressPreps = () => _addressPreps ?? /* @__PURE__ */ new Set();
+const getTemporalPreps = () => _temporalPreps ?? /* @__PURE__ */ new Set();
+let _streetAbbrevs = null;
+let _streetAbbrevsPromise = null;
+const loadStreetAbbrevs = async () => {
+	try {
+		const mod = await import("@stll/anonymize-data/config/address-street-types.json");
+		const data = mod.default ?? mod;
+		const abbrevs = /* @__PURE__ */ new Set();
+		for (const [key, words] of Object.entries(data)) {
+			if (key.startsWith("_")) continue;
+			if (!Array.isArray(words)) continue;
+			for (const w of words) if (w.includes(".")) abbrevs.add(w.toLowerCase());
+		}
+		_streetAbbrevs = abbrevs;
+	} catch {
+		_streetAbbrevs = /* @__PURE__ */ new Set();
+	}
+};
+/** Ensure street abbreviation data is loaded. */
+const initStreetAbbrevs = () => {
+	if (!_streetAbbrevsPromise) _streetAbbrevsPromise = loadStreetAbbrevs();
+	return _streetAbbrevsPromise;
+};
+const getStreetAbbrevs = () => _streetAbbrevs ?? /* @__PURE__ */ new Set();
+/**
+* Scan backwards from known address entities and
+* house number patterns to find street names.
+*
+* Strategy (a): from a house number like "2512/2a",
+* walk left to find the first uppercase word — that's
+* the street name start. "Mezi úvozy 2512/2a" →
+* captures "Mezi úvozy 2512/2a".
+*
+* Strategy (b): if a colon ":" appears within 3 chars
+* before the street start, boost confidence. Colons
+* signal "label: value" pairs universal in contracts.
+*
+* Strategy (c): in the header zone (top 15% of doc),
+* be more aggressive — detect street patterns even
+* without nearby address entities.
+*/
+const detectStreetPatternsNearAddresses = (fullText, existingEntities) => {
+	const results = [];
+	const addressEntities = existingEntities.filter((e) => e.label === "address");
+	const headerEnd = Math.floor(fullText.length * HEADER_ZONE_FRACTION);
+	const houseNumRe = /\b(?:\d{1,4}\/\d+[a-zA-Z]\b|\d{3,4}\/\d+\b|(?:1[3-9]|[2-9]\d)\/\d{3,}\b)/g;
+	houseNumRe.lastIndex = 0;
+	for (let m = houseNumRe.exec(fullText); m !== null; m = houseNumRe.exec(fullText)) {
+		const numStart = m.index;
+		const numEnd = numStart + m[0].length;
+		if (existingEntities.some((e) => e.start <= numStart && e.end >= numEnd)) continue;
+		const inHeader = numStart < headerEnd;
+		const nearAddress = addressEntities.some((e) => Math.abs(e.start - numEnd) < STREET_CONTEXT_WINDOW || Math.abs(e.end - numStart) < STREET_CONTEXT_WINDOW);
+		if (!inHeader && !nearAddress) continue;
+		let scanPos = numStart - 1;
+		while (scanPos >= 0 && /[\s\u00A0]/.test(fullText[scanPos] ?? "")) scanPos--;
+		if (scanPos < 0) continue;
+		let hasTemporalPrep = false;
+		let streetStart = scanPos + 1;
+		let wordCount = 0;
+		const MAX_WORDS = 5;
+		while (scanPos >= 0 && wordCount < MAX_WORDS) {
+			let wordEnd = scanPos + 1;
+			const hasDot = fullText[scanPos] === ".";
+			if (hasDot) scanPos--;
+			while (scanPos >= 0 && /[\p{L}\p{M}\d]/u.test(fullText[scanPos] ?? "")) scanPos--;
+			const wordStart = scanPos + 1;
+			const rawWord = fullText.slice(wordStart, wordEnd);
+			const word = hasDot ? rawWord.slice(0, -1) : rawWord;
+			if (word.length === 0) break;
+			const isStreetAbbrev = hasDot && getStreetAbbrevs().has(rawWord.toLowerCase());
+			const isUpper = UPPER_WORD_RE.test(word[0] ?? "");
+			const isPrep = getAddressPreps().has(word.toLowerCase());
+			const isDigitToken = /^\d{1,2}$/.test(word);
+			if (!isUpper && !isPrep && !isStreetAbbrev && !isDigitToken) break;
+			if (isPrep && getTemporalPreps().has(word.toLowerCase())) hasTemporalPrep = true;
+			streetStart = wordStart;
+			wordCount++;
+			while (scanPos >= 0 && /[\s\u00A0]/.test(fullText[scanPos] ?? "")) scanPos--;
+			const prevCh = fullText[scanPos];
+			if (prevCh === "\n" || prevCh === "	" || prevCh === ";" || prevCh === void 0) break;
+			if (prevCh === ",") break;
+		}
+		if (wordCount === 0) continue;
+		const streetText = fullText.slice(streetStart, numEnd);
+		if (streetText.length < 4) continue;
+		if (hasTemporalPrep) continue;
+		if (existingEntities.some((e) => e.start <= streetStart && e.end >= numEnd)) continue;
+		const score = fullText.slice(Math.max(0, streetStart - 5), streetStart).includes(":") ? .95 : inHeader ? .85 : .8;
+		results.push({
+			start: streetStart,
+			end: numEnd,
+			label: "address",
+			text: streetText,
+			score,
+			source: "regex"
+		});
+	}
+	const bareHouseRe = /(?<=\s|^)(\p{Lu}\p{Ll}[\p{Ll}\p{Lu}]+\s+\d{1,3})\b/gu;
+	bareHouseRe.lastIndex = 0;
+	const allAddr = [...addressEntities, ...results];
+	for (let m = bareHouseRe.exec(fullText); m !== null; m = bareHouseRe.exec(fullText)) {
+		const captured = m[1];
+		if (captured === void 0) continue;
+		const start = m.index;
+		const end = start + captured.length;
+		if (!allAddr.some((e) => {
+			if (Math.min(Math.abs(e.start - end), Math.abs(e.end - start)) > 50) return false;
+			const lo = Math.min(e.start, start);
+			const hi = Math.max(e.end, end);
+			return !fullText.slice(lo, hi).includes("\n");
+		})) continue;
+		const spaceIdx = captured.search(/\s+\d/);
+		const word = spaceIdx > 0 ? captured.slice(0, spaceIdx) : captured;
+		if (BARE_STOPWORDS.has(word)) continue;
+		if ([...existingEntities, ...results].some((e) => e.start < end && e.end > start)) continue;
+		results.push({
+			start,
+			end,
+			label: "address",
+			text: captured,
+			score: .75,
+			source: "regex"
+		});
+	}
+	return results;
+};
+const ORPHAN_STREET_RE = /^\s*(\p{Lu}[\p{Ll}\p{Lu}]+(?:\s+[\p{Lu}\p{Ll}][\p{Ll}]+)*\s+\d{2,4}[a-zA-Z]?)\s*$/gmu;
+/**
+* In the header zone (top 15%), find standalone lines
+* matching "[Uppercase word(s)] [number]" that sit
+* between other detected entities. These are almost
+* certainly street addresses in party definitions.
+*
+* Example: "Evropská 710" on its own line between
+* an organization entity and a postal code entity.
+*/
+const detectOrphanStreetLines = (fullText, existingEntities) => {
+	const headerEnd = Math.floor(fullText.length * HEADER_ZONE_FRACTION);
+	const results = [];
+	ORPHAN_STREET_RE.lastIndex = 0;
+	for (let m = ORPHAN_STREET_RE.exec(fullText); m !== null; m = ORPHAN_STREET_RE.exec(fullText)) {
+		const captured = m[1];
+		if (captured === void 0) continue;
+		const start = m.index + m[0].indexOf(captured);
+		const end = start + captured.length;
+		if (start >= headerEnd) continue;
+		if (existingEntities.some((e) => e.start <= start && e.end >= end)) continue;
+		if (!existingEntities.some((e) => Math.abs(e.start - end) < 200 || Math.abs(e.end - start) < 200)) continue;
+		results.push({
+			start,
+			end,
+			label: "address",
+			text: captured,
+			score: .85,
+			source: "regex"
+		});
+	}
+	return results;
+};
+//#endregion
+//#region src/filters/zone-classifier.ts
+/**
+* Additive score adjustments per document zone.
+* Header and signature blocks are dense with PII;
+* tables often contain structured identifying data.
+*/
+const ZONE_SCORE_ADJUSTMENTS = {
+	header: .1,
+	signature: .15,
+	body: 0,
+	table: .05
+};
+const loadSectionHeadings = async () => {
+	const mod = await import("@stll/anonymize-data/config/section-headings.json");
+	return (mod.default ?? mod).patterns.map((p) => new RegExp(p.re, p.flags));
+};
+const loadSigningClauses = async () => {
+	const mod = await import("@stll/anonymize-data/config/signing-clauses.json");
+	return (mod.default ?? mod).patterns.map((p) => {
+		const prefix = p.prefix || "";
+		const suffix = p.suffix || "";
+		const prepAlt = p.prepositions.length > 0 ? p.prepositions.join("|") : null;
+		const combined = `^\\s*(?:${prefix}${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}+)*"}${suffix})`;
+		return new RegExp(combined, "u");
+	});
+};
+/**
+* Ensure config data is loaded. Call once before
+* classifyZones. Safe to call multiple times.
+*/
+const initZoneClassifier = (ctx = defaultContext) => {
+	if (ctx.zoneInitPromise) return ctx.zoneInitPromise;
+	ctx.zoneInitPromise = Promise.all([loadSectionHeadings(), loadSigningClauses()]).then(([headings, clauses]) => {
+		ctx.zoneHeadingPatterns = headings;
+		ctx.zoneSigningPatterns = clauses;
+	}).catch((err) => {
+		ctx.zoneInitPromise = null;
+		throw err;
+	});
+	return ctx.zoneInitPromise;
+};
+const MIN_TABS_FOR_TABLE = 2;
+const isTableLine = (line) => {
+	let tabCount = 0;
+	for (const ch of line) {
+		if (ch === "	") tabCount++;
+		if (tabCount >= MIN_TABS_FOR_TABLE) return true;
+	}
+	return false;
+};
+/**
+* Classify a document into zones based on
+* structural heuristics. Zones are non-overlapping
+* and cover the entire text.
+*
+* Must call `initZoneClassifier()` first.
+*/
+const classifyZones = (fullText, ctx = defaultContext) => {
+	if (fullText.length === 0) return [];
+	const headingRes = ctx.zoneHeadingPatterns;
+	const signingRes = ctx.zoneSigningPatterns;
+	if (!headingRes || !signingRes) {
+		console.warn("[anonymize] classifyZones called before initZoneClassifier(); returning body-only");
+		return [{
+			zone: "body",
+			start: 0,
+			end: fullText.length
+		}];
+	}
+	const lines = fullText.split("\n");
+	const zones = [];
+	let headerEndLine = -1;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (line === void 0) continue;
+		for (const re of headingRes) if (re.test(line)) {
+			headerEndLine = i;
+			break;
+		}
+		if (headerEndLine !== -1) break;
+	}
+	let signatureStartLine = -1;
+	for (let i = lines.length - 1; i >= 0; i--) {
+		const line = lines[i];
+		if (line === void 0) continue;
+		for (const re of signingRes) if (re.test(line)) {
+			signatureStartLine = i;
+			break;
+		}
+		if (signatureStartLine !== -1) break;
+	}
+	const lineOffsets = [];
+	let offset = 0;
+	for (const line of lines) {
+		lineOffsets.push(offset);
+		offset += line.length + 1;
+	}
+	let headerEndOffset = headerEndLine >= 0 ? lineOffsets[headerEndLine] ?? 0 : 0;
+	const signatureStartOffset = signatureStartLine >= 0 ? lineOffsets[signatureStartLine] ?? fullText.length : fullText.length;
+	if (headerEndLine > 0 && signatureStartLine >= 0 && headerEndOffset > signatureStartOffset) {
+		headerEndLine = -1;
+		headerEndOffset = 0;
+	}
+	if (headerEndLine > 0) zones.push({
+		zone: "header",
+		start: 0,
+		end: headerEndOffset
+	});
+	const bodyStart = headerEndLine > 0 ? headerEndOffset : 0;
+	const bodyEnd = signatureStartLine >= 0 ? signatureStartOffset : fullText.length;
+	let tableStart = -1;
+	for (let i = Math.max(headerEndLine, 0); i < (signatureStartLine >= 0 ? signatureStartLine : lines.length); i++) {
+		const line = lines[i];
+		if (line === void 0) continue;
+		const lineStart = lineOffsets[i] ?? 0;
+		const lineEnd = lineStart + line.length;
+		if (isTableLine(line)) {
+			if (tableStart === -1) tableStart = lineStart;
+		} else if (tableStart !== -1) {
+			zones.push({
+				zone: "table",
+				start: tableStart,
+				end: lineStart
+			});
+			tableStart = -1;
+		}
+		if (i === (signatureStartLine >= 0 ? signatureStartLine - 1 : lines.length - 1) && tableStart !== -1) {
+			zones.push({
+				zone: "table",
+				start: tableStart,
+				end: Math.min(lineEnd + 1, bodyEnd)
+			});
+			tableStart = -1;
+		}
+	}
+	const sortedSpecial = zones.toSorted((a, b) => a.start - b.start);
+	let cursor = bodyStart;
+	const bodyZones = [];
+	for (const span of sortedSpecial) {
+		if (span.zone === "header") continue;
+		if (span.start > cursor) bodyZones.push({
+			zone: "body",
+			start: cursor,
+			end: span.start
+		});
+		cursor = Math.max(cursor, span.end);
+	}
+	if (cursor < bodyEnd) bodyZones.push({
+		zone: "body",
+		start: cursor,
+		end: bodyEnd
+	});
+	for (const z of bodyZones) zones.push(z);
+	if (signatureStartLine >= 0) zones.push({
+		zone: "signature",
+		start: signatureStartOffset,
+		end: fullText.length
+	});
+	return zones.toSorted((a, b) => a.start - b.start);
+};
+/**
+* Find which zone an entity's midpoint falls in.
+* Returns "body" if no zone matches (defensive).
+*/
+const findZone = (midpoint, zones) => {
+	for (const span of zones) if (midpoint >= span.start && midpoint < span.end) return span.zone;
+	return "body";
+};
+/**
+* Apply zone-based score adjustments to entities.
+* Entities in header/signature/table zones get a
+* small additive boost reflecting the higher PII
+* density in those regions.
+*
+* Returns a new array; does not mutate inputs.
+*/
+const applyZoneAdjustments = (entities, zones) => {
+	if (zones.length === 0) return entities.map((e) => ({ ...e }));
+	const result = [];
+	for (const entity of entities) {
+		const adjustment = ZONE_SCORE_ADJUSTMENTS[findZone((entity.start + entity.end) / 2, zones)];
+		if (adjustment > 0) result.push({
+			...entity,
+			score: Math.min(1, entity.score + adjustment)
+		});
+		else result.push({ ...entity });
+	}
+	return result;
+};
+//#endregion
+//#region src/filters/hotword-rules.ts
+let rules = null;
+let search = null;
+/**
+* Maps each TextSearch pattern index back to the
+* rule index that owns it, so a single AC scan
+* resolves all hotword hits to their rule.
+*/
+let patternToRule = null;
+let initPromise = null;
+const loadRules = async () => {
+	const mod = await import("@stll/anonymize-data/config/hotword-rules.json");
+	const loaded = (mod.default ?? mod).rules;
+	const patterns = [];
+	const mapping = [];
+	for (let ruleIdx = 0; ruleIdx < loaded.length; ruleIdx++) {
+		const rule = loaded[ruleIdx];
+		if (!rule) continue;
+		for (const hw of rule.hotwords) {
+			patterns.push({
+				pattern: hw,
+				literal: true,
+				caseInsensitive: true
+			});
+			mapping.push(ruleIdx);
+		}
+	}
+	const builtSearch = patterns.length > 0 ? new TextSearch(patterns, {
+		overlapStrategy: "all",
+		caseInsensitive: true,
+		wholeWords: true
+	}) : null;
+	patternToRule = mapping;
+	search = builtSearch;
+	rules = loaded;
+};
+/**
+* Load hotword rules from the data package.
+* Safe to call multiple times; subsequent calls
+* are no-ops.
+*/
+const initHotwordRules = async () => {
+	if (rules !== null) return;
+	if (initPromise !== null) return initPromise;
+	initPromise = loadRules().catch((err) => {
+		initPromise = null;
+		throw err;
+	});
+	return initPromise;
+};
+/**
+* Apply hotword context rules to detected entities.
+*
+* Scans `fullText` once with a single AC automaton
+* for all hotwords across all rules, then checks
+* proximity to each entity. Distance-decayed
+* adjustment: closer hotwords give a stronger boost.
+*
+* Returns a new array; input entities are not mutated.
+*/
+const applyHotwordRules = (entities, fullText) => {
+	if (rules === null || rules.length === 0 || search === null || patternToRule === null) return entities;
+	const hits = search.findIter(fullText);
+	if (hits.length === 0) return entities;
+	const hitsByRule = /* @__PURE__ */ new Map();
+	for (const hit of hits) {
+		const ruleIdx = patternToRule[hit.pattern];
+		if (ruleIdx === void 0) continue;
+		let bucket = hitsByRule.get(ruleIdx);
+		if (bucket === void 0) {
+			bucket = [];
+			hitsByRule.set(ruleIdx, bucket);
+		}
+		bucket.push(hit);
+	}
+	const result = [];
+	for (const entity of entities) {
+		let bestAdjustment = 0;
+		let bestReclassify;
+		for (let ruleIdx = 0; ruleIdx < rules.length; ruleIdx++) {
+			const rule = rules[ruleIdx];
+			if (!rule) continue;
+			if (!rule.targetLabels.includes(entity.label)) continue;
+			const ruleHits = hitsByRule.get(ruleIdx);
+			if (ruleHits === void 0) continue;
+			for (const hit of ruleHits) {
+				let distance;
+				let maxDistance;
+				if (hit.end <= entity.start) {
+					distance = entity.start - hit.end;
+					maxDistance = rule.proximityBefore;
+				} else if (hit.start >= entity.end) {
+					distance = hit.start - entity.end;
+					maxDistance = rule.proximityAfter;
+				} else {
+					distance = 0;
+					maxDistance = Math.max(rule.proximityBefore, rule.proximityAfter);
+				}
+				if (distance > maxDistance) continue;
+				const decay = maxDistance === 0 ? 1 : 1 - distance / maxDistance;
+				const adj = rule.scoreAdjustment * decay;
+				if (Math.abs(adj) > Math.abs(bestAdjustment)) {
+					bestAdjustment = adj;
+					if (adj > 0) bestReclassify = rule.reclassifyTo;
+					else bestReclassify = void 0;
+				}
+			}
+		}
+		if (bestAdjustment === 0) {
+			result.push(entity);
+			continue;
+		}
+		const newScore = Math.min(1, Math.max(0, entity.score + bestAdjustment));
+		const newLabel = bestReclassify !== void 0 ? bestReclassify : entity.label;
+		result.push({
+			...entity,
+			score: newScore,
+			label: newLabel
+		});
+	}
+	return result;
+};
+//#endregion
+//#region src/filters/boundary-consistency.ts
+/** Max gap (in chars) between entities to merge. */
+const MAX_GAP = 3;
+/**
+* Characters allowed in the gap between two adjacent
+* same-label entities that should be merged: spaces,
+* tabs, commas, and hyphens. Uses `[ \t,\-]` instead
+* of `\s` to avoid merging entities across newlines.
+*/
+const GAP_PATTERN = /^[ \t,\-]+$/;
+/**
+* Build a set of word boundary offsets for the full
+* text using `Intl.Segmenter`. Returns a sorted array
+* of offsets where words start and end.
+*/
+const buildWordBoundaries = (text) => {
+	const segmenter = new Intl.Segmenter("und", { granularity: "word" });
+	const boundaries = /* @__PURE__ */ new Set();
+	for (const seg of segmenter.segment(text)) {
+		if (!seg.isWordLike) continue;
+		boundaries.add(seg.index);
+		boundaries.add(seg.index + seg.segment.length);
+	}
+	return boundaries;
+};
+/**
+* Characters that act as hard stops when scanning
+* backward for a word boundary. Entity boundaries
+* should never extend past these.
+*/
+const WORD_START_STOPS = new Set([
+	"\n",
+	"\r",
+	",",
+	";",
+	"(",
+	")",
+	"[",
+	"]"
+]);
+/**
+* Find the word-start offset at or before `pos`.
+* Scans left until a word boundary is found.
+*/
+const wordStartAt = (pos, boundaries, text) => {
+	let p = pos;
+	while (p > 0 && !boundaries.has(p)) {
+		const prev = text[p - 1];
+		if (prev !== void 0 && WORD_START_STOPS.has(prev)) return p;
+		p--;
+	}
+	return p;
+};
+/**
+* Characters that act as hard stops when scanning
+* forward for a word boundary. Entity boundaries
+* should never extend past these.
+*/
+const WORD_END_STOPS = new Set([
+	"\n",
+	"\r",
+	",",
+	";",
+	".",
+	"(",
+	")",
+	"[",
+	"]"
+]);
+/**
+* Find the word-end offset at or after `pos`.
+* Scans right until a word boundary is found.
+*/
+const wordEndAt = (pos, boundaries, text) => {
+	let p = pos;
+	while (p < text.length && !boundaries.has(p)) {
+		const ch = text[p];
+		if (ch !== void 0 && WORD_END_STOPS.has(ch)) return p;
+		p++;
+	}
+	return p;
+};
+/**
+* Binary search: find the leftmost index in `arr`
+* where `arr[index].start >= value`.
+*/
+const lowerBound = (arr, value) => {
+	let lo = 0;
+	let hi = arr.length;
+	while (lo < hi) {
+		const mid = lo + hi >>> 1;
+		const el = arr[mid];
+		if (el && el.start < value) lo = mid + 1;
+		else hi = mid;
+	}
+	return lo;
+};
+/**
+* Merge adjacent same-label entities separated only by
+* whitespace, comma, or hyphen (max 3 chars). Also
+* merges same-label entities that partially overlap
+* (which can happen after word-boundary expansion).
+*
+* Looks for the last same-label entity in the result
+* (not just the very last entity) so that an
+* intervening different-label entity does not prevent
+* merging.
+*
+* Uses binary search for the `gapOccupied` check and
+* a Map for O(1) same-label prev lookup. O(n log n).
+*/
+const mergeAdjacent = (entities, fullText) => {
+	const sorted = entities.toSorted((a, b) => a.start - b.start);
+	const result = [];
+	const lastByLabel = /* @__PURE__ */ new Map();
+	for (const entity of sorted) {
+		const prev = lastByLabel.get(entity.label);
+		if (!prev) {
+			const copy = { ...entity };
+			result.push(copy);
+			lastByLabel.set(entity.label, copy);
+			continue;
+		}
+		if (entity.start < prev.end) {
+			prev.end = Math.max(prev.end, entity.end);
+			prev.text = fullText.slice(prev.start, prev.end);
+			prev.score = Math.max(prev.score, entity.score);
+			continue;
+		}
+		const gap = fullText.slice(prev.end, entity.start);
+		const gapStart = prev.end;
+		const gapEnd = entity.start;
+		const searchIdx = lowerBound(sorted, gapStart);
+		let gapOccupied = false;
+		for (let k = searchIdx; k < sorted.length; k++) {
+			const other = sorted[k];
+			if (!other || other.start >= gapEnd) break;
+			if (other.label !== entity.label && other.end > gapStart) {
+				gapOccupied = true;
+				break;
+			}
+		}
+		if (!gapOccupied && gap.length <= MAX_GAP && GAP_PATTERN.test(gap)) {
+			prev.end = entity.end;
+			prev.text = fullText.slice(prev.start, prev.end);
+			prev.score = Math.max(prev.score, entity.score);
+		} else {
+			const copy = { ...entity };
+			result.push(copy);
+			lastByLabel.set(entity.label, copy);
+		}
+	}
+	return result;
+};
+/**
+* Fix partial-word boundaries by extending entity
+* start/end to the nearest word boundary. Does not
+* extend across newlines or into spans occupied by
+* different-label entities.
+*
+* Uses binary search to skip irrelevant entries when
+* clamping at cross-label neighbors. O(n log n) in
+* the common case; O(n^2) worst case when many
+* same-label entities precede a cross-label boundary.
+*/
+const fixPartialWords = (entities, fullText) => {
+	const boundaries = buildWordBoundaries(fullText);
+	const sorted = entities.toSorted((a, b) => a.start - b.start);
+	const byEnd = sorted.map((e, idx) => ({
+		entity: e,
+		idx
+	})).sort((a, b) => a.entity.end - b.entity.end);
+	const endPositions = byEnd.map((x) => x.entity.end);
+	return sorted.map((e, eIdx) => {
+		let newStart = wordStartAt(e.start, boundaries, fullText);
+		let newEnd = wordEndAt(e.end, boundaries, fullText);
+		let lo = 0;
+		let hi = endPositions.length;
+		while (lo < hi) {
+			const mid = lo + hi >>> 1;
+			if ((endPositions[mid] ?? Number.POSITIVE_INFINITY) <= newStart) lo = mid + 1;
+			else hi = mid;
+		}
+		for (let k = lo; k < byEnd.length; k++) {
+			const entry = byEnd[k];
+			if (!entry || entry.entity.end > e.start) break;
+			if (entry.idx === eIdx) continue;
+			if (entry.entity.label === e.label) continue;
+			newStart = Math.max(newStart, entry.entity.end);
+		}
+		const startIdx = lowerBound(sorted, e.end);
+		for (let k = startIdx; k < sorted.length; k++) {
+			const other = sorted[k];
+			if (!other || other.start >= newEnd) break;
+			if (other === e) continue;
+			if (other.label === e.label) continue;
+			newEnd = Math.min(newEnd, other.start);
+		}
+		if (newStart === e.start && newEnd === e.end) return e;
+		return {
+			...e,
+			start: newStart,
+			end: newEnd,
+			text: fullText.slice(newStart, newEnd)
+		};
+	});
+};
+/**
+* Deduplicate entities with identical [start, end, label].
+* Keeps the entry with the highest score.
+*/
+const deduplicateSpans = (entities) => {
+	const seen = /* @__PURE__ */ new Map();
+	for (const entity of entities) {
+		const key = `${entity.start}:${entity.end}:${entity.label}`;
+		const existing = seen.get(key);
+		if (!existing || entity.score > existing.score) seen.set(key, entity);
+	}
+	return [...seen.values()];
+};
+/**
+* Remove nested same-label entities. If a shorter
+* entity is fully contained within a longer entity
+* of the same label, drop the shorter one.
+*
+* Uses a "max end seen" sweep per label. O(n) after
+* the initial sort.
+*/
+const removeNestedSameLabel = (entities) => {
+	const sorted = entities.toSorted((a, b) => {
+		if (a.start !== b.start) return a.start - b.start;
+		return b.end - a.end;
+	});
+	const result = [];
+	const maxEndByLabel = /* @__PURE__ */ new Map();
+	for (const entity of sorted) {
+		const maxEnd = maxEndByLabel.get(entity.label);
+		if (maxEnd !== void 0 && entity.end <= maxEnd) continue;
+		maxEndByLabel.set(entity.label, entity.end);
+		result.push(entity);
+	}
+	return result;
+};
+/**
+* Resolve cross-label overlaps that can arise when
+* `fixPartialWords` independently expands two
+* different-label entities toward the same word
+* boundary. The entity with the higher score (or
+* longer span on tie) keeps its boundary; the other
+* is trimmed so the overlap disappears.
+*
+* Preserved existing structure: sorted + early break
+* already gives good amortized behavior. O(n^2)
+* worst case but rare in practice.
+*/
+const resolveCrossLabelOverlaps = (entities, fullText) => {
+	const sorted = entities.map((e) => ({ ...e })).sort((a, b) => a.start - b.start);
+	for (let i = 0; i < sorted.length; i++) for (let j = i + 1; j < sorted.length; j++) {
+		const a = sorted[i];
+		const b = sorted[j];
+		if (!a || !b) continue;
+		if (b.start >= a.end) break;
+		if (a.label === b.label) continue;
+		const aContainsB = a.start <= b.start && a.end >= b.end;
+		const bContainsA = b.start <= a.start && b.end >= a.end;
+		if (aContainsB || bContainsA) continue;
+		const aLen = a.end - a.start;
+		const bLen = b.end - b.start;
+		if (a.score > b.score || a.score === b.score && aLen >= bLen) {
+			b.start = a.end;
+			b.text = fullText.slice(b.start, b.end);
+		} else {
+			a.end = b.start;
+			a.text = fullText.slice(a.start, a.end);
+		}
+	}
+	return sorted.filter((e) => e.start < e.end);
+};
+/**
+* Post-processing pass for entity boundary consistency.
+* Runs after mergeAndDedup, before false-positive
+* filtering.
+*
+* 1. Fix partial-word boundaries (respects cross-label
+*    neighbors to avoid introducing new overlaps)
+* 2. Resolve any remaining cross-label overlaps
+* 3. Deduplicate identical [start, end, label] spans
+* 4. Merge adjacent same-label entities (catches any
+*    new adjacency/overlap from step 1)
+* 5. Remove nested same-label entities
+*/
+const enforceBoundaryConsistency = (entities, fullText) => {
+	return removeNestedSameLabel(mergeAdjacent(deduplicateSpans(resolveCrossLabelOverlaps(fixPartialWords(entities, fullText), fullText)), fullText));
+};
+//#endregion
+//#region src/build-unified-search.ts
+/**
+* Build the unified search instances from all
+* detector pattern sources.
+*
+* Two TextSearch instances (not one) to avoid
+* 200K per-pattern object allocations:
+* 1. regex + triggers + legal-forms (mixed, ~140
+*    patterns, caseInsensitive for trigger AC)
+* 2. deny-list + street-types + gazetteer
+*    (caseInsensitive, overlap "all";
+*    deny-list/street-type use per-pattern
+*    wholeWords: true; gazetteer exact use
+*    wholeWords: false; gazetteer fuzzy use
+*    distance: 2 via @stll/fuzzy-search)
+*
+* All patterns are PatternEntry objects with
+* per-pattern literal/wholeWords settings.
+*/
+const buildUnifiedSearch = async (config, gazetteerEntries = [], ctx = defaultContext) => {
+	const [legalForms, triggers, denyListData, streetTypes, currencyPatterns, datePatterns, signingPatterns] = await Promise.all([
+		buildLegalFormPatterns(),
+		config.enableTriggerPhrases ? buildTriggerPatterns() : Promise.resolve({
+			patterns: [],
+			rules: []
+		}),
+		config.enableDenyList ? buildDenyList(config, ctx) : Promise.resolve(null),
+		buildStreetTypePatterns(),
+		getCurrencyPatterns(),
+		getDatePatterns(),
+		getSigningClausePatterns()
+	]);
+	const allRegex = [
+		...REGEX_PATTERNS,
+		...currencyPatterns,
+		...datePatterns,
+		...signingPatterns
+	];
+	const regexMeta = [
+		...REGEX_META,
+		...currencyPatterns.map(() => CURRENCY_PATTERN_META),
+		...datePatterns.map(() => DATE_PATTERN_META),
+		...signingPatterns.map(() => SIGNING_CLAUSE_META)
+	];
+	let offset = 0;
+	const regexSlice = {
+		start: offset,
+		end: offset + allRegex.length
+	};
+	offset = regexSlice.end;
+	const legalFormsSlice = {
+		start: offset,
+		end: offset + legalForms.length
+	};
+	offset = legalFormsSlice.end;
+	const triggersSlice = {
+		start: offset,
+		end: offset + triggers.patterns.length
+	};
+	const triggerEntries = triggers.patterns.map((p) => ({
+		pattern: p,
+		literal: true,
+		caseInsensitive: true
+	}));
+	const tsRegex = new TextSearch([
+		...allRegex,
+		...legalForms,
+		...triggerEntries
+	]);
+	offset = 0;
+	const denyListOriginals = denyListData?.originals ?? [];
+	const denyListSlice = {
+		start: offset,
+		end: offset + denyListOriginals.length
+	};
+	offset = denyListSlice.end;
+	const streetTypesSlice = {
+		start: offset,
+		end: offset + streetTypes.length
+	};
+	offset = streetTypesSlice.end;
+	const gazResult = config.enableGazetteer && gazetteerEntries.length > 0 ? buildGazetteerPatterns(gazetteerEntries) : null;
+	const gazetteerSlice = {
+		start: offset,
+		end: offset + (gazResult?.patterns.length ?? 0)
+	};
+	offset = gazetteerSlice.end;
+	const wrapWholeWord = (s) => ({
+		pattern: s,
+		literal: true,
+		wholeWords: true
+	});
+	const literalAllPatterns = [
+		...denyListOriginals.map(wrapWholeWord),
+		...streetTypes.map(wrapWholeWord),
+		...gazResult?.patterns ?? []
+	];
+	return {
+		tsRegex,
+		tsLiterals: literalAllPatterns.length > 0 ? new TextSearch(literalAllPatterns, {
+			caseInsensitive: true,
+			overlapStrategy: "all"
+		}) : new TextSearch([]),
+		slices: {
+			regex: regexSlice,
+			legalForms: legalFormsSlice,
+			triggers: triggersSlice,
+			denyList: denyListSlice,
+			streetTypes: streetTypesSlice,
+			gazetteer: gazetteerSlice
+		},
+		regexMeta,
+		triggerRules: triggers.rules,
+		denyListData,
+		gazetteerData: gazResult?.data ?? null
+	};
+};
+//#endregion
+//#region src/unified-search.ts
+const runUnifiedSearch = (instance, fullText) => {
+	const regexMatches = instance.tsRegex.findIter(fullText);
+	const normalized = normalizeForSearch(fullText);
+	return {
+		regexMatches,
+		literalMatches: instance.tsLiterals.findIter(normalized)
+	};
+};
+//#endregion
+//#region src/util/entity-masking.ts
+const MASK_TOKEN = "[MASKED]";
+const MASK_LEN = 8;
+/**
+* Replace detected entity spans with placeholder tokens.
+* Each entity span is replaced with "[MASKED]" (fixed
+* length). Returns the masked text and an offset mapping
+* function.
+*/
+const maskDetectedSpans = (fullText, entities) => {
+	if (entities.length === 0) return {
+		maskedText: fullText,
+		offsetMap: (s, e) => ({
+			start: s,
+			end: e
+		})
+	};
+	const sorted = entities.toSorted((a, b) => a.start - b.start || b.end - a.end);
+	const spans = [];
+	const first = sorted[0];
+	if (!first) return {
+		maskedText: fullText,
+		offsetMap: (s, e) => ({
+			start: s,
+			end: e
+		})
+	};
+	let cur = {
+		start: first.start,
+		end: first.end
+	};
+	for (let i = 1; i < sorted.length; i++) {
+		const s = sorted[i];
+		if (!s) continue;
+		if (s.start < cur.end) cur.end = Math.max(cur.end, s.end);
+		else {
+			spans.push(cur);
+			cur = {
+				start: s.start,
+				end: s.end
+			};
+		}
+	}
+	spans.push(cur);
+	const segments = [];
+	const parts = [];
+	let prev = 0;
+	let cumulativeShift = 0;
+	for (const span of spans) {
+		parts.push(fullText.slice(prev, span.start));
+		parts.push(MASK_TOKEN);
+		const delta = span.end - span.start - MASK_LEN;
+		cumulativeShift += delta;
+		const maskedStart = span.start - (cumulativeShift - delta);
+		const maskedEnd = maskedStart + MASK_LEN;
+		segments.push({
+			maskedStart,
+			maskedEnd,
+			shift: cumulativeShift,
+			origStart: span.start,
+			origEnd: span.end
+		});
+		prev = span.end;
+	}
+	parts.push(fullText.slice(prev));
+	const maskedText = parts.join("");
+	const offsetMap = (maskedStart, maskedEnd) => {
+		for (const seg of segments) if (maskedStart < seg.maskedEnd && maskedEnd > seg.maskedStart) return null;
+		let shift = 0;
+		for (const seg of segments) if (maskedStart >= seg.maskedEnd) shift = seg.shift;
+		else break;
+		return {
+			start: maskedStart + shift,
+			end: maskedEnd + shift
+		};
+	};
+	return {
+		maskedText,
+		offsetMap
+	};
+};
+/**
+* Map NER entities from masked-text offsets back to
+* original-text offsets. Discards any NER entity whose
+* mapped span overlaps a masked (rule-detected) region.
+*/
+const unmaskNerEntities = (nerEntities, maskResult, fullText) => {
+	const result = [];
+	for (const ner of nerEntities) {
+		const mapped = maskResult.offsetMap(ner.start, ner.end);
+		if (mapped === null) continue;
+		result.push({
+			...ner,
+			start: mapped.start,
+			end: mapped.end,
+			text: fullText.slice(mapped.start, mapped.end)
+		});
+	}
+	return result;
+};
+//#endregion
+//#region src/pipeline.ts
+const shouldReplace = (a, b) => {
+	const aPri = DETECTOR_PRIORITY[a.source] ?? 0;
+	const bPri = DETECTOR_PRIORITY[b.source] ?? 0;
+	if (aPri !== bPri) return aPri > bPri;
+	return a.score > b.score || a.score === b.score && a.end - a.start > b.end - b.start;
+};
+/** Labels where colons are structurally significant. */
+const COLON_LABELS = new Set(["ip address", "mac address"]);
+/** Strip leading/trailing whitespace and punctuation. */
+const sanitizeEntities = (entities) => entities.flatMap((e) => {
+	const strip = COLON_LABELS.has(e.label) ? /[\s,;]+/ : /[\s:,;]+/;
+	const leadTrimmed = e.text.replace(new RegExp(`^${strip.source}`, strip.flags), "");
+	const lead = e.text.length - leadTrimmed.length;
+	const cleaned = leadTrimmed.replace(new RegExp(`${strip.source}$`, strip.flags), "");
+	if (cleaned.length === 0) return [];
+	if (!/[\p{L}\p{N}]/u.test(cleaned)) return [];
+	if (cleaned === e.text) return [e];
+	return [{
+		...e,
+		start: e.start + lead,
+		end: e.start + lead + cleaned.length,
+		text: cleaned
+	}];
+});
+const mergeAndDedup = (...layers) => {
+	const all = [];
+	for (const layer of layers) for (const entity of layer) all.push(entity);
+	if (all.length === 0) return [];
+	const sorted = all.toSorted((a, b) => a.start - b.start);
+	const first = sorted[0];
+	if (!first) return [];
+	const merged = [{ ...first }];
+	for (let i = 1; i < sorted.length; i++) {
+		const entity = sorted[i];
+		const last = merged[merged.length - 1];
+		if (!entity || !last) continue;
+		if (last.end <= entity.start) merged.push({ ...entity });
+		else if (shouldReplace(entity, last)) merged[merged.length - 1] = { ...entity };
+	}
+	return sanitizeEntities(merged);
+};
+const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+let amountWordsRe = null;
+let amountWordsLoaded = false;
+const getAmountWordsRe = async () => {
+	if (amountWordsLoaded && amountWordsRe) return amountWordsRe;
+	try {
+		const alt = (await import("@stll/anonymize-data/config/amount-words.json")).default.patterns.flatMap((p) => p.keywords).map(escapeRegex).join("|");
+		amountWordsRe = new RegExp(`^[,;]?[^\\S\\n]*(\\((?:${alt})[:\\s][^)\\n]{1,120}\\))`, "i");
+	} catch {
+		amountWordsRe = /^[,;]?[^\S\n]*(\((?:slovy|slovně)[:\s][^)\n]{1,120}\))/i;
+	}
+	amountWordsLoaded = true;
+	return amountWordsRe;
+};
+const extendMonetaryAmountWords = (entities, fullText, re) => entities.map((e) => {
+	if (e.label !== "monetary amount") return e;
+	const after = fullText.slice(e.end);
+	const m = re.exec(after);
+	if (!m) return e;
+	const newEnd = e.end + m[0].length;
+	return {
+		...e,
+		end: newEnd,
+		text: fullText.slice(e.start, newEnd)
+	};
+});
+const checkAbort = (signal) => {
+	if (signal?.aborted) throw new DOMException("Pipeline aborted", "AbortError");
+};
+const configKey = (config, gazetteerEntries) => {
+	const gazFingerprint = config.enableGazetteer && gazetteerEntries.length > 0 ? gazetteerEntries.map((e) => `${e.id}:${e.canonical}:${e.label}:${[...e.variants].sort().join(",")}`).toSorted().join(";") : "";
+	return `${config.enableDenyList}:${config.enableTriggerPhrases}:${config.denyListCountries?.toSorted().join(",") ?? ""}:${config.denyListRegions?.toSorted().join(",") ?? ""}:${config.denyListExcludeCategories?.toSorted().join(",") ?? ""}:${config.enableGazetteer}:${gazFingerprint}`;
+};
+/**
+* Get or build a cached search instance. Cache state
+* lives on the provided PipelineContext, not at module
+* level.
+*/
+const getCachedSearch = async (config, gazetteerEntries, ctx) => {
+	const key = configKey(config, gazetteerEntries);
+	if (ctx.search && ctx.searchKey === key) return ctx.search;
+	if (ctx.searchPromise && ctx.searchKey === key) return ctx.searchPromise;
+	ctx.search = null;
+	ctx.searchKey = key;
+	const promise = buildUnifiedSearch(config, gazetteerEntries, ctx);
+	ctx.searchPromise = promise;
+	const result = await promise;
+	if (ctx.searchKey === key) ctx.search = result;
+	return result;
+};
+/**
+* Run the full detection pipeline.
+*
+* Two TextSearch instances scan the text (regex +
+* literals). Results are dispatched to each
+* detector's post-processor by pattern index range.
+*
+* Pass an AbortSignal to cancel the pipeline between
+* stages. Throws a DOMException with name "AbortError"
+* when cancelled.
+*
+* Pass an optional `context` to isolate cached state
+* from other pipeline runs. If omitted, a module-level
+* default context is used (backward compatible).
+*/
+const runPipeline = async (options) => {
+	const { fullText, config, gazetteerEntries, nerInference = null, onProgress, cachedSearch, signal, context } = options;
+	const ctx = context ?? defaultContext;
+	const log = (step, detail) => {
+		onProgress?.(step, detail);
+	};
+	checkAbort(signal);
+	let zoneInitOk = false;
+	const enableHotwords = config.enableHotwordRules === true;
+	let hotwordInitOk = false;
+	const hotwordInit = enableHotwords ? initHotwordRules().then(() => {
+		hotwordInitOk = true;
+	}).catch((err) => {
+		log("hotwords", "init failed; skipping");
+		console.warn("[anonymize] hotword rules init failed", err);
+	}) : Promise.resolve();
+	if (config.enableZoneClassification) {
+		const zoneInit = initZoneClassifier(ctx).then(() => {
+			zoneInitOk = true;
+		}).catch((err) => {
+			log("zones", "init failed; skipping");
+			console.warn("[anonymize] zone classifier init failed", err);
+		});
+		await Promise.all([
+			loadGenericRoles(ctx),
+			initPrepositions(),
+			initStreetAbbrevs(),
+			zoneInit,
+			hotwordInit
+		]);
+	} else await Promise.all([
+		loadGenericRoles(ctx),
+		initPrepositions(),
+		initStreetAbbrevs(),
+		hotwordInit
+	]);
+	if (cachedSearch && config.enableDenyList) await ensureDenyListData(ctx);
+	let zones = [];
+	if (config.enableZoneClassification && zoneInitOk) {
+		zones = classifyZones(fullText, ctx);
+		if (zones.length > 0) log("zones", [...new Set(zones.map((z) => z.zone))].join(", "));
+	}
+	checkAbort(signal);
+	const search = cachedSearch ?? await getCachedSearch(config, gazetteerEntries, ctx);
+	checkAbort(signal);
+	const { regexMatches, literalMatches } = runUnifiedSearch(search, fullText);
+	const { slices } = search;
+	const regexEntities = config.enableRegex ? processRegexMatches(regexMatches, slices.regex.start, slices.regex.end, search.regexMeta) : [];
+	if (regexEntities.length > 0) log("regex", `${regexEntities.length} matches`);
+	const legalFormEntities = processLegalFormMatches(regexMatches, slices.legalForms.start, slices.legalForms.end, fullText);
+	if (legalFormEntities.length > 0) log("legal-forms", `${legalFormEntities.length} matches`);
+	const triggerEntities = config.enableTriggerPhrases ? processTriggerMatches(regexMatches, slices.triggers.start, slices.triggers.end, fullText, search.triggerRules) : [];
+	if (triggerEntities.length > 0) log("trigger-phrases", `${triggerEntities.length} matches`);
+	checkAbort(signal);
+	let nameCorpusEntities = [];
+	if (config.enableNameCorpus && !config.enableDenyList) {
+		await initNameCorpus(ctx);
+		checkAbort(signal);
+		nameCorpusEntities = detectNameCorpus(fullText, ctx);
+		log("name-corpus", `${nameCorpusEntities.length} matches`);
+	}
+	const denyListEntities = config.enableDenyList && search.denyListData ? processDenyListMatches(literalMatches, slices.denyList.start, slices.denyList.end, fullText, search.denyListData, ctx) : [];
+	if (denyListEntities.length > 0) log("deny-list", `${denyListEntities.length} matches`);
+	const gazetteerEntities = config.enableGazetteer && search.gazetteerData ? processGazetteerMatches(literalMatches, slices.gazetteer.start, slices.gazetteer.end, fullText, search.gazetteerData) : [];
+	if (gazetteerEntities.length > 0) log("gazetteer", `${gazetteerEntities.length} matches`);
+	checkAbort(signal);
+	let nerEntities = [];
+	if (config.enableNer && nerInference) {
+		const maskResult = maskDetectedSpans(fullText, [
+			...triggerEntities,
+			...regexEntities,
+			...legalFormEntities,
+			...nameCorpusEntities,
+			...denyListEntities,
+			...gazetteerEntities
+		]);
+		log("ner", "running inference...");
+		const rawNer = await nerInference(maskResult.maskedText, config.labels, config.threshold, signal);
+		nerEntities = unmaskNerEntities(rawNer, maskResult, fullText);
+		const dropped = rawNer.length - nerEntities.length;
+		log("ner", `${nerEntities.length} entities` + (dropped > 0 ? ` (${dropped} masked)` : ""));
+	}
+	checkAbort(signal);
+	const preAddressEntities = [
+		...triggerEntities,
+		...regexEntities,
+		...legalFormEntities,
+		...nameCorpusEntities,
+		...denyListEntities,
+		...gazetteerEntities,
+		...nerEntities
+	];
+	const addressSeedEntities = await processAddressSeeds(literalMatches, slices.streetTypes.start, slices.streetTypes.end, fullText, preAddressEntities);
+	if (addressSeedEntities.length > 0) log("address-seeds", `${addressSeedEntities.length} expanded`);
+	checkAbort(signal);
+	const zoneAdjusted = applyZoneAdjustments([...preAddressEntities, ...addressSeedEntities], zones);
+	const preBoostEntities = enableHotwords && hotwordInitOk ? applyHotwordRules(zoneAdjusted, fullText) : zoneAdjusted;
+	let allEntities;
+	if (config.enableConfidenceBoost) {
+		allEntities = boostNearMissEntities(preBoostEntities, config.threshold);
+		const boosted = allEntities.length - preBoostEntities.filter((e) => e.score >= config.threshold).length;
+		if (boosted > 0) log("confidence-boost", `${boosted} near-miss promoted`);
+	} else allEntities = preBoostEntities.filter((e) => e.score >= config.threshold);
+	const streetPatterns = detectStreetPatternsNearAddresses(fullText, allEntities);
+	if (streetPatterns.length > 0) {
+		allEntities = [...allEntities, ...streetPatterns];
+		log("street-context", `${streetPatterns.length} street patterns near addresses`);
+	}
+	const orphanStreets = detectOrphanStreetLines(fullText, allEntities);
+	if (orphanStreets.length > 0) {
+		allEntities = [...allEntities, ...orphanStreets];
+		log("orphan-streets", `${orphanStreets.length} header street lines`);
+	}
+	const rawMerged = mergeAndDedup(allEntities);
+	log("merge", `${rawMerged.length} after dedup`);
+	const mergedExtended = extendMonetaryAmountWords(rawMerged, fullText, await getAmountWordsRe());
+	const consistent = enforceBoundaryConsistency(mergedExtended, fullText);
+	if (consistent.length < mergedExtended.length) log("boundary", `${mergedExtended.length - consistent.length} consolidated`);
+	let postOrgEntities = consistent;
+	if (config.enableCoreference) {
+		const thresholded = propagateOrgNames(consistent, fullText).filter((e) => e.score >= config.threshold);
+		if (thresholded.length > 0) {
+			postOrgEntities = mergeAndDedup(consistent, thresholded);
+			log("org-propagation", `${thresholded.length} base names`);
+		}
+	}
+	const merged = filterFalsePositives(postOrgEntities, ctx);
+	if (merged.length < postOrgEntities.length) log("filter", `removed ${postOrgEntities.length - merged.length} FPs`);
+	checkAbort(signal);
+	ctx.corefSourceMap.clear();
+	if (config.enableCoreference) {
+		const terms = await extractDefinedTerms(fullText, merged, ctx);
+		if (terms.length > 0) {
+			log("coreference", `${terms.length} defined terms`);
+			const corefSpans = findCoreferenceSpans(fullText, terms, ctx);
+			if (corefSpans.length > 0) {
+				log("coreference-rescan", `${corefSpans.length} aliases`);
+				return sanitizeEntities(filterFalsePositives(enforceBoundaryConsistency(mergeAndDedup(merged, corefSpans), fullText), ctx));
+			}
+		}
+	}
+	return sanitizeEntities(merged);
+};
+const OPERATOR_REGISTRY = {
+	replace: {
+		type: "replace",
+		reversibility: "reversible",
+		apply: (_text, _label, placeholder) => placeholder
+	},
+	redact: {
+		type: "redact",
+		reversibility: "irreversible",
+		apply: (_text, _label, _placeholder, redactString) => redactString
+	}
+};
+/**
+* Default operator config: replace for all labels.
+* Preserves existing pipeline behaviour.
+*/
+const DEFAULT_OPERATOR_CONFIG = {
+	operators: {},
+	redactString: "[REDACTED]"
+};
+/**
+* Resolve the operator for a label, falling back to "replace".
+*/
+const resolveOperator = (config, label) => config.operators[label] ?? "replace";
+//#endregion
+//#region src/redact.ts
+const WHITESPACE_RE = /\s+/g;
+const PHONE_NOISE_RE = /[()\s-]/g;
+const SPACE_DASH_RE = /[\s-]/g;
+/**
+* Normalize entity text so that surface-form variations
+* of the same real-world value map to a single canonical
+* key. Lowercased emails, stripped phone formatting, etc.
+*/
+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") return text.replace(WHITESPACE_RE, " ").toLowerCase().trim();
+	return text.trim();
+};
+/**
+* Build a stable mapping from entity text to numbered
+* placeholders. Same real-world value always maps to the
+* same placeholder (e.g., "Dr. Muller" and "Dr.  Muller"
+* both become [PERSON_1]).
+*
+* Placeholder format: [LABEL_N] where LABEL is uppercase
+* and N is a 1-based counter per label.
+*
+* @param ctx Pipeline context. Must be the same instance
+*   passed to `runPipeline` (or `findCoreferenceSpans`)
+*   so coreference placeholder links are preserved.
+*   Defaults to `defaultContext` for single-tenant usage.
+*/
+const buildPlaceholderMap = (entities, ctx = defaultContext) => {
+	const counters = /* @__PURE__ */ new Map();
+	const textLabelToPlaceholder = /* @__PURE__ */ new Map();
+	const normalizedToPlaceholder = /* @__PURE__ */ new Map();
+	const sorted = entities.toSorted((a, b) => a.start - b.start);
+	for (const entity of sorted) {
+		const compositeKey = `${entity.label}\0${entity.text}`;
+		if (textLabelToPlaceholder.has(compositeKey)) continue;
+		const labelKey = entity.label.toUpperCase().replace(WHITESPACE_RE, "_");
+		const sourceText = ctx.corefSourceMap.get(corefKey(entity));
+		if (sourceText !== void 0) {
+			const sourceNormalizedKey = `${labelKey}\0${normalizeEntityText(entity.label, sourceText)}`;
+			const sourceExisting = normalizedToPlaceholder.get(sourceNormalizedKey);
+			if (sourceExisting) {
+				textLabelToPlaceholder.set(compositeKey, sourceExisting);
+				continue;
+			}
+		}
+		const normalizedKey = `${labelKey}\0${normalizeEntityText(entity.label, entity.text)}`;
+		const existing = normalizedToPlaceholder.get(normalizedKey);
+		if (existing) {
+			textLabelToPlaceholder.set(compositeKey, existing);
+			continue;
+		}
+		const count = (counters.get(labelKey) ?? 0) + 1;
+		counters.set(labelKey, count);
+		const placeholder = `[${labelKey}_${count}]`;
+		textLabelToPlaceholder.set(compositeKey, placeholder);
+		normalizedToPlaceholder.set(normalizedKey, placeholder);
+	}
+	return textLabelToPlaceholder;
+};
+/**
+* Apply redactions to the source text, replacing each
+* confirmed entity span using the configured operator.
+*
+* Co-references are consistent: if the same text appears
+* multiple times, all occurrences get the same placeholder.
+*
+* @param ctx Pipeline context. Must be the same instance
+*   passed to `runPipeline` (or `findCoreferenceSpans`)
+*   so coreference placeholder links are preserved.
+*   Defaults to `defaultContext` for single-tenant usage.
+*/
+const redactText = (fullText, entities, config = DEFAULT_OPERATOR_CONFIG, ctx = defaultContext) => {
+	if (entities.length === 0) return {
+		redactedText: fullText,
+		redactionMap: /* @__PURE__ */ new Map(),
+		operatorMap: /* @__PURE__ */ new Map(),
+		entityCount: 0
+	};
+	const placeholderMap = buildPlaceholderMap(entities, ctx);
+	const sorted = entities.toSorted((a, b) => a.start - b.start);
+	const nonOverlapping = [];
+	let lastEnd = 0;
+	for (const entity of sorted) if (entity.start >= lastEnd) {
+		nonOverlapping.push(entity);
+		lastEnd = entity.end;
+	}
+	const parts = [];
+	const redactionMap = /* @__PURE__ */ new Map();
+	const operatorMap = /* @__PURE__ */ new Map();
+	let cursor = 0;
+	for (const entity of nonOverlapping) {
+		if (entity.start > cursor) parts.push(fullText.slice(cursor, entity.start));
+		const placeholder = placeholderMap.get(`${entity.label}\0${entity.text}`) ?? `[${entity.label.toUpperCase().replace(/\s+/g, "_")}]`;
+		const opType = resolveOperator(config, entity.label);
+		const operator = OPERATOR_REGISTRY[opType];
+		const replacement = operator.apply(entity.text, entity.label, placeholder, config.redactString);
+		parts.push(replacement);
+		operatorMap.set(placeholder, opType);
+		if (operator.reversibility === "reversible" && !redactionMap.has(placeholder)) redactionMap.set(placeholder, entity.text);
+		cursor = entity.end;
+	}
+	if (cursor < fullText.length) parts.push(fullText.slice(cursor));
+	return {
+		redactedText: parts.join(""),
+		redactionMap,
+		operatorMap,
+		entityCount: nonOverlapping.length
+	};
+};
+/**
+* Serialize the redaction key to JSON for export.
+* Includes operator metadata so the export is self-describing.
+*/
+const exportRedactionKey = (redactionMap, operatorMap) => {
+	const entries = {};
+	for (const [placeholder, value] of redactionMap) entries[placeholder] = {
+		original: value,
+		operator: operatorMap.get(placeholder) ?? "replace"
+	};
+	return JSON.stringify({ entries }, null, 2);
+};
+/**
+* De-anonymise text using a redaction key.
+* Replaces placeholders back with original values.
+* Only works for reversible operators (replace).
+*/
+const deanonymise = (redactedText, redactionMap) => {
+	let result = redactedText;
+	for (const [placeholder, original] of redactionMap) result = result.replaceAll(placeholder, original);
+	return result;
+};
+//#endregion
+//#region src/gliner/decoder.ts
+const sigmoid$1 = (x) => 1 / (1 + Math.exp(-x));
+/** Check if two spans overlap (optionally allowing multi-label). */
+const hasOverlapping = (a, b, multiLabel) => {
+	const a0 = a[0] ?? 0;
+	const a1 = a[1] ?? 0;
+	const b0 = b[0] ?? 0;
+	const b1 = b[1] ?? 0;
+	if (a0 === b0 && a1 === b1) return !multiLabel;
+	return !(a0 > b1 || b0 > a1);
+};
+/**
+* Greedy non-overlapping span selection.
+* Sorts by score descending, keeps each span only if it
+* doesn't overlap with already-selected spans.
+*/
+const greedySearch = (spans, flatNer, multiLabel) => {
+	const sorted = spans.toSorted((a, b) => b[4] - a[4]);
+	const selected = [];
+	for (const span of sorted) if (!selected.some((s) => {
+		if (flatNer) return hasOverlapping([span[1], span[2]], [s[1], s[2]], multiLabel);
+		if (span[1] <= s[1] && span[2] >= s[2] || s[1] <= span[1] && s[2] >= span[2]) return false;
+		return hasOverlapping([span[1], span[2]], [s[1], s[2]], multiLabel);
+	})) selected.push(span);
+	return selected.toSorted((a, b) => a[1] - b[1]);
+};
+/**
+* Decode span-level model logits into entity results.
+*/
+const decodeSpans = (batchSize, inputLength, maxWidth, numEntities, texts, batchIds, batchWordsStartIdx, batchWordsEndIdx, idToClass, modelOutput, flatNer, threshold, multiLabel) => {
+	const spans = Array.from({ length: batchSize }, () => []);
+	const batchPadding = inputLength * maxWidth * numEntities;
+	const startTokenPadding = maxWidth * numEntities;
+	const endTokenPadding = numEntities;
+	for (let id = 0; id < modelOutput.length; id++) {
+		const batch = Math.floor(id / batchPadding);
+		const startToken = Math.floor(id / startTokenPadding) % inputLength;
+		const endToken = startToken + Math.floor(id / endTokenPadding) % maxWidth;
+		const entity = id % numEntities;
+		const prob = sigmoid$1(modelOutput[id] ?? 0);
+		const batchStarts = batchWordsStartIdx[batch];
+		const batchEnds = batchWordsEndIdx[batch];
+		const batchSpans = spans[batch];
+		if (!batchStarts || !batchEnds || !batchSpans) continue;
+		if (prob >= threshold && startToken < batchStarts.length && endToken < batchEnds.length) {
+			const globalBatch = batchIds[batch] ?? 0;
+			const startIdx = batchStarts[startToken] ?? 0;
+			const endIdx = batchEnds[endToken] ?? 0;
+			const spanText = (texts[globalBatch] ?? "").slice(startIdx, endIdx);
+			batchSpans.push([
+				spanText,
+				startIdx,
+				endIdx,
+				idToClass[entity + 1] ?? "",
+				prob
+			]);
+		}
+	}
+	return spans.map((batchSpans) => greedySearch(batchSpans, flatNer, multiLabel));
+};
+//#endregion
+//#region src/gliner/token-decoder.ts
+const sigmoid = (x) => 1 / (1 + Math.exp(-x));
+const B_TAG = 0;
+const I_TAG = 1;
+/**
+* Decode token-level BIO logits into entity spans.
+*
+* For each word, checks if the B(egin) logit for any class
+* exceeds the threshold. If so, extends the span by consuming
+* subsequent I(nside) tokens of the same class.
+*/
+const decodeTokenSpans = (batchSize, numWords, numEntities, texts, batchIds, batchWordsStartIdx, batchWordsEndIdx, idToClass, modelOutput, threshold) => {
+	const results = Array.from({ length: batchSize }, () => []);
+	const wordStride = numEntities * 3;
+	const batchStride = numWords * wordStride;
+	for (let b = 0; b < batchSize; b++) {
+		const batchOffset = b * batchStride;
+		const starts = batchWordsStartIdx[b];
+		const ends = batchWordsEndIdx[b];
+		const text = texts[batchIds[b] ?? 0] ?? "";
+		const batchSpans = results[b];
+		if (!starts || !ends || !batchSpans) continue;
+		const actualWords = starts.length;
+		for (let e = 0; e < numEntities; e++) {
+			let w = 0;
+			while (w < actualWords) {
+				const bScore = sigmoid(modelOutput[batchOffset + w * wordStride + e * 3 + B_TAG] ?? 0);
+				if (bScore < threshold) {
+					w++;
+					continue;
+				}
+				const spanStart = w;
+				let spanEnd = w;
+				let maxScore = bScore;
+				while (spanEnd + 1 < actualWords) {
+					const iScore = sigmoid(modelOutput[batchOffset + (spanEnd + 1) * wordStride + e * 3 + I_TAG] ?? 0);
+					if (iScore < threshold) break;
+					spanEnd++;
+					maxScore = Math.max(maxScore, iScore);
+				}
+				const charStart = starts[spanStart] ?? 0;
+				const charEnd = ends[spanEnd] ?? 0;
+				const spanText = text.slice(charStart, charEnd);
+				const label = idToClass[e + 1] ?? "";
+				if (spanText.trim().length > 0 && label) batchSpans.push([
+					spanText,
+					charStart,
+					charEnd,
+					label,
+					maxScore
+				]);
+				w = spanEnd + 1;
+			}
+		}
+		const selected = [];
+		for (const span of batchSpans.toSorted((x, y) => y[4] - x[4])) if (!selected.some((s) => span[1] < s[2] && span[2] > s[1])) selected.push(span);
+		results[b] = selected.toSorted((x, y) => x[1] - y[1]);
+	}
+	return results;
+};
+//#endregion
+//#region src/gliner/processor.ts
+const segmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+/** Tokenize text into words with character offsets. */
+const tokenizeText = (text) => {
+	const words = [];
+	const starts = [];
+	const ends = [];
+	for (const { segment, index, isWordLike } of segmenter.segment(text)) {
+		if (!isWordLike && !/\d/u.test(segment)) continue;
+		words.push(segment);
+		starts.push(index);
+		ends.push(index + segment.length);
+	}
+	return [
+		words,
+		starts,
+		ends
+	];
+};
+/** Build entity label <-> id mappings. */
+const createMappings = (labels) => {
+	const classToId = {};
+	const idToClass = {};
+	for (let i = 0; i < labels.length; i++) {
+		const label = labels[i];
+		if (label === void 0) continue;
+		const id = i + 1;
+		classToId[label] = id;
+		idToClass[id] = label;
+	}
+	return {
+		classToId,
+		idToClass
+	};
+};
+/** Prepend entity prompt tokens to word tokens. */
+const prepareTextInputs = (batchTokens, entities) => {
+	const inputTexts = [];
+	const promptLengths = [];
+	const textLengths = [];
+	for (const tokens of batchTokens) {
+		textLengths.push(tokens.length);
+		const prompt = [];
+		for (const ent of entities) {
+			prompt.push("<<ENT>>");
+			prompt.push(ent);
+		}
+		prompt.push("<<SEP>>");
+		promptLengths.push(prompt.length);
+		inputTexts.push([...prompt, ...tokens]);
+	}
+	return [
+		inputTexts,
+		textLengths,
+		promptLengths
+	];
+};
+/** Encode word sequences into token IDs with masks. */
+const encodeInputs = (tokenizer, texts, promptLengths) => {
+	const clsTokenId = tokenizer.token_to_id("[CLS]") ?? 1;
+	const sepTokenId = tokenizer.token_to_id("[SEP]") ?? 2;
+	const allInputIds = [];
+	const allAttentionMasks = [];
+	const allWordsMasks = [];
+	for (let idx = 0; idx < texts.length; idx++) {
+		const promptLength = promptLengths[idx] ?? 0;
+		const words = texts[idx];
+		if (!words) continue;
+		const wordsMask = [0];
+		const inputIds = [clsTokenId];
+		const attentionMask = [1];
+		let wordCounter = 1;
+		for (let wordId = 0; wordId < words.length; wordId++) {
+			const word = words[wordId];
+			if (word === void 0) continue;
+			const wordTokens = tokenizer.encode(word).ids.slice(1, -1);
+			for (let tokenId = 0; tokenId < wordTokens.length; tokenId++) {
+				attentionMask.push(1);
+				if (wordId < promptLength) wordsMask.push(0);
+				else if (tokenId === 0) {
+					wordsMask.push(wordCounter);
+					wordCounter++;
+				} else wordsMask.push(0);
+				inputIds.push(wordTokens[tokenId] ?? 0);
+			}
+		}
+		inputIds.push(sepTokenId);
+		wordsMask.push(0);
+		attentionMask.push(1);
+		allInputIds.push(inputIds);
+		allAttentionMasks.push(attentionMask);
+		allWordsMasks.push(wordsMask);
+	}
+	return [
+		allInputIds,
+		allAttentionMasks,
+		allWordsMasks
+	];
+};
+/** Build span index pairs and masks for the model. */
+const prepareSpans = (batchTokens, maxWidth) => {
+	const spanIdxs = [];
+	const spanMasks = [];
+	for (const tokens of batchTokens) {
+		const len = tokens.length;
+		const idx = [];
+		const mask = [];
+		for (let i = 0; i < len; i++) for (let j = 0; j < maxWidth; j++) {
+			const endIdx = Math.min(i + j, len - 1);
+			idx.push([i, endIdx]);
+			mask.push(endIdx < len);
+		}
+		spanIdxs.push(idx);
+		spanMasks.push(mask);
+	}
+	return {
+		spanIdxs,
+		spanMasks
+	};
+};
+/** Pad a 2D or 3D array to uniform inner length. */
+const padArray = (arr, dimensions = 2) => {
+	if (arr.length === 0) return [];
+	const maxLength = Math.max(...arr.map((sub) => sub.length));
+	let finalDim = 0;
+	if (dimensions === 3) {
+		for (const sub of arr) if (sub.length > 0) {
+			finalDim = sub[0].length;
+			break;
+		}
+	}
+	return arr.map((sub) => {
+		const padCount = maxLength - sub.length;
+		const fill = dimensions === 3 ? Array.from({ length: padCount }, () => Array.from({ length: finalDim }).fill(0)) : Array.from({ length: padCount }).fill(0);
+		return [...sub, ...fill];
+	});
+};
+/** Prepare a complete batch for ONNX inference. */
+const prepareBatch = (tokenizer, texts, entities, maxWidth) => {
+	const batchTokens = [];
+	const batchWordsStartIdx = [];
+	const batchWordsEndIdx = [];
+	for (const text of texts) {
+		const [words, starts, ends] = tokenizeText(text);
+		batchTokens.push(words);
+		batchWordsStartIdx.push(starts);
+		batchWordsEndIdx.push(ends);
+	}
+	const { idToClass } = createMappings(entities);
+	const [inputTokens, textLengths, promptLengths] = prepareTextInputs(batchTokens, entities);
+	let [inputsIds, attentionMasks, wordsMasks] = encodeInputs(tokenizer, inputTokens, promptLengths);
+	inputsIds = padArray(inputsIds);
+	attentionMasks = padArray(attentionMasks);
+	wordsMasks = padArray(wordsMasks);
+	let { spanIdxs, spanMasks } = prepareSpans(batchTokens, maxWidth);
+	spanIdxs = padArray(spanIdxs, 3);
+	spanMasks = padArray(spanMasks);
+	return {
+		inputsIds,
+		attentionMasks,
+		wordsMasks,
+		textLengths,
+		spanIdxs,
+		spanMasks,
+		idToClass,
+		batchTokens,
+		batchWordsStartIdx,
+		batchWordsEndIdx
+	};
+};
+//#endregion
+//#region src/util/chunker.ts
+const MAX_CHUNK_CHARS = 1500;
+const OVERLAP_CHARS = 50;
+const MIN_CHUNK_LENGTH = 10;
+/**
+* Split text into overlapping chunks for GLiNER's
+* ~512 token context window. Character-based splitting
+* (rough approximation of token limits).
+*
+* Tries to break at sentence boundaries when possible.
+*/
+const chunkText = (text) => {
+	const chunks = [];
+	let offset = 0;
+	while (offset < text.length) {
+		let end = Math.min(offset + MAX_CHUNK_CHARS, text.length);
+		if (end < text.length) {
+			const lastPeriod = text.slice(offset, end).lastIndexOf(". ");
+			if (lastPeriod > MAX_CHUNK_CHARS * .5) end = offset + lastPeriod + 2;
+		}
+		const chunk = text.slice(offset, end);
+		if (chunk.trim().length > MIN_CHUNK_LENGTH) chunks.push(chunk);
+		offset = Math.max(offset + 1, end - OVERLAP_CHARS);
+	}
+	return chunks;
+};
+/**
+* Compute the byte offset of each chunk within the
+* original document text.
+*/
+const computeChunkOffsets = (fullText, chunks) => {
+	const offsets = [];
+	let searchFrom = 0;
+	for (const chunk of chunks) {
+		const idx = fullText.indexOf(chunk, searchFrom);
+		offsets.push(idx !== -1 ? idx : searchFrom);
+		searchFrom = idx !== -1 ? idx + Math.max(1, chunk.length - OVERLAP_CHARS) : searchFrom;
+	}
+	return offsets;
+};
+const POSITION_THRESHOLD = 5;
+/**
+* Merge entities from overlapping chunks back to
+* document-level offsets. Deduplicates entities that
+* appear in overlap regions (keeps highest score).
+*
+* Dedup invariant: each incoming entity is compared
+* against the highest-scored same-label near-dup in
+* its proximity window. If it loses, it is dropped.
+* This does NOT guarantee that all pairwise near-dup
+* relationships in the output are resolved; a lower-
+* scored entity can survive if the bridging entity
+* that would have replaced it was itself dropped by
+* a higher-scored match.
+*
+* Uses a reverse-scan over the sorted merged array
+* so each entity only compares against nearby
+* predecessors — O(n * w) average where w is the max
+* entities per POSITION_THRESHOLD window, O(n²) worst
+* case when replacements dominate (splice is O(n)).
+*/
+const mergeChunkEntities = (chunkOffsets, chunkResults) => {
+	const allEntities = [];
+	for (let i = 0; i < chunkResults.length; i++) {
+		const offset = chunkOffsets[i] ?? 0;
+		const entities = chunkResults[i];
+		if (!entities) continue;
+		for (const entity of entities) allEntities.push({
+			...entity,
+			start: entity.start + offset,
+			end: entity.end + offset
+		});
+	}
+	const sorted = allEntities.toSorted((a, b) => a.start - b.start);
+	const merged = [];
+	for (const entity of sorted) {
+		let bestDupIndex = -1;
+		let bestDupScore = -1;
+		for (let j = merged.length - 1; j >= 0; j--) {
+			const existing = merged[j];
+			if (existing === void 0) continue;
+			if (entity.start - existing.start >= POSITION_THRESHOLD) break;
+			if (existing.label === entity.label && Math.abs(existing.end - entity.end) < POSITION_THRESHOLD && existing.score > bestDupScore) {
+				bestDupIndex = j;
+				bestDupScore = existing.score;
+			}
+		}
+		if (bestDupIndex !== -1) {
+			const existing = merged[bestDupIndex];
+			if (existing !== void 0 && entity.score > existing.score) {
+				merged.splice(bestDupIndex, 1);
+				merged.push({ ...entity });
+			}
+		} else merged.push({ ...entity });
+	}
+	return merged;
+};
+//#endregion
+//#region src/util/levenshtein.ts
+/**
+* Compute the Levenshtein edit distance between two
+* strings. O(n*m) time, O(min(n,m)) space using a
+* single-row DP approach.
+*/
+const levenshtein = (rawA, rawB) => {
+	if (rawA === rawB) return 0;
+	if (rawA.length === 0) return rawB.length;
+	if (rawB.length === 0) return rawA.length;
+	const [shorter, longer] = rawA.length <= rawB.length ? [rawA, rawB] : [rawB, rawA];
+	const aLen = shorter.length;
+	const bLen = longer.length;
+	const row = new Uint16Array(aLen + 1);
+	for (let i = 0; i <= aLen; i++) row[i] = i;
+	for (let j = 1; j <= bLen; j++) {
+		let prev = row[0] ?? 0;
+		row[0] = j;
+		for (let i = 1; i <= aLen; i++) {
+			const cost = shorter[i - 1] === longer[j - 1] ? 0 : 1;
+			const temp = row[i] ?? 0;
+			row[i] = Math.min((row[i] ?? 0) + 1, (row[i - 1] ?? 0) + 1, prev + cost);
+			prev = temp;
+		}
+	}
+	return row[aLen] ?? 0;
+};
+//#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 };
+
+//# sourceMappingURL=index.js.map