@devlas/dte-sii 2.9.8 → 2.11.0

package/cert/MuestrasImpresas.js

@@ -20,7 +20,6 @@ const fs = require('fs');
 const path = require('path');
 const { XMLParser, XMLBuilder } = require('fast-xml-parser');
 const bwipjs = require('bwip-js');
-const { launchBrowser } = require('../utils/browser');
 
 // Usar constantes del core
 const {
@@ -52,6 +51,89 @@ const formatMonto = (value) => {
   return Number(value).toLocaleString('es-CL');
 };
 
+// ═══════════════════════════════════════════════════════════════
+// Constantes de layout PDF (SII Manual Muestras Impresas v3.0)
+// 1 cm = 28.3465 puntos tipográficos (pt)
+// ═══════════════════════════════════════════════════════════════
+
+const PDF_LAYOUT = {
+  page: {
+    width:     609.45,   // 21.5 cm — ancho estándar hoja SII
+    minHeight: 311.81,   // 11.0 cm — mínimo SII
+    maxHeight: 935.43,   // 33.0 cm — máximo SII
+  },
+  margin:      14.17,    // 0.5 cm mínimo SII en todos los bordes
+
+  gap: {
+    section:   10,
+    line:      13,
+    small:      6,
+    tiny:       4,
+  },
+
+  recuadro: {
+    width:     155.91,   // 5.5 cm — mínimo SII
+    minHeight:  42.52,   // 1.5 cm — mínimo SII
+    maxHeight: 113.39,   // 4.0 cm — máximo SII
+    border:     1.5,     // 0.5–1 mm según SII; usamos valor medio
+    padX:       8,
+    padY:       6,
+  },
+
+  ted: {
+    minWidth:  141.73,   // 5.0 cm — mínimo SII
+    minHeight:  56.69,   // 2.0 cm — mínimo SII
+    maxWidth:  255.12,   // 9.0 cm — máximo SII
+    maxHeight: 113.39,   // 4.0 cm — máximo SII
+    marginLeft: 56.69,   // 2.0 cm desde borde izquierdo (mínimo SII)
+    legendGap:   5,
+  },
+
+  font: {
+    razonSocial: 11,
+    normal:      10,
+    small:        9,
+    tiny:         8,
+    legal:        7,
+    legend:       7,
+  },
+
+  lineH: {
+    normal: 13,
+    small:  11,
+    tiny:   10,
+    legal:   9,
+  },
+
+  table: {
+    rowH:    12,
+    headerH: 14,
+    padX:     3,
+    padY:     2,
+  },
+
+  acuse: {
+    padX:     8,
+    padY:     8,
+    fieldH:  14,
+  },
+};
+
+/**
+ * Formatea RUT con separador de miles '.' según convención chilena SII.
+ * Ej: "12345678-9" → "12.345.678-9"
+ */
+function _formatRutConPuntos(rut) {
+  if (!rut) return '';
+  const str = String(rut).trim().replace(/\./g, '');
+  const idx  = str.lastIndexOf('-');
+  if (idx === -1) return str;
+  const num  = str.slice(0, idx);
+  const dv   = str.slice(idx + 1);
+  const formatted = num.replace(/\B(?=(\d{3})+(?!\d))/g, '.');
+  return `${formatted}-${dv}`;
+}
+
 class MuestrasImpresas {
   /**
    * @param {Object} options
@@ -488,45 +570,721 @@ class MuestrasImpresas {
    * Genera PDF desde HTML y lo escribe a disco.
    * @private
    */
-  async _generarPdf({ html, outputPath, browser }) {
-    const page = await browser.newPage();
-    await page.setContent(html, { waitUntil: 'networkidle0' });
-    await page.pdf({
-      path: outputPath,
-      printBackground: true,
-      width: '215mm',
-      height: '280mm',
-      margin: { top: '5mm', right: '5mm', bottom: '5mm', left: '5mm' },
+  // ═══════════════════════════════════════════════════════════════
+  // Helpers internos para generarPDFBuffer (pdf-lib, sin Chromium)
+  // ═══════════════════════════════════════════════════════════════
+
+  /** Parte texto en líneas que caben dentro de maxWidth usando la fuente dada. */
+  _pdfWrapText(text, font, fontSize, maxWidth) {
+    const str = String(text || '').trim();
+    if (!str) return [''];
+    const words  = str.split(' ');
+    const lines  = [];
+    let   line   = '';
+    for (const word of words) {
+      const test = line ? `${line} ${word}` : word;
+      if (font.widthOfTextAtSize(test, fontSize) <= maxWidth) {
+        line = test;
+      } else {
+        if (line) lines.push(line);
+        // Palabra sola más larga que maxWidth: dividir por caracteres
+        if (font.widthOfTextAtSize(word, fontSize) > maxWidth) {
+          let chars = '';
+          for (const ch of word) {
+            if (font.widthOfTextAtSize(chars + ch, fontSize) <= maxWidth) {
+              chars += ch;
+            } else {
+              if (chars) lines.push(chars);
+              chars = ch;
+            }
+          }
+          line = chars;
+        } else {
+          line = word;
+        }
+      }
+    }
+    if (line) lines.push(line);
+    return lines.length ? lines : [''];
+  }
+
+  /** Dibuja texto en coordenadas desde el tope de la página. */
+  _pdfText(page, text, x, yFromTop, H, font, size, color) {
+    const y = H - yFromTop - size;
+    if (y < -size || y > H + size) return; // fuera de página
+    page.drawText(String(text || ''), { x: Math.round(x), y: Math.round(y), font, size, color });
+  }
+
+  /** Dibuja texto centrado horizontalmente dentro de [x, x+width]. */
+  _pdfTextCentered(page, text, x, width, yFromTop, H, font, size, color) {
+    const str  = String(text || '');
+    const textW = font.widthOfTextAtSize(str, size);
+    this._pdfText(page, str, x + Math.max(0, (width - textW) / 2), yFromTop, H, font, size, color);
+  }
+
+  /** Dibuja un rectángulo (borde, relleno o ambos). */
+  _pdfRect(page, x, yFromTop, width, height, H, opts = {}) {
+    const drawOpts = {
+      x:      Math.round(x),
+      y:      Math.round(H - yFromTop - height),
+      width:  Math.round(width),
+      height: Math.round(height),
+    };
+    if (opts.fill)   drawOpts.color       = opts.fill;
+    if (opts.stroke) { drawOpts.borderColor = opts.stroke; drawOpts.borderWidth = opts.strokeWidth || 0.5; }
+    page.drawRectangle(drawOpts);
+  }
+
+  /** Dibuja una línea horizontal. */
+  _pdfHLine(page, x1, x2, yFromTop, H, opts = {}) {
+    page.drawLine({
+      start: { x: Math.round(x1), y: Math.round(H - yFromTop) },
+      end:   { x: Math.round(x2), y: Math.round(H - yFromTop) },
+      thickness: opts.thickness || 0.5,
+      color: opts.color,
     });
-    await page.close();
   }
 
   /**
-   * Genera un PDF desde HTML y devuelve el contenido como Buffer (sin escribir a disco).
-   * Útil para servir el PDF directamente desde una respuesta HTTP.
-   *
-   * @param {string} html - HTML a convertir a PDF
-   * @param {object} [opts]
-   * @param {string} [opts.width='215mm']
-   * @param {string} [opts.height='280mm']
-   * @returns {Promise<Buffer>}
+   * Genera el PNG del TED como Buffer (no data URI) para embeber en pdf-lib.
+   * Preserva el encoding latin1/binarytext que garantiza validez de firma SII.
    */
-  async generarPdfBuffer(html, opts = {}) {
-    const browser = await launchBrowser();
+  async _generarTedPngBuffer(tedXml) {
+    if (!tedXml || !tedXml.includes('<TED')) {
+      throw new Error('[MuestrasImpresas] _generarTedPngBuffer: TED XML inválido');
+    }
+    const latin1Buffer = Buffer.from(tedXml, 'latin1');
+    const binaryString = latin1Buffer.toString('binary');
+    return bwipjs.toBuffer({
+      bcid:        'pdf417',
+      text:        binaryString,
+      scale:       3,
+      height:      10,
+      padding:     6,
+      includetext: false,
+      binarytext:  true,
+    });
+  }
+
+  /** Retorna true si la guía de despacho es de traslado interno (sin cedible). */
+  _esGuiaInterna(doc) {
+    return doc.tipoDte === 52 && [5, 6].includes(doc.indTraslado);
+  }
+
+  /** Retorna true si el documento debe incluir acuse de recibo. */
+  _pdfNecesitaAcuse(doc, cedible) {
+    if (!cedible) return false;
+    if (NO_CEDIBLE_TIPOS.has(doc.tipoDte)) return false;
+    if (!CEDIBLE_TIPOS.has(doc.tipoDte))   return false;
+    if (this._esGuiaInterna(doc))          return false;
+    return true;
+  }
+
+  /** Carga logo como imagen pdf-lib (PNG o JPG). Retorna null si no hay logo. */
+  async _pdfLoadLogo(pdfDoc) {
+    if (!this.logoDataUri) return null;
     try {
-      const page = await browser.newPage();
-      await page.setContent(html, { waitUntil: 'networkidle0' });
-      const pdfBuffer = await page.pdf({
-        printBackground: true,
-        width: opts.width ?? '215mm',
-        height: opts.height ?? '280mm',
-        margin: { top: '10mm', right: '10mm', bottom: '10mm', left: '10mm' },
-      });
-      await page.close();
-      return Buffer.from(pdfBuffer);
-    } finally {
-      await browser.close();
+      const match = this.logoDataUri.match(/^data:image\/(png|jpe?g);base64,(.+)$/i);
+      if (!match) return null;
+      const buf = Buffer.from(match[2], 'base64');
+      return /jpe?g/i.test(match[1]) ? await pdfDoc.embedJpg(buf) : await pdfDoc.embedPng(buf);
+    } catch {
+      return null;
+    }
+  }
+
+  // ── Cálculos de altura (fase 1: sin dibujar) ─────────────────
+
+  _pdfCalcRecuadroHeight(doc, fonts) {
+    const innerW    = PDF_LAYOUT.recuadro.width - PDF_LAYOUT.recuadro.padX * 2;
+    const tipoLines = this._pdfWrapText(
+      NOMBRES_DTE_IMPRESOS[doc.tipoDte] || `DTE ${doc.tipoDte}`,
+      fonts.bold, PDF_LAYOUT.font.normal, innerW
+    );
+    const content =
+      PDF_LAYOUT.recuadro.padY +
+      PDF_LAYOUT.lineH.small +                          // RUT
+      PDF_LAYOUT.gap.tiny +
+      tipoLines.length * PDF_LAYOUT.lineH.small +       // tipo DTE (puede ser multilinea)
+      PDF_LAYOUT.gap.tiny +
+      PDF_LAYOUT.lineH.small +                          // folio
+      PDF_LAYOUT.recuadro.padY;
+    return Math.min(PDF_LAYOUT.recuadro.maxHeight, Math.max(PDF_LAYOUT.recuadro.minHeight, content));
+  }
+
+  _pdfCalcHeaderHeight(doc, fonts, logoImage) {
+    let leftH = 0;
+    if (logoImage) leftH += 25 + PDF_LAYOUT.gap.small;
+    leftH += PDF_LAYOUT.lineH.normal;   // razón social
+    leftH += PDF_LAYOUT.lineH.small;    // giro
+    leftH += PDF_LAYOUT.lineH.small;    // dirección
+    if (doc.emisor && doc.emisor.Sucursal) leftH += PDF_LAYOUT.lineH.small;
+
+    const recuadroH = this._pdfCalcRecuadroHeight(doc, fonts);
+    const rightH    = recuadroH + PDF_LAYOUT.gap.small + PDF_LAYOUT.lineH.small; // recuadro + oficina SII
+    return Math.max(leftH, rightH);
+  }
+
+  _pdfCalcReceptorHeight() {
+    return PDF_LAYOUT.acuse.padY * 2 + PDF_LAYOUT.lineH.small * 3 + PDF_LAYOUT.gap.tiny * 2;
+  }
+
+  _pdfCalcReferencesHeight(doc) {
+    if (!doc.referencias || !doc.referencias.length) return 0;
+    return (
+      PDF_LAYOUT.lineH.normal + PDF_LAYOUT.gap.small +
+      PDF_LAYOUT.table.headerH +
+      doc.referencias.length * PDF_LAYOUT.table.rowH +
+      PDF_LAYOUT.gap.section
+    );
+  }
+
+  _pdfCalcDetalleHeight(doc, fonts, W, M) {
+    const tableW = W - 2 * M;
+    const descW  = Math.round(tableW * 0.37) - PDF_LAYOUT.table.padX * 2;
+    let   rowsH  = 0;
+    for (const item of (doc.detalle || [])) {
+      const lines  = this._pdfWrapText(safeText(item && item.NmbItem || ''), fonts.normal, PDF_LAYOUT.font.tiny, descW);
+      const hasDcto = !!(item && (item.DescuentoMonto || item.DescuentoPct));
+      rowsH += Math.max(
+        PDF_LAYOUT.table.rowH,
+        lines.length * PDF_LAYOUT.lineH.tiny + PDF_LAYOUT.table.padY * 2 + (hasDcto ? PDF_LAYOUT.lineH.tiny : 0)
+      );
+    }
+    return PDF_LAYOUT.lineH.normal + PDF_LAYOUT.gap.small + PDF_LAYOUT.table.headerH + rowsH;
+  }
+
+  _pdfCalcTotalesHeight(doc) {
+    const { totales = {}, descuentosGlobales = [], tipoDte } = doc;
+    let rows = 0;
+    if (tipoDte === 34) {
+      if (totales.MntExe)   rows++;
+      if (totales.MntTotal) rows++;
+    } else {
+      rows += (descuentosGlobales || []).length;
+      if (totales.MntNeto)  rows++;
+      if (totales.MntExe)   rows++;
+      if (totales.IVA)      rows++;
+      if (totales.MntTotal) rows++;
+    }
+    return rows * (PDF_LAYOUT.table.rowH + 2) + 8;
+  }
+
+  _pdfCalcAcuseHeight(leyendaLines) {
+    const fieldsH  = PDF_LAYOUT.acuse.fieldH * 4 + PDF_LAYOUT.gap.small * 3;
+    const leyendaH = (leyendaLines || 3) * PDF_LAYOUT.lineH.legal;
+    return PDF_LAYOUT.acuse.padY * 2 + fieldsH + PDF_LAYOUT.gap.small + leyendaH + PDF_LAYOUT.gap.small;
+  }
+
+  // ── Renderizadores de sección (fase 2: dibujar) ───────────────
+
+  _pdfRenderHeader(page, doc, fonts, logoImage, y, H, W, M, rgb) {
+    const recuadroW = PDF_LAYOUT.recuadro.width;
+    const recuadroH = this._pdfCalcRecuadroHeight(doc, fonts);
+    const recuadroX = W - M - recuadroW;
+    const emisor    = doc.emisor || {};
+    const BLACK     = rgb(0, 0, 0);
+    const RED       = rgb(0.75, 0, 0);
+
+    // ── Columna izquierda: logo + datos emisor ──────────────────
+    let lx = M;
+    let ly = y;
+
+    if (logoImage) {
+      // Resolver Promise si fue retornada como tal
+      const img = logoImage;
+      const maxW = Math.min((recuadroX - M - PDF_LAYOUT.gap.section) * 0.4, 120);
+      const maxLogoH = 25;
+      const scale    = Math.min(maxW / img.width, maxLogoH / img.height);
+      const lw = img.width * scale;
+      const lh = img.height * scale;
+      page.drawImage(img, { x: lx, y: H - ly - lh, width: lw, height: lh });
+      ly += lh + PDF_LAYOUT.gap.small;
+    }
+
+    this._pdfText(page, safeText(emisor.RznSoc || emisor.RznSocEmisor || ''), lx, ly, H, fonts.bold, PDF_LAYOUT.font.razonSocial, BLACK);
+    ly += PDF_LAYOUT.lineH.normal;
+    this._pdfText(page, safeText(emisor.GiroEmis || ''), lx, ly, H, fonts.normal, PDF_LAYOUT.font.small, BLACK);
+    ly += PDF_LAYOUT.lineH.small;
+    const dir = `Casa Matriz: ${safeText(emisor.DirOrigen || '')}${emisor.CmnaOrigen ? ', ' + safeText(emisor.CmnaOrigen) : ''}`;
+    this._pdfText(page, dir, lx, ly, H, fonts.normal, PDF_LAYOUT.font.small, BLACK);
+    ly += PDF_LAYOUT.lineH.small;
+    if (emisor.Sucursal) {
+      this._pdfText(page, `Sucursal: ${safeText(emisor.Sucursal)}`, lx, ly, H, fonts.normal, PDF_LAYOUT.font.small, BLACK);
+    }
+
+    // ── Columna derecha: recuadro SII ───────────────────────────
+    this._pdfRect(page, recuadroX, y, recuadroW, recuadroH, H, { stroke: RED, strokeWidth: PDF_LAYOUT.recuadro.border });
+
+    const innerW     = recuadroW - PDF_LAYOUT.recuadro.padX * 2;
+    let   ry         = y + PDF_LAYOUT.recuadro.padY;
+
+    // RUT emisor
+    const rutText    = `R.U.T.: ${_formatRutConPuntos(safeText(emisor.RUTEmisor || ''))}`;
+    this._pdfTextCentered(page, rutText, recuadroX, recuadroW, ry, H, fonts.bold, PDF_LAYOUT.font.small, RED);
+    ry += PDF_LAYOUT.lineH.small + PDF_LAYOUT.gap.tiny;
+
+    // Tipo DTE (puede ocupar 2 líneas)
+    const tipoNombre = NOMBRES_DTE_IMPRESOS[doc.tipoDte] || `DTE ${doc.tipoDte}`;
+    const tipoLines  = this._pdfWrapText(tipoNombre, fonts.bold, PDF_LAYOUT.font.normal, innerW);
+    for (const line of tipoLines) {
+      this._pdfTextCentered(page, line, recuadroX, recuadroW, ry, H, fonts.bold, PDF_LAYOUT.font.normal, RED);
+      ry += PDF_LAYOUT.lineH.small;
+    }
+    ry += PDF_LAYOUT.gap.tiny;
+
+    // Folio
+    this._pdfTextCentered(page, `N° ${safeText(doc.folio)}`, recuadroX, recuadroW, ry, H, fonts.bold, PDF_LAYOUT.font.small, RED);
+
+    // Oficina SII bajo el recuadro
+    this._pdfTextCentered(
+      page, this.siiOficina,
+      recuadroX, recuadroW,
+      y + recuadroH + PDF_LAYOUT.gap.small,
+      H, fonts.normal, PDF_LAYOUT.font.tiny, BLACK
+    );
+
+    const headerBottom = Math.max(ly, y + recuadroH + PDF_LAYOUT.gap.small + PDF_LAYOUT.lineH.small);
+    return headerBottom;
+  }
+
+  _pdfRenderFecha(page, doc, fonts, y, H, M, rgb) {
+    this._pdfText(page, `Fecha Emisión: ${safeText(doc.fechaEmision)}`, M, y, H, fonts.bold, PDF_LAYOUT.font.normal, rgb(0,0,0));
+    return y + PDF_LAYOUT.lineH.normal;
+  }
+
+  _pdfRenderReceptor(page, doc, fonts, y, H, W, M, rgb) {
+    const receptor = doc.receptor || {};
+    const boxH     = this._pdfCalcReceptorHeight();
+    const boxW     = W - 2 * M;
+    const BLACK    = rgb(0,0,0);
+    const GRAY     = rgb(0.5, 0.5, 0.5);
+    const fs       = PDF_LAYOUT.font.small;
+    const lh       = PDF_LAYOUT.lineH.small;
+    const px       = M + PDF_LAYOUT.acuse.padX;
+
+    this._pdfRect(page, M, y, boxW, boxH, H, { stroke: GRAY, strokeWidth: 0.5 });
+
+    let py = y + PDF_LAYOUT.acuse.padY;
+
+    // Fila 1: Señor(es) + RUT
+    const sLabel = 'Señor(es): ';
+    this._pdfText(page, sLabel, px, py, H, fonts.bold, fs, BLACK);
+    this._pdfText(page, safeText(receptor.RznSocRecep || ''), px + fonts.bold.widthOfTextAtSize(sLabel, fs), py, H, fonts.normal, fs, BLACK);
+    const rutLabel = 'RUT: ';
+    const rutVal   = safeText(receptor.RUTRecep || '');
+    const rutTotal = `${rutLabel}${rutVal}`;
+    const rutX     = W - M - PDF_LAYOUT.acuse.padX - fonts.normal.widthOfTextAtSize(rutTotal, fs);
+    this._pdfText(page, rutLabel, rutX, py, H, fonts.bold, fs, BLACK);
+    this._pdfText(page, rutVal,   rutX + fonts.bold.widthOfTextAtSize(rutLabel, fs), py, H, fonts.normal, fs, BLACK);
+    py += lh + PDF_LAYOUT.gap.tiny;
+
+    // Fila 2: Dirección + Comuna
+    const dLabel = 'Dirección: ';
+    this._pdfText(page, dLabel, px, py, H, fonts.bold, fs, BLACK);
+    this._pdfText(page, safeText(receptor.DirRecep || ''), px + fonts.bold.widthOfTextAtSize(dLabel, fs), py, H, fonts.normal, fs, BLACK);
+    const cLabel   = 'Comuna: ';
+    const cVal     = safeText(receptor.CmnaRecep || '');
+    const cTotal   = `${cLabel}${cVal}`;
+    const cX       = W - M - PDF_LAYOUT.acuse.padX - fonts.normal.widthOfTextAtSize(cTotal, fs);
+    this._pdfText(page, cLabel, cX, py, H, fonts.bold, fs, BLACK);
+    this._pdfText(page, cVal,   cX + fonts.bold.widthOfTextAtSize(cLabel, fs), py, H, fonts.normal, fs, BLACK);
+    py += lh + PDF_LAYOUT.gap.tiny;
+
+    // Fila 3: Giro
+    const gLabel = 'Giro: ';
+    this._pdfText(page, gLabel, px, py, H, fonts.bold, fs, BLACK);
+    this._pdfText(page, safeText(receptor.GiroRecep || ''), px + fonts.bold.widthOfTextAtSize(gLabel, fs), py, H, fonts.normal, fs, BLACK);
+
+    return y + boxH;
+  }
+
+  _pdfRenderTraslado(page, doc, fonts, y, H, M, rgb) {
+    const texto = `Tipo de Traslado: ${doc.indTraslado} - ${NOMBRES_TRASLADO[doc.indTraslado] || ''}`;
+    this._pdfText(page, texto, M, y, H, fonts.normal, PDF_LAYOUT.font.small, rgb(0,0,0));
+    return y + PDF_LAYOUT.lineH.small;
+  }
+
+  _pdfRenderReferencias(page, doc, fonts, y, H, W, M, rgb) {
+    const tableW = W - 2 * M;
+    const BLACK  = rgb(0,0,0);
+    const DARK   = rgb(0.4, 0.4, 0.4);
+    const LGRAY  = rgb(0.88, 0.88, 0.88);
+
+    this._pdfText(page, 'Referencias a otros documentos', M, y, H, fonts.bold, PDF_LAYOUT.font.normal, BLACK);
+    y += PDF_LAYOUT.lineH.normal + PDF_LAYOUT.gap.small;
+
+    const colW = {
+      tipo:  Math.round(tableW * 0.30),
+      folio: Math.round(tableW * 0.15),
+      fecha: Math.round(tableW * 0.20),
+      razon: tableW - Math.round(tableW * 0.30) - Math.round(tableW * 0.15) - Math.round(tableW * 0.20),
+    };
+    const headers = ['Tipo Documento', 'Folio', 'Fecha', 'Razón Referencia'];
+    const widths  = [colW.tipo, colW.folio, colW.fecha, colW.razon];
+
+    // Encabezado tabla
+    this._pdfRect(page, M, y, tableW, PDF_LAYOUT.table.headerH, H, { fill: LGRAY });
+    let cx = M;
+    for (let i = 0; i < headers.length; i++) {
+      this._pdfRect(page, cx, y, widths[i], PDF_LAYOUT.table.headerH, H, { stroke: DARK, strokeWidth: 0.5 });
+      this._pdfText(page, headers[i], cx + PDF_LAYOUT.table.padX, y + PDF_LAYOUT.table.padY, H, fonts.bold, PDF_LAYOUT.font.tiny, BLACK);
+      cx += widths[i];
     }
+    y += PDF_LAYOUT.table.headerH;
+
+    // Filas
+    for (const ref of doc.referencias) {
+      const tipRef  = ref && ref.TpoDocRef ? (NOMBRES_DTE_IMPRESOS[ref.TpoDocRef] || `Tipo ${ref.TpoDocRef}`) : '';
+      const values  = [
+        safeText(tipRef),
+        safeText(ref && ref.FolioRef || ''),
+        safeText(ref && ref.FchRef   || ''),
+        safeText(ref && ref.RazonRef || ''),
+      ];
+      cx = M;
+      for (let i = 0; i < values.length; i++) {
+        this._pdfRect(page, cx, y, widths[i], PDF_LAYOUT.table.rowH, H, { stroke: DARK, strokeWidth: 0.5 });
+        this._pdfText(page, values[i], cx + PDF_LAYOUT.table.padX, y + PDF_LAYOUT.table.padY, H, fonts.normal, PDF_LAYOUT.font.tiny, BLACK);
+        cx += widths[i];
+      }
+      y += PDF_LAYOUT.table.rowH;
+    }
+    return y;
+  }
+
+  _pdfRenderDetalle(page, doc, fonts, y, H, W, M, rgb) {
+    const tableW = W - 2 * M;
+    const BLACK  = rgb(0,0,0);
+    const DARK   = rgb(0.4, 0.4, 0.4);
+    const LGRAY  = rgb(0.88, 0.88, 0.88);
+    const MGRAY  = rgb(0.4, 0.4, 0.4);
+
+    this._pdfText(page, 'Detalle', M, y, H, fonts.bold, PDF_LAYOUT.font.normal, BLACK);
+    y += PDF_LAYOUT.lineH.normal + PDF_LAYOUT.gap.small;
+
+    // Definición de columnas
+    const T = tableW;
+    const colW = {
+      num:   Math.round(T * 0.05),
+      cod:   Math.round(T * 0.10),
+      cant:  Math.round(T * 0.09),
+      unid:  Math.round(T * 0.07),
+      punit: Math.round(T * 0.13),
+      valor: Math.round(T * 0.14),
+    };
+    colW.desc = T - colW.num - colW.cod - colW.cant - colW.unid - colW.punit - colW.valor;
+
+    const colDefs = [
+      { key: 'num',   w: colW.num,   label: '#',         align: 'center' },
+      { key: 'cod',   w: colW.cod,   label: 'Código',    align: 'left'   },
+      { key: 'desc',  w: colW.desc,  label: 'Descripción', align: 'left', wrap: true },
+      { key: 'cant',  w: colW.cant,  label: 'Cant.',     align: 'right'  },
+      { key: 'unid',  w: colW.unid,  label: 'Unid.',     align: 'center' },
+      { key: 'punit', w: colW.punit, label: 'P.Unit.',   align: 'right'  },
+      { key: 'valor', w: colW.valor, label: 'Valor',     align: 'right'  },
+    ];
+
+    // Encabezado
+    this._pdfRect(page, M, y, tableW, PDF_LAYOUT.table.headerH, H, { fill: LGRAY });
+    let cx = M;
+    for (const col of colDefs) {
+      this._pdfRect(page, cx, y, col.w, PDF_LAYOUT.table.headerH, H, { stroke: DARK, strokeWidth: 0.5 });
+      const lw  = fonts.bold.widthOfTextAtSize(col.label, PDF_LAYOUT.font.tiny);
+      const lx  = col.align === 'center'
+        ? cx + (col.w - lw) / 2
+        : col.align === 'right'
+          ? cx + col.w - lw - PDF_LAYOUT.table.padX
+          : cx + PDF_LAYOUT.table.padX;
+      this._pdfText(page, col.label, lx, y + PDF_LAYOUT.table.padY, H, fonts.bold, PDF_LAYOUT.font.tiny, BLACK);
+      cx += col.w;
+    }
+    y += PDF_LAYOUT.table.headerH;
+
+    // Filas de detalle
+    for (let idx = 0; idx < (doc.detalle || []).length; idx++) {
+      const item    = doc.detalle[idx] || {};
+      const descW   = colW.desc - PDF_LAYOUT.table.padX * 2;
+      const descLines = this._pdfWrapText(safeText(item.NmbItem || ''), fonts.normal, PDF_LAYOUT.font.tiny, descW);
+      const hasDcto   = !!(item.DescuentoMonto || item.DescuentoPct);
+      const rowH      = Math.max(
+        PDF_LAYOUT.table.rowH,
+        descLines.length * PDF_LAYOUT.lineH.tiny + PDF_LAYOUT.table.padY * 2 + (hasDcto ? PDF_LAYOUT.lineH.tiny : 0)
+      );
+
+      const vals = {
+        num:   String(idx + 1),
+        cod:   safeText((item.CdgItem && item.CdgItem.VlrCodigo) || item.CdgItem || ''),
+        cant:  item.QtyItem != null ? String(item.QtyItem) : '',
+        unid:  safeText(item.UnmdItem || 'UN'),
+        punit: item.PrcItem != null ? `$${formatMonto(item.PrcItem)}` : '',
+        valor: item.MontoItem != null ? `$${formatMonto(item.MontoItem)}` : '',
+      };
+
+      cx = M;
+      for (const col of colDefs) {
+        this._pdfRect(page, cx, y, col.w, rowH, H, { stroke: DARK, strokeWidth: 0.5 });
+
+        if (col.key === 'desc') {
+          let ty = y + PDF_LAYOUT.table.padY;
+          for (const line of descLines) {
+            this._pdfText(page, line, cx + PDF_LAYOUT.table.padX, ty, H, fonts.normal, PDF_LAYOUT.font.tiny, BLACK);
+            ty += PDF_LAYOUT.lineH.tiny;
+          }
+          if (hasDcto) {
+            const dctoStr = item.DescuentoMonto
+              ? `Dcto: $${formatMonto(item.DescuentoMonto)}`
+              : `Dcto: ${item.DescuentoPct}%`;
+            this._pdfText(page, dctoStr, cx + PDF_LAYOUT.table.padX, ty, H, fonts.normal, PDF_LAYOUT.font.legal, MGRAY);
+          }
+        } else {
+          const val  = vals[col.key] || '';
+          const vW   = fonts.normal.widthOfTextAtSize(val, PDF_LAYOUT.font.tiny);
+          const valX = col.align === 'center'
+            ? cx + (col.w - vW) / 2
+            : col.align === 'right'
+              ? cx + col.w - vW - PDF_LAYOUT.table.padX
+              : cx + PDF_LAYOUT.table.padX;
+          this._pdfText(page, val, valX, y + (rowH - PDF_LAYOUT.font.tiny) / 2, H, fonts.normal, PDF_LAYOUT.font.tiny, BLACK);
+        }
+        cx += col.w;
+      }
+      y += rowH;
+    }
+    return y;
+  }
+
+  _pdfRenderTotales(page, doc, fonts, y, H, W, M, rgb) {
+    const { totales = {}, descuentosGlobales = [], tipoDte } = doc;
+    const esExenta = tipoDte === 34;
+    const boxW     = Math.round(W * 0.45);
+    const boxX     = W - M - boxW;
+    const rowH     = PDF_LAYOUT.table.rowH + 2;
+    const fs       = PDF_LAYOUT.font.normal;
+    const DARK     = rgb(0.4, 0.4, 0.4);
+    const BLACK    = rgb(0,0,0);
+
+    const rows = [];
+    if (esExenta) {
+      if (totales.MntExe)   rows.push(['Monto Exento',  `$${formatMonto(totales.MntExe)}`,  false]);
+      if (totales.MntTotal) rows.push(['Monto Total',   `$${formatMonto(totales.MntTotal)}`, true]);
+    } else {
+      for (const dg of (descuentosGlobales || [])) {
+        const label = dg && dg.TpoMov === 'D' ? 'Descuento Global' : 'Recargo Global';
+        const valor = dg && dg.ValorDR ? `$${formatMonto(dg.ValorDR)}` : (dg && dg.PctDR ? `${dg.PctDR}%` : '');
+        rows.push([label, valor, false]);
+      }
+      if (totales.MntNeto)  rows.push(['Monto Neto',                         `$${formatMonto(totales.MntNeto)}`,  false]);
+      if (totales.MntExe)   rows.push(['Monto Exento',                       `$${formatMonto(totales.MntExe)}`,   false]);
+      if (totales.IVA)      rows.push([`IVA (${totales.TasaIVA || 19}%)`,   `$${formatMonto(totales.IVA)}`,      false]);
+      if (totales.MntTotal) rows.push(['Monto Total',                        `$${formatMonto(totales.MntTotal)}`, true]);
+    }
+
+    let ry      = y + 2;
+    const labelW = Math.round(boxW * 0.55);
+    const valorW = boxW - labelW;
+
+    for (const [label, valor, isBold] of rows) {
+      const font = isBold ? fonts.bold : fonts.normal;
+      this._pdfRect(page, boxX,         ry, labelW, rowH, H, { stroke: DARK, strokeWidth: 0.5 });
+      this._pdfRect(page, boxX + labelW, ry, valorW, rowH, H, { stroke: DARK, strokeWidth: 0.5 });
+      this._pdfText(page, label, boxX + PDF_LAYOUT.table.padX, ry + PDF_LAYOUT.table.padY, H, font, fs, BLACK);
+      const vW  = font.widthOfTextAtSize(valor, fs);
+      this._pdfText(page, valor, boxX + labelW + valorW - vW - PDF_LAYOUT.table.padX, ry + PDF_LAYOUT.table.padY, H, font, fs, BLACK);
+      ry += rowH;
+    }
+    return y + rows.length * rowH + 8;
+  }
+
+  _pdfRenderAcuse(page, doc, fonts, y, H, W, M, rgb, leyendaMaxW) {
+    const BLACK = rgb(0,0,0);
+    const GRAY  = rgb(0.5, 0.5, 0.5);
+    const fs    = PDF_LAYOUT.font.small;
+    const px    = M + PDF_LAYOUT.acuse.padX;
+
+    const leyendaLines = this._pdfWrapText(DECLARACION_RECIBO, fonts.normal, PDF_LAYOUT.font.legal, leyendaMaxW);
+    const boxH  = this._pdfCalcAcuseHeight(leyendaLines.length);
+    const boxW  = W - 2 * M;
+
+    this._pdfRect(page, M, y, boxW, boxH, H, { stroke: BLACK, strokeWidth: 0.5 });
+
+    let py = y + PDF_LAYOUT.acuse.padY;
+
+    this._pdfText(page, 'Acuse de Recibo', px, py, H, fonts.bold, fs, BLACK);
+    py += PDF_LAYOUT.acuse.fieldH;
+
+    this._pdfText(page, 'Nombre: ____________________________', px, py, H, fonts.normal, fs, BLACK);
+    this._pdfText(page, 'R.U.T.: ___________________', px + (W - 2 * M - PDF_LAYOUT.acuse.padX * 2) * 0.5, py, H, fonts.normal, fs, BLACK);
+    py += PDF_LAYOUT.acuse.fieldH;
+
+    this._pdfText(page, 'Fecha: ___________________', px, py, H, fonts.normal, fs, BLACK);
+    this._pdfText(page, 'Recinto: __________________', px + (W - 2 * M - PDF_LAYOUT.acuse.padX * 2) * 0.5, py, H, fonts.normal, fs, BLACK);
+    py += PDF_LAYOUT.acuse.fieldH;
+
+    this._pdfText(page, 'Firma: ____________________________', px, py, H, fonts.normal, fs, BLACK);
+    py += PDF_LAYOUT.acuse.fieldH + PDF_LAYOUT.gap.small;
+
+    this._pdfHLine(page, px, M + boxW - PDF_LAYOUT.acuse.padX, py, H, { thickness: 0.5, color: GRAY });
+    py += PDF_LAYOUT.gap.tiny + 2;
+
+    for (const line of leyendaLines) {
+      this._pdfText(page, line, px, py, H, fonts.normal, PDF_LAYOUT.font.legal, BLACK);
+      py += PDF_LAYOUT.lineH.legal;
+    }
+    return y + boxH;
+  }
+
+  async _pdfRenderTed(pdfDoc, page, tedPng, fonts, y, H, W, M, rgb) {
+    const BLACK    = rgb(0,0,0);
+    const pdfImage = await pdfDoc.embedPng(tedPng);
+    const dims     = pdfImage.scale(1);
+
+    // Escalar respetando mínimos y máximos SII
+    const targetW  = Math.max(PDF_LAYOUT.ted.minWidth, Math.min(PDF_LAYOUT.ted.maxWidth, dims.width));
+    const scale    = targetW / dims.width;
+    const scaledW  = Math.round(targetW);
+    const scaledH  = Math.max(PDF_LAYOUT.ted.minHeight, Math.min(PDF_LAYOUT.ted.maxHeight, Math.round(dims.height * scale)));
+
+    // Distancia mínima de 2 cm desde el borde izquierdo del documento (incluye margen)
+    const tedX = M + PDF_LAYOUT.ted.marginLeft;
+
+    y += PDF_LAYOUT.gap.section;
+    page.drawImage(pdfImage, { x: tedX, y: H - y - scaledH, width: scaledW, height: scaledH });
+    y += scaledH + PDF_LAYOUT.ted.legendGap;
+
+    // Leyenda obligatoria (≥ 6pt según SII)
+    this._pdfText(page, 'Timbre Electrónico SII', tedX, y, H, fonts.bold, PDF_LAYOUT.font.legend, BLACK);
+    y += PDF_LAYOUT.lineH.legal;
+    this._pdfText(page, this.resolucion, tedX, y, H, fonts.normal, PDF_LAYOUT.font.legend, BLACK);
+    y += PDF_LAYOUT.lineH.legal;
+    this._pdfText(page, 'Verifique documento: www.sii.cl', tedX, y, H, fonts.normal, PDF_LAYOUT.font.legend, BLACK);
+    y += PDF_LAYOUT.lineH.legal;
+    return y;
+  }
+
+  _pdfRenderCedible(page, doc, fonts, H, W, M, rgb) {
+    const texto = doc.tipoDte === 52 ? 'CEDIBLE CON SU FACTURA' : 'CEDIBLE';
+    const tW    = fonts.bold.widthOfTextAtSize(texto, PDF_LAYOUT.font.razonSocial);
+    // Posición: inferior derecha del documento
+    this._pdfText(page, texto, W - M - tW, H - M - PDF_LAYOUT.font.razonSocial - PDF_LAYOUT.lineH.normal, H, fonts.bold, PDF_LAYOUT.font.razonSocial, rgb(0,0,0));
+  }
+
+  // ═══════════════════════════════════════════════════════════════
+  // Método público principal — sin Chromium, usa pdf-lib
+  // ═══════════════════════════════════════════════════════════════
+
+  /**
+   * Genera un Buffer PDF de la muestra impresa según Manual SII v3.0.
+   * No requiere Chromium ni ninguna dependencia del sistema operativo.
+   *
+   * El parámetro `doc` debe ser un elemento del array que retorna parseEnvioDTE().
+   *
+   * @param {Object}  doc              - Documento DTE parseado
+   * @param {Object}  [opts={}]
+   * @param {boolean} [opts.cedible=false] - Generar copia cedible con acuse de recibo
+   * @returns {Promise<Buffer>}        - Buffer PDF listo para enviar por HTTP
+   */
+  async generarPDFBuffer(doc, opts = {}) {
+    if (!doc || typeof doc !== 'object') {
+      throw new Error('[MuestrasImpresas] generarPDFBuffer: doc es requerido (resultado de parseEnvioDTE)');
+    }
+    if (!doc.tipoDte) {
+      throw new Error('[MuestrasImpresas] generarPDFBuffer: doc.tipoDte no encontrado');
+    }
+
+    const { cedible = false } = opts;
+    const { PDFDocument, StandardFonts, rgb } = require('pdf-lib');
+
+    const pdfDoc     = await PDFDocument.create();
+    const fontNormal = await pdfDoc.embedFont(StandardFonts.Helvetica);
+    const fontBold   = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
+    const fonts      = { normal: fontNormal, bold: fontBold };
+    const logoImage  = this.logoDataUri ? await this._pdfLoadLogo(pdfDoc) : null;
+
+    const W = PDF_LAYOUT.page.width;
+    const M = PDF_LAYOUT.margin;
+
+    // ── Fase 1: precalcular alturas para dimensionar la página ────
+    const needsAcuse    = this._pdfNecesitaAcuse(doc, cedible);
+    const leyendaW      = W - 2 * M - PDF_LAYOUT.acuse.padX * 2;
+    const leyendaLines  = needsAcuse
+      ? this._pdfWrapText(DECLARACION_RECIBO, fontNormal, PDF_LAYOUT.font.legal, leyendaW)
+      : [];
+
+    const headerH    = this._pdfCalcHeaderHeight(doc, fonts, logoImage);
+    const fechaH     = PDF_LAYOUT.lineH.normal;
+    const receptorH  = this._pdfCalcReceptorHeight();
+    const trasladoH  = (doc.tipoDte === 52 && doc.indTraslado) ? PDF_LAYOUT.lineH.small + PDF_LAYOUT.gap.small : 0;
+    const refsH      = this._pdfCalcReferencesHeight(doc);
+    const detalleH   = this._pdfCalcDetalleHeight(doc, fonts, W, M);
+    const totalesH   = this._pdfCalcTotalesHeight(doc);
+    const acuseH     = needsAcuse ? this._pdfCalcAcuseHeight(leyendaLines.length) + PDF_LAYOUT.gap.section : 0;
+    const tedH       = doc.tedXml
+      ? PDF_LAYOUT.gap.section + PDF_LAYOUT.ted.maxHeight + PDF_LAYOUT.ted.legendGap + PDF_LAYOUT.lineH.legal * 3 + M
+      : M;
+
+    const totalH =
+      M +
+      headerH   + PDF_LAYOUT.gap.section +
+      fechaH    + PDF_LAYOUT.gap.small   +
+      receptorH + PDF_LAYOUT.gap.section +
+      trasladoH +
+      refsH +
+      detalleH  + PDF_LAYOUT.gap.section +
+      totalesH  + PDF_LAYOUT.gap.section +
+      acuseH +
+      tedH;
+
+    const H = Math.min(
+      PDF_LAYOUT.page.maxHeight,
+      Math.max(PDF_LAYOUT.page.minHeight, Math.ceil(totalH))
+    );
+
+    // ── Fase 2: crear página y renderizar ─────────────────────────
+    const page = pdfDoc.addPage([W, H]);
+    let   y    = M;
+
+    y = this._pdfRenderHeader(page, doc, fonts, logoImage, y, H, W, M, rgb);
+    y += PDF_LAYOUT.gap.section;
+
+    y = this._pdfRenderFecha(page, doc, fonts, y, H, M, rgb);
+    y += PDF_LAYOUT.gap.small;
+
+    y = this._pdfRenderReceptor(page, doc, fonts, y, H, W, M, rgb);
+    y += PDF_LAYOUT.gap.section;
+
+    if (trasladoH > 0) {
+      y = this._pdfRenderTraslado(page, doc, fonts, y, H, M, rgb);
+      y += PDF_LAYOUT.gap.small;
+    }
+
+    if (refsH > 0) {
+      y = this._pdfRenderReferencias(page, doc, fonts, y, H, W, M, rgb);
+      y += PDF_LAYOUT.gap.section;
+    }
+
+    y = this._pdfRenderDetalle(page, doc, fonts, y, H, W, M, rgb);
+    y += PDF_LAYOUT.gap.section;
+
+    y = this._pdfRenderTotales(page, doc, fonts, y, H, W, M, rgb);
+    y += PDF_LAYOUT.gap.section;
+
+    if (needsAcuse) {
+      y = this._pdfRenderAcuse(page, doc, fonts, y, H, W, M, rgb, leyendaW);
+      y += PDF_LAYOUT.gap.section;
+    }
+
+    if (doc.tedXml) {
+      const tedPng = await this._generarTedPngBuffer(doc.tedXml);
+      y = await this._pdfRenderTed(pdfDoc, page, tedPng, fonts, y, H, W, M, rgb);
+    }
+
+    if (cedible && CEDIBLE_TIPOS.has(doc.tipoDte) && !this._esGuiaInterna(doc)) {
+      this._pdfRenderCedible(page, doc, fonts, H, W, M, rgb);
+    }
+
+    const pdfBytes = await pdfDoc.save();
+    return Buffer.from(pdfBytes);
   }
 
   /**
@@ -538,122 +1296,64 @@ class MuestrasImpresas {
    * @returns {Promise<Object>} Resultado con estadísticas y archivos generados
    */
   async generarMuestras({ xmlFiles, outDir, generarCedible = false }) {
-    fs.mkdirSync(outDir, { recursive: true });
-
-    // Crear subdirectorios según requisitos del SII
-    const pruebasDir = path.join(outDir, 'SET-PRUEBAS');
+    const pruebasDir    = path.join(outDir, 'SET-PRUEBAS');
     const simulacionDir = path.join(outDir, 'SET-SIMULACION');
-    fs.mkdirSync(pruebasDir, { recursive: true });
+    fs.mkdirSync(pruebasDir,    { recursive: true });
     fs.mkdirSync(simulacionDir, { recursive: true });
 
-    console.log('\n' + '═'.repeat(60));
-    console.log('GENERACIÓN DE MUESTRAS IMPRESAS');
-    console.log('═'.repeat(60));
-    console.log(` SET-PRUEBAS: ${pruebasDir}`);
-    console.log(` SET-SIMULACION: ${simulacionDir}`);
-
-    const browser = await launchBrowser();
     const resultado = {
-      success: true,
-      totalDocs: 0,
-      totalPdfs: 0,
-      archivos: [],
-      errores: [],
-      setPruebas: 0,
-      setSimulacion: 0,
+      success: true, totalDocs: 0, totalPdfs: 0,
+      archivos: [], errores: [], setPruebas: 0, setSimulacion: 0,
     };
 
-    try {
-      for (const filePath of xmlFiles) {
-        console.log(`\n Procesando: ${path.basename(filePath)}`);
-        const xml = fs.readFileSync(filePath, 'utf8');
-        
-        let documentos;
+    for (const filePath of xmlFiles) {
+      const sourceFile = path.basename(filePath).toLowerCase();
+      const isPruebas  = /envio-set-(basico|guia|exenta|compra)\.xml/i.test(sourceFile);
+      const targetDir  = isPruebas ? pruebasDir : simulacionDir;
+
+      let docs;
+      try {
+        docs = this.parseEnvioDTE(fs.readFileSync(filePath, 'utf8'));
+      } catch (e) {
+        resultado.errores.push({ file: filePath, error: e.message });
+        continue;
+      }
+
+      for (const doc of docs) {
+        resultado.totalDocs++;
+        const base = `muestra_${doc.tipoDte}_${doc.folio}`;
+
         try {
-          documentos = this.parseEnvioDTE(xml);
+          const buf = await this.generarPDFBuffer(doc, { cedible: false });
+          const out = path.join(targetDir, `${base}.pdf`);
+          fs.writeFileSync(out, buf);
+          resultado.totalPdfs++;
+          resultado.archivos.push(out);
+          if (isPruebas) resultado.setPruebas++; else resultado.setSimulacion++;
+          console.log(`   ✓ ${base}.pdf  (${buf.length} bytes)`);
         } catch (e) {
-          console.log(` [!] Error parseando: ${e.message}`);
-          resultado.errores.push({ file: filePath, error: e.message });
-          continue;
+          resultado.errores.push({ tipo: doc.tipoDte, folio: doc.folio, error: e.message });
+          console.error(`   ✗ ${base}.pdf  →  ${e.message}`);
         }
 
-        if (!documentos.length) {
-          console.log(' [!] Sin documentos');
-          continue;
-        }
-
-        // Determinar directorio de salida según archivo fuente
-        const sourceFile = path.basename(filePath).toLowerCase();
-        const isPruebas = /envio-set-(basico|guia|exenta|compra)\.xml/i.test(sourceFile);
-        const targetDir = isPruebas ? pruebasDir : simulacionDir;
-        const categoria = isPruebas ? 'PRUEBAS' : 'SIMULACION';
-        console.log(` Categoria: SET-${categoria}`);
-
-        for (const doc of documentos) {
-          resultado.totalDocs++;
-          
+        if (generarCedible && CEDIBLE_TIPOS.has(doc.tipoDte) && !this._esGuiaInterna(doc)) {
           try {
-            const tedDataUri = await this.generarPdf417(doc.tedXml);
-            
-            // Generar ejemplar tributario (sin cedible)
-            const html = this._buildHtml({ doc, esCedible: false, tedDataUri });
-
-            // PDFs organizados en subdirectorios según categoría SII
-            const outputName = `muestra_${doc.tipoDte}_${doc.folio}.pdf`;
-            const outputPath = path.join(targetDir, outputName);
-
-            await this._generarPdf({ html, outputPath, browser });
+            const buf = await this.generarPDFBuffer(doc, { cedible: true });
+            const out = path.join(targetDir, `${base}_cedible.pdf`);
+            fs.writeFileSync(out, buf);
             resultado.totalPdfs++;
-            resultado.archivos.push(outputPath);
-            if (isPruebas) resultado.setPruebas++;
-            else resultado.setSimulacion++;
-            console.log(` ✓ ${outputName}`);
-
-            // Generar copia cedible si corresponde
-            if (generarCedible && CEDIBLE_TIPOS.has(doc.tipoDte)) {
-              // Guía de traslado interno no tiene cedible
-              if (doc.tipoDte === 52 && [5, 6].includes(doc.indTraslado)) {
-                console.log(' Guia traslado interno - sin cedible');
-                continue;
-              }
-
-              const htmlCedible = this._buildHtml({ doc, esCedible: true, tedDataUri });
-              const outputNameCedible = `muestra_${doc.tipoDte}_${doc.folio}_cedible.pdf`;
-              const outputPathCedible = path.join(targetDir, outputNameCedible);
-
-              await this._generarPdf({ html: htmlCedible, outputPath: outputPathCedible, browser });
-              resultado.totalPdfs++;
-              resultado.archivos.push(outputPathCedible);
-              if (isPruebas) resultado.setPruebas++;
-              else resultado.setSimulacion++;
-              console.log(` ✓ ${outputNameCedible}`);
-            }
-
+            resultado.archivos.push(out);
+            if (isPruebas) resultado.setPruebas++; else resultado.setSimulacion++;
+            console.log(`   ✓ ${base}_cedible.pdf  (${buf.length} bytes)`);
           } catch (e) {
-            console.log(` [ERR] Error: ${e.message}`);
-            resultado.errores.push({ tipo: doc.tipoDte, folio: doc.folio, error: e.message });
+            resultado.errores.push({ tipo: doc.tipoDte, folio: doc.folio, cedible: true, error: e.message });
+            console.error(`   ✗ ${base}_cedible.pdf  →  ${e.message}`);
           }
         }
       }
-    } finally {
-      await browser.close();
-    }
-
-    // Resumen
-    console.log('\n' + '═'.repeat(60));
-    console.log('[OK] MUESTRAS IMPRESAS GENERADAS');
-    console.log('═'.repeat(60));
-    console.log(` Documentos procesados: ${resultado.totalDocs}`);
-    console.log(` PDFs generados: ${resultado.totalPdfs}`);
-    console.log(` SET-PRUEBAS: ${resultado.setPruebas} PDFs`);
-    console.log(` SET-SIMULACION: ${resultado.setSimulacion} PDFs`);
-    console.log(` Directorio base: ${outDir}`);
-
-    if (resultado.errores.length > 0) {
-      resultado.success = false;
-      console.log(` [!] Errores: ${resultado.errores.length}`);
     }
 
+    if (resultado.errores.length > 0) resultado.success = false;
     return resultado;
   }