@pranavraut033/ats-checker 1.3.3 → 2.0.0

package/dist/index.cjs

@@ -1,5 +1,228 @@
 'use strict';
 
+// src/utils/languages.ts
+var KNOWN_LANGUAGES = [
+  "english",
+  "spanish",
+  "french",
+  "german",
+  "italian",
+  "portuguese",
+  "dutch",
+  "russian",
+  "mandarin",
+  "chinese",
+  "cantonese",
+  "japanese",
+  "korean",
+  "arabic",
+  "hindi",
+  "polish",
+  "turkish",
+  "vietnamese",
+  "swedish",
+  "norwegian",
+  "danish",
+  "finnish",
+  "greek",
+  "hebrew",
+  "thai",
+  "indonesian",
+  "ukrainian",
+  "czech"
+];
+var LANGUAGE_ALIASES = {
+  mandarin: "chinese",
+  cantonese: "chinese"
+};
+var LEVEL_RANK = {
+  a1: 1,
+  a2: 2,
+  b1: 3,
+  b2: 4,
+  c1: 5,
+  c2: 6,
+  basic: 1,
+  elementary: 1,
+  limited: 2,
+  conversational: 3,
+  intermediate: 3,
+  professional: 4,
+  "upper intermediate": 4,
+  advanced: 4,
+  fluent: 5,
+  native: 6,
+  "native speaker": 6,
+  bilingual: 6,
+  // German
+  grundkenntnisse: 1,
+  gering: 2,
+  gut: 3,
+  fortgeschritten: 4,
+  flie\u00DFend: 5,
+  muttersprache: 6,
+  muttersprachler: 6,
+  // French
+  d\u00E9butant: 1,
+  \u00E9l\u00E9mentaire: 1,
+  limit\u00E9: 2,
+  interm\u00E9diaire: 3,
+  avanc\u00E9: 4,
+  courant: 5,
+  natif: 6,
+  "langue maternelle": 6,
+  bilingue: 6
+};
+var LANGUAGE_GROUP = KNOWN_LANGUAGES.join("|");
+var LEVEL_GROUP = Object.keys(LEVEL_RANK).sort((a, b) => b.length - a.length).map((l) => l.replace(/\s+/g, "\\s+")).join("|");
+var BOUNDARY_START = "(?:^|(?<=[^a-z\xE0-\xFF]))";
+var BOUNDARY_END = "(?:$|(?=[^a-z\xE0-\xFF]))";
+var LANGUAGE_LEVEL_RE = new RegExp(
+  `\\b(${LANGUAGE_GROUP})\\b(?:\\s*[\\(:\\-]?\\s*(${BOUNDARY_START}(?:${LEVEL_GROUP})${BOUNDARY_END}|[abc][12]))?`,
+  "gi"
+);
+var LEVEL_BEFORE_LANGUAGE_RE = new RegExp(
+  `${BOUNDARY_START}(${LEVEL_GROUP})${BOUNDARY_END}\\s+(?:in\\s+)?(${LANGUAGE_GROUP})\\b`,
+  "gi"
+);
+function canonicalLanguage(name) {
+  const lower = name.toLowerCase();
+  return LANGUAGE_ALIASES[lower] ?? lower;
+}
+function toParsedLanguage(name, level) {
+  const normalizedLevel = level?.toLowerCase().replace(/\s+/g, " ");
+  return {
+    name: canonicalLanguage(name),
+    level: normalizedLevel,
+    levelRank: normalizedLevel ? LEVEL_RANK[normalizedLevel] : void 0
+  };
+}
+function parseLanguageMentions(text) {
+  const found = /* @__PURE__ */ new Map();
+  for (const match of text.matchAll(LANGUAGE_LEVEL_RE)) {
+    const parsed = toParsedLanguage(match[1], match[2]);
+    const existing = found.get(parsed.name);
+    if (!existing || (parsed.levelRank ?? 0) > (existing.levelRank ?? 0)) {
+      found.set(parsed.name, parsed);
+    }
+  }
+  for (const match of text.matchAll(LEVEL_BEFORE_LANGUAGE_RE)) {
+    const parsed = toParsedLanguage(match[2], match[1]);
+    const existing = found.get(parsed.name);
+    if (!existing || (parsed.levelRank ?? 0) > (existing.levelRank ?? 0)) {
+      found.set(parsed.name, parsed);
+    }
+  }
+  return [...found.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function diffLanguages(resumeLanguages, requiredLanguages) {
+  const byName = new Map(resumeLanguages.map((l) => [l.name, l]));
+  const matched = [];
+  const missing = [];
+  for (const required of requiredLanguages) {
+    const have = byName.get(required.name);
+    const requiredRank = required.levelRank ?? 0;
+    const haveRank = have?.levelRank ?? 0;
+    if (have && haveRank >= requiredRank) {
+      matched.push(required);
+    } else {
+      missing.push(required);
+    }
+  }
+  return { matched, missing };
+}
+
+// src/utils/match.ts
+var SUFFIXES = [
+  { suffix: "ational", replacement: "ate", minStemLength: 3 },
+  { suffix: "ization", replacement: "ize", minStemLength: 3 },
+  { suffix: "ations", replacement: "ate", minStemLength: 3 },
+  { suffix: "ation", replacement: "ate", minStemLength: 3 },
+  { suffix: "ements", replacement: "e", minStemLength: 3 },
+  { suffix: "ement", replacement: "e", minStemLength: 3 },
+  { suffix: "ments", replacement: "ment", minStemLength: 3 },
+  { suffix: "ment", replacement: "", minStemLength: 3 },
+  { suffix: "ies", replacement: "y", minStemLength: 2 },
+  { suffix: "ied", replacement: "y", minStemLength: 2 },
+  { suffix: "ying", replacement: "y", minStemLength: 2 },
+  { suffix: "tion", replacement: "t", minStemLength: 3 },
+  { suffix: "sion", replacement: "s", minStemLength: 3 },
+  { suffix: "ness", replacement: "", minStemLength: 3 },
+  { suffix: "fully", replacement: "ful", minStemLength: 3 },
+  { suffix: "ally", replacement: "al", minStemLength: 3 },
+  { suffix: "ing", replacement: "", minStemLength: 3 },
+  { suffix: "edly", replacement: "", minStemLength: 3 },
+  { suffix: "ed", replacement: "", minStemLength: 3 },
+  { suffix: "ly", replacement: "", minStemLength: 3 },
+  { suffix: "er", replacement: "", minStemLength: 3 },
+  { suffix: "es", replacement: "", minStemLength: 3 },
+  { suffix: "s", replacement: "", minStemLength: 3 }
+];
+function stripOneSuffix(lower) {
+  for (const { suffix, replacement, minStemLength } of SUFFIXES) {
+    if (lower.endsWith(suffix) && lower.length - suffix.length >= minStemLength) {
+      let stemmed = lower.slice(0, lower.length - suffix.length) + replacement;
+      if (replacement === "" && stemmed.length >= 3 && stemmed[stemmed.length - 1] === stemmed[stemmed.length - 2] && !/[aeiou]/.test(stemmed[stemmed.length - 1])) {
+        stemmed = stemmed.slice(0, -1);
+      }
+      return stemmed;
+    }
+  }
+  return lower;
+}
+function stem(token) {
+  let word = token.trim().toLowerCase();
+  for (let pass = 0; pass < 2 && word.length > 3; pass++) {
+    const next = stripOneSuffix(word);
+    if (next === word) {
+      break;
+    }
+    word = next;
+  }
+  return word;
+}
+function levenshteinDistance(a, b, maxDistance) {
+  const s = a.toLowerCase();
+  const t = b.toLowerCase();
+  if (s === t) return 0;
+  const lenDiff = Math.abs(s.length - t.length);
+  if (lenDiff > maxDistance) return maxDistance + 1;
+  let prevRow = new Array(t.length + 1);
+  for (let j = 0; j <= t.length; j++) prevRow[j] = j;
+  for (let i = 1; i <= s.length; i++) {
+    const currRow = new Array(t.length + 1);
+    currRow[0] = i;
+    let rowMin = currRow[0];
+    for (let j = 1; j <= t.length; j++) {
+      const cost = s[i - 1] === t[j - 1] ? 0 : 1;
+      currRow[j] = Math.min(
+        prevRow[j] + 1,
+        // deletion
+        currRow[j - 1] + 1,
+        // insertion
+        prevRow[j - 1] + cost
+        // substitution
+      );
+      if (currRow[j] < rowMin) rowMin = currRow[j];
+    }
+    if (rowMin > maxDistance) {
+      return maxDistance + 1;
+    }
+    prevRow = currRow;
+  }
+  return prevRow[t.length];
+}
+function fuzzyEqual(a, b, opts) {
+  const x = a.trim().toLowerCase();
+  const y = b.trim().toLowerCase();
+  if (x === y) return true;
+  if (!x || !y) return false;
+  const longer = Math.max(x.length, y.length);
+  const defaultMax = longer <= 6 ? 1 : 2;
+  const maxDistance = opts?.maxDistance ?? defaultMax;
+  return levenshteinDistance(x, y, maxDistance) <= maxDistance;
+}
+
 // src/utils/text.ts
 var STOP_WORDS = /* @__PURE__ */ new Set([
   // articles / prepositions / conjunctions
@@ -129,6 +352,39 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "open",
   "dynamic"
 ]);
+var ROLE_NOUNS = [
+  "engineer",
+  "developer",
+  "manager",
+  "scientist",
+  "analyst",
+  "designer",
+  "architect",
+  "director",
+  "consultant",
+  "lead",
+  "vp",
+  "specialist",
+  "coordinator",
+  "administrator",
+  "accountant",
+  "recruiter",
+  "nurse",
+  "teacher",
+  "associate",
+  "representative",
+  "executive",
+  "officer",
+  "technician",
+  "strategist",
+  "marketer",
+  "writer",
+  "editor",
+  "product",
+  "principal",
+  "staff",
+  "head"
+];
 function normalizeWhitespace(text) {
   return text.replace(/\r\n?/g, "\n").replace(/\s+/g, " ").trim();
 }
@@ -139,11 +395,14 @@ function splitLines(text) {
   return text.replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean);
 }
 var TECH_TOKEN_RE = /[a-z0-9][a-z0-9.#+\-/]*[a-z0-9#+]/g;
-function tokenize(text) {
+function tokenize(text, options) {
   const normalized = normalizeForComparison(text);
-  return (normalized.match(TECH_TOKEN_RE) ?? []).filter(
+  const tokens = (normalized.match(TECH_TOKEN_RE) ?? []).filter(
     (t) => /[a-z]/.test(t) && !STOP_WORDS.has(t)
   );
+  {
+    return tokens;
+  }
 }
 function escapeRegExp(input) {
   return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -183,9 +442,48 @@ function containsTableLikeStructure(text) {
   }
   return tableLines >= 2;
 }
+var STANDARD_BULLET_RE = /^\s*(?:[-*•o‣▪]|\(?[a-z0-9]+[.)])\s+/i;
+var NON_STANDARD_BULLET_RE = /^\s*[➤➢✓✔✗➔❖◆♦❯›»★☆♥❤]/;
+var SPECIAL_CHAR_RE = /[-�]|[\x00-\x08\x0B\x0C\x0E-\x1F]/;
+function detectFormatting(raw) {
+  const lines = splitLines(raw);
+  const hasTables = containsTableLikeStructure(raw);
+  let wideGapLines = 0;
+  for (const line of lines) {
+    if (/\S( {6,})\S/.test(line)) {
+      wideGapLines += 1;
+    }
+  }
+  const hasMultiColumn = wideGapLines >= 2;
+  const hasSpecialChars = SPECIAL_CHAR_RE.test(raw);
+  let bulletLines = 0;
+  let nonStandardBulletLines = 0;
+  for (const line of lines) {
+    if (NON_STANDARD_BULLET_RE.test(line)) {
+      bulletLines += 1;
+      nonStandardBulletLines += 1;
+    } else if (STANDARD_BULLET_RE.test(line)) {
+      bulletLines += 1;
+    }
+  }
+  const nonStandardBullets = nonStandardBulletLines > 0 && nonStandardBulletLines >= bulletLines / 2;
+  const trimmed = raw.trim();
+  const letterCount = (trimmed.match(/[a-zA-Z]/g) ?? []).length;
+  const likelyScanned = trimmed.length > 0 && (letterCount < 20 || letterCount / trimmed.length < 0.2);
+  const contactParseable = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/.test(raw);
+  return {
+    hasTables,
+    hasMultiColumn,
+    hasSpecialChars,
+    nonStandardBullets,
+    likelyScanned,
+    contactParseable
+  };
+}
 
 // src/utils/skills.ts
 var aliasIndexCache = /* @__PURE__ */ new WeakMap();
+var stemIndexCache = /* @__PURE__ */ new WeakMap();
 function getAliasIndex(aliases) {
   let index = aliasIndexCache.get(aliases);
   if (!index) {
@@ -201,12 +499,44 @@ function getAliasIndex(aliases) {
   }
   return index;
 }
-function normalizeSkill(skill, aliases) {
+function getStemIndex(aliases) {
+  let index = stemIndexCache.get(aliases);
+  if (!index) {
+    index = /* @__PURE__ */ new Map();
+    for (const [key, canonical] of getAliasIndex(aliases)) {
+      const stemmed = stem(key);
+      if (!index.has(stemmed)) {
+        index.set(stemmed, canonical);
+      }
+    }
+    stemIndexCache.set(aliases, index);
+  }
+  return index;
+}
+function normalizeSkill(skill, aliases, options) {
   const normalized = skill.trim().toLowerCase();
-  return getAliasIndex(aliases).get(normalized) ?? normalized;
+  const exact = getAliasIndex(aliases).get(normalized);
+  if (exact) {
+    return exact;
+  }
+  if (!options?.fuzzy) {
+    return normalized;
+  }
+  const stemmed = stem(normalized);
+  const stemIndex = getStemIndex(aliases);
+  const stemHit = stemIndex.get(stemmed);
+  if (stemHit) {
+    return stemHit;
+  }
+  for (const [key, canonical] of stemIndex) {
+    if (fuzzyEqual(stemmed, key, { maxDistance: options.maxDistance })) {
+      return canonical;
+    }
+  }
+  return normalized;
 }
-function normalizeSkills(skills, aliases) {
-  return unique(skills.map((skill) => normalizeSkill(skill, aliases)));
+function normalizeSkills(skills, aliases, options) {
+  return unique(skills.map((skill) => normalizeSkill(skill, aliases, options)));
 }
 function deriveSkillAliases(registry) {
   const aliases = {};
@@ -224,141 +554,72 @@ function buildCategoryIndex(registry) {
 }
 function mergeKeywordRegistries(base, overrides) {
   const byCanonical = /* @__PURE__ */ new Map();
-  for (const entry of base) byCanonical.set(entry.canonical.toLowerCase(), entry);
-  for (const entry of overrides) byCanonical.set(entry.canonical.toLowerCase(), entry);
+  for (const entry of base)
+    byCanonical.set(entry.canonical.toLowerCase(), entry);
+  for (const entry of overrides)
+    byCanonical.set(entry.canonical.toLowerCase(), entry);
   return [...byCanonical.values()];
 }
 
-// src/utils/languages.ts
-var KNOWN_LANGUAGES = [
-  "english",
-  "spanish",
-  "french",
-  "german",
-  "italian",
-  "portuguese",
-  "dutch",
-  "russian",
-  "mandarin",
-  "chinese",
-  "cantonese",
-  "japanese",
-  "korean",
-  "arabic",
-  "hindi",
-  "polish",
-  "turkish",
-  "vietnamese",
-  "swedish",
-  "norwegian",
-  "danish",
-  "finnish",
-  "greek",
-  "hebrew",
-  "thai",
-  "indonesian",
-  "ukrainian",
-  "czech"
+// src/utils/titles.ts
+var SENIORITY_SIGNALS = [
+  { seniority: "principal", pattern: /\bprincipal\b/i },
+  { seniority: "lead", pattern: /\b(lead|staff|head of|director)\b/i },
+  { seniority: "senior", pattern: /\b(senior|sr\.?)\b/i },
+  {
+    seniority: "junior",
+    pattern: /\b(junior|jr\.?|entry[\s-]?level|intern(?:ship)?|associate)\b/i
+  }
 ];
-var LANGUAGE_ALIASES = {
-  mandarin: "chinese",
-  cantonese: "chinese"
+var SENIORITY_RANK = {
+  junior: 0,
+  mid: 1,
+  senior: 2,
+  lead: 3,
+  principal: 4
 };
-var LEVEL_RANK = {
-  a1: 1,
-  a2: 2,
-  b1: 3,
-  b2: 4,
-  c1: 5,
-  c2: 6,
-  basic: 1,
-  elementary: 1,
-  limited: 2,
-  conversational: 3,
-  intermediate: 3,
-  professional: 4,
-  "upper intermediate": 4,
-  advanced: 4,
-  fluent: 5,
-  native: 6,
-  "native speaker": 6,
-  bilingual: 6,
-  // German
-  grundkenntnisse: 1,
-  gering: 2,
-  gut: 3,
-  fortgeschritten: 4,
-  flie\u00DFend: 5,
-  muttersprache: 6,
-  muttersprachler: 6,
-  // French
-  "d\xE9butant": 1,
-  "\xE9l\xE9mentaire": 1,
-  "limit\xE9": 2,
-  "interm\xE9diaire": 3,
-  "avanc\xE9": 4,
-  courant: 5,
-  natif: 6,
-  "langue maternelle": 6,
-  bilingue: 6
-};
-var LANGUAGE_GROUP = KNOWN_LANGUAGES.join("|");
-var LEVEL_GROUP = Object.keys(LEVEL_RANK).sort((a, b) => b.length - a.length).map((l) => l.replace(/\s+/g, "\\s+")).join("|");
-var BOUNDARY_START = "(?:^|(?<=[^a-z\xE0-\xFF]))";
-var BOUNDARY_END = "(?:$|(?=[^a-z\xE0-\xFF]))";
-var LANGUAGE_LEVEL_RE = new RegExp(
-  `\\b(${LANGUAGE_GROUP})\\b(?:\\s*[\\(:\\-]?\\s*(${BOUNDARY_START}(?:${LEVEL_GROUP})${BOUNDARY_END}|[abc][12]))?`,
-  "gi"
-);
-var LEVEL_BEFORE_LANGUAGE_RE = new RegExp(
-  `${BOUNDARY_START}(${LEVEL_GROUP})${BOUNDARY_END}\\s+(?:in\\s+)?(${LANGUAGE_GROUP})\\b`,
-  "gi"
-);
-function canonicalLanguage(name) {
-  const lower = name.toLowerCase();
-  return LANGUAGE_ALIASES[lower] ?? lower;
-}
-function toParsedLanguage(name, level) {
-  const normalizedLevel = level?.toLowerCase().replace(/\s+/g, " ");
-  return {
-    name: canonicalLanguage(name),
-    level: normalizedLevel,
-    levelRank: normalizedLevel ? LEVEL_RANK[normalizedLevel] : void 0
-  };
-}
-function parseLanguageMentions(text) {
-  const found = /* @__PURE__ */ new Map();
-  for (const match of text.matchAll(LANGUAGE_LEVEL_RE)) {
-    const parsed = toParsedLanguage(match[1], match[2]);
-    const existing = found.get(parsed.name);
-    if (!existing || (parsed.levelRank ?? 0) > (existing.levelRank ?? 0)) {
-      found.set(parsed.name, parsed);
-    }
-  }
-  for (const match of text.matchAll(LEVEL_BEFORE_LANGUAGE_RE)) {
-    const parsed = toParsedLanguage(match[2], match[1]);
-    const existing = found.get(parsed.name);
-    if (!existing || (parsed.levelRank ?? 0) > (existing.levelRank ?? 0)) {
-      found.set(parsed.name, parsed);
+function inferSeniority(titles) {
+  let best;
+  for (const title of titles) {
+    for (const { seniority, pattern } of SENIORITY_SIGNALS) {
+      if (pattern.test(title)) {
+        if (!best || SENIORITY_RANK[seniority] > SENIORITY_RANK[best]) {
+          best = seniority;
+        }
+        break;
+      }
     }
   }
-  return [...found.values()].sort((a, b) => a.name.localeCompare(b.name));
+  return best;
 }
-function diffLanguages(resumeLanguages, requiredLanguages) {
-  const byName = new Map(resumeLanguages.map((l) => [l.name, l]));
-  const matched = [];
-  const missing = [];
-  for (const required of requiredLanguages) {
-    const have = byName.get(required.name);
-    const requiredRank = required.levelRank ?? 0;
-    const haveRank = have?.levelRank ?? 0;
-    if (have && haveRank >= requiredRank) {
-      matched.push(required);
-    } else {
-      missing.push(required);
+function normalizeTitle(title) {
+  return title.toLowerCase().replace(/[.,/#!$%^&*;:{}=_`~()]/g, " ").replace(/\s+/g, " ").trim();
+}
+function titleTokens(title) {
+  const tokens = normalizeTitle(title).split(" ").filter((t) => t && !STOP_WORDS.has(t)).map((t) => stem(t));
+  return new Set(tokens);
+}
+function titleMatch(resumeTitles, jdRoleKeywords) {
+  const keywords = jdRoleKeywords.map((k) => stem(normalizeTitle(k))).filter(Boolean);
+  if (keywords.length === 0) {
+    return 0;
+  }
+  const resumeTokenSets = resumeTitles.map(titleTokens);
+  const roleNounStems = new Set(ROLE_NOUNS.map((n) => stem(n)));
+  let matched = 0;
+  for (const keyword of keywords) {
+    const isRoleNoun = roleNounStems.has(keyword);
+    const hit = resumeTokenSets.some((tokens) => {
+      if (tokens.has(keyword)) {
+        return true;
+      }
+      return isRoleNoun && [...tokens].some((t) => roleNounStems.has(t) && t === keyword);
+    });
+    if (hit) {
+      matched += 1;
     }
   }
-  return { matched, missing };
+  return matched / keywords.length;
 }
 
 // src/core/parser/jd.parser.ts
@@ -387,13 +648,49 @@ function extractPreferredSkills(lines) {
   }
   return preferred;
 }
+var REQUIRED_HEADER_RE = /^(?:requirements?|must[\s-]?haves?|required\s+skills?|required\s+qualifications?|qualifications?|minimum\s+qualifications?)\s*:?\s*$/i;
+var PREFERRED_HEADER_RE = /^(?:preferred(?:\s+skills?|\s+qualifications?)?|nice[\s-]?to[\s-]?haves?|bonus(?:\s+points?)?|pluses?)\s*:?\s*$/i;
+var OTHER_HEADER_RE = /^(?:responsibilities|duties|about(?:\s+the)?(?:\s+role|\s+us|\s+company|\s+team)?|what\s+you.?ll\s+do|who\s+you\s+are|benefits|perks|compensation|how\s+to\s+apply|overview|summary|about)\s*:?\s*$/i;
+function extractHeaderScopedSkills(lines) {
+  const required = [];
+  const preferred = [];
+  let scope = null;
+  for (const line of lines) {
+    if (REQUIRED_HEADER_RE.test(line)) {
+      scope = "required";
+      continue;
+    }
+    if (PREFERRED_HEADER_RE.test(line)) {
+      scope = "preferred";
+      continue;
+    }
+    if (OTHER_HEADER_RE.test(line)) {
+      scope = null;
+      continue;
+    }
+    if (scope === "required") {
+      required.push(...tokenize(line));
+    } else if (scope === "preferred") {
+      preferred.push(...tokenize(line));
+    }
+  }
+  return { required, preferred };
+}
+var ROLE_NOUN_RE = new RegExp(`(${ROLE_NOUNS.join("|")})`, "gi");
 function extractRoleKeywords(text) {
-  const roleMatches = text.match(/(engineer|developer|manager|scientist|analyst|designer|architect|director|consultant|lead|vp)/gi) ?? [];
+  const roleMatches = text.match(ROLE_NOUN_RE) ?? [];
   const fallback = roleMatches.length === 0 ? [text.split(/\n/)[0] ?? ""] : [];
   return unique(tokenize([...roleMatches, ...fallback].join(" ")));
 }
+function extractTitleContextLines(text) {
+  const lines = splitLines(text);
+  const roleLines = lines.filter((line) => line.match(ROLE_NOUN_RE) !== null);
+  return roleLines.length > 0 ? roleLines : lines.slice(0, 1);
+}
 function extractMinExperience(text) {
-  const match = text.match(/(\d{1,2})\+?\s*(?:years?|yrs\.?|jahre?|ans?|années?)/i);
+  const match = text.match(
+    /(\d{1,2})\+?\s*(?:years?|yrs\.?|jahre?|ans?|années?)/i
+  );
   if (!match) return void 0;
   const parsed = Number.parseInt(match[1], 10);
   return parsed <= 60 ? parsed : void 0;
@@ -419,6 +716,38 @@ function isLanguageRequired(lang, jobDescription) {
     return LANG_SECTION_RE.test(line) || LANG_REQUIREMENT_HINT_RE.test(line);
   });
 }
+var YEARS_BEFORE_SKILL_RE = /(\d{1,2})\+?\s*years?\s*(?:of|in|with)?\s*((?:[a-z0-9][a-z0-9.#+\-/]*\s*){1,4})/gi;
+var SKILL_BEFORE_YEARS_RE = /((?:[a-z0-9][a-z0-9.#+\-/]*[\s,]*){1,4})\(?(\d{1,2})\+?\s*years?\)?/gi;
+function extractSkillExperienceRequirements(lines, skillVocab, aliases) {
+  const requirements = /* @__PURE__ */ new Map();
+  const record = (rawWord, years) => {
+    if (!Number.isFinite(years) || years <= 0 || years > 60) return;
+    const canonical = normalizeSkill(rawWord, aliases);
+    if (!skillVocab.has(rawWord.toLowerCase()) && !skillVocab.has(canonical))
+      return;
+    const existing = requirements.get(canonical);
+    if (existing === void 0 || years > existing) {
+      requirements.set(canonical, years);
+    }
+  };
+  for (const line of lines) {
+    for (const re of [YEARS_BEFORE_SKILL_RE, SKILL_BEFORE_YEARS_RE]) {
+      re.lastIndex = 0;
+      let match;
+      while (match = re.exec(line)) {
+        const years = Number.parseInt(
+          re === YEARS_BEFORE_SKILL_RE ? match[1] : match[2],
+          10
+        );
+        const candidateWords = tokenize(
+          re === YEARS_BEFORE_SKILL_RE ? match[2] : match[1]
+        );
+        for (const word of candidateWords) record(word, years);
+      }
+    }
+  }
+  return [...requirements.entries()].map(([skill, years]) => ({ skill, years })).sort((a, b) => a.skill.localeCompare(b.skill));
+}
 function extractDegreeLevels(text) {
   const found = /* @__PURE__ */ new Set();
   for (const [pattern, canonical] of DEGREE_VARIANTS) {
@@ -434,21 +763,47 @@ function parseJobDescription(jobDescription, config) {
     skillVocab.add(canonical.toLowerCase());
     for (const alias of aliases) skillVocab.add(alias.toLowerCase());
   }
-  for (const s of config.profile?.mandatorySkills ?? []) skillVocab.add(s.toLowerCase());
-  for (const s of config.profile?.optionalSkills ?? []) skillVocab.add(s.toLowerCase());
+  for (const s of config.profile?.mandatorySkills ?? [])
+    skillVocab.add(s.toLowerCase());
+  for (const s of config.profile?.optionalSkills ?? [])
+    skillVocab.add(s.toLowerCase());
   const isSkillLike = (t) => {
     if (skillVocab.has(t)) return true;
     if (/[.#+]/.test(t) && /[a-z]/.test(t)) return true;
-    if (t.includes("/")) return t.split("/").some((p) => p.length >= 2 && !STOP_WORDS.has(p));
+    if (t.includes("/"))
+      return t.split("/").some((p) => p.length >= 2 && !STOP_WORDS.has(p));
     return false;
   };
-  const requiredSkillsRaw = extractRequiredSkills(lines).filter(isSkillLike);
-  const preferredSkillsRaw = extractPreferredSkills(lines).filter(isSkillLike);
-  const requiredSkills = normalizeSkills(requiredSkillsRaw, config.skillAliases);
-  const preferredSkills = normalizeSkills(preferredSkillsRaw, config.skillAliases);
+  const headerScoped = extractHeaderScopedSkills(lines);
+  const requiredSkillsRaw = unique([
+    ...extractRequiredSkills(lines),
+    ...headerScoped.required
+  ]).filter(isSkillLike);
+  const preferredSkillsRaw = unique([
+    ...extractPreferredSkills(lines),
+    ...headerScoped.preferred
+  ]).filter(isSkillLike);
+  const requiredSkills = normalizeSkills(
+    requiredSkillsRaw,
+    config.skillAliases
+  );
+  const preferredSkills = normalizeSkills(
+    preferredSkillsRaw,
+    config.skillAliases
+  );
   const bodyTokens = tokenize(normalizedText).filter(isSkillLike);
   const roleKeywords = extractRoleKeywords(jobDescription);
-  const keywords = unique([...requiredSkills, ...preferredSkills, ...roleKeywords, ...bodyTokens]);
+  const keywords = unique([
+    ...requiredSkills,
+    ...preferredSkills,
+    ...roleKeywords,
+    ...bodyTokens
+  ]);
+  const skillExperienceRequirements = extractSkillExperienceRequirements(
+    lines,
+    skillVocab,
+    config.skillAliases
+  );
   return {
     raw: jobDescription,
     normalizedText,
@@ -457,13 +812,18 @@ function parseJobDescription(jobDescription, config) {
     roleKeywords,
     keywords,
     minExperienceYears: extractMinExperience(jobDescription),
+    skillExperienceRequirements,
     educationRequirements: extractDegreeLevels(jobDescription),
-    keywordSurfaceForms: collectKeywordSurfaceForms(jobDescription, config.skillAliases),
+    keywordSurfaceForms: collectKeywordSurfaceForms(
+      jobDescription,
+      config.skillAliases
+    ),
     // A language only counts as required if its mention carries a requirement/level cue
     // or sits in a "Languages:" line — plain references ("our Berlin office") don't count.
     requiredLanguages: parseLanguageMentions(jobDescription).filter(
       (lang) => isLanguageRequired(lang, jobDescription)
-    )
+    ),
+    seniority: inferSeniority(extractTitleContextLines(jobDescription))
   };
 }
 
@@ -561,7 +921,9 @@ function parseDateRange(text, referenceDate) {
   }
   const startToken = parseDateToken(rangeMatch[1]);
   const endRaw = rangeMatch[2];
-  const isPresent = /present|current|now|aktuell|heute|actuellement|présent|actuel/i.test(endRaw);
+  const isPresent = /present|current|now|aktuell|heute|actuellement|présent|actuel/i.test(
+    endRaw
+  );
   const endToken = isPresent ? void 0 : parseDateToken(endRaw);
   if (!startToken) {
     return null;
@@ -609,27 +971,92 @@ function sumExperienceYears(ranges) {
     totalMonths += curEnd - curStart + 1;
     return Number((totalMonths / 12).toFixed(2));
   }
-  const months = ranges.reduce((total, r) => total + (r.durationInMonths ?? 0), 0);
+  const months = ranges.reduce(
+    (total, r) => total + (r.durationInMonths ?? 0),
+    0
+  );
   return Number((months / 12).toFixed(2));
 }
+function detectEmploymentGaps(entries, minGapMonths = 3) {
+  const toIndex = (year, month) => year * 12 + month;
+  const intervals = entries.filter(
+    (e) => e.dates?.startYear !== void 0 && e.dates?.endYear !== void 0
+  ).map((e) => ({
+    s: toIndex(e.dates.startYear, e.dates.startMonth ?? 1),
+    e: toIndex(e.dates.endYear, e.dates.endMonth ?? 12),
+    label: e.title || e.company || "previous role"
+  })).sort((a, b) => a.s - b.s || b.e - a.e);
+  if (intervals.length < 2) {
+    return [];
+  }
+  const gaps = [];
+  let curEnd = intervals[0].e;
+  let curEndLabel = intervals[0].label;
+  for (let i = 1; i < intervals.length; i++) {
+    const interval = intervals[i];
+    if (interval.s <= curEnd + 1) {
+      if (interval.e > curEnd) {
+        curEnd = interval.e;
+        curEndLabel = interval.label;
+      }
+      continue;
+    }
+    const gapMonths = interval.s - curEnd - 1;
+    if (gapMonths >= minGapMonths) {
+      gaps.push({ afterRole: curEndLabel, months: gapMonths });
+    }
+    curEnd = interval.e;
+    curEndLabel = interval.label;
+  }
+  return gaps;
+}
 
 // src/core/parser/resume.parser.ts
 var SECTION_ALIASES = {
-  summary: ["summary", "profile", "about", "zusammenfassung", "profil", "r\xE9sum\xE9", "\xE0 propos"],
+  summary: [
+    "summary",
+    "profile",
+    "about",
+    "zusammenfassung",
+    "profil",
+    "r\xE9sum\xE9",
+    "\xE0 propos"
+  ],
   experience: [
     "experience",
     "work experience",
     "professional experience",
     "employment",
+    "work history",
+    "employment history",
     "erfahrung",
     "berufserfahrung",
     "exp\xE9rience",
     "exp\xE9rience professionnelle"
   ],
-  skills: ["skills", "technical skills", "technologies", "f\xE4higkeiten", "kenntnisse", "comp\xE9tences"],
-  education: ["education", "academics", "academic background", "ausbildung", "formation", "\xE9tudes"],
+  skills: [
+    "skills",
+    "technical skills",
+    "technologies",
+    "f\xE4higkeiten",
+    "kenntnisse",
+    "comp\xE9tences"
+  ],
+  education: [
+    "education",
+    "academics",
+    "academic background",
+    "ausbildung",
+    "formation",
+    "\xE9tudes"
+  ],
   projects: ["projects", "portfolio", "projekte", "projets"],
-  certifications: ["certifications", "licenses", "zertifizierungen", "certifications professionnelles"]
+  certifications: [
+    "certifications",
+    "licenses",
+    "zertifizierungen",
+    "certifications professionnelles"
+  ]
 };
 var STRONG_VERBS = [
   "led",
@@ -652,28 +1079,90 @@ var STRONG_VERBS = [
   "reduced",
   "increased"
 ];
-var WEAK_VERBS = ["worked", "helped", "performed", "responsible", "assisted", "participated", "involved"];
+var WEAK_VERBS = [
+  "worked",
+  "helped",
+  "performed",
+  "responsible",
+  "assisted",
+  "participated",
+  "involved"
+];
+var TITLE_SENIORITY_PREFIXES = [
+  "senior",
+  "lead",
+  "principal",
+  "staff",
+  "vp",
+  "director"
+];
+var TITLE_MODIFIER_WORDS = [
+  "software",
+  "full\\s*stack",
+  "frontend",
+  "backend"
+];
+var TITLE_PREFIX_WORDS = unique([
+  ...TITLE_SENIORITY_PREFIXES,
+  ...TITLE_MODIFIER_WORDS,
+  ...ROLE_NOUNS
+]);
+var TITLE_RE = new RegExp(`^(${TITLE_PREFIX_WORDS.join("|")})[^,(-]*`, "i");
 var METRIC_RE = /\d|%|\$|\bk\+|\bm\+/i;
 function classifyAchievement(line) {
   const lower = line.toLowerCase();
   const hasMetric = METRIC_RE.test(line);
-  const hasStrongVerb = STRONG_VERBS.some((verb) => new RegExp(`\\b${verb}\\b`).test(lower));
-  const hasWeakVerb = WEAK_VERBS.some((verb) => new RegExp(`\\b${verb}\\b`).test(lower));
+  const hasStrongVerb = STRONG_VERBS.some(
+    (verb) => new RegExp(`\\b${verb}\\b`).test(lower)
+  );
+  const hasWeakVerb = WEAK_VERBS.some(
+    (verb) => new RegExp(`\\b${verb}\\b`).test(lower)
+  );
   if (hasStrongVerb && hasMetric) {
-    return { text: line, strength: "strong", reason: "strong verb + quantified impact" };
+    return {
+      text: line,
+      strength: "strong",
+      reason: "strong verb + quantified impact"
+    };
   }
   if (hasWeakVerb) {
     return { text: line, strength: "weak", reason: "weak verb" };
   }
   return { text: line, strength: "weak", reason: "no quantified impact" };
 }
+var HEADER_TAIL_RE = /^[\s:.\-–—,]*(?:\d{4}\s*(?:[-–—]|to)\s*(?:\d{4}|present|current|now)|\d{4})?[\s:.\-–—,]*$/i;
+var MAX_HEADER_LINE_LENGTH = 60;
 function detectSection(line) {
-  const normalized = line.trim().toLowerCase();
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.length > MAX_HEADER_LINE_LENGTH) return null;
+  const normalized = trimmed.toLowerCase();
   for (const [section, aliases] of Object.entries(SECTION_ALIASES)) {
     for (const alias of aliases) {
       const safeAlias = escapeRegExp(alias);
-      const headerPattern = new RegExp(`^${safeAlias}(\\s*:)?$`, "i");
-      if (headerPattern.test(normalized)) {
+      const headerPattern = new RegExp(`^${safeAlias}(.*)$`, "i");
+      const match = normalized.match(headerPattern);
+      if (match && HEADER_TAIL_RE.test(match[1])) {
+        return section;
+      }
+    }
+  }
+  const coreLine = normalized.replace(/[\s:.\-–—,]+$/, "");
+  const lineWords = coreLine.split(/\s+/).filter(Boolean);
+  for (const [section, aliases] of Object.entries(SECTION_ALIASES)) {
+    for (const alias of aliases) {
+      const aliasWords = alias.split(/\s+/);
+      if (lineWords.length < aliasWords.length) continue;
+      const candidateWords = lineWords.slice(0, aliasWords.length);
+      const allFuzzy = aliasWords.every(
+        (aliasWord, i) => aliasWord !== candidateWords[i] && fuzzyEqual(stem(aliasWord), stem(candidateWords[i]))
+      );
+      if (!allFuzzy) continue;
+      const prefixPattern = new RegExp(
+        `^\\s*${candidateWords.map((w) => escapeRegExp(w)).join("\\s+")}(.*)$`,
+        "i"
+      );
+      const prefixMatch = normalized.match(prefixPattern);
+      if (prefixMatch && HEADER_TAIL_RE.test(prefixMatch[1])) {
         return section;
       }
     }
@@ -705,12 +1194,42 @@ function extractSections(text) {
   flush();
   return { sections, detected: unique(detected) };
 }
-function parseSkills(sectionContent, aliases) {
+function parseExplicitSkillList(sectionContent) {
   if (!sectionContent) return [];
   const hasBullets = /[•·‣▪○●◦]/.test(sectionContent);
   const normalized = hasBullets ? sectionContent.replace(/\n/g, " ") : sectionContent;
-  const raw = normalized.split(/[,;\n]|[•·‣▪○●◦]/).map((skill) => skill.trim().replace(/^[-•·‣▪○●◦\s]+|[-•·‣▪○●◦\s]+$/g, "").trim()).filter(Boolean);
-  return normalizeSkills(raw, aliases);
+  return normalized.split(/[,;\n]|[•·‣▪○●◦]/).map(
+    (skill) => skill.trim().replace(/^[-•·‣▪○●◦\s]+|[-•·‣▪○●◦\s]+$/g, "").trim()
+  ).filter(Boolean);
+}
+function extractKnownSkillsFromText(text, aliases) {
+  if (!text) return [];
+  const canonicalSet = new Set(
+    Object.keys(aliases).map((c) => c.toLowerCase())
+  );
+  const found = [];
+  for (const token of tokenize(text)) {
+    const canonical = normalizeSkill(token, aliases);
+    if (canonicalSet.has(canonical)) {
+      found.push(canonical);
+    }
+  }
+  return unique(found);
+}
+function parseSkills(sections, aliases) {
+  const explicit = normalizeSkills(
+    parseExplicitSkillList(sections.skills),
+    aliases
+  );
+  const fromExperience = extractKnownSkillsFromText(
+    sections.experience,
+    aliases
+  );
+  const fromSummary = extractKnownSkillsFromText(sections.summary, aliases);
+  return normalizeSkills(
+    unique([...explicit, ...fromExperience, ...fromSummary]),
+    aliases
+  );
 }
 function parseActionVerbs(text) {
   const words = tokenize(text);
@@ -719,7 +1238,7 @@ function parseActionVerbs(text) {
     weak: WEAK_VERBS.filter((verb) => words.includes(verb))
   };
 }
-function parseExperience(sectionContent, referenceDate) {
+function parseExperience(sectionContent, referenceDate, aliases) {
   if (!sectionContent) {
     return { entries: [], rangesInMonths: [], jobTitles: [], achievements: [] };
   }
@@ -730,23 +1249,32 @@ function parseExperience(sectionContent, referenceDate) {
   const achievements = [];
   for (const line of lines) {
     const range = parseDateRange(line, referenceDate);
+    const titleMatch2 = line.match(TITLE_RE);
+    const title = titleMatch2 ? titleMatch2[0].trim() : void 0;
     if (range) {
-      const previous = entries[entries.length - 1];
-      if (previous && !previous.dates) {
-        previous.dates = range;
+      if (title) {
+        jobTitles.push(title.toLowerCase());
+        entries.push({ title, dates: range, description: line, skills: [] });
       } else {
-        entries.push({ dates: range });
+        const previous = entries[entries.length - 1];
+        if (previous && !previous.dates) {
+          previous.dates = range;
+        } else {
+          entries.push({ dates: range, skills: [] });
+        }
       }
       if (range.durationInMonths) {
         rangesInMonths.push(range.durationInMonths);
       }
       continue;
     }
-    const titleMatch = line.match(/^(Senior|Lead|Principal|Staff|VP|Director|Consultant|Architect|Software|Full\s*Stack|Frontend|Backend|Engineer|Developer|Manager|Analyst)[^,-]*/i);
-    if (titleMatch) {
-      const title = titleMatch[0].trim();
+    if (title) {
       jobTitles.push(title.toLowerCase());
-      const entry = { title, description: line };
+      const entry = {
+        title,
+        description: line,
+        skills: []
+      };
       entries.push(entry);
       achievements.push(classifyAchievement(line));
       continue;
@@ -757,7 +1285,15 @@ function parseExperience(sectionContent, referenceDate) {
     }
     achievements.push(classifyAchievement(line));
   }
-  return { entries, rangesInMonths, jobTitles: unique(jobTitles), achievements };
+  for (const entry of entries) {
+    entry.skills = extractKnownSkillsFromText(entry.description, aliases);
+  }
+  return {
+    entries,
+    rangesInMonths,
+    jobTitles: unique(jobTitles),
+    achievements
+  };
 }
 function parseEducation(sectionContent) {
   if (!sectionContent) return [];
@@ -766,12 +1302,38 @@ function parseEducation(sectionContent) {
 function collectKeywords(text) {
   return unique(tokenize(text));
 }
+var EMAIL_RE = /[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}/i;
+var PHONE_RE = /\+?\(?\d{1,4}\)?(?:[\s.-]?\d{2,4}){2,4}/;
+var LINKEDIN_RE = /(?:https?:\/\/)?(?:[a-z]{2,3}\.)?linkedin\.com\/(?:in|pub)\/[a-z0-9\-_%]+\/?/i;
+var LOCATION_RE = /^[A-Z][A-Za-z.'-]+(?:\s[A-Z][A-Za-z.'-]+)*,\s*[A-Z][A-Za-z]{1,20}$/;
+function extractLocation(text) {
+  const candidateLines = splitLines(text).slice(0, 8);
+  for (const line of candidateLines) {
+    if (EMAIL_RE.test(line) || /\d/.test(line)) continue;
+    if (LOCATION_RE.test(line)) {
+      return line;
+    }
+  }
+  return void 0;
+}
+function extractContact(text) {
+  const email = text.match(EMAIL_RE)?.[0];
+  const phone = text.match(PHONE_RE)?.[0]?.trim();
+  const linkedin = text.match(LINKEDIN_RE)?.[0];
+  const location = extractLocation(text);
+  if (!email && !phone && !linkedin && !location) return void 0;
+  return { email, phone, linkedin, location };
+}
 function parseResume(resumeText, config) {
   const normalizedText = normalizeWhitespace(resumeText);
   const { sections, detected } = extractSections(resumeText);
-  const skills = parseSkills(sections.skills, config.skillAliases);
+  const skills = parseSkills(sections, config.skillAliases);
   const actionVerbs = parseActionVerbs(normalizedText);
-  const experienceData = parseExperience(sections.experience, config.referenceDate);
+  const experienceData = parseExperience(
+    sections.experience,
+    config.referenceDate,
+    config.skillAliases
+  );
   const educationEntries = parseEducation(sections.education);
   let totalExperienceYears = sumExperienceYears(
     experienceData.entries.map((entry) => entry.dates).filter((range) => Boolean(range))
@@ -784,7 +1346,12 @@ function parseResume(resumeText, config) {
       totalExperienceYears = parsed <= 60 ? parsed : 0;
     }
   }
-  const requiredSections = ["summary", "experience", "skills", "education"];
+  const requiredSections = [
+    "summary",
+    "experience",
+    "skills",
+    "education"
+  ];
   const warnings = [];
   const lineCount = splitLines(resumeText).length;
   if (resumeText.trim().length < 100) {
@@ -801,6 +1368,12 @@ function parseResume(resumeText, config) {
       warnings.push(`${section} section not detected`);
     }
   }
+  const contact = extractContact(resumeText);
+  if (!contact?.email) {
+    warnings.push(
+      "No email address detected \u2014 most ATS require a parseable contact email"
+    );
+  }
   return {
     raw: resumeText,
     normalizedText,
@@ -816,6 +1389,10 @@ function parseResume(resumeText, config) {
     totalExperienceYears,
     keywords: collectKeywords(normalizedText),
     languages: parseLanguageMentions(resumeText),
+    contact,
+    seniority: inferSeniority(experienceData.jobTitles),
+    employmentGaps: detectEmploymentGaps(experienceData.entries),
+    formatting: detectFormatting(resumeText),
     warnings
   };
 }
@@ -826,7 +1403,12 @@ var RuleEngine = class {
     this.config = config;
   }
   applySectionPenalties(resume) {
-    const requiredSections = ["summary", "experience", "skills", "education"];
+    const requiredSections = [
+      "summary",
+      "experience",
+      "skills",
+      "education"
+    ];
     let totalPenalty = 0;
     const warnings = [];
     const penaltyBySection = {
@@ -852,19 +1434,26 @@ var RuleEngine = class {
     const sectionResult = this.applySectionPenalties(input.resume);
     totalPenalty += sectionResult.totalPenalty;
     warnings.push(...sectionResult.warnings);
-    if (containsTableLikeStructure(input.resume.raw)) {
+    if (input.resume.formatting.hasTables) {
       totalPenalty += 8;
       warnings.push("Detected table-like or columnar formatting (penalty 8)");
     }
     if (input.overusedKeywords && input.overusedKeywords.length > 0) {
       const penalty = input.overusedKeywords.length * this.config.keywordDensity.overusePenalty;
       totalPenalty += penalty;
-      warnings.push(`Keyword stuffing detected for: ${input.overusedKeywords.join(", ")} (penalty ${penalty})`);
+      warnings.push(
+        `Keyword stuffing detected for: ${input.overusedKeywords.join(", ")} (penalty ${penalty})`
+      );
     }
     if (input.resume.detectedSections.length < 3) {
       totalPenalty += 5;
       warnings.push("Few recognizable sections found (penalty 5)");
     }
+    if (!input.resume.contact?.email) {
+      const penalty = this.config.sectionPenalties.missingContact;
+      totalPenalty += penalty;
+      warnings.push(`Missing contact email (penalty ${penalty})`);
+    }
     return { totalPenalty, warnings };
   }
   evaluate(input) {
@@ -895,9 +1484,31 @@ var RuleEngine = class {
 // src/core/scoring/scorer.ts
 var REQUIRED_SKILL_WEIGHT = 0.7;
 var OPTIONAL_SKILL_WEIGHT = 0.3;
-var EXPERIENCE_YEARS_WEIGHT = 0.75;
-var EXPERIENCE_ROLE_WEIGHT = 0.25;
-var ALL_CATEGORIES = ["technical", "tool", "concept", "soft", "marketing", "domain"];
+var EXPERIENCE_YEARS_WEIGHT = 0.65;
+var EXPERIENCE_ROLE_WEIGHT = 0.2;
+var EXPERIENCE_SENIORITY_WEIGHT = 0.15;
+var ALL_CATEGORIES = [
+  "technical",
+  "tool",
+  "concept",
+  "soft",
+  "marketing",
+  "domain"
+];
+var SENIORITY_RANK2 = {
+  junior: 0,
+  mid: 1,
+  senior: 2,
+  lead: 3,
+  principal: 4
+};
+var DEGREE_RANK = {
+  associate: 1,
+  bachelor: 2,
+  master: 3,
+  mba: 3,
+  phd: 4
+};
 function emptyCategoryBuckets() {
   const buckets = {};
   for (const category of ALL_CATEGORIES) {
@@ -905,18 +1516,32 @@ function emptyCategoryBuckets() {
   }
   return buckets;
 }
-function scoreSkills(resume, job, config) {
+function scoreSkills(resume, job, config, matchOptions) {
   const profileRequired = config.profile?.mandatorySkills ?? [];
   const profileOptional = config.profile?.optionalSkills ?? [];
   const required = new Set(
-    normalizeSkills([...job.requiredSkills, ...profileRequired], config.skillAliases)
+    normalizeSkills(
+      [...job.requiredSkills, ...profileRequired],
+      config.skillAliases,
+      matchOptions
+    )
   );
   const optional = new Set(
-    normalizeSkills([...job.preferredSkills, ...profileOptional], config.skillAliases)
+    normalizeSkills(
+      [...job.preferredSkills, ...profileOptional],
+      config.skillAliases,
+      matchOptions
+    )
+  );
+  const resumeSkills = new Set(
+    normalizeSkills(resume.skills, config.skillAliases, matchOptions)
+  );
+  const matchedRequired = [...required].filter(
+    (skill) => resumeSkills.has(skill)
+  );
+  const matchedOptional = [...optional].filter(
+    (skill) => resumeSkills.has(skill)
   );
-  const resumeSkills = new Set(normalizeSkills(resume.skills, config.skillAliases));
-  const matchedRequired = [...required].filter((skill) => resumeSkills.has(skill));
-  const matchedOptional = [...optional].filter((skill) => resumeSkills.has(skill));
   const requiredCoverage = required.size === 0 ? 1 : matchedRequired.length / required.size;
   const optionalCoverage = optional.size === 0 ? 1 : matchedOptional.length / optional.size;
   const score = clamp(
@@ -928,29 +1553,45 @@ function scoreSkills(resume, job, config) {
   const missing = [...required].filter((skill) => !resumeSkills.has(skill)).sort();
   return { score, matched, missing };
 }
+function computeSeniorityMatch(resume, job) {
+  const resumeSeniority = resume.seniority;
+  const required = job.seniority;
+  const met = !resumeSeniority || !required || SENIORITY_RANK2[resumeSeniority] >= SENIORITY_RANK2[required];
+  return { resume: resumeSeniority, required, met };
+}
 function scoreExperience(resume, job, config) {
+  const seniorityMatch = computeSeniorityMatch(resume, job);
   const requiredYears = job.minExperienceYears ?? config.profile?.minExperience ?? 0;
   if (!requiredYears) {
-    return { score: 100, missingYears: 0 };
+    return { score: 100, missingYears: 0, seniorityMatch };
   }
   const yearCoverage = clamp(resume.totalExperienceYears / requiredYears, 0, 2);
   const yearsComponent = clamp(yearCoverage, 0, 1) * EXPERIENCE_YEARS_WEIGHT;
-  const jobRoleSet = new Set(job.roleKeywords.map((value) => value.toLowerCase()));
-  const titleMatches = resume.jobTitles.filter((title) => jobRoleSet.has(title.toLowerCase()));
-  const titleCoverage = jobRoleSet.size === 0 ? 1 : titleMatches.length / jobRoleSet.size;
+  const titleCoverage = job.roleKeywords.length === 0 ? 1 : titleMatch(resume.jobTitles, job.roleKeywords);
   const roleComponent = clamp(titleCoverage, 0, 1) * EXPERIENCE_ROLE_WEIGHT;
-  const score = clamp((yearsComponent + roleComponent) * 100, 0, 100);
+  const seniorityComponent = (seniorityMatch.met ? 1 : 0) * EXPERIENCE_SENIORITY_WEIGHT;
+  const score = clamp(
+    (yearsComponent + roleComponent + seniorityComponent) * 100,
+    0,
+    100
+  );
   const missingYears = Math.max(requiredYears - resume.totalExperienceYears, 0);
-  return { score, missingYears: Number(missingYears.toFixed(2)) };
+  return {
+    score,
+    missingYears: Number(missingYears.toFixed(2)),
+    seniorityMatch
+  };
 }
 function keywordWeightOf(keyword, requiredSet, preferredSet, jdFrequencies) {
   const base = requiredSet.has(keyword) ? 3 : preferredSet.has(keyword) ? 2 : 1;
   const freqBonus = Math.min((jdFrequencies[keyword] ?? 1) - 1, 3) * 0.25;
   return base + freqBonus;
 }
-function scoreKeywords(resume, job, config) {
+function scoreKeywords(resume, job, config, matchOptions) {
   const jobKeywordSet = new Set(
-    job.keywords.map((k) => normalizeSkill(k, config.skillAliases))
+    job.keywords.map(
+      (k) => normalizeSkill(k, config.skillAliases, matchOptions)
+    )
   );
   if (jobKeywordSet.size === 0) {
     return {
@@ -963,20 +1604,32 @@ function scoreKeywords(resume, job, config) {
     };
   }
   const resumeTokens = tokenize(resume.normalizedText).map(
-    (t) => normalizeSkill(t, config.skillAliases)
+    (t) => normalizeSkill(t, config.skillAliases, matchOptions)
   );
   const resumeTokenSet = new Set(resumeTokens);
   const resumeFrequencies = countFrequencies(resumeTokens);
   const requiredSet = new Set(job.requiredSkills);
   const preferredSet = new Set(job.preferredSkills);
   const jdFrequencies = countFrequencies(
-    tokenize(job.normalizedText).map((t) => normalizeSkill(t, config.skillAliases))
+    tokenize(job.normalizedText).map(
+      (t) => normalizeSkill(t, config.skillAliases, matchOptions)
+    )
   );
   const weightOf = (keyword) => keywordWeightOf(keyword, requiredSet, preferredSet, jdFrequencies);
-  const matchedKeywords = [...jobKeywordSet].filter((keyword) => resumeTokenSet.has(keyword));
-  const missingKeywords = [...jobKeywordSet].filter((keyword) => !resumeTokenSet.has(keyword));
-  const totalWeight = [...jobKeywordSet].reduce((sum, keyword) => sum + weightOf(keyword), 0);
-  const matchedWeight = matchedKeywords.reduce((sum, keyword) => sum + weightOf(keyword), 0);
+  const matchedKeywords = [...jobKeywordSet].filter(
+    (keyword) => resumeTokenSet.has(keyword)
+  );
+  const missingKeywords = [...jobKeywordSet].filter(
+    (keyword) => !resumeTokenSet.has(keyword)
+  );
+  const totalWeight = [...jobKeywordSet].reduce(
+    (sum, keyword) => sum + weightOf(keyword),
+    0
+  );
+  const matchedWeight = matchedKeywords.reduce(
+    (sum, keyword) => sum + weightOf(keyword),
+    0
+  );
   const score = clamp(matchedWeight / totalWeight * 100, 0, 100);
   const totalTokens = resumeTokens.length || 1;
   const overusedKeywords = matchedKeywords.filter((keyword) => {
@@ -1013,38 +1666,158 @@ function scoreKeywords(resume, job, config) {
     keywordWeights
   };
 }
+function computePerSkillExperience(resume, config, matchOptions) {
+  const bySkill = /* @__PURE__ */ new Map();
+  for (const entry of resume.experience) {
+    if (!entry.dates || entry.skills.length === 0) continue;
+    const skillsInRole = normalizeSkills(
+      entry.skills,
+      config.skillAliases,
+      matchOptions
+    );
+    for (const skill of skillsInRole) {
+      const list = bySkill.get(skill) ?? [];
+      list.push(entry.dates);
+      bySkill.set(skill, list);
+    }
+  }
+  return [...bySkill.entries()].map(([skill, dates]) => ({ skill, years: sumExperienceYears(dates) })).sort((a, b) => a.skill.localeCompare(b.skill));
+}
+function computeSkillExperienceGaps(resume, job, config, matchOptions, perSkillExperience) {
+  if (job.skillExperienceRequirements.length === 0) return [];
+  const resumeSkills = new Set(
+    normalizeSkills(resume.skills, config.skillAliases, matchOptions)
+  );
+  const yearsBySkill = new Map(
+    perSkillExperience.map((p) => [p.skill, p.years])
+  );
+  const gaps = [];
+  for (const { skill, years } of job.skillExperienceRequirements) {
+    if (!resumeSkills.has(skill)) continue;
+    const resumeYears = yearsBySkill.get(skill) ?? 0;
+    if (resumeYears < years) {
+      gaps.push({ skill, requiredYears: years, resumeYears });
+    }
+  }
+  return gaps.sort((a, b) => a.skill.localeCompare(b.skill));
+}
 function scoreEducation(resume, job) {
   if (job.educationRequirements.length === 0) {
     return 100;
   }
-  const resumeDegreeLevels = extractDegreeLevels(resume.educationEntries.join(" "));
-  const matched = job.educationRequirements.filter(
-    (requirement) => resumeDegreeLevels.includes(requirement)
+  const resumeDegreeLevels = extractDegreeLevels(
+    resume.educationEntries.join(" ")
   );
-  if (matched.length === 0) {
+  if (resumeDegreeLevels.length === 0) {
     return 0;
   }
-  return clamp(matched.length / job.educationRequirements.length * 100, 0, 100);
+  const resumeMaxRank = Math.max(
+    ...resumeDegreeLevels.map((d) => DEGREE_RANK[d] ?? 0)
+  );
+  const perRequirementCredit = job.educationRequirements.map(
+    (requirement) => {
+      if (resumeDegreeLevels.includes(requirement)) return 1;
+      const requiredRank = DEGREE_RANK[requirement] ?? 0;
+      const diff = resumeMaxRank - requiredRank;
+      if (diff >= 1) return 0.85;
+      if (diff === 0) return 0.6;
+      if (diff === -1) return 0.35;
+      return 0;
+    }
+  );
+  const avgCredit = perRequirementCredit.reduce((sum, credit) => sum + credit, 0) / perRequirementCredit.length;
+  return clamp(avgCredit * 100, 0, 100);
+}
+function scoreParseability(formatting, contact, detectedSections) {
+  let score = 100;
+  const deductions = [];
+  const deduct = (points, reason) => {
+    score -= points;
+    deductions.push({ reason, points });
+  };
+  if (formatting.hasTables) {
+    deduct(
+      20,
+      "Table or columnar formatting detected \u2014 ATS parsers often misalign fields extracted from tables"
+    );
+  }
+  if (formatting.hasMultiColumn) {
+    deduct(
+      20,
+      "Multi-column layout detected \u2014 text may extract out of reading order in real ATS systems"
+    );
+  }
+  if (formatting.hasSpecialChars) {
+    deduct(
+      10,
+      "Special or control characters detected \u2014 likely icon fonts or a lossy text extraction"
+    );
+  }
+  if (formatting.nonStandardBullets) {
+    deduct(
+      8,
+      "Non-standard bullet characters detected \u2014 some ATS parsers won't recognize them as list items"
+    );
+  }
+  if (formatting.likelyScanned) {
+    deduct(
+      30,
+      "Resume text looks scanned or image-based with little extractable text"
+    );
+  }
+  if (!contact?.email || !formatting.contactParseable) {
+    deduct(15, "No parseable contact email detected");
+  }
+  if (detectedSections.length < 3) {
+    deduct(10, "Fewer than 3 standard resume sections were detected");
+  }
+  return {
+    score: clamp(score, 0, 100),
+    report: {
+      ...formatting,
+      detectedSectionCount: detectedSections.length,
+      deductions
+    }
+  };
 }
 function calculateScore(resume, job, config) {
-  const skillsResult = scoreSkills(resume, job, config);
+  const matchOptions = {
+    fuzzy: config.matching.fuzzy,
+    maxDistance: config.matching.threshold
+  };
+  const skillsResult = scoreSkills(resume, job, config, matchOptions);
   const experienceResult = scoreExperience(resume, job, config);
-  const keywordResult = scoreKeywords(resume, job, config);
+  const keywordResult = scoreKeywords(resume, job, config, matchOptions);
   const educationScore = scoreEducation(resume, job);
+  const parseabilityResult = scoreParseability(
+    resume.formatting,
+    resume.contact,
+    resume.detectedSections
+  );
   const breakdown = {
     skills: skillsResult.score,
     experience: experienceResult.score,
     keywords: keywordResult.score,
+    parseability: parseabilityResult.score,
     education: educationScore
   };
-  const weightedScore = breakdown.skills * config.weights.skills + breakdown.experience * config.weights.experience + breakdown.keywords * config.weights.keywords + breakdown.education * config.weights.education;
+  const weightedScore = breakdown.skills * config.weights.skills + breakdown.experience * config.weights.experience + breakdown.keywords * config.weights.keywords + breakdown.parseability * config.weights.parseability + breakdown.education * config.weights.education;
   const achievementStrength = {
     strong: resume.achievements.filter((a) => a.strength === "strong").length,
     weak: resume.achievements.filter((a) => a.strength === "weak").length
   };
-  const { matched: matchedLanguages, missing: missingLanguages } = diffLanguages(
-    resume.languages,
-    job.requiredLanguages
+  const { matched: matchedLanguages, missing: missingLanguages } = diffLanguages(resume.languages, job.requiredLanguages);
+  const perSkillExperience = computePerSkillExperience(
+    resume,
+    config,
+    matchOptions
+  );
+  const skillExperienceGaps = computeSkillExperienceGaps(
+    resume,
+    job,
+    config,
+    matchOptions,
+    perSkillExperience
   );
   return {
     score: clamp(Number(weightedScore.toFixed(2)), 0, 100),
@@ -1059,6 +1832,7 @@ function calculateScore(resume, job, config) {
     achievementStrength,
     matchedLanguages,
     missingLanguages,
+    skillExperienceGaps,
     suggestions: [],
     warnings: [],
     // detectedSections / parsedExperienceYears / experienceGap / experienceEntries: filled by index.ts
@@ -1067,7 +1841,11 @@ function calculateScore(resume, job, config) {
     parsedExperienceYears: 0,
     experienceEntries: [],
     missingExperienceYears: experienceResult.missingYears,
-    educationScore
+    educationScore,
+    parseabilityReport: parseabilityResult.report,
+    employmentGaps: resume.employmentGaps,
+    seniorityMatch: experienceResult.seniorityMatch,
+    perSkillExperience
   };
 }
 
@@ -1075,109 +1853,499 @@ function calculateScore(resume, job, config) {
 var defaultKeywordRegistry = [
   // languages / frameworks
   // ponytail: "node" split from javascript — Node.js runtime !== JS language
-  { canonical: "javascript", aliases: ["js"], category: "technical" },
+  {
+    canonical: "javascript",
+    aliases: ["js", "ecmascript", "es6"],
+    category: "technical"
+  },
   { canonical: "node", aliases: ["node.js", "nodejs"], category: "technical" },
   { canonical: "typescript", aliases: ["ts"], category: "technical" },
-  { canonical: "react", aliases: ["reactjs", "react.js"], category: "technical" },
-  { canonical: "angular", aliases: ["angularjs"], category: "technical" },
+  {
+    canonical: "react",
+    aliases: ["reactjs", "react.js"],
+    category: "technical"
+  },
+  {
+    canonical: "angular",
+    aliases: ["angularjs", "angular2+"],
+    category: "technical"
+  },
   { canonical: "vue", aliases: ["vue.js", "vuejs"], category: "technical" },
-  { canonical: "svelte", aliases: [], category: "technical" },
+  { canonical: "svelte", aliases: ["sveltekit"], category: "technical" },
   { canonical: "next.js", aliases: ["nextjs"], category: "technical" },
+  { canonical: "nuxt.js", aliases: ["nuxtjs", "nuxt"], category: "technical" },
+  { canonical: "remix", aliases: [], category: "technical" },
   { canonical: "c++", aliases: ["cpp"], category: "technical" },
   { canonical: "c#", aliases: ["csharp", ".net"], category: "technical" },
   { canonical: "java", aliases: [], category: "technical" },
   { canonical: "python", aliases: ["py"], category: "technical" },
   { canonical: "go", aliases: ["golang"], category: "technical" },
   { canonical: "rust", aliases: [], category: "technical" },
-  { canonical: "ruby", aliases: ["ruby on rails", "rails"], category: "technical" },
+  {
+    canonical: "ruby",
+    aliases: ["ruby on rails", "rails"],
+    category: "technical"
+  },
   { canonical: "php", aliases: [], category: "technical" },
-  { canonical: "swift", aliases: [], category: "technical" },
+  { canonical: "swift", aliases: ["swiftui"], category: "technical" },
   { canonical: "kotlin", aliases: [], category: "technical" },
   { canonical: "scala", aliases: [], category: "technical" },
+  { canonical: "perl", aliases: [], category: "technical" },
+  {
+    canonical: "r",
+    aliases: ["r language", "r programming"],
+    category: "technical"
+  },
+  { canonical: "matlab", aliases: [], category: "technical" },
+  {
+    canonical: "objective-c",
+    aliases: ["objective c", "objc"],
+    category: "technical"
+  },
+  { canonical: "dart", aliases: [], category: "technical" },
+  { canonical: "elixir", aliases: [], category: "technical" },
+  { canonical: "haskell", aliases: [], category: "technical" },
   { canonical: "html", aliases: ["html5"], category: "technical" },
   { canonical: "css", aliases: ["css3"], category: "technical" },
+  { canonical: "sass", aliases: ["scss"], category: "technical" },
+  { canonical: "less", aliases: [], category: "technical" },
+  {
+    canonical: "tailwind css",
+    aliases: ["tailwind", "tailwindcss"],
+    category: "technical"
+  },
+  { canonical: "bootstrap", aliases: [], category: "technical" },
+  { canonical: "webassembly", aliases: ["wasm"], category: "technical" },
   { canonical: "ios development", aliases: ["ios"], category: "technical" },
-  { canonical: "android development", aliases: ["android"], category: "technical" },
+  {
+    canonical: "android development",
+    aliases: ["android"],
+    category: "technical"
+  },
   { canonical: "react native", aliases: [], category: "technical" },
   { canonical: "flutter", aliases: [], category: "technical" },
+  { canonical: "xamarin", aliases: [], category: "technical" },
   { canonical: "machine learning", aliases: ["ml"], category: "technical" },
-  { canonical: "deep learning", aliases: [], category: "technical" },
-  { canonical: "natural language processing", aliases: ["nlp"], category: "technical" },
+  { canonical: "deep learning", aliases: ["dl"], category: "technical" },
+  {
+    canonical: "natural language processing",
+    aliases: ["nlp"],
+    category: "technical"
+  },
+  { canonical: "computer vision", aliases: ["cv"], category: "technical" },
+  {
+    canonical: "large language models",
+    aliases: ["llm", "llms"],
+    category: "technical"
+  },
+  {
+    canonical: "generative ai",
+    aliases: ["genai", "gen ai"],
+    category: "technical"
+  },
+  {
+    canonical: "reinforcement learning",
+    aliases: ["rl"],
+    category: "technical"
+  },
+  {
+    canonical: "neural networks",
+    aliases: ["neural network"],
+    category: "technical"
+  },
+  { canonical: "data engineering", aliases: [], category: "technical" },
+  {
+    canonical: "data warehousing",
+    aliases: ["data warehouse"],
+    category: "technical"
+  },
+  {
+    canonical: "etl",
+    aliases: ["extract transform load", "elt"],
+    category: "technical"
+  },
+  { canonical: "distributed systems", aliases: [], category: "technical" },
+  { canonical: "embedded systems", aliases: [], category: "technical" },
+  {
+    canonical: "firmware development",
+    aliases: ["firmware"],
+    category: "technical"
+  },
+  { canonical: "game development", aliases: [], category: "technical" },
+  { canonical: "unity", aliases: [], category: "technical" },
+  { canonical: "unreal engine", aliases: ["unreal"], category: "technical" },
+  { canonical: "web development", aliases: [], category: "technical" },
+  {
+    canonical: "full stack development",
+    aliases: ["full-stack development", "full stack"],
+    category: "technical"
+  },
+  { canonical: "api development", aliases: [], category: "technical" },
+  { canonical: "grpc", aliases: [], category: "technical" },
+  { canonical: "websockets", aliases: ["websocket"], category: "technical" },
+  { canonical: "linux", aliases: [], category: "technical" },
+  { canonical: "unix", aliases: [], category: "technical" },
+  {
+    canonical: "bash scripting",
+    aliases: ["bash", "shell scripting"],
+    category: "technical"
+  },
+  { canonical: "powershell", aliases: [], category: "technical" },
   // tools / platforms / infra
-  { canonical: "sql", aliases: ["postgres", "mysql", "sqlite"], category: "tool" },
+  {
+    canonical: "sql",
+    aliases: ["structured query language"],
+    category: "tool"
+  },
+  { canonical: "postgresql", aliases: ["postgres", "psql"], category: "tool" },
+  { canonical: "mysql", aliases: [], category: "tool" },
+  { canonical: "sqlite", aliases: [], category: "tool" },
+  {
+    canonical: "microsoft sql server",
+    aliases: ["mssql", "sql server", "t-sql"],
+    category: "tool"
+  },
+  {
+    canonical: "oracle database",
+    aliases: ["oracle db", "oracle"],
+    category: "tool"
+  },
+  { canonical: "mongodb", aliases: ["mongo"], category: "tool" },
+  { canonical: "cassandra", aliases: ["apache cassandra"], category: "tool" },
+  { canonical: "dynamodb", aliases: ["amazon dynamodb"], category: "tool" },
+  { canonical: "couchbase", aliases: [], category: "tool" },
+  { canonical: "neo4j", aliases: [], category: "tool" },
+  { canonical: "firebase", aliases: [], category: "tool" },
+  { canonical: "supabase", aliases: [], category: "tool" },
   { canonical: "graphql", aliases: ["gql"], category: "tool" },
   { canonical: "aws", aliases: ["amazon web services"], category: "tool" },
+  { canonical: "amazon ec2", aliases: ["ec2"], category: "tool" },
+  { canonical: "amazon s3", aliases: ["s3"], category: "tool" },
+  { canonical: "amazon rds", aliases: ["rds"], category: "tool" },
+  { canonical: "aws lambda", aliases: ["lambda"], category: "tool" },
+  { canonical: "amazon cloudfront", aliases: ["cloudfront"], category: "tool" },
+  { canonical: "amazon sqs", aliases: ["sqs"], category: "tool" },
+  { canonical: "amazon sns", aliases: ["sns"], category: "tool" },
   { canonical: "azure", aliases: ["microsoft azure"], category: "tool" },
-  { canonical: "gcp", aliases: ["google cloud", "google cloud platform"], category: "tool" },
-  { canonical: "docker", aliases: ["containers"], category: "tool" },
+  { canonical: "azure devops", aliases: [], category: "tool" },
+  { canonical: "azure functions", aliases: [], category: "tool" },
+  {
+    canonical: "google cloud platform",
+    aliases: ["gcp", "google cloud"],
+    category: "tool"
+  },
+  { canonical: "google bigquery", aliases: ["bigquery"], category: "tool" },
+  { canonical: "google kubernetes engine", aliases: ["gke"], category: "tool" },
+  {
+    canonical: "docker",
+    aliases: ["containers", "containerization"],
+    category: "tool"
+  },
   { canonical: "kubernetes", aliases: ["k8s"], category: "tool" },
+  { canonical: "helm", aliases: [], category: "tool" },
   { canonical: "terraform", aliases: [], category: "tool" },
+  { canonical: "pulumi", aliases: [], category: "tool" },
   { canonical: "ansible", aliases: [], category: "tool" },
+  { canonical: "puppet", aliases: [], category: "tool" },
+  { canonical: "chef", aliases: [], category: "tool" },
   { canonical: "jenkins", aliases: [], category: "tool" },
-  { canonical: "git", aliases: ["github", "gitlab"], category: "tool" },
+  { canonical: "circleci", aliases: ["circle ci"], category: "tool" },
+  { canonical: "github actions", aliases: [], category: "tool" },
+  { canonical: "gitlab ci", aliases: ["gitlab ci/cd"], category: "tool" },
+  { canonical: "travis ci", aliases: [], category: "tool" },
+  {
+    canonical: "git",
+    aliases: ["github", "gitlab", "bitbucket"],
+    category: "tool"
+  },
   { canonical: "jira", aliases: [], category: "tool" },
   { canonical: "confluence", aliases: [], category: "tool" },
+  { canonical: "trello", aliases: [], category: "tool" },
+  { canonical: "asana", aliases: [], category: "tool" },
+  { canonical: "monday.com", aliases: ["monday"], category: "tool" },
+  { canonical: "notion", aliases: [], category: "tool" },
+  { canonical: "linear", aliases: [], category: "tool" },
+  { canonical: "slack", aliases: [], category: "tool" },
+  { canonical: "microsoft teams", aliases: ["ms teams"], category: "tool" },
   { canonical: "pytorch", aliases: ["torch"], category: "tool" },
   { canonical: "tensorflow", aliases: ["tf"], category: "tool" },
+  { canonical: "keras", aliases: [], category: "tool" },
   { canonical: "scikit-learn", aliases: ["sklearn"], category: "tool" },
   { canonical: "pandas", aliases: [], category: "tool" },
   { canonical: "numpy", aliases: [], category: "tool" },
+  {
+    canonical: "hugging face",
+    aliases: ["huggingface", "transformers"],
+    category: "tool"
+  },
+  { canonical: "langchain", aliases: [], category: "tool" },
+  { canonical: "openai api", aliases: ["openai", "gpt api"], category: "tool" },
+  { canonical: "jupyter", aliases: ["jupyter notebook"], category: "tool" },
   { canonical: "fastapi", aliases: [], category: "tool" },
   { canonical: "flask", aliases: [], category: "tool" },
   { canonical: "django", aliases: [], category: "tool" },
-  { canonical: "kafka", aliases: [], category: "tool" },
+  {
+    canonical: "express.js",
+    aliases: ["express", "expressjs"],
+    category: "tool"
+  },
+  { canonical: "spring boot", aliases: ["spring"], category: "tool" },
+  { canonical: "laravel", aliases: [], category: "tool" },
+  { canonical: "kafka", aliases: ["apache kafka"], category: "tool" },
+  { canonical: "rabbitmq", aliases: [], category: "tool" },
   { canonical: "redis", aliases: [], category: "tool" },
+  { canonical: "memcached", aliases: [], category: "tool" },
   { canonical: "elasticsearch", aliases: ["elastic"], category: "tool" },
-  { canonical: "spark", aliases: ["apache spark"], category: "tool" },
+  { canonical: "logstash", aliases: [], category: "tool" },
+  { canonical: "kibana", aliases: [], category: "tool" },
+  { canonical: "grafana", aliases: [], category: "tool" },
+  { canonical: "prometheus", aliases: [], category: "tool" },
+  { canonical: "datadog", aliases: [], category: "tool" },
+  { canonical: "new relic", aliases: [], category: "tool" },
+  { canonical: "splunk", aliases: [], category: "tool" },
+  {
+    canonical: "spark",
+    aliases: ["apache spark", "pyspark"],
+    category: "tool"
+  },
+  { canonical: "hadoop", aliases: ["apache hadoop"], category: "tool" },
+  { canonical: "airflow", aliases: ["apache airflow"], category: "tool" },
+  { canonical: "dbt", aliases: ["data build tool"], category: "tool" },
+  { canonical: "snowflake", aliases: [], category: "tool" },
+  { canonical: "databricks", aliases: [], category: "tool" },
+  { canonical: "looker", aliases: [], category: "tool" },
   { canonical: "tableau", aliases: [], category: "tool" },
   { canonical: "power bi", aliases: ["powerbi"], category: "tool" },
-  { canonical: "excel", aliases: ["microsoft excel", "ms excel"], category: "tool" },
+  {
+    canonical: "excel",
+    aliases: ["microsoft excel", "ms excel"],
+    category: "tool"
+  },
+  { canonical: "google sheets", aliases: [], category: "tool" },
+  { canonical: "spss", aliases: [], category: "tool" },
+  { canonical: "sas", aliases: [], category: "tool" },
   { canonical: "salesforce", aliases: [], category: "tool" },
   { canonical: "hubspot", aliases: [], category: "tool" },
+  { canonical: "marketo", aliases: [], category: "tool" },
+  { canonical: "mailchimp", aliases: [], category: "tool" },
+  { canonical: "google analytics", aliases: ["ga4"], category: "tool" },
+  { canonical: "google tag manager", aliases: ["gtm"], category: "tool" },
   { canonical: "sap", aliases: [], category: "tool" },
   { canonical: "quickbooks", aliases: [], category: "tool" },
+  { canonical: "netsuite", aliases: [], category: "tool" },
   { canonical: "workday", aliases: [], category: "tool" },
   { canonical: "zendesk", aliases: [], category: "tool" },
   { canonical: "servicenow", aliases: [], category: "tool" },
+  { canonical: "freshdesk", aliases: [], category: "tool" },
   { canonical: "figma", aliases: [], category: "tool" },
+  { canonical: "sketch", aliases: [], category: "tool" },
+  { canonical: "adobe xd", aliases: ["xd"], category: "tool" },
+  { canonical: "invision", aliases: [], category: "tool" },
   { canonical: "photoshop", aliases: ["adobe photoshop"], category: "tool" },
-  { canonical: "illustrator", aliases: ["adobe illustrator"], category: "tool" },
+  {
+    canonical: "illustrator",
+    aliases: ["adobe illustrator"],
+    category: "tool"
+  },
+  {
+    canonical: "after effects",
+    aliases: ["adobe after effects"],
+    category: "tool"
+  },
+  { canonical: "premiere pro", aliases: ["adobe premiere"], category: "tool" },
   { canonical: "autocad", aliases: [], category: "tool" },
+  { canonical: "solidworks", aliases: [], category: "tool" },
+  { canonical: "postman", aliases: [], category: "tool" },
+  { canonical: "selenium", aliases: [], category: "tool" },
+  { canonical: "cypress", aliases: [], category: "tool" },
+  { canonical: "playwright", aliases: [], category: "tool" },
+  { canonical: "jest", aliases: [], category: "tool" },
+  { canonical: "mocha", aliases: [], category: "tool" },
+  { canonical: "junit", aliases: [], category: "tool" },
   // engineering concepts
   { canonical: "accessibility", aliases: ["a11y"], category: "concept" },
   { canonical: "frontend", aliases: ["front-end"], category: "concept" },
   { canonical: "backend", aliases: ["back-end"], category: "concept" },
-  { canonical: "security", aliases: ["cybersecurity"], category: "concept" },
-  { canonical: "testing", aliases: ["unittest", "pytest"], category: "concept" },
+  {
+    canonical: "security",
+    aliases: ["cybersecurity", "infosec"],
+    category: "concept"
+  },
+  {
+    canonical: "application security",
+    aliases: ["appsec"],
+    category: "concept"
+  },
+  {
+    canonical: "penetration testing",
+    aliases: ["pentesting", "pen testing"],
+    category: "concept"
+  },
+  { canonical: "vulnerability assessment", aliases: [], category: "concept" },
+  {
+    canonical: "identity and access management",
+    aliases: ["iam"],
+    category: "concept"
+  },
+  { canonical: "zero trust", aliases: [], category: "concept" },
+  { canonical: "encryption", aliases: [], category: "concept" },
+  {
+    canonical: "testing",
+    aliases: ["unittest", "pytest"],
+    category: "concept"
+  },
+  { canonical: "unit testing", aliases: [], category: "concept" },
+  { canonical: "integration testing", aliases: [], category: "concept" },
+  {
+    canonical: "end-to-end testing",
+    aliases: ["e2e testing"],
+    category: "concept"
+  },
+  { canonical: "regression testing", aliases: [], category: "concept" },
   { canonical: "microservices", aliases: [], category: "concept" },
-  { canonical: "agile", aliases: ["scrum"], category: "concept" },
+  {
+    canonical: "monolithic architecture",
+    aliases: ["monolith"],
+    category: "concept"
+  },
+  {
+    canonical: "event-driven architecture",
+    aliases: ["event driven architecture"],
+    category: "concept"
+  },
+  {
+    canonical: "serverless",
+    aliases: ["serverless architecture"],
+    category: "concept"
+  },
+  { canonical: "agile", aliases: [], category: "concept" },
+  { canonical: "scrum", aliases: [], category: "concept" },
   { canonical: "kanban", aliases: [], category: "concept" },
+  { canonical: "waterfall", aliases: [], category: "concept" },
+  { canonical: "sprint planning", aliases: [], category: "concept" },
   { canonical: "blockchain", aliases: [], category: "concept" },
+  { canonical: "smart contracts", aliases: [], category: "concept" },
   { canonical: "devops", aliases: [], category: "concept" },
-  { canonical: "ci/cd", aliases: ["continuous integration", "continuous deployment"], category: "concept" },
-  { canonical: "rest api", aliases: ["restful api", "rest apis"], category: "concept" },
+  {
+    canonical: "site reliability engineering",
+    aliases: ["sre"],
+    category: "concept"
+  },
+  {
+    canonical: "infrastructure as code",
+    aliases: ["iac"],
+    category: "concept"
+  },
+  {
+    canonical: "ci/cd",
+    aliases: [
+      "continuous integration",
+      "continuous deployment",
+      "continuous delivery"
+    ],
+    category: "concept"
+  },
+  {
+    canonical: "rest api",
+    aliases: ["restful api", "rest apis"],
+    category: "concept"
+  },
+  { canonical: "api design", aliases: [], category: "concept" },
   { canonical: "design patterns", aliases: [], category: "concept" },
   { canonical: "data structures", aliases: [], category: "concept" },
   { canonical: "algorithms", aliases: [], category: "concept" },
+  {
+    canonical: "object-oriented programming",
+    aliases: ["oop", "object oriented programming"],
+    category: "concept"
+  },
+  { canonical: "functional programming", aliases: [], category: "concept" },
   { canonical: "cloud computing", aliases: [], category: "concept" },
+  { canonical: "cloud migration", aliases: [], category: "concept" },
   { canonical: "system design", aliases: [], category: "concept" },
-  { canonical: "tdd", aliases: ["test driven development", "test-driven development"], category: "concept" },
+  { canonical: "high availability", aliases: [], category: "concept" },
+  { canonical: "scalability", aliases: [], category: "concept" },
+  { canonical: "load balancing", aliases: [], category: "concept" },
+  { canonical: "caching", aliases: [], category: "concept" },
+  {
+    canonical: "tdd",
+    aliases: ["test driven development", "test-driven development"],
+    category: "concept"
+  },
+  {
+    canonical: "bdd",
+    aliases: ["behavior driven development", "behavior-driven development"],
+    category: "concept"
+  },
+  { canonical: "code review", aliases: ["code reviews"], category: "concept" },
+  { canonical: "pair programming", aliases: [], category: "concept" },
   { canonical: "ux design", aliases: ["user experience"], category: "concept" },
-  { canonical: "ui design", aliases: ["user interface design"], category: "concept" },
+  {
+    canonical: "ui design",
+    aliases: ["user interface design"],
+    category: "concept"
+  },
+  { canonical: "user research", aliases: [], category: "concept" },
+  { canonical: "wireframing", aliases: [], category: "concept" },
+  { canonical: "prototyping", aliases: [], category: "concept" },
+  { canonical: "design systems", aliases: [], category: "concept" },
+  { canonical: "responsive design", aliases: [], category: "concept" },
   { canonical: "project management", aliases: [], category: "concept" },
+  { canonical: "program management", aliases: [], category: "concept" },
   { canonical: "change management", aliases: [], category: "concept" },
   { canonical: "risk management", aliases: [], category: "concept" },
   { canonical: "quality assurance", aliases: ["qa"], category: "concept" },
+  { canonical: "data privacy", aliases: [], category: "concept" },
+  { canonical: "version control", aliases: [], category: "concept" },
+  {
+    canonical: "documentation",
+    aliases: ["technical documentation"],
+    category: "concept"
+  },
+  { canonical: "requirements gathering", aliases: [], category: "concept" },
+  {
+    canonical: "business process improvement",
+    aliases: [],
+    category: "concept"
+  },
+  { canonical: "root cause analysis", aliases: [], category: "concept" },
+  { canonical: "lean", aliases: ["lean methodology"], category: "concept" },
+  { canonical: "six sigma", aliases: [], category: "concept" },
   // product / data domain
-  { canonical: "roadmap", aliases: [], category: "domain" },
+  { canonical: "roadmap", aliases: ["product roadmap"], category: "domain" },
   { canonical: "stakeholder management", aliases: [], category: "domain" },
   { canonical: "prioritization", aliases: [], category: "domain" },
   { canonical: "a/b testing", aliases: ["ab testing"], category: "domain" },
   { canonical: "analytics", aliases: [], category: "domain" },
   { canonical: "statistics", aliases: ["stats"], category: "domain" },
   { canonical: "data visualization", aliases: [], category: "domain" },
+  { canonical: "data governance", aliases: [], category: "domain" },
+  { canonical: "product management", aliases: [], category: "domain" },
+  { canonical: "product strategy", aliases: [], category: "domain" },
+  {
+    canonical: "go-to-market strategy",
+    aliases: ["go to market", "gtm strategy"],
+    category: "domain"
+  },
+  {
+    canonical: "user story writing",
+    aliases: ["user stories"],
+    category: "domain"
+  },
+  { canonical: "competitive analysis", aliases: [], category: "domain" },
+  {
+    canonical: "okrs",
+    aliases: ["objectives and key results"],
+    category: "domain"
+  },
+  {
+    canonical: "kpis",
+    aliases: ["key performance indicators"],
+    category: "domain"
+  },
   // finance / accounting domain
   { canonical: "financial analysis", aliases: [], category: "domain" },
+  { canonical: "financial modeling", aliases: [], category: "domain" },
   { canonical: "budgeting", aliases: [], category: "domain" },
   { canonical: "forecasting", aliases: [], category: "domain" },
   { canonical: "bookkeeping", aliases: [], category: "domain" },
@@ -1187,78 +2355,260 @@ var defaultKeywordRegistry = [
   { canonical: "auditing", aliases: ["audit"], category: "domain" },
   { canonical: "tax preparation", aliases: [], category: "domain" },
   { canonical: "gaap", aliases: [], category: "domain" },
+  { canonical: "ifrs", aliases: [], category: "domain" },
+  {
+    canonical: "reconciliation",
+    aliases: ["account reconciliation"],
+    category: "domain"
+  },
+  { canonical: "general ledger", aliases: [], category: "domain" },
+  { canonical: "cost accounting", aliases: [], category: "domain" },
+  {
+    canonical: "mergers and acquisitions",
+    aliases: ["m&a"],
+    category: "domain"
+  },
+  { canonical: "investment banking", aliases: [], category: "domain" },
+  { canonical: "portfolio management", aliases: [], category: "domain" },
+  { canonical: "equity research", aliases: [], category: "domain" },
+  {
+    canonical: "treasury management",
+    aliases: ["treasury"],
+    category: "domain"
+  },
+  { canonical: "fintech", aliases: [], category: "domain" },
+  {
+    canonical: "payments processing",
+    aliases: ["payment processing"],
+    category: "domain"
+  },
   // sales / account management domain
   { canonical: "lead generation", aliases: [], category: "domain" },
   { canonical: "account management", aliases: [], category: "domain" },
-  { canonical: "crm", aliases: ["customer relationship management"], category: "domain" },
-  { canonical: "sales pipeline", aliases: [], category: "domain" },
+  {
+    canonical: "crm",
+    aliases: ["customer relationship management"],
+    category: "domain"
+  },
+  {
+    canonical: "sales pipeline",
+    aliases: ["pipeline management"],
+    category: "domain"
+  },
   { canonical: "cold calling", aliases: [], category: "domain" },
   { canonical: "upselling", aliases: ["cross-selling"], category: "domain" },
   { canonical: "customer retention", aliases: [], category: "domain" },
+  {
+    canonical: "business development",
+    aliases: ["bizdev"],
+    category: "domain"
+  },
+  { canonical: "quota attainment", aliases: [], category: "domain" },
+  { canonical: "b2b sales", aliases: [], category: "domain" },
+  { canonical: "b2c sales", aliases: [], category: "domain" },
+  { canonical: "saas", aliases: ["software as a service"], category: "domain" },
+  { canonical: "e-commerce", aliases: ["ecommerce"], category: "domain" },
   // human resources domain
-  { canonical: "recruiting", aliases: ["talent acquisition"], category: "domain" },
+  {
+    canonical: "recruiting",
+    aliases: ["talent acquisition"],
+    category: "domain"
+  },
   { canonical: "onboarding", aliases: [], category: "domain" },
   { canonical: "employee relations", aliases: [], category: "domain" },
   { canonical: "benefits administration", aliases: [], category: "domain" },
   { canonical: "performance management", aliases: [], category: "domain" },
+  {
+    canonical: "compensation and benefits",
+    aliases: ["comp and benefits"],
+    category: "domain"
+  },
+  {
+    canonical: "diversity and inclusion",
+    aliases: ["dei"],
+    category: "domain"
+  },
+  { canonical: "employee engagement", aliases: [], category: "domain" },
+  {
+    canonical: "hris",
+    aliases: ["human resources information system"],
+    category: "domain"
+  },
   // healthcare domain
   { canonical: "patient care", aliases: [], category: "domain" },
   { canonical: "clinical documentation", aliases: [], category: "domain" },
   { canonical: "hipaa", aliases: [], category: "domain" },
-  { canonical: "electronic health records", aliases: ["ehr", "emr"], category: "domain" },
+  {
+    canonical: "electronic health records",
+    aliases: ["ehr", "emr"],
+    category: "domain"
+  },
   { canonical: "medical billing", aliases: [], category: "domain" },
+  {
+    canonical: "medical coding",
+    aliases: ["icd-10", "cpt coding"],
+    category: "domain"
+  },
+  { canonical: "telehealth", aliases: [], category: "domain" },
+  { canonical: "clinical trials", aliases: [], category: "domain" },
+  { canonical: "regulatory affairs", aliases: [], category: "domain" },
   // legal domain
   { canonical: "contract review", aliases: [], category: "domain" },
   { canonical: "legal research", aliases: [], category: "domain" },
   { canonical: "litigation", aliases: [], category: "domain" },
-  { canonical: "regulatory compliance", aliases: ["compliance"], category: "domain" },
+  {
+    canonical: "regulatory compliance",
+    aliases: ["compliance"],
+    category: "domain"
+  },
   { canonical: "due diligence", aliases: [], category: "domain" },
+  {
+    canonical: "intellectual property",
+    aliases: ["ip law"],
+    category: "domain"
+  },
+  {
+    canonical: "gdpr",
+    aliases: ["general data protection regulation"],
+    category: "domain"
+  },
+  { canonical: "soc 2", aliases: ["soc2"], category: "domain" },
+  { canonical: "iso 27001", aliases: [], category: "domain" },
+  { canonical: "pci dss", aliases: ["pci compliance"], category: "domain" },
   // education domain
   { canonical: "curriculum development", aliases: [], category: "domain" },
   { canonical: "lesson planning", aliases: [], category: "domain" },
   { canonical: "classroom management", aliases: [], category: "domain" },
   { canonical: "instructional design", aliases: [], category: "domain" },
+  { canonical: "student assessment", aliases: [], category: "domain" },
+  { canonical: "e-learning", aliases: ["elearning"], category: "domain" },
   // operations / supply chain domain
-  { canonical: "supply chain management", aliases: ["supply chain"], category: "domain" },
+  {
+    canonical: "supply chain management",
+    aliases: ["supply chain"],
+    category: "domain"
+  },
   { canonical: "inventory management", aliases: [], category: "domain" },
   { canonical: "procurement", aliases: [], category: "domain" },
   { canonical: "vendor management", aliases: [], category: "domain" },
   { canonical: "logistics", aliases: [], category: "domain" },
+  { canonical: "warehouse management", aliases: [], category: "domain" },
+  { canonical: "demand planning", aliases: [], category: "domain" },
+  { canonical: "manufacturing", aliases: [], category: "domain" },
+  { canonical: "quality control", aliases: [], category: "domain" },
+  { canonical: "lean manufacturing", aliases: [], category: "domain" },
   // customer service domain
-  { canonical: "customer support", aliases: ["customer service"], category: "domain" },
+  {
+    canonical: "customer support",
+    aliases: ["customer service"],
+    category: "domain"
+  },
   { canonical: "technical support", aliases: [], category: "domain" },
   { canonical: "conflict resolution", aliases: [], category: "domain" },
+  { canonical: "customer success", aliases: [], category: "domain" },
+  { canonical: "help desk", aliases: ["helpdesk"], category: "domain" },
   // soft skills
   { canonical: "communication", aliases: [], category: "soft" },
+  { canonical: "written communication", aliases: [], category: "soft" },
+  { canonical: "verbal communication", aliases: [], category: "soft" },
   { canonical: "leadership", aliases: [], category: "soft" },
+  { canonical: "team leadership", aliases: [], category: "soft" },
   { canonical: "teamwork", aliases: ["collaboration"], category: "soft" },
-  { canonical: "problem solving", aliases: ["problem-solving"], category: "soft" },
+  {
+    canonical: "cross-functional collaboration",
+    aliases: ["cross functional collaboration"],
+    category: "soft"
+  },
+  {
+    canonical: "problem solving",
+    aliases: ["problem-solving"],
+    category: "soft"
+  },
   { canonical: "adaptability", aliases: ["flexibility"], category: "soft" },
   { canonical: "time management", aliases: [], category: "soft" },
   { canonical: "critical thinking", aliases: [], category: "soft" },
   { canonical: "creativity", aliases: [], category: "soft" },
   { canonical: "attention to detail", aliases: [], category: "soft" },
-  { canonical: "decision making", aliases: ["decision-making"], category: "soft" },
+  {
+    canonical: "decision making",
+    aliases: ["decision-making"],
+    category: "soft"
+  },
   { canonical: "emotional intelligence", aliases: [], category: "soft" },
   { canonical: "negotiation", aliases: [], category: "soft" },
-  { canonical: "organization", aliases: ["organizational skills"], category: "soft" },
-  { canonical: "public speaking", aliases: ["presentation skills"], category: "soft" },
+  {
+    canonical: "organization",
+    aliases: ["organizational skills"],
+    category: "soft"
+  },
+  {
+    canonical: "public speaking",
+    aliases: ["presentation skills"],
+    category: "soft"
+  },
   { canonical: "mentoring", aliases: ["coaching"], category: "soft" },
   { canonical: "interpersonal skills", aliases: [], category: "soft" },
   { canonical: "work ethic", aliases: [], category: "soft" },
+  { canonical: "stakeholder communication", aliases: [], category: "soft" },
+  {
+    canonical: "self-motivation",
+    aliases: ["self motivation"],
+    category: "soft"
+  },
+  { canonical: "resilience", aliases: [], category: "soft" },
+  { canonical: "empathy", aliases: [], category: "soft" },
+  { canonical: "active listening", aliases: [], category: "soft" },
+  { canonical: "delegation", aliases: [], category: "soft" },
+  { canonical: "strategic thinking", aliases: [], category: "soft" },
+  { canonical: "multitasking", aliases: [], category: "soft" },
   // marketing
-  { canonical: "seo", aliases: ["search engine optimization"], category: "marketing" },
+  {
+    canonical: "seo",
+    aliases: ["search engine optimization"],
+    category: "marketing"
+  },
+  {
+    canonical: "sem",
+    aliases: ["search engine marketing"],
+    category: "marketing"
+  },
   { canonical: "branding", aliases: ["brand strategy"], category: "marketing" },
   { canonical: "campaign management", aliases: [], category: "marketing" },
   { canonical: "content marketing", aliases: [], category: "marketing" },
-  { canonical: "social media marketing", aliases: ["social media"], category: "marketing" },
+  { canonical: "content strategy", aliases: [], category: "marketing" },
+  {
+    canonical: "social media marketing",
+    aliases: ["social media"],
+    category: "marketing"
+  },
   { canonical: "email marketing", aliases: [], category: "marketing" },
   { canonical: "digital marketing", aliases: [], category: "marketing" },
+  {
+    canonical: "growth marketing",
+    aliases: ["growth hacking"],
+    category: "marketing"
+  },
   { canonical: "copywriting", aliases: [], category: "marketing" },
   { canonical: "market research", aliases: [], category: "marketing" },
-  { canonical: "ppc", aliases: ["pay-per-click", "google ads"], category: "marketing" },
-  { canonical: "conversion rate optimization", aliases: ["cro"], category: "marketing" },
-  { canonical: "public relations", aliases: ["pr"], category: "marketing" }
+  {
+    canonical: "ppc",
+    aliases: ["pay-per-click", "google ads"],
+    category: "marketing"
+  },
+  {
+    canonical: "conversion rate optimization",
+    aliases: ["cro"],
+    category: "marketing"
+  },
+  { canonical: "public relations", aliases: ["pr"], category: "marketing" },
+  { canonical: "marketing automation", aliases: [], category: "marketing" },
+  { canonical: "affiliate marketing", aliases: [], category: "marketing" },
+  { canonical: "influencer marketing", aliases: [], category: "marketing" },
+  { canonical: "product marketing", aliases: [], category: "marketing" },
+  { canonical: "event marketing", aliases: [], category: "marketing" },
+  { canonical: "brand awareness", aliases: [], category: "marketing" },
+  { canonical: "media planning", aliases: [], category: "marketing" },
+  { canonical: "lead nurturing", aliases: [], category: "marketing" }
 ];
 var defaultSkillAliases = deriveSkillAliases(defaultKeywordRegistry);
 var softwareEngineerProfile = {
@@ -1287,10 +2637,11 @@ var defaultProfiles = [
 
 // src/core/scoring/weights.ts
 var DEFAULT_WEIGHTS = {
-  skills: 0.3,
-  experience: 0.3,
+  skills: 0.25,
+  experience: 0.2,
   keywords: 0.25,
-  education: 0.15
+  parseability: 0.2,
+  education: 0.1
 };
 var DEFAULT_KEYWORD_DENSITY = {
   min: 25e-4,
@@ -1301,16 +2652,20 @@ var DEFAULT_SECTION_PENALTIES = {
   missingSummary: 4,
   missingExperience: 10,
   missingSkills: 8,
-  missingEducation: 6
+  missingEducation: 6,
+  // Raised from 0 (warning-only) in v1 — a real ATS treats an unparseable contact email as a
+  // near-knockout (no way to reach the candidate at all), so this now actually moves the score.
+  missingContact: 12
 };
 function normalizeWeights(weights) {
-  const total = weights.skills + weights.experience + weights.keywords + weights.education;
+  const total = weights.skills + weights.experience + weights.keywords + weights.parseability + weights.education;
   if (total === 0) {
-    const equal = 1 / 4;
+    const equal = 1 / 5;
     return {
       skills: equal,
       experience: equal,
       keywords: equal,
+      parseability: equal,
       education: equal,
       normalizedTotal: 1
     };
@@ -1319,6 +2674,7 @@ function normalizeWeights(weights) {
     skills: weights.skills / total,
     experience: weights.experience / total,
     keywords: weights.keywords / total,
+    parseability: weights.parseability / total,
     education: weights.education / total,
     normalizedTotal: 1
   };
@@ -1328,12 +2684,19 @@ function resolveConfig(config = {}) {
     skills: config.weights?.skills ?? DEFAULT_WEIGHTS.skills,
     experience: config.weights?.experience ?? DEFAULT_WEIGHTS.experience,
     keywords: config.weights?.keywords ?? DEFAULT_WEIGHTS.keywords,
+    parseability: config.weights?.parseability ?? DEFAULT_WEIGHTS.parseability,
     education: config.weights?.education ?? DEFAULT_WEIGHTS.education
   };
-  const keywordRegistry = mergeKeywordRegistries(defaultKeywordRegistry, config.keywordRegistry ?? []);
+  const keywordRegistry = mergeKeywordRegistries(
+    defaultKeywordRegistry,
+    config.keywordRegistry ?? []
+  );
   const resolved = {
     weights: normalizeWeights(weights),
-    skillAliases: { ...deriveSkillAliases(keywordRegistry), ...config.skillAliases ?? {} },
+    skillAliases: {
+      ...deriveSkillAliases(keywordRegistry),
+      ...config.skillAliases ?? {}
+    },
     keywordRegistry,
     categoryIndex: buildCategoryIndex(keywordRegistry),
     profile: config.profile ?? softwareEngineerProfile,
@@ -1344,6 +2707,13 @@ function resolveConfig(config = {}) {
       ...config.sectionPenalties ?? {}
     },
     allowPartialMatches: config.allowPartialMatches ?? true,
+    // Fuzzy/stem matching is on by default in v2 (typos, word-form variants like "developing"
+    // vs "develop", "ReactJS" vs "react") — callers who want v1's exact-match-only behavior can
+    // override via config.matching = { fuzzy: false }.
+    matching: {
+      fuzzy: config.matching?.fuzzy ?? true,
+      threshold: config.matching?.threshold
+    },
     referenceDate: config.referenceDate ? new Date(config.referenceDate) : void 0
   };
   return resolved;
@@ -1356,13 +2726,17 @@ function formatList(values, max = 6) {
   return trimmed.join(", ") + (uniqueValues.length > max ? "..." : "");
 }
 function buildAliasReplacementSuggestions(resume, job, config) {
-  const jobKeywordSet = new Set(job.keywords.map((k) => normalizeSkill(k, config.skillAliases)));
+  const jobKeywordSet = new Set(
+    job.keywords.map((k) => normalizeSkill(k, config.skillAliases))
+  );
   const replacements = [];
   for (const token of unique(tokenize(resume.normalizedText))) {
     const canonical = normalizeSkill(token, config.skillAliases);
     const jdSurface = job.keywordSurfaceForms[canonical];
     if (jdSurface && jobKeywordSet.has(canonical) && jdSurface.toLowerCase() !== token.toLowerCase()) {
-      replacements.push(`Replace "${token}" with "${jdSurface}" to match the job description's wording.`);
+      replacements.push(
+        `Replace "${token}" with "${jdSurface}" to match the job description's wording.`
+      );
     }
   }
   return unique(replacements).slice(0, 5);
@@ -1370,7 +2744,10 @@ function buildAliasReplacementSuggestions(resume, job, config) {
 var SuggestionEngine = class {
   generate(input) {
     const suggestions = [];
-    const warnings = [...input.ruleWarnings, ...input.resume.warnings];
+    const warnings = [
+      ...input.ruleWarnings,
+      ...input.resume.warnings
+    ];
     if (input.score.missingSkills.length > 0) {
       suggestions.push(
         `Highlight these required skills: ${formatList(input.score.missingSkills)}`
@@ -1381,7 +2758,9 @@ var SuggestionEngine = class {
         `Incorporate job-specific keywords: ${formatList(input.score.missingKeywords)}`
       );
     }
-    suggestions.push(...buildAliasReplacementSuggestions(input.resume, input.job, input.config));
+    suggestions.push(
+      ...buildAliasReplacementSuggestions(input.resume, input.job, input.config)
+    );
     if (input.score.overusedKeywords.length > 0) {
       suggestions.push(
         `Avoid keyword stuffing for: ${formatList(input.score.overusedKeywords)}`
@@ -1392,7 +2771,7 @@ var SuggestionEngine = class {
         `Clarify at least ${input.job.minExperienceYears ?? input.score.missingExperienceYears} years of relevant experience with quantified achievements.`
       );
     }
-    if (input.job.educationRequirements.length > 0 && input.score.educationScore === 0) {
+    if (input.job.educationRequirements.length > 0 && input.score.educationScore < 60) {
       suggestions.push(
         `State your education credentials matching: ${formatList(input.job.educationRequirements)}`
       );
@@ -1411,7 +2790,9 @@ var SuggestionEngine = class {
       const formatted = input.score.missingLanguages.map((l) => l.level ? `${l.name} (${l.level})` : l.name).join(", ");
       suggestions.push(`Mention your proficiency in: ${formatted}`);
     }
-    const weakAchievement = input.resume.achievements.find((a) => a.strength === "weak");
+    const weakAchievement = input.resume.achievements.find(
+      (a) => a.strength === "weak"
+    );
     if (weakAchievement) {
       suggestions.push(
         `Strengthen "${weakAchievement.text}" \u2014 add scope/metrics, e.g. "Built and maintained scalable services handling 500k+ requests/day."`
@@ -1422,6 +2803,34 @@ var SuggestionEngine = class {
         "Your resume may use a multi-column layout. Export as a single-column PDF or paste plain text \u2014 most ATS systems and this parser work best with a linear layout."
       );
     }
+    if (!input.resume.contact?.email) {
+      suggestions.push(
+        "Add a clearly formatted email address near the top of your resume so ATS and recruiters can contact you."
+      );
+    }
+    for (const gap of input.score.skillExperienceGaps) {
+      suggestions.push(
+        `The role asks for ${gap.requiredYears}+ years of ${gap.skill}; make that duration explicit in your experience section.`
+      );
+    }
+    if (input.score.breakdown.parseability < 80) {
+      for (const deduction of input.score.parseabilityReport.deductions) {
+        suggestions.push(`Improve resume parseability: ${deduction.reason}.`);
+      }
+    }
+    const GAP_THRESHOLD_MONTHS = 6;
+    for (const gap of input.score.employmentGaps) {
+      if (gap.months >= GAP_THRESHOLD_MONTHS) {
+        suggestions.push(
+          `Address the ${gap.months}-month employment gap after "${gap.afterRole}" \u2014 a brief explanation (upskilling, caregiving, freelance work, etc.) reassures recruiters.`
+        );
+      }
+    }
+    if (!input.score.seniorityMatch.met) {
+      suggestions.push(
+        `This role expects ${input.score.seniorityMatch.required} seniority, but your resume reads as ${input.score.seniorityMatch.resume}; emphasize scope/ownership that reflects the level the role expects.`
+      );
+    }
     return { suggestions, warnings };
   }
 };
@@ -1469,7 +2878,10 @@ var LLMBudgetManager = class {
       callsUsed: this.callCount,
       callsRemaining: Math.max(0, this.limits.maxCalls - this.callCount),
       tokensUsed: this.totalTokensUsed,
-      tokensRemaining: Math.max(0, this.limits.maxTotalTokens - this.totalTokensUsed),
+      tokensRemaining: Math.max(
+        0,
+        this.limits.maxTotalTokens - this.totalTokensUsed
+      ),
       totalCalls: this.limits.maxCalls,
       totalTokens: this.limits.maxTotalTokens
     };
@@ -1491,7 +2903,8 @@ var LLMBudgetManager = class {
 
 // src/llm/validation.ts
 function validateJsonSchema(data, schema) {
-  if (schema.type !== "object" || typeof data !== "object" || data === null) return false;
+  if (schema.type !== "object" || typeof data !== "object" || data === null)
+    return false;
   const obj = data;
   if (schema.required) {
     for (const r of schema.required) {
@@ -1521,9 +2934,12 @@ function validateJsonSchema(data, schema) {
           if (items && items.type && Array.isArray(value)) {
             const itemType = items.type;
             for (const item of value) {
-              if (itemType === "string" && typeof item !== "string") return false;
-              if (itemType === "number" && typeof item !== "number") return false;
-              if (itemType === "object" && (typeof item !== "object" || item === null)) return false;
+              if (itemType === "string" && typeof item !== "string")
+                return false;
+              if (itemType === "number" && typeof item !== "number")
+                return false;
+              if (itemType === "object" && (typeof item !== "object" || item === null))
+                return false;
             }
           }
           break;
@@ -1550,24 +2966,36 @@ var LLMManager = class {
    */
   async callLLM(systemPrompt, userPrompt, schema, options = {}) {
     const onUnhandled = (reason) => {
-      this.warnings.push(`Unhandled rejection during LLM call: ${String(reason)}`);
+      this.warnings.push(
+        `Unhandled rejection during LLM call: ${String(reason)}`
+      );
     };
     process.on("unhandledRejection", onUnhandled);
     let clientPromise = void 0;
     try {
-      const estimatedTokens = this.estimateTokens(systemPrompt, userPrompt, options.requestedTokens);
+      const estimatedTokens = this.estimateTokens(
+        systemPrompt,
+        userPrompt,
+        options.requestedTokens
+      );
       try {
         this.budgetManager.assertCanCall(estimatedTokens);
       } catch (e) {
         const msg = `LLM budget exhausted: ${e.message}`;
         this.warnings.push(msg);
-        globalThis.setTimeout(() => process.removeListener("unhandledRejection", onUnhandled), 100);
+        globalThis.setTimeout(
+          () => process.removeListener("unhandledRejection", onUnhandled),
+          100
+        );
         return { success: false, fallback: true, error: msg };
       }
       if (!this.isValidJsonSchema(schema)) {
         const msg = "Invalid JSON schema provided";
         this.warnings.push(msg);
-        globalThis.setTimeout(() => process.removeListener("unhandledRejection", onUnhandled), 100);
+        globalThis.setTimeout(
+          () => process.removeListener("unhandledRejection", onUnhandled),
+          100
+        );
         return { success: false, fallback: true, error: msg };
       }
       const strictUserPrompt = `${userPrompt}
@@ -1586,22 +3014,36 @@ No explanations. No markdown. No additional text.`;
       void clientPromise.catch(() => {
       });
       const timeoutPromise = new Promise((_, reject) => {
-        const id = globalThis.setTimeout(() => reject(new Error(`LLM call timeout after ${this.timeoutMs}ms`)), this.timeoutMs);
-        void clientPromise.finally(() => globalThis.clearTimeout(id));
+        const id = globalThis.setTimeout(
+          () => reject(new Error(`LLM call timeout after ${this.timeoutMs}ms`)),
+          this.timeoutMs
+        );
+        void clientPromise.finally(() => globalThis.clearTimeout(id)).catch(() => {
+        });
       });
       void timeoutPromise.catch(() => {
       });
-      const response = await Promise.race([clientPromise, timeoutPromise]);
+      const response = await Promise.race([
+        clientPromise,
+        timeoutPromise
+      ]);
       if (!response || !response.content) {
         const graceMs = Math.min(Math.max(this.timeoutMs * 2, 100), 500);
         try {
-          await Promise.race([clientPromise.catch(() => {
-          }), new Promise((r) => setTimeout(r, graceMs))]);
-        } catch (e) {
+          await Promise.race([
+            clientPromise.catch(() => {
+            }),
+            new Promise((r) => setTimeout(r, graceMs))
+          ]);
+        } catch {
         } finally {
           process.removeListener("unhandledRejection", onUnhandled);
         }
-        return { success: false, fallback: true, error: "Empty response from LLM" };
+        return {
+          success: false,
+          fallback: true,
+          error: "Empty response from LLM"
+        };
       }
       let parsedContent;
       try {
@@ -1615,9 +3057,12 @@ No explanations. No markdown. No additional text.`;
         this.warnings.push(msg);
         const graceMs = Math.min(Math.max(this.timeoutMs * 2, 100), 500);
         try {
-          await Promise.race([clientPromise.catch(() => {
-          }), new Promise((r) => setTimeout(r, graceMs))]);
-        } catch (e2) {
+          await Promise.race([
+            clientPromise.catch(() => {
+            }),
+            new Promise((r) => setTimeout(r, graceMs))
+          ]);
+        } catch {
         } finally {
           process.removeListener("unhandledRejection", onUnhandled);
         }
@@ -1628,9 +3073,12 @@ No explanations. No markdown. No additional text.`;
         this.warnings.push(msg);
         const graceMs = Math.min(Math.max(this.timeoutMs * 2, 100), 500);
         try {
-          await Promise.race([clientPromise.catch(() => {
-          }), new Promise((r) => setTimeout(r, graceMs))]);
-        } catch (e) {
+          await Promise.race([
+            clientPromise.catch(() => {
+            }),
+            new Promise((r) => setTimeout(r, graceMs))
+          ]);
+        } catch {
         } finally {
           process.removeListener("unhandledRejection", onUnhandled);
         }
@@ -1650,9 +3098,12 @@ No explanations. No markdown. No additional text.`;
       this.warnings.push(msg);
       const graceMs = Math.min(Math.max(this.timeoutMs * 2, 100), 500);
       try {
-        await Promise.race([clientPromise.catch(() => {
-        }), new Promise((r) => setTimeout(r, graceMs))]);
-      } catch (e2) {
+        await Promise.race([
+          clientPromise.catch(() => {
+          }),
+          new Promise((r) => setTimeout(r, graceMs))
+        ]);
+      } catch {
       } finally {
         process.removeListener("unhandledRejection", onUnhandled);
       }
@@ -1702,7 +3153,7 @@ No explanations. No markdown. No additional text.`;
   validateAgainstSchema(data, schema) {
     try {
       return validateJsonSchema(data, schema);
-    } catch (e) {
+    } catch {
       if (typeof data !== "object" || data === null) {
         return false;
       }
@@ -1762,7 +3213,15 @@ var sectionClassificationSchema = {
           },
           classification: {
             type: "string",
-            enum: ["summary", "experience", "skills", "education", "projects", "certifications", "other"],
+            enum: [
+              "summary",
+              "experience",
+              "skills",
+              "education",
+              "projects",
+              "certifications",
+              "other"
+            ],
             description: "Classified section type"
           },
           confidence: {
@@ -2065,7 +3524,10 @@ function analyzeResume(input) {
   let suggestions = suggestionResult.suggestions;
   const llmWarnings = [];
   if (input.llm && suggestionResult.suggestions.length > 0) {
-    const llmResult = enhanceSuggestionsWithLLM(input.llm, suggestionResult.suggestions);
+    const llmResult = enhanceSuggestionsWithLLM(
+      input.llm,
+      suggestionResult.suggestions
+    );
     if (llmResult.success) {
       suggestions = llmResult.enhancedSuggestions || suggestions;
     }
@@ -2085,21 +3547,25 @@ function analyzeResume(input) {
     achievementStrength: scoring.achievementStrength,
     matchedLanguages: scoring.matchedLanguages,
     missingLanguages: scoring.missingLanguages,
+    skillExperienceGaps: scoring.skillExperienceGaps,
     experienceGap: scoring.experienceGap,
     detectedSections: parsedResume.detectedSections,
     parsedExperienceYears: parsedResume.totalExperienceYears,
     experienceEntries: parsedResume.experience,
+    parseabilityReport: scoring.parseabilityReport,
+    employmentGaps: scoring.employmentGaps,
+    seniorityMatch: scoring.seniorityMatch,
+    perSkillExperience: scoring.perSkillExperience,
     suggestions,
     warnings: [...suggestionResult.warnings, ...llmWarnings]
   };
 }
-function enhanceSuggestionsWithLLM(config, suggestions) {
+function enhanceSuggestionsWithLLM(config, _suggestions) {
   if (!config.enable?.suggestions) {
     return { success: false, warnings: [] };
   }
   const warnings = [];
   try {
-    const llmManager = new LLMManager(config);
     warnings.push(
       "LLM suggestion enhancement skipped - use async analyzeResumeAsync for LLM features"
     );
@@ -2156,10 +3622,15 @@ async function analyzeResumeAsync(input) {
     achievementStrength: scoring.achievementStrength,
     matchedLanguages: scoring.matchedLanguages,
     missingLanguages: scoring.missingLanguages,
+    skillExperienceGaps: scoring.skillExperienceGaps,
     experienceGap: scoring.experienceGap,
     detectedSections: parsedResume.detectedSections,
     parsedExperienceYears: parsedResume.totalExperienceYears,
     experienceEntries: parsedResume.experience,
+    parseabilityReport: scoring.parseabilityReport,
+    employmentGaps: scoring.employmentGaps,
+    seniorityMatch: scoring.seniorityMatch,
+    perSkillExperience: scoring.perSkillExperience,
     suggestions,
     warnings: [...suggestionResult.warnings, ...llmWarnings]
   };
@@ -2181,13 +3652,19 @@ async function enhanceSuggestionsWithLLMAsync(config, suggestions) {
       if (result.error) {
         warnings.push(`LLM suggestion enhancement failed: ${result.error}`);
       }
-      return { success: false, warnings: [...warnings, ...llmManager.getWarnings()] };
+      return {
+        success: false,
+        warnings: [...warnings, ...llmManager.getWarnings()]
+      };
     }
     const enhanced = adaptSuggestionEnhancementResponse(result.data);
     const enhancedSuggestions = enhanced.filter((e) => e.actionable !== false).map((e) => e.enhanced);
     if (enhancedSuggestions.length === 0) {
       warnings.push("LLM returned no actionable enhanced suggestions");
-      return { success: false, warnings: [...warnings, ...llmManager.getWarnings()] };
+      return {
+        success: false,
+        warnings: [...warnings, ...llmManager.getWarnings()]
+      };
     }
     return {
       success: true,
@@ -2195,7 +3672,9 @@ async function enhanceSuggestionsWithLLMAsync(config, suggestions) {
       warnings: llmManager.getWarnings()
     };
   } catch (e) {
-    warnings.push(`Unexpected error in LLM enhancement: ${e.message}`);
+    warnings.push(
+      `Unexpected error in LLM enhancement: ${e.message}`
+    );
     return { success: false, warnings };
   }
 }