/* ==========================================================================
   MEDUSA AI · animación
   Fase 3.1: la apertura. La página abre vacía, la cara se dibuja sola y solo
   entonces aparecen los textos.

   La cara tiene dos capas (assets/svg/symbol_trazo.svg y symbol_partes.svg):
   · 'trazo' (docs/03): cada pieza se recorre como una linea con
     stroke-dashoffset desde su nodo hasta la cara, en orden de anillo desde
     el tentaculo de arriba; al acabar, el relleno de verdad se funde encima
     y el trazo se retira. js/apertura.js mide cada pieza y pone --largo.
   · 'elementos': cada pieza rellena crece desde su nodo (lo de antes).

   Los tiempos NO están aquí: salen de js/config.js.
   ========================================================================== */

/* El trazo no existe hasta que js/apertura.js dibuja con el. Sin el prefijo
   .js a proposito: sin JavaScript se ve solo el relleno, que es el simbolo. */
.cara__trazo { display: none; }

/* Sin JavaScript no se esconde nada: la página se lee entera */
.js .cara .cara__relleno path {
  clip-path: circle(0% at var(--nodo, 50% 50%));
}

.js .cara--dibujada .cara__relleno path {
  clip-path: circle(140% at var(--nodo, 50% 50%));
  transition: clip-path var(--paso, 300ms) cubic-bezier(.22, .61, .36, 1) var(--retardo, 0ms);
}

/* Estrategia 'trazo': el relleno no se destapa por piezas, espera entero
   y se funde al final; cada linea se recorre con el dashoffset. */
.js .cara--trazo .cara__trazo { display: block; }
.js .cara--trazo .cara__relleno path {
  clip-path: none;
  transition: none;
}
.js .cara--trazo .cara__relleno { opacity: 0; }
.js .cara--trazo .cara__trazo path {
  stroke-dasharray: var(--largo, 1);
  stroke-dashoffset: var(--oculto, 0);
}
.js .cara--trazo.cara--dibujada .cara__trazo path {
  stroke-dashoffset: 0;
  transition: stroke-dashoffset var(--paso, 300ms) cubic-bezier(.22, .61, .36, 1) var(--retardo, 0ms);
}
.js .cara--trazo.cara--rellena .cara__relleno {
  opacity: 1;
  transition: opacity var(--relleno, 300ms) ease;
}
.js .cara--trazo.cara--rellena .cara__trazo {
  opacity: 0;
  transition: opacity var(--relleno, 300ms) ease;
}

/* El guiño (#20): el «ojo» derecho se aplana sobre su propio centro y
   vuelve, una vez. Lo dispara js/apertura.js con cara--guina; tiempos en
   CONFIG.apertura.guino. Es relleno, no trazo: no hace falta vector-effect.
   Excepcion de marca autorizada por Vicenç (14/10): solo en esta cara. */
.apertura__cara .cara__ojo {
  transform-box: fill-box;
  transform-origin: center;
}
@keyframes cara-guino {
  0%, 100% { transform: scaleY(1); }
  45%, 55% { transform: scaleY(var(--guino-cierre, 0.08)); }
}
.js .apertura__cara.cara--guina .cara__ojo {
  animation: cara-guino var(--guino, 420ms) cubic-bezier(0.4, 0, 0.2, 1) 1;
}

.js .apertura__texto > * {
  opacity: 0;
}

.js .apertura--abierta .apertura__texto > * {
  opacity: 1;
  transition: opacity var(--fundido, 400ms) ease;
}

/* Con movimiento reducido, la web se lee entera sin animación: la cara
   dibujada y los textos visibles desde el principio (docs/03 §7). */
@media (prefers-reduced-motion: reduce) {
  .js .cara .cara__relleno path,
  .js .cara--dibujada .cara__relleno path {
    clip-path: none;
    transition: none;
  }
  .js .cara .cara__trazo { display: none; }
  .js .apertura__cara.cara--guina .cara__ojo { animation: none; }
  .js .cara .cara__relleno { opacity: 1; transition: none; }
  .js .apertura__texto > * {
    opacity: 1;
    transition: none;
  }
}


/* ==========================================================================
   ENTRADAS AL SUBIR
   El patron del bloque 2, que el 3 reutiliza: la pieza entra al asomar por
   el umbral de pantalla, con un desplazamiento hacia arriba y un fundido.
   Lo lleva js/entradas.js y los valores salen de CONFIG.bloque2.

   El pulso de la cara de la esquina que pedia docs/05 §3.3 no aplica: la
   cara acompanante se retiro por decision de Albert el 22/09.
   ========================================================================== */

.js .entra-al-subir {
  opacity: 0;
  transform: translateY(var(--desplazamiento, 20px));
}

.js .entra-al-subir.entra {
  opacity: 1;
  transform: none;
  transition: opacity var(--fundido, 500ms) ease,
              transform var(--fundido, 500ms) ease;
}


/* ==========================================================================
   Fase 3.4 · el bloque 3
   La pregunta ocupa una pantalla y se queda fija media pantalla mas antes de
   soltarse. El alto de mas del anclaje ES esa media pantalla, y lo fija
   js/bloque3.js desde CONFIG.
   ========================================================================== */

.js .pregunta__anclaje {
  height: calc(100svh + var(--fijado, 0px));
}

/* min-height y no height: si el contenido no cabe en una ventana baja, la
   pantalla crece y el anclaje dura menos, en vez de pisar la banda «No». */
.js .pregunta__pantalla {
  position: sticky;
  top: 0;
  min-height: 100svh;
}

/* El subtitulo de la frontera entra por abajo mientras la pantalla esta
   anclada: --avance va de 0 (llega) a 1 (se suelta), y lo escribe
   js/bloque3.js desde la posicion del scroll. Sin JS no hay --avance y el
   valor de reserva lo deja visible. */
.js .pregunta__frontera {
  opacity: var(--avance, 1);
  transform: translateY(calc((1 - var(--avance, 1)) * var(--desplazamiento, 20px)));
}

/* Las tres bandas en tres tramos. Solo cuando js/bloque3.js pone --viva en
   .frontera: el anclaje de cada caso mide una pantalla mas el tramo fijo
   (caso + entrada + pausa, en --tramo-caso); la pantalla se queda pegada
   con el caso centrado; y la banda, que espera debajo, sube LIGADA AL
   SCROLL: --subida va de 0 a 1 a lo largo del tramo de entrada, con
   suavizado, y la escribe bloque3.js en cada fotograma desde la posicion.
   Si el usuario para a mitad, la banda se queda a mitad. Cuando cubre la
   pantalla (--resuelto), empieza la pausa y el punto de la linea se
   desliza. */
.js .frontera--viva .caso__anclaje {
  height: calc(100svh + var(--tramo-caso, 0px));
}

.js .frontera--viva .caso__pantalla {
  position: sticky;
  top: 0;
  height: 100svh;
  display: grid;
  align-content: center;
  overflow: hidden;
}

.js .frontera--viva .caso__pantalla .frontera__caso {
  position: absolute;
  inset: 0;
  margin: 0;
  display: flex;
  flex-direction: column;
  justify-content: center;
  transform: translateY(calc((1 - var(--subida, 0)) * 100%));
}

.js .frontera--viva .caso--resuelto .frontera__caso {
  transform: translateY(0);
}

/* El punto de la linea: mientras la banda esta entrando NO se ve. Cuando la
   banda cubre la pantalla (--resuelto) aparece en el centro de la linea, con
   un fundido de --fundido-punto, y desde ahi se desliza en --punto-caso ms,
   con desaceleracion suave y sin rebote, hasta su posicion: hacia la
   medusa en «No», hacia «Tu» en «Si», y en «A medias» se queda. El tramo
   coloreado va de la medusa al punto y lo acompana (en «Si», la linea sigue
   gris). El estado —resuelto o no— sale de la posicion del scroll; esto es
   solo el trayecto. */
.js .frontera--viva .caso .linea__punto:not(.resumen__punto),
.js .frontera--viva .caso .linea__llena {
  transition: opacity var(--fundido-punto, 150ms) ease,
              left  var(--punto-caso, 500ms) cubic-bezier(0.25, 0.1, 0.25, 1) var(--fundido-punto, 150ms),
              width var(--punto-caso, 500ms) cubic-bezier(0.25, 0.1, 0.25, 1) var(--fundido-punto, 150ms);
}
.js .frontera--viva .caso:not(.caso--resuelto) .linea__punto:not(.resumen__punto) { left: 50%; opacity: 0; }
.js .frontera--viva .caso:not(.caso--resuelto) .linea__llena { width: calc(var(--lleno-inicio, 0.5) * 100%); opacity: 0; }

/* El resumen, al final de la banda «Si»: --resumen va de 0 a 1 con el
   scroll (lo escribe bloque3.js). El texto de la banda se desvanece, la
   linea sube hasta el centro de la pantalla (--desplaza-resumen, medido) y
   la frase de cierre aparece debajo. Cuando el texto ya se ha ido
   (--resumen ≥ 0,5, clase --resumen) entran los otros dos puntos, uno tras
   otro con --escalon-resumen, y las tres etiquetas con ellos. */
.js .frontera--viva .frontera__caso--si .frontera__texto {
  opacity: calc(1 - var(--resumen, 0));
}
.js .frontera--viva .frontera__caso--si .frontera__resumen {
  transform: translateY(calc(var(--resumen, 0) * var(--desplaza-resumen, 0px)));
}
.js .frontera--viva .frontera__caso--si .pregunta__cierre {
  position: absolute;
  top: 100%;
  left: 0;
  right: 0;
  opacity: var(--resumen, 0);
}
.js .frontera--viva .resumen__punto,
.js .frontera--viva .linea__etiqueta {
  opacity: 0;
  transition: opacity var(--fundido, 500ms) ease, transform var(--fundido, 500ms) ease;
}
.js .frontera--viva .resumen__punto { transform: scale(0.5); }
.js .frontera--viva .caso--resumen .resumen__punto { opacity: 1; transform: none; }
/* solo la opacidad: el transform de la etiqueta es su centrado */
.js .frontera--viva .caso--resumen .linea__etiqueta { opacity: 1; }
.js .frontera--viva .caso--resumen .resumen__punto--medias,
.js .frontera--viva .caso--resumen .resumen__punto--medias .linea__etiqueta { transition-delay: var(--escalon-resumen, 150ms); }
.js .frontera--viva .caso--resumen .linea__etiqueta--si { transition-delay: calc(2 * var(--escalon-resumen, 150ms)); }

/* La criatura respira y deriva mientras la pregunta esta en pantalla, con
   los mismos valores que en el cierre: es la misma criatura. Solo cuando
   js/bloque3.js pone --viva; sin JavaScript o con movimiento reducido,
   quieta. Los @keyframes respirar estan en la fase 3.8, mas abajo. */
.js .pregunta--viva .pregunta__criatura-caja {
  transform: translate3d(var(--deriva-x, 0), var(--deriva-y, 0), 0)
             rotate(var(--deriva-giro, 0deg));
}

.js .pregunta--viva .pregunta__criatura {
  animation: respirar calc(var(--respira-dur, 5000ms) / 2) ease-in-out infinite alternate;
}


@media (prefers-reduced-motion: reduce) {
  .js .entra-al-subir,
  .js .entra-al-subir.entra {
    opacity: 1;
    transform: none;
    transition: none;
  }
  /* Los puntos de la linea, ya colocados; el resumen, completo. Con
     movimiento reducido --viva no se pone nunca, asi que nada que deshacer. */
  /* Sin fijado: la pregunta pasa como un bloque mas */
  .js .pregunta__anclaje { height: auto; }
  .js .pregunta__pantalla { position: static; height: auto; min-height: 100svh; }
  .js .pregunta__frontera { opacity: 1; transform: none; }
}


/* ==========================================================================
   Fase 3.5 · el bloque 4, las siete estaciones

   Todo queda pegado a la pantalla mientras se recorren las siete. El alto del
   anclaje ES la suma de sus distancias, y lo pone js/bloque4.js desde CONFIG.

   Tres capas, como manda docs/04 §0: la criatura, el barrido del trazo y la
   deriva, que mueve las dos primeras juntas.
   ========================================================================== */

/* Nada se esconde hasta que js/bloque4.js dice que toma el mando, poniendo
   la clase --vivas. Asi, si ese archivo no carga o se rinde, el bloque se lee
   apilado y entero: no hay forma de que quede invisible. */
.js .estaciones--vivas {
  height: var(--alto-estaciones, auto);
}

.js .estaciones--vivas .estaciones__fijo {
  position: sticky;
  top: 0;
  height: 100svh;
  display: grid;
  grid-template-rows: auto auto minmax(0, 1fr);
  gap: var(--espacio-2);
  padding-block: var(--espacio-3);
}

/* La criatura ocupa el hueco que ocupara el video. Su alto lo decide
   js/bloque4.js por fase y por estacion (se encoge si lo de debajo no
   cabe); lo escribe en --alto-criatura sobre el anclaje, y el cambio se
   hace con la misma duracion que la entrada de la estacion. En el puente
   no se ve: la frase va sola. */
.js .estaciones--vivas .criatura {
  height: var(--alto-criatura, auto);   /* UNA para todo el bloque; la decide medir() */
  transition: opacity var(--entrada, 350ms) ease;
}
/* En el puente y su salida la criatura no esta, y se esconde en seco: solo
   aparece —fundida— cuando la frase ya se ha ido del todo */
.js .estaciones--vivas.estaciones--puente .criatura,
.js .estaciones--vivas.estaciones--puente-salida .criatura { opacity: 0; transition: none; }

/* --- la presentacion, sobre la misma reticula que el fijo ---------------- */

/* Va en absoluto sobre la pantalla fija, con la misma reticula (criatura,
   indicador, textos), para que la lista y la regla caigan exactamente en
   la zona de los textos y la criatura no se mueva al empezar las
   estaciones. Nada se ve salvo lo que la fase encienda. */
.js .estaciones--vivas .presentacion {
  position: absolute;
  inset: 0;
  margin: 0;
  padding-block: var(--espacio-3);
  display: grid;
  grid-template-rows: var(--alto-criatura, auto) var(--alto-progreso, 6px) minmax(0, 1fr);
  gap: var(--espacio-2);
  pointer-events: none;
}
.js .estaciones--vivas .presentacion > * {
  opacity: 0;
  transition: opacity var(--entrada, 350ms) ease;
}
/* Los tres en la unica columna: sin decirlo, el grid colocaba la lista en
   una columna implicita a la derecha, estrecha */
.js .estaciones--vivas .presentacion__puente { grid-column: 1; grid-row: 1 / -1; align-self: center; }
.js .estaciones--vivas .presentacion__lista  { grid-column: 1; grid-row: 3; align-self: start; }
.js .estaciones--vivas .presentacion__regla  { grid-column: 1; grid-row: 3; align-self: center; }

/* La salida del puente: la frase se va ligada al scroll (--puente, de 1 a
   0), sin transicion de tiempo; en la lista ya esta a 0 y ahi se queda */
.js .estaciones--vivas.estaciones--puente-salida .presentacion__puente {
  opacity: var(--puente, 1);
  transition: none;
}
.js .estaciones--vivas.estaciones--puente .presentacion__puente,
.js .estaciones--vivas.estaciones--lista  .presentacion__lista,
.js .estaciones--vivas.estaciones--calma  .presentacion__lista,
.js .estaciones--vivas.estaciones--regla  .presentacion__regla { opacity: 1; }

/* La despedida: la lista se va LIGADA AL SCROLL (--despedida, 0 → 1, lo
   escribe bloque4.js), sin transicion de tiempo, para que la regla solo
   entre cuando la lista ya no esta. */
.js .estaciones--vivas.estaciones--despedida .presentacion__lista {
  opacity: calc(1 - var(--despedida, 0));
  transition: none;
}
/* Y nunca lista y regla a la vez, tampoco en un salto: al entrar en la
   regla la lista se apaga en seco (sin arrastrar un fundido desde donde
   estuviera), y al volver a la despedida es la regla la que se apaga en
   seco mientras la lista vuelve por posicion. */
.js .estaciones--vivas.estaciones--regla .presentacion__lista { opacity: 0; transition: none; }
.js .estaciones--vivas.estaciones--despedida .presentacion__regla,
.js .estaciones--vivas.estaciones--calma .presentacion__regla,
.js .estaciones--vivas.estaciones--lista .presentacion__regla { transition: none; }

/* Las lineas van apareciendo una a una y se quedan. La que aun no ha
   llegado no ocupa sitio —alto 0 y el hueco del flex anulado—, para que
   no haya huecos ni fantasmas debajo de las que ya estan; al llegarle el
   turno entra en su posicion definitiva con un fundido y 8 px de subida. */
.js .estaciones--vivas .presentacion__agente {
  opacity: 0;
  transform: translateY(var(--espacio-1));
  height: 0;
  overflow: hidden;
  margin-top: calc(-1 * var(--espacio-1));
  transition: opacity var(--linea-fundido, 300ms) ease, transform var(--linea-fundido, 300ms) ease;
}
.js .estaciones--vivas .presentacion__agente--visto {
  opacity: 1;
  transform: none;
  height: auto;
  overflow: visible;
  margin-top: 0;
}

/* La calma: los nueve nodos y la cara encendidos a la vez (lo escribe
   bloque4.js en el barrido) y la criatura respirando, en sus dos capas a la
   vez para que el barrido no se separe de la base. En la despedida vuelven
   a tenue con el scroll, a la vez que la lista. */
.js .estaciones--vivas.estaciones--calma .criatura__capa {
  animation: respirar calc(var(--respira-calma, 2000ms) / 2) ease-in-out infinite alternate;
}
/* En la despedida, la opacidad de los nodos y de la cara la escribe
   bloque4.js desde la posicion (1 → 0 con la lista): sin transicion. */
/* En la lista, el tentaculo que se enciende espera --tentaculo-retardo y
   entra fundido, para que el nombre se lea antes que el color tambien en
   un salto; el que se apaga lo hace en seco (bloque4.js le quita la
   visibilidad, que no transiciona). */
.js .estaciones--vivas.estaciones--lista .barrido {
  transition: opacity var(--tentaculo-retardo, 150ms) ease var(--tentaculo-retardo, 150ms);
}

/* --- el cierre del bloque: la criatura crece y el equipo se enciende ---- */

/* En el cierre la criatura baja hasta centrar el conjunto (--baja-criatura,
   medido por bloque4.js) mientras crece al tamano de la presentacion; las
   dos frases van en absoluto bajo ella (--cierre-texto-top) y entran, la
   primera cuando la criatura ha terminado de crecer (clase --cierre-listo;
   tras un salto, ademas, cuando acaba la recuperacion: --espera-cascada) y
   la segunda --garantia-retardo despues. Con animaciones
   de fill-mode both: acaban siempre en su ultimo fotograma. */
.js .estaciones--vivas .cierre-equipo {
  position: absolute;
  left: 0; right: 0;
  top: var(--cierre-texto-top, 60%);
  margin: 0;
  pointer-events: none;
}
.js .estaciones--vivas .cierre-equipo > * { opacity: 0; }
.js .estaciones--vivas.estaciones--cierre-listo .cierre-equipo__titular {
  animation: aparece var(--titular-fundido, 400ms) ease var(--espera-cascada, 0ms) both;
}
.js .estaciones--vivas.estaciones--cierre-listo .cierre-equipo__garantia {
  animation: aparece var(--titular-fundido, 400ms) ease calc(var(--espera-cascada, 0ms) + var(--garantia-retardo, 300ms)) both;
}
/* En el cierre no hay estaciones ni indicador */
.js .estaciones--vivas.estaciones--cierre .progreso { opacity: 0; }
.js .estaciones--vivas.estaciones--cierre .criatura__capa {
  animation: respirar calc(var(--respira-calma, 2000ms) / 2) ease-in-out infinite alternate;
}

/* Mientras se presenta, el indicador de las estaciones no esta */
.js .estaciones--vivas.estaciones--presentando .progreso { opacity: 0; }
.js .estaciones--vivas .progreso { transition: opacity var(--entrada, 350ms) ease; }

/* La deriva: el vaiven lo escribe el JavaScript en estas dos variables */
.js .estaciones--vivas .criatura {
  /* --baja-criatura: cuanto baja en el cierre para centrar el conjunto */
  transform: translate3d(var(--deriva-x, 0), calc(var(--deriva-y, 0px) + var(--baja-criatura, 0px)), 0)
             rotate(var(--deriva-giro, 0deg));
}

/* La capa del barrido solo existe cuando el JavaScript lleva el mando */
.js .estaciones--vivas .criatura__barrido { display: block; }

/* El barrido arranca apagado y se recorre desde el nodo del tentaculo */
.js .estaciones--vivas .barrido {
  clip-path: circle(0% at var(--nodo, 50% 50%));
  opacity: 0;
}

/* --- las estaciones, apiladas en el mismo sitio -------------------------- */

.js .estaciones--vivas .estaciones__textos {
  position: relative;
  overflow: hidden;
}

/* El relevo: la estacion que esta SALE en --salida ms, y la que llega ENTRA
   en --entrada ms pero empezando cuando la otra ya ha salido (el retardo es
   la salida). Asi no hay ni un fotograma con dos agentes a la vez. Los dos
   valores los escribe js/bloque4.js desde CONFIG.bloque4.fundido.

   Van con ANIMACIONES y no con transiciones, a proposito: una animacion
   arranca siempre desde su primer fotograma y, con fill-mode both, acaba
   siempre en el ultimo, pase lo que pase con el estado anterior; una
   transicion parte del valor que hubiera y, si el navegador la retarga a
   medio camino (WebKit al cambiar la duracion en el mismo cambio de
   clase), puede quedarse a medias hasta el siguiente cambio. El estado
   final —quien esta y quien no— lo pone bloque4.js desde la posicion en
   cada fotograma; esto es solo el trayecto. */
.js .estaciones--vivas .estacion {
  position: absolute;
  inset: 0;
  opacity: 0;
  transform: translateY(var(--desplazamiento, 20px));
  pointer-events: none;

  /* En columna, con los pares quedandose todo el hueco que sobra. Sin esto
     el contenedor de pares colapsa a cero —sus hijos van en absoluto— y el
     pie de ficha se sienta encima del par. */
  display: flex;
  flex-direction: column;
  gap: var(--espacio-2);
}

/* La que se va (la clase --saliendo la pone bloque4.js a la que acaba de
   dejar de estar activa) se funde en --salida; la que llega entra en
   --entrada tras esperar --salida. Las demas, a cero sin animar. */
.js .estaciones--vivas .estacion--saliendo {
  animation: estacion-sale var(--salida, 150ms) ease both;
}
.js .estaciones--vivas .estacion--activa {
  pointer-events: auto;
  animation: estacion-entra var(--entrada, 350ms) ease var(--salida, 150ms) both;
}
@keyframes estacion-entra {
  from { opacity: 0; transform: translateY(var(--desplazamiento, 20px)); }
  to   { opacity: 1; transform: none; }
}
@keyframes estacion-sale {
  from { opacity: 1; transform: none; }
  to   { opacity: 0; transform: translateY(var(--desplazamiento, 20px)); }
}
@keyframes aparece {
  from { opacity: 0; }
  to   { opacity: 1; }
}

/* El cuerpo de la estacion —promesa, laminas y «donde para»— es lo que
   avanza con el scroll cuando no cabe (--desliza, de bloque4.js), recortado
   por su propia caja: la cabecera queda siempre entera y en su sitio, bajo
   el indicador. */
.js .estaciones--vivas .estacion__cuerpo {
  flex: 1;
  min-height: 0;
  overflow: hidden;
}
.js .estaciones--vivas .estacion__cuerpo > * {
  transform: translateY(calc(-1 * var(--desliza, 0px)));
}

/* Dentro de una estacion, sus laminas tambien se turnan, con el mismo
   relevo. La caja mide lo que mide la lamina mas alta —lo escribe
   js/bloque4.js en --alto-laminas—, no todo el hueco que sobra: asi la
   ficha va pegada al titular y no queda media pantalla vacia cuando toca
   el pie. Si una lamina no cabe, se recorta y se desliza con el scroll. */
.js .estaciones--vivas .estacion__pares {
  position: relative;
  flex: none;
  height: var(--alto-laminas, auto);   /* la de la lamina que toca; la escribe js/bloque4.js */
  overflow: hidden;
  transition: height var(--entrada, 350ms) ease;
}
.js .estaciones--vivas .estacion .par {
  position: absolute;
  inset: 0;
  opacity: 0;   /* la que no toca, a cero en seco */
}
.js .estaciones--vivas .estacion .par--activo {
  animation: aparece var(--entrada, 350ms) ease var(--salida, 150ms) both;
}

/* «Donde para» —lo que el agente NO hace— entra debajo de la ultima ficha
   cuando la estacion llega a su tramo final (clase --limite, que pone
   js/bloque4.js desde la posicion), y conviven. Escondido no ocupa sitio:
   alto 0 y el hueco del flex anulado, para que no deje un vacio debajo de
   la ficha. Si en esta pantalla no caben ficha y pie (lo mide
   bloque4.js), la estacion lleva ademas --sin-ficha: la caja de laminas se
   cierra y el pie sube a pegarse al titular. */
.js .estaciones--vivas .estacion__limite {
  opacity: 0;
  height: 0;
  overflow: hidden;
  margin-top: calc(-1 * var(--espacio-2));
}
.js .estaciones--vivas .estacion--limite .estacion__limite {
  height: auto;
  overflow: visible;
  margin-top: 0;
  animation: aparece var(--entrada, 350ms) ease var(--salida, 150ms) both;
}
.js .estaciones--vivas .estacion--sin-ficha .estacion__pares {
  height: 0;
  margin-bottom: calc(-1 * var(--espacio-2));
}

/* Los puntos cuentan lo mismo que la criatura (#21): los de las estaciones
   ya vistas, llenos; el actual, ademas, mas grande. En el cierre, los nueve
   llenos. Siguen en turquesa tenue: no llevan color de agente. */
.js .progreso__punto--lleno { opacity: 1; }
.js .progreso__punto--activo { opacity: 1; transform: scale(1.5); }

/* Un tentaculo que un salto de scroll ha pasado de largo no aparece de
   golpe: se completa desde su nodo en --recupera, y si son varios, en
   cascada (--escalon). Animacion y no transicion: arranca siempre en su
   primer fotograma, y con fill-mode both espera oculto su turno. Mientras
   dura manda sobre el clip-path en linea; al acabar, el de la posicion. */
@keyframes barrido-alcanza {
  from { clip-path: circle(calc(var(--alcance-barrido, 140%) * var(--desde-barrido, 0)) at var(--nodo, 50% 50%)); }
  to   { clip-path: circle(var(--alcance-barrido, 140%) at var(--nodo, 50% 50%)); }
}
.js .estaciones--vivas .barrido--alcanza {
  animation: barrido-alcanza var(--recupera, 450ms) cubic-bezier(0.25, 0.1, 0.25, 1) var(--escalon, 0ms) both;
}
.js .progreso__punto { transition: opacity var(--progreso, 200ms) ease, transform var(--progreso, 200ms) ease; }


@media (prefers-reduced-motion: reduce) {
  /* Siete estaciones apiladas y visibles, criatura quieta, sin anclaje ni
     deriva (docs/05 §3.5). Con la clase --vivas no se llega a poner nunca,
     asi que no hay nada que deshacer: solo se ocultan las piezas que no
     tienen sentido sin movimiento. */
  .js .progreso { display: none; }
  /* La criatura con los siete tentaculos encendidos, quietos, sin barrido
     ni respiracion: es la «calma» de la presentacion, que aqui no tiene
     tramo. Decision de Albert (23/09); ya era excepcion aceptada ver mas
     de dos colores de agente en el estado apilado. */
  .js .criatura__barrido { display: block; }
  .js .barrido { clip-path: none; opacity: 1; }
  .js .barrido--cara { opacity: 0; }   /* la cara, en tenue: no es momento de equipo */
}


/* ==========================================================================
   Fase 3.8 · el cierre
   La criatura late despacio y deriva, hasta que llegue el video. Nada se
   anima hasta que js/bloque6.js pone --vivo: sin JavaScript o con movimiento
   reducido, quieta.
   ========================================================================== */

/* El cierre anclado: el anclaje mide una pantalla mas los tres tramos
   (--tramo-cierre, de bloque6.js); la pantalla se queda pegada con todo
   en su sitio. Reticula: criatura · zona del titular · boton y nota · linea
   legal al pie. El logotipo de la firma va en la misma celda que el
   titular: cuando el titular se ha ido, ahi aterriza la criatura y ahi
   aparece el rotulo. */
.js .cierre--vivo.cierre { padding-bottom: 0; }   /* la pantalla llega al final de la pagina */
.js .cierre--vivo .cierre__anclaje {
  height: calc(100svh + var(--tramo-cierre, 0px));
}
.js .cierre--vivo .cierre__pantalla {
  position: sticky;
  top: 0;
  min-height: 100svh;
  display: grid;
  grid-template-rows: auto minmax(0, 1fr) auto auto;
  grid-template-columns: 100%;
  align-items: center;
  justify-items: center;
  row-gap: var(--espacio-6);
  padding-block: var(--espacio-3);
}
.js .cierre--vivo .cierre__criatura-caja { grid-row: 1; margin: 0; }
.js .cierre--vivo .cierre__remate        { grid-row: 2; grid-column: 1; }
.js .cierre--vivo .cierre__accion        { grid-row: 3; margin: 0; }
.js .cierre--vivo .cierre__firma         { display: contents; }
.js .cierre--vivo .firma__lockup         { grid-row: 2; grid-column: 1; }
.js .cierre--vivo .cierre__firma .anotacion { grid-row: 4; align-self: end; margin-top: var(--espacio-2); }  /* 48 + 16 = 64 */
/* La criatura, al ancho que deje sitio a todo lo demas en una pantalla
   (--ancho-criatura-cierre, de bloque6.js); de reserva, su medida de siempre */
.js .cierre--vivo .cierre__criatura-caja { width: var(--ancho-criatura-cierre, min(58%, 200px)); }

/* Fase de salida: el titular y la pregunta se van por arriba —se funden
   mientras suben un modulo de tres— ligados al scroll (--salida de 0 a 1).
   No recorren la pantalla entera: cruzarian la criatura, que esta encima. */
.js .cierre--vivo .cierre__remate {
  transform: translateY(calc(-1 * var(--salida, 0) * var(--espacio-3)));
  opacity: calc(1 - var(--salida, 0));
}
.js .cierre--vivo .cierre__remate.entra { transition: none; }   /* manda la posicion */

/* Fase de viaje: la criatura deriva y, cuando el titular ya no esta, viaja
   hasta la cara del logotipo —--viaje-x/y y --viaje-escala los escribe
   js/bloque6.js desde la posicion del scroll— mientras --viaje enciende la
   cara blanca. Al llegar (--firmado) se queda quieta: sin deriva ni
   respiracion. */
.js .cierre--vivo .cierre__criatura-caja {
  transform: translate3d(calc(var(--deriva-x, 0px) + var(--viaje-x, 0px)),
                         calc(var(--deriva-y, 0px) + var(--viaje-y, 0px)), 0)
             rotate(var(--deriva-giro, 0deg))
             scale(var(--viaje-escala, 1));
}
.js .cierre--vivo.cierre--firmado .cierre__criatura-caja {
  transform: translate3d(var(--viaje-x, 0px), var(--viaje-y, 0px), 0)
             scale(var(--viaje-escala, 1));
}

.js .cierre--vivo .cierre__criatura {
  /* --respira-dur es el ciclo ENTERO, ida y vuelta, como lo escribe el
     documento. Con alternate cada sentido dura la mitad. */
  animation: respirar calc(var(--respira-dur, 5000ms) / 2) ease-in-out infinite alternate;
}
.js .cierre--vivo.cierre--firmado .cierre__criatura { animation: none; }

/* La firma: el logotipo va recortado a su rotulo (la cara la trae la
   criatura) y aparece, fundido, cuando la criatura ha llegado. El corte cae
   a mitad del aire entre la cara y el rotulo del archivo oficial (filas
   1033 a 1194 de 1582). */
.js .cierre--vivo .firma__lockup {
  clip-path: inset(70.4% 0 0 0);
  opacity: 0;
}
.js .cierre--vivo.cierre--firmado .firma__lockup {
  animation: aparece var(--rotulo-fundido, 400ms) ease both;
}

/* El gancho del boton: hoy un pulso de opacidad; manana los ojos del video */
.js .cierre--vivo .criatura--pulso {
  animation: pulso var(--pulso, 200ms) ease-in-out;
}

@keyframes pulso {
  0%, 100% { opacity: 1; }
  50%      { opacity: 0.55; }
}


/* ==========================================================================
   Fase 4 · el bloque 3 en escritorio: la frontera en tres columnas
   Misma consulta que css/bloques.css (CONFIG.escritorio.anchoMinimo y
   ventana apaisada). Solo cuando js/bloque3.js pone --columnas: la escena
   (las tres columnas) se queda pegada a la pantalla mientras se recorre su
   tramo (--tramo-escena). Las columnas esperan apagadas en su sitio
   —insinuadas, nunca fuera del flujo, para que nada salte— y se encienden
   una a una (caso--encendido); el punto de la linea comun va a la ultima
   encendida; con --resumen pasan a tenue y entra el resumen.
   Las columnas se encienden con ANIMACION, no con transicion (ver el
   relevo del bloque 4): empieza en su primer fotograma pase lo que pase.
   ========================================================================== */

/* La luz de una tarjeta: 1 encendida, 0 apagada. Apagada es invisible del
   todo (ni texto a medio contraste ni un marco vacio, que se leia como
   «falta por cargar», Albert 03/10), pero su hueco sigue reservado. El
   caso, encima, se ve siempre. Va en una variable registrada para poder
   animarla; la llevan el caso, el texto de la tarjeta y el blanco de su
   fondo, pero NO el resumen, que vive dentro de la tarjeta del «Si» y no
   debe apagarse con ella. Las encendidas siguen encendidas en el resumen. */
@property --luz {
  syntax: '<number>';
  inherits: true;
  initial-value: 1;
}

/* Solo luz, sin desplazamiento: un transform en la columna del «Si»
   cambiaria la caja de referencia del resumen, que va dentro, y lo haria
   saltar mientras dura la animacion */
@keyframes columna-enciende {
  from { --luz: 0; }
  to   { --luz: 1; }
}
@keyframes resumen-entra {
  from { opacity: 0; }
  to   { opacity: 1; }
}

@media (min-width: 768px) and (min-height: 500px) and (orientation: landscape) {
  .js .frontera--columnas {
    height: calc(100svh + var(--tramo-escena, 0px));
  }
  .js .frontera--columnas .frontera__escena {
    position: sticky;
    top: 0;
    height: 100svh;
    align-content: center;
    padding-top: var(--espacio-6);
  }

  /* Los anclajes y las bandas de movil, desmontados: aqui la columna es
     solo el caso y su tarjeta, en su sitio */
  .js .frontera--columnas .caso__anclaje { height: auto; }
  .js .frontera--columnas .caso--medias .caso__anclaje { height: 100%; }
  .js .frontera--viva.frontera--columnas .caso__pantalla {
    position: static;
    height: auto;
    display: flex;
    overflow: visible;
  }
  .js .frontera--viva.frontera--columnas .caso--medias .caso__pantalla { height: 100%; }
  .js .frontera--viva.frontera--columnas .caso__pantalla .frontera__caso {
    position: static;
    inset: auto;
    transform: none;
  }

  /* La luz */
  .js .frontera--columnas .caso { --luz: 0; }
  .js .frontera--columnas .caso--encendido {
    animation: columna-enciende var(--fundido-columna, 400ms) ease-out both;
  }
  /* Los tres CASOS se ven desde que llega la escena, como preguntas sin
     responder; lo que se enciende es la tarjeta con el veredicto (Albert,
     03/10). La pantalla no queda a medias y el lector intenta responder
     antes de leer la respuesta. */
  .js .frontera--columnas .frontera__caso > :not(.frontera__resumen) { opacity: var(--luz); }
  .js .frontera--columnas .frontera__caso { background: rgb(255 255 255 / var(--luz)); }

  /* La linea comun: un solo punto, el de «El precio», hace de punto de la
     frontera mientras se encienden las columnas. Antes de la primera,
     escondido. Las lineas llenas de movil no se usan. */
  .js .frontera--viva.frontera--columnas .caso--si .frontera__resumen .linea__punto:not(.resumen__punto) {
    left: calc(var(--punto-x, 0) * 100%);
    opacity: 1;
    transition: left var(--punto-columna, 500ms) cubic-bezier(0.25, 0.1, 0.25, 1),
                opacity var(--fundido-punto, 150ms) ease;
  }
  .js .frontera--viva.frontera--columnas:not(.frontera--con-punto) .caso--si .frontera__resumen .linea__punto:not(.resumen__punto) {
    opacity: 0;
    transition: none;
  }
  .js .frontera--columnas .linea__llena { display: none; }

  /* La frase de cierre, bajo la linea: entra con el resumen */
  .js .frontera--viva.frontera--columnas .frontera__caso--si .pregunta__cierre {
    position: static;
    opacity: 0;
  }
  .js .frontera--viva.frontera--columnas.frontera--resumen .frontera__caso--si .pregunta__cierre {
    animation: resumen-entra var(--fundido-columna, 400ms) ease-out both;
  }
}


/* ==========================================================================
   Fase 4 · el bloque 4 en escritorio: la criatura a la derecha
   Misma consulta que css/bloques.css. La pantalla fija en dos columnas:
   los textos (indicador y estacion; la presentacion encima, en la misma
   celda) a la izquierda, y la criatura a la derecha, en una columna del
   ancho de la criatura mas grande (--ancho-criatura, de js/bloque4.js) para
   que su centro no se mueva cuando cambia de tamano. Al 60 % del alto en
   la presentacion y las estaciones; en el cierre viaja al centro
   (--mueve-criatura) mientras toma su tamano de cierre.
   ========================================================================== */

@media (min-width: 768px) and (min-height: 500px) and (orientation: landscape) {
  /* La criatura y su indicador, juntos y centrados en el alto a la
     derecha (filas 2 y 3); los textos ocupan todo el alto a la izquierda y
     cada ficha se centra en el, a la altura de la criatura. */
  .js .estaciones--vivas .estaciones__fijo {
    grid-template-columns: minmax(0, 1fr) var(--ancho-criatura, 40%);
    grid-template-rows: minmax(0, 1fr) auto auto minmax(0, 1fr);
    column-gap: var(--medianil-escritorio);
    row-gap: var(--espacio-3);
    padding-block: var(--espacio-6);
  }
  .js .estaciones--vivas .estaciones__fijo > .criatura {
    grid-column: 2;
    grid-row: 2;
    align-self: center;
    justify-self: center;
    width: calc(var(--alto-criatura, 0px) * 1192 / 1064);
    aspect-ratio: auto;
    transform: translate3d(calc(var(--deriva-x, 0px) + var(--mueve-criatura, 0px)),
                           calc(var(--deriva-y, 0px) + var(--baja-criatura, 0px)), 0)
               rotate(var(--deriva-giro, 0deg));
  }
  /* el indicador cuenta agentes: bajo la criatura, que es el equipo */
  .js .estaciones--vivas .estaciones__fijo > .progreso { grid-column: 2; grid-row: 3; justify-self: center; }
  .js .estaciones--vivas .estaciones__fijo > .estaciones__textos { grid-column: 1; grid-row: 1 / -1; }

  /* La presentacion, encima, con las mismas dos columnas: puente, lista y
     regla en la de los textos, centrados en el alto */
  .js .estaciones--vivas .presentacion {
    grid-template-columns: minmax(0, 1fr) var(--ancho-criatura, 40%);
    grid-template-rows: minmax(0, 1fr);
    column-gap: var(--medianil-escritorio);
    padding-block: var(--espacio-6);
  }
  .js .estaciones--vivas .presentacion__puente,
  .js .estaciones--vivas .presentacion__lista,
  .js .estaciones--vivas .presentacion__regla { grid-column: 1; grid-row: 1; align-self: center; }
  /* Pasar lista, en Titular: es el momento del equipo y, a 24 px, la
     lista quedaba perdida frente a la criatura. Alineada con las fichas
     que vienen despues, que empiezan en el mismo borde. */
  .js .estaciones--vivas .presentacion__nombre {
    font-weight: var(--peso-negro);
    font-size: var(--texto-titular);
    line-height: var(--interlinea-titular);
  }

  /* Las nueve lineas ocupan su sitio desde el principio y solo se
     encienden: centrada en el alto, una lista que creciera empujaria hacia
     arriba a las que ya estan */
  .js .estaciones--vivas .presentacion__agente {
    height: auto;
    overflow: visible;
    margin-top: 0;
  }

  /* En pantallas bajas (un portatil de 1024 x 768) la columna de texto se
     queda en ~400 px y la ficha mas larga (Enzo, con «donde para») no
     cabia por 62 px. Se recorta el AIRE de la pantalla fija, nunca la
     criatura (60 %, el encuadre del video) ni deslizando (spec). */
  @media (max-height: 800px) {
    .js .estaciones--vivas .estaciones__fijo {
      padding-block: var(--espacio-2);
      row-gap: var(--espacio-2);
    }
  }

  /* La ficha mide lo que su contenido, no toda la columna (sin
     deslizamiento no hace falta que la llene), y va centrada en el alto,
     a la altura de la criatura: pegada arriba dejaba media pantalla vacia */
  .js .estaciones--vivas .estacion {
    margin-block: auto;     /* con top y bottom a 0, la centra en el alto */
    height: fit-content;
    max-height: 100%;
  }

  /* Al entrar en el cierre la criatura va a cruzar la columna de los
     textos: la ultima ficha se va EN SECO, sin el fundido de salida, para
     que nunca la cruce a medio fundir */
  .js .estaciones--vivas.estaciones--cierre .estacion {
    animation: none;
    opacity: 0;
  }

  /* El cierre: las dos frases centradas bajo la criatura, ya en el centro */
  .js .estaciones--vivas .cierre-equipo { text-align: center; }
}
