@sirdaspdf/core 0.1.0

package/dist/tables.js

@@ -0,0 +1,186 @@
+/** Extrae cada trozo de texto con sus coordenadas, sin fusionar filas. */
+export async function extractCells(pdf, onProgress) {
+    const cells = [];
+    for (let p = 1; p <= pdf.numPages; p++) {
+        const page = await pdf.getPage(p);
+        const content = await page.getTextContent();
+        for (const it of content.items) {
+            if (!("str" in it) || !it.str.trim())
+                continue;
+            const t = it.transform;
+            cells.push({
+                text: it.str.trim(),
+                x0: t[4],
+                x1: t[4] + (it.width || 0),
+                y: Math.round(t[5] / 2) * 2,
+                page: p,
+            });
+        }
+        page.cleanup();
+        onProgress?.(p / pdf.numPages);
+    }
+    return cells;
+}
+/** Agrupa los trozos en filas por página y altura. */
+function toRows(cells) {
+    const byKey = new Map();
+    for (const c of cells) {
+        const key = `${c.page}:${c.y}`;
+        const row = byKey.get(key) ?? { page: c.page, y: c.y, items: [] };
+        row.items.push(c);
+        byKey.set(key, row);
+    }
+    return [...byKey.values()]
+        .map((r) => ({ ...r, items: r.items.sort((a, b) => a.x0 - b.x0) }))
+        .sort((a, b) => (a.page !== b.page ? a.page - b.page : b.y - a.y));
+}
+/** ¿La posición x cae en un hueco de esta fila (o fuera de su extensión)? */
+function isBlankAt(row, x) {
+    for (const it of row.items) {
+        if (x > it.x0 && x < it.x1)
+            return false;
+    }
+    return true;
+}
+/**
+ * Ancho típico de carácter en la fila. Sirve de referencia: un espacio entre
+ * palabras mide alrededor de un tercio de carácter, mientras que el hueco
+ * entre columnas es varias veces mayor.
+ */
+function charWidth(row) {
+    const widths = row.items
+        .filter((i) => i.text.length > 0)
+        .map((i) => (i.x1 - i.x0) / i.text.length)
+        .filter((w) => w > 0)
+        .sort((a, b) => a - b);
+    return widths.length ? widths[Math.floor(widths.length / 2)] : 5;
+}
+/**
+ * Posiciones candidatas a separador: el centro de cada hueco entre celdas que
+ * sea claramente mayor que un espacio entre palabras.
+ */
+function gapCentres(row) {
+    const minGap = Math.max(6, charWidth(row) * 2.5);
+    const out = [];
+    for (let i = 1; i < row.items.length; i++) {
+        const gap = row.items[i].x0 - row.items[i - 1].x1;
+        if (gap >= minGap)
+            out.push((row.items[i - 1].x1 + row.items[i].x0) / 2);
+    }
+    return out;
+}
+/** Corta un bloque de filas en columnas y devuelve la tabla, o null si no lo es. */
+function buildTable(block, opts) {
+    const candidates = block.flatMap((r) => gapCentres(r)).sort((a, b) => a - b);
+    if (!candidates.length)
+        return null;
+    // Agrupamos candidatos cercanos: son el mismo corte visto en varias filas.
+    const clusters = [];
+    for (const x of candidates) {
+        const last = clusters[clusters.length - 1];
+        if (last && x - last[last.length - 1] <= 8)
+            last.push(x);
+        else
+            clusters.push([x]);
+    }
+    // Un corte vale solo si está en blanco en casi todas las filas del bloque.
+    const separators = [];
+    for (const cluster of clusters) {
+        const x = cluster.reduce((s, v) => s + v, 0) / cluster.length;
+        const support = block.filter((r) => isBlankAt(r, x)).length / block.length;
+        if (support >= opts.minSeparatorSupport)
+            separators.push(x);
+    }
+    if (separators.length < opts.minCols - 1)
+        return null;
+    const slots = separators.length + 1;
+    let rows = [];
+    for (const row of block) {
+        const cellsOfRow = Array.from({ length: slots }, () => []);
+        for (const it of row.items) {
+            const mid = (it.x0 + it.x1) / 2;
+            let col = 0;
+            while (col < separators.length && mid > separators[col])
+                col++;
+            cellsOfRow[col].push(it.text);
+        }
+        rows.push(cellsOfRow.map((parts) => parts.join(" ").trim()));
+    }
+    // Una misma banda de espacio en blanco puede producir varios cortes (los
+    // importes alineados a la derecha empiezan en una x distinta por fila), y
+    // entre ellos queda una columna vacía en todas las filas. Se descartan.
+    const used = Array.from({ length: slots }, (_, i) => rows.some((r) => r[i] !== ""));
+    const columns = used.filter(Boolean).length;
+    if (columns < opts.minCols)
+        return null;
+    rows = rows.map((r) => r.filter((_, i) => used[i]));
+    // Una "tabla" donde casi todas las filas tienen una sola celda es, en
+    // realidad, un párrafo con sangría.
+    const filled = rows.filter((r) => r.filter(Boolean).length >= 2).length;
+    if (filled / rows.length < 0.6)
+        return null;
+    return { page: block[0].page, rows, columns };
+}
+/** Encuentra las tablas de un documento a partir de sus trozos de texto. */
+export function detectTables(cells, options = {}) {
+    const opts = {
+        minRows: options.minRows ?? 3,
+        minCols: options.minCols ?? 2,
+        maxRowGap: options.maxRowGap ?? 28,
+        minSeparatorSupport: options.minSeparatorSupport ?? 0.8,
+    };
+    const rows = toRows(cells);
+    const tables = [];
+    let block = [];
+    const flush = () => {
+        if (block.length >= opts.minRows) {
+            const table = buildTable(block, opts);
+            if (table)
+                tables.push(table);
+        }
+        block = [];
+    };
+    for (const row of rows) {
+        const prev = block[block.length - 1];
+        const breaks = prev !== undefined && (prev.page !== row.page || prev.y - row.y > opts.maxRowGap);
+        // Una fila de una sola celda no participa en una tabla: corta el bloque.
+        if (breaks || row.items.length < 2) {
+            flush();
+            if (row.items.length >= 2)
+                block.push(row);
+            continue;
+        }
+        block.push(row);
+    }
+    flush();
+    return tables;
+}
+/** Documento abierto → tablas detectadas. */
+export async function pdfToTables(pdf, options = {}, onProgress) {
+    return detectTables(await extractCells(pdf, onProgress), options);
+}
+/** Escapa un valor según RFC 4180. */
+function escapeCsv(value, delimiter) {
+    if (value.includes(delimiter) || /["\r\n]/.test(value)) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+}
+export function tableToCsv(table, { delimiter = ",", bom = false } = {}) {
+    const body = table.rows.map((r) => r.map((c) => escapeCsv(c, delimiter)).join(delimiter)).join("\r\n");
+    return (bom ? "" : "") + body;
+}
+/** Tabla en Markdown, usando la primera fila como encabezado. */
+export function tableToMarkdown(table) {
+    if (!table.rows.length)
+        return "";
+    const esc = (s) => s.replace(/\|/g, "\\|");
+    const [head, ...body] = table.rows;
+    const width = table.columns;
+    const pad = (r) => Array.from({ length: width }, (_, i) => esc(r[i] ?? ""));
+    return [
+        `| ${pad(head).join(" | ")} |`,
+        `| ${Array.from({ length: width }, () => "---").join(" | ")} |`,
+        ...body.map((r) => `| ${pad(r).join(" | ")} |`),
+    ].join("\n");
+}

package/dist/text.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Normaliza para comparar: minúsculas, sin acentos, sin puntuación y con los
+ * espacios colapsados. Dos textos que solo difieren en formato deben verse
+ * iguales, porque para un modelo de lenguaje lo son.
+ */
+export declare function normalizeForCompare(text: string): string;
+export declare function words(text: string): string[];
+/** FNV-1a de 32 bits: rápido, sin dependencias y estable entre ejecuciones. */
+export declare function fnv1a(s: string): number;
+/**
+ * Conjunto de n-gramas de palabras, como hashes. Si el texto es más corto que
+ * `n`, devuelve un único elemento con todo el texto: un documento de tres
+ * palabras sigue pudiendo ser un duplicado.
+ */
+export declare function ngramHashes(text: string, n: number): Set<number>;
+/** Los n-gramas como texto, para poder enseñar cuál coincidió. */
+export declare function ngrams(text: string, n: number): string[];
+/** Jaccard exacto entre dos conjuntos. */
+export declare function jaccard(a: Set<number>, b: Set<number>): number;

package/dist/text.js

@@ -0,0 +1,74 @@
+// Utilidades de texto compartidas por la deduplicación y la detección de
+// contaminación. Todo es determinista: la misma entrada da el mismo resultado
+// en cualquier máquina, que es lo que permite auditar un dataset.
+/**
+ * Normaliza para comparar: minúsculas, sin acentos, sin puntuación y con los
+ * espacios colapsados. Dos textos que solo difieren en formato deben verse
+ * iguales, porque para un modelo de lenguaje lo son.
+ */
+export function normalizeForCompare(text) {
+    return text
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/[^\p{L}\p{N}\s]/gu, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function words(text) {
+    const n = normalizeForCompare(text);
+    return n === "" ? [] : n.split(" ");
+}
+/** FNV-1a de 32 bits: rápido, sin dependencias y estable entre ejecuciones. */
+export function fnv1a(s) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        // h *= 16777619 en aritmética de 32 bits sin desbordar el doble de JS.
+        h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;
+    }
+    return h >>> 0;
+}
+/**
+ * Conjunto de n-gramas de palabras, como hashes. Si el texto es más corto que
+ * `n`, devuelve un único elemento con todo el texto: un documento de tres
+ * palabras sigue pudiendo ser un duplicado.
+ */
+export function ngramHashes(text, n) {
+    const w = words(text);
+    const out = new Set();
+    if (w.length === 0)
+        return out;
+    if (w.length < n) {
+        out.add(fnv1a(w.join(" ")));
+        return out;
+    }
+    for (let i = 0; i + n <= w.length; i++)
+        out.add(fnv1a(w.slice(i, i + n).join(" ")));
+    return out;
+}
+/** Los n-gramas como texto, para poder enseñar cuál coincidió. */
+export function ngrams(text, n) {
+    const w = words(text);
+    if (w.length === 0)
+        return [];
+    if (w.length < n)
+        return [w.join(" ")];
+    const out = [];
+    for (let i = 0; i + n <= w.length; i++)
+        out.push(w.slice(i, i + n).join(" "));
+    return out;
+}
+/** Jaccard exacto entre dos conjuntos. */
+export function jaccard(a, b) {
+    if (a.size === 0 && b.size === 0)
+        return 1;
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    const [small, large] = a.size <= b.size ? [a, b] : [b, a];
+    let shared = 0;
+    for (const x of small)
+        if (large.has(x))
+            shared++;
+    return shared / (a.size + b.size - shared);
+}

package/dist/verifiable.d.ts

@@ -0,0 +1,60 @@
+import type { Table } from "./tables.js";
+export type VerifiableKind = "lookup" | "count" | "extreme";
+export interface VerifiablePair {
+    /** La pregunta, con la tabla incluida como contexto. */
+    prompt: string;
+    /** La respuesta correcta, copiada literalmente de la tabla. */
+    answer: string;
+    kind: VerifiableKind;
+    source: {
+        document: string;
+        page: number;
+        /** Fila y columna de donde salió la respuesta, base 1 sin contar cabecera. */
+        row?: number;
+        column?: string;
+    };
+}
+export interface VerifiableOptions {
+    /** Incluir la tabla en el enunciado. Sin ella la tarea no es resoluble. */
+    includeTable?: boolean;
+    /** Máximo de pares por tabla, para no ahogar el conjunto con una sola. */
+    maxPerTable?: number;
+    /** Idioma de los enunciados. */
+    lang?: "es" | "en";
+}
+/**
+ * Genera pares verificables a partir de una tabla.
+ *
+ * Solo se generan preguntas cuya respuesta sea inequívoca: si una clave de fila
+ * se repite, o si una celda está vacía, esa pregunta no se emite. Un par
+ * ambiguo en un conjunto de refuerzo es peor que no tenerlo, porque castiga al
+ * modelo por acertar.
+ */
+export declare function tableToVerifiable(table: Table, document: string, options?: VerifiableOptions): VerifiablePair[];
+/**
+ * Comprueba una respuesta contra la esperada.
+ *
+ * Es la función de recompensa: devuelve 1 o 0, nada intermedio. Se comparan
+ * números como números cuando ambos lo son, para que «1.120.000» y «1120000»
+ * cuenten como la misma respuesta; en otro caso se comparan como texto sin
+ * distinguir mayúsculas ni espacios de sobra.
+ */
+export declare function verifyAnswer(expected: string, given: string): boolean;
+/**
+ * JSONL de pares verificables, un par por línea.
+ *
+ * El campo se llama `ground_truth` y no `answer` porque es el nombre que usa el
+ * conjunto de referencia de RLVR (allenai/RLVR-GSM-MATH-IF-Mixed-Constraints) y
+ * el que espera el ejemplo de función de recompensa de GRPOTrainer. `prompt` es
+ * la única columna que el entrenador exige; las demás le llegan a la función de
+ * recompensa como argumentos con nombre, así que la procedencia viaja gratis.
+ */
+export declare function verifiableToJsonl(pairs: VerifiablePair[]): string;
+/**
+ * La función de recompensa que acompaña a ese JSONL, lista para pegar.
+ *
+ * Se entrega junto a los datos porque la mitad del trabajo de montar RLVR es
+ * escribir el verificador, y aquí ya sabemos exactamente cómo se comparan estas
+ * respuestas: es la misma regla que aplica verifyAnswer.
+ */
+export declare function rewardFunctionPython(): string;

package/dist/verifiable.js

@@ -0,0 +1,244 @@
+import { tableToMarkdown } from "./tables.js";
+const PHRASES = {
+    es: {
+        lookup: (col, key) => `¿Cuál es el valor de «${col}» para «${key}»?`,
+        count: () => "¿Cuántas filas de datos tiene la tabla, sin contar la cabecera?",
+        max: (col) => `¿Cuál es el valor más alto de la columna «${col}»?`,
+        min: (col) => `¿Cuál es el valor más bajo de la columna «${col}»?`,
+        context: (doc, page) => `Tabla de la página ${page} de ${doc}:`,
+        ask: "Responde únicamente con el valor, sin explicación.",
+    },
+    en: {
+        lookup: (col, key) => `What is the value of "${col}" for "${key}"?`,
+        count: () => "How many data rows does the table have, not counting the header?",
+        max: (col) => `What is the highest value in the "${col}" column?`,
+        min: (col) => `What is the lowest value in the "${col}" column?`,
+        context: (doc, page) => `Table from page ${page} of ${doc}:`,
+        ask: "Answer with the value only, no explanation.",
+    },
+};
+/**
+ * Lee un número escrito a la colombiana (1.120.000,50) o a la inglesa
+ * (1,120,000.50), o devuelve null si no hay número.
+ *
+ * El caso ambiguo es un único separador seguido de exactamente tres cifras:
+ * «1.120» son mil ciento veinte en Bogotá y uno coma doce en Londres. Se
+ * resuelve como millar, porque estos pares salen de facturas y extractos donde
+ * esa es la lectura correcta. No afecta a comparar una respuesta consigo misma:
+ * dos textos idénticos ya coinciden antes de llegar aquí.
+ */
+function parseNumber(raw) {
+    const s = raw.replace(/[^\d.,-]/g, "").trim();
+    if (s === "" || !/\d/.test(s))
+        return null;
+    const dots = (s.match(/\./g) ?? []).length;
+    const commas = (s.match(/,/g) ?? []).length;
+    let normalized;
+    if (dots > 0 && commas > 0) {
+        // Los dos presentes: el último que aparece es el decimal.
+        normalized =
+            s.lastIndexOf(",") > s.lastIndexOf(".")
+                ? s.replace(/\./g, "").replace(",", ".")
+                : s.replace(/,/g, "");
+    }
+    else if (dots > 1 || commas > 1) {
+        // Repetido: solo puede ser separador de millares.
+        normalized = s.replace(/[.,]/g, "");
+    }
+    else if (dots === 1 || commas === 1) {
+        const sep = dots === 1 ? "." : ",";
+        const after = s.slice(s.indexOf(sep) + 1);
+        normalized = /^\d{3}$/.test(after)
+            ? s.replace(/[.,]/g, "") // millares
+            : s.replace(",", ".");
+    }
+    else {
+        normalized = s;
+    }
+    const n = Number(normalized);
+    return Number.isFinite(n) ? n : null;
+}
+/** Una columna es numérica si lo son casi todas sus celdas no vacías. */
+function numericColumn(rows, col) {
+    const values = rows.map((r) => r[col] ?? "").filter((v) => v.trim() !== "");
+    if (values.length < 2)
+        return false;
+    return values.filter((v) => parseNumber(v) !== null).length / values.length >= 0.8;
+}
+/**
+ * Genera pares verificables a partir de una tabla.
+ *
+ * Solo se generan preguntas cuya respuesta sea inequívoca: si una clave de fila
+ * se repite, o si una celda está vacía, esa pregunta no se emite. Un par
+ * ambiguo en un conjunto de refuerzo es peor que no tenerlo, porque castiga al
+ * modelo por acertar.
+ */
+export function tableToVerifiable(table, document, options = {}) {
+    const { includeTable = true, maxPerTable = 10, lang = "es" } = options;
+    const p = PHRASES[lang];
+    const rows = table.rows;
+    if (rows.length < 2)
+        return [];
+    const header = rows[0];
+    const body = rows.slice(1);
+    if (header.length < 2)
+        return [];
+    const context = includeTable
+        ? `${p.context(document, table.page)}\n\n${tableToMarkdown(table)}\n\n`
+        : "";
+    const ask = (question) => `${context}${question} ${p.ask}`;
+    // Claves de fila que aparecen una sola vez: si «Consulta general» está dos
+    // veces, preguntar por ella no tiene respuesta única.
+    const keyCount = new Map();
+    for (const row of body) {
+        const key = (row[0] ?? "").trim();
+        if (key)
+            keyCount.set(key, (keyCount.get(key) ?? 0) + 1);
+    }
+    const pairs = [];
+    for (let r = 0; r < body.length && pairs.length < maxPerTable; r++) {
+        const key = (body[r][0] ?? "").trim();
+        if (!key || keyCount.get(key) !== 1)
+            continue;
+        for (let c = 1; c < header.length && pairs.length < maxPerTable; c++) {
+            const col = (header[c] ?? "").trim();
+            const value = (body[r][c] ?? "").trim();
+            if (!col || !value)
+                continue;
+            pairs.push({
+                prompt: ask(p.lookup(col, key)),
+                answer: value,
+                kind: "lookup",
+                source: { document, page: table.page, row: r + 1, column: col },
+            });
+        }
+    }
+    if (pairs.length < maxPerTable) {
+        pairs.push({
+            prompt: ask(p.count()),
+            answer: String(body.length),
+            kind: "count",
+            source: { document, page: table.page },
+        });
+    }
+    // Máximo y mínimo por columna numérica: exige leer toda la columna, no una
+    // celda, así que es una tarea de otro tipo aunque salga de la misma tabla.
+    for (let c = 1; c < header.length && pairs.length < maxPerTable; c++) {
+        if (!numericColumn(body, c))
+            continue;
+        const col = (header[c] ?? "").trim();
+        const cells = body
+            .map((row) => ({ raw: (row[c] ?? "").trim(), n: parseNumber(row[c] ?? "") }))
+            .filter((x) => x.n !== null);
+        if (cells.length < 2)
+            continue;
+        const top = cells.reduce((a, b) => (b.n > a.n ? b : a));
+        const bottom = cells.reduce((a, b) => (b.n < a.n ? b : a));
+        // Si hay empate en el extremo, la respuesta no es única: se descarta.
+        if (cells.filter((x) => x.n === top.n).length === 1) {
+            pairs.push({
+                prompt: ask(p.max(col)),
+                answer: top.raw,
+                kind: "extreme",
+                source: { document, page: table.page, column: col },
+            });
+        }
+        if (pairs.length < maxPerTable && cells.filter((x) => x.n === bottom.n).length === 1) {
+            pairs.push({
+                prompt: ask(p.min(col)),
+                answer: bottom.raw,
+                kind: "extreme",
+                source: { document, page: table.page, column: col },
+            });
+        }
+    }
+    return pairs;
+}
+/**
+ * Comprueba una respuesta contra la esperada.
+ *
+ * Es la función de recompensa: devuelve 1 o 0, nada intermedio. Se comparan
+ * números como números cuando ambos lo son, para que «1.120.000» y «1120000»
+ * cuenten como la misma respuesta; en otro caso se comparan como texto sin
+ * distinguir mayúsculas ni espacios de sobra.
+ */
+export function verifyAnswer(expected, given) {
+    const a = expected.trim();
+    const b = given.trim();
+    if (a === b)
+        return true;
+    const na = parseNumber(a);
+    const nb = parseNumber(b);
+    if (na !== null && nb !== null)
+        return na === nb;
+    return a.toLowerCase().replace(/\s+/g, " ") === b.toLowerCase().replace(/\s+/g, " ");
+}
+/**
+ * JSONL de pares verificables, un par por línea.
+ *
+ * El campo se llama `ground_truth` y no `answer` porque es el nombre que usa el
+ * conjunto de referencia de RLVR (allenai/RLVR-GSM-MATH-IF-Mixed-Constraints) y
+ * el que espera el ejemplo de función de recompensa de GRPOTrainer. `prompt` es
+ * la única columna que el entrenador exige; las demás le llegan a la función de
+ * recompensa como argumentos con nombre, así que la procedencia viaja gratis.
+ */
+export function verifiableToJsonl(pairs) {
+    return pairs
+        .map((p) => JSON.stringify({ prompt: p.prompt, ground_truth: p.answer, kind: p.kind, sirdas: p.source }))
+        .join("\n");
+}
+/**
+ * La función de recompensa que acompaña a ese JSONL, lista para pegar.
+ *
+ * Se entrega junto a los datos porque la mitad del trabajo de montar RLVR es
+ * escribir el verificador, y aquí ya sabemos exactamente cómo se comparan estas
+ * respuestas: es la misma regla que aplica verifyAnswer.
+ */
+export function rewardFunctionPython() {
+    return `# Función de recompensa para los pares generados por \`sirdas rl\`.
+# Uso con TRL: el dataset necesita la columna "prompt"; las demás columnas
+# llegan aquí como argumentos con nombre.
+#
+#   from trl import GRPOConfig, GRPOTrainer
+#   trainer = GRPOTrainer(model=..., reward_funcs=sirdas_reward, args=..., train_dataset=ds)
+import re
+
+
+def _to_number(raw):
+    """Lee 1.120.000 (es) y 1,120,000.50 (en). Devuelve None si no hay número."""
+    s = re.sub(r"[^\\d.,-]", "", str(raw)).strip()
+    if not s or not re.search(r"\\d", s):
+        return None
+    dots, commas = s.count("."), s.count(",")
+    if dots and commas:
+        s = s.replace(".", "").replace(",", ".") if s.rfind(",") > s.rfind(".") else s.replace(",", "")
+    elif dots > 1 or commas > 1:
+        s = re.sub(r"[.,]", "", s)
+    elif dots == 1 or commas == 1:
+        sep = "." if dots == 1 else ","
+        after = s.split(sep, 1)[1]
+        s = re.sub(r"[.,]", "", s) if re.fullmatch(r"\\d{3}", after) else s.replace(",", ".")
+    try:
+        return float(s)
+    except ValueError:
+        return None
+
+
+def sirdas_reward(completions, ground_truth, **kwargs):
+    """1.0 si la respuesta coincide con el valor impreso en el documento, 0.0 si no."""
+    rewards = []
+    for completion, truth in zip(completions, ground_truth):
+        given = completion if isinstance(completion, str) else completion[-1]["content"]
+        given, truth = given.strip(), str(truth).strip()
+        if given == truth:
+            rewards.append(1.0)
+            continue
+        a, b = _to_number(truth), _to_number(given)
+        if a is not None and b is not None:
+            rewards.append(1.0 if a == b else 0.0)
+        else:
+            norm = lambda x: " ".join(x.lower().split())
+            rewards.append(1.0 if norm(a if a else truth) == norm(given) else 0.0)
+    return rewards
+`;
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@sirdaspdf/core",
+  "version": "0.1.0",
+  "description": "Sırdaş core: PDF operations, PDF→Markdown for AI and local PII anonymization. Runs in the browser and in Node; files never leave the machine.",
+  "keywords": [
+    "pdf",
+    "markdown",
+    "llm",
+    "anonymization",
+    "pii",
+    "privacy",
+    "local-first",
+    "dataset",
+    "fine-tuning",
+    "deduplication"
+  ],
+  "homepage": "https://sirdas.app",
+  "bugs": {
+    "url": "https://github.com/Brayan15p/SIRDAS-APP-PDF/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Brayan15p/SIRDAS-APP-PDF.git",
+    "directory": "packages/core"
+  },
+  "license": "MIT",
+  "author": "Sırdaş",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test test/*.test.ts",
+    "prepublishOnly": "npm run test"
+  },
+  "dependencies": {
+    "pdf-lib": "1.17.1"
+  },
+  "peerDependencies": {
+    "pdfjs-dist": ">=4"
+  },
+  "peerDependenciesMeta": {
+    "pdfjs-dist": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "pdfjs-dist": "4.10.38",
+    "typescript": "5.9.2"
+  }
+}