// === Escena IN04 — "El servicio, doblado y tras una red mundial" ===
// Duración real del mp3: 34.4s. SlideCanvas variant="light-soft".
// Motivo gemelo: el programa corre en DOS servidores gemelos (dos datacenters).
// Si A cae, B sigue (relevo en GRIS, no rojo). Encima, una red edge mundial
// (Cloudflare) enruta al más cercano y sano, y hace de ESCUDO: frena ataques
// (rojo dosificado). La puerta no es una máquina que se pueda tirar (IP única
// tachada = así NO); es una red del tamaño del planeta.
// LOCUCIÓN (audio/escena-04.mp3):
// "El programa también está doblado. Corre en dos centros de datos distintos.
//  Si uno cae, el otro sigue, sin que tú lo notes. ¿Y quién decide a cuál te
//  conecta? Una red repartida por todo el mundo. Te lleva siempre al más
//  cercano, y al que está sano. Esa red es también un escudo. Frena los ataques
//  antes de que lleguen a tus servidores. La puerta de entrada no es una máquina
//  que se pueda tirar. Es una red del tamaño del planeta. Datos y servicio,
//  doblados. Queda lo mejor: tus archivos."
function EscenaIN04({ t }){
  const T = {
    gemelos: 0.35,  // "El programa también está doblado" → 2 servidores gemelos (A / B)
    dc:      3.04,  // "dos centros de datos"             → etiquetas Datacenter 1 / Datacenter 2
    cae:     5.08,  // "Si uno cae"                       → A se ATENÚA a gris; tráfico se desvía a B (verde)
    mundo:  11.63,  // "red repartida por todo el mundo"  → banda de nodos edge + píldora Cloudflare
    ruta:   15.68,  // "al que está sano"                 → enrutado usuario → edge más cercano → Servidor B
    escudo: 18.17,  // "también un escudo"                → escudo se superpone a la capa edge
    ataque: 20.28,  // "Frena los ataques"               → flechas rojas golpean el escudo y se paran
    ipunica:25.58,  // "una máquina que se pueda tirar"   → apunte contraste: nodo "IP única" tachado (esto NO)
    glow:   27.99,  // "del tamaño del planeta"          → la banda edge mundial hace glow (protagonista)
    salida: 32.35,  // "Queda lo mejor"                   → píldora salida "TUS ARCHIVOS →"
  };

  const C = { blue:'#0085FF', green:'#10B981', green2:'#56E16A', orange:'#FB8C00',
              red:'#EF4444', ink:'#0F172A', gray:'#64748B', grayL:'#94A3B8', border:'#E2E8F0' };

  // ---- Geometría (1920×1080) ----
  const EDGE_Y = 322;
  const edgeX  = [388, 615, 842, 1069, 1296, 1523];
  const SA = { x:470, y:600, w:300, h:206, cx:620 };   // Servidor A (izq)
  const SB = { x:1150, y:600, w:300, h:206, cx:1300 };  // Servidor B (der)
  const Scy = 703;
  const USER = { x:150, y:648 };
  const SHX = 960, SHY = 300;

  // ---- Servidores gemelos (A calmado, B = "el gemelo" con overshoot) ----
  const saP = clamp((t-T.gemelos)/0.6, 0, 1),        saE = Easing.easeOutCubic(saP);
  const sbP = clamp((t-(T.gemelos+0.25))/0.6, 0, 1), sbE = Easing.easeOutBack(sbP);
  const dimA = Easing.easeOutCubic(clamp((t-T.cae)/0.7, 0, 1));   // A → gris (relevo, NO rojo)
  const bPulse = Math.sin(clamp((t-(T.cae+0.25))/1.1, 0, 1) * Math.PI); // B confirma UNA vez

  // ---- Etiquetas datacenter ----
  const dc1P = clamp((t-T.dc)/0.5, 0, 1),        dc1E = Easing.easeOutCubic(dc1P);
  const dc2P = clamp((t-(T.dc+0.25))/0.5, 0, 1), dc2E = Easing.easeOutCubic(dc2P);

  // ---- Línea de sincronía viva entre gemelos (fade-in + flujo dotted) ----
  const syncP = clamp((t-(T.gemelos+0.45))/0.7, 0, 1);
  const syncCol = dimA > 0.45 ? C.grayL : C.green;
  // pulso que viaja A→B UNA vez ("en tiempo real")
  const pt0 = T.gemelos + 1.35;
  const pulseP = clamp((t-pt0)/0.9, 0, 1);
  const pulseX = lerp(SA.x+SA.w, SB.x, Easing.easeInOutCubic(pulseP));
  const showPulse = pulseP > 0 && pulseP < 1 && dimA < 0.4;

  // ---- Desvío de tráfico A→B (relevo, GRIS) ----
  const divE = Easing.easeInOutCubic(clamp((t-T.cae)/0.8, 0, 1));
  const divHead = clamp((divE-0.72)/0.28, 0, 1);

  // ---- Red edge mundial ----
  const bandP = clamp((t-T.mundo)/0.7, 0, 1);
  const arcE  = Easing.easeInOutCubic(clamp((t-(T.mundo+0.2))/0.8, 0, 1));
  const cfP   = clamp((t-(T.mundo+0.45))/0.5, 0, 1), cfE = Easing.easeOutBack(cfP);

  // ---- Enrutado usuario → edge más cercano → Servidor B ----
  const userP = clamp((t-T.ruta)/0.4, 0, 1), userE = Easing.easeOutBack(userP);
  const routeE = Easing.easeInOutCubic(clamp((t-(T.ruta+0.15))/1.1, 0, 1));
  const routeHead = clamp((routeE-0.8)/0.2, 0, 1);
  const nearPulse = Math.sin(clamp((t-T.ruta)/1.2, 0, 1) * Math.PI); // el edge elegido late UNA vez

  // ---- Escudo sobre la capa edge ----
  const shP = clamp((t-T.escudo)/0.6, 0, 1), shE = Easing.easeOutBack(shP);

  // ---- Ataques frenados (rojo dosificado, breve) ----
  const ATT = [0,1,2].map(i=>{
    const ax = [820, 960, 1100][i];
    const t0 = T.ataque + i*0.34;
    const ap = clamp((t-t0)/0.55, 0, 1);
    const ae = Easing.easeOutCubic(clamp(ap/0.8, 0, 1));
    const tipY = lerp(162, 262, ae);
    const op = clamp(ap*4, 0, 1) * (1 - clamp((ap-0.85)/0.15, 0, 1));
    const hit = ap >= 0.72 ? Math.sin(clamp((ap-0.72)/0.28, 0, 1) * Math.PI) : 0;
    return { ax, ap, tipY, op, hit, live: ap > 0 && ap < 1 };
  });
  const shieldFlash = Math.max(0, ...ATT.map(a=>a.hit));

  // ---- Apunte de contraste: IP única tachada (esto NO) ----
  const ipP = clamp((t-T.ipunica)/0.55, 0, 1), ipE = Easing.easeOutCubic(ipP);
  const ipStrike = Easing.easeOutCubic(clamp((t-(T.ipunica+0.35))/0.4, 0, 1));

  // ---- Glow de la banda mundial (protagonista, UN pulse + hold) ----
  const glowHold  = clamp((t-T.glow)/0.6, 0, 1);
  const glowPulse = Math.sin(clamp((t-T.glow)/1.1, 0, 1) * Math.PI);
  const glowK = clamp(glowHold*0.6 + glowPulse*0.55, 0, 1);

  // ---- Píldora de salida ----
  const salP = clamp((t-T.salida)/0.5, 0, 1), salE = Easing.easeOutBack(salP);

  // ===== Tarjeta de servidor (gemelo) =====
  const ServerCard = ({ rect, name, appearP, appearE, isA })=>{
    if (appearP <= 0) return null;
    const dim = isA ? dimA : 0;
    const healthy = !(isA && dimA >= 0.4);
    const led = healthy ? C.green : C.grayL;
    const glowB = (!isA) ? (0.10 + 0.22*bPulse) : 0;
    return (
      <div style={{position:'absolute', left:rect.x, top:rect.y, width:rect.w, height:rect.h, zIndex:3,
        background:'#fff', border:`1px solid ${healthy ? C.border : '#CBD5E1'}`, borderRadius:18,
        boxShadow:`0 14px 34px rgba(15,23,42,${lerp(0.08,0.04,dim)}), 0 12px 30px rgba(16,185,129,${glowB})`,
        opacity: clamp(appearP*1.3,0,1) * (1-0.45*dim),
        filter:`saturate(${1-0.55*dim})`,
        transform:`translateY(${(1-appearE)*22}px) scale(${lerp(0.9,1,appearE)})`,
        padding:'18px 22px'}}>
        <div style={{display:'flex', alignItems:'center', justifyContent:'space-between'}}>
          <div style={{display:'flex', alignItems:'center', gap:9}}>
            <span style={{width:9, height:9, borderRadius:100, background:led, boxShadow:`0 0 0 3px ${led}22`}}/>
            <span className="f-mono" style={{fontSize:17, fontWeight:700, color:C.ink, letterSpacing:'0.02em'}}>{name}</span>
          </div>
          <span className="f-mono" style={{fontSize:10, fontWeight:700, letterSpacing:'1.5px', padding:'4px 10px', borderRadius:100,
            color: healthy ? '#059669' : C.gray, background: healthy ? 'rgba(16,185,129,0.10)' : 'rgba(100,116,139,0.10)',
            border:`1px solid ${healthy ? 'rgba(16,185,129,0.32)' : 'rgba(100,116,139,0.30)'}`}}>
            {healthy ? 'EN MARCHA' : 'EN ESPERA'}
          </span>
        </div>
        {/* rack: 3 unidades */}
        <div style={{marginTop:18, display:'flex', flexDirection:'column', gap:9}}>
          {[0,1,2].map(u=>(
            <div key={u} style={{height:26, borderRadius:7, background:'#F1F5F9', border:'1px solid #E2E8F0',
              display:'flex', alignItems:'center', gap:8, padding:'0 12px'}}>
              <span style={{width:7, height:7, borderRadius:100, background: healthy ? C.blue : C.grayL}}/>
              <span style={{flex:1, height:4, borderRadius:2, background:'#E2E8F0'}}/>
              <span style={{width:22, height:4, borderRadius:2, background:'#CBD5E1'}}/>
            </div>
          ))}
        </div>
      </div>
    );
  };

  return (
    <SlideCanvas variant="light-soft">
      <DemoHeader t={t} eyebrow="INFRAESTRUCTURA · EL SERVICIO"
        title={<span>Doblado, y tras una <span className="grad-text">red mundial</span></span>}/>

      {/* Glow radial detrás de la banda mundial */}
      {glowK > 0 && (
        <div style={{position:'absolute', left:340, top:190, width:1240, height:260, zIndex:0,
          background:`radial-gradient(ellipse 60% 60% at 50% 55%, rgba(0,133,255,${0.14*glowK}), transparent 70%)`,
          pointerEvents:'none'}}/>
      )}

      {/* Banda-escudo (cobertura de la capa edge) */}
      {shP > 0 && (
        <div style={{position:'absolute', left:344, top:266, width:1232, height:118, zIndex:1,
          borderRadius:22, background:`rgba(0,133,255,${0.06*shE})`,
          border:`1px solid rgba(0,133,255,${0.28*shE})`,
          boxShadow:`inset 0 0 0 6px rgba(0,133,255,${0.05*shE})`,
          opacity: shE}}/>
      )}

      {/* ===== CAPA VECTORIAL (arcos, sync, desvío, enrutado, escudo, ataques) ===== */}
      <svg width="1920" height="1080" viewBox="0 0 1920 1080" style={{position:'absolute', inset:0, zIndex:2, pointerEvents:'none'}}>

        {/* Arcos entre nodos edge (se dibujan) */}
        {bandP > 0 && edgeX.slice(0,-1).map((x,i)=>{
          const x2 = edgeX[i+1], mx = (x+x2)/2;
          return (
            <path key={'arc'+i} d={`M ${x} ${EDGE_Y} Q ${mx} ${EDGE_Y-42} ${x2} ${EDGE_Y}`}
              fill="none" stroke={C.blue} strokeWidth="2.5" strokeLinecap="round"
              opacity={0.45*arcE} pathLength="1" strokeDasharray="1" strokeDashoffset={1-arcE}/>
          );
        })}

        {/* Nodos edge */}
        {bandP > 0 && edgeX.map((x,i)=>{
          const np = clamp((t-(T.mundo+i*0.09))/0.4, 0, 1);
          const ne = Easing.easeOutBack(np);
          if (np <= 0) return null;
          const chosen = i === 0; // el edge más cercano al usuario
          const r = lerp(6, 22, ne);
          return (
            <g key={'edge'+i} opacity={clamp(np*1.3,0,1)}>
              {glowK > 0 && <circle cx={x} cy={EDGE_Y} r={22+10*glowK} fill="none" stroke={C.blue} strokeWidth="2" opacity={0.35*glowK}/>}
              {chosen && routeE > 0 && <circle cx={x} cy={EDGE_Y} r={22+8*nearPulse} fill="none" stroke={C.green} strokeWidth="3" opacity={0.7*nearPulse}/>}
              <circle cx={x} cy={EDGE_Y} r={r} fill="#fff" stroke={C.blue} strokeWidth="2.5"/>
              <circle cx={x} cy={EDGE_Y} r={lerp(0,5,ne)} fill={C.blue}/>
            </g>
          );
        })}

        {/* Escudo emblema centrado sobre la banda */}
        {shP > 0 && (
          <g transform={`translate(${SHX} ${SHY}) scale(${lerp(0.5,1,shE)})`} opacity={clamp(shP*1.3,0,1)}>
            <path d="M0 -64 L58 -44 L58 4 Q58 62 0 88 Q-58 62 -58 4 L-58 -44 Z"
              fill={`rgba(0,133,255,${0.10})`} stroke={C.blue} strokeWidth="3.5" strokeLinejoin="round"/>
            {/* rim rojo breve al recibir impacto */}
            <path d="M0 -64 L58 -44 L58 4 Q58 62 0 88 Q-58 62 -58 4 L-58 -44 Z"
              fill="none" stroke={C.red} strokeWidth="4" strokeLinejoin="round" opacity={0.85*shieldFlash}/>
            <path d="M-24 4 L-8 22 L26 -20" fill="none" stroke={C.blue} strokeWidth="6" strokeLinecap="round" strokeLinejoin="round"
              pathLength="1" strokeDasharray="1" strokeDashoffset={1-Easing.easeInOutCubic(clamp((t-(T.escudo+0.25))/0.5,0,1))}/>
          </g>
        )}

        {/* Ataques rojos que golpean el escudo y se paran */}
        {ATT.map((a,i)=> a.live && (
          <g key={'att'+i} opacity={a.op}>
            <line x1={a.ax} y1={162} x2={a.ax} y2={a.tipY} stroke={C.red} strokeWidth="4" strokeLinecap="round"/>
            <path d={`M ${a.ax-11} ${a.tipY-13} L ${a.ax} ${a.tipY} L ${a.ax+11} ${a.tipY-13}`}
              fill="none" stroke={C.red} strokeWidth="4" strokeLinecap="round" strokeLinejoin="round"/>
            {a.hit > 0 && <circle cx={a.ax} cy={a.tipY} r={4+9*a.hit} fill="none" stroke={C.red} strokeWidth="2.5" opacity={1-a.hit}/>}
          </g>
        ))}

        {/* Línea de sincronía viva entre gemelos (dotted en flujo) */}
        {syncP > 0 && (
          <line x1={SA.x+SA.w} y1={Scy} x2={SB.x} y2={Scy}
            stroke={syncCol} strokeWidth="3" strokeLinecap="round"
            strokeDasharray="2 12" strokeDashoffset={-(t*34)}
            opacity={0.85*syncP}/>
        )}

        {/* Pulso que viaja A→B una vez ("en tiempo real") */}
        {showPulse && (
          <circle cx={pulseX} cy={Scy} r="6" fill={C.green}
            opacity={clamp(Math.min(pulseP*6,(1-pulseP)*4),0,1)}/>
        )}

        {/* Desvío de tráfico A→B (relevo, GRIS — es control, no ataque) */}
        {divE > 0 && dimA > 0 && (
          <g opacity={clamp(divE*1.4,0,1)}>
            <path d={`M ${SA.cx+70} ${SA.y+6} C ${SA.cx+140} 512 ${SB.cx-140} 512 ${SB.cx} ${SB.y+2}`}
              fill="none" stroke={C.grayL} strokeWidth="3.5" strokeLinecap="round"
              pathLength="1" strokeDasharray="1" strokeDashoffset={1-divE}/>
            {divHead > 0 && (
              <path d={`M ${SB.cx-13} ${SB.y-11} L ${SB.cx} ${SB.y+2} L ${SB.cx+13} ${SB.y-11}`}
                fill="none" stroke={C.grayL} strokeWidth="3.5" strokeLinecap="round" strokeLinejoin="round" opacity={divHead}/>
            )}
          </g>
        )}

        {/* Enrutado usuario → edge más cercano → Servidor B (sano), esquivando A */}
        {routeE > 0 && (
          <g>
            <path d={`M ${USER.x+34} ${USER.y} L ${edgeX[0]} ${EDGE_Y+22} C 720 360 1120 560 ${SB.cx} ${SB.y}`}
              fill="none" stroke={C.green} strokeWidth="3.5" strokeLinecap="round" strokeLinejoin="round"
              pathLength="1" strokeDasharray="1" strokeDashoffset={1-routeE}/>
            {routeHead > 0 && (
              <path d={`M ${SB.cx-13} ${SB.y-12} L ${SB.cx} ${SB.y} L ${SB.cx+13} ${SB.y-12}`}
                fill="none" stroke={C.green} strokeWidth="3.5" strokeLinecap="round" strokeLinejoin="round" opacity={routeHead}/>
            )}
          </g>
        )}
      </svg>

      {/* Píldora Cloudflare (atrezzo de la red edge) */}
      {cfP > 0 && (
        <div style={{position:'absolute', left:1360, top:196, zIndex:5,
          display:'inline-flex', alignItems:'center', gap:9, padding:'8px 15px',
          background:'#fff', border:'1px solid #E2E8F0', borderRadius:100,
          boxShadow:'0 8px 20px rgba(15,23,42,0.08)',
          opacity: clamp(cfP*1.3,0,1), transform:`translateY(${(1-cfE)*-10}px) scale(${lerp(0.8,1,cfE)})`}}>
          <span style={{width:22, height:22, borderRadius:6, background:'#F6821F',
            display:'flex', alignItems:'center', justifyContent:'center'}}>
            <svg width="14" height="10" viewBox="0 0 24 16" fill="#fff"><path d="M17 15 H5 A5 5 0 0 1 5 5 A6.5 6.5 0 0 1 17.5 6 A4.5 4.5 0 0 1 22 10.5 A4.5 4.5 0 0 1 17 15 Z"/></svg>
          </span>
          <span className="f-mono" style={{fontSize:13, fontWeight:700, color:C.ink}}>Cloudflare</span>
        </div>
      )}

      {/* Eyebrow "red global" bajo la banda */}
      {bandP > 0 && (
        <div className="f-mono" style={{position:'absolute', left:0, right:0, top:396, textAlign:'center', zIndex:5,
          fontSize:12, fontWeight:700, letterSpacing:'3.5px', color: glowK > 0 ? C.blue : C.grayL,
          opacity: clamp(bandP*1.3,0,1)}}>
          RED EDGE · TODO EL PLANETA
        </div>
      )}

      {/* ===== Servidores gemelos ===== */}
      <ServerCard rect={SA} name="Servidor A" appearP={saP} appearE={saE} isA={true}/>
      <ServerCard rect={SB} name="Servidor B" appearP={sbP} appearE={sbE} isA={false}/>

      {/* Etiquetas datacenter + atrezzo OVHcloud */}
      {dc1P > 0 && (
        <div style={{position:'absolute', left:SA.x, top:SA.y+SA.h+16, width:SA.w, textAlign:'center', zIndex:4,
          opacity:dc1E, transform:`translateY(${(1-dc1E)*8}px)`}}>
          <div className="f-mono" style={{fontSize:13, fontWeight:700, letterSpacing:'2px', color: dimA>0.4?C.grayL:C.gray}}>DATACENTER 1</div>
          <div style={{display:'inline-flex', alignItems:'center', gap:6, marginTop:8, padding:'4px 11px',
            background:'#fff', border:'1px solid #E2E8F0', borderRadius:100, boxShadow:'0 4px 10px rgba(15,23,42,0.05)'}}>
            <span style={{width:14, height:14, borderRadius:4, background:'#123F6D'}}/>
            <span className="f-mono" style={{fontSize:11, fontWeight:700, color:'#123F6D'}}>OVHcloud</span>
          </div>
        </div>
      )}
      {dc2P > 0 && (
        <div style={{position:'absolute', left:SB.x, top:SB.y+SB.h+16, width:SB.w, textAlign:'center', zIndex:4,
          opacity:dc2E, transform:`translateY(${(1-dc2E)*8}px)`}}>
          <div className="f-mono" style={{fontSize:13, fontWeight:700, letterSpacing:'2px', color:C.gray}}>DATACENTER 2</div>
          <div style={{display:'inline-flex', alignItems:'center', gap:6, marginTop:8, padding:'4px 11px',
            background:'#fff', border:'1px solid #E2E8F0', borderRadius:100, boxShadow:'0 4px 10px rgba(15,23,42,0.05)'}}>
            <span style={{width:14, height:14, borderRadius:4, background:'#123F6D'}}/>
            <span className="f-mono" style={{fontSize:11, fontWeight:700, color:'#123F6D'}}>OVHcloud</span>
          </div>
        </div>
      )}

      {/* Nodo usuario (origen del enrutado) */}
      {userP > 0 && (
        <div style={{position:'absolute', left:USER.x-56, top:USER.y-30, zIndex:5,
          display:'flex', flexDirection:'column', alignItems:'center', gap:7,
          opacity:clamp(userP*1.3,0,1), transform:`scale(${lerp(0.7,1,userE)})`}}>
          <div style={{width:52, height:52, borderRadius:100, background:'#fff', border:`1px solid ${C.border}`,
            boxShadow:'0 8px 20px rgba(15,23,42,0.10)', display:'flex', alignItems:'center', justifyContent:'center'}}>
            <svg width="26" height="26" viewBox="0 0 24 24" fill="none">
              <circle cx="12" cy="8" r="4" stroke={C.gray} strokeWidth="2"/>
              <path d="M4 21 C4 16 8 14 12 14 C16 14 20 16 20 21" stroke={C.gray} strokeWidth="2" strokeLinecap="round"/>
            </svg>
          </div>
          <span className="f-mono" style={{fontSize:11, fontWeight:700, letterSpacing:'1.5px', color:C.gray}}>USUARIO</span>
        </div>
      )}

      {/* Relevo: etiqueta gris del desvío A→B */}
      {dimA > 0.15 && (
        <div className="f-mono" style={{position:'absolute', left:0, right:0, top:474, textAlign:'center', zIndex:5,
          fontSize:12, fontWeight:700, letterSpacing:'2.5px', color:C.grayL,
          opacity: clamp((dimA-0.15)/0.4,0,1) * (1 - clamp((t-T.mundo)/0.6,0,1))}}>
          RELEVO AUTOMÁTICO →
        </div>
      )}

      {/* Apunte de contraste: IP única tachada (esto NO) */}
      {ipP > 0 && (
        <div style={{position:'absolute', left:730, top:452, width:460, zIndex:8,
          opacity: clamp(ipP*1.3,0,1) * (1 - 0.25*clamp((t-(T.glow+1))/0.6,0,1)),
          transform:`translateY(${(1-ipE)*12}px)`,
          display:'flex', alignItems:'center', gap:16, justifyContent:'center'}}>
          <div style={{position:'relative'}}>
            <div style={{display:'inline-flex', alignItems:'center', gap:9, padding:'10px 16px',
              background:'#fff', border:'1px dashed #CBD5E1', borderRadius:12, filter:'saturate(0.6)'}}>
              <span style={{width:9, height:9, borderRadius:100, background:C.grayL}}/>
              <span className="f-mono" style={{fontSize:14, fontWeight:700, color:C.gray}}>IP única</span>
            </div>
            <svg width="200" height="60" viewBox="0 0 200 60" style={{position:'absolute', left:'50%', top:'50%', transform:'translate(-50%,-50%)', pointerEvents:'none'}}>
              <line x1="6" y1="52" x2="194" y2="8" stroke={C.red} strokeWidth="3.5" strokeLinecap="round"
                pathLength="1" strokeDasharray="1" strokeDashoffset={1-ipStrike}/>
            </svg>
          </div>
          <span className="f-plex" style={{fontSize:15, fontWeight:500, color:C.gray}}>
            un punto que <span style={{color:'#DC2626', fontWeight:700}}>tirar</span>. Aquí no.
          </span>
        </div>
      )}

      {/* ===== Píldora de salida ===== */}
      {salP > 0 && (
        <div style={{position:'absolute', left:0, right:0, bottom:40, textAlign:'center', zIndex:20,
          opacity:clamp(salP*1.3,0,1), transform:`translateY(${(1-salE)*16}px)`}}>
          <span className="f-mono" style={{display:'inline-flex', alignItems:'center', gap:12,
            fontSize:14, fontWeight:700, letterSpacing:'2.5px', color:C.ink,
            background:'#fff', border:`1px solid ${C.border}`, borderRadius:100, padding:'12px 26px',
            boxShadow:'0 12px 30px rgba(15,23,42,0.10)'}}>
            TUS ARCHIVOS
            <span style={{color:C.blue, fontSize:16}}>→</span>
          </span>
        </div>
      )}
    </SlideCanvas>
  );
}
Object.assign(window, { EscenaIN04 });
