helixlife-expert-cli 0.1.0

package/cli/dist/modules/meta/screening.js

@@ -0,0 +1,1255 @@
+import { basename, dirname, extname, resolve } from "node:path";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { ApiClient, createStderrProgress, helixlifeError, helixlifeErrorCode, printOutput, renderListAsMarkdown, } from "../../core/index.js";
+import { META_API_PREFIX, META_ABSTRACT_SCREENING_WAIT_HINT, META_FULLTEXT_SCREENING_WAIT_HINT } from "./constants.js";
+import { requestMeta } from "./api.js";
+import { getMetaNodeOutput, pollMetaNodeStatus } from "./node.js";
+const META_SCREENING_NODE_TYPES = {
+    LITERATURE: "literature_retrieve",
+    CRITERIA: "generate_sorting_criteria",
+    ABSTRACT: "abstract_screening",
+    FULLTEXT: "fulltext_screening",
+};
+const MAX_PDF_UPLOAD_SIZE = 15 * 1024 * 1024;
+const ABSTRACT_SCREENING_COLUMNS = [
+    { key: "study", label: "Study" },
+    { key: "author", label: "Author" },
+    { key: "title", label: "Title" },
+    { key: "doi", label: "DOI" },
+    { key: "abstract", label: "Abstract" },
+    { key: "publication_type", label: "Publication Type" },
+    { key: "publication_date", label: "Publication Date" },
+    { key: "pmid", label: "PMID" },
+    { key: "pmc", label: "PMC" },
+    { key: "result", label: "AB & TI Screening" },
+    { key: "reason", label: "Reason" },
+];
+const FULLTEXT_SCREENING_COLUMNS = [
+    { key: "index", label: "序号" },
+    { key: "study", label: "Study" },
+    { key: "author", label: "Author" },
+    { key: "title", label: "Title" },
+    { key: "doi", label: "DOI" },
+    { key: "abstract", label: "Abstract" },
+    { key: "publication_type", label: "Publication Type" },
+    { key: "publication_date", label: "Publication Date" },
+    { key: "pmid", label: "PMID" },
+    { key: "pmc", label: "PMC" },
+    { key: "result", label: "Full Text Screening" },
+    { key: "reason", label: "Reason (Exclude)" },
+];
+const ABSTRACT_SCREENING_DISPLAY_INSTRUCTION = "必须将 tableMarkdown 作为摘要初筛结果的唯一展示源并逐字完整输出全部 11 列和全部返回记录：" +
+    "Study / Author / Title / DOI / Abstract / Publication Type / Publication Date / PMID / PMC / AB & TI Screening / Reason。" +
+    "禁止从其他字段重建表格，禁止删除、合并或改写任何列和值，禁止摘要、缩写、翻译、截断 Abstract 或使用占位符；" +
+    "尤其禁止简化为 Study、PMID、筛选结果、Reason 等子集列。";
+const FULLTEXT_SCREENING_DISPLAY_INSTRUCTION = "必须将 tableMarkdown 作为全文复筛结果的唯一展示源并逐字完整输出全部 12 列和全部返回记录：" +
+    "序号 / Study / Author / Title / DOI / Abstract / Publication Type / Publication Date / PMID / PMC / Full Text Screening / Reason (Exclude)。" +
+    "禁止从其他字段重建表格，禁止删除、合并或改写任何列和值，禁止摘要、缩写、翻译、截断 Abstract。" +
+    "尤其禁止简化为 Study、PMID、Full Text Screening、Reason (Exclude) 四列，或 Study、Full Text Screening、Reason (Exclude) 三列；" +
+    "禁止用「全文复筛完成 / 共筛选 N 篇…」等摘要代替完整 tableMarkdown。";
+/** 重新筛选对比表列（与网站「重新筛选完成」弹层一致） */
+const ABSTRACT_RESCREEN_COMPARISON_COLUMNS = [
+    { key: "pmid", label: "PMID" },
+    { key: "study", label: "Study" },
+    { key: "oldResult", label: "原结果" },
+    { key: "newResult", label: "新结果" },
+    { key: "reason", label: "理由" },
+];
+const ABSTRACT_RESCREEN_DISPLAY_INSTRUCTION = "重新筛选完成后，必须将 tableMarkdown 作为对比结果的唯一展示源并逐字完整输出" +
+    "（含「重新筛选完成！」标题、汇总句、PMID/Study/原结果/新结果/理由对比表及脚注）。" +
+    "禁止用「重新筛选成功」等摘要代替表格，禁止删改任何列或记录。";
+/** 网站脚注中常见英文理由 → 中文 */
+const RESCREEN_REASON_ZH = {
+    irrelevant: "不相关",
+    "not relevant": "不相关",
+    "not-relevant": "不相关",
+};
+function parseJsonObject(raw, optionName) {
+    const jsonText = raw?.replace(/^\uFEFF/, "").trim();
+    if (!jsonText) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(jsonText);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("not an object");
+        }
+        return parsed;
+    }
+    catch {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `${optionName} 须为合法 JSON 对象`);
+    }
+}
+function parseJsonStringArray(raw, optionName) {
+    const jsonText = raw?.replace(/^\uFEFF/, "").trim();
+    if (!jsonText) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(jsonText);
+        if (!Array.isArray(parsed) ||
+            parsed.some((item) => typeof item !== "string")) {
+            throw new Error("not a string array");
+        }
+        return parsed;
+    }
+    catch {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `${optionName} 须为合法 JSON 字符串数组`);
+    }
+}
+async function parseJsonObjectInput(raw, filePath, optionName, fileOptionName) {
+    if (filePath?.trim()) {
+        const content = await readFile(filePath.trim(), "utf8");
+        return parseJsonObject(content, fileOptionName);
+    }
+    if (!raw?.trim()) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `缺少 ${optionName} 或 ${fileOptionName}`);
+    }
+    return parseJsonObject(raw, optionName);
+}
+async function parseJsonStringArrayInput(raw, filePath, optionName, fileOptionName) {
+    if (filePath?.trim()) {
+        const content = await readFile(filePath.trim(), "utf8");
+        return parseJsonStringArray(content, fileOptionName);
+    }
+    if (!raw?.trim()) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `缺少 ${optionName} 或 ${fileOptionName}`);
+    }
+    return parseJsonStringArray(raw, optionName);
+}
+function extractNodeOutput(node) {
+    if (node.output &&
+        typeof node.output === "object" &&
+        "output" in node.output) {
+        return node.output.output;
+    }
+    return node.output ?? {};
+}
+/**
+ * Safely narrows an unknown value to a plain record for API response traversal.
+ *
+ * @param value The unknown value returned by the API or nested response object.
+ * @returns The value as a record, or an empty record when it is not object-like.
+ */
+function unwrapRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+/**
+ * Extracts paginated list items from the common Meta response container shapes.
+ *
+ * @param data The raw list response, possibly wrapped by `data`, `items`, `records`, or similar keys.
+ * @returns The list item array used to build a WorkBuddy-friendly table.
+ */
+function extractListItems(data) {
+    const root = unwrapRecord(data);
+    const nested = unwrapRecord(root.data);
+    const payload = Object.keys(nested).length > 0 ? nested : root;
+    return Array.isArray(payload.items)
+        ? payload.items
+        : Array.isArray(payload.list)
+            ? payload.list
+            : Array.isArray(payload.records)
+                ? payload.records
+                : Array.isArray(payload.results)
+                    ? payload.results
+                    : Array.isArray(payload.data)
+                        ? payload.data
+                        : Array.isArray(data)
+                            ? data
+                            : [];
+}
+/**
+ * Formats scalar and array fields for markdown table display without dropping values.
+ *
+ * @param value The raw field value from a screening record.
+ * @returns A readable string, joining array values with commas.
+ */
+function formatListField(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => String(item ?? ""))
+            .filter(Boolean)
+            .join(", ");
+    }
+    return value === undefined || value === null ? "" : String(value);
+}
+/**
+ * Normalizes publication dates to the website-style `YYYY-MM-DD` display when possible.
+ *
+ * @param value The raw publication date value, either a timestamp, date string, or empty value.
+ * @returns A readable date string, or the original trimmed string when parsing is not possible.
+ */
+function formatPublicationDateForDisplay(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return new Date(value * 1000).toISOString().slice(0, 10);
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (/^\d{4}-\d{2}-\d{2}/.test(trimmed)) {
+            return trimmed.slice(0, 10);
+        }
+        const timestamp = Date.parse(trimmed);
+        return Number.isNaN(timestamp)
+            ? trimmed
+            : new Date(timestamp).toISOString().slice(0, 10);
+    }
+    return "";
+}
+/**
+ * Builds the abstract-screening table using the same columns and order as the website.
+ *
+ * @param data The raw abstract-screening list response.
+ * @returns A table descriptor with website column labels and normalized rows.
+ */
+function buildAbstractScreeningTable(data) {
+    const rows = extractListItems(data).map((item) => {
+        const record = unwrapRecord(item);
+        return {
+            study: formatListField(record.study),
+            author: formatListField(record.author),
+            title: formatListField(record.title),
+            doi: formatListField(record.doi),
+            abstract: formatListField(record.abstract),
+            publication_type: formatListField(record.publication_type),
+            publication_date: formatPublicationDateForDisplay(record.publication_date),
+            pmid: formatListField(record.pmid),
+            pmc: formatListField(record.pmc),
+            result: formatListField(record.result),
+            reason: formatListField(record.reason),
+        };
+    });
+    return { columns: [...ABSTRACT_SCREENING_COLUMNS], rows };
+}
+/**
+ * 构建全文复筛展示表；首列序号与 selectionOptions 对齐：`(page-1)*limit+行号`。
+ *
+ * @param data 全文复筛列表原始响应。
+ * @param page 当前页码（1-based）。
+ * @param limit 每页条数。
+ * @returns 含「序号」及网站列标签的表格描述。
+ */
+function buildFulltextScreeningTable(data, page, limit) {
+    const safePage = Math.max(1, page);
+    const safeLimit = Math.max(1, limit);
+    const rows = extractListItems(data).map((item, i) => {
+        const record = unwrapRecord(item);
+        return {
+            index: (safePage - 1) * safeLimit + i + 1,
+            study: formatListField(record.study),
+            author: formatListField(record.author),
+            title: formatListField(record.title),
+            doi: formatListField(record.doi),
+            abstract: formatListField(record.abstract),
+            publication_type: formatListField(record.publication_type),
+            publication_date: formatPublicationDateForDisplay(record.publication_date),
+            pmid: formatListField(record.pmid),
+            pmc: formatListField(record.pmc),
+            result: formatListField(record.result),
+            reason: formatListField(record.reason),
+        };
+    });
+    return { columns: [...FULLTEXT_SCREENING_COLUMNS], rows };
+}
+/** Keeps complete internal IDs available for subsequent record actions. */
+function buildScreeningRecordRefs(data) {
+    return extractListItems(data).map((item) => {
+        const record = unwrapRecord(item);
+        return {
+            id: formatListField(record.id),
+            study: formatListField(record.study),
+            title: formatListField(record.title),
+            doi: formatListField(record.doi),
+            pmid: formatListField(record.pmid),
+        };
+    });
+}
+/**
+ * 构建初筛文献选择器选项；序号按分页连续编号：(page-1)*limit+行号。
+ *
+ * @param recordRefs 当前页 recordRefs。
+ * @param page 当前页码（1-based）。
+ * @param limit 每页条数。
+ * @returns 供 AskQuestion 使用的 selectionOptions。
+ */
+function buildScreeningSelectionOptions(recordRefs, page, limit) {
+    const safePage = Math.max(1, page);
+    const safeLimit = Math.max(1, limit);
+    return recordRefs
+        .filter((ref) => ref.id.trim())
+        .map((ref, i) => {
+        const index = (safePage - 1) * safeLimit + i + 1;
+        const studyText = ref.study.trim() || "无 Study";
+        const pmidText = ref.pmid.trim() ? `PMID ${ref.pmid.trim()}` : "无 PMID";
+        return {
+            index,
+            // 半角括号/逗号：全角「，」在 AskQuestion 选择器中可能显示为 U+FFFD 乱码
+            label: `序号 ${index} (${studyText}, ${pmidText})`,
+            value: ref.id,
+            pmid: ref.pmid,
+            study: ref.study,
+        };
+    });
+}
+function withScreeningTable(result, table, instruction, recordRefs = [], tableMarkdownOverride, extras) {
+    const tableMarkdown = tableMarkdownOverride ?? renderListAsMarkdown(table.rows, table.columns);
+    return {
+        ...result,
+        displayInstruction: instruction,
+        columns: table.columns,
+        rows: table.rows,
+        displayColumns: table.columns.map((column) => column.label),
+        displayRows: table.rows,
+        tableMarkdown,
+        recordRefs,
+        table,
+        ...(extras?.selectionOptions ? { selectionOptions: extras.selectionOptions } : {}),
+        ...(extras?.page != null ? { page: extras.page } : {}),
+        ...(extras?.limit != null ? { limit: extras.limit } : {}),
+    };
+}
+/**
+ * 按 ID 批量读取筛选记录（分页扫描直至全部命中或列表结束）。
+ *
+ * @param options 工作流、节点、端点与目标 ID 列表。
+ * @returns id → 记录映射；未找到的 ID 不会出现在 Map 中。
+ */
+async function loadScreeningRecordsByIds(options) {
+    const wanted = new Set(options.ids.filter(Boolean));
+    const found = new Map();
+    if (wanted.size === 0) {
+        return found;
+    }
+    const limit = 50;
+    for (let page = 1;; page += 1) {
+        const data = await requestMeta(`${META_API_PREFIX}/${options.endpoint}`, {
+            params: {
+                run_id: options.workflowId,
+                node_id: options.nodeId,
+                page,
+                limit,
+            },
+            configPath: options.configPath,
+            action: options.action,
+        });
+        const items = extractListItems(data);
+        for (const item of items) {
+            const record = unwrapRecord(item);
+            const id = String(record.id ?? "");
+            if (wanted.has(id)) {
+                found.set(id, record);
+            }
+        }
+        if (found.size >= wanted.size || items.length < limit) {
+            break;
+        }
+    }
+    return found;
+}
+/** 脚注理由中文化；未知文案原样返回。 */
+function formatRescreenReasonZh(reason) {
+    const trimmed = reason.trim();
+    if (!trimmed || trimmed === "—") {
+        return trimmed;
+    }
+    return RESCREEN_REASON_ZH[trimmed.toLowerCase()] ?? trimmed;
+}
+/**
+ * 构建与网站一致的重新筛选对比展示（标题 + 汇总 + 表 + 脚注）。
+ *
+ * @param ids 本次重筛的记录 ID（保持选择顺序）。
+ * @param beforeMap 重筛前快照。
+ * @param afterMap 重筛后记录。
+ * @returns 对比表行、完整 Markdown 与 recordRefs。
+ */
+function buildAbstractRescreenComparison(options) {
+    const columns = [...ABSTRACT_RESCREEN_COMPARISON_COLUMNS];
+    const rows = [];
+    const recordRefs = [];
+    const changedSummaries = [];
+    for (const id of options.ids) {
+        const before = options.beforeMap.get(id);
+        const after = options.afterMap.get(id) ?? before;
+        if (!before && !after) {
+            continue;
+        }
+        const source = after ?? before ?? {};
+        const pmid = formatListField(source.pmid);
+        const study = formatListField(source.study);
+        const title = formatListField(source.title);
+        const oldResult = formatListField(before?.result) || "—";
+        const newResult = formatListField(after?.result) || "—";
+        const changed = oldResult !== newResult;
+        const reasonRaw = changed
+            ? formatListField(after?.reason) || "—"
+            : "—";
+        const cells = {
+            pmid,
+            study,
+            oldResult,
+            newResult,
+            reason: reasonRaw,
+        };
+        // 变更行加粗，对齐网站高亮
+        rows.push(changed
+            ? Object.fromEntries(Object.entries(cells).map(([key, value]) => [
+                key,
+                `**${value}**`,
+            ]))
+            : cells);
+        recordRefs.push({
+            id: formatListField(source.id) || id,
+            study,
+            title,
+            doi: formatListField(source.doi),
+            pmid,
+        });
+        if (changed) {
+            const studyLabel = study || "未知文献";
+            const titlePart = title ? ` - ${title}` : "";
+            const reasonZh = formatRescreenReasonZh(reasonRaw);
+            changedSummaries.push(`${studyLabel}${titlePart} 由 ${oldResult} 改为 ${newResult}（${reasonZh}）。`);
+        }
+    }
+    const total = rows.length;
+    const changedCount = changedSummaries.length;
+    const unchangedCount = total - changedCount;
+    const footer = changedCount === 0
+        ? `全部 ${total} 篇结果保持不变。`
+        : `${changedSummaries.join("")}${unchangedCount > 0 ? `其余 ${unchangedCount} 篇保持不变。` : ""}`;
+    const tableMarkdown = [
+        "重新筛选完成！",
+        "",
+        `${total} 篇文献中，${changedCount} 篇结果已更新：`,
+        "",
+        renderListAsMarkdown(rows, columns),
+        "",
+        footer,
+    ].join("\n");
+    return { columns, rows, tableMarkdown, recordRefs };
+}
+/** 调用筛选结果 `/export` 接口下载产物并落盘。 */
+async function downloadScreeningExportArtifact(options) {
+    const client = new ApiClient();
+    const response = await client.requestBinary(`${META_API_PREFIX}/${options.endpoint}`, {
+        method: "GET",
+        params: {
+            run_id: options.workflowId,
+            node_id: options.nodeId,
+        },
+    });
+    if (response.buffer.length === 0) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, `${options.action}下载内容为空`);
+    }
+    const output = resolve(options.outputDirectory?.trim() || ".", options.filename);
+    await mkdir(dirname(output), { recursive: true });
+    await writeFile(output, response.buffer);
+    return {
+        output,
+        filename: options.filename,
+        contentType: response.contentType ?? "application/octet-stream",
+        size: response.buffer.length,
+    };
+}
+/**
+ * Converts numeric-like values from SSE payloads into finite numbers.
+ *
+ * @param value The raw value from the SSE payload.
+ * @returns A finite number, or undefined when conversion fails.
+ */
+function toNumber(value) {
+    const number = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(number) ? number : undefined;
+}
+/**
+ * Normalizes screening SSE progress payloads into a consistent progress shape.
+ *
+ * @param payload The raw SSE payload emitted by the Meta screening endpoint.
+ * @returns A normalized progress payload, or undefined when required counters are missing.
+ */
+function normalizeScreeningProgress(payload) {
+    const current = toNumber(payload.current);
+    const total = toNumber(payload.total);
+    if (current === undefined || total === undefined || total <= 0) {
+        return undefined;
+    }
+    return {
+        current,
+        total,
+        percent: Math.ceil((current / total) * 100) || 0,
+        items: Array.isArray(payload.items) ? payload.items : undefined,
+        isDone: payload.is_done === true,
+    };
+}
+/**
+ * 订阅筛选节点 SSE 进度，并把百分比写入 stderr。
+ *
+ * JSON 模式下 stdout 必须只输出最终结果，因此进度只能写 stderr。
+ */
+function startScreeningProgressSse(options) {
+    const client = new ApiClient();
+    let lastPercent = -1;
+    return client
+        .requestSse(`${META_API_PREFIX}/sse/${options.nodeId}/${options.workflowId}`, {
+        method: "GET",
+        signal: options.signal,
+    }, (payload) => {
+        const progress = normalizeScreeningProgress(payload);
+        if (!progress) {
+            return;
+        }
+        const shouldPrint = progress.percent !== lastPercent &&
+            (progress.percent === 100 ||
+                progress.percent - lastPercent >= 5 ||
+                lastPercent < 0);
+        if (!shouldPrint) {
+            return;
+        }
+        lastPercent = progress.percent;
+        process.stderr.write(`${options.label}进度：${progress.current}/${progress.total}（${progress.percent}%）\n`);
+    })
+        .catch((error) => {
+        if (error instanceof Error && error.name === "AbortError") {
+            return;
+        }
+        process.stderr.write(`${options.label}进度订阅中断，继续等待节点结果...\n`);
+    });
+}
+function splitListField(value) {
+    if (typeof value === "string") {
+        return value
+            .split(/[，,;]/)
+            .map((item) => item.trim())
+            .filter(Boolean);
+    }
+    return value;
+}
+function normalizePublicationDate(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const timestamp = /^\d{4}-\d{2}-\d{2}$/.test(trimmed)
+        ? Date.parse(`${trimmed}T00:00:00Z`)
+        : Date.parse(trimmed);
+    return Number.isNaN(timestamp) ? value : Math.floor(timestamp / 1000);
+}
+function normalizeScreeningLiteratureInput(input, fallbackId) {
+    const allowedKeys = [
+        "id",
+        "study",
+        "author",
+        "title",
+        "doi",
+        "abstract",
+        "publication_type",
+        "publication_date",
+        "pmid",
+        "pmc",
+        "result",
+        "reason",
+    ];
+    const normalized = {};
+    for (const key of allowedKeys) {
+        if (key in input) {
+            normalized[key] = input[key];
+        }
+    }
+    if (!("id" in normalized) && fallbackId) {
+        normalized.id = fallbackId;
+    }
+    if ("author" in normalized) {
+        normalized.author = splitListField(normalized.author);
+    }
+    if ("publication_type" in normalized) {
+        normalized.publication_type = splitListField(normalized.publication_type);
+    }
+    if ("publication_date" in normalized) {
+        const publicationDate = normalizePublicationDate(normalized.publication_date);
+        if (publicationDate === undefined) {
+            delete normalized.publication_date;
+        }
+        else {
+            normalized.publication_date = publicationDate;
+        }
+    }
+    return normalized;
+}
+async function loadScreeningLiteratureForUpdate(options) {
+    const limit = 50;
+    for (let page = 1;; page += 1) {
+        const data = await requestMeta(`${META_API_PREFIX}/${options.endpoint}`, {
+            params: {
+                run_id: options.workflowId,
+                node_id: options.nodeId,
+                page,
+                limit,
+            },
+            configPath: options.configPath,
+            action: "读取待编辑筛选文献完整数据",
+        });
+        const items = extractListItems(data);
+        const record = items
+            .map((item) => unwrapRecord(item))
+            .find((item) => String(item.id ?? "") === options.recordId);
+        if (record)
+            return record;
+        if (items.length < limit)
+            break;
+    }
+    throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "未找到待编辑的筛选文献，已停止更新以避免覆盖丢失原字段");
+}
+async function getWorkflow(workflowId, configPath) {
+    return requestMeta(`${META_API_PREFIX}/workflow/runs/${encodeURIComponent(workflowId)}`, {
+        configPath,
+        action: "查询 Meta 工作流",
+    });
+}
+function findLatestNode(workflow, nodeType) {
+    return [...(workflow.nodes ?? [])]
+        .reverse()
+        .find((node) => node.node_type === nodeType);
+}
+async function resolveNodeId(options) {
+    if (options.nodeId?.trim()) {
+        return options.nodeId.trim();
+    }
+    const workflow = await getWorkflow(options.workflowId, options.configPath);
+    const node = findLatestNode(workflow, options.nodeType);
+    if (!node) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `当前工作流中未找到 ${options.label} 节点`);
+    }
+    return node.id;
+}
+async function getLatestCriteriaInput(options) {
+    if (options.criteriaJson?.trim() || options.criteriaFile?.trim()) {
+        return parseJsonObjectInput(options.criteriaJson, options.criteriaFile, "--criteria-json", "--criteria-file");
+    }
+    const workflow = await getWorkflow(options.workflowId, options.configPath);
+    const criteriaNode = findLatestNode(workflow, META_SCREENING_NODE_TYPES.CRITERIA);
+    const output = criteriaNode?.output;
+    if (output && typeof output === "object") {
+        return output;
+    }
+    throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "当前工作流中未找到可用的纳排标准，请传入 --criteria-json 或 --criteria-file");
+}
+function printScreeningStepResult(result, format) {
+    if (format === "json") {
+        printOutput({
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            nodeType: result.nodeType,
+            status: result.status,
+            displayInstruction: result.displayInstruction,
+            tableMarkdown: result.tableMarkdown,
+            recordRefs: result.recordRefs,
+            selectionOptions: result.selectionOptions,
+            page: result.page,
+            limit: result.limit,
+        }, "json");
+        return;
+    }
+    if (result.tableMarkdown) {
+        console.log(result.tableMarkdown);
+        return;
+    }
+    console.log(renderListAsMarkdown([
+        {
+            runnerId: result.runnerId,
+            nodeType: result.nodeType,
+            status: result.status,
+        },
+    ], [
+        { key: "runnerId", label: "runnerId" },
+        { key: "nodeType", label: "节点类型" },
+        { key: "status", label: "状态" },
+    ]));
+    console.log("\n输出：");
+    console.log(typeof result.output === "string"
+        ? result.output
+        : JSON.stringify(result.output, null, 2));
+}
+export async function createAbstractScreening(options) {
+    const criteria = await getLatestCriteriaInput(options);
+    const literatureNodeId = options.literatureNodeId?.trim() ??
+        (await resolveNodeId({
+            workflowId: options.workflowId,
+            nodeType: META_SCREENING_NODE_TYPES.LITERATURE,
+            label: "文献检索",
+            configPath: options.configPath,
+        }));
+    const input = {
+        inclusion_criteria: criteria.inclusion_criteria,
+        literature_node_id: literatureNodeId,
+    };
+    // 摘要初筛耗时长，启动前提示用户耐心等待（覆盖通用「接口正在处理中…」）
+    process.stderr.write(`${META_ABSTRACT_SCREENING_WAIT_HINT}\n`);
+    const progress = createStderrProgress(options.format === "json");
+    progress.start("正在进行摘要初筛...");
+    try {
+        const created = await requestMeta(`${META_API_PREFIX}/abstract-screening-result/execute`, {
+            method: "POST",
+            body: {
+                runner_id: options.workflowId,
+                node_type: META_SCREENING_NODE_TYPES.ABSTRACT,
+                input,
+            },
+            configPath: options.configPath,
+            action: "摘要初筛",
+        });
+        if (!created.node_id) {
+            throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, "摘要初筛响应缺少 node_id");
+        }
+        const sseController = new AbortController();
+        const sseProgress = startScreeningProgressSse({
+            workflowId: options.workflowId,
+            nodeId: created.node_id,
+            label: "摘要初筛",
+            signal: sseController.signal,
+        });
+        await pollMetaNodeStatus({
+            workflowId: options.workflowId,
+            nodeId: created.node_id,
+            configPath: options.configPath,
+        }).finally(() => {
+            sseController.abort();
+        });
+        await sseProgress;
+        const output = await getMetaNodeOutput({
+            workflowId: options.workflowId,
+            nodeId: created.node_id,
+            configPath: options.configPath,
+        });
+        progress.finish("摘要初筛完成，正在输出结果...");
+        const stepResult = {
+            runnerId: options.workflowId,
+            nodeId: created.node_id,
+            nodeType: META_SCREENING_NODE_TYPES.ABSTRACT,
+            status: output.data.status,
+            input,
+            output: extractNodeOutput(output.data),
+            node: output.data,
+        };
+        const listResult = await listAbstractScreening({
+            workflowId: options.workflowId,
+            nodeId: created.node_id,
+            page: 1,
+            limit: 10,
+            configPath: options.configPath,
+        });
+        return withScreeningTable(stepResult, listResult.table ?? {
+            columns: [...ABSTRACT_SCREENING_COLUMNS],
+            rows: [],
+        }, listResult.displayInstruction ?? ABSTRACT_SCREENING_DISPLAY_INSTRUCTION, listResult.recordRefs, undefined, {
+            selectionOptions: listResult.selectionOptions,
+            page: listResult.page,
+            limit: listResult.limit,
+        });
+    }
+    catch (error) {
+        progress.dispose();
+        throw error;
+    }
+}
+export async function listAbstractScreening(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_SCREENING_NODE_TYPES.ABSTRACT,
+        label: "摘要初筛",
+        configPath: options.configPath,
+    });
+    const page = Math.max(1, Number(options.page ?? 1) || 1);
+    const limit = Math.max(1, Number(options.limit ?? 10) || 10);
+    const data = await requestMeta(`${META_API_PREFIX}/abstract-screening-result`, {
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+            page,
+            limit,
+            sort: options.sort,
+            order: options.order,
+            publication_type: options.publicationType?.join(","),
+        },
+        configPath: options.configPath,
+        action: "查询摘要初筛列表",
+    });
+    const table = buildAbstractScreeningTable(data);
+    const recordRefs = buildScreeningRecordRefs(data);
+    const selectionOptions = buildScreeningSelectionOptions(recordRefs, page, limit);
+    return withScreeningTable({
+        runnerId: options.workflowId,
+        nodeId,
+        data,
+    }, table, `${ABSTRACT_SCREENING_DISPLAY_INSTRUCTION}` +
+        "上传/编辑/重筛选记录：原样用本页 selectionOptions（label 展示、value 作 id）；禁止自拟或展示 UUID。" +
+        "「上传PDF文件」：先弹 title=`请选择要上传 PDF 的文献` 并停轮；选定后仅聊天索要本地路径再停轮（禁止再弹选择器/手动输入）；" +
+        "收到路径后 upload-pdf；仅上传成功后再 count-pdf 并弹初筛操作选择器。", recordRefs, undefined, { selectionOptions, page, limit });
+}
+export async function updateAbstractScreening(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_SCREENING_NODE_TYPES.ABSTRACT,
+        label: "摘要初筛",
+        configPath: options.configPath,
+    });
+    const patch = await parseJsonObjectInput(options.dataJson, options.dataFile, "--data-json", "--data-file");
+    const original = await loadScreeningLiteratureForUpdate({
+        workflowId: options.workflowId,
+        nodeId,
+        endpoint: "abstract-screening-result",
+        recordId: options.id,
+        configPath: options.configPath,
+    });
+    const input = normalizeScreeningLiteratureInput({ ...original, ...patch }, options.id);
+    const data = await requestMeta(`${META_API_PREFIX}/abstract-screening-result`, {
+        method: "PUT",
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+            abstract_screening_id: options.id,
+        },
+        body: input,
+        configPath: options.configPath,
+        action: "更新摘要初筛文献",
+    });
+    return { runnerId: options.workflowId, nodeId, input, data };
+}
+export async function rerunAbstractScreening(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_SCREENING_NODE_TYPES.ABSTRACT,
+        label: "摘要初筛",
+        configPath: options.configPath,
+    });
+    const ids = await parseJsonStringArrayInput(options.idsJson, options.idsFile, "--ids-json", "--ids-file");
+    if (ids.length === 0) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "重新摘要初筛至少需要一条文献 ID");
+    }
+    // 重筛前快照，用于构建「原结果 / 新结果」对比表
+    const beforeMap = await loadScreeningRecordsByIds({
+        workflowId: options.workflowId,
+        nodeId,
+        endpoint: "abstract-screening-result",
+        ids,
+        configPath: options.configPath,
+        action: "读取重筛前初筛记录",
+    });
+    const missingBefore = ids.filter((id) => !beforeMap.has(id));
+    if (missingBefore.length > 0) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `未找到待重新筛选的初筛记录：${missingBefore.join(", ")}`);
+    }
+    const criteria = options.inclusionCriteria
+        ? { inclusion_criteria: options.inclusionCriteria }
+        : await getLatestCriteriaInput(options);
+    const input = {
+        inclusion_criteria: criteria.inclusion_criteria,
+        abstract_screening_id: ids,
+    };
+    const data = await requestMeta(`${META_API_PREFIX}/abstract-screening-result/re_screening`, {
+        method: "POST",
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+        },
+        body: input,
+        configPath: options.configPath,
+        action: "重新摘要初筛",
+    });
+    await pollMetaNodeStatus({
+        workflowId: options.workflowId,
+        nodeId,
+        configPath: options.configPath,
+    });
+    const afterMap = await loadScreeningRecordsByIds({
+        workflowId: options.workflowId,
+        nodeId,
+        endpoint: "abstract-screening-result",
+        ids,
+        configPath: options.configPath,
+        action: "读取重筛后初筛记录",
+    });
+    const comparison = buildAbstractRescreenComparison({
+        ids,
+        beforeMap,
+        afterMap,
+    });
+    return withScreeningTable({
+        runnerId: options.workflowId,
+        nodeId,
+        input,
+        data,
+    }, { columns: comparison.columns, rows: comparison.rows }, ABSTRACT_RESCREEN_DISPLAY_INSTRUCTION, comparison.recordRefs, comparison.tableMarkdown);
+}
+export async function countAbstractPdf(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_SCREENING_NODE_TYPES.ABSTRACT,
+        label: "摘要初筛",
+        configPath: options.configPath,
+    });
+    const data = await requestMeta(`${META_API_PREFIX}/abstract-screening-result/count-pdf`, {
+        params: {
+            run_id: options.workflowId,
+            abstract_node_id: nodeId,
+        },
+        configPath: options.configPath,
+        action: "查询摘要初筛 PDF 数量",
+    });
+    return { runnerId: options.workflowId, nodeId, data };
+}
+/**
+ * 为一条摘要初筛记录上传单篇全文 PDF。
+ *
+ * 请求结构与网站保持一致：工作流、节点和初筛记录 ID 放在 URL query，
+ * PDF 放在 multipart/form-data 的 file 字段。多文件串行策略由调用方负责。
+ *
+ * @param options 工作流、初筛记录 ID、PDF 路径及可选节点配置。
+ * @returns 上传接口返回的数据及本次使用的工作流、节点 ID。
+ */
+export async function uploadAbstractPdf(options) {
+    const recordId = options.id.trim();
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(recordId)) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "摘要初筛结果 ID 必须使用 recordRefs 中的完整 UUID，禁止截断、缩写或重建");
+    }
+    const filePath = options.file.trim();
+    if (extname(filePath).toLowerCase() !== ".pdf") {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "初筛全文仅支持上传 PDF 文件");
+    }
+    const fileStats = await stat(filePath);
+    if (fileStats.size > MAX_PDF_UPLOAD_SIZE) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "PDF 文件不能超过 15MB");
+    }
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_SCREENING_NODE_TYPES.ABSTRACT,
+        label: "摘要初筛",
+        configPath: options.configPath,
+    });
+    const buffer = await readFile(filePath);
+    const form = new FormData();
+    form.append("file", new Blob([buffer], { type: "application/pdf" }), basename(filePath));
+    const data = await requestMeta(`${META_API_PREFIX}/abstract-screening-result/upload`, {
+        method: "POST",
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+            abstract_screening_id: recordId,
+        },
+        body: form,
+        configPath: options.configPath,
+        action: "上传全文 PDF",
+    });
+    return { runnerId: options.workflowId, nodeId, data };
+}
+export async function createFulltextScreening(options) {
+    const criteria = await getLatestCriteriaInput(options);
+    const abstractNodeId = options.abstractNodeId?.trim() ??
+        (await resolveNodeId({
+            workflowId: options.workflowId,
+            nodeType: META_SCREENING_NODE_TYPES.ABSTRACT,
+            label: "摘要初筛",
+            configPath: options.configPath,
+        }));
+    const pdfCountResult = await countAbstractPdf({
+        workflowId: options.workflowId,
+        nodeId: abstractNodeId,
+        configPath: options.configPath,
+    });
+    const pdfCount = pdfCountResult.data &&
+        typeof pdfCountResult.data === "object" &&
+        "pdf-count" in pdfCountResult.data
+        ? Number(pdfCountResult.data["pdf-count"])
+        : 0;
+    // 初筛进入全文复筛硬门禁：至少 3 篇已上传 PDF
+    if (pdfCount < 3) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "全文复筛前至少需要三篇已上传 PDF 的文献");
+    }
+    // 全文复筛耗时长，启动前提示用户耐心等待（覆盖通用「接口正在处理中…」）
+    process.stderr.write(`${META_FULLTEXT_SCREENING_WAIT_HINT}\n`);
+    const progress = createStderrProgress(options.format === "json");
+    progress.start("正在进行全文复筛...");
+    try {
+        const created = await requestMeta(`${META_API_PREFIX}/fulltext-screening/execute`, {
+            method: "POST",
+            params: {
+                run_id: options.workflowId,
+                abstract_node_id: abstractNodeId,
+            },
+            body: criteria,
+            configPath: options.configPath,
+            action: "全文复筛",
+        });
+        if (!created.node_id) {
+            throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, "全文复筛响应缺少 node_id");
+        }
+        const sseController = new AbortController();
+        const sseProgress = startScreeningProgressSse({
+            workflowId: options.workflowId,
+            nodeId: created.node_id,
+            label: "全文复筛",
+            signal: sseController.signal,
+        });
+        await pollMetaNodeStatus({
+            workflowId: options.workflowId,
+            nodeId: created.node_id,
+            configPath: options.configPath,
+        }).finally(() => {
+            sseController.abort();
+        });
+        await sseProgress;
+        const output = await getMetaNodeOutput({
+            workflowId: options.workflowId,
+            nodeId: created.node_id,
+            configPath: options.configPath,
+        });
+        progress.finish("全文复筛完成，正在输出结果...");
+        const stepResult = {
+            runnerId: options.workflowId,
+            nodeId: created.node_id,
+            nodeType: META_SCREENING_NODE_TYPES.FULLTEXT,
+            status: output.data.status,
+            input: criteria,
+            output: extractNodeOutput(output.data),
+            node: output.data,
+        };
+        const listResult = await listFulltextScreening({
+            workflowId: options.workflowId,
+            nodeId: created.node_id,
+            page: 1,
+            limit: 10,
+            configPath: options.configPath,
+        });
+        return withScreeningTable(stepResult, listResult.table ?? {
+            columns: [...FULLTEXT_SCREENING_COLUMNS],
+            rows: [],
+        }, listResult.displayInstruction ?? FULLTEXT_SCREENING_DISPLAY_INSTRUCTION, listResult.recordRefs, undefined, {
+            selectionOptions: listResult.selectionOptions,
+            page: listResult.page,
+            limit: listResult.limit,
+        });
+    }
+    catch (error) {
+        progress.dispose();
+        throw error;
+    }
+}
+export async function listFulltextScreening(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_SCREENING_NODE_TYPES.FULLTEXT,
+        label: "全文复筛",
+        configPath: options.configPath,
+    });
+    const page = Math.max(1, Number(options.page ?? 1) || 1);
+    const limit = Math.max(1, Number(options.limit ?? 10) || 10);
+    const data = await requestMeta(`${META_API_PREFIX}/fulltext-screening`, {
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+            page,
+            limit,
+            sort: options.sort,
+            order: options.order,
+            publication_type: options.publicationType?.join(","),
+        },
+        configPath: options.configPath,
+        action: "查询全文复筛列表",
+    });
+    const table = buildFulltextScreeningTable(data, page, limit);
+    const recordRefs = buildScreeningRecordRefs(data);
+    const selectionOptions = buildScreeningSelectionOptions(recordRefs, page, limit);
+    return withScreeningTable({
+        runnerId: options.workflowId,
+        nodeId,
+        data,
+    }, table, `${FULLTEXT_SCREENING_DISPLAY_INSTRUCTION}` +
+        "编辑/重筛选记录：原样用本页 selectionOptions 弹选择器（label 展示、value 作 id）；" +
+        "禁止自拟选项或展示 UUID。" +
+        "「编辑文献信息」须展示网站表单全部字段；禁止缺少、简化、翻译表单字段。", recordRefs, undefined, { selectionOptions, page, limit });
+}
+function printScreeningActionTableResult(result, format) {
+    if (format === "json") {
+        printOutput({
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            displayInstruction: result.displayInstruction,
+            tableMarkdown: result.tableMarkdown,
+            recordRefs: result.recordRefs,
+            selectionOptions: result.selectionOptions,
+            page: result.page,
+            limit: result.limit,
+        }, "json");
+        return;
+    }
+    console.log(result.tableMarkdown ?? "");
+}
+/** 下载初筛/复筛最终产物。 */
+export async function exportFinalScreeningMarkdownArtifacts(options) {
+    const abstractNodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeType: META_SCREENING_NODE_TYPES.ABSTRACT,
+        label: "摘要初筛",
+        configPath: options.configPath,
+    });
+    const fulltextNodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeType: META_SCREENING_NODE_TYPES.FULLTEXT,
+        label: "全文复筛",
+        configPath: options.configPath,
+    });
+    return Promise.all([
+        downloadScreeningExportArtifact({
+            workflowId: options.workflowId,
+            nodeId: abstractNodeId,
+            endpoint: "abstract-screening-result/export",
+            filename: "初筛结果.xlsx",
+            action: "下载初筛结果",
+            outputDirectory: options.output,
+        }),
+        downloadScreeningExportArtifact({
+            workflowId: options.workflowId,
+            nodeId: fulltextNodeId,
+            endpoint: "fulltext-screening/export",
+            filename: "复筛结果.xlsx",
+            action: "下载复筛结果",
+            outputDirectory: options.output,
+        }),
+    ]);
+}
+export async function updateFulltextScreening(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_SCREENING_NODE_TYPES.FULLTEXT,
+        label: "全文复筛",
+        configPath: options.configPath,
+    });
+    const patch = await parseJsonObjectInput(options.dataJson, options.dataFile, "--data-json", "--data-file");
+    const recordId = String(patch.id ?? "").trim();
+    if (!recordId) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "编辑全文复筛文献必须提供 id");
+    }
+    const original = await loadScreeningLiteratureForUpdate({
+        workflowId: options.workflowId,
+        nodeId,
+        endpoint: "fulltext-screening",
+        recordId,
+        configPath: options.configPath,
+    });
+    const input = normalizeScreeningLiteratureInput({ ...original, ...patch });
+    const data = await requestMeta(`${META_API_PREFIX}/fulltext-screening`, {
+        method: "PUT",
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+        },
+        body: input,
+        configPath: options.configPath,
+        action: "更新全文复筛文献",
+    });
+    return { runnerId: options.workflowId, nodeId, input, data };
+}
+export async function rerunFulltextScreening(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_SCREENING_NODE_TYPES.FULLTEXT,
+        label: "全文复筛",
+        configPath: options.configPath,
+    });
+    const ids = await parseJsonStringArrayInput(options.idsJson, options.idsFile, "--ids-json", "--ids-file");
+    const input = { fulltext_screening_output_ids: ids };
+    const data = await requestMeta(`${META_API_PREFIX}/fulltext-screening/re-execute-on-selected`, {
+        method: "POST",
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+        },
+        body: input,
+        configPath: options.configPath,
+        action: "重新全文复筛",
+    });
+    await pollMetaNodeStatus({
+        workflowId: options.workflowId,
+        nodeId,
+        configPath: options.configPath,
+    });
+    return { runnerId: options.workflowId, nodeId, input, data };
+}
+export async function checkFulltextScreening(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_SCREENING_NODE_TYPES.FULLTEXT,
+        label: "全文复筛",
+        configPath: options.configPath,
+    });
+    const data = await requestMeta(`${META_API_PREFIX}/fulltext-screening/check-before-next`, {
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+        },
+        configPath: options.configPath,
+        action: "校验全文复筛",
+    });
+    return { runnerId: options.workflowId, nodeId, data };
+}
+export async function runCreateAbstractScreening(options) {
+    const result = await createAbstractScreening(options);
+    if ((options.format ?? "markdown") !== "json" && result.tableMarkdown) {
+        console.log(result.tableMarkdown);
+        return;
+    }
+    printScreeningStepResult(result, options.format ?? "markdown");
+}
+export async function runListAbstractScreening(options) {
+    const result = await listAbstractScreening(options);
+    printScreeningActionTableResult(result, options.format ?? "markdown");
+}
+export async function runUpdateAbstractScreening(options) {
+    const result = await updateAbstractScreening(options);
+    printOutput(result, options.format ?? "markdown");
+}
+export async function runRerunAbstractScreening(options) {
+    const result = await rerunAbstractScreening(options);
+    printScreeningActionTableResult(result, options.format ?? "markdown");
+}
+export async function runCountAbstractPdf(options) {
+    const result = await countAbstractPdf(options);
+    printOutput(result, options.format ?? "markdown");
+}
+export async function runUploadAbstractPdf(options) {
+    const result = await uploadAbstractPdf(options);
+    printOutput(result, options.format ?? "markdown");
+}
+export async function runCreateFulltextScreening(options) {
+    const result = await createFulltextScreening(options);
+    printScreeningStepResult(result, options.format ?? "markdown");
+}
+export async function runListFulltextScreening(options) {
+    const result = await listFulltextScreening(options);
+    printScreeningActionTableResult(result, options.format ?? "markdown");
+}
+export async function runUpdateFulltextScreening(options) {
+    const result = await updateFulltextScreening(options);
+    printOutput(result, options.format ?? "markdown");
+}
+export async function runRerunFulltextScreening(options) {
+    const result = await rerunFulltextScreening(options);
+    printOutput(result, options.format ?? "markdown");
+}
+export async function runCheckFulltextScreening(options) {
+    const result = await checkFulltextScreening(options);
+    printOutput(result, options.format ?? "markdown");
+}
+//# sourceMappingURL=screening.js.map