@whiteslove/parsing-lexicon 0.7.8 → 0.8.1

package/package.json

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

package/src/contact.js

@@ -9,6 +9,7 @@ const PHONE_LIKE_RE = /\+?\d(?:[\t \u00a0().-]*\d){9,}/g;
 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 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;
 
 const TELEGRAM_USERNAME_RE = /^[A-Za-z0-9_]{5,32}$/;
 const TELEGRAM_LINK_RE = /(?:https?:\/\/)?(?:t\.me|telegram\.me|telegram\.dog)\/([A-Za-z0-9_]{5,32})(?:\/[0-9]+)?(?:[/?#][^\s]*)?/giu;
@@ -20,6 +21,18 @@ function normalizedCountryHint(value) {
   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);
+  return PRICE_LABEL_BEFORE_NUMBER_RE.test(before);
+}
+
 function splitPhoneExtension(raw) {
   const match = String(raw || '').match(PHONE_EXTENSION_RE);
   if (!match) return { base: String(raw || '').trim(), extension: null };
@@ -38,6 +51,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,

package/src/geography-detection.js

@@ -1,8 +1,6 @@
 import { COUNTRIES, canonicalCountryCode } from './countries.js';
 import { CITIES } from './geography.js';
-import { aliasesOf, aliasesToRegex, normalizeForMatch } from './normalization.js';
-
-const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+import { aliasesOf, aliasesToRegex, escapeRegex, normalizeForMatch } from './normalization.js';
 
 function cityInflectionRegex(aliases) {
   const cyrillic = [...new Set(aliases.filter((alias) => /\p{Script=Cyrillic}/u.test(alias)))];

package/src/hiring-ats.d.ts

@@ -1,6 +1,6 @@
 import type { HiringSeniority, DegreeLevel, DegreeField } from './hiring-requirements.js';
 export type HiringAtsProfile = Readonly<{ raw: string; skills: Set<string>; skillEvidence: Map<string, number>; terms?: Set<string>; experienceYears?: number; seniority?: HiringSeniority; degreeLevel?: DegreeLevel; degreeFields: Set<DegreeField>; requiresUsSponsorship?: boolean }>;
-export type HiringAtsJob = Readonly<{ title: string; description?: string; tags?: string[]; skills?: string[]; niceToHave?: string[]; experienceMinYears?: number; seniority?: string | null; education?: string; country?: string; location?: string; sponsorshipEvidence?: string[] }>;
+export type HiringAtsJob = Readonly<{ title: string; description?: string; tags?: string[]; skills?: string[]; niceToHave?: string[]; experienceMinYears?: number; seniority?: string | null; education?: string; country?: string; location?: string }>;
 export function buildHiringAtsProfile(cvText: unknown, options?: { fuzzySkills?: boolean; referenceDate?: Date }): HiringAtsProfile;
 export function scoreHiringAts(profileOrCv: HiringAtsProfile | string, job: HiringAtsJob, options?: { fuzzySkills?: boolean; referenceDate?: Date }): Readonly<{ score: number; fitScore: number; eligible: boolean; blockers: readonly { code: string; label: string; critical: boolean }[]; breakdown: Readonly<{ skills: number; experience: number; seniority: number; scope: number; education: number; relevance: number }>; matched: readonly string[]; missing: readonly string[] }>;
 export function hiringAtsScoreColor(score: number): string;

package/src/hiring-ats.js

@@ -137,10 +137,7 @@ export function scoreHiringAts(profileOrCv, job, options = {}) {
   const relevance = extractTerms(keywordSource).size ? Math.round(coverage(profile.terms || extractTerms(profile.raw), extractTerms(keywordSource)) * 100) : 60;
   const breakdown = Object.freeze({ skills, experience: experience.score, seniority: seniority.score, scope: scope.score, education: education.score, relevance });
   let fitScore = Math.round(skills * .30 + experience.score * .20 + seniority.score * .20 + scope.score * .15 + education.score * .10 + relevance * .05);
-  // Source-specific ATS ingestion can supply the wording that established a
-  // sponsorship policy separately from the rendered description.  It remains
-  // input evidence, not consumer-side parsing logic.
-  const usText = `${job?.location || ''} ${title} ${description} ${tagText} ${(job?.sponsorshipEvidence || []).join(' ')}`;
+  const usText = `${job?.location || ''} ${title} ${description}`;
   const visaBlocked = (job?.country || '').toUpperCase() === 'US' || detectCountryCodeFromText(usText) === 'US'
     ? profile.requiresUsSponsorship === true && isNoSponsorshipRequirement(usText) : false;
   const blockers = visaBlocked ? [Object.freeze({ code: 'visa_sponsorship', label: 'Visa sponsorship unavailable', critical: true })] : [];

package/src/hiring-skills.js

@@ -1,4 +1,9 @@
 import { cleanHiringSourceText } from './hiring-source-semantics.js'
+import { escapeRegex } from './normalization.js'
+
+// Kept as a compatibility export for existing hiring consumers. The lexical
+// implementation itself has one canonical home in normalization.js.
+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.
@@ -249,10 +254,6 @@ export function normalizeSkillText(value) {
     .trim()
 }
 
-export function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
-
 export function buildSkillRegex(alias) {
   const normalized = normalizeSkillText(alias)
   const pattern = escapeRegex(normalized).replace(/\s+/g, '\\s+')

package/src/housing-address.js

@@ -8,8 +8,8 @@ import {
 const PHONE_RUN_RE = /\+?\d[\d\s().-]{7,}\d/gu;
 const ADDRESS_LABEL_RE = /(?:адрес|адреса|адресація|адресация|manzil|address|adresă|adresa)\s*[:=\-–—]\s*/iu;
 const PREFIX_STREET_MARKER = String.raw`(?:(?:ул(?:ица)?|вул(?:иця)?|пр|просп(?:ект)?|пр-т|переул(?:ок)?|пров(?:улок)?|проезд|наб(?:ережная)?|шоссе|str(?:ada)?|street|st|avenue|ave|road|rd|көше)\.?)`;
-const POSTFIX_STREET_MARKER = String.raw`(?:ko['’ʼ\u02bc]?cha(?:si)?|кўча(?:си)?|коча(?:си)?|kocha(?:si)?)`;
-const POSTFIX_STREET_TYPE = String.raw`(?:вулиця|улица|провулок|переулок|проспект|бульвар|набережна|набережная|шосе|шоссе|площа|площадь|узвіз|спуск|алея|аллея|дорога|тупик)`;
+const POSTFIX_STREET_MARKER = String.raw`(?:ko['’ʼ\u02bc]?cha(?:si)?|кўча(?:си)?|коча(?:си)?|kocha(?:si)?|көше(?:сі)?|көшесі|көчө(?:сү)?)`;
+const POSTFIX_STREET_TYPE = String.raw`(?:вулиця|улица|провулок|переулок|проспект|бульвар|набережна|набережная|шосе|шоссе|площа|площадь|узвіз|спуск|алея|аллея|дорога|тупик|көше(?:сі)?|көшесі|көчө(?:сү)?)`;
 const HOUSE_MARKER = String.raw`(?:дом|д\.|будинок|буд\.|house|h\.|uy|уй|үй|nr\.?|no\.?|№)`;
 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}`;
@@ -17,9 +17,9 @@ const STREET_WORD = String.raw`[\p{L}'’.-]{2,48}`;
 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)?)`;
-const ENTRANCE_MARKER = String.raw`(?:подъезд|під['’ʼ\u02bc]?їзд|entrance|intrare|kirish)`;
+const ENTRANCE_MARKER = String.raw`(?:подъезд|під['’ʼ\u02bc]?їзд|entrance|intrare|kirish|кіреберіс|кире\s+бериш)`;
 const STAIRCASE_MARKER = String.raw`(?:лестниц(?:а|ы)?|сходи|staircase|scara)`;
-const ADDRESS_FIELD_STOP_RE = /\s+(?:цена|ціна|нарх(?:и)?|narx|price|стоимост[ьи]|этаж(?:ность)?|поверх|qavat|қабат|кават|қават|комнат(?:ы|а)?|кімнат(?:и|а)?|xona|хона|площадь|площа|maydon|тел(?:ефон)?|phone|комисси\p{L}*|депозит|deposit|ориентир\p{L}*|ор[-–—]?р\.?)(?=$|[\s:№#-])/iu;
+const ADDRESS_FIELD_STOP_RE = /\s+(?:цена|ціна|нарх(?:и)?|narx|price|стоимост[ьи]|этаж(?:ность)?|поверх|qavat|қабат|кават|қават|комнат(?:ы|а)?|кімнат(?:и|а)?|xona|хона|площадь|площа|maydon|тел(?:ефон)?|phone|комисси\p{L}*|депозит|deposit|ориентир\p{L}*|ор[-–—]?р\.?|власник|собственник|owner|риелтор\p{L}*|агент\p{L}*|подробност\p{L}*|звоните|пиш(?:ите|іть))(?=$|[\s:№#-])/iu;
 const PROPERTY_AREA_LINE_RE = /(?:^|[^\p{L}\p{N}_])(?:(?:общая|жилая|полезная|кухонная)\s+площадь|площадь\s+(?:квартиры|дома|комнаты))(?=$|[^\p{L}\p{N}_])/iu;
 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;
@@ -189,9 +189,9 @@ function result(address, street = null, houseNumber = null, building = null, con
   const normalizedHouseNumber = normalizeNumber(houseNumber);
   const compactBuilding = normalizedHouseNumber?.match(/^(\d{1,5})(?:к|k)(\d{1,4})$/iu);
   const normalizedBuilding = normalizeNumber(building) || compactBuilding?.[2] || null;
-  // The public address is always a verified street component, optionally
-  // followed by its house/building. Never preserve a source label's whole
-  // location sentence as an address just because it was parsed on that path.
+  // `address` is a geocoding-compatible street/house value, never a fallback
+  // copy of a whole labelled listing line.  Districts, metros and nearby POIs
+  // are preserved as independent components by the caller.
   const canonicalAddress = normalizedStreet
     ? composeHousingAddress({ street: normalizedStreet, houseNumber: compactBuilding ? compactBuilding[1] : normalizedHouseNumber, building: normalizedBuilding })
     : null;
@@ -420,6 +420,10 @@ function explicitStreetAddress(text) {
     .map((part) => clean(part).slice(0, 1200))
     .filter(Boolean)
     .slice(0, 12);
+  const candidates = [];
+  const add = (value) => {
+    if (value?.street) candidates.push(value);
+  };
 
   for (const rawLine of lines) {
     if (PROPERTY_AREA_LINE_RE.test(rawLine)) continue;
@@ -427,30 +431,37 @@ function explicitStreetAddress(text) {
     if (!line) continue;
 
     const postfixTyped = postfixTypedStreetAddress(line);
-    if (postfixTyped) return postfixTyped;
+    if (postfixTyped) {
+      add(postfixTyped);
+      continue;
+    }
 
     const prefixTyped = prefixTypedStreetAddress(line);
-    if (prefixTyped) return prefixTyped;
+    if (prefixTyped) {
+      add(prefixTyped);
+      continue;
+    }
 
     const boundedPrefix = line.match(new RegExp(
       `(?:^|[\\s,;])${PREFIX_STREET_MARKER}(?!\\p{L})\\s*((?:${STREET_WORD}\\s+){0,3}${STREET_WORD})(?=$|[,;])`,
       'iu',
     ));
     if (boundedPrefix) {
-      return result(
+      add(result(
         boundedPrefix[0],
         boundedPrefix[1],
         null,
         null,
         scoreAddressConfidence(line, { source: 'explicit', hasStreetMarker: true, hasHouse: false }),
-      );
+      ));
+      continue;
     }
 
     const prefix = line.match(new RegExp(`(?:^|[\\s,;])(${PREFIX_STREET_MARKER})\\s+(.+)$`, 'iu'));
     if (prefix) {
       const tail = splitAddressTail(prefix[2]);
       if (tail) {
-        return result(
+        add(result(
           line,
           tail.street,
           tail.houseNumber,
@@ -460,7 +471,8 @@ function explicitStreetAddress(text) {
             hasStreetMarker: true,
             hasHouse: Boolean(tail.houseNumber),
           }),
-        );
+        ));
+        continue;
       }
     }
 
@@ -469,7 +481,7 @@ function explicitStreetAddress(text) {
       const tailText = clean(`${postfix[1]} ${postfix[3]}`);
       const tail = splitAddressTail(tailText);
       if (tail) {
-        return result(
+        add(result(
           line,
           tail.street,
           tail.houseNumber,
@@ -479,12 +491,23 @@ function explicitStreetAddress(text) {
             hasStreetMarker: true,
             hasHouse: Boolean(tail.houseNumber),
           }),
-        );
+        ));
       }
     }
   }
 
-  return null;
+  // 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
+    .map((value, index) => ({
+      value,
+      index,
+      score: (Number(value.confidence) || 0)
+        + (value.houseNumber ? 0.18 : 0)
+        + (value.building ? 0.03 : 0),
+    }))
+    .sort((a, b) => b.score - a.score || a.index - b.index)[0]?.value || null;
 }
 
 function knownStreetAddress(text, knownStreet) {
@@ -540,22 +563,13 @@ function labelledAddress(text, rawValue) {
 
   const line = clean(rawLine).slice(0, 140);
   if (!line) return null;
-  const structured = parseHousingAddress(line, { allowDelimitedBare: true });
-  if (structured.street || structured.houseNumber) return structured;
-
-  // A label alone is not evidence that arbitrary prose is a street.  Accept
-  // an unmarked form only when it is a short street-plus-house expression;
-  // landmark lists such as "Yakkasaroy, Magic City yonida" remain geo data.
-  const tail = splitAddressTail(line);
-  const candidateStreet = compactStreet(tail?.street);
-  const safeBare = Boolean(
-    tail?.houseNumber
-    && candidateStreet
-    && !LOCATION_RELATION_RE.test(candidateStreet)
-    && candidateStreet.split(/\s+/u).length <= 5
-    && candidateStreet.split(/\s+/u).every((word) => /^[\p{L}'’.-]{2,48}$/u.test(word)),
-  );
-  return safeBare ? parseHousingAddress(line, { allowBare: true }) : structured;
+  const delimited = parseHousingAddress(line, { allowDelimitedBare: true });
+  if (delimited.street) return delimited;
+  // A generic label such as "Manzil:" is often followed by district and POI
+  // prose.  Accept an unmarked bare form only when it has an actual house
+  // component; marker-based street forms were already handled above.
+  const bare = parseHousingAddress(line, { allowBare: true });
+  return bare.street && bare.houseNumber && !LOCATION_RELATION_RE.test(bare.street) ? bare : null;
 }
 
 function plausibleDelimitedStreet(value) {

package/src/housing-listing-enrichment.js

@@ -11,6 +11,7 @@ import { parseHousingAddress, resolveHousingAddressGeoEntities } from './housing
 import { HOUSING_LANDMARK_EXTENSIONS, HOUSING_POI_EXTENSIONS } from './housing-poi-extensions.js';
 import { resolveHousingIntent } from './housing-intent.js';
 import { extractHousingPoiRelations } from './housing-poi-relations.js';
+import { dictionaryFor } from './locations-runtime.js';
 
 const GENERIC_CATEGORY = Object.freeze({
   Park: 'park', Metro: 'metro', 'Bus stop': 'transport', 'Public transport': 'transport', 'Main road': 'transport',
@@ -31,19 +32,26 @@ 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;
 const WALK_MINUTES_RE = /(?:yayov|piyoda|пешком)\s*(\d{1,2})\s*(?:daqiqa|min(?:ute)?s?|минут)/iu;
 const TRANSIT_ROUTES_RE = /(?:aftobuslar|avtobuslar|автобуслар|автобусы)[^\r\n\d]{0,24}((?:\d{1,4}[\s,;/]*){1,10})/iu;
-const NEARBY_RELATION_TAIL_RE = /(?<!\p{L})(?:рядом\s+(?:с|со)|недалеко\s+от|возле|около|ориентир\s*[:—–-]?|ор[-–—]?р\.?\s*[:—–-]?|near(?:by)?|close\s+to|lângă|aproape\s+de)(?!\p{L})[^.!?\r\n;]*/giu;
+const NEARBY_RELATION_TAIL_RE = /(?<!\p{L})(?:рядом\s+(?:с|со)|недалеко\s+от|возле|около|напротив|навпроти|ориентир\s*[:—–-]?|ор[-–—]?р\.?\s*[:—–-]?|near(?:by)?|close\s+to|next\s+to|opposite|behind|in\s+front\s+of|yaqin(?:ida)?|lângă|aproape\s+de|în\s+apropiere\s+de|vizavi\s+de|în\s+spatele|în\s+fața)(?!\p{L})[^.!?\r\n;]*/giu;
+const NEARBY_POSTFIX_RELATION_RE = /(?<!\p{L})[^,;.!?\r\n]{2,96}?\s+(?:yonida|yaqin(?:ida)?|ro['’ʻʼ`]?parasida|жанында|қасында|жакын|каршысында|қарсысында|артында|алдында)(?=$|[,;.!?\r\n])/giu;
 const NEARBY_TRAVEL_TAIL_RE = /(?<!\p{L})(?:до|până\s+la)(?!\p{L})[^.!?\r\n;]{0,96}(?<!\p{L})\d{1,3}\s*(?:мин(?:ут(?:ы|а|ах)?|\.?)?|min(?:ute)?s?|дақиқ\p{L}*|daqiqa|км|km|метр(?:а|ов)?|m)(?!\p{L})[^.!?\r\n;]*/giu;
 const RESIDENTIAL_CONTEXT_RE = /(?:ж\.?\s*к\.?|жил(?:ой|ого)\s+комплекс|новострой(?:ка|ки)?|residential\s+complex|residence|turar\s+joy|uy[-\s]?joy|majmua|массив)/iu;
+const METRO_PREFIX_RE = /(?:^|[^\p{L}])(?:metro|metrosi|метро|м\.)\s*$/iu;
+const SUPERMARKET_PREFIX_RE = /(?:^|[^\p{L}])(?:супермаркет|supermarket|магазин)\s*$/iu;
 
 function unique(values) {
   return [...new Set(values.filter(Boolean))];
@@ -55,7 +63,7 @@ function categoryOf(entry) {
 
 function nearbyReferenceRanges(text) {
   const ranges = [];
-  for (const pattern of [NEARBY_RELATION_TAIL_RE, NEARBY_TRAVEL_TAIL_RE]) {
+  for (const pattern of [NEARBY_RELATION_TAIL_RE, NEARBY_POSTFIX_RELATION_RE, NEARBY_TRAVEL_TAIL_RE]) {
     const regex = new RegExp(pattern.source, pattern.flags);
     for (const match of text.matchAll(regex)) {
       const start = match.index ?? 0;
@@ -72,6 +80,7 @@ function insideNearbyReference(match, ranges) {
 function withoutNearbyLocationReferences(text) {
   return String(text || '')
     .replace(NEARBY_RELATION_TAIL_RE, ' ')
+    .replace(NEARBY_POSTFIX_RELATION_RE, ' ')
     .replace(NEARBY_TRAVEL_TAIL_RE, ' ');
 }
 
@@ -122,6 +131,42 @@ function genericMatches(text) {
   }));
 }
 
+// A city dictionary is the canonical lexical source.  Collect every contextual
+// match here instead of using matchDictionaryLocation(), which intentionally
+// returns just one longest match for simple lookup callers.
+function contextualCityMatches(text, country, city, type, prefix) {
+  const dictionary = dictionaryFor(String(country || '').toUpperCase(), city);
+  if (!dictionary || !prefix) return [];
+  const matches = [];
+  for (const entry of dictionary[type] || []) {
+    if (!entry?.re) continue;
+    const flags = [...new Set(`${entry.re.flags.replace(/g/g, '')}g`)].join('');
+    const re = new RegExp(entry.re.source, flags);
+    for (const match of text.matchAll(re)) {
+      const start = match.index ?? 0;
+      const before = text.slice(Math.max(0, start - 40), start);
+      if (!prefix.test(before)) continue;
+      matches.push({ canonical: entry.name, start, length: match[0].length });
+    }
+  }
+  return matches.sort((a, b) => a.start - b.start || b.length - a.length || a.canonical.localeCompare(b.canonical));
+}
+
+function cityMetro(text, country, city) {
+  return contextualCityMatches(text, country, city, 'metro', METRO_PREFIX_RE)[0]?.canonical || null;
+}
+
+function contextualNearby(text, country, city, metro) {
+  const shops = contextualCityMatches(text, country, city, 'landmarks', SUPERMARKET_PREFIX_RE)
+    .map((match) => match.canonical);
+  const generic = parseHousingNearby(text).filter((name) => {
+    if (name === 'Metro' && metro) return false;
+    if (name === 'Supermarket' && shops.length) return false;
+    return true;
+  });
+  return deepFreeze(unique([...shops, ...generic]));
+}
+
 export function parseHousingNearby(value) {
   const text = normalizeUnicode(value ?? '');
   if (!text) return deepFreeze([]);
@@ -135,7 +180,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);
@@ -246,7 +291,7 @@ export function parseHousingListingEnrichment(value, { country = '', city = '',
   const observedAmenities = parseHousingObservedAmenities(text);
   const quarter = matchTashkentHousingQuarter(text);
   const district = matchTashkentHousingDistrict(text)?.name || quarter?.district || null;
-  const metro = matchTashkentHousingMetro(text)?.name || null;
+  const metro = matchTashkentHousingMetro(text)?.name || cityMetro(text, country, city) || null;
   const primaryResidentialText = withoutNearbyLocationReferences(text);
   const parsedRc = specificResidentialComplex(primaryResidentialText)
     || matchTashkentResidentialComplex(primaryResidentialText)?.name
@@ -314,7 +359,7 @@ export function parseHousingListingEnrichment(value, { country = '', city = '',
     perPersonPrice,
     transitRoutes: parseHousingTransitRoutes(text),
     walkMinutes: walkMinutes(text),
-    nearby: parseHousingNearby(text),
+    nearby: contextualNearby(text, country, city, metro),
     ...(poiRelations.length ? { poiRelations, nearbyEntities: deepFreeze(nearbyEntities) } : {}),
     amenities: observedAmenities,
     district: district || null,

package/src/housing-listing-fields.js

@@ -102,7 +102,9 @@ function parseUtilitiesAmount(text) {
 function parseCommunalSeparated(text, country) {
   if (/(коммунал\p{L}*(?:\s+услуг\p{L}*)?\s*(?:отдельно|сверху|плюс|оплачива\p{L}*\s*отдельно)|свет\s*вода\s*газ\s*отдельно|k[oa]munal\p{L}*\s*(?:alohida|aloxida|ustiga)|камунал\s+туловлари\s+алохида|коммунал\s+тўловлари\s+алоҳида|utilities?\s*(?:separate|extra|not included))/iu.test(text)) return true;
   if (/(коммунал\p{L}*(?:\s+услуг\p{L}*)?\s*(?:включ|входит|в\s*стоимост)|вс[её]\s*включ|all\s*inclusive|kommunal\p{L}*\s*(?:kiritilgan|ichida)|комунал(?:каси)?\s+ичида|коммунал(?:каси)?\s+ичида|utilities?\s*included)/iu.test(text)) return false;
-  return String(country || '').toUpperCase() === 'UA' ? true : null;
+  // Utility-payment terms must be explicit.  A country default turns ordinary
+  // Ukrainian listings into a made-up "utilities separate" assertion.
+  return null;
 }
 
 function parseDepositRequired(text) {

package/src/housing-money.d.ts

@@ -10,7 +10,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

@@ -1,4 +1,4 @@
-import { aliasesOf, findCanonical } from './normalization.js';
+import { aliasesOf, escapeRegex, findCanonical } from './normalization.js';
 import { CURRENCY_TERMS, NUMBER_MULTIPLIERS } from './money-lexicon.js';
 import {
   MONEY_NUMBER_PATTERN,
@@ -31,10 +31,6 @@ const PAYMENT_AMOUNT_TERMS = Object.freeze([
 ].filter(Boolean));
 const PRICE_KEYWORD_RE = new RegExp(PRICE_KEYWORD, 'iu');
 
-function escapeRegex(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
 // One-letter `m/м` is deliberately excluded from the generic multiplier set.
 // Its meaning is resolved by housing-numeric-spans.js first, so area/distance/
 // microdistrict notation cannot leak into money parsing while explicit price
@@ -203,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({
@@ -214,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,
@@ -243,6 +240,33 @@ 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*(?:-{1,3}|–|—|to|до|dan\\s+gacha)\\s*(${MONEY_NUMBER_PATTERN})(?=$|[^\\p{L}\\p{N}_])`,
+    'igu',
+  );
+  for (const match of text.matchAll(labelledPriceRangeRe)) {
+    const minimum = parseNumericAmount(match[1]);
+    const maximum = parseNumericAmount(match[2]);
+    if (minimum == null || maximum == null || minimum > maximum) continue;
+    const start = match.index ?? 0;
+    addCandidate({
+      amount: Math.round(minimum),
+      currency: country === 'UZ' ? 'UZS' : fallbackCurrency || '',
+      start,
+      end: start + match[0].length,
+      explicitCurrency: false,
+      priceKeyword: true,
+      range: Object.freeze({ minimum: Math.round(minimum), maximum: Math.round(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;

package/src/housing-poi-relations.js

@@ -1,5 +1,6 @@
 import { deepFreeze } from './lexicon-core.js';
 import { normalizeUnicode } from './normalization.js';
+import { canonicalCity } from './geography.js';
 
 const TYPE_MARKERS = Object.freeze([
   ['poi.university', /(?:university|uni\b|institute|academy|college|universitet|institut|universiteti|университет|универ|институт|академия)/iu],
@@ -12,30 +13,30 @@ const TYPE_MARKERS = Object.freeze([
   ['poi.bus_station', /(?:bus\s+station|coach\s+station|автовокзал|автостанция|bus\s+terminal)/iu],
   ['poi.parking', /(?:parking|парковк\p{L}*|паркинг|автостоянк\p{L}*)/iu],
   ['poi.shopping_mall', /(?:shopping\s+(?:mall|cent(?:er|re))|mall\b|т[цр]\b|savdo\s+markaz)/iu],
+  ['poi.supermarket', /(?:supermarket|супермаркет|гипермаркет|магазин)/iu],
   ['poi.market', /(?:market|bazaar|bozor|базар|рынок)/iu],
   ['poi.park', /(?:park|bog['’ʻʼ`]?|парк)/iu],
   ['metro', /(?:metro|metrosi|метро|м\.)/iu],
 ]);
 
-const RELATION_RE = /(?<relation>рядом\s+(?:с|со)|возле|около|недалеко\s+от|напротив|за|перед|near(?:by)?|close\s+to|next\s+to|opposite|behind|in\s+front\s+of|yaqin(?:ida)?|yonida|ro['’ʻʼ`]?parasida|орналасқан\s+жерде|поруч|біля|поблизу|lângă|aproape\s+de)\s+(?<target>[^,;.!?\r\n]{2,96})/giu;
-// Uzbek usually places the relation after the landmark: "Magic City yonida"
-// rather than "yonida Magic City". Keep its target span separate so it never
-// leaks into an address/street field.
-const POSTFIX_RELATION_RE = /(?<target>[^,;.!?\r\n]{2,96}?)\s+(?<relation>yonida|yaqin(?:ida)?|ro['’ʻʼ`]?parasida)(?=$|[,;.!?\r\n])/giu;
-const DISTANCE_RE = /(?<amount>\d{1,3}(?:[.,]\d+)?)\s*(?<unit>km|км|min(?:ute)?s?|мин(?:ут(?:ы|а|ах)?)?|дақиқа|daqiqa|метр(?:а|ов)?|m)\s*(?<mode>пешком|пішки|walking?|yayov|piyoda|на\s+машине|by\s+car)?\s*(?:до|от|from|to|до\s+станции)\s+(?<target>[^,;.!?\r\n]{2,96})/giu;
+const RELATION_RE = /(?<relation>рядом\s+(?:с|со)|возле|около|недалеко\s+от|напротив|навпроти|за|перед|позаду|near(?:by)?|close\s+to|next\s+to|opposite|behind|in\s+front\s+of|yaqin(?:ida)?|yonida|ro['’ʻʼ`]?parasida|орналасқан\s+жерде|жанында|қасында|жакын|каршысында|қарсысында|артында|алдында|поруч|біля|поблизу|lângă|aproape\s+de|în\s+apropiere\s+de|vizavi\s+de|în\s+spatele|în\s+fața)\s+(?<target>[^,;.!?\r\n]{2,96})/giu;
+const POSTFIX_RELATION_RE = /(?<target>[^,;.!?\r\n]{2,96}?)\s+(?<relation>yonida|yaqin(?:ida)?|ro['’ʻʼ`]?parasida|жанында|қасында|жакын|каршысында|қарсысында|артында|алдында)(?=$|[,;.!?\r\n])/giu;
+const DISTANCE_UNIT = String.raw`(?:km|км|min(?:ute)?s?|мин(?:ут(?:ы|а|ах)?)?|хв(?:илин(?:и|у)?)?|дақиқа|daqiqa|метр(?:а|ов|ів)?|m)`;
+const DISTANCE_MODE = String.raw`(?:пешком|пішки|walking?|yayov|piyoda|на\s+машине|by\s+car)`;
+const DISTANCE_RE = new RegExp(String.raw`(?<amount>\d{1,3}(?:[.,]\d+)?)\s*(?<unit>${DISTANCE_UNIT})\s*(?<mode>${DISTANCE_MODE})?\s*(?:до|от|from|to|до\s+станции)\s+(?<target>[^,;.!?\r\n]{2,96})`, 'giu');
+const POSTFIX_DISTANCE_RE = new RegExp(String.raw`(?<target>[^,;.!?\r\n]{2,96}?)\s+(?<amount>\d{1,3}(?:[.,]\d+)?)\s*(?<unit>${DISTANCE_UNIT})(?:\s*(?<mode>${DISTANCE_MODE}))?(?=$|[,;.!?\r\n])`, 'giu');
 
 function cleanTarget(value) {
   return String(value || '')
     .replace(/\b(?:на\s+машине|пешком|пішки|walking?|piyoda|yayov)\b/giu, ' ')
-    .replace(/(?<!\p{L})(\p{L}{3,})(?:ga|qa|ka)(?!\p{L})/giu, '$1')
     .replace(/\s+/g, ' ').trim();
 }
 
 function relationKind(value) {
   const text = String(value || '').toLowerCase();
-  if (/напротив|opposite|ro['’ʻʼ`]?parasida/u.test(text)) return 'opposite';
-  if (/behind|\bза\b/u.test(text)) return 'behind';
-  if (/in\s+front|\bперед\b/u.test(text)) return 'in_front_of';
+  if (/напротив|навпроти|opposite|vizavi|ro['’ʻʼ`]?parasida|каршысында|қарсысында/u.test(text)) return 'opposite';
+  if (/behind|за|позаду|în\s+spatele|артында/u.test(text)) return 'behind';
+  if (/in\s+front|\bперед\b|în\s+fața|алдында/u.test(text)) return 'in_front_of';
   return 'near';
 }
 
@@ -43,10 +44,30 @@ function markerTypes(value) {
   return TYPE_MARKERS.filter(([, re]) => re.test(value)).map(([type]) => type);
 }
 
+function stripLeadingTypeMarker(value) {
+  return String(value || '')
+    .replace(/^(?:supermarket|супермаркет|гипермаркет|магазин|shopping\s+(?:mall|cent(?:er|re))|mall|т[цр]|savdo\s+markaz)\s+/iu, '')
+    .replace(/\s+/g, ' ').trim();
+}
+
+function parentMatchesCity(parentId, city, country) {
+  if (!city || !parentId) return true;
+  const expected = canonicalCity(city, country);
+  if (!expected) return true;
+  const parentCities = String(parentId)
+    .split(/[:/]/u)
+    .map((part) => canonicalCity(part, country))
+    .filter(Boolean);
+  // A resolver was already given the city scope. Reject only when its stable
+  // parent ID identifies a *different known city*; a catalog's local-language
+  // slug (e.g. Bucuresti) is a valid alias of the caller's canonical city.
+  return parentCities.length === 0 || parentCities.includes(expected);
+}
+
 function normalizeReference(candidate, country, city) {
   if (!candidate?.id || !candidate?.canonicalName && !candidate?.canonical) return null;
   if (candidate.country && String(candidate.country).toUpperCase() !== country) return null;
-  if (city && candidate.parentId && !String(candidate.parentId).toLowerCase().includes(String(city).toLowerCase())) return null;
+  if (!parentMatchesCity(candidate.parentId, city, country)) return null;
   return Object.freeze({
     id: String(candidate.id),
     canonical: String(candidate.canonicalName || candidate.canonical),
@@ -60,7 +81,9 @@ function resolveTarget(target, context) {
   if (typeof context.resolveGeoCandidates !== 'function') return [];
   const types = markerTypes(target);
   const query = cleanTarget(target) || String(target).trim();
-  const bareQuery = types.includes('metro') ? query.replace(/\b(?:metrosi|metro|метро|м\.)\b/giu, ' ').replace(/\s+/g, ' ').trim() : query;
+  const bareQuery = types.includes('metro')
+    ? query.replace(/\b(?:metrosi|metro|метро|м\.)\b/giu, ' ').replace(/\s+/g, ' ').trim()
+    : stripLeadingTypeMarker(query);
   for (const currentQuery of [...new Set([query, bareQuery])].filter((item) => item.length >= 2)) {
     const resolved = context.resolveGeoCandidates(Object.freeze({
       country: context.country,
@@ -80,7 +103,7 @@ function distanceDetails(groups) {
   if (!Number.isFinite(amount) || amount <= 0) return {};
   const unit = String(groups.unit || '').toLowerCase();
   if (/^(?:km|км)$/u.test(unit)) return { distanceMeters: Math.round(amount * 1000) };
-  if (/^(?:min|мин|дақиқа|daqiqa)/u.test(unit)) {
+  if (/^(?:min|мин|хв|дақиқа|daqiqa)/u.test(unit)) {
     const mode = /пешком|пішки|walking|yayov|piyoda/iu.test(groups.mode || '') ? 'walk'
       : /машине|by\s+car/iu.test(groups.mode || '') ? 'drive' : 'unknown';
     return { durationMinutes: Math.round(amount), mode };
@@ -96,7 +119,7 @@ export function extractHousingPoiRelations(value, { country = '', city = '', res
   if (!text || !normalizedCountry || typeof resolveGeoCandidates !== 'function') return deepFreeze([]);
   const context = { country: normalizedCountry, city, resolveGeoCandidates };
   const relations = [];
-  for (const pattern of [RELATION_RE, POSTFIX_RELATION_RE, DISTANCE_RE]) {
+  for (const pattern of [RELATION_RE, POSTFIX_RELATION_RE, DISTANCE_RE, POSTFIX_DISTANCE_RE]) {
     for (const match of text.matchAll(pattern)) {
       const groups = match.groups || {};
       const target = groups.target || '';

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/index.js

@@ -1,5 +1,8 @@
 export * from './lexicon-core.js';
 export * from './normalization.js';
+// Both normalization and hiring-skills expose an internal regex escaper.  The
+// root API deliberately chooses the generic normalization helper instead of
+// letting ESM's ambiguous star-export rule silently omit it.
 export { escapeRegex } from './normalization.js';
 export * from './parser-core.js';
 export * from './temporal.js';

package/src/money-core.js

@@ -1,4 +1,4 @@
-import { aliasesOf, findCanonical } from './normalization.js';
+import { aliasesOf, escapeRegex, findCanonical } from './normalization.js';
 import {
   CURRENCY_SYMBOL_CANDIDATES,
   CURRENCY_TERMS,
@@ -106,10 +106,6 @@ export function moneyCurrencyFromText(value, fallbackCurrency = null) {
   return candidates[0];
 }
 
-function escapeRegex(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
 export function moneyCurrencyPattern() {
   return [...new Set(CURRENCY_TERMS.flatMap((entry) => [entry.canonical, ...aliasesOf(entry)]).filter(Boolean))]
     .sort((a, b) => String(b).length - String(a).length)

package/src/tashkent-residential-complexes.js

@@ -6,6 +6,7 @@ const AMBIGUOUS_TASHKENT_COMPLEXES = new Set([
   'City Mall',
   'Darhan',
   'Pushkin',
+  'Seoul Mun',
 ]);
 
 function complex(name, aliases = []) {
@@ -188,6 +189,10 @@ export const TASHKENT_RESIDENTIAL_COMPLEXES = Object.freeze([
   complex('Sayram Avenue'),
   complex('Sayram Plaza'),
   complex('Sayram Tower'),
+  // The development contains both a residential complex and a commercial
+  // Seoul Mun destination.  Keep the housing entity, but require an explicit
+  // residential marker so a landmark mention is never promoted to an address.
+  complex('Seoul Mun', ['Seul Mun', 'Seoul Moon', 'Seul Moon', 'Сеул Мун']),
   complex('Seoul Riverside'),
   complex('Shahriabad'),
   complex('Shohsaroy Towers'),

package/src/temporal.d.ts

@@ -2,6 +2,22 @@ import type { ParseCandidate } from './parser-core.js';
 export type TemporalContext = Readonly<{ domain?: 'real-estate' | 'vacancy'; countryCode?: string; cityId?: string; locale?: string; referenceDate?: Date | string; publishedAt?: Date | string; fetchedAt?: Date | string; source?: string }>;
 export type CalendarDateValue = Readonly<{ year: number; month: number; day: number }>;
 export type TimeValue = Readonly<{ hour: number; minute: number }>;
+export type TimeRangeValue = Readonly<{ start: TimeValue; end: TimeValue; crossesMidnight: boolean }>;
 export type DurationValue = Readonly<{ value: number; unit: 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year'; bound: 'exact' | 'min' | 'max' }>;
+export type Weekday = 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday' | 'sunday';
+export type WorkScheduleValue = Readonly<{
+  type: 'cycle' | 'weekdays' | 'custom' | 'flexible';
+  workDays?: number;
+  restDays?: number;
+  cycleHours?: Readonly<{
+    work: number;
+    rest: number;
+  }>;
+  daysOffMode?: 'fixed' | 'floating' | 'rotating';
+  workingDays?: readonly Weekday[];
+  workingHours?: TimeRangeValue;
+}>;
+export type ShiftValue = Readonly<{ name?: string; hours: TimeRangeValue }>;
+export type TemporalData = Readonly<Record<string, CalendarDateValue | DurationValue | TimeValue | TimeRangeValue | WorkScheduleValue | readonly ShiftValue[] | unknown>>;
 export function extractTemporalCandidates(value: unknown, context?: TemporalContext): readonly ParseCandidate[];
-export function parseTemporal(value: unknown, context?: TemporalContext): Readonly<{ data: Readonly<Record<string, CalendarDateValue | DurationValue | TimeValue | unknown>>; confidence: Readonly<Record<string, number>>; debug: Readonly<{ candidates: readonly ParseCandidate[]; discardedCandidates: readonly ParseCandidate[]; refinersApplied: readonly string[] }> }>;
+export function parseTemporal(value: unknown, context?: TemporalContext): Readonly<{ data: TemporalData; confidence: Readonly<Record<string, number>>; debug: Readonly<{ candidates: readonly ParseCandidate[]; discardedCandidates: readonly ParseCandidate[]; refinersApplied: readonly string[] }> }>;

package/src/temporal.js

@@ -6,58 +6,107 @@ const DATE_WORD_RE = new RegExp(`(?<![\\p{L}\\p{N}])(\\d{1,2})\\s+(${MONTH_NAMES
 const DATE_MONTH_FIRST_RE = new RegExp(`(?<![\\p{L}\\p{N}])(${MONTH_NAMES})\\s+(\\d{1,2})(?:,?\\s+(20\\d{2}))?(?![\\p{L}\\p{N}])`, 'iu');
 const DATE_NUMERIC_RE = /(?<!\d)(?:(20\d{2})-(\d{1,2})-(\d{1,2})|(\d{1,2})[./](\d{1,2})[./](20\d{2}))(?!\d)/u;
 const DATE_NUMERIC_PARTIAL_RE = /(?<![\d.])(\d{1,2})[./](\d{1,2})(?![\d.])/u;
-const TIME_RE = /(?<![\d.:])(\d{1,2})(?:[:.](\d{2}))?\s*(am|pm|утра|вечера)?(?![\d.:])/iu;
-const TIME_RANGE_RE = /(?:с|from)?\s*(\d{1,2}(?:[:.]\d{2})?\s*(?:am|pm|утра|вечера)?)\s*(?:до|to|-|–|—)\s*(\d{1,2}(?:[:.]\d{2})?\s*(?:am|pm|утра|вечера)?)/iu;
-const DURATION_RE = /(?<![\p{L}\p{N}])(?:(от|минимум|не\s+менее|до|не\s+более|на)(?:\s+на)?\s*)?(полгода|год|месяц(?:а|ев)?|мес\.?|недел[ьяи]|дн(?:я|ей)?|день|час(?:а|ов)?|мин(?:ут[аы]?|\.)?|hours?|minutes?|months?|weeks?|days?|years?)(?:\s*)?(\d+(?:[.,]\d+)?)?(?![\p{L}\p{N}])/iu;
-const DURATION_NUMBER_FIRST_RE = /(?<![\p{L}\p{N}])(?:(от|минимум|не\s+менее|до|не\s+более|на)(?:\s+на)?\s*)?(\d+(?:[.,]\d+)?)(?:-?х)?\s*(месяц(?:а|ев)?|мес\.?|недел[ьяи]|дн(?:я|ей)?|день|час(?:а|ов)?|мин(?:ут[аы]?|\.)?|hours?|minutes?|months?|weeks?|days?|years?)(?![\p{L}\p{N}])/iu;
+const TIME_SUFFIX = String.raw`(?:am|pm|утра|вечера|ранку|вечора|ertalab|kechqurun)`;
+const TIME_RE = new RegExp(String.raw`(?<![\d.:])(\d{1,2})(?:[:.](\d{2}))?\s*(${TIME_SUFFIX})?(?![\d.:])`, 'iu');
+const TIME_RANGE_RE = new RegExp(String.raw`(?:с|з|from|dan)?\s*(\d{1,2}(?:[:.]\d{2})?\s*${TIME_SUFFIX}?)\s*(?:до|to|gacha|дейін|чейин|-|–|—)\s*(\d{1,2}(?:[:.]\d{2})?\s*${TIME_SUFFIX}?)`, 'iu');
+const DURATION_PREFIX = String.raw`(?:от|минимум|не\s+менее|kamida|eng\s+kam|кемінде|не\s+менш(?:е)?|at\s+least|до|не\s+более|ko'?pi\s+bilan|көп\s+емес|на|uchun|pe\s+o\s+perioadă\s+de)`;
+const DURATION_UNIT = String.raw`(?:полгода|год(?:а|ов)?|yil(?:ga)?|жыл(?:ға)?|рок(?:и|ів)?|an(?:i)?|месяц(?:а|ев)?|мес\.?|oy(?:ga)?|місяц(?:і|ів|я)?|luni?|недел[ьяи]|hafta(?:ga)?|апта(?:ға)?|тиж(?:день|ні|нів|ня)|săptămân\p{L}*|saptaman\p{L}*|дн(?:я|ей)?|день|kun(?:ga)?|күн(?:ге)?|день|днів|дні|zi(?:le)?|час(?:а|ов)?|soat(?:ga)?|сағат(?:қа)?|годин(?:а|и|у)?|ore?|мин(?:ут[аы]?|\.)?|daqiqa|минут\p{L}*|minute?)`;
+const DURATION_RE = new RegExp(String.raw`(?<![\p{L}\p{N}])(?:(` + DURATION_PREFIX + String.raw`)(?:\s+на)?\s*)?(` + DURATION_UNIT + String.raw`)(?:\s*)?(\d+(?:[.,]\d+)?)?(?![\p{L}\p{N}])`, 'iu');
+const DURATION_NUMBER_FIRST_RE = new RegExp(String.raw`(?<![\p{L}\p{N}])(?:(` + DURATION_PREFIX + String.raw`)(?:\s+на)?\s*)?(\d+(?:[.,]\d+)?)(?:-?х)?\s*(` + DURATION_UNIT + String.raw`)(?![\p{L}\p{N}])`, 'iu');
 const WEEKDAYS = Object.freeze(['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']);
-const DAY_ALIASES = Object.freeze({ пн: 0, понедельник: 0, понедельника: 0, mon: 0, monday: 0, вт: 1, вторник: 1, вторника: 1, tue: 1, tuesday: 1, ср: 2, среда: 2, среды: 2, wed: 2, wednesday: 2, чт: 3, четверг: 3, четверга: 3, thu: 3, thursday: 3, пт: 4, пятница: 4, пятницы: 4, fri: 4, friday: 4, сб: 5, суббота: 5, субботы: 5, sat: 5, saturday: 5, вс: 6, воскресенье: 6, воскресенья: 6, sun: 6, sunday: 6 });
-const RELATIVE_RE = /(?<![\p{L}\p{N}])(?:с\s+)?(сегодня|завтра|послезавтра|today|tomorrow|day\s+after\s+tomorrow|через\s+(\d+|неделю|две\s+недели)\s*(?:дн(?:я|ей)?|день|недел[ьюи])?)(?![\p{L}\p{N}])/giu;
+const DAY_ALIASES = Object.freeze({
+  пн: 0, понедельник: 0, понедельника: 0, понеділок: 0, понеділка: 0, mon: 0, monday: 0, dushanba: 0, дүйсенбі: 0, дүйшөмбү: 0, luni: 0,
+  вт: 1, вторник: 1, вторника: 1, вівторок: 1, вівторка: 1, tue: 1, tuesday: 1, seshanba: 1, сейсенбі: 1, шейшемби: 1, marți: 1, marti: 1,
+  ср: 2, среда: 2, среды: 2, середа: 2, середи: 2, wed: 2, wednesday: 2, chorshanba: 2, сәрсенбі: 2, шаршемби: 2, miercuri: 2,
+  чт: 3, четверг: 3, четверга: 3, четвер: 3, четверга: 3, thu: 3, thursday: 3, payshanba: 3, бейсенбі: 3, бейшемби: 3, joi: 3,
+  пт: 4, пятница: 4, пятницы: 4, "п'ятниця": 4, 'п’ятниця': 4, пятниця: 4, fri: 4, friday: 4, juma: 4, жұма: 4, жума: 4, vineri: 4,
+  сб: 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 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+|next\\s+)(${DAY_PATTERN})(?![\\p{L}\\p{N}])`, 'giu');
-const END_OF_MONTH_RE = new RegExp(`(?<![\\p{L}\\p{N}])(?:до|until|available\\s+until)\\s+(?:конца|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)\s+(?:начала\s+месяца|start\s+of\s+(?:the\s+)?month)(?![\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 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 referenceDate(context = {}) { return new Date(context.referenceDate || context.publishedAt || context.fetchedAt || Date.now()); }
+function referenceEntry(context = {}) {
+  for (const [source, value] of [['referenceDate', context.referenceDate], ['publishedAt', context.publishedAt], ['fetchedAt', context.fetchedAt]]) {
+    if (value == null || value === '') continue;
+    const date = new Date(value);
+    if (Number.isFinite(date.getTime())) return Object.freeze({ date, source });
+  }
+  return Object.freeze({ date: new Date(), source: 'currentDate' });
+}
+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|доступна\s+с|заезд\s+с)/iu.test(before) ? 'from' : /(?:до|until|не\s+позднее)/iu.test(before) ? 'until' : 'exact'; }
+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; }
-function parseClock(raw) { const match = String(raw).trim().match(/^(\d{1,2})(?:[:.](\d{2}))?\s*(am|pm|утра|вечера)?$/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 (/вечера/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/u.test(normalized) || normalized === 'полгода' ? 'year' : /месяц|мес|month/u.test(normalized) ? 'month' : /нед|week/u.test(normalized) ? 'week' : /дн|день|day/u.test(normalized) ? 'day' : /мин|minute/u.test(normalized) ? 'minute' : 'hour'; const bound = /от|минимум|не\s+менее/iu.test(prefix || '') ? 'min' : /до|не\s+более/iu.test(prefix || '') ? 'max' : 'exact'; return Object.freeze({ value, unit: canonicalUnit, bound }); }
-function semanticDurationType(text, start) {
+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) {
   const before = text.slice(Math.max(0, start - 56), start);
   const after = text.slice(start, Math.min(text.length, start + 56));
   if (/(?:испытательн(?:ый)?\s+срок|probation)[^.;\n]{0,30}$/iu.test(before)) return 'probationDuration';
   if (/(?:контракт|contract)[^.;\n]{0,30}$/iu.test(before)) return 'contractDuration';
-  if (/(?:сда[её]т|квартир|аренд|ijara|rent)[^.;\n]{0,45}$/iu.test(before) || /(?:сда[её]т|квартир|аренд|ijara|rent)/iu.test(after)) return 'minimumRentalDuration';
+  if (/(?:сда[её]т|квартир|аренд|ijara|rent|ijaraga\s+beril|оренд)[^.;\n]{0,45}$/iu.test(before) || /(?:сда[её]т|квартир|аренд|ijara|rent|ijaraga\s+beril|оренд)/iu.test(after)) {
+    if (duration?.bound === 'max') return 'maximumRentalDuration';
+    if (duration?.bound === 'exact') return 'fixedRentalDuration';
+    return 'minimumRentalDuration';
+  }
   return 'duration';
 }
 function addUtcDays(date, days) { const copy = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate() + days)); return dateValue(copy.getUTCFullYear(), copy.getUTCMonth() + 1, copy.getUTCDate()); }
-function relativeDays(raw) { const lower = raw.toLowerCase(); if (/сегодня|today/u.test(lower)) return 0; if (/завтра|tomorrow/u.test(lower)) return 1; if (/послезавтра|day\s+after/u.test(lower)) return 2; if (/две\s+недели/u.test(lower)) return 14; if (/неделю/u.test(lower)) return 7; const numeric = Number(lower.match(/\d+/u)?.[0]); return Number.isFinite(numeric) ? numeric : null; }
-function temporalContextType(text, start, context) { const around = text.slice(Math.max(0, start - 48), Math.min(text.length, start + 48)); if (/(?:свобод|доступ|заезд|заезж|move[- ]?in|available)/iu.test(around)) return 'availabilityDate'; if ((context.domain === 'vacancy' || /(?:ваканс|работ|job)/iu.test(around)) && /(?:выход|start|приступ)/iu.test(around)) return 'startDate'; return 'relativeDate'; }
+function relativeDays(raw) { const lower = raw.toLowerCase(); if (/сегодня|сьогодні|bugun|бүгін|бүгүн|astăzi|azi|today/u.test(lower)) return 0; if (/послезавтра|післязавтра|indin|бүрсігүні|бүрсүгүнү|poimâine|poimaine|day\s+after/u.test(lower)) return 2; if (/завтра|ertaga|ертең|эртең|mâine|maine|tomorrow/u.test(lower)) return 1; if (/две\s+недели/u.test(lower)) return 14; if (/неделю/u.test(lower)) return 7; const numeric = Number(lower.match(/\d+/u)?.[0]); return Number.isFinite(numeric) ? numeric : null; }
+function relativeDurationDays(amount, unit) {
+  const value = Number(amount);
+  if (!Number.isFinite(value) || value < 0) return null;
+  return /(?:тиж|săptăm|saptaman|апта|жума)/iu.test(unit) ? value * 7 : value;
+}
+function temporalContextType(text, start, context) { const around = text.slice(Math.max(0, start - 48), Math.min(text.length, start + 48)); if (/(?:свобод|доступ|заезд|заезж|ijara|bo['’`]?sh|бос|бош|вільн|disponibil|move[- ]?in|available)/iu.test(around)) return 'availabilityDate'; if ((context.domain === 'vacancy' || /(?:ваканс|работ|job|ish\s+grafigi|графік)/iu.test(around)) && /(?:выход|start|приступ|boshlash)/iu.test(around)) return 'startDate'; return 'relativeDate'; }
 function dateEntityType(text, start, context, relation = relationNear(text, start)) {
   const around = text.slice(Math.max(0, start - 48), Math.min(text.length, start + 48));
   if (/(?:deadline|apply\s+by|closing\s+date|дедлайн|срок(?:\s+подачи)?|термін(?:\s+подання)?)/iu.test(around)) return 'deadline';
   if (/(?:published|publication|опубликован|опублікован)/iu.test(around)) return 'publicationDate';
-  if (relation === 'until' || /(?:свобод|доступ|заезд|заезж|move[- ]?in|available)/iu.test(around) && /(?:до|until)/iu.test(around)) return 'availabilityUntil';
-  if (relation === 'from' || (context.domain === 'real-estate' && /(?:свобод|доступ|заезд|заезж|move[- ]?in|available)/iu.test(around))) return 'availabilityDate';
+  // Direction must belong to this date's local left context. Looking ahead
+  // across a whole listing makes "available from 12 February, until March"
+  // incorrectly classify the February date as an end date.
+  if (relation === 'until') return 'availabilityUntil';
+  if (relation === 'from' || (context.domain === 'real-estate' && /(?:свобод|доступ|заезд|заезж|ijara|bo['’`]?sh|вільн|disponibil|move[- ]?in|available)/iu.test(around))) return 'availabilityDate';
   return 'calendarDate';
 }
-function inferredDateEvidence(inferred, context) { return inferred ? [{ type: 'inferred-year', reference: context.referenceDate ? 'referenceDate' : context.publishedAt ? 'publishedAt' : context.fetchedAt ? 'fetchedAt' : 'currentDate' }] : []; }
+function inferredDateEvidence(inferred, context) { return inferred ? [{ type: 'inferred-year', reference: referenceEntry(context).source }] : []; }
+const SCHEDULE_CONTEXT_RE = /(?:график|смен[аы]|режим\s+работы|work\s*schedule|shift|работ[аы]|job|графік|змін[аи]|program(?:ul)?\s+de\s+lucru|ish\s+grafigi|жұмыс\s+кестесі|жумуш\s+графиги)/iu;
+function scheduleDaysOffMode(text) {
+  if (/(?:плавающ|floating|flexible\s+days\s+off)/iu.test(text)) return 'floating';
+  if (/(?:скользящ|сменн|rotating\s+days\s+off|выходные\s+по\s+графику)/iu.test(text)) return 'rotating';
+  return 'fixed';
+}
+function cycleScheduleValue(work, rest, daysOffMode) {
+  // Day cycles such as 2/2 and 5/2 are common. Values larger than a week in
+  // an explicit schedule context are the conventional shift notation 24/48
+  // or 12/24, not a claim of dozens of working days.
+  if (Math.max(work, rest) > 7) {
+    // An hour cycle has no fixed weekday rest days. Keep an explicitly
+    // floating mode, otherwise expose the inherent repeating rotation.
+    return Object.freeze({ type: 'cycle', cycleHours: Object.freeze({ work, rest }), daysOffMode: daysOffMode === 'fixed' ? 'rotating' : daysOffMode });
+  }
+  return Object.freeze({ type: 'cycle', workDays: work, restDays: rest, daysOffMode });
+}
 function isTimeRangeContextual(match, text) {
-  if (/[.:]|\b(?:am|pm|утра|вечера)\b/iu.test(match[0])) return true;
+  if (/[.:]|\b(?:am|pm|утра|вечера|ранку|вечора|ertalab|kechqurun)\b/iu.test(match[0])) return true;
   if (/^\s*(?:с|from)\b/iu.test(match[0])) return true;
   const start = match.index ?? 0;
-  return /(?:график|смен[аы]|режим\s+работы|work\s*schedule|shift|работ[аы]|job)/iu.test(text.slice(Math.max(0, start - 32), start + match[0].length + 32));
+  return SCHEDULE_CONTEXT_RE.test(text.slice(Math.max(0, start - 32), start + match[0].length + 32));
 }
 function isClockContextual(match, text) {
-  if (/(?:am|pm|утра|вечера)/iu.test(match[0])) return true;
+  if (/(?:am|pm|утра|вечера|ранку|вечора|ertalab|kechqurun)/iu.test(match[0])) return true;
   const start = match.index ?? 0;
-  return /(?:график|смен[аы]|режим\s+работы|work\s*schedule|shift|работ[аы]|job)/iu.test(text.slice(Math.max(0, start - 24), start + match[0].length + 24));
+  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 nextWeekday(date, weekday) { const current = (date.getUTCDay() + 6) % 7; let days = (weekday - current + 7) % 7; if (days === 0) days = 7; return addUtcDays(date, days); }
@@ -93,15 +142,23 @@ export function extractTemporalCandidates(value, context = {}) {
   }
   for (const match of text.matchAll(START_OF_MONTH_RE)) {
     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: context.referenceDate ? 'referenceDate' : context.publishedAt ? 'publishedAt' : context.fetchedAt ? 'fetchedAt' : 'currentDate' }]));
+    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_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: context.referenceDate ? 'referenceDate' : context.publishedAt ? 'publishedAt' : context.fetchedAt ? 'fetchedAt' : 'currentDate' }]));
+    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 }]));
+  }
+  for (const match of text.matchAll(RELATIVE_RE)) { const days = relativeDays(match[1]); if (days == null) continue; const type = temporalContextType(text, match.index ?? 0, context); candidates.push(candidate(type, addUtcDays(referenceDate(context), days), match, 'temporal.relative-date', .91, [{ type: 'context', value: `relative:${days}d` }, { type: 'reference-date', value: referenceEntry(context).source }])); }
+  for (const match of text.matchAll(EXTENDED_RELATIVE_RE)) {
+    const amount = match[1] || match[3] || match[5];
+    const unit = match[2] || match[4] || match[6];
+    const days = relativeDurationDays(amount, unit);
+    if (days == null) continue;
+    const type = temporalContextType(text, match.index ?? 0, 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(RELATIVE_RE)) { const days = relativeDays(match[1]); if (days == null) continue; const type = temporalContextType(text, match.index ?? 0, context); candidates.push(candidate(type, addUtcDays(referenceDate(context), days), match, 'temporal.relative-date', .91, [{ type: 'context', value: `relative:${days}d` }, { type: 'reference-date', value: context.referenceDate ? 'referenceDate' : context.publishedAt ? 'publishedAt' : context.fetchedAt ? 'fetchedAt' : 'currentDate' }])); }
-  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, 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, 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_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] }] : [])])); }
   const timeRangeSpans = [];
   for (const match of text.matchAll(new RegExp(TIME_RANGE_RE, 'giu'))) {
     const start = parseClock(match[1]); const end = parseClock(match[2]);
@@ -114,14 +171,17 @@ export function extractTemporalCandidates(value, context = {}) {
     if (timeRangeSpans.some(([rangeStart, rangeEnd]) => start >= rangeStart && end <= rangeEnd) || !isClockContextual(match, text)) continue;
     const clock = parseClock(match[0]); if (clock) candidates.push(candidate('clockTime', clock, match, 'temporal.clock-time', .94, [{ type: 'clock', value: 'explicit' }]));
   }
-  const scheduleContext = /(?:график|смен[аы]|режим\s+работы|work\s*schedule|shift|работ[аы]|job)/iu;
+  const scheduleContext = SCHEDULE_CONTEXT_RE;
   for (const match of text.matchAll(/(?<![\d:.])(\d{1,2})\s*(?:\/|\\|через|-)\s*(\d{1,2})(?![\d:.])/giu)) {
     const around = text.slice(Math.max(0, (match.index ?? 0) - 32), (match.index ?? 0) + match[0].length + 32); if (!scheduleContext.test(around)) continue;
-    candidates.push(candidate('workSchedule', Object.freeze({ type: 'cycle', workDays: Number(match[1]), restDays: Number(match[2]), daysOffMode: /плавающ|скользящ|сменн/iu.test(around) ? 'rotating' : 'fixed' }), match, 'temporal.schedule-cycle', .99, [{ type: 'context', value: 'schedule' }, { type: 'range', value: 'cycle' }]));
+    const daysOffMode = scheduleDaysOffMode(around);
+    const work = Number(match[1]); const rest = Number(match[2]);
+    candidates.push(candidate('workSchedule', cycleScheduleValue(work, rest, daysOffMode), match, 'temporal.schedule-cycle', .99, [{ type: 'context', value: 'schedule' }, { type: 'range', value: Math.max(work, rest) > 7 ? 'cycle-hours' : 'cycle' }, { type: 'days-off-mode', value: daysOffMode }]));
   }
   for (const match of text.matchAll(/(?<![\p{L}\p{N}])два\s+через\s+два(?![\p{L}\p{N}])/giu)) {
     const around = text.slice(Math.max(0, (match.index ?? 0) - 32), (match.index ?? 0) + match[0].length + 32); if (!scheduleContext.test(around)) continue;
-    candidates.push(candidate('workSchedule', Object.freeze({ type: 'cycle', workDays: 2, restDays: 2, daysOffMode: /плавающ|скользящ|сменн/iu.test(around) ? 'rotating' : 'fixed' }), match, 'temporal.schedule-cycle.words', .97, [{ type: 'context', value: 'schedule' }, { type: 'range', value: 'cycle' }]));
+    const daysOffMode = scheduleDaysOffMode(around);
+    candidates.push(candidate('workSchedule', Object.freeze({ type: 'cycle', workDays: 2, restDays: 2, daysOffMode }), match, 'temporal.schedule-cycle.words', .97, [{ type: 'context', value: 'schedule' }, { type: 'range', value: 'cycle' }, { type: 'days-off-mode', value: daysOffMode }]));
   }
   for (const match of text.matchAll(WEEKDAY_RANGE_RE)) {
     const start = DAY_ALIASES[match[1].toLowerCase()]; const end = DAY_ALIASES[match[2].toLowerCase()];

package/src/ua-location-extensions-metro.js

@@ -87,7 +87,7 @@ export const UA_METRO_LOCATION_EXTENSIONS = Object.freeze({
       ['Palats Sportu', 'Палац Спорту', 'Дворец Спорта'],
       ['Akademika Pavlova', 'Академіка Павлова', 'Академика Павлова', 'Ак. Павлова', 'Ак Павлова'],
       ['Studentska', 'Студентська', 'Студенческая'],
-      ['Saltivska', 'Heroiv Pratsi', 'Салтівська', 'Героїв Праці', 'Героев Труда'],
+      ['Saltivska', 'Heroiv Pratsi', 'Салтівська', 'Героїв Праці', 'Героев Труда', 'Героев Праці', 'Героев праци'],
       ['Peremoha', 'Перемога', 'Победа'],
       ['Oleksiivska', 'Олексіївська', 'Алексеевская'],
       ['Naukova', 'Наукова', 'Научная'],
@@ -104,4 +104,4 @@ export const UA_METRO_LOCATION_EXTENSIONS = Object.freeze({
       ['Metrobudivnykiv', 'Метробудівників', 'Метростроителей'],
     ]),
   }),
-});
+});