Update app.py

app.py

@@ -1,11 +1,373 @@
 # app.py — Universal Conlang Translator (Max Compresión Exacta)
-# ... (imports iguales)
+# Archivos necesarios en la raíz:
+#  - lexicon_minimax.json
+#  - lexicon_komin.json
+#  - lexicon_master.json
+#
+# requirements.txt (para HF Spaces):
+# gradio>=4.36.0
+# spacy>=3.7.4
+# es_core_news_sm @ https://github.com/explosion/spacy-models/releases/download/es_core_news_sm-3.7.0/es_core_news_sm-3.7.0-py3-none-any.whl
+# en_core_web_sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.1/en_core_web_sm-3.7.1-py3-none-any.whl
 
-# ... (load_lexicons, norm_es, etc. iguales)
+import os
+import re
+import json
+import base64
+import zlib
+import hashlib
+from typing import Dict, Tuple, Optional
+import gradio as gr
 
-# OOV y custom_b64 iguales
+# ------------ Archivos esperados ------------
+LEX_MINI   = "lexicon_minimax.json"
+LEX_KOMI   = "lexicon_komin.json"
+LEX_MASTER = "lexicon_master.json"
 
-# Actualiza b85 a custom_sidecar
+# ------------ Normalización ------------
+WORD_RE = re.compile(r"[A-Za-zÁÉÍÓÚÜÑáéíóúüñ]+", re.UNICODE)
+STRIP = str.maketrans("ÁÉÍÓÚÜÑáéíóúüñ", "AEIOUUNaeiouun")
+
+def norm_es(w: str) -> str:
+    return re.sub(r"[^a-záéíóúüñ]", "", (w or "").lower()).translate(STRIP)
+
+def norm_en(w: str) -> str:
+    return re.sub(r"[^a-z]", "", (w or "").lower())
+
+# ------------ Carga de léxicos ------------
+def load_json(path: str):
+    if not os.path.exists(path): return None
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+def load_lexicons():
+    mm = load_json(LEX_MINI) or {}
+    kk = load_json(LEX_KOMI) or {}
+    master = load_json(LEX_MASTER) or {}
+
+    es2mini = mm.get("mapping", {})
+    es2komi = kk.get("mapping", {})
+    mini2es = {v:k for k,v in es2mini.items()}
+    komi2es = {v:k for k,v in es2komi.items()}
+
+    es2en_lemma: Dict[str,str] = {}
+    en2es_lemma: Dict[str,str] = {}
+    en2mini, en2komi = {}, {}
+    mini2en, komi2en = {}, {}
+
+    if isinstance(master, dict) and "entries" in master:
+        for e in master["entries"]:
+            es = norm_es(str(e.get("lemma_es","")))
+            en = norm_en(str(e.get("lemma_en","")))
+            mi = str(e.get("minimax",""))
+            ko = str(e.get("komin",""))
+            if es and en:
+                es2en_lemma.setdefault(es, en)
+                en2es_lemma.setdefault(en, es)
+            if en and mi: en2mini.setdefault(en, mi)
+            if en and ko: en2komi.setdefault(en, ko)
+
+    mini2en = {v:k for k,v in en2mini.items()}
+    komi2en = {v:k for k,v in en2komi.items()}
+
+    return (es2mini, es2komi, mini2es, komi2es,
+            en2mini, en2komi, mini2en, komi2en,
+            es2en_lemma, en2es_lemma)
+
+(ES2MINI, ES2KOMI, MINI2ES, KOMI2ES,
+ EN2MINI, EN2KOMI, MINI2EN, KOMI2EN,
+ ES2EN_LEMMA, EN2ES_LEMMA) = load_lexicons()
+
+# ------------ OOV reversible (modo Semi-lossless) ------------
+ALPHA_MINI64 = "@ptkmnslraeiouy0123456789><=:/!?.+-_*#bcdfghjvqwxzACEGHIJKLMNOPRS"[:64]
+CJK_BASE = (
+    "天地人日月山川雨風星火水木土金石光影花草鳥犬猫魚"
+    "東西南北中外上下午夜明暗手口目耳心言書家道路門"
+    "大小長短早晚高低新古青紅白黒金銀銅玉米茶酒米"
+    "文学楽音画体気電海空森林雪雲砂島橋城村国自由静"
+)
+ALPHA_CJK64 = (CJK_BASE * 2)[:64]
+
+def to_custom_b64(b: bytes, alphabet: str) -> str:
+    std = base64.b64encode(b).decode("ascii")
+    trans = str.maketrans(
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+        alphabet
+    )
+    return std.translate(trans).rstrip("=")
+
+def from_custom_b64(s: str, alphabet: str) -> bytes:
+    trans = str.maketrans(
+        alphabet,
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+    )
+    std = s.translate(trans)
+    pad = "=" * ((4 - len(std) % 4) % 4)
+    return base64.b64decode(std + pad)
+
+def enc_oov_minimax(token: str) -> str:
+    return "~" + to_custom_b64(token.encode("utf-8"), ALPHA_MINI64)
+def dec_oov_minimax(code: str) -> str:
+    try: return from_custom_b64(code[1:], ALPHA_MINI64).decode("utf-8")
+    except Exception: return code
+
+def enc_oov_komin(token: str) -> str:
+    return "「" + to_custom_b64(token.encode("utf-8"), ALPHA_CJK64) + "」"
+def dec_oov_komin(code: str) -> str:
+    try: return from_custom_b64(code[1:-1], ALPHA_CJK64).decode("utf-8")
+    except Exception: return code
+
+def is_oov_minimax(code: str) -> bool:
+    return code.startswith("~") and len(code) > 1
+def is_oov_komin(code: str) -> bool:
+    return len(code) >= 2 and code.startswith("「") and code.endswith("」")
+
+# ------------ spaCy opcional ------------
+USE_SPACY = False
+try:
+    import spacy
+    try:
+        nlp_es = spacy.load("es_core_news_sm")
+        nlp_en = spacy.load("en_core_web_sm")
+        USE_SPACY = True
+    except Exception:
+        nlp_es = nlp_en = None
+except Exception:
+    nlp_es = nlp_en = None
+
+def lemma_of(tok, src_lang: str) -> str:
+    if src_lang == "Español":
+        return norm_es(tok.lemma_ if tok.lemma_ else tok.text)
+    else:
+        return norm_en(tok.lemma_ if tok.lemma_ else tok.text)
+
+# ------------ Selección de oración predicativa ------------
+def pick_predicative_sentence(doc):
+    sents = list(doc.sents) if doc.has_annotation("SENT_START") else [doc]
+    candidates = []
+    for s in sents:
+        roots = [t for t in s if t.dep_ == "ROOT" and t.pos_ in ("VERB","AUX")]
+        if not roots:
+            continue
+        root = roots[0]
+        has_q = "?" in s.text
+        has_subj = any(t.dep_.startswith("nsubj") for t in root.children)
+        score = (1 if has_q else 0) + (1 if has_subj else 0) + (len(s) / 1000.0)
+        candidates.append((score, s))
+    if not candidates:
+        return doc
+    return sorted(candidates, key=lambda x: x[0], reverse=True)[0][1].as_doc()
+
+def is_content_token(t) -> bool:
+    return True  # No filtra para exactitud
+
+# ------------ Mapeo lema→código ------------
+def code_es(lemma: str, target: str) -> str:
+    lemma = norm_es(lemma)
+    if target == "Minimax-ASCII":
+        return ES2MINI.get(lemma) or enc_oov_minimax(lemma)
+    else:
+        return ES2KOMI.get(lemma) or enc_oov_komin(lemma)
+
+def code_en(lemma: str, target: str) -> str:
+    lemma = norm_en(lemma)
+    if target == "Minimax-ASCII":
+        if EN2MINI: return EN2MINI.get(lemma) or enc_oov_minimax(lemma)
+        return enc_oov_minimax(lemma)
+    else:
+        if EN2KOMI: return EN2KOMI.get(lemma) or enc_oov_komin(lemma)
+        return enc_oov_komin(lemma)
+
+# ------------ Fraseador compacto ------------
+TAM_MINI = {"Pres":"P", "Past":"T", "Fut":"F", "UNK":"P"}
+TAM_KOMI = {"Pres":"Ⓟ", "Past":"Ⓣ", "Fut":"Ⓕ", "UNK":"Ⓟ"}
+
+def detect_polarity(doc) -> bool:
+    return "?" in doc.text
+
+def detect_neg(doc) -> bool:
+    for t in doc:
+        if t.dep_ == "neg" or t.lower_ in ("no","not","n't"):
+            return True
+    return False
+
+def detect_tense(root):
+    m = str(root.morph)
+    if "Tense=Past" in m: return "Past"
+    if "Tense=Fut" in m: return "Fut"
+    if "Tense=Pres" in m: return "Pres"
+    for c in root.children:
+        if c.pos_ == "AUX":
+            cm = str(c.morph)
+            if "Tense=Past" in cm: return "Past"
+            if c.lower_ == "will": return "Fut"
+    return "Pres"
+
+def detect_person(root, src_lang: str) -> Optional[str]:
+    m = str(root.morph)
+    person_str = "3"
+    number_str = "s"
+    if "Person=" in m:
+        for feat in m.split("|"):
+            if feat.startswith("Person="):
+                person_str = feat.split("=")[1]
+            elif feat.startswith("Number="):
+                number_str = "p" if feat.split("=")[1] == "Plur" else "s"
+        return person_str + number_str
+    return _person_of_doc(root.doc, src_lang)
+
+def extract_core(doc):
+    root = next((t for t in doc if t.dep_=="ROOT" and t.pos_ in ("VERB","AUX")), doc[0])
+    subs, objs, obls, advs = [], [], [], []
+    for t in root.children:
+        if t.dep_ in ("nsubj","nsubj:pass","csubj"):
+            subs.append(t)
+        elif t.dep_ in ("obj","dobj","iobj"):
+            objs.append(t)
+        elif t.dep_ in ("obl","pobj"):
+            obls.append(t)
+        elif t.dep_ in ("advmod","advcl") and t.pos_ == "ADV":
+            advs.append(t)
+    subs.sort(key=lambda x: x.i); objs.sort(key=lambda x: x.i)
+    obls.sort(key=lambda x: x.i); advs.sort(key=lambda x: x.i)
+    return root, subs, objs, obls, advs
+
+def _person_of_doc(doc, src_lang: str) -> Optional[str]:
+    try:
+        root = next((t for t in doc if t.dep_=="ROOT"), doc[0])
+        subj = next((t for t in root.children if t.dep_.startswith("nsubj")), None)
+        if subj is None: return None
+        plur = ("Number=Plur" in str(subj.morph)) if src_lang=="Español" else (subj.tag_ in ("NNS","NNPS"))
+        low = subj.lower_
+        if src_lang=="Español":
+            if low in ("yo",): return "1p" if plur else "1s"
+            if low in ("tú","vos"): return "2p" if plur else "2s"
+            if low in ("usted","él","ella"): return "3p" if plur else "3s"
+            lem = lemma_of(subj, "Español")
+            if lem in ("yo","nosotros"): return "1p" if plur else "1s"
+            if lem in ("tú","vosotros"): return "2p" if plur else "2s"
+            return "3p" if plur else "3s"
+        else:
+            if low in ("i",): return "1p" if plur else "1s"
+            if low in ("you",): return "2p" if plur else "2s"
+            if low in ("he","she","it"): return "3p" if plur else "3s"
+            return "3p" if plur else "3s"
+    except Exception:
+        return None
+
+def realize_minimax(doc, src_lang: str, drop_articles=True, zero_copula=True, semi_lossless=False, person_hint="2s"):
+    root, subs, objs, obls, advs = extract_core(doc)
+    tense = detect_tense(root)
+    is_q, is_neg = detect_polarity(doc), detect_neg(doc)
+
+    vlem  = lemma_of(root, src_lang) if USE_SPACY else ("ser" if "?" in doc.text else "estar")
+    vcode = code_es(vlem, "Minimax-ASCII") if src_lang=="Español" else code_en(vlem, "Minimax-ASCII")
+
+    tail = TAM_MINI.get(tense, "P")
+    if semi_lossless:
+        pi = detect_person(root, src_lang) or person_hint
+        tail += pi
+    if is_neg: tail += "N"
+    if is_q:   tail += "Q"
+    if tail:
+        vcode = f"{vcode}·{tail}"
+
+    def realize_np(tokens):
+        outs=[]
+        for t in tokens:
+            if not USE_SPACY or is_content_token(t):
+                lem  = lemma_of(t, src_lang) if USE_SPACY else (t.text)
+                code = code_es(lem, "Minimax-ASCII") if src_lang=="Español" else code_en(lem, "Minimax-ASCII")
+                if semi_lossless and USE_SPACY and (t.tag_ in ("NNS","NNPS") or "Number=Plur" in str(t.morph)):
+                    code = f"{code}[PL]"
+                outs.append(code)
+        return outs
+
+    S = realize_np(subs)
+    O = realize_np(objs) + realize_np(obls)
+    ADV=[]
+    for a in advs:
+        if not USE_SPACY or is_content_token(a):
+            lem  = lemma_of(a, src_lang) if USE_SPACY else a.text
+            ADV.append(code_es(lem, "Minimax-ASCII") if src_lang=="Español" else code_en(lem, "Minimax-ASCII"))
+
+    if zero_copula and not semi_lossless and vlem in ("ser","estar","be") and tense=="Pres" and not is_neg and not is_q:
+        parts = S + O + ADV
+    else:
+        parts = [vcode] + S + O + ADV
+    return " ".join(p for p in parts if p)
+
+def realize_komin(doc, src_lang: str, drop_articles=True, zero_copula=True, semi_lossless=False, person_hint="2s"):
+    root, subs, objs, obls, advs = extract_core(doc)
+    tense, is_q, is_neg = detect_tense(root), detect_polarity(doc), detect_neg(doc)
+
+    vlem  = lemma_of(root, src_lang) if USE_SPACY else ("ser" if "?" in doc.text else "estar")
+    vcode = code_es(vlem, "Kōmín-CJK") if src_lang=="Español" else code_en(vlem, "Kōmín-CJK")
+
+    P_SUBJ, P_OBJ = "ᵖ", "ᵒ"
+    NEG_M, Q_FIN = "̆", "？"
+    TAM = TAM_KOMI.get(tense, "Ⓟ")
+
+    if semi_lossless:
+        pi = detect_person(root, src_lang) or person_hint
+        TAM = TAM + f"[{pi}]"
+
+    def realize_np(tokens, particle):
+        outs=[]
+        for t in tokens:
+            if not USE_SPACY or is_content_token(t):
+                lem  = lemma_of(t, src_lang) if USE_SPACY else t.text
+                code = code_es(lem, "Kōmín-CJK") if src_lang=="Español" else code_en(lem, "Kōmín-CJK")
+                if semi_lossless and USE_SPACY and (t.tag_ in ("NNS","NNPS") or "Number=Plur" in str(t.morph)):
+                    code = f"{code}[PL]"
+                outs.append(code + particle)
+        return outs
+
+    S = realize_np(subs, P_SUBJ)
+    O = realize_np(objs + obls, P_OBJ)
+    ADV=[]
+    for a in advs:
+        if not USE_SPACY or is_content_token(a):
+            lem  = lemma_of(a, src_lang) if USE_SPACY else a.text
+            ADV.append(code_es(lem, "Kōmín-CJK") if src_lang=="Español" else code_en(lem, "Kōmín-CJK"))
+
+    v_form = vcode + TAM + (NEG_M if is_neg else "")
+
+    if zero_copula and not semi_lossless and vlem in ("ser","estar","be") and tense=="Pres" and not is_neg and not is_q:
+        parts = S + O + ADV
+    else:
+        parts = S + O + ADV + [v_form]
+    out = " ".join(parts)
+    if is_q: out += " " + Q_FIN
+    return out
+
+# ------------ Lossless (Base85 comprimido) ------------
+SIDECAR_B85_RE = re.compile(r"\s?§\((?P<b85>[A-Za-z0-9!#$%&()*+\-;<=>?@^_`{|}~]+)\)$")
+
+def b85_enc_raw(s: str) -> str:
+    comp = zlib.compress(s.encode("utf-8"), 9)
+    return base64.a85encode(comp, adobe=False).decode("ascii")
+
+def b85_dec_raw(b85s: str) -> str:
+    comp = base64.a85decode(b85s.encode("ascii"), adobe=False)
+    return zlib.decompress(comp).decode("utf-8")
+
+def attach_sidecar_b85(conlang_text: str, original_text: str) -> str:
+    blob = b85_enc_raw(original_text)
+    return f"{conlang_text} §({blob})"
+
+def extract_sidecar_b85(text: str) -> Optional[str]:
+    m = SIDECAR_B85_RE.search(text)
+    if not m: return None
+    try:
+        return b85_dec_raw(m.group("b85"))
+    except Exception:
+        return None
+
+def strip_sidecar_b85(text: str) -> str:
+    return SIDECAR_B85_RE.sub("", text).rstrip()
+
+# ------------ Custom sidecar para max compresión exacta ------------
 def custom_sidecar_enc(conlang_text: str, original_text: str) -> str:
     comp = zlib.compress(original_text.encode("utf-8"), 9)
     blob = to_custom_b64(comp, ALPHA_MINI64)
@@ -24,78 +386,431 @@ def extract_custom_sidecar(text: str) -> Optional[str]:
 def strip_custom_sidecar(text: str) -> str:
     return text.split('~')[0].rstrip() if '~' in text else text
 
-# Actualiza is_content_token: permite TODO para exactitud
-def is_content_token(t) -> bool:
-    return True  # No filtra nada; todo se codifica
+# ------------ Codificar / Decodificar léxico puro ------------
+def encode_simple(text: str, src_lang: str, target: str) -> str:
+    if not text.strip(): return ""
+    def repl_es(m):
+        key = norm_es(m.group(0))
+        code = ES2MINI.get(key) if target=="Minimax-ASCII" else ES2KOMI.get(key)
+        return code or (enc_oov_minimax(m.group(0)) if target=="Minimax-ASCII" else enc_oov_komin(m.group(0)))
+    def repl_en(m):
+        key = norm_en(m.group(0))
+        table = EN2MINI if target=="Minimax-ASCII" else EN2KOMI
+        if table and key in table:
+            return table[key]
+        return enc_oov_minimax(m.group(0)) if target=="Minimax-ASCII" else enc_oov_komin(m.group(0))
+    repl = repl_es if src_lang=="Español" else repl_en
+    return WORD_RE.sub(repl, text)
+
+def pluralize_es(word: str) -> str:
+    exceptions = {"uno": "unos", "buen": "buenos", "hombre": "hombres"}
+    if word in exceptions: return exceptions[word]
+    if word.endswith("z"): return word[:-1] + "ces"
+    if word.endswith(("a", "e", "i", "o")): return word + "s"
+    return word + "es"
+
+def pluralize_en(word: str) -> str:
+    exceptions = {"man": "men", "woman": "women", "child": "children"}
+    if word in exceptions: return exceptions[word]
+    if word.endswith("y") and len(word) > 1 and word[-2] not in "aeiou": return word[:-1] + "ies"
+    if word.endswith(("s", "sh", "ch", "x", "z")): return word + "es"
+    return word + "s"
+
+def pluralize(word: str, tgt_lang: str) -> str:
+    return pluralize_es(word) if tgt_lang == "Español" else pluralize_en(word)
+
+PRON_ES = {"yo", "tú", "él", "ella", "nosotros", "vosotros", "ellos", "ellas", "usted", "ustedes"}
+PRON_EN = {"i", "you", "he", "she", "it", "we", "they"}
+
+mini_tail_re = re.compile(r"^(?P<stem>.+?)·(?P<tail>[PTFNQ12sp]+)$")
 
-# Actualiza realize_minimax: incluye todos los tokens (saludos, wh, etc.)
-def realize_minimax(doc, src_lang: str, drop_articles=True, zero_copula=True, semi_lossless=False, person_hint="2s"):
-    # Split full text into tokens (incluye punct)
-    tokens = re.findall(r"\S+", doc)  # No filtra; todo
-    if not tokens: return ""
-    # Asume primer verbo-ish para hints (simple)
-    v_idx = next((i for i, t in enumerate(tokens) if t.lower() in ["estás", "eres", "soy", "estar", "ser"]), 0)
-    parts = []
-    for i, t in enumerate(tokens):
-        lem = t.lower().rstrip('?¿!¡.,;')  # Limpia punct para code, añade después
-        punct = t[len(lem):] if len(t) > len(lem) else ""
-        code = code_es(lem, "Minimax-ASCII") if src_lang=="Español" else code_en(lem, "Minimax-ASCII")
-        if i == v_idx and semi_lossless:
-            tense = "P"  # Detect simple
-            pi = "2s"  # Asume
-            tail = f"{tense}{pi}Q" if "?" in doc else f"{tense}{pi}"
-            code = f"{code}·{tail}"
-        parts.append(code + punct)
-    return " ".join(parts)
-
-# Decode: simple reverse para semi, pero sidecar para exact
 def decode_simple(text: str, source: str, tgt_lang: str) -> str:
-    # Para semi: reverse tokens, conjuga si ·tail
+    if not text.strip(): 
+        return ""
+    code2es = MINI2ES if source=="Minimax-ASCII" else KOMI2ES
+    code2en = MINI2EN if source=="Minimax-ASCII" else KOMI2EN
+    pron_set = PRON_ES if tgt_lang == "Español" else PRON_EN
+
+    if source == "Kōmín-CJK":
+        text = text.replace("？", "?").replace(" ", " ")
+        return " ".join([code2es.get(w, w) for w in text.split() if w != "?"])
+
     tokens = text.split()
-    out = []
-    for part in tokens:
-        m = mini_tail_re.match(part.rstrip('?¿!¡.,;'))
+    if not tokens: return ""
+
+    lemma_tokens = []
+    pl_flags = []
+    verb_idx = -1
+    verb_lemma = None
+    verb_tense = "Pres"
+    verb_person = "3s"
+    has_q = False
+    is_neg = False
+
+    for i, part in enumerate(tokens):
+        look = part.replace("[PL]", "")
+        had_pl = "[PL]" in part
+        pl_flags.append(had_pl)
+
+        m = mini_tail_re.match(look)
         if m:
+            verb_idx = len(lemma_tokens)
             stem = m.group("stem")
             tail = m.group("tail")
-            vlem = MINI2ES.get(stem, dec_oov_minimax(stem)) if tgt_lang == "Español" else MINI2EN.get(stem, stem)
-            # Conjuga simple
-            v_conj = _es_conj(vlem, "Pres", "2s") if tgt_lang == "Español" else _en_conj(vlem, "Pres", "2s")
-            out.append(v_conj)
-            if "Q" in tail:
-                out[-1] += "?"
-        else:
-            w = MINI2ES.get(part.rstrip('?¿!¡.,;'), dec_oov_minimax(part)) if tgt_lang == "Español" else part
-            out.append(w + (part[-1] if part[-1] in '?¿!¡.,;' else ''))
-    out_text = " ".join(out)
-    if "?" in text:
-        out_text = f"¿{out_text}?"
+            vlem_es = code2es.get(stem)
+            vlem_en = code2en.get(stem) if code2en else None
+            vlem = vlem_es if tgt_lang == "Español" else (vlem_en or vlem_es or stem)
+            if not vlem:
+                if is_oov_minimax(stem):
+                    vlem = dec_oov_minimax(stem)
+                else:
+                    vlem = stem
+            lemma_tokens.append(vlem)
+            pl_flags.append(False)
+
+            # Parse tail
+            if tail:
+                if len(tail) > 0 and tail[0] in "PTF":
+                    verb_tense = {"P": "Pres", "T": "Past", "F": "Fut"}.get(tail[0], "Pres")
+                    pos = 1
+                    person = "3s"
+                    if len(tail) > pos and tail[pos] in "123":
+                        pos += 1
+                        if len(tail) > pos and tail[pos] in "sp":
+                            person = tail[pos-1] + tail[pos]
+                            pos += 1
+                        else:
+                            person = tail[pos-1] + "s"
+                        verb_person = person
+                    is_neg = "N" in tail[pos:]
+                    has_q = "Q" in tail[pos:]
+            verb_lemma = vlem
+            continue
+
+        # No verbo
+        w_es = code2es.get(look)
+        w_en = code2en.get(look) if code2en else None
+        w = w_es if tgt_lang == "Español" else (w_en or w_es or look)
+        if not w:
+            if is_oov_minimax(look):
+                w = dec_oov_minimax(look)
+            else:
+                w = look
+        lemma_tokens.append(w)
+        pl_flags.append(had_pl)
+
+    if verb_idx == -1:
+        # Fallback zero copula
+        verb_lemma = "ser" if tgt_lang == "Español" else "be"
+        verb_tense = "Pres"
+        verb_person = "3s"
+        v_conj = _es_conj(verb_lemma, verb_tense, verb_person) if tgt_lang == "Español" else _en_conj(verb_lemma, verb_tense, verb_person)
+        lemma_tokens.insert(1 if lemma_tokens else 0, v_conj)
+        out_text = " ".join(lemma_tokens)
+    else:
+        # Conjuga
+        conj_func = _es_conj if tgt_lang == "Español" else _en_conj
+        v_conj = conj_func(verb_lemma, verb_tense, verb_person)
+        if is_neg:
+            neg_prefix = "no " if tgt_lang == "Español" else "not "
+            v_conj = neg_prefix + v_conj
+
+        # Reordena SVO
+        post_v = lemma_tokens[verb_idx + 1:]
+        pl_post = pl_flags[verb_idx + 1:]
+        s_idx = next((j for j, w in enumerate(post_v) if w.lower() in pron_set), None)
+        S = post_v[s_idx] if s_idx is not None else None
+        if S:
+            if pl_post[s_idx]:
+                S = pluralize(S, tgt_lang)
+            del post_v[s_idx]
+            del pl_post[s_idx]
+
+        O_ADV = []
+        if post_v:
+            O = pluralize(post_v[0], tgt_lang) if pl_post[0] else post_v[0]
+            O_ADV.append(O)
+            O_ADV.extend([pluralize(post_v[k], tgt_lang) if pl_post[k] else post_v[k] for k in range(1, len(post_v))])
+
+        parts = [p for p in [S, v_conj] + O_ADV if p]
+        out_text = " ".join(parts)
+
+    # Wh en Q: si primer token es wh, muévelo al frente
+    if has_q and lemma_tokens and lemma_tokens[0].lower() in {"como", "cómo", "what", "how"}:
+        wh = lemma_tokens.pop(0)
+        out_text = f"{wh} {out_text}"
+
+    # Pregunta
+    if has_q:
+        start_q = "¿" if tgt_lang == "Español" else ""
+        end_q = "?" if tgt_lang == "Español" else "?"
+        out_text = f"{start_q}{out_text.capitalize()}{end_q}"
+
     return out_text
 
-# Actualiza build_sentence y universal_translate
-def build_sentence(text: str, src_lang: str, target: str, drop_articles: bool, zero_copula: bool, mode: str, max_comp_exact: bool = False) -> str:
+# ------------ Conjugadores mínimos ------------
+_ES_SUBJ = {"1s":"yo","2s":"tú","3s":"él/ella","1p":"nosotros","2p":"vosotros","3p":"ellos"}
+_EN_SUBJ = {"1s":"I","2s":"you","3s":"he","1p":"we","2p":"you","3p":"they"}
+
+def _es_conj_regular(lemma, tense, person):
+    if not lemma.endswith(("ar","er","ir")): return lemma
+    stem = lemma[:-2]; vtype = lemma[-2:]
+    pres = {
+        "ar": {"1s":"o","2s":"as","3s":"a","1p":"amos","2p":"áis","3p":"an"},
+        "er": {"1s":"o","2s":"es","3s":"e","1p":"emos","2p":"éis","3p":"en"},
+        "ir": {"1s":"o","2s":"es","3s":"e","1p":"imos","2p":"ís","3p":"en"},
+    }
+    pret = {
+        "ar": {"1s":"é","2s":"aste","3s":"ó","1p":"amos","2p":"asteis","3p":"aron"},
+        "er": {"1s":"í","2s":"iste","3s":"ió","1p":"imos","2p":"isteis","3p":"ieron"},
+        "ir": {"1s":"í","2s":"iste","3s":"ió","1p":"imos","2p":"isteis","3p":"ieron"},
+    }
+    fut = {"1s":"é","2s":"ás","3s":"á","1p":"emos","2p":"éis","3p":"án"}
+    if tense == "Pres": return stem + pres[vtype].get(person, pres[vtype]["3s"])
+    if tense == "Past": return stem + pret[vtype].get(person, pret[vtype]["3s"])
+    return lemma + fut.get(person, fut["3s"])
+
+def _es_conj(lemma, tense, person):
+    if lemma == "ser":
+        tab = {
+            "Pres":{"1s":"soy","2s":"eres","3s":"es","1p":"somos","2p":"sois","3p":"son"},
+            "Past":{"1s":"fui","2s":"fuiste","3s":"fue","1p":"fuimos","2p":"fuisteis","3p":"fueron"},
+            "Fut":{"1s":"seré","2s":"serás","3s":"será","1p":"seremos","2p":"seréis","3p":"serán"},
+        }; return tab[tense].get(person, tab[tense]["3s"])
+    if lemma == "estar":
+        tab = {
+            "Pres":{"1s":"estoy","2s":"estás","3s":"está","1p":"estamos","2p":"estáis","3p":"están"},
+            "Past":{"1s":"estuve","2s":"estuviste","3s":"estuvo","1p":"estuvimos","2p":"estuvisteis","3p":"estuvieron"},
+            "Fut":{"1s":"estaré","2s":"estarás","3s":"estará","1p":"estaremos","2p":"estaréis","3p":"estarán"},
+        }; return tab[tense].get(person, tab[tense]["3s"])
+    if lemma == "ir":
+        tab = {
+            "Pres":{"1s":"voy","2s":"vas","3s":"va","1p":"vamos","2p":"vais","3p":"van"},
+            "Past":{"1s":"fui","2s":"fuiste","3s":"fue","1p":"fuimos","2p":"fuisteis","3p":"fueron"},
+            "Fut":{"1s":"iré","2s":"irás","3s":"irá","1p":"iremos","2p":"iréis","3p":"irán"},
+        }; return tab[tense].get(person, tab[tense]["3s"])
+    return _es_conj_regular(lemma, tense, person)
+
+def _en_conj(lemma, tense, person):
+    if lemma == "be":
+        if tense == "Pres":
+            return {"1s":"am","2s":"are","3s":"is","1p":"are","2p":"are","3p":"are"}.get(person, "is")
+        if tense == "Past":
+            return {"1s":"was","2s":"were","3s":"was","1p":"were","2p":"were","3p":"were"}.get(person, "was")
+        return "be"
+    if lemma == "have":
+        if tense == "Pres": return "has" if person=="3s" else "have"
+        if tense == "Past": return "had"
+        return "have"
+    if lemma == "go":
+        if tense == "Past": return "went"
+        return "goes" if (tense=="Pres" and person=="3s") else "go"
+    if lemma == "do":
+        if tense == "Past": return "did"
+        return "does" if (tense=="Pres" and person=="3s") else "do"
+
+    if tense == "Pres":
+        if person == "3s":
+            if lemma.endswith("y") and (len(lemma)<2 or lemma[-2] not in "aeiou"):
+                return lemma[:-1] + "ies"
+            if lemma.endswith(("s","sh","ch","x","z","o")):
+                return lemma + "es"
+            return lemma + "s"
+        return lemma
+    elif tense == "Past":
+        if lemma.endswith("e"): return lemma + "d"
+        if lemma.endswith("y") and (len(lemma)<2 or lemma[-2] not in "aeiou"): return lemma[:-1] + "ied"
+        return lemma + "ed"
+    else:
+        return lemma
+
+# ------------ Semi-lossless (rutas) ------------
+def _build_with_spacy(text: str, src_lang: str, target: str,
+                      drop_articles: bool, zero_copula: bool, semi_lossless: bool) -> str:
+    nlp = nlp_es if src_lang=="Español" else nlp_en
+    doc = nlp(text)
+    if target == "Minimax-ASCII":
+        return realize_minimax(doc, src_lang, drop_articles, zero_copula, semi_lossless=semi_lossless)
+    else:
+        return realize_komin(doc, src_lang, drop_articles, zero_copula, semi_lossless=semi_lossless)
+
+def build_sentence(text: str, src_lang: str, target: str,
+                   drop_articles: bool, zero_copula: bool, mode: str, max_comp_exact: bool = False) -> str:
     if not text.strip(): return ""
-    semi = True
-    core = realize_minimax(text, src_lang, drop_articles, zero_copula, semi) if USE_SPACY else encode_simple(text, src_lang, target)  # Usa realize para full include
+    semi = True  # Siempre semi-lossless
+    core = _build_with_spacy(text, src_lang, target, drop_articles, zero_copula and not semi, semi_lossless=semi) if USE_SPACY else encode_simple(text, src_lang, target)
     if max_comp_exact:
         return custom_sidecar_enc(core, text)
     return core
 
-def universal_translate(text: str, src: str, tgt: str, drop_articles: bool, zero_copula: bool, mode: str, max_comp_exact: bool = False) -> str:
+def universal_translate(text: str, src: str, tgt: str,
+                        drop_articles: bool, zero_copula: bool,
+                        mode: str, max_comp_exact: bool = False) -> str:
     if not text.strip(): return ""
     if src == tgt: return text
+
+    # Natural → Conlang
     if src in ("Español","English") and tgt in ("Minimax-ASCII","Kōmín-CJK"):
         return build_sentence(text, src, tgt, drop_articles, zero_copula, mode, max_comp_exact)
+
+    # Conlang → Natural (considera sidecars)
     if src in ("Minimax-ASCII","Kōmín-CJK") and tgt in ("Español","English"):
+        # Custom sidecar para exact
         orig = extract_custom_sidecar(text)
         if orig is not None: return orig
-        return decode_simple(strip_custom_sidecar(text), src, tgt)
-    # Resto igual...
+        # Fallback b85 si hay
+        orig = extract_sidecar_b85(text)
+        if orig is not None: return orig
+        # Semi-lossless
+        return decode_simple(strip_custom_sidecar(strip_sidecar_b85(text)), src, tgt)
+
+    # Natural ↔ Natural (lemas)
+    if src in ("Español","English") and tgt in ("Español","English"):
+        return translate_natural(text, src, tgt)
+
+    # Conlang ↔ Conlang (simplificado)
+    if src in ("Minimax-ASCII","Kōmín-CJK") and tgt in ("Minimax-ASCII","Kōmín-CJK"):
+        orig = extract_custom_sidecar(text)
+        if orig is not None:
+            # Preserva sidecar
+            core = strip_custom_sidecar(text)
+            es_lemmas = decode_simple(core, src, "Español")
+            words = re.findall(r"\w+|[^\w\s]+", es_lemmas)
+            out=[]
+            for w in words:
+                if re.fullmatch(r"\w+", w):
+                    code = ES2MINI.get(norm_es(w)) if tgt=="Minimax-ASCII" else ES2KOMI.get(norm_es(w))
+                    if not code:
+                        code = enc_oov_minimax(w) if tgt=="Minimax-ASCII" else enc_oov_komin(w)
+                    out.append(code)
+                else:
+                    out.append(w)
+            out_text = " ".join(out)
+            return custom_sidecar_enc(out_text, orig)
+        # Sin sidecar, normal
+        core = text
+        es_lemmas = decode_simple(core, src, "Español")
+        words = re.findall(r"\w+|[^\w\s]+", es_lemmas)
+        out=[]
+        for w in words:
+            if re.fullmatch(r"\w+", w):
+                code = ES2MINI.get(norm_es(w)) if tgt=="Minimax-ASCII" else ES2KOMI.get(norm_es(w))
+                if not code:
+                    code = enc_oov_minimax(w) if tgt=="Minimax-ASCII" else enc_oov_komin(w)
+                out.append(code)
+            else:
+                out.append(w)
+        return " ".join(out)
+
+    return "[No soportado]"
+
+def translate_natural(text: str, src_lang: str, tgt_lang: str) -> str:
+    if not text.strip(): return ""
+    if not USE_SPACY: return text
+    nlp = nlp_es if src_lang=="Español" else nlp_en
+    doc = nlp(text)
+    out=[]
+    for t in doc:
+        if not t.is_alpha:
+            out.append(t.text); continue
+        lem = lemma_of(t, src_lang)
+        if src_lang=="Español":
+            tr = ES2EN_LEMMA.get(lem)
+            out.append(tr if tr else lem)
+        else:
+            tr = EN2ES_LEMMA.get(lem)
+            out.append(tr if tr else lem)
+    return " ".join(out)
+
+def round_trip(text, src, tgt, mode, max_comp_exact):
+    conlang = universal_translate(text, src, tgt, True, False, mode, max_comp_exact)
+    back    = universal_translate(conlang, tgt, src, True, False, mode, max_comp_exact)
+    return conlang, back
+
+# ------------ UI y explicaciones ------------
+EXPLAIN_ES = """
+**Modo único: Semi-lossless** — Compacto con hints para reconstruir orden/morfología. Round-trip fiable (~90%). Activa "Max Compresión Exacta" para 100% exacto con sidecar oculto (~40% ahorro avg).
+**Conlangs**: Minimax (VSO, ·TAMpersonNQ), Kōmín (SOV, ᵖ/ᵒ Ⓟ[2s]̆？).
+"""
+
+ALL_LANGS = ["Español","English","Minimax-ASCII","Kōmín-CJK"]
+
+with gr.Blocks(title="Universal Conlang Translator") as demo:
+    gr.Markdown("# Universal Conlang Translator · Max Compresión Exacta")
+    gr.Markdown(EXPLAIN_ES)
+
+    # --- Traducir (universal) ---
+    with gr.Tab("Traducir"):
+        with gr.Row():
+            uni_src = gr.Dropdown(ALL_LANGS, value="Español", label="Fuente")
+            uni_tgt = gr.Dropdown(ALL_LANGS, value="Minimax-ASCII", label="Destino")
+        uni_text = gr.Textbox(lines=3, label="Texto", value="Hola, ¿cómo estás?")
+        with gr.Row():
+            uni_drop = gr.Checkbox(value=True, label="Omitir artículos (ES/EN→conlang)")
+            uni_zero = gr.Checkbox(value=False, label="Cópula cero (presente afirm.) (ES/EN→conlang)")
+            uni_max_comp = gr.Checkbox(value=False, label="Max Compresión Exacta (sidecar oculto)")
+        uni_mode = gr.Dropdown(["Semi-lossless"], value="Semi-lossless", visible=False)
+        uni_out = gr.Textbox(lines=6, label="Traducción")
+        gr.Button("Traducir").click(
+            universal_translate,
+            [uni_text, uni_src, uni_tgt, uni_drop, uni_zero, uni_mode, uni_max_comp],
+            [uni_out]
+        )
+
+    # --- Construir frase (ES/EN → Conlang) ---
+    with gr.Tab("Construir frase (ES/EN → Conlang)"):
+        with gr.Row():
+            src_lang = gr.Dropdown(["Español","English"], value="Español", label="Fuente")
+            target = gr.Dropdown(["Minimax-ASCII","Kōmín-CJK"], value="Minimax-ASCII", label="Conlang")
+        text_in = gr.Textbox(lines=3, label="Frase", value="Hola, ¿cómo estás?")
+        with gr.Row():
+            drop_articles = gr.Checkbox(value=True, label="Omitir artículos")
+            zero_copula   = gr.Checkbox(value=False, label="Cópula cero (presente afirm.)")
+            max_comp_build = gr.Checkbox(value=False, label="Max Compresión Exacta (sidecar oculto)")
+        mode_build = gr.Dropdown(["Semi-lossless"], value="Semi-lossless", visible=False)
+        out = gr.Textbox(lines=6, label="Salida")
+        gr.Button("Construir").click(
+            build_sentence,
+            [text_in, src_lang, target, drop_articles, zero_copula, mode_build, max_comp_build],
+            [out]
+        )
+
+    # --- Decodificar (Conlang → ES/EN) ---
+    with gr.Tab("Decodificar (Conlang → ES/EN)"):
+        with gr.Row():
+            src_code = gr.Dropdown(["Minimax-ASCII","Kōmín-CJK"], value="Minimax-ASCII", label="Fuente")
+            tgt_lang = gr.Dropdown(["Español","English"], value="Español", label="Destino")
+        code_in = gr.Textbox(lines=3, label="Texto en conlang (incluye ~blob si procede)")
+        out3 = gr.Textbox(lines=6, label="Salida")
+
+        def decode_lossless_aware(text, src, tgt):
+            orig = extract_custom_sidecar(text)
+            if orig is not None: return orig
+            orig = extract_sidecar_b85(text)
+            if orig is not None: return orig
+            return decode_simple(strip_custom_sidecar(strip_sidecar_b85(text)), src, tgt)
+
+        gr.Button("Decodificar").click(
+            decode_lossless_aware, [code_in, src_code, tgt_lang], [out3]
+        )
 
-# UI: cambia checkbox a "Max Compresión Exacta (sidecar oculto)"
-# En tabs: uni_max_comp = gr.Checkbox(value=False, label="Max Compresión Exacta")
-# Click: universal_translate(..., uni_max_comp)
+    # --- Round-trip ---
+    with gr.Tab("Prueba ida→vuelta"):
+        with gr.Row():
+            rt_src = gr.Dropdown(["Español","English"], value="Español", label="Fuente")
+            rt_tgt = gr.Dropdown(["Minimax-ASCII","Kōmín-CJK"], value="Minimax-ASCII", label="Conlang")
+        rt_text = gr.Textbox(lines=3, label="Frase", value="Hola, ¿cómo estás?")
+        rt_max_comp = gr.Checkbox(value=False, label="Max Compresión Exacta")
+        rt_mode = gr.Dropdown(["Semi-lossless"], value="Semi-lossless", visible=False)
+        rt_out_conlang = gr.Textbox(lines=3, label="Conlang (ida)")
+        rt_out_back    = gr.Textbox(lines=3, label="Vuelta")
+        gr.Button("Probar").click(
+            round_trip,
+            [rt_text, rt_src, rt_tgt, rt_mode, rt_max_comp],
+            [rt_out_conlang, rt_out_back]
+        )
 
-# Resto del código (conjugadores, UI) igual al anterior
+if __name__ == "__main__":
+    demo.launch()