/*
  Yaruki — el teléfono 3D persistente (plan, 4.2 y 5.2).
  Etapa 4: coreografía ligada al scroll (`assets/js/stage.js`, GSAP +
  ScrollTrigger) — gira 360° y "vuela" de lado a lado entre fases en
  escritorio con movimiento ok; crossfade liso en móvil/`reduced-motion`.
  `--rotacion-y`/`--vuelo-x`/`--vuelo-escala` las fija JS en cada cuadro de
  scroll (o una vez sola en el modo de inspección `?cara=`).

  Unidades `cqw` dentro de `.pantalla-telefono`: ese contenedor declara
  `container-type: inline-size`, así el texto de cada escena escala con el
  ancho real del teléfono en vez de con el viewport — mismo teléfono se ve
  proporcional en móvil y en desktop. Navegadores sin soporte de container
  queries (poco probable en 2026) heredan el tamaño de `scenes.css`, que da
  un `rem` de respaldo en el mismo `clamp()`.
*/

/*
  Móvil (<1024px, punto de control 2.5 — error 1, 3ra vuelta): `position:
  sticky`, entre `#hero` y `<main>` en el flujo normal (los 3 son hermanos
  directos de `.layout-con-stage`, que en móvil es sólo `display:block`):
  aparece una vez, en flujo, justo debajo del CTA del hero, y se pega
  arriba apenas seguir scrolleando lo sacaría de pantalla.

  Vuelta anterior: la garantía era de `z-index` (texto siempre pintando
  ENCIMA del teléfono) + un velo casi opaco sobre el texto. Evitaba la
  superposición, pero el dueño lo vio como el problema contrario: el
  teléfono quedaba "escondido, un fantasma detrás del texto" en vez de
  visible. Pidió lo opuesto — franja chica y VISIBLE arriba, texto abajo,
  sin que se toquen ni un poco.

  Acá la franja (`height: 44vh`) tiene fondo SÓLIDO (no un velo parcial) y
  gana el `z-index` (ver `.layout-con-stage` en base.css) — así tapa
  prolijo cualquier resto de la sección anterior que siga subiendo por
  detrás. La garantía real contra la superposición es geométrica, no de
  apilamiento: cada sección de texto arranca con `padding-top: 46vh` (ver
  `.seccion` en base.css), por debajo de la franja completa — el teléfono
  nunca llega a estar a la altura del texto que se está leyendo.
*/
.stage {
  position: sticky;
  top: 0;
  display: flex;
  justify-content: center;
  align-items: center;
  padding: var(--space-1) 0;
  pointer-events: none;
}

@media (max-width: 1023px) {
  .stage {
    height: var(--franja-alto, calc(44 * var(--vh-pequeno)));
    background: var(--color-bg);
  }

  /* Borde inferior difuminado: el texto que sube por detrás de la franja se
     desvanece en vez de cortarse en seco. */
  .stage::after {
    content: "";
    position: absolute;
    left: 0;
    right: 0;
    top: 100%;
    height: 2.5rem;
    background: linear-gradient(var(--color-bg), transparent);
    pointer-events: none;
  }

  /* Vidrio (#100): la franja es opaca (tapa el texto que sube) y malla.js repinta encima de ese fondo el
     trozo de malla que le toca, para que la malla se vea también ahí. Va debajo del teléfono y del degradado. */
  .malla-franja {
    position: absolute;
    z-index: -1;
    left: 0;
    top: 0;
    width: 100%;
    height: calc(100% + 2.5rem); /* también cubre el degradado de abajo */
    pointer-events: none;
    opacity: var(--malla-intensidad, 1);
    transition: opacity 700ms ease;
  }

  /* El degradado queda por debajo del canvas de la malla (los dos son hijos con z-index negativo de `.stage`). */
  html[data-vidrio] .stage::after {
    z-index: -2;
  }

  /* Foco no tapado (WCAG 2.4.11): al subir con Shift+Tab el navegador deja
     el enlace en el borde de arriba, detrás de la franja. Con este margen lo
     deja debajo de la franja y de su difuminado (prueba `foco-visible.mjs`). */
  .secciones :is(a, button) {
    scroll-margin-top: calc(var(--franja-alto, calc(44 * var(--vh-pequeno))) + 2.5rem);
  }
}

@media (min-width: 1024px) {
  .malla-franja {
    display: none;
  }

  .stage {
    top: var(--space-3);
    height: calc(100vh - var(--space-4));
    align-items: center;
    /* Abarca el ancho completo del layout y pinta encima del texto: sin
       eventos de puntero, para no tapar enlaces ni botones. */
    overflow: visible;
    /* Contenedor para `cqw`: el teléfono nace en su columna (abajo). */
    container-type: inline-size;
  }
}

.escenario-3d {
  /* Proporciones del teléfono como fracción del ancho: a 296px dan el
     radio de 44px, el bisel de 10px y ~15px de grosor del plan (4.2). */
  --phone-radius: calc(var(--phone-width) * 0.149);
  /* Bisel en px enteros (#99): la pantalla no arranca en una orilla fraccionaria dentro del frente inclinado. */
  --phone-bezel: round(calc(var(--phone-width) * 0.034), 1px);
  --phone-depth: calc(var(--phone-width) * 0.05);
  position: relative;
  perspective: 1600px;
  width: var(--phone-width);
  flex-shrink: 0;
  /* Vuelo de una columna a la otra: la perspectiva viaja con el teléfono,
     así el giro se ve simétrico en cualquier punto del recorrido. */
  transform: translateX(var(--vuelo-x, 0px)) scale(var(--vuelo-escala, 1));
}

@media (min-width: 1024px) {
  /*
    Posición inicial del teléfono antes de que llegue la coreografía: el
    centro de la columna derecha (la del hero, `LADO_HERO` en stage.js), la
    misma cuenta que `columnas["1"]` (`.seccion--derecha`: (ancho + hueco) / 4
    desde el centro del escenario). Sin esto nacía en el centro, encima del
    final del titular, y saltaba a su columna cuando stage.js fijaba
    `--vuelo-x` (0.05–0.35 s, también con reduced-motion; auditoría integral,
    prueba `arranque-telefono.mjs`). Si GSAP no carga, se queda aquí.
  */
  .escenario-3d {
    transform: translateX(var(--vuelo-x, calc((100cqw + var(--hueco, 0px)) / 4))) scale(var(--vuelo-escala, 1));
  }
}

/*
  Inclinación con el mouse (tilt.js, #99), compuesta aparte del giro. `--tilt-p` es la perspectiva EXTRA de la
  inclinación: se suma (en 1/d) a la de `.escenario-3d` hasta una efectiva de 900 px mientras el teléfono sigue
  al cursor, y vale «infinito» (1e7 px) en reposo y en los giros, así el giro de 360° conserva sus 1600 px.
  Origen al centro (el del envoltorio coincide con el de `.escenario-3d`, así las dos perspectivas se suman).
*/
.phone-tilt {
  transform-style: preserve-3d;
  transform-origin: 50% 50%;
  transform: translateX(var(--tilt-dx, 0px)) perspective(var(--tilt-p, 10000000px)) rotateX(var(--tilt-x, 0deg))
    rotateY(var(--tilt-y, 0deg));
}

/*
  Sombra de vuelo (plan 4.2: "sombra que se alarga y se suaviza") — una
  elipse aparte en vez de animar el `box-shadow` estático del teléfono: la
  etapa 4 sólo anima `transform`/`opacity` (regla explícita del encargo), y
  blur/spread de `box-shadow` no son ninguna de las dos. `stage.js` la
  escala/atenúa en cada cuadro con las mismas 2 propiedades permitidas.
*/
.phone-sombra-vuelo {
  position: absolute;
  left: 10%;
  right: 10%;
  bottom: -6%;
  height: 10%;
  border-radius: 50%;
  background: radial-gradient(closest-side, hsl(var(--shadow-color) / 0.55), transparent 75%);
  opacity: 0;
  transform: scaleX(1);
  pointer-events: none;
}

/* Teléfono chico en móvil, a propósito atado a `vh` y no a `vw` (punto de
   control 2.5, error 1, 3ra vuelta): tiene que caber ENTERO dentro de la
   franja fija de `.stage` (`height: 44vh`, arriba) con margen — atado al
   ancho del viewport (como antes) el alto resultante (`aspect-ratio:9/19.5`
   en `.phone`) no tenía relación con el alto real de la franja y se
   recortaba o se pasaba según el aparato. 18vh de ancho → ~39vh de alto
   (×19.5/9), con aire de sobra dentro de los 44vh en los 2 tamaños de
   prueba (390×844 y 360×740). */
@media (max-width: 1023px) {
  /* El ancho es el de siempre (`18vh`, tope 170 px); `min` con lo que cabe en la franja (ahora en `svh`) solo lo achica
     cuando, con las barras de Chrome a la vista, la franja no alcanzaría para el teléfono: sin barras no cambia. */
  .escenario-3d {
    --phone-width: min(clamp(120px, 18vh, 170px), calc((var(--franja-alto, calc(44 * var(--vh-pequeno))) - 1rem) * 0.4615));
  }

}

/* Sonda de alto: mide en px cuánto es 100svh para stage.js (alto visible pequeño, estable con las barras). */
.sonda-alto {
  position: fixed;
  top: 0;
  left: 0;
  width: 0;
  height: calc(100 * var(--vh-pequeno));
  visibility: hidden;
  pointer-events: none;
}

/* Tablet vertical: el teléfono llena la franja de 50vh (base.css) en vez de quedarse en 170px. */
@media (min-width: 768px) and (max-width: 1023px) and (orientation: portrait) {
  .escenario-3d {
    --phone-width: calc((var(--franja-alto) - 3.5rem) * 0.4615);
  }
}

/*
  Teléfono en horizontal (p. ej. 844×390): la franja de 44vh mediría ~170px
  y el teléfono no entraría. Ahí el layout pasa a 2 columnas como en
  escritorio (base.css) y el teléfono se dimensiona por el alto disponible.
*/
@media (max-width: 1023px) and (orientation: landscape) and (max-height: 520px) {
  .stage {
    height: 100vh;
    background: none;
  }

  .stage::after {
    display: none;
  }

  /* Sin franja arriba: el foco no necesita el margen de la rama móvil. */
  .secciones :is(a, button) {
    scroll-margin-top: 0;
  }

  .escenario-3d {
    --phone-width: calc((100vh - 2.5rem) * 0.4615);
  }
}

.phone {
  /* Fondo de la escena de abajo (stage.js pone `data-fondo`): lo usan la pantalla y su respaldo (#99). */
  --fondo-pantalla: var(--color-bg);
  position: relative;
  width: 100%;
  aspect-ratio: 9 / 19.5;
  transform-style: preserve-3d;
  /* `stage.js` sólo toca la variable; el vuelo y la inclinación viven en
     los envoltorios (.escenario-3d, .phone-tilt). */
  transform: rotateY(var(--rotacion-y, 0deg));
}

/*
  Sin `transition` acá a propósito (etapa 2, teléfono ESTÁTICO): un `transform`
  animado en `.phone` competía en una carrera real contra la captura de
  Chromium headless — `stage.js` fija `--rotacion-y` al cargar, y la captura
  podía llegar a mitad de la transición, con el teléfono en un ángulo
  intermedio en vez del pedido por `?cara=`. La coreografía real ligada al
  scroll (etapa 4) la va a animar GSAP cuadro a cuadro, no una `transition`
  de CSS, así que no hace falta una acá todavía.
*/

.phone[data-fondo="chat"],
.phone[data-fondo="elementos"] {
  --fondo-pantalla: var(--color-bg-elevated);
}

.phone[data-fondo="splash"],
.phone[data-fondo="logro"] {
  --fondo-pantalla: var(--color-accent);
}

.phone[data-fondo="llamada"] {
  /* El mismo degradado de `.ps-llamada` (scenes.css). */
  --fondo-pantalla: linear-gradient(180deg, #13111f 0%, #332c57 160%);
}

/*
  Rendijas en la pantalla con el teléfono inclinado (#99, revisión de Harold): con 20° y la perspectiva de 900 px el
  compositor dibuja la cara del frente en varios trozos (mosaicos y capas compuestas: la mascota que respira, la barra
  de estado que se encima). Entre trozo y trozo puede quedar una rendija de subpíxel, y lo que se ve por ella es lo
  que hay DETRÁS de la cara: la página. Este respaldo es un plano liso del color de la escena, apenas detrás del
  frente (1 px en Z) y del tamaño de la pantalla: por una rendija se ve el mismo color. Solo se pinta de frente
  (`backface-visibility`) y no recibe eventos. Las escenas además se enciman 1 px sobre la orilla de la pantalla
  (`.capa-escena`) y el bisel se redondea a px enteros: sin orillas fraccionarias entre capas.
*/
.phone::before {
  content: "";
  position: absolute;
  inset: var(--phone-bezel);
  border-radius: calc(var(--phone-radius) - var(--phone-bezel));
  background: var(--fondo-pantalla);
  transform: translateZ(calc(var(--phone-depth) / 2 - 1px));
  backface-visibility: hidden;
  pointer-events: none;
}

.phone-cara {
  position: absolute;
  inset: 0;
  border-radius: var(--phone-radius);
  backface-visibility: hidden;
  overflow: hidden;
}

.phone-frente {
  background: var(--color-bg-elevated);
  /* Filo exterior de 1px con el color del canto: en claro el marco blanco
     sobre el fondo crema casi no tenía silueta. Sombra en dos capas (una
     corta de contacto y una larga y suave), más creíble que una sola. */
  box-shadow:
    0 0 0 1px var(--color-canto),
    0 1px 0 1px rgba(255, 255, 255, 0.06) inset,
    0 2px 6px -2px hsl(var(--shadow-color) / 0.18),
    0 40px 70px -36px hsl(var(--shadow-color) / 0.45);
  padding: var(--phone-bezel);
  /*
    Empuja el frente a +D/2 en Z — junto con la espalda en -D/2 (ver abajo),
    el teléfono pasa de ser una tarjeta plana (frente y espalda coincidiendo
    en el mismo plano) a una caja real con grosor. Sin esto, los cantos
    (abajo) no tenían con qué encajar y la vista de canto se veía como una
    tira flotando aparte en vez de una sola pieza (punto de control 2, bug 6).
  */
  transform: translateZ(calc(var(--phone-depth) / 2));
}

.phone-isla {
  position: absolute;
  /* Centrada en la barra de estado de las escenas (36dp ≈ 9.3% del ancho,
     ver `.ps-status` en scenes.css); todo en fracción del ancho para que
     no quede gorda en el teléfono chico de móvil. */
  top: calc(var(--phone-bezel) + var(--phone-width) * 0.0135);
  left: 50%;
  transform: translateX(-50%);
  width: 24%;
  height: calc(var(--phone-width) * 0.066);
  border-radius: 999px;
  background: #050505;
  z-index: 5;
}

.phone-pantalla {
  position: relative;
  width: 100%;
  height: 100%;
  border-radius: calc(var(--phone-radius) - var(--phone-bezel));
  overflow: hidden;
  background: var(--fondo-pantalla);
  container-type: inline-size;
  container-name: pantalla;
}

/*
  Mientras llegan los módulos y GSAP (en red lenta, ~2 s) la pantalla está
  vacía: con el fondo del Splash (la primera escena, `.ps-splash` en
  scenes.css) no se ve blanca y luego morada de golpe. En cuanto stage.js
  monta una escena deja de estar vacía (prueba `arranque-telefono.mjs`).
*/
.phone-pantalla:empty {
  background: var(--color-accent);
}

/*
  Capas apiladas dentro de la pantalla — sólo las usa el cruce Splash→Login
  del hero (etapa 3): dos escenas montadas A LA VEZ, una encima de la otra,
  para poder cruzarlas con `opacity` en vez de reemplazar el HTML de golpe.
  El resto de los cambios de escena (fases B en adelante) siguen siendo un
  reemplazo liso de `innerHTML` — pasan con el teléfono de espaldas
  (`SceneManager` en stage.js), así que no hace falta animarlos.
*/
.capa-escena {
  position: absolute;
  /* 1 px más allá de la orilla de la pantalla (la recorta su `overflow`): la escena nunca termina justo en el borde. */
  inset: -1px;
}

/* Lo mismo cuando la escena va directo en la pantalla (modo de inspección `?escena=`, o sin GSAP). */
.phone-pantalla > .escena {
  margin: -1px;
  width: calc(100% + 2px);
  height: calc(100% + 2px);
}

/*
  Canto (grosor del teléfono). Antes eran 4 tiras planas rectangulares
  (izquierda/derecha/arriba/abajo): el frente y la espalda tienen
  `border-radius` de 44px, así que en cualquier ángulo intermedio las
  esquinas de las tiras asomaban como esquinas cuadradas.

  Ahora el cuerpo es una pila de N capas con el MISMO contorno redondeado
  que las caras (mismo tamaño, mismo radio), repartidas a lo largo de Z
  entre la espalda (-D/2) y el frente (+D/2). Vista de lado, la unión de
  las capas forma un canto continuo que sigue la curva de las esquinas.
  Las capas son opacas y rellenas a propósito: con capas de sólo borde, cerca
  de 90° el borde proyectado (b·cos θ) queda más fino que la separación
  entre capas (Δz·sin θ) y aparecen rayas.

  `stage.js` genera las capas y les pone `--z` (posición en Z, px) y `--luz`/
  `--sombra` (porcentajes de mezcla): el centro del canto es un poco más claro
  y los extremos más oscuros, como un marco de bordes redondeados.
  Sólo se muestran (`data-canto="visible"` en `.phone`) cuando el teléfono
  está girado: de frente o de espaldas quedarían tapadas por las caras y sólo
  sumarían capas de composición.
*/
.phone-canto {
  position: absolute;
  inset: 0;
  transform-style: preserve-3d;
  display: none;
  pointer-events: none;
}

.phone[data-canto="visible"] .phone-canto,
.phone[data-canto="filo"] .phone-canto {
  display: block;
}

.phone-capa {
  position: absolute;
  inset: 0;
  border-radius: var(--phone-radius);
  background: color-mix(
    in oklab,
    color-mix(in oklab, var(--color-canto), #fff calc(var(--luz, 0) * 1%)),
    #000 calc(var(--sombra, 0) * 1%)
  );
  transform: translateZ(calc(var(--z, 0) * var(--phone-depth)));
}

/*
  Planos sólidos de cada lado, perpendiculares a las caras (`rotateY(90deg)`
  sobre el borde). Vistas exactamente de filo (90°/270°), las capas de arriba
  se proyectan como líneas con huecos entre sí: rayas. A ese ángulo estos
  planos se ven de frente y tapan los huecos con el mismo degradado del canto.
  Sólo se muestran cerca del filo (`data-canto="filo"`, stage.js): girados más
  allá, su esquina recta asomaría por fuera del contorno redondeado.
*/
.phone-plano {
  position: absolute;
  top: 0;
  bottom: 0;
  width: var(--phone-depth);
  margin-left: calc(var(--phone-depth) / -2);
  border-radius: calc(var(--phone-depth) / 2);
  background: linear-gradient(
    90deg,
    color-mix(in oklab, var(--color-canto), #000 26%),
    color-mix(in oklab, var(--color-canto), #fff 22%) 50%,
    color-mix(in oklab, var(--color-canto), #000 26%)
  );
  display: none;
}

.phone[data-canto="filo"] .phone-plano {
  display: block;
}

.phone-plano--izq {
  left: 0;
  transform: rotateY(-90deg);
}

.phone-plano--der {
  left: 100%;
  transform: rotateY(90deg);
}

.phone-espalda {
  background: linear-gradient(135deg, var(--color-bg-elevated) 55%, var(--color-accent-soft) 140%);
  /* rotateY(180) la encara hacia -Z; translateZ(D/2) en ESE espacio ya
     rotado empuja hacia +Z del padre, o sea -D/2 real — ver nota de
     `.phone-frente`. */
  transform: rotateY(180deg) translateZ(calc(var(--phone-depth) / 2));
  /* Mismo filo de 1px que el frente: sin él, la carcasa blanca no tenía
     silueta contra el fondo crema. */
  box-shadow: 0 0 0 1px var(--color-canto);
  display: flex;
  align-items: center;
  justify-content: center;
}

.phone-modulo-camaras {
  position: absolute;
  top: 8%;
  left: 8%;
  width: 26%;
  aspect-ratio: 1;
  border-radius: 24%;
  background: color-mix(in srgb, var(--color-bg-elevated) 78%, #000 22%);
}

/*
  Posiciones EXPLÍCITAS por `top`/`left` en vez de grid: con un grid 2×2 acá
  adentro, el auto-placement (mismo escarmiento que el bug de `main`/`.stage`
  en base.css) terminaba apilando los 3 hijos casi en el mismo lugar — un
  módulo de ~70px no deja margen para depurar a ciegas, así que se
  posiciona cada lente/flash a mano, sin ambigüedad posible.
*/
.phone-lente {
  position: absolute;
  width: 34%;
  aspect-ratio: 1;
  border-radius: 50%;
  background: #050505;
  box-shadow: 0 0 0 2px color-mix(in srgb, var(--color-bg-elevated) 88%, #000 12%);
  left: 14%;
}

.phone-lente:nth-of-type(1) {
  top: 14%;
}

.phone-lente:nth-of-type(2) {
  bottom: 14%;
}

.phone-flash {
  position: absolute;
  width: 22%;
  aspect-ratio: 1;
  border-radius: 50%;
  background: var(--color-warning-bg);
  top: 14%;
  right: 14%;
}

/*
  Mascota de la espalda con su halo. Antes el halo era un `box-shadow`
  animado en bucle (repinta cada cuadro y corría siempre, aunque la espalda
  no se viera). Ahora es una capa aparte (`::before`) que sólo anima
  `transform`/`opacity`, y la animación queda en pausa salvo cuando la
  espalda está a la vista (`data-espalda="visible"`, stage.js).
*/
.phone-mascota-halo {
  position: relative;
  width: 22%;
  aspect-ratio: 1;
  border-radius: 50%;
  background: var(--color-accent);
  /* Mirada (tilt.js, #27/#99): el círculo completo se corre hasta 16 % de su tamaño (~1/6 del diámetro)
     hacia el cursor, por `translate` (se compone con la respiración, que usa `transform`). A 180° la espalda
     queda sin espejo en pantalla (giro del teléfono + rotateY de la cara), así que no se invierte. Brillo
     suave del lado del cursor, afuera del círculo y en su propio color (sobre la espalda clara u oscura);
     contorno transparente por lo mismo que en el Splash (scenes.css): sin bordes de caja pegados a lo pintado. */
  outline: 0.5rem solid transparent;
  translate: calc(var(--mira-x, 0) * 16%) calc(var(--mira-y, 0) * 16%);
  box-shadow: calc(var(--mira-x, 0) * 0.25rem) calc(var(--mira-y, 0) * 0.25rem) 0.9rem -0.1rem
    color-mix(in oklab, var(--color-accent) calc(var(--mira-r, 0) * 75%), transparent);
}

/* Colores forzados: sin el contorno transparente (se pintaría como un aro; ver scenes.css). */
@media (forced-colors: active) {
  .phone-mascota-halo {
    outline: none;
  }
}

.phone-mascota-halo::before {
  content: "";
  position: absolute;
  inset: 0;
  border-radius: 50%;
  background: var(--color-accent);
  opacity: 0;
}

@media (prefers-reduced-motion: no-preference) {
  .phone-mascota-halo {
    animation: halo-mascota 3s ease-in-out infinite paused;
  }

  .phone-mascota-halo::before {
    animation: halo-onda 3s ease-in-out infinite paused;
  }

  .phone[data-espalda="visible"] .phone-mascota-halo,
  .phone[data-espalda="visible"] .phone-mascota-halo::before {
    animation-play-state: running;
  }
}

@keyframes halo-mascota {
  0%,
  100% {
    transform: scale(1);
  }
  50% {
    transform: scale(1.08);
  }
}

@keyframes halo-onda {
  0%,
  100% {
    transform: scale(1);
    opacity: 0;
  }
  50% {
    transform: scale(1.55);
    opacity: 0.18;
  }
}
