theus-cli-linux-x64 1.2.2 → 1.4.0

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

@@ -1,170 +0,0 @@
----
-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

@@ -1,95 +0,0 @@
----
-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

@@ -1,284 +0,0 @@
----
-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

@@ -1,46 +0,0 @@
----
-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

@@ -1,86 +0,0 @@
----
-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>
-```