theus-cli-darwin-x64 0.2.84

package/vendor/theus-arsenal/skills/consultas-genomicas-gget/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: consultas-genomicas-gget
+description: Flujo con el CLI y el paquete Python de gget para consultas rápidas a bases de datos
+  genómicas, búsqueda de secuencias, consultas estilo BLAST, verificaciones de enriquecimiento y
+  registros reproducibles de evidencia bioinformática. Úsala cuando una tarea necesite una consulta
+  rápida a bases de datos de referencia genómica.
+---
+
+# gget
+
+Usa esta skill cuando una tarea necesite una consulta bioinformática rápida a través de bases de
+datos de referencia genómica con el CLI o el paquete de Python `gget`.
+
+## Cuándo usarla
+
+- Al buscar IDs de Ensembl, metadatos de genes, detalles de transcritos o secuencias.
+- Al ejecutar búsquedas rápidas BLAST o BLAT sin construir un pipeline local completo.
+- Al obtener enlaces de genomas de referencia y anotaciones desde Ensembl.
+- Al consultar módulos de estructura de proteínas, rutas, cáncer, expresión o asociación a enfermedad
+  a través de una sola interfaz.
+- Al crear un registro reproducible de evidencia de primera pasada antes de pasar a herramientas más
+  pesadas como Biopython, Snakemake, Nextflow, BLAST+ o clientes específicos de base de datos.
+
+Usa un flujo dedicado en lugar de `gget` cuando la tarea requiera interpretación clínica regulada,
+pipelines de producción de alto rendimiento o control fino sobre versiones de base de datos e índices locales.
+
+## Instalación
+
+Usa un entorno de Python limpio.
+
+```bash
+python -m venv .venv
+. .venv/bin/activate
+python -m pip install --upgrade pip
+python -m pip install --upgrade gget
+gget --help
+```
+
+Si `uv` está disponible:
+
+```bash
+uv venv
+. .venv/bin/activate
+uv pip install gget
+```
+
+Antes de confiar en un entorno antiguo, actualiza `gget` y vuelve a revisar la documentación del módulo.
+Las bases de datos upstream consultadas por `gget` cambian con el tiempo.
+
+## Patrones básicos
+
+Forma del CLI:
+
+```bash
+gget <módulo> [argumentos] [opciones]
+```
+
+Forma en Python:
+
+```python
+import gget
+
+result = gget.search(["BRCA1"], species="human")
+print(result)
+```
+
+Flujo común:
+
+1. Identifica la especie, el ensamblaje, el tipo de ID de gen y la base de datos necesaria.
+2. Revisa la documentación vigente del módulo para conocer los argumentos.
+3. Ejecuta primero una consulta pequeña.
+4. Guarda la salida con un nombre de archivo explícito y la fecha.
+5. Registra nombre del módulo, versión, argumentos y supuestos de base de datos.
+
+## Módulos comunes
+
+Usa la documentación upstream vigente para los argumentos exactos. Estos módulos son opciones
+frecuentes de primera elección:
+
+- `gget search`: encuentra IDs de Ensembl a partir de términos de búsqueda.
+- `gget info`: recupera metadatos para IDs de Ensembl, UniProt o relacionados.
+- `gget seq`: obtiene secuencias de nucleótidos o aminoácidos.
+- `gget ref`: recupera enlaces de descarga de genomas de referencia.
+- `gget blast`: ejecuta una consulta BLAST rápida.
+- `gget blat`: localiza una secuencia contra ensamblajes de genoma soportados.
+- `gget muscle`: ejecuta alineamiento múltiple de secuencias.
+- `gget diamond`: ejecuta alineamiento local de secuencias contra secuencias de referencia.
+- `gget alphafold` y `gget pdb`: inspeccionan referencias de estructura de proteínas.
+- `gget enrichr`, `gget opentargets`, `gget archs4`, `gget bgee`, `gget cbio` y `gget cosmic`:
+  exploran datos de enriquecimiento, dianas terapéuticas, expresión, cáncer y asociación a enfermedad.
+
+No asumas que cada módulo soporta cada versión de Python o cada conjunto de dependencias. Algunas
+dependencias científicas opcionales tienen soporte de versiones más estrecho que el paquete central.
+
+## Ejemplos rápidos
+
+Encontrar genes:
+
+```bash
+gget search -s human brca1 dna repair -o brca1-search.json
+```
+
+Obtener metadatos de gen:
+
+```bash
+gget info ENSG00000012048 -o brca1-info.json
+```
+
+Obtener una secuencia:
+
+```bash
+gget seq ENSG00000012048 -o brca1-seq.fa
+```
+
+Ejecutar una consulta BLAST pequeña:
+
+```bash
+gget blast "MEEPQSDPSVEPPLSQETFSDLWKLLPEN" -l 10 -o blast-results.json
+```
+
+Ejemplo en Python:
+
+```python
+import gget
+
+genes = gget.search(["BRCA1", "DNA repair"], species="human")
+info = gget.info(["ENSG00000012048"])
+sequence = gget.seq("ENSG00000012048")
+```
+
+## Registro de reproducibilidad
+
+Para salidas científicas, incluye suficientes metadatos para reproducir la consulta.
+
+```markdown
+| Fecha | Versión de gget | Módulo | Consulta | Especie/ensamblaje | Salida | Notas |
+| --- | --- | --- | --- | --- | --- | --- |
+| 2026-05-11 | `gget --version` | search | `BRCA1 DNA repair` | human | `brca1-search.json` | Docs verificados antes de correr |
+```
+
+Registra además:
+
+- versión de Python y gestor de entornos;
+- cualquier dependencia opcional instalada mediante `gget setup`;
+- identificadores específicos de base de datos devueltos por la consulta;
+- si la salida es JSON, CSV, FASTA o una exportación de DataFrame;
+- cualquier falla que se haya resuelto actualizando `gget`.
+
+## Lista de verificación
+
+- ¿Actualizaste o verificaste la versión instalada de `gget`?
+- ¿Revisaste la documentación upstream vigente del módulo antes de usar los argumentos?
+- ¿La especie o el ensamblaje es explícito?
+- ¿Los identificadores se preservan exactamente, incluidos los prefijos de Ensembl/UniProt?
+- ¿El resultado está etiquetado como salida de base de datos y no como interpretación clínica?
+- ¿La consulta es reproducible desde el comando o el fragmento de Python guardado?
+- ¿Las dependencias opcionales se instalan en un entorno aislado?
+
+## Nota
+
+Los resultados de `gget` son datos de bases de referencia, no interpretación clínica. No sustituyen
+el juicio de un profesional cualificado; toda decisión clínica o diagnóstica debe validarse mediante
+flujos regulados y revisión experta.
+
+## Referencias
+
+- [Documentación de gget](https://pachterlab.github.io/gget/)
+- [Actualizaciones de gget](https://pachterlab.github.io/gget/en/updates.html)
+- [Repositorio de gget en GitHub](https://github.com/pachterlab/gget)
+- [Artículo de gget en Bioinformatics](https://doi.org/10.1093/bioinformatics/btac836)

package/vendor/theus-arsenal/skills/contacto-inversores/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: contacto-inversores
+description: Redacta correos en frío, textos para intros cálidas, seguimientos, correos de actualización y comunicaciones con inversores durante el levantamiento de capital. Úsala cuando se necesite contactar a ángeles, VCs, inversores estratégicos o aceleradoras con mensajes concisos y personalizados.
+---
+
+# Contacto con inversores
+
+Escribe comunicación con inversores que sea corta, concreta y fácil de accionar.
+
+## Cuándo usarla
+
+- Al escribir un correo en frío a un inversor.
+- Al redactar una solicitud de introducción cálida.
+- Al enviar seguimientos tras una reunión o ante la falta de respuesta.
+- Al escribir actualizaciones para inversores durante un proceso.
+- Al adaptar el mensaje según la tesis del fondo o el encaje con un socio concreto.
+
+## Reglas centrales
+
+1. Personaliza cada mensaje saliente.
+2. Mantén la petición de baja fricción.
+3. Usa pruebas en lugar de adjetivos.
+4. Sé conciso.
+5. Nunca envíes un texto que podría ir dirigido a cualquier inversor.
+
+## Manejo de la voz
+
+Si la voz del usuario importa, ejecuta primero `voz-de-marca` y reutiliza su `VOICE PROFILE`.
+Esta skill debe conservar la estructura específica para inversores y la disciplina de la petición, no recrear su propio sistema de voz en paralelo.
+
+## Prohibiciones estrictas
+
+Elimina y reescribe cualquiera de estos:
+- "me encantaría conectar"
+- "emocionado de compartir"
+- elogios genéricos a la tesis sin una conexión real
+- adjetivos vagos sobre los fundadores
+- lenguaje suplicante
+- preguntas de cierre blandas cuando una petición directa es más clara
+
+## Estructura del correo en frío
+
+1. Asunto: corto y específico.
+2. Apertura: por qué este inversor en particular.
+3. Pitch: qué hace la empresa, por qué ahora y qué prueba importa.
+4. Petición: un único paso siguiente concreto.
+5. Firma: nombre, rol y un ancla de credibilidad si hace falta.
+
+## Fuentes de personalización
+
+Referencia una o más de estas:
+- empresas relevantes del portafolio
+- una tesis pública, charla, publicación o artículo
+- una conexión en común
+- un encaje claro de mercado o producto con el foco del inversor
+
+Si falta ese contexto, indica que el borrador aún necesita personalización en lugar de fingir que está terminado.
+
+## Cadencia de seguimiento
+
+Por defecto:
+- día 0: mensaje inicial
+- día 4 o 5: seguimiento corto con un dato nuevo
+- día 10 a 12: seguimiento final con un cierre limpio
+
+No sigas insistiendo después de eso salvo que el usuario quiera una secuencia más larga.
+
+## Solicitudes de introducción cálida
+
+Facilita la vida a quien conecta:
+- explica por qué la introducción tiene sentido
+- incluye un blurb reenviable
+- mantén el blurb reenviable por debajo de 100 palabras
+
+## Actualizaciones posteriores a una reunión
+
+Incluye:
+- el tema específico que se discutió
+- la respuesta o actualización prometida
+- una prueba nueva si está disponible
+- el paso siguiente
+
+## Control de calidad
+
+Antes de entregar:
+- el mensaje está genuinamente personalizado
+- la petición es explícita
+- la prueba es concreta
+- el relleno elogioso y el lenguaje suavizante desaparecieron
+- el conteo de palabras se mantiene ajustado
+
+## Skills relacionadas
+
+- `materiales-inversores`
+- `voz-de-marca`

package/vendor/theus-arsenal/skills/corrutinas-flows-kotlin/SKILL.md

@@ -0,0 +1,284 @@
+---
+name: corrutinas-flows-kotlin
+description: Patrones de corrutinas y Flow de Kotlin para Android y KMP — concurrencia estructurada, operadores de Flow, StateFlow, manejo de errores y testing.
+---
+
+# Corrutinas y Flows de Kotlin
+
+Patrones de concurrencia estructurada, streams reactivos basados en Flow y testing de corrutinas en proyectos Android y Kotlin Multiplatform.
+
+## Cuándo activarla
+
+- Al escribir código asíncrono con corrutinas de Kotlin
+- Al usar Flow, StateFlow o SharedFlow para datos reactivos
+- Al manejar operaciones concurrentes (carga en paralelo, debounce, reintentos)
+- Al testear corrutinas y Flows
+- Al gestionar scopes de corrutinas y cancelación
+
+## Concurrencia estructurada
+
+### Jerarquía de scopes
+
+```
+Application
+  └── viewModelScope (ViewModel)
+        └── coroutineScope { } (hijo estructurado)
+              ├── async { } (tarea concurrente)
+              └── async { } (tarea concurrente)
+```
+
+Usa siempre concurrencia estructurada — nunca `GlobalScope`:
+
+```kotlin
+// MAL
+GlobalScope.launch { fetchData() }
+
+// BIEN — ligado al ciclo de vida del ViewModel
+viewModelScope.launch { fetchData() }
+
+// BIEN — ligado al ciclo de vida del composable
+LaunchedEffect(key) { fetchData() }
+```
+
+### Descomposición en paralelo
+
+Usa `coroutineScope` + `async` para trabajo en paralelo:
+
+```kotlin
+suspend fun loadDashboard(): Dashboard = coroutineScope {
+    val items = async { itemRepository.getRecent() }
+    val stats = async { statsRepository.getToday() }
+    val profile = async { userRepository.getCurrent() }
+    Dashboard(
+        items = items.await(),
+        stats = stats.await(),
+        profile = profile.await()
+    )
+}
+```
+
+### SupervisorScope
+
+Usa `supervisorScope` cuando los fallos de un hijo no deben cancelar a sus hermanos:
+
+```kotlin
+suspend fun syncAll() = supervisorScope {
+    launch { syncItems() }       // un fallo aquí no cancela syncStats
+    launch { syncStats() }
+    launch { syncSettings() }
+}
+```
+
+## Patrones de Flow
+
+### Flow frío — conversión de una operación puntual a stream
+
+```kotlin
+fun observeItems(): Flow<List<Item>> = flow {
+    // Re-emite cada vez que la base de datos cambia
+    itemDao.observeAll()
+        .map { entities -> entities.map { it.toDomain() } }
+        .collect { emit(it) }
+}
+```
+
+### StateFlow para el estado de UI
+
+```kotlin
+class DashboardViewModel(
+    observeProgress: ObserveUserProgressUseCase
+) : ViewModel() {
+    val progress: StateFlow<UserProgress> = observeProgress()
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000),
+            initialValue = UserProgress.EMPTY
+        )
+}
+```
+
+`WhileSubscribed(5_000)` mantiene el upstream activo durante 5 segundos después de que el último suscriptor se va — sobrevive a los cambios de configuración sin reiniciarse.
+
+### Combinar múltiples Flows
+
+```kotlin
+val uiState: StateFlow<HomeState> = combine(
+    itemRepository.observeItems(),
+    settingsRepository.observeTheme(),
+    userRepository.observeProfile()
+) { items, theme, profile ->
+    HomeState(items = items, theme = theme, profile = profile)
+}.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), HomeState())
+```
+
+### Operadores de Flow
+
+```kotlin
+// Debounce en la entrada de búsqueda
+searchQuery
+    .debounce(300)
+    .distinctUntilChanged()
+    .flatMapLatest { query -> repository.search(query) }
+    .catch { emit(emptyList()) }
+    .collect { results -> _state.update { it.copy(results = results) } }
+
+// Reintento con backoff exponencial
+fun fetchWithRetry(): Flow<Data> = flow { emit(api.fetch()) }
+    .retryWhen { cause, attempt ->
+        if (cause is IOException && attempt < 3) {
+            delay(1000L * (1 shl attempt.toInt()))
+            true
+        } else {
+            false
+        }
+    }
+```
+
+### SharedFlow para eventos de una sola vez
+
+```kotlin
+class ItemListViewModel : ViewModel() {
+    private val _effects = MutableSharedFlow<Effect>()
+    val effects: SharedFlow<Effect> = _effects.asSharedFlow()
+
+    sealed interface Effect {
+        data class ShowSnackbar(val message: String) : Effect
+        data class NavigateTo(val route: String) : Effect
+    }
+
+    private fun deleteItem(id: String) {
+        viewModelScope.launch {
+            repository.delete(id)
+            _effects.emit(Effect.ShowSnackbar("Elemento eliminado"))
+        }
+    }
+}
+
+// Recolección en un Composable
+LaunchedEffect(Unit) {
+    viewModel.effects.collect { effect ->
+        when (effect) {
+            is Effect.ShowSnackbar -> snackbarHostState.showSnackbar(effect.message)
+            is Effect.NavigateTo -> navController.navigate(effect.route)
+        }
+    }
+}
+```
+
+## Dispatchers
+
+```kotlin
+// Trabajo intensivo en CPU
+withContext(Dispatchers.Default) { parseJson(largePayload) }
+
+// Trabajo de E/S
+withContext(Dispatchers.IO) { database.query() }
+
+// Hilo principal (UI) — por defecto en viewModelScope
+withContext(Dispatchers.Main) { updateUi() }
+```
+
+En KMP, usa `Dispatchers.Default` y `Dispatchers.Main` (disponibles en todas las plataformas). `Dispatchers.IO` es solo JVM/Android — usa `Dispatchers.Default` en las demás plataformas o provéelo vía DI.
+
+## Cancelación
+
+### Cancelación cooperativa
+
+Los bucles de larga duración deben comprobar la cancelación:
+
+```kotlin
+suspend fun processItems(items: List<Item>) = coroutineScope {
+    for (item in items) {
+        ensureActive()  // lanza CancellationException si fue cancelado
+        process(item)
+    }
+}
+```
+
+### Limpieza con try/finally
+
+```kotlin
+viewModelScope.launch {
+    try {
+        _state.update { it.copy(isLoading = true) }
+        val data = repository.fetch()
+        _state.update { it.copy(data = data) }
+    } finally {
+        _state.update { it.copy(isLoading = false) }  // se ejecuta siempre, incluso al cancelar
+    }
+}
+```
+
+## Testing
+
+### Testear StateFlow con Turbine
+
+```kotlin
+@Test
+fun `la busqueda actualiza la lista de elementos`() = runTest {
+    val fakeRepository = FakeItemRepository().apply { emit(testItems) }
+    val viewModel = ItemListViewModel(GetItemsUseCase(fakeRepository))
+
+    viewModel.state.test {
+        assertEquals(ItemListState(), awaitItem())  // estado inicial
+
+        viewModel.onSearch("query")
+        val loading = awaitItem()
+        assertTrue(loading.isLoading)
+
+        val loaded = awaitItem()
+        assertFalse(loaded.isLoading)
+        assertEquals(1, loaded.items.size)
+    }
+}
+```
+
+### Testear con TestDispatcher
+
+```kotlin
+@Test
+fun `la carga en paralelo completa correctamente`() = runTest {
+    val viewModel = DashboardViewModel(
+        itemRepo = FakeItemRepo(),
+        statsRepo = FakeStatsRepo()
+    )
+
+    viewModel.load()
+    advanceUntilIdle()
+
+    val state = viewModel.state.value
+    assertNotNull(state.items)
+    assertNotNull(state.stats)
+}
+```
+
+### Falsear Flows
+
+```kotlin
+class FakeItemRepository : ItemRepository {
+    private val _items = MutableStateFlow<List<Item>>(emptyList())
+
+    override fun observeItems(): Flow<List<Item>> = _items
+
+    fun emit(items: List<Item>) { _items.value = items }
+
+    override suspend fun getItemsByCategory(category: String): Result<List<Item>> {
+        return Result.success(_items.value.filter { it.category == category })
+    }
+}
+```
+
+## Antipatrones a evitar
+
+- Usar `GlobalScope` — filtra corrutinas, sin cancelación estructurada
+- Recolectar Flows en `init {}` sin un scope — usa `viewModelScope.launch`
+- Usar `MutableStateFlow` con colecciones mutables — usa siempre copias inmutables: `_state.update { it.copy(list = it.list + newItem) }`
+- Capturar `CancellationException` — deja que se propague para una cancelación correcta
+- Usar `flowOn(Dispatchers.Main)` para recolectar — el dispatcher de recolección es el del llamador
+- Crear un `Flow` en un `@Composable` sin `remember` — recrea el flow en cada recomposición
+
+## Skills relacionadas
+
+- `patrones-compose-multiplatform` — consumo de Flows desde la UI
+- `arquitectura-limpia-android` — dónde encajan las corrutinas en las capas
+- `testing-kotlin`

package/vendor/theus-arsenal/skills/creacion-video-remotion/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: creacion-video-remotion
+description: Buenas prácticas para Remotion — creación de video con React. 29 reglas de dominio
+  que cubren 3D, animaciones, audio, subtítulos, gráficas, transiciones y más.
+metadata:
+  tags: remotion, video, react, animacion, composicion, three.js, lottie
+---
+
+# Creación de video con Remotion
+
+## Cuándo usarla
+
+Usa esta skill siempre que trabajes con código de Remotion para obtener el conocimiento específico del dominio.
+
+## Cómo usarla
+
+Lee los archivos de reglas individuales para explicaciones detalladas y ejemplos de código:
+
+- [rules/3d.md](rules/3d.md) - Contenido 3D en Remotion con Three.js y React Three Fiber
+- [rules/animations.md](rules/animations.md) - Fundamentos de animación en Remotion
+- [rules/assets.md](rules/assets.md) - Importar imágenes, videos, audio y fuentes en Remotion
+- [rules/audio.md](rules/audio.md) - Uso de audio y sonido en Remotion: importación, recorte, volumen, velocidad, tono
+- [rules/calculate-metadata.md](rules/calculate-metadata.md) - Definir dinámicamente duración, dimensiones y props de la composición
+- [rules/can-decode.md](rules/can-decode.md) - Comprobar si el navegador puede decodificar un video usando Mediabunny
+- [rules/charts.md](rules/charts.md) - Patrones de gráficas y visualización de datos para Remotion
+- [rules/compositions.md](rules/compositions.md) - Definir composiciones, stills, carpetas, props por defecto y metadatos dinámicos
+- [rules/display-captions.md](rules/display-captions.md) - Mostrar subtítulos en Remotion con páginas estilo TikTok y resaltado de palabras
+- [rules/extract-frames.md](rules/extract-frames.md) - Extraer fotogramas de videos en marcas de tiempo específicas usando Mediabunny
+- [rules/fonts.md](rules/fonts.md) - Cargar Google Fonts y fuentes locales en Remotion
+- [rules/get-audio-duration.md](rules/get-audio-duration.md) - Obtener la duración de un archivo de audio en segundos con Mediabunny
+- [rules/get-video-dimensions.md](rules/get-video-dimensions.md) - Obtener el ancho y alto de un archivo de video con Mediabunny
+- [rules/get-video-duration.md](rules/get-video-duration.md) - Obtener la duración de un archivo de video en segundos con Mediabunny
+- [rules/gifs.md](rules/gifs.md) - Mostrar GIF sincronizados con la línea de tiempo de Remotion
+- [rules/images.md](rules/images.md) - Incrustar imágenes en Remotion con el componente Img
+- [rules/import-srt-captions.md](rules/import-srt-captions.md) - Importar archivos de subtítulos .srt en Remotion con @remotion/captions
+- [rules/lottie.md](rules/lottie.md) - Incrustar animaciones Lottie en Remotion
+- [rules/measuring-dom-nodes.md](rules/measuring-dom-nodes.md) - Medir dimensiones de elementos del DOM en Remotion
+- [rules/measuring-text.md](rules/measuring-text.md) - Medir texto, ajustarlo a contenedores y comprobar desbordamiento
+- [rules/sequencing.md](rules/sequencing.md) - Patrones de secuenciación en Remotion: retrasar, recortar y limitar la duración de elementos
+- [rules/tailwind.md](rules/tailwind.md) - Uso de TailwindCSS en Remotion
+- [rules/text-animations.md](rules/text-animations.md) - Patrones de tipografía y animación de texto para Remotion
+- [rules/timing.md](rules/timing.md) - Curvas de interpolación en Remotion: lineal, easing y animaciones spring
+- [rules/transcribe-captions.md](rules/transcribe-captions.md) - Transcribir audio para generar subtítulos en Remotion
+- [rules/transitions.md](rules/transitions.md) - Patrones de transición entre escenas para Remotion
+- [rules/trimming.md](rules/trimming.md) - Patrones de recorte en Remotion: cortar el inicio o el final de una animación
+- [rules/videos.md](rules/videos.md) - Incrustar videos en Remotion: recorte, volumen, velocidad, bucle, tono

package/vendor/theus-arsenal/skills/creacion-video-remotion/rules/3d.md

@@ -0,0 +1,86 @@
+---
+name: 3d
+description: Contenido 3D en Remotion con Three.js y React Three Fiber.
+metadata:
+  tags: 3d, three, threejs
+---
+
+# Usar Three.js y React Three Fiber en Remotion
+
+Sigue las buenas prácticas de React Three Fiber y Three.js.
+Solo hay que respetar las siguientes reglas específicas de Remotion:
+
+## Requisitos previos
+
+Primero debe estar instalado el paquete `@remotion/three`.
+Si no lo está, usa el siguiente comando:
+
+```bash
+npx remotion add @remotion/three # Si el proyecto usa npm
+bunx remotion add @remotion/three # Si el proyecto usa bun
+yarn remotion add @remotion/three # Si el proyecto usa yarn
+pnpm exec remotion add @remotion/three # Si el proyecto usa pnpm
+```
+
+## Uso de ThreeCanvas
+
+DEBES envolver el contenido 3D en `<ThreeCanvas>` e incluir una iluminación adecuada.
+`<ThreeCanvas>` DEBE tener las props `width` y `height`.
+
+```tsx
+import { ThreeCanvas } from "@remotion/three";
+import { useVideoConfig } from "remotion";
+
+const { width, height } = useVideoConfig();
+
+<ThreeCanvas width={width} height={height}>
+  <ambientLight intensity={0.4} />
+  <directionalLight position={[5, 5, 5]} intensity={0.8} />
+  <mesh>
+    <sphereGeometry args={[1, 32, 32]} />
+    <meshStandardMaterial color="red" />
+  </mesh>
+</ThreeCanvas>
+```
+
+## Ninguna animación fuera de `useCurrentFrame()`
+
+Los shaders, modelos, etc. NO DEBEN animarse por sí solos.
+No se permite ninguna animación que no esté dirigida por `useCurrentFrame()`.
+De lo contrario, provocará parpadeos durante el renderizado.
+
+Está prohibido usar `useFrame()` de `@react-three/fiber`.
+
+## Animar con `useCurrentFrame()`
+
+Usa `useCurrentFrame()` para realizar las animaciones.
+
+```tsx
+const frame = useCurrentFrame();
+const rotationY = frame * 0.02;
+
+<mesh rotation={[0, rotationY, 0]}>
+  <boxGeometry args={[2, 2, 2]} />
+  <meshStandardMaterial color="#4a9eff" />
+</mesh>
+```
+
+## Uso de `<Sequence>` dentro de `<ThreeCanvas>`
+
+La prop `layout` de cualquier `<Sequence>` dentro de un `<ThreeCanvas>` debe ser `none`.
+
+```tsx
+import { Sequence } from "remotion";
+import { ThreeCanvas } from "@remotion/three";
+
+const { width, height } = useVideoConfig();
+
+<ThreeCanvas width={width} height={height}>
+  <Sequence layout="none">
+    <mesh>
+      <boxGeometry args={[2, 2, 2]} />
+      <meshStandardMaterial color="#4a9eff" />
+    </mesh>
+  </Sequence>
+</ThreeCanvas>
+```