arca-siradig 1.0.0

package/dist/src/arca/employees.js

@@ -0,0 +1,80 @@
+import { fetchSiradigJson, parseInlineTable } from "./http.js";
+import { extractVisibleFieldsetData } from "./personal-data.js";
+const EMPLOYEES_MENU_URL = "verMenuEmpleadores.do";
+export async function readEmployees(page, request = page.request) {
+    const data = await fetchSiradigJson(request, EMPLOYEES_MENU_URL, "datosEmpleadoresJSON");
+    const employees = parseEmployeesJson(data);
+    if (employees !== null)
+        return employees;
+    await openEmployeesMenu(page);
+    return listEmployees(page);
+}
+export function parseEmployeesJson(data) {
+    const rows = parseInlineTable(data);
+    if (rows === null)
+        return null;
+    const employees = [];
+    for (const row of rows) {
+        const [cuit, name, startDate, endDate, withholdingAgent] = row.cells;
+        if (!row.id || !cuit || !name || row.cells.length !== 5)
+            return null;
+        employees.push({
+            id: row.id,
+            cuit,
+            name,
+            startDate: startDate || null,
+            endDate: endDate || null,
+            withholdingAgent: withholdingAgent || null,
+        });
+    }
+    return employees;
+}
+export async function openEmployeesMenu(page) {
+    await page.goto(new URL(EMPLOYEES_MENU_URL, page.url()).href, { waitUntil: "domcontentloaded" });
+}
+export async function listEmployees(page) {
+    const rows = page.locator("#nueva_tabla_empleadores tbody tr");
+    const employees = [];
+    for (let index = 0; index < (await rows.count()); index += 1) {
+        const row = rows.nth(index);
+        if (!(await row.isVisible())) {
+            continue;
+        }
+        const cells = await row.locator("td").allTextContents();
+        const [cuit = "", name = "", startDate = "", endDate = "", withholdingAgent = ""] = cells.map(normalizeText);
+        const id = normalizeText(await row.getAttribute("data-id-reg"));
+        if (!id || !cuit || !name) {
+            continue;
+        }
+        employees.push({
+            id,
+            cuit,
+            name,
+            startDate: startDate || null,
+            endDate: endDate || null,
+            withholdingAgent: withholdingAgent || null,
+        });
+    }
+    return employees;
+}
+export async function openEmployeeDetails(page, employeeId) {
+    await page.goto(new URL(`verEmpleador.do?id=${encodeURIComponent(employeeId)}`, page.url()).href, {
+        waitUntil: "domcontentloaded",
+    });
+    await page
+        .waitForFunction(() => {
+        const cuit = document.querySelector("#cuit")?.value?.trim();
+        const razonSocial = document.querySelector("#razonSocial")?.value?.trim();
+        return Boolean(cuit || razonSocial);
+    })
+        .catch(() => undefined);
+}
+export async function extractEmployeeData(page) {
+    return extractVisibleFieldsetData(page);
+}
+export function findEmployeeByCuit(employees, employeeCuit) {
+    return employees.find((employee) => employee.cuit === employeeCuit) ?? null;
+}
+function normalizeText(value) {
+    return (value ?? "").replace(/\s+/g, " ").trim();
+}

package/dist/src/arca/form.d.ts

@@ -0,0 +1,39 @@
+import type { Page } from "playwright";
+export type FormContext = {
+    period: number;
+    person: {
+        id: string;
+        name: string;
+    };
+};
+export type FormSummary = FormContext & {
+    source: "draft-preview";
+    submissionType: string | null;
+    withholdingAgent: {
+        id: string;
+        name: string;
+    } | null;
+    totals: Array<{
+        label: string;
+        amount: string;
+    }>;
+    sections: Array<{
+        title: string;
+        tables: string[][][];
+        hasData: boolean;
+    }>;
+};
+export declare function readFormContext(page: Page): Promise<FormContext>;
+export declare function verifyFormContext(page: Page, expected: {
+    period?: number;
+    person: string;
+}): Promise<FormContext>;
+export declare function openFormPeriod(page: Page, period: number): Promise<void>;
+export declare function selectFormPeriod(page: Page, expected: {
+    period?: number;
+    person: string;
+    selector?: string;
+}): Promise<FormContext>;
+export declare function openFormPreview(page: Page): Promise<void>;
+export declare function readFormSummary(page: Page): Promise<FormSummary>;
+export declare function printFormDraft(page: Page, path: string, period?: number): Promise<string>;

package/dist/src/arca/form.js

@@ -0,0 +1,143 @@
+import { resolvePdfDestination, savePdfWithUniqueName } from "../files/pdf.js";
+import { acceptReminderModalIfPresent, selectPerson } from "./persons.js";
+import { assertWorkerSiradigUrl, SIRADIG_BASE_URL } from "./session.js";
+export async function readFormContext(page) {
+    assertWorkerSiradigUrl(page.url());
+    const breadcrumb = await page.locator("#breadCrumb0").innerText();
+    const period = breadcrumb.match(/Per[ií]odo\s+(\d{4})/i)?.[1];
+    const person = await page.locator("#encabezado_usuario").evaluate((table) => {
+        const row = Array.from(table.querySelectorAll("tr")).find((row) => /Representando\s+a\s*:/i.test(row.cells[0]?.textContent ?? ""));
+        return row?.cells[1]?.textContent?.replace(/\s+/g, " ").trim() ?? "";
+    });
+    const match = person.match(/^(\d{11})\s*-\s*(.+)$/);
+    if (!period || !match) {
+        throw new Error(`No se pudo confirmar la persona y el período del formulario en ARCA.\n` +
+            `Encabezado: ${person || "no disponible"}. Período: ${period || "no disponible"}.\n` +
+            "Revisá la pantalla con --headless false y la selección con `arca-siradig persons list`.");
+    }
+    return { period: Number(period), person: { id: match[1], name: match[2] } };
+}
+export async function verifyFormContext(page, expected) {
+    const context = await readFormContext(page);
+    if (expected.period !== undefined && context.period !== expected.period) {
+        throw new Error(`ARCA abrió el período ${context.period}; se solicitó ${expected.period}.`);
+    }
+    if (context.person.id !== expected.person &&
+        normalizePersonName(context.person.name) !== normalizePersonName(expected.person)) {
+        throw new Error("ARCA abrió el formulario de una persona diferente de la solicitada.\n" +
+            `Persona esperada (CUIT o nombre): ${expected.person}.\n` +
+            `Persona en ARCA: CUIT ${context.person.id} - ${context.person.name}. Período: ${context.period}.\n` +
+            "Revisá `arca-siradig persons list` y elegí la persona con `--person <id|nombre>` o `arca-siradig persons select <id|nombre>`.\n" +
+            "El ID de selección de ARCA puede ser un índice interno; no necesariamente es el CUIT.");
+    }
+    return context;
+}
+export async function openFormPeriod(page, period) {
+    const url = new URL("jsp/determinarContribuyente.do", SIRADIG_BASE_URL);
+    url.searchParams.set("codigo", String(period));
+    await page.goto(url.href, { waitUntil: "domcontentloaded" });
+    const error = await page
+        .getByText("El período seleccionado es inválido o inexistente", {
+        exact: true,
+    })
+        .isVisible();
+    if (error)
+        throw new Error(`ARCA no permite acceder al período ${period}.`);
+}
+export async function selectFormPeriod(page, expected) {
+    const current = await verifyFormContext(page, { person: expected.person });
+    if (expected.period !== undefined && current.period !== expected.period) {
+        await openFormPeriod(page, expected.period);
+        if (await page.locator('input[type="button"].btn_empresa').count()) {
+            await selectPerson(page, expected.selector ?? current.person.name);
+        }
+        await acceptReminderModalIfPresent(page);
+    }
+    return verifyFormContext(page, { period: expected.period, person: current.person.id });
+}
+function normalizePersonName(name) {
+    return name.replace(/,/g, " ").replace(/\s+/g, " ").trim().toUpperCase();
+}
+export async function openFormPreview(page) {
+    await page.goto(new URL("jsp/vistaPreviaFormulario.do", SIRADIG_BASE_URL).href, {
+        waitUntil: "domcontentloaded",
+    });
+    await page.locator("#tabla_datos_personales").waitFor({ state: "attached", timeout: 15_000 });
+}
+export async function readFormSummary(page) {
+    const context = await readFormContext(page);
+    const preview = await page.locator("#contenido").evaluate((content) => {
+        const totals = [];
+        for (const table of Array.from(content.querySelectorAll("table.tabla_vista_previa"))) {
+            const cells = Array.from(table.rows[0]?.cells ?? []).map((cell) => cell.textContent?.replace(/\s+/g, " ").trim() ?? "");
+            if (cells.length === 3 && /Importe Total/i.test(cells[1])) {
+                totals.push({ label: cells[0], amount: cells[2] });
+            }
+        }
+        const sections = Array.from(content.querySelectorAll("h3")).map((heading) => {
+            const tables = [];
+            let hasData = false;
+            let row = heading.closest("tr")?.nextElementSibling;
+            while (row && !row.querySelector("h3")) {
+                for (const table of Array.from(row.querySelectorAll("table.tabla_vista_previa"))) {
+                    const rows = Array.from(table.rows)
+                        .filter((item) => item.closest("table") === table)
+                        .filter((item) => !Array.from(item.cells).some((cell) => cell.querySelector("table")))
+                        .map((item) => {
+                        if (Array.from(item.cells).some((cell) => cell.tagName === "TD" && cell.textContent?.trim()) ||
+                            /Subtotal\s*:/i.test(item.textContent ?? ""))
+                            hasData = true;
+                        return Array.from(item.cells).map((cell) => cell.textContent?.replace(/\s+/g, " ").trim() ?? "");
+                    });
+                    if (rows.length)
+                        tables.push(rows);
+                }
+                row = row.nextElementSibling;
+            }
+            return { title: heading.textContent?.replace(/\s+/g, " ").trim() ?? "", tables, hasData };
+        });
+        const ownCells = Array.from(content.querySelectorAll("td")).filter((cell) => !cell.querySelector("table"));
+        const submissionType = ownCells
+            .map((cell) => cell.textContent?.replace(/\s+/g, " ").trim() ?? "")
+            .find((text) => /Car[aá]cter de la presentaci[oó]n\s*:/i.test(text))
+            ?.split(":")
+            .slice(1)
+            .join(":")
+            .trim() ?? null;
+        const agentText = Array.from(content.querySelectorAll("th, td, div"))
+            .filter((element) => !element.querySelector("table"))
+            .map((element) => element.textContent?.replace(/\s+/g, " ").trim() ?? "")
+            .find((text) => /^Agente de retenci[oó]n:/i.test(text));
+        const agent = agentText?.match(/^Agente de retenci[oó]n:\s*CUIT\s*(\d{11})\s*-\s*(.+)$/i);
+        const withholdingAgent = agent
+            ? { id: agent[1], name: agent[2].replace(/\s+/g, " ").trim() }
+            : null;
+        return { totals, sections, submissionType, withholdingAgent };
+    });
+    if (!preview.sections.length || !preview.totals.length) {
+        throw new Error("La vista previa de ARCA no tiene el formato esperado; no se pudo leer el resumen.");
+    }
+    return { ...context, source: "draft-preview", ...preview };
+}
+export async function printFormDraft(page, path, period) {
+    const fiscalYear = period ?? (await readFormContext(page)).period;
+    const destination = await resolvePdfDestination(path, `f572-${fiscalYear}-borrador.pdf`);
+    const [download] = await Promise.all([
+        page.waitForEvent("download", { timeout: 30_000 }),
+        page.locator("#btn_imprimir_borrador").click(),
+    ]);
+    try {
+        const stream = await download.createReadStream();
+        const chunks = [];
+        for await (const chunk of stream)
+            chunks.push(Buffer.from(chunk));
+        const body = Buffer.concat(chunks);
+        if (body.subarray(0, 5).toString("ascii") !== "%PDF-") {
+            throw new Error("ARCA no devolvió el PDF del borrador. No se guardó ningún archivo.");
+        }
+        return await savePdfWithUniqueName(body, destination);
+    }
+    finally {
+        await download.delete();
+    }
+}

package/dist/src/arca/http.d.ts

@@ -0,0 +1,14 @@
+import type { APIRequestContext, APIResponse } from "playwright";
+export type SiradigRequestClient = {
+    get: (url: string, options?: Parameters<APIRequestContext["get"]>[1]) => Promise<Pick<APIResponse, "status" | "headers" | "body" | "dispose">>;
+};
+/** Reads only known consultation endpoints, sharing Playwright's authenticated context. */
+export declare function fetchSiradigJson(request: SiradigRequestClient, endpoint: string, variable: string): Promise<unknown | undefined>;
+export declare function decodeSiradigHtml(body: Uint8Array, contentType: string): string;
+/** Parses JSON literals without evaluating any of the portal's JavaScript. */
+export declare function extractInlineJson(html: string, variable: string): unknown | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function parseInlineTable(value: unknown): Array<{
+    id: string;
+    cells: string[];
+}> | null;

package/dist/src/arca/http.js

@@ -0,0 +1,108 @@
+const WORKER_BASE_URL = "https://serviciosjava2.afip.gob.ar/radig/jsp/";
+const READ_ENDPOINTS = new Set(["verMenuEmpleadores.do", "verMenuDeducciones.do"]);
+/** Reads only known consultation endpoints, sharing Playwright's authenticated context. */
+export async function fetchSiradigJson(request, endpoint, variable) {
+    if (!READ_ENDPOINTS.has(endpoint)) {
+        throw new Error("The SiRADIG HTTP endpoint is not an allowed consultation.");
+    }
+    try {
+        const response = await request.get(new URL(endpoint, WORKER_BASE_URL).href, {
+            maxRedirects: 0,
+            maxRetries: 0,
+            timeout: 15_000,
+        });
+        try {
+            // Redirects, expired sessions, and changed formats fall back to browser navigation.
+            const contentType = response.headers()["content-type"] ?? "";
+            if (response.status() !== 200 || !contentType.toLowerCase().includes("text/html")) {
+                return undefined;
+            }
+            return extractInlineJson(decodeSiradigHtml(await response.body(), contentType), variable);
+        }
+        finally {
+            await response.dispose();
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+export function decodeSiradigHtml(body, contentType) {
+    const charsetPattern = /charset\s*=\s*["']?([\w-]+)/i;
+    const headerCharset = contentType.match(charsetPattern)?.[1];
+    const prefix = new TextDecoder().decode(body.subarray(0, 8192));
+    const metaCharset = prefix.match(/<meta\b[^>]*charset\s*=\s*["']?([\w-]+)/i)?.[1];
+    return new TextDecoder(headerCharset ?? metaCharset ?? "utf-8").decode(body);
+}
+/** Parses JSON literals without evaluating any of the portal's JavaScript. */
+export function extractInlineJson(html, variable) {
+    if (!/^[A-Za-z_$][\w$]*$/.test(variable))
+        return undefined;
+    const escapedVariable = variable.replace(/\$/g, "\\$");
+    const assignment = new RegExp(`\\b(?:var|let|const)\\s+${escapedVariable}\\s*=\\s*`, "g");
+    for (const script of html.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script\s*>/gi)) {
+        const source = script[1] ?? "";
+        assignment.lastIndex = 0;
+        const match = assignment.exec(source);
+        if (!match)
+            continue;
+        const start = assignment.lastIndex;
+        if (source[start] !== "{" && source[start] !== "[")
+            continue;
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        for (let index = start; index < source.length; index += 1) {
+            const character = source[index];
+            if (inString) {
+                if (escaped)
+                    escaped = false;
+                else if (character === "\\")
+                    escaped = true;
+                else if (character === '"')
+                    inString = false;
+                continue;
+            }
+            if (character === '"')
+                inString = true;
+            else if (character === "{" || character === "[")
+                depth += 1;
+            else if (character === "}" || character === "]") {
+                depth -= 1;
+                if (depth === 0) {
+                    if (!/^\s*(?:;|$)/.test(source.slice(index + 1)))
+                        return undefined;
+                    try {
+                        return JSON.parse(source.slice(start, index + 1));
+                    }
+                    catch {
+                        return undefined;
+                    }
+                }
+            }
+        }
+    }
+    return undefined;
+}
+export function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function parseInlineTable(value) {
+    if (!isRecord(value) || !Array.isArray(value.filas))
+        return null;
+    const rows = [];
+    for (const row of value.filas) {
+        if (!isRecord(row) ||
+            !["string", "number"].includes(typeof row.idReg) ||
+            !Array.isArray(row.celdas) ||
+            !row.celdas.every((cell) => cell === null || ["string", "number"].includes(typeof cell)))
+            return null;
+        rows.push({
+            id: String(row.idReg).trim(),
+            cells: row.celdas.map((cell) => String(cell ?? "")
+                .replace(/\s+/g, " ")
+                .trim()),
+        });
+    }
+    return rows;
+}

package/dist/src/arca/menu.d.ts

@@ -0,0 +1,6 @@
+import type { Page } from "playwright";
+import type { MenuItem } from "../types.js";
+export declare const ENABLED_MENU_ITEM = "Datos Personales";
+export declare function listMenuItems(page: Page): Promise<MenuItem[]>;
+export declare function selectMenuItem(page: Page, label: string): Promise<void>;
+export declare function returnToMainMenu(page: Page): Promise<void>;

package/dist/src/arca/menu.js

@@ -0,0 +1,36 @@
+export const ENABLED_MENU_ITEM = "Datos Personales";
+const MENU_BUTTON_SELECTOR = 'a[id^="btn_"].ui-button';
+export async function listMenuItems(page) {
+    await page.locator("#btn_datos_personales").waitFor({ state: "attached", timeout: 15_000 });
+    const labels = await page.locator(MENU_BUTTON_SELECTOR).evaluateAll((buttons) => buttons
+        .filter((button) => !["btn_nuevo_borrador", "btn_guardar"].includes(button.id))
+        .map((button) => button.textContent?.replace(/\s+/g, " ").trim() ?? "")
+        .filter((label) => label.length > 0));
+    return [...new Set(labels)].map((label) => ({
+        label,
+        enabled: label === ENABLED_MENU_ITEM,
+    }));
+}
+export async function selectMenuItem(page, label) {
+    if (label !== ENABLED_MENU_ITEM) {
+        throw new Error(`The action "${label}" is not implemented yet.`);
+    }
+    await navigateByHref(page, page.locator("#btn_datos_personales"));
+    await page.waitForLoadState("domcontentloaded").catch(() => undefined);
+}
+export async function returnToMainMenu(page) {
+    const mainMenuLink = page
+        .locator("#btn_volver, #btn_volver_menu")
+        .filter({ hasText: "Menú Principal" })
+        .first();
+    await mainMenuLink.waitFor({ state: "visible", timeout: 15_000 });
+    await mainMenuLink.click();
+    await page.waitForLoadState("domcontentloaded").catch(() => undefined);
+}
+async function navigateByHref(page, link) {
+    const href = await link.getAttribute("href");
+    if (!href || href === "#") {
+        throw new Error("The selected action does not have a navigable href.");
+    }
+    await page.goto(new URL(href, page.url()).href, { waitUntil: "domcontentloaded" });
+}

package/dist/src/arca/personal-data.d.ts

@@ -0,0 +1,4 @@
+import type { Page } from "playwright";
+import type { DataGroup, PersonalDataGroup } from "../types.js";
+export declare function extractPersonalData(page: Page): Promise<PersonalDataGroup[]>;
+export declare function extractVisibleFieldsetData(page: Page): Promise<DataGroup[]>;

package/dist/src/arca/personal-data.js

@@ -0,0 +1,62 @@
+export async function extractPersonalData(page) {
+    return extractVisibleFieldsetData(page);
+}
+export async function extractVisibleFieldsetData(page) {
+    const groups = [];
+    const fieldsets = page.locator("#contenido fieldset");
+    for (let fieldsetIndex = 0; fieldsetIndex < (await fieldsets.count()); fieldsetIndex += 1) {
+        const fieldset = fieldsets.nth(fieldsetIndex);
+        if (!(await fieldset.isVisible())) {
+            continue;
+        }
+        const title = normalizeText(await fieldset.locator("legend").first().textContent());
+        const fields = [];
+        const rows = fieldset.locator("tr");
+        for (let rowIndex = 0; rowIndex < (await rows.count()); rowIndex += 1) {
+            const row = rows.nth(rowIndex);
+            if (!(await row.isVisible())) {
+                continue;
+            }
+            const label = normalizeText(await row.locator("th, [scope='row']").first().textContent());
+            if (!label) {
+                continue;
+            }
+            const value = await readRowValue(row);
+            if (value) {
+                fields.push({ label, value });
+            }
+        }
+        if (title && fields.length > 0) {
+            groups.push({ title, fields });
+        }
+    }
+    return groups;
+}
+async function readRowValue(row) {
+    const controls = row.locator("td input:not([type='hidden']), td textarea, td select");
+    const values = [];
+    for (let controlIndex = 0; controlIndex < (await controls.count()); controlIndex += 1) {
+        const control = controls.nth(controlIndex);
+        if (!(await control.isVisible())) {
+            continue;
+        }
+        const tagName = await control.evaluate((element) => element.tagName.toLowerCase());
+        const value = tagName === "select"
+            ? await control.locator("option:checked").textContent()
+            : await control.inputValue();
+        const normalized = normalizeText(value);
+        if (normalized) {
+            values.push(normalized);
+        }
+    }
+    if (values.length > 0) {
+        return values.join(" ");
+    }
+    return normalizeText(await row
+        .locator("td")
+        .allTextContents()
+        .then((items) => items.join(" ")));
+}
+function normalizeText(value) {
+    return (value ?? "").replace(/\s+/g, " ").trim();
+}

package/dist/src/arca/persons.d.ts

@@ -0,0 +1,11 @@
+import type { Page } from "playwright";
+import type { Person, ReminderModalInfo } from "../types.js";
+export declare function acceptReminderModalIfPresent(page: Page): Promise<ReminderModalInfo | null>;
+export declare function acceptReminderModal(page: Page, options?: {
+    timeoutMs?: number;
+}): Promise<ReminderModalInfo | null>;
+export declare function waitForPersonSelection(page: Page, options?: {
+    timeoutMs?: number;
+}): Promise<void>;
+export declare function listPersons(page: Page): Promise<Person[]>;
+export declare function selectPerson(page: Page, personIdentifier: string): Promise<void>;

package/dist/src/arca/persons.js

@@ -0,0 +1,115 @@
+import { assertWorkerSiradigUrl, recoverWorkerSiradigPage } from "./session.js";
+export async function acceptReminderModalIfPresent(page) {
+    return acceptReminderModal(page);
+}
+export async function acceptReminderModal(page, options = {}) {
+    const dialog = page
+        .locator(".ui-dialog")
+        .filter({ hasText: "Recordatorio - Formulario" })
+        .first();
+    const visible = await dialog
+        .isVisible({ timeout: options.timeoutMs ?? 1_500 })
+        .catch(() => false);
+    if (!visible) {
+        return null;
+    }
+    const title = normalize(await dialog
+        .locator(".ui-dialog-title")
+        .first()
+        .textContent()
+        .catch(() => ""));
+    const description = normalize(await dialog
+        .locator("p")
+        .first()
+        .textContent()
+        .catch(() => ""));
+    await dialog.getByRole("button", { name: "Aceptar" }).click();
+    await dialog.waitFor({ state: "hidden", timeout: 5_000 }).catch(() => undefined);
+    return { title, description };
+}
+export async function waitForPersonSelection(page, options = {}) {
+    assertWorkerSiradigUrl(page.url());
+    try {
+        await page
+            .locator('form[name="seleccionaEmpresaForm"], input[type="button"].btn_empresa')
+            .first()
+            .waitFor({ state: "attached", timeout: options.timeoutMs ?? 30_000 });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "TimeoutError") {
+            throw new Error("SiRADIG no mostró la pantalla de selección de personas. Revisá la pantalla con --headless false; no se pudo confirmar el listado de personas.");
+        }
+        throw error;
+    }
+}
+export async function listPersons(page) {
+    const persons = await page.locator('input[type="button"].btn_empresa').evaluateAll((buttons) => buttons
+        .map((button) => {
+        const name = button.getAttribute("value")?.trim() ?? "";
+        const onclick = button.getAttribute("onclick") ?? "";
+        const match = onclick.match(/idcontribuyente'\)\.value='([^']+)'/i);
+        const id = match?.[1] ?? null;
+        return {
+            id,
+            name,
+        };
+    })
+        .filter((person) => person.name.length > 0));
+    return dedupePersons(persons);
+}
+export async function selectPerson(page, personIdentifier) {
+    return selectPersonOnWorkerPage(page, personIdentifier, true);
+}
+async function selectPersonOnWorkerPage(page, personIdentifier, allowRecovery) {
+    assertWorkerSiradigUrl(page.url());
+    const personButtons = page.locator('input[type="button"].btn_empresa');
+    for (let index = 0; index < (await personButtons.count()); index += 1) {
+        const button = personButtons.nth(index);
+        const value = (await button.getAttribute("value"))?.trim();
+        const onclick = await button.getAttribute("onclick");
+        const id = onclick ? extractContribuyenteId(onclick) : null;
+        if (value === personIdentifier || id === personIdentifier) {
+            await button.click();
+            await page.waitForLoadState("domcontentloaded").catch(() => undefined);
+            try {
+                await page.waitForFunction(() => document.querySelector("#btn_datos_personales") !== null ||
+                    window.location.pathname.startsWith("/radig_emp/"), undefined, { timeout: 15_000 });
+                if (allowRecovery && new URL(page.url()).pathname.startsWith("/radig_emp/")) {
+                    await recoverWorkerSiradigPage(page);
+                    if (!(await page.locator("#btn_datos_personales").count())) {
+                        await selectPersonOnWorkerPage(page, personIdentifier, false);
+                    }
+                }
+                assertWorkerSiradigUrl(page.url());
+            }
+            catch (error) {
+                if (error instanceof Error && error.name === "TimeoutError") {
+                    throw new Error('Después de seleccionar la persona, SiRADIG no mostró el menú con "Datos Personales". Verificá que se haya abierto SiRADIG - Trabajador y revisá si hay un aviso pendiente con --headless false.');
+                }
+                throw error;
+            }
+            return;
+        }
+    }
+    throw new Error(`Person "${personIdentifier}" was not found.`);
+}
+function normalize(value) {
+    return (value ?? "").replace(/\s+/g, " ").trim();
+}
+function extractContribuyenteId(onclick) {
+    const match = onclick.match(/idcontribuyente'\)\.value='([^']+)'/i);
+    return match?.[1] ?? null;
+}
+function dedupePersons(persons) {
+    const seen = new Set();
+    const deduped = [];
+    for (const person of persons) {
+        const key = `${person.id ?? ""}:${person.name}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(person);
+    }
+    return deduped;
+}

package/dist/src/arca/receipt-types.d.ts

@@ -0,0 +1,4 @@
+import type { ReceiptType } from "../types.js";
+export declare const RECEIPT_TYPES: ReceiptType[];
+export declare function listReceiptTypes(): ReceiptType[];
+export declare function resolveReceiptTypeId(label: string): string | null;