truthguard-ai 0.2.0 → 0.3.0

package/dist-npm/Claims/index.js

@@ -0,0 +1,1669 @@
+"use strict";
+/**
+ * Claim Extractor
+ *
+ * Extracts factual claims from free-form LLM text.
+ *
+ * V1 supports:
+ *   - numbers  (integer and decimal)
+ *   - dates    (common formats → ISO-8601)
+ *   - names    (capitalised multi-word proper nouns)
+ *   - counts   (explicit "N [items]" patterns)
+ *
+ * V1 explicitly skips vague qualitative claims ("most", "significant", "many").
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseDate = tryParseDate;
+exports.parsePeriodBounds = parsePeriodBounds;
+exports.normalizeEntityName = normalizeEntityName;
+exports.entitiesMatch = entitiesMatch;
+exports.normalizeDiacritics = normalizeDiacritics;
+exports.extractClaims = extractClaims;
+const crypto_1 = require("crypto");
+const i18n_1 = require("../i18n");
+// ---------------------------------------------------------------------------
+// Vague qualifier guard
+// ---------------------------------------------------------------------------
+const VAGUE_QUALIFIERS = [
+    // ── English ──
+    'most', 'many', 'significant', 'several', 'few', 'some',
+    'various', 'numerous', 'majority', 'minority',
+    'large number', 'small number', 'a lot', 'lots', 'plenty', 'much',
+    // ── Serbian (sr) ──
+    'oko', 'otprilike', 'negde', 'većina', 'vecina', 'mnogo', 'malo',
+    'nekoliko', 'razni', 'razne', 'dosta', 'puno',
+    // ── Spanish (es) ──
+    'mucho', 'muchos', 'muchas', 'poco', 'pocos', 'algunos', 'algunas',
+    'varios', 'varias', 'mayoría', 'minoría', 'bastante', 'bastantes',
+    // ── French (fr) ──
+    'beaucoup', 'peu', 'plusieurs', 'quelques', 'divers', 'diverses',
+    'majorité', 'minorité', 'environ', 'à peu près',
+    // ── Portuguese (pt) ──
+    'muito', 'muitos', 'muitas', 'pouco', 'poucos', 'alguns', 'algumas',
+    'maioria', 'minoria', 'bastante', 'diversos', 'diversas',
+    // ── Russian (ru) ──
+    'много', 'мало', 'несколько', 'некоторые', 'различные',
+    'большинство', 'меньшинство', 'примерно', 'около', 'достаточно',
+    // ── Hindi (hi) ──
+    'बहुत', 'कुछ', 'कई', 'थोड़ा', 'ज़्यादातर', 'अधिकतर',
+    'लगभग', 'अनेक',
+    // ── Arabic (ar) ──
+    'كثير', 'قليل', 'بعض', 'عدة', 'معظم', 'أغلب',
+    'تقريبا', 'تقريباً', 'حوالي', 'نحو',
+    // ── Bengali (bn) ──
+    'অনেক', 'কিছু', 'কয়েক', 'সামান্য', 'বেশিরভাগ', 'প্রায়',
+    // ── Chinese (zh) ──
+    '很多', '一些', '少数', '大多数', '大部分', '少量', '大约', '大概',
+    // ── Japanese (ja) ──
+    'たくさん', 'いくつか', '少し', 'ほとんど', '多くの', '約', 'およそ',
+];
+/** Returns true if the surrounding text is dominated by a vague qualifier. */
+function containsVagueQualifier(text) {
+    const lower = text.toLowerCase();
+    return VAGUE_QUALIFIERS.some((q) => {
+        const re = new RegExp(`\\b${q}\\b`);
+        return re.test(lower);
+    });
+}
+// ---------------------------------------------------------------------------
+// Date parsing helpers
+// ---------------------------------------------------------------------------
+/** Month name → zero-padded number map (EN + SR). */
+const MONTH_NAMES = {
+    january: '01',
+    jan: '01',
+    february: '02',
+    feb: '02',
+    march: '03',
+    mar: '03',
+    april: '04',
+    apr: '04',
+    may: '05',
+    june: '06',
+    jun: '06',
+    july: '07',
+    jul: '07',
+    august: '08',
+    aug: '08',
+    september: '09',
+    sep: '09',
+    sept: '09',
+    october: '10',
+    oct: '10',
+    november: '11',
+    nov: '11',
+    december: '12',
+    dec: '12',
+    // Serbian nominative
+    januar: '01',
+    februar: '02',
+    mart: '03',
+    maj: '05',
+    avgust: '08',
+    septembar: '09',
+    oktobar: '10',
+    novembar: '11',
+    decembar: '12',
+    // Serbian genitive
+    januara: '01',
+    februara: '02',
+    marta: '03',
+    maja: '05',
+    avgusta: '08',
+    septembra: '09',
+    oktobra: '10',
+    novembra: '11',
+    decembra: '12',
+};
+/** Quarter start month (1-indexed). */
+const QUARTER_START_MONTH = { 1: 1, 2: 4, 3: 7, 4: 10 };
+/**
+ * Attempt to parse a date-like string into an ISO-8601 date (YYYY-MM-DD).
+ * Returns null if parsing fails.
+ */
+function tryParseDate(raw, _referenceDate) {
+    const s = raw.trim();
+    // Already ISO-8601 (YYYY-MM-DD)
+    if (/^\d{4}-\d{2}-\d{2}$/.test(s)) {
+        const d = new Date(s + 'T00:00:00Z');
+        if (!isNaN(d.getTime()))
+            return s;
+    }
+    // European: DD.MM.YYYY
+    const dotFull = s.match(/^(\d{1,2})\.(\d{1,2})\.(\d{4})$/);
+    if (dotFull) {
+        const day = dotFull[1].padStart(2, '0');
+        const mon = dotFull[2].padStart(2, '0');
+        const yr = dotFull[3];
+        const iso = `${yr}-${mon}-${day}`;
+        const dateObj = new Date(iso + 'T00:00:00Z');
+        if (!isNaN(dateObj.getTime()))
+            return iso;
+    }
+    // European short: DD.MM. or DD.MM (trailing dot optional for parsing)
+    // We validate day/month range and return a partial ISO date.
+    const dotShort = s.match(/^(\d{1,2})\.(\d{1,2})\.?$/);
+    if (dotShort) {
+        const day = parseInt(dotShort[1], 10);
+        const mon = parseInt(dotShort[2], 10);
+        const maxDay = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][mon] ?? 31;
+        if (day >= 1 && day <= maxDay && mon >= 1 && mon <= 12) {
+            return `0000-${String(mon).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+        }
+    }
+    // MM/DD/YYYY or DD/MM/YYYY — ambiguous, treat as MM/DD/YYYY
+    const slashMatch = s.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/);
+    if (slashMatch) {
+        const m = slashMatch[1].padStart(2, '0');
+        const d2 = slashMatch[2].padStart(2, '0');
+        const y = slashMatch[3];
+        const iso = `${y}-${m}-${d2}`;
+        const dateObj = new Date(iso + 'T00:00:00Z');
+        if (!isNaN(dateObj.getTime()))
+            return iso;
+    }
+    // "15 March 2024" or "March 15, 2024" (EN + SR)
+    const MONTH_NAMES_RE = 'january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|sept|october|oct|november|nov|december|dec|januar|januara|februar|februara|mart|marta|maj|maja|avgust|avgusta|septembar|septembra|oktobar|oktobra|novembar|novembra|decembar|decembra';
+    const monthDayYear = s.match(new RegExp(`^(\\d{1,2})\\s+(${MONTH_NAMES_RE})\\s+(\\d{4})$`, 'i'));
+    if (monthDayYear) {
+        const day = monthDayYear[1].padStart(2, '0');
+        const mon = MONTH_NAMES[monthDayYear[2].toLowerCase()];
+        const yr = monthDayYear[3];
+        if (mon)
+            return `${yr}-${mon}-${day}`;
+    }
+    const dayMonthYear = s.match(new RegExp(`^(${MONTH_NAMES_RE})\\s+(\\d{1,2}),?\\s+(\\d{4})$`, 'i'));
+    if (dayMonthYear) {
+        const mon = MONTH_NAMES[dayMonthYear[1].toLowerCase()];
+        const day = dayMonthYear[2].padStart(2, '0');
+        const yr = dayMonthYear[3];
+        if (mon)
+            return `${yr}-${mon}-${day}`;
+    }
+    // "March 2024" (no day — treat as YYYY-MM-01 for matching purposes)
+    const monthYear = s.match(/^(january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|sept|october|oct|november|nov|december|dec|januar|januara|februar|februara|mart|marta|maj|maja|juni|juli|avgust|avgusta|septembar|septembra|oktobar|oktobra|novembar|novembra|decembar|decembra)\s+(\d{4})$/i);
+    if (monthYear) {
+        const mon = MONTH_NAMES[monthYear[1].toLowerCase()];
+        const yr = monthYear[2];
+        if (mon)
+            return `${yr}-${mon}-01`;
+    }
+    // Quarter: "Q1 2024" or "Q3/2024"
+    const quarterMatch = s.match(/^Q([1-4])\s*[\/\s]\s*(\d{4})$/i);
+    if (quarterMatch) {
+        const q = parseInt(quarterMatch[1], 10);
+        const yr = quarterMatch[2];
+        const startMonth = QUARTER_START_MONTH[q];
+        return `${yr}-${String(startMonth).padStart(2, '0')}-01`;
+    }
+    // Half-year: "H1 2024" or "H2/2024"
+    const halfMatch = s.match(/^H([12])\s*[\/\s]\s*(\d{4})$/i);
+    if (halfMatch) {
+        const h = parseInt(halfMatch[1], 10);
+        const yr = halfMatch[2];
+        return `${yr}-${h === 1 ? '01' : '07'}-01`;
+    }
+    // Fiscal year: "FY2024", "FY 2024", "FY24"
+    const fyMatch = s.match(/^FY\s*(\d{2,4})$/i);
+    if (fyMatch) {
+        let yr = fyMatch[1];
+        if (yr.length === 2)
+            yr = `20${yr}`;
+        // Calendar-aligned fiscal year by default (Jan 1).
+        // Fiscal calendars that start Oct, Apr, etc. vary by org — we default to calendar year.
+        return `${yr}-01-01`;
+    }
+    // Relative dates (EN): "yesterday", "today", "tomorrow"
+    const lower = s.toLowerCase();
+    const ref = _referenceDate ?? new Date();
+    if (lower === 'yesterday' || lower === 'juče' || lower === 'juce') {
+        const d = new Date(ref);
+        d.setDate(d.getDate() - 1);
+        return toISO(d);
+    }
+    if (lower === 'today' || lower === 'danas') {
+        return toISO(ref);
+    }
+    if (lower === 'tomorrow' || lower === 'sutra') {
+        const d = new Date(ref);
+        d.setDate(d.getDate() + 1);
+        return toISO(d);
+    }
+    // "N days ago" / "pre N dana"
+    const daysAgoEN = s.match(/^(\d+)\s+days?\s+ago$/i);
+    if (daysAgoEN) {
+        const d = new Date(ref);
+        d.setDate(d.getDate() - parseInt(daysAgoEN[1], 10));
+        return toISO(d);
+    }
+    const daysAgoSR = s.match(/^pre\s+(\d+)\s+dan(?:a)?$/i);
+    if (daysAgoSR) {
+        const d = new Date(ref);
+        d.setDate(d.getDate() - parseInt(daysAgoSR[1], 10));
+        return toISO(d);
+    }
+    // "last week" / "prošle nedelje"
+    const lastWeekEN = /^last\s+week$/i.test(s);
+    const lastWeekSR = /^pro[sš]l[ea]\s+nedelj[ea]$/i.test(s);
+    if (lastWeekEN || lastWeekSR) {
+        const d = new Date(ref);
+        d.setDate(d.getDate() - 7);
+        // Snap to Monday of that week
+        const day = d.getDay();
+        const diff = day === 0 ? 6 : day - 1;
+        d.setDate(d.getDate() - diff);
+        return toISO(d);
+    }
+    // "last month" / "prošlog meseca"
+    const lastMonthEN = /^last\s+month$/i.test(s);
+    const lastMonthSR = /^pro[sš]lo?g?\s+meseca$/i.test(s);
+    if (lastMonthEN || lastMonthSR) {
+        const d = new Date(ref);
+        d.setMonth(d.getMonth() - 1);
+        d.setDate(1);
+        return toISO(d);
+    }
+    return null;
+}
+/** Format a Date as ISO-8601 YYYY-MM-DD. */
+function toISO(d) {
+    const yr = d.getFullYear();
+    const mo = String(d.getMonth() + 1).padStart(2, '0');
+    const dy = String(d.getDate()).padStart(2, '0');
+    return `${yr}-${mo}-${dy}`;
+}
+/** Last day of a given month. */
+function lastDayOfMonth(year, month) {
+    // month is 1-indexed
+    const d = new Date(Date.UTC(year, month, 0)); // day 0 of next month = last day of month
+    return toISO(d);
+}
+/** Quarter end month (1-indexed). */
+const QUARTER_END_MONTH = { 1: 3, 2: 6, 3: 9, 4: 12 };
+/**
+ * Parse a period expression into start/end bounds.
+ * Supports: Q1-Q4, H1/H2, FY, YTD, MTD, "last quarter", "this quarter",
+ * "last month", "this month", "MonthName YYYY", "YYYY", rolling periods.
+ *
+ * Returns null if the expression is not a recognized period.
+ */
+function parsePeriodBounds(raw, referenceDate) {
+    const s = raw.trim();
+    const lower = s.toLowerCase();
+    const ref = referenceDate ?? new Date();
+    const refYear = ref.getFullYear();
+    const refMonth = ref.getMonth() + 1; // 1-indexed
+    // Quarter: "Q1 2024", "Q3/2024", "Q1-2024"
+    const qm = s.match(/^Q([1-4])\s*[\/\s-]\s*(\d{4})$/i);
+    if (qm) {
+        const q = parseInt(qm[1], 10);
+        const yr = parseInt(qm[2], 10);
+        const sm = QUARTER_START_MONTH[q];
+        const em = QUARTER_END_MONTH[q];
+        return {
+            start: `${yr}-${String(sm).padStart(2, '0')}-01`,
+            end: lastDayOfMonth(yr, em),
+            label: s,
+        };
+    }
+    // Half-year: "H1 2024", "H2/2024"
+    const hm = s.match(/^H([12])\s*[\/\s-]\s*(\d{4})$/i);
+    if (hm) {
+        const h = parseInt(hm[1], 10);
+        const yr = parseInt(hm[2], 10);
+        return {
+            start: `${yr}-${h === 1 ? '01' : '07'}-01`,
+            end: lastDayOfMonth(yr, h === 1 ? 6 : 12),
+            label: s,
+        };
+    }
+    // Fiscal year: "FY2024", "FY 2024", "FY24"
+    const fym = s.match(/^FY\s*(\d{2,4})$/i);
+    if (fym) {
+        let yr = fym[1];
+        if (yr.length === 2)
+            yr = `20${yr}`;
+        const y = parseInt(yr, 10);
+        return {
+            start: `${y}-01-01`,
+            end: `${y}-12-31`,
+            label: s,
+        };
+    }
+    // "YTD" / "year to date" / "od pocetka godine"
+    if (/^(ytd|year[\s-]to[\s-]date|od po[cč]etka godine)$/i.test(lower)) {
+        return {
+            start: `${refYear}-01-01`,
+            end: toISO(ref),
+            label: s,
+        };
+    }
+    // "MTD" / "month to date" / "od pocetka meseca"
+    if (/^(mtd|month[\s-]to[\s-]date|od po[cč]etka meseca)$/i.test(lower)) {
+        return {
+            start: `${refYear}-${String(refMonth).padStart(2, '0')}-01`,
+            end: toISO(ref),
+            label: s,
+        };
+    }
+    // "this quarter" / "ovaj kvartal"
+    if (/^(this\s+quarter|current\s+quarter|ovaj\s+kvartal|teku[cć]i\s+kvartal)$/i.test(lower)) {
+        const q = Math.ceil(refMonth / 3);
+        const sm = QUARTER_START_MONTH[q];
+        const em = QUARTER_END_MONTH[q];
+        return {
+            start: `${refYear}-${String(sm).padStart(2, '0')}-01`,
+            end: lastDayOfMonth(refYear, em),
+            label: s,
+        };
+    }
+    // "last quarter" / "prethodni kvartal" / "prosli kvartal"
+    if (/^(last\s+quarter|previous\s+quarter|prethodn[io]\s+kvartal|pro[sš]l[io]\s+kvartal)$/i.test(lower)) {
+        let q = Math.ceil(refMonth / 3) - 1;
+        let yr = refYear;
+        if (q <= 0) {
+            q = 4;
+            yr--;
+        }
+        const sm = QUARTER_START_MONTH[q];
+        const em = QUARTER_END_MONTH[q];
+        return {
+            start: `${yr}-${String(sm).padStart(2, '0')}-01`,
+            end: lastDayOfMonth(yr, em),
+            label: s,
+        };
+    }
+    // "this month" / "ovaj mesec"
+    if (/^(this\s+month|current\s+month|ovaj\s+mesec|teku[cć]i\s+mesec)$/i.test(lower)) {
+        return {
+            start: `${refYear}-${String(refMonth).padStart(2, '0')}-01`,
+            end: lastDayOfMonth(refYear, refMonth),
+            label: s,
+        };
+    }
+    // "last month" / "proslog meseca" / "prethodni mesec"
+    if (/^(last\s+month|previous\s+month|pro[sš]lo?g?\s+meseca?|prethodn[io]\s+mesec)$/i.test(lower)) {
+        let m = refMonth - 1;
+        let yr = refYear;
+        if (m <= 0) {
+            m = 12;
+            yr--;
+        }
+        return {
+            start: `${yr}-${String(m).padStart(2, '0')}-01`,
+            end: lastDayOfMonth(yr, m),
+            label: s,
+        };
+    }
+    // "this year" / "ove godine"
+    if (/^(this\s+year|current\s+year|ov[ea]\s+godin[ea])$/i.test(lower)) {
+        return {
+            start: `${refYear}-01-01`,
+            end: `${refYear}-12-31`,
+            label: s,
+        };
+    }
+    // "last year" / "prosla godina"
+    if (/^(last\s+year|previous\s+year|pro[sš]l[ea]\s+godin[ea])$/i.test(lower)) {
+        return {
+            start: `${refYear - 1}-01-01`,
+            end: `${refYear - 1}-12-31`,
+            label: s,
+        };
+    }
+    // Rolling: "last N months" / "poslednjih N meseci" / "trailing N days"
+    const rollingMonths = lower.match(/^(?:last|poslednjih|trailing)\s+(\d+)\s+months?(?:i|a)?$/);
+    if (rollingMonths) {
+        const n = parseInt(rollingMonths[1], 10);
+        const d = new Date(ref);
+        d.setMonth(d.getMonth() - n);
+        d.setDate(1); // start of the month N months ago
+        return {
+            start: toISO(d),
+            end: toISO(ref),
+            label: s,
+        };
+    }
+    const rollingDays = lower.match(/^(?:last|poslednjih|trailing)\s+(\d+)\s+da(?:ys?|na)$/);
+    if (rollingDays) {
+        const n = parseInt(rollingDays[1], 10);
+        const d = new Date(ref);
+        d.setDate(d.getDate() - n);
+        return {
+            start: toISO(d),
+            end: toISO(ref),
+            label: s,
+        };
+    }
+    // "MonthName YYYY" → full month bounds
+    const MONTH_NAMES_RE_PERIOD = /^(january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|sept|october|oct|november|nov|december|dec|januar|januara|februar|februara|mart|marta|maj|maja|juni|juli|avgust|avgusta|septembar|septembra|oktobar|oktobra|novembar|novembra|decembar|decembra)\s+(\d{4})$/i;
+    const monthYearMatch = s.match(MONTH_NAMES_RE_PERIOD);
+    if (monthYearMatch) {
+        const mon = MONTH_NAMES[monthYearMatch[1].toLowerCase()];
+        const yr = parseInt(monthYearMatch[2], 10);
+        if (mon) {
+            const m = parseInt(mon, 10);
+            return {
+                start: `${yr}-${mon}-01`,
+                end: lastDayOfMonth(yr, m),
+                label: s,
+            };
+        }
+    }
+    // Standalone year: "2024"
+    const yearOnly = s.match(/^(\d{4})$/);
+    if (yearOnly) {
+        const yr = parseInt(yearOnly[1], 10);
+        if (yr >= 1900 && yr <= 2100) {
+            return {
+                start: `${yr}-01-01`,
+                end: `${yr}-12-31`,
+                label: s,
+            };
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+/**
+ * Count patterns — must appear before generic numbers to avoid double-counting.
+ *
+ * Examples:
+ *   "3 employees"   → count 3
+ *   "two records"   → count 2  (word-form)
+ */
+const WORD_NUMBERS = {
+    // ── English ──
+    zero: 0, one: 1, two: 2, three: 3, four: 4, five: 5,
+    six: 6, seven: 7, eight: 8, nine: 9, ten: 10,
+    eleven: 11, twelve: 12, thirteen: 13, fourteen: 14, fifteen: 15,
+    sixteen: 16, seventeen: 17, eighteen: 18, nineteen: 19, twenty: 20,
+    // ── Serbian (sr) ──
+    nula: 0, jedan: 1, jedna: 1, jedno: 1, dva: 2, dve: 2, tri: 3,
+    četiri: 4, cetiri: 4, pet: 5, šest: 6, sest: 6, sedam: 7, osam: 8,
+    devet: 9, deset: 10, jedanaest: 11, dvanaest: 12, trinaest: 13,
+    četrnaest: 14, cetrnaest: 14, petnaest: 15, šesnaest: 16, sesnaest: 16,
+    sedamnaest: 17, osamnaest: 18, devetnaest: 19, dvadeset: 20,
+    // ── Spanish (es) ──
+    cero: 0, uno: 1, una: 1, dos: 2, tres: 3, cuatro: 4, cinco: 5,
+    seis: 6, siete: 7, ocho: 8, nueve: 9, diez: 10,
+    once: 11, doce: 12, trece: 13, catorce: 14, quince: 15,
+    // ── French (fr) ── (six shared with EN, onze/quinze shared with ES)
+    zéro: 0, un: 1, une: 1, deux: 2, trois: 3, quatre: 4, cinq: 5,
+    sept: 7, huit: 8, neuf: 9, dix: 10,
+    douze: 12, treize: 13, quatorze: 14,
+    // ── Portuguese (pt) ── (cinco/quatro shared with ES, onze/doze/treze/catorze/quinze shared above)
+    um: 1, uma: 1, dois: 2, duas: 2, três: 3,
+    sete: 7, oito: 8, nove: 9, dez: 10,
+    // ── Russian (ru) ──
+    'ноль': 0, 'один': 1, 'одна': 1, 'одно': 1, 'два': 2, 'две': 2,
+    'три': 3, 'четыре': 4, 'пять': 5, 'шесть': 6, 'семь': 7,
+    'восемь': 8, 'девять': 9, 'десять': 10,
+    'одиннадцать': 11, 'двенадцать': 12, 'тринадцать': 13,
+    'четырнадцать': 14, 'пятнадцать': 15, 'шестнадцать': 16,
+    'семнадцать': 17, 'восемнадцать': 18, 'девятнадцать': 19, 'двадцать': 20,
+    // ── Hindi (hi) ──
+    'शून्य': 0, 'एक': 1, 'दो': 2, 'तीन': 3, 'चार': 4, 'पाँच': 5, 'पांच': 5,
+    'छह': 6, 'सात': 7, 'आठ': 8, 'नौ': 9, 'दस': 10,
+    // ── Arabic (ar) ──
+    'صفر': 0, 'واحد': 1, 'اثنان': 2, 'ثلاثة': 3, 'أربعة': 4, 'خمسة': 5,
+    'ستة': 6, 'سبعة': 7, 'ثمانية': 8, 'تسعة': 9, 'عشرة': 10,
+    // ── Bengali (bn) ──
+    'শূন্য': 0, 'এক': 1, 'দুই': 2, 'তিন': 3, 'চার': 4, 'পাঁচ': 5,
+    'ছয়': 6, 'সাত': 7, 'আট': 8, 'নয়': 9, 'দশ': 10,
+    // ── Chinese (zh) ──
+    '零': 0, '一': 1, '二': 2, '两': 2, '三': 3, '四': 4, '五': 5,
+    '六': 6, '七': 7, '八': 8, '九': 9, '十': 10,
+    // ── Japanese (ja) — shares kanji above, add kana ──
+    'ゼロ': 0, 'いち': 1, 'に': 2, 'さん': 3, 'よん': 4, 'ご': 5,
+    'ろく': 6, 'なな': 7, 'はち': 8, 'きゅう': 9, 'じゅう': 10,
+};
+// Month names (ALL_MONTHS) imported from ../i18n
+/**
+ * Named date-like phrases that should be extracted as date claims.
+ */
+const DATE_REGEX = new RegExp([
+    // ISO: 2024-03-15
+    '\\b(\\d{4}-\\d{2}-\\d{2})\\b',
+    // European: DD.MM.YYYY (must precede generic numeric to avoid overlap)
+    '\\b(\\d{1,2}\\.\\d{1,2}\\.\\d{4})\\b',
+    // European short: DD.MM. or DD.MM (trailing dot optional)
+    '\\b(\\d{1,2}\\.\\d{1,2}\\.?)(?=\\s|$|[,;—–\\-\\)])',
+    // MM/DD/YYYY
+    '\\b(\\d{1,2}\\/\\d{1,2}\\/\\d{4})\\b',
+    // 15 March 2024 / March 15, 2024 (EN + SR)
+    '\\b(\\d{1,2}\\s+(?:' + i18n_1.ALL_MONTHS + ')\\s+\\d{4})\\b',
+    '\\b((?:' + i18n_1.ALL_MONTHS + ')\\s+\\d{1,2},?\\s+\\d{4})\\b',
+    // March 2024 / Mart 2024 / mars 2024 / … (all 11 languages)
+    '\\b((?:' + i18n_1.ALL_MONTHS + ')\\s+\\d{4})\\b',
+    // Quarter: Q1 2024 / Q3/2024
+    '\\b(Q[1-4]\\s*[/\\s]\\s*\\d{4})\\b',
+    // Relative dates (EN)
+    '\\b(yesterday|today|tomorrow)\\b',
+    '\\b(\\d+\\s+days?\\s+ago)\\b',
+    '\\b(last\\s+(?:week|month))\\b',
+    // Relative dates (SR)
+    '\\b(ju[cč]e|danas|sutra)\\b',
+    '\\b(pre\\s+\\d+\\s+dana?)\\b',
+    '\\b(pro[sš]l[ea]\\s+nedelj[ea]|pro[sš]lo?g?\\s+meseca)\\b',
+    // Relative dates (ES)
+    '\\b(ayer|hoy|ma[ñn]ana)\\b',
+    '\\b(hace\\s+\\d+\\s+d[ií]as?)\\b',
+    '\\b(la\\s+semana\\s+pasada|el\\s+mes\\s+pasado)\\b',
+    // Relative dates (FR)
+    '\\b(hier|aujourd\'hui|demain)\\b',
+    '\\b(il\\s+y\\s+a\\s+\\d+\\s+jours?)\\b',
+    '\\b(la\\s+semaine\\s+derni[eè]re|le\\s+mois\\s+dernier)\\b',
+    // Relative dates (PT)
+    '\\b(ontem|hoje|amanh[aã])\\b',
+    '\\b(h[aá]\\s+\\d+\\s+dias?)\\b',
+    '\\b(semana\\s+passada|m[eê]s\\s+passado)\\b',
+    // Relative dates (RU)
+    '(вчера|сегодня|завтра)',
+    '(\\d+\\s+дн(?:ей|я)\\s+назад)',
+    '(на\\s+прошлой\\s+неделе|в\\s+прошлом\\s+месяце)',
+    // Relative dates (HI)
+    '(कल|आज|कल)',
+    '(\\d+\\s+दिन\\s+पहले)',
+    '(पिछले\\s+हफ्ते|पिछले\\s+महीने)',
+    // Relative dates (AR)
+    '(أمس|اليوم|غدا|غداً)',
+    '(منذ\\s+\\d+\\s+(?:يوم|أيام))',
+    '(الأسبوع\\s+الماضي|الشهر\\s+الماضي)',
+    // Relative dates (BN)
+    '(গতকাল|আজ|আগামীকাল)',
+    '(\\d+\\s+দিন\\s+আগে)',
+    '(গত\\s+সপ্তাহে|গত\\s+মাসে)',
+    // Relative dates (ZH)
+    '(昨天|今天|明天)',
+    '(\\d+\\s*天前)',
+    '(上周|上个月)',
+    // Relative dates (JA)
+    '(昨日|今日|明日)',
+    '(\\d+\\s*日前)',
+    '(先週|先月)',
+].join('|'), 'gi');
+/**
+ * Unit words that indicate a measurement rather than a count of entities.
+ * Digits followed by these words should be extracted as numbers, not counts.
+ *
+ * Covers 11 languages: English, Spanish, French, Portuguese, Serbian,
+ * Russian, Hindi, Arabic, Bengali, Mandarin Chinese, Japanese.
+ * International abbreviations (km, kg, cm, …) are universal.
+ */
+const UNIT_WORDS = new Set([
+    // ── English ──
+    'percent', 'percentage', 'degree', 'degrees',
+    'second', 'seconds', 'minute', 'minutes', 'hour', 'hours',
+    'day', 'days', 'week', 'weeks', 'month', 'months', 'year', 'years',
+    'mile', 'miles', 'meter', 'meters', 'metre', 'metres',
+    'km', 'kg', 'lb', 'lbs', 'cm', 'mm',
+    // ── Spanish (es) ──
+    'segundo', 'segundos', 'minuto', 'minutos', 'hora', 'horas',
+    'día', 'dias', 'días', 'dia', 'semana', 'semanas',
+    'mes', 'meses', 'año', 'años', 'porcentaje', 'grado', 'grados',
+    // ── French (fr) ──
+    'seconde', 'secondes', 'heure', 'heures',
+    'jour', 'jours', 'semaine', 'semaines', 'mois',
+    'an', 'ans', 'année', 'années', 'pourcent', 'pourcentage',
+    'degré', 'degrés',
+    // ── Portuguese (pt) ──
+    'hora', 'horas', 'dia', 'dias', 'semana', 'semanas',
+    'mês', 'ano', 'anos', 'porcentagem', 'porcento', 'grau', 'graus',
+    // ── Serbian (sr) ──
+    'sekunda', 'sekundi', 'sekunde',
+    'minut', 'minuta', 'minuti',
+    'sat', 'sata', 'sati',
+    'dan', 'dana', 'dani',
+    'nedelja', 'nedelje', 'sedmica', 'sedmice',
+    'mesec', 'meseci', 'meseca',
+    'godina', 'godine',
+    'procenat', 'procenata', 'posto',
+    'stepen', 'stepeni', 'stepena',
+    // ── Russian (ru) ──
+    'секунда', 'секунды', 'секунд',
+    'минута', 'минуты', 'минут',
+    'час', 'часа', 'часов',
+    'день', 'дня', 'дней',
+    'неделя', 'недели', 'недель',
+    'месяц', 'месяца', 'месяцев',
+    'год', 'года', 'лет',
+    'процент', 'процентов', 'процента',
+    'градус', 'градуса', 'градусов',
+    // ── Hindi (hi) ──
+    'सेकंड', 'मिनट', 'घंटा', 'घंटे', 'घंटों',
+    'दिन', 'दिनों',
+    'हफ्ता', 'हफ्ते', 'हफ्तों', 'सप्ताह',
+    'महीना', 'महीने', 'महीनों',
+    'साल', 'वर्ष', 'प्रतिशत', 'डिग्री',
+    // ── Arabic (ar) ──
+    'ثانية', 'ثوان', 'ثواني',
+    'دقيقة', 'دقائق',
+    'ساعة', 'ساعات',
+    'يوم', 'أيام',
+    'أسبوع', 'أسابيع',
+    'شهر', 'أشهر', 'شهور',
+    'سنة', 'سنوات',
+    'بالمئة', 'نسبة', 'درجة', 'درجات',
+    // ── Bengali (bn) ──
+    'সেকেন্ড', 'মিনিট', 'ঘণ্টা', 'দিন',
+    'সপ্তাহ', 'মাস', 'বছর', 'শতাংশ', 'ডিগ্রি',
+    // ── Mandarin Chinese (zh) ──
+    '秒', '分钟', '小时', '天', '日',
+    '周', '星期', '个月', '月', '年',
+    '百分比', '度',
+    // ── Japanese (ja) ──
+    '時間', '分', '週間', '週', 'ヶ月', 'か月',
+    'パーセント',
+    // ── Currency ──
+    'usd', 'eur', 'gbp', 'rsd', 'chf', 'jpy', 'cny', 'rub', 'inr', 'brl',
+    'dollar', 'dollars', 'euro', 'euros', 'evro', 'evra',
+    'funta', 'funti',
+    'dinar', 'dinara', 'dinari', 'din',
+    'franc', 'francs', 'franak', 'franaka',
+    'yen', 'yuan', 'ruble', 'rubles',
+    'rupee', 'rupees',
+    'real', 'reais',
+]);
+/**
+ * Count pattern: digit or word-number followed by a noun-like word.
+ * Uses a negative lookbehind `(?<![.\d-])` to prevent:
+ *   - Matching decimal fractional parts:  "5" in "94.5 employees" → no match
+ *   - Matching negative number digits:    "5" in "-5 degrees" → no match
+ * Note: "minus 3 employees" is still matched because the space between
+ * "minus" and "3" means the character immediately before "3" is a space,
+ * not a "-", so the lookbehind does not block it.
+ * Examples: "3 employees", "two records", "5 items"
+ */
+const COUNT_REGEX = /(?<![.\d-])\b(\d+|zero|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty)\s+([\p{L}]{2,})(?=[\s.,;:!?)\]>"']|$)/giu;
+/** Returns true if the match position is a list marker (e.g. "1. ", "2.\t"). */
+function isListMarker(text, matchStart, matchEnd) {
+    // Check that the character after the number is '.' followed by whitespace
+    const afterMatch = text.substring(matchEnd, matchEnd + 2);
+    if (!/^\.\s/.test(afterMatch) && !/^\.$/.test(afterMatch))
+        return false;
+    // Check that the number is at the start of a line (or start of text)
+    if (matchStart === 0)
+        return true;
+    const before = text.substring(Math.max(0, matchStart - 3), matchStart);
+    // Start of line: preceded by newline, or only whitespace/markdown since newline
+    return /(?:^|\n)\s*(?:[*\->]\s*)?$/.test(before);
+}
+/**
+ * Generic numeric pattern — matches integers, decimals, and negative numbers.
+ * Uses a negative lookbehind to avoid re-matching parts of decimal numbers
+ * (e.g., "5" in "94.5") or numbers that are part of larger numbers.
+ *
+ * Alternatives (in order):
+ * 1. European dot-thousands:  1.234.567 or 4.496  (X.XXX pattern)
+ * 2. Comma/space thousands:   1,234,567 or 1 234 567  + optional .decimal
+ * 3. Plain numbers:           12345 or 12345.67
+ */
+const NUMBER_REGEX = /(?<![.\w])(-?\d{1,3}(?:\.\d{3})+|-?\d{1,3}(?:[,\s]\d{3})*(?:\.\d+)?|-?\d+(?:\.\d+)?)\b/g;
+/**
+ * Detect European-style thousand separator: dot followed by exactly 3 digits
+ * at the end of the number string.  E.g. "4.496" → 4496, "1.845" → 1845.
+ * Does NOT match real decimals like "94.5" or "3.14".
+ */
+const DOT_THOUSANDS_RE = /^-?\d{1,3}(?:\.\d{3})+$/;
+/**
+ * Fraction pattern: "3/4", "1/2", "2/3", etc.
+ * Uses lookbehind/lookahead to avoid date-like "03/12/2024" and paths "src/lib".
+ * Matches: "1/2", "3/4", "7/8" but not "12/03/2024" or multi-segment paths.
+ */
+const FRACTION_REGEX = /(?<![/\d])(\d+)\s*\/\s*(\d+)(?![\d/])/g;
+/**
+ * Proper name pattern: two or more consecutive Title-Cased words.
+ * Avoids capturing single common title-cased words at sentence starts.
+ */
+const NAME_REGEX = /(?:^|[\s,;.!?()\[\]*])([\p{Lu}][\p{Ll}]{1,}(?:\s+[\p{Lu}][\p{Ll}]{1,})+)(?=[\s,;.!?()\[\]*]|$)/gu;
+// HEADING_STOP_WORDS imported from ../i18n
+/** Returns true if every word in the candidate name is a common heading word. */
+function isHeadingPhrase(name) {
+    const words = name.trim().split(/\s+/);
+    return words.every((w) => i18n_1.HEADING_STOP_WORDS.has(w.toLowerCase()));
+}
+/**
+ * Common sentence starters / discourse markers that get title-cased at
+ * sentence beginnings but are NOT part of a person name.
+ * Used to strip false name prefixes: "Dakle Marina" → "Marina" (not a 2-word name).
+ */
+const SENTENCE_STARTERS = new Set([
+    // Serbian
+    'dakle', 'znači', 'naime', 'stoga', 'tada', 'zato', 'upravo', 'ovde',
+    'inače', 'zapravo', 'takodje', 'takođe', 'medjutim', 'međutim',
+    'ipak', 'svakako', 'naravno', 'ustvari', 'nažalost', 'konkretno',
+    'ukratko', 'posebno', 'slobodno', 'jednostavno', 'pretpostavljam',
+    // English
+    'therefore', 'however', 'moreover', 'furthermore', 'meanwhile',
+    'basically', 'essentially', 'actually', 'unfortunately', 'specifically',
+    'obviously', 'clearly', 'indeed', 'certainly', 'additionally',
+    // status/section words
+    'status', 'poređenje', 'poredjenje', 'analiza', 'izveštaj', 'izvestaj',
+    'pregled', 'detalji', 'objašnjenje', 'objasnjenje', 'razlog',
+]);
+// ---------------------------------------------------------------------------
+// Entity proximity helper
+// ---------------------------------------------------------------------------
+/** Regex for a single Title-Cased word (proper noun candidate). */
+const PROPER_NOUN_RE = /\b([A-Z][a-zà-ž]{1,})\b/g;
+/**
+ * Find the nearest proper noun before `position` in the same sentence.
+ * Returns the name string or undefined.
+ */
+function findNearestEntity(text, position) {
+    // Extract the sentence-like segment: go back to the previous sentence boundary
+    const sentenceStart = Math.max(0, text.lastIndexOf('.', position - 1) + 1, text.lastIndexOf('\n', position - 1) + 1, text.lastIndexOf(':', position - 1) + 1);
+    const segment = text.substring(sentenceStart, position);
+    // Find all proper nouns in this segment
+    PROPER_NOUN_RE.lastIndex = 0;
+    let match;
+    let lastMatch;
+    while ((match = PROPER_NOUN_RE.exec(segment)) !== null) {
+        lastMatch = match[1];
+    }
+    return lastMatch;
+}
+/**
+ * Detect the unit word following a number at a given position.
+ * Looks at the text right after the number for a known unit word.
+ */
+function detectUnitAfterNumber(text, numberEnd) {
+    const after = text.substring(numberEnd, numberEnd + 30).trimStart().toLowerCase();
+    // Word-segmented scripts (Latin, Cyrillic, Devanagari, Arabic, Bengali)
+    const unitMatch = after.match(/^([\p{L}]+)/u);
+    if (unitMatch && UNIT_WORDS.has(unitMatch[1])) {
+        return unitMatch[1];
+    }
+    // CJK and other scripts without word boundaries — check prefix matches
+    for (const word of UNIT_WORDS) {
+        if (after.startsWith(word)) {
+            return word;
+        }
+    }
+    return undefined;
+}
+/** Currency symbols that precede numbers: "$100", "€50", "¥1000". */
+const CURRENCY_PREFIX = {
+    '$': 'usd', '€': 'eur', '£': 'gbp', '¥': 'jpy', '₹': 'inr', 'R$': 'brl',
+};
+/**
+ * Detect a currency symbol immediately before a number.
+ * E.g. "$100" → 'usd', "€50" → 'eur'.
+ */
+function detectCurrencyBeforeNumber(text, numberStart) {
+    for (const [sym, unit] of Object.entries(CURRENCY_PREFIX)) {
+        const start = numberStart - sym.length;
+        if (start >= 0 && text.substring(start, numberStart) === sym) {
+            return unit;
+        }
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Entity normalisation
+// ---------------------------------------------------------------------------
+/**
+ * Strip diacritics (č→c, ć→c, š→s, ž→z, đ→d, etc.) and lowercase.
+ * Allows entity matching across diacritic and case variants.
+ */
+function normalizeEntityName(name) {
+    return name
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '') // strip combining marks
+        .replace(/\u0111/g, 'd') // đ → d
+        .replace(/\u0110/g, 'D') // Đ → D
+        .toLowerCase()
+        .trim();
+}
+/**
+ * Check if two entity names refer to the same person/thing.
+ * Handles: case, diacritics, partial name matching (first/last name subset).
+ */
+function entitiesMatch(a, b) {
+    const normA = normalizeEntityName(a);
+    const normB = normalizeEntityName(b);
+    // Exact match after normalisation
+    if (normA === normB)
+        return true;
+    // Partial name: one is a substring of the other (e.g. "Ana" vs "Ana Jović")
+    const partsA = normA.split(/\s+/);
+    const partsB = normB.split(/\s+/);
+    // Check if any part of A matches any part of B
+    if (partsA.length !== partsB.length) {
+        const shorter = partsA.length < partsB.length ? partsA : partsB;
+        const longer = partsA.length < partsB.length ? partsB : partsA;
+        // Every word of the shorter name appears in the longer name
+        if (shorter.every((p) => longer.includes(p)))
+            return true;
+    }
+    return false;
+}
+const AGGREGATION_QUALIFIERS = [
+    {
+        op: 'sum',
+        patterns: [
+            /\bukupno\b/i, /\bukupn[aei]\b/i, /\bzbir\b/i, /\bsuma\b/i,
+            /\btotal(?:ly|e?)?\b/i, /\bsum\b/i, /\bin total\b/i,
+            /\bсума\b/i, /\bитого\b/i, /\bвсего\b/i,
+            /\ben total\b/i, /\bau total\b/i, /\bno total\b/i,
+        ],
+    },
+    {
+        op: 'avg',
+        patterns: [
+            /\bu proseku\b/i, /\bprose[čc]n[oaie]\b/i, /\bprosek\b/i,
+            /\baverage\b/i, /\bavg\.?\b/i, /\bmean\b/i,
+            /\bсредн[яеий]\b/i, /\bв среднем\b/i,
+            /\bpromedio\b/i, /\bmoyenne?\b/i, /\bmédia\b/i,
+        ],
+    },
+    {
+        op: 'count',
+        patterns: [
+            /\bbroj\b/i, /\biznos\b/i,
+            /\bcount\b/i, /\bnumber of\b/i,
+            /\bколичество\b/i, /\bчисло\b/i,
+        ],
+    },
+    {
+        op: 'min',
+        patterns: [
+            /\bminimaln[oaie]\b/i, /\bnajmanj[eai]\b/i, /\bnajni[žz][eai]\b/i,
+            /\bminimum\b/i, /\bmin\.?\b/i, /\blowest\b/i, /\bat least\b/i,
+            /\bминимальн/i, /\bминимум\b/i,
+        ],
+    },
+    {
+        op: 'max',
+        patterns: [
+            /\bmaksimaln[oaie]\b/i, /\bnajve[ćc][eai]\b/i, /\bnajvi[šs][eai]\b/i,
+            /\bmaximum\b/i, /\bmax\.?\b/i, /\bhighest\b/i, /\bat most\b/i,
+            /\bмаксимальн/i, /\bмаксимум\b/i,
+        ],
+    },
+    {
+        op: 'pct_of_total',
+        patterns: [
+            /\budeo\b/i, /\bu[čc]e[šs][ćc]e\b/i,
+            /\bshare\b/i, /\bproportion\b/i,
+            /\bдоля\b/i, /\bудельн/i,
+        ],
+    },
+];
+/**
+ * Scan the text segment *before* a number for aggregation qualifiers.
+ * Returns the detected aggregationOp or undefined.
+ */
+function detectAggregationQualifier(text, numberStart) {
+    // Look at up to 40 chars before the number
+    const before = text.substring(Math.max(0, numberStart - 40), numberStart);
+    for (const { op, patterns } of AGGREGATION_QUALIFIERS) {
+        if (patterns.some((p) => p.test(before))) {
+            return op;
+        }
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Negation detection (L1)
+// ---------------------------------------------------------------------------
+/**
+ * Multilingual negation patterns.
+ * When a claim is preceded by a negation particle, it implies value = 0 or
+ * absence. The claim gets `negated: true`.
+ *
+ * Examples: "nema kašnjenja" → negated, "no tardiness" → negated,
+ *           "nijedan zaposleni" → negated, "без опозданий" → negated.
+ */
+const NEGATION_PATTERNS = [
+    // Serbian
+    /\bnema\b/i, /\bnije\b/i, /\bnijedan[ae]?\b/i, /\bniti\s+jedan[ae]?\b/i,
+    /\bbez\b/i, /\bniko\b/i, /\bništa\b/i, /\bnikakv[oaie]\b/i,
+    // English
+    /\bno\b/i, /\bnone\b/i, /\bnot\s+any\b/i, /\bzero\b/i, /\bwithout\b/i,
+    /\bneither\b/i, /\bnor\b/i, /\bnot\s+a\s+single\b/i, /\bhasn'?t\b/i,
+    /\bisn'?t\b/i, /\bwasn'?t\b/i, /\bdoesn'?t\b/i, /\bdidn'?t\b/i,
+    // Russian
+    /\bнет\b/i, /\bне\s+было\b/i, /\bни\s+одного\b/i, /\bбез\b/i,
+    /\bникак[оиейая]\b/i, /\bникто\b/i, /\bничего\b/i,
+];
+function detectNegation(text, claimStart) {
+    const before = text.substring(Math.max(0, claimStart - 40), claimStart);
+    return NEGATION_PATTERNS.some((p) => p.test(before));
+}
+const COMPARISON_PATTERNS = [
+    {
+        op: '>',
+        patterns: [
+            /\bviše\s+od\b/i, /\bviše\s+nego\b/i, /\bpreko\b/i, /\biznad\b/i,
+            /\bmore\s+than\b/i, /\bover\b/i, /\babove\b/i, /\bexceeds?\b/i, /\bgreater\s+than\b/i,
+            /\bбольше\b/i, /\bсвыше\b/i, /\bболее\b/i,
+        ],
+    },
+    {
+        op: '<',
+        patterns: [
+            /\bmanje\s+od\b/i, /\bmanje\s+nego\b/i, /\bispod\b/i,
+            /\bless\s+than\b/i, /\bunder\b/i, /\bbelow\b/i, /\bfewer\s+than\b/i,
+            /\bменьше\b/i, /\bниже\b/i, /\bменее\b/i,
+        ],
+    },
+    {
+        op: '>=',
+        patterns: [
+            /\bnajmanje\b/i, /\bbar\s+\d/i, /\bminimum\b/i,
+            /\bat\s+least\b/i, /\bno\s+less\s+than\b/i, /\bminimum\s+of\b/i,
+            /\bкак\s+минимум\b/i, /\bне\s+менее\b/i,
+        ],
+    },
+    {
+        op: '<=',
+        patterns: [
+            /\bnajviše\b/i, /\bmaksimum\b/i, /\bdo\b(?=\s+\d)/i,
+            /\bat\s+most\b/i, /\bno\s+more\s+than\b/i, /\bmaximum\s+of\b/i, /\bup\s+to\b/i,
+            /\bне\s+более\b/i, /\bмаксимум\b/i,
+        ],
+    },
+    {
+        op: '==',
+        patterns: [
+            /\btačno\b/i, /\bupravo\b/i,
+            /\bexactly\b/i, /\bprecisely\b/i,
+            /\bровно\b/i, /\bточно\b/i,
+        ],
+    },
+];
+function detectComparisonOp(text, numberStart) {
+    const before = text.substring(Math.max(0, numberStart - 40), numberStart);
+    for (const { op, patterns } of COMPARISON_PATTERNS) {
+        if (patterns.some((p) => p.test(before))) {
+            return op;
+        }
+    }
+    return undefined;
+}
+const CHANGE_DIRECTION_PATTERNS = [
+    {
+        dir: 'increase',
+        patterns: [
+            // Serbian
+            /\brast\b/i, /\bporast(?:ao|la|lo)?\b/i, /\bpove[ćc]anj[eaou]\b/i,
+            /\bpove[ćc]a[nlot]\b/i, /\bskok\b/i, /\bsko[čc]i[lot]\b/i,
+            /\bve[ćc][eai]\s+(?:za|od|nego)\b/i,
+            // English
+            /\bincrease[ds]?\b/i, /\bgrew\b/i, /\bgrowth\b/i, /\brise[ns]?\b/i,
+            /\brose\b/i, /\bjump(?:ed|s)?\b/i, /\bgain(?:ed|s)?\b/i, /\bup\s+by\b/i,
+            // Russian
+            /\bрост\b/i, /\bувеличени[еяю]\b/i, /\bвырос(?:ла|ло)?\b/i,
+            /\bповышени[еяю]\b/i,
+        ],
+    },
+    {
+        dir: 'decrease',
+        patterns: [
+            // Serbian
+            /\bpad\b/i, /\bpa[dl](?:ao|la|lo)?\b/i, /\bsmanjivanj[eaou]\b/i,
+            /\bsmanjeno?\b/i, /\bsmanji[lot]\b/i, /\bsni[žz]enj[eaou]\b/i,
+            /\bmanj[eai]\s+(?:za|od|nego)\b/i,
+            // English
+            /\bdecrease[ds]?\b/i, /\bfell\b/i, /\bdecline[ds]?\b/i, /\bdrop(?:ped|s)?\b/i,
+            /\breduction\b/i, /\breduced?\b/i, /\bdown\s+by\b/i, /\bloss(?:es)?\b/i,
+            // Russian
+            /\bпадени[еяю]\b/i, /\bснижени[еяю]\b/i, /\bупал[оа]?\b/i,
+            /\bуменьшени[еяю]\b/i,
+        ],
+    },
+];
+function detectChangeDirection(text, numberStart) {
+    const before = text.substring(Math.max(0, numberStart - 50), numberStart);
+    for (const { dir, patterns } of CHANGE_DIRECTION_PATTERNS) {
+        if (patterns.some((p) => p.test(before))) {
+            return dir;
+        }
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Superlative / ranking detection (L1)
+// ---------------------------------------------------------------------------
+/**
+ * Detects superlative claims: "najkritičniji" → rank 1, "top 5" → rank 5.
+ * Scans text around a name/entity claim.
+ */
+const SUPERLATIVE_RANK1 = [
+    // Serbian superlatives (prefix "naj-")
+    /\bnaj[a-zčćžšđ]+[aeiou]\b/i,
+    /\bprv[oaie]\b/i, /\bposlednji?\b/i,
+    // English
+    /\bbest\b/i, /\bworst\b/i, /\bhighest\b/i, /\blowest\b/i,
+    /\bmost\b/i, /\bleast\b/i, /\bgreatest\b/i, /\bsmallest\b/i,
+    /\btop\b(?!\s*\d)/i, /\bbottom\b(?!\s*\d)/i,
+    // Russian
+    /\bнаибол[еь]/i, /\bнаименьш/i, /\bлучш/i, /\bхудш/i,
+    /\bсамый\b/i, /\bсамая\b/i, /\bсамое\b/i,
+];
+const TOP_N_PATTERN = /\btop\s+(\d+)\b/i;
+function detectRank(text, claimStart) {
+    const before = text.substring(Math.max(0, claimStart - 50), claimStart);
+    const tn = TOP_N_PATTERN.exec(before);
+    if (tn)
+        return parseInt(tn[1], 10);
+    if (SUPERLATIVE_RANK1.some((p) => p.test(before)))
+        return 1;
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Status transition detection (L1)
+// ---------------------------------------------------------------------------
+/**
+ * Detects status transitions: "promenjen sa pending na odobren".
+ * Returns [fromStatus, toStatus] or undefined.
+ */
+const TRANSITION_PATTERNS = [
+    // Serbian: promenjen/prebačen sa X na Y
+    /(?:promenjen[oaie]?|preba[čc]en[oaie]?|preš(?:ao|la|lo))\s+(?:sa|iz)\s+["']?(\w+)["']?\s+(?:na|u)\s+["']?(\w+)["']?/i,
+    // English: changed/updated from X to Y
+    /(?:changed?|updated?|moved?|transitioned?|switched?)\s+(?:from)\s+["']?(\w+)["']?\s+(?:to)\s+["']?(\w+)["']?/i,
+    // Russian: изменён с X на Y
+    /(?:изменён[аоы]?|переведён[аоы]?)\s+(?:с|из)\s+["']?(\w+)["']?\s+(?:на|в)\s+["']?(\w+)["']?/i,
+];
+function detectTransition(text, claimStart, claimEnd) {
+    const ctx = text.substring(Math.max(0, claimStart - 80), Math.min(text.length, claimEnd + 80));
+    for (const pat of TRANSITION_PATTERNS) {
+        const tm = pat.exec(ctx);
+        if (tm && tm[1] && tm[2]) {
+            return { from: tm[1].toLowerCase(), to: tm[2].toLowerCase() };
+        }
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Diacritic normalization
+// ---------------------------------------------------------------------------
+/**
+ * Strips combining diacritical marks for matching purposes.
+ * "Tasić" → "Tasic", "Čačak" → "Cacak", "Новосибирск" → "Новосибирск" (Cyrillic unchanged).
+ * Uses Unicode NFD decomposition + strip combining marks (U+0300–U+036F).
+ */
+function normalizeDiacritics(str) {
+    return str.normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/đ/g, 'd').replace(/Đ/g, 'D');
+}
+// ---------------------------------------------------------------------------
+// Domain nouns — semantically rich count context
+// ---------------------------------------------------------------------------
+/**
+ * Domain-specific nouns that provide meaningful context for count claims.
+ * When "23 zaposlenih" is extracted, the metric field is set to "employee"
+ * so downstream rules can distinguish employee counts from generic numbers.
+ */
+const DOMAIN_NOUNS = new Map([
+    // Serbian — employee/person/member/worker
+    ['zaposleni', 'employee'], ['zaposlena', 'employee'], ['zaposlenih', 'employee'],
+    ['zaposlene', 'employee'], ['zaposlen', 'employee'], ['zaposlenog', 'employee'],
+    ['osoba', 'person'], ['osobe', 'person'], ['osobа', 'person'],
+    ['radnik', 'worker'], ['radnika', 'worker'], ['radnici', 'worker'],
+    ['radnice', 'worker'],
+    ['član', 'member'], ['člana', 'member'], ['članovi', 'member'],
+    ['članova', 'member'],
+    ['smena', 'shift'], ['smene', 'shift'], ['smenu', 'shift'],
+    ['kašnjenje', 'tardiness'], ['kašnjenja', 'tardiness'],
+    ['kasnjenje', 'tardiness'], ['kasnjenja', 'tardiness'],
+    ['izostanak', 'absence'], ['izostanka', 'absence'], ['izostanaka', 'absence'], ['izostanci', 'absence'],
+    // English
+    ['employee', 'employee'], ['employees', 'employee'],
+    ['person', 'person'], ['people', 'person'], ['persons', 'person'],
+    ['worker', 'worker'], ['workers', 'worker'],
+    ['member', 'member'], ['members', 'member'],
+    ['shift', 'shift'], ['shifts', 'shift'],
+    ['absence', 'absence'], ['absences', 'absence'],
+    ['record', 'record'], ['records', 'record'],
+    ['entry', 'entry'], ['entries', 'entry'],
+    ['item', 'item'], ['items', 'item'],
+    ['incident', 'incident'], ['incidents', 'incident'],
+    // Russian
+    ['сотрудник', 'employee'], ['сотрудника', 'employee'], ['сотрудников', 'employee'],
+    ['человек', 'person'], ['людей', 'person'],
+]);
+/**
+ * Extracts factual claims from a text string.
+ *
+ * Extraction order:
+ * 1. Dates  — before numbers so date digits are not re-extracted as numbers
+ * 2. Counts — before numbers so count numerals are not re-extracted as plain numbers
+ * 3. Numbers
+ * 4. Names
+ *
+ * Vague qualitative claims are skipped.
+ */
+function extractClaims(text, options = {}) {
+    const claims = [];
+    const sourceStepId = options.sourceStepId ?? 'unknown';
+    const sourceRole = options.sourceRole ?? 'final_response';
+    const makeSource = (rawText) => ({
+        stepId: sourceStepId,
+        role: sourceRole,
+        rawText,
+    });
+    // Track character ranges already consumed so we don't double-extract.
+    const consumed = [];
+    const isConsumed = (start, end) => consumed.some(([s, e]) => start < e && end > s);
+    const consume = (start, end) => {
+        consumed.push([start, end]);
+    };
+    // 1. Dates
+    DATE_REGEX.lastIndex = 0;
+    let m;
+    while ((m = DATE_REGEX.exec(text)) !== null) {
+        const raw = m[0];
+        const start = m.index;
+        const end = start + raw.length;
+        const parsed = tryParseDate(raw, options.referenceDate);
+        if (parsed && !isConsumed(start, end)) {
+            // Disambiguation: DD.MM without trailing dot (e.g. "31.6") is ambiguous —
+            // it could be a decimal number. Reject when followed by a word (likely a
+            // unit like "sati", "hours"), accept when followed by a range separator
+            // (—, –, -), punctuation, or end of text.
+            if (/^\d{1,2}\.\d{1,2}$/.test(raw)) {
+                const afterText = text.substring(end);
+                // If followed by whitespace then a letter → likely decimal + unit, skip
+                if (/^\s+[a-zA-Z\u00C0-\u024F]/.test(afterText)) {
+                    continue;
+                }
+            }
+            consume(start, end);
+            const claim = {
+                claimId: (0, crypto_1.randomUUID)(),
+                type: 'date',
+                value: parsed,
+                rawText: raw,
+                source: makeSource(raw),
+            };
+            // -----------------------------------------------------------------------
+            // Date range context: consume adjacent range numbers so they aren't
+            // extracted as separate number claims.
+            //
+            // Patterns (before a month-year match like "mart 2026"):
+            //   "1-21. mart 2026"  → range 2026-03-01 to 2026-03-21
+            //   "10-20. marta 2026" → range 2026-03-10 to 2026-03-20
+            //   "1. - 21. mart 2026" → range
+            //   "od 1. do 21. maart" → range
+            // -----------------------------------------------------------------------
+            const beforeCtx = text.substring(Math.max(0, start - 40), start);
+            const rangePrefix = beforeCtx.match(/(\d{1,2})\s*[\.\s]*[-–—]\s*(\d{1,2})\s*[\.\s]*$/);
+            if (rangePrefix && parsed.length >= 7) {
+                // Consume the range prefix chars so numbers aren't re-extracted
+                const prefixLen = rangePrefix[0].length;
+                const prefixStart = start - prefixLen;
+                consume(prefixStart, start);
+                const yearMonth = parsed.substring(0, 8); // "YYYY-MM-"
+                const rangeStartDay = rangePrefix[1];
+                const rangeEndDay = rangePrefix[2];
+                // Range start date
+                const startDateISO = yearMonth + rangeStartDay.padStart(2, '0');
+                const startDateObj = new Date(startDateISO + 'T00:00:00Z');
+                if (!isNaN(startDateObj.getTime())) {
+                    claims.push({
+                        claimId: (0, crypto_1.randomUUID)(),
+                        type: 'date',
+                        value: startDateISO,
+                        rawText: rangePrefix[0].trim() + ' ' + raw,
+                        source: makeSource(rangePrefix[0].trim() + ' ' + raw),
+                    });
+                }
+                // Range end date (overrides the original month-only claim)
+                const endDateISO = yearMonth + rangeEndDay.padStart(2, '0');
+                const endDateObj = new Date(endDateISO + 'T00:00:00Z');
+                if (!isNaN(endDateObj.getTime())) {
+                    // Replace the original claim value (which was month-start) with range-end
+                    claim.value = endDateISO;
+                    claim.rawText = rangePrefix[0].trim() + ' ' + raw;
+                }
+            }
+            else {
+                // Also check for single-number prefix: "15. mart 2026" or "od 15. mart 2026"
+                // Only applies to month-name dates (e.g. "mart 2026") where the prefix provides
+                // the missing day. Skip when the raw match already contains a numeric day
+                // (e.g. "02.12.2024") to avoid "1. 02.12.2024" → "2024-12-01".
+                const rawAlreadyHasDay = /\d{1,2}[.\/\-]\d{1,2}[.\/\-]?\d{0,4}/.test(raw);
+                const singlePrefix = beforeCtx.match(/(\d{1,2})\s*\.\s*$/);
+                if (singlePrefix && parsed.length >= 7 && !rawAlreadyHasDay) {
+                    const prefixLen = singlePrefix[0].length;
+                    const prefixStart = start - prefixLen;
+                    consume(prefixStart, start);
+                    const yearMonth = parsed.substring(0, 8);
+                    const dayISO = yearMonth + singlePrefix[1].padStart(2, '0');
+                    const dayObj = new Date(dayISO + 'T00:00:00Z');
+                    if (!isNaN(dayObj.getTime())) {
+                        claim.value = dayISO;
+                        claim.rawText = singlePrefix[0].trim() + ' ' + raw;
+                    }
+                    // Check for "od X. do Y." pattern before the single prefix:
+                    // e.g. "od 10. do 20. marta" → also consume "10."
+                    const beforeSingle = text.substring(Math.max(0, prefixStart - 30), prefixStart);
+                    const odPrefix = beforeSingle.match(/(?:od|from|von|de|с)\s+(\d{1,2})\s*\.?\s*(?:do|to|bis|à|до)\s*$/i);
+                    if (odPrefix) {
+                        const odLen = odPrefix[0].length;
+                        const odStart = prefixStart - odLen;
+                        consume(odStart, prefixStart);
+                        // Extract range start date
+                        const rangeStartISO = yearMonth + odPrefix[1].padStart(2, '0');
+                        const rangeObj = new Date(rangeStartISO + 'T00:00:00Z');
+                        if (!isNaN(rangeObj.getTime())) {
+                            claims.push({
+                                claimId: (0, crypto_1.randomUUID)(),
+                                type: 'date',
+                                value: rangeStartISO,
+                                rawText: odPrefix[0].trim() + ' ' + singlePrefix[0].trim() + ' ' + raw,
+                                source: makeSource(odPrefix[0].trim() + ' ' + singlePrefix[0].trim() + ' ' + raw),
+                            });
+                        }
+                    }
+                }
+            }
+            claims.push(claim);
+        }
+    }
+    // 1b. Fractions (e.g. "3/4", "1/2") — must run before counts and generic numbers
+    FRACTION_REGEX.lastIndex = 0;
+    while ((m = FRACTION_REGEX.exec(text)) !== null) {
+        const raw = m[0];
+        const start = m.index;
+        const end = start + raw.length;
+        if (isConsumed(start, end))
+            continue;
+        const numerator = parseInt(m[1], 10);
+        const denominator = parseInt(m[2], 10);
+        if (denominator === 0 || numerator > 1000 || denominator > 1000)
+            continue;
+        // Skip date-like patterns (month/day or day/month): both parts ≤ 31
+        if (numerator >= 1 && numerator <= 12 && denominator >= 1 && denominator <= 31) {
+            // Check for surrounding date context (year nearby)
+            const ctx = text.substring(Math.max(0, start - 15), Math.min(text.length, end + 15));
+            if (/\b(19|20)\d{2}\b/.test(ctx))
+                continue;
+        }
+        const decimalValue = numerator / denominator;
+        consume(start, end);
+        claims.push({
+            claimId: (0, crypto_1.randomUUID)(),
+            type: 'number',
+            value: decimalValue,
+            rawText: raw,
+            source: makeSource(raw),
+            unit: detectUnitAfterNumber(text, end),
+            entity: findNearestEntity(text, start),
+        });
+    }
+    // 1c. Numeric ranges: "od 10 do 20 sati", "between 5 and 10 hours",
+    //     "от 10 до 20 часов", "de 5 a 10 horas"
+    // Extracts two endpoint claims + marks both as part of a range.
+    {
+        const RANGE_PATTERN = /\b(?:od|between|от|de|tra|entre)\s+(-?\d+(?:[.,]\d+)?)\s+(?:do|and|to|до|a|e)\s+(-?\d+(?:[.,]\d+)?)\s+([\p{L}]+)/giu;
+        let rm;
+        while ((rm = RANGE_PATTERN.exec(text)) !== null) {
+            const fullStart = rm.index;
+            const fullEnd = fullStart + rm[0].length;
+            if (isConsumed(fullStart, fullEnd))
+                continue;
+            const lo = parseFloat(rm[1].replace(',', '.'));
+            const hi = parseFloat(rm[2].replace(',', '.'));
+            const unitWord = rm[3].toLowerCase();
+            if (isNaN(lo) || isNaN(hi))
+                continue;
+            consume(fullStart, fullEnd);
+            const unit = UNIT_WORDS.has(unitWord) ? unitWord : undefined;
+            const entity = findNearestEntity(text, fullStart);
+            claims.push({
+                claimId: (0, crypto_1.randomUUID)(),
+                type: 'number',
+                value: lo,
+                rawText: rm[0],
+                source: makeSource(rm[0]),
+                unit,
+                entity,
+            });
+            claims.push({
+                claimId: (0, crypto_1.randomUUID)(),
+                type: 'number',
+                value: hi,
+                rawText: rm[0],
+                source: makeSource(rm[0]),
+                unit,
+                entity,
+            });
+        }
+    }
+    // 1d. Percentage-of patterns: "12.5% od ukupnog", "30% of total", "15% от общего"
+    // Extracted as aggregation claims with pct_of_total op.
+    {
+        const PCT_OF_PATTERN = /(-?\d+(?:[.,]\d+)?)\s*%\s*(?:od|of|от|de|du|des|do)\s+([\p{L}]+(?:\s+[\p{L}]+)?)/giu;
+        let pm;
+        while ((pm = PCT_OF_PATTERN.exec(text)) !== null) {
+            const fullStart = pm.index;
+            const fullEnd = fullStart + pm[0].length;
+            if (isConsumed(fullStart, fullEnd))
+                continue;
+            const pctValue = parseFloat(pm[1].replace(',', '.'));
+            if (isNaN(pctValue))
+                continue;
+            consume(fullStart, fullEnd);
+            claims.push({
+                claimId: (0, crypto_1.randomUUID)(),
+                type: 'number',
+                value: pctValue,
+                rawText: pm[0],
+                source: makeSource(pm[0]),
+                unit: 'percent',
+                entity: findNearestEntity(text, fullStart),
+                aggregationOp: 'pct_of_total',
+            });
+        }
+    }
+    // 2. Counts (digit or word number + noun)
+    // Compound time expressions: "7 sati 22 minuta" / "7 hours and 24 minutes"
+    // Convert to a single claim in minutes (the smallest meaningful unit).
+    // E.g. "7 sati 22 minuta" → 442 minutes, "2h 30min" → 150 minutes.
+    // Also handles optional seconds component.
+    {
+        const TIME_EXPANSION = /\b(\d{1,2})\s+(?:sat[ia]?|hours?|heure[s]?|hora[s]?|час[а-я]*)[\s,]+(?:i|and|et|y|и)?\s*(\d{1,2})\s+(?:minut[aei]?|minutes?|мин[а-я]*)(?:[\s,]+(?:i|and|et|y|и)?\s*(\d{1,2})\s+(?:sekund[aei]?|seconds?|сек[а-я]*))?\b/gi;
+        let te;
+        while ((te = TIME_EXPANSION.exec(text)) !== null) {
+            consume(te.index, te.index + te[0].length);
+            const hours = parseInt(te[1], 10);
+            const mins = parseInt(te[2], 10);
+            const totalMinutes = hours * 60 + mins;
+            claims.push({
+                claimId: (0, crypto_1.randomUUID)(),
+                type: 'number',
+                value: totalMinutes,
+                rawText: te[0],
+                source: makeSource(te[0]),
+                unit: 'minutes',
+                entity: findNearestEntity(text, te.index),
+            });
+        }
+    }
+    // Also match abbreviated compound time: "7h 22min", "7h22m", "3h 15min"
+    {
+        const COMPOUND_TIME_ABBREV = /\b(\d{1,3})\s*h(?:rs?)?\s*(?:i\s+)?(\d{1,2})\s*min(?:ut[aei]?)?\b/gi;
+        let ta;
+        while ((ta = COMPOUND_TIME_ABBREV.exec(text)) !== null) {
+            if (isConsumed(ta.index, ta.index + ta[0].length))
+                continue;
+            consume(ta.index, ta.index + ta[0].length);
+            const hours = parseInt(ta[1], 10);
+            const mins = parseInt(ta[2], 10);
+            const totalMinutes = hours * 60 + mins;
+            claims.push({
+                claimId: (0, crypto_1.randomUUID)(),
+                type: 'number',
+                value: totalMinutes,
+                rawText: ta[0],
+                source: makeSource(ta[0]),
+                unit: 'minutes',
+                entity: findNearestEntity(text, ta.index),
+            });
+        }
+    }
+    COUNT_REGEX.lastIndex = 0;
+    while ((m = COUNT_REGEX.exec(text)) !== null) {
+        const raw = m[0];
+        const numPart = m[1];
+        const nounPart = m[2];
+        const start = m.index;
+        const end = start + raw.length;
+        if (isConsumed(start, end))
+            continue;
+        if (containsVagueQualifier(text.substring(Math.max(0, start - 30), end + 30)))
+            continue;
+        // Skip time components: "24 ujutru" from "7:24 ujutru" is a time, not a count
+        {
+            const timeCtxStart = Math.max(0, start - 10);
+            const timeCtx = text.substring(timeCtxStart, Math.min(text.length, end + 10));
+            const localOffset = start - timeCtxStart;
+            const TIME_PAT = /\b(\d{1,2}):(\d{2})(?::(\d{2}))?\b/g;
+            let tm;
+            let insideTime = false;
+            while ((tm = TIME_PAT.exec(timeCtx)) !== null) {
+                const tStart = tm.index;
+                const tEnd = tStart + tm[0].length;
+                // Check if the digit portion of the count sits inside a time pattern
+                if (localOffset >= tStart && localOffset + numPart.length <= tEnd) {
+                    consume(start - (localOffset - tStart), start - (localOffset - tStart) + tm[0].length);
+                    insideTime = true;
+                    break;
+                }
+            }
+            if (insideTime)
+                continue;
+        }
+        // Unit words — measurements like "36 hours" or "5 degrees"
+        // Extract as number claim WITH unit metadata (not count)
+        if (UNIT_WORDS.has(nounPart.toLowerCase())) {
+            const numericValue = WORD_NUMBERS[numPart.toLowerCase()] !== undefined
+                ? WORD_NUMBERS[numPart.toLowerCase()]
+                : parseFloat(numPart.replace(/[,\s]/g, ''));
+            if (isNaN(numericValue))
+                continue;
+            consume(start, end);
+            const claim = {
+                claimId: (0, crypto_1.randomUUID)(),
+                type: 'number',
+                value: numericValue,
+                rawText: raw,
+                source: makeSource(raw),
+                unit: nounPart.toLowerCase(),
+                entity: findNearestEntity(text, start),
+                aggregationOp: detectAggregationQualifier(text, start),
+                ...(detectNegation(text, start) ? { negated: true } : {}),
+                ...(detectComparisonOp(text, start) ? { comparisonOp: detectComparisonOp(text, start) } : {}),
+                ...(detectChangeDirection(text, start) ? { changeDirection: detectChangeDirection(text, start) } : {}),
+            };
+            claims.push(claim);
+            continue;
+        }
+        // Skip ordered list markers: "1. " at line start (numPart ends before ".")
+        const numPartEnd = start + numPart.length;
+        if (isListMarker(text, start, numPartEnd))
+            continue;
+        const numericValue = WORD_NUMBERS[numPart.toLowerCase()] !== undefined
+            ? WORD_NUMBERS[numPart.toLowerCase()]
+            : parseFloat(numPart.replace(/[,\s]/g, ''));
+        if (isNaN(numericValue))
+            continue;
+        // Skip 4-digit years (1900–2099) when adjacent to a month name.
+        // E.g. "februar 2026\n\nSlavica" → COUNT_REGEX matches "2026 Slavica"
+        // across the newline, but 2026 is a year, not a count of "Slavica".
+        if (/^\d{4}$/.test(numPart) && numericValue >= 1900 && numericValue <= 2099) {
+            const MONTH_PAT = /(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|sept|october|oct|november|nov|december|dec|januar|januara|februar|februara|mart|marta|maj|maja|jun[ia]|jul[ia]|avgust|avgusta|septembar|septembra|oktobar|oktobra|novembar|novembra|decembar|decembra)\b/i;
+            const beforeCtx = text.substring(Math.max(0, start - 25), start);
+            if (MONTH_PAT.test(beforeCtx)) {
+                consume(start, end);
+                continue;
+            }
+        }
+        consume(start, end);
+        const domainMetric = DOMAIN_NOUNS.get(nounPart.toLowerCase());
+        const claim = {
+            claimId: (0, crypto_1.randomUUID)(),
+            type: 'count',
+            value: numericValue,
+            rawText: raw,
+            source: makeSource(raw),
+            entity: findNearestEntity(text, start),
+            aggregationOp: detectAggregationQualifier(text, start),
+            ...(domainMetric ? { metric: domainMetric } : {}),
+            ...(detectNegation(text, start) ? { negated: true } : {}),
+            ...(detectComparisonOp(text, start) ? { comparisonOp: detectComparisonOp(text, start) } : {}),
+            ...(detectChangeDirection(text, start) ? { changeDirection: detectChangeDirection(text, start) } : {}),
+        };
+        claims.push(claim);
+    }
+    // 3b. Generic numbers (not already consumed as date, count, or fraction)
+    NUMBER_REGEX.lastIndex = 0;
+    while ((m = NUMBER_REGEX.exec(text)) !== null) {
+        const raw = m[0];
+        const start = m.index;
+        const end = start + raw.length;
+        if (isConsumed(start, end))
+            continue;
+        if (containsVagueQualifier(text.substring(Math.max(0, start - 30), end + 30)))
+            continue;
+        // Skip numbers that are part of hyphenated compound words:
+        // e.g. "24-satni" (24-hour), "3-mesečni" (3-month)
+        if (text[end] === '-' && /^[a-zA-Z\u00C0-\u024F]/.test(text[end + 1] || '')) {
+            consume(start, end);
+            continue;
+        }
+        // Skip ordered list markers: "1. ", "2. " at line start
+        if (isListMarker(text, start, end)) {
+            consume(start, end);
+            continue;
+        }
+        const numericValue = DOT_THOUSANDS_RE.test(raw)
+            ? parseFloat(raw.replace(/\./g, '')) // European thousands: "4.496" → 4496
+            : parseFloat(raw.replace(/[,\s]/g, '')); // US/standard thousands: "4,496" → 4496
+        if (isNaN(numericValue))
+            continue;
+        // Skip standalone 4-digit values in the year range (1900-2099).
+        // These are almost always calendar years, not meaningful data claims.
+        // Also catch years adjacent to month names (e.g. "februar 2026") that
+        // the count extractor might otherwise pick up.
+        if (/^\d{4}$/.test(raw)) {
+            const yr = numericValue;
+            if (yr >= 1900 && yr <= 2099) {
+                consume(start, end);
+                continue;
+            }
+        }
+        // Skip European date fragments: DD.MM or DD.MM.YYYY
+        // E.g. "03.12" (3rd December), "10.12.2024" — not numeric claims.
+        // But NOT when followed by a unit word (e.g. "23.1 minuta" is a decimal, not a date).
+        if (/^\d{1,2}\.\d{1,2}(\.\d{2,4})?$/.test(raw)) {
+            const parts = raw.split('.');
+            const day = parseInt(parts[0], 10);
+            const month = parseInt(parts[1], 10);
+            const afterNum = text.substring(end);
+            const followedByUnit = /^\s+[a-zA-Z\u00C0-\u024F]/.test(afterNum);
+            if (day >= 1 && day <= 31 && month >= 1 && month <= 12 && !followedByUnit) {
+                consume(start, end);
+                continue;
+            }
+        }
+        // Skip day-of-month numbers (1-31) adjacent to month names.
+        // E.g. "Subota, 15. mart" or "March 15" — date component, not a data claim.
+        if (numericValue >= 1 && numericValue <= 31 && /^\d{1,2}$/.test(raw)) {
+            const monthPat = /(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|sept|october|oct|november|nov|december|dec|januar|januara|februar|februara|mart|marta|maj|maja|avgust|avgusta|septembar|septembra|oktobar|oktobra|novembar|novembra|decembar|decembra)\b/i;
+            const afterCtx = text.substring(end, Math.min(text.length, end + 30));
+            const beforeCtx = text.substring(Math.max(0, start - 30), start);
+            if (new RegExp('^[\\s.*_]*\\.?\\s*' + monthPat.source, 'i').test(afterCtx) ||
+                new RegExp(monthPat.source + '\\s*$', 'i').test(beforeCtx)) {
+                consume(start, end);
+                continue;
+            }
+        }
+        // Skip time components: numbers inside HH:MM:SS or HH:MM patterns.
+        // E.g. "07:24:02" should not produce claims for 7, 24, 2.
+        // Check surrounding context for colon-separated digit groups.
+        {
+            const timeCtxStart = Math.max(0, start - 10);
+            const timeCtx = text.substring(timeCtxStart, Math.min(text.length, end + 10));
+            const localOffset = start - timeCtxStart;
+            const TIME_PATTERN = /\b(\d{1,2}):(\d{2})(?::(\d{2}))?\b/g;
+            let tm;
+            let insideTime = false;
+            while ((tm = TIME_PATTERN.exec(timeCtx)) !== null) {
+                const tStart = tm.index;
+                const tEnd = tStart + tm[0].length;
+                if (localOffset >= tStart && localOffset + raw.length <= tEnd) {
+                    // Consume the entire timestamp so other components are skipped too
+                    consume(start - (localOffset - tStart), start - (localOffset - tStart) + tm[0].length);
+                    insideTime = true;
+                    break;
+                }
+            }
+            if (insideTime)
+                continue;
+        }
+        consume(start, end);
+        const unitAfter = detectUnitAfterNumber(text, end);
+        const claim = {
+            claimId: (0, crypto_1.randomUUID)(),
+            type: 'number',
+            value: numericValue,
+            rawText: raw,
+            source: makeSource(raw),
+            unit: unitAfter ?? detectCurrencyBeforeNumber(text, start),
+            entity: findNearestEntity(text, start),
+            aggregationOp: detectAggregationQualifier(text, start),
+            ...(detectNegation(text, start) ? { negated: true } : {}),
+            ...(detectComparisonOp(text, start) ? { comparisonOp: detectComparisonOp(text, start) } : {}),
+            ...(detectChangeDirection(text, start) ? { changeDirection: detectChangeDirection(text, start) } : {}),
+        };
+        claims.push(claim);
+    }
+    // 3b. Status transitions: "sa X na Y", "from X to Y", "из X в Y"
+    // Creates a synthetic name claim with transitionFrom / transitionTo metadata.
+    {
+        const TRANS_REGEX = /\b(?:sa|iz|od|from|из|von)\s+([\p{L}\p{N}_]+)\s+(?:na|u|do|to|in|в|auf|nach)\s+([\p{L}\p{N}_]+)\b/giu;
+        let tr;
+        while ((tr = TRANS_REGEX.exec(text)) !== null) {
+            const fullStart = tr.index;
+            const fullEnd = fullStart + tr[0].length;
+            if (isConsumed(fullStart, fullEnd))
+                continue;
+            consume(fullStart, fullEnd);
+            claims.push({
+                claimId: (0, crypto_1.randomUUID)(),
+                type: 'name',
+                value: tr[1] + ' → ' + tr[2],
+                rawText: tr[0],
+                source: makeSource(tr[0]),
+                transitionFrom: tr[1],
+                transitionTo: tr[2],
+            });
+        }
+    }
+    // 4. Names (proper nouns — 2+ Title-Cased words)
+    NAME_REGEX.lastIndex = 0;
+    while ((m = NAME_REGEX.exec(text)) !== null) {
+        const raw = m[0];
+        const namePart = m[1].trim();
+        const start = m.index;
+        const end = start + raw.length;
+        if (isConsumed(start, end))
+            continue;
+        // Skip matches that span line boundaries (cosmetic title-casing across lines)
+        if (raw.includes('\n') || raw.includes('\r'))
+            continue;
+        // Skip section headers / label phrases (all words are common English words)
+        if (isHeadingPhrase(namePart))
+            continue;
+        // Strip sentence-starting discourse markers: "Dakle Marina" → "Marina"
+        const nameWords = namePart.split(/\s+/);
+        let cleanedName = namePart;
+        if (nameWords.length >= 2 && SENTENCE_STARTERS.has(nameWords[0].toLowerCase())) {
+            const remainder = nameWords.slice(1).join(' ');
+            // Only keep if remainder has at least one word (single-word names don't qualify here)
+            if (nameWords.length === 2)
+                continue; // "Dakle Marina" → single word "Marina" — not a name claim
+            cleanedName = remainder;
+        }
+        consume(start, end);
+        const nameRank = detectRank(text, start);
+        const transition = detectTransition(text, start, end);
+        const claim = {
+            claimId: (0, crypto_1.randomUUID)(),
+            type: 'name',
+            value: cleanedName,
+            rawText: raw,
+            source: makeSource(raw),
+            ...(nameRank !== undefined ? { rank: nameRank } : {}),
+            ...(transition ? { transitionFrom: transition.from, transitionTo: transition.to } : {}),
+        };
+        claims.push(claim);
+    }
+    return claims;
+}
+//# sourceMappingURL=index.js.map