@devlas/dte-sii 2.9.8 → 2.12.0

package/LibroGuia.js

@@ -40,8 +40,10 @@ class LibroGuia extends LibroBase {
       throw new Error('Debe establecer la carátula antes de generar');
     }
 
+    const tipoEnvio = String(this.caratula?.TipoEnvio || '').toUpperCase();
     const caratulaXml = this._renderCaratula();
     const resumenXml = this._renderResumen();
+    // AJUSTE con documentos: Detalle + ResumenSegmento + ResumenPeriodo
     const detalleXml = this._renderDetalle();
 
     const schemaLoc = 'http://www.sii.cl/SiiDte LibroGuia_v10.xsd';
@@ -87,7 +89,9 @@ class LibroGuia extends LibroBase {
   _renderResumen() {
     const resumen = this._buildResumenPeriodo();
     if (!resumen) return '';
-    
+
+    const tipoEnvio = String(this.caratula?.TipoEnvio || '').toUpperCase();
+
     const order = [
       'TotFolAnulado',
       'TotGuiaAnulada',
@@ -95,30 +99,37 @@ class LibroGuia extends LibroBase {
       'TotMntGuiaVta',
       'TotTraslado',
     ];
-    
-    let xml = '<ResumenPeriodo>';
-    order.forEach((key) => {
-      const value = resumen[key];
-      if (value === undefined || value === null || value === '' || value === false) return;
-      
-      if (Array.isArray(value)) {
-        value.forEach((item) => {
-          if (item && typeof item === 'object') {
-            xml += `<${key}>`;
-            Object.keys(item).forEach((itemKey) => {
-              if (item[itemKey] !== undefined && item[itemKey] !== null && item[itemKey] !== '') {
-                xml += `<${itemKey}>${this._escapeXmlText(String(item[itemKey]))}</${itemKey}>`;
-              }
-            });
-            xml += `</${key}>`;
-          }
-        });
-      } else {
-        xml += `<${key}>${this._escapeXmlText(String(value))}</${key}>`;
-      }
-    });
-    xml += '</ResumenPeriodo>';
-    return xml;
+
+    const _renderSection = (tag) => {
+      let xml = `<${tag}>`;
+      order.forEach((key) => {
+        const value = resumen[key];
+        if (value === undefined || value === null || value === '' || value === false) return;
+        if (Array.isArray(value)) {
+          value.forEach((item) => {
+            if (item && typeof item === 'object') {
+              xml += `<${key}>`;
+              Object.keys(item).forEach((itemKey) => {
+                if (item[itemKey] !== undefined && item[itemKey] !== null && item[itemKey] !== '') {
+                  xml += `<${itemKey}>${this._escapeXmlText(String(item[itemKey]))}</${itemKey}>`;
+                }
+              });
+              xml += `</${key}>`;
+            }
+          });
+        } else {
+          xml += `<${key}>${this._escapeXmlText(String(value))}</${key}>`;
+        }
+      });
+      xml += `</${tag}>`;
+      return xml;
+    };
+
+    // AJUSTE con documentos: ResumenSegmento (delta) + ResumenPeriodo (acumulado)
+    if (tipoEnvio === 'AJUSTE' && this.detalle.length > 0) {
+      return _renderSection('ResumenSegmento') + _renderSection('ResumenPeriodo');
+    }
+    return _renderSection('ResumenPeriodo');
   }
 
   _renderDetalle() {

package/SiiCertificacion.js

@@ -458,6 +458,53 @@ class SiiCertificacion {
     }
   }
 
+  /**
+   * Consulta los libros IECV ya enviados al SII para un año dado.
+   * Usa el portal QEstLibro (DTEauth?7) para determinar si cada período tiene
+   * un envío MENSUAL (TOTAL/LTC) o RECTIFICA (AJUSTE) por tipo de operación.
+   *
+   * @param {number|string} year - Año (ej: 2026)
+   * @returns {Promise<Object>} Mapa con estructura:
+   *   { '2026-04': { COMPRA: { periodicidad: 'MENSUAL', estado: 'Recibido', codigo: 'COMPRA-...' }, VENTA: {...} } }
+   */
+  async consultarLibrosExistentes(year) {
+    const year4 = String(year || new Date().getFullYear());
+
+    await this.session.ensureSession('/cgi_dte/UPL/DTEauth?7');
+
+    const url = `https://maullin.sii.cl/cgi_dte/UPL/QEstLibro` +
+      `?rutCompany=${this.rutEmpresa}&dvCompany=${this.dvEmpresa}` +
+      `&TrackId=&year=${year4}&month=00&tipo=TODOS`;
+
+    const resp = await this.session.request(url);
+    const html = resp.body || '';
+
+    if (html.includes('NO ESTA AUTORIZADO') || html.includes('SESION HA EXPIRADO')) {
+      throw new Error('QEstLibro: sesión no autorizada o expirada');
+    }
+
+    // Cada fila tiene 6 <td>: periodo, operacion, estado, tipoLibro, periodicidad, cantidad+link
+    // Capturamos los 5 primeros <td> de texto plano + el Codigo de la URL del link
+    const result = {};
+    const rowRegex =
+      /<tr><td[^>]*>([^<]+)<\/td><td[^>]*>([^<]+)<\/td><td[^>]*>([^<]+)<\/td><td[^>]*>([^<]+)<\/td><td[^>]*>([^<]+)<\/td><td[^>]*>[^<]*<a href=QDetEstLibro\?Codigo=([^&"'\s>]+)/gi;
+
+    let m;
+    while ((m = rowRegex.exec(html)) !== null) {
+      const periodo      = m[1].trim();
+      const tipo         = m[2].trim().toUpperCase();        // COMPRA | VENTA
+      const estado       = m[3].trim();                      // Recibido | ...
+      const periodicidad = m[5].trim().toUpperCase();        // MENSUAL | RECTIFICA
+      const codigo       = m[6].trim();
+
+      if (!/^\d{4}-\d{2}$/.test(periodo)) continue;
+      if (!result[periodo]) result[periodo] = {};
+      result[periodo][tipo] = { periodicidad, estado, codigo };
+    }
+
+    return result;
+  }
+
   /**
    * Declara avance en una etapa de certificación con TrackIds específicos
    * @param {Object} options - Opciones
@@ -859,15 +906,50 @@ class SiiCertificacion {
         console.log(` [!] No se pudo verificar la declaración: ${verifyErr.message}`);
       }
 
-      // allRejected: SII rechazó todos los sets declarados — período incorrecto, no tiene sentido reintentar
+      // conErrores: el SII procesó el envío pero encontró errores en el contenido del XML.
+      // Detectar en el body de la respuesta de pe_avance3 (no en la re-verificación de pe_avance2).
+      const _erroresBody = body || '';
+      const _nombresConError = [];
+      const _patronesNombre = [
+        'LIBRO DE VENTAS', 'LIBRO DE COMPRAS PARA EXENTOS', 'LIBRO DE COMPRAS',
+        'LIBRO DE GUIAS', 'SET BASICO', 'SET GUIA DE DESPACHO', 'SET FACTURA EXENTA',
+        'SET CASO GENERAL FACTURA COMPRA', 'SET DE SIMULACION',
+      ];
+      for (const _nom of _patronesNombre) {
+        // Buscar fila que contenga el nombre Y "ENVIO CON ERRORES O REPAROS".
+        // Se usa un lookahead negativo para que "LIBRO DE COMPRAS" no haga match dentro de
+        // "LIBRO DE COMPRAS PARA EXENTOS", evitando falsos positivos.
+        const _nomEscapado = _nom.replace(/ /g, '\\s+');
+        // Si el nombre es un prefijo de otro nombre más largo, agregar un límite tras él.
+        const _otrosNombres = _patronesNombre.filter(n => n !== _nom && n.startsWith(_nom));
+        let _patronNom = _nomEscapado;
+        if (_otrosNombres.length > 0) {
+          // Lookahead negativo: no debe seguir el texto diferenciador de los nombres más largos
+          const _sufijos = _otrosNombres.map(n => n.slice(_nom.length).replace(/ /g, '\\s+').trim());
+          _patronNom += `(?!\\s+(?:${_sufijos.join('|')}))`;
+        }
+        const _re = new RegExp(_patronNom + '[\\s\\S]{0,200}?ENVIO CON ERRORES O REPAROS', 'i');
+        if (_re.test(_erroresBody)) _nombresConError.push(_nom);
+      }
+      const conErrores = _nombresConError.length > 0;
+      if (conErrores) {
+        console.log(` [ERR] SII rechazó por ERRORES DE CONTENIDO: ${_nombresConError.join(', ')}`);
+      }
+
+      // allRejected: SII rechazó todos los sets declarados — período incorrecto, no tiene sentido reintentar.
+      // Solo aplica cuando NO hay errores de contenido explícitos (esos deben manejarse por separado).
       const _declaredCount = Object.keys(fieldMapping).filter(k => sets[k]).length;
-      const allRejected = !enRevision && camposVacios.length > 0 && camposVacios.length >= _declaredCount && _declaredCount > 0;
+      const allRejected = !enRevision && !conErrores && camposVacios.length > 0 && camposVacios.length >= _declaredCount && _declaredCount > 0;
 
       return {
         success: verificado || enRevision,
-        error: verificacionError || errorMsg || undefined,
+        error: conErrores
+          ? `ENVIO CON ERRORES O REPAROS: ${_nombresConError.join(', ')}`
+          : (verificacionError || errorMsg || undefined),
         verificado,
         enRevision,
+        conErrores,
+        nombresConError: _nombresConError,
         allRejected,
         status: declareResponse.status,
         rawHtml: body,

package/SiiPortalAuth.js

@@ -83,7 +83,7 @@ class SiiPortalAuth {
     if (!pfxBuffer) throw new Error('SiiPortalAuth: pfxBuffer es obligatorio');
     if (pfxPassword === undefined) throw new Error('SiiPortalAuth: pfxPassword es obligatorio');
 
-    const { certPem, keyPem } = SiiPortalAuth._extractPems(pfxBuffer, pfxPassword);
+    const { certPem, keyPem, chainPem } = SiiPortalAuth._extractPems(pfxBuffer, pfxPassword);
     this._certPem = certPem;
     this._keyPem  = keyPem;
     // Huella para identificar de qué cert es la sesión cacheada
@@ -96,7 +96,11 @@ class SiiPortalAuth {
     }
 
     this._agentePlano = new https.Agent(SII_TLS_OPTS);
-    this._agenteCert  = new https.Agent({ ...SII_TLS_OPTS, cert: certPem, key: keyPem });
+    // chainPem incluye hoja + intermedios + raíz extraídos por forge.
+    // Necesario para PFX con cadena completa (ej. IDOK) — SII necesita los
+    // intermedios para verificar la firma. tls.createSecureContext({ pfx }) no se
+    // usa porque OpenSSL 3 (Node 24) rechaza ciertos formatos PKCS12 modernos.
+    this._agenteCert  = new https.Agent({ ...SII_TLS_OPTS, cert: chainPem, key: keyPem });
 
     _instanceRegistry.set(this._certHash, this);
   }
@@ -106,24 +110,86 @@ class SiiPortalAuth {
    * (node-forge soporta PKCS12 moderno AES-256 que Node nativo rechaza)
    * @private
    */
+  /**
+   * Extrae clave privada y cadena de certificados de un PFX/PKCS12.
+   * Soporta: RSA y EC, 1 a N certificados, cadenas desordenadas,
+   * pkcs8ShroudedKeyBag y keyBag, algoritmos legacy (RC2, 3DES) y modernos.
+   * Usa forge (no tls.createSecureContext) para ser compatible con formatos
+   * PKCS12 que OpenSSL 3 rechaza (ej. IDOK con SHA-1 MAC o AES-256 encryption).
+   *
+   * @returns {{ certPem: string, keyPem: string, chainPem: string }}
+   *   certPem  - solo el certificado hoja (para _certHash)
+   *   keyPem   - clave privada PEM
+   *   chainPem - cadena completa ordenada: hoja → intermedios → raíz
+   */
   static _extractPems(pfxBuffer, password) {
-    const p12Asn1 = forge.asn1.fromDer(pfxBuffer.toString('binary'));
-    const p12 = forge.pkcs12.pkcs12FromAsn1(p12Asn1, password);
-
-    // Clave privada
-    const keyBags = p12.getBags({ bagType: forge.pki.oids.pkcs8ShroudedKeyBag });
-    const keyBag  = keyBags[forge.pki.oids.pkcs8ShroudedKeyBag]?.[0]
-      || p12.getBags({ bagType: forge.pki.oids.keyBag })[forge.pki.oids.keyBag]?.[0];
-    if (!keyBag?.key) throw new Error('SiiPortalAuth: no se encontró clave privada en el PFX');
-    const keyPem = forge.pki.privateKeyToPem(keyBag.key);
-
-    // Certificado
-    const certBags = p12.getBags({ bagType: forge.pki.oids.certBag });
-    const certBag  = certBags[forge.pki.oids.certBag]?.[0];
-    if (!certBag?.cert) throw new Error('SiiPortalAuth: no se encontró certificado en el PFX');
-    const certPem = forge.pki.certificateToPem(certBag.cert);
-
-    return { certPem, keyPem };
+    // ── 1. Parsear PKCS12 ────────────────────────────────────────────────────
+    let p12;
+    try {
+      p12 = forge.pkcs12.pkcs12FromAsn1(forge.asn1.fromDer(pfxBuffer.toString('binary')), password);
+    } catch (e) {
+      throw new Error(`SiiPortalAuth: no se pudo parsear el PFX — ${e.message}`);
+    }
+
+    // ── 2. Clave privada: probar todos los tipos de key bag ──────────────────
+    let keyObj = null;
+    for (const oid of [forge.pki.oids.pkcs8ShroudedKeyBag, forge.pki.oids.keyBag]) {
+      const bags = p12.getBags({ bagType: oid })[oid] || [];
+      const found = bags.find(b => b.key);
+      if (found) { keyObj = found.key; break; }
+    }
+    if (!keyObj) throw new Error('SiiPortalAuth: no se encontró clave privada en el PFX');
+    const keyPem = forge.pki.privateKeyToPem(keyObj);
+
+    // ── 3. Certificados: recopilar todos ─────────────────────────────────────
+    const certBags = p12.getBags({ bagType: forge.pki.oids.certBag })[forge.pki.oids.certBag] || [];
+    const allCerts = certBags.map(b => b.cert).filter(Boolean);
+    if (!allCerts.length) throw new Error('SiiPortalAuth: no se encontró certificado en el PFX');
+
+    // ── 4. Identificar el certificado hoja ───────────────────────────────────
+    // Estrategia 1: el cert cuya clave pública coincide con la clave privada
+    let leafCert = null;
+    try {
+      // Funciona para RSA y EC mientras forge pueda derivar la clave pública
+      const pubFromKey = forge.pki.setRsaPublicKey
+        ? forge.pki.setRsaPublicKey(keyObj.n, keyObj.e)   // RSA
+        : null;
+      if (pubFromKey) {
+        const pubPem = forge.pki.publicKeyToPem(pubFromKey);
+        leafCert = allCerts.find(c => forge.pki.publicKeyToPem(c.publicKey) === pubPem) ?? null;
+      }
+    } catch (_) { /* EC u otro — caer a estrategia 2 */ }
+
+    // Estrategia 2: el primer cert que NO sea CA (basicConstraints.cA = false/absent)
+    if (!leafCert) {
+      leafCert = allCerts.find(c => {
+        const bc = c.getExtension('basicConstraints');
+        return !bc || bc.cA !== true;
+      }) ?? allCerts[0];
+    }
+
+    // ── 5. Ordenar cadena: hoja → intermedios → raíz ─────────────────────────
+    // Construir la cadena siguiendo relaciones issuer→subject
+    const remaining = allCerts.filter(c => c !== leafCert);
+    const chain = [leafCert];
+    let current = leafCert;
+
+    while (remaining.length > 0) {
+      // El siguiente eslabón es el cert cuyo subject coincide con el issuer del actual
+      const issuerHash = current.issuer.hash;
+      const idx = remaining.findIndex(c => c.subject.hash === issuerHash);
+      if (idx < 0) break;                              // fin de cadena conocida
+      current = remaining.splice(idx, 1)[0];
+      if (chain.includes(current)) break;             // ciclo (self-signed raíz)
+      chain.push(current);
+    }
+    // Appender cualquier cert restante que no pudimos encadenar
+    chain.push(...remaining);
+
+    const certPem  = forge.pki.certificateToPem(leafCert);
+    const chainPem = chain.map(c => forge.pki.certificateToPem(c)).join('');
+
+    return { certPem, keyPem, chainPem };
   }
 
   // ─── HTTP helpers ────────────────────────────────────────────────────────────

package/SiiSession.js

@@ -157,10 +157,57 @@ class SiiSession {
    * @returns {Promise<Object>}
    */
   async request(url, options = {}) {
+    const isPost = (options.method || 'GET').toUpperCase() === 'POST';
+    const RETRY_DELAYS = [2000, 4000, 8000];
+    const RETRYABLE_CODES = new Set(['ETIMEDOUT', 'ECONNRESET', 'ECONNREFUSED', 'ENOTFOUND', 'TimeoutError']);
+    const RETRYABLE_STATUS = new Set([502, 503, 504]);
+
+    let lastErr;
+    for (let attempt = 0; attempt <= RETRY_DELAYS.length; attempt++) {
+      if (attempt > 0) {
+        const delay = RETRY_DELAYS[attempt - 1];
+        log.warn(`[SiiSession] request timeout/5xx — reintentando en ${delay / 1000}s (intento ${attempt}/${RETRY_DELAYS.length})...`);
+        await new Promise(r => setTimeout(r, delay));
+      }
+      try {
+        const result = await this._doRequest(url, options, isPost);
+        if (RETRYABLE_STATUS.has(result.status)) {
+          lastErr = new Error(`HTTP ${result.status}`);
+          continue;
+        }
+        return result;
+      } catch (err) {
+        const code = err.code || err.constructor?.name || '';
+        if (RETRYABLE_CODES.has(code)) { lastErr = err; continue; }
+        throw err; // error no retriable — propagar inmediatamente
+      }
+    }
+    throw lastErr;
+  }
+
+  /**
+   * Realiza la petición HTTP sin retry. Llamado desde request().
+   * @private
+   */
+  async _doRequest(url, options, isPost) {
     const res = await got(url, {
       method: options.method || 'GET',
       headers: {
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+        'Accept-Language': 'es-419,es-US;q=0.9,es;q=0.8,en;q=0.7',
+        'sec-ch-ua': '"Chromium";v="122", "Not(A:Brand";v="24", "Google Chrome";v="122"',
+        'sec-ch-ua-mobile': '?0',
+        'sec-ch-ua-platform': '"Windows"',
+        'Sec-Fetch-Dest': 'document',
+        'Sec-Fetch-Mode': 'navigate',
+        'Sec-Fetch-Site': 'same-origin',
+        'Sec-Fetch-User': '?1',
+        'Upgrade-Insecure-Requests': '1',
+        ...(isPost ? {
+          'Cache-Control': 'max-age=0',
+          'Origin': `https://${this.baseHost}`,
+        } : {}),
         ...(this.cookieJar ? { Cookie: this.cookieJar } : {}),
         ...(options.headers || {}),
       },
@@ -168,29 +215,21 @@ class SiiSession {
       followRedirect: false,
       throwHttpErrors: false,
       https: this.tlsOptions || { rejectUnauthorized: false },
-      responseType: 'buffer', // Obtener como buffer para manejar encoding
+      responseType: 'buffer',
+      timeout: { request: options.timeoutMs ?? 20000 },
     });
 
     this.cookieJar = this._mergeCookies(this.cookieJar, res.headers['set-cookie']);
-    
-    // Detectar encoding del Content-Type y convertir correctamente
-    let bodyStr;
+
     const contentType = res.headers['content-type'] || '';
     const buffer = res.body;
-    
-    // El SII de Chile usa ISO-8859-1 para TODO su contenido (HTML, XML, text/plain, octet-stream, etc.)
-    // Forzar ISO-8859-1 para cualquier respuesta de sii.cl que no especifique UTF-8
     const isSiiUrl = url.includes('sii.cl');
     const hasUtf8 = contentType.toLowerCase().includes('utf-8');
-    const forceIso = contentType.toLowerCase().includes('iso-8859-1') || 
+    const forceIso = contentType.toLowerCase().includes('iso-8859-1') ||
                      contentType.toLowerCase().includes('latin1');
-    
-    // Aplicar ISO-8859-1 si:
-    // 1. El Content-Type especifica ISO-8859-1/latin1, O
-    // 2. Es una URL del SII y NO especifica UTF-8 (incluyendo octet-stream, text/*, xml, etc.)
+
+    let bodyStr;
     if (forceIso || (isSiiUrl && !hasUtf8)) {
-      // SII usa ISO-8859-1, convertir cada byte a su codepoint Unicode correspondiente
-      // ISO-8859-1 es un subconjunto directo de Unicode (codepoints 0-255)
       bodyStr = '';
       for (let i = 0; i < buffer.length; i++) {
         bodyStr += String.fromCharCode(buffer[i]);
@@ -198,12 +237,12 @@ class SiiSession {
     } else {
       bodyStr = buffer.toString('utf8');
     }
-    
+
     return {
       status: res.statusCode,
       headers: res.headers,
       body: bodyStr,
-      rawBody: res.body, // Buffer original por si se necesita
+      rawBody: res.body,
       url: res.url,
       cookieJar: this.cookieJar,
     };

package/cert/BoletaCert.js

@@ -162,6 +162,7 @@ class BoletaCert {
         tipo: 39,
         folio: folioActual,
         fechaEmision: fechaHoy,
+        precioConIva: true, // Set de pruebas SII define precios "con IVA" (precio al consumidor)
         emisor: {
           RUTEmisor: this.emisor.rut,
           RznSocEmisor: this.emisor.razon_social,
@@ -453,8 +454,34 @@ class BoletaCert {
       }
     } else {
       console.log(` [OK] Enviado - TrackId: ${resultadoBoleta.trackId}`);
+
+      // Verificar estado SOAP antes de continuar. Error 6 "Rut No Autorizado a Firmar"
+      // es fatal — reintentar con otro sec no sirve de nada.
+      process.stderr.write(`[PROGRESS]${JSON.stringify({ step: 'BOLETA_SOAP_CHECK' })}\n`);
+      console.log(` ⏳ Esperando 20s para verificar estado SOAP del EnvioBOLETA...`);
+      await new Promise(r => setTimeout(r, 20000));
+      try {
+        const _estadoBoleta = await enviador.consultarEstadoSoap(resultadoBoleta.trackId, this.emisor.rut);
+        console.log(` [Estado SOAP EnvioBOLETA] ${_estadoBoleta.estado} — ${_estadoBoleta.mensaje}`);
+        if (_estadoBoleta.esRechazado) {
+          const _glosa = _estadoBoleta.glosa || _estadoBoleta.estado || '?';
+          const _esAuth = /autorizado|autorizar|firmar|permiso/i.test(_glosa);
+          console.log(` [ERR] EnvioBOLETA rechazado por SII${_esAuth ? ' (error de autorización)' : ''}: ${_glosa}`);
+          return {
+            success: false,
+            error: `EnvioBOLETA rechazado por SII: ${_glosa} (${_estadoBoleta.estado})`,
+            fase: 'EnvioBOLETA-SOAP',
+            noAutorizado: _esAuth,
+            estadoSoap: _estadoBoleta.estado,
+          };
+        }
+        // Estado intermedio (REC, SOK, FOK…) → SII aún procesa, continuar con RCOF
+      } catch (_e) {
+        console.log(` [!] No se pudo verificar estado SOAP EnvioBOLETA: ${_e.message} — continuando`);
+      }
     }
-    
+
+    process.stderr.write(`[PROGRESS]${JSON.stringify({ step: 'BOLETA_RCOF' })}\n`);
     // 5 & 6. Generar y enviar RCOF — loop hasta que SII lo acepte o se agoten intentos.
     // Estrategia: enviar → si ok, esperar 30s → consultar estado (EPR o RPR = éxito).
     // Si DUPLICADO: el SII ya tiene un RCOF para este RUT/período. El entorno de certificación
@@ -528,8 +555,17 @@ class BoletaCert {
         break;
       }
 
-      // SII lo rechazó explícitamente — probar con el siguiente sec
-      console.log(` [⚠️ RECHAZADO] RCOF sec=${secActual} rechazado (${estadoRcof.estado}: ${estadoRcof.glosa || estadoRcof.mensaje}). Probando sec=${secActual + 1}...`);
+      // SII lo rechazó explícitamente.
+      // Si es un error de autorización (error 6 "Rut No Autorizado a Firmar"),
+      // cambiar sec no sirve — abortar inmediatamente.
+      const _glosaRcof = estadoRcof.glosa || estadoRcof.mensaje || '';
+      const _esAuthRcof = /autorizado|autorizar|firmar|permiso/i.test(_glosaRcof);
+      if (_esAuthRcof) {
+        console.log(` [ERR-AUTH] RCOF rechazado por error de autorización (${estadoRcof.estado}): ${_glosaRcof} — abortando (reintentar no ayuda)`);
+        resultadoRCOF = { ok: false, error: `Empresa no autorizada para firmar RCOF: ${_glosaRcof}`, noAutorizado: true };
+        break;
+      }
+      console.log(` [⚠️ RECHAZADO] RCOF sec=${secActual} rechazado (${estadoRcof.estado}: ${_glosaRcof}). Probando sec=${secActual + 1}...`);
       trackIdRCOFloop = null;
     }
 
@@ -542,7 +578,8 @@ class BoletaCert {
           success: false,
           error: resultadoRCOF.error,
           fase: 'RCOF',
-          trackIdBoleta: resultadoBoleta.trackId
+          noAutorizado: resultadoRCOF.noAutorizado || false,
+          trackIdBoleta: resultadoBoleta.trackId,
         };
       }
     }