Communitygithub.com

delorenj/skills

Crea composiciones, animaciones, tarjetas de título, superposiciones, subtítulos, voces en off, visuales reactivos al audio y transiciones de escena en HyperFrames HTML.

¿Qué es skills?

Esta habilidad permite a un agente de IA actuar como un compositor y editor de video completo dentro del ecosistema HyperFrames, donde el HTML es la fuente de verdad para la producción de video. Está diseñada para manejar todo el flujo de trabajo de creación de video, desde la planificación conceptual hasta la animación final, incluyendo la generación de narración con texto a voz, la sincronización de animaciones con ritmos musicales, la adición de transiciones entre escenas y la gestión de composiciones parametrizadas con variables. Soporta la creación de contenido para diversas plataformas (redes sociales, héroe de sitio web, demostraciones) y se integra con herramientas CLI como `hyperframes-cli` para renderizado y `hyperframes-media` para preprocesamiento de activos. La habilidad enfatiza un enfoque estructurado: primero establecer un sistema de diseño basado en un archivo `design.md`, luego expandir la intención del usuario, planificar la estructura narrativa y rítmica, y finalmente implementar animaciones con GSAP, siguiendo el principio de 'Layout Before Animation' para evitar superposiciones no intencionadas.

Compatible con~Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/delorenj/skills/tree/HEAD/hyperframes-upstream-hyperframes

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Vista previa

Del README del skill

Documentación

HyperFrames

HTML es la fuente de verdad para el video. Una composición es un archivo HTML con atributos data-* para sincronización, una línea de tiempo GSAP para animación y CSS para la apariencia. El framework maneja la visibilidad de los clips, la reproducción de medios y la sincronización de la línea de tiempo.

Enfoque

Descubrimiento (solo solicitudes exploratorias)

Para solicitudes abiertas ("hazme un video de lanzamiento de producto", "crea algo para nuestra marca") donde el usuario no se ha comprometido con una dirección, comprende la intención antes de elegir colores:

  • Audiencia — ¿Quién ve esto? ¿Desarrolladores? ¿Ejecutivos? ¿Consumidores generales?
  • Plataforma — ¿Dónde se reproduce? ¿Redes sociales (15s), héroe de sitio web, demostración de producto, interna?
  • Prioridad — ¿Qué es lo más importante? ¿Calidad de movimiento? ¿Precisión del contenido? ¿Fidelidad de marca? ¿Velocidad?
  • Variaciones — ¿El usuario quiere opciones, o una sola mejor opción?

Para solicitudes específicas ("añade una tarjeta de título", "arregla la sincronización de la escena 3"), omite el descubrimiento.

Para solicitudes exploratorias, considera ofrecer 2-3 variaciones que difieran significativamente — no solo cambios de color, sino diferentes ritmos, niveles de energía o enfoques estructurales. Una segura/esperada, una ambiciosa. No lo hagas obligatorio — es una herramienta disponible cuando sea apropiado.

Paso 1: Sistema de diseño

Si existe design.md o DESIGN.md en el proyecto, léelo primero (verifica ambas mayúsculas/minúsculas — son archivos diferentes en Linux). Es la fuente de verdad para los colores de marca, fuentes y restricciones. Usa sus valores exactos — no inventes colores ni sustituyas fuentes. Cualquier formato funciona (frontmatter YAML, prosa, tablas — solo extrae los valores).

Si nombra fuentes que no puedes encontrar localmente (sin directorio fonts/ con archivos .woff2, ni una fuente incorporada), advierte al usuario antes de escribir HTML: "design.md especifica [nombre de fuente] pero no se encontraron archivos de fuente. Agrega archivos .woff2 a fonts/ o recurriré a la [alternativa incorporada más cercana]."

Si no existe design.md, ofrece al usuario una opción:

  1. ¿El usuario nombró un estilo o estado de ánimo? → Lee visual-styles.md para los 8 preajustes nombrados. Elige la coincidencia más cercana.
  2. ¿Quieres explorar opciones visualmente? → Ejecuta el selector de diseño: lee references/design-picker.md para el flujo de trabajo completo. Esto sirve una página de selección visual. El usuario configura el estado de ánimo, la paleta, la tipografía y el movimiento en el navegador, luego copia el design.md generado y lo pega de vuelta en la conversación.
  3. ¿Quieres saltar e ir rápido? → Pregunta: estado de ánimo, claro u oscuro, ¿colores/fuentes de marca? Luego elige una paleta de house-style.md.

design.md define la marca. No define las reglas de composición de video. Esas provienen de references/video-composition.md y house-style.md. Usa los colores de marca a una escala adecuada para video — no a la opacidad de una interfaz web.

Paso 2: Expansión de la solicitud

Siempre ejecutar en cada composición (excepto piezas de una sola escena y ediciones triviales). Este paso fundamenta la intención del usuario contra design.md y house-style.md y produce un intermedio consistente que todos los agentes posteriores leen de la misma manera.

Lee references/prompt-expansion.md para el proceso completo y el formato de salida.

Paso 3: Planificar

Antes de escribir HTML, piensa a un alto nivel:

  1. Qué — ¿qué debería experimentar el espectador? Identifica el arco narrativo, los momentos clave y los latidos emocionales.
  2. Estructura — cuántas composiciones, cuáles son subcomposiciones vs. en línea, qué pistas transportan qué (video, audio, superposiciones, subtítulos).
  3. Ritmo — declara tu ritmo de escena antes de implementar. Qué escenas son impactos rápidos, cuáles son pausas, dónde caen los shaders, dónde alcanza su punto máximo la energía. Nombra el patrón: rápido-rápido-LENTO-rápido-SHADER-pausa. Lee references/beat-direction.md para plantillas de ritmo.
  4. Sincronización — qué clips impulsan la duración, dónde caen las transiciones, cuál es el ritmo.
  5. Diseño — construye el estado final primero. Ver "Diseño Antes de la Animación" abajo.
  6. Animar — luego agrega movimiento usando las reglas a continuación.

Construye lo que se pidió. Una solicitud de "una tarjeta de título" no es una solicitud de "una tarjeta de título + 3 escenas de apoyo + música ambiental + subtítulos." Cada escena, cada elemento, cada interpolación debe ganarse su lugar. Si escenas o elementos adicionales mejoraran genuinamente la pieza, propónlos — no los agregues.

Para ediciones pequeñas (corregir un color, ajustar la sincronización, agregar un elemento), pasa directamente a las reglas.

Diseño Antes de la Animación

Posiciona cada elemento donde debería estar en su momento más visible — el fotograma donde ha entrado completamente, está colocado correctamente y aún no está saliendo. Escribe esto primero como HTML+CSS estático. Sin GSAP todavía.

Por qué es importante: Si posicionas elementos en su estado inicial animado (fuera de pantalla, escalado a 0, opacidad 0) y los interpolas a donde crees que deberían aterrizar, estás adivinando el diseño final. Las superposiciones son invisibles hasta que el video se renderiza. Al construir el estado final primero, puedes ver y solucionar problemas de diseño antes de agregar cualquier movimiento.

El proceso

  1. Identifica el fotograma heroico para cada escena — el momento en que la mayoría de los elementos son visibles simultáneamente. Este es el diseño que construyes.
  2. Escribe CSS estático para ese fotograma. El contenedor .scene-content DEBE llenar la escena completa usando width: 100%; height: 100%; padding: Npx; con display: flex; flex-direction: column; gap: Npx; box-sizing: border-box. Usa padding para empujar el contenido hacia adentro — NUNCA uses position: absolute; top: Npx en un contenedor de contenido. Los contenedores de contenido posicionados absolutamente se desbordan cuando el contenido es más alto que el espacio restante. Reserva position: absolute solo para elementos decorativos.
  3. Agrega entradas con gsap.from() — anima DESDE fuera de pantalla/invisible HASTA la posición CSS. La posición CSS es la verdad fundamental; la interpolación describe el viaje para llegar allí. (En subcomposiciones cargadas vía data-composition-src, prefiere gsap.fromTo() — ver reglas GSAP de carga en references/motion-principles.md).
  4. Agrega salidas con gsap.to() — anima HASTA fuera de pantalla/invisible DESDE la posición CSS.

Ejemplo

/* scene-content llena la escena, el padding posiciona el contenido */
.scene-content {
  display: flex;
  flex-direction: column;
  justify-content: center;
  width: 100%;
  height: 100%;
  padding: 120px 160px;
  gap: 24px;
  box-sizing: border-box;
}
.title {
  font-size: 120px;
}
.subtitle {
  font-size: 42px;
}
/* El contenedor llena cualquier tamaño de escena (1920x1080, 1080x1920, etc.).
   El padding posiciona el contenido. Flex + gap maneja el espaciado. */

INCORRECTO — dimensiones fijas y posicionamiento absoluto:

.scene-content {
  position: absolute;
  top: 200px;
  left: 160px;
  width: 1920px;
  height: 1080px;
  display: flex; /* ... */
}
// Paso 3: Animar HACIA esas posiciones
tl.from(".title", { y: 60, opacity: 0, duration: 0.6, ease: "power3.out" }, 0);
tl.from(".subtitle", { y: 40, opacity: 0, duration: 0.5, ease: "power3.out" }, 0.2);
tl.from(".logo", { scale: 0.8, opacity: 0, duration: 0.4, ease: "power2.out" }, 0.3);

// Paso 4: Animar FUERA de esas posiciones
tl.to(".title", { y: -40, opacity: 0, duration: 0.4, ease: "power2.in" }, 3);
tl.to(".subtitle", { y: -30, opacity: 0, duration: 0.3, ease: "power2.in" }, 3.1);
tl.to(".logo", { scale: 0.9, opacity: 0, duration: 0.3, ease: "power2.in" }, 3.2);

Cuando los elementos comparten espacio a través del tiempo

Si el elemento A sale antes de que el elemento B entre en la misma área, ambos deben tener posiciones CSS correctas para sus respectivos fotogramas heroicos. El orden de la línea de tiempo garantiza que nunca coexistan visualmente — pero si omites el paso de diseño, no detectarás el caso en que accidentalmente se superpongan debido a un error de sincronización.

Qué cuenta como superposición intencional

Los efectos en capas (brillo detrás del texto, elementos de sombra, patrones de fondo) y los diseños apilados en Z (pilas de tarjetas, capas de profundidad) son intencionales. El paso de diseño se trata de detectar superposiciones no intencionales — dos titulares cayendo uno sobre otro, una estadística cubriendo una etiqueta, contenido sangrando fuera del fotograma.

Atributos de Datos

Todos los Clips

AtributoRequeridoValores
idSíIdentificador único
data-startSíSegundos o referencia de ID de clip ("el-1", "intro + 2")
data-durationRequerido para img/div/composicionesSegundos. Video/audio por defecto usa duración del medio.
data-track-indexSíEntero. Los clips de la misma pista no pueden superponerse.
data-media-startNoDesplazamiento de recorte en la fuente (segundos)
data-volumeNo0-1 (por defecto 1)

data-track-index no afecta la superposición visual — usa CSS z-index.

Clips de Composición

AtributoRequeridoValores
data-composition-idSíID de composición único
data-startSíHora de inicio (composición raíz: usa "0")
data-durationSíTiene prioridad sobre la duración de la línea de tiempo GSAP
data-width / data-heightSíDimensiones en píxeles (1920x1080 o 1080x1920)
data-composition-srcNoRuta a un archivo HTML externo
data-variable-valuesNoObjeto JSON de anulaciones de variables por instancia en un host de subcomp

En el elemento <html> raíz:

AtributoRequeridoValores
data-composition-variablesNoArray JSON de variables declaradas (id/type/label/default) — impulsa la UI de edición de Studio y proporciona valores predeterminados para getVariables()

Estructura de Composición

Las subcomposiciones cargadas vía data-composition-src usan un envoltorio <template>. Las composiciones independientes (el index.html principal) NO usan <template> — colocan el div data-composition-id directamente en <body>. Usar <template> en un archivo independiente oculta todo el contenido del navegador y rompe el renderizado.

Estructura de subcomposición:

<template id="my-comp-template">
  <div data-composition-id="my-comp" data-width="1920" data-height="1080">
    <!-- contenido -->
    <style>
      [data-composition-id="my-comp"] {
        /* estilos con ámbito */
      }
    </style>
    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/gsap.min.js"></script>
    <script>
      window.__timelines = window.__timelines || {};
      const tl = gsap.timeline({ paused: true });
      // interpolaciones...
      window.__timelines["my-comp"] = tl;
    </script>
  </div>
</template>

Carga en la raíz: <div id="el-1" data-composition-id="my-comp" data-composition-src="compositions/my-comp.html" data-start="0" data-duration="10" data-track-index="1"></div>

Variables (Composiciones Parametrizadas)

Renderiza la misma composición con contenido diferente — título, color de tema, precios, subtítulos — sin editar el HTML fuente.

Patrón de tres pasos:

  1. Declara variables en la raíz <html> de la composición con data-composition-variables. Cada entrada necesita id, type (uno de string, number, color, boolean, enum), label, y default. Las entradas Enum también necesitan options: [{value, label}, ...].
  2. Lee los valores resueltos dentro del script de la composición con window.__hyperframes.getVariables(). Devuelve el resultado combinado de valores predeterminados declarados + anulaciones por instancia + anulaciones CLI.
  3. Anula en tiempo de renderizado con npx hyperframes render --variables '{...}' (nivel superior) o con data-variable-values='{...}' en el elemento host (por instancia para subcomps).
<!doctype html>
<html
  data-composition-variables='[
  {"id":"title","type":"string","label":"Título","default":"Hola"},
  {"id":"theme","type":"enum","label":"Tema","default":"light","options":[
    {"value":"light","label":"Claro"},
    {"value":"dark","label":"Oscuro"}
  ]}
]'
>
  <body>
    <div data-composition-id="root" data-width="1920" data-height="1080">
      <h1 id="hero" class="clip" data-start="0" data-duration="3"></h1>
      <script>
        const { title, theme } = window.__hyperframes.getVariables();
        document.getElementById("hero").textContent = title;
        document.body.dataset.theme = theme;
      </script>
    </div>
  </body>
</html>
# Vista previa de desarrollo usa valores predeterminados declarados
npx hyperframes preview

# Renderizar con anulaciones
npx hyperframes render --variables '{"title":"Informe Q4","theme":"dark"}' --output q4.mp4

# O desde un archivo JSON
npx hyperframes render --variables-file ./vars.json

Valores por instancia de subcomposición: el mismo getVariables() funciona dentro de subcomps cargadas vía data-composition-src. Cada elemento host pasa sus propios valores:

<div
  data-composition-id="card-pro"
  data-composition-src="compositions/card.html"
  data-variable-values='{"title":"Pro","price":"$29"}'
></div>
<div
  data-composition-id="card-enterprise"
  data-composition-src="compositions/card.html"
  data-variable-values='{"title":"Enterprise","price":"$99"}'
></div>

Sincronización de Audio

Agrega audio para crear pistas de sonido, voces en off o música que reacciona a tu composición.

Atributos de Clip de Audio

AtributoRequeridoValores
data-srcSíRuta al archivo de audio
data-startSíTiempo de inicio en la línea de tiempo de la composición
data-durationNoPor defecto: duración completa del archivo de audio
data-media-startNoTiempo de inicio dentro del archivo de audio (segundos)
data-volumeNo0-1 (por defecto 1)
data-track-indexSíLos clips de audio comparten pistas con clips de video

Usa cualquier formato de audio que admita el navegador. Los navegadores modernos admiten .mp3, .wav, .ogg, .m4a, .aac. Para una máxima compatibilidad, usa .mp3.

Visuales Reactivas al Audio

Para composiciones que reaccionan al audio en tiempo real, usa la API Web Audio:

<audio id="music" data-src="/assets/music.mp3" data-start="0" data-duration="10" data-volume="0.8"></audio>
<div id="visualizer" class="clip" data-start="0" data-duration="10">
  <canvas id="waveform"></canvas>
  <script>
    const audio = document.getElementById("music");
    const audioCtx = new (window.AudioContext || window.webkitAudioContext)();
    const source = audioCtx.createMediaElementSource(audio);
    const analyser = audioCtx.createAnalyser();
    source.connect(analyser);
    analyser.connect(audioCtx.destination);
    const bufferLength = analyser.frequencyBinCount;
    const dataArray = new Uint8Array(bufferLength);
    const canvas = document.getElementById("waveform");
    const ctx = canvas.getContext("2d");
    function draw() {
      requestAnimationFrame(draw);
      analyser.getByteFrequencyData(dataArray);
      // dibuja usando dataArray...
    }
    draw();
  </script>
</div>

Subtítulos y Leyendas

Los subtítulos se sincronizan con el audio usando el atributo data-captions con una URL de archivo WebVTT (.vtt). Alternativamente, usa data-captions-inline para datos VTT en línea.

<video data-src="/assets/video.mp4" data-start="0" data-duration="10" data-captions="/assets/captions.vtt"></video>

Archivo .vtt de ejemplo:

WEBVTT

00:00:01.000 --> 00:00:04.000
Bienvenido a HyperFrames

00:00:05.000 --> 00:00:08.000
Comienza la cuenta regresiva

00:00:09.000 --> 00:00:12.000
Tres... dos... uno...

Subtítulos en línea:

<div
  data-captions-inline='[
    {"start":1,"end":4,"text":"Bienvenido"},
    {"start":5,"end":8,"text":"Comienza la cuenta regresiva"},
    {"start":9,"end":12,"text":"Tres... dos... uno..."}
  ]'
></div>

Transiciones

Las transiciones conectan escenas. Se definen como composiciones separadas con un data-transition que las marca como transiciones y una duración en segundos.

Transiciones Incorporadas

HyperFrames incluye transiciones predefinidas en el directorio transitions/:

ArchivoEfecto
crossfade.htmlFundido cruzado suave
wipe-left.htmlBarrido de izquierda a derecha
wipe-right.htmlBarrido de derecha a izquierda
wipe-up.htmlBarrido de abajo hacia arriba
wipe-down.htmlBarrido de arriba hacia abajo
reveal.htmlRevelado de círculo
shader-glitch.htmlTransición de glitch (shader)
shader-blur.htmlTransición de desenfoque (shader)

Transiciones Personalizadas

Cada transición personalizada es una composición de archivo único (usa <template> como cualquier subcomposición). Debe:

  1. Marcarse como transición con data-transition="true" en el elemento raíz.
  2. Declarar duración en el elemento raíz con data-duration="N" (segundos).
  3. Renderizar sobre la escena de salida y fundirse a la escena de entrada, usando dos variables mágicas que recibe de la línea de tiempo del marco:
    • __exitFrame — un callback que renderiza el último fotograma de la escena saliente en un canvas.
    • __enterFrame — un callback que renderiza el primer fotograma de la escena entrante en un canvas.

Estructura de transición personalizada:

<template id="my-wipe-transition">
  <div
    data-composition-id="my-wipe"
    data-width="1920"
    data-height="1080"
    data-transition="true"
    data-duration="1"
  >
    <canvas id="exit-canvas"></canvas>
    <canvas id="enter-canvas"></canvas>
    <style>
      [data-composition-id="my-wipe"] {
        position: relative;
        width: 100%;
        height: 100%;
      }
      #exit-canvas, #enter-canvas {
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
      }
    </style>
    <script>
      window.__timelines = window.__timelines || {};
      const tl = gsap.timeline({ paused: true });
      // Accede a los fotogramas usando window.__exitFrame y window.__enterFrame
      tl.to("#exit-canvas", { opacity: 0, duration: 0.5 })
        .from("#enter-canvas", { opacity: 0, duration: 0.5 });
      window.__timelines["my-wipe"] = tl;
    </script>
  </div>
</template>

Uso: Coloca la transición entre dos clips de composición en la raíz. El marco establece automáticamente un orden de pista que coloca la transición sobre la escena saliente y por debajo de la escena entrante, luego anima su duración. Mientras la transición está activa, el marco congela ambas escenas en sus fotogramas actuales.

<div data-composition-id="scene-intro" data-start="0" data-duration="3" data-track-index="1"></div>
<div
  data-composition-id="wipe"
  data-composition-src="transitions/wipe-left.html"
  data-start="0"
  data-duration="0.5"
  data-track-index="1"
></div>
<div data-composition-id="scene-main" data-start="3" data-duration="5" data-track-index="1"></div>

(Nota: data-track-index para transiciones debe coincidir con la pista de las escenas que conecta para la superposición sincronizada. La transición se activa al final de la escena de salida y anima a lo largo de su duración, fundiendo a la siguiente escena).

Reglas de Animación

Directrices Generales de GSAP

  1. Usa gsap.timeline() para todas las animaciones. Usa tl.from() para entradas, tl.to() para salidas.
  2. Nombra las líneas de tiempo con una clave que coincida con el ID de la composición: window.__timelines["root"] = tl;
  3. Pausa la línea de tiempo por defecto: gsap.timeline({ paused: true }). El marco la reproduce.
  4. Usa el tercer parámetro (posición) para controlar la sincronización: segundos absolutos, etiquetas "+=N", o etiquetas relativas.
  5. Las etiquetas se definen con tl.addLabel("intro", 0) y se referencian como "intro", "intro += 0.5".
  6. Evita duraciones muy pequeñas (menos de 0.15s) — GSAP puede omitirlas en algunas condiciones de carga.

Movimiento de Cámara

No hay zoom de cámara horizontal. El zoom de cámara, el paneo y la inclinación deben ser sutiles y con un propósito — no telegrafiados ni con efecto de "mareo".

Reglas:

  • Solo vertical o de profundidad. Recortar horizontalmente en falso es demasiado obvio.
  • Máximo 15% de zoom. No sobrepases 1.15x de escala. Más allá se ve a artificial y preferencias del espectador.
  • Usa transform-origin. Siempre especifica el origen de transformación para que los extremos de la escena se paneen correctamente (no se desplacen).
  • Una dirección. Si paneas hacia arriba, no panees hacia abajo en la misma escena. Si te acercas, no te alejes.
  • Borde de fotograma verificado. Cada elemento crítico (texto principal, rostros de personas, logotipos) debe ser visible en el fotograma cuando el zoom está en su punto máximo. No cortes cabezas o texto de ancho completo.
  • Movimiento empujado por la duración. Para una escena de 5 segundos: 1 segundo de retraso, 3 segundos de paneo/zoom suave, 1 segundo de retención. Acelera para escenas cortas. Extiende la retención para escenas largas. El movimiento debe sentirse incidental, no como el evento principal.

Variantes de Movimiento

Estos son los patrones de movimiento aprobados. No inventes otros nuevos a menos que exista una solicitud explícita.

TécnicaComportamientoAtributos de ejemplo
Revelar hacia arribaEl texto se revela de abajo hacia arriba con un desenfoquey: 60, opacity: 0, filter: "blur(10px)"
Revelar hacia abajoEl texto se revela de arriba hacia abajoy: -60, opacity: 0
RebotarLos elementos entran rebotando desde una escala pequeñascale: 0.5, opacity: 0, ease: "back.out(1.7)"
BarridoEl texto se barre desde un lado (se desliza hacia adentro)x: 200, opacity: 0, ease: "power4.out"
DesvanecerEl texto aparece con un suave desvanecimientoopacity: 0, duration: 0.6
EscaleraLos elementos aparecen secuencialmente con un pequeño retrasoDesplazamiento de posición = 0.15 por elemento
N/ASin animación en absoluto — el elemento está presente desde data-start=0Sin GSAP en ese elemento

Sincronización de Latidos (Reactivo a Música)

Cuando se te pida sincronizar animaciones con latidos de música:

  1. Calcula el BPM de la pista de música. (Pregunta al usuario o asume un BPM razonable como 120.)
  2. Calcula la duración del latido: latidoDuration = 60 / BPM.
  3. Declara el patrón de latidos al inicio del script de animación: const BPM = 120; const beatDuration = 60 / BPM;.
  4. Sincroniza los eventos de animación con los latidos. Por ejemplo, si cada pulso visual debería ocurrir en cada latido:
tl.to(".pulse-element", { scale: 1.2, duration: 0.1, ease: "power2.out" }, 0);
tl.to(".pulse-element", { scale: 1.0, duration: 0.1, ease: "power2.in" }, beatDuration * 0.25);
tl.to(".pulse-element", { scale: 1.2, duration: 0.1, ease: "power2.out" }, beatDuration);
tl.to(".pulse-element", { scale: 1.0, duration: 0.1, ease: "power2.in" }, beatDuration * 1.25);
  1. Etiqueta los latidos para una sincronización más fácil: tl.addLabel("beat1", 0); tl.addLabel("beat2", beatDuration);.
  2. Usa una variedad de movimientos: no todos los latidos necesitan pulso de escala. Alterna entre pulso, brillo, cambio de color y desvanecimiento.

Sincronización de Silabificación (Texto a Voz)

Cuando se te solicite sincronizar texto con audio de voz generado, HyperFrames soporta un proceso de dos pasos:

  1. Genera voz: usa el comando tts (texto a voz, parte del skill de medios). Esto produce un archivo de audio y un archivo de metadatos JSON de sílabas sincronizadas con marcas de tiempo de inicio/fin.
  2. Consume los datos de sílabas: en tu composición, lee el archivo JSON de sílabas y anima el texto para que coincida con cada sílaba. Ejemplo:
const syllables = await fetch("./narration.json").then(r => r.json());
// syllable.words: "Bienvenido"
// syllable.start: 0.5 (segundos)
// syllable.end: 0.8 (segundos)
syllables.forEach((s, i) => {
  tl.call(() => highlightWord(i), [], s.start);
  tl.call(() => unhighlightWord(i), [], s.end);
});

Composición de Video

Composiciones Anidadas (Sub-composiciones)

Las subcomposiciones encapsulan una escena o elemento reutilizable. Se cargan en la composición raíz usando data-composition-src.

Ventajas:

  • Encapsulación: CSS, HTML y JS con ámbito.
  • Parametrización: Pasa variables para personalizar el contenido.
  • Reutilización: El mismo diseño de escena con diferentes datos.

Referencias de Archivos

Para obtener información detallada sobre referencias de archivos y cómo cargar medios, consulta references/file-references.md.

Renderizado

Renderiza una composición a un archivo de video usando la CLI:

npx hyperframes render entrada.html --output salida.mp4

Opciones de la CLI:

OpciónDescripción
--output, -oRuta del archivo de salida (por defecto: salida.mp4)
--width, -wAncho del video (por defecto: 1920)
--height, -hAlto del video (por defecto: 1080)
--fps, -fFotogramas por segundo (por defecto: 30)
--variablesJSON de variables para anular
--variables-fileArchivo JSON de variables para anular

Salida a ./render/: si no se especifica --output, la CLI escribe el archivo renderizado al directorio ./render/ con un nombre de archivo basado en la entrada.

Preguntas Frecuentes

¿Cuándo debo usar data-duration vs. data-media-start?

data-duration establece la duración total del clip en la línea de tiempo. data-media-start recorta el tiempo de inicio del archivo de medios fuente. Para audio/video, la duración del clip por defecto es la duración del archivo de medios; data-duration la anula.

¿Cómo creo animaciones de subida?

Usa tl.from(el, { y: 100 }) — pero recuerda construir el estado final primero. El CSS posiciona el elemento donde debe estar, luego gsap.from() lo anima desde ahí.

¿Cuál es la diferencia entre data-start y data-media-start?

data-start es cuándo comienza el clip en la línea de tiempo de la composición (por ejemplo, a los 5 segundos). data-media-start es un desplazamiento dentro del archivo de medios (por ejemplo, comenzar a reproducir el video desde el fotograma de 2 segundos).

Individual skills in this repo

This repo contains 14 individual skills — each has its own dedicated page.

delorenj/skills

Plan and generate terminal ASCII animations/screensaver-style output (FPS, refresh rules, loop policy, low-flicker guidance), with a static poster frame and an optional local demo script.

delorenj/skills

ASCII video: convert video/audio to colored ASCII MP4/GIF.

delorenj/skills

Plan, build and quality-check a premium short commercial for a real business (roofing, property, ecommerce, B2B software) using AI-generated footage, code-built motion (HTML/GSAP), selective Three.js and an independent-critic "Gauntlet" loop. Use when asked to make a launch-style / SaaS-style video, business ad, explainer, sample reel or pitch video, or to review and improve one. Encodes motion principles distilled from 28 professional launch films, a quality bar, audio rules and a business-offer playbook.

delorenj/skills

CSS animation adapter patterns for HyperFrames. Use when authoring CSS keyframes, animation-delay based timing, animation-fill-mode, animation-play-state, or CSS-only motion that HyperFrames must seek deterministically during preview and rendering.

delorenj/skills

Generate professional voiceovers using ElevenLabs AI. Use when the user needs to create voiceovers for videos, audio narration, or text-to-speech content. Supports multiple voices with character presets (narrator, salesperson, expert) for natural delivery. Includes single scene regeneration for fine-tuning.

delorenj/skills

HyperFrames CLI dev loop — `npx hyperframes` for scaffolding (init), validation (lint, inspect), preview, render, and environment troubleshooting (doctor, browser, info, upgrade). Use when running any of these commands or troubleshooting the HyperFrames build/render environment. For asset preprocessing commands (`tts`, `transcribe`, `remove-background`), invoke the `hyperframes-media` skill instead.

delorenj/skills

Asset preprocessing for HyperFrames compositions — text-to-speech narration (Kokoro), audio/video transcription (Whisper), and background removal for transparent overlays (u2net). Use when generating voiceover from text, transcribing speech for captions, removing the background from a video or image to use as a transparent overlay, choosing a TTS voice or whisper model, or chaining these (TTS → transcribe → captions). Each command downloads its own model on first run.

delorenj/skills

Install and wire registry blocks and components into HyperFrames compositions. Use when running hyperframes add, installing a block or component, wiring an installed item into index.html, or working with hyperframes.json. Covers the add command, install locations, block sub-composition wiring, component snippet merging, and registry discovery.

delorenj/skills

Manim CE animations: 3Blue1Brown math/algo videos.

delorenj/skills

Join a Google Meet or Zoom call as a video meeting agent via PikaStreaming. Trigger: user drops a Google Meet or Zoom link, or asks to join a meeting.

delorenj/skills

Translate an existing Remotion (React-based) video composition into a HyperFrames HTML composition. Use ONLY when the user explicitly asks to port, convert, migrate, translate, or rewrite a Remotion composition as HyperFrames (e.g. "port my Remotion project to HyperFrames"). Do NOT use when (a) authoring a NEW HyperFrames composition (even if A/B-testing a Remotion video); (b) Remotion is mentioned in passing; (c) Remotion code is shared as reference, not for translation; (d) the user wants "the same video as my Remotion one" without explicitly asking to migrate the source — treat as a fresh HyperFrames build. When in doubt, default to the `hyperframes` skill. Detects unsupported patterns (useState, useEffect side effects, async calculateMetadata, third-party React component libraries, `@remotion/lambda`) and recommends the runtime interop escape hatch instead of a lossy translation.

delorenj/skills

Generate speech using the self-hosted voxxy (vox) TTS service at https://vox.delo.sh. Use when the user asks to speak, say, narrate, synthesize speech, clone a voice, create a voice, add or register a voice, pipe TTS, or control voice qualities by description (e.g. "a young woman with a cheerful voice"). Handles HTTP API usage, voice profile management, description-based voice design, cloning, MCP registration, and integration patterns for new platforms.

delorenj/skills

Capture a website and create a HyperFrames video from it. Use when: (1) a user provides a URL and wants a video, (2) someone says "capture this site", "turn this into a video", "make a promo from my site", (3) the user wants a social ad, product tour, or any video based on an existing website, (4) the user shares a link and asks for any kind of video content. Even if the user just pastes a URL — this is the skill to use.

delorenj/skills

YouTube transcripts to summaries, threads, blogs.

Skills relacionados