med-pdf-nmo 0.1.0

package/dist/pdf.js

@@ -0,0 +1,396 @@
+import { normalizeForSearch, normalizeText } from "./normalize.js";
+let configuredPdfJs = null;
+/**
+ * Настраивает модуль PDF.js, который будет использовать runtime.
+ *
+ * В браузере это удобно вызывать, когда PDF.js загружен с CDN или через
+ * собственный bundler. В Node.js обычно достаточно пакетного импорта.
+ *
+ * @param pdfjsLib Объект модуля с методом `getDocument`.
+ */
+export function setPdfJsLib(pdfjsLib) {
+    configuredPdfJs = pdfjsLib;
+}
+async function resolvePdfJs(options = {}) {
+    if (options.pdfjsLib?.getDocument)
+        return options.pdfjsLib;
+    if (configuredPdfJs?.getDocument)
+        return configuredPdfJs;
+    const fromGlobal = globalThis.pdfjsLib ?? globalThis.PDFJS;
+    if (fromGlobal?.getDocument)
+        return fromGlobal;
+    try {
+        return await import("pdfjs-dist/legacy/build/pdf.mjs");
+    }
+    catch {
+        throw new Error("PDF.js is not available. In the browser, include pdf.js before this library or call setPdfJsLib(pdfjsLib).");
+    }
+}
+async function toUint8Array(input) {
+    if (input instanceof Uint8Array) {
+        return new Uint8Array(input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength));
+    }
+    if (input instanceof ArrayBuffer)
+        return new Uint8Array(input.slice(0));
+    if (typeof Blob !== "undefined" && input instanceof Blob) {
+        return new Uint8Array(await input.arrayBuffer());
+    }
+    if (typeof input === "string") {
+        if (typeof fetch !== "function") {
+            throw new Error("String PDF input is treated as a URL, but fetch() is not available in this environment.");
+        }
+        const response = await fetch(input);
+        if (!response.ok)
+            throw new Error(`Failed to fetch PDF: ${response.status} ${response.statusText}`);
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    if (input?.arrayBuffer && typeof input.arrayBuffer === "function") {
+        return new Uint8Array(await input.arrayBuffer());
+    }
+    throw new Error("PDF input must be ArrayBuffer, Uint8Array, Blob/File, or URL string.");
+}
+function lineKey(item) {
+    const [, , , , , y] = item.transform ?? [1, 0, 0, 1, 0, 0];
+    return Math.round(y / 3) * 3;
+}
+function itemX(item) {
+    return item.transform?.[4] ?? 0;
+}
+function itemY(item) {
+    return item.transform?.[5] ?? 0;
+}
+function groupItemsIntoLineObjects(items) {
+    const useful = items
+        .filter((item) => typeof item.str === "string" && item.str.trim())
+        .sort((a, b) => itemY(b) - itemY(a) || itemX(a) - itemX(b));
+    const groups = [];
+    for (const item of useful) {
+        const key = lineKey(item);
+        let group = groups.find((candidate) => Math.abs(candidate.key - key) <= 2);
+        if (!group) {
+            group = { key, items: [] };
+            groups.push(group);
+        }
+        group.items.push(item);
+    }
+    groups.sort((a, b) => b.key - a.key);
+    return groups
+        .map((group) => {
+        const sortedItems = group.items.sort((a, b) => itemX(a) - itemX(b));
+        const text = sortedItems
+            .map((item) => item.str.trim())
+            .join(" ")
+            .replace(/\s+/g, " ")
+            .trim();
+        return {
+            text,
+            y: group.key,
+            items: sortedItems.map((item) => ({
+                text: item.str.trim(),
+                x: itemX(item),
+                y: itemY(item),
+                width: item.width ?? 0,
+                height: item.height ?? 0,
+            })),
+        };
+    })
+        .filter((line) => line.text);
+}
+/**
+ * Убирает повторяющийся служебный текст PDF (running header/footer, ссылки),
+ * который не несет содержательной информации для скоринга.
+ *
+ * Сопоставление идет с `normalizeText` (чистая кириллица в нижнем регистре),
+ * а не с `normalizeForSearch`, потому что последняя сворачивает кириллические
+ * lookalike-символы в латиницу. Правила нарочно общие и не привязаны к
+ * конкретному документу: колонтитул "страница N из M", бегущий заголовок
+ * "клинические рекомендации - <название> - <годы>" и строки-ссылки.
+ */
+function stripLikelyBoilerplate(lines) {
+    return lines.filter((line) => {
+        const text = typeof line === "string" ? line : line.text;
+        if (!normalizeForSearch(text))
+            return false;
+        const clean = normalizeText(text);
+        if (/^страниц[аы]\s+\d+\s+из\s+\d+\b/.test(clean))
+            return false;
+        if (/^[-\s]*\d{1,3}[-\s]*$/.test(clean))
+            return false;
+        if (/(https?:\/\/|www\.|disuria\.ru)/.test(clean))
+            return false;
+        return true;
+    });
+}
+function buildPageText(lines) {
+    const out = [];
+    for (const line of lines) {
+        const previous = out[out.length - 1] ?? "";
+        const startsList = /^(\d+(?:\.\d+)*[.)]?|[-*•]|[a-zа-я]\))\s+/iu.test(line);
+        const previousEnds = /[.!?;:]$/.test(previous) || previous.length < 30;
+        if (out.length && !startsList && !previousEnds && line.length < 100) {
+            out[out.length - 1] = `${previous} ${line}`.replace(/\s+/g, " ");
+        }
+        else {
+            out.push(line);
+        }
+    }
+    return out.join("\n");
+}
+const BIBLIO_HEADING = /^(список\s+литературы|литература|библиографи)/;
+const BIBLIO_NEXT_SECTION = /^(приложение|критерии оценки качества|связанные документы)/;
+const TOC_HEADING = /^(содержание|оглавление)\b/;
+// Точечная выноска оглавления: "Диагностика ............ 12" или вариант с
+// символом многоточия "Диагностика …………… 12". 4+ точек подряд или символ «…»
+// в обычном тексте как выноска не встречаются. Одиночное «…» в прозе не опасно:
+// удаление включается только для плотного блока таких строк в начале документа.
+const TOC_LEADER = /\.(\s?\.){3,}|…/;
+/** Плоский индекс всех строк документа: {p: индекс страницы, l: индекс строки в странице}. */
+function buildFlatLineIndex(pages) {
+    const flat = [];
+    pages.forEach((page, p) => page.lines.forEach((_, l) => flat.push({ p, l })));
+    return flat;
+}
+/**
+ * Удаляет строки flat[start..end) со страниц и пересобирает text/normalized.
+ * Каждый вызов должен получать свежий flat-индекс, потому что предыдущее
+ * удаление меняет page.lines.
+ */
+function removeFlatLineSpan(pages, flat, start, end) {
+    const removeByPage = new Map();
+    for (let i = start; i < end; i += 1) {
+        const f = flat[i];
+        if (!removeByPage.has(f.p))
+            removeByPage.set(f.p, new Set());
+        removeByPage.get(f.p).add(f.l);
+    }
+    for (const [p, removed] of removeByPage) {
+        const page = pages[p];
+        page.lines = page.lines.filter((_, idx) => !removed.has(idx));
+        page.lineItems = page.lineItems.filter((_, idx) => !removed.has(idx));
+        page.text = buildPageText(page.lines);
+        page.normalized = normalizeForSearch(page.text);
+        page.charLength = page.text.length;
+    }
+}
+/**
+ * Удаляет оглавление в начале документа.
+ *
+ * В НМО-рекомендациях оглавление часто идет БЕЗ заголовка "Содержание" — сразу
+ * списком пунктов с точечными выносками ("Диагностика ........ 12"). Поэтому
+ * детект идет по сигнатуре выноски, а не по заголовку: в ранней части документа
+ * берется плотный блок от первой до последней строки с выноской и удаляется
+ * целиком (вместе с переносами длинных названий). Предшествующий заголовок
+ * "Содержание"/"Оглавление" тоже убирается, если он есть.
+ *
+ * Оглавление это навигация (названия разделов + номера страниц), оно дублирует
+ * реальные заголовки тела и не может быть ответом. Тело идет ПОСЛЕ оглавления и
+ * выносок не имеет, поэтому контент не страдает.
+ */
+function removeTableOfContents(pages) {
+    const flat = buildFlatLineIndex(pages);
+    if (!flat.length)
+        return;
+    const lineRaw = (f) => pages[f.p].lines[f.l];
+    // Пункты оглавления опознаются по точечной выноске; берем их в ранней части.
+    const earlyLimit = Math.max(1, Math.floor(flat.length * 0.4));
+    const leaderIdx = [];
+    for (let i = 0; i < earlyLimit; i += 1) {
+        if (TOC_LEADER.test(lineRaw(flat[i])))
+            leaderIdx.push(i);
+    }
+    if (leaderIdx.length < 5)
+        return;
+    let start = leaderIdx[0];
+    const end = leaderIdx[leaderIdx.length - 1] + 1;
+    // Блок должен быть плотным по выноскам (оглавление, а не случайные строки).
+    if (leaderIdx.length / Math.max(1, end - start) < 0.3)
+        return;
+    // Включить предшествующий заголовок "Содержание"/"Оглавление", если он есть.
+    const prev = start > 0 ? normalizeText(lineRaw(flat[start - 1])) : "";
+    if (prev && prev.length <= 30 && TOC_HEADING.test(prev))
+        start -= 1;
+    removeFlatLineSpan(pages, flat, start, end);
+}
+/**
+ * Удаляет секцию "Список литературы" со страниц PDF.
+ *
+ * Список литературы это ссылки и цитаты (авторы, журналы, годы), он занимает
+ * около пятой части текста и не может быть правильным ответом на клинический
+ * вопрос НМО, но засоряет поиск и числовые/латинские совпадения. Секция строго
+ * ограничена: от заголовка "Список литературы" до следующего раздела
+ * ("Приложение ..."), поэтому все приложения с клиническим контентом
+ * сохраняются. Берется последнее вхождение заголовка (чтобы не спутать с
+ * пунктом оглавления) и только в последней части документа.
+ */
+function removeBibliographySection(pages) {
+    const flat = buildFlatLineIndex(pages);
+    if (!flat.length)
+        return;
+    const lineText = (f) => normalizeText(pages[f.p].lines[f.l]);
+    let start = -1;
+    for (let i = 0; i < flat.length; i += 1) {
+        const t = lineText(flat[i]);
+        if (BIBLIO_HEADING.test(t) && t.length <= 30)
+            start = i;
+    }
+    if (start < 0 || start < flat.length * 0.4)
+        return;
+    let end = flat.length;
+    for (let i = start + 1; i < flat.length; i += 1) {
+        if (BIBLIO_NEXT_SECTION.test(lineText(flat[i]))) {
+            end = i;
+            break;
+        }
+    }
+    removeFlatLineSpan(pages, flat, start, end);
+}
+/**
+ * Ранг приложения по букве/номеру: А1=1, А2=2, А3=3, Б=4, В=5, Г=6, иначе 0.
+ *
+ * Используется, чтобы безопасно удалять только метаданные-приложения (А1-А3:
+ * состав рабочей группы, методология, связанные документы) и всегда сохранять
+ * клинические приложения (Б — алгоритмы, В — памятка пациенту, Г — шкалы).
+ */
+function appendixRank(t) {
+    if (/^приложение\s*а\s*1/.test(t) || /^приложениеа\s*1/.test(t))
+        return 1;
+    if (/^приложение\s*а\s*2/.test(t) || /^приложениеа\s*2/.test(t))
+        return 2;
+    if (/^приложение\s*а\s*3/.test(t) || /^приложениеа\s*3/.test(t))
+        return 3;
+    if (/^приложение\s*б/.test(t) || /^приложениеб/.test(t))
+        return 4;
+    if (/^приложение\s*в/.test(t) || /^приложениев/.test(t))
+        return 5;
+    if (/^приложение\s*г/.test(t) || /^приложениег/.test(t))
+        return 6;
+    return 0;
+}
+/**
+ * Удаляет метаданные-приложение: от приложения ранга `fromRank` до первого
+ * приложения с рангом >= `toRank`. Это служебные разделы (ФИО рабочей группы,
+ * методология, связанные документы), а не клинический контент. Удаление
+ * происходит ТОЛЬКО если найдены и стартовое приложение, и приложение-терминатор
+ * нужного ранга, иначе ничего не удаляется — так клинические приложения Б/В/Г
+ * не пострадают, даже если разметка PDF нестандартная. Диапазонная форма
+ * позволяет убрать одно приложение изолированно (например, только А3),
+ * сохранив соседние.
+ */
+function removeMetadataAppendices(pages, fromRank, toRank) {
+    const flat = buildFlatLineIndex(pages);
+    if (!flat.length)
+        return;
+    const lineText = (f) => normalizeText(pages[f.p].lines[f.l]);
+    let start = -1;
+    for (let i = 0; i < flat.length; i += 1) {
+        if (appendixRank(lineText(flat[i])) === fromRank)
+            start = i;
+    }
+    if (start < 0 || start < flat.length * 0.4)
+        return;
+    let end = -1;
+    for (let i = start + 1; i < flat.length; i += 1) {
+        if (appendixRank(lineText(flat[i])) >= toRank) {
+            end = i;
+            break;
+        }
+    }
+    if (end < 0)
+        return;
+    removeFlatLineSpan(pages, flat, start, end);
+}
+/**
+ * Удаляет список приложений из front matter (первые ~15% документа).
+ *
+ * В части PDF оглавление перечисляет приложения отдельным блоком без точечных
+ * выносок ("Приложение А1. Состав рабочей группы... / Приложение А2. Методология
+ * / Приложение А3. Справочные материалы"), поэтому leader-детект оглавления его
+ * не ловит. Это TOC-остаток (само тело приложений в конце документа). Удаляется
+ * только плотный блок из >=2 заголовков приложений в первых 15% — настоящие
+ * приложения тела лежат в последней части и не затрагиваются.
+ */
+function removeFrontMatterAppendixList(pages) {
+    const flat = buildFlatLineIndex(pages);
+    if (!flat.length)
+        return;
+    const limit = Math.max(1, Math.floor(flat.length * 0.15));
+    const idx = [];
+    for (let i = 0; i < limit; i += 1) {
+        if (appendixRank(normalizeText(pages[flat[i].p].lines[flat[i].l])) > 0)
+            idx.push(i);
+    }
+    if (idx.length < 2 || idx[idx.length - 1] - idx[0] > 15)
+        return;
+    const start = idx[0];
+    let end = idx[idx.length - 1] + 1;
+    // Захватить одну строку-перенос названия последнего приложения, если она короткая.
+    if (end < limit) {
+        const t = normalizeText(pages[flat[end].p].lines[flat[end].l]);
+        if (t.length > 0 && t.length < 60 && appendixRank(t) === 0 && !/^(список|термины|введение|1\b)/.test(t))
+            end += 1;
+    }
+    removeFlatLineSpan(pages, flat, start, end);
+}
+/**
+ * Извлекает текст и легкие layout-метаданные из PDF.
+ *
+ * Экстрактор принимает байты, браузерные File/Blob, ArrayBuffer-подобные
+ * объекты или URL-строки. Возвращает текст страниц, строки, нормализованный
+ * текст и флаг `ocrNeeded`, если в PDF найдено подозрительно мало текста.
+ *
+ * @param pdfInput Байты PDF, File/Blob, ArrayBuffer, Uint8Array или URL.
+ * @param options Необязательный `cacheKey` и явно переданный `pdfjsLib`.
+ * @returns Текст страниц и метаданные, которые использует predictor.
+ */
+export async function extractPdfText(pdfInput, options = {}) {
+    const pdfjs = await resolvePdfJs(options);
+    const data = await toUint8Array(pdfInput);
+    const loadingTask = pdfjs.getDocument({
+        data,
+        disableWorker: true,
+        useSystemFonts: true,
+        isEvalSupported: false,
+    });
+    const pdf = await loadingTask.promise;
+    const pages = [];
+    for (let pageNumber = 1; pageNumber <= pdf.numPages; pageNumber += 1) {
+        const page = await pdf.getPage(pageNumber);
+        const content = await page.getTextContent({
+            disableCombineTextItems: false,
+            includeMarkedContent: false,
+        });
+        const lineObjects = stripLikelyBoilerplate(groupItemsIntoLineObjects(content.items));
+        const lines = lineObjects.map((line) => line.text);
+        const text = buildPageText(lines);
+        pages.push({
+            page: pageNumber,
+            text,
+            lines,
+            lineItems: lineObjects,
+            normalized: normalizeForSearch(text),
+            charLength: text.length,
+        });
+    }
+    removeTableOfContents(pages);
+    removeFrontMatterAppendixList(pages);
+    removeBibliographySection(pages);
+    removeMetadataAppendices(pages, 1, 2);
+    const pageTextChars = pages.reduce((sum, page) => sum + page.text.length, 0);
+    return {
+        pdfId: options.cacheKey ?? (typeof pdfInput === "string" ? pdfInput : "<browser-pdf>"),
+        cacheVersion: 1,
+        pageCount: pdf.numPages,
+        extractedAt: new Date().toISOString(),
+        pages,
+        ocrNeeded: pageTextChars < Math.max(1000, pdf.numPages * 100),
+    };
+}
+/**
+ * Очищает кеш извлечения PDF.
+ *
+ * Текущая browser-first реализация хранит текст PDF в runtime-кеше predictor,
+ * поэтому эта функция намеренно оставлена как совместимый no-op.
+ */
+export function clearPdfMemoryCache() {
+    // Browser build keeps PDF text in the predictor runtime cache.
+}

package/dist/predictor/config.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Зафиксированная конфигурация predictor, выбранная по результатам
+ * измеримых валидационных прогонов.
+ */
+export declare const DEFAULT_CONFIG: {
+    multiRelativeThreshold: number;
+    multiAbsoluteThreshold: number;
+    multiGapThreshold: number;
+    multiMinAnswers: number;
+    multiThirdGapThreshold: number;
+    multiThirdRelativeThreshold: number;
+    frozenFeatureRanker: boolean;
+    multiCardinalityModel: boolean;
+    multiAllOptionsGuard: boolean;
+    multiCrowdedTailGuard: boolean;
+    pairwiseContrastRanker: boolean;
+    structuralClusterAdjustments: boolean;
+    singleSpecificityTieBreak: boolean;
+    singleTieMaxRawGap: number;
+    singleTieMinRawRatio: number;
+    singleTieSpecificityGap: number;
+    sharedMultiSegmentBoost: boolean;
+    countRelationBoost: boolean;
+    topQuestionChunks: number;
+    evidenceLimit: number;
+};
+/** Runtime-форма объекта конфигурации predictor. */
+export type PredictorConfig = typeof DEFAULT_CONFIG;

package/dist/predictor/config.js

@@ -0,0 +1,26 @@
+/**
+ * Зафиксированная конфигурация predictor, выбранная по результатам
+ * измеримых валидационных прогонов.
+ */
+export const DEFAULT_CONFIG = {
+    multiRelativeThreshold: 0.84,
+    multiAbsoluteThreshold: 12,
+    multiGapThreshold: 0.72,
+    multiMinAnswers: 2,
+    multiThirdGapThreshold: 0.45,
+    multiThirdRelativeThreshold: 0.55,
+    frozenFeatureRanker: true,
+    multiCardinalityModel: true,
+    multiAllOptionsGuard: true,
+    multiCrowdedTailGuard: true,
+    pairwiseContrastRanker: true,
+    structuralClusterAdjustments: true,
+    singleSpecificityTieBreak: true,
+    singleTieMaxRawGap: 0.2,
+    singleTieMinRawRatio: 0.94,
+    singleTieSpecificityGap: 0.5,
+    sharedMultiSegmentBoost: true,
+    countRelationBoost: true,
+    topQuestionChunks: 28,
+    evidenceLimit: 8,
+};

package/dist/predictor/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const FOCUS_STOPWORDS: Set<any>;
+export declare const LABEL_CUES: string[];
+export declare const SECTION_GENERIC_TOKENS: Set<any>;

package/dist/predictor/constants.js

@@ -0,0 +1,59 @@
+import { normalizeForSearch, uniqueTokens } from "../normalize.js";
+const FOCUS_STOPWORD_TEXT = [
+    "пациент",
+    "пациенты",
+    "пациентам",
+    "больной",
+    "больным",
+    "пострадавший",
+    "пострадавшим",
+    "заболевание",
+    "заболевания",
+    "состояние",
+    "состояния",
+    "группа",
+    "группы",
+    "острый",
+    "острым",
+    "хронический",
+    "рекомендуется",
+    "рекомендовано",
+    "рекомендованы",
+    "проведение",
+    "проводится",
+    "применение",
+    "назначается",
+    "исследование",
+    "является",
+    "являются",
+    "относятся",
+    "относится",
+    "следующие",
+    "метод",
+    "методы",
+    "цель",
+    "целью",
+    "данные",
+    "данных",
+    "наличие",
+    "форма",
+    "формы",
+    "тип",
+    "вид",
+    "виды",
+];
+export const FOCUS_STOPWORDS = new Set(FOCUS_STOPWORD_TEXT.flatMap((item) => uniqueTokens(item)));
+export const LABEL_CUES = ["легк", "средн", "тяжел", "крайн", "умерен", "локализован", "генерализован"].map((item) => normalizeForSearch(item));
+export const SECTION_GENERIC_TOKENS = new Set([
+    "поражение",
+    "поражения",
+    "повреждение",
+    "дыхательный",
+    "дыхательных",
+    "путь",
+    "путей",
+    "орган",
+    "органы",
+    "ткань",
+    "система",
+].flatMap((item) => uniqueTokens(item)));

package/dist/predictor/runtime.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Нормализует публичные варианты ответа в стабильные объекты `{ id, text }`.
+ */
+export declare function normalizeAnswers(answers: any): any;
+/**
+ * Создает или переиспользует runtime-состояние PDF для одного предсказания.
+ *
+ * Runtime содержит извлеченный текст PDF, поисковые чанки и BM25-индекс.
+ * Кеширование идет по явному `cacheKey`, URL-строке или identity объекта.
+ */
+export declare function getPdfRuntime(pdfInput: any, options?: any): Promise<any>;
+/**
+ * Очищает keyed runtime-кеш PDF.
+ */
+export declare function clearPdfRuntimeCache(): void;

package/dist/predictor/runtime.js

@@ -0,0 +1,59 @@
+import { BM25Index } from "../bm25.js";
+import { buildChunks } from "../chunk.js";
+import { extractPdfText } from "../pdf.js";
+const keyedRuntimeCache = new Map();
+const objectRuntimeCache = new WeakMap();
+function answerId(index) {
+    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    if (index < alphabet.length)
+        return alphabet[index];
+    return `A${index + 1}`;
+}
+/**
+ * Нормализует публичные варианты ответа в стабильные объекты `{ id, text }`.
+ */
+export function normalizeAnswers(answers) {
+    return answers.map((answer, index) => {
+        if (typeof answer === "string") {
+            return { id: answerId(index), text: answer };
+        }
+        return {
+            id: String(answer.id ?? answerId(index)),
+            text: String(answer.text ?? ""),
+        };
+    });
+}
+function objectKey(input) {
+    return input && typeof input === "object" ? input : null;
+}
+/**
+ * Создает или переиспользует runtime-состояние PDF для одного предсказания.
+ *
+ * Runtime содержит извлеченный текст PDF, поисковые чанки и BM25-индекс.
+ * Кеширование идет по явному `cacheKey`, URL-строке или identity объекта.
+ */
+export async function getPdfRuntime(pdfInput, options = {}) {
+    const cacheKey = options.cacheKey ?? (typeof pdfInput === "string" ? pdfInput : null);
+    if (cacheKey && keyedRuntimeCache.has(cacheKey))
+        return keyedRuntimeCache.get(cacheKey);
+    const weakKey = objectKey(pdfInput);
+    if (!cacheKey && weakKey && objectRuntimeCache.has(weakKey))
+        return objectRuntimeCache.get(weakKey);
+    const runtimePromise = (async () => {
+        const pdfText = await extractPdfText(pdfInput, options);
+        const chunks = buildChunks(pdfText);
+        const index = new BM25Index(chunks);
+        return { pdfText, chunks, index };
+    })();
+    if (cacheKey)
+        keyedRuntimeCache.set(cacheKey, runtimePromise);
+    else if (weakKey)
+        objectRuntimeCache.set(weakKey, runtimePromise);
+    return runtimePromise;
+}
+/**
+ * Очищает keyed runtime-кеш PDF.
+ */
+export function clearPdfRuntimeCache() {
+    keyedRuntimeCache.clear();
+}

package/dist/predictor/scorers/biomedical-symbols.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Возвращает короткие латинские/буквенно-цифровые токены из варианта ответа:
+ * гены, маркеры, коды и похожие biomedical-обозначения.
+ */
+export declare function latinAnswerTokens(text: any): [] | RegExpMatchArray;
+/**
+ * Ищет OCR-поддержку латинского варианта ответа на релевантных страницах.
+ * Это общий fallback для коротких biomedical-кодов, а не медицинский словарь.
+ */
+export declare function bestLatinFuzzySupport({ pages, topQuestionPages, questionTokens, answer }: {
+    pages: any;
+    topQuestionPages: any;
+    questionTokens: any;
+    answer: any;
+}): any;
+/**
+ * Проверяет, что вопрос действительно про мутации/полиморфизмы генов.
+ * Такой gate нужен, чтобы gene-specific OCR-логика не влияла на обычные вопросы.
+ */
+export declare function geneMutationQuestion(question: any): boolean;
+/**
+ * Делит текст PDF на достаточно длинные предложения. Для biomedical-symbol
+ * задач предложение часто надежнее широкого окна, потому что список генов
+ * обычно находится в одной фразе.
+ */
+export declare function sentenceSegments(text: any): string[];
+/**
+ * Для вопросов про мутации генов выбирает предложение с фокусом вопроса и
+ * проверяет, есть ли в нем вариант ответа как латинский или OCR-искаженный код.
+ */
+export declare function bestGeneSentenceSupport({ pages, topQuestionPages, question, answer }: {
+    pages: any;
+    topQuestionPages: any;
+    question: any;
+    answer: any;
+}): any;