@whiteslove/parsing-lexicon 0.2.14 → 0.3.2

package/index.d.ts

@@ -80,7 +80,7 @@ export type SearchCluster = Readonly<{
 export type AreaEntry = Readonly<{
   canonical: string;
   name: string;
-  type: 'local_area';
+  type: 'local_area' | 'microdistrict';
   country: 'UZ';
   city: 'Tashkent';
   aliases: readonly string[];
@@ -92,6 +92,7 @@ export type LocationCityDictionary = Readonly<{
   localAreas?: readonly LocationEntry[];
   suburbs?: readonly LocationEntry[];
   settlements?: readonly LocationEntry[];
+  developmentAreas?: readonly LocationEntry[];
   metro?: readonly LocationEntry[] | readonly MetroStation[];
   residentialComplexes?: readonly LocationEntry[];
   streets?: readonly LocationEntry[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whiteslove/parsing-lexicon",
-  "version": "0.2.14",
+  "version": "0.3.2",
   "description": "Shared deterministic multilingual parsing lexicon for Whiteslove housing and hiring services",
   "repository": {
     "type": "git",
@@ -10,15 +10,27 @@
   "main": "./src/index.js",
   "types": "./index.d.ts",
   "exports": {
-    ".": { "types": "./index.d.ts", "import": "./src/index.js" },
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./src/index.js"
+    },
     "./lexicon-core": "./src/lexicon-core.js",
     "./normalization": "./src/normalization.js",
     "./countries": "./src/countries.js",
-    "./country-context": { "types": "./src/country-context.d.ts", "import": "./src/country-context.js" },
+    "./country-context": {
+      "types": "./src/country-context.d.ts",
+      "import": "./src/country-context.js"
+    },
     "./geo": "./src/geo.js",
     "./geography": "./src/geography.js",
-    "./geography-display": { "types": "./src/geography-display.d.ts", "import": "./src/geography-display.js" },
-    "./geography-detection": { "types": "./src/geography-detection.d.ts", "import": "./src/geography-detection.js" },
+    "./geography-display": {
+      "types": "./src/geography-display.d.ts",
+      "import": "./src/geography-display.js"
+    },
+    "./geography-detection": {
+      "types": "./src/geography-detection.d.ts",
+      "import": "./src/geography-detection.js"
+    },
     "./central-asia": "./src/central-asia.js",
     "./ukraine": "./src/ukraine.js",
     "./location-merge": "./src/location-merge.js",
@@ -33,54 +45,170 @@
     "./tashkent-colloquial": "./src/tashkent-colloquial.js",
     "./tashkent-residential-complexes": "./src/tashkent-residential-complexes.js",
     "./tashkent-pois": "./src/tashkent-pois.js",
-    "./tashkent-housing-geography": { "types": "./src/tashkent-housing-geography.d.ts", "import": "./src/tashkent-housing-geography.js" },
+    "./tashkent-housing-geography": {
+      "types": "./src/tashkent-housing-geography.d.ts",
+      "import": "./src/tashkent-housing-geography.js"
+    },
     "./odesa-metropolitan": "./src/odesa-metropolitan.js",
     "./housing": "./src/housing.js",
-    "./housing-intent": { "types": "./src/housing-intent.d.ts", "import": "./src/housing-intent.js" },
-    "./housing-commercial": { "types": "./src/housing-commercial.d.ts", "import": "./src/housing-commercial.js" },
-    "./housing-context": { "types": "./src/housing-context.d.ts", "import": "./src/housing-context.js" },
-    "./housing-address": { "types": "./src/housing-address.d.ts", "import": "./src/housing-address.js" },
-    "./housing-structured": { "types": "./src/housing-structured.d.ts", "import": "./src/housing-structured.js" },
-    "./housing-safety": { "types": "./src/housing-safety.d.ts", "import": "./src/housing-safety.js" },
-    "./housing-title": { "types": "./src/housing-title.d.ts", "import": "./src/housing-title.js" },
-    "./housing-language": { "types": "./src/housing-language.d.ts", "import": "./src/housing-language.js" },
-    "./housing-features": { "types": "./src/housing-features.d.ts", "import": "./src/housing-features.js" },
-    "./housing-listing-fields": { "types": "./src/housing-listing-fields.d.ts", "import": "./src/housing-listing-fields.js" },
-    "./housing-text": { "types": "./src/housing-text.d.ts", "import": "./src/housing-text.js" },
-    "./housing-source-aliases": { "types": "./src/housing-source-aliases.d.ts", "import": "./src/housing-source-aliases.js" },
+    "./housing-intent": {
+      "types": "./src/housing-intent.d.ts",
+      "import": "./src/housing-intent.js"
+    },
+    "./housing-commercial": {
+      "types": "./src/housing-commercial.d.ts",
+      "import": "./src/housing-commercial.js"
+    },
+    "./housing-context": {
+      "types": "./src/housing-context.d.ts",
+      "import": "./src/housing-context.js"
+    },
+    "./housing-address": {
+      "types": "./src/housing-address.d.ts",
+      "import": "./src/housing-address.js"
+    },
+    "./housing-structured": {
+      "types": "./src/housing-structured.d.ts",
+      "import": "./src/housing-structured.js"
+    },
+    "./housing-safety": {
+      "types": "./src/housing-safety.d.ts",
+      "import": "./src/housing-safety.js"
+    },
+    "./housing-title": {
+      "types": "./src/housing-title.d.ts",
+      "import": "./src/housing-title.js"
+    },
+    "./housing-language": {
+      "types": "./src/housing-language.d.ts",
+      "import": "./src/housing-language.js"
+    },
+    "./housing-features": {
+      "types": "./src/housing-features.d.ts",
+      "import": "./src/housing-features.js"
+    },
+    "./housing-listing-fields": {
+      "types": "./src/housing-listing-fields.d.ts",
+      "import": "./src/housing-listing-fields.js"
+    },
+    "./housing-text": {
+      "types": "./src/housing-text.d.ts",
+      "import": "./src/housing-text.js"
+    },
+    "./housing-source-aliases": {
+      "types": "./src/housing-source-aliases.d.ts",
+      "import": "./src/housing-source-aliases.js"
+    },
     "./housing-poi-extensions": "./src/housing-poi-extensions.js",
-    "./housing-display": { "types": "./src/housing-display.d.ts", "import": "./src/housing-display.js" },
-    "./housing-listing-enrichment": { "types": "./src/housing-listing-enrichment.d.ts", "import": "./src/housing-listing-enrichment.js" },
+    "./housing-display": {
+      "types": "./src/housing-display.d.ts",
+      "import": "./src/housing-display.js"
+    },
+    "./housing-listing-enrichment": {
+      "types": "./src/housing-listing-enrichment.d.ts",
+      "import": "./src/housing-listing-enrichment.js"
+    },
     "./hiring": "./src/hiring.js",
     "./hiring-languages": "./src/hiring-languages.js",
-    "./hiring-language-extensions": { "types": "./src/hiring-language-extensions.d.ts", "import": "./src/hiring-language-extensions.js" },
-    "./hiring-context": { "types": "./src/hiring-context.d.ts", "import": "./src/hiring-context.js" },
-    "./hiring-source-aliases": { "types": "./src/hiring-source-aliases.d.ts", "import": "./src/hiring-source-aliases.js" },
-    "./hiring-source-semantics": { "types": "./src/hiring-source-semantics.d.ts", "import": "./src/hiring-source-semantics.js" },
-    "./hiring-requirements": { "types": "./src/hiring-requirements.d.ts", "import": "./src/hiring-requirements.js" },
-    "./hiring-semantics": { "types": "./src/hiring-semantics.d.ts", "import": "./src/hiring-semantics.js" },
-    "./hiring-work-semantics": { "types": "./src/hiring-work-semantics.d.ts", "import": "./src/hiring-work-semantics.js" },
-    "./hiring-candidate-fields": { "types": "./src/hiring-candidate-fields.d.ts", "import": "./src/hiring-candidate-fields.js" },
-    "./hiring-temporal": { "types": "./src/hiring-temporal.d.ts", "import": "./src/hiring-temporal.js" },
-    "./hiring-vacancy-fields": { "types": "./src/hiring-vacancy-fields.d.ts", "import": "./src/hiring-vacancy-fields.js" },
-    "./hiring-location-fields": { "types": "./src/hiring-location-fields.d.ts", "import": "./src/hiring-location-fields.js" },
-    "./hiring-salary-context": { "types": "./src/hiring-salary-context.d.ts", "import": "./src/hiring-salary-context.js" },
+    "./hiring-language-extensions": {
+      "types": "./src/hiring-language-extensions.d.ts",
+      "import": "./src/hiring-language-extensions.js"
+    },
+    "./hiring-context": {
+      "types": "./src/hiring-context.d.ts",
+      "import": "./src/hiring-context.js"
+    },
+    "./hiring-source-aliases": {
+      "types": "./src/hiring-source-aliases.d.ts",
+      "import": "./src/hiring-source-aliases.js"
+    },
+    "./hiring-source-semantics": {
+      "types": "./src/hiring-source-semantics.d.ts",
+      "import": "./src/hiring-source-semantics.js"
+    },
+    "./hiring-requirements": {
+      "types": "./src/hiring-requirements.d.ts",
+      "import": "./src/hiring-requirements.js"
+    },
+    "./hiring-semantics": {
+      "types": "./src/hiring-semantics.d.ts",
+      "import": "./src/hiring-semantics.js"
+    },
+    "./hiring-work-semantics": {
+      "types": "./src/hiring-work-semantics.d.ts",
+      "import": "./src/hiring-work-semantics.js"
+    },
+    "./hiring-candidate-fields": {
+      "types": "./src/hiring-candidate-fields.d.ts",
+      "import": "./src/hiring-candidate-fields.js"
+    },
+    "./hiring-temporal": {
+      "types": "./src/hiring-temporal.d.ts",
+      "import": "./src/hiring-temporal.js"
+    },
+    "./hiring-vacancy-fields": {
+      "types": "./src/hiring-vacancy-fields.d.ts",
+      "import": "./src/hiring-vacancy-fields.js"
+    },
+    "./hiring-location-fields": {
+      "types": "./src/hiring-location-fields.d.ts",
+      "import": "./src/hiring-location-fields.js"
+    },
+    "./hiring-salary-context": {
+      "types": "./src/hiring-salary-context.d.ts",
+      "import": "./src/hiring-salary-context.js"
+    },
     "./money": "./src/money.js",
-    "./currency": { "types": "./src/currency.d.ts", "import": "./src/currency.js" },
-    "./contact": { "types": "./src/contact.d.ts", "import": "./src/contact.js" },
-    "./housing-money": { "types": "./src/housing-money.d.ts", "import": "./src/housing-money.js" },
+    "./currency": {
+      "types": "./src/currency.d.ts",
+      "import": "./src/currency.js"
+    },
+    "./contact": {
+      "types": "./src/contact.d.ts",
+      "import": "./src/contact.js"
+    },
+    "./housing-money": {
+      "types": "./src/housing-money.d.ts",
+      "import": "./src/housing-money.js"
+    },
     "./hiring-professions": "./src/hiring-professions.js",
-    "./hiring-skills": { "types": "./src/hiring-skills.d.ts", "import": "./src/hiring-skills.js" },
+    "./hiring-skills": {
+      "types": "./src/hiring-skills.d.ts",
+      "import": "./src/hiring-skills.js"
+    },
     "./hiring-advanced": "./src/hiring-advanced.js"
   },
-  "files": ["src", "index.d.ts", "README.md"],
+  "files": [
+    "src",
+    "index.d.ts",
+    "README.md"
+  ],
   "sideEffects": false,
-  "engines": { "node": ">=20" },
-  "scripts": { "test": "node --test" },
-  "publishConfig": { "access": "public" },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
     "libphonenumber-js": "^1.11.20"
   },
-  "keywords": ["parsing", "lexicon", "uzbek", "kazakh", "ukrainian", "romanian", "russian", "housing", "hiring", "salary", "professions", "geography"],
+  "keywords": [
+    "parsing",
+    "lexicon",
+    "uzbek",
+    "kazakh",
+    "ukrainian",
+    "romanian",
+    "russian",
+    "housing",
+    "hiring",
+    "salary",
+    "professions",
+    "geography"
+  ],
   "license": "MIT"
 }

package/src/central-asia-locations.js

@@ -22,6 +22,7 @@ const TYPE_BY_KEY = Object.freeze({
   localAreas: 'local_area',
   suburbs: 'suburb',
   settlements: 'settlement',
+  developmentAreas: 'development_area',
   metro: 'metro',
   residentialComplexes: 'residential_complex',
   streets: 'street',
@@ -73,31 +74,85 @@ function explicitCityFromText(text, countryCode) {
   return matches[0]?.item?.canonical || null;
 }
 
-function isExplicitMetroContext(value, match) {
-  const start = match.index ?? 0;
-  const end = start + match[0].length;
-  const before = value.slice(Math.max(0, start - 36), start);
-  const after = value.slice(end, end + 36);
-  return /(?:метро|metro|станц(?:ия|ии)?|station|ст\.?\s*м\.?|м\.)\s*[:\-–—]?\s*$/iu.test(before)
-    || /^\s*(?:метро|metro|station|станц(?:ия|ии)?)(?=$|[^\p{L}\p{N}_])/iu.test(after);
+const CONTEXT_PATTERNS = Object.freeze({
+  metro: Object.freeze({
+    before: /(?:метро|metro|станц(?:ия|ии)?|station|ст\.?\s*м\.?)\s*[:\-–—]?\s*$/iu,
+    after: /^\s*[:\-–—]?\s*(?:метро|metro|станц(?:ия|ии)?|station)(?=$|[^\p{L}\p{N}_])/iu,
+    inside: /(?:метро|metro|станц(?:ия|ии)?|station)/iu,
+  }),
+  district: Object.freeze({
+    before: /(?:район|р-н|рн|туман\p{L}{0,4}|tumani|district)\s*[:\-–—]?\s*$/iu,
+    after: /^\s*[:\-–—]?\s*(?:район|р-н|рн|туман\p{L}{0,4}|tumani|district)(?=$|[^\p{L}\p{N}_])/iu,
+  }),
+  mahalla: Object.freeze({
+    before: /(?:махалл(?:а|я)|маҳалла(?:си)?|mahalla(?:si)?|mfy|мфй)\s*[:\-–—]?\s*$/iu,
+    after: /^\s*[:\-–—]?\s*(?:махалл(?:а|я)|маҳалла(?:си)?|mahalla(?:si)?|mfy|мфй)(?=$|[^\p{L}\p{N}_])/iu,
+  }),
+  microdistrict: Object.freeze({
+    before: /(?:массив(?:и)?|massiv(?:i)?|жилмассив|ж\/м|микрорайон|мкр\.?|mavze(?:si)?|мавзе(?:си)?|квартал|kvartal|daha|даха|даҳа)\s*[:\-–—]?\s*$/iu,
+    after: /^\s*(?:\d{1,2}[aа]?\s*)?[:\-–—]?\s*(?:массив(?:и)?|massiv(?:i)?|жилмассив|ж\/м|микрорайон|мкр\.?|mavze(?:si)?|мавзе(?:си)?|квартал|kvartal|daha|даха|даҳа)(?=$|[^\p{L}\p{N}_])/iu,
+  }),
+  local_area: Object.freeze({
+    before: /(?:массив(?:и)?|massiv(?:i)?|жилмассив|ж\/м|микрорайон|мкр\.?|mavze(?:si)?|мавзе(?:си)?|квартал|kvartal|daha|даха|даҳа|зона|area)\s*[:\-–—]?\s*$/iu,
+    after: /^\s*(?:\d{1,2}[aа]?\s*)?[:\-–—]?\s*(?:массив(?:и)?|massiv(?:i)?|жилмассив|ж\/м|микрорайон|мкр\.?|mavze(?:si)?|мавзе(?:си)?|квартал|kvartal|daha|даха|даҳа|зона|area)(?=$|[^\p{L}\p{N}_])/iu,
+  }),
+  development_area: Object.freeze({
+    before: /(?:(?:международн\p{L}*|international)\s+)?(?:бизнес[-\s]?центр|делов\p{L}*\s+центр|business\s+cent(?:er|re)|development\s+area|mixed[-\s]?use\s+(?:district|development))\s*[:\-–—]?\s*$/iu,
+    after: /^\s*[:\-–—]?\s*(?:(?:международн\p{L}*|international)\s+)?(?:бизнес[-\s]?центр|делов\p{L}*\s+центр|business\s+cent(?:er|re)|development\s+area|mixed[-\s]?use\s+(?:district|development))(?=$|[^\p{L}\p{N}_])/iu,
+  }),
+  residential_complex: Object.freeze({
+    before: /(?:жк|жилой\s+комплекс|residential\s+complex|residence|turar\s+joy\s+majmuasi|tjm)\s*[:\-–—]?\s*$/iu,
+    after: /^\s*[:\-–—]?\s*(?:жк|жилой\s+комплекс|residential\s+complex|residence|turar\s+joy\s+majmuasi|tjm)(?=$|[^\p{L}\p{N}_])/iu,
+  }),
+  street: Object.freeze({
+    before: /(?:улица|ул\.?|street|st\.?|ko['’ʻ]?cha(?:si)?|кўча(?:си)?)\s*[:\-–—]?\s*$/iu,
+    after: /^\s*[:\-–—]?\s*(?:улица|ул\.?|street|st\.?|ko['’ʻ]?cha(?:si)?|кўча(?:си)?)(?=$|[^\p{L}\p{N}_])/iu,
+  }),
+  poi: Object.freeze({
+    before: /(?:базар|рынок|bozor(?:i)?|мечет\p{L}*|масжид|masjid|mosque|парк|park|mall|молл|трц|тц|вокзал|аэропорт|airport|университет|university)\s*[:\-–—]?\s*$/iu,
+    after: /^\s*[:\-–—]?\s*(?:базар|рынок|bozor(?:i)?|мечет\p{L}*|масжид|masjid|mosque|парк|park|mall|молл|трц|тц|вокзал|аэропорт|airport|университет|university)(?=$|[^\p{L}\p{N}_])/iu,
+  }),
+});
+
+function hasExplicitContext(value, candidate) {
+  const pattern = CONTEXT_PATTERNS[candidate.type];
+  if (!pattern) return false;
+  const before = value.slice(Math.max(0, candidate.start - 40), candidate.start);
+  const after = value.slice(candidate.end, Math.min(value.length, candidate.end + 40));
+  return pattern.before.test(before) || pattern.after.test(after) || Boolean(pattern.inside?.test(candidate.matchedText));
+}
+
+function overlaps(a, b) {
+  return a.start < b.end && b.start < a.end;
+}
+
+function containsSpan(outer, inner) {
+  return outer.start <= inner.start && outer.end >= inner.end;
+}
+
+const SEMANTIC_CHAR_RE = /[\p{L}\p{N}_]/u;
+function semanticBounds(value, match) {
+  let start = match.index ?? 0;
+  let end = start + match[0].length;
+  while (start < end && !SEMANTIC_CHAR_RE.test(value[start])) start += 1;
+  while (end > start && !SEMANTIC_CHAR_RE.test(value[end - 1])) end -= 1;
+  return { start, end };
 }
 
-function metroOverlapsArea(item, data) {
-  const itemKeys = new Set([item.name, ...(item.aliases || [])].map(normalizeForMatch).filter(Boolean));
-  return ['microdistricts', 'localAreas'].some((key) => (data?.[key] || []).some((area) =>
-    [area.name, ...(area.aliases || [])].map(normalizeForMatch).some((value) => itemKeys.has(value)),
-  ));
+function publicMatch(candidate) {
+  const { start, end, matchedText, explicitContext, ...result } = candidate;
+  return Object.freeze(result);
 }
 
 function findEntryMatches(text, cityName, data) {
   const value = String(text || '');
-  const matches = [];
+  const raw = [];
   for (const key of LOCATION_LIST_KEYS) {
     for (const item of data?.[key] || []) {
       const match = value.match(item?.re);
       if (!match) continue;
-      if (key === 'metro' && metroOverlapsArea(item, data) && !isExplicitMetroContext(value, match)) continue;
-      matches.push(Object.freeze({
+      const { start, end } = semanticBounds(value, match);
+      const candidate = {
         country: item.country || null,
         city: cityName,
         type: item.entityType || TYPE_BY_KEY[key] || key,
@@ -108,10 +163,39 @@ function findEntryMatches(text, cityName, data) {
         parent: item.parent || item.district || null,
         confidence: item.confidence || null,
         language: item.language || null,
-      }));
+        start,
+        end,
+        matchedText: value.slice(start, end),
+        explicitContext: false,
+      };
+      candidate.explicitContext = hasExplicitContext(value, candidate);
+      raw.push(candidate);
     }
   }
-  return matches;
+
+  const filtered = raw.filter((candidate) => {
+    const peers = raw.filter((other) => other !== candidate && overlaps(candidate, other));
+    if (candidate.explicitContext) return true;
+
+    // An explicit type marker is stronger than a same-surface alias of another type:
+    // "метро Минор" is a station, while "Минор махалла" is the mahalla.
+    if (peers.some((peer) => peer.explicitContext && peer.type !== candidate.type)) return false;
+
+    // Prefer the semantically longer phrase when one alias contains another, e.g.
+    // "Сергели машинный базар" over the bare district/metro token "Сергели".
+    const length = candidate.end - candidate.start;
+    if (peers.some((peer) => containsSpan(peer, candidate) && (peer.end - peer.start) > length)) return false;
+
+    // Bare station names that are also real neighborhoods/mahallas/districts are
+    // not enough to assert metro semantics. Explicit metro context restores them.
+    if (candidate.type === 'metro' && peers.some((peer) =>
+      ['district', 'microdistrict', 'mahalla', 'local_area'].includes(peer.type)
+    )) return false;
+
+    return true;
+  });
+
+  return filtered.map(publicMatch);
 }
 
 function isAmbiguousMatch(match, countryCode) {

package/src/geo.js

@@ -112,16 +112,17 @@ export function tashkentMetroLabels() {
   return Object.fromEntries(TASHKENT_METRO.map((item) => [item.name, { ru: item.labels.ru, en: item.labels.en, line: item.line }]));
 }
 
-const area = (name, aliases) => deepFreeze({ canonical: name, name, type: 'local_area', country: 'UZ', city: 'Tashkent', aliases });
+// Historical consumer name retained, but entries now carry their actual semantic type.
+const area = (name, aliases, type = 'local_area') => deepFreeze({ canonical: name, name, type, country: 'UZ', city: 'Tashkent', aliases });
 
 export const TASHKENT_AREAS = Object.freeze({
   Almazar: Object.freeze([
-    area('Sebzar', ['себзар', 'sebzar', 'ц 17', 'ц 18', 'c 17', 'c 18']),
+    area('Sebzar', ['себзар', 'sebzar', 'ц 17', 'ц 18', 'c 17', 'c 18'], 'microdistrict'),
     area('Karakamysh-1/2', ['каракамыш 1 2', 'қорақамиш 1 2', 'qoraqamish 1 2', 'karakamish 1 2']),
     area('Karakamysh-2/3', ['каракамыш 2 3', 'қорақамиш 2 3', 'qoraqamish 2 3', 'karakamish 2 3']),
     area('Karakamysh-2/4', ['каракамыш 2 4', 'қорақамиш 2 4', 'qoraqamish 2 4', 'karakamish 2 4']),
     area('Karakamysh-2/5', ['каракамыш 2 5', 'қорақамиш 2 5', 'qoraqamish 2 5', 'karakamish 2 5']),
-    area('Olympia', ['олимпия', 'olimpiya', 'olympia']), area('Vuzgorodok', ['вузгородок', 'вуз городок', 'vuzgorodok']),
+    area('Olympia', ['олимпия', 'olimpiya', 'olympia'], 'microdistrict'), area('Vuzgorodok', ['вузгородок', 'вуз городок', 'vuzgorodok']),
     area('Medgorodok', ['медгородок', 'мед городок', 'medgorodok']), area('Takhtapul', ['тахтапуль', 'тахтапул', 'taxtapul', 'takhtapul']),
     area('Chimbay', ['чимбай', 'chimboy', 'chimbay']),
   ]),
@@ -132,12 +133,12 @@ export const TASHKENT_AREAS = Object.freeze({
   'Mirzo Ulugbek': Object.freeze([
     area('Buyuk Ipak Yuli', ['буюк ипак йули', 'буюк ипак йўли', 'buyuk ipak yuli', "buyuk ipak yo'li", 'ц 1', 'c 1']),
     area('Alay', ['олой', 'алайский', 'алайск', 'alay', 'ц 2', 'c 2']),
-    ...[1, 2, 3, 4, 6].map((n) => area(`Karasu-${n}`, [`карасу ${n}`, `қорасув ${n}`, `qorasuv ${n}`, `karasu ${n}`])),
-    ...[1, 2, 3, 4].map((n) => area(`TTZ-${n}`, [`ттз ${n}`, `ttz ${n}`])),
+    ...[1, 2, 3, 4].map((n) => area(`Karasu-${n}`, [`карасу ${n}`, `қорасув ${n}`, `qorasuv ${n}`, `karasu ${n}`], 'microdistrict')),
+    area('Karasu-6', ['карасу 6', 'қорасув 6', 'qorasuv 6', 'karasu 6'], 'microdistrict'),
+    ...[1, 2, 3, 4].map((n) => area(`TTZ-${n}`, [`ттз ${n}`, `ttz ${n}`], 'microdistrict')),
     area('Yalangach', ['ялангач', 'yalangach', "yalang'och"]), area('Feruza', ['феруза', 'feruza']), area('Geofizika', ['геофизика', 'поселок геофизиков', 'geofizika']),
   ]),
   Sergeli: Object.freeze([
-    area('Sergeli Car Bazaar', ['сергели машинный базар', 'сергели машина бозор', 'sergeli moshina bozor', 'sergile moshena bozor', 'sergele moshina bozor']),
     area('Yangi Sergeli', ['янги сергели', 'yangi sergeli']), area('Stroygorod', ['стройгород', 'stroygorod']),
   ]),
   Chilanzar: Object.freeze([
@@ -157,13 +158,13 @@ export const TASHKENT_AREAS = Object.freeze({
     area('Rakat', ['ракат', 'rakat']), area('Rakatboshi', ['ракатбоши', 'rakatboshi']),
   ]),
   Yangihayot: Object.freeze([
-    area('Uzgarish', ['узгарыш', 'ўзгариш', "o'zgarish", 'uzgarish']), area('Dustlik-1', ['дустлик 1', 'дўстлик 1', "do'stlik 1", 'dustlik 1']),
-    area('Dustlik-2', ['дустлик 2', 'дўстлик 2', "do'stlik 2", 'dustlik 2']), area('Yangi Choshtepa', ['янги чоштепа', 'yangi choshtepa']), area('Sputnik', ['спутник', 'йўлдош', "yo'ldosh", 'yoldosh']),
+    area('Uzgarish', ['узгарыш', 'ўзгариш', "o'zgarish", 'uzgarish']), area('Dustlik-1', ['дустлик 1', 'дўстлик 1', "do'stlik 1", 'dustlik 1'], 'microdistrict'),
+    area('Dustlik-2', ['дустлик 2', 'дўстлик 2', "do'stlik 2", 'dustlik 2'], 'microdistrict'), area('Yangi Choshtepa', ['янги чоштепа', 'yangi choshtepa'], 'microdistrict'), area('Sputnik', ['спутник', 'йўлдош', "yo'ldosh", 'yoldosh'], 'microdistrict'),
   ]),
   Yashnobod: Object.freeze([
     area('Kuylyuk Center', ['куйлюк центр', 'куйлик центр', "qo'yliq markaz", 'kuylyuk center']),
     ...[1, 2, 3, 4].map((n) => area(`Aviasozlar-${n}`, [`авиасозлар ${n}`, `городок авиастроителей ${n}`, `aviasozlar ${n}`])),
     ...[1, 2, 3, 4].map((n) => area(`Tuzel-${n}`, [`тузель ${n}`, `tuzel ${n}`])),
-    area('Tashselmash', ['ташсельмаш', 'tashselmash']), area('Alimkent', ['алимкент', 'olimkent', 'alimkent']), area('Shohimardon', ['шохимардон', 'shohimardon']),
+    area('Tashselmash', ['ташсельмаш', 'tashselmash'], 'microdistrict'), area('Alimkent', ['алимкент', 'olimkent', 'alimkent']), area('Shohimardon', ['шохимардон', 'shohimardon']),
   ]),
 });

package/src/geography-display.js

@@ -49,7 +49,7 @@ export const GEOGRAPHY_DISPLAY_NAMES = Object.freeze({
     district: Object.freeze({
       Chilanzar: 'Чиланзар', Yunusabad: 'Юнусабад', 'Mirzo Ulugbek': 'Мирзо-Улугбек',
       Yakkasaray: 'Яккасарай', Shaykhantahur: 'Шайхантахур', Yashnobod: 'Яшнабад', Sergeli: 'Сергели',
-      Uchtepa: 'Учтепа', Mirobod: 'Мирабад', Bektemir: 'Бектемир', Olmazor: 'Алмазар',
+      Uchtepa: 'Учтепа', Mirobod: 'Мирабад', Bektemir: 'Бектемир', Almazar: 'Алмазар', Yangihayot: 'Янгихаёт',
       Almaly: 'Алмалинский', Bostandyk: 'Бостандыкский', Medeu: 'Медеуский', Auezov: 'Ауэзовский',
       Turksib: 'Турксибский', Nauryzbay: 'Наурызбайский', Alatau: 'Алатауский', Zhetysu: 'Жетысуский',
       Podil: 'Подол', Pechersk: 'Печерск', Pecherskyi: 'Печерский', Obolon: 'Оболонь',

package/src/hiring-candidate-fields.d.ts

@@ -3,6 +3,7 @@ export type CandidateContacts = Readonly<{ phone?: string; email?: string; teleg
 
 export function extractCandidateGender(value: unknown): CandidateGender | undefined;
 export function extractCandidateName(value: unknown): string;
+export function isCandidateNameHidden(value: unknown): boolean;
 export function extractCandidateAge(value: unknown, now?: Date): number | null;
 export function parseCandidateExperienceValue(value: unknown): number | null;
 export function extractCandidateExperienceYears(value: unknown): number | null;

package/src/hiring-candidate-fields.js

@@ -40,6 +40,14 @@ export function extractCandidateName(value) {
     .trim().replace(/\s{2,}/g, ' ').slice(0, 100);
 }
 
+const HIDDEN_NAME_RE = /^(?:[?？��]{2,}|(?:фио|ф\.и\.о\.?|піб|имя|ім['’ʼ]я|name|full name)?\s*(?:скрыт\p{L}*|прихован\p{L}*|hidden|yashiril\p{L}*|ascuns)|не\s+указан\p{L}*|not\s+specified|anonymous|аноним\p{L}*|onlayn|online|resume|резюме)$/iu;
+
+/** Detects a source board's "name hidden"/anonymous placeholder value. */
+export function isCandidateNameHidden(value) {
+  const text = String(value ?? '').trim();
+  return text ? HIDDEN_NAME_RE.test(text) : false;
+}
+
 export function extractCandidateAge(value, now = new Date()) {
   const text = String(value || '');
   const patterns = [

package/src/hiring.js

@@ -66,7 +66,7 @@ export const EMPLOYMENT_TYPES = Object.freeze([
     uzLatn: ["to'liq bandlik", 'to‘liq bandlik', "to'liq kun", 'toliq ish kuni'], uzCyrl: ['тўлиқ бандлик', 'тўлиқ кун', 'тўлиқ иш куни'], kk: ['толық жұмыс күні', 'толық жұмыспен қамту'],
   }),
   group('partTime', {
-    ru: ['частичная занятость', 'неполная занятость', 'неполный день', 'неполный рабочий день', 'подработка'], en: ['part time', 'part-time', 'part time employment'], uk: ['часткова зайнятість', 'неповний день', 'підробіток'], ro: ['part-time', 'jumătate de normă', 'jumatate de norma', 'program parțial', 'program partial'],
+    ru: ['частичная занятость', 'неполная занятость', 'неполный день', 'неполный рабочий день', 'подработка'], en: ['part time', 'part-time', 'part time employment'], uk: ['часткова зайнятість', 'неповна зайнятість', 'неповний день', 'підробіток'], ro: ['part-time', 'jumătate de normă', 'jumatate de norma', 'program parțial', 'program partial'],
     uzLatn: ['yarim stavka', 'qisman bandlik', "qo'shimcha ish"], uzCyrl: ['ярим ставка', 'қисман бандлик', 'қўшимча иш'], kk: ['жартылай жұмыс', 'толық емес жұмыс күні', 'қосымша жұмыс'],
   }),
   group('contract', {
@@ -95,7 +95,7 @@ export const EMPLOYMENT_TYPES = Object.freeze([
 ]);
 
 export const WORK_MODES = Object.freeze([
-  group('remote', { ru: ['удалённо', 'удаленно', 'удалённая работа', 'дистанционно'], en: ['remote', 'work from home', 'wfh'], uk: ['віддалено', 'дистанційно', 'віддалена робота'], ro: ['remote', 'de acasă', 'de acasa', 'muncă la distanță', 'munca la distanta'], uzLatn: ['masofadan', 'masofaviy', 'uydan ishlash'], uzCyrl: ['масофадан', 'масофавий', 'уйдан ишлаш'], kk: ['қашықтан', 'қашықтан жұмыс', 'үйден жұмыс'] }),
+  group('remote', { ru: ['удалённо', 'удаленно', 'удалённая работа', 'дистанционно'], en: ['remote', 'work from home', 'wfh'], uk: ['віддалено', 'дистанційно', 'віддалена робота', 'дистанційна робота', 'дистанційний формат'], ro: ['remote', 'de acasă', 'de acasa', 'muncă la distanță', 'munca la distanta'], uzLatn: ['masofadan', 'masofaviy', 'uydan ishlash'], uzCyrl: ['масофадан', 'масофавий', 'уйдан ишлаш'], kk: ['қашықтан', 'қашықтан жұмыс', 'үйден жұмыс'] }),
   group('hybrid', { ru: ['гибрид', 'гибридный формат'], en: ['hybrid', 'hybrid work'], uk: ['гібрид', 'гібридний формат'], ro: ['hibrid', 'mod hibrid'], uzLatn: ['gibrid'], uzCyrl: ['гибрид'], kk: ['гибрид', 'аралас формат'] }),
   group('onsite', { ru: ['офис', 'в офисе', 'на месте', 'очно'], en: ['onsite', 'on-site', 'office', 'in person'], uk: ['офіс', 'в офісі', 'на місці'], ro: ['la birou', 'on-site', 'la sediu', 'fizic'], uzLatn: ['ofisda', 'joyida'], uzCyrl: ['офисда', 'жойида'], kk: ['кеңседе', 'офисте', 'орнында'] }),
 ]);

package/src/housing-listing-enrichment.js

@@ -1,7 +1,7 @@
 import { deepFreeze } from './lexicon-core.js';
 import { findAllCanonical, normalizeUnicode } from './normalization.js';
 import { GENERIC_LANDMARK_TERMS } from './landmarks.js';
-import { canonicalTashkentDistrict, canonicalTashkentMetro } from './geo.js';
+import { matchTashkentHousingDistrict, matchTashkentHousingMetro } from './tashkent-housing-geography.js';
 import { TASHKENT_LANDMARKS } from './tashkent-pois.js';
 import { parseHousingRoomCount, parseHousingFloor, parseHousingAreas } from './housing-structured.js';
 import { parseHousingListingFields } from './housing-listing-fields.js';
@@ -193,8 +193,8 @@ export function parseHousingListingEnrichment(value, { country = '' } = {}) {
   const audience = parseHousingAudience(text);
   const perPersonPrice = parseHousingPerPersonPrice(text, { country });
   const observedAmenities = parseHousingObservedAmenities(text);
-  const district = canonicalTashkentDistrict(text);
-  const metro = canonicalTashkentMetro(text);
+  const district = matchTashkentHousingDistrict(text)?.name || null;
+  const metro = matchTashkentHousingMetro(text)?.name || null;
   const parsedRc = specificResidentialComplex(text) || parseHousingResidentialComplex(text);
   const commission = parseHousingCommission(text);
   const commissionAmount = parseHousingCommissionAmount(text);

package/src/location-merge.js

@@ -7,6 +7,7 @@ export const LOCATION_LIST_KEYS = Object.freeze([
   'localAreas',
   'suburbs',
   'settlements',
+  'developmentAreas',
   'residentialComplexes',
   'metro',
   'streets',

package/src/locations.js

@@ -7,6 +7,7 @@ import {
   matchUkraineSecondaryCity,
 } from './location-data.js';
 import { LOCATION_LIST_KEYS, mergeLocationCountries } from './location-merge.js';
+import { aliasesToRegex } from './normalization.js';
 import { KZ_LOCATION_EXTENSIONS } from './kz-location-extensions.js';
 import { UZ_LOCATION_EXTENSIONS } from './uz-location-extensions.js';
 import { UA_MAJOR_LOCATION_EXTENSIONS } from './ua-location-extensions-major.js';
@@ -25,16 +26,80 @@ export const UA_EXTRA_LOCATION_DICTIONARIES = Object.freeze({
   }),
 });
 
+const TASHKENT_UNSUPPORTED_SEED_MICRODISTRICTS = new Set([
+  'Sergeli',
+  'Yunusabad-20',
+  'Yunusabad-21',
+  'Yunusabad-22',
+]);
+
+// The UZ seed is compatibility storage. In 0.3 semantic corrections are
+// applied before merging it with the canonical Uzbekistan extension layer.
+const UZ_BASE_LOCATION_DICTIONARIES = Object.freeze({
+  ...(BASE_LOCATION_DICTIONARIES.UZ || {}),
+  Tashkent: Object.freeze({
+    ...(BASE_LOCATION_DICTIONARIES.UZ?.Tashkent || {}),
+    microdistricts: Object.freeze(
+      (BASE_LOCATION_DICTIONARIES.UZ?.Tashkent?.microdistricts || [])
+        .filter(({ name }) => !TASHKENT_UNSUPPORTED_SEED_MICRODISTRICTS.has(name)),
+    ),
+    residentialComplexes: Object.freeze(
+      (BASE_LOCATION_DICTIONARIES.UZ?.Tashkent?.residentialComplexes || [])
+        .filter(({ name }) => name !== 'Tashkent City'),
+    ),
+  }),
+});
+
+function normalizeUzSemanticLocations(country) {
+  const tashkent = country?.Tashkent;
+  if (!tashkent) return country;
+  const qorasuv = (tashkent.microdistricts || []).find(({ name }) => name === 'Qorasuv');
+  if (!qorasuv) return country;
+
+  // Bare Qorasuv is ambiguous with numbered Qorasuv/Karasu blocks. The
+  // umbrella area therefore requires an area/massif/daha form in free text.
+  const qorasuvAliases = Object.freeze([...new Set([
+    ...(qorasuv.aliases || []).filter((alias) => !/^(?:qorasuv|korasuv|корасув|карасу)$/iu.test(String(alias).trim())),
+    'Qorasuv dahasi',
+    'Qorasuv daha',
+    'Қорасув даҳаси',
+    'Корасув дахаси',
+    'Карасу даха',
+  ])]);
+  const qorasuvArea = Object.freeze({
+    ...qorasuv,
+    type: 'local_area',
+    entityType: 'local_area',
+    parent: 'Mirzo Ulugbek',
+    aliases: qorasuvAliases,
+    re: aliasesToRegex(qorasuvAliases),
+  });
+
+  return Object.freeze({
+    ...country,
+    Tashkent: Object.freeze({
+      ...tashkent,
+      microdistricts: Object.freeze((tashkent.microdistricts || []).filter(({ name }) => name !== 'Qorasuv')),
+      localAreas: Object.freeze([
+        ...(tashkent.localAreas || []),
+        qorasuvArea,
+      ]),
+    }),
+  });
+}
+
+const UZ_LOCATION_DICTIONARIES = normalizeUzSemanticLocations(mergeLocationCountries(
+  UZ_BASE_LOCATION_DICTIONARIES,
+  UZ_LOCATION_EXTENSIONS,
+));
+
 const COUNTRY_LOCATION_DICTIONARIES = Object.freeze({
   ...BASE_LOCATION_DICTIONARIES,
   KZ: mergeLocationCountries(
     BASE_LOCATION_DICTIONARIES.KZ || {},
     KZ_LOCATION_EXTENSIONS,
   ),
-  UZ: mergeLocationCountries(
-    BASE_LOCATION_DICTIONARIES.UZ || {},
-    UZ_LOCATION_EXTENSIONS,
-  ),
+  UZ: UZ_LOCATION_DICTIONARIES,
   UA: mergeLocationCountries(
     UA_EXTRA_LOCATION_DICTIONARIES,
     UA_MAJOR_LOCATION_EXTENSIONS,

package/src/tashkent-colloquial.js

@@ -1,6 +1,13 @@
 import { TASHKENT_AREAS } from './geo.js';
 
-const area = (name, aliases) => Object.freeze({ name, aliases: Object.freeze(aliases) });
+const area = (name, aliases, type = 'local_area') => Object.freeze({
+  canonical: name,
+  name,
+  type,
+  country: 'UZ',
+  city: 'Tashkent',
+  aliases: Object.freeze(aliases),
+});
 
 /** Additions to the core Tashkent catalog; entries here do not duplicate geo.js rows. */
 export const TASHKENT_AREA_ADDITIONS = Object.freeze({
@@ -18,7 +25,7 @@ export const TASHKENT_AREA_ADDITIONS = Object.freeze({
     area('Binokor-2', ['бинокор 2', 'binokor 2']),
     area('Majnuntol', ['мажнунтол', 'majnuntol']),
     area('Olima Oshirova', ['олима оширова', 'olima oshirova']),
-    area('Bektemir', ['бектемир массив', 'bektemir massivi']),
+    area('Bektemir', ['бектемир массив', 'bektemir massivi'], 'microdistrict'),
   ]),
   Mirobod: Object.freeze([
     area('Farovon', ['фаровон', 'farovon']),
@@ -32,15 +39,15 @@ export const TASHKENT_AREA_ADDITIONS = Object.freeze({
     area('Riyoziy', ['риёзий', 'riyoziy']),
   ]),
   Sergeli: Object.freeze([
-    area('Sergeli-2 G-40', ['сергели 2 г 40', 'sergeli 2 g 40']),
+    area('Sergeli-2 G-40', ['сергели 2 г 40', 'sergeli 2 g 40'], 'microdistrict'),
     area('Babur Quarter', ['квартал бабур', 'бабур квартал', 'babur kvartal']),
   ]),
   Uchtepa: Object.freeze([
     area('Al-Khorezmi-2', ['аль хорезми 2', 'ал хорезми 2', 'al xorazmiy 2', 'al khorezmi 2']),
-    area('Shark', ['массив шарк', 'шарк массив', 'sharq massivi']),
+    area('Shark', ['массив шарк', 'шарк массив', 'sharq massivi'], 'microdistrict'),
   ]),
   Chilanzar: Object.freeze([
-    area('Almazar Massif', ['массив алмазар', 'массив олмазор', 'almazar massivi', 'olmazor massivi']),
+    area('Almazar Massif', ['массив алмазар', 'массив олмазор', 'almazar massivi', 'olmazor massivi'], 'microdistrict'),
   ]),
   Shaykhantahur: Object.freeze([
     area('Labzak C-13', ['лабзак ц 13', 'лабзак ц-13', 'labzak c 13', 'labzak c-13']),
@@ -55,16 +62,11 @@ export const TASHKENT_AREA_ADDITIONS = Object.freeze({
     area('Katta Hasanboy', ['катта хасанбой', 'katta hasanboy']),
   ]),
   Yakkasaray: Object.freeze([
-    area('Glinka', ['глинка', 'glinka']),
-    area('Bobur', ['массив бобур', 'bobur massivi']),
-    area('Konstitutsiya', ['конституция массив', 'konstitutsiya massivi']),
+    area('Bobur', ['массив бобур', 'bobur massivi'], 'microdistrict'),
+    area('Konstitutsiya', ['конституция массив', 'konstitutsiya massivi'], 'microdistrict'),
     area('Hamid Sulaymonov', ['хамид сулаймонов', 'hamid sulaymonov']),
   ]),
-  Yangihayot: Object.freeze([
-    area('Yangi Choshtepa', ['янги чоштепа', 'yangi choshtepa']),
-  ]),
   Yashnobod: Object.freeze([
-    area('Aviasozlar-3', ['авиасозлар 3', 'авиасозлар-3', 'aviasozlar 3', 'aviasozlar-3']),
     area('Asalabad-1', ['асалабад 1', 'asalobod 1', 'asalabad 1']),
     area('Asalabad-2', ['асалабад 2', 'asalobod 2', 'asalabad 2']),
     area('Mumtoz', ['мумтаз', 'mumtoz']),

package/src/tashkent-housing-geography.d.ts

@@ -27,6 +27,15 @@ export interface TashkentMetroEntry {
   readonly re: RegExp;
 }
 
+export interface TashkentDistrictEntry {
+  readonly canonical: string;
+  readonly name: string;
+  readonly type: 'district';
+  readonly country: 'UZ';
+  readonly city: 'Tashkent';
+  readonly re: RegExp;
+}
+
 export const TASHKENT_HOUSING_LANDMARKS: readonly TashkentHousingLocationEntry[];
 export const TASHKENT_NUMBERED_AREA_ALIASES: Readonly<Record<string, readonly string[]>>;
 
@@ -34,5 +43,6 @@ export function matchTashkentHousingLandmarks(value: unknown): TashkentHousingLo
 export function matchTashkentNumberedArea(value: unknown, canonical: string): TashkentNumberedAreaMatch | null;
 export function hasTashkentAreaAlias(value: unknown, canonical: string): boolean;
 export function hasExplicitTashkentDistrict(value: unknown, canonical: string): boolean;
+export function matchTashkentHousingDistrict(value: unknown): TashkentDistrictEntry | null;
 export function matchTashkentHousingMetro(value: unknown): TashkentMetroEntry | null;
 export function matchTashkentHousingTransit(value: unknown): TashkentHousingLocationEntry | null;

package/src/tashkent-housing-geography.js

@@ -1,5 +1,5 @@
-import { aliasesToRegex, escapeRegex, normalizeForMatch } from './normalization.js';
-import { TASHKENT_METRO } from './geo.js';
+import { aliasesOf, aliasesToRegex, escapeRegex, normalizeForMatch } from './normalization.js';
+import { TASHKENT_DISTRICTS, TASHKENT_METRO } from './geo.js';
 
 function locationEntry(name, category, aliases = [], options = {}) {
   const all = [...new Set([name, ...aliases].filter(Boolean))];
@@ -16,6 +16,19 @@ function locationEntry(name, category, aliases = [], options = {}) {
   });
 }
 
+const TASHKENT_HOUSING_DISTRICTS = Object.freeze(TASHKENT_DISTRICTS.map((district) => {
+  const aliases = [...new Set([district.canonical, ...aliasesOf(district)].filter(Boolean))];
+  return Object.freeze({
+    canonical: district.canonical,
+    name: district.canonical,
+    type: 'district',
+    country: 'UZ',
+    city: 'Tashkent',
+    aliases: Object.freeze(aliases),
+    re: aliasesToRegex(aliases),
+  });
+}));
+
 /**
  * Housing-oriented Tashkent names that occur in listings as landmarks even when
  * the generic POI catalogue cannot safely classify the bare token on its own.
@@ -30,7 +43,7 @@ export const TASHKENT_HOUSING_LANDMARKS = Object.freeze([
   locationEntry('Novomoskovskaya', 'residential_complex', [
     'Новомосковская', 'Новомосковской', 'Novomoskovskaya',
   ]),
-  locationEntry('Yangi Choshtepa', 'local_area', [
+  locationEntry('Yangi Choshtepa', 'microdistrict', [
     'Янги Чоштепа', 'Янги чоштепа', 'Yangi Choshtepa',
   ]),
   locationEntry('Glinka', 'landmark', [
@@ -89,6 +102,50 @@ function hasRequiredContext(entry, text, start, end) {
   return entry.contextRe?.test(around) ?? false;
 }
 
+function matchContext(text, match, beforeRe, afterRe, insideRe = null) {
+  const start = match.index ?? 0;
+  const end = start + match[0].length;
+  const before = text.slice(Math.max(0, start - 36), start);
+  const after = text.slice(end, Math.min(text.length, end + 36));
+  return beforeRe.test(before) || afterRe.test(after) || Boolean(insideRe?.test(match[0]));
+}
+
+const METRO_BEFORE_RE = /(?:метро|metro|станц(?:ия|ии)?|station|ст\.?\s*м\.?)\s*[:\-–—]?\s*$/iu;
+const METRO_AFTER_RE = /^\s*[:\-–—]?\s*(?:метро|metro|станц(?:ия|ии)?|station)(?=$|[^\p{L}\p{N}_])/iu;
+const METRO_INSIDE_RE = /(?:метро|metro|станц(?:ия|ии)?|station)/iu;
+const DISTRICT_BEFORE_RE = /(?:район|р-н|рн|туман\p{L}{0,4}|tumani|district)\s*[:\-–—]?\s*$/iu;
+const DISTRICT_AFTER_RE = /^\s*[:\-–—]?\s*(?:район|р-н|рн|туман\p{L}{0,4}|tumani|district)(?=$|[^\p{L}\p{N}_])/iu;
+const DISTRICT_INSIDE_RE = /(?:район|р-н|рн|туман\p{L}{0,4}|tumani|district)/iu;
+const AREA_BEFORE_RE = /(?:массив(?:и)?|massiv(?:i)?|жилмассив|ж\/м|микрорайон|мкр\.?|mavze(?:si)?|мавзе(?:си)?|квартал|kvartal|daha|даха|даҳа)\s*[:\-–—]?\s*$/iu;
+const AREA_AFTER_RE = /^\s*(?:\d{1,2}[aа]?\s*)?[:\-–—]?\s*(?:массив(?:и)?|massiv(?:i)?|жилмассив|ж\/м|микрорайон|мкр\.?|mavze(?:si)?|мавзе(?:си)?|квартал|kvartal|daha|даха|даҳа)(?=$|[^\p{L}\p{N}_])/iu;
+const AREA_INSIDE_RE = /(?:массив(?:и)?|massiv(?:i)?|жилмассив|ж\/м|микрорайон|мкр\.?|mavze(?:si)?|мавзе(?:си)?|квартал|kvartal|daha|даха|даҳа)/iu;
+const MAHALLA_BEFORE_RE = /(?:махалл(?:а|я)|маҳалла(?:си)?|mahalla(?:si)?|mfy|мфй)\s*[:\-–—]?\s*$/iu;
+const MAHALLA_AFTER_RE = /^\s*[:\-–—]?\s*(?:махалл(?:а|я)|маҳалла(?:си)?|mahalla(?:si)?|mfy|мфй)(?=$|[^\p{L}\p{N}_])/iu;
+const MAHALLA_INSIDE_RE = /(?:махалл(?:а|я)|маҳалла(?:си)?|mahalla(?:si)?|mfy|мфй)/iu;
+const LANDMARK_AFTER_RE = /^\s*[:\-–—]?\s*(?:базар|рынок|bozor(?:i)?|мечет\p{L}*|масжид|masjid|mosque|парк|park|mall|молл|вокзал|аэропорт|airport)(?=$|[^\p{L}\p{N}_])/iu;
+const LANDMARK_BEFORE_RE = /(?:базар|рынок|bozor(?:i)?|мечет\p{L}*|масжид|masjid|mosque|парк|park|mall|молл|вокзал|аэропорт|airport)\s*[:\-–—]?\s*$/iu;
+const LANDMARK_INSIDE_RE = /(?:базар|рынок|bozor(?:i)?|мечет\p{L}*|масжид|masjid|mosque|парк|park|mall|молл|вокзал|аэропорт|airport)/iu;
+
+function hasExplicitMetroContext(text, match) {
+  return matchContext(text, match, METRO_BEFORE_RE, METRO_AFTER_RE, METRO_INSIDE_RE);
+}
+
+function hasExplicitDistrictContext(text, match) {
+  return matchContext(text, match, DISTRICT_BEFORE_RE, DISTRICT_AFTER_RE, DISTRICT_INSIDE_RE);
+}
+
+function hasExplicitAreaContext(text, match) {
+  return matchContext(text, match, AREA_BEFORE_RE, AREA_AFTER_RE, AREA_INSIDE_RE);
+}
+
+function hasExplicitMahallaContext(text, match) {
+  return matchContext(text, match, MAHALLA_BEFORE_RE, MAHALLA_AFTER_RE, MAHALLA_INSIDE_RE);
+}
+
+function hasExplicitLandmarkContext(text, match) {
+  return matchContext(text, match, LANDMARK_BEFORE_RE, LANDMARK_AFTER_RE, LANDMARK_INSIDE_RE);
+}
+
 /** Return all housing landmarks in stable catalogue-priority order. */
 export function matchTashkentHousingLandmarks(value) {
   const text = String(value ?? '');
@@ -180,25 +237,51 @@ export function hasExplicitTashkentDistrict(value, canonical) {
   return new RegExp(`(?:^|\\s)(?:${alternatives})\\s+${DISTRICT_MARKER}(?:\\s|$)`, 'iu').test(text);
 }
 
+/** Resolve administrative districts only when the surrounding housing context agrees. */
+export function matchTashkentHousingDistrict(value) {
+  const text = String(value ?? '');
+  if (!text) return null;
+  for (const district of TASHKENT_HOUSING_DISTRICTS) {
+    const match = text.match(district.re);
+    if (!match) continue;
+    if (hasExplicitDistrictContext(text, match)) return district;
+    if (hasExplicitMetroContext(text, match) || hasExplicitAreaContext(text, match) || hasExplicitMahallaContext(text, match)) continue;
+    if (matchTashkentNumberedArea(text, district.name)) continue;
+    return district;
+  }
+  return null;
+}
+
 const EXTRA_METRO_ALIASES = Object.freeze({
   Sergeli: Object.freeze(['Sergile', 'Sergele']),
 });
 
 const QOYLIQ_MASSIF_RE = /(?:куйлюк|куйлик|kuylyuk|kuyliq|qoyliq|qo[‘’ʻ']?yliq|қўйлиқ)(?:\s+\d{1,2})?\s+(?:массив(?:и)?|massiv(?:i)?)/iu;
+const METRO_NUMBERED_AREA = Object.freeze({
+  Chilonzor: 'Chilanzar',
+  Sergeli: 'Sergeli',
+  Yunusobod: 'Yunusabad',
+  Yangihayot: 'Yangihayot',
+});
 
-/** Resolve listing typos/transliterations to an existing canonical metro entry. */
+/** Resolve listing typos/transliterations while respecting explicit non-metro geography. */
 export function matchTashkentHousingMetro(value) {
   const text = String(value ?? '');
   if (!text) return null;
   for (const station of TASHKENT_METRO) {
-    if (!station.re.test(text)) continue;
-    // Qoyliq is also a large housing massif. In housing text an explicit
-    // "массив/massiv" marker wins over the homonymous metro station.
+    const match = text.match(station.re);
+    if (!match) continue;
+    if (hasExplicitMetroContext(text, match)) return station;
     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)) {
-    if (!aliasesToRegex(aliases).test(text)) continue;
+    const match = text.match(aliasesToRegex(aliases));
+    if (!match) continue;
+    if (hasExplicitDistrictContext(text, match) || hasExplicitAreaContext(text, match) || hasExplicitMahallaContext(text, match)) continue;
     return TASHKENT_METRO.find((station) => station.name === canonical) || null;
   }
   return null;

package/src/uz-location-extensions.js

@@ -13,12 +13,13 @@ function entries(rows = [], defaults = {}) {
   }));
 }
 
-function city({ districts = [], mahallas = [], microdistricts = [], localAreas = [], residentialComplexes = [], landmarks = [], suburbs = [] }) {
+function city({ districts = [], mahallas = [], microdistricts = [], localAreas = [], developmentAreas = [], residentialComplexes = [], landmarks = [], suburbs = [] }) {
   return Object.freeze({
     ...(districts.length ? { districts: entries(districts, { entityType: 'district', country: 'UZ' }) } : {}),
     ...(mahallas.length ? { mahallas: entries(mahallas, { entityType: 'mahalla', country: 'UZ' }) } : {}),
     ...(microdistricts.length ? { microdistricts: entries(microdistricts, { entityType: 'microdistrict', country: 'UZ' }) } : {}),
     ...(localAreas.length ? { localAreas: entries(localAreas, { entityType: 'local_area', country: 'UZ' }) } : {}),
+    ...(developmentAreas.length ? { developmentAreas: entries(developmentAreas, { entityType: 'development_area', country: 'UZ' }) } : {}),
     ...(residentialComplexes.length ? { residentialComplexes: entries(residentialComplexes, { entityType: 'residential_complex', country: 'UZ' }) } : {}),
     ...(landmarks.length ? { landmarks: entries(landmarks, { entityType: 'poi', country: 'UZ' }) } : {}),
     ...(suburbs.length ? { suburbs: entries(suburbs, { entityType: 'suburb', country: 'UZ' }) } : {}),
@@ -57,8 +58,38 @@ const nukusMahallas = NUKUS_MFY_NAMES.map((name) => ({
 
 export const UZ_LOCATION_EXTENSIONS = Object.freeze({
   Tashkent: city({
+    mahallas: [
+      { name: 'Khastimam', aliases: ['Хастимом'], parent: 'Almazar' },
+      { name: 'Yangi Tashkent', aliases: ['Yangi Toshkent','Янги Тошкент','Янги Ташкент'], parent: 'Almazar' },
+      { name: 'Umid', aliases: ['Умид'], parent: 'Almazar' },
+      { name: 'Kashgar', aliases: ['Qashqar','Кашгар'], parent: 'Yunusabad' },
+      { name: 'Buyuk Turan', aliases: ['Buyuk Turon','Буюк Турон','Буюк Туран'], parent: 'Yunusabad' },
+      { name: 'Minor', aliases: ['Минор'], parent: 'Yunusabad' },
+      { name: 'Labzak', aliases: ['Лабзак'], parent: 'Shaykhantahur' },
+      { name: 'Rakat', aliases: ['Ракат'], parent: 'Yakkasaray' },
+      { name: 'Belaryk', aliases: ['Беларык'], parent: 'Yakkasaray' },
+      { name: 'Shahjahan', aliases: ['Shahjahon','Шахжахон'], parent: 'Yakkasaray' },
+      { name: 'Mukimiy', aliases: ['Muqimiy','Мукими','Муқимий'], parent: 'Yakkasaray' },
+      { name: 'Birlashgan', aliases: ['Бирлашган'], parent: 'Yashnobod' },
+      { name: 'Nadyra', aliases: ['Nodira','Нодира'], parent: 'Yashnobod' },
+      { name: 'Makhmur', aliases: ['Maxmur','Махмур'], parent: 'Yashnobod' },
+      { name: 'Munavvarqori', aliases: ['Munavvar Qori','Мунаввар Қори','Мунаввар Кори'], parent: 'Mirzo Ulugbek' },
+      { name: 'Beshkapa', aliases: ['Бешкапа'], parent: 'Mirzo Ulugbek' },
+      { name: 'Chashtepa', aliases: ['Чаштепа'], parent: 'Yangihayot' },
+      { name: 'Yangi Darhan', aliases: ['Yangi Darxon','Янги Дархан','Янги Дархон'], parent: 'Yangihayot' },
+    ],
     microdistricts: [
       ['Qorasuv', 'Qorasuv massivi', 'Korasuv massivi', 'Корасув Массиви', 'Корасув массиви', 'Карасу массив', 'Карасу массиви', 'Қорасув массиви'],
+      { name: 'Sergeli-3A', aliases: ['Sergeli 3A','Сергели-3А','Сергели 3А','Сергели 3А массив','Сергели-3А массив'], parent: 'Yangihayot' },
+      { name: 'Sergeli-5A', aliases: ['Sergeli 5A','Сергели-5А','Сергели 5А','Сергели 5А массив','Сергели-5А массив'], parent: 'Yangihayot' },
+      { name: 'Sergeli-7A', aliases: ['Sergeli 7A','Сергели-7А','Сергели 7А','Сергели 7А массив','Сергели-7А массив'], parent: 'Yangihayot' },
+    ],
+    localAreas: [
+      { name: 'Yangidarhan-1', aliases: ['Yangi Darhan-1','Yangi Darxon-1','Янги Дархан-1','Янги Дархон-1'], parent: 'Yangihayot' },
+      { name: 'Yangidarhan-2', aliases: ['Yangi Darhan-2','Yangi Darxon-2','Янги Дархан-2','Янги Дархон-2'], parent: 'Yangihayot' },
+    ],
+    developmentAreas: [
+      ['Tashkent City', 'Ташкент Сити', 'Toshkent City', 'Tashkent City IBC'],
     ],
   }),