@ramiidv/arca-empleados 0.2.0 → 0.3.0

package/dist/serializer.js

@@ -1,304 +1,327 @@
-import { ArcaSerializationError } from './errors.js';
-import { TipoOperacion } from './constants.js';
-import { normalizeCuil } from './validators.js';
-// ---------------------------------------------------------------------------
-// Formatting helpers
-// ---------------------------------------------------------------------------
 /**
- * Formats a Date as DDMMYYYY.
+ * Serializador del archivo TXT de ingreso masivo de relaciones laborales de
+ * Simplificación Registral: registros de ancho fijo de 130 posiciones, tipo `01`.
+ *
+ * Diseño de registro: Manual de Ayuda de Simplificación Registral, ARCA, feb. 2025, pág. 24.
+ * https://www.arca.gob.ar/simplificacionregistral/ayuda/documentos/SR_Manual-de-Ayuda_20250218_definitivo.pdf
+ *
+ * Lo que el manual NO define (relleno, decimales de la retribución, codificación, fin
+ * de línea, valor de los campos vacíos) sigue la convención habitual de los diseños
+ * de registro de ARCA y es configurable con {@link OpcionesSerializacion}; ver README.
  */
-export function formatDate(date) {
-    const day = String(date.getDate()).padStart(2, '0');
-    const month = String(date.getMonth() + 1).padStart(2, '0');
-    const year = String(date.getFullYear());
-    return `${day}${month}${year}`;
+import { ArcaValidationError, formatDate, normalizeCuit } from '@ramiidv/arca-common';
+import { ArcaSerializationError } from './errors.js';
+import { CODIGOS_MOVIMIENTO, LONGITUD_REGISTRO, TIPO_REGISTRO } from './constants.js';
+function campo(campo, descripcion, desde, hasta, tipo) {
+    return Object.freeze({ campo, descripcion, desde, hasta, longitud: hasta - desde + 1, tipo });
 }
-/**
- * Converts a boolean to 'S' or 'N'.
- */
-export function boolToStr(val) {
-    return val ? 'S' : 'N';
+/** Diseño de registro `01` (manual de Simplificación Registral, pág. 24). */
+export const DISENO_REGISTRO = Object.freeze([
+    campo('tipoRegistro', 'Tipo de registro', 1, 2, 'N'),
+    campo('movimiento', 'Código de movimiento', 3, 4, 'A'),
+    campo('cuil', 'Cuil del empleado', 5, 15, 'N'),
+    campo('trabajadorAgropecuario', 'Marca de trabajador agropecuario', 16, 16, 'A'),
+    campo('modalidadContrato', 'Modalidad de contrato', 17, 19, 'N'),
+    campo('fechaInicio', 'Fecha de inicio de rel. laboral', 20, 29, 'F'),
+    campo('fechaFin', 'Fecha de fin de rel. laboral', 30, 39, 'F'),
+    campo('obraSocial', 'Código obra social', 40, 45, 'N'),
+    campo('situacionRevista', 'Código de situación de revista', 46, 47, 'N'),
+    campo('fechaTelegramaRenuncia', 'Fecha recepción telegrama de renuncia', 48, 57, 'F'),
+    campo('retribucion', 'Retribución pactada', 58, 72, 'N'),
+    campo('modalidadLiquidacion', 'Modalidad de liquidación', 73, 73, 'N'),
+    campo('sucursal', 'Sucursal - Domicilio de desempeño', 74, 78, 'N'),
+    campo('actividad', 'Actividad en el domicilio de desempeño', 79, 84, 'N'),
+    campo('puesto', 'Puesto desempeñado', 85, 88, 'A'),
+    campo('rectificacion', 'Rectificación', 89, 90, 'N'),
+    campo('cct', 'Código de Convenio Colectivo de Trabajo', 91, 100, 'A'),
+    campo('categoriaProfesional', 'Categoría profesional', 101, 106, 'N'),
+    campo('tipoServicio', 'Tipo de servicio', 107, 109, 'N'),
+    campo('fechaSuspensionServiciosTemporarios', 'Fecha de suspensión servicios temporarios', 110, 119, 'F'),
+    campo('numeroFormularioAgropecuario', 'Número formulario agropecuario', 120, 129, 'N'),
+    campo('marcaCovidTipoContratoCCG', 'Marca de trabajador licenciado por COVID / Tipo de contrato CCG', 130, 130, 'N'),
+]);
+/** Campos numéricos con default `0` según el manual (en lugar de "vacío"). */
+const DEFAULT_CERO = new Set(['rectificacion', 'marcaCovidTipoContratoCCG']);
+const CONTROL_CHARS = /[\u0000-\u001F\u007F-\u009F]/;
+function resolverOpciones(opts = {}) {
+    const r = {
+        eol: opts.eol ?? '\r\n',
+        eolFinal: opts.eolFinal ?? true,
+        encoding: opts.encoding ?? 'latin1',
+        noRepresentables: opts.noRepresentables ?? 'error',
+        numericoVacio: opts.numericoVacio ?? 'ceros',
+    };
+    if (r.eol !== '\r\n' && r.eol !== '\n')
+        throw new TypeError(`eol inválido: ${JSON.stringify(opts.eol)}`);
+    if (r.encoding !== 'latin1' && r.encoding !== 'ascii') {
+        throw new TypeError(`encoding inválido: ${JSON.stringify(opts.encoding)} (usar 'latin1' o 'ascii')`);
+    }
+    if (r.noRepresentables !== 'error' && r.noRepresentables !== 'transliterar') {
+        throw new TypeError(`noRepresentables inválido: ${JSON.stringify(opts.noRepresentables)}`);
+    }
+    if (r.numericoVacio !== 'ceros' && r.numericoVacio !== 'espacios') {
+        throw new TypeError(`numericoVacio inválido: ${JSON.stringify(opts.numericoVacio)}`);
+    }
+    return r;
 }
-/**
- * Formats a number with 2 decimal places as a string (e.g. 1500.50 -> "1500.50").
- */
-function formatMonto(val) {
-    if (val === undefined || val === null)
-        return '';
-    return val.toFixed(2);
+function maxCodePoint(encoding) {
+    return encoding === 'ascii' ? 0x7f : 0xff;
 }
-/**
- * Returns the string representation of a value, or empty string if undefined/null.
- */
-function str(val) {
-    if (val === undefined || val === null)
-        return '';
-    return String(val);
+function fail(c, value, motivo, cause) {
+    throw new ArcaSerializationError(`Campo "${c.campo}" (posiciones ${c.desde}-${c.hasta}, ${c.descripcion}): ${motivo}`, { field: c.campo, desde: c.desde, hasta: c.hasta, value, cause });
 }
+// ---------------------------------------------------------------------------
+// Fechas
+// ---------------------------------------------------------------------------
+const FECHA_STRING_RE = /^(\d{4})([-/]?)(\d{2})\2(\d{2})$/;
 /**
- * Escapes a string field for the pipe-delimited format.
- * Replaces pipe characters (|), newlines, and carriage returns to prevent
- * corruption of the file format.
+ * Formatea una fecha como `AAAA/MM/DD` (formato de las fechas del archivo de
+ * Simplificación Registral). Distinto del `formatDate` de common (`AAAAMMDD`).
+ *
+ * - `Date`: fecha calendario en Argentina (`America/Argentina/Buenos_Aires`),
+ *   independiente de la zona horaria del proceso.
+ * - string `AAAA-MM-DD`, `AAAAMMDD` o `AAAA/MM/DD`: se toma literal.
+ *
+ * @throws ArcaValidationError si el formato es otro, la fecha no existe o el `Date` es inválido.
  */
-function escapeField(val) {
-    if (!val)
-        return '';
-    return val
-        .replace(/\\/g, '\\\\')
-        .replace(/\|/g, '\\|')
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r');
+export function formatFechaSR(fecha) {
+    let input;
+    if (typeof fecha === 'string') {
+        const m = FECHA_STRING_RE.exec(fecha);
+        if (!m) {
+            throw new ArcaValidationError(`Fecha inválida: "${fecha}". Formato esperado: AAAA-MM-DD, AAAAMMDD o AAAA/MM/DD.`, [{ field: 'fecha', message: 'Formato esperado: AAAA-MM-DD, AAAAMMDD o AAAA/MM/DD', value: fecha }], 'fecha');
+        }
+        input = `${m[1]}-${m[3]}-${m[4]}`;
+    }
+    else if (fecha instanceof Date) {
+        input = fecha;
+    }
+    else {
+        throw new ArcaValidationError(`Fecha inválida: se esperaba Date o string, se recibió ${tipoDe(fecha)}.`, [{ field: 'fecha', message: 'Se esperaba Date o string', value: fecha }], 'fecha');
+    }
+    const yyyymmdd = formatDate(input);
+    return `${yyyymmdd.slice(0, 4)}/${yyyymmdd.slice(4, 6)}/${yyyymmdd.slice(6, 8)}`;
 }
-/**
- * Returns the escaped string representation of a value, or empty string if undefined/null.
- * Use this for free-text fields (calle, localidad, razon social, nombres, etc.).
- */
-function strEsc(val) {
-    if (val === undefined || val === null)
-        return '';
-    return escapeField(val);
+function tipoDe(v) {
+    if (v === null)
+        return 'null';
+    if (Array.isArray(v))
+        return 'array';
+    if (typeof v === 'number' && Number.isNaN(v))
+        return 'NaN';
+    return typeof v;
 }
 // ---------------------------------------------------------------------------
-// Record serializers
+// Campos
 // ---------------------------------------------------------------------------
-/**
- * Serializes the file header line.
- * Format: 00|CUIT|RAZON_SOCIAL|FECHA_GENERACION|CANTIDAD_REGISTROS|
- */
-export function serializeHeader(archivo) {
-    const cuit = normalizeCuil(archivo.cuitEmpleador);
-    const razon = strEsc(archivo.razonSocial ?? '');
-    const fecha = formatDate(archivo.fechaGeneracion);
-    const cantidad = String(archivo.cantidadRegistros);
-    return `00|${cuit}|${razon}|${fecha}|${cantidad}|`;
+function vacio(v) {
+    return v === undefined || v === null || v === '';
 }
-/**
- * Serializes an alta (employee registration) record.
- * Format: 01|CUIT_EMPLEADOR|TIPO_OP|CUIL|FECHA_INICIO|MODALIDAD|OBRA_SOCIAL|ACTIVIDAD|AGROPECUARIO|FECHA_FIN|CALLE|NUMERO|PISO|DEPTO|LOCALIDAD|CP|PROVINCIA|TELEFONO|
- */
-export function serializeAlta(cuitEmpleador, alta) {
-    const cuit = normalizeCuil(cuitEmpleador);
-    const cuil = normalizeCuil(alta.cuil);
-    const dom = alta.domicilioExplotacion;
-    const fields = [
-        '01',
-        cuit,
-        String(TipoOperacion.ALTA),
-        cuil,
-        formatDate(alta.fechaInicio),
-        String(alta.modalidadContratacion),
-        alta.obraSocial,
-        alta.actividadEconomica,
-        boolToStr(alta.trabajadorAgropecuario),
-        alta.fechaFin ? formatDate(alta.fechaFin) : '',
-        strEsc(dom.calle),
-        strEsc(dom.numero),
-        strEsc(dom.piso),
-        strEsc(dom.depto),
-        strEsc(dom.localidad),
-        dom.codigoPostal,
-        String(dom.provincia),
-        strEsc(dom.telefono),
-    ];
-    return fields.join('|') + '|';
+function formatearNumerico(c, value, o) {
+    if (vacio(value)) {
+        if (DEFAULT_CERO.has(c.campo))
+            return '0'.repeat(c.longitud);
+        return (o.numericoVacio === 'ceros' ? '0' : ' ').repeat(c.longitud);
+    }
+    let digits;
+    if (typeof value === 'number') {
+        if (!Number.isSafeInteger(value) || value < 0) {
+            fail(c, value, `debe ser un entero no negativo (se recibió ${Number.isNaN(value) ? 'NaN' : value}).`);
+        }
+        digits = String(value);
+    }
+    else if (typeof value === 'string') {
+        if (!/^\d+$/.test(value))
+            fail(c, value, `debe contener solo dígitos (se recibió "${value}").`);
+        digits = value;
+    }
+    else {
+        fail(c, value, `se esperaba number o string de dígitos, se recibió ${tipoDe(value)}.`);
+    }
+    if (digits.length > c.longitud) {
+        fail(c, value, `"${digits}" tiene ${digits.length} dígitos y el campo admite ${c.longitud}.`);
+    }
+    return digits.padStart(c.longitud, '0');
 }
-/**
- * Serializes a baja (employee termination) record.
- * Format: 01|CUIT_EMPLEADOR|TIPO_OP|CUIL|FECHA_BAJA|MOTIVO_BAJA|
- */
-export function serializeBaja(cuitEmpleador, baja) {
-    const cuit = normalizeCuil(cuitEmpleador);
-    const cuil = normalizeCuil(baja.cuil);
-    const fields = [
-        '01',
-        cuit,
-        String(TipoOperacion.BAJA),
-        cuil,
-        formatDate(baja.fechaBaja),
-        String(baja.motivoBaja),
-    ];
-    return fields.join('|') + '|';
+function formatearRetribucion(c, value, o) {
+    if (vacio(value))
+        return formatearNumerico(c, undefined, o);
+    if (typeof value !== 'number')
+        fail(c, value, `se esperaba number, se recibió ${tipoDe(value)}.`);
+    if (!Number.isFinite(value) || value < 0) {
+        fail(c, value, `debe ser un importe finito y no negativo (se recibió ${value}).`);
+    }
+    const centavosExactos = value * 100;
+    const centavos = Math.round(centavosExactos);
+    if (Math.abs(centavosExactos - centavos) > 1e-6 * Math.max(1, Math.abs(centavosExactos))) {
+        fail(c, value, `admite como máximo 2 decimales (se recibió ${value}).`);
+    }
+    if (!Number.isSafeInteger(centavos))
+        fail(c, value, 'importe demasiado grande.');
+    const digits = String(centavos);
+    if (digits.length > c.longitud) {
+        fail(c, value, `${value} ocupa ${digits.length} posiciones (2 decimales implícitos) y el campo admite ${c.longitud}.`);
+    }
+    return digits.padStart(c.longitud, '0');
 }
-/**
- * Serializes a modificacion (employee modification) record.
- * Format: 01|CUIT_EMPLEADOR|TIPO_OP|CUIL|FECHA_INICIO|MODALIDAD|OBRA_SOCIAL|ACTIVIDAD|AGROPECUARIO|FECHA_FIN|CALLE|NUMERO|PISO|DEPTO|LOCALIDAD|CP|PROVINCIA|TELEFONO|
- */
-export function serializeModificacion(cuitEmpleador, mod) {
-    const cuit = normalizeCuil(cuitEmpleador);
-    const cuil = normalizeCuil(mod.cuil);
-    const dom = mod.domicilioExplotacion;
-    const fields = [
-        '01',
-        cuit,
-        String(TipoOperacion.MODIFICACION),
-        cuil,
-        formatDate(mod.fechaInicio),
-        str(mod.modalidadContratacion),
-        str(mod.obraSocial),
-        str(mod.actividadEconomica),
-        mod.trabajadorAgropecuario !== undefined ? boolToStr(mod.trabajadorAgropecuario) : '',
-        mod.fechaFin ? formatDate(mod.fechaFin) : '',
-        dom ? strEsc(dom.calle) : '',
-        dom ? strEsc(dom.numero) : '',
-        dom ? strEsc(dom.piso) : '',
-        dom ? strEsc(dom.depto) : '',
-        dom ? strEsc(dom.localidad) : '',
-        dom ? dom.codigoPostal : '',
-        dom ? String(dom.provincia) : '',
-        dom ? strEsc(dom.telefono) : '',
-    ];
-    return fields.join('|') + '|';
+function transliterar(s) {
+    return s.normalize('NFD').replace(/[̀-ͯ]/g, '').normalize('NFC');
 }
-/**
- * Serializes a datos complementarios record.
- * Format: 02|CUIT_EMPLEADOR|CUIL|FECHA_INICIO|SITUACION_REVISTA|NIVEL_EDUCACION|PUESTO|CCT|TIPO_SERVICIO|MOD_LIQUIDACION|ESTADO_CIVIL|REMUNERACION|HORAS|APORTE_ADICIONAL|CONTRIB_TAREAS_DIF|COD_SINIESTRADO|MARCA_PREAVISO|FECHA_PREAVISO|CONCEPTO_LIQUIDACION|
- */
-export function serializeDatosComplementarios(cuitEmpleador, datos) {
-    const cuit = normalizeCuil(cuitEmpleador);
-    const cuil = normalizeCuil(datos.cuil);
-    const fields = [
-        '02',
-        cuit,
-        cuil,
-        formatDate(datos.fechaInicio),
-        String(datos.situacionRevista),
-        str(datos.nivelEducacion),
-        strEsc(datos.puestoDesempenado),
-        strEsc(datos.convenioColectivo),
-        str(datos.tipoServicio),
-        str(datos.modalidadLiquidacion),
-        str(datos.estadoCivil),
-        formatMonto(datos.remuneracion),
-        str(datos.cantidadHorasTrabajadas),
-        formatMonto(datos.porcentajeAporteAdicionalSS),
-        str(datos.contribucionTareasDiferenciales),
-        str(datos.codigoSiniestrado),
-        datos.marcaPreaviso !== undefined ? boolToStr(datos.marcaPreaviso) : '',
-        datos.fechaPreaviso ? formatDate(datos.fechaPreaviso) : '',
-        str(datos.conceptoLiquidacion),
-    ];
-    return fields.join('|') + '|';
+function formatearAlfanumerico(c, value, o) {
+    if (vacio(value))
+        return ' '.repeat(c.longitud);
+    if (typeof value !== 'string')
+        fail(c, value, `se esperaba string, se recibió ${tipoDe(value)}.`);
+    if (CONTROL_CHARS.test(value))
+        fail(c, value, 'contiene caracteres de control (saltos de línea, tabulaciones, etc.).');
+    const max = maxCodePoint(o.encoding);
+    let s = value.normalize('NFC');
+    const noRepresentable = (t) => [...t].find((ch) => ch.codePointAt(0) > max);
+    if (noRepresentable(s) !== undefined && o.noRepresentables === 'transliterar')
+        s = transliterar(s);
+    const bad = noRepresentable(s);
+    if (bad !== undefined) {
+        fail(c, value, `el caracter "${bad}" no es representable en ${o.encoding === 'ascii' ? 'ASCII' : 'ISO-8859-1'}.`);
+    }
+    if (s.length > c.longitud) {
+        fail(c, value, `"${s}" tiene ${s.length} caracteres y el campo admite ${c.longitud}.`);
+    }
+    return s.padEnd(c.longitud, ' ');
 }
-/**
- * Serializes a CBU record.
- * Format: 03|CUIT_EMPLEADOR|CUIL|FECHA_INICIO|CBU|TIPO_CUENTA|
- */
-export function serializeCBU(cuitEmpleador, cbuData) {
-    const cuit = normalizeCuil(cuitEmpleador);
-    const cuil = normalizeCuil(cbuData.cuil);
-    const fields = [
-        '03',
-        cuit,
-        cuil,
-        formatDate(cbuData.fechaInicio),
-        cbuData.cbu,
-        str(cbuData.tipoCuenta),
-    ];
-    return fields.join('|') + '|';
+function formatearFecha(c, value) {
+    if (vacio(value))
+        return ' '.repeat(c.longitud);
+    try {
+        return formatFechaSR(value);
+    }
+    catch (e) {
+        if (e instanceof ArcaValidationError)
+            fail(c, value, e.message, e);
+        throw e;
+    }
 }
-/**
- * Serializes a relacion familiar record.
- * Format: 04|CUIT_EMPLEADOR|CUIL|FECHA_INICIO|TIPO_RELACION|CUIL_FAMILIAR|DNI_FAMILIAR|NOMBRE|APELLIDO|FECHA_NACIMIENTO|DISCAPACITADO|ESCOLARIDAD|OBRA_SOCIAL_FAMILIAR|CUIL_TITULAR_OS|
- */
-export function serializeRelacionFamiliar(cuitEmpleador, rel) {
-    const cuit = normalizeCuil(cuitEmpleador);
-    const cuil = normalizeCuil(rel.cuil);
-    const fields = [
-        '04',
-        cuit,
-        cuil,
-        formatDate(rel.fechaInicio),
-        String(rel.tipoRelacion),
-        rel.cuilFamiliar ? normalizeCuil(rel.cuilFamiliar) : '',
-        str(rel.dniFamiliar),
-        strEsc(rel.nombreFamiliar),
-        strEsc(rel.apellidoFamiliar),
-        formatDate(rel.fechaNacimiento),
-        rel.discapacitado !== undefined ? boolToStr(rel.discapacitado) : '',
-        str(rel.escolaridad),
-        str(rel.obraSocialFamiliar),
-        rel.cuilTitularObraSocial ? normalizeCuil(rel.cuilTitularObraSocial) : '',
-    ];
-    return fields.join('|') + '|';
+function formatearCuil(c, value) {
+    if (typeof value !== 'string' && typeof value !== 'number') {
+        fail(c, value, `es obligatorio (string o number de 11 dígitos), se recibió ${tipoDe(value)}.`);
+    }
+    const n = normalizeCuit(value);
+    if (!/^\d{11}$/.test(n))
+        fail(c, value, `debe tener 11 dígitos (se recibió "${String(value)}").`);
+    return n;
 }
-/**
- * Serializes a domicilio de explotacion record.
- * Format: 05|CUIT_EMPLEADOR|CUIL|CALLE|NUMERO|PISO|DEPTO|LOCALIDAD|CP|PROVINCIA|TELEFONO|ACTIVIDAD_ECONOMICA|
- */
-export function serializeDomicilio(cuitEmpleador, dom) {
-    const cuit = normalizeCuil(cuitEmpleador);
-    const cuil = normalizeCuil(dom.cuil);
-    const fields = [
-        '05',
-        cuit,
-        cuil,
-        strEsc(dom.calle),
-        strEsc(dom.numero),
-        strEsc(dom.piso),
-        strEsc(dom.depto),
-        strEsc(dom.localidad),
-        dom.codigoPostal,
-        String(dom.provincia),
-        strEsc(dom.telefono),
-        str(dom.actividadEconomica),
-    ];
-    return fields.join('|') + '|';
+function formatearCampo(c, registro, o) {
+    if (c.campo === 'tipoRegistro')
+        return TIPO_REGISTRO;
+    const value = registro[c.campo];
+    switch (c.campo) {
+        case 'movimiento':
+            if (typeof value !== 'string' || !CODIGOS_MOVIMIENTO.includes(value)) {
+                fail(c, value, `debe ser uno de ${CODIGOS_MOVIMIENTO.join(', ')} (se recibió ${JSON.stringify(value) ?? tipoDe(value)}).`);
+            }
+            return value;
+        case 'cuil':
+            return formatearCuil(c, value);
+        case 'retribucion':
+            return formatearRetribucion(c, value, o);
+    }
+    switch (c.tipo) {
+        case 'N': return formatearNumerico(c, value, o);
+        case 'A': return formatearAlfanumerico(c, value, o);
+        case 'F': return formatearFecha(c, value);
+    }
+}
+function assertObjeto(registro) {
+    if (typeof registro !== 'object' || registro === null || Array.isArray(registro)) {
+        throw new ArcaSerializationError(`El registro debe ser un objeto con los datos de la relación laboral, se recibió ${tipoDe(registro)}.`, { value: registro });
+    }
 }
 // ---------------------------------------------------------------------------
-// Full file serializer
+// API pública
 // ---------------------------------------------------------------------------
 /**
- * Serializes a complete F935Archivo to a string.
- * Returns the full file content with header and all record lines.
- * @throws ArcaSerializationError if serialization fails.
+ * Serializa un registro `01` a una línea de exactamente 130 caracteres (sin fin de línea).
+ * @throws ArcaSerializationError si algún campo no se puede escribir (nunca trunca).
+ */
+export function serializarRegistro(registro, opciones) {
+    const o = resolverOpciones(opciones);
+    assertObjeto(registro);
+    const linea = DISENO_REGISTRO.map((c) => formatearCampo(c, registro, o)).join('');
+    if (linea.length !== LONGITUD_REGISTRO) {
+        // Invariante: cada formateador devuelve exactamente `longitud` caracteres.
+        throw new ArcaSerializationError(`Registro de ${linea.length} caracteres (se esperaban ${LONGITUD_REGISTRO}).`);
+    }
+    return linea;
+}
+/**
+ * Devuelve todos los errores de formato de un registro (sin lanzar), uno por campo.
+ * @internal Lo usa `validateRegistro`.
  */
-export function serializeArchivo(archivo) {
+export function erroresDeFormato(registro, opciones) {
+    const o = resolverOpciones(opciones);
     try {
-        const lines = [];
-        // Header
-        lines.push(serializeHeader(archivo));
-        // Records
-        for (const registro of archivo.registros) {
-            lines.push(serializeRegistro(archivo.cuitEmpleador, registro));
-        }
-        return lines.join('\n');
+        assertObjeto(registro);
+    }
+    catch (e) {
+        return [{ field: 'registro', message: e.message, value: registro }];
     }
-    catch (error) {
-        if (error instanceof ArcaSerializationError) {
-            throw error;
+    const errores = [];
+    for (const c of DISENO_REGISTRO) {
+        try {
+            formatearCampo(c, registro, o);
+        }
+        catch (e) {
+            if (!(e instanceof ArcaSerializationError))
+                throw e;
+            errores.push({ field: c.campo, message: e.message, value: e.value });
         }
-        const message = error instanceof Error ? error.message : String(error);
-        throw new ArcaSerializationError(`Error al serializar el archivo F935: ${message}`);
     }
+    return errores;
 }
 /**
- * Serializes a single F935Registro based on its type.
+ * Serializa varios registros al contenido completo del archivo (string).
+ * Por defecto: líneas separadas por CRLF y CRLF final.
+ * @throws ArcaSerializationError con `indice` del registro que falló y `cause` = error original.
  */
-function serializeRegistro(cuitEmpleador, registro) {
-    switch (registro.tipo) {
-        case 1:
-            switch (registro.operacion) {
-                case 0:
-                    return serializeAlta(cuitEmpleador, registro.data);
-                case 1:
-                    return serializeBaja(cuitEmpleador, registro.data);
-                case 2:
-                    return serializeModificacion(cuitEmpleador, registro.data);
-                default:
-                    throw new ArcaSerializationError(`Tipo de operacion desconocido en registro tipo 1`);
-            }
-        case 2:
-            return serializeDatosComplementarios(cuitEmpleador, registro.data);
-        case 3:
-            return serializeCBU(cuitEmpleador, registro.data);
-        case 4:
-            return serializeRelacionFamiliar(cuitEmpleador, registro.data);
-        case 5:
-            return serializeDomicilio(cuitEmpleador, registro.data);
-        default: {
-            const _exhaustive = registro;
-            throw new ArcaSerializationError(`Tipo de registro desconocido: ${_exhaustive.tipo}`);
+export function serializarArchivo(registros, opciones) {
+    const o = resolverOpciones(opciones);
+    if (!Array.isArray(registros)) {
+        throw new ArcaSerializationError(`Se esperaba un array de registros, se recibió ${tipoDe(registros)}.`);
+    }
+    const lineas = registros.map((r, i) => {
+        try {
+            return serializarRegistro(r, o);
+        }
+        catch (e) {
+            if (!(e instanceof ArcaSerializationError))
+                throw e;
+            throw new ArcaSerializationError(`Registro ${i}: ${e.message}`, {
+                field: e.field, desde: e.desde, hasta: e.hasta, value: e.value, indice: i, cause: e,
+            });
+        }
+    });
+    return unirLineas(lineas, o);
+}
+/** @internal */
+export function unirLineas(lineas, opciones) {
+    const o = resolverOpciones(opciones);
+    if (lineas.length === 0)
+        return '';
+    return lineas.join(o.eol) + (o.eolFinal ? o.eol : '');
+}
+/**
+ * Codifica el contenido del archivo a `Buffer` (ISO-8859-1 por defecto, un byte por caracter).
+ * @throws ArcaSerializationError si hay un caracter no representable en la codificación.
+ */
+export function codificarArchivo(contenido, encoding = 'latin1') {
+    if (encoding !== 'latin1' && encoding !== 'ascii') {
+        throw new TypeError(`encoding inválido: ${JSON.stringify(encoding)} (usar 'latin1' o 'ascii')`);
+    }
+    const max = maxCodePoint(encoding);
+    for (let i = 0; i < contenido.length; i++) {
+        if (contenido.charCodeAt(i) > max) {
+            throw new ArcaSerializationError(`El caracter "${contenido[i]}" (posición ${i} del contenido) no es representable en ${encoding}.`, { value: contenido[i] });
         }
     }
+    return Buffer.from(contenido, 'latin1');
 }
 //# sourceMappingURL=serializer.js.map