@devlas/dte-sii 2.12.22 → 2.12.23

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,143 @@ 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 {
+        const anul = await this.anularFolios({ tipoDte });
+
+        // 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
@@ -425,8 +565,14 @@ 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' });
           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 (_) {}

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,64 @@ 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 {
+        const limpieza = await this.folioService.anularFolios({ tipoDte: Number(tipoDte) });
+        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.23",
   "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",