@whiteslove/parsing-lexicon 0.8.0 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whiteslove/parsing-lexicon",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Shared deterministic multilingual parsing lexicon for WhitesLove housing and hiring services",
   "repository": {
     "type": "git",

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,20 +7,50 @@ 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 TELEGRAM_USERNAME_RE = /^[A-Za-z0-9_]{5,32}$/;
+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');
+
+// 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();
   return /^[A-Z]{2}$/.test(country) ? country : undefined;
 }
 
+// PHONE_LIKE_RE deliberately accepts punctuation-separated digit sequences.
+// That also resembles a grouped monetary range such as
+// "Narxi: 950 000 - 1.000.000".  A nearby explicit price label is stronger
+// semantic evidence than the broad (unvalidated) ten-digit phone mask, so do
+// not hide that span before the money candidate parser sees it.  This does
+// not weaken validated national-phone parsing below.
+function isExplicitPriceSpan(text, start, raw) {
+  if (!/[\-–—]/u.test(raw)) return false;
+  const before = text.slice(Math.max(0, start - 48), start);
+  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) {
   const match = String(raw || '').match(PHONE_EXTENSION_RE);
   if (!match) return { base: String(raw || '').trim(), extension: null };
@@ -38,6 +69,7 @@ export function findPhoneLikeSpans(value, options = {}) {
     const digits = raw.replace(/\D/g, '');
     if (digits.length < 10) continue;
     const start = match.index ?? 0;
+    if (isExplicitPriceSpan(text, start, raw)) continue;
     spans.push(Object.freeze({
       start,
       end: start + raw.length,
@@ -140,7 +172,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,
@@ -200,7 +232,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.js

@@ -14,6 +14,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 +29,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}])`,
@@ -217,7 +227,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 +374,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 +398,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}])`,
@@ -443,7 +457,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) {

package/src/housing-listing-enrichment.d.ts

@@ -12,6 +12,8 @@ export interface HousingListingEnrichment {
   terrace?: boolean | null;
   privateYard?: boolean | null;
   dishwasher?: boolean | null;
+  refrigerator?: boolean | null;
+  washingMachine?: boolean | null;
   airConditioner?: boolean | null;
   tv?: boolean | null;
   microwave?: boolean | null;
@@ -56,6 +58,7 @@ export interface HousingListingEnrichment {
   district?: string | null;
   quarter?: { number: number; suffix: string } | null;
   metro?: string | null;
+  developmentArea?: string | null;
   residenceComplex?: string | null;
   address?: string | null;
   addressStreet?: string | null;

package/src/housing-listing-enrichment.js

@@ -12,6 +12,7 @@ import { HOUSING_LANDMARK_EXTENSIONS, HOUSING_POI_EXTENSIONS } from './housing-p
 import { resolveHousingIntent } from './housing-intent.js';
 import { extractHousingPoiRelations } from './housing-poi-relations.js';
 import { dictionaryFor } from './locations-runtime.js';
+import { matchCentralAsiaLocationEntities } from './central-asia-locations.js';
 
 const GENERIC_CATEGORY = Object.freeze({
   Park: 'park', Metro: 'metro', 'Bus stop': 'transport', 'Public transport': 'transport', 'Main road': 'transport',
@@ -32,11 +33,15 @@ const APPLIANCE_PATTERNS = Object.freeze([
 const FIRST_RENT_UZ_RE = /(?:hali\s+hech\s+kim\s+(?:yashamagan|turmagan)|ҳали\s+ҳеч\s+ким\s+(?:яшамаган|турмаган))/iu;
 const LANDLORD_PRESENT_RE = /(?:xozaykali|hojaykali|xo['’]?jaykali|с\s+хозяйк(?:ой|ой\s+в\s+квартире)|хозяйк\p{L}*\s+(?:жив[её]т|прожива\p{L}*)|with\s+(?:the\s+)?(?:landlord|owner)\s+(?:present|living\s+in)|cu\s+proprietar(?:ul)?\s+în\s+cas(?:ă|a)|үй\s*иесі\s+(?:тұрады|бірге\s+тұрады))/iu;
 const STUDENT_RE = /(?:studentlar\s+uchun|talabalar\s+uchun|студент(?:ам|ы|ок|ов)?\s+(?:можно|для)|для\s+студент|students?\s+(?:only|welcome)|for\s+students|pentru\s+studen[țt]i|studen[țt]i(?:lor)?|студенттерге|студенттер\s+үшін|(?:oila|oyla)(?:ga|lar|li)?\s+yoki\s+\d{1,2}\s+ta\s+bola(?:lar)?(?:ga)?\s+(?:ijara(?:ga)?\s+)?(?:beril|topshiril))/iu;
-const NO_BROKER_RE = /(?:bez\s+makler|maklersiz|vositachisiz|без\s+(?:маклер|посредник|риелтор|риэлтор|комисси)|no\s+(?:broker|agent|commission|agency\s+fee)|f[ăa]r[ăa]\s+(?:comision|agen[țt]ie|intermediari)|делдалсыз|комиссиясыз)/iu;
+const NO_BROKER_RE = /(?:bez\s*makler|maklersiz|vositachisiz|без\s+(?:маклер|посредник|риелтор|риэлтор|комисси)|no\s+(?:broker|agent|commission|agency\s+fee)|f[ăa]r[ăa]\s+(?:comision|agen[țt]ie|intermediari)|делдалсыз|комиссиясыз)/iu;
 const BROKER_RE = /(?:makler|vositachi|макл(?:ер[а-яё]*)?|ри[еэ]лтор[а-яё]*|агентств[а-яё]*|комисси[а-яё]*|broker|realtor|commission|comision(?:ul)?|agen[țt]ie|delda[lл]\p{L}*|делдал\p{L}*)/iu;
 const MEN_RE = /(?:o['’ʻʼ‘`]?g['’ʻʼ‘`]?il\s+bola(?:lar)?(?:ga)?|ogil\s+bola(?:lar)?(?:ga)?|sherik\s+bola|эркак(?:лар)?|erkak(?:lar)?(?:ga)?|только\s+(?:мужчин|парн)|\bmen\s+only\b|b[ăa]rba[țt]i(?:lor)?|b[ăa]ie[țt]i(?:lor)?|жігіттерге|жігіттер(?:ге)?|хлопц(?:ям|і|ів)?|чоловік(?:ам|и)?)/iu;
 const WOMEN_RE = /(?:qiz(?:lar)?(?:ga)?|ayol(?:lar)?(?:ga|ni)?|киз(?:лар)?(?:га)?|аёл(?:лар)?(?:га|ни)?|девушк\p{L}*|женщин\p{L}*|girls?\s+only|women\s+only|fete(?:lor)?|femei(?:lor)?|қыздарға|қыздар(?:ға)?|дівчат(?:ам|а|ок)?|жінк(?:ам|и)?)/iu;
 const FAMILY_RE = /(?:семь\p{L}*|family|oila(?:ga|lar|li)?|oyla(?:ga|lar|li)?|oila\s+uchun|оилага|оелага|оилавий|oelaga|famil(?:ie|ia)|cuplu(?:ri)?|отбасына|отбасылы|жанұяға|сім['’ʼ]?[яїі](?:ям|ям[иі])?|сімейн\p{L}*)/iu;
+// A category word in an exclusion clause is negative evidence, not a tenant
+// preference.  Keep this narrow and local to avoid rejecting ordinary
+// "oila uchun" / "для семьи" invitations elsewhere in the listing.
+const FAMILY_EXCLUSION_RE = /(?:oila|oyla|семь\p{L}*|family|famil(?:ie|ia)|cuplu(?:ri)?|отбас\p{L}*|жанұя\p{L}*)[^\r\n.!?]{0,48}(?:bezovta\s+qilmasin|murojaat\s+qilmasin|kerak\s+emas|qabul\s+qilinmaydi|не\s+(?:беспокоить|принимаем)|not\s+(?:allowed|welcome))/iu;
 const ROOM_SHARE_RE = /(?:sherik(?:ka|lik|likga)?|шерик(?:ка|лик)?|roommate|flatmate|подселени|койко[-\s]?мест|место\s+в\s+(?:комнат|квартир)|birga\s+yashash(?:ga)?|kvartira(?:ga|da)?[^\r\n.!?]{0,36}(?:\d+|bitta|1)\s*(?:ta\s*)?(?:qiz|ayol)[^\r\n.!?]{0,20}(?:ijarachi\s*)?(?:kerak|kere)|coleg\s+de\s+(?:apartament|camer[ăa])|bed\s+space|бөлмелес(?:\s+керек)?|көрші\s+керек)/iu;
 const AIR_CONDITIONER_RE = /(?:кондицион|air\s*con|konditsioner|kandit(?:s|c)?aner|kanditsaner|кандитсанер)/iu;
 const PER_PERSON_PRICE_RE = /(?:kishi\s+boshiga|киши\s+бошига)\s*(\d{1,3}(?:[\s.,]\d{3})*|\d+(?:[.,]\d+)?)\s*(ming|минг|million|mln|млн)?(?:dan|дан)?/iu;
@@ -152,6 +157,13 @@ function cityMetro(text, country, city) {
   return contextualCityMatches(text, country, city, 'metro', METRO_PREFIX_RE)[0]?.canonical || null;
 }
 
+function cityDevelopmentArea(text, country, city) {
+  const normalizedCountry = String(country || '').toUpperCase();
+  if (!['KZ', 'UZ'].includes(normalizedCountry) || !city) return null;
+  return matchCentralAsiaLocationEntities(text, normalizedCountry, city)
+    .matches.find((match) => match.type === 'development_area' && match.role !== 'nearby')?.name || null;
+}
+
 function contextualNearby(text, country, city, metro) {
   const shops = contextualCityMatches(text, country, city, 'landmarks', SUPERMARKET_PREFIX_RE)
     .map((match) => match.canonical);
@@ -176,7 +188,7 @@ export function parseHousingNearby(value) {
 
 export function parseHousingAudience(value) {
   const text = normalizeUnicode(value ?? '');
-  const family = FAMILY_RE.test(text);
+  const family = FAMILY_RE.test(text) && !FAMILY_EXCLUSION_RE.test(text);
   const women = WOMEN_RE.test(text);
   const men = MEN_RE.test(text);
   const students = STUDENT_RE.test(text);
@@ -284,10 +296,14 @@ export function parseHousingListingEnrichment(value, { country = '', city = '',
   const areas = parseHousingAreas(text);
   const audience = parseHousingAudience(text);
   const perPersonPrice = parseHousingPerPersonPrice(text, { country });
-  const observedAmenities = parseHousingObservedAmenities(text);
+  const observedAmenities = parseHousingObservedAmenities(text).filter((amenity) =>
+    (amenity !== 'Washing machine' || listingFields.washingMachine !== false)
+    && (amenity !== 'Refrigerator' || listingFields.refrigerator !== false),
+  );
   const quarter = matchTashkentHousingQuarter(text);
   const district = matchTashkentHousingDistrict(text)?.name || quarter?.district || null;
   const metro = matchTashkentHousingMetro(text)?.name || cityMetro(text, country, city) || null;
+  const developmentArea = cityDevelopmentArea(text, country, city);
   const primaryResidentialText = withoutNearbyLocationReferences(text);
   const parsedRc = specificResidentialComplex(primaryResidentialText)
     || matchTashkentResidentialComplex(primaryResidentialText)?.name
@@ -318,6 +334,8 @@ export function parseHousingListingEnrichment(value, { country = '', city = '',
     terrace: listingFields.terrace ?? null,
     privateYard: listingFields.privateYard ?? null,
     dishwasher: listingFields.dishwasher ?? null,
+    refrigerator: listingFields.refrigerator ?? null,
+    washingMachine: listingFields.washingMachine ?? null,
     airConditioner: listingFields.airConditioner ?? (AIR_CONDITIONER_RE.test(text) ? true : null),
     tv: listingFields.tv ?? null,
     microwave: listingFields.microwave ?? null,
@@ -361,6 +379,7 @@ export function parseHousingListingEnrichment(value, { country = '', city = '',
     district: district || null,
     quarter: quarter ? { number: quarter.number, suffix: quarter.suffix } : null,
     metro: metro || null,
+    developmentArea,
     residenceComplex: parsedRc || null,
     address: address.address,
     addressStreet: address.street,

package/src/housing-listing-fields.js

@@ -9,6 +9,28 @@ const bool = (text, positive, negative = null) => {
   return positive.test(text) ? true : null;
 };
 
+const REFRIGERATOR_RE = /(?:холодильник\p{L}*|haladelnik|xolodilnik|muzlatgich|refrigerator|fridge)/iu;
+const WASHING_MACHINE_RE = /(?:кир\s*машин\p{L}*|кирмошин\p{L}*|стиральн\p{L}*\s+машин\p{L}*|washing\s+machine|kir\s*moshina|kirmoshina|kir\s*yuvish\s+mashin\p{L}*)/iu;
+
+function listedUzbekAbsence(text, appliance) {
+  // Marketplace Uzbek frequently puts a single "yo'q" after a short,
+  // separator-free appliance list: "haladelnik kir moshina gilam yo'q".
+  // Treat it as a list-level negative only inside the local clause and never
+  // across a positive "bor" assertion or a sentence boundary.
+  const clauses = String(text || '').matchAll(/([^.!?\r\n]{0,120})\b(?:yo['’ʻʼ`]?q|йўқ)(?=$|[^\p{L}\p{N}_])/giu);
+  for (const clause of clauses) {
+    const items = clause[1] || '';
+    if (/\bbor\b|мавжуд|есть|имеется|with\b/iu.test(items)) continue;
+    if (appliance.test(items)) return true;
+  }
+  return false;
+}
+
+function applianceState(text, appliance, directNegative) {
+  if (directNegative.test(text) || listedUzbekAbsence(text, appliance)) return false;
+  return appliance.test(text) ? true : null;
+}
+
 const number = (match, min, max) => {
   const value = match ? Number(match[1]) : null;
   return Number.isFinite(value) && value >= min && value <= max ? value : null;
@@ -143,6 +165,16 @@ export function parseHousingListingFields(value, { country = '', dealType = null
   const firstRent = bool(text,
     /первая\s+(?:сдача|аренда)|впервые\s+(?:сда[её]тся|сдается|в\s+аренду)|(?:ранее|раньше|до\s+этого)\s+никто\s+не\s+жил|никто\s+(?:ранее|раньше)\s+не\s+жил|first\s+(?:rental|letting)|never\s+(?:rented|lived\s+in|occupied)/iu,
   );
+  const refrigerator = applianceState(
+    text,
+    REFRIGERATOR_RE,
+    /(?:без|нет)\s+(?:холодильник\p{L}*|haladelnik|xolodilnik|muzlatgich)|(?:холодильник\p{L}*|haladelnik|xolodilnik|muzlatgich)\s+(?:нет|yo['’ʻʼ`]?q|йўқ)|no\s+(?:refrigerator|fridge)/iu,
+  );
+  const washingMachine = applianceState(
+    text,
+    WASHING_MACHINE_RE,
+    /(?:без|нет)\s+(?:кир\s*машин\p{L}*|кирмошин\p{L}*|стиральн\p{L}*\s+машин\p{L}*|kir\s*moshina|kirmoshina)|(?:кир\s*машин\p{L}*|кирмошин\p{L}*|стиральн\p{L}*\s+машин\p{L}*|kir\s*moshina|kirmoshina)\s+(?:нет|yo['’ʻʼ`]?q|йўқ)|no\s+washing\s+machine/iu,
+  );
 
   return deepFreeze({
     bedrooms: parseBedrooms(text),
@@ -166,6 +198,8 @@ export function parseHousingListingFields(value, { country = '', dealType = null
       /посудомоечн\p{L}*|посудомойк\p{L}*|dishwasher|mașin[ăa]\s+de\s+spălat\s+vase/iu,
       /без\s+посудомоечн\p{L}*(?:\s+машин\p{L}*)?|нет\s+посудомоечн\p{L}*(?:\s+машин\p{L}*)?|посудомоечн\p{L}*(?:\s+машин\p{L}*)?\s+нет|no\s+dishwasher/iu,
     ),
+    refrigerator,
+    washingMachine,
     airConditioner: bool(
       text,
       /кондицион|сплит[- ]?систем|konditsioner|kansaner|kandisaner|klimat|air\s*con|aer\s+condi[țt]ionat/iu,

package/src/housing-money.d.ts

@@ -2,6 +2,7 @@ export type HousingPriceParseResult = Readonly<{
   amount: number | null;
   currency: string;
   approximate: boolean;
+  range?: Readonly<{ minimum: number; maximum: number }>;
 }>;
 
 export type HousingMoneyParseContext = Readonly<{
@@ -10,7 +11,7 @@ export type HousingMoneyParseContext = Readonly<{
   fallbackCurrency?: string;
   dealType?: 'sale' | 'longRent' | 'shortRent' | string | null;
 }>;
-export type HousingMoneyCandidate = Readonly<{ amount: number; currency: string; start: number; end: number; explicitCurrency: boolean; scale: string | null; priceKeyword: boolean; paymentRole: string; approximate: boolean; confidenceBoost: number; confidence: number }>;
+export type HousingMoneyCandidate = Readonly<{ amount: number; currency: string; start: number; end: number; explicitCurrency: boolean; scale: string | null; priceKeyword: boolean; range: Readonly<{ minimum: number; maximum: number }> | null; paymentRole: string; approximate: boolean; confidenceBoost: number; confidence: number }>;
 export function extractHousingMoneyCandidates(value: unknown, context?: string | HousingMoneyParseContext): readonly HousingMoneyCandidate[];
 export function rankHousingPriceCandidates(candidates: readonly HousingMoneyCandidate[]): readonly HousingMoneyCandidate[];
 

package/src/housing-money.js

@@ -199,7 +199,7 @@ export function extractHousingMoneyCandidates(value, context = '') {
   const text = maskPhoneLikeSpans(String(value || ''), ' ', { country });
   const candidates = [];
   const seen = new Set();
-  const addCandidate = ({ amount, currency, start, end, explicitCurrency, scale = null, priceKeyword = false, confidenceBoost = 0 }) => {
+  const addCandidate = ({ amount, currency, start, end, explicitCurrency, scale = null, priceKeyword = false, range = null, confidenceBoost = 0 }) => {
     if (amount == null || amount < 1 || amount > 5_000_000_000 || seen.has(`${start}:${end}`)) return;
     seen.add(`${start}:${end}`);
     candidates.push(Object.freeze({
@@ -210,6 +210,7 @@ export function extractHousingMoneyCandidates(value, context = '') {
       explicitCurrency,
       scale,
       priceKeyword,
+      range,
       paymentRole: candidatePaymentRole(text, start, end),
       approximate: APPROXIMATE_RE.test(text.slice(Math.max(0, start - 12), end)),
       confidenceBoost,
@@ -223,7 +224,7 @@ export function extractHousingMoneyCandidates(value, context = '') {
   // than two competing prices.  These must be extracted before the shorter
   // generic currency/scale candidates below.
   const expandedUzbekThousandsRe = new RegExp(
-    `${PRICE_KEYWORD}[^\\d\\r\\n]{0,16}(\\d{4})[.]000\\s*(?:с[ўу]м|so['‘’ʻʼ]?m|som|sum|uzs)(?=$|[^\\p{L}\\p{N}_])`,
+    `${PRICE_KEYWORD}[^\\d\\r\\n]{0,16}(\\d{4})(?:[.]|[\\s\\u00a0])000\\s*(?:с[ўу]м|so['‘’ʻʼ]?m|som|sum|uzs)(?=$|[^\\p{L}\\p{N}_])`,
     'igu',
   );
   for (const match of text.matchAll(expandedUzbekThousandsRe)) {
@@ -239,6 +240,38 @@ export function extractHousingMoneyCandidates(value, context = '') {
     });
   }
 
+  // A price-labelled range is common in Telegram rentals even when the author
+  // omits "sum".  In Uzbek country context, grouped endpoints are an explicit
+  // UZS signal; preserve both endpoints on the candidate while exposing the
+  // lower bound through the legacy single-price result.  It must be collected
+  // before generic amounts so the second endpoint cannot be selected merely
+  // because it is larger.
+  const labelledPriceRangeRe = new RegExp(
+    `${PRICE_KEYWORD}\\s*[:=\\-–—]?\\s*(${MONEY_NUMBER_PATTERN})\\s*(?:(${SCALE_PATTERN})(?=$|[^\\p{L}\\p{N}_]))?\\s*(?:-{1,3}|–|—|to|до|dan\\s+gacha)\\s*(${MONEY_NUMBER_PATTERN})\\s*(?:(${SCALE_PATTERN})(?=$|[^\\p{L}\\p{N}_]))?(?=$|[^\\p{L}\\p{N}_])`,
+    'igu',
+  );
+  for (const match of text.matchAll(labelledPriceRangeRe)) {
+    // A scale stated on only one endpoint applies to both: "50-60 тыс сум"
+    // means 50,000-60,000, not 50-60,000. Mirrors money.js's range parsing.
+    const firstScale = match[2] || match[4] || null;
+    const secondScale = match[4] || match[2] || null;
+    const minimum = parsedMoneyAmount(match[1], firstScale);
+    const maximum = parsedMoneyAmount(match[3], secondScale);
+    if (minimum == null || maximum == null || minimum > maximum) continue;
+    const start = match.index ?? 0;
+    addCandidate({
+      amount: minimum,
+      currency: country === 'UZ' ? 'UZS' : fallbackCurrency || '',
+      start,
+      end: start + match[0].length,
+      explicitCurrency: false,
+      scale: firstScale || secondScale || null,
+      priceKeyword: true,
+      range: Object.freeze({ minimum, maximum }),
+      confidenceBoost: 0.2,
+    });
+  }
+
   const splitMillionRe = /(?:^|[^\p{L}\p{N}_])(\d{1,3})\s*(?:млн\.?|mln\.?|миллион(?:а|ов)?|million(?:s)?)\s+(\d{1,3})(?=$|[^\p{L}\p{N}_])/giu;
   for (const match of text.matchAll(splitMillionRe)) {
     const start = match.index ?? 0;
@@ -365,11 +398,13 @@ export function parseHousingPrice(value, context = '') {
   // regional formats below remain as deterministic fallbacks until each is
   // represented by a richer candidate extractor.
   if (preferredCandidate && preferredCandidate.confidence >= 0.65) {
-    return Object.freeze({
+    const result = {
       amount: preferredCandidate.amount,
       currency: preferredCandidate.currency || fallbackCurrency || '',
       approximate: preferredCandidate.approximate,
-    });
+    };
+    if (preferredCandidate.range) result.range = preferredCandidate.range;
+    return Object.freeze(result);
   }
   let currency = moneyCurrencyFromText(priceText, fallbackCurrency || '')
     || moneyCurrencyFromText(text, fallbackCurrency || '')
@@ -408,7 +443,7 @@ export function parseHousingPrice(value, context = '') {
   // Uzbek ads also use a dot as a thousands separator after four leading
   // digits: "2500.000 сум" means 2,500,000 UZS, not 2,500 UZS.
   const expandedUzbekThousands = priceText.match(new RegExp(
-    `${PRICE_KEYWORD}[^\\d\\r\\n]{0,16}(\\d{4})[.]000\\s*(?:с[ўу]м|so['‘’ʻʼ]?m|som|sum|uzs)(?=$|[^\\p{L}\\p{N}_])`,
+    `${PRICE_KEYWORD}[^\\d\\r\\n]{0,16}(\\d{4})(?:[.]|[\\s\\u00a0])000\\s*(?:с[ўу]м|so['‘’ʻʼ]?m|som|sum|uzs)(?=$|[^\\p{L}\\p{N}_])`,
     'iu',
   ));
   if (price == null && expandedUzbekThousands) {
@@ -517,7 +552,16 @@ export function parseHousingPrice(value, context = '') {
       const digits = raw.replace(/[\s.,]/g, '');
       if (digits[0] === '0') continue;
       const amount = parseNumericAmount(raw);
-      if (amount != null && amount >= 1000 && amount <= 5_000_000_000 && (best == null || amount > best)) best = amount;
+      if (amount == null || amount < 1000 || amount > 5_000_000_000) continue;
+      // A bare 4-digit amount in this range is at least as likely to be a
+      // build year ("2022 \u0433\u043E\u0434\u0430 \u043F\u043E\u0441\u0442\u0440\u043E\u0439\u043A\u0438") as a price. Only accept it here
+      // when there's independent currency/price evidence nearby.
+      if (amount >= 1900 && amount <= 2100) {
+        const window = priceText.slice(Math.max(0, start - 40), Math.min(priceText.length, start + raw.length + 40));
+        const hasPriceEvidence = PRICE_KEYWORD_RE.test(window) || Boolean(moneyCurrencyFromText(window, ''));
+        if (!hasPriceEvidence) continue;
+      }
+      if (best == null || amount > best) best = amount;
     }
     price = best;
   }

package/src/housing-structured.js

@@ -87,7 +87,7 @@ export function parseHousingRoomCount(value) {
     if (total >= 1 && total <= 20) return total;
   }
   for (const [re, rooms] of NUMBER_WORDS) if (re.test(text)) return rooms;
-  const numeric = text.match(/(?:^|[^\p{L}\p{N}])(\d{1,2})\s*(?:(?:-\s*)?комнат\p{L}*|(?:-\s*)?к(?:\.|\b)|(?:-\s*)?xona(?:li)?|(?:-\s*)?хона(?:лик|ли)?|бөлмелі|rooms?)(?=$|[^\p{L}\p{N}])/iu);
+  const numeric = text.match(/(?:^|[^\p{L}\p{N}])(\d{1,2})\s*(?:ta\s*)?(?:(?:-\s*)?комнат\p{L}*|(?:-\s*)?к(?:\.|\b)|(?:-\s*)?xona(?:li|si|lari)?|(?:-\s*)?хона(?:лик|ли|си|лари)?|бөлмелі|rooms?)(?=$|[^\p{L}\p{N}])/iu);
   if (numeric) {
     const rooms = toNumber(numeric[1]);
     if (rooms != null && rooms >= 1 && rooms <= 20) return rooms;

package/src/tashkent-housing-geography.js

@@ -286,19 +286,27 @@ export function matchTashkentHousingMetro(value) {
   const text = String(value ?? '');
   if (!text) return null;
   for (const station of TASHKENT_METRO) {
-    const match = text.match(station.re);
-    if (!match) continue;
-    if (hasExplicitMetroContext(text, match)) return station;
+    const flags = [...new Set(`${station.re.flags.replace(/g/gu, '')}g`)].join('');
+    const matches = [...text.matchAll(new RegExp(station.re.source, flags))];
+    if (!matches.length) continue;
+    // An explicit marker must win even if an earlier bare occurrence shares a
+    // name with a district. For example, "Sergeli tumani, metro Sergeli"
+    // still refers to the station at the second occurrence.
+    if (matches.some((match) => hasExplicitMetroContext(text, match))) return station;
+    const sameNamedDistrict = hasExplicitTashkentDistrict(text, station.name);
+    for (const match of matches) {
+      if (sameNamedDistrict) continue;
     // "Toshkent" is both a metro station and the city's own name, so a bare
     // mention ("Toshkent shahri") is not evidence of the station the way a
     // bare mention of any other station name would be. Require an explicit
     // metro context for this one station specifically.
-    if (station.name === 'Toshkent') continue;
-    if (station.name === 'Qoyliq' && QOYLIQ_MASSIF_RE.test(text)) continue;
-    const areaCanonical = METRO_NUMBERED_AREA[station.name];
-    if (areaCanonical && matchTashkentNumberedArea(text, areaCanonical)) continue;
-    if (hasExplicitDistrictContext(text, match) || hasExplicitAreaContext(text, match) || hasExplicitMahallaContext(text, match) || hasExplicitLandmarkContext(text, match)) continue;
-    return station;
+      if (station.name === 'Toshkent') continue;
+      if (station.name === 'Qoyliq' && QOYLIQ_MASSIF_RE.test(text)) continue;
+      const areaCanonical = METRO_NUMBERED_AREA[station.name];
+      if (areaCanonical && matchTashkentNumberedArea(text, areaCanonical)) continue;
+      if (hasExplicitDistrictContext(text, match) || hasExplicitAreaContext(text, match) || hasExplicitMahallaContext(text, match) || hasExplicitLandmarkContext(text, match)) continue;
+      return station;
+    }
   }
   for (const [canonical, aliases] of Object.entries(EXTRA_METRO_ALIASES)) {
     const match = text.match(aliasesToRegex(aliases));

package/src/tashkent-residential-complexes.js

@@ -4,6 +4,7 @@ const AMBIGUOUS_TASHKENT_COMPLEXES = new Set([
   'Amir Temur',
   'Bodomzor',
   'City Mall',
+  'DARVOZA',
   'Darhan',
   'Pushkin',
   'Seoul Mun',

package/src/temporal.js

@@ -23,13 +23,14 @@ const DAY_ALIASES = Object.freeze({
   сб: 5, суббота: 5, субботы: 5, субота: 5, sat: 5, saturday: 5, shanba: 5, сенбі: 5, ишемби: 5, sâmbătă: 5, sambata: 5,
   вс: 6, воскресенье: 6, воскресенья: 6, неділя: 6, неділю: 6, sun: 6, sunday: 6, yakshanba: 6, жексенбі: 6, жекшемби: 6, duminică: 6, duminica: 6,
 });
-const RELATIVE_RE = /(?<![\p{L}\p{N}])(?:с\s+|з\s+|dan\s+)?(сегодня|завтра|послезавтра|сьогодні|післязавтра|bugun|ertaga|indin|бүгін|ертең|бүрсігүні|бүгүн|эртең|бүрсүгүнү|astăzi|azi|mâine|maine|poimâine|poimaine|today|tomorrow|day\s+after\s+tomorrow|через\s+(\d+|неделю|две\s+недели)\s*(?:дн(?:я|ей)?|день|недел[ьюи])?)(?![\p{L}\p{N}])/giu;
+const RELATIVE_RE = /(?<![\p{L}\p{N}])(?:с\s+|з\s+|dan\s+)?(послезавтрашн\p{L}*\s+дн\p{L}*|сегодняшн\p{L}*\s+дн\p{L}*|завтрашн\p{L}*\s+дн\p{L}*|післязавтрашн\p{L}*\s+дн\p{L}*|сьогоднішн\p{L}*\s+дн\p{L}*|сегодня|завтра|послезавтра|сьогодні|післязавтра|bugun|ertaga|indin|бүгін|ертең|бүрсігүні|бүгүн|эртең|бүрсүгүнү|astăzi|azi|mâine|maine|poimâine|poimaine|today|tomorrow|day\s+after\s+tomorrow|через\s+(\d+|неделю|две\s+недели)\s*(?:дн(?:я|ей)?|день|недел[ьюи])?)(?![\p{L}\p{N}])/giu;
 const EXTENDED_RELATIVE_RE = /(?<![\p{L}\p{N}])(?:через\s+(\d+)\s+(дні|днів|тижд(?:ень|ні|нів|ня))|peste\s+(\d+)\s+(zile?|săptămân(?:ă|i)|saptaman(?:a|i))|(\d+)\s+(күннен|аптадан|кун(?:дөн|дон)|жумадан)\s+(?:кейін|кийин))(?![\p{L}\p{N}])/giu;
 const DAY_PATTERN = Object.keys(DAY_ALIASES).sort((a, b) => b.length - a.length).join('|');
 const WEEKDAY_RANGE_RE = new RegExp(`(?<![\\p{L}\\p{N}])(${DAY_PATTERN})\\s*(?:-|–|—|до|to|по)\\s*(${DAY_PATTERN})(?![\\p{L}\\p{N}])`, 'giu');
 const NEXT_WEEKDAY_RE = new RegExp(`(?<![\\p{L}\\p{N}])(?:со?\\s+следующ(?:его|ей)\\s+|з\\s+наступн(?:ого|ої)\\s+|next\\s+)(${DAY_PATTERN})(?![\\p{L}\\p{N}])`, 'giu');
 const END_OF_MONTH_RE = new RegExp(`(?<![\\p{L}\\p{N}])(?:до|until|p[âa]nă\\s+la|gacha|дейін|чейин|available\\s+until)\\s+(?:конца|кінця|sf[âa]rșit(?:ul)?(?:\\s+lunii)?|end\\s+of)\\s+(${MONTH_NAMES})(?:\\s+(20\\d{2}))?(?![\\p{L}\\p{N}])`, 'giu');
-const START_OF_MONTH_RE = /(?<![\p{L}\p{N}])(?:с|з|from|din|dan|бастап|баштап)\s+(?:начала\s+месяца|початку\s+місяця|începutul\s+lunii|start\s+of\s+(?:the\s+)?month)(?![\p{L}\p{N}])/giu;
+const START_OF_MONTH_RE = /(?<![\p{L}\p{N}])(?:с|з|from|din|dan|бастап|баштап)\s+(?:начала\s+месяца|початку\s+місяця|începutul\s+lunii|start\s+of\s+(?:the\s+)?month|1(?:-го)?\s+числа|первого\s+числа|1(?:-го)?\s+числа\s+місяця)(?![\p{L}\p{N}])/giu;
+const NEXT_MONTH_RE = /(?<![\p{L}\p{N}])(?:next\s+month|со?\s+следующего\s+месяца|з\s+наступного\s+місяця)(?![\p{L}\p{N}])/giu;
 const SHIFT_RE = /(?<!\d)(\d{1,2})\s*(?:смен[аы]|shift)\s*(\d{1,2}(?:[:.]\d{2})?\s*(?:am|pm|утра|вечера)?)\s*(?:-|–|—|до|to)\s*(\d{1,2}(?:[:.]\d{2})?\s*(?:am|pm|утра|вечера)?)/giu;
 
 function referenceEntry(context = {}) {
@@ -44,8 +45,19 @@ function referenceDate(context = {}) { return referenceEntry(context).date; }
 function dateValue(year, month, day) { return Object.freeze({ year, month, day }); }
 function validDate(value) { const date = new Date(Date.UTC(value.year, value.month - 1, value.day)); return date.getUTCFullYear() === value.year && date.getUTCMonth() === value.month - 1 && date.getUTCDate() === value.day; }
 function candidate(entityType, value, match, parser, confidence, evidence) { const start = match.index ?? 0; return createParseCandidate({ id: `${entityType}:${start}`, entityType, value, raw: match[0], start, end: start + match[0].length, parser, confidence, evidence }); }
-function relationNear(text, start) { const before = text.slice(Math.max(0, start - 32), start); return /(?:с|з|from|din|dan|бастап|баштап|доступна\s+(?:с|з)|заезд\s+(?:с|з))/iu.test(before) ? 'from' : /(?:до|until|p[âa]nă\s+la|gacha|дейін|чейин|не\s+позднее)/iu.test(before) ? 'until' : 'exact'; }
-function inferYear(month, day, relation, context) { const reference = referenceDate(context); let year = reference.getUTCFullYear(); const candidateDate = Date.UTC(year, month - 1, day); if (relation === 'from' && candidateDate < reference.getTime() - 36 * 3_600_000) year += 1; if (relation === 'until' && candidateDate < reference.getTime() - 36 * 3_600_000) year += 1; return year; }
+// Bare "с"/"з"/"до" are single Cyrillic letters and match as a substring of
+// countless ordinary words ("Сдаю", "доступна") without a boundary guard —
+// "Сдаю до 15.03" was misread as 'from' off the "С" in "Сдаю" alone, hiding
+// the actual "до" (until) marker that followed.
+const RELATION_FROM_RE = /(?<![\p{L}\p{N}])(?:с|з|from|din|dan|бастап|баштап|доступна\s+(?:с|з)|заезд\s+(?:с|з))(?![\p{L}\p{N}])/iu;
+const RELATION_UNTIL_RE = /(?<![\p{L}\p{N}])(?:до|until|p[âa]nă\s+la|gacha|дейін|чейин|не\s+позднее)(?![\p{L}\p{N}])/iu;
+function relationNear(text, start) { const before = text.slice(Math.max(0, start - 32), start); return RELATION_FROM_RE.test(before) ? 'from' : RELATION_UNTIL_RE.test(before) ? 'until' : 'exact'; }
+// A year-less date is assumed to refer to its next occurrence when the
+// current year's reading has already passed — not just for explicit
+// "from"/"until" wording. A bare mention with no relation ('exact') is the
+// common case (e.g. "12 января встреча") and would otherwise silently
+// resolve to a date up to a year in the past.
+function inferYear(month, day, relation, context) { const reference = referenceDate(context); let year = reference.getUTCFullYear(); const candidateDate = Date.UTC(year, month - 1, day); if (candidateDate < reference.getTime() - 36 * 3_600_000) year += 1; return year; }
 function parseClock(raw) { const match = String(raw).trim().match(new RegExp(String.raw`^(\d{1,2})(?:[:.](\d{2}))?\s*(${TIME_SUFFIX})?$`, 'iu')); if (!match) return null; let hour = Number(match[1]); const minute = Number(match[2] || 0); const suffix = String(match[3] || '').toLowerCase(); if (suffix === 'pm' && hour < 12) hour += 12; if (suffix === 'am' && hour === 12) hour = 0; if (/(?:вечера|вечора|kechqurun)/u.test(suffix) && hour < 12) hour += 12; return hour < 24 && minute < 60 ? Object.freeze({ hour, minute }) : null; }
 function durationValue(prefix, amount, unit) { const normalized = String(unit).toLowerCase(); const value = normalized === 'полгода' ? .5 : Number(amount || 1); const canonicalUnit = /год|year|yil|жыл|рок|\ban/i.test(normalized) || normalized === 'полгода' ? 'year' : /месяц|мес|month|\boy|місяц|lun/i.test(normalized) ? 'month' : /нед|week|hafta|апта|тиж|săptăm|saptaman/i.test(normalized) ? 'week' : /дн|день|day|\bkun|күн|zi/i.test(normalized) ? 'day' : /мин|minute|daqiqa/i.test(normalized) ? 'minute' : 'hour'; const bound = /от|минимум|не\s+менее|kamida|eng\s+kam|кемінде|не\s+менш|at\s+least/iu.test(prefix || '') ? 'min' : /до|не\s+более|ko'?pi\s+bilan|көп\s+емес/iu.test(prefix || '') ? 'max' : 'exact'; return Object.freeze({ value, unit: canonicalUnit, bound }); }
 function semanticDurationType(text, start, duration) {
@@ -109,6 +121,7 @@ function isClockContextual(match, text) {
   return SCHEDULE_CONTEXT_RE.test(text.slice(Math.max(0, start - 24), start + match[0].length + 24));
 }
 function dateAtMonthEnd(year, month) { return dateValue(year, month, new Date(Date.UTC(year, month, 0)).getUTCDate()); }
+function dateAtNextMonthStart(reference) { const month = reference.getUTCMonth() + 2; const year = reference.getUTCFullYear() + Math.floor((month - 1) / 12); return dateValue(year, ((month - 1) % 12) + 1, 1); }
 function nextWeekday(date, weekday) { const current = (date.getUTCDay() + 6) % 7; let days = (weekday - current + 7) % 7; if (days === 0) days = 7; return addUtcDays(date, days); }
 
 /** Extract generic temporal candidates without silently fabricating a Date. */
@@ -120,7 +133,7 @@ export function extractTemporalCandidates(value, context = {}) {
   }
   for (const match of text.matchAll(new RegExp(DATE_NUMERIC_PARTIAL_RE, 'gu'))) {
     const start = match.index ?? 0; const around = text.slice(Math.max(0, start - 40), start + match[0].length + 40);
-    if (!/(?:deadline|apply\s+by|closing\s+date|дедлайн|срок(?:\s+подачи)?|термін(?:\s+подання)?|свобод|доступ|заезд|заезж|available|move[- ]?in|\b(?:с|до|from|until)\b)/iu.test(around)) continue;
+    if (!/(?:deadline|apply\s+by|closing\s+date|дедлайн|срок(?:\s+подачи)?|термін(?:\s+подання)?|свобод|доступ|заезд|заезж|available|move[- ]?in|(?<![\p{L}\p{N}])(?:с|до|from|until)(?![\p{L}\p{N}]))/iu.test(around)) continue;
     const relation = relationNear(text, start); const inferred = true;
     const date = dateValue(inferYear(Number(match[2]), Number(match[1]), relation, context), Number(match[2]), Number(match[1]));
     if (validDate(date)) candidates.push(candidate(dateEntityType(text, start, context, relation), date, match, 'temporal.calendar.numeric-partial', .86, [{ type: 'regex', rule: 'numeric-partial-date' }, ...inferredDateEvidence(inferred, context)]));
@@ -144,6 +157,10 @@ export function extractTemporalCandidates(value, context = {}) {
     const reference = referenceDate(context); const date = dateValue(reference.getUTCFullYear(), reference.getUTCMonth() + 1, 1);
     candidates.push(candidate(temporalContextType(text, match.index ?? 0, context), date, match, 'temporal.relative.month-start', .88, [{ type: 'context', value: 'month-start' }, { type: 'reference-date', value: referenceEntry(context).source }]));
   }
+  for (const match of text.matchAll(NEXT_MONTH_RE)) {
+    const date = dateAtNextMonthStart(referenceDate(context));
+    candidates.push(candidate(temporalContextType(text, match.index ?? 0, context), date, match, 'temporal.relative.next-month', .88, [{ type: 'context', value: 'next-month' }, { type: 'reference-date', value: referenceEntry(context).source }]));
+  }
   for (const match of text.matchAll(NEXT_WEEKDAY_RE)) {
     const weekday = DAY_ALIASES[match[1].toLowerCase()]; if (weekday == null) continue;
     candidates.push(candidate(temporalContextType(text, match.index ?? 0, context), nextWeekday(referenceDate(context), weekday), match, 'temporal.relative.next-weekday', .9, [{ type: 'dictionary', dictionary: 'weekdays', key: match[1] }, { type: 'reference-date', value: referenceEntry(context).source }]));
@@ -158,7 +175,15 @@ export function extractTemporalCandidates(value, context = {}) {
     candidates.push(candidate(type, addUtcDays(referenceDate(context), days), match, 'temporal.relative-date.extended', .91, [{ type: 'context', value: `relative:${days}d` }, { type: 'unit', value: unit }, { type: 'reference-date', value: referenceEntry(context).source }]));
   }
   for (const match of text.matchAll(new RegExp(DURATION_NUMBER_FIRST_RE, 'giu'))) { const value = durationValue(match[1], match[2], match[3]); candidates.push(candidate(semanticDurationType(text, match.index ?? 0, value), value, match, 'temporal.duration.number-unit', .95, [{ type: 'unit', value: match[3] }, ...(match[1] ? [{ type: 'prefix', value: match[1] }] : [])])); }
-  for (const match of text.matchAll(new RegExp(DURATION_RE, 'giu'))) { if (match[3]) continue; const value = durationValue(match[1], match[3], match[2]); candidates.push(candidate(semanticDurationType(text, match.index ?? 0, value), value, match, 'temporal.duration.word-unit', .94, [{ type: 'unit', value: match[2] }, ...(match[1] ? [{ type: 'prefix', value: match[1] }] : [])])); }
+  for (const match of text.matchAll(new RegExp(DURATION_RE, 'giu'))) {
+    if (match[3]) continue;
+    // Bare genitive "дня" is almost always part of another phrase ("конца
+    // дня", "сегодняшнего дня", "через 2 дня") rather than a standalone
+    // 1-day duration. Only accept it here when an explicit duration prefix
+    // ("на", "минимум", ...) makes the duration reading unambiguous.
+    if (!match[1] && /^дня$/iu.test(match[2])) continue;
+    const value = durationValue(match[1], match[3], match[2]); candidates.push(candidate(semanticDurationType(text, match.index ?? 0, value), value, match, 'temporal.duration.word-unit', .94, [{ type: 'unit', value: match[2] }, ...(match[1] ? [{ type: 'prefix', value: match[1] }] : [])]));
+  }
   const timeRangeSpans = [];
   for (const match of text.matchAll(new RegExp(TIME_RANGE_RE, 'giu'))) {
     const start = parseClock(match[1]); const end = parseClock(match[2]);