How the ATS simulator actually works

// lib/parse-file.ts  (runs in the browser)
const PARSE_TIMEOUT_MS = 20_000

export async function parsePdfToText(file: File): Promise<string> {
  // The legacy build ships polyfills Chrome may lack. The modern build
  // crashes its worker there and getDocument() never settles.
  const pdfjsLib = await import('pdfjs-dist/legacy/build/pdf.mjs')
  pdfjsLib.GlobalWorkerOptions.workerSrc = new URL(
    'pdfjs-dist/legacy/build/pdf.worker.mjs',
    import.meta.url,
  ).toString()

  const doc = await pdfjsLib.getDocument({ data: await file.arrayBuffer() }).promise
  const pageTexts: string[] = []
  for (let n = 1; n <= doc.numPages; n++) {
    const content = await (await doc.getPage(n)).getTextContent()
    pageTexts.push(content.items.map((i) => ('str' in i ? i.str : '')).join(' '))
  }
  return pageTexts.join('\n\n').replace(/[ \t]+/g, ' ').trim()
}

export async function parseResumeFile(file: File): Promise<string> {
  const isPdf = file.type === 'application/pdf' || file.name.toLowerCase().endsWith('.pdf')
  const parsing = isPdf ? parsePdfToText(file) : parseDocxToText(file)

  // A worker that fails to start can leave parsing pending forever.
  // Race it against a timer so the UI can never freeze.
  let timeoutId: ReturnType<typeof setTimeout>
  const timeout = new Promise<never>((_, reject) => {
    timeoutId = setTimeout(() => reject(new Error('Reading your file took too long.')), PARSE_TIMEOUT_MS)
  })
  try {
    return await Promise.race([parsing, timeout])
  } finally {
    clearTimeout(timeoutId!)
  }
}

// lib/redact-pii.ts  (runs in the browser, BEFORE any network call)  - excerpt
export function redactResume(text: string): RedactResumeResult {
  const lines = text.split('\n').map((line) => line.replace(/\s+/g, ' ').trim())
  const headings = lines.map(detectHeading) // "Experience", "References", ...

  // 1. Everything before the first section heading is the header block.
  const firstSection = headings.findIndex((kind) => kind !== null)
  const preSection = lines.slice(0, firstSection)
  const nameTerms = namesFrom(preSection)
  const out: string[] = []
  if (preSection.some(Boolean)) out.push('[REDACTED_HEADER]') // one token: size does not leak

  for (let i = firstSection; i < lines.length; i++) {
    const heading = headings[i]
    if (heading === 'references' || heading === 'personal') {
      removedBlock = heading            // 2. drop the whole section
      out.push('[REDACTED_' + heading.toUpperCase() + ']')
      continue
    }
    if (removedBlock) continue

    if (section === 'experience' && entry.mode === 'header') {
      // 3. job header lines keep title + dates only
      const result = redactJobHeaderLine(lines[i], matches)
      companyTerms.push(...result.companyNames.flatMap(companyVariants))
      out.push(result.line)
      continue
    }
    out.push(redactEntities(lines[i], matches)) // email, phone, links, address...
  }

  // 4. Names and employers can reappear in task bullets: scrub them everywhere.
  let scrubbed = scrubGlobally(out, nameTerms, 'name', matches)
  scrubbed = scrubGlobally(scrubbed, companyTerms, 'company', matches)
  // 5. Remove leftover header/footer lines such as "Name | Page 2".
  return finish(scrubbed.map((l) => (isFooterLine(l) ? '[REDACTED_FOOTER]' : l)))
}

// "Acme Technologies Pty Ltd" is also written "Acme Technologies" and "Acme".
function companyVariants(name: string): string[] {
  const withoutLegal = stripLegalSuffix(name)
  const core = stripGenericCompanyWords(withoutLegal)
  return [name, withoutLegal, core]
}

// Unsure whether a header segment is a job title? Treat it as an employer.
function classifySegment(text: string): 'title' | 'company' {
  const isTitle = !LEGAL_SUFFIX.test(text) && TITLE_WORDS.test(text) && wordCount(text) <= 6
  return isTitle ? 'title' : 'company'
}

// app/api/extract/route.ts  (ValidateCV server -> Vercel AI Gateway)
const resumeSchema = z.object({
  headline: z.string(),
  roles: z.array(z.object({
    title: z.string(),
    employer: z.string(),
    startDate: z.string(),   // "2021-03" or "Mar 2021"
    endDate: z.string(),     // "2023-08" or "Present"
    bullets: z.array(z.string()),
  })),
  skills: z.array(z.string()),
  totalYearsExperience: z.number(),
})

const jobDescriptionSchema = z.object({
  title: z.string(),
  mustHave: z.array(requirementSchema),
  niceToHave: z.array(requirementSchema),
  knockouts: z.array(z.string()),   // hard filters: visa, clearance, mandatory degree
  keywords: z.array(z.string()),
})

// The two extractions are independent, so they run in parallel.
const [jdResult, resumeResult] = await Promise.all([
  generateObject({
    model: 'openai/gpt-4o-mini',   // plain Gateway model ID, no provider SDK
    schema: jobDescriptionSchema,
    temperature: 0,                // parsing task: same input -> same output
    prompt: '<extraction instructions + redacted job description>',
  }),
  generateObject({
    model: 'openai/gpt-4o-mini',
    schema: resumeSchema,
    temperature: 0,
    prompt: '<extraction instructions + redacted resume text>',
  }),
])

// app/analysis/page.tsx  (the only network call the free report makes)
const response = await fetch('/api/extract', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ resumeText, jobDescriptionText }),  // both already redacted
})
const data = await response.json()   // { resume, jobDescription }  structured JSON

// Everything after this line (Stages 1-3) is computed locally in the browser.

// lib/analysis.ts  ->  analyzeParsing()   (pure TypeScript, no network)
const STATUS_SCORE = { pass: 100, warning: 60, fail: 20 }

// Multi-column PDFs extract as interleaved text: long lines or big
// whitespace gaps. We can't see the layout, so we detect its symptoms.
const lines = resumeText.split('\n').filter((line) => line.trim().length > 0)
const suspiciousLines = lines.filter((line) => /\s{4,}/.test(line) || line.length > 220).length
const columnStatus =
  lines.length === 0 ? 'warning'
  : suspiciousLines / lines.length > 0.15 ? 'warning'
  : 'pass'

// Section headers are matched by intent, not exact wording.
const expectedHeaders = [
  { label: 'Summary',    pattern: /\b(summary|profile|objective)\b/i },
  { label: 'Experience', pattern: /\b(experience|employment|work history)\b/i },
  { label: 'Education',  pattern: /\beducation\b/i },
  { label: 'Skills',     pattern: /\bskills\b/i },
]
const found = expectedHeaders.filter(({ pattern }) => pattern.test(resumeText))
const headerStatus = found.length >= 3 ? 'pass' : found.length === 2 ? 'warning' : 'fail'

// Final score: unweighted mean of the five check scores.
const score = Math.round(
  checklist.reduce((sum, item) => sum + STATUS_SCORE[item.status], 0) / checklist.length,
)

// lib/analysis.ts  ->  analyzeExperience()   (pure TypeScript)
function parseMonthDate(value: string): number | null {
  if (/present|current/i.test(value)) return Date.now()
  const iso = value.match(/(\d{4})-(\d{2})/)
  if (iso) return new Date(Number(iso[1]), Number(iso[2]) - 1, 1).getTime()
  const parsed = Date.parse(value)               // "Mar 2021", "March 2021"...
  return Number.isNaN(parsed) ? null : parsed    // unparseable -> skip, never guess
}

// Roles arrive newest-first. Compare each role's start with the END of the
// role before it; a hole of 3+ months is flagged (first gap only).
for (let i = 0; i < roles.length - 1; i++) {
  const earlierRoleEnd = parseMonthDate(roles[i + 1].endDate)
  const laterRoleStart = parseMonthDate(roles[i].startDate)
  if (earlierRoleEnd === null || laterRoleStart === null) continue

  const gapMonths = Math.round((laterRoleStart - earlierRoleEnd) / (1000 * 60 * 60 * 24 * 30))
  if (gapMonths >= 3) {
    gap = { detected: true, /* duration, period, between */ }
    break
  }
}
// The gap is advisory. It is displayed, but never subtracted from a score.

// lib/analysis.ts  ->  matchRequirements()   (pure TypeScript)
const STOPWORDS = new Set(['and', 'the', 'with', 'for', 'years', 'related', 'etc', 'plus'])

function normalizeTokens(value: string): string[] {
  return value
    .toLowerCase()
    .replace(/[^a-z0-9+\s]/g, ' ')   // keep "+" so c++ and "c#"-style terms survive
    .split(/\s+/)
    .filter((token) => token.length > 2)
}

export function matchRequirements(resume: ExtractedResume, requirements: ExtractedRequirement[]) {
  // One searchable corpus: headline + skills + every role title and bullet.
  const corpus = [
    resume.headline,
    resume.skills.join(' '),
    ...resume.roles.flatMap((role) => [role.title, ...role.bullets]),
  ].join(' ').toLowerCase()

  return requirements.map((requirement) => {
    const tokens = normalizeTokens(requirement.label).filter((t) => !STOPWORDS.has(t))

    const directMatch = corpus.includes(requirement.label.toLowerCase())
    const tokenMatch = tokens.length > 0 && tokens.some((token) => corpus.includes(token))

    return { skill: requirement.label, matched: directMatch || tokenMatch }
  })
}

// app/api/assess/route.ts  (Stage 4: LLM judges, TypeScript does the maths)
const requirementJudgementSchema = z.object({
  requirement: z.string(),
  // 0 = no evidence, 1 = weak, 2 = solid match, 3 = meets or exceeds
  score: z.number().int().min(0).max(3),
  evidenceQuote: z.string(),   // verbatim resume quote, or "" when score is 0
  reasoning: z.string(),       // one sentence
})

const { object } = await generateObject({
  model: 'openai/gpt-4o-mini',
  schema: z.object({ requirementJudgements: z.array(requirementJudgementSchema) }),
  temperature: 0,
  prompt: '<rubric + requirements + redacted resume>',
})

// The model NEVER computes the percentage. Must-haves weigh double.
const mustHaveLabels = new Set(jobDescription.mustHave.map((r) => r.label))
let weightedTotal = 0
let weightSum = 0
for (const judgement of object.requirementJudgements) {
  const weight = mustHaveLabels.has(judgement.requirement) ? 2 : 1
  weightedTotal += judgement.score * weight
  weightSum += 3 * weight          // 3 is the maximum score per requirement
}
const overallScore = weightSum > 0 ? Math.round((weightedTotal / weightSum) * 100) : 0