fix(pdf): inlinar imagenes como data: URL para evitar canvas tainted

Las imagenes son rutas same-origin, pero HF responde con un 302 al CDN
(us.aws.cdn.hf.co). html2canvas solo pone crossOrigin cuando la URL ya es
cross-origin (useCORS && !isSameOrigin), asi que cargaba sin CORS, seguia el
redirect y contaminaba el canvas -> toDataURL() fallaba con
"Tainted canvases may not be exported".

- inlineImage(): fetch -> blob -> data: URL, cacheado por URL
- se inlinean el background del slide y todas sus <img> antes de capturar,
y se restauran despues
- toDataURL() por pagina informa que diapositiva falla
- si la generacion falla, el deck vuelve a ser usable en vez de quedarse oculto

index.html

@@ -2841,6 +2841,30 @@
             if (e.key === 'ArrowLeft') changeSlide(-1);
         });
 
+        // Las imagenes del deck son rutas same-origin, pero HF responde con un 302 hacia
+        // el CDN (us.aws.cdn.hf.co). html2canvas solo aplica crossOrigin cuando la URL YA
+        // es cross-origin (useCORS && !isSameOrigin), asi que las carga sin CORS, sigue el
+        // redirect y contamina el canvas: toDataURL() lanza "Tainted canvases may not be
+        // exported". Inlinearlas como data: URL elimina el problema de raiz.
+        const pdfImageCache = new Map();
+        function inlineImage(url) {
+            if (!url || url.startsWith('data:')) return Promise.resolve(url);
+            if (!pdfImageCache.has(url)) {
+                pdfImageCache.set(url, (async () => {
+                    const res = await fetch(url);
+                    if (!res.ok) throw new Error(res.status + ' ' + url);
+                    const blob = await res.blob();
+                    return await new Promise((resolve, reject) => {
+                        const rd = new FileReader();
+                        rd.onloadend = () => resolve(rd.result);
+                        rd.onerror = () => reject(rd.error);
+                        rd.readAsDataURL(blob);
+                    });
+                })());
+            }
+            return pdfImageCache.get(url);
+        }
+
         // ===================== GENERADOR DE PDF - FORZADO DESKTOP =====================
         async function generatePDF() {
             const loadingOverlay = document.getElementById('pdf-loading');
@@ -2908,21 +2932,30 @@
                         document.head.appendChild(tempMeta);
                     }
 
-                    // Convertir bg a base64
+                    // Inlinear bg del slide + todas sus <img> como data: URL (ver inlineImage)
+                    const restoreImages = [];
                     const bgStyle = window.getComputedStyle(slide).backgroundImage;
                     const urlMatch = bgStyle.match(/url\(["']?(.*?)["']?\)/);
-                    if (urlMatch && urlMatch[1]) {
+                    if (urlMatch && urlMatch[1] && !urlMatch[1].startsWith('data:')) {
                         try {
-                            const res = await fetch(urlMatch[1]);
-                            const blob = await res.blob();
-                            const b64 = await new Promise(r => { 
-                                const rd = new FileReader(); 
-                                rd.onloadend = () => r(rd.result); 
-                                rd.readAsDataURL(blob); 
-                            });
-                            slide.style.backgroundImage = `url(${b64})`;
+                            const b64 = await inlineImage(urlMatch[1]);
+                            const prevBg = slide.style.backgroundImage;
+                            restoreImages.push(() => { slide.style.backgroundImage = prevBg; });
+                            slide.style.backgroundImage = `url("${b64}")`;
                         } catch (e) { console.warn("BG conversion failed:", e); }
                     }
+                    for (const img of slide.querySelectorAll('img[src]')) {
+                        if (img.src.startsWith('data:')) continue;
+                        try {
+                            const b64 = await inlineImage(img.src);
+                            const prevSrc = img.getAttribute('src');
+                            restoreImages.push(() => { img.setAttribute('src', prevSrc); });
+                            img.src = b64;
+                            if (!img.complete) {
+                                await new Promise(r => { img.onload = r; img.onerror = r; });
+                            }
+                        } catch (e) { console.warn("IMG conversion failed:", img.src, e); }
+                    }
 
                     // Capturar
                     const canvas = await html2canvas(slide, {
@@ -2943,6 +2976,8 @@
                         removeContainer: true
                     });
 
+                    restoreImages.forEach(fn => fn());
+
                     // === RESTAURAR viewport original DESPUÉS de capturar ===
                     await new Promise(resolve => setTimeout(resolve, 100));
                     if (originalMetaViewport) {
@@ -2955,8 +2990,14 @@
                         }
                     }
 
+                    let pageData;
+                    try {
+                        pageData = canvas.toDataURL('image/jpeg', 0.95);
+                    } catch (e) {
+                        throw new Error(`Could not export slide ${i + 1}: ${e.message}`);
+                    }
                     if (i > 0) pdf.addPage();
-                    pdf.addImage(canvas.toDataURL('image/jpeg', 0.95), 'JPEG', 0, 0, 1920, 1080, undefined, 'FAST');
+                    pdf.addImage(pageData, 'JPEG', 0, 0, 1920, 1080, undefined, 'FAST');
 
                     links.forEach(link => {
                         pdf.link(link.x, link.y, link.width, link.height, { url: link.url });
@@ -2980,6 +3021,10 @@
 
             } catch (err) {
                 console.error('Error:', err);
+                slides.forEach((s, idx) => {
+                    s.classList.remove('capture-mode');
+                    s.style.display = idx === originalSlide ? 'flex' : 'none';
+                });
                 alert('Error al generar PDF: ' + err.message);
             } finally {
                 loadingOverlay.style.display = 'none';