@whiteslove/parsing-lexicon 0.8.1 → 0.8.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whiteslove/parsing-lexicon",
-  "version": "0.8.1",
+  "version": "0.8.4",
   "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/central-asia-locations.js

@@ -66,7 +66,10 @@ function explicitCityFromText(text, countryCode) {
       const start = match.index || 0;
       const before = value.slice(Math.max(0, start - 40), start);
       const after = value.slice(start + match[0].length, start + match[0].length + 48);
-      if (!/(?:shahri|город|viloyati|область|andijon|андижан)/iu.test(`${before} ${after}`)) continue;
+      // Kept in sync with geography-detection.js's CITY_CONTEXT_RE breadth
+      // (shahr/шаар/город/city/viloyat/област forms) plus the Xonobod-
+      // specific Andijan-region markers this catalog also relies on.
+      if (!/(?:shahr(?:i)?|шаар(?:ы|ында|ына|ынан)?|город(?:а|е|у|ом)?|city|viloyat(?:i)?|област\p{L}{0,4}|andijon|андижан)/iu.test(`${before} ${after}`)) continue;
     }
     matches.push({ item, length: normalizeForMatch(match[0]).length });
   }

package/src/contact.js

@@ -1,4 +1,5 @@
 import { parsePhoneNumberFromString } from 'libphonenumber-js/min';
+import { moneyCurrencyPattern } from './money-core.js';
 
 // Broad phone-like detection used by other parsers for exclusion/classification.
 // It deliberately stays tolerant and does not validate against a country plan.
@@ -6,15 +7,29 @@ const PHONE_LIKE_RE = /\+?\d(?:[\t \u00a0().-]*\d){9,}/g;
 
 // Contact extraction may start from shorter national formats, but candidates are
 // only returned after libphonenumber validation.
-const PHONE_CANDIDATE_RE = /\+?\d(?:[\t \u00a0().-]*\d){6,}(?:[\t \u00a0]*(?:ext\.?|extension|x|доб\.?|дод\.?)\s*\d{1,6})?/giu;
-const PHONE_EXTENSION_RE = /[\t \u00a0]*(?:ext\.?|extension|x|доб\.?|дод\.?)\s*(\d{1,6})$/iu;
+const PHONE_EXTENSION_ALTERNATION = 'ext\\.?|extension|x|доб\\.?|дод\\.?';
+const PHONE_CANDIDATE_RE = new RegExp(`\\+?\\d(?:[\\t \\u00a0().-]*\\d){6,}(?:[\\t \\u00a0]*(?:${PHONE_EXTENSION_ALTERNATION})\\s*\\d{1,6})?`, 'giu');
+const PHONE_EXTENSION_RE = new RegExp(`[\\t \\u00a0]*(?:${PHONE_EXTENSION_ALTERNATION})\\s*(\\d{1,6})$`, 'iu');
 const DATE_LIKE_PHONE_RE = /^\d{1,2}[./-]\d{1,2}[./-](?:\d{2}|\d{4})(?:\s+\d{1,2})?$/u;
 const PRICE_LABEL_BEFORE_NUMBER_RE = /(?:цена|ціна|нарх(?:и)?|narx(?:i)?|price|стоимост[ьи]|аренд(?:а|ная\s+плата)?|rent)\s*[:=\-–—]?\s*$/iu;
+// A currency term/symbol adjacent to a hyphenated digit span is evidence of a
+// price range even without an explicit label word ("50000-60000 сум"); a bare
+// phone number never carries one. Both sides are fully bounded (unlike
+// housing-money.js's number-adjacent variant) since this only scans nearby
+// window text, not text touching the digits themselves.
+const CURRENCY_TERM_NEARBY_RE = new RegExp(`(?<![\\p{L}\\p{N}_])(?:${moneyCurrencyPattern()})(?![\\p{L}\\p{N}_])`, 'iu');
 
-const TELEGRAM_USERNAME_RE = /^[A-Za-z0-9_]{5,32}$/;
+// Real Telegram usernames must start with a letter (Telegram itself rejects
+// a digit-led one), so a digit-led "handle" like "@12345_promo" is more
+// likely an order/SKU code than a contact.
+const TELEGRAM_USERNAME_RE = /^[A-Za-z][A-Za-z0-9_]{4,31}$/;
 const TELEGRAM_LINK_RE = /(?:https?:\/\/)?(?:t\.me|telegram\.me|telegram\.dog)\/([A-Za-z0-9_]{5,32})(?:\/[0-9]+)?(?:[/?#][^\s]*)?/giu;
 const TELEGRAM_TG_RE = /tg:\/\/resolve\?[^\s]*?\bdomain=([A-Za-z0-9_]{5,32})\b[^\s]*/giu;
 const TELEGRAM_MENTION_RE = /(^|[^\p{L}\p{N}_@])@([A-Za-z0-9_]{5,32})\b/gu;
+// Reserved t.me path segments (joinchat/share/... carry no real handle) and
+// app-name mentions people write as "@Telegram"/"@WhatsApp" — neither is a
+// contactable personal username.
+const RESERVED_TELEGRAM_NAME_RE = /^(?:joinchat|share|addstickers|addtheme|addemoji|confirmphone|login|proxy|socks|iv|s|boost|giftcode|setlanguage|telegram|whatsapp|viber|instagram|facebook)$/iu;
 
 function normalizedCountryHint(value) {
   const country = String(value || '').trim().toUpperCase();
@@ -30,7 +45,10 @@ function normalizedCountryHint(value) {
 function isExplicitPriceSpan(text, start, raw) {
   if (!/[\-–—]/u.test(raw)) return false;
   const before = text.slice(Math.max(0, start - 48), start);
-  return PRICE_LABEL_BEFORE_NUMBER_RE.test(before);
+  if (PRICE_LABEL_BEFORE_NUMBER_RE.test(before)) return true;
+  const end = start + raw.length;
+  const after = text.slice(end, Math.min(text.length, end + 24));
+  return CURRENCY_TERM_NEARBY_RE.test(before) || CURRENCY_TERM_NEARBY_RE.test(after);
 }
 
 function splitPhoneExtension(raw) {
@@ -93,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);
@@ -154,7 +180,7 @@ export function normalizePhone(value, options = {}) {
 
 function telegramContact(username, raw, start, source) {
   const normalized = String(username || '').replace(/^@/, '');
-  if (!TELEGRAM_USERNAME_RE.test(normalized)) return null;
+  if (!TELEGRAM_USERNAME_RE.test(normalized) || RESERVED_TELEGRAM_NAME_RE.test(normalized)) return null;
   return Object.freeze({
     start,
     end: start + raw.length,
@@ -214,7 +240,10 @@ export function parsePrimaryContact(value) {
   }
   // Bounded like the `trailing` keyword below: "тел"/"phone" must be a whole
   // word, not a suffix of an unrelated word ("хостел", "котел").
-  const keyword = text.match(/(?<![\p{L}\p{N}_])(?:tel|тел|phone|моб|whats?app|viber|telegram|звонит|звоніть|aloqa|byla|contact)(?![\p{L}\p{N}_])[^\d+]{0,8}(\+?\d[\d\s().-]{6,}\d)/iu);
+  // Widened beyond bare stems to cover the conjugated imperative forms
+  // ('Звоните', 'Позвоните', 'Наберите', 'Дзвоніть') that are the actual
+  // everyday phrasing in CIS classifieds — the bare stems alone missed them.
+  const keyword = text.match(/(?<![\p{L}\p{N}_])(?:tel|тел|phone|моб|whats?app|viber|telegram|(?:по|пере|за)?звонит\p{L}*|(?:за|під)?дзвоніть\p{L}*|звоніть\p{L}*|наберит\p{L}*|номер\p{L}*|aloqa|byla|contact)(?![\p{L}\p{N}_])[^\d+]{0,20}(\+?\d[\d\s().-]{6,}\d)/iu);
   if (keyword) {
     const digits = keyword[1].replace(/\D/g, '');
     if (digits.length >= 9 && digits.length <= 15) return keyword[1].trim();

package/src/geography-central-asia.js

@@ -76,7 +76,10 @@ const KZ_BASE_CITIES = Object.freeze([
   entity('Karaganda', { kk: ['Қарағанды'], ru: ['Караганда'], en: ['Karaganda', 'Qaragandy'] }, { country: 'KZ' }),
   entity('Aktobe', { kk: ['Ақтөбе'], ru: ['Актобе'], en: ['Aktobe', 'Aqtobe'] }, { country: 'KZ' }),
   entity('Atyrau', { kk: ['Атырау'], ru: ['Атырау'], en: ['Atyrau'] }, { country: 'KZ' }),
-  entity('Oral', { kk: ['Орал'], ru: ['Уральск', 'Орал'], en: ['Oral', 'Uralsk'] }, { country: 'KZ' }),
+  // "Oral" is an ordinary English word ("an oral agreement"); "Уральск"/
+  // "Uralsk" are unambiguous and stay unguarded, only the short aliases need
+  // nearby city context.
+  entity('Oral', { kk: ['Орал'], ru: ['Уральск', 'Орал'], en: ['Oral', 'Uralsk'] }, { country: 'KZ', contextRequiredAliases: ['Oral', 'Орал'] }),
   entity('Taraz', { kk: ['Тараз'], ru: ['Тараз', 'Джамбул'], en: ['Taraz'] }, { country: 'KZ' }),
   entity('Pavlodar', { kk: ['Павлодар'], ru: ['Павлодар'], en: ['Pavlodar'] }, { country: 'KZ' }),
   entity('Semey', { kk: ['Семей'], ru: ['Семей', 'Семипалатинск'], en: ['Semey', 'Semipalatinsk'] }, { country: 'KZ' }),
@@ -148,7 +151,10 @@ export const KZ_CITY_ADDITIONS = Object.freeze([
   catalogCity('Kurchatov', { kk: ['Курчатов'], ru: ['Курчатов'], en: ['Kurchatov'] }, { country: 'KZ', priority: 'P4' }),
   catalogCity('Ayagoz', { kk: ['Аягөз'], ru: ['Аягоз'], en: ['Ayagoz'] }, { country: 'KZ', priority: 'P4' }),
   catalogCity('Khromtau', { kk: ['Хромтау'], ru: ['Хромтау'], en: ['Khromtau'] }, { country: 'KZ', priority: 'P4' }),
-  catalogCity('Alga', { kk: ['Алға'], ru: ['Алга'], en: ['Alga'] }, { country: 'KZ', priority: 'P4' }),
+  // "Alga" (a common Kazakh exclamation, "forward!") and "alga" (the English
+  // word for algae) collide badly in ordinary prose, with no unambiguous
+  // longer alias available.
+  catalogCity('Alga', { kk: ['Алға'], ru: ['Алга'], en: ['Alga'] }, { country: 'KZ', priority: 'P4', contextRequired: true }),
   catalogCity('Kandyagash', { kk: ['Қандыағаш'], ru: ['Кандыагаш'], en: ['Kandyagash'] }, { country: 'KZ', priority: 'P4' }),
   catalogCity('Shalkar', { kk: ['Шалқар'], ru: ['Шалкар'], en: ['Shalkar'] }, { country: 'KZ', priority: 'P4' }),
   catalogCity('Kulsary', { kk: ['Құлсары'], ru: ['Кульсары'], en: ['Kulsary'] }, { country: 'KZ', priority: 'P4' }),
@@ -160,9 +166,12 @@ export const KZ_CITY_ADDITIONS = Object.freeze([
   catalogCity('Zhitikara', { kk: ['Жітіқара'], ru: ['Житикара'], en: ['Zhitikara'] }, { country: 'KZ', priority: 'P4' }),
   catalogCity('Aksai', { kk: ['Ақсай'], ru: ['Аксай'], en: ['Aksai'] }, { country: 'KZ', priority: 'P4' }),
   catalogCity('Baikonur', { kk: ['Байқоңыр'], ru: ['Байконур'], en: ['Baikonur'] }, { country: 'KZ', priority: 'P4', type: 'special_status_city' }),
-  catalogCity('Aral', { kk: ['Арал'], ru: ['Аральск', 'Арал'], en: ['Aral', 'Aralsk'] }, { country: 'KZ', priority: 'P4' }),
+  // "Aral"/"Арал" collide with "Aral Sea" mentions; "Аральск"/"Aralsk" stay
+  // unguarded since they're unambiguous.
+  catalogCity('Aral', { kk: ['Арал'], ru: ['Аральск', 'Арал'], en: ['Aral', 'Aralsk'] }, { country: 'KZ', priority: 'P4', contextRequiredAliases: ['Aral', 'Арал'] }),
   catalogCity('Kazaly', { kk: ['Қазалы'], ru: ['Казалинск', 'Казалы'], en: ['Kazaly', 'Kazalinsk'] }, { country: 'KZ', priority: 'P4' }),
-  catalogCity('Shu', { kk: ['Шу'], ru: ['Шу'], en: ['Shu'] }, { country: 'KZ', priority: 'P4' }),
+  // "Shu" is a two-letter token with no unambiguous longer alias.
+  catalogCity('Shu', { kk: ['Шу'], ru: ['Шу'], en: ['Shu'] }, { country: 'KZ', priority: 'P4', contextRequired: true }),
   catalogCity('Karatau', { kk: ['Қаратау'], ru: ['Каратау'], en: ['Karatau'] }, { country: 'KZ', priority: 'P4' }),
   catalogCity('Zhanatas', { kk: ['Жаңатас'], ru: ['Жанатас'], en: ['Zhanatas'] }, { country: 'KZ', priority: 'P4' }),
   catalogCity('Merke', { kk: ['Мерке'], ru: ['Мерке'], en: ['Merke'] }, { country: 'KZ', priority: 'P4' }),

package/src/geography-detection.js

@@ -66,8 +66,18 @@ export function detectCountryCodeFromText(value) {
   const exact = canonicalCountryCode(text);
   if (exact) return exact;
 
-  const country = COUNTRY_MATCHERS.find(({ re }) => re.test(text))?.item;
-  if (country?.code) return country.code;
+  // Multiple countries can legitimately be mentioned in one text (e.g. a
+  // relocation ad, "from X to Y"). Prefer whichever is mentioned first
+  // rather than whichever happens to be declared first in COUNTRY_MATCHERS.
+  let earliestCountry = null;
+  let earliestStart = Infinity;
+  for (const { item, re } of COUNTRY_MATCHERS) {
+    const match = text.match(re);
+    if (!match) continue;
+    const start = match.index ?? 0;
+    if (start < earliestStart) { earliestStart = start; earliestCountry = item; }
+  }
+  if (earliestCountry?.code) return earliestCountry.code;
 
   // Keep dotted U.S. and explicit "remote US" support without treating the
   // ordinary English pronoun "us" as a geography signal.
@@ -81,10 +91,21 @@ export function detectCityFromText(value, country = null) {
   const text = String(value || '');
   if (!text) return null;
   const code = country ? canonicalCountryCode(country) : null;
-  const match = CITY_MATCHERS.find((matcher) =>
-    (!code || matcher.item.country === code) && Boolean(cityTextMatch(text, matcher)));
-  if (!match) return null;
-  return Object.freeze({ canonical: match.item.canonical, country: match.item.country || null });
+  // Prefer whichever known city is mentioned first in the text, not whichever
+  // is declared first in CITY_MATCHERS (see detectCitiesFromText, which
+  // already orders by match position — this mirrors that for the single-hit
+  // case).
+  let earliest = null;
+  let earliestStart = Infinity;
+  for (const matcher of CITY_MATCHERS) {
+    if (code && matcher.item.country !== code) continue;
+    const match = cityTextMatch(text, matcher);
+    if (!match) continue;
+    const start = match.index ?? 0;
+    if (start < earliestStart) { earliestStart = start; earliest = matcher.item; }
+  }
+  if (!earliest) return null;
+  return Object.freeze({ canonical: earliest.canonical, country: earliest.country || null });
 }
 
 /** Detect every known city in free text, ordered by first mention and deduplicated by canonical name. */

package/src/geography.js

@@ -67,7 +67,9 @@ export const KG_CITIES = Object.freeze([
   entity('Batken', { ky: ['Баткен'], ru: ['Баткен'], en: ['Batken'] }, { country: 'KG', type: 'city' }),
   entity('Kara-Balta', { ky: ['Кара-Балта', 'Кара Балта'], ru: ['Кара-Балта', 'Кара Балта'], en: ['Kara-Balta', 'Kara Balta'] }, { country: 'KG', type: 'city' }),
   entity('Balykchy', { ky: ['Балыкчы'], ru: ['Балыкчи'], en: ['Balykchy', 'Balykchi'] }, { country: 'KG', type: 'city' }),
-  entity('Kant', { ky: ['Кант'], ru: ['Кант'], en: ['Kant'] }, { country: 'KG', type: 'city' }),
+  // "Kant" collides with the philosopher's name in ordinary English prose
+  // and has no unambiguous longer alias, unlike Manas/Jalal-Abad above.
+  entity('Kant', { ky: ['Кант'], ru: ['Кант'], en: ['Kant'] }, { country: 'KG', type: 'city', contextRequired: true }),
   entity('Uzgen', { ky: ['Өзгөн', 'Озгон'], ru: ['Узген', 'Озгон'], en: ['Uzgen', 'Özgön', 'Ozgon'] }, { country: 'KG', type: 'city' }),
   entity('Kyzyl-Kiya', { ky: ['Кызыл-Кыя', 'Кызыл Кыя'], ru: ['Кызыл-Кия', 'Кызыл Кия'], en: ['Kyzyl-Kiya', 'Kyzyl Kiya'] }, { country: 'KG', type: 'city' }),
   entity('Aydarken', { ky: ['Айдаркен'], ru: ['Айдаркен', 'Хайдаркан'], en: ['Aydarken', 'Aidarken', 'Khaidarkan'] }, { country: 'KG', type: 'city' }),

package/src/hiring-ats.js

@@ -7,7 +7,11 @@ import {
 import { detectDegreeRequirement, detectHiringScopeSignals } from './hiring-semantics.js';
 import { canonicalSkillName, extractSkillNames, matchSkillCandidates } from './hiring-skills.js';
 
-const SECTION_WEIGHT = Object.freeze({ experience: 1, projects: 0.7, profile: 0.55, skills: 0.4, education: 0.35, other: 0.45 });
+// "other" is unclassified/preamble text (no recognized section heading yet).
+// It must rank below every genuine section — otherwise keyword-stuffing
+// outside any real heading would outscore the same term listed under an
+// explicit Skills section, rewarding exactly the wrong signal.
+const SECTION_WEIGHT = Object.freeze({ experience: 1, projects: 0.7, profile: 0.55, skills: 0.4, education: 0.35, other: 0.3 });
 const DEGREE_RANK = Object.freeze({ secondary: 0, bachelor: 1, master: 2, doctorate: 3 });
 const SCOPE_LABELS = Object.freeze({ architecture: 'Architecture / system design', leadership: 'Technical leadership', mentoring: 'Mentoring engineers', scale: 'Large-scale systems', ownership: 'Product / feature ownership' });
 const TERM_STOP_WORDS = new Set(['the', 'and', 'for', 'with', 'that', 'this', 'from', 'into', 'your', 'you', 'our', 'are', 'will', 'have', 'has', 'who', 'what', 'when', 'where', 'which', 'their', 'they', 'them', 'about', 'within', 'across', 'using', 'including', 'work', 'working', 'team', 'teams', 'role', 'company', 'years', 'year', 'experience', 'skills', 'skill', 'strong', 'good', 'excellent', 'ability', 'knowledge', 'looking', 'required', 'requirements', 'preferred', 'responsibilities', 'opportunity', 'candidate', 'position', 'professional', 'develop', 'development', 'build', 'building', 'software', 'engineer', 'engineering', 'help', 'support', 'ensure', 'provide', 'plus', 'nice', 'must', 'need', 'needs', 'для', 'что', 'как', 'или', 'это', 'мы', 'вы', 'ваш', 'ваша', 'ваши', 'наш', 'наша', 'наши', 'работа', 'работы', 'работать', 'опыт', 'лет', 'года', 'год', 'команда', 'команды', 'знание', 'знания', 'навыки', 'требования', 'обязанности', 'будет', 'нужно', 'необходимо', 'умение', 'разработка', 'разработки', 'позиция', 'кандидат']);

package/src/hiring-context.js

@@ -91,13 +91,28 @@ export const LOCATION_CONTEXT_TERMS = Object.freeze([
 ]);
 
 export const WORK_AUTHORIZATION_TERMS = Object.freeze([
-  group('sponsorshipOffered', { ru: ['визовая поддержка', 'спонсируем рабочую визу', 'оформляем рабочую визу'], en: ['visa sponsorship available', 'visa sponsorship provided', 'we sponsor visas', 'sponsorship available'], uk: ['візова підтримка', 'спонсоруємо робочу візу'], ro: ['sponsorizare viză', 'sponsorizare pentru viză'], uzLatn: ['viza yordami'], uzCyrl: ['виза ёрдами'], kk: ['визаға демеушілік'] }),
+  group('sponsorshipOffered', { ru: ['визовая поддержка', 'спонсируем рабочую визу', 'оформляем рабочую визу', 'виза h-1b', 'спонсорство h-1b', 'спонсорство визы h1b'], en: ['visa sponsorship available', 'visa sponsorship provided', 'we sponsor visas', 'sponsorship available', 'h-1b sponsorship', 'h1b sponsorship'], uk: ['візова підтримка', 'спонсоруємо робочу візу'], ro: ['sponsorizare viză', 'sponsorizare pentru viză'], uzLatn: ['viza yordami'], uzCyrl: ['виза ёрдами'], kk: ['визаға демеушілік'] }),
   group('noSponsorship', { ru: ['без визовой поддержки', 'визу не спонсируем', 'спонсорства визы нет'], en: ['no visa sponsorship', 'visa sponsorship is not available', 'we do not sponsor', 'unable to sponsor', 'cannot sponsor', 'no sponsorship'], uk: ['без візової підтримки', 'візу не спонсоруємо'], ro: ['fără sponsorizare pentru viză'], uzLatn: ['viza homiyligi yoq'], uzCyrl: ['виза ҳомийлиги йўқ'], kk: ['виза демеушілігі жоқ'] }),
-  group('workPermitRequired', { ru: ['разрешение на работу обязательно', 'нужно разрешение на работу'], en: ['work permit required', 'must have work authorization', 'must be authorized to work', 'right to work required'], uk: ['дозвіл на роботу обов’язковий'], ro: ['permis de muncă obligatoriu'], uzLatn: ['ishlash ruxsati kerak'], uzCyrl: ['ишлаш рухсати керак'], kk: ['жұмыс істеуге рұқсат қажет'] }),
+  // Bare "патент" is deliberately excluded: it also means an IP patent
+  // ("патентное право", "работа с патентами"), so only phrases that
+  // unambiguously mean the RF migrant work-permit document qualify.
+  group('workPermitRequired', { ru: ['разрешение на работу обязательно', 'нужно разрешение на работу', 'патент на работу', 'нужен патент', 'требуется патент', 'наличие патента', 'патент обязателен'], en: ['work permit required', 'must have work authorization', 'must be authorized to work', 'right to work required'], uk: ['дозвіл на роботу обов’язковий'], ro: ['permis de muncă obligatoriu'], uzLatn: ['ishlash ruxsati kerak'], uzCyrl: ['ишлаш рухсати керак'], kk: ['жұмыс істеуге рұқсат қажет'] }),
   group('citizenshipRequired', { ru: ['только граждане', 'гражданство обязательно'], en: ['citizenship required', 'citizens only'], uk: ['лише громадяни', 'громадянство обов’язкове'], ro: ['cetățenie obligatorie'], uzLatn: ['faqat fuqarolar'], uzCyrl: ['фақат фуқаролар'], kk: ['тек азаматтар'] }),
   group('residencePermit', { ru: ['внж', 'вид на жительство'], en: ['residence permit', 'residency permit'], uk: ['посвідка на проживання'], ro: ['permis de ședere'], uzLatn: ['yashash ruxsati'], uzCyrl: ['яшаш рухсати'], kk: ['тұруға ықтиярхат'] }),
 ]);
 
+// workAuthorization can carry several matched canonicals from the same text
+// (e.g. a posting that both restricts and offers). When a negative/restrictive
+// signal and a positive sponsorship signal co-occur, the restriction is the
+// more specific, deliberately-stated one — drop the contradictory positive.
+const CONTRADICTS_SPONSORSHIP_OFFERED = Object.freeze(['noSponsorship', 'citizenshipRequired']);
+
+function resolveWorkAuthorizationConflicts(canonicals) {
+  if (!canonicals.includes('sponsorshipOffered')) return canonicals;
+  if (!canonicals.some((item) => CONTRADICTS_SPONSORSHIP_OFFERED.includes(item))) return canonicals;
+  return canonicals.filter((item) => item !== 'sponsorshipOffered');
+}
+
 export const HIRING_AVAILABILITY_TERMS = Object.freeze([
   group('urgent', { ru: ['срочно нужен', 'срочно требуется', 'срочный набор'], en: ['urgent hire', 'hiring urgently', 'urgent opening'], uk: ['терміново потрібен'], ro: ['angajare urgentă'], uzLatn: ['zudlik bilan xodim kerak'], uzCyrl: ['зудлик билан ходим керак'], kk: ['шұғыл қызметкер керек'] }),
   group('immediateStart', { ru: ['выход завтра', 'приступить сразу', 'выход сразу'], en: ['immediate start', 'start immediately', 'asap start'], uk: ['вийти одразу', 'почати одразу'], ro: ['începere imediată'], uzLatn: ['darhol ish boshlash'], uzCyrl: ['дарҳол иш бошлаш'], kk: ['бірден бастау'] }),
@@ -400,7 +415,7 @@ export function parseHiringContext(value, { title = '', mode = null } = {}) {
     application: matchCanonicals(text, APPLICATION_TERMS),
     companyContext: matchCanonicals(text, COMPANY_TERMS),
     locationContext: matchCanonicals(text, LOCATION_CONTEXT_TERMS),
-    workAuthorization: matchCanonicals(text, WORK_AUTHORIZATION_TERMS),
+    workAuthorization: resolveWorkAuthorizationConflicts(matchCanonicals(text, WORK_AUTHORIZATION_TERMS)),
     availability: matchCanonicals(text, HIRING_AVAILABILITY_TERMS),
     travel: has(text, TRAVEL_TERMS),
     relocation: has(text, RELOCATION_CONTEXT_TERMS),

package/src/hiring-requirements.d.ts

@@ -9,6 +9,9 @@ export function detectDegreeFields(value: unknown): readonly DegreeField[];
 export function extractRequiredExperienceYears(value: unknown): number | null;
 export function hasUsWorkAuthorization(value: unknown): boolean;
 export function requiresUsSponsorship(value: unknown): boolean | null;
+// Shared with hiring-source-semantics.js's detectVisaSponsorshipWording.
+export const SPONSORSHIP_NOT_OFFERED_RE: RegExp;
+export const SPONSORSHIP_OFFERED_RE: RegExp;
 export function isNoSponsorshipRequirement(value: unknown): boolean;
 export function bucketVacancyText(value: unknown): Readonly<{ required: string; optional: string; context: string; noise: string }>;
 export function classifyCvSectionHeading(value: unknown): CvSection | null;

package/src/hiring-requirements.js

@@ -70,9 +70,37 @@ export function requiresUsSponsorship(value) {
   return null;
 }
 
+// Shared with hiring-source-semantics.js's detectVisaSponsorshipWording so the
+// negative and positive sponsorship signals cannot drift into two competing
+// implementations. SPONSORSHIP_OBJECT covers "visa support" as an alternative
+// object to "sponsorship" (not just the latter) so "We do not offer work visa
+// support" / "no work visa sponsorship provided" resolve the same way as
+// "we do not offer visa sponsorship" — the modifier group tries "work visa "
+// as a unit first and falls back (via normal regex backtracking) to "work "
+// alone so "visa support" is still available as the object.
+const SPONSORSHIP_OBJECT_MODIFIER = '(?:work\\s+visa\\s+|work\\s+|visa\\s+|immigration\\s+|employment\\s+)?';
+const SPONSORSHIP_OBJECT = '(?:sponsorship|visa\\s+support)';
+
+export const SPONSORSHIP_NOT_OFFERED_RE = new RegExp(
+  `(?:\\bno\\s+${SPONSORSHIP_OBJECT_MODIFIER}${SPONSORSHIP_OBJECT}\\b`
+  + `|\\b(?:will\\s+not|cannot|can't|unable\\s+to|not\\s+able\\s+to)\\s+sponsor\\b`
+  + `|\\b(?:does|do)\\s+not\\s+(?:offer|provide|support)\\s+(?:current\\s+or\\s+future\\s+)?${SPONSORSHIP_OBJECT_MODIFIER}${SPONSORSHIP_OBJECT}\\b`
+  + `|\\bwithout\\s+(?:the\\s+need\\s+for\\s+)?(?:(?:current\\s+(?:and\\/or|or)\\s+future|current|future)\\s+)?(?:employer\\s+|visa\\s+)?sponsorship\\b`
+  + `|\\bmust\\s+(?:be\\s+)?(?:legally\\s+)?authoriz\\w+\\s+to\\s+work[^.!?]{0,100}\\bwithout\\s+(?:current\\s+or\\s+future\\s+)?sponsorship\\b`
+  + `|\\bmust\\s+not\\s+require\\s+(?:current\\s+or\\s+future\\s+)?(?:visa\\s+|employment\\s+)?sponsorship\\b`
+  + `|\\b(?:current\\s+and\\/or\\s+future|current\\s+or\\s+future)\\s+sponsorship\\s+(?:is\\s+)?not\\s+(?:available|provided|offered)\\b`
+  + `|\\bsponsorship\\s+(?:is\\s+)?not\\s+(?:available|provided|offered)\\b`
+  + `|\\bno\\s+c2c(?:\\s+or\\s+visa\\s+sponsorship)?\\b`
+  + `|\\bmay\\s+not\\s+be\\s+able\\s+to\\b[^\\n!?]{0,450}\\b(?:sponsor|support|provide)\\b[^\\n!?]{0,180}\\bsponsorship\\b`
+  + `|\\b(?:will|can|may)\\s+not\\b[^\\n!?]{0,220}\\b(?:sponsor|support|provide)\\b[^\\n!?]{0,160}\\bsponsorship\\b`
+  + `|\\bnot\\s+(?:currently\\s+)?(?:able\\s+to\\s+)?(?:sponsor|support|provide)\\b[^\\n!?]{0,160}\\bsponsorship\\b)`,
+  'iu',
+);
+
+export const SPONSORSHIP_OFFERED_RE = /(?:\bwill\s+sponsor\b|\bwe\s+sponsor\b|\b(?:can|may)\s+sponsor\b|\bopen\s+to\s+(?:visa\s+)?sponsorship\b|\bvisa\s+sponsorship\s+(?:is\s+)?(?:available|provided|offered|possible)\b|\b(?:h-?1b|h1-b)\s+(?:visa\s+)?sponsorship\b|\bh-?1b\s+transfer\b|\bimmigration\s+sponsorship\b|\bemployment\s+visa\s+sponsorship\b|\bwork\s+visa\s+sponsorship\b|\bsponsor(?:ing)?\s+(?:qualified|eligible|selected)\s+candidates\b|\beligible\s+for\s+(?:visa\s+)?sponsorship\b|\bvisa\s+support\b|\bwork\s+visa\s+support\b)/iu;
+
 export function isNoSponsorshipRequirement(value) {
-  const text = String(value || '');
-  return /(?:\bno\s+(?:visa\s+|immigration\s+|employment\s+)?sponsorship\b|\b(?:will\s+not|cannot|can't|unable\s+to|not\s+able\s+to)\s+sponsor\b|\b(?:does|do)\s+not\s+(?:offer|provide|support)\s+(?:current\s+or\s+future\s+)?(?:visa\s+|employment\s+)?sponsorship\b|\bwithout\s+(?:the\s+need\s+for\s+)?(?:current\s+or\s+future\s+)?(?:employer\s+|visa\s+)?sponsorship\b|\bmust\s+(?:be\s+)?(?:legally\s+)?authoriz\w+\s+to\s+work[^.!?]{0,100}\bwithout\s+(?:current\s+or\s+future\s+)?sponsorship\b|\bsponsorship\s+(?:is\s+)?not\s+(?:available|provided|offered)\b|\bmay\s+not\s+be\s+able\s+to\b[^\n!?]{0,450}\b(?:sponsor|support|provide)\b[^\n!?]{0,180}\bsponsorship\b|\b(?:will|can|may)\s+not\b[^\n!?]{0,220}\b(?:sponsor|support|provide)\b[^\n!?]{0,160}\bsponsorship\b|\bnot\s+(?:currently\s+)?(?:able\s+to\s+)?(?:sponsor|support|provide)\b[^\n!?]{0,160}\bsponsorship\b)/i.test(text);
+  return SPONSORSHIP_NOT_OFFERED_RE.test(String(value || ''));
 }
 
 const REQUIRED_MARKER_RE = /\b(requirements?|qualifications?|minimum qualifications?|required skills?|must[- ]?have|you have|what (?:we|you) (?:are looking for|need|bring)|you(?:'|’)ll need|who you are|ideal candidate|what makes you a fit)\b|требован|квалификац|обязательн|необходим(?:о|ые|ый)|что мы (?:жд[её]м|ожидаем)|кого мы ищем|вимог|кваліфікац|обов['’]?язков|необхідн|кого ми шукаємо/i;

package/src/hiring-skills.js

@@ -7,7 +7,7 @@ export { escapeRegex } from './normalization.js'
 
 // These canonical labels are ordinary words or one-letter tokens. Matching the
 // label itself would create noisy results; only their explicit aliases are safe.
-const AMBIGUOUS_CANONICALS = new Set(['C', 'Go', 'Make', 'REST', 'Spring'])
+const AMBIGUOUS_CANONICALS = new Set(['C', 'Go', 'Make', 'REST', 'Spring', 'R'])
 
 const group = (category, subcategory, entries) =>
   entries.map(([name, aliases = []]) => ({
@@ -22,7 +22,7 @@ const group = (category, subcategory, entries) =>
 export const SKILL_CATALOG = [
   ...group('IT', 'Frontend', [
     ['HTML', ['html5']], ['CSS', ['css3']], ['Sass', ['scss']], ['Less', ['less css']],
-    ['JavaScript', ['ecmascript', 'es6', 'js developer', 'js framework']], ['TypeScript', ['type script']],
+    ['JavaScript', ['ecmascript', 'es6', 'js developer', 'js framework', 'js']], ['TypeScript', ['type script', 'ts']],
     ['React', ['react.js', 'reactjs']], ['React Native', ['react-native']],
     ['Vue', ['vue.js', 'vuejs']], ['Nuxt', ['nuxt.js', 'nuxtjs']],
     ['Next.js', ['nextjs', 'next js']], ['Angular', ['angular.js', 'angularjs']],
@@ -95,6 +95,7 @@ export const SKILL_CATALOG = [
   ]),
   ...group('Data', 'Analytics & AI', [
     ['Data Analysis', ['analytics', 'data analytics', 'анализ данных']], ['Business Analytics'], ['Commercial Analytics'],
+    ['R', ['r language', 'r programming', 'rstudio', 'r stats', 'tidyverse']],
     ['Pandas'], ['NumPy'], ['Jupyter'], ['Power BI', ['powerbi']], ['Tableau'], ['Looker'], ['Qlik'],
     ['Apache Spark', ['pyspark']], ['Hadoop'], ['Airflow'], ['Kafka'], ['RabbitMQ'], ['ETL'],
     ['Data Warehouse'], ['Data Science'], ['Machine Learning', ['машинное обучение']], ['Deep Learning'], ['TensorFlow'],

package/src/hiring-source-semantics.js

@@ -3,6 +3,7 @@ import { aliasesOf, escapeRegex, normalizeUnicode } from './normalization.js';
 import { parseSalary } from './money.js';
 import { extractCandidateName } from './hiring-candidate-fields.js';
 import { countryCurrency } from './country-context.js';
+import { SPONSORSHIP_NOT_OFFERED_RE, SPONSORSHIP_OFFERED_RE } from './hiring-requirements.js';
 
 const FIELD_EXTRA_ALIASES = Object.freeze({
   candidate: Object.freeze({
@@ -248,13 +249,12 @@ export function detectUsLocation(value) {
   return /\bunited states\b|\busa\b|\bu\.s\.?\b|\bUS(?:\s+remote)?\b|\b(?:AL|AK|AZ|AR|CA|CO|CT|DE|FL|GA|HI|ID|IL|IN|IA|KS|KY|LA|ME|MD|MA|MI|MN|MS|MO|MT|NE|NV|NH|NJ|NM|NY|NC|ND|OH|OK|OR|PA|RI|SC|SD|TN|TX|UT|VT|VA|WA|WV|WI|WY|DC)\b/i.test(String(value || ''));
 }
 
-const NEGATIVE_SPONSORSHIP_RE = /(?:\bno\s+(?:visa\s+|immigration\s+|employment\s+)?sponsorship\b|\b(?:will\s+not|cannot|can't|unable\s+to|not\s+able\s+to)\s+sponsor\b|\bdo(?:es)?\s+not\s+(?:offer|provide)\s+(?:visa\s+|immigration\s+|employment\s+)?sponsorship\b|\bwithout\s+(?:the\s+need\s+for\s+)?(?:(?:current\s+(?:and\/or|or)\s+future|current|future)\s+)?(?:employer\s+|visa\s+)?sponsorship\b|\bmust\s+(?:be\s+)?(?:legally\s+)?authoriz\w+\s+to\s+work[^.!?]{0,80}\bwithout\s+(?:current\s+or\s+future\s+|current\s+|future\s+)?sponsorship\b|\bmust\s+not\s+require\s+(?:current\s+or\s+future\s+|current\s+|future\s+)?(?:visa\s+|employment\s+)?sponsorship\b|\b(?:current\s+and\/or\s+future|current\s+or\s+future)\s+sponsorship\s+(?:is\s+)?not\s+(?:available|provided|offered)\b|\bsponsorship\s+(?:is\s+)?not\s+(?:available|provided|offered)\b|\bno\s+c2c(?:\s+or\s+visa\s+sponsorship)?\b|\bmay\s+not\s+be\s+able\s+to\b[^\n!?]{0,450}\b(?:sponsor|support|provide)\b[^\n!?]{0,180}\bsponsorship\b|\b(?:will|can|may)\s+not\b[^\n!?]{0,220}\b(?:support|provide)\b[^\n!?]{0,160}\bsponsorship\b|\bnot\s+(?:currently\s+)?(?:able\s+to\s+)?(?:support|provide)\b[^\n!?]{0,160}\bsponsorship\b)/iu;
-const POSITIVE_SPONSORSHIP_RE = /(?:\bwill\s+sponsor\b|\bwe\s+sponsor\b|\b(?:can|may)\s+sponsor\b|\bopen\s+to\s+(?:visa\s+)?sponsorship\b|\bvisa\s+sponsorship\s+(?:is\s+)?(?:available|provided|offered|possible)\b|\b(?:h-?1b|h1-b)\s+(?:visa\s+)?sponsorship\b|\bh-?1b\s+transfer\b|\bimmigration\s+sponsorship\b|\bemployment\s+visa\s+sponsorship\b|\bwork\s+visa\s+sponsorship\b|\bsponsor(?:ing)?\s+(?:qualified|eligible|selected)\s+candidates\b|\beligible\s+for\s+(?:visa\s+)?sponsorship\b|\bvisa\s+support\b|\bwork\s+visa\s+support\b)/iu;
-
+// The negative/positive regexes themselves live in hiring-requirements.js so
+// this detector and isNoSponsorshipRequirement() cannot drift apart.
 export function detectVisaSponsorshipWording(value) {
   const text = String(value || '');
-  if (NEGATIVE_SPONSORSHIP_RE.test(text)) return 'notOffered';
-  if (POSITIVE_SPONSORSHIP_RE.test(text)) return 'offered';
+  if (SPONSORSHIP_NOT_OFFERED_RE.test(text)) return 'notOffered';
+  if (SPONSORSHIP_OFFERED_RE.test(text)) return 'offered';
   return null;
 }
 

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;
@@ -14,6 +15,11 @@ const HOUSE_MARKER = String.raw`(?:дом|д\.|будинок|буд\.|house|h\.
 const BUILDING_MARKER = String.raw`(?:корп(?:ус)?\.?|к\.|строен(?:ие)?|стр\.|будова|секц(?:ия|ія)?|bloc|corp|building|bldg\.?|korpus|bino|bina|бино)`;
 const NUMBER_TOKEN = String.raw`\d{1,5}(?:[-\/]?[\p{L}]\d{0,4})?(?:[\/-]\d{1,4}(?:[-\/]?[\p{L}]\d{0,4})?){0,2}`;
 const STREET_WORD = String.raw`[\p{L}'’.-]{2,48}`;
+// Common post-Soviet street names lead with a bare numeral ("8 Марта",
+// "50 лет Октября"). It's only ever a prefix before the required letter
+// word(s) below, never a substitute for them, so it cannot swallow a
+// following bare house number on its own.
+const LEADING_STREET_NUMERAL = String.raw`\d{1,3}`;
 const SECONDARY_TOKEN = String.raw`(?:${NUMBER_TOKEN}|[\p{L}])`;
 const LEVEL_NUMBER_TOKEN = String.raw`\d{1,3}(?:[-–—]?(?:й|ый|ий|st|nd|rd|th))?`;
 const LEVEL_MARKER = String.raw`(?:этаж(?:е|у|ом)?|поверх(?:у|е|ом)?|floor|qavat(?:da)?|қабат(?:та)?|кават|қават|etaj(?:da|ul)?)`;
@@ -24,8 +30,13 @@ const PROPERTY_AREA_LINE_RE = /(?:^|[^\p{L}\p{N}_])(?:(?:общая|жилая|
 const NON_ADDRESS_BARE_RE = /^(?:(?:(?:перш(?:ий|ому)|перв(?:ый|ом)|друг(?:ий|ому)|втор(?:ой|ом)|трет(?:ій|ьем|ий)|\d{1,3}(?:-?й)?)\s+(?:поверх|этаж|floor|qavat|қабат))|(?:поверх|этаж|floor|qavat|қабат)(?:\s|$)|(?:район|р-н|рн|мікрорайон|микрорайон|мкр\.?|жк|ж\.к\.|жилой\s+комплекс|житловий\s+комплекс|residential\s+complex)(?:\s|$)|(?:недалеко|поруч|рядом|біля|около|возле)(?=$|[^\p{L}\p{N}_])|(?:зупинка|остановка|станція|станция)(?:\s|$))/iu;
 const DELIMITED_STREET_REJECT_RE = /(?:^|\s)(?:город|місто|city|район|р-н|рн|мікрорайон|микрорайон|мкр|жк|метро|поверх|этаж|floor|qavat|кімнат\p{L}*|комнат\p{L}*|квартира|квартири|квартиры|оренда|аренда|продаж\p{L}*|цена|ціна|площад\p{L}*|площа|зупинка|остановка|ориентир\p{L}*|ор[-–—]?р\.?)(?:\s|$)/iu;
 const LOCATION_RELATION_RE = /(?:yonida|yaqin(?:ida)?|ro['’ʻʼ`]?parasida|near(?:by)?|close\s+to|next\s+to|рядом|возле|около|недалеко|поруч|біля|lângă|aproape)/iu;
+const DESCRIPTIVE_MAHALLA_WORD_RE = /^(?:orqasidagi|yonidagi|yaqinidagi|oldidagi|ortidagi|nearby|behind|opposite)$/iu;
+// "кв." also abbreviates "квадратный" (square, as in "кв. м" / square meters).
+// A lone captured letter must not be "м"/"m" itself, or "площадь 45 кв. м"
+// would misread the area unit as an apartment number.
+const UNIT_LETTER_TOKEN = String.raw`(?!(?:м|m)(?:²|2)?(?![\p{L}\p{N}]))[\p{L}]`;
 const UNIT_COMPONENT_PATTERNS = Object.freeze([
-  String.raw`(?:^|[\s,;])(?:кв\.?|кв-ра)(?!\p{L})\s*(?:№|#)?\s*(${SECONDARY_TOKEN})(?=$|[^\p{L}\p{N}])`,
+  String.raw`(?:^|[\s,;])(?:кв\.?|кв-ра)(?!\p{L})\s*(?:№|#)?\s*(${NUMBER_TOKEN}|${UNIT_LETTER_TOKEN})(?=$|[^\p{L}\p{N}])`,
   String.raw`(?:^|[\s,;])квартира\s*(?:№|#)\s*(${SECONDARY_TOKEN})(?=$|[^\p{L}\p{N}])`,
   String.raw`(?:^|[\s,;])(?:apt\.?|ap\.?|unit)(?!\p{L})\s*(?:no\.?|nr\.?|№|#)?\s*(${SECONDARY_TOKEN})(?=$|[^\p{L}\p{N}])`,
   String.raw`(?:^|[\s,;])apartament(?:ul)?\s*(?:nr\.?|№|#)\s*(${SECONDARY_TOKEN})(?=$|[^\p{L}\p{N}])`,
@@ -73,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, 'шлях')
@@ -217,7 +233,11 @@ function tashkentGeoComponents(value) {
   const district = matchTashkentHousingDistrict(text)?.name || null;
   const metro = matchTashkentHousingMetro(text)?.name || null;
   const mahalla = text.match(/(?:^|[^\p{L}])(\p{L}[\p{L}'’ʼ-]{1,48})\s+(?:mahalla(?:si)?|маҳалла(?:си)?|махалл[ая]|mfy)(?=$|[^\p{L}])/iu)?.[1] || null;
-  return Object.freeze({ district, metro, mahalla: compactStreet(mahalla) });
+  return Object.freeze({
+    district,
+    metro,
+    mahalla: DESCRIPTIVE_MAHALLA_WORD_RE.test(mahalla || '') ? null : compactStreet(mahalla),
+  });
 }
 
 function attachGeoComponents(parsed, value) {
@@ -360,7 +380,7 @@ function splitAddressTail(raw) {
 
 function postfixTypedStreetAddress(line) {
   const suffix = line.match(new RegExp(
-    `(?:^|[^\\p{L}\\p{N}])((?:${STREET_WORD}\\s+){0,4}${STREET_WORD}\\s+${POSTFIX_STREET_TYPE})` +
+    `(?:^|[^\\p{L}\\p{N}])((?:${LEADING_STREET_NUMERAL}\\s+)?(?:${STREET_WORD}\\s+){0,4}${STREET_WORD}\\s+${POSTFIX_STREET_TYPE})` +
       `\\s*[,;]?\\s*(${NUMBER_TOKEN})` +
       `(?:\\s*[,;]?\\s*${BUILDING_MARKER}\\s*(${NUMBER_TOKEN}))?` +
       `(?=$|[^\\p{L}\\p{N}])`,
@@ -384,7 +404,7 @@ function postfixTypedStreetAddress(line) {
 function prefixTypedStreetAddress(line) {
   const prefix = line.match(new RegExp(
     `(?:^|[\\s,;])${PREFIX_STREET_MARKER}\\s+` +
-      `((?:${STREET_WORD}\\s+){0,4}${STREET_WORD})` +
+      `((?:${LEADING_STREET_NUMERAL}\\s+)?(?:${STREET_WORD}\\s+){0,4}${STREET_WORD})` +
       `\\s*[,;]?\\s*(?:${HOUSE_MARKER}\\s*)?(${NUMBER_TOKEN})` +
       `(?:\\s*[,;]?\\s*${BUILDING_MARKER}\\s*(${NUMBER_TOKEN}))?` +
       `(?=$|[^\\p{L}\\p{N}])`,
@@ -410,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))
@@ -443,7 +475,7 @@ function explicitStreetAddress(text) {
     }
 
     const boundedPrefix = line.match(new RegExp(
-      `(?:^|[\\s,;])${PREFIX_STREET_MARKER}(?!\\p{L})\\s*((?:${STREET_WORD}\\s+){0,3}${STREET_WORD})(?=$|[,;])`,
+      `(?:^|[\\s,;])${PREFIX_STREET_MARKER}(?!\\p{L})\\s*((?:${LEADING_STREET_NUMERAL}\\s+)?(?:${STREET_WORD}\\s+){0,3}${STREET_WORD})(?=$|[,;])`,
       'iu',
     ));
     if (boundedPrefix) {
@@ -499,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,
@@ -507,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) {
@@ -612,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;