@whiteslove/parsing-lexicon 0.6.17 → 0.7.0

package/index.d.ts

@@ -371,15 +371,21 @@ export function classifyHiringIntent(value: unknown): Readonly<{ intent: 'candid
 export function parseExperience(value: unknown): ExperienceParseResult | null;
 
 export * from './src/housing-context.js';
+export * from './src/housing-address.js';
+export * from './src/parser-core.js';
+export * from './src/temporal.js';
 export * from './src/hiring-context.js';
 export * from './src/housing-intent.js';
 export * from './src/housing-structured.js';
+export * from './src/housing-parser-v2.js';
 export * from './src/housing-safety.js';
 export * from './src/housing-title.js';
 export * from './src/housing-language.js';
 export * from './src/housing-features.js';
 export * from './src/housing-listing-fields.js';
 export * from './src/housing-card-fields.js';
+export * from './src/hiring-skills.js';
+export * from './src/hiring-ats.js';
 
 // housing semantic helper declarations added in 0.2.5
 export function resolveHousingOccupancy(value: unknown): 'wholeProperty' | 'room' | 'sharedRoom' | 'bedSpace' | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whiteslove/parsing-lexicon",
-  "version": "0.6.17",
+  "version": "0.7.0",
   "description": "Shared deterministic multilingual parsing lexicon for WhitesLove housing and hiring services",
   "repository": {
     "type": "git",
@@ -16,6 +16,14 @@
     },
     "./lexicon-core": "./src/lexicon-core.js",
     "./normalization": "./src/normalization.js",
+    "./parser-core": {
+      "types": "./src/parser-core.d.ts",
+      "import": "./src/parser-core.js"
+    },
+    "./temporal": {
+      "types": "./src/temporal.d.ts",
+      "import": "./src/temporal.js"
+    },
     "./countries": "./src/countries.js",
     "./country-context": {
       "types": "./src/country-context.d.ts",
@@ -37,18 +45,6 @@
     },
     "./central-asia": "./src/central-asia.js",
     "./ukraine": "./src/ukraine.js",
-    "./ua-geo-coordinates": {
-      "types": "./src/ua-geo-coordinates.d.ts",
-      "import": "./src/ua-geo-coordinates.js"
-    },
-    "./ua-geo-resolver": {
-      "types": "./src/ua-geo-resolver.d.ts",
-      "import": "./src/ua-geo-resolver.js"
-    },
-    "./uz-geo-coordinates": {
-      "types": "./src/uz-geo-coordinates.d.ts",
-      "import": "./src/uz-geo-coordinates.js"
-    },
     "./location-merge": "./src/location-merge.js",
     "./locations": "./src/locations-runtime.js",
     "./kg-location-extensions": "./src/kg-location-extensions.js",
@@ -118,6 +114,10 @@
       "import": "./src/housing-source-aliases.js"
     },
     "./housing-poi-extensions": "./src/housing-poi-extensions.js",
+    "./housing-poi-relations": {
+      "types": "./src/housing-poi-relations.d.ts",
+      "import": "./src/housing-poi-relations.js"
+    },
     "./housing-display": {
       "types": "./src/housing-display.d.ts",
       "import": "./src/housing-display.js"
@@ -203,6 +203,14 @@
       "import": "./src/hiring-skills.js"
     },
     "./hiring-advanced": "./src/hiring-advanced.js",
+    "./hiring-ats": {
+      "types": "./src/hiring-ats.d.ts",
+      "import": "./src/hiring-ats.js"
+    },
+    "./housing-parser-v2": {
+      "types": "./src/housing-parser-v2.d.ts",
+      "import": "./src/housing-parser-v2.js"
+    },
     "./hiring-safety": {
       "types": "./src/hiring-safety.d.ts",
       "import": "./src/hiring-safety.js"

package/src/contact.d.ts

@@ -36,8 +36,8 @@ export type TelegramContact = Readonly<{
   source: 'mention' | 'url' | 'tg';
 }>;
 
-export function findPhoneLikeSpans(value: unknown): readonly PhoneLikeSpan[];
-export function maskPhoneLikeSpans(value: unknown, replacement?: string): string;
+export function findPhoneLikeSpans(value: unknown, options?: { country?: string | null; countryHint?: string | null }): readonly PhoneLikeSpan[];
+export function maskPhoneLikeSpans(value: unknown, replacement?: string | { country?: string | null; countryHint?: string | null }, options?: { country?: string | null; countryHint?: string | null }): string;
 export function parsePhoneNumbers(value: unknown, options?: ParsePhoneOptions): readonly ParsedPhoneNumber[];
 export function normalizePhone(value: unknown, options?: ParsePhoneOptions): ParsedPhoneNumber | null;
 export function findTelegramContacts(value: unknown): readonly TelegramContact[];

package/src/contact.js

@@ -28,8 +28,9 @@ function splitPhoneExtension(raw) {
   };
 }
 
-export function findPhoneLikeSpans(value) {
+export function findPhoneLikeSpans(value, options = {}) {
   const text = String(value || '');
+  const countryHint = normalizedCountryHint(options.country || options.countryHint);
   const spans = [];
   for (const match of text.matchAll(PHONE_LIKE_RE)) {
     const raw = match[0];
@@ -43,12 +44,38 @@ export function findPhoneLikeSpans(value) {
       digits,
     }));
   }
-  return Object.freeze(spans);
+
+  // Uzbekistan's ordinary national presentation is nine digits (for example
+  // 99 188 19 19).  It is too short for the deliberately country-neutral
+  // broad mask above, but libphonenumber can validate/identify it when the
+  // caller has already established UZ context.  Do not generalize this to all
+  // countries: a bare nine digit number is often a price or a house number.
+  if (countryHint === 'UZ') {
+    for (const candidate of parsePhoneNumbers(text, { countryHint, includePossible: true })) {
+      // The short masking exception is intentionally narrow. `99` is a
+      // common Uzbekistan mobile prefix in listings; accepting every possible
+      // nine-digit national number would hide legitimate UZS sale prices.
+      if (candidate.digits.length !== 9 || !candidate.digits.startsWith('99') || !candidate.possible) continue;
+      if (spans.some((span) => span.start <= candidate.start && span.end >= candidate.end)) continue;
+      spans.push(Object.freeze({
+        start: candidate.start,
+        end: candidate.end,
+        raw: candidate.raw,
+        digits: candidate.digits,
+      }));
+    }
+  }
+  return Object.freeze(spans.sort((a, b) => a.start - b.start || b.end - a.end));
 }
 
-export function maskPhoneLikeSpans(value, replacement = ' ') {
+export function maskPhoneLikeSpans(value, replacement = ' ', options = {}) {
+  // Backward-compatible convenience: maskPhoneLikeSpans(value, { country }).
+  if (replacement && typeof replacement === 'object') {
+    options = replacement;
+    replacement = ' ';
+  }
   const text = String(value || '');
-  const spans = findPhoneLikeSpans(text);
+  const spans = findPhoneLikeSpans(text, options);
   if (!spans.length) return text;
 
   let out = '';

package/src/geo.js

@@ -20,7 +20,7 @@ export const TASHKENT_DISTRICTS = Object.freeze([
   entity('Yunusabad', { uzLatn: ['Yunusobod', 'Yunusobod tumani', 'Yunusabad'], uzCyrl: ['Юнусобод', 'Юнусобод тумани'], ru: ['Юнусабад', 'Юнусабадский район'], en: ['Yunusabad', 'Yunusobod'] }),
   entity('Yakkasaray', { uzLatn: ['Yakkasaroy', 'Yakkasaroy tumani', 'Yakkasaray'], uzCyrl: ['Яккасарой', 'Яккасарой тумани'], ru: ['Яккасарай', 'Яккасарайский район'], en: ['Yakkasaray', 'Yakkasaroy'] }),
   entity('Yangihayot', { uzLatn: ['Yangihayot', 'Yangihayot tumani'], uzCyrl: ['Янгиҳаёт', 'Янгиҳаёт тумани', 'Янгихаёт'], ru: ['Янгихаётский район', 'Янгихаёт'], en: ['Yangihayot'] }),
-  entity('Yashnobod', { uzLatn: ['Yashnobod', 'Yashnobod tumani', 'Yashnabod', 'Yashnabod tumani'], uzCyrl: ['Яшнобод', 'Яшнобод тумани'], ru: ['Яшнабад', 'Яшнабадский район'], en: ['Yashnobod', 'Yashnabad'] }),
+  entity('Yashnobod', { uzLatn: ['Yashnobod', 'Yashnobod tumani', 'Yashnabod', 'Yashnabod tumani', 'Yashnobot', 'Yashnobot tumani'], uzCyrl: ['Яшнобод', 'Яшнобод тумани'], ru: ['Яшнабад', 'Яшнабадский район'], en: ['Yashnobod', 'Yashnabad'] }),
 ]);
 
 export function canonicalTashkentDistrict(value) {
@@ -176,4 +176,4 @@ export const TASHKENT_AREAS = Object.freeze({
     ...[1, 2, 3, 4].map((n) => area(`Tuzel-${n}`, [`тузель ${n}`, `tuzel ${n}`])),
     area('Tashselmash', ['ташсельмаш', 'tashselmash']), area('Alimkent', ['алимкент', 'olimkent', 'alimkent']), area('Shohimardon', ['шохимардон', 'shohimardon']),
   ]),
-});
+});

package/src/hiring-ats.d.ts

@@ -0,0 +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 }>;
+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

@@ -0,0 +1,153 @@
+import { detectCountryCodeFromText } from './geography-detection.js';
+import {
+  SENIORITY_RANK, bucketVacancyText, classifyCvSectionHeading, detectDegreeFields,
+  detectDegreeLevel, detectHiringSeniority, extractCvExperienceYears,
+  extractRequiredExperienceYears, isNoSponsorshipRequirement, requiresUsSponsorship,
+} from './hiring-requirements.js';
+import { detectDegreeRequirement, detectHiringScopeSignals } from './hiring-semantics.js';
+import { canonicalSkillName, extractSkillNames, matchSkillCandidates } from './hiring-skills.js';
+
+const SECTION_WEIGHT = Object.freeze({ experience: 1, projects: 0.7, profile: 0.55, skills: 0.4, education: 0.35, other: 0.45 });
+const DEGREE_RANK = Object.freeze({ secondary: 0, bachelor: 1, master: 2, doctorate: 3 });
+const SCOPE_LABELS = Object.freeze({ architecture: 'Architecture / system design', leadership: 'Technical leadership', mentoring: 'Mentoring engineers', scale: 'Large-scale systems', ownership: 'Product / feature ownership' });
+const TERM_STOP_WORDS = new Set(['the', 'and', 'for', 'with', 'that', 'this', 'from', 'into', 'your', 'you', 'our', 'are', 'will', 'have', 'has', 'who', 'what', 'when', 'where', 'which', 'their', 'they', 'them', 'about', 'within', 'across', 'using', 'including', 'work', 'working', 'team', 'teams', 'role', 'company', 'years', 'year', 'experience', 'skills', 'skill', 'strong', 'good', 'excellent', 'ability', 'knowledge', 'looking', 'required', 'requirements', 'preferred', 'responsibilities', 'opportunity', 'candidate', 'position', 'professional', 'develop', 'development', 'build', 'building', 'software', 'engineer', 'engineering', 'help', 'support', 'ensure', 'provide', 'plus', 'nice', 'must', 'need', 'needs', 'для', 'что', 'как', 'или', 'это', 'мы', 'вы', 'ваш', 'ваша', 'ваши', 'наш', 'наша', 'наши', 'работа', 'работы', 'работать', 'опыт', 'лет', 'года', 'год', 'команда', 'команды', 'знание', 'знания', 'навыки', 'требования', 'обязанности', 'будет', 'нужно', 'необходимо', 'умение', 'разработка', 'разработки', 'позиция', 'кандидат']);
+
+function canonicalSet(values = []) {
+  return new Set(values.map((value) => canonicalSkillName(value)).filter(Boolean));
+}
+
+function extractTerms(value) {
+  const words = String(value || '').toLowerCase().replace(/[’']/g, '').match(/[a-zа-яёіїєґ][a-zа-яёіїєґ0-9+#.-]{2,}/giu) || [];
+  return new Set(words.filter((word) => !TERM_STOP_WORDS.has(word) && !/^\d+$/u.test(word)));
+}
+
+function coverage(have, wanted) {
+  if (!wanted.size) return 0;
+  let found = 0;
+  for (const value of wanted) if (have.has(value)) found += 1;
+  return found / wanted.size;
+}
+
+function evidenceFromCv(raw, { fuzzySkills = false } = {}) {
+  const evidence = new Map();
+  let section = 'other';
+  const add = (line, weight) => {
+    for (const name of extractSkillNames(line)) evidence.set(name, Math.max(evidence.get(name) || 0, weight));
+    if (!fuzzySkills) return;
+    for (const match of matchSkillCandidates(line, { fuzzy: true, allowAmbiguousExact: section === 'skills' })) {
+      // Fuzzy evidence is deliberately discounted relative to direct canonical
+      // or alias evidence in the same section, and never overrides it.
+      const score = match.matchType === 'fuzzy' ? weight * Math.min(0.75, match.confidence) : weight;
+      evidence.set(match.canonical, Math.max(evidence.get(match.canonical) || 0, score));
+    }
+  };
+  for (const line of String(raw || '').replace(/\r/g, '').split('\n')) {
+    const heading = classifyCvSectionHeading(line.trim());
+    if (heading) { section = heading; continue; }
+    if (line.trim()) add(line, SECTION_WEIGHT[section]);
+  }
+  return evidence;
+}
+
+export function buildHiringAtsProfile(cvText, options = {}) {
+  const raw = String(cvText || '');
+  const skillEvidence = evidenceFromCv(raw, options);
+  return Object.freeze({
+    raw,
+    skills: new Set(skillEvidence.keys()), skillEvidence,
+    terms: extractTerms(raw),
+    experienceYears: extractCvExperienceYears(raw, options.referenceDate) ?? undefined,
+    seniority: detectHiringSeniority(raw) || undefined,
+    degreeLevel: detectDegreeLevel(raw) || undefined,
+    degreeFields: new Set(detectDegreeFields(raw)),
+    requiresUsSponsorship: requiresUsSponsorship(raw) ?? undefined,
+  });
+}
+
+function scoreSeniority(candidate, required) {
+  if (!required) return { score: 100, gap: 0 };
+  if (!candidate) return { score: 45, gap: 1 };
+  const gap = SENIORITY_RANK[required] - SENIORITY_RANK[candidate];
+  return { score: gap <= 0 ? 100 : gap === 1 ? 65 : gap === 2 ? 30 : 10, gap };
+}
+function scoreExperience(candidate, required) {
+  if (required === undefined) return { score: 100, gap: 0 };
+  if (candidate === undefined) return { score: 35, gap: required };
+  if (candidate >= required) return { score: 100, gap: 0 };
+  const ratio = candidate / required;
+  return { score: ratio >= .85 ? 75 : ratio >= .7 ? 55 : ratio >= .5 ? 35 : 15, gap: Math.max(0, required - candidate) };
+}
+function scoreScope(jobText, cvText) {
+  const required = detectHiringScopeSignals(jobText, { mode: 'vacancy' });
+  if (!required.length) return { score: 100, missing: [], requiredCount: 0 };
+  const have = new Set(detectHiringScopeSignals(cvText, { mode: 'candidate' }));
+  const missing = required.filter((code) => !have.has(code)).map((code) => SCOPE_LABELS[code] || code);
+  return { score: Math.round((1 - missing.length / required.length) * 100), missing, requiredCount: required.length };
+}
+function scoreEducation(profile, requirement) {
+  if (!requirement.level && !requirement.field) return { score: 100, fieldMismatch: false, levelMismatch: false };
+  const levelMismatch = requirement.level && (DEGREE_RANK[profile.degreeLevel] ?? -1) < DEGREE_RANK[requirement.level];
+  const fieldMismatch = requirement.field && !profile.degreeFields.has(requirement.field) && !(requirement.field === 'computer_science' && profile.degreeFields.has('engineering'));
+  if (levelMismatch) return { score: requirement.equivalentExperience ? 45 : 10, fieldMismatch: Boolean(fieldMismatch), levelMismatch: true };
+  if (fieldMismatch) return { score: requirement.equivalentExperience ? 60 : 35, fieldMismatch: true, levelMismatch: false };
+  return { score: 100, fieldMismatch: false, levelMismatch: false };
+}
+
+/** Portable, explainable ATS scoring; no browser, transport, or UI concerns. */
+export function scoreHiringAts(profileOrCv, job, options = {}) {
+  const profile = typeof profileOrCv === 'string' ? buildHiringAtsProfile(profileOrCv, options) : profileOrCv;
+  const description = String(job?.description || ''); const title = String(job?.title || ''); const tagText = (job?.tags || []).join(' ');
+  const buckets = bucketVacancyText(description);
+  const titleSkills = new Set(extractSkillNames(title)); const requiredTextSkills = new Set(extractSkillNames(buckets.required));
+  const optionalTextSkills = new Set(extractSkillNames(buckets.optional)); const contextTextSkills = new Set(extractSkillNames(buckets.context));
+  const noiseSkills = new Set(extractSkillNames(buckets.noise)); const serverRequired = canonicalSet(job?.skills); const serverOptional = canonicalSet(job?.niceToHave);
+  const required = new Set([...titleSkills, ...requiredTextSkills]); const optional = new Set(optionalTextSkills); const context = new Set();
+  // Server tags can be useful context, but they only become required when the
+  // vacancy itself supplies title/requirement evidence. This preserves the
+  // established 4 / 1 / .35 evidence architecture.
+  for (const skill of serverRequired) {
+    if (noiseSkills.has(skill) && !required.has(skill)) continue;
+    if (requiredTextSkills.has(skill) || titleSkills.has(skill)) required.add(skill); else context.add(skill);
+  }
+  for (const skill of serverOptional) {
+    if (noiseSkills.has(skill) && !optionalTextSkills.has(skill)) continue;
+    optional.add(skill);
+  }
+  for (const skill of [...extractSkillNames(tagText), ...contextTextSkills]) {
+    if (noiseSkills.has(skill) || required.has(skill) || optional.has(skill)) continue;
+    context.add(skill);
+  }
+  for (const skill of required) { optional.delete(skill); context.delete(skill); }
+  for (const skill of optional) context.delete(skill);
+  let possible = 0; let earned = 0; const matched = []; const missingSkills = [];
+  const evidenceFor = (skill) => profile.skillEvidence.get(skill) ?? (profile.skills.has(skill) ? 0.45 : 0);
+  for (const [skills, weight, requiredSkill] of [[required, 4, true], [optional, 1, false], [context, .35, false]]) {
+    for (const skill of skills) {
+      possible += weight; const evidence = evidenceFor(skill);
+      if (evidence) { earned += weight * evidence; matched.push(skill); } else if (requiredSkill) missingSkills.push(skill);
+    }
+  }
+  const experience = scoreExperience(profile.experienceYears, job?.experienceMinYears ?? extractRequiredExperienceYears(`${buckets.required} ${description}`) ?? undefined);
+  const seniority = scoreSeniority(profile.seniority, detectHiringSeniority(title) || detectHiringSeniority(job?.seniority || '') || undefined);
+  const scope = scoreScope(`${title} ${buckets.required} ${description}`, profile.raw);
+  const educationRequirement = detectDegreeRequirement(`${buckets.required} ${job?.education || ''}`);
+  const education = scoreEducation(profile, educationRequirement);
+  const skills = possible ? Math.round(earned / possible * 100) : 60;
+  const keywordSource = buckets.required || buckets.optional ? `${buckets.required} ${buckets.optional}` : `${title} ${tagText} ${buckets.context.slice(0, 1800)}`;
+  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);
+  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 })] : [];
+  fitScore = Math.max(0, Math.min(100, fitScore));
+  const missing = [...blockers.map((item) => item.label), ...missingSkills, ...scope.missing];
+  if (experience.gap > 0) missing.push(`${job?.experienceMinYears ?? extractRequiredExperienceYears(`${buckets.required} ${description}`)}+ years experience`);
+  if (seniority.gap > 0) missing.push(`${String(detectHiringSeniority(title) || detectHiringSeniority(job?.seniority || '') || '').replace(/^./u, (letter) => letter.toUpperCase())} seniority`);
+  if (education.fieldMismatch && educationRequirement.field === 'computer_science') missing.push('Computer Science / related degree');
+  else if (education.levelMismatch && educationRequirement.level) missing.push(`${educationRequirement.level} degree`);
+  return Object.freeze({ score: blockers.length ? Math.min(fitScore, 49) : fitScore, fitScore, eligible: !blockers.length, blockers: Object.freeze(blockers), breakdown, matched: Object.freeze([...new Set(matched)].slice(0, 12)), missing: Object.freeze([...new Set(missing.filter(Boolean))].slice(0, 12)) });
+}
+
+export function hiringAtsScoreColor(score) { return Number(score) >= 75 ? '#34d399' : Number(score) >= 50 ? '#fbbf24' : '#f87171'; }

package/src/hiring-skills.d.ts

@@ -9,6 +9,12 @@ export interface SkillDefinition extends SkillMeta {
 export interface SkillDetail extends SkillMeta {
   name: string;
 }
+export interface SkillMatch {
+  canonical: string;
+  matched: string;
+  matchType: 'exact' | 'alias' | 'normalized' | 'fuzzy';
+  confidence: number;
+}
 export const SKILL_CATALOG: SkillDefinition[];
 export const SKILL_KEYWORDS: Readonly<Record<string, readonly string[]>>;
 export const SKILL_META: Readonly<Record<string, SkillMeta>>;
@@ -18,4 +24,6 @@ export function buildSkillRegex(alias: string): RegExp;
 export function canonicalSkillName(value: string): string | undefined;
 export function extractSkillDetails(text: string): SkillDetail[];
 export function extractSkillNames(text: string): string[];
+export function matchSkill(value: unknown, options?: { fuzzy?: boolean; allowAmbiguousExact?: boolean }): SkillMatch | null;
+export function matchSkillCandidates(value: unknown | readonly unknown[], options?: { fuzzy?: boolean; allowAmbiguousExact?: boolean; limit?: number }): readonly SkillMatch[];
 export function getSkillMeta(name: string): SkillMeta | undefined;

package/src/hiring-skills.js

@@ -279,6 +279,88 @@ for (const { name, aliases } of SKILL_CATALOG) {
   for (const alias of aliases) CANONICAL_BY_ALIAS.set(normalizeSkillText(alias), name)
 }
 
+function levenshtein(left, right) {
+  const a = String(left); const b = String(right);
+  const row = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1; i <= a.length; i += 1) {
+    let previous = row[0]; row[0] = i;
+    for (let j = 1; j <= b.length; j += 1) {
+      const saved = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1));
+      previous = saved;
+    }
+  }
+  return row[b.length];
+}
+
+function fuzzyDistanceLimit(token) {
+  if (token.length < 5) return 0;
+  if (token.length <= 7) return 1;
+  if (token.length <= 12) return 2;
+  return 3;
+}
+
+/**
+ * Resolve one deliberately bounded hiring skill candidate. Fuzzy matching is
+ * opt-in and compares complete tokens only; it never changes generic lexicon
+ * lookup or performs substring matching in ordinary prose.
+ */
+export function matchSkill(value, options = {}) {
+  const raw = String(value ?? '').trim();
+  if (!raw) return null;
+  const normalized = normalizeSkillText(raw);
+  const canonical = CANONICAL_BY_ALIAS.get(normalized);
+  if (canonical) {
+    const definition = SKILL_CATALOG.find((entry) => entry.name === canonical);
+    const canonicalNormalized = normalizeSkillText(definition.name);
+    // Bare ordinary words are unsafe in free prose. A caller that already has
+    // a bounded skills field can opt in explicitly, while generic CV text
+    // still requires an unambiguous alias such as `spring framework`.
+    if (AMBIGUOUS_CANONICALS.has(canonical) && normalized === canonicalNormalized && options.allowAmbiguousExact !== true) return null;
+    const type = raw === definition.name ? 'exact' : canonicalNormalized === normalized ? 'normalized' : 'alias';
+    return Object.freeze({ canonical, matched: raw, matchType: type, confidence: type === 'exact' ? 1 : type === 'normalized' ? 0.99 : 0.97 });
+  }
+  if (options.fuzzy !== true || /\s/u.test(normalized) || !/^[a-z][a-z0-9+#.-]*$/iu.test(normalized)) return null;
+
+  const candidates = [];
+  for (const { name, aliases } of SKILL_CATALOG) {
+    if (AMBIGUOUS_CANONICALS.has(name)) continue;
+    for (const term of [name, ...aliases]) {
+      const candidate = normalizeSkillText(term);
+      // Short terms have a very high collision rate (Go/good, C/CSS, REST/
+      // restaurant). They are exact-or-alias only.
+      if (candidate.length < 5 || /\s/u.test(candidate)) continue;
+      const limit = fuzzyDistanceLimit(candidate);
+      const distance = levenshtein(normalized, candidate);
+      if (distance <= limit) candidates.push({ canonical: name, distance, candidate });
+    }
+  }
+  candidates.sort((a, b) => a.distance - b.distance || a.candidate.length - b.candidate.length || a.canonical.localeCompare(b.canonical));
+  const best = candidates[0];
+  if (!best) return null;
+  return Object.freeze({
+    canonical: best.canonical,
+    matched: raw,
+    matchType: 'fuzzy',
+    confidence: Number((1 - best.distance / Math.max(normalized.length, best.candidate.length)).toFixed(2)),
+  });
+}
+
+/** Match a bounded list or a tokenized skills field, preserving evidence. */
+export function matchSkillCandidates(value, options = {}) {
+  const values = Array.isArray(value)
+    ? value
+    : String(value ?? '').split(/[\s,;|/]+/u);
+  const byCanonical = new Map();
+  for (const candidate of values.slice(0, options.limit ?? 128)) {
+    const match = matchSkill(candidate, options);
+    if (!match) continue;
+    const previous = byCanonical.get(match.canonical);
+    if (!previous || match.confidence > previous.confidence) byCanonical.set(match.canonical, match);
+  }
+  return Object.freeze([...byCanonical.values()].sort((a, b) => b.confidence - a.confidence || a.canonical.localeCompare(b.canonical)));
+}
+
 export function canonicalSkillName(value) {
   const normalized = normalizeSkillText(value)
   return CANONICAL_BY_ALIAS.get(normalized) ?? extractSkillNames(normalized)[0]

package/src/hiring-temporal.js

@@ -1,5 +1,5 @@
 export const HIRING_MONTHS = Object.freeze({
-  январь: 0, января: 0, february: 1, февраль: 1, февраля: 1,
+  январь: 0, января: 0, january: 0, jan: 0, february: 1, feb: 1, февраль: 1, февраля: 1,
   март: 2, марта: 2, april: 3, апрель: 3, апреля: 3,
   may: 4, май: 4, мая: 4, june: 5, июнь: 5, июня: 5,
   july: 6, июль: 6, июля: 6, august: 7, август: 7, августа: 7,

package/src/housing-address.d.ts

@@ -4,7 +4,20 @@ export type HousingAddressParts = Readonly<{
   houseNumber: string | null;
   building: string | null;
   confidence: number;
+  unit?: string;
+  level?: string;
+  entrance?: string;
+  staircase?: string;
   district?: string;
+  metro?: string;
+  mahalla?: string;
+  geoEntities?: Readonly<Partial<Record<'street' | 'district' | 'metro' | 'mahalla' | 'residentialComplex', Readonly<{
+    id: string;
+    canonical: string;
+    type: string;
+    country: string;
+    parentId?: string;
+  }>>>>;
   quarter?: Readonly<{
     number: number;
     suffix: string;
@@ -17,9 +30,42 @@ export function parseHousingAddress(
     allowBare?: boolean;
     allowDelimitedBare?: boolean;
     knownStreet?: string | null;
+    knownStreets?: readonly string[];
+    country?: string | null;
+    city?: string | null;
+    resolveGeoEntity?: ((input: Readonly<{ country: string; city?: string; type: string; canonical: string }>) => Readonly<{
+      id: string;
+      canonicalName?: string;
+      canonical?: string;
+      type?: string;
+      country?: string;
+      parentId?: string;
+    }> | null | undefined);
   }>,
 ): HousingAddressParts;
 
+export function resolveHousingAddressGeoEntities(
+  parts: HousingAddressParts | null | undefined,
+  options: Readonly<{
+    country?: string | null;
+    city?: string | null;
+    resolveGeoEntity?: ((input: Readonly<{ country: string; city?: string; type: string; canonical: string }>) => Readonly<{
+      id: string;
+      canonicalName?: string;
+      canonical?: string;
+      type?: string;
+      country?: string;
+      parentId?: string;
+    }> | null | undefined);
+  }>,
+): Readonly<Partial<Record<'street' | 'district' | 'metro' | 'mahalla' | 'residentialComplex', Readonly<{
+  id: string;
+  canonical: string;
+  type: string;
+  country: string;
+  parentId?: string;
+}>>>>;
+
 export function composeHousingAddress(parts?: Readonly<{
   street?: unknown;
   houseNumber?: unknown;