resuml 3.0.0 → 3.1.0

package/dist/{chunk-R4MD5YMV.js → chunk-QR77BRMN.js}

@@ -4,1442 +4,169 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/core.ts
-import { parse } from "yaml";
-import merge from "lodash.merge";
-import { validate } from "@jsonresume/schema";
-async function processResumeData(yamlContents) {
-  if (yamlContents.length === 0) {
-    throw new Error("No YAML content provided for processing.");
-  }
-  const dataObjects = yamlContents.map((content) => {
-    try {
-      return parse(content);
-    } catch (error) {
-      console.warn("Failed to parse YAML content:", error);
-      return null;
-    }
-  }).filter((data) => typeof data === "object" && data !== null);
-  if (dataObjects.length === 0) {
-    throw new Error("No valid YAML content found after parsing.");
-  }
-  const customizer = (objValue, srcValue) => {
-    if (Array.isArray(objValue)) {
-      return objValue.concat(srcValue);
-    }
-    return void 0;
-  };
-  const mergedData = dataObjects.reduce((acc, data) => merge(acc, data, customizer), {});
-  return new Promise((resolve, reject) => {
-    validate(mergedData, (errors, isValid) => {
-      if (!isValid) {
-        reject(
-          new Error(`Resume data failed schema validation: ${JSON.stringify(errors, null, 2)}`)
-        );
-      } else {
-        resolve(mergedData);
-      }
-    });
-  });
+// src/ats/skills/matcher.ts
+function isTokenChar(ch) {
+  if (ch >= "a" && ch <= "z") return true;
+  if (ch >= "A" && ch <= "Z") return true;
+  if (ch >= "0" && ch <= "9") return true;
+  return ch === "." || ch === "/" || ch === "-" || ch === "+" || ch === "#" || ch === "_";
 }
-
-// src/utils/config.ts
-import fs from "fs";
-import path from "path";
-import yaml from "yaml";
-import { z } from "zod";
-import merge2 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 merge2({}, defaultConfig, result.data.ats ?? {});
+function isLetter(ch) {
+  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z";
 }
-function effectiveWeight(checkId, defaultWeight, config) {
-  return config.weights.checks[checkId] ?? defaultWeight;
+function isDigit(ch) {
+  return ch >= "0" && ch <= "9";
 }
-
-// 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++;
+function trimTokenBoundary(tok) {
+  let start = 0;
+  let end = tok.length;
+  while (start < end) {
+    const ch = tok.charAt(start);
+    if (isLetter(ch) || isDigit(ch) || ch === "+" || ch === "#") break;
+    start++;
   }
-  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."]
-    };
+  while (end > start) {
+    const ch = tok.charAt(end - 1);
+    if (isLetter(ch) || isDigit(ch) || ch === "+" || ch === "#") break;
+    end--;
   }
-  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;
+  return start === 0 && end === tok.length ? tok : tok.slice(start, end);
 }
-
-// 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);
+function tokenize(text) {
+  const tokens = [];
+  const len = text.length;
+  let i = 0;
+  while (i < len) {
+    while (i < len && !isTokenChar(text.charAt(i))) i++;
+    const start = i;
+    while (i < len && isTokenChar(text.charAt(i))) i++;
+    if (i === start) continue;
+    const raw = trimTokenBoundary(text.slice(start, i));
+    if (!raw) continue;
+    let hasCore = false;
+    for (let k = 0; k < raw.length; k++) {
+      const ch = raw.charAt(k);
+      if (isLetter(ch) || isDigit(ch) || ch === "+" || ch === "#") {
+        hasCore = true;
+        break;
+      }
+    }
+    if (!hasCore) continue;
+    let letterCount = 0;
+    let upperCount = 0;
+    for (let k = 0; k < raw.length; k++) {
+      const ch = raw.charAt(k);
+      if (isLetter(ch)) {
+        letterCount++;
+        if (ch >= "A" && ch <= "Z") upperCount++;
+      }
+    }
+    const isAllUpper = letterCount >= 2 && upperCount === letterCount;
+    tokens.push({ raw, norm: raw.toLowerCase(), isAllUpper });
   }
-  const ms = merged.reduce((sum, [s, e]) => sum + (e - s), 0);
-  return ms / (1e3 * 60 * 60 * 24 * 365.25);
+  return tokens;
 }
-
-// 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;
+function phraseToTokens(phrase) {
+  return phrase.toLowerCase().split(/\s+/).map((t) => trimTokenBoundary(t)).filter(Boolean);
 }
-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 });
+function looksLikeAcronym(phrase) {
+  const trimmed = phrase.trim();
+  if (/\s/.test(trimmed)) return false;
+  if (trimmed.length < 2 || trimmed.length > 6) return false;
+  const letters = trimmed.replace(/[^a-zA-Z]/g, "");
+  return letters.length >= 2 && letters === letters.toUpperCase();
+}
+var SkillIndex = class {
+  skills;
+  byFirstToken = /* @__PURE__ */ new Map();
+  maxPhraseLen;
+  constructor(skills) {
+    this.skills = skills;
+    let maxLen = 1;
+    skills.forEach((skill, i) => {
+      for (const phrase of [skill.canonical, ...skill.aliases]) {
+        const tokens = phraseToTokens(phrase);
+        const first = tokens[0];
+        if (!first) continue;
+        maxLen = Math.max(maxLen, tokens.length);
+        const list = this.byFirstToken.get(first);
+        const entry = {
+          skillIdx: i,
+          phraseTokens: tokens,
+          requiresCaseMatch: looksLikeAcronym(phrase)
+        };
+        if (list) list.push(entry);
+        else this.byFirstToken.set(first, [entry]);
+      }
+    });
+    for (const list of this.byFirstToken.values()) {
+      list.sort((a, b) => b.phraseTokens.length - a.phraseTokens.length);
     }
+    this.maxPhraseLen = maxLen;
   }
-  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 || []);
+  /**
+   * Scan text for skills. Longest-match wins at each position, e.g. "Next.js"
+   * doesn't also fire "Next", and "Google Cloud Platform" doesn't also fire
+   * "Google".
+   *
+   * Returns a list of unique skills with occurrence counts.
+   */
+  scan(text) {
+    const tokens = tokenize(text);
+    const hits = /* @__PURE__ */ new Map();
+    let i = 0;
+    while (i < tokens.length) {
+      const head = tokens[i];
+      if (!head) break;
+      const bucket = this.byFirstToken.get(head.norm);
+      if (!bucket) {
+        i++;
+        continue;
+      }
+      let matched = false;
+      for (const cand of bucket) {
+        const len = cand.phraseTokens.length;
+        if (i + len > tokens.length) continue;
+        let ok = true;
+        for (let k = 0; k < len; k++) {
+          const tok = tokens[i + k];
+          if (!tok || tok.norm !== cand.phraseTokens[k]) {
+            ok = false;
+            break;
+          }
+        }
+        if (!ok) continue;
+        if (cand.requiresCaseMatch && !head.isAllUpper) continue;
+        hits.set(cand.skillIdx, (hits.get(cand.skillIdx) ?? 0) + 1);
+        i += len;
+        matched = true;
+        break;
+      }
+      if (!matched) i++;
+    }
+    const result = [];
+    for (const [skillIdx, count] of hits) {
+      const skill = this.skills[skillIdx];
+      if (!skill) continue;
+      result.push({ skill, occurrences: count });
+    }
+    result.sort((a, b) => {
+      if (a.skill.hot !== b.skill.hot) return a.skill.hot ? -1 : 1;
+      if (a.occurrences !== b.occurrences) return b.occurrences - a.occurrences;
+      return a.skill.canonical.localeCompare(b.skill.canonical);
+    });
+    return result;
   }
-  for (const p of resume.projects || []) {
-    if (p.description) parts.push(p.description);
-    parts.push(...p.highlights || []);
+  get size() {
+    return this.skills.length;
   }
-  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: []
-    };
+  get maxPhraseTokens() {
+    return this.maxPhraseLen;
   }
-  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;
-  }
+function buildSkillIndex(skills) {
+  return new SkillIndex(skills);
 }
-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
-];
 
 // data/skills/skills.json
 var skills_default = {
@@ -16407,1028 +15134,21 @@ var skills_default = {
   ]
 };
 
-// src/ats/skills/matcher.ts
-function isTokenChar(ch) {
-  if (ch >= "a" && ch <= "z") return true;
-  if (ch >= "A" && ch <= "Z") return true;
-  if (ch >= "0" && ch <= "9") return true;
-  return ch === "." || ch === "/" || ch === "-" || ch === "+" || ch === "#" || ch === "_";
-}
-function isLetter(ch) {
-  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z";
-}
-function isDigit(ch) {
-  return ch >= "0" && ch <= "9";
-}
-function trimTokenBoundary(tok) {
-  let start = 0;
-  let end = tok.length;
-  while (start < end) {
-    const ch = tok.charAt(start);
-    if (isLetter(ch) || isDigit(ch) || ch === "+" || ch === "#") break;
-    start++;
-  }
-  while (end > start) {
-    const ch = tok.charAt(end - 1);
-    if (isLetter(ch) || isDigit(ch) || ch === "+" || ch === "#") break;
-    end--;
-  }
-  return start === 0 && end === tok.length ? tok : tok.slice(start, end);
-}
-function tokenize(text) {
-  const tokens = [];
-  const len = text.length;
-  let i = 0;
-  while (i < len) {
-    while (i < len && !isTokenChar(text.charAt(i))) i++;
-    const start = i;
-    while (i < len && isTokenChar(text.charAt(i))) i++;
-    if (i === start) continue;
-    const raw = trimTokenBoundary(text.slice(start, i));
-    if (!raw) continue;
-    let hasCore = false;
-    for (let k = 0; k < raw.length; k++) {
-      const ch = raw.charAt(k);
-      if (isLetter(ch) || isDigit(ch) || ch === "+" || ch === "#") {
-        hasCore = true;
-        break;
-      }
-    }
-    if (!hasCore) continue;
-    let letterCount = 0;
-    let upperCount = 0;
-    for (let k = 0; k < raw.length; k++) {
-      const ch = raw.charAt(k);
-      if (isLetter(ch)) {
-        letterCount++;
-        if (ch >= "A" && ch <= "Z") upperCount++;
-      }
-    }
-    const isAllUpper = letterCount >= 2 && upperCount === letterCount;
-    tokens.push({ raw, norm: raw.toLowerCase(), isAllUpper });
-  }
-  return tokens;
-}
-function phraseToTokens(phrase) {
-  return phrase.toLowerCase().split(/\s+/).map((t) => trimTokenBoundary(t)).filter(Boolean);
-}
-function looksLikeAcronym(phrase) {
-  const trimmed = phrase.trim();
-  if (/\s/.test(trimmed)) return false;
-  if (trimmed.length < 2 || trimmed.length > 6) return false;
-  const letters = trimmed.replace(/[^a-zA-Z]/g, "");
-  return letters.length >= 2 && letters === letters.toUpperCase();
-}
-var SkillIndex = class {
-  skills;
-  byFirstToken = /* @__PURE__ */ new Map();
-  maxPhraseLen;
-  constructor(skills) {
-    this.skills = skills;
-    let maxLen = 1;
-    skills.forEach((skill, i) => {
-      for (const phrase of [skill.canonical, ...skill.aliases]) {
-        const tokens = phraseToTokens(phrase);
-        const first = tokens[0];
-        if (!first) continue;
-        maxLen = Math.max(maxLen, tokens.length);
-        const list = this.byFirstToken.get(first);
-        const entry = {
-          skillIdx: i,
-          phraseTokens: tokens,
-          requiresCaseMatch: looksLikeAcronym(phrase)
-        };
-        if (list) list.push(entry);
-        else this.byFirstToken.set(first, [entry]);
-      }
-    });
-    for (const list of this.byFirstToken.values()) {
-      list.sort((a, b) => b.phraseTokens.length - a.phraseTokens.length);
-    }
-    this.maxPhraseLen = maxLen;
-  }
-  /**
-   * Scan text for skills. Longest-match wins at each position, e.g. "Next.js"
-   * doesn't also fire "Next", and "Google Cloud Platform" doesn't also fire
-   * "Google".
-   *
-   * Returns a list of unique skills with occurrence counts.
-   */
-  scan(text) {
-    const tokens = tokenize(text);
-    const hits = /* @__PURE__ */ new Map();
-    let i = 0;
-    while (i < tokens.length) {
-      const head = tokens[i];
-      if (!head) break;
-      const bucket = this.byFirstToken.get(head.norm);
-      if (!bucket) {
-        i++;
-        continue;
-      }
-      let matched = false;
-      for (const cand of bucket) {
-        const len = cand.phraseTokens.length;
-        if (i + len > tokens.length) continue;
-        let ok = true;
-        for (let k = 0; k < len; k++) {
-          const tok = tokens[i + k];
-          if (!tok || tok.norm !== cand.phraseTokens[k]) {
-            ok = false;
-            break;
-          }
-        }
-        if (!ok) continue;
-        if (cand.requiresCaseMatch && !head.isAllUpper) continue;
-        hits.set(cand.skillIdx, (hits.get(cand.skillIdx) ?? 0) + 1);
-        i += len;
-        matched = true;
-        break;
-      }
-      if (!matched) i++;
-    }
-    const result = [];
-    for (const [skillIdx, count] of hits) {
-      const skill = this.skills[skillIdx];
-      if (!skill) continue;
-      result.push({ skill, occurrences: count });
-    }
-    result.sort((a, b) => {
-      if (a.skill.hot !== b.skill.hot) return a.skill.hot ? -1 : 1;
-      if (a.occurrences !== b.occurrences) return b.occurrences - a.occurrences;
-      return a.skill.canonical.localeCompare(b.skill.canonical);
-    });
-    return result;
-  }
-  get size() {
-    return this.skills.length;
-  }
-  get maxPhraseTokens() {
-    return this.maxPhraseLen;
-  }
-};
-function buildSkillIndex(skills) {
-  return new SkillIndex(skills);
-}
-
 // src/ats/skills/index.ts
 var cached = null;
 function getSkillIndex() {
   if (!cached) cached = buildSkillIndex(skills_default.skills);
   return cached;
 }
-
-// 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/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 tokenize2(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 }) => {
-  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 = extractJdTitle(jobDescription);
-  if (!resumeTitle || !jdTitle) {
-    return {
-      id: "title-alignment",
-      tier: "match",
-      weight: "high",
-      status: "warn",
-      score: 50,
-      message: "Could not extract title from JD or resume.",
-      hints: ["Set basics.label to your target title."]
-    };
-  }
-  const j = jaccard(tokenize2(resumeTitle), tokenize2(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 allMatchChecks = [hardSkillOverlap, titleAlignment, 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/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 = [];
-  if (options.jobDescription) {
-    const matchChecks = allMatchChecks.map(
-      (fn) => fn(resume, language, { jobDescription: options.jobDescription })
-    );
-    match = buildTier("match", matchChecks, cfg);
-    knockouts = extractKnockouts(resume, options.jobDescription);
-  }
-  const totalScore = computeTotalScore(
-    { parsing: parsing.score, match: match?.score, recruiter: recruiter.score },
-    cfg.weights.tiers
-  );
-  const rating = scoreToRating(totalScore, cfg.thresholds.rating);
-  const summary = generateSummary(totalScore, rating, !!options.jobDescription, knockouts.length);
-  return {
-    score: totalScore,
-    rating,
-    tiers: match ? { parsing, match, recruiter } : { parsing, recruiter },
-    knockouts,
-    summary
-  };
-}
-
-// src/utils/themeLoader.ts
-import { execFileSync } from "child_process";
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-function installTheme(packageName) {
-  try {
-    execFileSync("npm", ["install", packageName], {
-      stdio: ["inherit", "pipe", "pipe"],
-      encoding: "utf8"
-    });
-  } catch (error) {
-    throw new Error(`Failed to install ${packageName}: ${error.message}`);
-  }
-}
-function loadTheme(themeName, options) {
-  let jsonResumeThemeName;
-  let nativeThemeName;
-  const autoInstall = options?.autoInstall !== false;
-  try {
-    jsonResumeThemeName = themeName.startsWith("jsonresume-theme-") ? themeName : `jsonresume-theme-${themeName}`;
-    try {
-      return require2(jsonResumeThemeName);
-    } catch (_jsonResumeError) {
-      nativeThemeName = `@resuml/theme-${themeName}`;
-      try {
-        return require2(nativeThemeName);
-      } catch (_nativeError) {
-        if (!autoInstall) {
-          throw new Error(
-            `Theme package ${jsonResumeThemeName} or ${nativeThemeName} not found in node_modules.
-Please install the theme package manually.`
-          );
-        }
-        console.log(`\u{1F4E6} Theme ${jsonResumeThemeName} not found. Installing...`);
-        try {
-          installTheme(jsonResumeThemeName);
-          console.log(`\u2705 Successfully installed ${jsonResumeThemeName}`);
-          return require2(jsonResumeThemeName);
-        } catch (installError) {
-          throw new Error(
-            `Failed to auto-install theme ${jsonResumeThemeName}: ${installError.message}`
-          );
-        }
-      }
-    }
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("Failed to auto-install")) {
-      throw error;
-    }
-    throw new Error(`Theme package ${themeName} not found`);
-  }
-}
-
-// src/utils/resumeTemplate.ts
-function generateResumeYaml(name, email, label) {
-  return `# =============================================================================
-# Resume - Generated by resuml
-# Documentation: https://github.com/phoinixi/resuml
-# Schema: https://jsonresume.org/schema/
-# =============================================================================
-
-# --- Basic Information ---
-basics:
-  name: '${name}'
-  label: '${label}'
-  # image: 'https://example.com/photo.jpg'
-  email: '${email}'
-  # phone: '+1-555-123-4567'
-  # url: 'https://yourwebsite.com'
-  summary: >-
-    Write a short professional summary here.
-    This supports multi-line strings in YAML.
-  location:
-    # address: '123 Main Street'
-    # postalCode: '12345'
-    city: 'Your City'
-    countryCode: 'US'
-    # region: 'Your State'
-  profiles:
-    - network: 'LinkedIn'
-      username: 'your-username'
-      url: 'https://linkedin.com/in/your-username'
-    - network: 'GitHub'
-      username: 'your-username'
-      url: 'https://github.com/your-username'
-
-# --- Work Experience ---
-work:
-  - name: 'Company Name'
-    position: 'Job Title'
-    url: 'https://company.com'
-    startDate: '2020-01-01'
-    # endDate: '2023-12-31'  # Omit for current position
-    summary: 'Brief description of your role and responsibilities.'
-    highlights:
-      - 'Key achievement or responsibility'
-      - 'Another notable accomplishment'
-
-# --- Education ---
-education:
-  - institution: 'University Name'
-    url: 'https://university.edu'
-    area: 'Field of Study'
-    studyType: 'Bachelor of Science'
-    startDate: '2014-09-01'
-    endDate: '2018-06-01'
-    # score: '3.8'
-    courses:
-      - 'Relevant Course 1'
-      - 'Relevant Course 2'
-
-# --- Skills ---
-skills:
-  - name: 'Programming Languages'
-    level: 'Expert'
-    keywords:
-      - 'JavaScript'
-      - 'TypeScript'
-      - 'Python'
-  - name: 'Frameworks'
-    level: 'Advanced'
-    keywords:
-      - 'React'
-      - 'Node.js'
-
-# --- Projects ---
-# projects:
-#   - name: 'Project Name'
-#     description: 'Brief project description'
-#     highlights:
-#       - 'Key feature or result'
-#     keywords:
-#       - 'Technology Used'
-#     startDate: '2023-01-01'
-#     endDate: '2023-06-30'
-#     url: 'https://github.com/you/project'
-#     roles:
-#       - 'Developer'
-#     type: 'application'
-
-# --- Languages ---
-# languages:
-#   - language: 'English'
-#     fluency: 'Native speaker'
-#   - language: 'Spanish'
-#     fluency: 'Professional working proficiency'
-
-# --- Interests ---
-# interests:
-#   - name: 'Open Source'
-#     keywords:
-#       - 'Contributing'
-#       - 'Community'
-
-# --- References ---
-# references:
-#   - name: 'Jane Smith'
-#     reference: 'It was a pleasure working with...'
-
-# --- Awards ---
-# awards:
-#   - title: 'Award Name'
-#     date: '2023-01-01'
-#     awarder: 'Organization'
-#     summary: 'Description of the award'
-
-# --- Certificates ---
-# certificates:
-#   - name: 'Certificate Name'
-#     date: '2023-01-01'
-#     issuer: 'Issuing Organization'
-#     url: 'https://example.com/cert'
-
-# --- Publications ---
-# publications:
-#   - name: 'Publication Title'
-#     publisher: 'Publisher'
-#     releaseDate: '2023-01-01'
-#     url: 'https://example.com/publication'
-#     summary: 'Brief description'
-
-# --- Volunteer ---
-# volunteers:
-#   - organization: 'Organization Name'
-#     position: 'Volunteer Role'
-#     url: 'https://organization.com'
-#     startDate: '2022-01-01'
-#     summary: 'Description of volunteer work'
-#     highlights:
-#       - 'Notable contribution'
-`;
-}
-
-// src/utils/themeInfo.ts
-import { createRequire as createRequire2 } from "module";
-var KNOWN_THEMES = [
-  {
-    name: "stackoverflow",
-    pkg: "jsonresume-theme-stackoverflow",
-    description: "Stack Overflow inspired theme"
-  },
-  { name: "elegant", pkg: "jsonresume-theme-elegant", description: "Elegant and professional" },
-  { name: "react", pkg: "jsonresume-theme-react", description: "Built with React components" },
-  { name: "even", pkg: "jsonresume-theme-even", description: "Clean and minimal" },
-  { name: "kendall", pkg: "jsonresume-theme-kendall", description: "Simple and clean layout" },
-  { name: "macchiato", pkg: "jsonresume-theme-macchiato", description: "Beautiful and modern" },
-  { name: "flat", pkg: "jsonresume-theme-flat", description: "Flat design theme" },
-  { name: "class", pkg: "jsonresume-theme-class", description: "Classic professional look" },
-  { name: "short", pkg: "jsonresume-theme-short", description: "Compact single-page resume" },
-  { name: "spartan", pkg: "jsonresume-theme-spartan", description: "Minimalist Spartan design" },
-  { name: "paper", pkg: "jsonresume-theme-paper", description: "Paper-like clean design" },
-  { name: "onepage", pkg: "jsonresume-theme-onepage", description: "One page resume layout" }
-];
-function isThemeInstalled(pkg) {
-  try {
-    const req = createRequire2(process.cwd() + "/");
-    req.resolve(pkg);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getInstalledVersion(pkg) {
-  try {
-    const req = createRequire2(process.cwd() + "/");
-    const pkgJson = req(`${pkg}/package.json`);
-    return pkgJson.version ?? null;
-  } catch {
-    return null;
-  }
-}
-
-// src/ats/rubric.ts
-var rubric = [
-  // Parsing tier - Greenhouse-doc-grounded
-  {
-    id: "conventional-sections",
-    tier: "parsing",
-    weight: "high",
-    evidenceLevel: "evidence",
-    description: "Required JSON Resume sections (basics, work, education) are present.",
-    source: "https://support.greenhouse.io/hc/en-us/articles/200989175-Unsuccessful-resume-parse"
-  },
-  {
-    id: "date-format-consistency",
-    tier: "parsing",
-    weight: "medium",
-    evidenceLevel: "evidence",
-    description: "Dates use ISO-8601 (YYYY-MM-DD or YYYY-MM); no mixed formats; no >6mo gaps.",
-    source: "https://hireflow.net/blog/taleo-resume-parsing-problems-explained"
-  },
-  {
-    id: "contact-in-body",
-    tier: "parsing",
-    weight: "high",
-    evidenceLevel: "evidence",
-    description: "Email and phone present in basics block (parseable by Textkernel/Sovren).",
-    source: "https://developer.textkernel.com/tx-platform/v10/faq/"
-  },
-  {
-    id: "reverse-chron-order",
-    tier: "parsing",
-    weight: "medium",
-    evidenceLevel: "evidence",
-    description: "work[] and education[] sorted descending by startDate."
-  },
-  {
-    id: "education-complete",
-    tier: "parsing",
-    weight: "low",
-    evidenceLevel: "evidence",
-    description: "Each education entry has institution, area, and studyType."
-  },
-  {
-    id: "pdf-text-extractable",
-    tier: "parsing",
-    weight: "high",
-    evidenceLevel: "evidence",
-    description: "Rendered PDF body text is selectable (>=70% of resume word count extractable).",
-    source: "https://www.ashbyhq.com/product-updates/ai-assisted-application-review"
-  },
-  {
-    id: "pdf-size-under-2.5mb",
-    tier: "parsing",
-    weight: "medium",
-    evidenceLevel: "evidence",
-    description: "Rendered PDF is under 2.5 MB (Greenhouse documented limit).",
-    source: "https://support.greenhouse.io/hc/en-us/articles/200989175-Unsuccessful-resume-parse"
-  },
-  // Match tier - JD-aware
-  {
-    id: "hard-skill-overlap",
-    tier: "match",
-    weight: "high",
-    evidenceLevel: "evidence",
-    description: "Hard skill overlap with JD using bundled O*NET-trie skill index. ESCO migration tracked separately."
-  },
-  {
-    id: "title-alignment",
-    tier: "match",
-    weight: "high",
-    evidenceLevel: "evidence",
-    description: "Most-recent work[].position aligns with JD title via token Jaccard after stripping seniority modifiers."
-  },
-  {
-    id: "education-level",
-    tier: "match",
-    weight: "medium",
-    evidenceLevel: "evidence",
-    description: "Max studyType meets/exceeds JD education requirement (Bachelor/Master/PhD detection)."
-  },
-  {
-    id: "yoe-match",
-    tier: "match",
-    weight: "high",
-    evidenceLevel: "evidence",
-    description: "Total years of experience (overlap-merged from work[]) meets JD years requirement."
-  },
-  // Recruiter tier - Rezi/Teal/Enhancv-grounded numbers
-  {
-    id: "summary-length",
-    tier: "recruiter",
-    weight: "medium",
-    evidenceLevel: "convention",
-    description: "Professional summary 20-50 words / 2-4 sentences.",
-    source: "https://www.rezi.ai/rezi-docs/the-rezi-score-explained"
-  },
-  {
-    id: "action-verb-start",
-    tier: "recruiter",
-    weight: "medium",
-    evidenceLevel: "convention",
-    description: "Highlights start with an action verb."
-  },
-  {
-    id: "quantification-density",
-    tier: "recruiter",
-    weight: "high",
-    evidenceLevel: "convention",
-    description: "At least 50% of highlights include numbers/metrics."
-  },
-  {
-    id: "pronoun-leakage",
-    tier: "recruiter",
-    weight: "low",
-    evidenceLevel: "convention",
-    description: "Convention, not ATS: ATS does not filter on pronouns; this is recruiter style.",
-    source: "https://resume.io/blog/first-person-resume"
-  },
-  {
-    id: "bullets-per-role",
-    tier: "recruiter",
-    weight: "medium",
-    evidenceLevel: "convention",
-    description: "Each work entry has 3-6 highlights (10 for senior).",
-    source: "https://www.rezi.ai/rezi-docs/the-rezi-score-explained"
-  },
-  {
-    id: "word-count-total",
-    tier: "recruiter",
-    weight: "low",
-    evidenceLevel: "convention",
-    description: "Total resume body 400-800 words (1600 senior).",
-    source: "https://www.rezi.ai/rezi-docs/the-rezi-score-explained"
-  },
-  {
-    id: "highlight-length",
-    tier: "recruiter",
-    weight: "low",
-    evidenceLevel: "convention",
-    description: "Each highlight fits within two visual lines (~30 words)."
-  },
-  {
-    id: "has-linkedin",
-    tier: "recruiter",
-    weight: "low",
-    evidenceLevel: "convention",
-    description: "LinkedIn profile present in basics.profiles."
-  },
-  {
-    id: "skills-populated",
-    tier: "recruiter",
-    weight: "medium",
-    evidenceLevel: "convention",
-    description: "At least 3 skill categories with keywords."
-  }
-];
-var byId = new Map(rubric.map((r) => [r.id, r]));
-function getRubricEntry(id, opts = {}) {
-  const entry = byId.get(id);
-  if (!entry && opts.strict) throw new Error(`Unknown rubric id: ${id}`);
-  return entry;
-}
-function rubricByTier(tier) {
-  return rubric.filter((r) => r.tier === tier);
-}
-function listRubricMarkdown() {
-  const tiers = ["parsing", "match", "recruiter"];
-  const sections = tiers.map((t) => {
-    const entries = rubricByTier(t);
-    const lines = entries.map(
-      (e) => `- **${e.id}** (${e.weight}, ${e.evidenceLevel}): ${e.description}${e.source ? `
-  Source: ${e.source}` : ""}`
-    ).join("\n");
-    return `## Tier: ${t}
-
-${lines}`;
-  });
-  return ["# resuml ATS Rubric", "", ...sections].join("\n\n");
+function _resetSkillIndexCache() {
+  cached = null;
 }
 
 export {
   __export,
-  processResumeData,
-  loadConfig,
-  analyzeAts,
-  loadTheme,
-  generateResumeYaml,
-  KNOWN_THEMES,
-  isThemeInstalled,
-  getInstalledVersion,
-  getRubricEntry,
-  listRubricMarkdown
+  tokenize,
+  SkillIndex,
+  getSkillIndex,
+  _resetSkillIndexCache
 };
-//# sourceMappingURL=chunk-R4MD5YMV.js.map
+//# sourceMappingURL=chunk-QR77BRMN.js.map