primocode 7.18.0 → 8.0.1

package/studio/server.py

@@ -0,0 +1,862 @@
+#!/usr/bin/env python3
+"""
+PrimoCode Studio — suíte de criação operada por IA.
+
+    python3 server.py            # http://localhost:7777
+    python3 server.py 8080
+
+Só biblioteca padrão do Python. Nada para instalar.
+"""
+
+import base64
+import functools
+import json
+import mimetypes
+import os
+import re
+import sys
+import unicodedata
+import uuid
+from datetime import datetime, timezone
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import urlparse, unquote
+
+RAIZ = os.path.dirname(os.path.abspath(__file__))
+WEB = os.path.join(RAIZ, "web")
+ARQUIVOS = os.path.join(RAIZ, "arquivos")
+FERRAMENTAS = os.path.join(RAIZ, "ferramentas")
+MIDIA = os.path.join(RAIZ, "midia")
+PORTA = int(sys.argv[1]) if len(sys.argv) > 1 else 7777
+
+# 60 MB por arquivo: cobre faixa longa em mp3 e foto de câmera sem susto
+LIMITE_MIDIA = 60 * 1024 * 1024
+
+os.makedirs(ARQUIVOS, exist_ok=True)
+os.makedirs(MIDIA, exist_ok=True)
+
+
+# ------------------------------------------------------------- ferramentas --
+
+FERRAMENTAS_INFO = [
+    {
+        "slug": "prisma",
+        "nome": "Prisma",
+        "papel": "Apresentações",
+        "equivale": "PowerPoint, Keynote, Canva Apresentações",
+        "modelo": "cena",
+        "resumo": "Decks com layouts automáticos, temas, animação de entrada, notas do apresentador e export em PDF.",
+        "cor": "#FF5A36",
+    },
+    {
+        "slug": "tela",
+        "nome": "Tela",
+        "papel": "Design gráfico",
+        "equivale": "Photoshop, Figma, Canva",
+        "modelo": "cena",
+        "resumo": "Artes em canvas livre com camadas, formas, texto, imagens, gradientes e sombras. Post, capa, banner, thumbnail.",
+        "cor": "#8B5CF6",
+    },
+    {
+        "slug": "prosa",
+        "nome": "Prosa",
+        "papel": "Documentos",
+        "equivale": "Word, Google Docs, Notion",
+        "modelo": "documento",
+        "resumo": "Textos longos com hierarquia, citações, listas, tabelas, capa e sumário. Export em HTML e Markdown.",
+        "cor": "#2E9E6B",
+    },
+    {
+        "slug": "grade",
+        "nome": "Grade",
+        "papel": "Planilhas",
+        "equivale": "Excel, Google Sheets",
+        "modelo": "planilha",
+        "resumo": "Tabelas com fórmulas, formatação condicional, totais e gráficos. Export em CSV.",
+        "cor": "#1F8FE0",
+    },
+    {
+        "slug": "corte",
+        "nome": "Corte",
+        "papel": "Vídeo",
+        "equivale": "CapCut, Premiere, After Effects",
+        "modelo": "cena",
+        "resumo": "Montagem por cenas com duração, transições e animação. Reproduz no navegador e grava .webm.",
+        "cor": "#E0397A",
+    },
+    {
+        "slug": "traco",
+        "nome": "Traço",
+        "papel": "Diagramas",
+        "equivale": "Miro, Whimsical, Lucidchart",
+        "modelo": "cena",
+        "resumo": "Fluxos, mapas mentais, arquiteturas e organogramas com nós e conectores que se ligam sozinhos.",
+        "cor": "#D9A21B",
+    },
+]
+
+POR_SLUG = {f["slug"]: f for f in FERRAMENTAS_INFO}
+
+
+# -------------------------------------------------------------- utilidades --
+
+def _normaliza(texto, tamanho):
+    """NFKD → ASCII → não-alfanumérico vira hífen → minúsculo → corta.
+    Compartilhada por slugify() e nome_seguro(), que faziam a mesma conta
+    com um corte de tamanho diferente cada uma."""
+    texto = unicodedata.normalize("NFKD", texto or "").encode("ascii", "ignore").decode()
+    texto = re.sub(r"[^a-zA-Z0-9]+", "-", texto).strip("-").lower()
+    return (texto or "arquivo")[:tamanho]
+
+
+def slugify(texto):
+    return _normaliza(texto, 40)
+
+
+def caminho(arq_id):
+    if not re.fullmatch(r"[a-z0-9\-]{1,72}", arq_id or ""):
+        return None
+    return os.path.join(ARQUIVOS, arq_id + ".json")
+
+
+def ler(arq_id):
+    c = caminho(arq_id)
+    if not c or not os.path.exists(c):
+        return None
+    with open(c, encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+def gravar(arq):
+    arq["atualizado"] = datetime.now(timezone.utc).isoformat(timespec="seconds")
+    with open(caminho(arq["id"]), "w", encoding="utf-8") as fh:
+        json.dump(arq, fh, ensure_ascii=False, indent=2)
+    return arq
+
+
+def listar():
+    saida = []
+    for nome in os.listdir(ARQUIVOS):
+        if not nome.endswith(".json"):
+            continue
+        try:
+            with open(os.path.join(ARQUIVOS, nome), encoding="utf-8") as fh:
+                a = json.load(fh)
+            doc = a.get("doc") or {}
+            saida.append({
+                "id": a["id"],
+                "titulo": a.get("titulo", "Sem título"),
+                "ferramenta": a.get("ferramenta", "prisma"),
+                "pecas": len(doc.get("cenas") or doc.get("blocos") or doc.get("abas") or []),
+                "atualizado": a.get("atualizado", ""),
+            })
+        except Exception:
+            pass
+    return sorted(saida, key=lambda a: a["atualizado"], reverse=True)
+
+
+# ------------------------------------------------------------------ mídia --
+
+TIPOS_OK = {
+    ".png": "imagem", ".jpg": "imagem", ".jpeg": "imagem", ".gif": "imagem",
+    ".webp": "imagem", ".svg": "imagem", ".avif": "imagem",
+    ".mp3": "audio", ".m4a": "audio", ".wav": "audio", ".ogg": "audio",
+    ".aac": "audio", ".flac": "audio", ".opus": "audio", ".weba": "audio",
+    ".mp4": "video", ".webm": "video", ".mov": "video",
+}
+
+# .weba é WebM só com áudio — é o que sai da gravação de voz pelo microfone
+mimetypes.add_type("audio/webm", ".weba")
+mimetypes.add_type("audio/mp4", ".m4a")
+
+
+def nome_seguro(nome):
+    base, ext = os.path.splitext(nome or "arquivo")
+    return _normaliza(base, 48), ext.lower()
+
+
+def listar_midia():
+    fora = []
+    for nome in sorted(os.listdir(MIDIA)):
+        ext = os.path.splitext(nome)[1].lower()
+        if ext not in TIPOS_OK:
+            continue
+        caminho_arq = os.path.join(MIDIA, nome)
+        fora.append({
+            "nome": nome,
+            "url": "/midia/" + nome,
+            "tipo": TIPOS_OK[ext],
+            "bytes": os.path.getsize(caminho_arq),
+        })
+    return sorted(fora, key=lambda m: m["nome"])
+
+
+def guardar_midia(dados):
+    """Recebe {nome, dados:"data:...;base64,..."} e grava em midia/."""
+    bruto = dados.get("dados") or ""
+    m = re.match(r"^data:([^;]*);base64,(.*)$", bruto, re.S)
+    if not m:
+        return {"erro": "envie 'dados' como data URI base64"}, 400
+
+    base, ext = nome_seguro(dados.get("nome"))
+    if ext not in TIPOS_OK:
+        adivinhado = mimetypes.guess_extension(m.group(1) or "") or ""
+        ext = adivinhado.lower()
+        if ext not in TIPOS_OK:
+            return {"erro": "formato não aceito", "aceitos": sorted(TIPOS_OK)}, 400
+
+    try:
+        conteudo = base64.b64decode(m.group(2), validate=True)
+    except Exception:
+        return {"erro": "base64 inválido"}, 400
+
+    if len(conteudo) > LIMITE_MIDIA:
+        return {"erro": "arquivo acima de %d MB" % (LIMITE_MIDIA // 1048576)}, 413
+
+    nome = base + ext
+    if os.path.exists(os.path.join(MIDIA, nome)):
+        nome = base + "-" + uuid.uuid4().hex[:4] + ext
+    with open(os.path.join(MIDIA, nome), "wb") as fh:
+        fh.write(conteudo)
+
+    return {"nome": nome, "url": "/midia/" + nome,
+            "tipo": TIPOS_OK[ext], "bytes": len(conteudo)}, 201
+
+
+def criar(dados):
+    # O cliente é um agente de IA falando JSON cru — um tipo errado aqui
+    # (titulo como lista, por exemplo) não pode virar AttributeError sem
+    # resposta HTTP nenhuma; melhor um 400 com o motivo.
+    ferramenta_bruta = dados.get("ferramenta")
+    if ferramenta_bruta is not None and not isinstance(ferramenta_bruta, str):
+        raise ValueError("ferramenta precisa ser texto")
+    ferramenta = (ferramenta_bruta or "prisma").lower()
+    if ferramenta not in POR_SLUG:
+        return None
+
+    titulo_bruto = dados.get("titulo")
+    if titulo_bruto is not None and not isinstance(titulo_bruto, str):
+        raise ValueError("titulo precisa ser texto")
+    titulo = (titulo_bruto or "Sem título").strip()
+
+    doc = dados.get("doc")
+    if doc is not None and not isinstance(doc, dict):
+        raise ValueError("doc precisa ser um objeto")
+
+    arq_id = ferramenta + "-" + slugify(titulo) + "-" + uuid.uuid4().hex[:5]
+    return gravar({
+        "id": arq_id,
+        "ferramenta": ferramenta,
+        "titulo": titulo,
+        "doc": doc or exemplo(ferramenta),
+    })
+
+
+def exemplo(ferramenta):
+    """Documento inicial de cada ferramenta — o mínimo que já fica bonito."""
+    if ferramenta == "prosa":
+        return {
+            "tema": "papel",
+            "blocos": [
+                {"tipo": "titulo", "texto": "Título do documento"},
+                {"tipo": "paragrafo", "texto": "Comece a escrever por aqui."},
+            ],
+        }
+    if ferramenta == "grade":
+        return {
+            "tema": "claro",
+            "abas": [{
+                "nome": "Planilha 1",
+                "colunas": ["Item", "Valor"],
+                "linhas": [["Exemplo", 100]],
+            }],
+        }
+    if ferramenta == "tela":
+        return {
+            "tema": "meia-noite", "largura": 1080, "altura": 1080,
+            "cenas": [{"layout": "livre", "fundo": "malha", "elementos": [
+                {"tipo": "texto", "x": 100, "y": 440, "l": 880, "a": 200,
+                 "texto": "Sua arte", "tamanho": 120, "peso": 700, "alinhar": "centro"},
+            ]}],
+        }
+    if ferramenta == "corte":
+        return {
+            "tema": "meia-noite", "largura": 1920, "altura": 1080,
+            "cenas": [
+                {"layout": "capa", "duracao": 3, "fundo": "malha",
+                 "elementos": [{"tipo": "texto", "papel": "titulo", "texto": "Primeira cena"}]},
+                {"layout": "capa", "duracao": 3, "fundo": "brilho",
+                 "elementos": [{"tipo": "texto", "papel": "titulo", "texto": "Segunda cena"}]},
+            ],
+        }
+    if ferramenta == "traco":
+        return {
+            "tema": "meia-noite", "largura": 1920, "altura": 1080,
+            "cenas": [{"layout": "livre", "elementos": [
+                {"id": "a", "tipo": "no", "x": 300, "y": 460, "l": 340, "a": 160, "texto": "Início"},
+                {"id": "b", "tipo": "no", "x": 1100, "y": 460, "l": 340, "a": 160, "texto": "Fim"},
+                {"tipo": "conector", "de": "a", "para": "b"},
+            ]}],
+        }
+    return {
+        "tema": "meia-noite", "largura": 1920, "altura": 1080,
+        "cenas": [
+            {"layout": "capa", "fundo": "malha", "elementos": [
+                {"tipo": "texto", "papel": "chapeu", "texto": "PrimoCode Studio"},
+                {"tipo": "texto", "papel": "titulo", "texto": "Título da apresentação"},
+                {"tipo": "texto", "papel": "apoio", "texto": "Uma frase que explica do que se trata."},
+            ]},
+            {"layout": "titulo", "elementos": [
+                {"tipo": "texto", "papel": "titulo", "texto": "Uma ideia por cena"},
+                {"tipo": "lista", "itens": ["Primeiro ponto", "Segundo ponto", "Terceiro ponto"]},
+            ]},
+        ],
+    }
+
+
+# ------------------------------------------------------------------ manual --
+
+def manual():
+    """Junta ferramentas/*.md — a pasta é a fonte da verdade para a IA."""
+    ordem = ["00-protocolo", "01-modelos"] + [f["slug"] for f in FERRAMENTAS_INFO]
+    partes = ["PRIMOCODE STUDIO — MANUAL PARA AGENTES",
+              "Servidor: http://localhost:%d" % PORTA, ""]
+    for nome in ordem:
+        p = os.path.join(FERRAMENTAS, nome + ".md")
+        if os.path.exists(p):
+            with open(p, encoding="utf-8") as fh:
+                partes.append(fh.read().rstrip())
+            partes.append("\n" + "=" * 70 + "\n")
+    return "\n".join(partes)
+
+
+# ----------------------------------------------------------------- handler --
+
+def seguro(metodo):
+    """Qualquer exceção não prevista na rota vira 500 em JSON, não conexão
+    fechada sem resposta nenhuma — era o comportamento padrão do
+    BaseHTTPRequestHandler para exceção não tratada num do_*, e o cliente (o
+    agente de IA) não tem como interpretar uma conexão que só morre."""
+    @functools.wraps(metodo)
+    def envolto(self, *a, **kw):
+        try:
+            return metodo(self, *a, **kw)
+        except Exception as e:
+            try:
+                self.js({"erro": "erro interno: %s" % e}, 500)
+            except Exception:
+                pass
+    return envolto
+
+
+class Handler(SimpleHTTPRequestHandler):
+    server_version = "PrimoCode/1.0"
+
+    def __init__(self, *a, **kw):
+        super().__init__(*a, directory=WEB, **kw)
+
+    def log_message(self, fmt, *args):
+        if "/api/" in (self.path or ""):
+            sys.stderr.write("  %s %s\n" % (self.command, self.path))
+
+    def end_headers(self):
+        self.send_header("Cache-Control", "no-store, max-age=0")
+        super().end_headers()
+
+    # -------------------------------------------------------------- saídas --
+
+    def js(self, obj, status=200):
+        corpo = json.dumps(obj, ensure_ascii=False).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(corpo)))
+        self.end_headers()
+        self.wfile.write(corpo)
+
+    def txt(self, texto, ctype="text/plain; charset=utf-8", status=200, baixar=None):
+        corpo = texto.encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(corpo)))
+        if baixar:
+            self.send_header("Content-Disposition", 'attachment; filename="%s"' % baixar)
+        self.end_headers()
+        self.wfile.write(corpo)
+
+    def pagina(self, nome):
+        with open(os.path.join(WEB, nome), encoding="utf-8") as fh:
+            self.txt(fh.read(), "text/html; charset=utf-8")
+
+    def corpo(self):
+        n = int(self.headers.get("Content-Length") or 0)
+        if not n:
+            return {}
+        try:
+            return json.loads(self.rfile.read(n).decode("utf-8"))
+        except Exception:
+            return {}
+
+    # -------------------------------------------------------------- rotas --
+
+    @seguro
+    def do_GET(self):
+        p = urlparse(self.path).path
+
+        if p == "/":
+            return self.pagina("home.html")
+        if re.fullmatch(r"/t/[^/]+/[^/]+", p):
+            return self.pagina("tool.html")
+        if re.fullmatch(r"/v/[^/]+", p):
+            return self.pagina("view.html")
+
+        if p == "/api/manual":
+            return self.txt(manual())
+        if p == "/api/ferramentas":
+            return self.js(FERRAMENTAS_INFO)
+
+        m = re.fullmatch(r"/api/ferramentas/([a-z]+)", p)
+        if m:
+            info = POR_SLUG.get(m.group(1))
+            if not info:
+                return self.js({"erro": "ferramenta desconhecida"}, 404)
+            doc = os.path.join(FERRAMENTAS, m.group(1) + ".md")
+            texto = ""
+            if os.path.exists(doc):
+                with open(doc, encoding="utf-8") as fh:
+                    texto = fh.read()
+            return self.txt(texto or json.dumps(info, ensure_ascii=False, indent=2))
+
+        if p == "/api/midia":
+            return self.js(listar_midia())
+        if p.startswith("/midia/"):
+            return self.servir_midia(unquote(p[len("/midia/"):]))
+
+        if p == "/api/arquivos":
+            return self.js(listar())
+
+        m = re.fullmatch(r"/api/arquivos/([^/]+)", p)
+        if m:
+            a = ler(m.group(1))
+            return self.js(a) if a else self.js({"erro": "não encontrado"}, 404)
+
+        m = re.fullmatch(r"/api/arquivos/([^/]+)/export", p)
+        if m:
+            a = ler(m.group(1))
+            if not a:
+                return self.js({"erro": "não encontrado"}, 404)
+            return self.exportar(a)
+
+        return super().do_GET()
+
+    def servir_midia(self, nome):
+        """Serve com suporte a Range — sem isso o áudio não busca no <audio>."""
+        if "/" in nome or ".." in nome:
+            return self.js({"erro": "caminho inválido"}, 400)
+        caminho_arq = os.path.join(MIDIA, nome)
+        if not os.path.isfile(caminho_arq):
+            return self.js({"erro": "não encontrado"}, 404)
+
+        tamanho = os.path.getsize(caminho_arq)
+        ctype = mimetypes.guess_type(caminho_arq)[0] or "application/octet-stream"
+        faixa = self.headers.get("Range")
+        inicio, fim = 0, tamanho - 1
+        status = 200
+
+        if faixa:
+            m = re.match(r"bytes=(\d*)-(\d*)", faixa)
+            if m:
+                if not m.group(1) and m.group(2):
+                    # "bytes=-500" é sufixo HTTP válido: os ÚLTIMOS 500 bytes,
+                    # não os primeiros 500 — sem este caso à parte, group(2)
+                    # virava fim absoluto e o pedido servia o pedaço errado.
+                    inicio = max(0, tamanho - int(m.group(2)))
+                    fim = tamanho - 1
+                else:
+                    if m.group(1):
+                        inicio = int(m.group(1))
+                    if m.group(2):
+                        fim = min(int(m.group(2)), tamanho - 1)
+                if inicio > fim or inicio >= tamanho:
+                    self.send_response(416)
+                    self.send_header("Content-Range", "bytes */%d" % tamanho)
+                    self.end_headers()
+                    return
+                status = 206
+
+        self.send_response(status)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Accept-Ranges", "bytes")
+        self.send_header("Content-Length", str(fim - inicio + 1))
+        if status == 206:
+            self.send_header("Content-Range", "bytes %d-%d/%d" % (inicio, fim, tamanho))
+        self.end_headers()
+
+        with open(caminho_arq, "rb") as fh:
+            fh.seek(inicio)
+            restante = fim - inicio + 1
+            while restante > 0:
+                pedaco = fh.read(min(262144, restante))
+                if not pedaco:
+                    break
+                self.wfile.write(pedaco)
+                restante -= len(pedaco)
+
+    @seguro
+    def do_POST(self):
+        rota = urlparse(self.path).path
+        if rota == "/api/midia":
+            corpo, status = guardar_midia(self.corpo())
+            return self.js(corpo, status)
+
+        if rota == "/api/arquivos":
+            try:
+                a = criar(self.corpo())
+            except ValueError as e:
+                return self.js({"erro": str(e)}, 400)
+            if not a:
+                return self.js({"erro": "ferramenta inválida",
+                                "validas": list(POR_SLUG)}, 400)
+            base = "http://localhost:%d" % PORTA
+            return self.js({
+                "id": a["id"],
+                "ferramenta": a["ferramenta"],
+                "titulo": a["titulo"],
+                "editar": "%s/t/%s/%s" % (base, a["ferramenta"], a["id"]),
+                "ver": "%s/v/%s" % (base, a["id"]),
+            }, 201)
+        return self.js({"erro": "não encontrado"}, 404)
+
+    @seguro
+    def do_PUT(self):
+        m = re.fullmatch(r"/api/arquivos/([^/]+)", urlparse(self.path).path)
+        if not m:
+            return self.js({"erro": "não encontrado"}, 404)
+        a = ler(m.group(1))
+        if not a:
+            return self.js({"erro": "não encontrado"}, 404)
+        dados = self.corpo()
+        # Mesma validação de criar(): sem isso, um PUT com titulo/doc do tipo
+        # errado grava sujeira que só quebra depois, no consumo (export etc).
+        if "titulo" in dados and dados["titulo"] is not None and not isinstance(dados["titulo"], str):
+            return self.js({"erro": "titulo precisa ser texto"}, 400)
+        if "doc" in dados and dados["doc"] is not None and not isinstance(dados["doc"], dict):
+            return self.js({"erro": "doc precisa ser um objeto"}, 400)
+        for chave in ("titulo", "doc"):
+            if chave in dados:
+                a[chave] = dados[chave]
+        return self.js(gravar(a))
+
+    @seguro
+    def do_DELETE(self):
+        rota = urlparse(self.path).path
+        m = re.fullmatch(r"/api/midia/([^/]+)", rota)
+        if m:
+            nome = unquote(m.group(1))
+            alvo = os.path.join(MIDIA, nome)
+            if "/" not in nome and ".." not in nome and os.path.isfile(alvo):
+                os.remove(alvo)
+                return self.js({"ok": True})
+            return self.js({"erro": "não encontrado"}, 404)
+
+        m = re.fullmatch(r"/api/arquivos/([^/]+)", rota)
+        c = caminho(m.group(1)) if m else None
+        if c and os.path.exists(c):
+            os.remove(c)
+            return self.js({"ok": True})
+        return self.js({"erro": "não encontrado"}, 404)
+
+    # ------------------------------------------------------------- export --
+
+    def exportar(self, a):
+        ferramenta = a.get("ferramenta")
+        doc = a.get("doc") or {}
+
+        if ferramenta == "grade":
+            linhas = []
+            for aba in doc.get("abas", []):
+                linhas.append(",".join(csv_celula(c) for c in aba.get("colunas", [])))
+                for lin in calcular_aba(aba):
+                    linhas.append(",".join(csv_celula(c) for c in lin))
+                linhas.append("")
+            return self.txt("\n".join(linhas), "text/csv; charset=utf-8",
+                            baixar=a["id"] + ".csv")
+
+        if ferramenta == "prosa":
+            return self.txt(prosa_markdown(doc), "text/markdown; charset=utf-8",
+                            baixar=a["id"] + ".md")
+
+        return self.txt(html_autonomo(a), "text/html; charset=utf-8",
+                        baixar=a["id"] + ".html")
+
+
+def csv_celula(valor):
+    if isinstance(valor, float):
+        valor = round(valor, 2)
+        if valor == int(valor):
+            valor = int(valor)
+    s = "" if valor is None else str(valor)
+    return '"%s"' % s.replace('"', '""') if re.search(r'[",\n\r]', s) else s
+
+
+# ------------------------------------------------- fórmulas (espelha o JS) --
+
+def _mediana(v):
+    if not v:
+        return 0
+    o = sorted(v)
+    m = len(o) // 2
+    return o[m] if len(o) % 2 else (o[m - 1] + o[m]) / 2
+
+
+_FUNCOES = {
+    "SOMA": sum,
+    "MEDIA": lambda v: sum(v) / len(v) if v else 0,
+    "MIN": lambda v: min(v) if v else 0,
+    "MAX": lambda v: max(v) if v else 0,
+    "CONT": len,
+    "ARRED": lambda v: round(v[0], int(v[1])) if len(v) > 1 else round(v[0] if v else 0),
+    "ABS": lambda v: abs(v[0] if v else 0),
+    "RAIZ": lambda v: abs(v[0] if v else 0) ** 0.5,
+    "POT": lambda v: (v[0] if v else 0) ** (v[1] if len(v) > 1 else 2),
+    "TETO": lambda v: -(-(v[0] if v else 0) // 1),
+    "PISO": lambda v: (v[0] if v else 0) // 1,
+    "MEDIANA": _mediana,
+    "MAIOR": lambda v: sorted(v[:-1], reverse=True)[max(0, int(v[-1]) - 1)] if len(v) > 1 else 0,
+    "MENOR": lambda v: sorted(v[:-1])[max(0, int(v[-1]) - 1)] if len(v) > 1 else 0,
+    "SE": lambda v: (v[1] if len(v) > 1 else 1) if v and v[0] else (v[2] if len(v) > 2 else 0),
+}
+
+
+def _criterio(texto):
+    m = re.match(r'^(<=|>=|<>|!=|<|>|=)?\s*(-?[\d.,]+)$', str(texto).strip().strip('"\''))
+    if not m:
+        return lambda x: False
+    op, alvo = m.group(1) or "=", float(m.group(2).replace(",", "."))
+    return {
+        ">": lambda x: x > alvo, "<": lambda x: x < alvo,
+        ">=": lambda x: x >= alvo, "<=": lambda x: x <= alvo,
+        "<>": lambda x: x != alvo, "!=": lambda x: x != alvo,
+    }.get(op, lambda x: x == alvo)
+
+
+def _col(letras):
+    n = 0
+    for c in letras:
+        n = n * 26 + (ord(c) - 64)
+    return n - 1
+
+
+def _num(v):
+    if isinstance(v, (int, float)):
+        return v
+    if v in (None, ""):
+        return 0
+    try:
+        return float(re.sub(r"[R$\s%.]", "", str(v)).replace(",", "."))
+    except ValueError:
+        return 0
+
+
+def calcular_aba(aba):
+    """Resolve as fórmulas da aba e devolve a matriz de valores."""
+    linhas = [list(l) for l in aba.get("linhas", [])]
+
+    def celula(c, l, prof):
+        # l/c negativos (referência tipo "A0", que vira índice -1) não podem
+        # passar: índice negativo do Python "funciona" contando do fim da
+        # lista, e a última linha da planilha aparecia como resposta de uma
+        # referência inválida em vez de virar 0.
+        if prof > 24 or l < 0 or c < 0 or l >= len(linhas) or c >= len(linhas[l]):
+            return 0
+        bruto = linhas[l][c]
+        if isinstance(bruto, str) and bruto.startswith("="):
+            return avaliar(bruto[1:], prof + 1)
+        return bruto
+
+    def faixa(ref, prof):
+        m = re.fullmatch(r"([A-Z]+)(\d+):([A-Z]+)(\d+)", ref)
+        if not m:
+            return []
+        c1, l1, c2, l2 = _col(m.group(1)), int(m.group(2)) - 1, _col(m.group(3)), int(m.group(4)) - 1
+        return [_num(celula(c, l, prof))
+                for l in range(min(l1, l2), max(l1, l2) + 1)
+                for c in range(min(c1, c2), max(c1, c2) + 1)]
+
+    def ref_simples(ref, prof):
+        m = re.fullmatch(r"([A-Z]+)(\d+)", ref)
+        return celula(_col(m.group(1)), int(m.group(2)) - 1, prof) if m else 0
+
+    def avaliar(expr, prof):
+        def fn(m):
+            nome = m.group(1)
+            partes = [p.strip() for p in m.group(2).split(";")]
+
+            if nome in ("SOMASE", "CONTSE"):
+                base = faixa(partes[0], prof) if re.fullmatch(r"[A-Z]+\d+:[A-Z]+\d+", partes[0]) else []
+                passou = [x for x in base if _criterio(partes[1] if len(partes) > 1 else "")(x)]
+                return repr(sum(passou) if nome == "SOMASE" else len(passou))
+
+            f = _FUNCOES.get(nome)
+            if not f:
+                return "0"
+            vals = []
+            for parte in partes:
+                if re.fullmatch(r"[A-Z]+\d+:[A-Z]+\d+", parte):
+                    vals += faixa(parte, prof)
+                elif parte:
+                    # qualquer outro argumento é uma expressão: resolve antes
+                    vals.append(_num(avaliar(parte, prof)))
+            try:
+                # MAIOR/MENOR estouram IndexError com k maior que o intervalo;
+                # POT estoura OverflowError com base/expoente grandes demais.
+                # Uma fórmula ruim vira "#ERRO" NESSA célula, não derruba a
+                # exportação inteira (mesma regra do eval() logo abaixo).
+                return repr(f(vals))
+            except Exception:
+                return "#ERRO"
+
+        # repete até esgotar: resolve de dentro para fora em fórmula aninhada
+        e, voltas = expr, 0
+        while re.search(r"[A-Z]+\(", e) and voltas < 12:
+            e = re.sub(r"([A-Z]+)\(([^()]*)\)", fn, e)
+            voltas += 1
+        e = re.sub(r"\b[A-Z]+\d+\b", lambda m: repr(_num(ref_simples(m.group(0), prof))), e)
+        # comparações são permitidas para o SE funcionar
+        if not re.fullmatch(r"[-+*/().\d\s,<>=!]*", e):
+            return "#ERRO"
+        try:
+            pronto = e.replace(",", ".").replace("<>", "!=")
+            pronto = re.sub(r"([^<>!=])=(?!=)", r"\1==", pronto) or "0"
+            r = eval(pronto, {"__builtins__": {}}, {})
+            if isinstance(r, bool):
+                return 1 if r else 0
+            return round(r, 6) if isinstance(r, float) else r
+        except Exception:
+            return "#ERRO"
+
+    return [[celula(c, l, 0) for c in range(len(linhas[l]))] for l in range(len(linhas))]
+
+
+def prosa_markdown(doc):
+    fora = []
+    capa = doc.get("capa")
+    if capa:
+        if capa.get("chapeu"):
+            fora += ["*%s*" % capa["chapeu"], ""]
+        if capa.get("titulo"):
+            fora += ["# " + capa["titulo"], ""]
+        if capa.get("apoio"):
+            fora += [capa["apoio"], ""]
+        assinatura = " · ".join(x for x in (capa.get("autor"), capa.get("data")) if x)
+        if assinatura:
+            fora += ["_%s_" % assinatura, ""]
+        fora += ["---", ""]
+
+    for b in doc.get("blocos", []):
+        t, texto = b.get("tipo"), b.get("texto", "")
+        if t == "titulo":
+            fora.append("# " + texto)
+        elif t == "secao":
+            fora.append("## " + texto)
+        elif t == "subsecao":
+            fora.append("### " + texto)
+        elif t == "chapeu":
+            fora.append("*" + texto + "*")
+        elif t == "apoio":
+            fora.append("_" + texto + "_")
+        elif t == "destaque":
+            fora.append("> **%s**  " % b.get("titulo", "Nota"))
+            fora.append("> " + texto)
+        elif t == "sumario":
+            fora.append("## " + (texto or "Sumário"))
+            fora += ["%d. %s" % (i + 1, s.get("texto", ""))
+                     for i, s in enumerate([x for x in doc.get("blocos", []) if x.get("tipo") == "secao"])]
+        elif t == "citacao":
+            fora.append("> " + texto)
+            if b.get("autor"):
+                fora += [">", "> — " + b["autor"]]
+        elif t == "lista":
+            fora += ["- " + i for i in b.get("itens", [])]
+        elif t == "numerada":
+            fora += ["%d. %s" % (i + 1, v) for i, v in enumerate(b.get("itens", []))]
+        elif t == "codigo":
+            fora.append("```\n" + texto + "\n```")
+        elif t == "divisor":
+            fora.append("---")
+        elif t == "tabela":
+            linhas = b.get("linhas", [])
+            if linhas:
+                fora.append("| " + " | ".join(map(str, linhas[0])) + " |")
+                fora.append("|" + "---|" * len(linhas[0]))
+                for l in linhas[1:]:
+                    fora.append("| " + " | ".join(map(str, l)) + " |")
+        else:
+            fora.append(texto)
+        fora.append("")
+    return "\n".join(fora)
+
+
+def embutir_midia(texto, limite=24 * 1024 * 1024):
+    """Troca /midia/x por data URI para o export abrir sem servidor nenhum."""
+    def troca(m):
+        nome = unquote(m.group(1))
+        alvo = os.path.join(MIDIA, nome)
+        if "/" in nome or ".." in nome or not os.path.isfile(alvo):
+            return m.group(0)
+        if os.path.getsize(alvo) > limite:
+            return m.group(0)                       # grande demais: mantém o link
+        tipo = mimetypes.guess_type(alvo)[0] or "application/octet-stream"
+        with open(alvo, "rb") as fh:
+            return "data:%s;base64,%s" % (tipo, base64.b64encode(fh.read()).decode())
+
+    return re.sub(r"/midia/([A-Za-z0-9._%\-]+)", troca, texto)
+
+
+def html_autonomo(a):
+    """Arquivo único: CSS, renderizadores, áudio, mídia e documento embutidos."""
+    def leia(*partes):
+        with open(os.path.join(WEB, *partes), encoding="utf-8") as fh:
+            return fh.read()
+
+    js = "\n".join(leia("js", n) for n in
+                   ("icones.js", "audio.js", "render.js", "render-prosa.js", "render-grade.js"))
+
+    dados = json.dumps(a, ensure_ascii=False).replace("</script", "<\\/script")
+
+    return """<!doctype html>
+<html lang="pt-BR"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>%(titulo)s</title>
+<style>%(css)s</style></head>
+<body class="modo-ver">
+<div id="palco" class="palco"></div>
+<script id="dados" type="application/json">%(dados)s</script>
+<script>%(js)s</script>
+<script>%(player)s</script>
+</body></html>
+""" % {
+        "titulo": (a.get("titulo") or "PrimoCode").replace("<", "&lt;"),
+        "css": leia("core.css") + leia("render.css"),
+        "dados": embutir_midia(dados),
+        "js": js,
+        "player": leia("js", "player.js"),
+    }
+
+
+# -------------------------------------------------------------------- main --
+
+if __name__ == "__main__":
+    url = "http://localhost:%d" % PORTA
+    print("""
+  ██  PrimoCode Studio
+  ────────────────────────────────────────────────────────
+  Estúdio          %s
+  Manual da IA     %s/api/manual
+  Ferramentas      %s
+  ────────────────────────────────────────────────────────
+  Ctrl+C para parar
+""" % (url, url, ", ".join(f["nome"] for f in FERRAMENTAS_INFO)))
+
+    try:
+        ThreadingHTTPServer(("127.0.0.1", PORTA), Handler).serve_forever()
+    except KeyboardInterrupt:
+        print("\n  Encerrado.\n")