npm - theus-cli - Versions diffs - 0.2.83 → 0.2.85 - Mend

theus-cli 0.2.83 → 0.2.85

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (738) hide show

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

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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>
-```