@devlas/dte-sii 2.13.2 → 2.14.0

package/CafSolicitor.js

@@ -366,6 +366,115 @@ class CafSolicitor {
    *   la simulación de certificación.
    * @returns {Promise<Object>} - { success, cafPath, xml, maxAutor, foliosDisp, error, errorCode }
    */
+  /**
+   * Lista los rangos de folios YA AUTORIZADOS que el SII permite volver a descargar.
+   *
+   * Es la salida a un timbraje bloqueado que no cuesta cupo. Cuando el SII niega folios
+   * nuevos dice, textual: "usted tiene disponible una cantidad de folios suficiente...
+   * debe emitir y enviar documentos electrónicos al SII o anular folios". Anular es
+   * contraproducente —los folios anulados pesan 6 meses EN CONTRA del cupo, así que
+   * profundiza el bloqueo—; emitir es lo que lo levanta. Pero para emitir hace falta el
+   * CAF, y si se perdió, esto lo recupera.
+   *
+   * ⚠️ El listado del paso 2 incluye rangos ANULADOS sin distinguirlos: recién al abrir
+   * cada uno (paso 3) el portal avisa "el rango de folios que desea reobtener ha sido
+   * anulado completamente... los documentos que el Servicio reciba con dichos folios
+   * serán rechazados". Por eso hay que abrir cada rango para saber si sirve, y por eso
+   * este método hace un request por rango. Verificado en maullin el 14/08/2026 con el
+   * RUT 77967443-6: de 6 rangos listados en el tipo 56, solo 2 eran usables.
+   *
+   * @param {number} tipoDte
+   * @returns {Promise<Array<{ campos: Object, folioDesde: number, folioHasta: number,
+   *                           cantidad: number, anulado: boolean }>>}
+   */
+  async listarReobtenibles(tipoDte) {
+    const { numero, dv } = splitRut(this.rutEmisor);
+
+    await this.session.request(`https://${this.session.getBaseHost()}/cvc_cgi/dte/rf_reobtencion1_folios`);
+    const lista = await this.session.submitForm('/cvc_cgi/dte/rf_reobtencion2_folios', {
+      RUT_EMP: numero, DV_EMP: String(dv).toUpperCase(), PAGINA: '1',
+      COD_DOCTO: String(tipoDte), ACEPTAR: 'Consultar',
+    }, '/cvc_cgi/dte/rf_reobtencion1_folios');
+
+    // Cada rango viene en su propio <form name="frmN"> con todos sus ocultos.
+    const rangos = [...String(lista.body || '').matchAll(/<form\s+name="frm\d+"[\s\S]*?<\/form>/gi)]
+      .map(([bloque]) => {
+        const campos = {};
+        for (const [, k, v] of bloque.matchAll(/<input[^>]*name="([^"]+)"[^>]*value="([^"]*)"/gi)) campos[k] = v;
+        return campos;
+      })
+      .filter(c => c.FOLIO_INI && c.FOLIO_FIN);
+
+    const salida = [];
+    for (const campos of rangos) {
+      const detalle = await this.session.submitForm(
+        '/cvc_cgi/dte/rf_reobtencion3_folios', campos, '/cvc_cgi/dte/rf_reobtencion2_folios',
+      );
+      const html = String(detalle.body || '');
+      salida.push({
+        campos,
+        folioDesde: Number(campos.FOLIO_INI),
+        folioHasta: Number(campos.FOLIO_FIN),
+        cantidad: Number(campos.FOLIO_FIN) - Number(campos.FOLIO_INI) + 1,
+        anulado: /ha sido anulado/i.test(html),
+        // El paso 3 ya trae el formulario final; se guarda para no repetir el request.
+        confirmacion: html,
+      });
+    }
+    return salida;
+  }
+
+  /**
+   * Descarga el CAF de un rango ya autorizado. `rango` es un elemento de
+   * `listarReobtenibles()`. Devuelve el mismo shape que `solicitar()` para que el
+   * llamador no tenga que distinguir de dónde salió el CAF.
+   */
+  async reobtenerCaf(tipoDte, rango) {
+    if (rango.anulado) {
+      return { success: false, errorCode: 'RANGO_ANULADO',
+        error: `El rango ${rango.folioDesde}-${rango.folioHasta} del tipo ${tipoDte} está anulado: el SII rechazaría cualquier documento emitido con esos folios.` };
+    }
+
+    // El paso 3 devolvió el formulario final (`form1` → rf_genera_folio) con sus ocultos.
+    const campos = {};
+    const bloque = String(rango.confirmacion || '').match(/<form\s+name="form1"[\s\S]*?<\/form>/i)?.[0] ?? '';
+    for (const [, k, v] of bloque.matchAll(/<input[^>]*name="([^"]+)"[^>]*value="([^"]*)"/gi)) campos[k] = v;
+    if (!campos.FOLIO_INI) {
+      return { success: false, errorCode: 'REOBTENCION_SIN_FORMULARIO',
+        error: 'El SII no devolvió el formulario de generación para este rango.' };
+    }
+
+    // `rf_genera_folio` NO devuelve el XML: emite la resolución ("el SII ha autorizado...
+    // la numeración desde N hasta M") y recién ahí ofrece el enlace de descarga, que es
+    // otro formulario contra `rf_genera_archivo`. Son dos pasos, como en el timbraje
+    // normal (of_genera_folio → of_genera_archivo).
+    const autorizacion = await this.session.submitForm('/cvc_cgi/dte/rf_genera_folio',
+      { ...campos, ACEPTAR: 'Solicitar Folios' }, '/cvc_cgi/dte/rf_reobtencion3_folios');
+
+    const camposArchivo = {};
+    const formArchivo = String(autorizacion.body || '')
+      .match(/<form[^>]*action="[^"]*rf_genera_archivo"[\s\S]*?<\/form>/i)?.[0] ?? '';
+    for (const [, k, v] of formArchivo.matchAll(/<input[^>]*name="([^"]+)"[^>]*value="([^"]*)"/gi)) camposArchivo[k] = v;
+    if (!camposArchivo.FOLIO_INI) {
+      return { success: false, errorCode: 'REOBTENCION_SIN_DESCARGA',
+        error: 'El SII autorizó la reobtención pero no ofreció el enlace de descarga del CAF.' };
+    }
+
+    const resp = await this.session.submitForm('/cvc_cgi/dte/rf_genera_archivo',
+      { ...camposArchivo, ACEPTAR: 'AQUI' }, '/cvc_cgi/dte/rf_genera_folio');
+    const body = String(resp.body || '');
+    if (!body.includes('<AUTORIZACION')) {
+      return { success: false, errorCode: 'REOBTENCION_SIN_CAF',
+        error: 'El SII no devolvió el XML del CAF al reobtener.' };
+    }
+
+    const cafPath = this._saveCafOrganized(body, tipoDte);
+    return {
+      success: true, cafPath, xml: body, reobtenido: true,
+      folioDesde: rango.folioDesde, folioHasta: rango.folioHasta, otorgados: rango.cantidad,
+    };
+  }
+
   async solicitar({ tipoDte, cantidad = 1, minCantidad = null, soloConsultarTope = false }) {
     const { numero: rut, dv } = splitRut(this.rutEmisor);
     const debugDir = this._getDebugDir(tipoDte);
@@ -421,9 +530,14 @@ class CafSolicitor {
 
       this._saveDebug(debugDir, 'step1-submit.html', response.body || '');
 
-      // Guardar sesión para reutilización
+      // Guardar sesión para reutilización. Best-effort: si falla, se pierde el
+      // reuso pero NO se aborta la solicitud de folios ya en curso.
       if (this.sessionPath) {
-        this.session.saveSession(this.sessionPath);
+        try {
+          this.session.saveSession(this.sessionPath);
+        } catch (e) {
+          console.warn(`[CafSolicitor] No se pudo guardar la sesión: ${e.message}`);
+        }
       }
 
       // Rechazo duro por falta de Verificación de Actividades: debe detectarse ANTES de
@@ -658,12 +772,31 @@ class CafSolicitor {
    * Procesa el flujo multi-paso del SII para obtener CAF
    * @private
    */
+  /**
+   * Igual que `esRechazoDuro`, pero además deja registrado si el motivo fue el bloqueo de
+   * timbraje, para que `consultarTope()` pueda distinguir "el SII no limita este tipo" de
+   * "el SII no autoriza nada" — dos casos que se ven idénticos porque en ambos la página
+   * viene sin MAX_AUTOR.
+   *
+   * Existe porque el corte por rechazo duro está en CUATRO puntos distintos del flujo
+   * (`_processMultiStepFlow` dos veces, su paso intermedio y `_processStep3`), y cada uno
+   * retorna apenas lo detecta. Marcar la bandera en uno solo dejaba la detección
+   * inalcanzable según por dónde saliera: el sondeo del tipo 56 informaba "no está
+   * racionando" con el timbraje cerrado (14/08/2026). Se marca donde se detecta, no en un
+   * punto elegido a mano.
+   * @private
+   */
+  _esRechazoDuroYMarca(html) {
+    if (CafSolicitor.esBloqueoTimbraje(html)) this._lastBloqueoTimbraje = true;
+    return CafSolicitor.esRechazoDuro(html);
+  }
+
   async _processMultiStepFlow(response, rut, dv, tipoDte, cantidad, debugDir) {
     let currentHtml = response.body || '';
 
     // Defensivo: mismo rechazo por Verificación de Actividades puede aparecer si el SII
     // lo entrega recién en un paso posterior en vez del response inicial de solicitar().
-    if (CafSolicitor.esRechazoDuro(currentHtml)) {
+    if (this._esRechazoDuroYMarca(currentHtml)) {
       return response; // solicitar() traduce el motivo desde response.body
     }
 
@@ -698,7 +831,7 @@ class CafSolicitor {
 
       // Rechazo duro antes del check de COD_DOCTO: la página de rechazo también contiene
       // "COD_DOCTO" en su JavaScript, lo que causaría un POST innecesario con datos vacíos.
-      if (CafSolicitor.esRechazoDuro(currentHtml)) {
+      if (this._esRechazoDuroYMarca(currentHtml)) {
         return response; // solicitar() traduce el motivo desde response.body
       }
 
@@ -721,7 +854,7 @@ class CafSolicitor {
         currentHtml = response.body || '';
         this._saveDebug(debugDir, 'select.html', currentHtml);
 
-        if (CafSolicitor.esRechazoDuro(currentHtml)) {
+        if (this._esRechazoDuroYMarca(currentHtml)) {
           return response; // solicitar() traduce el motivo desde response.body
         }
       }
@@ -740,7 +873,14 @@ class CafSolicitor {
   async _processStep3(response, rut, dv, tipoDte, cantidad, debugDir) {
     let currentHtml = response.body || '';
 
-    if (CafSolicitor.esRechazoDuro(currentHtml)) {
+    // Se marca ANTES del corte por rechazo duro, no después.
+    //
+    // `esRechazoDuro` incluye el bloqueo de timbraje, así que en ese caso la función
+    // retorna acá mismo y todo lo que viene abajo —incluida la lectura de MAX_AUTOR—
+    // no se ejecuta. Marcarlo más adelante dejaba la bandera en false justo en el único
+    // caso que tiene que detectar, y el sondeo seguía informando "el SII no está
+    // racionando este tipo" con el timbraje cerrado (visto el 14/08/2026, tipo 56).
+    if (this._esRechazoDuroYMarca(currentHtml)) {
       return response; // solicitar() traduce el motivo desde response.body
     }
 

package/DTE.js

@@ -20,7 +20,7 @@ const {
   TIPOS_BOLETA,
   TASA_IVA,
 } = require('./utils');
-const { serializeNode, fixEntities, escapeAttr, escapeText, buildSignedInfo, buildSignature } = require('./utils/c14n');
+const { serializeNode, escapeAttr, escapeText, buildSignedInfo, buildSignature } = require('./utils/c14n');
 
 // ============================================
 // CONSTANTES
@@ -410,7 +410,7 @@ class DTE {
     }
 
     c14n += '</Documento>';
-    return fixEntities(c14n);
+    return c14n;
   }
   
   // ============================================

package/FolioService.js

@@ -109,11 +109,17 @@ class FolioService {
 
     // Solicitador de CAF interno (migrado de test-caf-solicitar.js)
     this.cafSolicitor = null;
-    if (options.pfxPath && options.pfxPassword) {
+    // `pfxBuffer` también sirve: el constructor pedía `pfxPath` sí o sí, aunque la propia
+    // clase ya acepta buffer para la sesión y CafSolicitor lo soporta. Un consumidor que
+    // tiene el certificado en memoria (leído de la BD, sin escribirlo a disco) quedaba con
+    // `cafSolicitor: null` y todo lo que depende de él —solicitar, consultar tope,
+    // reobtener— fallaba con "CafSolicitor no inicializado".
+    if ((options.pfxPath || options.pfxBuffer) && options.pfxPassword) {
       this.cafSolicitor = new CafSolicitor({
         ambiente: this.ambiente,
         rutEmisor: this.rutEmisor,
         pfxPath: options.pfxPath,
+        pfxBuffer: options.pfxBuffer,
         pfxPassword: options.pfxPassword,
         baseDir: this.baseDir,
         sessionPath: this.sessionPath,
@@ -152,7 +158,23 @@ class FolioService {
             try {
               const xml = fs.readFileSync(fullPath, 'utf8');
               const tdMatch = xml.match(/<TD>(\d+)<\/TD>/i);
-              if (tdMatch && Number(tdMatch[1]) === Number(tipoDte)) {
+              // ⚠️ El RUT se valida acá, contra el <RE> del propio CAF, y NO se da por
+              // supuesto por la ruta.
+              //
+              // `cafDir` (debug/auto-caf) es COMPARTIDO entre todos los comercios del
+              // servidor: sus subcarpetas llevan el RUT, pero la búsqueda es recursiva y
+              // antes solo comparaba el tipo de DTE. Un CAF de otra empresa con el mismo
+              // tipo entraba como candidato válido.
+              //
+              // Pasó de verdad (14/08/2026): al reusar CAF previos, los tipos 56 y 61 del
+              // RUT 77967443-6 resolvieron a CAF de 78206276-K. El timbre quedó firmado con
+              // la llave de otro contribuyente y el SII devolvió `RFR - Rechazado por Error
+              // en Firma` para todo el envío, lo que a su vez trababa la declaración de
+              // simulación ("no debe contener documentos con reparos o rechazos").
+              const reMatch = xml.match(/<RE>([^<]+)<\/RE>/i);
+              const rutCaf  = (reMatch?.[1] ?? '').replace(/\./g, '').trim().toUpperCase();
+              const rutMio  = String(this.rutEmisor).replace(/\./g, '').trim().toUpperCase();
+              if (tdMatch && Number(tdMatch[1]) === Number(tipoDte) && rutCaf === rutMio) {
                 const stat = fs.statSync(fullPath);
                 matches.push({ filePath: fullPath, mtime: stat.mtimeMs });
               }
@@ -307,6 +329,86 @@ class FolioService {
    *   usar para destrabar el tope. Ponerlo en false lo deja en modo consulta.
    * @returns {Promise<Object>} { ok, cafPath, otorgados, maxAutor, foliosDisp, errorCode, error }
    */
+  /**
+   * Intenta cubrir `cantidad` folios recuperando un CAF ya autorizado, sin pedirle folios
+   * nuevos al SII.
+   *
+   * Es el paso que va ANTES de pedir y muy antes de anular. Cuando el SII bloquea el
+   * timbraje lo hace porque el contribuyente ya tiene folios sin usar; recuperarlos y
+   * emitir con ellos es justo lo que el SII pide para levantar el bloqueo, mientras que
+   * anular lo empeora (los folios anulados pesan 6 meses en contra del cupo).
+   *
+   * ⚠️ Solo sirve un rango que por sí solo alcance: el generador de sets recibe UN CAF por
+   * tipo (`cafManager.ensureCaf({ tipoDte })` en CertRunner), así que no se pueden juntar
+   * dos rangos sueltos para el mismo tipo. El SII suele entregarlos de a un folio, así que
+   * esto no siempre alcanza — y cuando no alcanza, se devuelve el motivo en vez de fingir.
+   *
+   * @returns {Promise<{ ok: boolean, cafPath?: string, motivo?: string, disponibles?: number }>}
+   */
+  async reobtenerCaf({ tipoDte, cantidad }) {
+    if (!this.cafSolicitor) {
+      return { ok: false, motivo: 'CafSolicitor no inicializado' };
+    }
+    let rangos;
+    try {
+      rangos = await this.cafSolicitor.listarReobtenibles(Number(tipoDte));
+    } catch (err) {
+      // Nunca fatal: si la reobtención falla, el flujo sigue por el camino normal.
+      console.warn(`[FolioService] Tipo ${tipoDte}: no se pudo consultar reobtención — ${err.message}`);
+      return { ok: false, motivo: err.message };
+    }
+
+    const usables = rangos.filter(r => !r.anulado);
+    const anulados = rangos.length - usables.length;
+    console.log(
+      `[FolioService] Tipo ${tipoDte}: ${rangos.length} rango(s) reobtenible(s), ` +
+      `${usables.length} usable(s)${anulados ? `, ${anulados} anulado(s) descartado(s)` : ''}`
+    );
+
+    const total = usables.reduce((n, r) => n + r.cantidad, 0);
+    if (total < cantidad) {
+      return {
+        ok: false,
+        disponibles: total,
+        motivo: `los rangos usables no alcanzan (se necesitan ${cantidad}, hay ${total})`,
+      };
+    }
+
+    // En orden de folio ascendente: los documentos del set quedan numerados de menor a
+    // mayor, como si vinieran de un rango contiguo.
+    const elegidos = [];
+    let acumulado = 0;
+    for (const r of usables.sort((a, b) => a.folioDesde - b.folioDesde)) {
+      if (acumulado >= cantidad) break;
+      elegidos.push(r);
+      acumulado += r.cantidad;
+    }
+
+    // Se descargan TODOS los que hagan falta: el SII entrega los folios reobtenidos de a
+    // uno, así que cubrir 4 folios puede requerir 4 CAF distintos. Los sets los aceptan
+    // como lista (ver SetBase._tomarFolio) porque cada uno firma con su propia llave.
+    const cafPaths = [];
+    for (const rango of elegidos) {
+      const res = await this.cafSolicitor.reobtenerCaf(Number(tipoDte), rango);
+      if (!res.success) {
+        // Si uno falla a mitad, lo ya descargado igual sirve mientras alcance.
+        console.warn(`[FolioService] Tipo ${tipoDte}: falló reobtener ${rango.folioDesde}-${rango.folioHasta} — ${res.error}`);
+        continue;
+      }
+      cafPaths.push(res.cafPath);
+      console.log(`[FolioService] Tipo ${tipoDte}: CAF REOBTENIDO (folios ${res.folioDesde}-${res.folioHasta}) — sin gastar cupo`);
+    }
+
+    const cubiertos = elegidos
+      .filter((_, i) => i < cafPaths.length)
+      .reduce((n, r) => n + r.cantidad, 0);
+    if (cubiertos < cantidad) {
+      return { ok: false, disponibles: cubiertos,
+        motivo: `se reobtuvieron ${cubiertos} folio(s) de los ${cantidad} necesarios` };
+    }
+    return { ok: true, cafPaths, cafPath: cafPaths[0] };
+  }
+
   /**
    * Consulta cuánto autoriza el SII para un tipo, SIN emitir nada.
    *
@@ -325,11 +427,16 @@ class FolioService {
     if (!this.cafSolicitor) {
       throw new Error('FolioService: CafSolicitor no inicializado (se requiere pfxPath y pfxPassword)');
     }
+    this.cafSolicitor._lastBloqueoTimbraje = false;
     await this.cafSolicitor.solicitar({ tipoDte, cantidad: 1, soloConsultarTope: true });
     const maxAutor   = this.cafSolicitor._lastMaxAutor ?? null;
     const foliosDisp = this.cafSolicitor._lastFoliosDisp ?? null;
-    // `_lastFoliosDisp` queda en null justamente cuando el SII no publicó los campos.
-    return { sinTope: foliosDisp === null, maxAutor, foliosDisp };
+    const bloqueado  = this.cafSolicitor._lastBloqueoTimbraje === true;
+    // `_lastFoliosDisp` queda en null en DOS casos opuestos: cuando el SII no está
+    // limitando este tipo, y cuando lo tiene bloqueado del todo (ahí tampoco publica los
+    // campos, muestra "NO AUTORIZA TIMBRAJE"). Sin `bloqueado`, el segundo se leía como el
+    // primero y el llamador se saltaba la limpieza que era justo lo que hacía falta.
+    return { sinTope: foliosDisp === null && !bloqueado, maxAutor, foliosDisp, bloqueado };
   }
 
   async solicitarCafExacto({ tipoDte, cantidad, permitirAnular = true }) {
@@ -647,7 +754,40 @@ class FolioService {
       console.log(`[FolioService] Pasada ${pasada + 1}: ${rangos.length} rango(s) a procesar`);
       const host = this.session.getBaseHost();
 
+      // Corte cuando el SII deja de permitir anular, para no gastar requests confirmando
+      // lo mismo rango tras rango.
+      //
+      // ⚠️ Solo cuentan las negativas REALES. `ya-anulado` y `recepcionado` no son
+      // negativas: son resultados esperados (ese rango ya estaba anulado, o sus folios ya
+      // se usaron) y aparecen mezclados con anulaciones exitosas.
+      //
+      // Contarlos rompía la limpieza (medido el 13/08/2026, RUT 77967443-6, tipo 33):
+      //     20 rangos a procesar
+      //     ✓ 47-49 anulado   ✓ 43-46 anulado
+      //     ✗ 31-34 ya anulado ✗ 27-30 ya anulado  → CORTE, 8 rangos sin intentar
+      // Los éxitos y los "ya anulado" se intercalan, así que cortar ahí abandona rangos
+      // todavía anulables y deja el racionamiento puesto: la corrida quedó esperando por
+      // folios que se podrían haber liberado en esa misma pasada.
+      const NO_SON_NEGATIVA = new Set(['ya-anulado', 'recepcionado']);
+      const esNegativaDelSii = (razon) => !NO_SON_NEGATIVA.has(razon);
+      const MAX_RECHAZOS_SEGUIDOS = 2;
+      let rechazosSeguidos = 0;
+
+      let procesados = 0;
       for (const range of rangos) {
+        if (rechazosSeguidos >= MAX_RECHAZOS_SEGUIDOS) {
+          console.warn(
+            `[FolioService] Tipo ${tipoDte}: ${rechazosSeguidos} rangos rechazados seguidos — ` +
+            `el SII no está permitiendo anular, se abandona la limpieza ` +
+            // Se cuenta contra los rangos de ESTA pasada, no contra `vistos`, que acumula
+            // entre pasadas y hacía que el número saliera negativo (visto el 13/08/2026:
+            // "se abandona la limpieza (-16 rango(s) sin intentar)").
+            `(${rangos.length - procesados} rango(s) sin intentar).`
+          );
+          break;
+        }
+        procesados++;
+        const anuladosAntes = anulados.length;
         vistos.add(`${range.folioDesde}-${range.folioHasta}`);
         const iniA = folioDesde != null ? Math.max(range.folioDesde, folioDesde) : range.folioDesde;
         const finA = folioHasta != null ? Math.min(range.folioHasta, folioHasta) : range.folioHasta;
@@ -675,6 +815,7 @@ class FolioService {
         } catch (err) {
           console.error(`[FolioService] af_anular3 falló rango ${iniA}-${finA}: ${err.message}`);
           rechazados.push({ folioDesde: iniA, folioHasta: finA, count, reason: 'error-red' });
+          rechazosSeguidos = rechazosSeguidos + 1;
           continue;
         }
 
@@ -687,6 +828,7 @@ class FolioService {
             body3.includes('efectuado anteriormente') ||
             /anulad[oa]\s+anteriormente/i.test(body3)) {
           rechazados.push({ folioDesde: iniA, folioHasta: finA, count, reason: 'ya-anulado' });
+          // 'ya anulado' NO cuenta: es un no-op, no una negativa del SII.
           // Se recuerda para que la próxima corrida no lo reintente.
           yaAnulados.add(`${iniA}-${finA}`);
           console.warn(`[FolioService] ✗ Rango ${iniA}-${finA}: ya anulado (af_anular3)`);
@@ -711,6 +853,7 @@ class FolioService {
         } catch (err) {
           console.error(`[FolioService] af_anular bulk falló rango ${iniA}-${finA}: ${err.message}`);
           rechazados.push({ folioDesde: iniA, folioHasta: finA, count, reason: 'error-red' });
+          rechazosSeguidos = rechazosSeguidos + 1;
           continue;
         }
 
@@ -718,6 +861,7 @@ class FolioService {
                           bodyBulk.includes('SOLICITUD ANULACION DE FOLIOS');
         if (exitoBulk) {
           anulados.push({ folioDesde: iniA, folioHasta: finA, count });
+          rechazosSeguidos = 0;
           // Un rango recién anulado sigue apareciendo en `consultarFolios` como
           // "sin utilizar": si no se recuerda acá, la próxima corrida lo
           // reintenta y el SII contesta "ya anulado". Ésta es la fuente
@@ -738,6 +882,7 @@ class FolioService {
         if (!yaConflicto) {
           const razon = this._parseAnulacionResult(bodyBulk).reason || 'error';
           rechazados.push({ folioDesde: iniA, folioHasta: finA, count, reason: razon });
+          if (esNegativaDelSii(razon)) rechazosSeguidos = rechazosSeguidos + 1;
           // Mismo criterio que en el camino folio-a-folio: solo se recuerdan los
           // rechazos definitivos, no los transitorios.
           if (razon === 'ya-anulado' || razon === 'recepcionado') {

package/Signer.js

@@ -9,7 +9,7 @@
 const crypto = require('crypto');
 const { DOMParser } = require('@xmldom/xmldom');
 const { formatBase64InXml } = require('./utils');
-const { serializeNode, fixEntities, buildSignedInfo, buildSignature } = require('./utils/c14n');
+const { serializeNode, buildSignedInfo, buildSignature } = require('./utils/c14n');
 
 // ============================================
 // CLASE SIGNER
@@ -87,7 +87,7 @@ class Signer {
     }
     
     c14n += '</SetDTE>';
-    return fixEntities(c14n);
+    return c14n;
   }
 }
 

package/SiiCertificacion.js

@@ -107,7 +107,15 @@ class SiiCertificacion {
       const _sp = options.sessionPath;
       this.session.ensureSession = async function(targetPath) {
         const result = await _origEnsure(targetPath);
-        _sess.saveSession(_sp);
+        // Best-effort: este hook corre en CADA establecimiento de sesión, así que
+        // una falla al escribir el cache (disco lleno, permisos, volumen no montado)
+        // tumbaría toda operación contra el SII. Persistir la sesión es una
+        // optimización; la operación en curso ya tiene la sesión viva en memoria.
+        try {
+          _sess.saveSession(_sp);
+        } catch (e) {
+          console.warn(`[SiiCertificacion] No se pudo guardar la sesión en ${_sp}: ${e.message}`);
+        }
         return result;
       };
     }

package/SiiSession.js

@@ -538,17 +538,41 @@ class SiiSession {
   }
 
   /**
-   * Guarda la sesión actual en un archivo JSON
+   * Guarda la sesión actual en un archivo JSON.
+   *
+   * Crea el directorio contenedor si no existe: `filePath` suele apuntar a un
+   * volumen persistente o a una carpeta de debug que en el primer arranque
+   * todavía no está creada, y sin esto `writeFileSync` lanza ENOENT. Perder la
+   * sesión obliga a re-loguearse contra el SII en cada operación, que es el
+   * camino directo al bloqueo por "máximo de sesiones autenticadas" del RUT.
+   *
    * @param {string} filePath - Ruta del archivo donde guardar
    */
+  /**
+   * Huella del certificado con el que se configuró el TLS de esta sesión.
+   *
+   * Identifica de QUIÉN es la sesión. Sin esto, `SII_SESSION_PATH` —que en producción es
+   * un archivo ÚNICO para todos los comercios (`/data/sii/session.json`)— hacía que la
+   * sesión de un contribuyente se cargara para las operaciones de otro.
+   * @private
+   */
+  _huellaCert() {
+    const pem = this.tlsOptions?.cert;
+    if (!pem) return null;
+    return require('crypto').createHash('sha256').update(String(pem)).digest('hex').slice(0, 16);
+  }
+
   saveSession(filePath) {
     const fs = require('fs');
+    const path = require('path');
     const sessionData = {
       cookieJar: this.cookieJar,
       baseHost: this.baseHost,
+      certHash: this._huellaCert(),
       savedAt: Date.now(),
       expiresAt: Date.now() + (90 * 60 * 1000), // 90 minutos de validez
     };
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
     fs.writeFileSync(filePath, JSON.stringify(sessionData, null, 2), 'utf8');
   }
 
@@ -576,6 +600,26 @@ class SiiSession {
         console.log('Host SII no coincide, se requiere nuevo login');
         return false;
       }
+
+      // ⚠️ Y que la sesión sea de ESTE certificado.
+      //
+      // `SII_SESSION_PATH` es un archivo único para todo el proceso (en producción
+      // `/data/sii/session.json`), así que en un servidor multi-tenant la sesión del
+      // último comercio que operó queda ahí para el siguiente. Cargarla significa actuar
+      // ante el SII como el usuario de OTRO contribuyente.
+      //
+      // Caso real (14/08/2026): una corrida del RUT 78206276-K reusó la sesión del
+      // certificado de otra empresa y el portal respondió "usted no está autorizado por la
+      // empresa para ingresar a esta opción" al pedir el set de pruebas. El mismo pedido
+      // con autenticación fresca funcionó. El síntoma no dice "sesión equivocada", dice
+      // "sin permisos", que manda a buscar el problema donde no está.
+      //
+      // Las sesiones viejas no traen `certHash`: se descartan, que es lo seguro.
+      const huella = this._huellaCert();
+      if (huella && data.certHash !== huella) {
+        console.log('[SessionSii] Sesión de otro certificado — se ignora y se hace login propio');
+        return false;
+      }
       
       this.cookieJar = data.cookieJar || '';
       console.log('[SessionSii] Sesión SII cargada desde archivo');