resuml 3.0.0 → 3.2.0

package/dist/chunk-C2JG5KF4.js

@@ -0,0 +1,2088 @@
+import {
+  getSkillIndex
+} from "./chunk-QR77BRMN.js";
+
+// src/ats/checks/parsing.ts
+var ISO_DATE = /^\d{4}(-\d{2})?(-\d{2})?$/;
+var conventionalSections = (resume) => {
+  const required = ["basics", "work", "education"];
+  const missing = required.filter((s) => {
+    const v = resume[s];
+    if (Array.isArray(v)) return v.length === 0;
+    return v === void 0;
+  });
+  const passed = missing.length === 0;
+  return {
+    id: "conventional-sections",
+    tier: "parsing",
+    weight: "high",
+    status: passed ? "pass" : "fail",
+    score: Math.round((required.length - missing.length) / required.length * 100),
+    message: passed ? "All conventional sections present." : `Missing required sections: ${missing.join(", ")}.`,
+    hints: passed ? [] : [`Add ${missing.join(", ")} to your YAML.`]
+  };
+};
+var dateFormatConsistency = (resume) => {
+  const all = [];
+  for (const w of resume.work || []) {
+    if (w.startDate) all.push({ date: w.startDate, where: `work "${w.name || ""}".startDate` });
+    if (w.endDate) all.push({ date: w.endDate, where: `work "${w.name || ""}".endDate` });
+  }
+  for (const e of resume.education || []) {
+    if (e.startDate)
+      all.push({ date: e.startDate, where: `education "${e.institution || ""}".startDate` });
+    if (e.endDate)
+      all.push({ date: e.endDate, where: `education "${e.institution || ""}".endDate` });
+  }
+  if (all.length === 0) {
+    return {
+      id: "date-format-consistency",
+      tier: "parsing",
+      weight: "medium",
+      status: "skipped",
+      score: 0,
+      message: "No dates to check.",
+      hints: []
+    };
+  }
+  const bad = all.filter((d) => !ISO_DATE.test(d.date));
+  const passed = bad.length === 0;
+  return {
+    id: "date-format-consistency",
+    tier: "parsing",
+    weight: "medium",
+    status: passed ? "pass" : bad.length <= 1 ? "warn" : "fail",
+    score: Math.round((all.length - bad.length) / all.length * 100),
+    message: passed ? "All dates use ISO-8601 format." : `Non-ISO dates: ${bad.slice(0, 3).map((b) => `${b.where}=${b.date}`).join("; ")}.`,
+    hints: passed ? [] : ["Use YYYY-MM or YYYY-MM-DD for every date field."]
+  };
+};
+var contactInBody = (resume) => {
+  const b = resume.basics;
+  const checks = [
+    { ok: !!b?.name, field: "name" },
+    { ok: !!b?.email, field: "email" },
+    { ok: !!b?.phone, field: "phone" },
+    { ok: !!b?.location?.city, field: "location.city" }
+  ];
+  const missing = checks.filter((c) => !c.ok).map((c) => c.field);
+  const passed = missing.length === 0;
+  return {
+    id: "contact-in-body",
+    tier: "parsing",
+    weight: "high",
+    status: passed ? "pass" : "fail",
+    score: Math.round((checks.length - missing.length) / checks.length * 100),
+    message: passed ? "Contact information present in basics." : `Missing contact fields: ${missing.join(", ")}.`,
+    hints: passed ? [] : [`Add ${missing.join(", ")} to basics.`]
+  };
+};
+var reverseChronOrder = (resume) => {
+  const work = resume.work || [];
+  if (work.length < 2) {
+    return {
+      id: "reverse-chron-order",
+      tier: "parsing",
+      weight: "medium",
+      status: "skipped",
+      score: 100,
+      message: "Single or no work entry.",
+      hints: []
+    };
+  }
+  let outOfOrder = 0;
+  for (let i = 0; i < work.length - 1; i++) {
+    const curr = work[i];
+    const next = work[i + 1];
+    const a = curr?.startDate || "";
+    const b = next?.startDate || "";
+    if (a && b && a < b) outOfOrder++;
+  }
+  const passed = outOfOrder === 0;
+  return {
+    id: "reverse-chron-order",
+    tier: "parsing",
+    weight: "medium",
+    status: passed ? "pass" : "fail",
+    score: passed ? 100 : Math.max(0, 100 - outOfOrder * 50),
+    message: passed ? "Work entries in reverse-chronological order." : `${outOfOrder} pair(s) out of reverse-chronological order.`,
+    hints: passed ? [] : ["Reorder work[] so the most recent role is first."]
+  };
+};
+var educationComplete = (resume) => {
+  const edu = resume.education || [];
+  if (edu.length === 0) {
+    return {
+      id: "education-complete",
+      tier: "parsing",
+      weight: "low",
+      status: "fail",
+      score: 0,
+      message: "No education entries.",
+      hints: ["Add at least one education entry with institution, area, and studyType."]
+    };
+  }
+  const incomplete = edu.filter((e) => !e.institution || !e.area || !e.studyType);
+  const passed = incomplete.length === 0;
+  return {
+    id: "education-complete",
+    tier: "parsing",
+    weight: "low",
+    status: passed ? "pass" : "fail",
+    score: Math.round((edu.length - incomplete.length) / edu.length * 100),
+    message: passed ? "All education entries complete." : `${incomplete.length} education entry(ies) missing institution/area/studyType.`,
+    hints: passed ? [] : ["Fill in institution, area and studyType for every education entry."]
+  };
+};
+var allParsingChecks = [
+  conventionalSections,
+  dateFormatConsistency,
+  contactInBody,
+  reverseChronOrder,
+  educationComplete
+];
+
+// src/ats/i18n/en.ts
+var en = {
+  actionVerbs: [
+    // Leadership & Management
+    "achieved",
+    "administered",
+    "advanced",
+    "allocated",
+    "approved",
+    "assigned",
+    "authorized",
+    "chaired",
+    "consolidated",
+    "coordinated",
+    "delegated",
+    "directed",
+    "established",
+    "executed",
+    "headed",
+    "hired",
+    "hosted",
+    "led",
+    "managed",
+    "mentored",
+    "motivated",
+    "orchestrated",
+    "organized",
+    "oversaw",
+    "planned",
+    "presided",
+    "prioritized",
+    "produced",
+    "recruited",
+    "spearheaded",
+    "supervised",
+    // Technical & Engineering
+    "architected",
+    "automated",
+    "built",
+    "coded",
+    "configured",
+    "debugged",
+    "deployed",
+    "designed",
+    "developed",
+    "devised",
+    "engineered",
+    "implemented",
+    "installed",
+    "integrated",
+    "launched",
+    "maintained",
+    "migrated",
+    "modernized",
+    "optimized",
+    "overhauled",
+    "programmed",
+    "prototyped",
+    "refactored",
+    "reengineered",
+    "resolved",
+    "restructured",
+    "revamped",
+    "scaled",
+    "shipped",
+    "standardized",
+    "streamlined",
+    "tested",
+    "troubleshot",
+    "upgraded",
+    // Achievement & Impact
+    "accelerated",
+    "accomplished",
+    "boosted",
+    "completed",
+    "contributed",
+    "converted",
+    "decreased",
+    "delivered",
+    "doubled",
+    "earned",
+    "eliminated",
+    "exceeded",
+    "expanded",
+    "expedited",
+    "generated",
+    "grew",
+    "improved",
+    "increased",
+    "maximized",
+    "minimized",
+    "outperformed",
+    "pioneered",
+    "recovered",
+    "reduced",
+    "saved",
+    "simplified",
+    "solved",
+    "surpassed",
+    "transformed",
+    "tripled",
+    // Communication & Collaboration
+    "advised",
+    "advocated",
+    "briefed",
+    "collaborated",
+    "communicated",
+    "consulted",
+    "convinced",
+    "counseled",
+    "defined",
+    "demonstrated",
+    "documented",
+    "educated",
+    "facilitated",
+    "guided",
+    "influenced",
+    "informed",
+    "instructed",
+    "liaised",
+    "negotiated",
+    "partnered",
+    "persuaded",
+    "presented",
+    "promoted",
+    "proposed",
+    "published",
+    "recommended",
+    "represented",
+    "trained",
+    // Analysis & Research
+    "analyzed",
+    "assessed",
+    "audited",
+    "benchmarked",
+    "calculated",
+    "compared",
+    "compiled",
+    "conducted",
+    "discovered",
+    "evaluated",
+    "examined",
+    "explored",
+    "forecasted",
+    "identified",
+    "inspected",
+    "interpreted",
+    "investigated",
+    "mapped",
+    "measured",
+    "modeled",
+    "monitored",
+    "quantified",
+    "researched",
+    "reviewed",
+    "surveyed",
+    "synthesized",
+    "tracked",
+    "validated",
+    "verified",
+    // Creation & Innovation
+    "conceptualized",
+    "crafted",
+    "created",
+    "customized",
+    "formulated",
+    "founded",
+    "initiated",
+    "innovated",
+    "introduced",
+    "invented",
+    "originated",
+    "shaped"
+  ],
+  pronouns: ["i", "me", "my", "mine", "myself", "we", "our", "ours"],
+  stopWords: [
+    // Articles & determiners
+    "a",
+    "an",
+    "the",
+    "and",
+    "or",
+    "but",
+    "in",
+    "on",
+    "at",
+    "to",
+    "for",
+    "of",
+    "with",
+    "by",
+    "from",
+    "is",
+    "was",
+    "are",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "shall",
+    "can",
+    "this",
+    "that",
+    "these",
+    "those",
+    "it",
+    "its",
+    "as",
+    "if",
+    "not",
+    "no",
+    "so",
+    "up",
+    "out",
+    "about",
+    "into",
+    "over",
+    "after",
+    "before",
+    "between",
+    "under",
+    "above",
+    "below",
+    "all",
+    "each",
+    "every",
+    "both",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "than",
+    "too",
+    "very",
+    // Pronouns & possessives (also checked by pronoun check, but filter from JD keywords)
+    "you",
+    "your",
+    "yours",
+    "yourself",
+    "we",
+    "our",
+    "ours",
+    "ourselves",
+    "they",
+    "them",
+    "their",
+    "theirs",
+    "he",
+    "she",
+    "his",
+    "her",
+    "hers",
+    "who",
+    "whom",
+    "whose",
+    "which",
+    "what",
+    "where",
+    "when",
+    "how",
+    "why",
+    // Common JD filler words (not meaningful for skill matching)
+    "able",
+    "also",
+    "across",
+    "already",
+    "always",
+    "among",
+    "any",
+    "apply",
+    "become",
+    "believe",
+    "best",
+    "bring",
+    "change",
+    "come",
+    "committed",
+    "company",
+    "comfortable",
+    "critical",
+    "current",
+    "day",
+    "desired",
+    "either",
+    "end",
+    "ensure",
+    "environment",
+    "equal",
+    "even",
+    "excellent",
+    "exciting",
+    "exceptional",
+    "expected",
+    "experience",
+    "fast",
+    "field",
+    "find",
+    "first",
+    "focused",
+    "follow",
+    "get",
+    "give",
+    "go",
+    "going",
+    "good",
+    "great",
+    "group",
+    "grow",
+    "growing",
+    "growth",
+    "help",
+    "here",
+    "high",
+    "highly",
+    "ideal",
+    "impact",
+    "important",
+    "include",
+    "includes",
+    "including",
+    "industry",
+    "interested",
+    "job",
+    "join",
+    "just",
+    "keep",
+    "key",
+    "know",
+    "large",
+    "latest",
+    "lead",
+    "level",
+    "like",
+    "location",
+    "long",
+    "look",
+    "looking",
+    "love",
+    "make",
+    "many",
+    "much",
+    "must",
+    "need",
+    "new",
+    "next",
+    "offer",
+    "one",
+    "only",
+    "open",
+    "opportunity",
+    "order",
+    "others",
+    "own",
+    "pace",
+    "part",
+    "partner",
+    "passionate",
+    "people",
+    "per",
+    "play",
+    "plus",
+    "position",
+    "preferred",
+    "provide",
+    "put",
+    "qualifications",
+    "quickly",
+    "range",
+    "related",
+    "required",
+    "requirements",
+    "requirement",
+    "responsible",
+    "responsibilities",
+    "responsibility",
+    "result",
+    "right",
+    "role",
+    "run",
+    "same",
+    "see",
+    "seek",
+    "seeking",
+    "set",
+    "several",
+    "since",
+    "skills",
+    "someone",
+    "start",
+    "state",
+    "still",
+    "strong",
+    "success",
+    "successful",
+    "support",
+    "sure",
+    "take",
+    "team",
+    "then",
+    "there",
+    "thing",
+    "think",
+    "through",
+    "time",
+    "together",
+    "top",
+    "truly",
+    "try",
+    "two",
+    "type",
+    "use",
+    "used",
+    "using",
+    "value",
+    "want",
+    "way",
+    "well",
+    "while",
+    "within",
+    "without",
+    "work",
+    "working",
+    "world",
+    "would",
+    "year",
+    "years",
+    // Section headers & structural words (not technical skills)
+    "description",
+    "overview",
+    "summary",
+    "duties",
+    "bachelor",
+    "bachelors",
+    "master",
+    "masters",
+    "degree",
+    "phd",
+    "minimum",
+    "preferred",
+    "implement",
+    "process",
+    "robust",
+    "consistent",
+    "operations",
+    // URL/email/domain fragments
+    "http",
+    "https",
+    "www",
+    "com",
+    "org",
+    "net",
+    "mailto",
+    // Resume/YAML schema field names (in case raw YAML is pasted)
+    "name",
+    "keywords",
+    "highlights",
+    "startdate",
+    "enddate",
+    "website",
+    "profiles",
+    "basics",
+    "position",
+    "institution",
+    "studytype",
+    "fluency",
+    "issuer",
+    "network",
+    "username",
+    "countrycode",
+    "region",
+    // Generic nouns that aren't skills
+    "product",
+    "company",
+    "service",
+    "services",
+    "platform",
+    "solutions",
+    "ability",
+    "opportunity",
+    "candidate",
+    "applicant",
+    "position",
+    "salary",
+    "compensation",
+    "benefits",
+    "perks",
+    "bonus",
+    "development",
+    "management",
+    "knowledge",
+    "modern",
+    "advanced",
+    "practices",
+    "nice",
+    "technologies",
+    "technology",
+    "frameworks",
+    "framework",
+    "tools",
+    "data",
+    "based",
+    "contribute",
+    "contributions",
+    "migration",
+    "leading",
+    "source",
+    "visit",
+    // Common verbs & verb forms (not technical skills, supplement action verbs list)
+    "collaborate",
+    "collaborating",
+    "collaboratively",
+    "communicate",
+    "communicating",
+    "contributing",
+    "coordinate",
+    "coordinating",
+    "demonstrate",
+    "demonstrating",
+    "design",
+    "designing",
+    "designed",
+    "develop",
+    "developing",
+    "developed",
+    "drive",
+    "driving",
+    "driven",
+    "enable",
+    "enabling",
+    "evaluate",
+    "evaluating",
+    "execute",
+    "executing",
+    "facilitate",
+    "facilitating",
+    "identify",
+    "identifying",
+    "influence",
+    "influencing",
+    "interact",
+    "interacting",
+    "lead",
+    "leverage",
+    "leveraging",
+    "manage",
+    "managing",
+    "mentor",
+    "mentoring",
+    "operate",
+    "operating",
+    "optimize",
+    "optimizing",
+    "participate",
+    "participating",
+    "report",
+    "reporting",
+    "solve",
+    "solving",
+    "understand",
+    "understanding",
+    // Common adjectives & descriptors (not technical skills)
+    "fluent",
+    "proficient",
+    "deep",
+    "solid",
+    "proven",
+    "hands-on",
+    "detail-oriented",
+    "results-driven",
+    "self-motivated",
+    "proactive",
+    "creative",
+    "innovative",
+    "dynamic",
+    "strategic",
+    "analytical",
+    "collaborative",
+    "effective",
+    "efficient",
+    "reliable",
+    "flexible",
+    "adaptable",
+    "motivated",
+    "dedicated",
+    "capable",
+    "qualified",
+    "diverse",
+    "inclusive",
+    "global",
+    "local",
+    "remote",
+    "hybrid",
+    "onsite",
+    "full-time",
+    "part-time",
+    "contract",
+    "permanent",
+    // Role titles & department names (not skills themselves)
+    "designer",
+    "designers",
+    "developer",
+    "developers",
+    "engineer",
+    "engineers",
+    "manager",
+    "managers",
+    "director",
+    "analyst",
+    "analysts",
+    "architect",
+    "architects",
+    "consultant",
+    "consultants",
+    "specialist",
+    "specialists",
+    "coordinator",
+    "lead",
+    "principal",
+    "staff",
+    "junior",
+    "mid",
+    "department",
+    "organization",
+    "division",
+    "stakeholder",
+    "stakeholders",
+    "client",
+    "clients",
+    "customer",
+    "customers",
+    // Date & time words
+    "date",
+    "dates",
+    "month",
+    "months",
+    "week",
+    "weeks",
+    "daily",
+    "weekly",
+    "monthly",
+    "quarterly",
+    "annual",
+    "annually",
+    // More generic words that aren't skills
+    "code",
+    "coding",
+    "url",
+    "contact",
+    "information",
+    "apply",
+    "application",
+    "review",
+    "reviews",
+    "quality",
+    "scale",
+    "scalable",
+    "system",
+    "systems",
+    "solution",
+    "feature",
+    "features",
+    "project",
+    "projects",
+    "build",
+    "building",
+    "deliver",
+    "delivery",
+    "cross-functional"
+  ]
+};
+var en_default = en;
+
+// src/ats/i18n/de.ts
+var de = {
+  actionVerbs: [
+    // Führung & Management
+    "geleitet",
+    "gef\xFChrt",
+    "koordiniert",
+    "organisiert",
+    "verwaltet",
+    "delegiert",
+    "beaufsichtigt",
+    "betreut",
+    "eingestellt",
+    "motiviert",
+    "verantwortet",
+    "gesteuert",
+    "\xFCberwacht",
+    "priorisiert",
+    "geplant",
+    // Technik & Entwicklung
+    "entwickelt",
+    "implementiert",
+    "programmiert",
+    "konfiguriert",
+    "automatisiert",
+    "deployt",
+    "gebaut",
+    "entworfen",
+    "integriert",
+    "migriert",
+    "modernisiert",
+    "optimiert",
+    "refaktoriert",
+    "skaliert",
+    "standardisiert",
+    "getestet",
+    "aufgebaut",
+    "eingef\xFChrt",
+    "bereitgestellt",
+    "umgesetzt",
+    // Leistung & Ergebnisse
+    "verbessert",
+    "gesteigert",
+    "reduziert",
+    "beschleunigt",
+    "erreicht",
+    "\xFCbertroffen",
+    "erweitert",
+    "vereinfacht",
+    "gel\xF6st",
+    "transformiert",
+    "erh\xF6ht",
+    "verdoppelt",
+    "verdreifacht",
+    "generiert",
+    "gespart",
+    "maximiert",
+    "minimiert",
+    "eliminiert",
+    "geliefert",
+    "abgeschlossen",
+    // Kommunikation & Zusammenarbeit
+    "beraten",
+    "pr\xE4sentiert",
+    "dokumentiert",
+    "geschult",
+    "trainiert",
+    "vermittelt",
+    "kommuniziert",
+    "verhandelt",
+    "zusammengearbeitet",
+    "unterst\xFCtzt",
+    "gef\xF6rdert",
+    "empfohlen",
+    "vorgestellt",
+    "publiziert",
+    // Analyse & Forschung
+    "analysiert",
+    "bewertet",
+    "evaluiert",
+    "untersucht",
+    "erforscht",
+    "identifiziert",
+    "gemessen",
+    "\xFCberwacht",
+    "validiert",
+    "verifiziert",
+    "gepr\xFCft",
+    "verglichen",
+    "recherchiert",
+    "quantifiziert",
+    // Kreation & Innovation
+    "konzipiert",
+    "erstellt",
+    "gestaltet",
+    "initiiert",
+    "innoviert",
+    "eingef\xFChrt",
+    "gegr\xFCndet",
+    "formuliert"
+  ],
+  pronouns: [
+    "ich",
+    "mich",
+    "mir",
+    "mein",
+    "meine",
+    "meinem",
+    "meiner",
+    "meines",
+    "wir",
+    "unser",
+    "unsere"
+  ],
+  stopWords: [
+    "ein",
+    "eine",
+    "einer",
+    "eines",
+    "einem",
+    "der",
+    "die",
+    "das",
+    "den",
+    "dem",
+    "des",
+    "und",
+    "oder",
+    "aber",
+    "in",
+    "an",
+    "auf",
+    "zu",
+    "f\xFCr",
+    "von",
+    "mit",
+    "bei",
+    "aus",
+    "ist",
+    "war",
+    "sind",
+    "waren",
+    "wird",
+    "wurde",
+    "werden",
+    "hat",
+    "hatte",
+    "haben",
+    "hatten",
+    "sein",
+    "kann",
+    "k\xF6nnte",
+    "soll",
+    "sollte",
+    "muss",
+    "musste",
+    "darf",
+    "diese",
+    "dieser",
+    "dieses",
+    "diesem",
+    "diesen",
+    "als",
+    "wenn",
+    "nicht",
+    "kein",
+    "keine",
+    "so",
+    "auch",
+    "noch",
+    "schon",
+    "nach",
+    "vor",
+    "\xFCber",
+    "unter",
+    "zwischen",
+    "durch",
+    "ohne",
+    "um",
+    "bis",
+    "alle",
+    "jede",
+    "jeder",
+    "jedes",
+    "mehr",
+    "viel",
+    "sehr"
+  ]
+};
+var de_default = de;
+
+// src/ats/i18n/index.ts
+var languages = { en: en_default, de: de_default };
+function getLanguageData(language) {
+  return languages[language] ?? languages["en"] ?? en_default;
+}
+
+// src/ats/checks/yoe.ts
+function computeYoeYears(work) {
+  const ranges = (work || []).filter((w) => w.startDate).map((w) => {
+    const s = new Date(w.startDate).getTime();
+    const e = w.endDate ? new Date(w.endDate).getTime() : Date.now();
+    return [s, e];
+  }).sort((a, b) => a[0] - b[0]);
+  if (ranges.length === 0) return 0;
+  const merged = [ranges[0]];
+  for (let i = 1; i < ranges.length; i++) {
+    const last = merged[merged.length - 1];
+    const curr = ranges[i];
+    if (curr[0] <= last[1]) last[1] = Math.max(last[1], curr[1]);
+    else merged.push(curr);
+  }
+  const ms = merged.reduce((sum, [s, e]) => sum + (e - s), 0);
+  return ms / (1e3 * 60 * 60 * 24 * 365.25);
+}
+
+// src/ats/checks/recruiter.ts
+var wordCount = (s) => s.trim().split(/\s+/).filter(Boolean).length;
+var firstWord = (s) => s.trim().split(/\s+/)[0]?.toLowerCase().replace(/[^a-zA-ZäöüßÄÖÜàáâãéèêëíìîïóòôõúùûñç]/g, "") || "";
+function isSenior(resume, cfg) {
+  return computeYoeYears(resume.work) >= cfg.thresholds.seniorYoeCutoff;
+}
+var summaryLength = (resume) => {
+  const s = resume.basics?.summary?.trim();
+  if (!s) {
+    return {
+      id: "summary-length",
+      tier: "recruiter",
+      weight: "medium",
+      status: "fail",
+      score: 0,
+      message: "No professional summary.",
+      hints: ["Add a 2-4 sentence summary (20-50 words) to basics.summary."]
+    };
+  }
+  const w = wordCount(s);
+  if (w >= 20 && w <= 50) {
+    return {
+      id: "summary-length",
+      tier: "recruiter",
+      weight: "medium",
+      status: "pass",
+      score: 100,
+      message: `Summary length good (${w} words).`,
+      hints: []
+    };
+  }
+  if (w >= 10 && w <= 80) {
+    return {
+      id: "summary-length",
+      tier: "recruiter",
+      weight: "medium",
+      status: "warn",
+      score: 70,
+      message: `Summary ${w < 20 ? "short" : "long"} (${w} words). Aim for 20-50.`,
+      hints: [w < 20 ? "Expand to 20-50 words." : "Trim to the most impactful 20-50 words."]
+    };
+  }
+  return {
+    id: "summary-length",
+    tier: "recruiter",
+    weight: "medium",
+    status: "fail",
+    score: Math.max(0, 100 - Math.abs(w - 35) * 2),
+    message: `Summary length ${w} words is far from target.`,
+    hints: ["Rewrite the summary in 2-4 sentences (20-50 words)."]
+  };
+};
+var actionVerbStart = (resume, language) => {
+  const verbs = new Set(getLanguageData(language).actionVerbs);
+  const all = [];
+  (resume.work || []).forEach((w, i) => {
+    (w.highlights || []).forEach(
+      (h, j) => all.push({ text: h, path: `work[${i}].highlights[${j}]` })
+    );
+  });
+  (resume.projects || []).forEach((p, i) => {
+    (p.highlights || []).forEach(
+      (h, j) => all.push({ text: h, path: `projects[${i}].highlights[${j}]` })
+    );
+  });
+  if (all.length === 0) {
+    return {
+      id: "action-verb-start",
+      tier: "recruiter",
+      weight: "medium",
+      status: "skipped",
+      score: 0,
+      message: "No highlights.",
+      hints: []
+    };
+  }
+  const without = all.filter((h) => !verbs.has(firstWord(h.text)));
+  const passed = without.length === 0;
+  return {
+    id: "action-verb-start",
+    tier: "recruiter",
+    weight: "medium",
+    status: passed ? "pass" : without.length / all.length > 0.3 ? "fail" : "warn",
+    score: Math.round((all.length - without.length) / all.length * 100),
+    message: passed ? "All highlights start with action verbs." : `${without.length} of ${all.length} highlights miss an action verb.`,
+    hints: passed ? [] : without.slice(0, 3).map((h) => `${h.path}: start with an action verb instead of "${firstWord(h.text)}".`)
+  };
+};
+var QUANT_RE = /\d+%?|\$[\d,]+|[\d,]+\+?\s*(users|clients|customers|people|team|members|projects|applications|servers|services|endpoints|requests|transactions)/i;
+var quantificationDensity = (resume) => {
+  const all = [];
+  (resume.work || []).forEach((w, i) => {
+    (w.highlights || []).forEach(
+      (h, j) => all.push({ text: h, path: `work[${i}].highlights[${j}]` })
+    );
+  });
+  (resume.projects || []).forEach((p, i) => {
+    (p.highlights || []).forEach(
+      (h, j) => all.push({ text: h, path: `projects[${i}].highlights[${j}]` })
+    );
+  });
+  if (all.length === 0) {
+    return {
+      id: "quantification-density",
+      tier: "recruiter",
+      weight: "high",
+      status: "skipped",
+      score: 0,
+      message: "No highlights.",
+      hints: []
+    };
+  }
+  const quantified = all.filter((h) => QUANT_RE.test(h.text));
+  const ratio = quantified.length / all.length;
+  const status = ratio >= 0.5 ? "pass" : ratio >= 0.3 ? "warn" : "fail";
+  return {
+    id: "quantification-density",
+    tier: "recruiter",
+    weight: "high",
+    status,
+    score: Math.min(100, Math.round(ratio * 200)),
+    message: `${quantified.length}/${all.length} highlights quantified (${Math.round(ratio * 100)}%).`,
+    hints: status === "pass" ? [] : all.filter((h) => !QUANT_RE.test(h.text)).slice(0, 3).map((h) => `${h.path}: add a number/metric.`)
+  };
+};
+var pronounLeakage = (resume, language) => {
+  const set = new Set(getLanguageData(language).pronouns);
+  const blocks = [];
+  if (resume.basics?.summary) blocks.push({ text: resume.basics.summary, path: "basics.summary" });
+  (resume.work || []).forEach((w, i) => {
+    if (w.summary) blocks.push({ text: w.summary, path: `work[${i}].summary` });
+    (w.highlights || []).forEach(
+      (h, j) => blocks.push({ text: h, path: `work[${i}].highlights[${j}]` })
+    );
+  });
+  const hits = [];
+  for (const b of blocks) {
+    for (const w of b.text.toLowerCase().split(/\s+/)) {
+      const clean = w.replace(/[^a-zA-ZäöüßÄÖÜ]/g, "");
+      if (set.has(clean)) hits.push({ pronoun: clean, path: b.path });
+    }
+  }
+  const passed = hits.length === 0;
+  return {
+    id: "pronoun-leakage",
+    tier: "recruiter",
+    weight: "low",
+    status: passed ? "pass" : hits.length > 3 ? "fail" : "warn",
+    score: passed ? 100 : Math.max(0, 100 - hits.length * 15),
+    message: passed ? "No first-person pronouns." : `${hits.length} pronoun(s): ${[...new Set(hits.map((h) => h.pronoun))].join(", ")}.`,
+    hints: passed ? [] : hits.slice(0, 3).map((h) => `${h.path}: drop "${h.pronoun}" (convention, not ATS).`)
+  };
+};
+var bulletsPerRole = (resume, _l, cfg) => {
+  const work = resume.work || [];
+  if (work.length === 0) {
+    return {
+      id: "bullets-per-role",
+      tier: "recruiter",
+      weight: "medium",
+      status: "skipped",
+      score: 0,
+      message: "No work entries.",
+      hints: []
+    };
+  }
+  const senior = isSenior(resume, cfg);
+  const min = cfg.thresholds.bulletsPerRole.min;
+  const max = senior ? cfg.thresholds.bulletsPerRole.seniorMax : cfg.thresholds.bulletsPerRole.max;
+  const offenders = [];
+  work.forEach((w, i) => {
+    const n = (w.highlights || []).length;
+    if (n < min || n > max) offenders.push({ path: `work[${i}]`, n });
+  });
+  const passed = offenders.length === 0;
+  return {
+    id: "bullets-per-role",
+    tier: "recruiter",
+    weight: "medium",
+    status: passed ? "pass" : work.length === 1 ? "warn" : offenders.length > work.length / 2 ? "fail" : "warn",
+    score: Math.round((work.length - offenders.length) / work.length * 100),
+    message: passed ? `All roles have ${min}-${max} highlights.` : `${offenders.length} role(s) outside ${min}-${max} highlights.`,
+    hints: passed ? [] : offenders.slice(0, 3).map((o) => `${o.path}: ${o.n} highlights, target ${min}-${max}.`)
+  };
+};
+var wordCountTotal = (resume, _l, cfg) => {
+  const senior = isSenior(resume, cfg);
+  const min = cfg.thresholds.wordCount.min;
+  const max = senior ? cfg.thresholds.wordCount.seniorMax : cfg.thresholds.wordCount.max;
+  const parts = [];
+  if (resume.basics?.summary) parts.push(resume.basics.summary);
+  for (const w of resume.work || []) {
+    if (w.summary) parts.push(w.summary);
+    parts.push(...w.highlights || []);
+  }
+  for (const p of resume.projects || []) {
+    if (p.description) parts.push(p.description);
+    parts.push(...p.highlights || []);
+  }
+  const total = wordCount(parts.join(" "));
+  const passed = total >= min && total <= max;
+  const status = passed ? "pass" : total < min * 0.7 || total > max * 1.5 ? "fail" : "warn";
+  return {
+    id: "word-count-total",
+    tier: "recruiter",
+    weight: "low",
+    status,
+    score: passed ? 100 : Math.max(0, 100 - Math.round(Math.abs(total - (min + max) / 2) / 10)),
+    message: `Resume body: ${total} words (target ${min}-${max}${senior ? ", senior" : ""}).`,
+    hints: passed ? [] : [total < min ? "Add more depth to highlights." : "Trim less impactful highlights."]
+  };
+};
+var highlightLength = (resume) => {
+  const all = [];
+  (resume.work || []).forEach((w, i) => {
+    (w.highlights || []).forEach(
+      (h, j) => all.push({ text: h, path: `work[${i}].highlights[${j}]` })
+    );
+  });
+  if (all.length === 0) {
+    return {
+      id: "highlight-length",
+      tier: "recruiter",
+      weight: "low",
+      status: "skipped",
+      score: 0,
+      message: "No highlights.",
+      hints: []
+    };
+  }
+  const long = all.filter((h) => wordCount(h.text) > 30);
+  const passed = long.length === 0;
+  return {
+    id: "highlight-length",
+    tier: "recruiter",
+    weight: "low",
+    status: passed ? "pass" : long.length / all.length > 0.3 ? "fail" : "warn",
+    score: Math.round((all.length - long.length) / all.length * 100),
+    message: passed ? "All highlights at most 30 words." : `${long.length} highlight(s) over 30 words.`,
+    hints: passed ? [] : long.slice(0, 3).map((h) => `${h.path}: trim to 30 words or fewer.`)
+  };
+};
+function isLinkedInUrl(url) {
+  if (!url) return false;
+  try {
+    const host = new URL(url).hostname.toLowerCase();
+    return host === "linkedin.com" || host.endsWith(".linkedin.com");
+  } catch {
+    return false;
+  }
+}
+var hasLinkedin = (resume) => {
+  const profiles = resume.basics?.profiles || [];
+  const found = profiles.some(
+    (p) => p.network?.toLowerCase() === "linkedin" || isLinkedInUrl(p.url)
+  );
+  return {
+    id: "has-linkedin",
+    tier: "recruiter",
+    weight: "low",
+    status: found ? "pass" : "warn",
+    score: found ? 100 : 0,
+    message: found ? "LinkedIn profile present." : "No LinkedIn profile.",
+    hints: found ? [] : ["Add a LinkedIn profile to basics.profiles."]
+  };
+};
+var skillsPopulated = (resume) => {
+  const skills = resume.skills || [];
+  const withKeywords = skills.filter((s) => (s.keywords?.length ?? 0) > 0);
+  const passed = withKeywords.length >= 3;
+  return {
+    id: "skills-populated",
+    tier: "recruiter",
+    weight: "medium",
+    status: passed ? "pass" : withKeywords.length < 2 ? "fail" : "warn",
+    score: Math.min(100, Math.round(withKeywords.length / 3 * 100)),
+    message: passed ? `${withKeywords.length} skill categories with keywords.` : `Only ${withKeywords.length} skill categories with keywords (need 3+).`,
+    hints: passed ? [] : ["Add at least 3 skill categories with keywords."]
+  };
+};
+var allRecruiterChecks = [
+  summaryLength,
+  actionVerbStart,
+  quantificationDensity,
+  pronounLeakage,
+  bulletsPerRole,
+  wordCountTotal,
+  highlightLength,
+  hasLinkedin,
+  skillsPopulated
+];
+
+// src/ats/jdMatcher.ts
+function extractResumeText(resume) {
+  const parts = [];
+  if (resume.basics?.summary) parts.push(resume.basics.summary);
+  if (resume.basics?.label) parts.push(resume.basics.label);
+  for (const w of resume.work || []) {
+    if (w.position) parts.push(w.position);
+    if (w.summary) parts.push(w.summary);
+    parts.push(...w.highlights || []);
+  }
+  for (const s of resume.skills || []) {
+    if (s.name) parts.push(s.name);
+    parts.push(...s.keywords || []);
+  }
+  for (const p of resume.projects || []) {
+    if (p.name) parts.push(p.name);
+    if (p.description) parts.push(p.description);
+    parts.push(...p.highlights || []);
+  }
+  for (const e of resume.education || []) {
+    if (e.area) parts.push(e.area);
+    if (e.studyType) parts.push(e.studyType);
+    parts.push(...e.courses || []);
+  }
+  for (const c of resume.certificates || []) {
+    if (c.name) parts.push(c.name);
+  }
+  return parts.join(" ");
+}
+function splitJdSections(text) {
+  const lines = text.split("\n");
+  const reqPatterns = /^(required|requirements?|minimum|preferred|qualifications?|must[\s-]have|nice[\s-]to[\s-]have|what you.?ll|what we.?re looking|skills|technical|you.?ll need|responsibilities|you will)/i;
+  const nonReqPatterns = /^(about|summary|who we are|our (company|team|mission)|description|overview|benefits|perks|compensation|salary)/i;
+  let inReqSection = false;
+  const reqLines = [];
+  for (const line of lines) {
+    const header = line.trim().replace(/[:#*-]/g, "").trim();
+    if (reqPatterns.test(header)) inReqSection = true;
+    else if (nonReqPatterns.test(header)) inReqSection = false;
+    if (inReqSection) reqLines.push(line);
+  }
+  return {
+    requirementText: reqLines.join("\n"),
+    fullText: text
+  };
+}
+function rankSkills(fullMatches, requirementMatches) {
+  const reqIds = new Set(requirementMatches.map((m) => m.skill.id));
+  return fullMatches.map((m) => {
+    const inRequirementSection = reqIds.has(m.skill.id);
+    const score = m.occurrences * 1 + (inRequirementSection ? 3 : 0) + (m.skill.hot ? 1.5 : 0);
+    return {
+      canonical: m.skill.canonical,
+      occurrences: m.occurrences,
+      inRequirementSection,
+      hot: m.skill.hot,
+      score
+    };
+  }).sort((a, b) => {
+    if (a.inRequirementSection !== b.inRequirementSection) return a.inRequirementSection ? -1 : 1;
+    if (a.score !== b.score) return b.score - a.score;
+    return a.canonical.localeCompare(b.canonical);
+  });
+}
+function matchJobDescription(resume, jobDescription, _language = "en") {
+  if (!jobDescription.trim()) {
+    return { matched: [], missing: [], extra: [], matchPercentage: 0 };
+  }
+  const skillIndex = getSkillIndex();
+  const fullMatches = skillIndex.scan(jobDescription);
+  const { requirementText } = splitJdSections(jobDescription);
+  const requirementMatches = requirementText.trim() ? skillIndex.scan(requirementText) : fullMatches;
+  const ranked = rankSkills(fullMatches, requirementMatches).slice(0, 25);
+  const resumeText = extractResumeText(resume);
+  const resumeMatches = skillIndex.scan(resumeText);
+  const resumeSkillIds = new Set(resumeMatches.map((m) => m.skill.id));
+  const matched = [];
+  const missing = [];
+  for (const r of ranked) {
+    const match = fullMatches.find((m) => m.skill.canonical === r.canonical);
+    if (!match) continue;
+    if (resumeSkillIds.has(match.skill.id)) matched.push(r.canonical);
+    else missing.push(r.canonical);
+  }
+  const matchPercentage = ranked.length > 0 ? Math.round(matched.length / ranked.length * 100) : 0;
+  const jdSkillIds = new Set(fullMatches.map((m) => m.skill.id));
+  const extra = [];
+  for (const m of resumeMatches) {
+    if (!jdSkillIds.has(m.skill.id)) extra.push(m.skill.canonical);
+  }
+  extra.splice(25);
+  return { matched, missing, extra, matchPercentage };
+}
+
+// src/ats/roleFamily.ts
+var SIGNATURES = {
+  engineering: [
+    "software engineer",
+    "engineer",
+    "developer",
+    "programmer",
+    "swe",
+    "backend",
+    "back-end",
+    "frontend",
+    "front-end",
+    "full stack",
+    "full-stack",
+    "devops",
+    "sre",
+    "site reliability",
+    "software development",
+    "microservices",
+    "codebase"
+  ],
+  data: [
+    "data scientist",
+    "data engineer",
+    "machine learning",
+    "ml engineer",
+    "data analyst",
+    "analytics engineer",
+    "mlops"
+  ],
+  design: [
+    "designer",
+    "ux ",
+    "ui designer",
+    "product design",
+    "graphic design",
+    "visual design",
+    "user research"
+  ],
+  product: ["product manager", "product owner", "program manager", "product management"],
+  recruiting: [
+    "recruiter",
+    "recruiting",
+    "recruitment",
+    "talent acquisition",
+    "sourcer",
+    "sourcing",
+    "full-cycle recruiting",
+    "candidate experience",
+    "hiring manager",
+    "people ops",
+    "human resources"
+  ],
+  sales: [
+    "account executive",
+    "business development",
+    "sales development",
+    "sales representative",
+    "quota",
+    "sdr",
+    "bdr"
+  ],
+  marketing: [
+    "marketing",
+    "growth marketing",
+    "demand generation",
+    "content marketing",
+    "brand manager",
+    "seo"
+  ],
+  legal: ["legal counsel", "attorney", "paralegal", "lawyer", "litigation", "general counsel"],
+  finance: ["accountant", "accounting", "controller", "fp&a", "financial analyst", "bookkeeping"],
+  support: [
+    "customer support",
+    "customer success",
+    "support specialist",
+    "technical support",
+    "help desk"
+  ],
+  operations: ["operations manager", "business operations", "supply chain", "logistics"]
+};
+var FAMILIES = Object.keys(SIGNATURES);
+function countOccurrences(haystack, needle) {
+  let count = 0;
+  let idx = haystack.indexOf(needle);
+  while (idx !== -1) {
+    count++;
+    idx = haystack.indexOf(needle, idx + needle.length);
+  }
+  return count;
+}
+function classifyRoleFamily(body, title = "") {
+  const b = body.toLowerCase();
+  const t = title.toLowerCase();
+  const scores = FAMILIES.map((family) => {
+    let score = 0;
+    for (const sig of SIGNATURES[family]) {
+      score += countOccurrences(b, sig);
+      score += countOccurrences(t, sig) * 3;
+    }
+    return { family, score };
+  }).sort((a, b2) => b2.score - a.score);
+  const top = scores[0];
+  const second = scores[1];
+  if (!top || top.score < 2) return null;
+  const margin = top.score - (second?.score ?? 0);
+  if (margin < 1) return null;
+  return { family: top.family, score: top.score, margin };
+}
+var SPECIALTY_SIGNATURES = {
+  frontend: ["frontend", "front-end", "front end", "react", "vue", "angular", "css", "ui engineer", "web developer", "design system"],
+  backend: ["backend", "back-end", "back end", "server-side", "microservices", "api development", "distributed systems"],
+  security: ["security", "appsec", "application security", "infosec", "penetration", "vulnerability", "secure coding", "cryptography", "threat"],
+  ml: ["machine learning", "ml engineer", "deep learning", "nlp", "computer vision", "ai engineer", "pytorch", "tensorflow"],
+  mobile: ["ios engineer", "android engineer", "mobile engineer", "swift", "kotlin", "react native", "flutter"],
+  devops: ["devops", "sre", "site reliability", "platform engineer", "kubernetes", "terraform", "infrastructure engineer"],
+  data: ["data engineer", "etl", "data pipeline", "spark", "hadoop", "data warehouse"],
+  embedded: ["embedded", "firmware", "rtos", "microcontroller", "bare metal"],
+  qa: ["qa engineer", "test engineer", "sdet", "automation testing", "quality assurance"]
+};
+var SPECIALTIES = Object.keys(SPECIALTY_SIGNATURES);
+function classifySpecialty(body, title = "") {
+  const b = body.toLowerCase();
+  const t = title.toLowerCase();
+  const scores = SPECIALTIES.map((sp) => {
+    let score = 0;
+    for (const sig of SPECIALTY_SIGNATURES[sp]) {
+      score += countOccurrences(b, sig);
+      score += countOccurrences(t, sig) * 3;
+    }
+    return { sp, score };
+  }).sort((a, b2) => b2.score - a.score);
+  const top = scores[0];
+  const second = scores[1];
+  if (!top || top.score < 2) return null;
+  if (top.score - (second?.score ?? 0) < 1) return null;
+  return top.sp;
+}
+var SPECIALTY_MIN_SCORE = 4;
+var TOP_MARGIN_FACTOR = 0.5;
+var SPECIALTY_ABS_MARGIN = 3;
+function resumeSpecialties(resume) {
+  const text = resumeRoleText(resume).toLowerCase();
+  const scored = SPECIALTIES.map((sp) => {
+    let score = 0;
+    for (const sig of SPECIALTY_SIGNATURES[sp]) score += countOccurrences(text, sig);
+    return { sp, score };
+  }).sort((a, b) => b.score - a.score);
+  const top = scored[0];
+  if (!top || top.score < SPECIALTY_MIN_SCORE) return [];
+  const margin = Math.min(SPECIALTY_ABS_MARGIN, Math.max(TOP_MARGIN_FACTOR * top.score, 1));
+  const threshold = top.score - margin;
+  return scored.filter((s) => s.score >= threshold).map((s) => s.sp);
+}
+function resumeRoleText(resume) {
+  const parts = [];
+  if (resume.basics?.label) parts.push(resume.basics.label);
+  if (resume.basics?.summary) parts.push(resume.basics.summary);
+  for (const w of resume.work ?? []) {
+    if (w.position) parts.push(w.position);
+    if (w.summary) parts.push(w.summary);
+    parts.push(...w.highlights ?? []);
+  }
+  for (const s of resume.skills ?? []) {
+    if (s.name) parts.push(s.name);
+    parts.push(...s.keywords ?? []);
+  }
+  return parts.join(" ");
+}
+
+// src/ats/checks/match.ts
+var SENIORITY = /\b(junior|senior|lead|staff|principal|head of|vp|chief)\b/gi;
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "of",
+  "at",
+  "for",
+  "in",
+  "on",
+  "to",
+  "with",
+  "and",
+  "or"
+]);
+function tokenize(s) {
+  return s.toLowerCase().replace(SENIORITY, "").replace(/[^a-z0-9 ]/g, " ").split(/\s+/).filter((w) => w && !STOPWORDS.has(w));
+}
+function jaccard(a, b) {
+  const A = new Set(a), B = new Set(b);
+  let inter = 0;
+  for (const x of A) if (B.has(x)) inter++;
+  const union = A.size + B.size - inter;
+  return union === 0 ? 0 : inter / union;
+}
+function trimTitle(t) {
+  return t.trim().replace(/\s*[,\-–—]\s.*$/, "").trim();
+}
+function extractJdTitle(jd) {
+  const lines = jd.split("\n").slice(0, 8);
+  for (const l of lines) {
+    const m = l.match(/(?:role|position|title)[\s:-]+(.+)/i) || l.match(/looking for (?:an? )?(.+?)(?:\s+with|\s+to|$)/i);
+    if (m?.[1]) return trimTitle(m[1]);
+  }
+  const fallback = lines.find(
+    (l) => /\b(engineer|developer|manager|designer|analyst|scientist|architect|lead)\b/i.test(l)
+  );
+  return fallback ? trimTitle(fallback) : void 0;
+}
+var titleAlignment = (resume, _l, { jobDescription, jobTitle }) => {
+  if (!jobDescription) {
+    return {
+      id: "title-alignment",
+      tier: "match",
+      weight: "high",
+      status: "skipped",
+      score: 0,
+      message: "No JD.",
+      hints: []
+    };
+  }
+  const resumeTitle = resume.work?.[0]?.position || resume.basics?.label;
+  const jdTitle = jobTitle?.trim() ? trimTitle(jobTitle) : extractJdTitle(jobDescription);
+  if (!resumeTitle || !jdTitle) {
+    return {
+      id: "title-alignment",
+      tier: "match",
+      weight: "high",
+      status: "skipped",
+      score: 0,
+      message: "Could not extract a title from the JD or resume.",
+      hints: ["Set basics.label to your target title, or supply the posting title."]
+    };
+  }
+  const j = jaccard(tokenize(resumeTitle), tokenize(jdTitle));
+  const status = j >= 0.6 ? "pass" : j >= 0.3 ? "warn" : "fail";
+  return {
+    id: "title-alignment",
+    tier: "match",
+    weight: "high",
+    status,
+    score: Math.round(j * 100),
+    message: `Title overlap ${Math.round(j * 100)}% (resume "${resumeTitle}" vs JD "${jdTitle}").`,
+    hints: status === "pass" ? [] : [`Consider aligning basics.label closer to "${jdTitle}".`]
+  };
+};
+var EDU_RE = {
+  3: /\b(phd|ph\.?d|doctorate|doctoral)\b/i,
+  2: /\b(master|m\.?s|m\.?a|mba|graduate degree)\b/i,
+  1: /\b(bachelor|b\.?s|b\.?a|undergraduate)\b/i
+};
+function eduLevel(text) {
+  if (!text) return 0;
+  if (EDU_RE[3].test(text)) return 3;
+  if (EDU_RE[2].test(text)) return 2;
+  if (EDU_RE[1].test(text)) return 1;
+  return 0;
+}
+var educationLevel = (resume, _l, { jobDescription }) => {
+  if (!jobDescription) {
+    return {
+      id: "education-level",
+      tier: "match",
+      weight: "medium",
+      status: "skipped",
+      score: 0,
+      message: "No JD.",
+      hints: []
+    };
+  }
+  const required = eduLevel(jobDescription);
+  if (required === 0) {
+    return {
+      id: "education-level",
+      tier: "match",
+      weight: "medium",
+      status: "skipped",
+      score: 0,
+      message: "JD does not specify education level.",
+      hints: []
+    };
+  }
+  const have = Math.max(0, ...(resume.education || []).map((e) => eduLevel(e.studyType || "")));
+  const passed = have >= required;
+  return {
+    id: "education-level",
+    tier: "match",
+    weight: "medium",
+    status: passed ? "pass" : "fail",
+    score: passed ? 100 : Math.round(have / required * 100),
+    message: `Resume level ${have}, JD required ${required}.`,
+    hints: passed ? [] : ["JD requires a higher degree level than the resume reports."]
+  };
+};
+var YOE_RE = /(\d+)\s*(?:\+|[-–—]\s*\d+|to\s*\d+)?\s*years?/i;
+var yoeMatch = (resume, _l, { jobDescription }) => {
+  if (!jobDescription) {
+    return {
+      id: "yoe-match",
+      tier: "match",
+      weight: "high",
+      status: "skipped",
+      score: 0,
+      message: "No JD.",
+      hints: []
+    };
+  }
+  const m = jobDescription.match(YOE_RE);
+  if (!m) {
+    return {
+      id: "yoe-match",
+      tier: "match",
+      weight: "high",
+      status: "skipped",
+      score: 0,
+      message: "JD does not specify years requirement.",
+      hints: []
+    };
+  }
+  const required = parseInt(m[1] ?? "0", 10);
+  const have = Math.floor(computeYoeYears(resume.work || []));
+  const status = have >= required ? "pass" : have >= required - 1 ? "warn" : "fail";
+  return {
+    id: "yoe-match",
+    tier: "match",
+    weight: "high",
+    status,
+    score: Math.min(100, Math.round(have / required * 100)),
+    message: `${have} YOE detected vs ${required} required.`,
+    hints: status === "pass" ? [] : ["Highlight relevant earlier roles or projects to fill the gap."]
+  };
+};
+var hardSkillOverlap = (resume, language, { jobDescription }) => {
+  if (!jobDescription) {
+    return {
+      id: "hard-skill-overlap",
+      tier: "match",
+      weight: "high",
+      status: "skipped",
+      score: 0,
+      message: "No JD.",
+      hints: []
+    };
+  }
+  const km = matchJobDescription(resume, jobDescription, language);
+  const pct = km.matchPercentage;
+  const status = pct >= 70 ? "pass" : pct >= 50 ? "warn" : "fail";
+  return {
+    id: "hard-skill-overlap",
+    tier: "match",
+    weight: "high",
+    status,
+    score: pct,
+    message: `${km.matched.length}/${km.matched.length + km.missing.length} hard skills matched (${pct}%).`,
+    hints: status === "pass" ? [] : km.missing.slice(0, 5).map((s) => `Add evidence of "${s}" to skills/highlights.`)
+  };
+};
+var roleFamilyMatch = (resume, _l, { jobDescription, jobTitle }) => {
+  if (!jobDescription) {
+    return {
+      id: "role-family-match",
+      tier: "match",
+      weight: "high",
+      status: "skipped",
+      score: 0,
+      message: "No JD.",
+      hints: []
+    };
+  }
+  const jd = classifyRoleFamily(jobDescription, jobTitle ?? "");
+  const cv = classifyRoleFamily(resumeRoleText(resume));
+  if (!jd || !cv) {
+    return {
+      id: "role-family-match",
+      tier: "match",
+      weight: "high",
+      status: "skipped",
+      score: 0,
+      message: "Could not confidently classify the role family of the JD or resume.",
+      hints: []
+    };
+  }
+  if (jd.family !== cv.family) {
+    return {
+      id: "role-family-match",
+      tier: "match",
+      weight: "high",
+      status: "fail",
+      score: 0,
+      message: `Role mismatch: ${cv.family} resume vs ${jd.family} role.`,
+      hints: [
+        `This posting reads as a ${jd.family} role; your resume reads as ${cv.family}. Likely not a fit.`
+      ]
+    };
+  }
+  if (cv.family === "engineering") {
+    const jdSpec = classifySpecialty(jobDescription, jobTitle ?? "");
+    if (jdSpec) {
+      const cvTopSpecs = resumeSpecialties(resume);
+      const satisfied = cvTopSpecs.length === 0 || cvTopSpecs.includes(jdSpec);
+      if (!satisfied) {
+        return {
+          id: "role-family-match",
+          tier: "match",
+          weight: "high",
+          status: "fail",
+          score: 0,
+          message: `Specialty mismatch: ${jdSpec} role, resume specializes in ${cvTopSpecs[0] ?? "general engineering"}.`,
+          hints: [
+            `This is a ${jdSpec} engineering role; your resume doesn't show ${jdSpec} depth. Likely not a fit.`
+          ]
+        };
+      }
+    }
+  }
+  return {
+    id: "role-family-match",
+    tier: "match",
+    weight: "high",
+    status: "pass",
+    score: 100,
+    message: `Role family aligned (${cv.family}).`,
+    hints: []
+  };
+};
+var allMatchChecks = [
+  hardSkillOverlap,
+  titleAlignment,
+  roleFamilyMatch,
+  educationLevel,
+  yoeMatch
+];
+var KNOCKOUTS = [
+  {
+    signal: "work-auth",
+    jdPattern: /(work\s*auth|authorization to work|right to work|us citizen|green card|h-?1b|visa sponsorship)/i,
+    resumeMatch: (r) => /(work auth|authorized|citizen|green card|visa)/i.test(r.basics?.summary || ""),
+    recommendation: "Confirm authorization status in the application form."
+  },
+  {
+    signal: "location",
+    jdPattern: /(must be located|on-?site|relocate|based in)\s+([a-zA-Z ,]+)/i,
+    resumeMatch: (r, m) => {
+      const jdLoc = (m[2] ?? "").toLowerCase().trim();
+      const resumeCity = (r.basics?.location?.city ?? "").toLowerCase().trim();
+      if (!jdLoc || !resumeCity) return false;
+      return jdLoc.includes(resumeCity) || resumeCity.includes(jdLoc.split(/[, ]+/)[0] ?? "");
+    },
+    recommendation: "Verify location requirement against your basics.location.city."
+  },
+  {
+    signal: "clearance",
+    jdPattern: /(ts\/sci|secret clearance|security clearance|active clearance)/i,
+    resumeMatch: (r) => /clearance/i.test(JSON.stringify(r)),
+    recommendation: "Confirm clearance level on the application form."
+  },
+  {
+    signal: "certification",
+    jdPattern: /(cissp|aws certified|pmp|ccna|cpa|required certification)/i,
+    resumeMatch: (r) => (r.certificates?.length ?? 0) > 0,
+    recommendation: "List required certificates in the certificates section if held."
+  }
+];
+function extractKnockouts(resume, jobDescription) {
+  const out = [];
+  for (const k of KNOCKOUTS) {
+    const m = jobDescription.match(k.jdPattern);
+    if (!m) continue;
+    if (k.resumeMatch(resume, m)) continue;
+    out.push({
+      signal: k.signal,
+      evidence: `JD: "${m[0]}"; resume silent.`,
+      recommendation: k.recommendation
+    });
+  }
+  return out;
+}
+
+// src/ats/scoring.ts
+var weightMultiplier = {
+  high: 3,
+  medium: 2,
+  low: 1
+};
+function gradeFromScore(score, t) {
+  if (score >= t.A) return "A";
+  if (score >= t.B) return "B";
+  if (score >= t.C) return "C";
+  if (score >= t.D) return "D";
+  return "F";
+}
+function computeTierScore(checks) {
+  const active = checks.filter((c) => c.status !== "skipped");
+  if (active.length === 0) return 0;
+  let weighted = 0;
+  let total = 0;
+  for (const c of active) {
+    const m = weightMultiplier[c.weight];
+    weighted += c.score * m;
+    total += 100 * m;
+  }
+  return total > 0 ? Math.round(weighted / total * 100) : 0;
+}
+function computeTotalScore(tiers, weights) {
+  if (tiers.match === void 0) {
+    const sum2 = weights.parsing + weights.recruiter;
+    const wp = weights.parsing / sum2;
+    const wr = weights.recruiter / sum2;
+    return Math.round(
+      tiers.parsing * (sum2 === 50 ? 0.4 : wp) + tiers.recruiter * (sum2 === 50 ? 0.6 : wr)
+    );
+  }
+  const sum = weights.parsing + weights.match + weights.recruiter;
+  return Math.round(
+    (tiers.parsing * weights.parsing + tiers.match * weights.match + tiers.recruiter * weights.recruiter) / sum
+  );
+}
+function scoreToRating(score, t) {
+  if (score >= t.excellent) return "excellent";
+  if (score >= t.good) return "good";
+  if (score >= t.needsWork) return "needs-work";
+  return "poor";
+}
+function generateSummary(score, rating, hasJd, knockouts) {
+  const ratingLabel = {
+    excellent: "Excellent",
+    good: "Good",
+    "needs-work": "Needs Work",
+    poor: "Poor"
+  }[rating];
+  const knockoutNote = knockouts > 0 ? ` ${knockouts} knockout signal${knockouts === 1 ? "" : "s"} flagged.` : "";
+  return `ATS ${score}/100 (${ratingLabel}).${hasJd ? " Includes JD match." : ""}${knockoutNote}`;
+}
+
+// src/utils/config.ts
+import fs from "fs";
+import path from "path";
+import yaml from "yaml";
+import { z } from "zod";
+import merge from "lodash.merge";
+var weightEnum = z.enum(["high", "medium", "low"]);
+var atsConfigSchema = z.object({
+  weights: z.object({
+    tiers: z.object({
+      parsing: z.number().int().min(0).max(100),
+      match: z.number().int().min(0).max(100),
+      recruiter: z.number().int().min(0).max(100)
+    }).partial().optional(),
+    checks: z.record(z.string(), weightEnum).optional()
+  }).partial().optional(),
+  thresholds: z.object({
+    rating: z.object({
+      excellent: z.number(),
+      good: z.number(),
+      needsWork: z.number()
+    }).partial().optional(),
+    grade: z.object({ A: z.number(), B: z.number(), C: z.number(), D: z.number() }).partial().optional(),
+    seniorYoeCutoff: z.number().int().min(0).optional(),
+    wordCount: z.object({ min: z.number(), max: z.number(), seniorMax: z.number() }).partial().optional(),
+    bulletsPerRole: z.object({ min: z.number(), max: z.number(), seniorMax: z.number() }).partial().optional()
+  }).partial().optional(),
+  disable: z.array(z.string()).optional(),
+  locale: z.string().optional()
+});
+var fileSchema = z.object({ ats: atsConfigSchema.optional() });
+var defaultConfig = {
+  weights: {
+    tiers: { parsing: 30, match: 50, recruiter: 20 },
+    checks: {}
+  },
+  thresholds: {
+    rating: { excellent: 90, good: 75, needsWork: 60 },
+    grade: { A: 90, B: 80, C: 70, D: 60 },
+    seniorYoeCutoff: 10,
+    wordCount: { min: 400, max: 800, seniorMax: 1600 },
+    bulletsPerRole: { min: 3, max: 6, seniorMax: 10 }
+  },
+  disable: [],
+  locale: "en"
+};
+function loadConfig(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const file = opts.configPath ?? path.join(cwd, "resuml.config.yaml");
+  if (!fs.existsSync(file)) return defaultConfig;
+  const raw = fs.readFileSync(file, "utf8");
+  const parsed = yaml.parse(raw) ?? {};
+  const result = fileSchema.safeParse(parsed);
+  if (!result.success) {
+    const issue = result.error.issues[0];
+    const where = issue?.path.join(".") ?? "<root>";
+    throw new Error(`Invalid resuml.config.yaml at "${where}": ${issue?.message}`);
+  }
+  return merge({}, defaultConfig, result.data.ats ?? {});
+}
+function effectiveWeight(checkId, defaultWeight, config) {
+  return config.weights.checks[checkId] ?? defaultWeight;
+}
+
+// src/ats/index.ts
+function applyConfig(checks, cfg) {
+  return checks.filter((c) => !cfg.disable.includes(c.id)).map((c) => ({ ...c, weight: effectiveWeight(c.id, c.weight, cfg) }));
+}
+function buildTier(_tier, checks, cfg) {
+  const filtered = applyConfig(checks, cfg);
+  const score = computeTierScore(filtered);
+  return {
+    score,
+    grade: gradeFromScore(score, cfg.thresholds.grade),
+    checks: filtered
+  };
+}
+function analyzeAts(resume, options = {}) {
+  const cfg = options.config ?? defaultConfig;
+  const language = options.language ?? cfg.locale;
+  const parsingChecks = allParsingChecks.map((fn) => fn(resume, language));
+  const recruiterChecks = allRecruiterChecks.map((fn) => fn(resume, language, cfg));
+  const parsing = buildTier("parsing", parsingChecks, cfg);
+  const recruiter = buildTier("recruiter", recruiterChecks, cfg);
+  let match;
+  let knockouts = [];
+  let roleMismatch = false;
+  if (options.jobDescription) {
+    const matchChecks = allMatchChecks.map(
+      (fn) => fn(resume, language, { jobDescription: options.jobDescription, jobTitle: options.jobTitle })
+    );
+    match = buildTier("match", matchChecks, cfg);
+    roleMismatch = matchChecks.some(
+      (c) => c.id === "role-family-match" && c.status === "fail"
+    );
+    knockouts = extractKnockouts(resume, options.jobDescription);
+  }
+  let totalScore = computeTotalScore(
+    { parsing: parsing.score, match: match?.score, recruiter: recruiter.score },
+    cfg.weights.tiers
+  );
+  const capped = roleMismatch && totalScore > ROLE_MISMATCH_CAP;
+  if (capped) totalScore = ROLE_MISMATCH_CAP;
+  const rating = scoreToRating(totalScore, cfg.thresholds.rating);
+  let summary = generateSummary(totalScore, rating, !!options.jobDescription, knockouts.length);
+  if (capped) summary += " Score capped: resume role family does not match this posting.";
+  return {
+    score: totalScore,
+    rating,
+    tiers: match ? { parsing, match, recruiter } : { parsing, recruiter },
+    knockouts,
+    summary
+  };
+}
+var ROLE_MISMATCH_CAP = 45;
+
+export {
+  loadConfig,
+  analyzeAts
+};
+//# sourceMappingURL=chunk-C2JG5KF4.js.map