@devlas/dte-sii 2.12.22 → 2.12.24

package/CafSolicitor.js

@@ -187,17 +187,78 @@ class CafSolicitor {
     );
   }
 
+  /**
+   * Detecta la página de bloqueo duro de timbraje del SII.
+   *
+   * El SII usa al menos DOS redacciones para la misma página de rechazo:
+   *   - "NO SE AUTORIZA TIMBRAJE ELECTRÓNICO"  (la documentada en PLAN-MEJORAS-CAF.md)
+   *   - "NO AUTORIZA TIMBRAJE ELECTRÓNICA"     (observada 2026-07-22 en tipo 56)
+   *
+   * Detectar solo la primera hacía que la segunda cayera al genérico
+   * `UNKNOWN: No se obtuvo CAF en la respuesta`, sin disparar el remedio de
+   * anular folios — que es justamente lo que la página pide hacer. Ambas
+   * variantes carecen de <form> e <input>, así que sin esta detección el flujo
+   * sigue de largo hasta fallar sin diagnóstico.
+   *
+   * @param {string} html - Cuerpo de la respuesta del SII
+   * @returns {boolean}
+   */
+  /**
+   * Campos de tipo de documento del formulario de postulación (`pe_confirma`),
+   * verificados contra el form real del SII el 2026-07-22.
+   *
+   * El listado original omitía `CONIVA`, `SET11`, `BOLELE` y `BOLEXE`, que el
+   * SII sí incluye. Se exportan acá para que el consumidor no tenga que
+   * mantener la lista duplicada.
+   */
+  static get CAMPOS_POSTULACION() {
+    return {
+      // Factura electrónica
+      ESFAC: 'S',   // habilita la sección factura
+      FACT: 'S',    // Facturas
+      CONIVA: 'S',  // con IVA
+      NC: 'S',      // Notas de crédito
+      ND: 'S',      // Notas de débito
+      SET03: 'S',   // Guías de despacho
+      SET06: 'S',   // Facturas exentas
+      SET72: 'S',   // Factura de compra
+      // Boleta electrónica
+      ESBOL: 'S',   // habilita la sección boleta
+      BOLELE: 'S',
+      BOLELEC: 'S', // Boleta electrónica
+      BOLEXE: 'S',
+      BOLEXEN: 'S', // Boleta exenta electrónica
+      // NO se marcan por defecto:
+      //   SET11 → Documentos de exportación (requiere trámite aduanero aparte)
+      //   SET84 → Liquidación factura electrónica (caso de uso específico)
+    };
+  }
+
+  static esBloqueoTimbraje(html) {
+    return /NO\s+(SE\s+)?AUTORIZA\s+TIMBRAJE/i.test(String(html || ''));
+  }
+
   /**
    * Solicita un CAF al SII
    * @param {Object} params - Parámetros
    * @param {number} params.tipoDte - Tipo de DTE (33, 34, 39, 56, 61, etc.)
    * @param {number} [params.cantidad=1] - Cantidad de folios a solicitar
-   * @returns {Promise<Object>} - { success, cafPath, xml, error }
+   * @param {number} [params.minCantidad] - Mínimo aceptable. Si el SII declara un
+   *   MAX_AUTOR menor, se aborta ANTES de emitir en vez de aceptar un rango corto
+   *   (ver `_processStep3`). Útil para flujos que necesitan N folios exactos, como
+   *   la simulación de certificación.
+   * @returns {Promise<Object>} - { success, cafPath, xml, maxAutor, foliosDisp, error, errorCode }
    */
-  async solicitar({ tipoDte, cantidad = 1 }) {
+  async solicitar({ tipoDte, cantidad = 1, minCantidad = null }) {
     const { numero: rut, dv } = splitRut(this.rutEmisor);
     const debugDir = this._getDebugDir(tipoDte);
 
+    // Estado por-solicitud leído desde el form del SII en _processStep3
+    this._lastMaxAutor = null;
+    this._lastFoliosDisp = null;
+    this._maxAutorInsuficiente = false;
+    this._minCantidad = minCantidad;
+
     // Rate limiting: mínimo 1001ms entre solicitudes para no saturar el portal SII.
     const _now = Date.now();
     const _elapsed = _now - CafSolicitor._lastSolicitudAt;
@@ -272,13 +333,34 @@ class CafSolicitor {
         return { success: false, errorCode: 'WAAP_BLOCKED', error: 'IP bloqueada por el firewall del SII. Espera antes de reintentar.' };
       }
 
+      // Abort temprano por MAX_AUTOR insuficiente (ver _processStep3). Se chequea antes
+      // que el resto porque en este caso no se llegó a emitir nada: el body es la página
+      // del paso previo, sin <AUTORIZACION> ni marcador de error propio.
+      if (this._maxAutorInsuficiente) {
+        return {
+          success: false,
+          errorCode: 'MAX_AUTOR_INSUFICIENTE',
+          maxAutor: this._lastMaxAutor,
+          foliosDisp: this._lastFoliosDisp,
+          error: `SII: autoriza como máximo ${this._lastMaxAutor} folio(s) para el tipo ${tipoDte} ` +
+            `y se requieren ${minCantidad} (FOLIOS_DISP=${this._lastFoliosDisp}). ` +
+            `Ocurre cuando hay folios timbrados sin utilizar — anúlalos o emite documentos de este tipo.`,
+        };
+      }
+
       // Verificar si obtuvimos el CAF
       if (response.body && response.body.includes('<AUTORIZACION')) {
         const cafPath = this._saveCafOrganized(response.body, tipoDte);
-        return { success: true, cafPath, xml: response.body, maxAutor: this._lastMaxAutor ?? cantidad };
+        return {
+          success: true,
+          cafPath,
+          xml: response.body,
+          maxAutor: this._lastMaxAutor ?? cantidad,
+          foliosDisp: this._lastFoliosDisp,
+        };
       }
 
-      if (response.body && response.body.includes('NO SE AUTORIZA')) {
+      if (response.body && CafSolicitor.esBloqueoTimbraje(response.body)) {
         return { success: false, errorCode: 'TIMBRAJE_BLOQUEADO', error: 'SII: No se autoriza timbraje. Folios acumulados excesivos o situaciones tributarias pendientes. Revisa el portal SII → Factura Electrónica → Solicitud de Timbraje.' };
       }
 
@@ -301,6 +383,26 @@ class CafSolicitor {
       // (ej: ya hay un timbraje del mismo día que consume parte del cupo diario).
       // Solución: reintentar con cantidad=1 para garantizar obtener al menos 1 folio.
       if (response.body && response.body.includes('menor o igual al m')) {
+        // Con `minCantidad` el llamador necesita N folios exactos: caer a 1 le
+        // entrega un CAF inservible Y suma +1 a FOLIOS_DISP (el folio queda sin
+        // usar), agravando el racionamiento en el próximo intento. Este retry
+        // preexistente bypaseaba el chequeo temprano de _processStep3, que solo
+        // cubre el MAX_AUTOR declarado en el formulario — no el efectivo, que el
+        // SII recién aplica al recibir el submit.
+        if (minCantidad && minCantidad > 1) {
+          console.warn(
+            `[CafSolicitor] Tipo ${tipoDte}: MAX_AUTOR efectivo insuficiente para ${cantidad} folios ` +
+            `y se requieren al menos ${minCantidad} — no se cae a 1 folio.`
+          );
+          return {
+            success: false,
+            errorCode: 'MAX_AUTOR_INSUFICIENTE',
+            maxAutor: this._lastMaxAutor,
+            foliosDisp: this._lastFoliosDisp,
+            error: `SII rechazó ${cantidad} folios para el tipo ${tipoDte} por exceder el máximo autorizado, ` +
+              `y se requieren al menos ${minCantidad}. Ocurre cuando hay folios timbrados sin utilizar.`,
+          };
+        }
         if (cantidad > 1) {
           console.warn(`[CafSolicitor] MAX_AUTOR excedido para ${cantidad} folios — reintentando con 1 folio...`);
           // No limpiar cookieJar: el error es del formulario, no de la sesión.
@@ -436,7 +538,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 (currentHtml.includes('NO SE AUTORIZA')) {
+      if (CafSolicitor.esBloqueoTimbraje(currentHtml)) {
         return response; // solicitar() detectará el bloqueo en response.body
       }
 
@@ -459,7 +561,7 @@ class CafSolicitor {
         currentHtml = response.body || '';
         this._saveDebug(debugDir, 'select.html', currentHtml);
 
-        if (currentHtml.includes('NO SE AUTORIZA')) {
+        if (CafSolicitor.esBloqueoTimbraje(currentHtml)) {
           return response; // solicitar() detectará el bloqueo en response.body
         }
       }
@@ -487,9 +589,32 @@ class CafSolicitor {
 
     // CANT_DOCTOS debe enviarse con un valor <= MAX_AUTOR.
     // Si se omite o excede MAX_AUTOR, el SII rechaza devolviendo la página de inicio (rechazo silencioso).
+    //
+    // MAX_AUTOR/FOLIOS_DISP solo aparecen cuando el SII está LIMITANDO este tipo de
+    // documento (confirmado experimentalmente 2026-07-22: tras anular folios, los tipos
+    // 56 y 61 dejaron de exponerlos). Su ausencia significa "sin tope" → no se recorta.
+    const tieneMaxAutor =
+      inputs3.MAX_AUTOR !== undefined && inputs3.MAX_AUTOR !== '';
     const maxAutor = parseInt(inputs3.MAX_AUTOR || String(cantidad), 10);
+    const foliosDisp = parseInt(inputs3.FOLIOS_DISP || '0', 10);
     const cantReal = Math.min(cantidad, maxAutor);
     this._lastMaxAutor = maxAutor; // guardado para retornarlo desde solicitar()
+    this._lastFoliosDisp = tieneMaxAutor ? foliosDisp : null;
+
+    // El SII raciona MAX_AUTOR según los folios timbrados sin utilizar (FOLIOS_DISP):
+    // con FOLIOS_DISP=0 autoriza 100, con 2 ya baja a 1, y si sigue subiendo pasa a
+    // bloqueo duro ("NO SE AUTORIZA"). Aceptar un rango corto es contraproducente para
+    // quien necesita N folios exactos (ej. simulación de certificación): el CAF chico
+    // no se usa, suma +1 a FOLIOS_DISP y empeora el tope en el próximo intento.
+    // Por eso, si el llamador declaró un mínimo, se aborta ANTES de emitir.
+    if (tieneMaxAutor && this._minCantidad && maxAutor < this._minCantidad) {
+      this._maxAutorInsuficiente = true;
+      console.warn(
+        `[CafSolicitor] Tipo ${tipoDte}: MAX_AUTOR=${maxAutor} < mínimo requerido ${this._minCantidad} ` +
+        `(FOLIOS_DISP=${foliosDisp}) — abortando sin emitir para no agravar el racionamiento.`
+      );
+      return response;
+    }
 
     const step3Fields = {
       ...inputs3,

package/FolioService.js

@@ -213,7 +213,10 @@ class FolioService {
     try {
       await this.solicitarCaf({ tipoDte, cantidad });
     } catch (error) {
-      // Continuar con fallback
+      // Continuar con fallback, pero dejar rastro: sin este log era imposible
+      // diagnosticar por qué aparecían CAFs de 1 folio (el fallback de más abajo)
+      // en vez del rango pedido.
+      console.warn(`[FolioService] solicitarCaf tipo ${tipoDte} x${cantidad} falló: ${error.message} — probando fallback`);
     }
     
     let resolvedPath = this.findLatestCaf(tipoDte);
@@ -247,6 +250,147 @@ class FolioService {
     return resolvedPath;
   }
 
+  /**
+   * Cuenta los folios de un CAF leyendo su rango <D>/<H>.
+   * @private
+   * @returns {number} Cantidad de folios, o 0 si no se pudo parsear
+   */
+  _contarFoliosCaf(cafPath) {
+    try {
+      const xml = fs.readFileSync(cafPath, 'utf8');
+      const d = xml.match(/<D>(\d+)<\/D>/);
+      const h = xml.match(/<H>(\d+)<\/H>/);
+      if (!d || !h) return 0;
+      return Number(h[1]) - Number(d[1]) + 1;
+    } catch (_) {
+      return 0;
+    }
+  }
+
+  /**
+   * Solicita un CAF garantizando una cantidad EXACTA de folios.
+   *
+   * A diferencia de `solicitarCafConFallback` — que acepta lo que el SII dé y
+   * cae a 1 folio como último recurso, algo razonable para reponer folios de
+   * emisión en runtime — este método sirve a flujos que necesitan N folios
+   * exactos en una sola pasada (ej. la simulación de certificación, que genera
+   * un plan fijo de documentos y muere si falta un folio).
+   *
+   * El SII raciona vía MAX_AUTOR según los folios timbrados sin utilizar
+   * (FOLIOS_DISP), y si se acumulan pasa a bloqueo duro. Anularlos revierte
+   * ambos estados — verificado contra maullin el 2026-07-22: anular 6 folios
+   * llevó FOLIOS_DISP 6→0 y MAX_AUTOR 1→5, y levantó los bloqueos duros de los
+   * tipos 56 y 61. Por eso acá se anula y se reintenta una vez.
+   *
+   * @param {Object} params
+   * @param {number} params.tipoDte - Tipo de DTE
+   * @param {number} params.cantidad - Folios requeridos (mínimo aceptable)
+   * @param {boolean} [params.permitirAnular=true] - Si puede anular folios sin
+   *   usar para destrabar el tope. Ponerlo en false lo deja en modo consulta.
+   * @returns {Promise<Object>} { ok, cafPath, otorgados, maxAutor, foliosDisp, errorCode, error }
+   */
+  async solicitarCafExacto({ tipoDte, cantidad, permitirAnular = true }) {
+    if (!this.cafSolicitor) {
+      throw new Error('FolioService: CafSolicitor no inicializado (se requiere pfxPath y pfxPassword)');
+    }
+
+    const pedir = () =>
+      this.cafSolicitor.solicitar({ tipoDte, cantidad, minCantidad: cantidad });
+
+    let result = await pedir();
+
+    // Ambos códigos tienen la misma causa raíz (folios sin utilizar acumulados)
+    // y el mismo remedio. MAX_AUTOR_INSUFICIENTE aborta antes de emitir;
+    // TIMBRAJE_BLOQUEADO es el estado terminal al que se llega si se ignora.
+    const recuperable =
+      result.errorCode === 'MAX_AUTOR_INSUFICIENTE' ||
+      result.errorCode === 'TIMBRAJE_BLOQUEADO';
+
+    if (!result.success && recuperable && permitirAnular) {
+      console.warn(
+        `[FolioService] Tipo ${tipoDte}: ${result.errorCode} — anulando folios sin utilizar y reintentando...`
+      );
+      try {
+        // Acotado: acá sí interesan los folios viejos (son los que inflan
+        // FOLIOS_DISP), pero sin barrer el historial entero — anular de a
+        // cientos satura al SII y suma al contador de "anulados últimos 6
+        // meses", que también juega en contra del cupo.
+        const anul = await this.anularFolios({ tipoDte, maxRangos: 20 });
+
+        // Desglosar los motivos reales del rechazo: no todos son "ya recepcionado"
+        // (folio consumido en un DTE enviado). También caen acá los folios ya
+        // anulados en una pasada anterior, que el SII sigue listando como
+        // candidatos pero rechaza al reintentar.
+        const motivos = (anul.rechazados || []).reduce((acc, r) => {
+          const k = r.reason || 'sin motivo';
+          acc[k] = (acc[k] || 0) + (r.count || 1);
+          return acc;
+        }, {});
+        const detalleMotivos = Object.entries(motivos)
+          .map(([k, v]) => `${v} ${k}`)
+          .join(', ');
+        console.log(
+          `[FolioService] Tipo ${tipoDte}: ${anul.totalAnulados} folio(s) anulado(s), ` +
+          `${anul.totalRechazados} rechazado(s)${detalleMotivos ? ` (${detalleMotivos})` : ''}`
+        );
+
+        if (anul.totalAnulados === 0) {
+          // Sin folios liberados, el tope del SII no se movió: reintentar es un
+          // request garantizado a fallar. Se corta acá con un diagnóstico preciso.
+          return {
+            ok: false,
+            cafPath: null,
+            otorgados: 0,
+            maxAutor: result.maxAutor ?? null,
+            foliosDisp: result.foliosDisp ?? null,
+            errorCode: 'SIN_FOLIOS_ANULABLES',
+            error:
+              `El SII tiene bloqueado el timbraje del tipo ${tipoDte} y no quedan folios anulables ` +
+              `(${anul.totalRechazados} rechazado(s)${detalleMotivos ? `: ${detalleMotivos}` : ''}). ` +
+              `Para destrabarlo hay que emitir y enviar al SII documentos de este tipo con los folios ya timbrados, ` +
+              `o esperar: el SII recalcula el tope según la emisión y las anulaciones de los últimos 6 meses.`,
+          };
+        }
+
+        result = await pedir();
+      } catch (err) {
+        console.warn(`[FolioService] Tipo ${tipoDte}: anulación falló: ${err.message}`);
+      }
+    }
+
+    const base = {
+      maxAutor: result.maxAutor ?? null,
+      foliosDisp: result.foliosDisp ?? null,
+    };
+
+    if (!result.success) {
+      return {
+        ok: false,
+        cafPath: null,
+        otorgados: 0,
+        ...base,
+        errorCode: result.errorCode || 'UNKNOWN',
+        error: result.error || `No se pudo obtener CAF para tipo ${tipoDte}`,
+      };
+    }
+
+    // Defensa final: aunque MAX_AUTOR haya dado el visto bueno, verificar que el
+    // rango realmente alcance antes de dárselo por bueno al llamador.
+    const otorgados = this._contarFoliosCaf(result.cafPath);
+    if (otorgados < Number(cantidad)) {
+      return {
+        ok: false,
+        cafPath: result.cafPath,
+        otorgados,
+        ...base,
+        errorCode: 'FOLIOS_INSUFICIENTES',
+        error: `SII otorgó ${otorgados} folio(s) de ${cantidad} requeridos para el tipo ${tipoDte}.`,
+      };
+    }
+
+    return { ok: true, cafPath: result.cafPath, otorgados, ...base };
+  }
+
   /**
    * Consulta el estado de folios en el SII
    * @param {Object} params - Parámetros
@@ -360,7 +504,53 @@ class FolioService {
    * @param {string} [params.motivo]
    * @returns {Promise<{ok:boolean, anulados:Array, rechazados:Array, totalAnulados:number, totalRechazados:number}>}
    */
-  async anularFolios({ tipoDte, folioDesde = null, folioHasta = null, motivo = 'Folios no utilizados', maxRangos = 50 }) {
+  /**
+   * @param {number} [params.soloUltimosDias] - Si se indica, solo se anulan los
+   *   rangos timbrados dentro de esos días. Sirve para limpiar los sobrantes de
+   *   una corrida reciente sin tocar el historial de la empresa: sin este filtro
+   *   la función barre TODOS los rangos sin utilizar, lo que en un RUT con
+   *   volumen real significa cientos de anulaciones contra el SII — y, peor, el
+   *   propio SII cuenta los folios anulados de los últimos 6 meses en contra del
+   *   cupo de timbraje. Verificado 2026-07-22: una limpieza sin acotar anuló 296
+   *   folios de un RUT antes de detenerla.
+   */
+  /**
+   * Ruta del registro de rangos ya anulados, por RUT y tipo de DTE.
+   *
+   * El SII sigue listando un folio anulado como "sin utilizar" —anulado es, en
+   * efecto, sin usar— así que `consultarFolios` lo devuelve para siempre y cada
+   * limpieza vuelve a intentarlo. Sin memoria entre corridas eso son
+   * round-trips al SII que solo pueden fallar, y peor: van comiendo el cupo de
+   * `maxRangos`, hasta dejar fuera a los sobrantes que sí hay que anular.
+   */
+  _anuladosPath(tipoDte) {
+    const rutLimpio = String(this.rutEmisor || '').replace(/[^0-9kK]/g, '');
+    return path.join(this.debugDir, `folios-anulados-${rutLimpio}-${tipoDte}.json`);
+  }
+
+  /** Set de claves "desde-hasta" que el SII ya reportó como anuladas. */
+  _cargarAnulados(tipoDte) {
+    try {
+      const raw = fs.readFileSync(this._anuladosPath(tipoDte), 'utf8');
+      const arr = JSON.parse(raw);
+      return new Set(Array.isArray(arr) ? arr : []);
+    } catch (_) {
+      // Sin registro previo (o ilegible): se parte de cero. Nunca es fatal —
+      // como mucho se repite el intento una vez más.
+      return new Set();
+    }
+  }
+
+  _guardarAnulados(tipoDte, set) {
+    try {
+      fs.mkdirSync(this.debugDir, { recursive: true });
+      fs.writeFileSync(this._anuladosPath(tipoDte), JSON.stringify([...set]), 'utf8');
+    } catch (err) {
+      console.warn(`[FolioService] No se pudo persistir registro de anulados: ${err.message}`);
+    }
+  }
+
+  async anularFolios({ tipoDte, folioDesde = null, folioHasta = null, motivo = 'Folios no utilizados', maxRangos = 50, soloUltimosDias = null }) {
     const debugStampA = new Date().toISOString().replace(/[:.]/g, '-');
     const debugDirA = path.join(this.debugDir, 'auto-caf', 'anulacion', debugStampA);
     fs.mkdirSync(debugDirA, { recursive: true });
@@ -369,18 +559,38 @@ class FolioService {
     const anulados   = [];
     const rechazados = [];
     const vistos     = new Set(); // claves "folioDesde-folioHasta" ya procesadas en esta ejecución
+    // Rangos que el SII ya reportó como anulados en corridas anteriores: se
+    // saltan de entrada para no gastar el cupo de `maxRangos` en reintentos
+    // que solo pueden volver a fallar. Ver `_anuladosPath`.
+    const yaAnulados = this._cargarAnulados(tipoDte);
+    const yaAnuladosInicial = yaAnulados.size;
 
     const maxPasadas = 4;
 
     for (let pasada = 0; pasada < maxPasadas; pasada++) {
       const consulta = await this.consultarFolios({ tipoDte });
 
+      // Corte por antigüedad: `fecha` viene como DD-MM-AAAA en cada rango.
+      // Un rango sin fecha parseable se descarta cuando el filtro está activo —
+      // ante la duda, no anular.
+      const limiteMs = Number.isFinite(soloUltimosDias)
+        ? Date.now() - soloUltimosDias * 24 * 60 * 60 * 1000
+        : null;
+
       // Filtrar rangos dentro del rango solicitado y que no hayamos intentado aún
       let rangos = consulta.ranges.filter(r => {
         if (Number.isFinite(folioDesde) && Number.isFinite(folioHasta)) {
           if (r.folioDesde > folioHasta || r.folioHasta < folioDesde) return false;
         }
-        return !vistos.has(`${r.folioDesde}-${r.folioHasta}`);
+        if (limiteMs !== null) {
+          const { dia, mes, ano } = this._parseFecha(r.fecha);
+          if (!dia || !mes || !ano) return false;
+          const t = new Date(`${ano}-${mes}-${dia}T00:00:00`).getTime();
+          if (!Number.isFinite(t) || t < limiteMs) return false;
+        }
+        const clave = `${r.folioDesde}-${r.folioHasta}`;
+        if (yaAnulados.has(clave)) return false;
+        return !vistos.has(clave);
       });
 
       // Limitar a los más recientes para evitar operaciones masivas
@@ -425,9 +635,17 @@ class FolioService {
           continue;
         }
 
+        // El SII responde "ha sido anulado anteriormente" (no "efectuado"), variante
+        // que las tres cadenas originales no cubrían: el rango caía al POST de
+        // af_anular con inputs vacíos y volvía una página de error con "Error 500",
+        // registrándose como fallo genérico en vez de "ya anulado". Verificado
+        // 2026-07-22 contra maullin, tipo 56 folios 2/4/5/6.
         if (body3.includes('ya ha sido efectuado') || body3.includes('ya fue anulado') ||
-            body3.includes('efectuado anteriormente')) {
+            body3.includes('efectuado anteriormente') ||
+            /anulad[oa]\s+anteriormente/i.test(body3)) {
           rechazados.push({ folioDesde: iniA, folioHasta: finA, count, reason: 'ya-anulado' });
+          // 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)`);
           try { fs.writeFileSync(path.join(debugDirA, `rango-${iniA}-${finA}-af_anular3-error.html`), body3, 'utf8'); } catch (_) {}
           continue;
@@ -457,6 +675,11 @@ class FolioService {
                           bodyBulk.includes('SOLICITUD ANULACION DE FOLIOS');
         if (exitoBulk) {
           anulados.push({ folioDesde: iniA, folioHasta: finA, count });
+          // 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
+          // principal de los rangos zombis.
+          yaAnulados.add(`${iniA}-${finA}`);
           try { fs.writeFileSync(path.join(debugDirA, `rango-${iniA}-${finA}-af_anular-ok.html`), bodyBulk, 'utf8'); } catch (_) {}
           console.log(`[FolioService] ✓ Rango ${iniA}-${finA} (${count} folios) anulado en bulk`);
           continue;
@@ -497,6 +720,7 @@ class FolioService {
           const ok = bs.includes('ha autorizado la anulaci') || bs.includes('SOLICITUD ANULACION DE FOLIOS');
           if (ok) {
             anulados.push({ folioDesde: folio, folioHasta: folio, count: 1 });
+            yaAnulados.add(`${folio}-${folio}`);
           } else {
             const razon = this._parseAnulacionResult(bs).reason || 'error';
             rechazados.push({ folioDesde: folio, folioHasta: folio, count: 1, reason: razon });
@@ -509,9 +733,16 @@ class FolioService {
       if (pasada < maxPasadas - 1) await this._sleep(1500);
     }
 
+    if (yaAnulados.size !== yaAnuladosInicial) {
+      this._guardarAnulados(tipoDte, yaAnulados);
+    }
+
     const totalAnulados   = anulados.reduce((s, r) => s + r.count, 0);
     const totalRechazados = rechazados.reduce((s, r) => s + r.count, 0);
-    console.log(`[FolioService] Completado: ${totalAnulados} anulados, ${totalRechazados} rechazados`);
+    console.log(
+      `[FolioService] Completado: ${totalAnulados} anulados, ${totalRechazados} rechazados` +
+      (yaAnulados.size ? ` (${yaAnulados.size} rango(s) en memoria, se omiten en la próxima corrida)` : '')
+    );
 
     return { ok: true, anulados, rechazados, totalAnulados, totalRechazados };
   }

package/SiiCertificacion.js

@@ -1553,7 +1553,20 @@ class SiiCertificacion {
 
       if (algunoRechazado) {
         emitProgress(STEPS.SETS_REJECTED);
-        return { success: false, error: 'Sets rechazados', estados: estadosRelevantes };
+        // El detalle va en el error, no solo en `estados`: el llamador suele
+        // interpolar `error` en el mensaje que ve el usuario, y un literal
+        // "Sets rechazados" rendía el inútil "Sets rechazados: Sets rechazados"
+        // sin decir cuál set ni con qué estado. Se nombran solo los rechazados
+        // para no ahogar el dato entre los que sí pasaron.
+        const detalle = Object.values(estadosRelevantes)
+          .filter(e => e.esRechazado)
+          .map(e => `${e.nombre}: ${e.estado}`)
+          .join('; ');
+        return {
+          success: false,
+          error: detalle || 'el SII rechazó uno o más sets',
+          estados: estadosRelevantes,
+        };
       }
     }
 

package/SiiSession.js

@@ -620,8 +620,23 @@ SiiSession.extractInputValues = function(html) {
   const regex = /<input[^>]+>/gi;
   const matches = html.match(regex) || [];
   matches.forEach((tag) => {
-    const nameMatch = tag.match(/name\s*=\s*"([^"]+)"/i);
-    const valueMatch = tag.match(/value\s*=\s*"([^"]*)"/i);
+    // El SII mezcla estilos en el mismo formulario: unos atributos van con
+    // comillas y otros sin ellas (`value = 1`). Con solo el patrón entrecomillado,
+    // esos campos se enviaban vacíos y el SII rebotaba a la misma página sin
+    // explicar por qué — observado 2026-07-22 en pe_datos_empresa, donde
+    // EXISTE_PROD/EXISTE_CERT vienen sin comillas y trababan la postulación.
+    // El fallback sin comillas exige un separador antes del atributo: sin eso
+    // captura el `value=` que aparece DENTRO de handlers JS
+    // (`onblur="this.value=this.value.toUpperCase()"`), devolviendo basura
+    // como valor del campo.
+    const nameMatch =
+      tag.match(/name\s*=\s*"([^"]+)"/i) ||
+      tag.match(/name\s*=\s*'([^']+)'/i) ||
+      tag.match(/(?:^|[\s<])name\s*=\s*([^\s>"']+)/i);
+    const valueMatch =
+      tag.match(/value\s*=\s*"([^"]*)"/i) ||
+      tag.match(/value\s*=\s*'([^']*)'/i) ||
+      tag.match(/(?:^|[\s<])value\s*=\s*([^\s>"']+)/i);
     if (nameMatch) {
       inputs[nameMatch[1]] = valueMatch ? valueMatch[1] : '';
     }

package/cert/CertRunner.js

@@ -247,23 +247,76 @@ class CertRunner {
     this.folioHelper.counters.clear();
     this.folioHelper.usedFolios.clear();
     
+    // Limpieza previa de folios timbrados y nunca utilizados.
+    //
+    // Cada corrida de simulación regenera su plan de documentos completo, así que
+    // los folios que quedaron de un intento fallido NO se reutilizan jamás: son
+    // basura garantizada. Pero el SII los cuenta como "disponibles sin utilizar"
+    // (FOLIOS_DISP) y baja el tope de timbraje (MAX_AUTOR) hasta bloquearlo del
+    // todo. Observado 2026-07-22 en un RUT de certificación: 7 intentos fallidos
+    // dejaron 21 folios muertos en los tipos 34 y 52, y llevaron a los tipos 56 y
+    // 61 a bloqueo duro irreversible (sin folios anulables restantes).
+    //
+    // Limpiar ANTES de pedir rompe ese espiral. Es seguro: solo se anulan folios
+    // que el SII reporta como no recepcionados, y los que ya fueron anulados o
+    // usados se rechazan sin efecto.
+    for (const tipoDte of Object.keys(cafRequired)) {
+      try {
+        // ACOTADA a propósito. Solo interesan los folios que ESTA certificación
+        // timbró y dejó sin usar, que son de hoy. Sin el corte por antigüedad la
+        // limpieza barre el historial completo de la empresa: en un RUT con
+        // volumen real eso son cientos de anulaciones contra el SII y, peor, el
+        // SII cuenta los folios anulados de los últimos 6 meses EN CONTRA del
+        // cupo de timbraje — la limpieza terminaría provocando el bloqueo que
+        // intenta evitar. Verificado 2026-07-22: sin acotar anuló 296 folios de
+        // un RUT (rango 1851–2909) antes de detenerla a mano.
+        const limpieza = await this.folioService.anularFolios({
+          tipoDte: Number(tipoDte),
+          soloUltimosDias: 1,
+          maxRangos: 10,
+        });
+        if (limpieza.totalAnulados > 0) {
+          console.log(
+            ` Tipo ${tipoDte}: ${limpieza.totalAnulados} folio(s) sin usar de intentos previos anulados`
+          );
+        }
+      } catch (err) {
+        // No es fatal: si la limpieza falla, la solicitud de abajo igual puede
+        // funcionar, y si no, solicitarCafExacto reintenta anulando.
+        console.warn(`[CertRunner] Limpieza previa tipo ${tipoDte} falló: ${err.message}`);
+      }
+    }
+
     for (const [tipoDte, cantidad] of Object.entries(cafRequired)) {
       emitProgress(STEPS.CAF_REQUESTING, { tipo: Number(tipoDte) });
       console.log(` Tipo ${tipoDte}: ${cantidad} folios...`);
-      
-      // Usar solicitarCafConFallback que solicita y retorna el path
-      const cafPath = await this.folioService.solicitarCafConFallback({
+
+      // solicitarCafExacto (no ConFallback): la simulación genera un plan fijo de
+      // documentos y muere si falta un folio, así que un CAF corto no sirve. El
+      // método aborta antes de emitir si el SII no autoriza lo suficiente, anula
+      // folios sin utilizar para destrabar el tope, y reintenta.
+      const res = await this.folioService.solicitarCafExacto({
         tipoDte: Number(tipoDte),
         cantidad: Number(cantidad),
       });
-      
-      if (!cafPath) {
-        throw new Error(`No se pudo obtener CAF para tipo ${tipoDte}`);
+
+      if (!res.ok) {
+        const detalle = [
+          res.maxAutor != null ? `MAX_AUTOR=${res.maxAutor}` : null,
+          res.foliosDisp != null ? `FOLIOS_DISP=${res.foliosDisp}` : null,
+        ].filter(Boolean).join(', ');
+        throw new Error(
+          `Folios insuficientes para tipo ${tipoDte}: se requieren ${cantidad} y el SII ` +
+          `otorgó ${res.otorgados}${detalle ? ` (${detalle})` : ''}. ` +
+          `El SII limita el timbraje cuando hay folios ya autorizados sin utilizar; ` +
+          `emite o anula documentos electrónicos de este tipo y reintenta. ` +
+          `[${res.errorCode}] ${res.error || ''}`.trim()
+        );
       }
-      
-      cafs[tipoDte] = cafPath;
+
+      cafs[tipoDte] = res.cafPath;
       emitProgress(STEPS.CAF_OK, { tipo: Number(tipoDte) });
-      console.log(` ✓ CAF tipo ${tipoDte}`);
+      console.log(` ✓ CAF tipo ${tipoDte} (${res.otorgados} folios)`);
     }
     
     return cafs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devlas/dte-sii",
-  "version": "2.12.22",
+  "version": "2.12.24",
   "description": "Facturación y boletas electrónicas para el SII de Chile. Genera, timbra, firma y envía DTEs, libros electrónicos y automatiza la certificación.",
   "main": "index.js",
   "types": "dte-sii.d.ts",