@stll/anonymize-wasm 1.4.0 → 1.4.1

package/dist/wasm.mjs

@@ -1,4 +1,6 @@
 import { DEFAULT_ENTITY_LABELS, DETECTION_SOURCES, DETECTOR_PRIORITY, OPERATOR_TYPES } from "./constants.mjs";
+import { t as amount_words_default } from "./amount-words.mjs";
+import { t as address_street_types_default } from "./address-street-types.mjs";
 import { TextSearch } from "@stll/text-search-wasm";
 import { at, be, bg, br, cy, cz, de, dk, ee, es, fi, fr, gb, gr, hr, hu, ie, it, lt, lu, lv, mt, nl, pl, pt, ro, se, si, sk } from "@stll/stdnum";
 import { toRegex } from "@stll/stdnum/patterns";
@@ -885,6 +887,7 @@ const getSentenceVerbIndicatorsSync = () => sentenceVerbIndicatorsCache ?? SENTE
 const UPPER = "A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽÄÖÜÀÂÆÇÈÊËÎÏÔÙÛŸÑĄĆĘŁŃŚŹŻ\\u0130";
 const LOWER = "a-záčďéěíňóřšťúůýžäöüßàâæçèêëîïôùûÿñąćęłńśźż\\u0131";
 const CAP_WORD = `(?:[${UPPER}]{2,}|[${UPPER}][${LOWER}${UPPER}]+)`;
+const SINGLE_CAP = `[${UPPER}](?![${LOWER}${UPPER}])`;
 const ALLCAP_WORD = `[${UPPER}]{2,}`;
 const ROMAN_NUMERAL_RE = /^(?=[IVXLCDM])M{0,3}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3})$/;
 let legalRoleHeadsCache = null;
@@ -912,11 +915,22 @@ const warmLegalRoleHeads = async () => {
 		loadLegalRoleHeads(),
 		loadAllLegalSuffixes(),
 		loadSentenceVerbIndicators(),
-		loadClauseNounHeads()
+		loadClauseNounHeads(),
+		loadConnectorProseHeads(),
+		loadStructuralSingleCapPrefixes()
 	]);
 };
 let allLegalSuffixesCache = null;
 let allLegalSuffixesPromise = null;
+let normalizedLegalBoundarySuffixesCache = null;
+let normalizedInNameLegalFormWordsCache = null;
+const normalizeLegalSuffixToken = (suffix) => suffix.replace(/[.,\s]/g, "");
+const isBoundaryLegalSuffixForm = (form) => {
+	const normalized = normalizeLegalSuffixToken(form);
+	if (normalized.length === 0) return false;
+	if (LEGAL_SUFFIXES.includes(form)) return true;
+	return /[.]/u.test(form) || normalized === normalized.toUpperCase();
+};
 const loadAllLegalSuffixes = async () => {
 	if (allLegalSuffixesCache) return allLegalSuffixesCache;
 	if (allLegalSuffixesPromise) return allLegalSuffixesPromise;
@@ -941,11 +955,15 @@ const loadAllLegalSuffixes = async () => {
 		}
 		out.sort((a, b) => b.length - a.length);
 		allLegalSuffixesCache = out;
+		normalizedLegalBoundarySuffixesCache = new Set(out.filter(isBoundaryLegalSuffixForm).map(normalizeLegalSuffixToken).filter((suffix) => suffix.length > 0));
+		normalizedInNameLegalFormWordsCache = new Set(out.filter((form) => !isBoundaryLegalSuffixForm(form) && !/\s/u.test(form)).map(normalizeLegalSuffixToken).filter((suffix) => suffix.length > 0));
 		return out;
 	})();
 	return allLegalSuffixesPromise;
 };
 const getAllLegalSuffixesSync = () => allLegalSuffixesCache ?? LEGAL_SUFFIXES;
+const getNormalizedLegalBoundarySuffixesSync = () => normalizedLegalBoundarySuffixesCache ?? new Set(LEGAL_SUFFIXES.map(normalizeLegalSuffixToken).filter((suffix) => suffix.length > 0));
+const getNormalizedInNameLegalFormWordsSync = () => normalizedInNameLegalFormWordsCache ?? /* @__PURE__ */ new Set();
 /**
 * Sync accessor for the full legal-form vocabulary
 * (`data/legal-forms.json` plus `LEGAL_SUFFIXES`,
@@ -985,18 +1003,72 @@ const loadClauseNounHeads = async () => {
 	return clauseNounHeadsPromise;
 };
 const getClauseNounHeadsSync = () => clauseNounHeadsCache ?? CLAUSE_NOUN_HEADS_SEED;
+let connectorProseHeadsCache = null;
+let connectorProseHeadsPromise = null;
+const loadConnectorProseHeads = async () => {
+	if (connectorProseHeadsCache) return connectorProseHeadsCache;
+	if (connectorProseHeadsPromise) return connectorProseHeadsPromise;
+	connectorProseHeadsPromise = (async () => {
+		let data = {};
+		try {
+			const mod = await import("./generic-roles.mjs");
+			data = mod.default ?? mod;
+		} catch (err) {
+			console.warn("[anonymize] legal-forms: failed to load generic-roles.json:", err);
+		}
+		const all = /* @__PURE__ */ new Set();
+		if (Array.isArray(data.roles)) {
+			for (const role of data.roles) if (typeof role === "string" && role.length > 0) all.add(role.toLowerCase());
+		}
+		connectorProseHeadsCache = all;
+		return all;
+	})();
+	return connectorProseHeadsPromise;
+};
+const getConnectorProseHeadsSync = () => connectorProseHeadsCache ?? /* @__PURE__ */ new Set();
+let structuralSingleCapPrefixesCache = null;
+let structuralSingleCapPrefixesPromise = null;
+const loadStructuralSingleCapPrefixes = async () => {
+	if (structuralSingleCapPrefixesCache) return structuralSingleCapPrefixesCache;
+	if (structuralSingleCapPrefixesPromise) return structuralSingleCapPrefixesPromise;
+	structuralSingleCapPrefixesPromise = (async () => {
+		let data = {};
+		try {
+			const mod = await import("./structural-single-cap-prefixes.mjs");
+			data = mod.default ?? mod;
+		} catch (err) {
+			console.warn("[anonymize] legal-forms: failed to load structural-single-cap-prefixes.json:", err);
+		}
+		const all = /* @__PURE__ */ new Set();
+		for (const [key, value] of Object.entries(data)) {
+			if (key.startsWith("_")) continue;
+			if (!Array.isArray(value)) continue;
+			for (const prefix of value) {
+				if (typeof prefix !== "string" || prefix.length === 0) continue;
+				all.add(prefix.toLowerCase());
+			}
+		}
+		structuralSingleCapPrefixesCache = all;
+		return all;
+	})();
+	return structuralSingleCapPrefixesPromise;
+};
+const getStructuralSingleCapPrefixesSync = () => structuralSingleCapPrefixesCache ?? /* @__PURE__ */ new Set();
 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 buildDottedAbbreviationAlternation = (forms) => [...new Set(forms.filter((form) => /^[\p{Lu}][\p{L}\p{M}]{0,5}\.$/u.test(form)).map((form) => form.slice(0, -1)).filter((form) => form.length > 0))].toSorted((a, b) => b.length - a.length).map(escapeForRegex).join("|");
 const buildPatternString = (forms) => {
 	if (forms.length === 0) return null;
 	const alt = forms.toSorted((a, b) => b.length - a.length).map(escapeForRegex).join("|");
 	const HSPACE = "[^\\S\\n]";
 	const LOWER_CONNECTOR = `${HSPACE}+(?:a|and|und|et|e|y|i)${HSPACE}+(?=[${LOWER}])`;
 	const SIMPLE_SEP = `(?:${HSPACE}|[&,.${DASH_INNER}]){1,4}`;
-	const CAP_OR_NUM_WORD = `(?:${CAP_WORD}|\\d{1,4})`;
+	const CAP_OR_NUM_WORD = `(?:${CAP_WORD}|${SINGLE_CAP}|\\d{1,4})`;
 	const LOWER_WORD = `(?:(?!(?:and|und|et)(?![${UPPER}${LOWER}]))[${LOWER}][${LOWER}${UPPER}]+)`;
 	const ANY_WORD_TAIL = `(?:(?!(?:and|und|et)(?![${UPPER}${LOWER}]))[${UPPER}${LOWER}][${LOWER}${UPPER}]+|[${UPPER}]{2,3}|\\d{1,4})`;
-	return `${`(?:${`(?:${CAP_WORD})(?:${SIMPLE_SEP}(?:${CAP_OR_NUM_WORD})){0,10}`})(?:${`${SIMPLE_SEP}(?:${LOWER_WORD})(?:(?:${LOWER_CONNECTOR}|${SIMPLE_SEP})(?:${ANY_WORD_TAIL})){0,10}`})?`}(?:\\s+|,\\s*)(?:${alt})(?![${LOWER}])`;
+	const dottedAbbreviationAlt = buildDottedAbbreviationAlternation(forms);
+	const dottedAbbreviationTail = dottedAbbreviationAlt.length > 0 ? `(?:${SIMPLE_SEP}(?:${dottedAbbreviationAlt})\\.)?` : "";
+	return `${`(?:${`(?:${CAP_WORD})(?:${SIMPLE_SEP}(?:${CAP_OR_NUM_WORD})){0,10}` + dottedAbbreviationTail})(?:${`${SIMPLE_SEP}(?:${LOWER_WORD})(?:(?:${LOWER_CONNECTOR}|${SIMPLE_SEP})(?:${ANY_WORD_TAIL})){0,10}`})?`}(?:\\s+|,\\s*)(?:${alt})(?![${LOWER}])`;
 };
 /**
 * Build legal form regex pattern strings.
@@ -1029,6 +1101,7 @@ const buildLegalFormPatterns = async () => {
 	const allcapPrefix = `(?:${ALLCAP_WORD})(?:[ \\t&,.${DASH_INNER}]{1,4}(?:${ALLCAP_WORD})){0,2}`;
 	const allcapAlt = allForms.toSorted((a, b) => b.length - a.length).map(escapeForRegex).join("|");
 	patterns.push(`${allcapPrefix}(?:[ \\t]+|,[ \\t]*)(?:${allcapAlt})(?![${LOWER}])`);
+	patterns.push(`(?:^|(?<=[^${UPPER}${LOWER}\\p{N}]))[${UPPER}](?:[ \\t]+|,[ \\t]*)(?:${allcapAlt})(?![${UPPER}${LOWER}\\p{N}])`);
 	return patterns;
 };
 const CONNECTOR_RE = /^(?:a|and|und|et|e|y|i|&)$/i;
@@ -1038,6 +1111,12 @@ const COMPANY_SUFFIX_WORDS_RE = /^(?:Company|Co|Bank|Brothers|Bros|Sons|Group|Ho
 const IN_NAME_PREPOSITION_RE = /^(?:of|the)$/i;
 const ENTITY_HEAD_WORD_RE = /^[\p{L}\p{M}&]+/u;
 const LEADING_CLAUSE_RE = /(?:^|\s)(?:by\s+and\s+between|is\s+between)\s+/giu;
+const BARE_SINGLE_CAP_LEGAL_FORM_RE = new RegExp(`^[${UPPER}](?:[ \\t]+|,[ \\t]*)`, "u");
+const STRUCTURAL_SINGLE_CAP_RE = new RegExp(`^([\\p{L}\\p{M}]+)[ \\t]+[${UPPER}](?:[.${DASH_INNER}]?\\d{1,3})?(?:[ \\t]+|,[ \\t]*)`, "u");
+const isStructuralSingleCapMatch = (text) => {
+	const first = STRUCTURAL_SINGLE_CAP_RE.exec(text)?.[1];
+	return first !== void 0 && getStructuralSingleCapPrefixesSync().has(first.toLowerCase());
+};
 /**
 * Find the word ending just before `pos` in `text`,
 * skipping any whitespace (not newlines).
@@ -1062,25 +1141,145 @@ const findWordBefore = (text, pos) => {
 		start: wordStart
 	};
 };
+const hasSingleCapPrefixBefore = (fullText, matchStart) => {
+	const prev = findWordBefore(fullText, matchStart);
+	return prev !== null && prev.word.length === 1 && UPPER_LETTER_RE.test(prev.word);
+};
+const isBareSingleCapStructuralInnerMatch = (fullText, matchStart, text) => {
+	if (!BARE_SINGLE_CAP_LEGAL_FORM_RE.test(text)) return false;
+	const prev = findWordBefore(fullText, matchStart);
+	return prev !== null && getStructuralSingleCapPrefixesSync().has(prev.word.toLowerCase());
+};
+const trimEmbeddedLegalFormListPrefix = (entityStart, entityText) => {
+	let cut = -1;
+	for (const suffix of getAllLegalSuffixesSync()) {
+		const suffixClean = suffix.replace(/[.,\s]/g, "");
+		if (suffixClean.length > 0 && ROMAN_NUMERAL_RE.test(suffixClean)) continue;
+		let fromIndex = 0;
+		while (fromIndex < entityText.length) {
+			const suffixStart = entityText.indexOf(suffix, fromIndex);
+			if (suffixStart === -1) break;
+			fromIndex = suffixStart + suffix.length;
+			const suffixEnd = suffixStart + suffix.length;
+			if (suffixEnd >= entityText.length - 1) continue;
+			const afterSuffix = entityText.slice(suffixEnd);
+			const boundary = /^,\s+(?=\p{Lu})/u.exec(afterSuffix);
+			if (boundary === null) continue;
+			const nextStart = suffixEnd + boundary[0].length;
+			const remainder = entityText.slice(nextStart);
+			if (!getAllLegalSuffixesSync().some((form) => remainder.endsWith(form))) continue;
+			cut = Math.max(cut, nextStart);
+		}
+	}
+	if (cut <= 0) return {
+		entityStart,
+		entityText
+	};
+	return {
+		entityStart: entityStart + cut,
+		entityText: entityText.slice(cut)
+	};
+};
+const hasMiddleInitialBefore = (fullText, pos) => {
+	const previousWord = findWordBefore(fullText, pos);
+	if (!previousWord) return false;
+	let scan = previousWord.start - 1;
+	while (scan >= 0 && (fullText[scan] === " " || fullText[scan] === "	")) scan--;
+	return scan >= 1 && fullText[scan] === "." && UPPER_LETTER_RE.test(fullText[scan - 1] ?? "");
+};
 /**
 * Count consecutive uppercase-starting words immediately
 * before `pos`. Stops at the first non-upper word or at
-* text/line start. Used to disambiguate "<First> <Last>
-* and <ORG>" from "<Multi-word Org> and <Continuation>".
-*/
-const countUpperWordsBefore = (fullText, pos) => {
+* text/line start. Used to disambiguate sentence prose
+* ("<First> <Last> and <ORG>", "<Defined-Term> and
+* <ORG>") from multi-word organisation names that span
+* an "and" connector ("UniCredit Bank Czech Republic and
+* Slovakia, a.s.").
+*
+* When `crossInNamePreps` is true, the walk also steps
+* over in-name lowercase prepositions ("of", "the") as
+* long as they sit between two upper words. This lets
+* the suffix-mode "and"-crossing logic see through
+* "<Trust ← and ← America ← of ← Bank>" and emit one
+* full organisation span.
+*/
+const countUpperWordsBefore = (fullText, pos, crossInNamePreps = false) => {
 	let count = 0;
 	let scan = pos;
 	while (scan > 0) {
 		const found = findWordBefore(fullText, scan);
-		if (!found) break;
-		if (!UPPER_LETTER_RE.test(found.word)) break;
-		count++;
-		scan = found.start;
+		if (found) {
+			if (UPPER_LETTER_RE.test(found.word)) {
+				count++;
+				scan = found.start;
+				continue;
+			}
+			if (crossInNamePreps && IN_NAME_PREPOSITION_RE.test(found.word)) {
+				const prev = findWordBefore(fullText, found.start);
+				if (!prev) break;
+				if (!UPPER_LETTER_RE.test(prev.word)) break;
+				scan = found.start;
+				continue;
+			}
+			break;
+		}
+		let p = scan - 1;
+		while (p >= 0 && (fullText[p] === " " || fullText[p] === "	")) p--;
+		if (p >= 1 && fullText[p] === "." && UPPER_LETTER_RE.test(fullText[p - 1] ?? "")) {
+			count++;
+			scan = p - 1;
+			continue;
+		}
+		break;
 	}
 	return count;
 };
 /**
+* True when `word` is a recognized legal-form suffix
+* (case-sensitive against the legal-forms vocabulary).
+* Used when deciding whether to cross an "and" connector
+* during backward extension — if the word immediately
+* preceding the connector is itself a legal-form suffix,
+* the "and" sits between two organisation names rather
+* than inside one ("Morgan Securities LLC and Allen &
+* Company LLC"), so the walk must stop there.
+*/
+const isKnownLegalFormSuffix = (word) => {
+	if (word.length === 0) return false;
+	return getNormalizedLegalBoundarySuffixesSync().has(word);
+};
+const isInNameLegalFormWord = (word) => {
+	if (word.length === 0) return false;
+	return getNormalizedInNameLegalFormWordsSync().has(word);
+};
+/**
+* If `pos` is immediately preceded (modulo horizontal
+* whitespace) by an initial-dot run like `J.P.`, `U.S.`,
+* or `N.A.`, return the position where the initial run
+* starts. Otherwise return `pos` unchanged. The run must
+* be word-bounded on the left so we never absorb a stray
+* sentence-ending dot.
+*/
+const skipInitialsBackward = (fullText, pos) => {
+	let scan = pos - 1;
+	while (scan >= 0) {
+		const ch = fullText.charAt(scan);
+		if (ch === "\n" || !/\s/.test(ch)) break;
+		scan--;
+	}
+	if (scan < 0 || fullText.charAt(scan) !== ".") return pos;
+	const scanLimit = Math.max(0, scan + 1 - 100);
+	const head = fullText.slice(scanLimit, scan + 1);
+	const match = /(?:\p{Lu}\.[^\S\n]?){2,}$/u.exec(head);
+	if (match === null) return pos;
+	const start = scanLimit + match.index;
+	if (start > 0) {
+		const prevCh = fullText.charAt(start - 1);
+		if (/[\p{L}\p{M}\p{N}]/u.test(prevCh)) return pos;
+	}
+	return start;
+};
+/**
 * Extend a match backward through uppercase words and
 * lowercase connectors. Stops at start of text,
 * newline, or a word that doesn't qualify.
@@ -1109,19 +1308,30 @@ const extendBackward = (fullText, matchStart, options = {}) => {
 		const isConnector = CONNECTOR_RE.test(word);
 		const isInNamePrep = suffixMode && IN_NAME_PREPOSITION_RE.test(word);
 		if (isUpper) pos = wordStart;
-		else if (isConnector) {
-			if (!suffixMode && AND_TYPE_CONNECTOR_RE.test(word) && countUpperWordsBefore(fullText, wordStart) === 2) break;
+		else if (isConnector) if (AND_TYPE_CONNECTOR_RE.test(word)) {
+			const prev = findWordBefore(fullText, wordStart);
+			if (!prev) break;
+			if (!UPPER_LETTER_RE.test(prev.word)) break;
+			if (isKnownLegalFormSuffix(prev.word)) break;
+			const upperWordsBefore = countUpperWordsBefore(fullText, wordStart, suffixMode);
+			const middleInitialBefore = hasMiddleInitialBefore(fullText, wordStart);
+			if (upperWordsBefore <= 1 && (getClauseNounHeadsSync().has(prev.word.toLowerCase()) || getConnectorProseHeadsSync().has(prev.word.toLowerCase()))) break;
+			if (suffixMode ? middleInitialBefore && hasSingleCapPrefixBefore(fullText, matchStart) : upperWordsBefore === 2 && !isInNameLegalFormWord(prev.word) || middleInitialBefore) break;
+			pos = prev.start;
+		} else {
 			const prev = findWordBefore(fullText, wordStart);
 			if (!prev) break;
 			if (!UPPER_LETTER_RE.test(prev.word)) break;
 			pos = prev.start;
-		} else if (isInNamePrep) {
+		}
+		else if (isInNamePrep) {
 			const prev = findWordBefore(fullText, wordStart);
 			if (!prev) break;
 			if (!UPPER_LETTER_RE.test(prev.word)) break;
 			pos = prev.start;
 		} else break;
 	}
+	pos = skipInitialsBackward(fullText, pos);
 	return pos;
 };
 const trimLeadingClause = (text) => {
@@ -1162,6 +1372,7 @@ const processLegalFormMatches = (allMatches, sliceStart, sliceEnd, fullText) =>
 		const firstWordMatch = /^[\p{L}\p{M}]+(?:-[\p{L}\p{M}]+)*/u.exec(text);
 		let processedStart = match.start;
 		let processedText = text;
+		if (isStructuralSingleCapMatch(processedText) || fullText !== void 0 && isBareSingleCapStructuralInnerMatch(fullText, match.start, text)) continue;
 		let trimmed = false;
 		const firstWordText = firstWordMatch?.[0] ?? "";
 		const firstWordLeading = /^[\p{L}\p{M}]+/u.exec(firstWordText)?.[0] ?? "";
@@ -1212,12 +1423,15 @@ const processLegalFormMatches = (allMatches, sliceStart, sliceEnd, fullText) =>
 		let entityStart = processedStart;
 		let entityText = processedText;
 		if (fullText && !trimmed) {
-			const extended = extendBackward(fullText, processedStart);
+			const extended = !BARE_SINGLE_CAP_LEGAL_FORM_RE.test(processedText) ? extendBackward(fullText, processedStart) : processedStart;
 			if (extended < processedStart) {
 				entityStart = extended;
 				entityText = fullText.slice(extended, processedStart + processedText.length).trimEnd();
 			}
 		}
+		const listTrim = trimEmbeddedLegalFormListPrefix(entityStart, entityText);
+		entityStart = listTrim.entityStart;
+		entityText = listTrim.entityText;
 		const clauseTrim = trimLeadingClause(entityText);
 		if (clauseTrim.offset > 0) {
 			entityStart += clauseTrim.offset;
@@ -1564,20 +1778,23 @@ const processGazetteerMatches = (allMatches, sliceStart, sliceEnd, fullText, dat
 		const label = data.labels[localIdx];
 		if (!label) continue;
 		const extended = tryPrefixExtension(fullText, match.start, match.end);
+		const isExtended = extended !== null;
 		const end = extended?.end ?? match.end;
 		const text = extended?.text ?? fullText.slice(match.start, match.end);
 		exactSpans.push({
 			start: match.start,
 			end
 		});
-		results.push({
+		const entity = {
 			start: match.start,
 			end,
 			label,
 			text,
 			score: .9,
 			source: DETECTION_SOURCES.GAZETTEER
-		});
+		};
+		if (isExtended) entity.sourceDetail = "gazetteer-extension";
+		results.push(entity);
 	}
 	for (const match of allMatches) {
 		const idx = match.pattern;
@@ -2122,8 +2339,10 @@ 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$2 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const escapeRegexPhrase = (s) => escapeRegex$2(s.trim()).replace(/\s+/g, "[^\\S\\n\\t]+");
 /** Escape for use inside a regex character class. */
 const escapeCharClass = (s) => s.replace(/[\]\\^-]/g, "\\$&");
+const toSortedAlternation = (values) => [...new Set(values.map(escapeRegexPhrase).filter((value) => value.length > 0))].toSorted((a, b) => b.length - a.length).join("|");
 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 = `\\p{Lu}\\p{Ll}+`;
@@ -2134,6 +2353,7 @@ const HONORIFIC_ALT = [...HONORIFICS].toSorted((a, b) => b.length - a.length).ma
 	const escaped = escapeRegex$2(h);
 	return HONORIFIC_BOUNDARY.has(h) ? `\\b${escaped}` : escaped;
 }).join("|");
+const AMOUNT_WORDS = amount_words_default;
 const toEntry = (validator, label, score) => {
 	const pattern = toRegex(validator).source;
 	if (!pattern) return null;
@@ -2347,6 +2567,58 @@ 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.,;:!?)\\]>])?`;
+const BARE_DOMAIN = {
+	pattern: `${BARE_HOST}(?:\\.${HOST_LABEL})*\\.(?:${LONG_TLDS})\\b${PATH_SUFFIX}|${BARE_HOST}(?:\\.${HOST_LABEL})+\\.(?:${SHORT_TLDS})\\b${PATH_SUFFIX}`,
+	label: "url",
+	score: .9
+};
+const IPV6_ADDRESS = {
+	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
+};
+const MAC_ADDRESS = {
+	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
+};
+const UK_POSTCODE = {
+	pattern: "\\b(?:GIR[^\\S\\n]?0AA|[A-PR-UWYZ](?:[A-HK-Y][0-9](?:[0-9]|[ABEHMNPRV-Y])?|[0-9](?:[0-9]|[A-HJKPS-UW])?)[^\\S\\n]?[0-9][ABD-HJLNP-UW-Z]{2})\\b",
+	label: "address",
+	score: .9
+};
+const UK_NINO = {
+	pattern: "\\b[A-CEGHJ-PR-TWXYZ][A-CEGHJ-NPR-TWXYZ][^\\S\\n]?\\d{2}[^\\S\\n]?\\d{2}[^\\S\\n]?\\d{2}[^\\S\\n]?[A-D]?\\b",
+	label: "social security number",
+	score: .95,
+	validator: gb.nino
+};
+const TIME_12H = {
+	pattern: "\\b(?:1[0-2]|0?[1-9]):[0-5]\\d[^\\S\\n]?(?:[aApP]\\.?[mM]\\.?)(?=[\\s,;!?)]|$)",
+	label: "date",
+	score: .9
+};
+const PERCENT_TOKEN = `${`(?:[+${DASH_INNER}])?(?:\\d{1,3}(?:[.,]\\d{3})+(?:[.,]\\d{1,4})?|\\d+(?:[.,]\\d{1,4})?)`}[^\\S\\n]{0,2}%`;
+const PERCENT_RANGE_NUMBER = `\\d+(?:[.,]\\d{1,4})?`;
+const PERCENT_RANGE = `${PERCENT_RANGE_NUMBER}[^\\S\\n]*${DASH}[^\\S\\n]*${PERCENT_RANGE_NUMBER}[^\\S\\n]{0,2}%`;
+const buildPercentWordPattern = (config) => {
+	const phrases = [];
+	for (const entry of config.percentages ?? []) {
+		const ones = entry.ones.map(escapeRegex$2);
+		const standalone = (entry.standalone ?? []).map(escapeRegex$2);
+		const baseWords = [
+			...ones,
+			...entry.teens,
+			...entry.tens
+		].map(escapeRegex$2);
+		const compoundSeparator = entry.allowSpaceCompoundSeparator ? `(?:${DASH}|[^\\S\\n]+)` : DASH;
+		const compound = `(?:${baseWords.join("|")})` + (ones.length > 0 ? `(?:${compoundSeparator}(?:${ones.join("|")}))?` : "");
+		const word = `(?:${[...standalone, compound].join("|")})`;
+		const keyword = `(?:${entry.keywords.map(escapeRegex$2).join("|")})`;
+		phrases.push(`${word}[^\\S\\n]+${keyword}`);
+	}
+	return phrases.length > 0 ? `(?i:(?:${phrases.join("|")}))` : "(?!)";
+};
 /**
 * All static PII regex definitions. Scanned in a
 * single pass by @stll/regex-set (Rust DFA).
@@ -2388,36 +2660,16 @@ const ALL_REGEX_DEFS = [
 	BR_RG_WITH_SSP,
 	BR_OAB,
 	URL,
+	IPV6_ADDRESS,
+	MAC_ADDRESS,
+	BARE_DOMAIN,
+	UK_POSTCODE,
+	UK_NINO,
+	TIME_12H,
 	{
-		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
-	},
-	{
-		pattern: "\\b(?:GIR[^\\S\\n]?0AA|[A-PR-UWYZ](?:[A-HK-Y][0-9](?:[0-9]|[ABEHMNPRV-Y])?|[0-9](?:[0-9]|[A-HJKPS-UW])?)[^\\S\\n]?[0-9][ABD-HJLNP-UW-Z]{2})\\b",
-		label: "address",
-		score: .9
-	},
-	{
-		pattern: "\\b[A-CEGHJ-PR-TWXYZ][A-CEGHJ-NPR-TWXYZ][^\\S\\n]?\\d{2}[^\\S\\n]?\\d{2}[^\\S\\n]?\\d{2}[^\\S\\n]?[A-D]?\\b",
-		label: "social security number",
-		score: .95,
-		validator: gb.nino
-	},
-	{
-		pattern: "\\b(?:1[0-2]|0?[1-9]):[0-5]\\d[^\\S\\n]?(?:[aApP]\\.?[mM]\\.?)(?=[\\s,;!?)]|$)",
-		label: "date",
-		score: .9
+		pattern: `(?<![\\p{L}\\p{N}_.,])(?:${buildPercentWordPattern(AMOUNT_WORDS)}[^\\S\\n]*\\([^\\S\\n]*${PERCENT_TOKEN}[^\\S\\n]*\\)|${PERCENT_RANGE}|${PERCENT_TOKEN})(?![\\p{L}\\p{N}_])`,
+		label: "monetary amount",
+		score: .85
 	},
 	...STDNUM_ENTRIES
 ];
@@ -2491,6 +2743,41 @@ const DATE_PATTERN_META = Object.freeze({
 	label: "date",
 	score: 1
 });
+const buildMagnitudePattern = (config) => {
+	const words = [];
+	const caseInsensitiveAbbreviations = [];
+	const caseSensitiveAbbreviations = [];
+	for (const entry of config.magnitudeSuffixes ?? []) {
+		words.push(...entry.words ?? []);
+		caseInsensitiveAbbreviations.push(...entry.abbreviationsCaseInsensitive ?? []);
+		caseSensitiveAbbreviations.push(...entry.abbreviationsCaseSensitive ?? []);
+	}
+	const branches = [];
+	const wordsAlt = toSortedAlternation(words);
+	const abbreviationCiAlt = toSortedAlternation(caseInsensitiveAbbreviations);
+	const abbreviationCsAlt = toSortedAlternation(caseSensitiveAbbreviations);
+	if (wordsAlt) branches.push(`[^\\S\\n\\t]+(?i:(?:${wordsAlt}))\\b`);
+	if (abbreviationCiAlt) branches.push(`[^\\S\\n\\t]?(?i:${abbreviationCiAlt})\\b`);
+	if (abbreviationCsAlt) branches.push(`[^\\S\\n\\t]?(?:${abbreviationCsAlt})\\b`);
+	return branches.length > 0 ? `(?:${branches.join("|")})?` : "";
+};
+const buildQuantityFollowerGuard = (config) => {
+	const modifiers = [];
+	const nouns = [];
+	for (const entry of config.shareQuantityTerms ?? []) {
+		modifiers.push(...entry.modifiers ?? []);
+		nouns.push(...entry.nouns);
+	}
+	const modifierAlt = toSortedAlternation(modifiers);
+	const nounAlt = toSortedAlternation(nouns);
+	if (!nounAlt) return "";
+	return `(?![^\\S\\n\\t]+(?i:${modifierAlt ? `(?:(?:${modifierAlt})[^\\S\\n\\t]+){0,3}` : ""}(?:${nounAlt}))\\b)`;
+};
+const buildFinancialLexicons = (config) => Object.freeze({
+	magnitude: buildMagnitudePattern(config),
+	quantityFollowerGuard: buildQuantityFollowerGuard(config)
+});
+const FINANCIAL_LEXICONS = buildFinancialLexicons(AMOUNT_WORDS);
 /**
 * Build symbol character class, code alternation,
 * and local-name alternation from currencies.json,
@@ -2530,9 +2817,13 @@ const buildCurrencyPatterns = (data) => {
 	const patterns = [];
 	const DECIMAL = `(?:[.,](?=\\d|[${DASH_INNER}])[^\\S\\n\\t]?(?:\\d{1,2}${DASH}?|${DASH}{1,2}))?`;
 	const END = `(?:\\b|(?=\\s|[.,;!?)]|$))`;
-	if (symbols) patterns.push(`(?:[${symbols}])[^\\S\\n\\t]?${NUM}${DECIMAL}${END}`);
-	if (trailingAlt) patterns.push(`\\b(?:${trailingAlt})[^\\S\\n\\t]{0,2}${NUM}${DECIMAL}${END}`);
-	if (trailingAlt) patterns.push(`\\b${NUM}${DECIMAL}[^\\S\\n\\t]{0,4}(?:${trailingAlt})${END}`);
+	const MAGNITUDE = FINANCIAL_LEXICONS.magnitude;
+	if (symbols) patterns.push(`(?:[${symbols}])[^\\S\\n\\t]?${NUM}${DECIMAL}${MAGNITUDE}${END}`);
+	if (trailingAlt) patterns.push(`\\b(?:${trailingAlt})[^\\S\\n\\t]{0,2}${NUM}${DECIMAL}${MAGNITUDE}${END}`);
+	if (trailingAlt) {
+		const optionalLeadingSymbol = symbols ? `(?<![\\p{L}\\p{N}_])(?:[${symbols}][^\\S\\n\\t]?)?` : "\\b";
+		patterns.push(`${optionalLeadingSymbol}${NUM}${DECIMAL}${MAGNITUDE}[^\\S\\n\\t]{0,4}(?:${trailingAlt})${FINANCIAL_LEXICONS.quantityFollowerGuard}${END}`);
+	}
 	return patterns;
 };
 /** Cached promise for currency patterns. Loaded once. */
@@ -2846,10 +3137,19 @@ const stripQuotes = (value) => {
 		text: stripped
 	};
 };
-/** Hard stop characters for to-next-comma scanning. */
+/**
+* Hard stop characters for to-next-comma scanning. A closing
+* parenthesis or closing bracket terminates a clause just like
+* an opening one: `State of New York or any other jurisdiction)`
+* is the tail of a parenthesised insertion, not the start of a
+* larger phrase that should be absorbed into a jurisdiction span.
+*/
 const COMMA_STOP_CHARS = new Set([
 	"\n",
 	"(",
+	")",
+	"[",
+	"]",
 	"	",
 	";"
 ]);
@@ -3015,6 +3315,27 @@ const getAddressStopKeywordsSync = () => addressStopKeywordsCache ?? ADDRESS_STO
 const warmAddressStopKeywords = async () => {
 	await loadAddressStopKeywords();
 };
+const MAX_TRIGGER_VALUE_LEN = 100;
+const MIN_TRIGGER_PHONE_DIGITS = 5;
+const PHONE_VALUE_START_RE = /^[+(\d]/;
+const ISO_DATE_PREFIX_RE = /^\d{4}-\d{2}-\d{2}\b/;
+const INLINE_FIELD_LABEL_RE = /\b[\p{L}][\p{L}\p{M} /-]{1,32}:/u;
+const INLINE_FIELD_LABEL_STOP_RE = /(?:^|[^\S\n\t])[\p{L}][\p{L}\p{M} /-]{1,32}:/u;
+const capAtWordBoundary = (valueText, cap) => {
+	let capped = cap;
+	const isWordChar = (i) => /[\p{L}\p{N}]/u.test(valueText[i] ?? "");
+	while (capped > 0 && isWordChar(capped - 1) && isWordChar(capped)) capped--;
+	return capped;
+};
+const isPlausiblePhoneTriggerValue = (value) => {
+	const trimmed = value.trimStart();
+	if (!PHONE_VALUE_START_RE.test(trimmed)) return false;
+	if (ISO_DATE_PREFIX_RE.test(trimmed)) return false;
+	if (INLINE_FIELD_LABEL_RE.test(trimmed)) return false;
+	let digits = 0;
+	for (const ch of trimmed) if (/\d/.test(ch)) digits++;
+	return digits >= MIN_TRIGGER_PHONE_DIGITS;
+};
 const extractValue = (text, triggerEnd, strategy, label) => {
 	const remaining = text.slice(triggerEnd);
 	const stripped = remaining.replace(/^[\s:;]+/, "");
@@ -3026,21 +3347,11 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 			const stopWords = strategy.stopWords ?? [];
 			const stopWordRe = stopWords.length > 0 ? new RegExp(`^(?:${stopWords.map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})(?![\\p{L}\\p{N}])`, "iu") : null;
 			let end = 0;
-			let foundStop = false;
 			while (end < valueText.length) {
 				const ch = valueText[end];
-				if (ch !== void 0 && COMMA_STOP_CHARS.has(ch)) {
-					foundStop = true;
-					break;
-				}
-				if (ch === "." && isSentenceTerminator(valueText, end)) {
-					foundStop = true;
-					break;
-				}
-				if (stopWordRe !== null && (end === 0 || !/[\p{L}\p{N}]/u.test(valueText[end - 1] ?? "")) && stopWordRe.test(valueText.slice(end))) {
-					foundStop = true;
-					break;
-				}
+				if (ch !== void 0 && COMMA_STOP_CHARS.has(ch)) break;
+				if (ch === "." && isSentenceTerminator(valueText, end)) break;
+				if (stopWordRe !== null && (end === 0 || !/[\p{L}\p{N}]/u.test(valueText[end - 1] ?? "")) && stopWordRe.test(valueText.slice(end))) break;
 				if (ch === ",") {
 					const afterComma = valueText.slice(end);
 					if (DECIMAL_COMMA_RE.test(afterComma)) {
@@ -3052,12 +3363,12 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 						end += degreeMatch[0].length;
 						continue;
 					}
-					foundStop = true;
 					break;
 				}
 				end++;
 			}
-			if (!foundStop) end = Math.min(end, 100);
+			const lengthCap = strategy.maxLength ?? 100;
+			if (end > lengthCap) end = capAtWordBoundary(valueText, lengthCap);
 			const rawSlice = valueText.slice(0, end);
 			const extracted = rawSlice.trim();
 			if (extracted.length === 0) return null;
@@ -3071,12 +3382,24 @@ const extractValue = (text, triggerEnd, strategy, label) => {
 		case "to-end-of-line": {
 			const consumed = remaining.length - valueText.length;
 			if (consumed > 0 && remaining.slice(0, consumed).includes("\n")) return null;
-			const LINE_STOPS = ["\n"];
+			const LINE_STOPS = ["\n", "	"];
 			let end = valueText.length;
+			let foundLineStop = false;
 			for (const ch of LINE_STOPS) {
 				const idx = valueText.indexOf(ch);
-				if (idx !== -1 && idx < end) end = idx;
+				if (idx !== -1 && idx < end) {
+					end = idx;
+					foundLineStop = true;
+				}
+			}
+			if (label === "phone number") {
+				const inlineLabel = INLINE_FIELD_LABEL_STOP_RE.exec(valueText.slice(0, end));
+				if (inlineLabel) {
+					end = inlineLabel.index;
+					foundLineStop = true;
+				}
 			}
+			if (!foundLineStop) end = capAtWordBoundary(valueText, Math.min(end, MAX_TRIGGER_VALUE_LEN));
 			const rawSlice = valueText.slice(0, end);
 			const extracted = rawSlice.trim();
 			if (extracted.length === 0) return null;
@@ -3256,6 +3579,7 @@ const processTriggerMatches = (allMatches, sliceStart, sliceEnd, fullText, rules
 		const value = rawValue ? stripQuotes(rawValue) : null;
 		if (value) {
 			if (!applyValidations(value.text, rule.validations)) continue;
+			if (rule.label === "phone number" && !isPlausiblePhoneTriggerValue(value.text)) continue;
 			const entityStart = rule.includeTrigger ? match.start : value.start;
 			const entityEnd = value.end;
 			const entityText = fullText.slice(entityStart, entityEnd);
@@ -3597,7 +3921,7 @@ const normalizeHomoglyphs = (text) => {
 //#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 POSTAL_CODE_RE$1 = /\d{3}\s?\d{2}/;
 const HAS_DIGIT_RE = /\d/;
 const ADDRESS_COMPONENT_EXTRA_RE = /(?:^|\s)(?:č\.p\.|č\.ev\.|č\.|sídliště)(?=[\s,./]|$)/i;
 const BARE_COURS_PROSE_RE = /(?:^|\s)cours(?!\s+\p{Lu})(?=[\s,./]|$)/u;
@@ -3662,7 +3986,7 @@ const normalizeEntity = (entity) => {
 		text
 	};
 };
-const EMPTY_GENERIC_ROLES = /* @__PURE__ */ new Set();
+const EMPTY_GENERIC_ROLES$1 = /* @__PURE__ */ new Set();
 /**
 * Load generic-roles.json and cache the result on the
 * given context. Must be awaited during pipeline init
@@ -3686,14 +4010,14 @@ const loadGenericRoles = (ctx = defaultContext) => {
 	return ctx.genericRolesPromise;
 };
 /** Sync accessor — returns empty set before init. */
-const getGenericRoles = (ctx) => ctx.genericRoles ?? EMPTY_GENERIC_ROLES;
+const getGenericRoles = (ctx) => ctx.genericRoles ?? EMPTY_GENERIC_ROLES$1;
 const STREET_TYPES_SEED_RE = /(?:^|\s)(?:ul\.|ulice|nám\.|náměstí|tř\.|třída|nábř\.|nábřeží|bulvár)(?=[\s,./]|$)/i;
 let _streetTypesRe = STREET_TYPES_SEED_RE;
 let _streetTypesPromise = null;
 const escapeRegex$1 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 const loadStreetTypeRegex = async () => {
 	try {
-		const data = (await import("./address-street-types.mjs")).default ?? {};
+		const data = (await import("./address-street-types.mjs").then((n) => n.n)).default ?? {};
 		const words = /* @__PURE__ */ new Set();
 		for (const [key, val] of Object.entries(data)) {
 			if (key.startsWith("_")) continue;
@@ -3762,7 +4086,7 @@ const filterFalsePositives = (entities, ctx = defaultContext, fullText) => {
 		}
 		if ((normalized.label === "person" || normalized.label === "organization") && roles.has(normalizeHomoglyphs(trimmed).toLowerCase())) continue;
 		if (normalized.label === "organization" && normalized.source === "legal-form" && trimmed === trimmed.toUpperCase() && LEGAL_FORM_HEADING_RE.test(trimmed)) continue;
-		if (normalized.label === "address" && trimmed.length > 40 && !POSTAL_CODE_RE.test(trimmed) && !HAS_DIGIT_RE.test(trimmed) && !hasAddressComponent(trimmed) && !JURISDICTION_RE.test(trimmed)) continue;
+		if (normalized.label === "address" && trimmed.length > 40 && !POSTAL_CODE_RE$1.test(trimmed) && !HAS_DIGIT_RE.test(trimmed) && !hasAddressComponent(trimmed) && !JURISDICTION_RE.test(trimmed)) continue;
 		if (normalized.label === "address" && normalized.source === "trigger" && !HAS_DIGIT_RE.test(trimmed) && !hasAddressComponent(trimmed) && !JURISDICTION_RE.test(trimmed)) continue;
 		if (normalized.label === "address" && normalized.source === "trigger" && !HAS_DIGIT_RE.test(trimmed) && isOnlyAmbiguousCours(trimmed)) continue;
 		if (normalized.label === "address" && SIGNING_CLAUSE_ADDRESS_RE.test(trimmed)) continue;
@@ -3827,6 +4151,23 @@ const EMPTY_ALLOW_LIST = /* @__PURE__ */ new Set();
 /** Sync accessor — returns empty set before init. */
 const getAllowList = (ctx) => ctx.allowList ?? EMPTY_ALLOW_LIST;
 /**
+* Curated dictionary entries that are pure dotted
+* single-letter acronyms (e.g. `S.C.`, `D.N.J.`, `C.E.C.`)
+* need targeted suffix guards. The AC search matches
+* case-insensitively on token boundaries where `.` is not
+* a word character, so `S.C.` can match inside `U.S.C.`.
+* Two-segment non-address aliases are too noisy and are
+* dropped at build time; longer official aliases stay
+* searchable and are only suppressed when the source text
+* shows they are the tail of a longer dotted token.
+* Caller-supplied custom entries are exempted.
+*/
+const DOTTED_ACRONYM_RE = /^(?=.{3,}$)\p{L}(?:\.\p{L}){0,3}\.?$/u;
+const isCuratedNoiseAcronym = (normalized) => DOTTED_ACRONYM_RE.test(normalized);
+const dottedAcronymSegmentCount = (normalized) => normalized.split(".").filter(Boolean).length;
+const isShortCuratedNoiseAcronym = (normalized) => isCuratedNoiseAcronym(normalized) && dottedAcronymSegmentCount(normalized) <= 2;
+const isDottedAcronymSuffixCollision = (fullText, start, matchText) => isCuratedNoiseAcronym(matchText) && /[\p{L}]\.$/u.test(fullText.slice(Math.max(0, start - 2), start));
+/**
 * 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
@@ -3962,7 +4303,7 @@ let streetTypeReLoaded = false;
 const loadStreetTypeRe = async () => {
 	if (streetTypeReLoaded) return cachedStreetTypeRe;
 	try {
-		const config = (await import("./address-street-types.mjs")).default ?? {};
+		const config = (await import("./address-street-types.mjs").then((n) => n.n)).default ?? {};
 		const words = [];
 		for (const value of Object.values(config)) {
 			if (!Array.isArray(value)) continue;
@@ -4076,6 +4417,7 @@ const buildDenyList = async (config, ctx = defaultContext) => {
 	const addDenyListEntry = (entry, label, source = "deny-list") => {
 		const normalized = source === "custom-deny-list" ? normalizeForSearch(entry) : normalizeForSearch(entry).replace(/[|\\]/g, "");
 		if (normalized.length === 0) return;
+		if (source !== "custom-deny-list" && label !== "address" && isShortCuratedNoiseAcronym(normalized)) return;
 		const lower = normalized.toLowerCase();
 		const existing = patternIndex.get(lower);
 		if (existing !== void 0) {
@@ -4153,6 +4495,7 @@ const appendNameCorpusEntries = (config, ctx, patternList, labelList, sourceList
 	const addNameEntry = (name, source) => {
 		const normalized = normalizeForSearch(name).replace(/[|\\]/g, "");
 		if (normalized.length === 0) return;
+		if (isCuratedNoiseAcronym(normalized)) return;
 		const lower = normalized.toLowerCase();
 		const existing = patternIndex.get(lower);
 		if (existing !== void 0) {
@@ -4239,12 +4582,14 @@ const processDenyListMatches = (allMatches, sliceStart, sliceEnd, fullText, data
 		const customEdgesAreValid = customMatchHasValidEdges(fullText, match.start, match.end, pattern);
 		const customLabels = customEdgesAreValid ? customPatternLabels : [];
 		if ((!labels || labels.length === 0) && customLabels.length === 0) continue;
-		const curatedLabels = UPPER_START_RE.test(sourceChar) && !getStopwords(ctx).has(keyword) && !getAllowList(ctx).has(keyword) && !ALL_UPPER_RE.test(matchText) ? (labels ?? []).filter((label) => !customPatternLabels.includes(label) && customEdgesAreValid) : [];
-		if (curatedLabels.length === 0 && customLabels.length === 0) continue;
+		const acronymMatchesAcronym = !(pattern.length > 0 && pattern.length <= 5 && ALL_UPPER_RE.test(pattern)) || ALL_UPPER_RE.test(matchText);
+		const curatedLabels = UPPER_START_RE.test(sourceChar) && !getStopwords(ctx).has(keyword) && !getAllowList(ctx).has(keyword) && acronymMatchesAcronym && !ALL_UPPER_RE.test(matchText) ? (labels ?? []).filter((label) => !customPatternLabels.includes(label) && customEdgesAreValid) : [];
+		const filteredCuratedLabels = isDottedAcronymSuffixCollision(fullText, match.start, matchText) ? [] : curatedLabels;
+		if (filteredCuratedLabels.length === 0 && customLabels.length === 0) continue;
 		const entry = {
 			start: match.start,
 			end: match.end,
-			labels: curatedLabels,
+			labels: filteredCuratedLabels,
 			customLabels,
 			sources,
 			text: matchText,
@@ -4310,6 +4655,7 @@ const processDenyListMatches = (allMatches, sliceStart, sliceEnd, fullText, data
 		const first = chain.at(0);
 		const last = chain.at(-1);
 		if (!first || !last) continue;
+		if (isSuppressibleDefinedTermQuote(fullText, first.start, ctx)) continue;
 		const extended = extendPersonName(fullText, first.start, last.end, ctx);
 		const score = chain.length >= 2 ? .9 : .5;
 		if (chain.length === 1) {
@@ -4405,6 +4751,95 @@ const extendCityDistricts = (entities, fullText) => {
 * by a capitalized word (for "Miroslav Braňka" when
 * only "Braňka" matched).
 */
+/**
+* Defined-term marker: an opening typographic or straight
+* quote enclosing the chain start, AND a closing quote
+* within a short window followed by a
+* definitional cue (`means`, `shall mean`, `shall have
+* the meaning(s)`, `refers to`). Legal documents reserve
+* this construction for defined terms; the contents are
+* not personal names even when individual tokens collide
+* with the name corpus.
+*
+* Plain quotations like `"John Unknown" said ...` do NOT
+* count: there is no definitional cue, so the trailing
+* surname extension is still allowed to absorb `Unknown`.
+*/
+const OPENING_QUOTES = new Set([
+	"\"",
+	"'",
+	"“",
+	"„",
+	"‟",
+	"‘",
+	"‛",
+	"«"
+]);
+const CLOSING_QUOTES = new Set([
+	"\"",
+	"'",
+	"”",
+	"’",
+	"»",
+	"“"
+]);
+const DEFINED_TERM_CUE_RE = /^[\s,]*(?:means?|shall\s+means?|shall\s+have\s+the\s+meanings?|refers?\s+to|has\s+the\s+meanings?|is\s+defined)\b/iu;
+const DEFINED_TERM_LOOKAHEAD = 120;
+const DEFINED_TERM_LOOKBEHIND = 80;
+const EMPTY_GENERIC_ROLES = /* @__PURE__ */ new Set();
+const isLetter = (ch) => ch !== void 0 && /^\p{L}$/u.test(ch);
+const isApostropheInsideWord = (text, index) => isLetter(text[index - 1]) && isLetter(text[index + 1]);
+const isQuoteBoundary = (text, index) => {
+	const ch = text[index];
+	if (ch !== "'" && ch !== "’") return true;
+	return !isApostropheInsideWord(text, index);
+};
+const findDefinedTermQuoteContent = (text, start) => {
+	const min = Math.max(0, start - DEFINED_TERM_LOOKBEHIND);
+	let quoteStart = -1;
+	for (let i = start - 1; i >= min; i--) {
+		const ch = text[i];
+		if (ch === "\n") break;
+		if (ch && OPENING_QUOTES.has(ch) && isQuoteBoundary(text, i)) {
+			quoteStart = i;
+			break;
+		}
+		if (ch && CLOSING_QUOTES.has(ch) && isQuoteBoundary(text, i)) break;
+	}
+	if (quoteStart === -1) return null;
+	const max = Math.min(text.length, quoteStart + 1 + DEFINED_TERM_LOOKAHEAD);
+	for (let i = start; i < max; i++) {
+		const ch = text[i];
+		if (!ch || !CLOSING_QUOTES.has(ch) || !isQuoteBoundary(text, i)) continue;
+		const after = text.slice(i + 1, max);
+		if (!DEFINED_TERM_CUE_RE.test(after)) return null;
+		return {
+			content: text.slice(quoteStart + 1, i),
+			afterClosingQuote: after
+		};
+	}
+	return null;
+};
+const FIRST_WORD_RE = /^\p{L}+/u;
+const WORD_RE = /\p{L}+/gu;
+const startsWithKnownFirstName = (quoteContent, ctx) => {
+	const firstWord = FIRST_WORD_RE.exec(quoteContent.trim())?.[0];
+	if (!firstWord) return false;
+	return new Set(getNameCorpusFirstNames(ctx).map((name) => name.toLowerCase())).has(firstWord.toLowerCase());
+};
+const hasPersonRoleDefinition = (afterClosingQuote, ctx) => {
+	const roleWords = afterClosingQuote.replace(DEFINED_TERM_CUE_RE, "").match(WORD_RE)?.slice(0, 8) ?? [];
+	if (roleWords.length === 0) return false;
+	const genericRoles = ctx.genericRoles ?? EMPTY_GENERIC_ROLES;
+	return roleWords.some((word) => genericRoles.has(word.toLowerCase()));
+};
+const isSuppressibleDefinedTermQuote = (text, start, ctx) => {
+	const definedTermQuote = findDefinedTermQuoteContent(text, start);
+	if (definedTermQuote === null) return false;
+	const words = definedTermQuote.content.match(WORD_RE) ?? [];
+	if (words.length >= 2 && startsWithKnownFirstName(definedTermQuote.content, ctx) && hasPersonRoleDefinition(definedTermQuote.afterClosingQuote, ctx)) return false;
+	return words.length >= 2;
+};
 const extendPersonName = (text, start, end, ctx) => {
 	let newEnd = end;
 	let pos = newEnd;
@@ -4415,7 +4850,7 @@ const extendPersonName = (text, start, end, ctx) => {
 		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(/[,;.]+$/, "");
+		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;
@@ -4438,6 +4873,15 @@ const extendPersonName = (text, start, end, ctx) => {
 * cluster occasionally absorbs.
 */
 const ADDRESS_TRAILING_TRIM_RE = new RegExp(`[,;:\\s${OPENING_BRACKETS_INNER}${QUOTE_DOUBLE_INNER}${QUOTE_SINGLE_INNER}′]`, "u");
+const POSTAL_ADJACENT = `\\p{L}\\p{N}_${DASH_INNER}`;
+const POSTAL_CODE_RE = new RegExp(`(?<![${POSTAL_ADJACENT}])(?:\\d{3}\\s\\d{2}|\\d{2}${DASH}\\d{3}|\\d{5}${DASH}\\d{3}|\\d{5}${DASH}\\d{4})(?![${POSTAL_ADJACENT}])`, "gu");
+const BR_CEP_SHAPE_RE = new RegExp(`^\\d{5}${DASH}\\d{3}$`, "u");
+const US_ZIP_PLUS_FOUR_SHAPE_RE = new RegExp(`^\\d{5}${DASH}\\d{4}$`, "u");
+const US_STATE_ABBREV_BEFORE_ZIP_RE = new RegExp(`(?:^|[^A-Za-z0-9])(A[KLRZ]|C[AOT]|D[CE]|F[LM]|G[AU]|HI|I[ADLN]|K[SY]|LA|M[ADEHINOPST]|N[CDEHJMVY]|O[HKR]|P[AR]|RI|S[CD]|T[NX]|UT|V[AIT]|W[AIVY])\\s*,?\\s*$`, "u");
+const US_ZIP_CONTEXT_WINDOW = 120;
+const US_CITY_ZIP_GAP_RE = /^[\s,]+$/u;
+const HOUSE_NUMBER_BEFORE_STREET_RE = /\b\d{1,6}(?:[-/]\d{1,6})?\s+(?:\p{Lu}\p{L}+[^\S\n\t]+){0,4}$/u;
+const HOUSE_NUMBER_AFTER_STREET_RE = /^[^\S\n\t]+\d{1,6}(?:[-/]\d{1,6})?\b/u;
 let cachedBoundaryRe = null;
 const loadBoundaryWords = async () => {
 	try {
@@ -4452,7 +4896,7 @@ let cachedBrCepContextPromise = null;
 const loadBrCueWords = async () => {
 	const sources = await Promise.all([(async () => {
 		try {
-			return (await import("./address-street-types.mjs")).default["pt-br"];
+			return (await import("./address-street-types.mjs").then((n) => n.n)).default["pt-br"];
 		} catch {
 			return;
 		}
@@ -4496,6 +4940,48 @@ const hasBrCueNearby = (fullText, start, end, re) => {
 	const window = fullText.slice(windowStart, windowEnd);
 	return new RegExp(re.source, re.flags.replace("g", "")).test(window);
 };
+const getUsStateSeedBeforeZip = (fullText, start) => {
+	const stateWindowStart = Math.max(0, start - 24);
+	const stateWindow = fullText.slice(stateWindowStart, start);
+	const match = US_STATE_ABBREV_BEFORE_ZIP_RE.exec(stateWindow);
+	const state = match?.[1];
+	if (!match || !state) return null;
+	const stateOffset = match[0].indexOf(state);
+	const stateStart = stateWindowStart + match.index + stateOffset;
+	return {
+		type: "state",
+		start: stateStart,
+		end: stateStart + state.length,
+		text: state
+	};
+};
+const hasHouseNumberNearStreetWord = (fullText, seed) => {
+	if (/\d/.test(seed.text)) return true;
+	const before = fullText.slice(Math.max(0, seed.start - 50), seed.start);
+	if (HOUSE_NUMBER_BEFORE_STREET_RE.test(before)) return true;
+	const after = fullText.slice(seed.end, Math.min(fullText.length, seed.end + 24));
+	return HOUSE_NUMBER_AFTER_STREET_RE.test(after);
+};
+const getUsZipPlusFourContext = (fullText, start, seeds) => {
+	const stateSeed = getUsStateSeedBeforeZip(fullText, start);
+	if (stateSeed !== null) return {
+		stateSeed,
+		hasContext: true
+	};
+	return {
+		stateSeed: null,
+		hasContext: seeds.some((seed) => {
+			if (Math.abs(seed.start - start) > US_ZIP_CONTEXT_WINDOW) return false;
+			if (seed.type === "address-trigger") return true;
+			if (seed.type === "city" && seed.end <= start) {
+				const gap = fullText.slice(seed.end, start);
+				return US_CITY_ZIP_GAP_RE.test(gap);
+			}
+			if (seed.type === "street-word") return hasHouseNumberNearStreetWord(fullText, seed);
+			return false;
+		})
+	};
+};
 /**
 * Build regex for boundary words. Matches any
 * boundary word preceded by a word boundary.
@@ -4520,7 +5006,7 @@ const getBoundaryRe = async () => {
 const buildStreetTypePatterns = async () => {
 	let config = {};
 	try {
-		config = (await import("./address-street-types.mjs")).default;
+		config = (await import("./address-street-types.mjs").then((n) => n.n)).default;
 	} catch {
 		return [];
 	}
@@ -4565,13 +5051,22 @@ const collectSeeds = (allMatches, sliceStart, sliceEnd, fullText, existingEntiti
 			text: e.text
 		});
 	}
-	const postalRe = /\b(?:\d{3}\s\d{2}|\d{2}-\d{3}|\d{5}-\d{3})\b/g;
+	const postalRe = POSTAL_CODE_RE;
+	postalRe.lastIndex = 0;
 	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)) continue;
-		if (/^\d{5}-\d{3}$/.test(postalMatch[0]) && (brCepContextRe === null || !hasBrCueNearby(fullText, start, end, brCepContextRe))) continue;
+		if (BR_CEP_SHAPE_RE.test(postalMatch[0]) && (brCepContextRe === null || !hasBrCueNearby(fullText, start, end, brCepContextRe))) continue;
+		if (US_ZIP_PLUS_FOUR_SHAPE_RE.test(postalMatch[0])) {
+			const usContext = getUsZipPlusFourContext(fullText, start, seeds);
+			if (!usContext.hasContext) continue;
+			const stateSeed = usContext.stateSeed;
+			if (stateSeed !== null) {
+				if (!seeds.some((seed) => seed.start === stateSeed.start && seed.end === stateSeed.end)) seeds.push(stateSeed);
+			}
+		}
 		seeds.push({
 			type: "postal-code",
 			start,
@@ -4650,6 +5145,7 @@ const scoreCluster = (cluster) => {
 	let score = .5;
 	if (types.has("postal-code")) score += .15;
 	if (types.has("city")) score += .15;
+	if (types.has("state")) score += .15;
 	if (types.has("street-word")) score += .15;
 	if (types.has("address-trigger")) score += .1;
 	return Math.min(score, .95);
@@ -4836,7 +5332,44 @@ const BARE_STOPWORDS = new Set([
 	"Splatnost",
 	"Variabilní",
 	"Konstantní",
-	"Specifický"
+	"Specifický",
+	"Section",
+	"Sections",
+	"Article",
+	"Articles",
+	"Schedule",
+	"Schedules",
+	"Exhibit",
+	"Exhibits",
+	"Annex",
+	"Annexes",
+	"Appendix",
+	"Appendices",
+	"Clause",
+	"Clauses",
+	"Chapter",
+	"Chapters",
+	"Paragraph",
+	"Paragraphs",
+	"Subsection",
+	"Subsections",
+	"Form",
+	"Page",
+	"Pages",
+	"Item",
+	"Items",
+	"Note",
+	"Notes",
+	"Rule",
+	"Rules",
+	"Attachment",
+	"Attachments",
+	"Volume",
+	"Volumes",
+	"Book",
+	"Books",
+	"Part",
+	"Parts"
 ]);
 const NEAR_MISS_BAND = .15;
 const BOOST_PER_NEIGHBOUR = .05;
@@ -4909,21 +5442,23 @@ const initPrepositions = () => {
 };
 const getAddressPreps = () => _addressPreps ?? /* @__PURE__ */ new Set();
 const getTemporalPreps = () => _temporalPreps ?? /* @__PURE__ */ new Set();
-let _streetAbbrevs = null;
+const buildStreetAbbrevs = (data) => {
+	const abbrevs = /* @__PURE__ */ new Set();
+	for (const [key, words] of Object.entries(data)) {
+		if (key.startsWith("_")) continue;
+		if (!Array.isArray(words)) continue;
+		for (const word of words) if (typeof word === "string" && word.includes(".")) abbrevs.add(word.toLowerCase());
+	}
+	return abbrevs;
+};
+let _streetAbbrevs = buildStreetAbbrevs(address_street_types_default);
 let _streetAbbrevsPromise = null;
 const loadStreetAbbrevs = async () => {
 	try {
-		const mod = await import("./address-street-types.mjs");
-		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;
+		const mod = await import("./address-street-types.mjs").then((n) => n.n);
+		_streetAbbrevs = buildStreetAbbrevs(mod.default ?? mod);
 	} catch {
-		_streetAbbrevs = /* @__PURE__ */ new Set();
+		_streetAbbrevs ??= /* @__PURE__ */ new Set();
 	}
 };
 /** Ensure street abbreviation data is loaded. */
@@ -5035,7 +5570,7 @@ const detectStreetPatternsNearAddresses = (fullText, existingEntities) => {
 	}
 	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;
+const ORPHAN_STREET_RE = /^[^\S\n]*(\p{Lu}[\p{Ll}\p{Lu}]+(?:[^\S\n]+[\p{Lu}\p{Ll}][\p{Ll}]+)*[^\S\n]+\d{2,4}[a-zA-Z]?)[^\S\n]*$/gmu;
 /**
 * In the header zone (top 15%), find standalone lines
 * matching "[Uppercase word(s)] [number]" that sit
@@ -5413,6 +5948,7 @@ const hasLockedBoundary$1 = (entity) => entity.sourceDetail === "custom-deny-lis
 * of `\s` to avoid merging entities across newlines.
 */
 const GAP_PATTERN = /^[ \t,\-]+$/;
+const isLegalFormOrganization = (entity) => entity.label === "organization" && entity.source === DETECTION_SOURCES.LEGAL_FORM;
 /**
 * Build a set of word boundary offsets for the full
 * text using `Intl.Segmenter`. Returns a sorted array
@@ -5552,7 +6088,7 @@ const mergeAdjacent = (entities, fullText) => {
 				break;
 			}
 		}
-		if (!hasLockedBoundary$1(prev) && !gapOccupied && gap.length <= MAX_GAP && GAP_PATTERN.test(gap)) {
+		if (!hasLockedBoundary$1(prev) && !(isLegalFormOrganization(prev) && isLegalFormOrganization(entity) && gap.includes(",")) && !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);
@@ -5952,6 +6488,8 @@ const unmaskNerEntities = (nerEntities, maskResult, fullText) => {
 const LITERAL_SOURCES = new Set(["deny-list", "gazetteer"]);
 const isCallerOwnedEntity = (entity) => entity.sourceDetail === "custom-deny-list" || entity.sourceDetail === "custom-regex";
 const hasLockedBoundary = (entity) => isCallerOwnedEntity(entity);
+const LITERAL_BOUNDARY_PUNCT_RE = /^["“„‟‘‛'«]|["”’'»!.]$/u;
+const hasCuratedLiteralBoundary = (entity) => LITERAL_SOURCES.has(entity.source) && entity.label !== "person" && entity.sourceDetail !== "gazetteer-extension" && LITERAL_BOUNDARY_PUNCT_RE.test(entity.text);
 const shouldReplace = (a, b) => {
 	const aLen = a.end - a.start;
 	const bLen = b.end - b.start;
@@ -5967,6 +6505,31 @@ const shouldReplace = (a, b) => {
 /** Labels where colons are structurally significant. */
 const COLON_LABELS = new Set(["ip address", "mac address"]);
 /**
+* Labels whose entities should have a trailing sentence
+* `.` stripped during sanitisation. Restricted to
+* proper-noun-style labels where a final period is
+* almost always the sentence terminator that ran into
+* the capture, not a structural part of the value.
+* Numeric labels (`date`, `date of birth`, `phone
+* number`, `monetary amount`, `time`) and `person`
+* stay out — German writes `21. März`, post-nominal
+* degrees write `M.Sc.`, times write `5:00 p.m.`, and
+* stripping the dot would corrupt those spans.
+*/
+const PERIOD_STRIPPED_LABELS = new Set([
+	"organization",
+	"location",
+	"address"
+]);
+const ADDRESS_FINAL_TOKEN_RE = /(?:^|[\s,])([\p{L}\p{M}.]+\.)$/u;
+const LOCATION_FINAL_DOTTED_ABBREV_RE = /(?:^|[\s,])(?:\p{Lu}\.){2,}$/u;
+const hasKnownAddressFinalAbbrev = (text) => {
+	const finalToken = ADDRESS_FINAL_TOKEN_RE.exec(text)?.[1];
+	if (!finalToken) return false;
+	return getStreetAbbrevs().has(finalToken.toLowerCase());
+};
+const hasLocationFinalAbbrev = (text) => LOCATION_FINAL_DOTTED_ABBREV_RE.test(text);
+/**
 * Labels whose detectors emit precise, evidence-backed spans. When
 * one of these fires at the exact same offsets as a fuzzier
 * `address` hit (city dictionary lookup, address-seed cluster), the
@@ -6039,16 +6602,63 @@ const resolveSameSpanLabelConflicts = (entities) => {
 	if (dropped.size === 0) return entities;
 	return entities.filter((e) => !dropped.has(e));
 };
+/**
+* Trailing typographic punctuation that detectors
+* occasionally swallow when a capture runs to the end
+* of a sentence or quoted phrase. Stripped from every
+* non-literal, non-locked entity. Curated dictionary and
+* gazetteer entries with punctuation that is clearly part of
+* the literal (`Hello bank!`, `"Juez y parte"`) keep their
+* own boundaries. Generated/extended spans from the same
+* sources still pass through cleanup so dangling punctuation
+* does not become part of the redaction
+* (e.g. `Bond Hedge Documentation"` →
+* `Bond Hedge Documentation`).
+*
+* `)` is deliberately omitted — monetary amounts are
+* extended to include trailing "(slovy ...)" / "(in
+* words ...)" parentheticals where the closing paren
+* is structural, and stripping it would leave the open
+* paren dangling. `.` is also omitted because the
+* trailing-period rule below has label-aware handling
+* (legal-form abbreviations keep their dot).
+*/
+const TRAILING_PUNCT_CLASS = `["“”‘’'»!?]`;
+/**
+* Leading typographic punctuation that detectors
+* occasionally swallow when a capture starts at an
+* opening quote. `(` is deliberately omitted — it is
+* almost always the opening of a structural
+* parenthetical (registration number group, monetary
+* "(slovy ...)" extension) that the detector
+* intentionally captured.
+*/
+const LEADING_PUNCT_CLASS = `["“”‘’'«¿¡]`;
+const STRIP_BY_LABEL = {
+	colon: /[\s,;]+/,
+	default: /[\s:,;]+/
+};
+const LEADING_TRIM_BY_LABEL = {
+	colon: new RegExp(`^(?:\\.\\s|${STRIP_BY_LABEL.colon.source}|${LEADING_PUNCT_CLASS})+`),
+	default: new RegExp(`^(?:\\.\\s|${STRIP_BY_LABEL.default.source}|${LEADING_PUNCT_CLASS})+`)
+};
+const TRAILING_TRIM_BY_LABEL = {
+	colon: new RegExp(`(?:${STRIP_BY_LABEL.colon.source}|${TRAILING_PUNCT_CLASS})+$`),
+	default: new RegExp(`(?:${STRIP_BY_LABEL.default.source}|${TRAILING_PUNCT_CLASS})+$`)
+};
 /** Strip leading/trailing whitespace and punctuation. */
 const sanitizeEntities = (entities) => entities.flatMap((e) => {
-	if (hasLockedBoundary(e)) return [e];
-	const strip = COLON_LABELS.has(e.label) ? /[\s,;]+/ : /[\s:,;]+/;
-	const leadTrimmed = e.text.replace(/^(?:\.\s)+/, "").replace(new RegExp(`^${strip.source}`, strip.flags), "");
+	if (hasLockedBoundary(e) || hasCuratedLiteralBoundary(e)) return [e];
+	const stripKind = COLON_LABELS.has(e.label) ? "colon" : "default";
+	const leadRe = LEADING_TRIM_BY_LABEL[stripKind];
+	const trailRe = TRAILING_TRIM_BY_LABEL[stripKind];
+	const leadTrimmed = e.text.replace(leadRe, "");
 	const lead = e.text.length - leadTrimmed.length;
-	let cleaned = leadTrimmed.replace(new RegExp(`${strip.source}$`, strip.flags), "");
-	if (e.label === "organization" && cleaned.endsWith(".") && !LITERAL_SOURCES.has(e.source)) {
-		if (!getKnownLegalSuffixes().some((suffix) => cleaned.endsWith(suffix))) cleaned = cleaned.slice(0, -1).trimEnd();
+	let cleaned = leadTrimmed.replace(trailRe, "");
+	if (PERIOD_STRIPPED_LABELS.has(e.label) && cleaned.endsWith(".") && !LITERAL_SOURCES.has(e.source)) {
+		if (!(getKnownLegalSuffixes().some((suffix) => cleaned.endsWith(suffix)) || e.label === "address" && hasKnownAddressFinalAbbrev(cleaned) || e.label === "location" && hasLocationFinalAbbrev(cleaned))) cleaned = cleaned.slice(0, -1).trimEnd();
 	}
+	cleaned = cleaned.replace(trailRe, "");
 	if (cleaned.length === 0) return [];
 	if (!/[\p{L}\p{N}]/u.test(cleaned)) return [];
 	const collapsed = cleaned.replace(/\s*\n\s*/g, " ").replace(/\s{2,}/g, " ");
@@ -6105,7 +6715,7 @@ let amountWordsLoaded = false;
 const getAmountWordsRe = async () => {
 	if (amountWordsLoaded && amountWordsRe) return amountWordsRe;
 	try {
-		const alt = (await import("./amount-words.mjs")).default.patterns.flatMap((p) => p.keywords).map(escapeRegex).join("|");
+		const alt = (await import("./amount-words.mjs").then((n) => n.n)).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;