med-pdf-nmo 0.1.0

package/dist/predictor/scorers/exact-answer.js

@@ -0,0 +1,75 @@
+import { coverage, extractNumbers, normalizeForSearch, tokenize } from "../../normalize.js";
+import { answerSearchPhrases, betterEvidence, containsNormalizedPhrase, evidenceSnippet, findPhraseOccurrences, numberCoverage, tokenHitCount, tokenizeNormalized, } from "../text-utils.js";
+function exactAnswerPhrases(answerText, answerTokens) {
+    const answerNumbers = extractNumbers(answerText);
+    const minTokenCount = Math.max(3, Math.ceil(Math.max(1, answerTokens.length) * 0.72));
+    const phrases = [];
+    const seen = new Set();
+    for (const phrase of answerSearchPhrases(answerText)) {
+        const normalized = normalizeForSearch(phrase);
+        if (!normalized || normalized.length < 10 || seen.has(normalized))
+            continue;
+        const tokens = tokenize(phrase);
+        if (tokens.length < minTokenCount)
+            continue;
+        if (answerNumbers.length && numberCoverage(answerText, normalized) < 0.99)
+            continue;
+        phrases.push({ raw: phrase, normalized, tokens });
+        seen.add(normalized);
+    }
+    return phrases;
+}
+function exactAnswerApplicable(question, answer) {
+    const normalizedQuestion = normalizeForSearch(question);
+    const answerNumbers = extractNumbers(answer.text);
+    if (answerNumbers.length < 3)
+        return false;
+    const routeDoseQuestion = containsNormalizedPhrase(normalizedQuestion, "\u0432\u043d\u0443\u0442\u0440\u044c \u043f\u043e") ||
+        (containsNormalizedPhrase(normalizedQuestion, "\u043d\u0430\u0437\u043d\u0430\u0447") &&
+            containsNormalizedPhrase(normalizedQuestion, "\u043f\u043e") &&
+            containsNormalizedPhrase(normalizedQuestion, "\u0432\u043d\u0443\u0442\u0440"));
+    return routeDoseQuestion;
+}
+export function bestExactAnswerSupport({ mode, pages, topQuestionPages, question, answer, questionTokens, answerTokens, focusTokens }) {
+    if (mode !== "single")
+        return null;
+    if (!exactAnswerApplicable(question, answer))
+        return null;
+    const phrases = exactAnswerPhrases(answer.text, answerTokens);
+    if (!phrases.length)
+        return null;
+    let best = null;
+    for (const page of pages) {
+        const nearQuestionPage = !topQuestionPages?.size || topQuestionPages.has(page.page) || topQuestionPages.has(page.page - 1) || topQuestionPages.has(page.page + 1);
+        for (const phrase of phrases) {
+            const hits = findPhraseOccurrences(page.normalized, phrase.raw, { textIsNormalized: true });
+            for (const hit of hits) {
+                const local = page.normalized.slice(Math.max(0, hit - 380), Math.min(page.normalized.length, hit + phrase.normalized.length + 380));
+                const localTokens = tokenizeNormalized(local);
+                const focusHits = tokenHitCount(focusTokens, localTokens);
+                const focusCoverage = focusTokens.length ? coverage(focusTokens, localTokens) : 0;
+                const questionCoverage = questionTokens.length ? coverage(questionTokens, localTokens) : 0;
+                if (!nearQuestionPage && focusHits < 2 && focusCoverage < 0.22)
+                    continue;
+                if (focusTokens.length && focusHits < 1 && focusCoverage < 0.16 && questionCoverage < 0.14)
+                    continue;
+                const answerLengthBonus = Math.min(4.8, phrase.tokens.length * 0.55);
+                const score = 20.2 +
+                    answerLengthBonus +
+                    Math.min(0.8, focusCoverage) * 8.2 +
+                    Math.min(4, focusHits) * 0.95 +
+                    Math.min(0.6, questionCoverage) * 2.4 +
+                    numberCoverage(answer.text, local) * 2.4 +
+                    (nearQuestionPage ? 1.2 : 0);
+                best = betterEvidence(best, {
+                    answerId: answer.id,
+                    page: page.page,
+                    text: evidenceSnippet(page.text, question, answer.text),
+                    score,
+                    kind: "exact_answer_phrase",
+                });
+            }
+        }
+    }
+    return best;
+}

package/dist/predictor/scorers/fibrosis-stage.d.ts

@@ -0,0 +1,6 @@
+export declare function bestFibrosisStageSupport({ mode, pages, question, answer }: {
+    mode: any;
+    pages: any;
+    question: any;
+    answer: any;
+}): any;

package/dist/predictor/scorers/fibrosis-stage.js

@@ -0,0 +1,103 @@
+import { extractNumbers, normalizeForSearch } from "../../normalize.js";
+import { betterEvidence, containsNormalizedPhrase, rawTokens } from "../text-utils.js";
+function fibrosisDescriptorKey(text) {
+    const normalized = normalizeForSearch(text);
+    const metavir = normalized.match(/^f\s*([0-4])\b/iu);
+    if (metavir?.[1] === "0" && containsNormalizedPhrase(normalized, "\u043e\u0442\u0441\u0443\u0442"))
+        return "none";
+    if (metavir?.[1] === "1" && containsNormalizedPhrase(normalized, "\u0431\u0435\u0437") && containsNormalizedPhrase(normalized, "\u0441\u0435\u043f\u0442"))
+        return "mild";
+    if (metavir?.[1] === "2" && containsNormalizedPhrase(normalized, "\u0435\u0434\u0438\u043d\u0438\u0447") && containsNormalizedPhrase(normalized, "\u0441\u0435\u043f\u0442"))
+        return "moderate";
+    if (metavir?.[1] === "3" && (containsNormalizedPhrase(normalized, "\u043c\u043d\u043e\u0433\u043e\u0447\u0438\u0441\u043b") || containsNormalizedPhrase(normalized, "\u0431\u0435\u0437 \u0446\u0438\u0440\u0440\u043e\u0437")))
+        return "marked";
+    if (metavir?.[1] === "4" && containsNormalizedPhrase(normalized, "\u0446\u0438\u0440\u0440\u043e\u0437"))
+        return "cirrhosis";
+    if (!containsNormalizedPhrase(normalized, "\u0444\u0438\u0431\u0440\u043e\u0437") && !containsNormalizedPhrase(normalized, "\u0446\u0438\u0440\u0440\u043e\u0437"))
+        return null;
+    if (containsNormalizedPhrase(normalized, "\u0431\u0435\u0437 \u0446\u0438\u0440\u0440\u043e\u0437") && !containsNormalizedPhrase(normalized, "\u0444\u0438\u0431\u0440\u043e\u0437"))
+        return null;
+    if (containsNormalizedPhrase(normalized, "\u0431\u0435\u0437 \u0444\u0438\u0431\u0440\u043e\u0437") || containsNormalizedPhrase(normalized, "\u043e\u0442\u0441\u0443\u0442"))
+        return "none";
+    if (containsNormalizedPhrase(normalized, "\u0441\u043b\u0430\u0431\u043e\u0432\u044b\u0440\u0430\u0436"))
+        return "mild";
+    if (containsNormalizedPhrase(normalized, "\u0443\u043c\u0435\u0440\u0435\u043d"))
+        return "moderate";
+    if (containsNormalizedPhrase(normalized, "\u0442\u044f\u0436\u0435\u043b"))
+        return "severe";
+    if (containsNormalizedPhrase(normalized, "\u0446\u0438\u0440\u0440\u043e\u0437"))
+        return "cirrhosis";
+    if (containsNormalizedPhrase(normalized, "\u0432\u044b\u0440\u0430\u0436"))
+        return "marked";
+    return null;
+}
+function questionFibrosisStage(question) {
+    const tokens = rawTokens(question);
+    const stageIndex = tokens.findIndex((token) => token.startsWith("\u0441\u0442\u0430\u0434"));
+    for (let index = Math.max(0, stageIndex); index >= 0 && index < Math.min(tokens.length, stageIndex + 4); index += 1) {
+        const token = tokens[index];
+        if (/^[0-4]$/u.test(token))
+            return token;
+    }
+    const normalized = normalizeForSearch(question);
+    const fStage = normalized.match(/\bf\s*([0-4])\b/iu);
+    return fStage?.[1] ?? null;
+}
+function answerFibrosisStage(answerText) {
+    const normalized = normalizeForSearch(answerText);
+    const exact = normalized.match(/^(?:f\s*)?([0-4])$/iu);
+    if (exact)
+        return exact[1];
+    const numbers = extractNumbers(answerText).map((item) => String(item).replace(",", "."));
+    const stageNumbers = numbers.filter((number) => /^[0-4]$/u.test(number));
+    return stageNumbers.length === 1 ? stageNumbers[0] : null;
+}
+function fibrosisRowStage(line) {
+    const normalized = normalizeForSearch(line).trim();
+    const numeric = normalized.match(/^([0-4])\s*-/u);
+    if (numeric)
+        return numeric[1];
+    const metavir = normalized.match(/^f\s*([0-4])\b/iu);
+    return metavir?.[1] ?? null;
+}
+export function bestFibrosisStageSupport({ mode, pages, question, answer }) {
+    if (mode !== "single")
+        return null;
+    const questionNorm = normalizeForSearch(question);
+    if (!containsNormalizedPhrase(questionNorm, "\u0444\u0438\u0431\u0440\u043e\u0437") &&
+        !containsNormalizedPhrase(questionNorm, "\u0446\u0438\u0440\u0440\u043e\u0437") &&
+        !containsNormalizedPhrase(questionNorm, "\u0441\u0442\u0430\u0434")) {
+        return null;
+    }
+    const qStage = questionFibrosisStage(question);
+    const qDescriptor = fibrosisDescriptorKey(question);
+    const answerStage = answerFibrosisStage(answer.text);
+    const answerDescriptor = fibrosisDescriptorKey(answer.text);
+    if (!qStage && answerStage && !containsNormalizedPhrase(questionNorm, "\u0441\u043e\u043e\u0442\u0432\u0435\u0442"))
+        return null;
+    const targetStage = qStage ?? answerStage;
+    const targetDescriptor = qStage ? answerDescriptor : qDescriptor;
+    if (!targetStage || !targetDescriptor)
+        return null;
+    let best = null;
+    for (const page of pages) {
+        const lines = page.lines ?? [];
+        for (let index = 0; index < lines.length; index += 1) {
+            const text = lines[index];
+            const stage = fibrosisRowStage(text);
+            if (stage !== targetStage)
+                continue;
+            const descriptor = fibrosisDescriptorKey(text);
+            if (descriptor !== targetDescriptor)
+                continue;
+            best = betterEvidence(best, {
+                answerId: answer.id,
+                page: page.page,
+                text,
+                score: 22.4,
+                kind: "fibrosis_stage_row",
+            });
+        }
+    }
+    return best;
+}

package/dist/predictor/scorers/focused.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Собирает компактный набор токенов вопроса, по которым остальные scorer'ы ищут
+ * релевантные страницы, строки и локальные окна в PDF.
+ *
+ * В набор попадают явные cue-фразы, числа из вопроса и негeneric-токены; это
+ * снижает шанс, что вариант ответа будет поддержан похожим, но чужим фрагментом.
+ */
+export declare function questionFocusTokens(question: any): any[];
+/**
+ * Ищет вариант ответа в небольшом окне вокруг точного/нормализованного вхождения
+ * и требует рядом фокус вопроса или совпадающие числа из вопроса.
+ */
+export declare function bestFocusedSupport({ pages, topQuestionPages, question, answer, answerTokens, focusTokens, intent }: {
+    pages: any;
+    topQuestionPages: any;
+    question: any;
+    answer: any;
+    answerTokens: any;
+    focusTokens: any;
+    intent: any;
+}): any;
+/**
+ * Возвращает кешированные line/pair-сегменты с уже посчитанной нормализацией и
+ * токенами; кеш живет на объекте страницы и не попадает в публичный результат.
+ */
+export declare function cachedLineTokenSegments(page: any): any;
+/**
+ * Сравнивает вариант ответа с локальными line/pair-сегментами и отдает поддержку
+ * только когда рядом есть фокус вопроса, числа или достаточно сильное совпадение.
+ */
+export declare function bestLineTokenSupport({ pages, topQuestionPages, question, answer, questionTokens, answerTokens, focusTokens, intent }: {
+    pages: any;
+    topQuestionPages: any;
+    question: any;
+    answer: any;
+    questionTokens: any;
+    answerTokens: any;
+    focusTokens: any;
+    intent: any;
+}): any;

package/dist/predictor/scorers/focused.js

@@ -0,0 +1,204 @@
+import { coverage, extractNumbers, normalizeForSearch, normalizeText, tokenize, uniqueTokens } from "../../normalize.js";
+import { FOCUS_STOPWORDS } from "../constants.js";
+import { answerSearchPhrases, betterEvidence, cachedPageTokens, containsNormalizedPhrase, evidenceSnippet, expandNumberToken, findPhraseOccurrences, focusedAnswerSearchPhrases, numberCoverage, pageWindow, strictSoftCoverage, tokenizeNormalized, tokenHitCount, } from "../text-utils.js";
+/**
+ * Собирает компактный набор токенов вопроса, по которым остальные scorer'ы ищут
+ * релевантные страницы, строки и локальные окна в PDF.
+ *
+ * В набор попадают явные cue-фразы, числа из вопроса и негeneric-токены; это
+ * снижает шанс, что вариант ответа будет поддержан похожим, но чужим фрагментом.
+ */
+export function questionFocusTokens(question) {
+    const allTokens = uniqueTokens(question);
+    const cueTokens = cueFocusTokens(question);
+    const numbers = new Set(extractNumbers(question).flatMap(expandNumberToken));
+    const filtered = allTokens.filter((token) => {
+        if (!token)
+            return false;
+        if (numbers.has(token) || /^\d/.test(token))
+            return true;
+        if (FOCUS_STOPWORDS.has(token))
+            return false;
+        return token.length > 2;
+    });
+    const merged = [];
+    for (const token of [...cueTokens, ...filtered]) {
+        if (!merged.includes(token))
+            merged.push(token);
+    }
+    return merged.slice(0, 16);
+}
+/**
+ * Достает из вопроса короткие смысловые хвосты после устойчивых формулировок
+ * вроде "с целью", "для" и возрастных ограничений.
+ */
+function cueFocusTokens(question) {
+    const raw = normalizeText(question);
+    const parts = [];
+    const patterns = [
+        /с\s+целью\s+(.+?)(?:\s+рекоменд|\s+провод|\s+назнач|$)/u,
+        /для\s+(.+?)(?:\s+рекоменд|\s+провод|\s+назнач|$)/u,
+        /(?:старше|младше|моложе|до|после)\s+\d+(?:[.,]\d+)?\s+(?:лет|года|месяц|дней|сут)/u,
+        /по\s+([а-яa-z0-9 -]{4,48})/u,
+    ];
+    for (const pattern of patterns) {
+        const match = raw.match(pattern);
+        if (match?.[0])
+            parts.push(match[1] ?? match[0]);
+    }
+    return uniqueTokens(parts.join(" ")).filter((token) => !FOCUS_STOPWORDS.has(token));
+}
+/**
+ * Ищет вариант ответа в небольшом окне вокруг точного/нормализованного вхождения
+ * и требует рядом фокус вопроса или совпадающие числа из вопроса.
+ */
+export function bestFocusedSupport({ pages, topQuestionPages, question, answer, answerTokens, focusTokens, intent }) {
+    if (!focusTokens?.length)
+        return null;
+    const answerPhrases = focusedAnswerSearchPhrases(answer.text).slice(0, 24);
+    let best = null;
+    for (const page of pages) {
+        if (topQuestionPages?.size && !topQuestionPages.has(page.page))
+            continue;
+        const pageNorm = page.normalized;
+        for (const phrase of answerPhrases) {
+            const normalizedPhrase = normalizeForSearch(phrase);
+            if (!normalizedPhrase || normalizedPhrase.length < 5)
+                continue;
+            const hits = findPhraseOccurrences(pageNorm, phrase, { textIsNormalized: true });
+            for (const hit of hits) {
+                const local = pageWindow(page, hit, 260);
+                const localTokens = tokenizeNormalized(local);
+                const focusCoverage = coverage(focusTokens, localTokens);
+                const questionNumberCoverage = numberCoverage(question, local);
+                if (focusCoverage < 0.22 && questionNumberCoverage <= 0)
+                    continue;
+                const answerCoverage = coverage(answerTokens, localTokens);
+                const limitedPenalty = intent.negative || intent.exception ? 0 : limitedCuePenalty(local);
+                const score = 2.2 +
+                    focusCoverage * 5.2 +
+                    answerCoverage * 1.2 +
+                    questionNumberCoverage * (intent.numeric ? 4.0 : 2.2) -
+                    limitedPenalty;
+                if (score <= 2.6)
+                    continue;
+                best = betterEvidence(best, {
+                    answerId: answer.id,
+                    page: page.page,
+                    text: evidenceSnippet(page.text, phrase, question),
+                    score,
+                    kind: "focused_answer_window",
+                });
+            }
+        }
+    }
+    return best;
+}
+/**
+ * Строит короткие строковые сегменты страницы: одну строку и пару соседних строк.
+ * Эти сегменты дают дешевый локальный evidence без широкого поиска по странице.
+ */
+function lineTokenSegments(page) {
+    const lines = page.lines ?? [];
+    const segments = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line?.length >= 8)
+            segments.push({ text: line, kind: "line" });
+        if (index + 1 < lines.length) {
+            const pair = `${line} ${lines[index + 1]}`.replace(/\s+/g, " ").trim();
+            if (pair.length >= 16 && pair.length <= 700)
+                segments.push({ text: pair, kind: "line_pair" });
+        }
+    }
+    return segments;
+}
+/**
+ * Возвращает кешированные line/pair-сегменты с уже посчитанной нормализацией и
+ * токенами; кеш живет на объекте страницы и не попадает в публичный результат.
+ */
+export function cachedLineTokenSegments(page) {
+    if (!page.__lineTokenSegments) {
+        Object.defineProperty(page, "__lineTokenSegments", {
+            value: lineTokenSegments(page).map((segment) => ({
+                ...segment,
+                normalized: normalizeForSearch(segment.text),
+                tokens: tokenize(segment.text),
+            })),
+            enumerable: false,
+        });
+    }
+    return page.__lineTokenSegments;
+}
+/**
+ * Сравнивает вариант ответа с локальными line/pair-сегментами и отдает поддержку
+ * только когда рядом есть фокус вопроса, числа или достаточно сильное совпадение.
+ */
+export function bestLineTokenSupport({ pages, topQuestionPages, question, answer, questionTokens, answerTokens, focusTokens, intent }) {
+    if (!answerTokens.length)
+        return null;
+    const numericAnswer = extractNumbers(answer.text).length > 0;
+    const minAnswerSupport = numericAnswer ? 0.65 : answerTokens.length <= 2 ? 0.95 : 0.62;
+    const usefulFocusTokens = (focusTokens?.length ? focusTokens : questionTokens).filter((token) => token.length > 2 || /^\d/.test(token));
+    if (!usefulFocusTokens.length)
+        return null;
+    const answerPhrases = answerSearchPhrases(answer.text);
+    let best = null;
+    for (const page of pages) {
+        const isTopPage = topQuestionPages?.has(page.page);
+        const pageTokens = cachedPageTokens(page);
+        const pageFocusHits = tokenHitCount(usefulFocusTokens, pageTokens);
+        const pageAnswerSupport = Math.max(strictSoftCoverage(answerTokens, pageTokens), numberCoverage(answer.text, page.normalized));
+        if (!isTopPage && (pageFocusHits < 2 || pageAnswerSupport < minAnswerSupport))
+            continue;
+        for (const segment of cachedLineTokenSegments(page)) {
+            const segmentTokens = segment.tokens;
+            if (!segmentTokens.length)
+                continue;
+            const answerCoverage = strictSoftCoverage(answerTokens, segmentTokens);
+            const numericCoverage = numberCoverage(answer.text, segment.text);
+            const answerSupport = Math.max(answerCoverage, numericCoverage);
+            if (answerSupport < minAnswerSupport)
+                continue;
+            const focusHits = tokenHitCount(usefulFocusTokens, segmentTokens);
+            const focusCoverage = coverage(usefulFocusTokens, segmentTokens);
+            const questionNumberCoverage = numberCoverage(question, segment.text);
+            const enoughFocus = isTopPage ? focusHits >= 1 || focusCoverage >= 0.16 : focusHits >= 2 || focusCoverage >= 0.24;
+            if (!enoughFocus && questionNumberCoverage <= 0)
+                continue;
+            const exactPhrase = answerPhrases.some((phrase) => containsNormalizedPhrase(segment.normalized, phrase));
+            const lengthPenalty = segment.text.length > 420 ? Math.min(1.4, (segment.text.length - 420) / 220) : 0;
+            const score = 3.2 +
+                answerSupport * 4.4 +
+                Math.min(0.55, focusCoverage) * 5.2 +
+                Math.min(4, focusHits) * 0.42 +
+                questionNumberCoverage * (intent.numeric ? 2.5 : 1.2) +
+                (exactPhrase ? 0.8 : 0) +
+                (isTopPage ? 0.5 : 0) -
+                lengthPenalty;
+            if (score < 6.2)
+                continue;
+            best = betterEvidence(best, {
+                answerId: answer.id,
+                page: page.page,
+                text: segment.text,
+                score,
+                kind: `line_token_${segment.kind}`,
+            });
+        }
+    }
+    return best;
+}
+/**
+ * Штрафует локальные окна с ограничивающими формулировками, чтобы "не
+ * рекомендуется" и "только при невозможности" не выглядели как обычная поддержка.
+ */
+function limitedCuePenalty(normalizedText) {
+    const limitedCues = ["не рекомендуется", "не рекомендовано", "только в случаях", "при невозможности", "невозможности", "за исключением"];
+    let penalty = 0;
+    for (const cue of limitedCues) {
+        if (containsNormalizedPhrase(normalizedText, cue))
+            penalty += 0.8;
+    }
+    return Math.min(1.6, penalty);
+}

package/dist/predictor/scorers/frequency.d.ts

@@ -0,0 +1,10 @@
+export declare function frequencyAnswer(answerText: any): boolean;
+export declare function frequencySearchPhrases(answerText: any): unknown[];
+export declare function bestFrequencyRecommendationSupport({ mode, pages, topQuestionPages, question, answer, focusTokens }: {
+    mode: any;
+    pages: any;
+    topQuestionPages: any;
+    question: any;
+    answer: any;
+    focusTokens: any;
+}): any;

package/dist/predictor/scorers/frequency.js

@@ -0,0 +1,203 @@
+import { coverage, extractNumbers, normalizeForSearch, normalizeText, tokenize, uniqueTokens } from "../../normalize.js";
+import { betterEvidence, containsNormalizedPhrase, numberCoverage, tokenHitCount } from "../text-utils.js";
+export function frequencyAnswer(answerText) {
+    const raw = normalizeText(answerText);
+    return /\d|один|два|три|четыре|пять|шесть|семь|восемь|девять/u.test(raw) && /(год|месяц|недел|дн|сут|час|(?:^|\s)ч\.?(?:\s|$)|раз)/u.test(raw);
+}
+export function frequencySearchPhrases(answerText) {
+    const raw = normalizeText(answerText);
+    const numbers = extractNumbers(answerText);
+    const phrases = new Set();
+    if (answerText && /(год|месяц|недел|дн|сут|час|(?:^|\s)ч\.?(?:\s|$)|раз|\d)/u.test(raw))
+        phrases.add(answerText);
+    for (const number of numbers) {
+        if (/год/u.test(raw)) {
+            phrases.add(`${number} год`);
+            phrases.add(`${number} раз в год`);
+        }
+        if (/месяц/u.test(raw)) {
+            phrases.add(`${number} месяц`);
+            phrases.add(`${number} месяцев`);
+            phrases.add(`${number} месяца`);
+        }
+        if (/недел/u.test(raw)) {
+            phrases.add(`${number} неделю`);
+            phrases.add(`${number} недели`);
+            phrases.add(`${number} недель`);
+        }
+        if (/(дн|сут)/u.test(raw)) {
+            phrases.add(`${number} день`);
+            phrases.add(`${number} дня`);
+            phrases.add(`${number} дней`);
+            phrases.add(`${number} сутки`);
+            phrases.add(`${number} суток`);
+        }
+        if (/час|(?:^|\s)ч\.?(?:\s|$)/u.test(raw)) {
+            phrases.add(`${number} ч`);
+            phrases.add(`${number} ч.`);
+            phrases.add(`${number} час`);
+            phrases.add(`${number} часа`);
+            phrases.add(`${number} часов`);
+        }
+    }
+    return [...phrases].filter((phrase) => {
+        const phraseNorm = normalizeForSearch(phrase);
+        if (!/\u0441\u0443\u0442/u.test(raw) && containsNormalizedPhrase(phraseNorm, "\u0441\u0443\u0442"))
+            return false;
+        if (!/\u0434\u043d/u.test(raw) && (containsNormalizedPhrase(phraseNorm, "\u0434\u0435\u043d\u044c") || containsNormalizedPhrase(phraseNorm, "\u0434\u043d\u044f") || containsNormalizedPhrase(phraseNorm, "\u0434\u043d\u0435\u0439")))
+            return false;
+        if (!/\u0447\u0430\u0441|(?:^|\s)\u0447\.?(?:\s|$)/u.test(raw) && (containsNormalizedPhrase(phraseNorm, "\u0447\u0430\u0441") || containsNormalizedPhrase(phraseNorm, "\u0447.")))
+            return false;
+        if (/^\d+\s+\u0447$/u.test(phraseNorm))
+            return true;
+        return phraseNorm.length >= 4;
+    });
+}
+function lineWindowSegments(page, radius = 2) {
+    const lines = page.lines ?? [];
+    const segments = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const text = lines.slice(index, Math.min(lines.length, index + radius + 1)).join(" ").replace(/\s+/g, " ").trim();
+        if (text.length >= 16 && text.length <= 900) {
+            segments.push({
+                text,
+                normalized: normalizeForSearch(text),
+                tokens: tokenize(text),
+            });
+        }
+    }
+    return segments;
+}
+function cachedLineWindowSegments(page) {
+    if (!page.__lineWindowSegments) {
+        Object.defineProperty(page, "__lineWindowSegments", {
+            value: lineWindowSegments(page, 3),
+            enumerable: false,
+        });
+    }
+    return page.__lineWindowSegments;
+}
+const FREQUENCY_GENERIC_FOCUS = new Set([
+    "динамическое",
+    "динамического",
+    "наблюдение",
+    "наблюдения",
+    "пациент",
+    "пациентам",
+    "хвгс",
+    "хвгв",
+    "цп",
+    "цирроз",
+    "печень",
+    "печени",
+    "рекомендуется",
+    "рекомендовано",
+    "выполнение",
+    "выполнять",
+    "проведение",
+    "проводить",
+    "контроль",
+    "контроля",
+    "эффективность",
+    "эффективности",
+    "исключение",
+    "рецидив",
+    "раз",
+].flatMap((item) => uniqueTokens(item)));
+const FREQUENCY_ANSWER_GENERIC = new Set([
+    "внутривенное",
+    "внутривенно",
+    "внутримышечно",
+    "местное",
+    "перорально",
+    "введение",
+    "вводят",
+    "назначение",
+    "назначают",
+    "применение",
+    "применяют",
+    "дозе",
+    "доза",
+    "средняя",
+    "суточная",
+    "содержанием",
+    "составе",
+    "область",
+    "боли",
+    "сутки",
+    "суток",
+    "дней",
+    "дня",
+    "недель",
+    "недели",
+    "течение",
+    "каждые",
+    "каждый",
+    "курсом",
+    "раствора",
+    "раствор",
+    "таблеток",
+    "крема",
+    "геля",
+    "мг",
+    "мл",
+    "кг",
+    "раз",
+].flatMap((item) => uniqueTokens(item)));
+function specificFrequencyFocusTokens(focusTokens) {
+    return focusTokens.filter((token) => token.length >= 4 && !/^\d/.test(token) && !FREQUENCY_GENERIC_FOCUS.has(token));
+}
+/**
+ * Выделяет из числового варианта предмет назначения: препарат, действующее вещество
+ * или медицинское средство. Это защищает scorer от ложных совпадений, когда в PDF
+ * рядом найден только срок или кратность, но указан другой препарат.
+ */
+function frequencyAnswerSubjectTokens(answerText) {
+    const tokens = uniqueTokens(answerText).filter((token) => token.length >= 5 && !/^\d/u.test(token) && !/[/%]/u.test(token) && !FREQUENCY_ANSWER_GENERIC.has(token));
+    return tokens.slice(0, 5);
+}
+function frequencySubjectCompatible(answerText, segmentTokens) {
+    const subjectTokens = frequencyAnswerSubjectTokens(answerText);
+    if (!subjectTokens.length)
+        return true;
+    return tokenHitCount(subjectTokens, segmentTokens) > 0;
+}
+export function bestFrequencyRecommendationSupport({ mode, pages, topQuestionPages, question, answer, focusTokens }) {
+    if (mode !== "single")
+        return null;
+    if (!frequencyAnswer(answer.text))
+        return null;
+    const questionRaw = normalizeText(question);
+    if (!/(рекоменд|наблюден|контрол|выполн|провод)/u.test(questionRaw))
+        return null;
+    const phrases = frequencySearchPhrases(answer.text).slice(0, 10);
+    if (!phrases.length)
+        return null;
+    const specificTokens = specificFrequencyFocusTokens(focusTokens);
+    let best = null;
+    for (const page of pages) {
+        if (topQuestionPages?.size && !topQuestionPages.has(page.page))
+            continue;
+        for (const segment of cachedLineWindowSegments(page)) {
+            if (!containsNormalizedPhrase(segment.normalized, "рекоменд"))
+                continue;
+            const hasAnswer = phrases.some((phrase) => containsNormalizedPhrase(segment.normalized, phrase));
+            if (!hasAnswer)
+                continue;
+            if (!frequencySubjectCompatible(answer.text, segment.tokens))
+                continue;
+            if (specificTokens.length && tokenHitCount(specificTokens, segment.tokens) < Math.min(2, specificTokens.length))
+                continue;
+            const focusCoverage = coverage(focusTokens, segment.tokens);
+            const score = 11.8 + focusCoverage * 9.0 + numberCoverage(answer.text, segment.normalized) * 1.0;
+            best = betterEvidence(best, {
+                answerId: answer.id,
+                page: page.page,
+                text: segment.text,
+                score,
+                kind: "frequency_recommendation_line",
+            });
+        }
+    }
+    return best;
+}