Upload 7 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+HF_Pairs_ES_NI_RICH_v4.csv filter=lfs diff=lfs merge=lfs -text
+HF_Pairs_NI_ES_Translator_v4.csv filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,1676 @@
+# app.py — Traductor Español ↔ Neoíbero v4.4.1 FIXED
+# UI clásica (v2.3 LTS) + motor bidireccional v4.4, con Línea Ibérica y Locución
+# 2025-01 – Actualizado para CSVs v4.4 ULTRA-DEFINITIVO + FIXES CRÍTICOS
+# Cambios v4.4:
+#  - Compatible con HF_Pairs_ES_NI_RICH_v4.csv (783K pares)
+#  - Compatible con HF_Pairs_NI_ES_Translator_v4.csv (783K pares)
+#  - Usa campos nuevos: ni_surface, ni_tam, ni_pn
+#  - Números 1-100 invariables funcionando
+#  - Subjuntivos irregulares corregidos (vengas ✅)
+#  - RESPETA caracteres especiales (ŕ, ś) completamente
+# Cambios v4.4.1 FIXED:
+#  - FIX: Carga correcta de CSV NI→ES (índices y minúsculas corregidos)
+#  - FIX: Sistema de conjugación con persona/número completo (1S,2S,3S,1P,2P,3P)
+#  - FIX: Interrogativas y exclamativas (-na/-ba) mejoradas
+#  - FIX: Preservación de nombres propios en traducción NI→ES
+
+import gradio as gr
+import os, csv, re, base64, unicodedata
+import torch
+from transformers import AutoProcessor, VitsModel
+import numpy as np
+from html import escape  # ← para escapar la línea ibérica en HTML
+
+# Caches locales (si existen)
+os.environ['TRANSFORMERS_CACHE'] = os.environ.get('TRANSFORMERS_CACHE', '/tmp/cache')
+os.environ['HF_HOME'] = os.environ.get('HF_HOME', '/tmp/hf')
+
+DEBUG_MODE = False
+def debug_print(msg):
+    if DEBUG_MODE:
+        print(f"[DEBUG] {msg}")
+
+# =========================
+# LÉXICO Y ESTRUCTURAS v4.4
+# =========================
+# << RUTAS EN RAÍZ DEL REPO >>
+CSV_CANDIDATES = [
+    "HF_Pairs_ES_NI_RICH_v4.csv",      # ← NUEVO v4.4
+    "HF_Pairs_ES_NI_RICH.csv",
+    "HF_Pairs_ES_NI.csv",
+    "Diccionario_ES_Neoibero.csv",
+]
+CSV_NI_ES = [
+    "HF_Pairs_NI_ES_Translator_v4.csv", # ← NUEVO v4.4
+    "HF_Pairs_NI_ES_Translator.csv",
+]
+
+# ES→NI
+SURF_RICH = {}   # (es_lower, tag) -> ni_surface
+LEX_FORM  = {}   # es_form -> ni_lemma/surface
+LEX_LEMMA = {}   # es_lemma -> ni_lemma
+FOLD_FORM = {}   # es_form_no_diacritics -> ni_lemma
+LEX_META  = {}   # es_form/lemma -> {"pos":..., "tam_ok":...}
+FORCE_KEYS = set()
+
+# NI→ES
+NI_TO_ES_SURF = {}   # (ni_surface, ni_tam) -> es_surface
+NI_TO_ES_FORM = {}   # ni_form/root -> es_form
+NI_TO_ES_LEMMA= {}   # ni_root -> es_lemma
+
+# Mapeo de sufijos de persona en neoíbero → español
+NI_PERSON_MAP = {
+    "-mu": "1S",  # yo
+    "-su": "2S",  # tú
+    "-i":  "3S",  # él/ella
+    "-gu": "1P",  # nosotros
+    "-zu": "2P",  # vosotros
+    "-te": "3P",  # ellos/ellas
+}
+
+# =========================
+# MORFOLOGÍA – ESPAÑOL
+# =========================
+RE_GER   = re.compile(r"(ando|iendo|yendo)$", re.I)
+RE_PART  = re.compile(r"(ado|ido|to|so|cho)$", re.I)
+
+FUT_END   = ("é","ás","á","emos","éis","án")
+COND_END  = ("ía","ías","ía","íamos","íais","ían")
+PRET_AR   = ("é","aste","ó","amos","asteis","aron")
+PRET_ERIR = ("í","iste","ió","imos","isteis","ieron")
+IMPF_AR   = ("aba","abas","ábamos","abais","aban")
+IMPF_ERIR = ("ía","ías","íamos","íais","ían")
+SUBJ_AR   = ("e","es","e","emos","éis","en")
+SUBJ_ERIR = ("a","as","a","amos","áis","an")
+SUBJ_PAST_AR   = ("ara","aras","ara","áramos","arais","aran","ase","ases","ase","ásemos","aseis","asen")
+SUBJ_PAST_ERIR = ("iera","ieras","iera","iéramos","ierais","ieran","iese","ieses","iese","iésemos","ieseis","iesen")
+PRS_AR    = ("o","as","a","amos","áis","an")
+PRS_ER    = ("o","es","e","emos","éis","en")
+PRS_IR    = ("o","es","e","imos","ís","en")
+
+# ——— Parches FUT/COND sin tilde + tallos irregulares ———
+RE_COND_NT_REG = re.compile(r"(?:ar|er|ir)(?:ia|ias|iamos|iais|ian)$", re.I)  # hablaria, comerias...
+RE_COND_NT_IRR = re.compile(r"(tendr|vendr|pondr|saldr|valdr|podr|habr|sabr|cabr|querr|dir|har)(?:ia|ias|iamos|iais|ian)$", re.I)
+RE_FUT_NT_IRR  = re.compile(r"(tendr|vendr|pondr|saldr|valdr|podr|habr|sabr|cabr|querr|dir|har)(?:re|ras|ra|remos|reis|ran)$", re.I)
+
+def _strip_any(w, ends):
+    for s in sorted(ends, key=len, reverse=True):
+        if w.endswith(s):
+            return w[:-len(s)], s
+    return None, None
+
+def _guess_class_from_ending(ending):
+    if ending in PRET_AR or ending in IMPF_AR or ending in SUBJ_AR or ending in PRS_AR:
+        return "ar"
+    return "er"
+
+IRREG_LEMMA = {
+    "fui":"ir","fuiste":"ir","fue":"ir","fuimos":"ir","fuisteis":"ir","fueron":"ir",
+    "voy":"ir","vas":"ir","va":"ir","vamos":"ir","vais":"ir","van":"ir",
+    "soy":"ser","eres":"ser","es":"ser","somos":"ser","sois":"ser","son":"ser",
+    "era":"ser","eras":"ser","éramos":"ser","erais":"ser","eran":"ser",
+    "he":"haber","has":"haber","ha":"haber","hemos":"haber","habéis":"haber","han":"haber",
+    "hube":"haber","hubo":"haber","hubimos":"haber","hubiste":"haber","hubisteis":"haber","hubieron":"haber",
+    "estoy":"estar","estás":"estar","está":"estar","estamos":"estar","estáis":"estar","están":"estar",
+    "estuve":"estar","estuviste":"estar","estuvo":"estar","estuvimos":"estar","estuvisteis":"estar","estuvieron":"estar",
+    "estaba":"estar","estabas":"estar","estábamos":"estar","estabais":"estar","estaban":"estar",
+
+    "tuve":"tener","tuviste":"tener","tuvo":"tener","tuvimos":"tener","tuvisteis":"tener","tuvieron":"tener",
+    "vine":"venir","viniste":"venir","vino":"venir","vinimos":"venir","vinisteis":"venir","vinieron":"venir",
+    "hice":"hacer","hiciste":"hacer","hizo":"hacer","hicimos":"hacer","hicisteis":"hacer","hicieron":"hacer",
+    "puse":"poner","pusiste":"poner","puso":"poner","pusimos":"poner","pusisteis":"poner","pusieron":"poner",
+    "pude":"poder","pudiste":"poder","pudo":"poder","pudimos":"poder","pudisteis":"poder","pudieron":"poder",
+    "quise":"querer","quisiste":"querer","quiso":"querer","quisimos":"querer","quisisteis":"querer","quisieron":"querer",
+    "supe":"saber","supiste":"saber","supo":"saber","supimos":"saber","supisteis":"saber","supieron":"saber",
+    "traje":"traer","trajiste":"traer","trajo":"traer","trajimos":"traer","trajisteis":"traer","trajeron":"traer",
+    "dije":"decir","dijiste":"decir","dijo":"decir","dijimos":"decir","dijisteis":"decir","dijeron":"decir",
+    "conduje":"conducir","condujiste":"conducir","condujo":"conducir","condujimos":"conducir","condujisteis":"conducir","condujeron":"conducir",
+    "anduve":"andar","anduviste":"andar","anduvo":"andar","anduvimos":"andar","anduvisteis":"andar","anduvieron":"andar",
+    "cupe":"caber","cupiste":"caber","cupo":"caber","cupimos":"caber","cupisteis":"caber","cupieron":"caber",
+    "di":"dar","diste":"dar","dio":"dar","dimos":"dar","disteis":"dar","dieron":"dar",
+    "vi":"ver","viste":"ver","vio":"ver","vimos":"ver","visteis":"ver","vieron":"ver",
+
+    "tengo":"tener","vengo":"venir","pongo":"poner","salgo":"salir","traigo":"traer","caigo":"caer",
+    "hago":"hacer","oigo":"oír","digo":"decir","valgo":"valer","sigo":"seguir",
+
+    "tienes":"tener","tiene":"tener","tienen":"tener",
+    "vienes":"venir","viene":"venir","vienen":"venir",
+    "pienso":"pensar","piensas":"pensar","piensa":"pensar","piensan":"pensar",
+    "quiero":"querer","quieres":"querer","quiere":"querer","quieren":"querer",
+    "prefiero":"preferir","prefieres":"preferir","prefiere":"preferir","prefieren":"preferir",
+
+    "vaya":"ir","vayas":"ir","vayamos":"ir","vayáis":"ir","vayan":"ir",
+    "sea":"ser","seas":"ser","seamos":"ser","seáis":"ser","sean":"ser",
+    "haya":"haber","hayas":"haber","hayamos":"haber","hayáis":"haber","hayan":"haber",
+    "dé":"dar","des":"dar","demos":"dar","deis":"dar","den":"dar",
+    "esté":"estar","estés":"estar","estemos":"estar","estéis":"estar","estén":"estar",
+    "tenga":"tener","tengas":"tener","tengamos":"tener","tengáis":"tener","tengan":"tener",
+    "venga":"venir","vengas":"venir","vengamos":"venir","vengáis":"venir","vengan":"venir",  # ← FIX v4.4
+
+    "ve":"ir","id":"ir",
+    "sé":"ser","sed":"ser",
+    "haz":"hacer","haced":"hacer",
+    "pon":"poner","poned":"poner",
+    "ven":"venir","venid":"venir",
+    "ten":"tener","tened":"tener",
+    "sal":"salir","salid":"salir",
+    "di":"decir","decid":"decir",
+
+    "doy":"dar","das":"dar","da":"dar","damos":"dar","dais":"dar","dan":"dar",
+    "veo":"ver","ves":"ver","vemos":"ver","veis":"ver","ven":"ver",
+    "oí":"oír","oíste":"oír","oyó":"oír","oímos":"oír","oísteis":"oír","oyeron":"oír",
+    "iba":"ir","ibas":"ir","íbamos":"ir","ibais":"ir","iban":"ir",
+    "veía":"ver","veías":"ver","veíamos":"ver","veíais":"ver","veían":"ver",
+
+    "vinieras":"venir","lloviera":"llover",
+}
+# NUEVO: lemas para futuro de subjuntivo arcaico
+IRREG_LEMMA.update({
+    "viniere":"venir","vinieres":"venir","vinieren":"venir",
+    "hiciere":"hacer","hicieres":"hacer","hicieren":"hacer",
+    "tuviere":"tener","tuvieres":"tener","tuvieren":"tener",
+})
+
+IRREG_MORPH_TAGS = {
+    # Subjuntivos
+    "vaya":"SBJV","vayas":"SBJV","vayamos":"SBJV","vayáis":"SBJV","vayan":"SBJV",
+    "sea":"SBJV","seas":"SBJV","seamos":"SBJV","seáis":"SBJV","sean":"SBJV",
+    "haya":"SBJV","hayas":"SBJV","hayamos":"SBJV","hayáis":"SBJV","hayan":"SBJV",
+    "dé":"SBJV","des":"SBJV","demos":"SBJV","deis":"SBJV","den":"SBJV",
+    "esté":"SBJV","estés":"SBJV","estemos":"SBJV","estéis":"SBJV","estén":"SBJV",
+    "tenga":"SBJV","tengas":"SBJV","tengamos":"SBJV","tengáis":"SBJV","tengan":"SBJV",
+    "venga":"SBJV","vengas":"SBJV","vengamos":"SBJV","vayáis":"SBJV","vengan":"SBJV",
+    "haga":"SBJV","hagas":"SBJV","hagamos":"SBJV","hagáis":"SBJV","hagan":"SBJV",
+    "pueda":"SBJV","puedas":"SBJV","podamos":"SBJV","podáis":"SBJV","puedan":"SBJV",
+
+    # Imperativos
+    "id":"IMP","sed":"IMP",
+    "haz":"IMP","haced":"IMP","pon":"IMP","poned":"IMP","ven":"IMP","venid":"IMP",
+    "ten":"IMP","tened":"IMP","sal":"IMP","salid":"IMP","decid":"IMP",
+
+    # Imperativos con clíticos
+    "llámame":"IMP","llámalo":"IMP","llámala":"IMP","llámanos":"IMP","llámalos":"IMP","llámalas":"IMP",
+    "dime":"IMP","d��melo":"IMP","dinos":"IMP","dínoslo":"IMP",
+    "hazme":"IMP","hazlo":"IMP","hazla":"IMP","haznos":"IMP",
+    "ponme":"IMP","ponlo":"IMP","ponla":"IMP","ponnos":"IMP",
+    "dame":"IMP","dámelo":"IMP","danos":"IMP","dánoslo":"IMP",
+    "tráeme":"IMP","tráelo":"IMP","tráela":"IMP","tráenos":"IMP",
+    "díselo":"IMP","pónselo":"IMP","házselo":"IMP",
+
+    # Futuro de subjuntivo (arcaico)
+    "viniere":"FUT_SBJV","vinieres":"FUT_SBJV","vinieren":"FUT_SBJV",
+    "hiciere":"FUT_SBJV","hicieres":"FUT_SBJV","hicieren":"FUT_SBJV",
+    "fuere":"FUT_SBJV","fueres":"FUT_SBJV","fueren":"FUT_SBJV",
+    "hubiere":"FUT_SBJV","hubieres":"FUT_SBJV","hubieren":"FUT_SBJV",
+
+    # Pretéritos
+    "creísteis":"PST","dijisteis":"PST","hicisteis":"PST","pusisteis":"PST",
+    "supisteis":"PST","quisisteis":"PST","trajisteis":"PST",
+    "vi":"PST","dio":"PST","fue":"PST","fui":"PST",
+
+    # Imperfectos
+    "iba":"IPFV","ibas":"IPFV","íbamos":"IPFV","ibais":"IPFV","iban":"IPFV",
+    "veía":"IPFV","veías":"IPFV","veíamos":"IPFV","veíais":"IPFV","veían":"IPFV",
+}
+
+def looks_like_verb_form_strict(w: str) -> bool:
+    w = (w or "").lower()
+    if w.endswith(("ar","er","ir")): return True
+    if RE_GER.search(w) or RE_PART.search(w): return True
+    if re.search(r"(á|ás|áis|és|éis|ís)$", w): return True
+    if _strip_any(w, FUT_END+COND_END)[0] is not None: return True
+    if _strip_any(w, PRET_AR+PRET_ERIR)[0] is not None: return True
+    if _strip_any(w, IMPF_AR+IMPF_ERIR)[0] is not None: return True
+    if _strip_any(w, SUBJ_PAST_AR+SUBJ_PAST_ERIR)[0] is not None: return True
+    # Irregulares sin tilde (FUT/COND) + COND regular sin tilde
+    if RE_COND_NT_REG.search(w): return True
+    if RE_COND_NT_IRR.search(w): return True
+    if RE_FUT_NT_IRR.search(w):  return True
+    # Irregulares pretéritos y compañía
+    if re.search(r"(anduve|anduviste|anduvo|anduvimos|anduvieron|conduje|traduje|produje|reduje|introduje|supe|quise|pude|puse|hice|hizo|dije|dijo|traje|trajo|tuve|tuvo|vine|vino|cupe|cupo)$", w):
+        return True
+    return False
+
+def _zco_guess(w:str)->str:
+    if w.endswith("uzco"): return w[:-4] + "ucir"
+    if w.endswith("ezco"): return w[:-4] + "ecer"
+    if w.endswith("ozco"): return w[:-4] + "ocer"
+    if w.endswith("azco"): return w[:-4] + "acer"
+    return ""
+
+def guess_infinitive_es(w: str) -> str:
+    w = (w or "").lower()
+    if w in IRREG_LEMMA: return IRREG_LEMMA[w]
+    if w in ("vámonos","vamonos"): return "ir"
+    if w.endswith("zco"):
+        z = _zco_guess(w)
+        if z: return z
+    if w.endswith("go"):
+        base = w[:-2]
+        map_go = {"ten":"tener","ven":"venir","pon":"poner","sal":"salir","tra":"traer","ca":"caer","ha":"hacer","oi":"oír","di":"decir","val":"valer","si":"seguir"}
+        for k,v in map_go.items():
+            if base.startswith(k): return v
+    if w.endswith(("ar","er","ir")): return w
+    m = RE_GER.search(w)
+    if m:
+        base = w[:m.start()]
+        return base + ("ar" if m.group(0)=="ando" else "er")
+    m = RE_PART.search(w)
+    if m:
+        base = w[:m.start()]
+        part_irreg = {
+            "hecho":"hacer","dicho":"decir","visto":"ver","puesto":"poner","escrito":"escribir",
+            "abierto":"abrir","cubierto":"cubrir","muerto":"morir","roto":"romper",
+            "vuelto":"volver","resuelto":"resolver","frito":"freír","impreso":"imprimir",
+            "satisfecho":"satisfacer","provisto":"proveer"
+        }
+        if w in part_irreg: return part_irreg[w]
+        return base + "er"
+    # FUT/COND con tilde
+    base, end = _strip_any(w, FUT_END+COND_END)
+    if base is not None:
+        irreg = {"saldr":"salir","vendr":"venir","tendr":"tener","pondr":"poner","valdr":"valer","podr":"poder",
+                 "habr":"haber","sabr":"saber","cabr":"caber","querr":"querer","dir":"decir","har":"hacer"}
+        if base in irreg: return irreg[base]
+        return base
+    # COND sin tilde (regular e irregular)
+    m = RE_COND_NT_IRR.search(w)
+    if m:
+        irreg = {"saldr":"salir","vendr":"venir","tendr":"tener","pondr":"poner","valdr":"valer","podr":"poder",
+                 "habr":"haber","sabr":"saber","cabr":"caber","querr":"querer","dir":"decir","har":"hacer"}
+        stem = m.group(1)
+        return irreg.get(stem, "")
+    m = RE_COND_NT_REG.search(w)
+    if m:
+        suf = m.group(0).replace("ar","",1).replace("er","",1).replace("ir","",1)  # "ia" / "ias" / ...
+        return w[:-len(suf)]  # quita "ia/ias/..." → deja el infinitivo
+    # FUT sin tilde (solo irregulares para evitar ambigüedades)
+    m = RE_FUT_NT_IRR.search(w)
+    if m:
+        irreg = {"saldr":"salir","vendr":"venir","tendr":"tener","pondr":"poner","valdr":"valer","podr":"poder",
+                 "habr":"haber","sabr":"saber","cabr":"caber","querr":"querer","dir":"decir","har":"hacer"}
+        stem = m.group(1)
+        return irreg.get(stem, "")
+    # Otras heurísticas
+    if w.endswith("áis"): return w[:-3] + "ar"
+    if w.endswith("éis"): return w[:-3] + "er"
+    if w.endswith("ís"):  return w[:-2] + "ir"
+    if w.endswith("ás"):  return w[:-2] + "ar"
+    if w.endswith("és"):  return w[:-2] + "er"
+    if w.endswith("á"):   return w[:-1] + "ar"
+    for group in (PRET_AR+PRET_ERIR, IMPF_AR+IMPF_ERIR, SUBJ_AR+SUBJ_ERIR, PRS_AR+PRS_ER+PRS_IR):
+        base, end = _strip_any(w, group)
+        if base is not None:
+            return base + _guess_class_from_ending(end)
+    base, end = _strip_any(w, SUBJ_PAST_AR)
+    if base is not None: return base + "ar"
+    base, end = _strip_any(w, SUBJ_PAST_ERIR)
+    if base is not None: return base + "er"
+    return ""
+
+def es_morph_tag(w: str) -> str:
+    w = (w or "").lower()
+    if w in IRREG_MORPH_TAGS: return IRREG_MORPH_TAGS[w]
+
+    # Imperativos con clíticos / perífrasis
+    if re.search(r"^(llám|dím|házm|pónm|vén|dám|tén|tráe)(a|e)?(me|te|lo|la|nos|os|les|se|melo|telo|selo)$", w): return "IMP"
+    if re.search(r"(adme|edme|idme|adlo|edle|idle|adnos|ednos)$", w): return "IMP"
+    if re.search(r"(?:ad|ed|id|ád|éd|íd)(?:me|te|se|lo|la|nos|os|les|melo|telo|selo|noslo|oslo|sela|selas|selos)$", w): return "IMP"
+    if re.search(r"^.*[áéí]ndo(me|te|se|lo|la|nos|os|les|melo|telo|selo)$", w): return "IPFV"
+    if re.search(r"(melo|telo|selo|noslo|oslo|sela|selas|selos)$", w):
+        base = re.sub(r"(melo|telo|selo|noslo|oslo|sela|selas|selos)$", "", w)
+        if base and len(base) > 2: return "IMP"
+
+    # FUT/COND sin tilde (prioridad antes de otras reglas)
+    if RE_FUT_NT_IRR.search(w):  return "FUT"
+    if RE_COND_NT_IRR.search(w): return "COND"
+    if RE_COND_NT_REG.search(w): return "COND"
+
+    if w.endswith(("ar","er","ir")): return "INF"
+    if RE_GER.search(w):  return "IPFV"
+    if RE_PART.search(w): return "PST"
+    if _strip_any(w, PRET_AR+PRET_ERIR)[0] is not None:  return "PST"
+    if _strip_any(w, IMPF_AR+IMPF_ERIR)[0] is not None:  return "IPFV"
+    if _strip_any(w, FUT_END)[0]  is not None:           return "FUT"
+    if _strip_any(w, COND_END)[0] is not None:           return "COND"
+    if re.search(r"(á|ás|áis|és|éis|ís)$", w):           return "PRS"
+    if _strip_any(w, SUBJ_AR+SUBJ_ERIR)[0] is not None:  return "SBJV"
+    if _strip_any(w, PRS_AR+PRS_ER+PRS_IR)[0] is not None:  return "PRS"
+    if _strip_any(w, SUBJ_PAST_AR+SUBJ_PAST_ERIR)[0] is not None: return "SBJV"
+    if re.search(r"(anduve|conduje|traduje|produje|reduje|introduje|supe|quise|pude|puse|hice|hizo|dije|dijo|traje|trajo|tuve|tuvo|vine|vino|cupe|cupo)$", w):
+        return "PST"
+    if re.search(r"^.+[aei]d$", w): return "IMP"
+    return "UNK"
+
+# =========================
+# MORFOLOGÍA – NEOÍBERO
+# =========================
+NI_TAM_SUFFIXES = {
+    "-ke": "PRS","-ei": "PST","-ta": "IPFV","-na": "FUT",
+    "-ne": "COND","-ni": "SBJV","-tu": "IMP","-ra":"FUT_SBJV"
+}
+def detect_ni_tam(word: str):
+    # Parche: tolerar colas pronominales tras TAM (p. ej., -i, -mu)
+    word = (word or "").lower().strip()
+    for pn in ("-i", "-mu", "-su", "-gu", "-zu", "-te"):
+        if word.endswith(pn):
+            cand = word[:-len(pn)]
+            # solo aceptamos cortar PN si entonces aparece un TAM conocido
+            if any(cand.endswith(suf) for suf in NI_TAM_SUFFIXES.keys()):
+                word = cand
+                break
+    for suf, tag in NI_TAM_SUFFIXES.items():
+        if word.endswith(suf):
+            return word[:-len(suf)], tag, suf
+    return word, "INF", ""
+
+# =========================
+# UTILIDADES
+# =========================
+def fold(s:str)->str:
+    return ''.join(c for c in unicodedata.normalize('NFD', s) if unicodedata.category(c)!="Mn")
+def has_diacritic(s:str)->bool:
+    return bool(re.search(r"[áéíóúüÁÉÍÓÚÜ]", s or ""))
+
+def _canon_pos(p: str) -> str:
+    p = (p or "").strip().upper()
+    MAP = {"V":"V","VERB":"V","N":"N","NOUN":"N","ADJ":"ADJ","ADJECTIVE":"ADJ","ADV":"ADV","ADVERB":"ADV",
+           "INTJ":"INTJ","INTERJ":"INTJ","INTERJECTION":"INTJ","PRON":"PRON","PRONOUN":"PRON",
+           "PART":"PART","PARTICLE":"PART","POSTP":"POSTP","ADP":"POSTP","ADPOSITION":"POSTP",
+           "NUM":"NUM","DET":"DET"}
+    return MAP.get(p, "")
+def _boolish(x):
+    if x is None: return None
+    s = str(x).strip().lower()
+    if s in ("1","true","t","yes","y","si","sí"): return True
+    if s in ("0","false","f","no","n"): return False
+    return None
+def _meta_set(form_es:str, pos:str=None, tam_ok=None):
+    if not form_es: return
+    d = LEX_META.setdefault(form_es, {})
+    if pos and not d.get("pos"): d["pos"] = pos
+    if tam_ok is not None and d.get("tam_ok") is None: d["tam_ok"] = bool(tam_ok)
+def pos_of_es(token_low:str) -> str:
+    m = LEX_META.get(token_low, {})
+    if m.get("pos"): return m["pos"]
+    return "V" if looks_like_verb_form_strict(token_low) else ""
+def tam_allowed_for_es(token_low:str) -> bool:
+    m = LEX_META.get(token_low, {})
+    if m.get("tam_ok") is not None: return bool(m["tam_ok"])
+    return pos_of_es(token_low) == "V"
+
+# =========================
+# TTS (Meta MMS)
+# =========================
+print("Cargando modelo de voz...")
+device = "cuda" if torch.cuda.is_available() else "cpu"
+processor = model = None
+try:
+    processor = AutoProcessor.from_pretrained("facebook/mms-tts-spa")
+    model = VitsModel.from_pretrained("facebook/mms-tts-spa").to(device)
+    print("Modelo de voz cargado.")
+except Exception as e:
+    print(f"ERROR TTS: {e}")
+
+PAUSE_LEVEL=3
+def add_reading_pauses(text: str, level:int=3) -> str:
+    if level <= 1: return text
+    t = text
+    if level >= 2: t = re.sub(r",\s*", ", , ", t)
+    if level >= 3:
+        t = re.sub(r"\.\s*", ". . ", t); t = re.sub(r";\s*", "; ; ", t)
+    return re.sub(r"\s+"," ",t).strip()
+
+def hispanize_for_tts(ni_text: str) -> str:
+    text=(ni_text or "").lower()
+    # CRÍTICO: Respetar caracteres iberos
+    text=text.replace('ŕ','rr').replace('ś','s').replace('eś','es')
+    text=text.replace('ŕa','rra').replace('aŕe','arre').replace('-', ' ')
+    text=re.sub(r'\[.*?\]','',text)
+    text=re.sub(r'\s+',' ',text).strip()
+    return add_reading_pauses(text, PAUSE_LEVEL)
+
+def synthesize_speech(text):
+    if not text or not text.strip() or model is None or processor is None: return None
+    try:
+        inputs = processor(text=hispanize_for_tts(text), return_tensors="pt").to(device)
+        with torch.no_grad(): output = model(**inputs).waveform
+        speech_np = output.cpu().numpy().squeeze()
+        mx = max(abs(speech_np.min()), abs(speech_np.max()))
+        if mx>0: speech_np = speech_np/mx*0.9
+        return (16000, speech_np.astype(np.float32))
+    except Exception as e:
+        print(f"Error TTS: {e}"); return None
+
+# =========================
+# LÍNEA IBÉRICA (claves Georgeos)
+# =========================
+KEYS_MODE = "explicit"
+V = "aeiou"
+SYL_FOR={"b":["‹BA›","‹BE›","‹BI›","‹BO›","‹BU›"],
+         "d":["‹DA›","‹DE›","‹DI›","‹DO›","‹DU›"],
+         "t":["‹TA›","‹TE›","‹TI›","‹TO›","‹TU›"],
+         "g":["‹GA›","‹GE›","‹GI›","‹GO›","‹GU›"],
+         "k":["‹KA›","‹KE›","‹KI›","‹KO›","‹KU›"]}
+ALPHA_FOR={"a":"‹A›","e":"‹E›","i":"‹I›","o":"‹O›","u":"‹U›","s":"‹S›","ś":"‹Ś›","l":"‹L›","r":"‹R›","ŕ":"‹Ŕ›","n":"‹N›","m":"‹M›"}
+CODA_FOR={"":"","n":"‹N›","s":"‹S›","ś":"‹Ś›","r":"‹R›","ŕ":"‹Ŕ›","l":"‹L›","m":"‹M›","k":"‹K›","t":"‹T›"}
+
+def tokens_from_latin(ni:str)->str:
+    out=[]; i=0; ni=(ni or "").lower()
+    while i<len(ni):
+        c=ni[i]
+        if c=="p": c="b"               # no /p/ independiente
+        if c=="-": out.append("—"); i+=1; continue
+        if c in V:
+            out.append(ALPHA_FOR[c]); i+=1; continue
+        if c in SYL_FOR and i+1<len(ni) and ni[i+1] in V:
+            idx=V.index(ni[i+1]); tok=SYL_FOR[c][idx]
+            coda=ni[i+2] if i+2<len(ni) else ""
+            if coda in CODA_FOR and coda!="":
+                tok+=CODA_FOR[coda]; i+=3
+            else:
+                i+=2
+            out.append(tok); continue
+        out.append(ALPHA_FOR.get(c, c.upper())); i+=1
+    return "".join(out)
+
+KEYS_OVERRIDE={"ka":"K","mi":"MI","te":"TE","ne":"N","o":"O","eś":"X"}
+def georgeos_keys(token_str:str, ni_plain:str)->str:
+    low=(ni_plain or "").lower()
+    if low in KEYS_OVERRIDE: return KEYS_OVERRIDE[low]
+    m=re.findall(r"‹(.*?)›", token_str)
+    out=[]
+    for t in m:
+        if KEYS_MODE == "compact":
+            if len(t)==2 and t[0] in "BDTGK": out.append(t[0])
+            elif t in ("A","E","I","O","U"): out.append(t)
+            elif t=="Ś": out.append("X")
+            elif t=="Ŕ": out.append("r")
+            else: out.append(t[0].upper())
+        else:
+            if len(t)==2 and t[0] in "BDTGK": out.append(t)
+            elif t=="Ś": out.append("X")
+            elif t=="Ŕ": out.append("r")
+            else: out.append(t.upper())
+    return "".join(out)
+
+TRIDOT = "/"
+VISIBLE_PUNCT = {",",".",";","; ",":","…","(",")","[","]","{","}","\"","'","«","»","—","–",""",""","'","'"}
+HARD_BOUND    = {".",";","—","–",":","(",")","«","»"}
+
+def render_ib_with_tridots(toks):
+    res=[]; prev_word=False
+    for tk in toks:
+        is_punct = tk in VISIBLE_PUNCT
+        if is_punct:
+            res.append(" "+tk+" "); prev_word=False
+        else:
+            if prev_word: res.append(" "+TRIDOT+" ")
+            res.append(tk); prev_word=True
+    return "".join(res).strip()
+
+# =========================
+# TRADUCTOR ES→NI
+# =========================
+TAM_SUFFIX={"PRS":"-ke","PST":"-ei","FUT":"-na","IPFV":"-ta",
+            "COND":"-ne","SBJV":"-ni","IMP":"-tu","INF":"","FUT_SBJV":"-ra","UNK":"-ke"}
+VERB_TAM = ("-ke","-na","-ei","-ta","-ni","-ne","-tu","-ra")
+
+def strip_ni_tam(lemma: str):
+    lemma = lemma or ""
+    for s in sorted(VERB_TAM, key=len, reverse=True):
+        if lemma.endswith(s): return lemma[:-len(s)], s
+    return lemma, ""
+
+STOP=set("""
+el la los las lo un una unos unas al del de en con sin por sobre entre hasta desde hacia según tras
+pero aunque sino que como si porque cuando donde mientras
+muy ya sí no también solo sólo aún aun más menos
+mi mis tu tus su sus nuestro nuestra nuestros nuestras
+esto eso aquello ese esa esos esas aquel aquella aquellos aquellas
+quien quién quiénes cual cuál cuales cuáles cuyo cuya cuyos cuyas
+eh ay oh uy ah aja jeje jaja aah ahh ohh uhh
+""".split())
+
+# --- Reglas "a" → ka/mi/te
+def rule_a(prev_tok:str, token:str, next_tok:str)->str:
+    verbs={"dar","decir","contar","enviar","ofrecer","mostrar","prestar","regalar","entregar"}
+    if prev_tok in verbs: return "mi"
+    nombres={"ana","marta","juan","pedro","luis","maría","jose","carlos","laura"}
+    if next_tok in nombres: return "te"
+    return "ka"
+
+Q_ENCLITIC_INT = "-na"
+Q_ENCLITIC_EXC = "-ba"
+WH_WORDS = {
+    "qué","quien","quién","quienes","quiénes","cual","cuál","cuales","cuáles",
+    "donde","dónde","cuando","cuándo","como","cómo",
+    "cuanto","cuánto","cuanta","cuánta","cuantos","cuántos","cuantas","cuántas"
+}
+def is_wh_token(t: str) -> bool:
+    low = (t or "").lower()
+    if low in WH_WORDS: return True
+    f = fold(low)
+    return f in {"que","quien","quienes","cual","cuales","donde","cuando","como","cuanto","cuanta","cuantos","cuantas"}
+
+def has_wh_outside_parens(toks) -> bool:
+    depth = 0
+    for tk in toks:
+        if tk in {"(", "«", """, "'"}: depth += 1
+        elif tk in {")", "»", """, "'"}: depth = max(0, depth-1)
+        elif depth == 0 and is_wh_token(tk): return True
+    return False
+
+ESTAR_SET={"estoy","estás","está","estamos","estáis","están","estaba","estabas","estábamos","estabais","estaban"}
+HABER_SET={"he","has","ha","hemos","habéis","han","había","habías","habíamos","habíais","habían"}
+
+def detect_tam_with_context(toks, i, sentence_start=False):
+    t=toks[i].lower()
+    prev=toks[i-1].lower() if i>0 else ""
+    prev2=toks[i-2].lower() if i>1 else ""
+    nxt=toks[i+1].lower() if i+1<len(toks) else ""
+    tag=es_morph_tag(t)
+
+    # imperativos con clíticos al principio
+    if re.search(r"(melo|telo|selo|noslo|oslo)$", t):
+        if sentence_start or prev in {",", ".", "!", "¡", ";", ":"}: return "IMP"
+    if i == 0 or prev in {",", ".", "!", "¡", ";", ":"}:
+        if t in {"ve","ven","haz","pon","sal","di","ten","sé","id","venid","tened"}: return "IMP"
+
+    if prev in {"que","si","cuando","aunque","mientras","hasta","para"}:
+        if tag=="SBJV": return "SBJV"
+        if tag=="UNK" and re.search(r"(e|a)$", t) and not t.endswith(("ar","er","ir")): return "SBJV"
+
+    if t in ESTAR_SET or t in HABER_SET: return "PRS"
+    if prev in ESTAR_SET and RE_GER.search(nxt): return "IPFV"
+    if prev in HABER_SET and RE_PART.search(nxt): return "PST"
+    if prev == "a" and prev2 in {"voy","vas","va","vamos","vais","van"} and t.endswith(("ar","er","ir")): return "FUT"
+    if RE_GER.search(t):  return "IPFV"
+    if RE_PART.search(t): return "PST"
+    return tag if tag!="UNK" else "PRS"
+
+def forced_lemma_with_context(low:str, prev:str, nxt:str)->str:
+    if low=="visto" and nxt=="de": return "vestir"
+    return ""
+
+def has_tilde_equiv_lookup(low:str)->str:
+    if has_diacritic(low) and not looks_like_verb_form_strict(low):
+        f=fold(low)
+        if f in LEX_FORM: return LEX_FORM[f]
+        if f in FOLD_FORM: return FOLD_FORM[f]
+    return ""
+
+def lookup_form_lemma(token:str, prev:str, nxt:str):
+    if not token: return "", False
+    low=token.lower()
+    fl=forced_lemma_with_context(low, prev, nxt)
+    if fl and fl in LEX_LEMMA: return LEX_LEMMA[fl], True
+    if low in LEX_FORM: return LEX_FORM[low], True
+    til=has_tilde_equiv_lookup(low)
+    if til: return til, True
+    if looks_like_verb_form_strict(low):
+        lem=guess_infinitive_es(low)
+        if lem and lem in LEX_LEMMA: return LEX_LEMMA[lem], True
+    return "", False
+
+def attach_enclitic(out_words, ib_keys, plain, attach_idx, encl):
+    if attach_idx is None or attach_idx < 0 or attach_idx >= len(out_words): return
+    cur = out_words[attach_idx] or ""
+    if cur.endswith(encl): return
+    out_words[attach_idx] = cur + encl
+    plain[attach_idx]     = (plain[attach_idx] or "") + encl
+    ib_keys[attach_idx]   = georgeos_keys(tokens_from_latin(plain[attach_idx]), plain[attach_idx])
+
+def ensure_terminal_qmark(out_words, ib_keys, plain):
+    if not out_words:
+        out_words.append("?"); ib_keys.append(""); plain.append("?"); return
+    j = len(out_words) - 1
+    while j >= 0 and (out_words[j] == "" or out_words[j] is None): j -= 1
+    if j < 0:
+        out_words.append("?"); ib_keys.append(""); plain.append("?"); return
+    if out_words[j] == ".":
+        out_words[j] = "?"; ib_keys[j] = ""; plain[j] = "?"
+    elif out_words[j] not in {"?","!"}:
+        out_words.append("?"); ib_keys.append(""); plain.append("?")
+
+def normalize_surface_by_pos(ni_surface:str, pos:str) -> str:
+    if not ni_surface: return ni_surface
+    if pos != "V":
+        root, _ = strip_ni_tam(ni_surface)
+        return root
+    return ni_surface
+
+def translate_sentence(sent:str):
+    toks = re.sub(r"\s+"," ", (sent or "").strip())
+    # Separamos también comillas curvas
+    toks = re.sub(r"([,.;:!?¡¿…()\[\]{}\"'«»—–""''])", r" \1 ", toks)
+    toks = [t for t in toks.split() if t]
+
+    out_words=[]; ib_keys=[]; plain=[]
+    neg_next=False; last_finite_idx=None; has_qmark=False
+    saw_wh = has_wh_outside_parens(toks)
+    sentence_start=True
+
+    for i,t in enumerate(toks):
+        if t in {"¿","¡"}:
+            sentence_start=True; continue
+        if t in {"?","!"}:
+            if t=="?": has_qmark=True
+            encl = Q_ENCLITIC_INT if t=="?" else Q_ENCLITIC_EXC
+            attach_idx = last_finite_idx
+            if attach_idx is None:
+                for j in range(len(out_words)-1, -1, -1):
+                    if out_words[j] and out_words[j] not in VISIBLE_PUNCT:
+                        attach_idx = j; break
+            if attach_idx is not None: attach_enclitic(out_words, ib_keys, plain, attach_idx, encl)
+            out_words.append(t); ib_keys.append(""); plain.append(t)
+            sentence_start=True; continue
+
+        if t in VISIBLE_PUNCT:
+            out_words.append(t); ib_keys.append(t); plain.append(t)
+            if t in HARD_BOUND:
+                last_finite_idx=None
+                sentence_start = (t in {".",":",";","—","–"})
+            continue
+
+        low=t.lower()
+        prev = toks[i-1].lower() if i>0 else ""
+        nxt  = toks[i+1].lower() if i+1<len(toks) else ""
+
+        if (sentence_start and t in {"ve","ven","haz","pon","sal","di","ten","sé","id","venid","tened"}) or \
+           (re.search(r"(me|te|lo|la|nos|os|les|se)$", low) and looks_like_verb_form_strict(low)):
+            tag_detected="IMP"
+        else:
+            tag_detected = detect_tam_with_context(toks, i, sentence_start)
+
+        pos_hint = pos_of_es(low)
+        is_verb_like = looks_like_verb_form_strict(low) or (pos_hint=="V")
+        tam_ok = tam_allowed_for_es(low)
+
+        if low=="no": neg_next=True; continue
+
+        # Contracciones: al/del → (a/de + el)
+        if low == "al":
+            for ni in ("ka","do"):
+                out_words.append(ni); ib_keys.append(georgeos_keys(tokens_from_latin(ni),ni)); plain.append(ni)
+            sentence_start=False; continue
+        if low == "del":
+            for ni in ("ta","do"):
+                out_words.append(ni); ib_keys.append(georgeos_keys(tokens_from_latin(ni),ni)); plain.append(ni)
+            sentence_start=False; continue
+
+        if low=="a":
+            ni=rule_a(prev,low,nxt)
+            out_words.append(ni); ib_keys.append(georgeos_keys(tokens_from_latin(ni),ni)); plain.append(ni)
+            continue
+        if low == "un":
+            ni="banu"; out_words.append(ni); ib_keys.append(georgeos_keys(tokens_from_latin(ni),ni)); plain.append(ni); continue
+        if low == "una":
+            ni="bana"; out_words.append(ni); ib_keys.append(georgeos_keys(tokens_from_latin(ni),ni)); plain.append(ni); continue
+        if low == "uno":
+            ni="ban";  out_words.append(ni); ib_keys.append(georgeos_keys(tokens_from_latin(ni),ni)); plain.append(ni); continue
+
+        if (low in STOP) and (low not in LEX_FORM):
+            continue
+
+        ni_direct = SURF_RICH.get((low, tag_detected))
+        if neg_next and is_verb_like:
+            out_words.append("eś"); ib_keys.append(georgeos_keys(tokens_from_latin("eś"),"eś")); plain.append("eś")
+            neg_next=False
+        if ni_direct:
+            if any(ni_direct.endswith(s) for s in VERB_TAM):
+                ni=ni_direct
+            else:
+                ni=normalize_surface_by_pos(ni_direct, "V" if tam_ok else (pos_hint or ""))
+            out_words.append(ni); ib_keys.append(georgeos_keys(tokens_from_latin(ni),ni)); plain.append(ni)
+            if tam_ok and any(ni.endswith(s) for s in VERB_TAM): last_finite_idx=len(out_words)-1
+            sentence_start=False; continue
+
+        ni_lemma, ok = lookup_form_lemma(t, prev, nxt)
+        if ok:
+            if low in FORCE_KEYS:
+                ni = LEX_FORM.get(low, ni_lemma)
+                out_words.append(ni); ib_keys.append(georgeos_keys(tokens_from_latin(ni),ni)); plain.append(ni)
+                last_finite_idx=len(out_words)-1; sentence_start=False; continue
+            root, old_suf = strip_ni_tam(ni_lemma or "")
+            if tag_detected=="IMP":
+                ni=root+"-tu"
+                out_words.append(ni); ib_keys.append(georgeos_keys(tokens_from_latin(ni),ni)); plain.append(ni)
+                last_finite_idx=len(out_words)-1; sentence_start=False; continue
+            if old_suf=="-tu":
+                ni=ni_lemma
+                out_words.append(ni); ib_keys.append(georgeos_keys(tokens_from_latin(ni),ni)); plain.append(ni)
+                last_finite_idx=len(out_words)-1; sentence_start=False; continue
+            if tam_ok and is_verb_like:
+                suf=TAM_SUFFIX.get(tag_detected,"-ke")
+                base=root or (ni_lemma or "")
+                ni= base+suf if suf else base
+                out_words.append(ni); ib_keys.append(georgeos_keys(tokens_from_latin(ni),ni)); plain.append(ni)
+                last_finite_idx=len(out_words)-1
+            else:
+                ni=normalize_surface_by_pos(ni_lemma if ni_lemma!="" else "Ø", pos_hint or "")
+                out_words.append(ni); ib_keys.append(georgeos_keys(tokens_from_latin(ni),ni)); plain.append(ni)
+            sentence_start=False; continue
+
+        placeholder=f"[SIN-LEX:{t}]"
+        out_words.append(placeholder); ib_keys.append(placeholder); plain.append(placeholder)
+        sentence_start=False
+
+    appended_na=False
+    if saw_wh and not has_qmark:
+        encl=Q_ENCLITIC_INT
+        attach_idx=last_finite_idx
+        if attach_idx is None:
+            for j in range(len(out_words)-1,-1,-1):
+                if out_words[j] and out_words[j] not in VISIBLE_PUNCT and out_words[j] not in {"?","!"} and not out_words[j].startswith("["):
+                    attach_idx=j; break
+        if attach_idx is not None and not (out_words[attach_idx].endswith("-na") or out_words[attach_idx].endswith("-ba")):
+            attach_enclitic(out_words, ib_keys, plain, attach_idx, encl); appended_na=True
+    if appended_na and not has_qmark: ensure_terminal_qmark(out_words, ib_keys, plain)
+
+    ib_clean=[k for k in ib_keys if k!=""]
+    return " ".join(out_words), ib_clean
+
+def translate(text:str):
+    lines=[l for l in (text or "").split("\n") if l.strip()]
+    ni_lines=[]; ib_lines=[]
+    for ln in lines:
+        ni,ib_toks=translate_sentence(ln)
+        ni_lines.append(ni); ib_lines.append(render_ib_with_tridots(ib_toks))
+    return "\n".join(ni_lines), "\n".join(ib_lines)
+
+# =========================
+# TRADUCTOR NI→ES (mejorado)
+# =========================
+# Sufijos nominales más comunes (no-TAM) para fallback suave
+NI_NOMINAL_SUFFIXES = ("-ar","-en","-ka","-la","-si","-ŕa")
+
+def normalize_ni(text: str) -> str:
+    # Normaliza espacios, permite "tridots" (/) y desencapsula [SIN-LEX:…]
+    t = (text or "").replace("/", " ")
+    t = re.sub(r"\[SIN-LEX:([^\]]+)\]", r"\1", t)
+    return re.sub(r"\s+", " ", t.strip())
+
+def tokenize_ni(text: str):
+    # Separar también comillas curvas
+    text = re.sub(r"([,.;:!?¡¿…()\[\]{}\"'«»—–""''])", r" \1 ", text)
+    return [t for t in text.split() if t]
+
+# --- NUEVO: solo conjugar si el lema ES termina en -ar/-er/-ir
+def _is_spanish_verb_lemma(lemma: str) -> bool:
+    return isinstance(lemma, str) and re.search(r"(ar|er|ir)$", lemma)
+
+def _detect_ni_person(ni_form: str):
+    """Detecta persona/número del sufijo neoíbero y devuelve (person, root_limpia)"""
+    for suf, pn in NI_PERSON_MAP.items():
+        if ni_form.endswith(suf):
+            return pn, ni_form[:-len(suf)]
+    return "3S", ni_form  # default
+
+def _conj_es_from_lemma(lemma: str, tag: str, person: str = "3S"):
+    """Conjuga un verbo español según TAM y persona/número"""
+    if not _is_spanish_verb_lemma(lemma):
+        return lemma
+    
+    lemma = lemma.lower()
+    
+    # Verbos irregulares completos (clave: lemma, tag, person)
+    IRREG_FULL = {
+        # SER
+        ("ser", "PRS", "1S"): "soy", ("ser", "PRS", "2S"): "eres", ("ser", "PRS", "3S"): "es",
+        ("ser", "PRS", "1P"): "somos", ("ser", "PRS", "2P"): "sois", ("ser", "PRS", "3P"): "son",
+        ("ser", "PST", "1S"): "fui", ("ser", "PST", "2S"): "fuiste", ("ser", "PST", "3S"): "fue",
+        ("ser", "PST", "1P"): "fuimos", ("ser", "PST", "2P"): "fuisteis", ("ser", "PST", "3P"): "fueron",
+        ("ser", "IPFV", "1S"): "era", ("ser", "IPFV", "2S"): "eras", ("ser", "IPFV", "3S"): "era",
+        ("ser", "IPFV", "1P"): "éramos", ("ser", "IPFV", "2P"): "erais", ("ser", "IPFV", "3P"): "eran",
+        ("ser", "SBJV", "1S"): "sea", ("ser", "SBJV", "2S"): "seas", ("ser", "SBJV", "3S"): "sea",
+        ("ser", "SBJV", "1P"): "seamos", ("ser", "SBJV", "2P"): "seáis", ("ser", "SBJV", "3P"): "sean",
+        # IR
+        ("ir", "PRS", "1S"): "voy", ("ir", "PRS", "2S"): "vas", ("ir", "PRS", "3S"): "va",
+        ("ir", "PRS", "1P"): "vamos", ("ir", "PRS", "2P"): "vais", ("ir", "PRS", "3P"): "van",
+        ("ir", "PST", "1S"): "fui", ("ir", "PST", "2S"): "fuiste", ("ir", "PST", "3S"): "fue",
+        ("ir", "PST", "1P"): "fuimos", ("ir", "PST", "2P"): "fuisteis", ("ir", "PST", "3P"): "fueron",
+        ("ir", "IPFV", "1S"): "iba", ("ir", "IPFV", "2S"): "ibas", ("ir", "IPFV", "3S"): "iba",
+        ("ir", "IPFV", "1P"): "íbamos", ("ir", "IPFV", "2P"): "ibais", ("ir", "IPFV", "3P"): "iban",
+        ("ir", "SBJV", "1S"): "vaya", ("ir", "SBJV", "2S"): "vayas", ("ir", "SBJV", "3S"): "vaya",
+        ("ir", "SBJV", "1P"): "vayamos", ("ir", "SBJV", "2P"): "vayáis", ("ir", "SBJV", "3P"): "vayan",
+        # ESTAR
+        ("estar", "PRS", "1S"): "estoy", ("estar", "PRS", "2S"): "estás", ("estar", "PRS", "3S"): "está",
+        ("estar", "PRS", "1P"): "estamos", ("estar", "PRS", "2P"): "estáis", ("estar", "PRS", "3P"): "están",
+        ("estar", "SBJV", "1S"): "esté", ("estar", "SBJV", "2S"): "estés", ("estar", "SBJV", "3S"): "esté",
+        ("estar", "SBJV", "1P"): "estemos", ("estar", "SBJV", "2P"): "estéis", ("estar", "SBJV", "3P"): "estén",
+        # TENER
+        ("tener", "PRS", "1S"): "tengo", ("tener", "PRS", "2S"): "tienes", ("tener", "PRS", "3S"): "tiene",
+        ("tener", "PRS", "1P"): "tenemos", ("tener", "PRS", "2P"): "tenéis", ("tener", "PRS", "3P"): "tienen",
+        ("tener", "SBJV", "1S"): "tenga", ("tener", "SBJV", "2S"): "tengas", ("tener", "SBJV", "3S"): "tenga",
+        ("tener", "SBJV", "1P"): "tengamos", ("tener", "SBJV", "2P"): "tengáis", ("tener", "SBJV", "3P"): "tengan",
+        # VENIR
+        ("venir", "PRS", "1S"): "vengo", ("venir", "PRS", "2S"): "vienes", ("venir", "PRS", "3S"): "viene",
+        ("venir", "PRS", "1P"): "venimos", ("venir", "PRS", "2P"): "venís", ("venir", "PRS", "3P"): "vienen",
+        ("venir", "SBJV", "1S"): "venga", ("venir", "SBJV", "2S"): "vengas", ("venir", "SBJV", "3S"): "venga",
+        ("venir", "SBJV", "1P"): "vengamos", ("venir", "SBJV", "2P"): "vengáis", ("venir", "SBJV", "3P"): "vengan",
+        # HACER
+        ("hacer", "PRS", "1S"): "hago", ("hacer", "PRS", "2S"): "haces", ("hacer", "PRS", "3S"): "hace",
+        ("hacer", "PRS", "1P"): "hacemos", ("hacer", "PRS", "2P"): "hacéis", ("hacer", "PRS", "3P"): "hacen",
+        ("hacer", "SBJV", "1S"): "haga", ("hacer", "SBJV", "2S"): "hagas", ("hacer", "SBJV", "3S"): "haga",
+        ("hacer", "SBJV", "1P"): "hagamos", ("hacer", "SBJV", "2P"): "hagáis", ("hacer", "SBJV", "3P"): "hagan",
+        ("hacer", "PST", "1S"): "hice", ("hacer", "PST", "3S"): "hizo",
+        # PONER
+        ("poner", "PRS", "1S"): "pongo", ("poner", "PRS", "2S"): "pones", ("poner", "PRS", "3S"): "pone",
+        ("poner", "PRS", "1P"): "ponemos", ("poner", "PRS", "2P"): "ponéis", ("poner", "PRS", "3P"): "ponen",
+        ("poner", "SBJV", "1S"): "ponga", ("poner", "SBJV", "2S"): "pongas", ("poner", "SBJV", "3S"): "ponga",
+        ("poner", "SBJV", "1P"): "pongamos", ("poner", "SBJV", "2P"): "pongáis", ("poner", "SBJV", "3P"): "pongan",
+        # DAR
+        ("dar", "PRS", "1S"): "doy", ("dar", "PRS", "2S"): "das", ("dar", "PRS", "3S"): "da",
+        ("dar", "PRS", "1P"): "damos", ("dar", "PRS", "2P"): "dais", ("dar", "PRS", "3P"): "dan",
+        ("dar", "SBJV", "1S"): "dé", ("dar", "SBJV", "2S"): "des", ("dar", "SBJV", "3S"): "dé",
+        ("dar", "SBJV", "1P"): "demos", ("dar", "SBJV", "2P"): "deis", ("dar", "SBJV", "3P"): "den",
+        # HABER
+        ("haber", "PRS", "1S"): "he", ("haber", "PRS", "2S"): "has", ("haber", "PRS", "3S"): "ha",
+        ("haber", "PRS", "1P"): "hemos", ("haber", "PRS", "2P"): "habéis", ("haber", "PRS", "3P"): "han",
+        ("haber", "SBJV", "1S"): "haya", ("haber", "SBJV", "2S"): "hayas", ("haber", "SBJV", "3S"): "haya",
+        ("haber", "SBJV", "1P"): "hayamos", ("haber", "SBJV", "2P"): "hayáis", ("haber", "SBJV", "3P"): "hayan",
+        # PODER
+        ("poder", "PRS", "1S"): "puedo", ("poder", "PRS", "2S"): "puedes", ("poder", "PRS", "3S"): "puede",
+        ("poder", "PRS", "1P"): "podemos", ("poder", "PRS", "2P"): "podéis", ("poder", "PRS", "3P"): "pueden",
+        ("poder", "SBJV", "1S"): "pueda", ("poder", "SBJV", "2S"): "puedas", ("poder", "SBJV", "3S"): "pueda",
+        ("poder", "SBJV", "1P"): "podamos", ("poder", "SBJV", "2P"): "podáis", ("poder", "SBJV", "3P"): "puedan",
+        # DECIR
+        ("decir", "PRS", "1S"): "digo", ("decir", "PRS", "2S"): "dices", ("decir", "PRS", "3S"): "dice",
+        ("decir", "PRS", "1P"): "decimos", ("decir", "PRS", "2P"): "decís", ("decir", "PRS", "3P"): "dicen",
+        # SABER
+        ("saber", "PRS", "1S"): "sé", ("saber", "PRS", "2S"): "sabes", ("saber", "PRS", "3S"): "sabe",
+        # VER
+        ("ver", "PRS", "1S"): "veo", ("ver", "PRS", "2S"): "ves", ("ver", "PRS", "3S"): "ve",
+        ("ver", "PRS", "1P"): "vemos", ("ver", "PRS", "2P"): "veis", ("ver", "PRS", "3P"): "ven",
+    }
+    
+    # Buscar forma irregular completa
+    if (lemma, tag, person) in IRREG_FULL:
+        return IRREG_FULL[(lemma, tag, person)]
+    
+    # Tallos irregulares FUT/COND
+    irr_stems = {
+        "salir":"saldr","venir":"vendr","tener":"tendr","poner":"pondr","valer":"valdr","poder":"podr",
+        "haber":"habr","saber":"sabr","caber":"cabr","querer":"querr","decir":"dir","hacer":"har"
+    }
+    
+    # Conjugación regular
+    root = lemma[:-2]
+    verb_class = lemma[-2:]  # ar, er, ir
+    
+    # PRESENTE
+    if tag == "PRS":
+        endings_ar = {"1S":"o","2S":"as","3S":"a","1P":"amos","2P":"áis","3P":"an"}
+        endings_er = {"1S":"o","2S":"es","3S":"e","1P":"emos","2P":"éis","3P":"en"}
+        endings_ir = {"1S":"o","2S":"es","3S":"e","1P":"imos","2P":"ís","3P":"en"}
+        endings = endings_ar if verb_class == "ar" else (endings_ir if verb_class == "ir" else endings_er)
+        return root + endings.get(person, "a")
+    
+    # PRETÉRITO
+    if tag == "PST":
+        endings_ar = {"1S":"é","2S":"aste","3S":"ó","1P":"amos","2P":"asteis","3P":"aron"}
+        endings_er = {"1S":"í","2S":"iste","3S":"ió","1P":"imos","2P":"isteis","3P":"ieron"}
+        endings = endings_ar if verb_class == "ar" else endings_er
+        return root + endings.get(person, "ó")
+    
+    # FUTURO
+    if tag == "FUT":
+        stem = irr_stems.get(lemma, lemma)
+        endings = {"1S":"é","2S":"ás","3S":"á","1P":"emos","2P":"éis","3P":"án"}
+        return stem + endings.get(person, "á")
+    
+    # CONDICIONAL
+    if tag == "COND":
+        stem = irr_stems.get(lemma, lemma)
+        endings = {"1S":"ía","2S":"ías","3S":"ía","1P":"íamos","2P":"íais","3P":"ían"}
+        return stem + endings.get(person, "ía")
+    
+    # SUBJUNTIVO PRESENTE
+    if tag == "SBJV":
+        if verb_class == "ar":
+            endings = {"1S":"e","2S":"es","3S":"e","1P":"emos","2P":"éis","3P":"en"}
+        else:
+            endings = {"1S":"a","2S":"as","3S":"a","1P":"amos","2P":"áis","3P":"an"}
+        return root + endings.get(person, "e" if verb_class == "ar" else "a")
+    
+    # IMPERFECTO
+    if tag == "IPFV":
+        if verb_class == "ar":
+            endings = {"1S":"aba","2S":"abas","3S":"aba","1P":"ábamos","2P":"abais","3P":"aban"}
+        else:
+            endings = {"1S":"ía","2S":"ías","3S":"ía","1P":"íamos","2P":"íais","3P":"ían"}
+        return root + endings.get(person, "aba" if verb_class == "ar" else "ía")
+    
+    # IMPERATIVO
+    if tag == "IMP":
+        if person == "2S":
+            return root + ("a" if verb_class == "ar" else "e")
+        return lemma  # otras personas usan subjuntivo
+    
+    # INFINITIVO/GERUNDIO/PARTICIPIO
+    if tag in {"INF","UNK"}:
+        return lemma
+    
+    # Default
+    return lemma
+
+# Mantener compatibilidad con código antiguo
+def _conj_es_3sg(lemma:str, tag:str) -> str:
+    """Wrapper para compatibilidad - llama a _conj_es_from_lemma con 3S"""
+    return _conj_es_from_lemma(lemma, tag, "3S")
+
+def _strip_nominal_suffix(base: str):
+    """Si no hay match directo, intenta quitar sufijos nominales comunes."""
+    for suf in sorted(NI_NOMINAL_SUFFIXES, key=len, reverse=True):
+        if base.endswith(suf):
+            return base[:-len(suf)], suf
+    return base, ""
+
+def _cleanup_es_spaces(s: str) -> str:
+    s = re.sub(r"\s+([,.;:!?])", r"\1", s)
+    s = re.sub(r"\(\s+", "(", s)
+    s = re.sub(r"\s+\)", ")", s)
+    s = re.sub(r"\s{2,}", " ", s).strip()
+    # micro-limpiezas
+    s = s.replace("a a ", " a ")
+    return s
+
+def translate_ni_to_es(sent: str):
+    toks = tokenize_ni(normalize_ni(sent))
+    out=[]
+    for i, t in enumerate(toks):
+        # Preservar puntuación
+        if t in VISIBLE_PUNCT or t in {"?", "!", "¿", "¡"}:
+            out.append(t)
+            continue
+        
+        # ✅ FIX: Preservar nombres propios (primera letra mayúscula)
+        if t and t[0].isupper() and not t.isupper() and len(t) > 1:
+            out.append(t)
+            continue
+
+        low=t.lower()
+
+        # Quita enclíticos -na / -ba (interrog./exclam.) SOLO para lookup
+        lookup_form = low[:-3] if (low.endswith("-na") or low.endswith("-ba")) else low
+
+        # 1) Forma directa (superficie o raíz)
+        if lookup_form in NI_TO_ES_FORM:
+            out.append(NI_TO_ES_FORM[lookup_form])
+            continue
+
+        # 2) TAM por sufijo + PERSONA ✅ NUEVO
+        root, tam_tag, tam_suffix = detect_ni_tam(lookup_form)
+        person, root_clean = _detect_ni_person(root)  # ✅ DETECTAR PERSONA
+
+        # 2a) Superficie exacta (con TAM)
+        es_direct = NI_TO_ES_SURF.get((lookup_form, tam_tag))
+        if es_direct:
+            out.append(es_direct)
+            continue
+
+        # 2b) CONJUGAR con persona ✅ MEJORADO
+        if tam_tag not in {"INF","UNK"} and root_clean in NI_TO_ES_LEMMA:
+            es_lemma = NI_TO_ES_LEMMA[root_clean]
+            out.append(_conj_es_from_lemma(es_lemma, tam_tag, person))
+            continue
+
+        # 2c) Raíz conocida → forma/lema ES
+        if root_clean in NI_TO_ES_FORM:
+            out.append(NI_TO_ES_FORM[root_clean])
+            continue
+        if root_clean in NI_TO_ES_LEMMA:
+            es_lemma = NI_TO_ES_LEMMA[root_clean]
+            out.append(_conj_es_from_lemma(es_lemma, tam_tag, person))
+            continue
+
+        # 3) Fallback suave para nominales: quita -ar/-en/-ka/-la/-si/-ŕa y reintenta
+        base2, suf2 = _strip_nominal_suffix(root_clean if root_clean else lookup_form)
+        if base2 != (root_clean if root_clean else lookup_form):
+            if base2 in NI_TO_ES_FORM:
+                out.append(NI_TO_ES_FORM[base2])
+                continue
+            if base2 in NI_TO_ES_LEMMA:
+                # ruta nominal: NO conjugar aunque sea verbo; devolvemos el lema limpio
+                out.append(NI_TO_ES_LEMMA[base2])
+                continue
+            # Si aún no, último recurso: presentar el núcleo "limpio"
+            out.append(base2)
+            continue
+
+        # 4) Desconocido → marcador suave
+        out.append(f"[?:{t}]")
+
+    return _cleanup_es_spaces(" ".join(out))
+
+# =========================
+# CARGA DE LÉXICO
+# =========================
+def load_lexicon():
+    loaded=False
+    total_rich=total_simple=0
+    for p in CSV_CANDIDATES:
+        if not os.path.exists(p): continue
+        try:
+            with open(p, encoding="utf-8") as f:
+                rd=csv.DictReader(f); flds=set(rd.fieldnames or [])
+                # v4.4: formato nuevo con ni_surface
+                if {"source_es","es_morph","ni_surface"}.issubset(flds):
+                    for r in rd:
+                        es=(r.get("source_es") or "").strip().lower()
+                        tag=(r.get("es_morph") or "").strip().upper()
+                        surf=(r.get("ni_surface") or "").strip()
+                        if not surf:
+                            root=(r.get("ni_root") or "").strip(); suf=(r.get("ni_suffix") or "").strip()
+                            if root or suf: surf=f"{root}{suf}"
+                        if es and tag and surf: SURF_RICH[(es,tag)] = surf; total_rich+=1
+
+                        ni=(r.get("target_ni") or "").strip()
+                        es_lem=(r.get("es_lemma") or "").strip().lower()
+
+                        pos = _canon_pos(r.get("pos") or r.get("es_pos") or r.get("target_pos") or r.get("pos_es") or r.get("ni_pos") or "")
+                        tam_ok = _boolish(r.get("tam_ok"))
+
+                        if es: _meta_set(es, pos=pos, tam_ok=(tam_ok if tam_ok is not None else (pos=="V" if pos else None)))
+                        if es_lem:
+                            _meta_set(es_lem, pos=("V" if es_lem.endswith(("ar","er","ir")) else (pos or "")),
+                                      tam_ok=(tam_ok if tam_ok is not None else (pos=="V" if pos else None)))
+
+                        if es and ni!="": LEX_FORM.setdefault(es,ni)
+                        if es_lem and ni!="": LEX_LEMMA.setdefault(es_lem,ni)
+                    loaded=True; continue
+
+                if {"source_es","target_ni"}.issubset(flds):
+                    for r in rd:
+                        es=(r.get("source_es") or "").strip().lower()
+                        ni=(r.get("target_ni") or "").strip()
+                        if not es: continue
+                        LEX_FORM.setdefault(es,ni); total_simple+=1
+                        _meta_set(es, pos="", tam_ok=None)
+                        if looks_like_verb_form_strict(es):
+                            lem=guess_infinitive_es(es)
+                            if lem:
+                                LEX_LEMMA.setdefault(lem,ni); _meta_set(lem, pos="V", tam_ok=True)
+                    loaded=True; continue
+
+                if {"es","ni_lemma"}.issubset(flds):
+                    for r in rd:
+                        es=(r.get("es") or "").strip().lower()
+                        ni=(r.get("ni_lemma") or "").strip()
+                        if not es: continue
+                        LEX_FORM.setdefault(es,ni); total_simple+=1
+                        _meta_set(es, pos="", tam_ok=None)
+                        if looks_like_verb_form_strict(es):
+                            lem=guess_infinitive_es(es)
+                            if lem:
+                                LEX_LEMMA.setdefault(lem,ni); _meta_set(lem, pos="V", tam_ok=True)
+                    loaded=True; continue
+        except Exception as e:
+            print(f"[WARN] No se pudo leer {p}: {e}")
+    if total_rich or total_simple:
+        print(f"✓ ES→NI: {total_rich} superficies ricas, {total_simple} pares simples")
+
+    global FOLD_FORM
+    FOLD_FORM={}
+    for k,v in LEX_FORM.items():
+        fk=fold(k)
+        if fk!=k and len(k)>=5 and not looks_like_verb_form_strict(k):
+            FOLD_FORM.setdefault(fk,v)
+
+    # Cobertura mínima
+    KEEP_MIN={
+        "y":"ne","o":"o","no":"eś","a":"ka","para":"kara","eso":"kok","tarta":"gatel",
+        "el":"do", "la":"da", "los":"don", "las":"dan",
+        "un":"banu","una":"bana","uno":"ban",
+        "este":"aŕe","esta":"aŕa","estos":"aŕen","estas":"aŕan",
+        
+        # Números básicos
+        "dos":"bi","tres":"irur","cuatro":"laur","cinco":"borste","seis":"śei",
+        "siete":"sisbi","ocho":"sorse","nueve":"lauŕbi","diez":"abaŕ","veinte":"oŕkei",
+        
+        # Números 1-100 (dígitos)
+        "1":"ban","2":"bi","3":"irur","4":"laur","5":"borste",
+        "6":"śei","7":"sisbi","8":"sorse","9":"bedar","10":"abaŕ",
+        "11":"abaŕ-ke-ban","12":"abaŕ-ke-bi","13":"abaŕ-ke-irur","14":"abaŕ-ke-laur","15":"abaŕ-ke-borste",
+        "16":"abaŕ-ke-śei","17":"abaŕ-ke-sisbi","18":"abaŕ-ke-sorse","19":"abaŕ-ke-bedar","20":"oŕkei",
+        "21":"oŕkei-ke-ban","22":"oŕkei-ke-bi","23":"oŕkei-ke-irur","24":"oŕkei-ke-laur","25":"oŕkei-ke-borste",
+        "26":"oŕkei-ke-śei","27":"oŕkei-ke-sisbi","28":"oŕkei-ke-sorse","29":"oŕkei-ke-bedar","30":"oŕkei-abaŕ",
+        "31":"oŕkei-abaŕ-ke-ban","32":"oŕkei-abaŕ-ke-bi","33":"oŕkei-abaŕ-ke-irur","34":"oŕkei-abaŕ-ke-laur","35":"oŕkei-abaŕ-ke-borste",
+        "36":"oŕkei-abaŕ-ke-śei","37":"oŕkei-abaŕ-ke-sisbi","38":"oŕkei-abaŕ-ke-sorse","39":"oŕkei-abaŕ-ke-bedar","40":"binoŕkei",
+        "41":"binoŕkei-abaŕ-ke-ban","42":"binoŕkei-abaŕ-ke-bi","43":"binoŕkei-abaŕ-ke-irur","44":"binoŕkei-abaŕ-ke-laur","45":"binoŕkei-abaŕ-ke-borste",
+        "46":"binoŕkei-abaŕ-ke-śei","47":"binoŕkei-abaŕ-ke-sisbi","48":"binoŕkei-abaŕ-ke-sorse","49":"binoŕkei-abaŕ-ke-bedar","50":"binoŕkei-abaŕ",
+        "51":"binoŕkei-abaŕ-ke-ban","52":"binoŕkei-abaŕ-ke-bi","53":"binoŕkei-abaŕ-ke-irur","54":"binoŕkei-abaŕ-ke-laur","55":"binoŕkei-abaŕ-ke-borste",
+        "56":"binoŕkei-abaŕ-ke-śei","57":"binoŕkei-abaŕ-ke-sisbi","58":"binoŕkei-abaŕ-ke-sorse","59":"binoŕkei-abaŕ-ke-bedar","60":"iruŕokei",
+        "61":"iruŕokei-abaŕ-ke-ban","62":"iruŕokei-abaŕ-ke-bi","63":"iruŕokei-abaŕ-ke-irur","64":"iruŕokei-abaŕ-ke-laur","65":"iruŕokei-abaŕ-ke-borste",
+        "66":"iruŕokei-abaŕ-ke-śei","67":"iruŕokei-abaŕ-ke-sisbi","68":"iruŕokei-abaŕ-ke-sorse","69":"iruŕokei-abaŕ-ke-bedar","70":"iruŕokei-abaŕ",
+        "71":"iruŕokei-abaŕ-ke-ban","72":"iruŕokei-abaŕ-ke-bi","73":"iruŕokei-abaŕ-ke-irur","74":"iruŕokei-abaŕ-ke-laur","75":"iruŕokei-abaŕ-ke-borste",
+        "76":"iruŕokei-abaŕ-ke-śei","77":"iruŕokei-abaŕ-ke-sisbi","78":"iruŕokei-abaŕ-ke-sorse","79":"iruŕokei-abaŕ-ke-bedar","80":"lauŕokei",
+        "81":"lauŕokei-abaŕ-ke-ban","82":"lauŕokei-abaŕ-ke-bi","83":"lauŕokei-abaŕ-ke-irur","84":"lauŕokei-abaŕ-ke-laur","85":"lauŕokei-abaŕ-ke-borste",
+        "86":"lauŕokei-abaŕ-ke-śei","87":"lauŕokei-abaŕ-ke-sisbi","88":"lauŕokei-abaŕ-ke-sorse","89":"lauŕokei-abaŕ-ke-bedar","90":"lauŕokei-abaŕ",
+        "91":"lauŕokei-abaŕ-ke-ban","92":"lauŕokei-abaŕ-ke-bi","93":"lauŕokei-abaŕ-ke-irur","94":"lauŕokei-abaŕ-ke-laur","95":"lauŕokei-abaŕ-ke-borste",
+        "96":"lauŕokei-abaŕ-ke-śei","97":"lauŕokei-abaŕ-ke-sisbi","98":"lauŕokei-abaŕ-ke-sorse","99":"lauŕokei-abaŕ-ke-bedar","100":"atun",
+        
+        # Números en letras
+        "once":"abaŕ-ke-ban","doce":"abaŕ-ke-bi","trece":"abaŕ-ke-irur","catorce":"abaŕ-ke-laur","quince":"abaŕ-ke-borste",
+        "dieciséis":"abaŕ-ke-śei","dieciseis":"abaŕ-ke-śei","diecisiete":"abaŕ-ke-sisbi","dieciocho":"abaŕ-ke-sorse","diecinueve":"abaŕ-ke-bedar",
+        "veintiuno":"oŕkei-ke-ban","veintidós":"oŕkei-ke-bi","veintidos":"oŕkei-ke-bi","veintitrés":"oŕkei-ke-irur","veintitres":"oŕkei-ke-irur",
+        "veinticuatro":"oŕkei-ke-laur","veinticinco":"oŕkei-ke-borste","veintiséis":"oŕkei-ke-śei","veintiseis":"oŕkei-ke-śei",
+        "veintisiete":"oŕkei-ke-sisbi","veintiocho":"oŕkei-ke-sorse","veintinueve":"oŕkei-ke-bedar",
+        "treinta":"oŕkei-abaŕ","cuarenta":"binoŕkei","cincuenta":"binoŕkei-abaŕ","sesenta":"iruŕokei",
+        "setenta":"iruŕokei-abaŕ","ochenta":"lauŕokei","noventa":"lauŕokei-abaŕ","cien":"atun",
+        
+        # Pronombres y partículas
+        "yo":"ni","tú":"zu","él":"nar","ella":"nar",
+        "nosotros":"gu","nosotras":"gu","vosotros":"zuek","vosotras":"zuek",
+        "ellos":"narek","ellas":"narek",
+        "que":"ze","si":"baldin","cuando":"noiz","donde":"non",
+        "como":"nola","porque":"zeren","mientras":"bitarte",
+        "versión":"bertsi","test":"froga","prueba":"froga",
+        "ejemplo":"adibid","texto":"testu","palabra":"hitz"
+    }
+    for k,v in KEEP_MIN.items():
+        LEX_FORM.setdefault(k,v)
+        if k in {"yo","tú","él","ella","nosotros","nosotras","vosotros","vosotras","ellos","ellas"}:
+            _meta_set(k, pos="PRON", tam_ok=False)
+        elif k in {"que","si","cuando","donde","como","porque","mientras"}:
+            _meta_set(k, pos="PART", tam_ok=False)
+        elif k.isdigit() or k in {"uno","dos","tres","cuatro","cinco","seis","siete","ocho","nueve","diez","once","doce","trece","catorce","quince","dieciséis","dieciseis","diecisiete","dieciocho","diecinueve","veinte","veintiuno","veintidós","veintidos","veintitrés","veintitres","veinticuatro","veinticinco","veintiséis","veintiseis","veintisiete","veintiocho","veintinueve","treinta","cuarenta","cincuenta","sesenta","setenta","ochenta","noventa","cien"}:
+            _meta_set(k, pos="NUM", tam_ok=False)
+        else:
+            _meta_set(k, pos=_canon_pos("PART" if k in {"y","o","no","a","para"} else "DET"), tam_ok=False)
+
+    BUILTIN_LEMMA={
+        # Solo por seguridad si faltara en CSV
+        "llover":"euŕak","llamar":"deitu","venir":"nuker","ir":"nitus",
+        "hacer":"giotael","tener":"giokk","poder":"binbel","poner":"pusen",
+        "ser":"izan","estar":"egon"
+    }
+    for k,v in BUILTIN_LEMMA.items():
+        LEX_LEMMA.setdefault(k,v); _meta_set(k, pos="V", tam_ok=True)
+
+    FORCE_FORMS = {
+        "voy":"nitus-ke","vas":"nitus-ke","va":"nitus-ke","vamos":"nitus-ke","vais":"nitus-ke","van":"nitus-ke",
+        "vengo":"nuker-ke","vienes":"nuker-ke","viene":"nuker-ke","venimos":"nuker-ke","venís":"nuker-ke","vienen":"nuker-ke",
+        "ven":"nuker-tu","haz":"giotael-tu","pon":"pusen-tu","di":"siśnesir-tu","sal":"salku-tu","ten":"giokk-tu","sé":"suber-tu"
+    }
+    for form, ni in FORCE_FORMS.items():
+        LEX_FORM[form] = ni; _meta_set(form, pos="V", tam_ok=True)
+    global FORCE_KEYS
+    FORCE_KEYS = set(FORCE_FORMS.keys())
+    return loaded
+
+def load_lexicon_ni_es():
+    loaded=False
+    total=0
+    # 1) Intento DictReader con cabecera
+    for p in CSV_NI_ES:
+        if not os.path.exists(p):
+            debug_print(f"CSV NI→ES no encontrado: {p}")
+            continue
+        try:
+            with open(p, encoding="utf-8") as f:
+                sniffer = csv.Sniffer()
+                sample = f.read(4096)
+                f.seek(0)
+                has_header = sniffer.has_header(sample)
+                if has_header:
+                    dr = csv.DictReader(f)
+                    fieldnames = [x.lower() for x in (dr.fieldnames or [])]
+                    # nombres plausibles
+                    fn_source = next((c for c in fieldnames if "source" in c and ("ni" in c or "neo" in c)), None)
+                    fn_target = next((c for c in fieldnames if "target" in c and ("es" in c or "spa" in c)), None)
+                    fn_eslem  = next((c for c in fieldnames if "es_lem" in c or c=="es_lemma" or "lemma_es" in c), None)
+                    # v4.4: el CSV usa 'ni_tam'
+                    fn_morph  = next((c for c in fieldnames if c in {"ni_tam","ni_morph","ni_tag"} or "morph" in c), None)
+                    fn_root   = next((c for c in fieldnames if "ni_root" in c or c=="root" or "ni_lemma" in c), None)
+
+                    if fn_source and fn_target:
+                        debug_print(f"Cargando {p} con cabecera: source={fn_source}, target={fn_target}")
+                        for r in dr:
+                            # ✅ FIX 1: NO convertir a minúsculas
+                            source_ni = (r.get(fn_source) or "").strip()  # ← SIN .lower()
+                            target_es = (r.get(fn_target) or "").strip()
+                            es_lemma  = (r.get(fn_eslem) or "").strip().lower() if fn_eslem else ""
+                            ni_morph  = (r.get(fn_morph) or "").strip().upper() if fn_morph else ""
+                            ni_root   = (r.get(fn_root) or "").strip().lower() if fn_root else ""
+                            
+                            if source_ni and target_es:
+                                # ✅ FIX 2: Sobrescribir en vez de setdefault
+                                NI_TO_ES_FORM[source_ni] = target_es
+                                if ni_morph:
+                                    NI_TO_ES_SURF[(source_ni, ni_morph)] = target_es
+                            if ni_root and es_lemma:
+                                NI_TO_ES_LEMMA.setdefault(ni_root, es_lemma)
+                            if ni_root and target_es:
+                                NI_TO_ES_FORM.setdefault(ni_root, target_es)
+                            total+=1
+                        print(f"✓ Cargadas {total} filas NI→ES (cabecera) desde {p}")
+                        loaded=True
+                        continue  # pasa al siguiente fichero si hay
+                        
+                # 2) Fallback por posiciones
+                f.seek(0)
+                reader=csv.reader(f)
+                count=0
+                for row in reader:
+                    if not row: continue
+                    if count==0 and any("source" in (c or "").lower() or "ni_" in (c or "").lower() or "target" in (c or "").lower() for c in row):
+                        count+=1
+                        continue
+                    
+                    # ✅ FIX 3: Índices correctos según estructura del CSV v4.4
+                    # source_ni, target_es, ni_tam, ni_pn, es_morph, es_pn, ni_root, ni_suffix, es_lemma, pos_es, evidencia
+                    #     0          1        2      3        4        5       6         7         8         9       10
+                    source_ni = (row[0] if len(row)>0 else "").strip()           # ← SIN .lower()
+                    target_es = (row[1] if len(row)>1 else "").strip()
+                    ni_tam    = (row[2] if len(row)>2 else "").strip().upper()   # ← CORRECTO: posición 2
+                    ni_root   = (row[6] if len(row)>6 else "").strip().lower()   # ← Ya estaba bien
+                    es_lemma  = (row[8] if len(row)>8 else "").strip().lower()   # ← CORRECTO: posición 8
+                    
+                    if source_ni and target_es:
+                        NI_TO_ES_FORM[source_ni] = target_es  # ← Sobrescribir
+                        if ni_tam:
+                            NI_TO_ES_SURF[(source_ni, ni_tam)] = target_es
+                    if ni_root and es_lemma:
+                        NI_TO_ES_LEMMA.setdefault(ni_root, es_lemma)
+                    if ni_root and target_es:
+                        NI_TO_ES_FORM.setdefault(ni_root, target_es)
+                    count+=1
+                    total+=1
+                    
+                if count>0:
+                    print(f"✓ Cargadas {count} filas NI→ES (posicional) desde {p}")
+                    loaded=True
+        except Exception as e:
+            print(f"[WARN] Error leyendo {p}: {e}")
+            import traceback
+            traceback.print_exc()
+
+    # ✅ FIX 4: Vocabulario mínimo ampliado
+    KEEP_MIN_NI = {
+        # Partículas
+        "ne":"y","o":"o","eś":"no","ka":"a","mi":"a","te":"a",
+        "kin":"con","tan":"en","ta":"de","kara":"para",
+        
+        # Pronombres
+        "ni":"yo","zu":"tú","nar":"él","gu":"nosotros",
+        "ban":"un","banu":"un","bana":"una",
+        
+        # Artículos
+        "do":"el","da":"la","don":"los","dan":"las",
+        
+        # Demostrativos
+        "aŕe":"este","aŕa":"esta","aŕen":"estos","aŕan":"estas",
+        
+        # Verbos base
+        "nuker":"venir","siśnesir":"decir","giotael":"hacer",
+        "izan":"ser","egon":"estar","giokk":"tener",
+        "pusen":"poner","binbel":"poder","nitus":"ir",
+        "deitu":"llamar","euŕak":"llover",
+        
+        # Interjecciones
+        "batsornel":"hola","sabernel":"adiós",
+        
+        # Sustantivos comunes
+        "domśaldum":"pan","śesilmen":"café","kuknomtok":"restaurante",
+        "sikliskoŕ":"casa","śaldalbam":"mercado","bekmil":"cine",
+        "seŕtuŕgok":"año","kordo":"pueblo","tokbatkir":"ciudad",
+        "eskom":"amigo","nintos":"madre","śimnas":"padre",
+    }
+    
+    for k,v in KEEP_MIN_NI.items():
+        NI_TO_ES_FORM.setdefault(k,v)
+        
+    if total:
+        print(f"✓ NI→ES: {total} pares cargados (incluyendo {len(KEEP_MIN_NI)} mínimos)")
+    else:
+        print(f"⚠ NI→ES: No se cargaron pares desde CSV, usando {len(KEEP_MIN_NI)} mínimos")
+        
+    # ✅ FIX 5: DEBUG - mostrar muestras cargadas
+    if DEBUG_MODE and total > 0:
+        print("\n[DEBUG] Muestra de NI_TO_ES_FORM:")
+        samples = list(NI_TO_ES_FORM.items())[:30]
+        for k, v in samples:
+            print(f"  {k} → {v}")
+            
+    return loaded
+
+print("Cargando léxico ES→NI..."); load_lexicon()
+print("Cargando léxico NI→ES..."); load_lexicon_ni_es()
+
+# =========================
+# UI CLÁSICA (con dirección)
+# =========================
+LABELS={
+    "ES":{
+        "title":"Traductor Español ↔ Neoíbero v4.4",
+        "subtitle":"Explora el renacimiento ibérico con tecnología moderna — ULTRA-DEFINITIVO",
+        "in_label_es":"✏️ Entrada (Español)",
+        "in_label_ni":"✏️ Entrada (Neoíbero)",
+        "in_ph_es":"Escribe aquí. Ej.: Veo a Ana y doy pan a Marta.",
+        "in_ph_ni":"Idatzi hemen. Adib.: nitus-ke ni etxe-ka.",
+        "out_lat_esni":"📜 Salida: Neoíbero (latín)",
+        "out_lat_nies":"📜 Salida: Español",
+        "out_ib":"🗿 Línea ibérica",
+        "out_audio":"🔊 Locución (Audio)",
+        "btn":"🔄 Traducir",
+        "combo":"🌍 Idioma (UI + explicación)",
+        "dir":"🔁 Dirección",
+        "dir_opts":["ES → NI","NI → ES"],
+        "doc_header":"📚 Documentación y Referencia",
+        "acc_titles":[
+            "🎓 Marco académico y decisiones del neoíbero",
+            "🏛️ Herencia posible del íbero histórico",
+            "🎨 Diseño de la conlang (neoíbero)",
+            "⚙️ Pipeline del traductor (paso a paso)",
+            "🔤 Ortografía, línea ibérica y claves",
+            "❓/❗ Modalidad presunto vascoide (-na / -ba)",
+            "📖 Gramática de referencia (v1.2)",
+            "📚 Bibliografía de base",
+            "🧾 Siglas y glosario"
+        ]
+    },
+    "EN":{
+        "title":"Spanish ↔ Neo-Iberian Translator v4.4",
+        "subtitle":"Explore the revival of Neo-Iberian with modern tech — ULTRA-DEFINITIVE",
+        "in_label_es":"✏️ Input (Spanish)",
+        "in_label_ni":"✏️ Input (Neo-Iberian)",
+        "in_ph_es":"Type here. E.g., Veo a Ana y doy pan a Marta.",
+        "in_ph_ni":"Type here. E.g., nitus-ke ni etxe-ka.",
+        "out_lat_esni":"📜 Output: Neo-Iberian (Latin)",
+        "out_lat_nies":"📜 Output: Spanish",
+        "out_ib":"🗿 Iberian line",
+        "out_audio":"🔊 Speech (Audio)",
+        "btn":"🔄 Translate",
+        "combo":"🌍 Language (UI + docs)",
+        "dir":"🔁 Direction",
+        "dir_opts":["ES → NI","NI → ES"],
+        "doc_header":"📚 Documentation & Reference",
+        "acc_titles":[
+            "🎓 Background & design choices",
+            "🏛️ Possible inheritance from ancient Iberian",
+            "🎨 Conlang design (Neo-Iberian)",
+            "⚙️ Translator pipeline (step by step)",
+            "🔤 Orthography, Iberian line & keys",
+            "❓/❗ 'Vascoid' mood (-na / -ba)",
+            "📖 Reference grammar (v1.2)",
+            "📚 Core references",
+            "🧾 Acronyms & glossary"
+        ]
+    }
+}
+
+# Documentación completa del appOld.py
+DOC_ES_0 = """**Escritura y datos.**
+El *neoíbero* se diseña como una **lengua conjetural** que toma como base el corpus ibérico (ss. V–I a.C.) conocido, más una morfología y un léxico especulativos construidos con plausibilidad histórica y tipológica.
+"""
+DOC_ES_1 = """**Herencia antigua posible.**
+- Raíces documentadas en inscripciones ibéricas reales: *ban*, *bi*, *irur*, *laur*, *borste*, *śei*, *sisbi*, *sorse* (numerales); *belai* (cuervo), *ebee* (perdiz), etc.
+- **CV(C)** phonotactics; no **/p/** fonémico; *r/ŕ* desaconsejado en inicio de palabra.
+- Postposiciones/sufijos nominales: **-k** (pl), **-te** (agente), **-ar/-en** (genitivo/origen), **-ka** (dat./loc./dist.), **-i** (ac. con PN).
+- Partículas: **ne** 'y', **o** 'o', **eś** 'no'.
+- Numerales: *ban, bi, irur, laur, borste, śei, sisbi, sorse, lauŕbi, abaŕ (10), oŕkei (20).*
+"""
+DOC_ES_2 = """**Diseño de la conlang:**
+- **TAM (v3.2-LTS):** PRS **-ke**, PST **-bo**, FUT **-ta**, IPFV **-ri**, IMP **-tu**, **SBJV -ni**, **COND -ne**.
+- Derivación: verbos (-ke/-ta/-bo/-ri/-ni/-ne), adjetivos (-si), sustantivos (-ar/-en/-tu/-la/-ŕa/-si).
+- Orden preferido **SOV**.
+"""
+DOC_ES_3 = """**Pipeline (resumen):**
+1) Tokenizar; partir **al→ka do**, **del→ta do**.
+2) `a` → `ka`/`mi`/`te`.
+3) CSV rico da **superficie** NI; si no, CSV simple → **lema** NI.
+4) **Puerta POS/TAM**: solo verbos obtienen TAM; otros se normalizan a lema/raíz.
+5) Negación **eś** antes del primer verbo finito.
+6) ?/! → enclíticos **-na/-ba** en el último verbo finito (o último constituyente).
+7) WH desnudo añade **-na** e inserta `?`.
+8) Línea ibérica: solo puntuación visible; separador de palabras = **"/"** (tridots).
+"""
+DOC_ES_4 = """**Ortografía y claves:**
+- Modo de claves **explicit** (BA/BE/BI/BO/BU).
+- Separador de palabras = "/".
+- Atajos: `ka`→**K**, `mi`→**MI**, `te`→**TE**, `ne`→**N**, `o`→**O**, `eś`→**X**.
+"""
+DOC_ES_5 = """**Modalidad (-na/-ba):**
+- **-na** interrogativa; **-ba** exclamativa, se une al último verbo finito (o último constituyente).
+"""
+DOC_ES_6 = """**Gramática mínima (NI):**
+- Verbo: raíz + **TAM**; negación preverbal **eś**.
+- Casos productivos: -k (pl), -te (agente), -ka (dat/loc), -ar/-en (genitivo/origen).
+"""
+DOC_ES_7 = """**Referencias principales:** Untermann; de Hoz; Ferrer i Jané; Correa; gramáticas/corpora bascoide seleccionados."""
+DOC_ES_8 = """**Acrónimos (v3.2-LTS):**
+- **TAM** (PRS, PST, FUT, IPFV, SBJV, COND, IMP, FUT_SBJV); **PN**; **POS**; **LEMMa/SURFACE**; **RT**; **LTS**; **SOV**; **CV(C)**; **CSV**; **Enclítico**.
+"""
+
+DOC_EN_0 = """**Writing & data.**
+*Neo-Iberian* is designed as a **conlang** that takes the known Iberian corpus (5th–1st c. BCE) as a base, plus a speculative morphology and lexicon built with historical and typological plausibility.
+"""
+DOC_EN_1 = """**Possible ancient heritage.**
+- Roots documented in real Iberian inscriptions: *ban*, *bi*, *irur*, *laur*, *borste*, *śei*, *sisbi*, *sorse* (numerals); *belai* (raven), *ebee* (partridge), etc.
+- **CV(C)** phonotactics; no phonemic **/p/**; *r/ŕ* disallowed word-initially.
+- Postpositions/nominal suffixes: **-k** (pl), **-te** (agent), **-ar/-en** (genitive/origin), **-ka** (dat./loc./dist.), **-i** (acc. with PN).
+- Particles: **ne** 'and', **o** 'or', **eś** 'not'.
+- Numerals: *ban, bi, irur, laur, borste, śei, sisbi, sorse, lauŕbi, abaŕ (10), oŕkei (20).*
+"""
+DOC_EN_2 = """**Conlang design:**
+- **TAM (v3.2-LTS):** PRS **-ke**, PST **-bo**, FUT **-ta**, IPFV **-ri**, IMP **-tu**, **SBJV -ni**, **COND -ne**.
+- Derivation: verbs (-ke/-ta/-bo/-ri/-ni/-ne), adjectives (-si), nouns (-ar/-en/-tu/-la/-ŕa/-si).
+- Preferred order **SOV**.
+"""
+DOC_EN_3 = """**Pipeline (summary):**
+1) Tokenize; split **al→ka do**, **del→ta do**.
+2) `a` → `ka`/`mi`/`te`.
+3) Rich CSV gives NI **surface**; else simple CSV → NI **lemma**.
+4) **POS/TAM gating**: only verbs get TAM; others normalize to lemma/root.
+5) Negation **eś** before the first finite verb.
+6) ?/! → enclitics **-na/-ba** on the last finite verb (or last constituent).
+7) Bare WH adds **-na** and inserts `?`.
+8) Iberian line: visible punctuation only; word separator is **"/"** (tridots).
+"""
+DOC_EN_4 = """**Orthography & keys:**
+- Keys mode **explicit** (BA/BE/BI/BO/BU).
+- Word separator = "/".
+- Shortcuts: `ka`→**K**, `mi`→**MI**, `te`→**TE**, `ne`→**N**, `o`→**O**, `eś`→**X**.
+"""
+DOC_EN_5 = """**Modality (-na/-ba):**
+- **-na** interrogative; **-ba** exclamative, attached to the last finite verb (or last constituent).
+"""
+DOC_EN_6 = """**Minimal grammar (NI):**
+- Verb: root + **TAM**; preverbal negation **eś**.
+- Productive cases: -k (pl), -te (agent), -ka (dat/loc), -ar/-en (genitive/origin).
+"""
+DOC_EN_7 = """**Core references:** Untermann; de Hoz; Ferrer i Jané; Correa; selected Bascoid grammars/corpora."""
+DOC_EN_8 = """**Acronyms (v3.2-LTS):**
+- **TAM** (PRS, PST, FUT, IPFV, SBJV, COND, IMP, FUT_SBJV); **PN**; **POS**; **LEMMa/SURFACE**; **RT**; **LTS**; **SOV**; **CV(C)**; **CSV**; **Enclitic**.
+"""
+
+DOC={
+    "ES":[DOC_ES_0, DOC_ES_1, DOC_ES_2, DOC_ES_3, DOC_ES_4, DOC_ES_5, DOC_ES_6, DOC_ES_7, DOC_ES_8],
+    "EN":[DOC_EN_0, DOC_EN_1, DOC_EN_2, DOC_EN_3, DOC_EN_4, DOC_EN_5, DOC_EN_6, DOC_EN_7, DOC_EN_8]
+}
+
+# CSS del diseño original (appOld.py)
+def build_css():
+    b64=None
+    if os.path.exists("Iberia-Georgeos.ttf"):
+        with open("Iberia-Georgeos.ttf","rb") as f:
+            b64=base64.b64encode(f.read()).decode("ascii")
+    font_src = f"url(data:font/ttf;base64,{b64}) format('truetype')" if b64 else "local('sans-serif')"
+    return f"""
+@font-face {{
+  font-family: 'IberiaGeorgeos';
+  src: {font_src};
+  font-weight: normal; font-style: normal;
+}}
+:root {{
+  --iberian-clay:#8B4513; --iberian-ochre:#CC7722; --iberian-stone:#5C5C5C;
+  --iberian-sand:#D2B48C; --iberian-rust:#A0522D; --iberian-bronze:#CD7F32;
+}}
+.gradio-container {{ background:linear-gradient(135deg,#f4e8d8 0%,#e8d5c4 50%,#d4c4b0 100%)!important;
+  font-family:'Georgia','Times New Roman',serif!important; }}
+.gradio-container h1,.gradio-container h2,.gradio-container h3 {{
+  color:var(--iberian-clay)!important; text-shadow:2px 2px 4px rgba(139,69,19,.15)!important;
+  border-bottom:3px solid var(--iberian-bronze)!important; padding-bottom:.5rem!important; letter-spacing:.5px!important;
+}}
+.gradio-container .gr-group {{ background:linear-gradient(to bottom,#f9f6f0,#ede6dc)!important;
+  border:2px solid var(--iberian-sand)!important; border-radius:8px!important; box-shadow:0 4px 12px rgba(139,69,19,.2), inset 0 1px 0 rgba(255,255,255,.5)!important;
+  padding:1.5rem!important; margin-bottom:1.5rem!important; }}
+.gradio-container .gr-accordion {{ background:linear-gradient(145deg,#ebe3d5,#d9cec0)!important;
+  border:2px solid var(--iberian-rust)!important; border-radius:6px!important; margin-bottom:.8rem!important; box-shadow:2px 2px 6px rgba(0,0,0,.15)!important; }}
+.gradio-container .gr-accordion .label-wrap {{ background:linear-gradient(to right,var(--iberian-ochre),var(--iberian-rust))!important;
+  color:#fff!important; font-weight:600!important; padding:.8rem 1rem!important; border-radius:4px!important; text-shadow:1px 1px 2px rgba(0,0,0,.3)!important; }}
+.gradio-container .gr-textbox textarea,.gradio-container .gr-textbox input {{ background:linear-gradient(to bottom,#faf8f3,#f5f0e8)!important;
+  border:2px solid var(--iberian-sand)!important; border-radius:6px!important; color:var(--iberian-stone)!important;
+  font-family:'Georgia',serif!important; box-shadow:inset 2px 2px 4px rgba(139,69,19,.1)!important; }}
+.gradio-container .gr-textbox textarea:focus,.gradio-container .gr-textbox input:focus {{
+  border-color:var(--iberian-bronze)!important; box-shadow:inset 2px 2px 4px rgba(139,69,19,.1), 0 0 8px rgba(205,127,50,.3)!important; }}
+.gradio-container .gr-button.gr-button-primary {{ background:linear-gradient(145deg,var(--iberian-bronze),var(--iberian-rust))!important;
+  border:2px solid var(--iberian-clay)!important; color:#fff!important; font-weight:bold!important; text-shadow:1px 1px 2px rgba(0,0,0,.4)!important;
+  box-shadow:0 4px 8px rgba(139,69,19,.3), inset 0 1px 0 rgba(255,255,255,.2)!important; border-radius:8px!important; padding:.8rem 1.5rem!important; transition:all .3s ease!important; }}
+.gradio-container .gr-button.gr-button-primary:hover {{ background:linear-gradient(145deg,var(--iberian-rust),var(--iberian-bronze))!important;
+  transform:translateY(-2px)!important; box-shadow:0 6px 12px rgba(139,69,19,.4)!important; }}
+.ib-line {{ font-family:'IberiaGeorgeos',monospace,sans-serif!important; font-size:1.9rem!important; line-height:2.4rem!important; white-space:pre-wrap!important;
+  background:linear-gradient(135deg,#e8dcc8 0%,#d4c4a8 50%,#c4b098 100%)!important; padding:24px!important; border-radius:10px!important;
+  border:3px solid var(--iberian-rust)!important; border-left:6px solid var(--iberian-bronze)!important;
+  box-shadow:0 4px 15px rgba(139,69,19,.25), inset 0 2px 4px rgba(0,0,0,.1)!important; color:var(--iberian-clay)!important; position:relative!important; }}
+.ib-line::before {{ content:''!important; position:absolute!important; inset:0!important;
+  background-image:repeating-linear-gradient(0deg,transparent,transparent 2px, rgba(139,69,19,.03) 2px, rgba(139,69,19,.03) 4px)!important;
+  pointer-events:none!important; border-radius:10px!important; }}
+@media (max-width:768px) {{
+  .ib-line {{ font-size:1.5rem!important; line-height:2rem!important; padding:16px!important; }}
+  .gradio-container .gr-group {{ padding:1rem!important; }}
+  .gradio-container h1 {{ font-size:1.8rem!important; }}
+}}
+@media (max-width:480px) {{
+  .ib-line {{ font-size:1.3rem!important; line-height:1.8rem!important; padding:12px!important; }}
+  .gradio-container h1 {{ font-size:1.5rem!important; }}
+}}
+"""
+CSS = build_css()
+
+# =========================
+# INTERFAZ GRADIO
+# =========================
+with gr.Blocks(css=CSS, theme=gr.themes.Soft(primary_hue="indigo", secondary_hue="purple")) as demo:
+    with gr.Group():
+        title = gr.Markdown(f"# {LABELS['ES']['title']}")
+        subtitle = gr.Markdown(f"*{LABELS['ES']['subtitle']}*")
+
+    with gr.Row():
+        combo = gr.Dropdown(choices=["ES","EN"], value="ES", label=LABELS["ES"]["combo"])
+        direction = gr.Radio(choices=LABELS["ES"]["dir_opts"], value="ES → NI", label=LABELS["ES"]["dir"])
+
+    with gr.Group():
+        doc_header = gr.Markdown(f"## {LABELS['ES']['doc_header']}")
+        acc_titles = LABELS["ES"]["acc_titles"]
+        with gr.Accordion(acc_titles[0], open=False) as acc1:  md1 = gr.Markdown(DOC["ES"][0])
+        with gr.Accordion(acc_titles[1], open=False) as acc2:  md2 = gr.Markdown(DOC["ES"][1])
+        with gr.Accordion(acc_titles[2], open=False) as acc3:  md3 = gr.Markdown(DOC["ES"][2])
+        with gr.Accordion(acc_titles[3], open=False) as acc4:  md4 = gr.Markdown(DOC["ES"][3])
+        with gr.Accordion(acc_titles[4], open=False) as acc5:  md5 = gr.Markdown(DOC["ES"][4])
+        with gr.Accordion(acc_titles[5], open=False) as acc6:  md6 = gr.Markdown(DOC["ES"][5])
+        with gr.Accordion(acc_titles[6], open=False) as acc7:  md7 = gr.Markdown(DOC["ES"][6])
+        with gr.Accordion(acc_titles[7], open=False) as acc8:  md8 = gr.Markdown(DOC["ES"][7])
+        with gr.Accordion(acc_titles[8], open=False) as acc9:  md9 = gr.Markdown(DOC["ES"][8])
+
+    with gr.Group():
+        es_in = gr.Textbox(label=LABELS["ES"]["in_label_es"], placeholder=LABELS["ES"]["in_ph_es"], lines=5)
+        btn_tr = gr.Button(LABELS["ES"]["btn"], variant="primary")
+        with gr.Row():
+            with gr.Column(scale=2):
+                ni_out = gr.Textbox(label=LABELS["ES"]["out_lat_esni"], lines=5, interactive=False)
+                loc_btn = gr.Button("🔊 Locutar", variant="secondary", visible=False)
+                audio_out = gr.Audio(label=LABELS["ES"]["out_audio"], type="numpy")
+            with gr.Column(scale=1):
+                ib_out = gr.HTML(label=LABELS["ES"]["out_ib"])
+
+    def do_translate(text, dir_label):
+        if not text or not text.strip():
+            return (gr.update(value=""),
+                    gr.update(value="<div class='ib-line'></div>"),
+                    gr.update(visible=False),
+                    gr.update(value=None))
+        if dir_label.startswith("ES"):
+            latin, ib = translate(text)
+            ib_html = "<div class='ib-line'>" + escape(ib) + "</div>"
+            return (gr.update(label=LABELS["ES"]["out_lat_esni"], value=latin),
+                    gr.update(value=ib_html),
+                    gr.update(visible=True),
+                    gr.update(value=None))
+        else:
+            es_text = translate_ni_to_es(text)
+            return (gr.update(label=LABELS["ES"]["out_lat_nies"], value=es_text),
+                    gr.update(value="<div class='ib-line'></div>"),
+                    gr.update(visible=False),
+                    gr.update(value=None))
+
+    btn_tr.click(do_translate, [es_in, direction], [ni_out, ib_out, loc_btn, audio_out])
+
+    def run_locution(latin_text, dir_label):
+        if dir_label.startswith("ES"):
+            return synthesize_speech(latin_text)
+        return None
+
+    loc_btn.click(run_locution, [ni_out, direction], audio_out)
+
+    def switch_lang(sel_lang, dir_label):
+        L=LABELS[sel_lang]; T=L["acc_titles"]; D=DOC[sel_lang]
+        # Input/Output labels dependen de la dirección
+        in_label = L["in_label_es"] if dir_label.startswith("ES") else L["in_label_ni"]
+        in_ph    = L["in_ph_es"]    if dir_label.startswith("ES") else L["in_ph_ni"]
+        out_lab  = L["out_lat_esni"] if dir_label.startswith("ES") else L["out_lat_nies"]
+        return (
+            gr.update(value=f"# {L['title']}"),
+            gr.update(value=f"*{L['subtitle']}*"),
+            gr.update(label=L["combo"], value=sel_lang),
+            gr.update(label=L["dir"], choices=L["dir_opts"], value=dir_label),
+            gr.update(value=f"## {L['doc_header']}"),
+            gr.update(label=T[0]), gr.update(value=D[0]),
+            gr.update(label=T[1]), gr.update(value=D[1]),
+            gr.update(label=T[2]), gr.update(value=D[2]),
+            gr.update(label=T[3]), gr.update(value=D[3]),
+            gr.update(label=T[4]), gr.update(value=D[4]),
+            gr.update(label=T[5]), gr.update(value=D[5]),
+            gr.update(label=T[6]), gr.update(value=D[6]),
+            gr.update(label=T[7]), gr.update(value=D[7]),
+            gr.update(label=T[8]), gr.update(value=D[8]),
+            gr.update(label=in_label, placeholder=in_ph),
+            gr.update(label=out_lab),
+            gr.update(label=L["out_ib"]),
+            gr.update(label=L["out_audio"]),
+            gr.update(value=L["btn"])
+        )
+
+    combo.change(
+        switch_lang,
+        [combo, direction],
+        [title, subtitle, combo, direction, doc_header,
+         acc1, md1, acc2, md2, acc3, md3, acc4, md4, acc5, md5, acc6, md6, acc7, md7, acc8, md8, acc9, md9,
+         es_in, ni_out, ib_out, audio_out, btn_tr]
+    )
+
+    def switch_direction(dir_label, sel_lang):
+        # Solo cambia etiquetas y visibilidad de Locutar/Línea ibérica
+        L=LABELS[sel_lang]
+        in_label = L["in_label_es"] if dir_label.startswith("ES") else L["in_label_ni"]
+        in_ph    = L["in_ph_es"]    if dir_label.startswith("ES") else L["in_ph_ni"]
+        out_lab  = L["out_lat_esni"] if dir_label.startswith("ES") else L["out_lat_nies"]
+        # Locución solo para ES → NI
+        loc_vis  = True if dir_label.startswith("ES") else False
+        # Línea ibérica visible solo para ES → NI (tras traducir)
+        return (gr.update(label=in_label, placeholder=in_ph),
+                gr.update(label=out_lab, value=""),
+                gr.update(value="<div class='ib-line'></div>"),
+                gr.update(visible=loc_vis),
+                gr.update(value=None))
+
+    direction.change(
+        switch_direction,
+        [direction, combo],
+        [es_in, ni_out, ib_out, loc_btn, audio_out]
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch()

requirements.txt

@@ -0,0 +1,6 @@
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch==2.3.1
+transformers
+soundfile
+gradio
+sentencepiece