@pranavraut033/ats-checker 1.3.3 → 2.0.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { clamp, mergeKeywordRegistries, defaultKeywordRegistry, softwareEngineerProfile, buildCategoryIndex, deriveSkillAliases, normalizeWhitespace, splitLines, normalizeSkills, tokenize, unique, containsTableLikeStructure, normalizeForComparison, STOP_WORDS, normalizeSkill, countFrequencies, escapeRegExp } from './chunk-ZJ5E4H7Z.mjs';
-export { defaultKeywordRegistry, defaultProfiles, defaultSkillAliases } from './chunk-ZJ5E4H7Z.mjs';
+import { ROLE_NOUNS, unique, clamp, mergeKeywordRegistries, defaultKeywordRegistry, softwareEngineerProfile, buildCategoryIndex, deriveSkillAliases, normalizeWhitespace, splitLines, detectFormatting, normalizeSkills, tokenize, normalizeForComparison, STOP_WORDS, normalizeSkill, countFrequencies, escapeRegExp, fuzzyEqual, stem } from './chunk-JAFFS7YZ.mjs';
+export { defaultKeywordRegistry, defaultProfiles, defaultSkillAliases } from './chunk-JAFFS7YZ.mjs';
 
 // src/utils/languages.ts
 var KNOWN_LANGUAGES = [
@@ -64,11 +64,11 @@ var LEVEL_RANK = {
   muttersprache: 6,
   muttersprachler: 6,
   // French
-  "d\xE9butant": 1,
-  "\xE9l\xE9mentaire": 1,
-  "limit\xE9": 2,
-  "interm\xE9diaire": 3,
-  "avanc\xE9": 4,
+  d\u00E9butant: 1,
+  \u00E9l\u00E9mentaire: 1,
+  limit\u00E9: 2,
+  interm\u00E9diaire: 3,
+  avanc\u00E9: 4,
   courant: 5,
   natif: 6,
   "langue maternelle": 6,
@@ -133,6 +133,67 @@ function diffLanguages(resumeLanguages, requiredLanguages) {
   return { matched, missing };
 }
 
+// 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 SENIORITY_RANK = {
+  junior: 0,
+  mid: 1,
+  senior: 2,
+  lead: 3,
+  principal: 4
+};
+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 best;
+}
+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 / keywords.length;
+}
+
 // src/core/parser/jd.parser.ts
 var DEGREE_VARIANTS = [
   [/\b(?:bachelor(?:'s)?|b\.s\.?|bs\.?|bsc\.?|licence)\b/i, "bachelor"],
@@ -159,13 +220,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;
@@ -191,6 +288,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) {
@@ -206,21 +335,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,
@@ -229,13 +384,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))
   };
 }
 
@@ -333,7 +493,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;
@@ -381,27 +543,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",
@@ -424,28 +651,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;
       }
     }
@@ -477,12 +766,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);
@@ -491,7 +810,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: [] };
   }
@@ -502,23 +821,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;
@@ -529,7 +857,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 [];
@@ -538,12 +874,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))
@@ -556,7 +918,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) {
@@ -573,6 +940,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,
@@ -588,6 +961,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
   };
 }
@@ -598,7 +975,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 = {
@@ -624,19 +1006,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) {
@@ -667,9 +1056,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) {
@@ -677,18 +1088,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(
@@ -700,29 +1125,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 {
@@ -735,20 +1176,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) => {
@@ -785,38 +1238,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),
@@ -831,6 +1404,7 @@ function calculateScore(resume, job, config) {
     achievementStrength,
     matchedLanguages,
     missingLanguages,
+    skillExperienceGaps,
     suggestions: [],
     warnings: [],
     // detectedSections / parsedExperienceYears / experienceGap / experienceEntries: filled by index.ts
@@ -839,16 +1413,21 @@ function calculateScore(resume, job, config) {
     parsedExperienceYears: 0,
     experienceEntries: [],
     missingExperienceYears: experienceResult.missingYears,
-    educationScore
+    educationScore,
+    parseabilityReport: parseabilityResult.report,
+    employmentGaps: resume.employmentGaps,
+    seniorityMatch: experienceResult.seniorityMatch,
+    perSkillExperience
   };
 }
 
 // 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,
@@ -859,16 +1438,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
     };
@@ -877,6 +1460,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
   };
@@ -886,12 +1470,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,
@@ -902,6 +1493,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;
@@ -914,13 +1512,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);
@@ -928,7 +1530,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)}`
@@ -939,7 +1544,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)}`
@@ -950,7 +1557,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)}`
       );
@@ -969,7 +1576,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."`
@@ -980,6 +1589,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 };
   }
 };
@@ -1027,7 +1664,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
     };
@@ -1049,7 +1689,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) {
@@ -1079,9 +1720,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;
@@ -1108,24 +1752,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}
@@ -1144,22 +1800,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 {
@@ -1173,9 +1843,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);
         }
@@ -1186,9 +1859,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);
         }
@@ -1208,9 +1884,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);
       }
@@ -1260,7 +1939,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;
       }
@@ -1320,7 +1999,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: {
@@ -1623,7 +2310,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;
     }
@@ -1643,21 +2333,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"
     );
@@ -1714,10 +2408,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]
   };
@@ -1739,13 +2438,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,
@@ -1753,7 +2458,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 };
   }
 }