@danhachuel/thunderbolt 0.4.76 → 0.4.78

package/app/main.py

@@ -69,6 +69,7 @@ from hermes_ui.update_manager import check_version, restart_current_process, upd
 from hermes_ui.script_documents import list_script_documents, read_script_document, save_script_document, script_storage_path
 from hermes_ui.script_generation import generate_script_document
 from hermes_ui.voice_preview import DEFAULT_SAMPLE, load_preview_file, synthesize_preview
+from hermes_ui.elevenlabs_voices import ElevenLabsVoicesError, cached_personal_voices, fetch_personal_voices, personal_voice_options
 from hermes_ui.thumbnail_generation import ThumbnailGenerationError, generate_thumbnail_image
 from hermes_ui.thumbnails import (
     generate_thumbnail_for_task,
@@ -185,7 +186,7 @@ VIDEO_CONCATENATION_OPTIONS = ["Random Concatenation (Recommended)", "Sequential
 VIDEO_TRANSITION_OPTIONS = ["None", "Fade", "Dissolve"]
 VIDEO_ENCODER_OPTIONS = ["Default (Recommended)", "H.264", "H.265"]
 VOICEOVER_MODE_OPTIONS = ["Auto", "Upload", "None"]
-VOICEOVER_SERVICE_OPTIONS = ["Azure Speech SDK V2", "Azure TTS V1"]
+VOICEOVER_SERVICE_OPTIONS = ["Azure Speech SDK V2", "Azure TTS V1", "ElevenLabs"]
 VOICEOVER_VOLUME_OPTIONS = ["20%", "40%", "60%", "80%", "100%"]
 VOICEOVER_SPEED_OPTIONS = ["0.5x", "0.75x", "1.0x", "1.25x", "1.5x", "2.0x"]
 BACKGROUND_MUSIC_SOURCE_OPTIONS = ["Ficheiro existente", "Carregar ficheiro", "Criar via Suno API", "Random Background Music", "Sem música"]
@@ -928,6 +929,9 @@ def voice_catalog(current: str = "") -> list[str]:
         voices.extend(f"{item.get('name', '')}-{item.get('gender', '')}" for item in voice_data if item.get("name"))
     except (OSError, json.JSONDecodeError):
         pass
+    for voice_id in personal_voice_options(read_json("settings.json", {})):
+        if voice_id not in voices:
+            voices.append(voice_id)
     for candidate in (current, "en-US-AriaNeural-Female", "pt-BR-FranciscaNeural-Female", "pt-BR-AntonioNeural-Male"):
         if candidate and candidate not in voices:
             voices.append(candidate)
@@ -1091,6 +1095,8 @@ def render_video_generation_settings(
                     and str(configured_voice_settings.get("azure_speech_region") or "").strip()
                 )
                 voice_service_default = "Azure Speech SDK V2" if configured_azure_voice else "Azure TTS V1"
+                if str(st.session_state.get(f"{prefix}_voice", "")).strip() in personal_voice_options(configured_voice_settings):
+                    voice_service_default = "ElevenLabs"
                 voice_service_index = VOICEOVER_SERVICE_OPTIONS.index(voice_service_default)
                 settings["voiceover_service"] = st.selectbox(
                     "Voiceover Service",
@@ -1108,7 +1114,13 @@ def render_video_generation_settings(
                         st.session_state[channel_state_key] = channel_id
                 current_voice = str(st.session_state.get(f"{prefix}_voice", ""))
                 voice_options = voice_catalog(current_voice)
-                settings["voice"] = st.selectbox("Voice (match script language)", voice_options, format_func=lambda value: value or "Sem voz seleccionada", key=f"{prefix}_voice")
+                personal_options = personal_voice_options(configured_voice_settings)
+                settings["voice"] = st.selectbox(
+                    "Voice (match script language)",
+                    voice_options,
+                    format_func=lambda value: personal_options.get(value, value) if value else "Sem voz seleccionada",
+                    key=f"{prefix}_voice",
+                )
                 volume_speed_cols = st.columns(2)
                 with volume_speed_cols[0]:
                     settings["voiceover_volume"] = st.selectbox("Voiceover Volume", VOICEOVER_VOLUME_OPTIONS, index=VOICEOVER_VOLUME_OPTIONS.index("100%"), key=f"{prefix}_voiceover_volume")
@@ -3312,7 +3324,7 @@ def render_music_creation():
             ("music_task_prompt", "prompt"),
         ):
             st.session_state[state_key] = str(generated_fields.get(generated_key) or "")
-    provider_label = st.selectbox("Provider de geração musical", ["Suno AI", "Google Lyria"], key="music_task_provider")
+    provider_label = st.selectbox("Provider de geração musical", ["Suno AI", "Google Lyria", "Eleven Music"], key="music_task_provider")
     theme = st.text_input("Tema / assunto principal", key="music_task_theme", placeholder="Ex.: uma viagem nocturna pela costa portuguesa")
     title = st.text_input("Título da música", key="music_task_title")
     language = st.selectbox(
@@ -3324,6 +3336,26 @@ def render_music_creation():
     )
     genre = st.selectbox("Género musical", list(MUSIC_GENRES), key="music_task_genre")
     vocal = st.selectbox("Vocal", list(MUSIC_VOCAL_OPTIONS), key="music_task_vocal")
+    eleven_voice_id = ""
+    eleven_voice_gender = ""
+    if provider_label == "Eleven Music":
+        cached_voices = cached_personal_voices()
+        if not cached_voices:
+            st.info("Sincronize primeiro as vozes pessoais em Vozes Personalizadas. O Eleven Music não disponibiliza voz de coral para este selector.")
+        else:
+            voice_options = {str(item.get("voice_id")): item for item in cached_voices if item.get("voice_id")}
+            selected_voice_id = st.selectbox(
+                "Voz personalizada (Eleven Music)",
+                [""] + list(voice_options),
+                format_func=lambda item: "Sem voz personalizada" if not item else str(voice_options[item].get("name") or item),
+                key="music_task_eleven_voice",
+            )
+            eleven_voice_id = selected_voice_id
+            selected_voice = voice_options.get(selected_voice_id, {})
+            labels = selected_voice.get("labels") if isinstance(selected_voice.get("labels"), dict) else {}
+            raw_gender = str(labels.get("gender") or labels.get("sex") or "").strip().casefold()
+            eleven_voice_gender = "female" if raw_gender in {"female", "feminino", "woman", "mulher"} else ("male" if raw_gender in {"male", "masculino", "man", "homem"} else "")
+            st.caption(f"Tipo de voz detectado automaticamente: {eleven_voice_gender or 'não identificado'}. Vozes de coral não estão disponíveis no Eleven Music.")
     references = st.text_area(
         "Referências culturais, paisagens, clima ou artistas similares (opcional)",
         key="music_task_references",
@@ -3368,6 +3400,8 @@ def render_music_creation():
                 vocal=vocal,
                 references=references,
                 theme=theme,
+                voice_id=eleven_voice_id,
+                voice_gender=eleven_voice_gender,
             )
             st.success(f"Música criada no Music Backlog: {task['title']}")
             st.rerun()
@@ -3376,8 +3410,49 @@ def render_music_creation():
 
 
 def render_custom_music_voices() -> None:
-    """Reserved view for future reusable custom music-voice blueprints."""
+    """List and test personal ElevenLabs voices without exposing credentials."""
     st.title("Vozes Personalizadas")
+    st.caption("Vozes pessoais do ElevenLabs Voice Lab disponíveis para narração no Thunderbolt.")
+    settings = read_json("settings.json", {})
+    refresh_col, cache_col = st.columns([1, 2])
+    with refresh_col:
+        refresh = st.button("Actualizar vozes", type="primary", use_container_width=True, key="elevenlabs_refresh_voices")
+    try:
+        voices, metadata = fetch_personal_voices(settings, force=refresh)
+        if metadata.get("source") == "cache":
+            label = "cache local"
+            if metadata.get("stale"):
+                st.warning("A API não respondeu; a mostrar a última lista guardada localmente.")
+        else:
+            label = "API ElevenLabs"
+        with cache_col:
+            st.caption(f"Fonte: {label} · última actualização: {metadata.get('updated_at') or '—'}")
+    except ElevenLabsVoicesError as exc:
+        st.warning(str(exc))
+        st.info("As vozes padrão continuam disponíveis na criação de vídeos.")
+        return
+
+    if not voices:
+        st.info("Nenhuma voz pessoal foi encontrada nesta conta ElevenLabs.")
+        return
+    test_text = st.text_input("Texto curto para testar uma voz", value=DEFAULT_SAMPLE, key="elevenlabs_voice_test_text")
+    for voice in voices:
+        with st.container(border=True):
+            voice_cols = st.columns([2.2, 1.8, 1])
+            with voice_cols[0]:
+                st.markdown(f"**{voice.get('name', 'Sem nome')}**")
+                st.caption(f"ID: `{voice.get('voice_id', '')}`")
+            with voice_cols[1]:
+                labels = voice.get("labels") or {}
+                st.caption("Categoria: personal")
+                st.caption("Labels: " + (", ".join(f"{key}: {value}" for key, value in labels.items()) if labels else "não disponíveis"))
+            with voice_cols[2]:
+                if st.button("Testar voz", key=f"elevenlabs_test_voice_{voice['voice_id']}", use_container_width=True):
+                    try:
+                        preview = synthesize_preview(test_text, "elevenlabs", voice["voice_id"], settings)
+                        st.audio(str(preview), format="audio/mpeg")
+                    except (OSError, RuntimeError, ValueError) as exc:
+                        st.error(f"Não foi possível testar esta voz: {exc}")
 
 
 def render_scripts():

package/hermes_ui/elevenlabs_voices.py

@@ -0,0 +1,134 @@
+"""ElevenLabs personal voice catalogue with local, credential-safe caching."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+from typing import Any, Callable
+
+import requests
+
+from . import storage
+
+CACHE_FILENAME = "elevenlabs_voices.json"
+DEFAULT_CACHE_TTL_SECONDS = 6 * 60 * 60
+VOICES_ENDPOINT = "https://api.elevenlabs.io/v1/voices"
+
+
+class ElevenLabsVoicesError(RuntimeError):
+    """A safe, user-facing error raised while reading the ElevenLabs catalogue."""
+
+
+def cache_path() -> Path:
+    return storage.STATE / CACHE_FILENAME
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _normalise_voice(item: Any) -> dict[str, Any] | None:
+    if not isinstance(item, dict):
+        return None
+    voice_id = str(item.get("voice_id") or "").strip()
+    category = str(item.get("category") or "").strip().casefold()
+    name = str(item.get("name") or "").strip()
+    if not voice_id or not name or category != "personal":
+        return None
+    labels = item.get("labels") if isinstance(item.get("labels"), dict) else {}
+    samples = item.get("samples") if isinstance(item.get("samples"), list) else []
+    return {
+        "voice_id": voice_id,
+        "name": name,
+        "category": "personal",
+        "labels": {str(key): str(value) for key, value in labels.items()},
+        "samples": [sample for sample in samples if isinstance(sample, dict)],
+    }
+
+
+def normalise_voices(payload: Any) -> list[dict[str, Any]]:
+    items = payload.get("voices", []) if isinstance(payload, dict) else []
+    if not isinstance(items, list):
+        raise ElevenLabsVoicesError("A API ElevenLabs devolveu uma lista de vozes inválida.")
+    result = [_normalise_voice(item) for item in items]
+    return [item for item in result if item is not None]
+
+
+def _read_cache() -> dict[str, Any] | None:
+    payload = storage.read_json(CACHE_FILENAME, {})
+    return payload if isinstance(payload, dict) and isinstance(payload.get("voices"), list) else None
+
+
+def _cache_is_fresh(cache: dict[str, Any], ttl_seconds: int) -> bool:
+    try:
+        updated = datetime.fromisoformat(str(cache.get("updated_at")).replace("Z", "+00:00"))
+        return (_utc_now() - updated).total_seconds() < ttl_seconds
+    except (TypeError, ValueError, OverflowError):
+        return False
+
+
+def _save_cache(voices: list[dict[str, Any]], *, source: str) -> dict[str, Any]:
+    payload = {"updated_at": _utc_now().isoformat(), "source": source, "voices": voices}
+    storage.write_json(CACHE_FILENAME, payload)
+    return payload
+
+
+def fetch_personal_voices(
+    settings: dict[str, Any],
+    *,
+    force: bool = False,
+    ttl_seconds: int = DEFAULT_CACHE_TTL_SECONDS,
+    request_get: Callable[..., Any] = requests.get,
+) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    """Return personal voices, using cache unless force is requested."""
+    cache = _read_cache()
+    if cache and not force and _cache_is_fresh(cache, ttl_seconds):
+        return list(cache["voices"]), {"source": "cache", "updated_at": cache.get("updated_at")}
+
+    api_key = str(settings.get("elevenlabs_api_key") or "").strip()
+    if not api_key:
+        if cache:
+            return list(cache["voices"]), {"source": "cache", "updated_at": cache.get("updated_at"), "stale": True}
+        raise ElevenLabsVoicesError("Configure a API Key do ElevenLabs em Configuração API antes de actualizar as vozes.")
+    try:
+        response = request_get(VOICES_ENDPOINT, headers={"xi-api-key": api_key}, timeout=30)
+        status = int(getattr(response, "status_code", 200))
+        if status == 401:
+            raise ElevenLabsVoicesError("A API Key do ElevenLabs foi recusada. Confirme a chave em Configuração API.")
+        if status == 429:
+            raise ElevenLabsVoicesError("O limite de pedidos do ElevenLabs foi atingido. Tente novamente mais tarde.")
+        response.raise_for_status()
+        voices = normalise_voices(response.json())
+        saved = _save_cache(voices, source="elevenlabs_api")
+        return voices, {"source": "api", "updated_at": saved["updated_at"]}
+    except ElevenLabsVoicesError:
+        if cache:
+            return list(cache["voices"]), {"source": "cache", "updated_at": cache.get("updated_at"), "stale": True}
+        raise
+    except requests.Timeout as exc:
+        if cache:
+            return list(cache["voices"]), {"source": "cache", "updated_at": cache.get("updated_at"), "stale": True}
+        raise ElevenLabsVoicesError("O ElevenLabs demorou demasiado tempo a responder. Tente novamente.") from exc
+    except (requests.RequestException, ValueError, json.JSONDecodeError) as exc:
+        if cache:
+            return list(cache["voices"]), {"source": "cache", "updated_at": cache.get("updated_at"), "stale": True}
+        raise ElevenLabsVoicesError("Não foi possível obter as vozes do ElevenLabs. Verifique a ligação e a API Key.") from exc
+
+
+def personal_voice_options(settings: dict[str, Any]) -> dict[str, str]:
+    """Return voice_id -> display label without contacting the remote API."""
+    cache = _read_cache()
+    if not cache:
+        return {}
+    return {
+        str(voice["voice_id"]): f"{voice.get('name', voice['voice_id'])} · ElevenLabs personal"
+        for voice in cache.get("voices", [])
+        if isinstance(voice, dict) and voice.get("voice_id")
+    }
+
+
+def cached_personal_voices() -> list[dict[str, Any]]:
+    """Return the locally cached personal voices without making a network call."""
+    cache = _read_cache()
+    return [voice for voice in (cache or {}).get("voices", []) if isinstance(voice, dict)]

package/hermes_ui/music.py

@@ -155,6 +155,8 @@ def create_music_task(
     vocal: str = "",
     references: str = "",
     theme: str = "",
+    voice_id: str = "",
+    voice_gender: str = "",
 ) -> dict[str, Any]:
     """Enqueue one audio-only generation; no video task or video worker is used."""
     cleaned_prompt = str(prompt or "").strip()
@@ -164,7 +166,7 @@ def create_music_task(
     task = {
         "id": f"music_{uuid.uuid4().hex[:12]}",
         "kind": "audio_generation",
-        "provider": "lyria" if str(provider).strip().casefold() == "google lyria" else "suno",
+        "provider": "lyria" if str(provider).strip().casefold() == "google lyria" else ("eleven_music" if str(provider).strip().casefold() == "eleven music" else "suno"),
         "model": str(model or "").strip(),
         "title": str(title or "Música sem título").strip() or "Música sem título",
         "prompt": cleaned_prompt,
@@ -173,6 +175,8 @@ def create_music_task(
         "vocal": str(vocal or "").strip(),
         "references": str(references or "").strip(),
         "theme": str(theme or "").strip(),
+        "voice_id": str(voice_id or "").strip(),
+        "voice_gender": str(voice_gender or "").strip().casefold(),
         "duration_seconds": 120,
         "state": "to_do",
         "stage": "music_generation",
@@ -258,6 +262,33 @@ def request_lyria_generation(settings: dict[str, Any], prompt: str, title: str =
         return {"ok": False, "message": "Não foi possível contactar Google Lyria.", "data": {}}
 
 
+def request_eleven_music_generation(settings: dict[str, Any], prompt: str, title: str = "", model: str = "music_v2", *, voice_id: str = "", voice_gender: str = "") -> dict[str, Any]:
+    """Generate music through Eleven Music's synchronous Music API."""
+    api_key = str(settings.get("elevenlabs_api_key") or "").strip()
+    if not api_key:
+        return {"ok": False, "message": "Configure a API Key do ElevenLabs em Configuração API antes de solicitar Eleven Music.", "data": {}}
+    clean_prompt = str(prompt or "").strip()
+    if voice_id:
+        gender = voice_gender if voice_gender in {"male", "female"} else "unspecified"
+        clean_prompt = f"{clean_prompt}\nVocal principal: voz personalizada ElevenLabs seleccionada ({gender}). Não usar coro."
+    try:
+        response = requests.post(
+            "https://api.elevenlabs.io/v1/music",
+            params={"output_format": "mp3_44100_128"},
+            headers={"xi-api-key": api_key, "Content-Type": "application/json"},
+            json={"prompt": clean_prompt[:4100], "model_id": model or "music_v2", "force_instrumental": False},
+            timeout=300,
+        )
+        if response.status_code >= 400:
+            return {"ok": False, "message": f"Eleven Music devolveu HTTP {response.status_code}.", "data": {"status_code": response.status_code}}
+        if not response.content:
+            return {"ok": False, "message": "Eleven Music não devolveu áudio.", "data": {}}
+        output = store_music_file(f"{title or 'eleven-music-generated'}.mp3", response.content)
+        return {"ok": True, "message": "Música gerada por Eleven Music.", "data": {"audio_path": str(output), "model": model or "music_v2", "voice_id": voice_id, "voice_gender": voice_gender}}
+    except (requests.RequestException, OSError, ValueError) as exc:
+        return {"ok": False, "message": f"Não foi possível contactar Eleven Music: {exc}", "data": {}}
+
+
 def run_music_task(task_id: str, settings: dict[str, Any]) -> dict[str, Any] | None:
     """Run exactly one queued audio generation and persist only its audio artefact."""
     task = next((record for record in list_music_tasks() if str(record.get("id") or "") == str(task_id)), None)
@@ -268,6 +299,9 @@ def run_music_task(task_id: str, settings: dict[str, Any]) -> dict[str, Any] | N
     if provider == "lyria":
         result = request_lyria_generation(settings, str(task.get("prompt") or ""), str(task.get("title") or ""), str(task.get("model") or ""))
         audio_path = str((result.get("data") or {}).get("audio_path") or "")
+    elif provider == "eleven_music":
+        result = request_eleven_music_generation(settings, str(task.get("prompt") or ""), str(task.get("title") or ""), str(task.get("model") or "music_v2"), voice_id=str(task.get("voice_id") or ""), voice_gender=str(task.get("voice_gender") or ""))
+        audio_path = str((result.get("data") or {}).get("audio_path") or "")
     else:
         result = request_suno_generation(
             settings,

package/hermes_ui/pipeline_worker.py

@@ -25,6 +25,7 @@ from hermes_ui.media_providers import FULL_IA_VIDEO_PROVIDER_CODES, media_cards_
 from hermes_ui.material_sources import material_api_keys, material_source_cards, selected_material_source
 from hermes_ui.thumbnail_generation import ThumbnailGenerationError, generate_thumbnail_image
 from hermes_ui.thumbnail_blueprints import thumbnail_blueprint_for_channel
+from hermes_ui.voice_preview import synthesize_preview
 
 PIPELINE_LOCK_FILENAME = "pipeline_worker.lock"
 PIPELINE_LOG_FILENAME = "pipeline_worker.json"
@@ -763,6 +764,8 @@ def _uses_azure_speech_sdk_v2(
     settings: dict[str, Any] | None = None,
 ) -> bool:
     service = str(generation_settings.get("voiceover_service") or "").strip().casefold()
+    if service in {"elevenlabs", "eleven labs"}:
+        return False
     if service in {
         "azure speech sdk v2",
         "azure speech",
@@ -913,6 +916,23 @@ def _run_video_helper_once(
             sync_moneyprinter_config(settings, str(configured_root))
         except OSError as exc:
             raise PipelineError(f"Não foi possível sincronizar a configuração do MoneyPrinterTurbo: {exc}") from exc
+    generation_settings = task.get("generation_settings") if isinstance(task.get("generation_settings"), dict) else {}
+    voiceover_mode = str(generation_settings.get("voiceover_mode") or "").strip().casefold()
+    voiceover_service = str(generation_settings.get("voiceover_service") or "").strip().casefold()
+    generated_elevenlabs_audio: Path | None = None
+    if voiceover_mode not in {"none", "upload"} and voiceover_service == "elevenlabs":
+        elevenlabs_voice = str(task.get("voice") or generation_settings.get("voice") or "").strip()
+        script_text = str(task.get("video_script") or generation_settings.get("video_script") or "").strip()
+        if not elevenlabs_voice:
+            raise PipelineError("Seleccione uma voz personalizada ElevenLabs antes de criar o vídeo.")
+        if not str(settings.get("elevenlabs_api_key") or "").strip():
+            raise PipelineError("ElevenLabs foi seleccionado, mas a API Key não está configurada.")
+        if not script_text:
+            raise PipelineError("ElevenLabs foi seleccionado, mas o roteiro ainda não está disponível.")
+        try:
+            generated_elevenlabs_audio = synthesize_preview(script_text, "elevenlabs", elevenlabs_voice, settings)
+        except (OSError, RuntimeError, ValueError) as exc:
+            raise PipelineError(f"Não foi possível gerar a narração ElevenLabs: {exc}") from exc
     env_values = {
         "MPT_LLM_PROVIDER": provider,
         "MPT_LLM_API_KEY": str(card.get("api_key") or "").strip(),
@@ -932,7 +952,6 @@ def _run_video_helper_once(
     if configured_root:
         command.extend(["--root", str(configured_root)])
     command.extend(["--subject", subject, "--"])
-    generation_settings = task.get("generation_settings") if isinstance(task.get("generation_settings"), dict) else {}
     if _uses_azure_speech_sdk_v2(generation_settings, settings) and str(generation_settings.get("voiceover_mode") or "").strip().casefold() not in {"none", "upload"}:
         missing_voice_config = [
             field for field, value in (
@@ -951,7 +970,7 @@ def _run_video_helper_once(
             })
             raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
     command.extend(_moneyprinter_cli_args(task, route, settings=settings))
-    if str(generation_settings.get("voiceover_mode") or "").strip().casefold() == "upload":
+    if voiceover_mode == "upload":
         voiceover_file = Path(str(generation_settings.get("voiceover_file") or "").strip()).expanduser()
         if not str(voiceover_file) or not voiceover_file.is_file() or voiceover_file.stat().st_size <= 0:
             message = "O modo Upload foi seleccionado, mas não existe um ficheiro de narração válido. Carregue o áudio em Configurações de áudio."
@@ -959,6 +978,8 @@ def _run_video_helper_once(
             metadata.update({"failure_api": "Ficheiro local", "failure_provider": "local_storage", "failure_service": "Áudio de narração", "failure_config_fields": "voiceover_file"})
             raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
         command.extend(["--custom-audio-file", str(voiceover_file.resolve())])
+    elif generated_elevenlabs_audio is not None:
+        command.extend(["--custom-audio-file", str(generated_elevenlabs_audio.resolve())])
     output_lines: list[str] = []
     line_queue: queue.Queue[str | None] = queue.Queue()
     started_at = time.monotonic()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.4.76",
+  "version": "0.4.78",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",