@devlas/dte-sii 2.12.12 → 2.12.14

package/EnviadorSII.js

@@ -799,6 +799,18 @@ class EnviadorSII {
       timeoutMs: 30000,
     });
 
+    // El SII (maullín especialmente) a veces responde 5xx/503 en vez del XML de estado.
+    // Distinguirlo explícitamente para no reportarlo como "estado no encontrado" genérico
+    // — es una caída transitoria del SII, no un problema del envío ni del parseo.
+    if (!response.ok) {
+      return {
+        ok: false,
+        error: `SII no disponible (HTTP ${response.status})`,
+        httpStatus: response.status,
+        respuesta: response.text,
+      };
+    }
+
     // Usar decodeXmlEntities centralizado
     const decoded = decodeXmlEntities(response.text).replace(/
/g, '\n');
     

package/SiiCertificacion.js

@@ -18,6 +18,23 @@
 const SiiSession = require('./SiiSession.js');
 const { STEPS, emitProgress } = require('./utils/progress');
 
+/** Decodifica entidades HTML latinas (el portal SII las usa en vez de UTF-8 crudo) y limpia
+ * tags/whitespace, para poder aplicar regex de texto sobre las respuestas de forma confiable. */
+function limpiarTextoPortal(html) {
+  const decodificar = (s) => s
+    .replace(/á/gi, 'á').replace(/é/gi, 'é').replace(/í/gi, 'í')
+    .replace(/ó/gi, 'ó').replace(/ú/gi, 'ú').replace(/ñ/gi, 'ñ')
+    .replace(/Á/g, 'Á').replace(/É/g, 'É').replace(/Í/g, 'Í')
+    .replace(/Ó/g, 'Ó').replace(/Ú/g, 'Ú').replace(/Ñ/g, 'Ñ')
+    .replace(/ /gi, ' ').replace(/&/gi, '&').replace(/"/gi, '"')
+    .replace(/&#(\d+);/g, (_, n) => String.fromCharCode(+n));
+  return decodificar(
+    html.replace(/<script[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<[^>]+>/g, ' ')
+  ).replace(/\s+/g, ' ').trim();
+}
+
 /**
  * Etapas de certificacion DTE
  */
@@ -989,13 +1006,21 @@ class SiiCertificacion {
 
       const formHtml = formResponse.body || '';
 
-      // 3. Enviar formulario de avance final
-      // El botón "Avanzar Siguiente Paso" cambia la acción a /pe_avance4
+      // 3. Enviar formulario de avance final.
+      // El botón "Avanzar Siguiente Paso" del portal es <input type="button" onclick="avanzar()">,
+      // y avanzar() SOLO cambia el action del form a /pe_avance4 y lo submitea — no toca ningún
+      // campo. TOTREG y PASO vienen en inputs hidden que YA trae el form de pe_avance2, y PASO
+      // varía según la etapa actual (ej. "P01" para SET DE PRUEBAS, "P05" para DOCUMENTOS
+      // IMPRESOS). Antes se hardcodeaba PASO:'P01' → solo funcionaba en la primera transición;
+      // en cualquier otra etapa el SII lo ignoraba silenciosamente y respondía "la empresa ya
+      // se encuentra en el paso X" (no avanzaba nada, pero tampoco reportaba error).
+      const totregMatch = formHtml.match(/name="TOTREG"[^>]*value="([^"]*)"/i);
+      const pasoMatch    = formHtml.match(/name="PASO"[^>]*value="([^"]*)"/i);
       const formData = {
         RUT_EMP: this.rutEmpresa,
         DV_EMP: this.dvEmpresa,
-        TOTREG: '0',
-        PASO: 'P01',
+        TOTREG: totregMatch ? totregMatch[1] : '0',
+        PASO: pasoMatch ? pasoMatch[1] : 'P01',
         ACEPTAR: 'Avanzar Siguiente Paso',
       };
 
@@ -1037,11 +1062,29 @@ class SiiCertificacion {
         console.log(' [DEBUG] Respuesta avanzar guardada en:', debugPath);
       }
 
-      const hasError = body.toLowerCase().includes('error') && !body.includes('Error de Sesión');
-      const hasSuccess = body.includes('exitosamente') || body.includes('Avance declarado') || body.includes('actualizado');
+      // El botón real (avanzar()) solo cambia el action y submitea — no valida nada del lado
+      // cliente. La respuesta del SII distingue estos casos por texto, no por status HTTP
+      // (siempre 200) ni por la palabra "error" (aparece en el <script> de todas las páginas
+      // del portal):
+      //   "ha pasado al paso X"                    → avance REAL a otro paso intermedio
+      //   "ha finalizado con la certificación..."   → avance REAL — llegó al paso final,
+      //                                               queda pendiente declarar cumplimiento
+      //                                               (pe_avance7→8, ver declararCumplimiento())
+      //   "ya se encuentra en el paso X"            → no-op: no avanzó nada (PASO no
+      //                                               coincidía, o el SII aún no habilita el
+      //                                               siguiente paso) — NO es un error
+      //   cualquier otro texto                      → error real
+      const texto = limpiarTextoPortal(body);
+      const RE_AVANZO = /ha pasado al paso|ha finalizado con la certificaci/i;
+      const avanzo    = RE_AVANZO.test(texto);
+      const sinCambio = /ya se encuentra en el paso/i.test(texto);
+      const frases = texto.split(/(?<=\.)\s+/);
+      const mensaje = (frases.find(f => RE_AVANZO.test(f) || /ya se encuentra en el paso/i.test(f)) || '').trim() || null;
 
       return {
-        success: !hasError || hasSuccess,
+        success: avanzo,
+        sinCambio,
+        mensaje,
         rawHtml: body,
       };
 
@@ -1172,10 +1215,30 @@ class SiiCertificacion {
       );
 
       const body = formResponse.body || '';
-      const hasError = body.includes('Error') || body.includes('error');
+
+      // El chequeo anterior (body.includes('error')) era demasiado laxo: cualquier página con
+      // la palabra "error" (incluso dentro de un <script>) daba falso negativo, y no detectaba
+      // el caso REAL de bloqueo, que el SII devuelve con HTTP 200 y texto explícito:
+      //   "El contribuyente ... no ha finalizado su certificación, encontrándose en el paso
+      //    DOCUMENTOS IMPRESOS, por lo que no podrá efectuar la Declaración de Cumplimiento."
+      // Eso pasa mientras el SII no haya APROBADO las muestras impresas (quedan "Por revisar").
+      const texto = limpiarTextoPortal(body);
+
+      const RE_BLOQUEO = /no ha finalizado su certificaci|no podr[aá] efectuar la Declaraci/i;
+      const bloqueado  = RE_BLOQUEO.test(texto);
+
+      // Tomar la FRASE que contiene el motivo — no el primer "El contribuyente..." que aparezca
+      // (la página arranca con un párrafo descriptivo que también empieza así, y antes se
+      // devolvía ese texto genérico en vez del motivo real del bloqueo).
+      const frases = texto.split(/(?<=\.)\s+/);
+      const mensaje = bloqueado
+        ? (frases.find(f => RE_BLOQUEO.test(f)) || '').trim() || null
+        : (frases.find(f => /declaraci[oó]n de cumplimiento|ha finalizado|certificad[ao]/i.test(f)) || '').trim() || null;
 
       return {
-        success: !hasError,
+        success: !bloqueado,
+        bloqueado,
+        mensaje,
         rawHtml: body,
       };
 

package/cert/CertRunner.js

@@ -168,6 +168,20 @@ class CertRunner {
    * @returns {Promise<Object>} { success, estructuras, error }
    */
   async obtenerSets(options = {}) {
+    if (options.hydrateOnly) {
+      // Solo hidrata this._estructuras desde memoria o disco — NUNCA llama al SII. Necesario
+      // como modo aparte porque el resto de esta función SIEMPRE pide un set nuevo al SII
+      // (forceRefresh: true, ver abajo), lo que REINICIA la postulación real completa. Un
+      // llamado pensado solo para "popular estado" no puede arriesgarse a tocar esa rama.
+      if (!this._estructuras) {
+        const estructurasPath = path.join(this.debugDir, 'estructuras.json');
+        if (fs.existsSync(estructurasPath)) {
+          this._estructuras = JSON.parse(fs.readFileSync(estructurasPath, 'utf8'));
+        }
+      }
+      return { success: !!this._estructuras, estructuras: this._estructuras, hydrated: true };
+    }
+
     const resultado = await this.setsProvider.obtenerSets({
       setsOpcionales: options.setsOpcionales || {
         SET03: 'S',  // SET GUIA DE DESPACHO
@@ -199,6 +213,28 @@ class CertRunner {
     return { success: true, estructuras: resultado.estructuras };
   }
 
+  /**
+   * Inyecta estructuras ya descargadas (desde BD/caché) sin pedirlas al SII. Formaliza lo que
+   * hoy hacen los callers a mano (`runner._estructuras = JSON.parse(...)`) con acceso directo
+   * a un campo "privado". Útil para reanudar en una fase posterior (libros, simulación) sin
+   * volver a llamar obtenerSets() — que SIEMPRE resetea la postulación real (forceRefresh).
+   * @param {Object} estructurasJson
+   */
+  setEstructuras(estructurasJson) {
+    this._estructuras = estructurasJson;
+  }
+
+  /**
+   * Inyecta resultados previos (trackIds de sets ya enviados) en this.resultados sin
+   * re-ejecutar los envíos. Hace merge — no borra resultados ya presentes que no vengan en
+   * resultadosJson. Formaliza `runner.resultados[k] = {...}` (acceso directo hoy en
+   * run-certificacion.js) con un método explícito.
+   * @param {Object} resultadosJson
+   */
+  setResultados(resultadosJson) {
+    Object.assign(this.resultados, resultadosJson);
+  }
+
   /**
    * Solicita CAFs frescos para los tipos especificados
    * @param {Object} cafRequired - { 33: 4, 56: 1, 61: 3 }
@@ -437,13 +473,18 @@ class CertRunner {
    * Declara avance de los sets ejecutados con reintentos automáticos
    * @param {Object} [resultadosExt] - Resultados externos (usa this.resultados si no se pasa)
    * @param {Object} [estructurasExt] - Estructuras externas (usa this._estructuras si no se pasa)
-   * @param {Object} [options] - { maxIntentos, intervalo }
+   * @param {Object} [options] - { maxIntentos, intervalo, ignorarVacio }
+   * @param {boolean} [options.ignorarVacio] - Si this.resultados no tiene trackIds (runner
+   *   recién creado, sin hidratar), en vez de devolver el error genérico "No hay sets para
+   *   declarar" consulta el estado real del portal: si la etapa ya avanzó más allá de SET DE
+   *   PRUEBAS, los sets YA fueron declarados y aprobados en una ejecución anterior — no hay
+   *   nada que hacer y no es un error. Default false — comportamiento previo sin cambios.
    * @returns {Promise<Object>} Resultado de la declaración
    */
   async declararAvance(resultadosExt, estructurasExt, options = {}) {
     const resultados = resultadosExt || this.resultados;
     const estructuras = estructurasExt || this._estructuras;
-    const { maxIntentos = 10, intervalo = 5000 } = options;
+    const { maxIntentos = 10, intervalo = 5000, ignorarVacio = false } = options;
 
     if (!estructuras) {
       throw new Error('No hay estructuras. Ejecutar obtenerSets() primero.');
@@ -470,6 +511,13 @@ class CertRunner {
     }
 
     if (Object.keys(sets).length === 0) {
+      if (ignorarVacio) {
+        const avance = await this.consultarAvance().catch(() => null);
+        const etapa = avance?.etapaActual;
+        if (etapa && etapa !== 'SET DE PRUEBAS') {
+          return { success: true, yaDeclarado: true, etapaActual: etapa };
+        }
+      }
       return { success: false, error: 'No hay sets para declarar' };
     }
 
@@ -519,6 +567,11 @@ class CertRunner {
    * @returns {Promise<Object>} Resultado con todos los libros
    */
   async ejecutarFase4Libros(options = {}) {
+    // Permite pasar las estructuras explícitamente (ej. runner recién creado, hidratado desde
+    // BD/caché en vez de obtenerSets()) — igual que ejecutarSimulacion(). Si no vienen, cae al
+    // estado interno (comportamiento previo, sin cambios para callers existentes).
+    const estructuras = options.estructuras || this._estructuras;
+
     // NOTA: Ya NO decrementamos aquí - cada libro decrementa su propio período
     emitProgress(STEPS.BOOKS_START);
     console.log('\n' + '═'.repeat(60));
@@ -580,8 +633,8 @@ class CertRunner {
     // con el mes de esas fechas. Usar currentMonth-1 causa "ENVIO CON ERRORES O REPAROS".
     let _periodoBase = null;
     const _fchDocMuestra =
-      this._estructuras?.libroCompras?.detalle?.[0]?.FchDoc ||
-      this._estructuras?.libroComprasExentos?.detalle?.[0]?.FchDoc;
+      estructuras?.libroCompras?.detalle?.[0]?.FchDoc ||
+      estructuras?.libroComprasExentos?.detalle?.[0]?.FchDoc;
     if (_fchDocMuestra) {
       const _dt = new Date(_fchDocMuestra);
       if (!isNaN(_dt.getTime())) {
@@ -729,7 +782,7 @@ class CertRunner {
     }
 
     // 4. Libro de Compras para Exentos (solo si el SII lo entregó y no está ya aprobado)
-    if (this._estructuras?.libroComprasExentos) {
+    if (estructuras?.libroComprasExentos) {
       try {
         if (_estaConforme('LIBRO DE COMPRAS PARA EXENTOS')) {
           emitProgress(STEPS.BOOK_SKIPPED, { book: 'libroComprasExentos' });
@@ -867,7 +920,7 @@ class CertRunner {
       // NO es un error de período. Solo LNC/LRH son errores reales que requieren acción.
       const _esperarAprobacion = async (librosAVerificar) => {
         const _todosCandidatos = ['LIBRO DE VENTAS', 'LIBRO DE COMPRAS', 'LIBRO DE GUIAS'];
-        if (this._estructuras?.libroComprasExentos) _todosCandidatos.push('LIBRO DE COMPRAS PARA EXENTOS');
+        if (estructuras?.libroComprasExentos) _todosCandidatos.push('LIBRO DE COMPRAS PARA EXENTOS');
         const _librosAVerif = librosAVerificar || _todosCandidatos.filter(n => !_estaConforme(n));
         console.log(`\nEsperando aprobacion del SII para: ${_librosAVerif.join(', ')}`);
         let _ss = {};
@@ -914,6 +967,27 @@ class CertRunner {
           if (_pendientesAun.length > 0 && (_i + 1) % 4 === 0) {
             console.log(` [...] Aún esperando (${Math.round((_i + 1) * 15 / 60)} min): ${_pendientesAun.join(', ')}`);
           }
+          // Cross-check SOAP: el portal se queda en S21 ("declarado") para un envío que el
+          // SOAP ya reporta RECHAZADO (LNC = período ocupado → "ENVIO CON ERRORES O REPAROS"
+          // en pe_avance3). Ese estado NUNCA pasa a REVISADO CONFORME; sin este chequeo se
+          // espera el timeout completo (10 min) al pedo. Consultar SOAP cada 2 intentos (~30s):
+          // si algún pendiente está rechazado, cortar y dejar que phase b reintente período.
+          // Solo se corta ante un rechazo POSITIVO (ok && esRechazado); errores de red/503 se
+          // ignoran para no cortar una espera legítima.
+          if (_enviadorSoap && _pendientesAun.length > 0 && (_i + 1) % 2 === 0) {
+            for (const _n of _pendientesAun) {
+              const _k = _SII_NOMBRE_A_KEY[_n];
+              const _tid = _k && resultados[_k]?.trackId;
+              if (!_tid) continue;
+              try {
+                const _soap = await _enviadorSoap.consultarEstadoSoap(_tid, _rutEmisor);
+                if (_soap.ok && _soap.esRechazado) {
+                  console.log(`\n [SOAP] ${_n} (${_tid}): ${_soap.estado} — ${_soap.glosa || 'rechazado'}. No llegará a CONFORME → reintentando período.`);
+                  return { ok: false, estadosFinal: _ss };
+                }
+              } catch { /* SOAP inestable (503) — ignorar y seguir con el portal */ }
+            }
+          }
         }
         console.log('\n[!] Timeout (10 min). El SII aún no responde. Verifica con --avance más tarde.');
         return { ok: false, estadosFinal: _ss };
@@ -932,16 +1006,19 @@ class CertRunner {
       const _enviadorSoap = this._createLibroEnviador();
       const _rutEmisor = this.config.emisor.rut;
 
-      // Polling hasta 30 minutos (120 intentos × 15s).
-      // LSO (schema OK, procesando contenido) y otros intermedios esperan hasta LOK o rechazo.
-      const _MAX_SOAP_POLLS = 120;
+      // Polling hasta 5 minutos (20 intentos × 15s). Si los libros no llegan a LOK
+      // en ese lapso se declara igual (ver más abajo "Declarando igual"). El SII de
+      // certificación (maullín) suele dejar los libros en LSO mucho tiempo sin avanzar,
+      // así que esperar 30 min (el valor anterior) solo agregaba demora sin cambiar el
+      // resultado. LSO y otros intermedios igual esperan hasta LOK o rechazo, pero acotado.
+      const _MAX_SOAP_POLLS = 20;
       const _SOAP_INTERVAL_MS = 15000;
       let _soapPendientes = new Set(_librosParaConsultar.map(l => l.key));
       const _soapFinalStates = {}; // key → resultado SOAP terminal (LOK/LNC/LRH/etc.)
       const _soapErrCount = {};    // key → contador de errores SOAP consecutivos (ok:false o throw)
       const _MAX_SOAP_ERR = 10;    // reintentos antes de desistir por errores transitorios
 
-      console.log('\n[SOAP] Consultando estado de envíos (espera hasta 15 min)...');
+      console.log('\n[SOAP] Consultando estado de envíos (espera hasta 5 min)...');
       await sleep(15000); // espera inicial — SII tarda al menos 15s en validar schema
       for (let _pi = 0; _pi < _MAX_SOAP_POLLS && _soapPendientes.size > 0; _pi++) {
         for (const { key, nombre } of _librosParaConsultar) {
@@ -957,9 +1034,9 @@ class CertRunner {
               _soapErrCount[key] = (_soapErrCount[key] || 0) + 1;
               if (_soapErrCount[key] >= _MAX_SOAP_ERR) {
                 _soapPendientes.delete(key);
-                console.log(` [SOAP] ${nombre} (${_tid}): [?] demasiados errores — desistiendo`);
+                console.log(` [SOAP] ${nombre} (${_tid}): [?] demasiados errores — desistiendo (${_detalle})`);
               } else {
-                console.log(` [SOAP] ${nombre} (${_tid}): [?] error transitorio (${_soapErrCount[key]}/${_MAX_SOAP_ERR}) — reintentando...`);
+                console.log(` [SOAP] ${nombre} (${_tid}): [?] error transitorio (${_soapErrCount[key]}/${_MAX_SOAP_ERR}) — reintentando... (${_detalle})`);
               }
             } else {
               _soapErrCount[key] = 0; // reset en cualquier respuesta válida
@@ -988,7 +1065,7 @@ class CertRunner {
       }
       if (_soapPendientes.size > 0) {
         const _nombresTimeout = _librosParaConsultar.filter(l => _soapPendientes.has(l.key)).map(l => l.nombre);
-        console.log(` [SOAP] ${_nombresTimeout.join(', ')} siguen en proceso tras 15 min. Declarando igual — verifica correos del SII.`);
+        console.log(` [SOAP] ${_nombresTimeout.join(', ')} siguen en proceso tras 5 min. Declarando igual — verifica correos del SII.`);
       }
 
       // 4. Declarar + retry automático:
@@ -1045,7 +1122,7 @@ class CertRunner {
 
           // Construir la lista inicial de libros a verificar
           const _todosLibrosNombres = ['LIBRO DE VENTAS', 'LIBRO DE COMPRAS', 'LIBRO DE GUIAS'];
-          if (this._estructuras?.libroComprasExentos) _todosLibrosNombres.push('LIBRO DE COMPRAS PARA EXENTOS');
+          if (estructuras?.libroComprasExentos) _todosLibrosNombres.push('LIBRO DE COMPRAS PARA EXENTOS');
           let _librosAVerificar = _todosLibrosNombres.filter(n => !_estaConforme(n));
 
           // Si SOAP detectó LNC/LRH para algún libro → excluirlos de la espera portal.
@@ -1640,6 +1717,42 @@ class CertRunner {
     }
   }
 
+  /**
+   * Cierre final de la certificación DTE, en un solo paso:
+   *   1. "Avanzar Siguiente Paso" (pe_avance4) — solo funciona si el SII ya APROBÓ las muestras
+   *      impresas. Mientras estén "Por revisar" el portal responde "ya se encuentra en el paso
+   *      DOCUMENTOS IMPRESOS" y no avanza (no es un error: hay que esperar al SII).
+   *   2. "Declaración de Cumplimiento de Requisitos" (pe_avance7 → pe_avance8).
+   *
+   * Reemplaza los 3 pasos manuales que el usuario debía hacer a mano en el portal del SII.
+   * @returns {Promise<Object>} { success, bloqueado, mensaje, avance, declaracion }
+   */
+  async declararCumplimientoFinal() {
+    console.log('\n' + '═'.repeat(60));
+    console.log('CIERRE FINAL: AVANZAR PASO + DECLARAR CUMPLIMIENTO');
+    console.log('═'.repeat(60));
+
+    console.log('\n → Avanzando al siguiente paso (pe_avance4)...');
+    const avance = await this.avanzarSiguientePaso().catch(e => ({ success: false, error: e.message }));
+    console.log(avance?.success ? ' ✓ Avance enviado' : ` [!] Avance no aplicado: ${avance?.error || 'sin cambios'}`);
+
+    console.log('\n → Declarando cumplimiento de requisitos (pe_avance7 → pe_avance8)...');
+    const declaracion = await this.siiCert.declararCumplimiento();
+
+    if (declaracion.bloqueado) {
+      console.log(`\n [!] El SII NO permite declarar todavía: ${declaracion.mensaje || 'certificación no finalizada'}`);
+      console.log('     Las muestras impresas siguen pendientes de revisión del SII.');
+      return { success: false, bloqueado: true, mensaje: declaracion.mensaje, avance, declaracion };
+    }
+    if (!declaracion.success) {
+      console.log(`\n [ERR] Error declarando cumplimiento: ${declaracion.error || 'desconocido'}`);
+      return { success: false, bloqueado: false, mensaje: declaracion.error, avance, declaracion };
+    }
+
+    console.log('\n [OK] DECLARACIÓN DE CUMPLIMIENTO EFECTUADA');
+    return { success: true, bloqueado: false, mensaje: declaracion.mensaje, avance, declaracion };
+  }
+
   /**
    * Espera a que los libros sean aprobados y luego avanza al siguiente paso
    * @param {Object} [options] - { maxIntentos, intervalo }
@@ -2305,9 +2418,11 @@ class CertRunner {
     const { cookies, makeReq } = await this._autenticarPfeInternet();
 
     const [empRut, empDv] = this.config.emisor.rut.replace(/\./g, '').split('-');
-    // Extraer RUT del certificado desde la ruta del PFX (e.g. "19925444-8.pfx")
-    const certBase = path.basename(this.config.certificado.path, '.pfx');
-    const [certRut, certDv = '0'] = certBase.includes('-') ? certBase.split('-') : [certBase, '0'];
+    // RUT del titular del certificado — desde el objeto Certificado (parsea el PFX), NO del
+    // nombre de archivo: cuando la API inyecta un PFX temporal (p.ej. "1-<ts>-cert.pfx") el
+    // nombre no contiene el RUT → certRut salía basura → validarUsuario "No hay usuario a validar".
+    const certRutFull = (this.certificado?.rut || path.basename(this.config.certificado.path, '.pfx')).replace(/\./g, '');
+    const [certRut, certDv = '0'] = certRutFull.includes('-') ? certRutFull.split('-') : [certRutFull, '0'];
 
     const gwtHeaders = {
       'Content-Type': 'text/x-gwt-rpc; charset=UTF-8',
@@ -2386,7 +2501,10 @@ class CertRunner {
       ].join(CRLF);
 
       console.log(` → Subiendo ${archivo.filename}...`);
-      const uploadResp = await makeReq(`${PFE_BASE}uploadFile${archivo.uploadN}`, {
+      // El portal SII exige el RUT de la empresa como query params (?re={rut}&dve={dv}),
+      // igual que downloadFile. Sin ellos responde HTTP 200 con "no vienen los parametros
+      // necesarios" y el envío no se registra → la etapa nunca avanza a DOCUMENTOS IMPRESOS.
+      const uploadResp = await makeReq(`${PFE_BASE}uploadFile${archivo.uploadN}?re=${empRut}&dve=${empDv}`, {
         method: 'POST',
         body: multipartBody,
         headers: {
@@ -2403,19 +2521,54 @@ class CertRunner {
       }
 
       const respLow = respBody.toLowerCase();
-      const hasError = uploadResp.status >= 400
-        || (respLow.includes('error') && !respLow.includes('procesado'))
+      // La página de error del portal GWT devuelve HTTP 200 con "no vienen los parametros
+      // necesarios" / <title>ERROR</title> → NO es éxito aunque el status sea 200. Antes se
+      // tomaba status===200 como éxito y se marcaba el intercambio confirmado en falso.
+      const esPaginaError = respLow.includes('no vienen los parametros')
+        || respLow.includes('<title>error')
         || respLow.includes('rechaz');
-      const hasSuccess = respLow.includes('procesado') || respLow.includes('exitosamente')
-        || respLow.includes('cargado') || uploadResp.status === 200;
+      const hasError = uploadResp.status >= 400 || esPaginaError;
 
-      if (hasError && !hasSuccess) {
+      if (hasError) {
         throw new Error(`Error al subir ${archivo.filename}: HTTP ${uploadResp.status} — ${respBody.substring(0, 200)}`);
       }
       console.log(` ✓ ${archivo.filename} subido (HTTP ${uploadResp.status})`);
     }
 
-    return { success: true, resultado: 'Los 3 archivos XML de intercambio subidos correctamente' };
+    // === PASO 3: Confirmar el intercambio (GWT RPC) — el "commit" que avanza a DOCUMENTOS
+    // IMPRESOS. Sin esto los 3 XML quedan subidos pero la postulación NO avanza. Secuencia
+    // capturada del portal real (F12): validarSetContriPostSeguimiento + updatePostulacion-
+    // Seguimiento ×3 (una por cada documento subido, ids 40/41/43). Antes hacíamos solo una
+    // (43) → por eso no avanzaba: faltaban las otras dos + la validación previa.
+    console.log(' → pfeInternet: validarSetContriPostSeguimiento...');
+    const validSetPayload =
+      `7|0|7|${PFE_BASE}|${PFE_POLICY}|${PFE_SVC}|validarSetContriPostSeguimiento|` +
+      `java.lang.Integer/3438268394|java.lang.String/2004016611|${empDv}|` +
+      `1|2|3|4|2|5|6|5|${empRut}|7|`;
+    const validSetResp = await makeReq(`${PFE_BASE}facade`, {
+      method: 'POST', body: validSetPayload, headers: gwtHeaders, cookies,
+    });
+    if (debugDir) fs.writeFileSync(path.join(debugDir, 'pfe-validarset-resp.txt'), (validSetResp.body || '').substring(0, 800), 'utf8');
+
+    // updatePostulacionSeguimiento × 3 (ids 40, 41, 43 — uno por documento de intercambio)
+    const SEGUIMIENTO_IDS = [40, 41, 43];
+    for (const seguimientoId of SEGUIMIENTO_IDS) {
+      console.log(` → pfeInternet: updatePostulacionSeguimiento (id=${seguimientoId})...`);
+      const segPayload =
+        `7|0|7|${PFE_BASE}|${PFE_POLICY}|${PFE_SVC}|updatePostulacionSeguimiento|` +
+        `cl.sii.sdi.dim.pfe.to.PostulacionSeguimientoTo/3921005560|java.lang.Integer/3438268394|${empDv}|` +
+        `1|2|3|4|1|5|5|6|${seguimientoId}|0|0|0|0|7|6|${empRut}|`;
+      const segResp = await makeReq(`${PFE_BASE}facade`, {
+        method: 'POST', body: segPayload, headers: gwtHeaders, cookies,
+      });
+      if (debugDir) fs.writeFileSync(path.join(debugDir, `pfe-seguimiento-${seguimientoId}-resp.txt`), (segResp.body || '').substring(0, 500), 'utf8');
+      if (!/\/\/OK/.test(segResp.body || '')) {
+        throw new Error(`updatePostulacionSeguimiento(${seguimientoId}) no confirmó: ${(segResp.body || '').substring(0, 200)}`);
+      }
+    }
+    console.log(' ✓ Intercambio confirmado (3 seguimientos) — postulación avanza a DOCUMENTOS IMPRESOS');
+
+    return { success: true, resultado: 'Los 3 archivos XML de intercambio subidos y confirmados (avanza a DOCUMENTOS IMPRESOS)' };
   }
 
   // ═══════════════════════════════════════════════════════════════
@@ -2717,11 +2870,18 @@ class CertRunner {
       (() => { const m = leeResp.body.match(/"(El estado de la postulacion[^"\\]*(?:\\.[^"\\]*)*)"/i); return m ? m[1].replace(/\\x27/g, "'").replace(/\\x22/g, '"') : null; })()
     );
     if (errorEstadoMsg) {
+      // OJO: el SII devuelve "El estado de la postulacion NO es: 'DOCUMENTOS IMPRESOS'" en DOS
+      // situaciones distintas, y el mensaje no las distingue:
+      //   a) la postulación TODAVÍA NO llegó a DOCUMENTOS IMPRESOS (falta completar intercambio)
+      //   b) la postulación YA PASÓ esa etapa (p.ej. DECLARACION EFECTUADA = certificación
+      //      terminada) → subir muestras de nuevo ya no aplica, no hay nada que esperar.
+      // Por eso el hint sugiere verificar la etapa con --avance en vez de asumir que hay una
+      // revisión en curso.
       console.log(` → Portal SII bloqueado: ${errorEstadoMsg}`);
       return {
         success: false, blocked: true, estado: 'BLOQUEADO',
         error: errorEstadoMsg,
-        hint: 'Espere a que el SII procese la revisión en curso (APROBADO/RECHAZADO) antes de re-subir.',
+        hint: 'La postulación no está en DOCUMENTOS IMPRESOS: puede que aún no haya llegado a esa etapa, o que YA la haya superado (certificación terminada). Verifica la etapa real con --avance.',
       };
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devlas/dte-sii",
-  "version": "2.12.12",
+  "version": "2.12.14",
   "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",