@devlas/dte-sii 2.9.2 → 2.9.3

package/CafSolicitor.js

@@ -17,6 +17,15 @@ const path = require('path');
 const SiiSession = require('./SiiSession');
 const { splitRut } = require('./utils/rut');
 
+/**
+ * Registro global de sesiones SII (singleton por ambiente+rut).
+ * Permite reutilizar la misma sesión HTTP entre múltiples llamadas a CafSolicitor
+ * sin abrir una nueva sesión en el portal del SII cada vez.
+ * Clave: `${ambiente}::${rutEmisor}`
+ * @type {Map<string, SiiSession>}
+ */
+const _sessionRegistry = new Map();
+
 /**
  * Clase para solicitar CAFs al SII
  */
@@ -28,7 +37,6 @@ class CafSolicitor {
    * @param {string} options.pfxPath - Ruta absoluta al certificado PFX
    * @param {string} options.pfxPassword - Contraseña del certificado
    * @param {string} [options.baseDir] - Directorio base para guardar archivos
-   * @param {string} [options.sessionPath] - Ruta al archivo de sesión compartida
    * @param {string} [options.runStamp] - Timestamp de la ejecución
    */
   constructor(options = {}) {
@@ -48,22 +56,22 @@ class CafSolicitor {
     this.ambiente = options.ambiente.toLowerCase();
     this.rutEmisor = options.rutEmisor;
     this.baseDir = options.baseDir || path.resolve(__dirname, '..', '..');
-    this.sessionPath = options.sessionPath || null;
     this.runStamp = options.runStamp || new Date().toISOString().replace(/[:.]/g, '-');
 
-    // Crear SiiSession para manejar HTTP y cookies
-    this.session = new SiiSession({
-      ambiente: this.ambiente,
-      pfxPath: options.pfxPath,
-      pfxPassword: options.pfxPassword,
-    });
-
-    // Cargar sesión compartida si existe
-    if (this.sessionPath) {
-      const loaded = this.session.loadSession(this.sessionPath);
-      if (loaded) {
-        console.log('[CafSolicitor] ✓ Usando sesión compartida');
-      }
+    // Reutilizar sesión SII global si ya existe para este ambiente+rut.
+    // Esto evita abrir múltiples sesiones en el portal del SII.
+    const sessionKey = `${this.ambiente}::${this.rutEmisor}`;
+    if (_sessionRegistry.has(sessionKey)) {
+      this.session = _sessionRegistry.get(sessionKey);
+      console.log('[CafSolicitor] ♻️ Reutilizando sesión SII en memoria');
+    } else {
+      this.session = new SiiSession({
+        ambiente: this.ambiente,
+        pfxPath: options.pfxPath,
+        pfxPassword: options.pfxPassword,
+      });
+      _sessionRegistry.set(sessionKey, this.session);
+      console.log('[CafSolicitor] 🔑 Nueva sesión SII registrada para', sessionKey);
     }
   }
 
@@ -193,16 +201,73 @@ class CafSolicitor {
       // 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 };
+        return { success: true, cafPath, xml: response.body, maxAutor: this._lastMaxAutor ?? cantidad };
       }
 
       if (response.body && response.body.includes('Autenticaci')) {
         return { success: false, error: 'El SII devolvió página de autenticación' };
       }
 
-      // Detectar error de límite diario del SII
+      // Detectar error de MAX_AUTOR: "La cantidad de documentos a timbrar debe ser menor o igual al máximo autorizado"
+      // Puede ocurrir cuando el MAX_AUTOR efectivo del SII es menor al mostrado en el formulario
+      // (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')) {
-        return { success: false, error: 'Límite diario de folios SII agotado (MAX_AUTOR). Reintenta mañana.' };
+        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.
+          // Reutilizar la sesión activa evita abrir una nueva y acumular sesiones en el SII.
+          this.runStamp = new Date().toISOString().replace(/[:.]/g, '-');
+          return this.solicitar({ tipoDte, cantidad: 1 });
+        }
+        return { success: false, error: 'Cantidad de folios excede el máximo que SII autoriza por solicitud para este tipo de documento (MAX_AUTOR). Verifica el estado de timbraje de tu empresa en el portal SII.' };
+      }
+
+      // Detectar rango ya autorizado — el CAF existe en SII pero no fue capturado
+      // (ocurre cuando una solicitud previa tuvo éxito en SII pero falló en la red al devolver el XML,
+      // o cuando of_genera_archivo devolvió DTE-OFGA y el SII registró el rango igualmente)
+      const finalBody = response.body || '';
+      if (finalBody.includes('ya fue autorizado el rango desde') || finalBody.includes('ya fue autorizado')) {
+        const m = finalBody.match(/ya fue autorizado el rango desde\s+(\d+)\s+hasta\s+(\d+)/i);
+        const desde = m ? parseInt(m[1]) : null;
+        const hasta  = m ? parseInt(m[2]) : null;
+
+        // Intentar recuperar el XML directamente enviando los datos del rango a of_genera_archivo.
+        // El SII tiene el CAF autorizado en su sistema; si enviamos los campos correctos
+        // puede devolver el XML aunque la sesión de timbraje original ya terminó.
+        if (desde != null && hasta != null) {
+          console.warn(`[CafSolicitor] Rango ${desde}-${hasta} ya autorizado — intentando recuperar XML desde of_genera_archivo...`);
+          const today = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+          const recoveryFields = {
+            RUT_EMP: rut,
+            DV_EMP: dv,
+            COD_DOCTO: String(tipoDte),
+            FOLIO_INI: String(desde),
+            FOLIO_FIN: String(hasta),
+            FECHA: today,
+            ACEPTAR: 'AQUI',
+          };
+          try {
+            const recoveryResponse = await this.session.submitForm('/cvc_cgi/dte/of_genera_archivo', recoveryFields);
+            const recoveryBody = recoveryResponse.body || '';
+            this._saveDebug(debugDir, 'recovery.xml', recoveryBody);
+            if (recoveryBody.includes('<AUTORIZACION')) {
+              console.log(`[CafSolicitor] ✅ CAF recuperado exitosamente para rango ${desde}-${hasta}`);
+              const cafPath = this._saveCafOrganized(recoveryBody, tipoDte);
+              return { success: true, cafPath, xml: recoveryBody, maxAutor: hasta - desde + 1 };
+            }
+            console.warn(`[CafSolicitor] Recuperación de rango ${desde}-${hasta} no devolvió XML (${recoveryBody.substring(0, 80).replace(/\s+/g, ' ')})`);
+          } catch (recoveryErr) {
+            console.warn(`[CafSolicitor] Error al intentar recuperar rango: ${recoveryErr.message}`);
+          }
+        }
+
+        const rangoStr = desde != null && hasta != null ? ` ${desde}-${hasta}` : '';
+        return {
+          success: false,
+          rangoYaAutorizado: desde != null && hasta != null ? { folioDesde: desde, folioHasta: hasta } : null,
+          error: `SII: Ya existe CAF autorizado para el rango${rangoStr}. El XML fue aprobado por SII en una solicitud previa pero no se pudo recuperar automáticamente. Descárgalo manualmente desde el portal SII (Factura Electrónica → Solicitud de Timbraje).`,
+        };
       }
 
       return { success: false, error: 'No se obtuvo CAF en la respuesta' };
@@ -238,15 +303,16 @@ class CafSolicitor {
       // Selección de tipo de documento
       if (currentHtml.includes('COD_DOCTO')) {
         const selectInputs = SiiSession.extractInputValues(currentHtml);
-        // Respetar MAX_AUTOR que el SII informa en el formulario.
-        const maxAutorSelect = parseInt(selectInputs.MAX_AUTOR || '999', 10);
-        const cantSelect = Math.min(cantidad, maxAutorSelect);
+        // NO enviar CANT_DOCTOS aquí — el browser tampoco lo envía en este paso.
+        // Si se envía un número, el SII no incluye MAX_AUTOR ni CONTROL="S" en la
+        // respuesta, lo que causa rechazo silencioso en of_genera_folio más adelante.
+        // El SII fija CANT_DOCTOS automáticamente según MAX_AUTOR al responder.
         const selectFields = {
           ...selectInputs,
           RUT_EMP: rut,
           DV_EMP: dv,
           COD_DOCTO: tipoDte,
-          CANT_DOCTOS: cantSelect,
+          CANT_DOCTOS: '',
         };
 
         response = await this.session.submitForm('/cvc_cgi/dte/of_solicita_folios_dcto', selectFields);
@@ -270,16 +336,19 @@ class CafSolicitor {
     
     const formAction3 = SiiSession.extractFormAction(currentHtml) || '/cvc_cgi/dte/of_confirma_folio';
     const inputs3 = SiiSession.extractInputValues(currentHtml);
-    
-    // Respetar MAX_AUTOR si viene en este paso también
-    const maxAutorStep3 = parseInt(inputs3.MAX_AUTOR || '999', 10);
-    const cantStep3 = Math.min(cantidad, maxAutorStep3);
+
+    // 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).
+    const maxAutor = parseInt(inputs3.MAX_AUTOR || String(cantidad), 10);
+    const cantReal = Math.min(cantidad, maxAutor);
+    this._lastMaxAutor = maxAutor; // guardado para retornarlo desde solicitar()
+
     const step3Fields = {
       ...inputs3,
       RUT_EMP: rut,
       DV_EMP: dv,
       COD_DOCTO: tipoDte,
-      CANT_DOCTOS: cantStep3,
+      CANT_DOCTOS: String(cantReal),
       ACEPTAR: 'Solicitar Numeración',
     };
 
@@ -351,9 +420,20 @@ class CafSolicitor {
     currentHtml = response.body || '';
     this._saveDebug(debugDir, 'genera.html', currentHtml);
 
+    // El SII rechaza el request si ese rango ya fue autorizado en una solicitud previa
+    // (ocurre en reintentos cuando la primera solicitud llegó a SII pero falló la red al devolver el XML)
+    if (currentHtml.includes('ya fue autorizado')) {
+      const m = currentHtml.match(/ya fue autorizado el rango desde\s+(\d+)\s+hasta\s+(\d+)/i);
+      console.warn(`[CafSolicitor] of_genera_folio: rango ya autorizado${m ? ' ' + m[1] + '-' + m[2] : ''} — el XML existe en SII pero no se obtuvo`);
+      return response;
+    }
+
     // Paso final: of_genera_archivo
     if (!currentHtml.includes('<AUTORIZACION') && currentHtml.includes('of_genera_archivo')) {
-      response = await this._processGeneraArchivo(response, debugDir);
+      // Guardar los inputs del genera.html para poder reintentar of_genera_archivo si falla con DTE-OFGA
+      const generaInputs = SiiSession.extractInputValues(currentHtml);
+      const generaFormAction = SiiSession.extractFormAction(currentHtml) || '/cvc_cgi/dte/of_genera_archivo';
+      response = await this._processGeneraArchivo(response, debugDir, generaInputs, generaFormAction);
     }
 
     return response;
@@ -362,8 +442,12 @@ class CafSolicitor {
   /**
    * Procesa generación de archivo CAF
    * @private
+   * @param {Object} response - Respuesta previa
+   * @param {string} debugDir - Directorio de debug
+   * @param {Object} [retryInputs] - Inputs de genera.html para retry si falla con DTE-OFGA
+   * @param {string} [retryFormAction] - URL de of_genera_archivo para retry
    */
-  async _processGeneraArchivo(response, debugDir) {
+  async _processGeneraArchivo(response, debugDir, retryInputs, retryFormAction) {
     let currentHtml = response.body || '';
     
     const formAction = SiiSession.extractFormAction(currentHtml) || '/cvc_cgi/dte/of_genera_archivo';
@@ -378,6 +462,32 @@ class CafSolicitor {
     currentHtml = response.body || '';
     this._saveDebug(debugDir, 'archivo.xml', currentHtml);
 
+    // El SII a veces devuelve error interno DTE-OFGA (servidor sobrecargado o fallo transitorio).
+    // En ese caso el rango ya fue registrado en SII pero el XML no se generó.
+    // Reintentar el mismo POST hasta 3 veces con delay de 3s antes de rendirse.
+    if (!currentHtml.includes('<AUTORIZACION') && currentHtml.includes('DTE-OFGA')) {
+      for (let attempt = 1; attempt <= 3; attempt++) {
+        const delaySecs = attempt * 3;
+        console.warn(`[CafSolicitor] Error DTE-OFGA en of_genera_archivo — reintentando en ${delaySecs}s (intento ${attempt}/3)...`);
+        await new Promise(r => setTimeout(r, delaySecs * 1000));
+        // Reintentar con los inputs originales del genera.html si están disponibles,
+        // ya que los del archivo.xml (página de error) no tienen los campos necesarios.
+        const retryFields = retryInputs ? { ...retryInputs, ACEPTAR: 'AQUI' } : fields;
+        const retryAction = retryFormAction || formAction;
+        response = await this.session.submitForm(retryAction, retryFields);
+        currentHtml = response.body || '';
+        this._saveDebug(debugDir, `archivo-retry${attempt}.xml`, currentHtml);
+        if (currentHtml.includes('<AUTORIZACION')) {
+          console.log(`[CafSolicitor] ✅ CAF obtenido en retry ${attempt} de of_genera_archivo`);
+          return response;
+        }
+        if (!currentHtml.includes('DTE-OFGA')) {
+          // Error diferente (ya fue autorizado, etc.) — salir del loop
+          break;
+        }
+      }
+    }
+
     // A veces hay un paso extra
     if (!currentHtml.includes('<AUTORIZACION') && currentHtml.includes('of_genera_archivo')) {
       const formAction2 = SiiSession.extractFormAction(currentHtml) || '/cvc_cgi/dte/of_genera_archivo';

package/DTE.js

@@ -71,9 +71,14 @@ class DTE {
   
   _convertirDatosSimplificados(d) {
     const esExenta = d.tipo === 41;
+    const esBoleta = TIPOS_BOLETA.includes(d.tipo);
     const precioConIva = d.precioConIva === true;
-    const { detalle, mntNeto, mntExento } = this._procesarItems(d.items, esExenta, precioConIva);
-    const totales = this._calcularTotales(mntNeto, mntExento, esExenta);
+    // Boletas afectas: reportar precios al consumidor (bruto con IVA) en <Detalle>.
+    // El SII valida MntTotal = suma(MontoItem), por lo que MontoItem debe ser precio con IVA.
+    // Para facturas: convertir a neto (precio sin IVA) como de costumbre.
+    const convertirANeto = precioConIva && !esBoleta;
+    const { detalle, mntNeto, mntExento } = this._procesarItems(d.items, esExenta, convertirANeto);
+    const totales = this._calcularTotales(mntNeto, mntExento, esExenta, esBoleta, esBoleta && precioConIva);
     
     const resultado = {
       Encabezado: {
@@ -145,14 +150,28 @@ class DTE {
   
   // PrcItem = precio neto unitario (o precio con IVA si se usa precioConIva:true).
   // IVA = mntNeto * TasaIVA.
-  _calcularTotales(mntNeto, mntExento, esExenta) {
+  _calcularTotales(mntNeto, mntExento, esExenta, esBoleta = false, esBruto = false) {
+    // Boleta afecta con precios al consumidor (brutos): mntNeto contiene el total bruto (con IVA).
+    // MntNeto y IVA se derivan del bruto; MntTotal = bruto + exento = suma(MontoItem).
+    if (esBoleta && esBruto && !esExenta && mntNeto > 0) {
+      const bruto = mntNeto;
+      const neto  = Math.round(bruto / (1 + TASA_IVA / 100));
+      const iva   = bruto - neto;
+      const mntTotal = bruto + mntExento;
+      const totales = { MntNeto: neto };
+      if (mntExento > 0) totales.MntExe = mntExento;
+      totales.IVA      = iva;
+      totales.MntTotal = mntTotal;
+      return totales;
+    }
+
     const neto = esExenta ? 0 : mntNeto;
     const iva  = esExenta ? 0 : Math.round(neto * TASA_IVA / 100);
     const mntTotal = neto + iva + mntExento;
     
     const totales = {};
     if (neto > 0) totales.MntNeto = neto;
-    if (neto > 0) totales.TasaIVA = TASA_IVA;  // requerido en facturas
+    if (neto > 0 && !esBoleta) totales.TasaIVA = TASA_IVA;  // requerido en facturas, NO en boletas (EnvioBOLETA_v11.xsd no lo admite)
     if (mntExento > 0) totales.MntExe = mntExento;
     if (neto > 0) totales.IVA = iva;
     totales.MntTotal = mntTotal;

package/EnviadorSII.js

@@ -437,7 +437,7 @@ class EnviadorSII {
     formData.append('rutCompany', rutCompany.toString());
     formData.append('dvCompany', dvCompany.toUpperCase());
     
-    const xmlBuffer = Buffer.from(xml, 'utf-8');
+    const xmlBuffer = Buffer.from(xml, 'latin1');
     formData.append('archivo', xmlBuffer, {
       filename: 'EnvioBOLETA.xml',
       contentType: 'application/xml',
@@ -703,13 +703,20 @@ class EnviadorSII {
       else if (estado === 'RCH') mensaje = `[ERR] Rechazado: ${json.glosa || json.descripcion || 'Sin detalle'}`;
       else mensaje = `Estado: ${estado}`;
       
+      const esExitoso    = ['EPR', 'RPR', 'RLV'].includes(estado);
+      const esRechazado  = ['RPT', 'RFR', 'VOF', 'RCT', 'RCH', 'RSC'].includes(estado);
+      const esIntermedio = !esExitoso && !esRechazado;
+
       return {
         ok: true,
-        trackId: trackId,
-        estado: estado,
+        ...json,
+        trackId,
+        estado,
         descripcion: json.descripcion || json.glosa,
         mensaje,
-        ...json,
+        esExitoso,
+        esRechazado,
+        esIntermedio,
       };
     } catch (e) {
       return {
@@ -1343,24 +1350,34 @@ class EnviadorSII {
       99: 'Error desconocido',
     };
 
-    // STATUS 7 = Envío duplicado (para EnvioBOLETA/EnvioDTE).
-    // EXCEPCIÓN: CHR-00001 en <DETAIL> = error de charset, NO es duplicado.
+    // STATUS 7 = puede ser duplicado real, o error de schema/charset (NO duplicado).
     if (status === 7) {
       const detailMatch = responseText.match(/<ERROR>([^<]*)<\/ERROR>/i);
       const detailMsg = detailMatch ? detailMatch[1] : '';
+
+      // CHR-00001: error de charset en el XML (encoding incorrecto)
       if (detailMsg.includes('CHR-00001')) {
         return {
-          ok: false,
-          status,
+          ok: false, status,
           error: `Error de charset en XML enviado (${detailMsg}). Verifique encoding="ISO-8859-1" en la declaración XML.`,
-          respuesta: responseText,
-          duplicado: false,
+          respuesta: responseText, duplicado: false,
+        };
+      }
+
+      // SCH-00001: XML no cumple el esquema (ej: campo undefined, fecha inválida, esquema incorrecto)
+      if (detailMsg.includes('SCH-00001')) {
+        return {
+          ok: false, status,
+          error: `XML rechazado por SII: esquema inválido (${detailMsg}). El XML contiene campos malformados o la referencia de esquema no es reconocida.`,
+          respuesta: responseText, duplicado: false,
         };
       }
+
+      // Duplicado real: SII ya recibió este SetDTE ID
       if (trackId) {
         return { ok: true, status, trackId, archivo: fileName, mensaje: `[DUPLICADO] TrackID recuperado: ${trackId}`, respuesta: responseText };
       }
-      return { ok: false, status, error: errorMessages[7], respuesta: responseText, duplicado: true };
+      return { ok: false, status, error: `${errorMessages[7]}. Detail: ${detailMsg || 'sin detalle'}`, respuesta: responseText, duplicado: true };
     }
 
     return {

package/Envio.js

@@ -62,17 +62,21 @@ class EnvioBase {
   }
   
   /**
-   * Generar SetId con formato específico
+   * Generar SetId con formato específico.
+   * @param {string} prefix
+   * @param {string} [suffix] - Sufijo opcional (ej: ID de sobre) para garantizar unicidad entre sobres del mismo segundo.
    */
-  _generateSetId(prefix) {
+  _generateSetId(prefix, suffix) {
     const now = new Date();
-    const dd = String(now.getDate()).padStart(2, '0');
-    const mm = String(now.getMonth() + 1).padStart(2, '0');
+    const dd   = String(now.getDate()).padStart(2, '0');
+    const mm   = String(now.getMonth() + 1).padStart(2, '0');
     const yyyy = now.getFullYear();
-    const hh = String(now.getHours()).padStart(2, '0');
-    const min = String(now.getMinutes()).padStart(2, '0');
-    const ss = String(now.getSeconds()).padStart(2, '0');
-    return `${prefix}_${dd}_${mm}_${yyyy}_${hh}_${min}_${ss}`;
+    const hh   = String(now.getHours()).padStart(2, '0');
+    const min  = String(now.getMinutes()).padStart(2, '0');
+    const ss   = String(now.getSeconds()).padStart(2, '0');
+    const ms   = String(now.getMilliseconds()).padStart(3, '0');
+    const base = `${prefix}_${dd}_${mm}_${yyyy}_${hh}_${min}_${ss}_${ms}`;
+    return suffix ? `${base}_${suffix}` : base;
   }
   
   /**

package/FolioService.js

@@ -249,10 +249,14 @@ class FolioService {
     const debugDir = path.join(this.debugDir, 'auto-caf', 'anulacion', debugStamp);
     fs.mkdirSync(debugDir, { recursive: true });
 
-    // Asegurar sesión
-    this.session.reset();
+    // Asegurar sesión — sin reset() para reutilizar cookieJar cargado del caché
     const page = await this.session.ensureSession('/cvc_cgi/dte/af_anular1');
 
+    // Persistir sesión para reutilizar en llamadas posteriores (evita abrir sesiones SII extra)
+    if (this.sessionPath) {
+      try { this.session.saveSession(this.sessionPath); } catch (_) {}
+    }
+
     if (!page.body || !page.body.includes('ANULACION DE FOLIOS')) {
       fs.writeFileSync(path.join(debugDir, 'error.html'), page.body || '', 'utf8');
       throw new Error('No se pudo acceder a la página de anulación.');
@@ -264,17 +268,21 @@ class FolioService {
       ...hiddenInputs,
       RUT_EMP: rut,
       DV_EMP: dv,
+      PAGINA: '1',
       COD_DOCTO: String(tipoDte),
       ACEPTAR: 'Consultar',
     };
 
-    const consulta = await this.session.submitForm(
-      '/cvc_cgi/dte/af_anular2',
-      fields,
-      `https://${this.session.getBaseHost()}/cvc_cgi/dte/af_anular1`
+    const consulta = await this._withRetry('af_anular2', () =>
+      this.session.submitForm(
+        '/cvc_cgi/dte/af_anular2',
+        fields,
+        `https://${this.session.getBaseHost()}/cvc_cgi/dte/af_anular1`
+      )
     );
 
     let currentHtml = consulta.body || '';
+    try { fs.writeFileSync(path.join(debugDir, 'page-1.html'), currentHtml, 'utf8'); } catch (_) {}
     let info = this._parseAnulacionTable(currentHtml);
     let action = SiiSession.extractFormActionByName(currentHtml, 'frm') || '/cvc_cgi/dte/af_anular2';
     let hiddenInputsConsulta = SiiSession.extractInputValues(currentHtml);
@@ -291,10 +299,12 @@ class FolioService {
         nextFields.PAGINA = String(nextButton.page);
       }
       
-      const nextRes = await this.session.submitForm(
-        action,
-        nextFields,
-        `https://${this.session.getBaseHost()}/cvc_cgi/dte/af_anular2`
+      const nextRes = await this._withRetry(`af_anular2 pág ${nextButton.page || safety + 2}`, () =>
+        this.session.submitForm(
+          action,
+          nextFields,
+          `https://${this.session.getBaseHost()}/cvc_cgi/dte/af_anular2`
+        )
       );
 
       currentHtml = nextRes.body || '';
@@ -318,6 +328,7 @@ class FolioService {
       safety += 1;
     }
 
+    console.log(`[FolioService] consultarFolios tipoDte=${tipoDte}: ${info.ranges.length} rango(s) encontrado(s)`);
     return {
       ok: true,
       tipoDte,
@@ -330,110 +341,179 @@ class FolioService {
   }
 
   /**
-   * Anula folios en el SII
-   * @param {Object} params - Parámetros
-   * @returns {Promise<Object>}
+   * Anula folios en el SII usando el flujo bulk: af_anular3 → af_anular.
+   * Un request por rango CAF en lugar de un request por folio individual.
+   *
+   * @param {Object} params
+   * @param {number} params.tipoDte
+   * @param {number|null} [params.folioDesde]  - Si se omite, anula todos los rangos pendientes
+   * @param {number|null} [params.folioHasta]
+   * @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' }) {
-    const consulta = await this.consultarFolios({ tipoDte });
-    const anulados = [];
+    const debugStampA = new Date().toISOString().replace(/[:.]/g, '-');
+    const debugDirA = path.join(this.debugDir, 'auto-caf', 'anulacion', debugStampA);
+    fs.mkdirSync(debugDirA, { recursive: true });
+
+    const { rut, dv } = SiiSession.parseRut(this.rutEmisor);
+    const anulados   = [];
     const rechazados = [];
+    const vistos     = new Set(); // claves "folioDesde-folioHasta" ya procesadas en esta ejecución
 
-    // Calcular total de folios a anular para mostrar progreso
-    let totalFolios = 0;
-    if (Number.isFinite(folioDesde) && Number.isFinite(folioHasta)) {
-      totalFolios = folioHasta - folioDesde + 1;
-    } else {
-      for (const range of consulta.ranges) {
-        totalFolios += (range.folioHasta - range.folioDesde + 1);
-      }
-    }
-    let foliosAnulados = 0;
+    const maxPasadas = 4;
 
-    const anularFolioIndividual = async (folio) => {
-      let currentHtml = consulta.html;
+    for (let pasada = 0; pasada < maxPasadas; pasada++) {
+      const consulta = await this.consultarFolios({ tipoDte });
 
-      const range = consulta.ranges.find((r) => folio >= r.folioDesde && folio <= r.folioHasta);
-      
-      if (range && range.formFields && Object.keys(range.formFields).length) {
-        const selectRes = await this.session.submitForm(
-          range.formAction || consulta.action,
-          range.formFields,
-          `https://${this.session.getBaseHost()}/cvc_cgi/dte/af_anular1`
-        );
-        currentHtml = selectRes.body || currentHtml;
-      } else if (range && range.selection) {
-        const selectFields = {
-          ...consulta.hiddenInputs,
-          [range.selection.name]: range.selection.value || '',
-        };
-        const selectRes = await this.session.submitForm(
-          consulta.action,
-          selectFields,
-          `https://${this.session.getBaseHost()}/cvc_cgi/dte/af_anular1`
-        );
-        currentHtml = selectRes.body || currentHtml;
+      // 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 (rangos.length === 0) {
+        console.log(`[FolioService] Pasada ${pasada + 1}: sin rangos nuevos, finalizando`);
+        break;
       }
 
-      const action = SiiSession.extractFormAction(currentHtml) || consulta.action;
-      const fields = SiiSession.extractInputValues(currentHtml);
-      this._setFolioFields(fields, folio, folio);
-      this._setMotivoField(fields, motivo);
+      console.log(`[FolioService] Pasada ${pasada + 1}: ${rangos.length} rango(s) a procesar`);
+      const host = this.session.getBaseHost();
 
-      const resultRes = await this.session.submitForm(
-        action,
-        fields,
-        `https://${this.session.getBaseHost()}/cvc_cgi/dte/af_anular2`
-      );
+      for (const range of rangos) {
+        vistos.add(`${range.folioDesde}-${range.folioHasta}`);
+        const iniA = folioDesde != null ? Math.max(range.folioDesde, folioDesde) : range.folioDesde;
+        const finA = folioHasta != null ? Math.min(range.folioHasta, folioHasta) : range.folioHasta;
+        const count = finA - iniA + 1;
+        const { dia, mes, ano } = this._parseFecha(range.fecha);
 
-      // Guardar resultado para debug
-      try {
-        const debugDir = path.join(this.debugDir, 'auto-caf', 'anulacion', 'resultados');
-        fs.mkdirSync(debugDir, { recursive: true });
-        const stamp = new Date().toISOString().replace(/[:.]/g, '-');
-        fs.writeFileSync(path.join(debugDir, `sii-anulacion-result-${folio}-${stamp}.html`), resultRes.body || '', 'utf8');
-      } catch (_) {
-        // ignore
-      }
+        // Paso 1: af_anular3 — obtener el formulario con campos ocultos del SII
+        let body3;
+        try {
+          const r3 = await this._withRetry(`af_anular3 rango ${iniA}-${finA}`, () =>
+            this.session.submitForm(
+              '/cvc_cgi/dte/af_anular3',
+              {
+                RUT_EMP: rut, DV_EMP: dv,
+                DIA: dia, MES: mes, ANO: ano,
+                COD_DOCTO: String(tipoDte),
+                FOLIO_INI: String(range.folioDesde),
+                FOLIO_FIN: String(range.folioHasta),
+                CANT_DOCTOS: String(range.cantidad ?? (range.folioHasta - range.folioDesde + 1)),
+              },
+              `https://${host}/cvc_cgi/dte/af_anular2`
+            )
+          );
+          body3 = r3.body || '';
+        } catch (err) {
+          console.error(`[FolioService] af_anular3 falló rango ${iniA}-${finA}: ${err.message}`);
+          rechazados.push({ folioDesde: iniA, folioHasta: finA, count, reason: 'error-red' });
+          continue;
+        }
 
-      // Log de progreso
-      foliosAnulados += 1;
-      const pct = Math.round((foliosAnulados / totalFolios) * 100);
-      process.stdout.write(`\r Anulando folio ${folio} (${foliosAnulados}/${totalFolios} - ${pct}%)`);
+        if (body3.includes('ya ha sido efectuado') || body3.includes('ya fue anulado') ||
+            body3.includes('efectuado anteriormente')) {
+          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 (_) {}
+          continue;
+        }
+        try { fs.writeFileSync(path.join(debugDirA, `rango-${iniA}-${finA}-af_anular3.html`), body3, 'utf8'); } catch (_) {}
 
-      return { folio, ...this._parseAnulacionResult(resultRes.body || '') };
-    };
+        // Extraer campos ocultos del formulario devuelto por SII
+        const formFields = SiiSession.extractInputValues(body3);
+        formFields.FOLIO_INI_A = String(iniA);
+        formFields.FOLIO_FIN_A = String(finA);
+        formFields.MOTIVO = motivo;
 
-    // Anular rango específico o todos
-    if (Number.isFinite(folioDesde) && Number.isFinite(folioHasta)) {
-      for (let folio = folioDesde; folio <= folioHasta; folio += 1) {
-        const result = await anularFolioIndividual(folio);
-        if (result.ok) {
-          anulados.push(result);
-        } else if (result.ok === false) {
-          rechazados.push(result);
+        // Paso 2: af_anular — intentar anulación bulk del rango completo
+        let bodyBulk;
+        try {
+          const rBulk = await this._withRetry(`af_anular bulk ${iniA}-${finA}`, () =>
+            this.session.submitForm('/cvc_cgi/dte/af_anular', formFields, `https://${host}/cvc_cgi/dte/af_anular3`)
+          );
+          bodyBulk = rBulk.body || '';
+        } catch (err) {
+          console.error(`[FolioService] af_anular bulk falló rango ${iniA}-${finA}: ${err.message}`);
+          rechazados.push({ folioDesde: iniA, folioHasta: finA, count, reason: 'error-red' });
+          continue;
         }
-      }
-    } else {
-      // Anular todos los rangos
-      for (const range of consulta.ranges) {
-        for (let folio = range.folioDesde; folio <= range.folioHasta; folio += 1) {
-          const result = await anularFolioIndividual(folio);
-          if (result.ok) {
-            anulados.push(result);
-          } else if (result.ok === false) {
-            rechazados.push(result);
+
+        const exitoBulk = bodyBulk.includes('ha autorizado la anulaci') ||
+                          bodyBulk.includes('SOLICITUD ANULACION DE FOLIOS');
+        if (exitoBulk) {
+          anulados.push({ folioDesde: iniA, folioHasta: finA, count });
+          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;
+        }
+
+        try { fs.writeFileSync(path.join(debugDirA, `rango-${iniA}-${finA}-af_anular-fail.html`), bodyBulk, 'utf8'); } catch (_) {}
+        console.warn(`[FolioService] bulk falló rango ${iniA}-${finA}: ${bodyBulk.slice(0, 300).replace(/\s+/g, ' ')}`);
+
+        const yaConflicto = bodyBulk.includes('ya ha sido efectuado') ||
+                            bodyBulk.includes('ya fue anulado') ||
+                            bodyBulk.includes('efectuado anteriormente') ||
+                            bodyBulk.includes('recepcionad');
+        if (!yaConflicto) {
+          const razon = this._parseAnulacionResult(bodyBulk).reason || 'error';
+          rechazados.push({ folioDesde: iniA, folioHasta: finA, count, reason: razon });
+          console.warn(`[FolioService] ✗ Rango ${iniA}-${finA} rechazado: ${razon}`);
+          continue;
+        }
+
+        // Fallback: algunos folios del rango ya fueron anulados/receptados.
+        // Reutilizar la sesión de af_anular3 y anular folio a folio.
+        console.log(`[FolioService] Rango ${iniA}-${finA}: conflicto bulk, fallback folio-a-folio...`);
+        let i = 0;
+        for (let folio = iniA; folio <= finA; folio++) {
+          i++;
+          process.stdout.write(`\r[FolioService] ${iniA}-${finA}: folio ${folio} (${i}/${count})  `);
+          const singleFields = { ...formFields, FOLIO_INI_A: String(folio), FOLIO_FIN_A: String(folio) };
+          let bs;
+          try {
+            const rSingle = await this._withRetry(`af_anular folio ${folio}`, () =>
+              this.session.submitForm('/cvc_cgi/dte/af_anular', singleFields, `https://${host}/cvc_cgi/dte/af_anular3`)
+            );
+            bs = rSingle.body || '';
+          } catch (err) {
+            rechazados.push({ folioDesde: folio, folioHasta: folio, count: 1, reason: 'error-red' });
+            continue;
+          }
+          const ok = bs.includes('ha autorizado la anulaci') || bs.includes('SOLICITUD ANULACION DE FOLIOS');
+          if (ok) {
+            anulados.push({ folioDesde: folio, folioHasta: folio, count: 1 });
+          } else {
+            const razon = this._parseAnulacionResult(bs).reason || 'error';
+            rechazados.push({ folioDesde: folio, folioHasta: folio, count: 1, reason: razon });
           }
         }
+        console.log('');
       }
-    }
 
-    // Nueva línea después del progreso
-    if (totalFolios > 0) {
-      console.log('');
+      // Pausa breve entre pasadas para no saturar el SII
+      if (pasada < maxPasadas - 1) await this._sleep(1500);
     }
 
-    return { ok: true, anulados, rechazados };
+    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`);
+
+    return { ok: true, anulados, rechazados, totalAnulados, totalRechazados };
+  }
+
+  /**
+   * Parsea una fecha "DD-MM-YYYY" o "DD/MM/YYYY" en sus componentes.
+   * @private
+   */
+  _parseFecha(fecha) {
+    const clean = String(fecha || '').replace(/[\s ]/g, '').trim();
+    const m = clean.match(/^(\d{1,2})[-\/](\d{1,2})[-\/](\d{4})$/);
+    if (m) return { dia: m[1].padStart(2, '0'), mes: m[2].padStart(2, '0'), ano: m[3] };
+    // Si no tiene fecha válida, dejar vacío (el SII puede no requerirla siempre)
+    return { dia: '', mes: '', ano: '' };
   }
 
   /**
@@ -547,6 +627,15 @@ class FolioService {
    * @private
    */
   _parseAnulacionTable(html) {
+    // Primario: extraer desde formularios (no depende de posición de columnas, más robusto
+    // ante tablas anidadas que cortan el regex de filas)
+    const formRanges = this._extractRangesFromForms(html);
+    if (formRanges.length > 0) {
+      const ultimoFolioFinal = formRanges.reduce((acc, r) => r.folioHasta > acc ? r.folioHasta : acc, 0);
+      return { ranges: formRanges, ultimoFolioFinal: ultimoFolioFinal || null };
+    }
+
+    // Fallback: parsing por columnas de tabla (backup si no hay forms con FOLIO_INI/FOLIO_FIN)
     const rows = html.match(/<tr[^>]*>[\s\S]*?<\/tr>/gi) || [];
     const ranges = [];
 
@@ -588,6 +677,53 @@ class FolioService {
     return { ranges, ultimoFolioFinal: ultimoFolioFinal || null };
   }
 
+  /**
+   * Extrae rangos de folios directamente de los <form> de la página af_anular2.
+   * Cada fila de la tabla tiene un form con inputs ocultos FOLIO_INI, FOLIO_FIN,
+   * CANT_DOCTOS, DIA, MES, ANO. Este método es más confiable que parsear columnas
+   * porque no se ve afectado por tablas anidadas ni por variaciones en el orden de columnas.
+   * @private
+   */
+  _extractRangesFromForms(html) {
+    const ranges = [];
+    const formRegex = /<form[^>]*>[\s\S]*?<\/form>/gi;
+    const forms = String(html || '').match(formRegex) || [];
+
+    forms.forEach(formHtml => {
+      const fields = SiiSession.extractInputValues(formHtml);
+      const folioDesde = SiiSession.parseIntFromText(fields.FOLIO_INI);
+      const folioHasta = SiiSession.parseIntFromText(fields.FOLIO_FIN);
+      if (!Number.isFinite(folioDesde) || !Number.isFinite(folioHasta)) return;
+
+      const cantidadRaw = SiiSession.parseIntFromText(fields.CANT_DOCTOS);
+      const cantidad = Number.isFinite(cantidadRaw) ? cantidadRaw : (folioHasta - folioDesde + 1);
+      const dia = String(fields.DIA || '').padStart(2, '0');
+      const mes = String(fields.MES || '').padStart(2, '0');
+      const ano = fields.ANO || '';
+      const fecha = (dia !== '00' && mes !== '00' && ano) ? `${dia}-${mes}-${ano}` : null;
+
+      ranges.push({
+        fecha,
+        cantidad,
+        folioDesde,
+        folioHasta,
+        efectuadoPor: null,
+        selection: null,
+        formFields: fields,
+        formAction: SiiSession.extractFormAction(formHtml) || '',
+      });
+    });
+
+    // Deduplicar por folioDesde+folioHasta (el SII puede repetir el mismo form)
+    const seen = new Set();
+    return ranges.filter(r => {
+      const key = `${r.folioDesde}-${r.folioHasta}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
   /**
    * @private
    */
@@ -675,6 +811,7 @@ class FolioService {
     if (
       text.includes('ya fue anulado') ||
       text.includes('anulado anteriormente') ||
+      text.includes('ya ha sido efectuado anteriormente') ||
       (text.includes('anulad') && text.includes('ya'))
     ) {
       return { ok: false, reason: 'ya-anulado' };
@@ -695,9 +832,41 @@ class FolioService {
     if (text.includes('anulaci') && text.includes('no')) {
       return { ok: false, reason: 'rechazado' };
     }
+
+    if (text.trim() === 'error 500' || text.includes('error 500') || text.includes('internal server error')) {
+      return { ok: false, reason: 'error-sii-500' };
+    }
     
     return { ok: null, reason: 'desconocido' };
   }
+
+  /**
+   * Reintenta una función async ante errores de red.
+   * No reintenta en errores de lógica (respuestas HTML del SII con error).
+   * @private
+   */
+  async _withRetry(label, fn) {
+    const retries = this.config.retries ?? 2;
+    const delayMs = this.config.retryDelayMs ?? 1500;
+    let lastErr;
+    for (let i = 0; i <= retries; i++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastErr = err;
+        if (i < retries) {
+          console.warn(`[FolioService] ${label}: error "${err.message}", reintentando (${i + 1}/${retries})...`);
+          await this._sleep(delayMs);
+        }
+      }
+    }
+    throw lastErr;
+  }
+
+  /** @private */
+  _sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+  }
 }
 
 module.exports = FolioService;

package/SiiSession.js

@@ -264,6 +264,76 @@ class SiiSession {
     return { success: true, response: redirected.response };
   }
 
+  /**
+   * Cierra la sesión activa en el SII para liberar el cupo de sesiones.
+   * Es seguro llamar aunque no haya sesión activa.
+   */
+  async logout() {
+    if (!this.cookieJar) return;
+    // El SII usa estos endpoints según el tipo de autenticación.
+    // Intentamos ambos; ignoramos errores.
+    const logoutUrls = [
+      `https://${this.baseHost}/cgi_AUT2000/autLogout.cgi`,
+      'https://www.sii.cl/AUT2000/autLogout.cgi',
+      'https://herculesr.sii.cl/cgi_AUT2000/autLogout.cgi',
+    ];
+    for (const url of logoutUrls) {
+      try {
+        await this.request(url, { method: 'GET' });
+      } catch (_) {}
+    }
+    this.cookieJar = '';
+  }
+
+  /**
+   * Detecta la página de "demasiadas sesiones" y, si el SII ofrece un form
+   * para cerrar las sesiones anteriores, lo envía automáticamente.
+   * Devuelve true si se envió el form de cierre (hay que reintentar la sesión).
+   * @private
+   */
+  async _tryForceCloseSessions(body) {
+    if (!body || !body.includes('superado el m')) return false;
+
+    // Guardar HTML para diagnóstico
+    try {
+      const fs = require('fs');
+      const path = require('path');
+      const dbgDir = path.resolve(__dirname, '..', 'devlas-cloud-api-node', 'debug', 'sii-sessions');
+      fs.mkdirSync(dbgDir, { recursive: true });
+      fs.writeFileSync(path.join(dbgDir, `demasiadas-sesiones-${Date.now()}.html`), body, 'utf-8');
+    } catch (_) {}
+
+    // El SII a veces incluye un form o link para cerrar sesiones anteriores
+    // Buscamos: action con "CierraAnt", "cerrar", "logout" o "Anular"
+    const formActionMatch = body.match(/<form[^>]+action=["']([^"']*(?:CierraAnt|cerrar|Logout|anular)[^"']*)/i);
+    if (formActionMatch) {
+      const closeUrl = formActionMatch[1];
+      const inputs = SiiSession.extractInputValues(body);
+      console.warn(`[SiiSession] Detectadas demasiadas sesiones — cerrando sesiones anteriores en ${closeUrl}...`);
+      try {
+        await this.submitForm(closeUrl, { ...inputs, ACEPTAR: 'Aceptar' });
+        return true;
+      } catch (e) {
+        console.warn(`[SiiSession] No se pudo cerrar sesiones anteriores: ${e.message}`);
+      }
+    }
+
+    // Alternativa: link directo (href) a CierraAnt o similar
+    const linkMatch = body.match(/href=["']([^"']*CierraAnt[^"']*)/i);
+    if (linkMatch) {
+      const closeUrl = new URL(linkMatch[1], `https://${this.baseHost}`).toString();
+      console.warn(`[SiiSession] Cerrando sesiones anteriores via GET ${closeUrl}...`);
+      try {
+        await this.request(closeUrl, { method: 'GET' });
+        return true;
+      } catch (e) {
+        console.warn(`[SiiSession] No se pudo cerrar sesiones anteriores: ${e.message}`);
+      }
+    }
+
+    return false;
+  }
+
   /**
    * Asegura una sesión autenticada para acceder a una página
    * @param {string} targetPath - Ruta del recurso
@@ -278,9 +348,25 @@ class SiiSession {
 
     // Detectar bloqueo por demasiadas sesiones
     if (response.body && response.body.includes('superado el m')) {
-      const errorMsg = 'SII: Demasiadas sesiones abiertas. Espera ~30 min o cierra sesión manualmente en el portal SII.';
-      console.error(`\n[ERR] ${errorMsg}\n`);
-      throw new Error(errorMsg);
+      // Intentar cerrar sesiones anteriores automáticamente si el SII lo ofrece
+      const closed = await this._tryForceCloseSessions(response.body);
+      if (closed) {
+        // Reintentar la sesión después de cerrar las anteriores
+        console.warn('[SiiSession] Sesiones anteriores cerradas — reintentando autenticación...');
+        response = await this.request(targetUrl, { method: 'GET' });
+        const redirected2 = await this.followRedirects(response);
+        response = redirected2.response;
+        // Si sigue con demasiadas sesiones, lanzar error
+        if (response.body && response.body.includes('superado el m')) {
+          const errorMsg = 'SII: Demasiadas sesiones abiertas. Espera ~30 min o cierra sesión manualmente en el portal SII.';
+          console.error(`\n[ERR] ${errorMsg}\n`);
+          throw new Error(errorMsg);
+        }
+      } else {
+        const errorMsg = 'SII: Demasiadas sesiones abiertas. Espera ~30 min o cierra sesión manualmente en el portal SII.';
+        console.error(`\n[ERR] ${errorMsg}\n`);
+        throw new Error(errorMsg);
+      }
     }
 
     // Si requiere autenticación
@@ -291,9 +377,23 @@ class SiiSession {
         
         // Verificar si el login resultó en bloqueo por sesiones
         if (response.body && response.body.includes('superado el m')) {
-          const errorMsg = 'SII: Demasiadas sesiones abiertas. Espera ~30 min o cierra sesión manualmente en el portal SII.';
-          console.error(`\n[ERR] ${errorMsg}\n`);
-          throw new Error(errorMsg);
+          // Intentar cerrar sesiones anteriores automáticamente
+          const closed = await this._tryForceCloseSessions(response.body);
+          if (closed) {
+            console.warn('[SiiSession] Sesiones anteriores cerradas post-login — reintentando...');
+            const retry = await this.request(targetUrl, { method: 'GET' });
+            const redirected3 = await this.followRedirects(retry);
+            response = redirected3.response;
+            if (response.body && response.body.includes('superado el m')) {
+              const errorMsg = 'SII: Demasiadas sesiones abiertas. Espera ~30 min o cierra sesión manualmente en el portal SII.';
+              console.error(`\n[ERR] ${errorMsg}\n`);
+              throw new Error(errorMsg);
+            }
+          } else {
+            const errorMsg = 'SII: Demasiadas sesiones abiertas. Espera ~30 min o cierra sesión manualmente en el portal SII.';
+            console.error(`\n[ERR] ${errorMsg}\n`);
+            throw new Error(errorMsg);
+          }
         }
       }
     }

package/package.json

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