@whiteslove/parsing-lexicon 0.8.2 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whiteslove/parsing-lexicon",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "Shared deterministic multilingual parsing lexicon for WhitesLove housing and hiring services",
   "repository": {
     "type": "git",
@@ -193,6 +193,10 @@
       "types": "./src/housing-money.d.ts",
       "import": "./src/housing-money.js"
     },
+    "./semantic-spans": {
+      "types": "./src/semantic-spans.d.ts",
+      "import": "./src/semantic-spans.js"
+    },
     "./hiring-professions": "./src/hiring-professions.js",
     "./hiring-profession-display": {
       "types": "./src/hiring-profession-display.d.ts",
@@ -226,7 +230,9 @@
     "node": ">=20"
   },
   "scripts": {
-    "test": "node --test"
+    "test": "node --test",
+    "sync:geo-map-data": "node ./scripts/sync-geo-map-data-lexicon.js",
+    "audit:geo-map-data": "node ./scripts/audit-geo-map-data-lexicon.js"
   },
   "publishConfig": {
     "access": "public"

package/src/contact.js

@@ -111,11 +111,19 @@ export function maskPhoneLikeSpans(value, replacement = ' ', options = {}) {
   const spans = findPhoneLikeSpans(text, options);
   if (!spans.length) return text;
 
+  // The replacement must fill the exact span length. A single-character
+  // replacement collapsing a whole multi-digit phone span down to one
+  // character silently shifts every character offset after it, which is
+  // harmless to a caller that only reads back matched substrings but
+  // corrupts any offset (start/end) computed against this masked text and
+  // later compared to the original, unmasked string.
+  const fill = String(replacement || ' ') || ' ';
   let out = '';
   let cursor = 0;
   for (const span of spans) {
     out += text.slice(cursor, span.start);
-    out += replacement;
+    const spanLength = span.end - span.start;
+    out += fill.repeat(Math.ceil(spanLength / fill.length)).slice(0, spanLength);
     cursor = span.end;
   }
   return out + text.slice(cursor);

package/src/housing-address.d.ts

@@ -71,3 +71,14 @@ export function composeHousingAddress(parts?: Readonly<{
   houseNumber?: unknown;
   building?: unknown;
 }>): string | null;
+
+export type HousingAddressCandidate = Readonly<{
+  address: string | null;
+  street: string | null;
+  houseNumber: string | null;
+  building: string | null;
+  confidence: number;
+  score: number;
+}>;
+
+export function extractHousingAddressCandidates(value: unknown): readonly HousingAddressCandidate[];

package/src/housing-address.js

@@ -4,6 +4,7 @@ import {
   matchTashkentHousingMetro,
   matchTashkentNumberedArea,
 } from './tashkent-housing-geography.js';
+import { detectNonAddressSpans } from './semantic-spans.js';
 
 const PHONE_RUN_RE = /\+?\d[\d\s().-]{7,}\d/gu;
 const ADDRESS_LABEL_RE = /(?:адрес|адреса|адресація|адресация|manzil|address|adresă|adresa)\s*[:=\-–—]\s*/iu;
@@ -83,6 +84,11 @@ function compactStreet(value) {
     // "проживания" -> "оживания").
     .replace(new RegExp(`^${PREFIX_STREET_MARKER}(?!\\p{L})\\s*`, 'iu'), '')
     .replace(new RegExp(`\\s+${POSTFIX_STREET_MARKER}$`, 'iu'), '')
+    // A generic street-word capture has no stop-word list of its own, so a
+    // trailing relation marker ("недалеко", "рядом") from prose describing
+    // a *different* nearby location can get swept into the street name
+    // itself (e.g. "ул. Первого Мая недалеко"). Trim it and anything after.
+    .replace(new RegExp(`\\s+(?:${LOCATION_RELATION_RE.source})(?:\\s+.*)?$`, 'iu'), '')
     // OCR frequently substitutes “оя” for the Ukrainian/Russian “ля” in
     // “шлях”; correct the street-token typo before canonical lookup.
     .replace(/(?<!\p{L})шоях(?!\p{L})/giu, 'шлях')
@@ -424,11 +430,23 @@ function addressCandidateLine(line) {
   const markerIndex = text.search(new RegExp(`${PREFIX_STREET_MARKER}|${POSTFIX_STREET_MARKER}`, 'iu'));
   const searchStart = markerIndex >= 0 ? markerIndex : 0;
   const tail = text.slice(searchStart);
-  const match = tail.match(ADDRESS_FIELD_STOP_RE);
-  return match ? clean(text.slice(0, searchStart + (match.index ?? 0))) : line;
-}
-
-function explicitStreetAddress(text) {
+  const stopMatch = tail.match(ADDRESS_FIELD_STOP_RE);
+  const stopAt = stopMatch ? searchStart + (stopMatch.index ?? 0) : Infinity;
+  // A money/contact/temporal span overlapping the street phrase (e.g.
+  // "99 1881919", "100$ депозит", "от 1 месяца") is at least as strong
+  // evidence that this text belongs to another domain as the local
+  // stop-word list below — reuse the shared classifier instead of growing
+  // another ad-hoc stop-word list here for every new case found. The
+  // classifier already excludes calendar-date-shaped temporal spans
+  // ("8 Марта", "9 Января" — a real Soviet-legacy street-naming
+  // convention) from its TEMPORAL results, so this stays safe for those.
+  const nonAddressSpan = detectNonAddressSpans(text)
+    .find((span) => span.start >= searchStart && span.start < stopAt);
+  const cutAt = nonAddressSpan ? Math.min(stopAt, nonAddressSpan.start) : stopAt;
+  return cutAt < Infinity ? clean(text.slice(0, cutAt)) : line;
+}
+
+function collectExplicitStreetCandidates(text) {
   const lines = text
     .split(/[\r\n|]/u)
     .map((part) => clean(part).slice(0, 1200))
@@ -513,7 +531,7 @@ function explicitStreetAddress(text) {
   // Listing text often names a nearby street before the actual postal
   // address. Keep alternatives long enough to rank component evidence rather
   // than returning whichever regex happened to run first.
-  return candidates
+  return Object.freeze(candidates
     .map((value, index) => ({
       value,
       index,
@@ -521,7 +539,27 @@ function explicitStreetAddress(text) {
         + (value.houseNumber ? 0.18 : 0)
         + (value.building ? 0.03 : 0),
     }))
-    .sort((a, b) => b.score - a.score || a.index - b.index)[0]?.value || null;
+    .sort((a, b) => b.score - a.score || a.index - b.index)
+    .map(({ value, score }) => Object.freeze({ ...value, score: Number(score.toFixed(2)) })));
+}
+
+function explicitStreetAddress(text) {
+  const { score, ...winner } = collectExplicitStreetCandidates(text)[0] || {};
+  return winner.street ? Object.freeze(winner) : null;
+}
+
+/**
+ * Expose every plausible street/house candidate found in free-form listing
+ * text, ranked by evidence score, instead of only the single winner
+ * parseHousingAddress() commits to. Useful when the caller wants to inspect
+ * or re-rank competing parses (e.g. a nearby street mentioned before the
+ * actual postal address).
+ */
+export function extractHousingAddressCandidates(value) {
+  const text = clean(value);
+  if (!text) return Object.freeze([]);
+  const addressText = stripSecondaryComponents(text) || text;
+  return collectExplicitStreetCandidates(addressText);
 }
 
 function knownStreetAddress(text, knownStreet) {
@@ -626,7 +664,15 @@ function bareAddress(text) {
   const cleaned = clean(text);
   if (!cleaned || PROPERTY_AREA_LINE_RE.test(cleaned) || NON_ADDRESS_BARE_RE.test(cleaned)) return null;
   const stopMatch = cleaned.match(ADDRESS_FIELD_STOP_RE);
-  const truncated = stopMatch ? clean(cleaned.slice(0, stopMatch.index)) : cleaned;
+  const stopAt = stopMatch ? stopMatch.index : Infinity;
+  // allowBare trusts the caller's claim that this whole field is an
+  // address, so it has no street-marker anchor to lean on the way
+  // addressCandidateLine() does — a money/contact/temporal amount is the
+  // only guard against source data that mislabels e.g. a rental-duration
+  // field ("от 1 месяца") as an address field.
+  const nonAddressSpan = detectNonAddressSpans(cleaned).find((span) => span.start < stopAt);
+  const cutAt = nonAddressSpan ? Math.min(stopAt, nonAddressSpan.start) : stopAt;
+  const truncated = cutAt < Infinity ? clean(cleaned.slice(0, cutAt)) : cleaned;
   if (!truncated) return null;
   const tail = splitAddressTail(truncated);
   if (!tail) return null;

package/src/housing-intent.d.ts

@@ -9,4 +9,12 @@ export const HOUSING_ACTION_MAP: Readonly<Record<HousingAction, Readonly<{ listi
 export function resolveHousingIntent(value: unknown): HousingIntentResult | null;
 export declare function classifyHousingDealType(value: unknown): 'sale' | 'longRent' | 'shortRent' | null;
 export declare function looksExplicitDailyRentalMention(value: unknown): boolean;
+export type HousingCommercialAdSignals = Readonly<{
+  multipleBusinessNames: boolean;
+  repeatedContactBlocks: boolean;
+  manyPriceMentions: boolean;
+  promotionalText: boolean;
+}>;
+export declare function detectHousingCommercialAdSignals(value: unknown): HousingCommercialAdSignals;
+export declare function isHousingCommercialAd(value: unknown): boolean;
 

package/src/housing-intent.js

@@ -1,5 +1,6 @@
 import { findCanonical } from './normalization.js';
 import { lexiconEntity } from './lexicon-core.js';
+import { findPhoneLikeSpans } from './contact.js';
 
 const group = (canonical, aliases, extra = {}) => lexiconEntity(canonical, aliases, extra);
 const KK_RENT_OUT_ALIASES = Object.freeze(['жалға беремін', 'жалға беріледі']);
@@ -161,3 +162,42 @@ export function looksExplicitDailyRentalMention(value) {
   return EXPLICIT_SHORT_STAY_RE.test(String(value || ''));
 }
 
+// A commercial hotel-group advertisement lists several distinct business
+// names, several unrelated phone numbers and a scattering of prices — none
+// of which cohere into one describable property the way a single owner
+// listing does. Each signal alone is common in ordinary listings (a broker
+// might list two contact numbers; a listing might mention one hotel by
+// name as a nearby landmark), so only their co-occurrence is meaningful.
+const HOTEL_BUSINESS_MARKER_RE = /(?:\bhotel\b|гостиниц\p{L}*|отел[ья]?\p{L}*|\bhostel\b|хостел\p{L}*|mehmonxona\p{L}*|guest\s*house|\bb\s*&\s*b\b|bed\s+and\s+breakfast)/giu;
+const PROMOTIONAL_MARKER_RE = /(?:скидк\p{L}*|\bакция\b|бронируйте|бронирование|звоните\s+прямо\s+сейчас|call\s+now|book\s+now|chegirma|eng\s+arzon\s+narx|лучшие\s+цены|top\s+prices|специальное\s+предложение)/iu;
+const PRICE_LIKE_RE = /\d{2,6}\s*(?:\$|usd|сум|сўм|so['’ʻʼ]?m|som|сом|тенге|kzt)/giu;
+
+/**
+ * Weak-signal evidence for a commercial/multi-property advertisement rather
+ * than a single owner's listing. Exposed separately from
+ * isHousingCommercialAd() so callers can inspect which signals fired.
+ */
+export function detectHousingCommercialAdSignals(value) {
+  const text = String(value || '');
+  const hotelNameCount = new Set((text.match(HOTEL_BUSINESS_MARKER_RE) || []).map((match) => match.toLowerCase())).size;
+  const phoneCount = findPhoneLikeSpans(text).length;
+  const priceCount = (text.match(PRICE_LIKE_RE) || []).length;
+  return Object.freeze({
+    multipleBusinessNames: hotelNameCount >= 2,
+    repeatedContactBlocks: phoneCount >= 3,
+    manyPriceMentions: priceCount >= 3,
+    promotionalText: PROMOTIONAL_MARKER_RE.test(text),
+  });
+}
+
+/**
+ * True when at least two independent weak signals of a commercial/
+ * multi-property advertisement co-occur. A single signal (one hotel name
+ * mentioned as a landmark, two phone numbers on a broker listing) is
+ * common in ordinary single-property ads and must not trigger this alone.
+ */
+export function isHousingCommercialAd(value) {
+  const signals = detectHousingCommercialAdSignals(value);
+  return Object.values(signals).filter(Boolean).length >= 2;
+}
+

package/src/housing-money.js

@@ -10,6 +10,7 @@ import {
 import { maskPhoneLikeSpans } from './contact.js';
 import { DEPOSIT_TERMS, SELLER_TERMS } from './housing.js';
 import { COUNTRIES, canonicalCountryCode, countryByCode } from './countries.js';
+import { extractTemporalCandidates } from './temporal.js';
 import {
   classifyHousingSingleMSpans,
   HOUSING_NUMERIC_SPAN_TYPES,
@@ -94,6 +95,21 @@ function parsedMoneyAmount(numberValue, scaleValue) {
 
 const APPROXIMATE_RE = /около|примерно|~|≈/iu;
 
+// A number already claimed by a duration/date/schedule reading ("на 1200
+// дней", "с 2027 года") is not a plausible bare price — it is at least as
+// likely to be that temporal value's own count/year as a price digit that
+// happens to sit near it. This is only used as a last-resort exclusion in
+// the bare-amount fallback below, once every explicit currency/scale/
+// keyword path has already failed to find a price. Only reasonably
+// confident temporal candidates disqualify a span, so an ambiguous bare
+// number elsewhere in the text is unaffected. Calls temporal.js directly
+// rather than semantic-spans.js: that module itself depends on this file's
+// extractHousingMoneyCandidates(), so importing it here would cycle back.
+function overlapsConfidentTemporalSpan(text, start, end) {
+  return extractTemporalCandidates(text).some((item) => (Number(item.confidence) || 0) >= 0.5
+    && start < item.end && item.start < end);
+}
+
 function perSquareMeterMatches(text, fallbackCurrency = '') {
   const matches = [];
   const seen = new Set();
@@ -561,6 +577,10 @@ export function parseHousingPrice(value, context = '') {
         const hasPriceEvidence = PRICE_KEYWORD_RE.test(window) || Boolean(moneyCurrencyFromText(window, ''));
         if (!hasPriceEvidence) continue;
       }
+      // A number already read as a duration/date/schedule value ("\u043D\u0430 1200
+      // \u0434\u043D\u0435\u0439") is not a plausible bare price either \u2014 e.g. "\u0441\u0434\u0430\u044E \u043D\u0430 1200
+      // \u0434\u043D\u0435\u0439" must not report 1200 as the rent.
+      if (overlapsConfidentTemporalSpan(priceText, start, start + raw.length)) continue;
       if (best == null || amount > best) best = amount;
     }
     price = best;

package/src/housing-poi-relations.js

@@ -8,10 +8,10 @@ const TYPE_MARKERS = Object.freeze([
   ['poi.kindergarten', /(?:kindergarten|childcare|bogcha|bog['’ʻʼ`]cha|детск(?:ий|ого)\s+сад|садик|балабақша)/iu],
   ['poi.hospital', /(?:hospital|shifoxona|больниц\p{L}*|госпитал\p{L}*)/iu],
   ['poi.clinic', /(?:clinic|polyclinic|medical\s+cent(?:er|re)|klinika|поликлиник\p{L}*|клиник\p{L}*|медицинск\p{L}*\s+центр)/iu],
-  ['poi.airport', /(?:airport|aeroport|аэропорт)/iu],
-  ['poi.railway_station', /(?:railway\s+station|train\s+station|railway|temir\s+yol|вокзал|ж\.?д\.?\s*вокзал|железнодорожн\p{L}*\s+вокзал)/iu],
-  ['poi.bus_station', /(?:bus\s+station|coach\s+station|автовокзал|автостанция|bus\s+terminal)/iu],
-  ['poi.parking', /(?:parking|парковк\p{L}*|паркинг|автостоянк\p{L}*)/iu],
+  ['poi.airport', /(?:airport|aeroport|аэропорт|аеропорт|әуежай)/iu],
+  ['poi.railway_station', /(?:railway\s+station|train\s+station|railway|gar[ăa]|temir\s+yo['’ʻʼ`]?l|темир\s+йўл|темір\s*жол|залізничн\p{L}*\s+вокзал|вокзал|ж\.?д\.?\s*вокзал|железнодорожн\p{L}*\s+вокзал)/iu],
+  ['poi.bus_station', /(?:bus\s+station|coach\s+station|автовокзал|автостанц\p{L}*|avtovokzal|avtostansiya|autogar[ăa]|bus\s+terminal)/iu],
+  ['poi.parking', /(?:parking|car\s+park|парковк\p{L}*|паркінг|паркуван\p{L}*|паркинг|автостоянк\p{L}*|avtoturargoh|автотұрақ|көлік\s+тұра)/iu],
   ['poi.shopping_mall', /(?:shopping\s+(?:mall|cent(?:er|re))|mall\b|т[цр]\b|savdo\s+markaz)/iu],
   ['poi.supermarket', /(?:supermarket|супермаркет|гипермаркет|магазин)/iu],
   ['poi.market', /(?:market|bazaar|bozor|базар|рынок)/iu],

package/src/housing-structured.d.ts

@@ -76,6 +76,7 @@ export type HousingStructuredResult = Readonly<{
   text: string;
   source: Readonly<{ platform: string | null; contact: string | null }>;
   intent: Readonly<{ action: string | null; listingKind: string | null; dealType: string }> | null;
+  isCommercialAd: boolean;
   context: Readonly<Record<string, unknown>>;
   rooms: number | null;
   floor: Readonly<{ floor: number | null; totalFloors: number | null }>;

package/src/housing-structured.js

@@ -5,7 +5,7 @@ import { moneyCurrencyFromText } from './money-core.js';
 import { DEPOSIT_TERMS, SELLER_TERMS, UTILITY_TERMS } from './housing.js';
 import { GENERIC_LANDMARK_TERMS } from './landmarks.js';
 import { LOCATION_RELATIONS, parseHousingContext } from './housing-context.js';
-import { resolveHousingIntent } from './housing-intent.js';
+import { isHousingCommercialAd, resolveHousingIntent } from './housing-intent.js';
 import { countryCurrency, countryPhoneHint } from './country-context.js';
 import { findTelegramContacts, maskPhoneLikeSpans, parsePhoneNumbers } from './contact.js';
 import { parseHousingAddress } from './housing-address.js';
@@ -425,6 +425,12 @@ export function parseHousingStructured(value, options = {}) {
     ? deepFreeze({ ...parsedPayments, utilities: null })
     : parsedPayments;
   const numericOptions = { country, dealType: effectiveDealType };
+  // A commercial/multi-property advertisement (hotel group, several
+  // listed businesses) has no single coherent address or price to extract
+  // — whichever one a naive parse picked would be arbitrary and misleading
+  // rather than downranked-but-plausible. Suppress both instead of
+  // returning a confident-looking but meaningless single value.
+  const isCommercialAd = isHousingCommercialAd(text);
 
   return deepFreeze({
     text,
@@ -433,20 +439,25 @@ export function parseHousingStructured(value, options = {}) {
       contact: sourcePost.contact,
     },
     intent,
+    isCommercialAd,
     context: parseHousingContext(text),
     rooms: parseHousingRoomCount(text),
     floor: parseHousingFloor(text),
     area: parseHousingAreas(text, numericOptions),
-    price: parseHousingPrice(text, {
-      country,
-      currency: fallbackCurrency,
-      dealType: effectiveDealType,
-    }),
-    address: parseHousingAddress(text, {
-      knownStreet: options.knownStreet || null,
-      allowDelimitedBare: options.allowDelimitedBareAddress === true,
-      allowBare: options.allowBareAddress === true,
-    }),
+    price: isCommercialAd
+      ? deepFreeze({ amount: null, currency: fallbackCurrency, approximate: false })
+      : parseHousingPrice(text, {
+        country,
+        currency: fallbackCurrency,
+        dealType: effectiveDealType,
+      }),
+    address: isCommercialAd
+      ? deepFreeze({ address: null, street: null, houseNumber: null, building: null, confidence: 0 })
+      : parseHousingAddress(text, {
+        knownStreet: options.knownStreet || null,
+        allowDelimitedBare: options.allowDelimitedBareAddress === true,
+        allowBare: options.allowBareAddress === true,
+      }),
     residentialComplex: parseHousingResidentialComplex(text),
     amenities: parseHousingAmenities(text),
     listingFields,

package/src/landmarks.js

@@ -25,4 +25,6 @@ export const GENERIC_LANDMARK_TERMS = Object.freeze([
   group('Church', { ru: ['церковь', 'храм'], en: ['church', 'cathedral'], uk: ['церква', 'храм', 'собор'], ro: ['biserică', 'biserica', 'catedrală', 'catedrala'], uzLatn: ['cherkov', 'ibodatxona'], uzCyrl: ['черков'], kk: ['шіркеу', 'собор'] }),
   group('Railway station', { ru: ['вокзал', 'железнодорожный вокзал'], en: ['railway station', 'train station'], uk: ['вокзал', 'залізничний вокзал'], ro: ['gară', 'gara', 'gară feroviară', 'gara feroviara'], uzLatn: ['vokzal', 'temir yol vokzali', "temir yo'l vokzali"], uzCyrl: ['вокзал', 'темир йўл вокзали'], kk: ['теміржол вокзалы', 'вокзал'] }),
   group('Airport', { ru: ['аэропорт'], en: ['airport'], uk: ['аеропорт'], ro: ['aeroport'], uzLatn: ['aeroport'], uzCyrl: ['аэропорт'], kk: ['әуежай', 'аэропорт'] }),
+  group('Bus station', { ru: ['автовокзал', 'автостанция'], en: ['bus station', 'bus terminal', 'coach station'], uk: ['автовокзал', 'автостанція'], ro: ['autogară', 'autogara', 'stație de autobuz', 'statie de autobuz'], uzLatn: ['avtovokzal', 'avtostansiya', 'avtobus vokzali'], uzCyrl: ['автовокзал', 'автостанция', 'автобус вокзали'], kk: ['автовокзал', 'автостанция', 'автобус вокзалы'] }),
+  group('Parking', { ru: ['парковка', 'паркинг', 'автостоянка'], en: ['parking', 'car park', 'parking lot'], uk: ['парковка', 'паркінг', 'автостоянка'], ro: ['parcare', 'loc de parcare'], uzLatn: ['parking', 'avtoturargoh', 'mashina turargohi'], uzCyrl: ['паркинг', 'автотураргоҳ', 'машина тураргоҳи'], kk: ['тұрақ', 'автотұрақ', 'көлік тұрағы'] }),
 ]);

package/src/location-data.js

@@ -177,6 +177,11 @@ export const LOCATION_DICTIONARIES = Object.freeze({
         ['Gara de Nord', 'București Nord', 'Северный вокзал Бухареста'], ['Piața Romană', 'Piata Romana'], ['Piața Victoriei', 'Piata Victoriei'],
       ]),
     }),
+    Otopeni: Object.freeze({
+      landmarks: entries([
+        ['Bucharest Henri Coandă International Airport', 'Henri Coandă Airport', 'Henri Coanda Airport', 'Otopeni Airport', 'Aeroportul Internațional Henri Coandă', 'Aeroportul Otopeni', 'Аэропорт Отопень', 'OTP', 'LROP'],
+      ]),
+    }),
     Brasov: Object.freeze({
       microdistricts: entries([
         ['Tractorul'], ['Coresi'], ['Astra'], ['Racadau', 'Răcădău'], ['Bartolomeu'], ['Noua'], ['Darste', 'Dârste'], ['Schei', 'Șchei'],

package/src/locations.js

@@ -10,6 +10,7 @@ import { mergeLocationCountries } from './location-merge.js';
 import { aliasesToRegex } from './normalization.js';
 import { KZ_LOCATION_EXTENSIONS } from './kz-location-extensions.js';
 import { UZ_LOCATION_EXTENSIONS } from './uz-location-extensions.js';
+import { UZ_MAP_DATA_LOCATION_EXTENSIONS } from './uz-map-data-location-extensions.js';
 import { UA_MAJOR_LOCATION_EXTENSIONS } from './ua-location-extensions-major.js';
 import { UA_REGIONAL_LOCATION_EXTENSIONS } from './ua-location-extensions-regional.js';
 import { UA_SECONDARY_LOCATION_EXTENSIONS } from './ua-secondary-cities.js';
@@ -606,9 +607,72 @@ function normalizeUaSemanticLocations(country) {
   });
 }
 
+// UZ_MAP_DATA_LOCATION_EXTENSIONS is bulk auto-imported/transliterated data.
+// mergeLocationEntries() only dedupes entries that share the exact same
+// canonical `name`, so a handful of its entries create a second, competing
+// entity for a real street that already has a reviewed canonical under a
+// different (often English) name — one that already lists the map-data
+// entry's own transliteration as an alias. Whichever of the two entries a
+// lookup happens to match first then wins by array position, which is
+// fragile and can surface the auto-transliterated name instead of the
+// reviewed one.
+//
+// Exclude each known duplicate by city + canonical name rather than
+// changing the shared merge algorithm: a generic alias-overlap merge (and
+// a generic "drop any map-data entry whose canonical exactly matches an
+// existing alias anywhere in the reviewed data") were both tried and
+// reverted, since either one also affected genuinely distinct entries that
+// happen to share one incidental alias elsewhere in this large dataset —
+// this hand-verified list only touches the specific streets confirmed to
+// be pure duplicates.
+const UZ_MAP_DATA_KNOWN_DUPLICATES = Object.freeze({
+  // Duplicates the reviewed "Shimoliy Olmazor Street" (merged later, in
+  // locations-runtime.js's UZ_TASHKENT_REVIEWED_STREET_EXTENSIONS), which
+  // already lists this exact transliteration as an alias.
+  Tashkent: new Set(["Shimoliy Olmazor ko'chasi"]),
+  // Duplicates the reviewed "University Boulevard", "Gagarin Street",
+  // "Spitamen Avenue", "Rudakiy Street" and "Mirzo Ulugbek Street"
+  // (uz-samarkand-context-extensions.js).
+  Samarkand: new Set([
+    'Universitet bulvari',
+    "Gagarin ko'chasi",
+    "Spitamen shoh ko'chasi",
+    "Rudakiy ko'chasi",
+    "Mirzo Ulug'bek ko'chasi",
+  ]),
+  // Duplicates the reviewed "Amir Temur Street" and "Bunyodkor Street"
+  // (uz-location-extensions.js).
+  Angren: new Set(["Amir Temur ko'chasi", "Bunyodkor ko'chasi"]),
+});
+
+// A bare number ("2", "5", "9") is never a legitimate standalone street/POI
+// name on its own — these are OSM import artifacts (a house number or
+// building tag mistakenly carried through as the object's name) that
+// otherwise resolve as a "street" matching any bare house-number-shaped
+// text (e.g. the "5" in "..., дом 5"). Unlike the named-duplicate cases
+// above, this is safe to apply everywhere rather than per city: a real
+// street/POI canonical is never purely numeric.
+const BARE_NUMERIC_NAME_RE = /^\d+$/u;
+
+function withoutKnownMapDataDuplicates(extensions) {
+  return Object.freeze(Object.fromEntries(Object.entries(extensions).map(([city, data]) => {
+    const excluded = UZ_MAP_DATA_KNOWN_DUPLICATES[city];
+    return [city, Object.freeze(Object.fromEntries(Object.entries(data).map(([key, entries]) => [
+      key,
+      Array.isArray(entries)
+        ? Object.freeze(entries.filter((entry) => !BARE_NUMERIC_NAME_RE.test(String(entry?.name ?? '').trim())
+          && !(excluded && excluded.has(entry?.name))))
+        : entries,
+    ])))];
+  })));
+}
+
+const UZ_MAP_DATA_LOCATION_EXTENSIONS_CURATED = withoutKnownMapDataDuplicates(UZ_MAP_DATA_LOCATION_EXTENSIONS);
+
 const UZ_LOCATION_DICTIONARIES = normalizeUzSemanticLocations(mergeLocationCountries(
   UZ_BASE_LOCATION_DICTIONARIES,
   UZ_LOCATION_EXTENSIONS,
+  UZ_MAP_DATA_LOCATION_EXTENSIONS_CURATED,
 ));
 
 const UA_SEMANTIC_LOCATION_EXTENSIONS = normalizeUaSemanticLocations(UA_MAJOR_LOCATION_EXTENSIONS);
@@ -642,4 +706,4 @@ export {
   UA_SECONDARY_CITIES,
   matchUkraineRegion,
   matchUkraineSecondaryCity,
-};
+};

package/src/semantic-spans.d.ts

@@ -0,0 +1,19 @@
+export type NonAddressSpanType = 'contact' | 'money' | 'temporal';
+
+export const NON_ADDRESS_SPAN_TYPE: Readonly<{
+  CONTACT: 'contact';
+  MONEY: 'money';
+  TEMPORAL: 'temporal';
+}>;
+
+export type NonAddressSpan = Readonly<{
+  type: NonAddressSpanType;
+  start: number;
+  end: number;
+}>;
+
+export function detectNonAddressSpans(
+  value: unknown,
+  context?: Readonly<Record<string, unknown>> & { types?: readonly NonAddressSpanType[] },
+): readonly NonAddressSpan[];
+export function overlapsAnySpan(start: number, end: number, spans: readonly NonAddressSpan[]): boolean;

package/src/semantic-spans.js

@@ -0,0 +1,83 @@
+import { findPhoneLikeSpans } from './contact.js';
+import { extractHousingMoneyCandidates } from './housing-money.js';
+import { extractTemporalCandidates } from './temporal.js';
+
+/**
+ * A shared, reusable classification of text spans that already belong to
+ * another semantic domain (money, contact, temporal) before any address/geo
+ * parsing runs. This deliberately does not reimplement money/date/contact
+ * detection — it orchestrates the existing domain extractors so a span
+ * claimed by one domain (e.g. "от 1 месяца", "99 1881919", "100$ депозит")
+ * can be recognized as NOT_ADDRESS evidence by any consumer, instead of each
+ * parser independently growing its own local guard against the same class
+ * of cross-domain contamination.
+ */
+export const NON_ADDRESS_SPAN_TYPE = Object.freeze({
+  CONTACT: 'contact',
+  MONEY: 'money',
+  TEMPORAL: 'temporal',
+});
+
+function moneySpans(text, context) {
+  // A bare unlabelled number (a plausible house number) must not be treated
+  // as money evidence — only candidates with an explicit currency marker or
+  // a recognized price keyword/scale are strong enough non-address evidence.
+  return extractHousingMoneyCandidates(text, context)
+    .filter((candidate) => candidate.explicitCurrency || candidate.priceKeyword || candidate.scale)
+    .map((candidate) => ({ type: NON_ADDRESS_SPAN_TYPE.MONEY, start: candidate.start, end: candidate.end }));
+}
+
+function contactSpans(text, context) {
+  return findPhoneLikeSpans(text, context)
+    .map((span) => ({ type: NON_ADDRESS_SPAN_TYPE.CONTACT, start: span.start, end: span.end }));
+}
+
+// Calendar dates built from a literal "<day> <month-name>" pattern
+// (temporal.calendar.month-name/month-first/month-end) are the one temporal
+// shape that collides with real street names: many Soviet-legacy streets
+// ("8 Марта", "9 Января", "1 Мая") are themselves day-plus-month-name
+// phrases. Everything else temporal.js recognizes — durations, schedules,
+// clock times, relative wording ("завтра", "через 3 дня") — has no such
+// collision risk and is safe to treat as non-address evidence.
+const CALENDAR_MONTH_NAME_PARSERS = new Set([
+  'temporal.calendar.month-name',
+  'temporal.calendar.month-first',
+  'temporal.calendar.month-end',
+]);
+
+function temporalSpans(text, context) {
+  return extractTemporalCandidates(text, context)
+    .filter((candidate) => (Number(candidate.confidence) || 0) >= 0.5 && !CALENDAR_MONTH_NAME_PARSERS.has(candidate.parser))
+    .map((candidate) => ({ type: NON_ADDRESS_SPAN_TYPE.TEMPORAL, start: candidate.start, end: candidate.end }));
+}
+
+const ALL_SPAN_TYPES = Object.freeze(Object.values(NON_ADDRESS_SPAN_TYPE));
+
+/**
+ * Detect spans in free-form listing/vacancy text that already belong to the
+ * money, contact or temporal domain. Each span carries its type, start and
+ * end offset (into the original string) so a consumer can mask or reject an
+ * overlapping candidate from an unrelated parser (typically address/geo).
+ *
+ * Pass `context.types` (an array of NON_ADDRESS_SPAN_TYPE values) to skip
+ * running the other extractors entirely — useful when a caller only cares
+ * about one domain (e.g. money/contact but not temporal, since calendar-
+ * date-shaped street names like "8 Марта" make TEMPORAL a poor address-line
+ * exclusion signal) and wants to avoid the unused extractor's cost.
+ */
+export function detectNonAddressSpans(value, context = {}) {
+  const text = String(value || '');
+  if (!text) return Object.freeze([]);
+  const types = Array.isArray(context.types) && context.types.length ? context.types : ALL_SPAN_TYPES;
+  const spans = [
+    ...(types.includes(NON_ADDRESS_SPAN_TYPE.CONTACT) ? contactSpans(text, context) : []),
+    ...(types.includes(NON_ADDRESS_SPAN_TYPE.MONEY) ? moneySpans(text, context) : []),
+    ...(types.includes(NON_ADDRESS_SPAN_TYPE.TEMPORAL) ? temporalSpans(text, context) : []),
+  ];
+  return Object.freeze(spans.sort((a, b) => a.start - b.start || a.end - b.end));
+}
+
+/** True when [start, end) overlaps any span in the given (sorted or unsorted) span list. */
+export function overlapsAnySpan(start, end, spans) {
+  return spans.some((span) => start < span.end && span.start < end);
+}