@ha7ch/job-pro 1.0.93

package/dist/liepin.js

@@ -0,0 +1,357 @@
+// Generic 猎聘 (Liepin) aggregator factory for `job-pro`.
+//
+// ============================================================
+// WHY THIS EXISTS
+//
+// Four of the 50 companies (hikvision / cicc / cainiao / webank) have no
+// publicly reachable canonical job feed — see `docs/stub-unblock.md`.
+// Liepin (https://www.liepin.com) is a major Chinese job aggregator
+// whose public `pc-search-job` endpoint surfaces real, currently-open
+// positions for every Chinese employer of consequence. It does NOT
+// require authentication, just a one-time XSRF-TOKEN cookie that the
+// liepin.com home page sets on first request.
+//
+// We use Liepin here as a fallback ONLY for the 4 adapters above. The
+// other 46 adapters continue to talk to their company's own API. Every
+// position surfaced through this factory has `source: "api-c.liepin.com"`
+// in its envelope so consumers can tell it's a third-party feed.
+//
+// ============================================================
+// API DISCOVERY (probed 2026-05-16)
+//
+//   1. GET  https://www.liepin.com/                          → Set-Cookie: XSRF-TOKEN=<token>
+//   2. POST https://api-c.liepin.com/api/com.liepin.searchfront4c.pc-search-job
+//        Content-Type: application/json;charset=UTF-8
+//        Origin:       https://www.liepin.com
+//        X-Client-Type: web
+//        X-Xsrf-Token: <token from cookie>
+//        X-Fscp-Std-Info: {"client_id": "40108"}
+//        X-Fscp-Version: 1.1
+//        Body: { data: { mainSearchPcConditionForm: { key:"<co>", city:"410",
+//                                                     dq:"410", currentPage:N,
+//                                                     pageSize:M, … },
+//                        passThroughForm: { scene:"init" } } }
+//        Response: { flag:1, data:{ data:{ jobCardList:[{ comp, job, recruiter, … }],
+//                                          compCard:{…} } } }
+//
+// `city:"410"` = 全国 (all of China). Per-city codes are documented in
+// Liepin's filter taxonomy; left as future work.
+import { randomUUID } from "node:crypto";
+import { extractResumeSignals, scoreOverlap, checkResume } from "./tencent.js";
+export { checkResume, extractResumeSignals, scoreOverlap };
+const HOME = "https://www.liepin.com";
+const SEARCH_URL = "https://api-c.liepin.com/api/com.liepin.searchfront4c.pc-search-job";
+const SOURCE = "api-c.liepin.com";
+const USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36";
+// ---------- shared XSRF-TOKEN cache ----------
+// One token per Node process. Liepin's token is short-lived (~hour) but for a
+// CLI process that finishes in seconds, refreshing on every invocation is
+// fine. We still cache it within the process so multi-call workflows reuse it.
+let _token = null;
+async function getToken() {
+    if (_token && Date.now() - _token.fetchedAt < 30 * 60 * 1000) {
+        return { ok: true, xsrf: _token.value, cookie: _token.cookieHeader };
+    }
+    let response;
+    try {
+        response = await fetch(HOME, {
+            method: "GET",
+            headers: { "User-Agent": USER_AGENT, "Accept-Language": "zh-CN,zh;q=0.9" },
+        });
+    }
+    catch (err) {
+        return { ok: false, message: `network error: ${err instanceof Error ? err.message : err}` };
+    }
+    // getSetCookie() is the Node-undici-canonical API for multi-Set-Cookie headers.
+    const headersAny = response.headers;
+    const setCookies = typeof headersAny.getSetCookie === "function"
+        ? headersAny.getSetCookie.call(response.headers) ?? []
+        : (response.headers.get("set-cookie") ?? "").split(/,(?=[^;]+=)/);
+    let xsrf = "";
+    const cookieParts = [];
+    for (const c of setCookies) {
+        const kv = c.split(";")[0].trim();
+        cookieParts.push(kv);
+        if (kv.startsWith("XSRF-TOKEN="))
+            xsrf = kv.slice("XSRF-TOKEN=".length);
+    }
+    if (!xsrf) {
+        return { ok: false, message: "liepin.com did not set an XSRF-TOKEN cookie" };
+    }
+    _token = { value: xsrf, cookieHeader: cookieParts.join("; "), fetchedAt: Date.now() };
+    return { ok: true, xsrf, cookie: _token.cookieHeader };
+}
+// ---------- summarise ----------
+function summarize(card) {
+    const comp = card.comp ?? {};
+    const job = card.job ?? {};
+    return {
+        post_id: String(job.jobId ?? ""),
+        title: (job.title ?? "").trim(),
+        project: "",
+        recruit_label: job.jobKind === "1" ? "全职" : job.jobKind === "2" ? "社招" : "",
+        bgs: (comp.compIndustry ?? "").trim(),
+        work_cities: (job.dq ?? "").trim(),
+        apply_url: job.link ?? job.pcOuterLink ?? (job.jobId ? `https://www.liepin.com/job/${encodeURIComponent(String(job.jobId))}.shtml` : HOME),
+    };
+}
+// ---------- core: search for a single page ----------
+async function searchOnePage(companyName, keyword, page, pageSize) {
+    const tok = await getToken();
+    if (!tok.ok)
+        return tok;
+    const fullKey = [companyName, keyword].filter(Boolean).join(" ").trim();
+    const body = {
+        data: {
+            mainSearchPcConditionForm: {
+                city: "410",
+                dq: "410",
+                pubTime: "",
+                currentPage: Math.max(0, page - 1),
+                pageSize: Math.max(1, Math.min(40, pageSize)),
+                key: fullKey,
+                suggestTag: "",
+                workYearCode: "",
+                compId: "",
+                compName: companyName,
+                compTag: "",
+                industry: "",
+                salaryCode: "",
+                jobKind: "",
+                compScale: "",
+                compKind: "",
+                compStage: "",
+                eduLevel: "",
+                salaryLow: "",
+                salaryHigh: "",
+            },
+            passThroughForm: { scene: "init", skId: "", fkId: "", ckId: "", suggest: null },
+        },
+    };
+    let response;
+    try {
+        response = await fetch(SEARCH_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json;charset=UTF-8",
+                "User-Agent": USER_AGENT,
+                Origin: HOME,
+                Referer: `${HOME}/zhaopin/?key=${encodeURIComponent(fullKey)}`,
+                Accept: "application/json, text/plain, */*",
+                "Accept-Language": "zh-CN,zh;q=0.9",
+                "X-Client-Type": "web",
+                "X-Requested-With": "XMLHttpRequest",
+                "X-Fscp-Std-Info": '{"client_id": "40108"}',
+                "X-Fscp-Version": "1.1",
+                "X-Fscp-Trace-Id": randomUUID(),
+                "X-Xsrf-Token": tok.xsrf,
+                Cookie: tok.cookie,
+            },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (err) {
+        return { ok: false, message: `network error: ${err instanceof Error ? err.message : err}` };
+    }
+    if (!response.ok) {
+        return { ok: false, message: `HTTP ${response.status}: ${response.statusText}` };
+    }
+    let env;
+    try {
+        env = (await response.json());
+    }
+    catch (err) {
+        return { ok: false, message: `bad JSON: ${err instanceof Error ? err.message : err}` };
+    }
+    if (env.flag !== 1 || !env.data?.data) {
+        return { ok: false, message: env.msg ?? `flag=${env.flag} code=${env.code ?? "?"}` };
+    }
+    const inner = env.data.data;
+    const jobs = inner.jobCardList ?? [];
+    // Filter to the actual target company (Liepin's relevance ranker leaks
+    // adjacent employers when there's no exact match).
+    const exact = jobs.filter((c) => (c.comp?.compName ?? "") === companyName);
+    return {
+        ok: true,
+        total: exact.length === 0 ? jobs.length : exact.length,
+        jobs: exact.length === 0 ? jobs : exact,
+        compCard: inner.compCard,
+    };
+}
+export function createAdapter(cfg) {
+    const ATTRIBUTION = `via Liepin (api-c.liepin.com) — official portal not publicly accessible`;
+    async function searchPositions(opts = {}) {
+        const page = Math.max(1, opts.page ?? 1);
+        const pageSize = Math.max(1, Math.min(40, opts.pageSize ?? 20));
+        const r = await searchOnePage(cfg.companyName, (opts.keyword ?? "").trim(), page, pageSize);
+        if (!r.ok) {
+            return {
+                ok: false,
+                source: SOURCE,
+                company: cfg.companyName,
+                attribution: ATTRIBUTION,
+                message: r.message,
+                query: opts,
+                positions: [],
+            };
+        }
+        return {
+            ok: true,
+            source: SOURCE,
+            company: cfg.companyName,
+            attribution: ATTRIBUTION,
+            comp_card: r.compCard,
+            query: opts,
+            page,
+            page_size: pageSize,
+            total: r.total,
+            positions: r.jobs.map(summarize),
+        };
+    }
+    async function fetchAllPositions(opts = {}) {
+        const pageSize = Math.max(1, Math.min(40, opts.pageSize ?? 40));
+        const maxPages = Math.max(1, opts.maxPages ?? 10);
+        const bucket = [];
+        let total = 0;
+        let lastMsg = "ok";
+        let anyOk = false;
+        for (let page = 1; page <= maxPages; page++) {
+            const r = await searchOnePage(cfg.companyName, (opts.keyword ?? "").trim(), page, pageSize);
+            if (!r.ok) {
+                lastMsg = r.message;
+                break;
+            }
+            anyOk = true;
+            total = r.total;
+            if (!r.jobs.length)
+                break;
+            for (const c of r.jobs)
+                bucket.push(summarize(c));
+            if (r.jobs.length < pageSize)
+                break;
+        }
+        if (!anyOk) {
+            return {
+                ok: false,
+                source: SOURCE,
+                company: cfg.companyName,
+                attribution: ATTRIBUTION,
+                message: lastMsg,
+                total: 0,
+                fetched: 0,
+                positions: [],
+            };
+        }
+        return {
+            ok: true,
+            source: SOURCE,
+            company: cfg.companyName,
+            attribution: ATTRIBUTION,
+            total,
+            fetched: bucket.length,
+            positions: bucket,
+        };
+    }
+    async function fetchPositionDetail(postId) {
+        const id = (postId ?? "").trim();
+        if (!id)
+            return { ok: false, source: SOURCE, message: "post_id is required" };
+        // Liepin's detail page is `/job/{id}.shtml` — non-API, HTML-only. We
+        // surface the deep-link rather than pretend to fetch a JSON detail.
+        return {
+            ok: true,
+            source: SOURCE,
+            company: cfg.companyName,
+            attribution: ATTRIBUTION,
+            post_id: id,
+            apply_url: `https://www.liepin.com/job/${encodeURIComponent(id)}.shtml`,
+            message: "Liepin position detail is HTML-only; visit apply_url for the full JD.",
+        };
+    }
+    async function fetchDictionaries() {
+        // Surface the compCard payload (industry / scale / tags) as the closest
+        // thing to a "taxonomy" we can offer from a third-party aggregator.
+        const r = await searchOnePage(cfg.companyName, "", 1, 5);
+        if (!r.ok) {
+            return { ok: false, source: SOURCE, message: r.message };
+        }
+        return {
+            ok: true,
+            source: SOURCE,
+            company: cfg.companyName,
+            attribution: ATTRIBUTION,
+            comp_card: r.compCard ?? null,
+            note: "Liepin doesn't expose a per-company filter taxonomy; comp_card holds " +
+                "the company profile (industry, scale, stage, tags).",
+        };
+    }
+    const NOTICES_MSG = `${cfg.label}: surfaced via Liepin aggregator; no notices endpoint available.`;
+    async function listNotices() {
+        return { ok: false, source: SOURCE, message: NOTICES_MSG, notices: [] };
+    }
+    async function getNotice(noticeId) {
+        return { ok: false, source: SOURCE, message: NOTICES_MSG, notice_id: noticeId };
+    }
+    async function findNoticesByQuestion(question, _opts = {}) {
+        return { ok: false, source: SOURCE, question, message: NOTICES_MSG, matches: [] };
+    }
+    // matchResume reuses extractResumeSignals / scoreOverlap from tencent.ts
+    // so the contract matches every other adapter.
+    async function matchResume(text, opts = {}) {
+        const topN = Math.max(1, opts.topN ?? 5);
+        const candidates = Math.max(topN, opts.candidates ?? 20);
+        const { terms, cities } = extractResumeSignals(text ?? "");
+        if (!terms.length) {
+            return {
+                ok: false,
+                source: SOURCE,
+                message: "could not extract any technical signals from the text",
+                preview: (text ?? "").slice(0, 120),
+            };
+        }
+        const keyword = terms.slice(0, 3).join(" ");
+        const list = await searchPositions({ keyword, page: 1, pageSize: 40 });
+        if (!list.ok) {
+            return { ok: false, source: SOURCE, message: list.message, positions: [] };
+        }
+        const scored = [];
+        for (const p of list.positions) {
+            const blob = [p.title, p.bgs, p.work_cities, p.recruit_label].join(" ");
+            const { score, reasons } = scoreOverlap(blob, terms, cities);
+            if (score > 0)
+                scored.push({ score, position: p, reasons });
+        }
+        scored.sort((a, b) => b.score - a.score);
+        let shortlist = scored.slice(0, Math.max(topN, candidates));
+        if (!shortlist.length) {
+            shortlist = list.positions.slice(0, candidates).map((position) => ({ score: 0, position, reasons: [] }));
+        }
+        const matches = shortlist.slice(0, topN).map((s) => {
+            const mr = s.reasons.length > 0
+                ? s.reasons.slice(0, 5)
+                : ["no specific keyword overlap — surfaced from Liepin search"];
+            return { ...s.position, match_reasons: mr };
+        });
+        return {
+            ok: true,
+            source: SOURCE,
+            attribution: ATTRIBUTION,
+            extracted_terms: terms,
+            city_preferences: cities,
+            matches,
+            note: "match_reasons surfaces overlapping keywords, not a probability of getting an interview. " +
+                "The only authority on selection is HR.",
+        };
+    }
+    return {
+        searchPositions,
+        fetchAllPositions,
+        fetchPositionDetail,
+        fetchDictionaries,
+        listNotices,
+        getNotice,
+        findNoticesByQuestion,
+        matchResume,
+        checkResume,
+    };
+}

package/dist/lilith.js

@@ -0,0 +1,300 @@
+// 莉莉丝游戏 (Lilith Games) careers adapter — Feishu portal_type=6 via CDP.
+//
+// ============================================================
+// API DISCOVERY (probed 2026-05-16)
+//
+// Lilith's careers feed is hosted at `lilithgames.jobs.feishu.cn` (Feishu
+//招聘 / ATSX). It looks like a standard Feishu tenant on the surface, BUT
+// the `/api/v1/search/job/posts` POST is rejected with `HTTP 405` from
+// ByteDance Tengine for any anonymous caller — Lilith's tenant is one of
+// the few that requires the in-browser `_signature` anti-bot token. The
+// signature is computed by `verifycenter` (`lf-cdn-tos.bytescm.com/.../rc-verifycenter`)
+// at runtime and appended to the URL query string + headers; it's
+// session-bound and short-lived.
+//
+// Reverse-engineering verifycenter is non-trivial. We work around it by
+// using `puppeteer-core` to drive the user's real Chrome (see cli/src/cdp.ts):
+// navigate to the careers page, wait for the SPA's own `search/job/posts`
+// XHR, and read the JSON straight off the network response. Same data
+// shape as `cli/src/feishu.ts`, just sourced through a real browser.
+//
+// Probed 2026-05-16: portal_type=6, channel id 7055353811552127239, default
+// limit=10. The career page filters by `location_code_list` query string;
+// we pass through search options the same way.
+import { extractResumeSignals, scoreOverlap, checkResume } from "./tencent.js";
+import { withPage } from "./cdp.js";
+export { checkResume };
+const SOURCE = "lilithgames.jobs.feishu.cn";
+const HOST = "https://lilithgames.jobs.feishu.cn";
+const CAREER_PAGE = `${HOST}/career/`;
+const DETAIL_PAGE = (id) => `${HOST}/career/${encodeURIComponent(id)}/detail`;
+function summarize(item) {
+    const id = String(item.id ?? "");
+    const cityList = item.city_list ?? [];
+    const work_cities = cityList.length > 1
+        ? cityList.map((c) => c.name ?? "").filter(Boolean).join(" / ")
+        : cityList[0]?.name ?? item.city_info?.name ?? "";
+    const project = item.job_category?.name ?? item.job_function?.name ?? "";
+    return {
+        post_id: id,
+        title: item.title ?? "",
+        project,
+        recruit_label: item.recruit_type?.name ?? "",
+        bgs: "",
+        work_cities,
+        apply_url: id ? DETAIL_PAGE(id) : CAREER_PAGE,
+    };
+}
+function STUB_MESSAGE(reason) {
+    return ("Lilith Games (莉莉丝): feishu portal_type=6 requires a browser-minted " +
+        "`_signature` ByteDance anti-bot token. " +
+        `Could not run the browser fallback: ${reason}. ` +
+        "Install Google Chrome (or set $JOB_PRO_CHROME=/path/to/chrome) and " +
+        "ensure puppeteer-core is installed (it ships with this CLI by default).");
+}
+async function searchViaBrowser(opts) {
+    const limit = Math.max(1, Math.min(50, opts.pageSize ?? 10));
+    const keyword = (opts.keyword ?? "").trim().slice(0, 60);
+    const cityCode = (opts.cityCode ?? "").trim();
+    // The career page URL itself drives the SPA's initial XHR with the
+    // matching filters baked in. We construct a URL that yields the desired
+    // search response without needing post-load interactions.
+    const params = new URLSearchParams({
+        keywords: keyword,
+        location: cityCode,
+        project: "",
+        type: "",
+        category: "",
+        current: String(opts.page ?? 1),
+        limit: String(limit),
+        functionCategory: "",
+    });
+    const targetUrl = `${CAREER_PAGE}?${params.toString()}`;
+    const r = await withPage(async (page) => {
+        // We arm a response waiter BEFORE goto so we don't miss the XHR.
+        // The Feishu SPA fires multiple identical XHRs (one for filters, one
+        // for the actual search); we filter to the one that includes
+        // `search/job/posts` in the URL AND has non-zero content-length.
+        const responsePromise = page.waitForResponse((resp) => {
+            const u = resp.url();
+            return resp.status() === 200 && /\/api\/v1\/search\/job\/posts/.test(u);
+        }, { timeout: 25000 });
+        await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 30000 });
+        const resp = await responsePromise;
+        return (await resp.json());
+    });
+    if (!r.ok) {
+        return { ok: false, message: STUB_MESSAGE(r.error.message) };
+    }
+    const env = r.value;
+    if (env.code !== 0 || !env.data) {
+        return {
+            ok: false,
+            message: `upstream returned code=${env.code} (${env.message ?? "unknown"})`,
+        };
+    }
+    const rawJobs = env.data.job_post_list ?? [];
+    return {
+        ok: true,
+        result: {
+            ok: true,
+            total: env.data.count ?? rawJobs.length,
+            positions: rawJobs.map(summarize),
+            rawJobs,
+        },
+    };
+}
+// ---------- public API ----------
+export async function searchPositions(opts = {}) {
+    const r = await searchViaBrowser(opts);
+    if (!r.ok) {
+        return {
+            ok: false,
+            source: SOURCE,
+            message: r.message,
+            query: opts,
+            positions: [],
+        };
+    }
+    return {
+        ok: true,
+        source: SOURCE,
+        query: opts,
+        page: opts.page ?? 1,
+        page_size: opts.pageSize ?? 10,
+        total: r.result.total,
+        positions: r.result.positions,
+    };
+}
+export async function fetchAllPositions(opts = {}) {
+    const limit = Math.max(1, Math.min(50, opts.pageSize ?? 30));
+    const maxPages = Math.max(1, opts.maxPages ?? 20);
+    const bucket = [];
+    let total = 0;
+    for (let page = 1; page <= maxPages; page++) {
+        const r = await searchViaBrowser({ ...opts, page, pageSize: limit });
+        if (!r.ok) {
+            if (bucket.length === 0) {
+                return {
+                    ok: false,
+                    source: SOURCE,
+                    message: r.message,
+                    total: 0,
+                    fetched: 0,
+                    positions: [],
+                };
+            }
+            break;
+        }
+        if (page === 1)
+            total = r.result.total;
+        if (!r.result.positions.length)
+            break;
+        bucket.push(...r.result.positions);
+        if (bucket.length >= total)
+            break;
+    }
+    return {
+        ok: true,
+        source: SOURCE,
+        total,
+        fetched: bucket.length,
+        positions: bucket,
+    };
+}
+// fetchPositionDetail: Feishu has no per-id REST endpoint; scan via search.
+export async function fetchPositionDetail(postId) {
+    const id = (postId ?? "").trim();
+    if (!id)
+        return { ok: false, source: SOURCE, message: "post_id is required" };
+    const limit = 50;
+    const maxPages = 10;
+    for (let page = 1; page <= maxPages; page++) {
+        const r = await searchViaBrowser({ page, pageSize: limit });
+        if (!r.ok)
+            return { ok: false, source: SOURCE, post_id: id, message: r.message };
+        const found = r.result.rawJobs.find((p) => String(p.id) === id);
+        if (found) {
+            const summary = summarize(found);
+            return {
+                ok: true,
+                source: SOURCE,
+                post_id: id,
+                title: found.title ?? "",
+                project: summary.project,
+                recruit_label: summary.recruit_label,
+                description: found.description ?? "",
+                requirements: found.requirement ?? "",
+                work_cities: found.city_list ?? (found.city_info ? [found.city_info] : []),
+                apply_url: summary.apply_url,
+            };
+        }
+        if (r.result.rawJobs.length < limit)
+            break;
+    }
+    return {
+        ok: false,
+        source: SOURCE,
+        post_id: id,
+        message: `post ${id} not found in browser-driven search (scanned up to ${maxPages * limit} posts)`,
+    };
+}
+// fetchDictionaries: synthesize from one page of results.
+let _dictCache = null;
+export async function fetchDictionaries() {
+    if (_dictCache !== null)
+        return _dictCache;
+    const r = await searchViaBrowser({ pageSize: 50 });
+    if (!r.ok) {
+        const result = { ok: false, source: SOURCE, message: r.message };
+        _dictCache = result;
+        return result;
+    }
+    const cats = new Set();
+    const cities = new Set();
+    for (const j of r.result.rawJobs) {
+        const name = j.job_category?.name ?? j.job_function?.name;
+        if (name)
+            cats.add(name);
+        for (const c of j.city_list ?? [])
+            if (c.name)
+                cities.add(c.name);
+        if (j.city_info?.name)
+            cities.add(j.city_info.name);
+    }
+    const result = {
+        ok: true,
+        source: SOURCE,
+        total: r.result.total,
+        sample_categories: [...cats].sort(),
+        sample_cities: [...cities].sort(),
+    };
+    _dictCache = result;
+    return result;
+}
+const NOTICES_MSG = "Lilith Games (莉莉丝): no public notices endpoint on Feishu tenant";
+export async function listNotices() {
+    return { ok: false, source: SOURCE, message: NOTICES_MSG, notices: [] };
+}
+export async function getNotice(noticeId) {
+    return { ok: false, source: SOURCE, message: NOTICES_MSG, notice_id: noticeId };
+}
+export async function findNoticesByQuestion(question, _opts = {}) {
+    return { ok: false, source: SOURCE, question, message: NOTICES_MSG, matches: [] };
+}
+export async function matchResume(text, opts = {}) {
+    const topN = Math.max(1, opts.topN ?? 5);
+    const candidates = Math.max(topN, opts.candidates ?? 20);
+    const { terms, cities } = extractResumeSignals(text ?? "");
+    if (!terms.length) {
+        return {
+            ok: false,
+            source: SOURCE,
+            message: "could not extract any technical signals from the text",
+            preview: (text ?? "").slice(0, 120),
+        };
+    }
+    const keyword = terms.slice(0, 3).join(" ");
+    const r = await searchViaBrowser({ keyword, pageSize: 50 });
+    if (!r.ok) {
+        return { ok: false, source: SOURCE, message: r.message, positions: [] };
+    }
+    const scored = [];
+    for (const p of r.result.positions) {
+        const blob = [p.title, p.project, p.recruit_label, p.work_cities].join(" ");
+        const { score, reasons } = scoreOverlap(blob, terms, cities);
+        if (score > 0)
+            scored.push({ score, position: p, reasons });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    let shortlist = scored.slice(0, Math.max(topN, candidates));
+    if (!shortlist.length) {
+        shortlist = r.result.positions.slice(0, candidates).map((position) => ({ score: 0, position, reasons: [] }));
+    }
+    const matches = shortlist.slice(0, topN).map((s) => {
+        const mr = s.reasons.length > 0
+            ? s.reasons.slice(0, 5)
+            : ["no specific keyword overlap — surfaced from initial keyword search"];
+        return { ...s.position, match_reasons: mr };
+    });
+    return {
+        ok: true,
+        source: SOURCE,
+        extracted_terms: terms,
+        city_preferences: cities,
+        matches,
+        note: "match_reasons surfaces overlapping keywords, not a probability of getting an interview. " +
+            "The only authority on selection is HR.",
+    };
+}
+export { extractResumeSignals, scoreOverlap };
+// ---------- Phase 2: fetchApplicationSchema ----------
+import { makeFeishuApplyFn } from "./feishu.js";
+export const fetchApplicationSchema = makeFeishuApplyFn({
+    host: "lilithgames.jobs.feishu.cn",
+    source: "lilithgames.jobs.feishu.cn",
+    channel: "career",
+    applyUrlPrefix: "https://lilithgames.jobs.feishu.cn/career/position",
+    fetchTitle: (id) => fetchPositionDetail(id),
+    submitKind: "cdp-real-browser",
+});

package/dist/megvii.js

@@ -0,0 +1,27 @@
+// 旷视科技 / Megvii / Face++ careers — Moka SSR + AES-128-CBC.
+//
+// Two portals on the same Moka tenant `megviihr`:
+//   campus  → https://app.mokahr.com/campus_apply/megviihr/38642
+//   social  → https://app.mokahr.com/social-recruitment/megviihr/38641
+// Probed 2026-05; ~5 visible positions (Megvii hiring is currently low).
+// See cli/src/moka.ts for the shared factory.
+import { createAdapter } from "./moka.js";
+const adapter = createAdapter({
+    orgSlug: "megviihr",
+    label: "Megvii",
+    channels: [
+        { siteId: 38642, kind: "campus_apply", recruitType: "campus" },
+        { siteId: 38641, kind: "social-recruitment", recruitType: "social" },
+    ],
+    defaultRecruitType: "social",
+});
+export const searchPositions = adapter.searchPositions;
+export const fetchAllPositions = adapter.fetchAllPositions;
+export const fetchPositionDetail = adapter.fetchPositionDetail;
+export const fetchDictionaries = adapter.fetchDictionaries;
+export const listNotices = adapter.listNotices;
+export const getNotice = adapter.getNotice;
+export const findNoticesByQuestion = adapter.findNoticesByQuestion;
+export const matchResume = adapter.matchResume;
+export const checkResume = adapter.checkResume;
+export const fetchApplicationSchema = adapter.fetchApplicationSchema;