@iflow-mcp/jakeliume-webpeel 0.22.0

package/dist/core/jobs.js

@@ -0,0 +1,634 @@
+/**
+ * Jobs extraction module — turns job board pages into structured JSON
+ *
+ * Two-phase pipeline:
+ *   Phase A (Search): Fetch a job search URL → parse markdown → extract job cards
+ *   Phase B (Details): For top N results, fetch each detail URL → extract full description
+ *
+ * Supports LinkedIn, Glassdoor, and Indeed out of the box.
+ * Call `cleanup()` from the main webpeel export when you are done fetching.
+ */
+import { peel } from '../index.js';
+function detectSource(url) {
+    const h = url.toLowerCase();
+    if (h.includes('linkedin.com'))
+        return 'linkedin';
+    if (h.includes('glassdoor.com'))
+        return 'glassdoor';
+    if (h.includes('indeed.com'))
+        return 'indeed';
+    if (h.includes('upwork.com'))
+        return 'upwork';
+    return 'generic';
+}
+function stealthNeeded(src) {
+    return src === 'indeed' || src === 'glassdoor' || src === 'upwork';
+}
+function buildSearchUrl(src, kw, loc) {
+    switch (src) {
+        case 'linkedin':
+            return `https://www.linkedin.com/jobs/search/?keywords=${enc(kw)}&location=${enc(loc)}`;
+        case 'glassdoor':
+            return `https://www.glassdoor.com/Job/jobs.htm?sc.keyword=${enc(kw)}&locT=C&locId=1132348&sc.location=${enc(loc)}`;
+        case 'indeed':
+            return `https://www.indeed.com/jobs?q=${enc(kw)}&l=${enc(loc)}`;
+        case 'upwork':
+            return `https://www.upwork.com/nx/search/jobs/?q=${enc(kw)}&sort=recency`;
+        default:
+            throw new Error('Cannot build URL for generic source — provide a url');
+    }
+}
+const enc = encodeURIComponent;
+function clean(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/…/g, '…')
+        .replace(/ /g, ' ')
+        .replace(/'/g, "'")
+        .replace(/"/g, '"')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function absUrl(href, base) {
+    try {
+        return new URL(href, base).href;
+    }
+    catch {
+        return href;
+    }
+}
+function findSalary(text) {
+    const m = text.match(/\$[\d,]+(?:\.\d+)?(?:\s*[-–]\s*\$[\d,]+(?:\.\d+)?)?(?:\s*(?:a\s+year|per\s+hour|an\s+hour|\/hr|\/yr|K(?:\s|$)))?/i);
+    return m ? m[0].trim() : undefined;
+}
+function findDate(text) {
+    const m = text.match(/(\d+[dhm])\b/) || text.match(/(\d+\s+(?:day|week|month|hour|minute)s?\s+ago)/i);
+    return m ? m[1].trim() : undefined;
+}
+function hasRemote(text) {
+    return /\bremote\b/i.test(text);
+}
+/** Simple concurrency limiter — runs at most `n` tasks in parallel. */
+async function pLimited(tasks, n) {
+    const results = new Array(tasks.length);
+    let cursor = 0;
+    async function worker() {
+        while (cursor < tasks.length) {
+            const idx = cursor++;
+            results[idx] = await tasks[idx]();
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(n, tasks.length) }, () => worker()));
+    return results;
+}
+function parseTotalFromHeading(content) {
+    const m = content.match(/^#\s+([\d,]+)\+?\s+/m);
+    return m ? parseInt(m[1].replace(/,/g, ''), 10) : 0;
+}
+// ── LinkedIn Parser ────────────────────────────────────────────────────
+function parseLinkedIn(content, searchUrl, limit) {
+    const jobs = [];
+    const totalFound = parseTotalFromHeading(content);
+    // Each card starts with "- [Title](url)" in the markdown list
+    const blocks = content.split(/\n-\s+\[/).slice(1);
+    for (const block of blocks) {
+        if (jobs.length >= limit)
+            break;
+        // Link: we stripped the leading "- [", so block starts with "Title](url)…"
+        const lm = block.match(/^([^\]]+)\]\(([^)]+)\)/);
+        if (!lm)
+            continue;
+        const detailUrl = lm[2];
+        if (!detailUrl.includes('linkedin.com/jobs/view/'))
+            continue;
+        // Title from ### heading (preferred) or link text
+        const hm = block.match(/###\s+(.+)/);
+        const title = clean(hm ? hm[1] : lm[1]);
+        if (!title)
+            continue;
+        // Company from #### [Company](url) or #### Company
+        const cm = block.match(/####\s+\[([^\]]+)\]/) || block.match(/####\s+(.+)/);
+        const company = cm ? clean(cm[1]) : '';
+        // Scan remaining lines for location + date
+        // Only look at lines AFTER the #### company heading
+        let location = '';
+        let postedAt;
+        let pastCompany = false;
+        for (const raw of block.split('\n')) {
+            const l = raw.trim();
+            if (!l)
+                continue;
+            // Skip everything until we're past the company heading
+            if (l.startsWith('####')) {
+                pastCompany = true;
+                continue;
+            }
+            if (!pastCompany)
+                continue;
+            if (l.startsWith('#') || l.startsWith('[') || l.startsWith('-') || l === 'Actively Hiring' || l === 'Promoted')
+                continue;
+            // Skip lines that contain URLs
+            if (l.includes('http://') || l.includes('https://'))
+                continue;
+            // Date-only line
+            const dateCandidate = findDate(l);
+            // Location line that may have date appended: "New York, NY 2 weeks ago"
+            if (!location && /^[A-Z][a-z]+.*,\s*[A-Z]/.test(l)) {
+                // Split off trailing date if present
+                const dateInLine = findDate(l);
+                if (dateInLine) {
+                    postedAt = dateInLine;
+                    location = clean(l.replace(/\d+\s+(?:week|day|month|hour|minute)s?\s+ago/i, '').replace(/\d+[dhm]\s*$/i, ''));
+                }
+                else {
+                    location = clean(l);
+                }
+                continue;
+            }
+            if (dateCandidate && l.length < 30) {
+                postedAt = dateCandidate;
+            }
+        }
+        jobs.push({
+            title, company, location,
+            salary: findSalary(block),
+            remote: hasRemote(block),
+            postedAt,
+            detailUrl: absUrl(detailUrl, searchUrl),
+            source: 'linkedin',
+        });
+    }
+    return { jobs, totalFound: totalFound || jobs.length };
+}
+// ── Glassdoor Parser ───────────────────────────────────────────────────
+function parseGlassdoor(content, searchUrl, limit) {
+    const jobs = [];
+    const totalFound = parseTotalFromHeading(content);
+    // Each card is a top-level list item: company, rating, [Title](url), location, salary, snippet, skills, date
+    const blocks = content.split(/\n-\s+/).slice(1);
+    for (const block of blocks) {
+        if (jobs.length >= limit)
+            break;
+        const lines = block.split('\n').map(l => l.trim()).filter(Boolean);
+        if (lines.length < 2)
+            continue;
+        // Job title link
+        const lm = block.match(/\[([^\]]+)\]\((https?:\/\/[^\s)]*glassdoor\.com\/job-listing\/[^)]+)\)/);
+        if (!lm)
+            continue;
+        const title = clean(lm[1]);
+        const detailUrl = lm[2];
+        // Company + rating come before the link
+        let company = '';
+        let rating;
+        for (const l of lines) {
+            if (l.includes('[') && l.includes('glassdoor.com'))
+                break;
+            const rm = l.match(/^(\d\.\d)$/);
+            if (rm) {
+                rating = parseFloat(rm[1]);
+                continue;
+            }
+            if (!company && l.length > 1 && !/^\d/.test(l))
+                company = clean(l);
+        }
+        // Fields after the title link
+        let location = '';
+        let salary;
+        let snippet;
+        let skills;
+        let postedAt;
+        let pastLink = false;
+        for (const l of lines) {
+            if (l.includes(title) || l.includes('glassdoor.com/job-listing/')) {
+                pastLink = true;
+                continue;
+            }
+            if (!pastLink)
+                continue;
+            const sm = l.match(/\*\*Skills?:\*\*\s*(.+)/i);
+            if (sm) {
+                skills = sm[1].split(',').map(s => s.trim()).filter(Boolean);
+                continue;
+            }
+            if (/^\d+[dwm]$/.test(l)) {
+                postedAt = l;
+                continue;
+            }
+            if (!salary && /\$/.test(l)) {
+                salary = findSalary(l) || clean(l);
+                continue;
+            }
+            if (!location && /^[A-Z][a-z]+.*,\s*[A-Z]{2}/.test(l)) {
+                location = clean(l);
+                continue;
+            }
+            if (!snippet && l.length > 40 && !l.startsWith('**'))
+                snippet = clean(l);
+        }
+        jobs.push({
+            title, company, location, salary,
+            remote: hasRemote(block), postedAt,
+            detailUrl: absUrl(detailUrl, searchUrl),
+            snippet, skills, rating,
+            source: 'glassdoor',
+        });
+    }
+    return { jobs, totalFound: totalFound || jobs.length };
+}
+// ── Indeed Parser ──────────────────────────────────────────────────────
+function parseIndeed(content, _searchUrl, limit) {
+    const jobs = [];
+    // Indeed markdown: job listings as list items with [Title](url), company, location, salary
+    // Also try HTML attribute patterns in case raw HTML leaks through
+    const htmlJobRe = /id="job_([a-f0-9]+)"[^>]*>.*?<span\s+title="([^"]+)"[^>]*>[^<]*<\/span>/gs;
+    const htmlJobs = [...content.matchAll(htmlJobRe)];
+    if (htmlJobs.length > 0) {
+        // HTML mode — parse HTML attributes directly
+        const companyRe = /data-testid="company-name"[^>]*>([^<]+)<\/span>/g;
+        const locRe = /data-testid="text-location"[^>]*>([^<]+)<\/div>/g;
+        const cm = [...content.matchAll(companyRe)];
+        const lm = [...content.matchAll(locRe)];
+        for (let i = 0; i < htmlJobs.length && jobs.length < limit; i++) {
+            const jk = htmlJobs[i][1];
+            const title = clean(htmlJobs[i][2]);
+            jobs.push({
+                title,
+                company: cm[i] ? clean(cm[i][1]) : '',
+                location: lm[i] ? clean(lm[i][1]) : '',
+                salary: findSalary(content.slice(htmlJobs[i].index || 0, (htmlJobs[i + 1]?.index) || content.length)),
+                remote: false,
+                detailUrl: `https://www.indeed.com/viewjob?jk=${jk}`,
+                source: 'indeed',
+            });
+        }
+    }
+    else {
+        // Markdown mode — parse the converted markdown output
+        // Indeed search results have title links followed by company, location, salary lines
+        const blocks = content.split(/\n-\s+/).slice(1);
+        for (const block of blocks) {
+            if (jobs.length >= limit)
+                break;
+            // Title link: [Job Title](url)
+            const lm = block.match(/\[([^\]]+)\]\((https?:\/\/[^\s)]*indeed\.com\/[^)]*(?:viewjob|rc\/clk)[^)]*)\)/);
+            if (!lm)
+                continue;
+            const title = clean(lm[1]);
+            let detailUrl = lm[2];
+            // Extract jk parameter from URL for clean detail URL
+            const jkMatch = detailUrl.match(/[?&]jk=([a-f0-9]+)/);
+            if (jkMatch)
+                detailUrl = `https://www.indeed.com/viewjob?jk=${jkMatch[1]}`;
+            // Parse remaining lines for company, location, salary
+            const lines = block.split('\n').map(l => l.trim()).filter(Boolean);
+            let company = '';
+            let location = '';
+            let salary;
+            for (const l of lines) {
+                if (l.includes(title) || l.includes('indeed.com'))
+                    continue;
+                if (!salary) {
+                    const s = findSalary(l);
+                    if (s) {
+                        salary = s;
+                        continue;
+                    }
+                }
+                // Company is usually the first non-title, non-link, non-salary text
+                if (!company && l.length > 2 && !l.startsWith('[') && !l.startsWith('#') && !/^\d/.test(l)) {
+                    company = clean(l);
+                    continue;
+                }
+                // Location matches City, ST pattern
+                if (!location && /^[A-Z][a-z]+.*,\s*[A-Z]{2}/.test(l)) {
+                    location = clean(l);
+                }
+            }
+            if (title) {
+                jobs.push({
+                    title, company, location, salary,
+                    remote: hasRemote(block),
+                    detailUrl,
+                    source: 'indeed',
+                });
+            }
+        }
+    }
+    const totalRe = content.match(/(?:of|about)\s+([\d,]+)\s+jobs/i) || content.match(/([\d,]+)\s+jobs/i);
+    const totalFound = totalRe ? parseInt(totalRe[1].replace(/,/g, ''), 10) : jobs.length;
+    return { jobs, totalFound };
+}
+// ── Upwork Parser ──────────────────────────────────────────────────────
+/**
+ * Parse Upwork job search results from converted markdown.
+ *
+ * Upwork search URL pattern:
+ *   https://www.upwork.com/nx/search/jobs/?q=AI+engineer&sort=recency
+ *
+ * The markdown representation varies; we handle both list-item blocks and
+ * heading-separated blocks.
+ */
+function parseUpwork(content, searchUrl, limit) {
+    const jobs = [];
+    // Total count — Upwork often shows "X+ jobs found"
+    const totalMatch = content.match(/(\d[\d,]*)\+?\s+(?:jobs?|results?)\s+(?:found|available|match)/i);
+    const totalFound = totalMatch ? parseInt(totalMatch[1].replace(/,/g, ''), 10) : 0;
+    // Split into job blocks — each job typically starts with a link to /jobs/
+    // Pattern: [Job Title](https://www.upwork.com/jobs/...)
+    const jobLinkRe = /\[([^\]]+)\]\((https:\/\/www\.upwork\.com\/jobs\/[^)]+)\)/g;
+    const titleMatches = [...content.matchAll(jobLinkRe)];
+    if (titleMatches.length === 0) {
+        // Fallback: try /nx/jobs/ links (search page variant)
+        const altLinkRe = /\[([^\]]+)\]\((https:\/\/www\.upwork\.com\/(?:nx\/)?(?:jobs?|freelance-jobs?)[^)]*)\)/g;
+        const altMatches = [...content.matchAll(altLinkRe)];
+        if (altMatches.length === 0) {
+            return { jobs, totalFound };
+        }
+        titleMatches.push(...altMatches);
+    }
+    for (let i = 0; i < titleMatches.length && jobs.length < limit; i++) {
+        const match = titleMatches[i];
+        const title = clean(match[1]);
+        const detailUrl = absUrl(match[2], searchUrl);
+        // Extract the block of text between this match and the next
+        const blockStart = match.index ?? 0;
+        const blockEnd = (titleMatches[i + 1]?.index) ?? content.length;
+        const block = content.slice(blockStart, blockEnd);
+        // Budget / hourly rate — look for $ amounts near keywords
+        let budget;
+        const budgetMatch = block.match(/\$[\d,]+(?:\.\d+)?(?:\s*[-–]\s*\$[\d,]+(?:\.\d+)?)?\s*(?:\/\s*hr|per\s+hour|hourly)?/i) ||
+            block.match(/(?:budget|fixed[\s-]?price|hourly\s+rate)[:\s]+\$[\d,]+(?:\s*[-–]\s*\$[\d,]+)?/i);
+        if (budgetMatch)
+            budget = budgetMatch[0].trim();
+        // Job type
+        let jobType;
+        if (/\bhourly\b/i.test(block))
+            jobType = 'hourly';
+        else if (/\bfixed[\s-]?price\b/i.test(block))
+            jobType = 'fixed-price';
+        // Experience level
+        let experienceLevel;
+        const expMatch = block.match(/\b(entry[- ]?level|intermediate|expert|beginner)\b/i);
+        if (expMatch)
+            experienceLevel = expMatch[1];
+        // Client rating
+        let clientRating;
+        const ratingMatch = block.match(/(\d+(?:\.\d+)?)\s*(?:of\s+5\s+)?(?:stars?|★)/i);
+        if (ratingMatch) {
+            const r = parseFloat(ratingMatch[1]);
+            if (r >= 0 && r <= 5)
+                clientRating = r;
+        }
+        // Client spend
+        let clientSpend;
+        const spendMatch = block.match(/\$[\d,.]+[KkMm]?\+?\s*(?:spent|total\s+spent)/i);
+        if (spendMatch)
+            clientSpend = spendMatch[0].replace(/\s*(?:spent|total\s+spent)/i, '').trim();
+        // Skills (look for "Skills:" or comma-separated tech terms)
+        let skills;
+        const skillsMatch = block.match(/(?:skills?|tags?)[:\s]+([^\n]+)/i);
+        if (skillsMatch) {
+            skills = skillsMatch[1].split(/[,;]/).map((s) => s.trim()).filter((s) => s.length > 1 && s.length < 40);
+        }
+        // Posted time
+        const postedAt = findDate(block);
+        // Description snippet — first substantial non-metadata line after the title
+        let snippet;
+        const lines = block.split('\n').map((l) => l.trim()).filter(Boolean);
+        for (const line of lines) {
+            if (line === title)
+                continue;
+            if (line.startsWith('[') || line.startsWith('http'))
+                continue;
+            if (/^\$/.test(line) || /^\d+\s*(?:star|hour|day|week|month|review)/i.test(line))
+                continue;
+            if (line.length > 60) {
+                snippet = clean(line).slice(0, 200);
+                break;
+            }
+        }
+        if (!title)
+            continue;
+        jobs.push({
+            title,
+            company: '', // Upwork jobs don't surface a company on the search page
+            location: 'Remote', // Upwork is inherently remote
+            remote: true,
+            salary: budget, // Reuse salary field for budget display
+            budget,
+            jobType,
+            experienceLevel,
+            clientRating,
+            clientSpend,
+            skills,
+            snippet,
+            postedAt,
+            detailUrl,
+            source: 'upwork',
+        });
+    }
+    return { jobs, totalFound: totalFound || jobs.length };
+}
+// Match both heading markers (## Section) and bold markers (**Section:**)
+const SEC_DESC = /(?:#{1,4}\s*|^\*\*)(?:(?:full\s+)?job\s+description|about\s+(?:the\s+)?(?:role|position|job|opportunity)|overview|summary)\*?\*?:?\s*$/im;
+const SEC_REQ = /(?:#{1,4}\s*|^\*\*)(?:requirements?|qualifications?|what\s+(?:you(?:'ll)?\s+)?(?:need|bring)|minimum\s+qualifications?|must\s+have|what\s+we(?:'re)?\s+look(?:ing)?\s+for|nice\s+to\s+have)\*?\*?:?\s*$/im;
+const SEC_RESP = /(?:#{1,4}\s*|^\*\*)(?:responsibilities|what\s+you(?:'ll)?\s+do|duties|key\s+responsibilities|your\s+role|in\s+this\s+role)\*?\*?:?\s*$/im;
+const SEC_BEN = /(?:#{1,4}\s*|^\*\*)(?:benefits?|perks?|what\s+we\s+offer|compensation(?:\s+and\s+benefits)?|why\s+(?:join|work)|our\s+offer)\*?\*?:?\s*$/im;
+function extractBullets(text) {
+    const out = [];
+    for (const line of text.split('\n')) {
+        const t = line.replace(/^[-*•]\s+/, '').trim();
+        if (t.length > 5)
+            out.push(t);
+    }
+    return out.length > 0 ? out : undefined;
+}
+function splitSections(content) {
+    const res = {};
+    let cur = null;
+    let buf = [];
+    function flush() {
+        const txt = buf.join('\n').trim();
+        buf = [];
+        if (!txt || !cur)
+            return;
+        if (cur === 'desc')
+            res.description = txt;
+        else if (cur === 'req')
+            res.requirements = extractBullets(txt);
+        else if (cur === 'resp')
+            res.responsibilities = extractBullets(txt);
+        else if (cur === 'ben')
+            res.benefits = extractBullets(txt);
+    }
+    for (const line of content.split('\n')) {
+        if (SEC_DESC.test(line)) {
+            flush();
+            cur = 'desc';
+            continue;
+        }
+        if (SEC_REQ.test(line)) {
+            flush();
+            cur = 'req';
+            continue;
+        }
+        if (SEC_RESP.test(line)) {
+            flush();
+            cur = 'resp';
+            continue;
+        }
+        if (SEC_BEN.test(line)) {
+            flush();
+            cur = 'ben';
+            continue;
+        }
+        if (cur && /^#{1,4}\s+/.test(line)) {
+            flush();
+            cur = null;
+            continue;
+        }
+        if (cur)
+            buf.push(line);
+    }
+    flush();
+    if (!res.description)
+        res.description = content.slice(0, 2000).trim();
+    return res;
+}
+/** Strip trailing noise sections (similar jobs, people also viewed, etc.) */
+function stripDetailNoise(content) {
+    const cutPatterns = [
+        /^#{1,3}\s*similar\s+jobs/im,
+        /^#{1,3}\s*people\s+also\s+viewed/im,
+        /^#{1,3}\s*similar\s+searches/im,
+        /^#{1,3}\s*explore\s+collaborative/im,
+        /^#{1,3}\s*seniority\s+level/im,
+        /^#{1,3}\s*company\s+and\s+salary/im,
+        /^#{1,3}\s*career\s+guide/im,
+        /^#{1,3}\s*jobs\s+with\s+similar/im,
+        /^#{1,3}\s*similar\s+jobs?\s+nearby/im,
+    ];
+    let result = content;
+    for (const pattern of cutPatterns) {
+        const m = pattern.exec(result);
+        if (m && m.index !== undefined && m.index > result.length * 0.3) {
+            result = result.slice(0, m.index).trim();
+        }
+    }
+    return result;
+}
+function parseJobDetail(content, card) {
+    // Strip noise sections before parsing
+    const cleaned = stripDetailNoise(content);
+    const sections = splitSections(cleaned);
+    const empMatch = cleaned.match(/\b(full[- ]?time|part[- ]?time|contract|internship|freelance|temporary)\b/i);
+    const expMatch = cleaned.match(/\b(entry[- ]?level|mid[- ]?level|senior|lead|principal|staff|junior|intern)\b/i);
+    const applyMatch = cleaned.match(/\[(?:apply|submit)[^\]]*\]\(([^)]+)\)/i) ||
+        cleaned.match(/href="([^"]*(?:apply|submit|careers)[^"]*)"/i);
+    // Salary from "## Pay found in job post" or "### Base pay range" sections
+    const salary = card.salary || findSalary(cleaned);
+    return {
+        ...card,
+        salary: salary || card.salary,
+        description: sections.description || cleaned.slice(0, 3000),
+        requirements: sections.requirements,
+        responsibilities: sections.responsibilities,
+        benefits: sections.benefits,
+        applyUrl: applyMatch ? applyMatch[1] : undefined,
+        employmentType: empMatch ? empMatch[1].toLowerCase().replace(/\s+/g, '-') : undefined,
+        experienceLevel: expMatch ? expMatch[1] : undefined,
+    };
+}
+// ── Main ───────────────────────────────────────────────────────────────
+/**
+ * Search job boards and return structured results.
+ *
+ * Uses `peel()` internally so all smart-escalation / stealth logic applies.
+ * Call `cleanup()` from the main webpeel export when you're done with all
+ * fetching (this module does **not** call it automatically because the
+ * browser instance is shared across the library).
+ */
+export async function searchJobs(options) {
+    const startTime = Date.now();
+    const { url, keywords = '', location = '', source: reqSource = 'linkedin', limit = 25, fetchDetails = 0, timeout = 30000, } = options;
+    // 1. Determine source & URL
+    let searchUrl;
+    let source;
+    if (url) {
+        searchUrl = url;
+        source = detectSource(url);
+    }
+    else {
+        if (!keywords)
+            throw new Error('Either url or keywords must be provided');
+        source = reqSource;
+        searchUrl = buildSearchUrl(source, keywords, location);
+    }
+    // 2. Fetch search page
+    const needsStealth = stealthNeeded(source);
+    const result = await peel(searchUrl, {
+        stealth: needsStealth,
+        render: needsStealth, // Stealth sites are usually SPAs requiring browser rendering
+        timeout,
+        format: 'markdown',
+    });
+    // 3. Parse job cards
+    let parsed;
+    switch (source) {
+        case 'linkedin':
+            parsed = parseLinkedIn(result.content, searchUrl, limit);
+            break;
+        case 'glassdoor':
+            parsed = parseGlassdoor(result.content, searchUrl, limit);
+            break;
+        case 'indeed':
+            parsed = parseIndeed(result.content, searchUrl, limit);
+            break;
+        case 'upwork':
+            parsed = parseUpwork(result.content, searchUrl, limit);
+            break;
+        default: {
+            // Try each parser for unknown URLs
+            parsed = parseLinkedIn(result.content, searchUrl, limit);
+            if (!parsed.jobs.length)
+                parsed = parseGlassdoor(result.content, searchUrl, limit);
+            if (!parsed.jobs.length)
+                parsed = parseIndeed(result.content, searchUrl, limit);
+            if (!parsed.jobs.length)
+                parsed = parseUpwork(result.content, searchUrl, limit);
+            break;
+        }
+    }
+    // 4. Optionally fetch detail pages (max 3 concurrent)
+    let detailsFetched = 0;
+    let jobs = parsed.jobs;
+    if (fetchDetails > 0 && parsed.jobs.length > 0) {
+        const toFetch = parsed.jobs.slice(0, fetchDetails);
+        const srcForStealth = source;
+        const tasks = toFetch.map((card) => async () => {
+            try {
+                const dr = await peel(card.detailUrl, {
+                    stealth: stealthNeeded(srcForStealth),
+                    timeout,
+                    format: 'markdown',
+                });
+                detailsFetched++;
+                return parseJobDetail(dr.content, card);
+            }
+            catch {
+                return card; // graceful fallback
+            }
+        });
+        const detailed = await pLimited(tasks, 3);
+        jobs = [...detailed, ...parsed.jobs.slice(fetchDetails)];
+    }
+    return {
+        jobs,
+        totalFound: parsed.totalFound,
+        source,
+        searchUrl,
+        detailsFetched,
+        timeTakenMs: Date.now() - startTime,
+    };
+}

package/dist/core/json-ld.d.ts

@@ -0,0 +1,15 @@
+/**
+ * JSON-LD Structured Data Extractor
+ *
+ * Extracts and converts JSON-LD (schema.org) data to clean markdown.
+ * Handles Recipe, Product, Article, FAQPage, HowTo, Event, LocalBusiness, Review.
+ * This is a FIRST-CLASS content source — tried before HTML DOM parsing.
+ */
+export interface JsonLdResult {
+    found: boolean;
+    type: string;
+    content: string;
+    title: string;
+    data: any;
+}
+export declare function extractJsonLd(html: string): JsonLdResult | null;