primocode 8.22.1 → 8.25.0

package/studio/server.py

@@ -140,6 +140,10 @@ ASSINATURA = _assinatura()
 
 # 60 MB por arquivo: cobre faixa longa em mp3 e foto de câmera sem susto
 LIMITE_MIDIA = 60 * 1024 * 1024
+# Vídeo do usuário é outra escala: um celular grava 100 MB por minuto. O teto
+# de 60 MB recusava quase toda gravação real — e "edite meu vídeo" morria na
+# primeira ordem. Só vale para o caminho bruto, que não passa por base64.
+LIMITE_VIDEO = 2 * 1024 * 1024 * 1024
 
 os.makedirs(ARQUIVOS, exist_ok=True)
 os.makedirs(MIDIA, exist_ok=True)
@@ -628,6 +632,60 @@ def listar_midia():
     return sorted(fora, key=lambda m: m["nome"])
 
 
+def _nome_livre(base, ext):
+    nome = base + ext
+    if os.path.exists(os.path.join(MIDIA, nome)):
+        nome = base + "-" + uuid.uuid4().hex[:4] + ext
+    return nome
+
+
+def guardar_midia_bruta(nome_pedido, fluxo, tamanho):
+    """Grava o arquivo lendo o corpo direto do socket, sem passar por base64.
+
+    Um vídeo gravado no celular tem centenas de MB. Em base64 ele cresce um
+    terço, vira uma linha só de JSON e precisa caber INTEIRO na memória três
+    vezes — no texto, no decodificado e no que o json guarda. O estúdio
+    engasgava antes de gravar um byte, e o dono só via "falhou".
+
+    Aqui o corpo desce em pedaços de 1 MB direto para o disco: o consumo não
+    depende do tamanho do arquivo.
+    """
+    base, ext = nome_seguro(nome_pedido)
+    if ext not in TIPOS_OK:
+        return {"erro": "formato não aceito", "aceitos": sorted(TIPOS_OK)}, 400
+    if tamanho <= 0:
+        return {"erro": "corpo vazio"}, 400
+    limite = LIMITE_VIDEO if TIPOS_OK[ext] == "video" else LIMITE_MIDIA
+    if tamanho > limite:
+        return {"erro": "arquivo acima de %d MB" % (limite // 1048576)}, 413
+
+    nome = _nome_livre(base, ext)
+    destino = os.path.join(MIDIA, nome)
+    escrito = 0
+    try:
+        with open(destino, "wb") as fh:
+            while escrito < tamanho:
+                pedaco = fluxo.read(min(1048576, tamanho - escrito))
+                if not pedaco:
+                    break
+                fh.write(pedaco)
+                escrito += len(pedaco)
+    except Exception as erro:
+        try: os.remove(destino)
+        except OSError: pass
+        return {"erro": "não consegui gravar: %s" % erro}, 500
+
+    if escrito != tamanho:
+        # Meio arquivo é pior que nenhum: o <video> abre, mostra o começo e
+        # corta no meio da frase, e nada denuncia de onde veio.
+        try: os.remove(destino)
+        except OSError: pass
+        return {"erro": "a transferência parou em %d de %d bytes" % (escrito, tamanho)}, 400
+
+    return {"nome": nome, "url": "/midia/" + nome,
+            "tipo": TIPOS_OK[ext], "bytes": escrito}, 201
+
+
 def guardar_midia(dados):
     """Recebe {nome, dados:"data:...;base64,..."} e grava em midia/."""
     bruto = dados.get("dados") or ""
@@ -647,12 +705,11 @@ def guardar_midia(dados):
     except Exception:
         return {"erro": "base64 inválido"}, 400
 
-    if len(conteudo) > LIMITE_MIDIA:
-        return {"erro": "arquivo acima de %d MB" % (LIMITE_MIDIA // 1048576)}, 413
+    limite = LIMITE_VIDEO if TIPOS_OK[ext] == "video" else LIMITE_MIDIA
+    if len(conteudo) > limite:
+        return {"erro": "arquivo acima de %d MB" % (limite // 1048576)}, 413
 
-    nome = base + ext
-    if os.path.exists(os.path.join(MIDIA, nome)):
-        nome = base + "-" + uuid.uuid4().hex[:4] + ext
+    nome = _nome_livre(base, ext)
     with open(os.path.join(MIDIA, nome), "wb") as fh:
         fh.write(conteudo)
 
@@ -660,6 +717,132 @@ def guardar_midia(dados):
             "tipo": TIPOS_OK[ext], "bytes": len(conteudo)}, 201
 
 
+# ------------------------------------------------------------ análise de áudio --
+#
+# "Ele vai cortar as pausas demoradas no vídeo."
+#
+# Para cortar as pausas é preciso SABER onde elas estão, e ninguém aqui sabe
+# ler o áudio de um .mp4: o PrimoCode não tem dependência nenhuma, e o Python
+# da máquina do usuário lê WAV e mais nada. ffmpeg resolveria — e seria mais
+# uma instalação de 80 MB para quem só quer editar um vídeo.
+#
+# Quem sabe decodificar MP4, MOV e webm já está aberto na mesa: o navegador.
+# `decodeAudioData` faz isso desde sempre, em qualquer sistema, sem instalar
+# coisa alguma. Então a conta roda lá, e o servidor só segura o pedido e a
+# resposta enquanto isso — é um quadro de recados entre o agente e a aba.
+#
+# Fica na memória de propósito: é resultado de trabalho, não trabalho. Se o
+# estúdio reiniciar, pedir de novo custa segundos.
+ANALISES = {}
+LIMITE_ANALISES = 40
+
+
+def criar_analise(dados):
+    arquivo = (dados or {}).get("arquivo") or ""
+    if not arquivo.startswith("/midia/"):
+        return {"erro": 'passe "arquivo" como a URL que /api/midia devolveu (ex.: "/midia/x.mp4")'}, 400
+    nome = unquote(arquivo[len("/midia/"):])
+    if nome != os.path.basename(nome) or not os.path.exists(os.path.join(MIDIA, nome)):
+        return {"erro": "não achei %s em midia/" % arquivo}, 404
+
+    # Podar antes de inserir: sem isto uma sessão longa acumula análises que
+    # ninguém mais vai ler.
+    if len(ANALISES) >= LIMITE_ANALISES:
+        for velho in sorted(ANALISES, key=lambda k: ANALISES[k]["criado"])[:len(ANALISES) - LIMITE_ANALISES + 1]:
+            ANALISES.pop(velho, None)
+
+    ident = uuid.uuid4().hex[:10]
+    ANALISES[ident] = {
+        "id": ident, "arquivo": arquivo, "estado": "pedido",
+        "silencio": float((dados or {}).get("silencio") or 0.45),
+        "pausa": float((dados or {}).get("pausa") or 0.6),
+        "criado": time.time(), "resultado": None,
+    }
+    return {"id": ident, "pagina": "/analise#" + ident, "estado": "pedido"}, 201
+
+
+def gravar_analise(ident, dados):
+    tarefa = ANALISES.get(ident)
+    if not tarefa:
+        return {"erro": "análise não encontrada"}, 404
+    if (dados or {}).get("erro"):
+        tarefa["estado"] = "erro"
+        tarefa["resultado"] = {"erro": str(dados["erro"])[:300]}
+    else:
+        tarefa["estado"] = "pronto"
+        tarefa["resultado"] = {
+            "duracao": dados.get("duracao"),
+            "trechos": dados.get("trechos") or [],
+            "pausas": dados.get("pausas") or [],
+            "cortado": dados.get("cortado"),
+        }
+    return {"ok": True, "estado": tarefa["estado"]}, 200
+
+
+# ------------------------------------------------------- revisão de monotonia --
+#
+# "Ele não alterna entre os temas, usa um tema só pra todos os vídeos, e o
+# vídeo sempre tem a mesma estrutura. Fica tudo genérico."
+#
+# O estúdio tem dez temas, onze fundos, oito transições e seis trilhas. O
+# agente usa uma fatia estreita e repete — porque a spec tem UM exemplo
+# completo e modelo ancora em exemplo. Conselho escrito na spec ajuda pouco
+# quando ela nem sempre é relida.
+#
+# Então quem revisa é o próprio estúdio, na hora de gravar. Isto NÃO recusa
+# nada: um vídeo monótono continua sendo um vídeo, e recusar conteúdo válido
+# seria pior que o problema. O que ele faz é devolver o que dá para melhorar,
+# em texto que o agente lê como resultado da tool — do mesmo jeito que
+# validar_doc ensina o formato quando o tipo está errado.
+def revisar_monotonia(doc, ferramenta):
+    if ferramenta not in ("corte", "prisma") or not isinstance(doc, dict):
+        return []
+    cenas = [c for c in (doc.get("cenas") or []) if isinstance(c, dict)]
+    if len(cenas) < 3:
+        return []                       # peça curta demais para julgar
+
+    avisos = []
+
+    fundos = [c.get("fundo") for c in cenas]
+    distintos = {f if isinstance(f, str) else "?" for f in fundos if f}
+    if len(distintos) <= 1:
+        avisos.append(
+            "todas as %d cenas usam o mesmo fundo%s. São onze: malha, brilho, grade, "
+            "pontos, suave, vinheta, aurora, nevoa, ondas, raios, xadrez. Fundo igual "
+            "em tudo é o que faz o vídeo parecer template."
+            % (len(cenas), " (" + list(distintos)[0] + ")" if distintos else " — nenhum"))
+
+    trs = [c.get("transicao") for c in cenas[1:] if c.get("transicao")]
+    if len(trs) >= 2 and len(set(trs)) == 1:
+        avisos.append(
+            'toda transição é "%s". São oito: corte, fade, deslizar, subir, zoom, '
+            "limpar, persiana, flash. Tudo igual parece slide, não vídeo." % trs[0])
+
+    if ferramenta == "corte" and not doc.get("trilha"):
+        avisos.append(
+            "o vídeo está sem trilha. Seis estilos gerados existem (pulso, ambiente, "
+            "lofi, epico, alegre, tenso) e nenhum custa arquivo nem licença — escolha "
+            "pelo assunto.")
+
+    duracoes = [c.get("duracao") for c in cenas if isinstance(c.get("duracao"), (int, float))]
+    if len(duracoes) >= 4 and len(set(duracoes)) == 1:
+        avisos.append(
+            "todas as cenas duram %s s. Ritmo igual do começo ao fim cansa: gancho "
+            "curto, argumento mais longo, fecho curto." % duracoes[0])
+
+    anims = []
+    for c in cenas:
+        for e in (c.get("elementos") or []):
+            if isinstance(e, dict) and e.get("anim"):
+                anims.append(e["anim"])
+    if len(anims) >= 4 and len(set(anims)) == 1:
+        avisos.append(
+            'toda animação de entrada é "%s". Varie: subir, surgir, esquerda, direita, '
+            "zoom, desfoque, cair, girar, saltar, revelar, cortina, elastico." % anims[0])
+
+    return avisos
+
+
 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
@@ -752,6 +935,40 @@ def _tema_invalido(tema, onde=""):
             % (tema, onde, ", ".join(sorted(TEMAS_VALIDOS))))
 
 
+def _clipe_invalido(e, i, j):
+    """Um `clipe` é um TRECHO da gravação do usuário: arquivo, começo e fim.
+
+    Os três erros abaixo saem calados. `src` faltando ou apontando para o
+    disco da pessoa dá <video> que nunca carrega — cena preta, sem aviso.
+    `ate` antes de `de` dá trecho de duração negativa, que vira cena de zero
+    segundo. E `de`/`ate` em texto ("00:12") faz a conta de duração virar
+    concatenação, que foi como já saiu um vídeo de 00:00 daqui.
+    """
+    onde = "elemento %d da cena %d" % (j + 1, i + 1)
+    src = e.get("src")
+    if not isinstance(src, str) or not src.strip():
+        return ('%s é "clipe" mas está sem "src". O caminho é a URL que /api/midia devolveu '
+                '(ex.: "/midia/gravacao.mp4"). Envie o arquivo primeiro; caminho do disco '
+                '("/Users/...", "C:\\\\...") o navegador não abre.' % onde)
+    if re.match(r"^([a-zA-Z]:[\\/]|/(Users|home|mnt|var|tmp)/|file:)", src.strip()):
+        return ('%s aponta para o disco (%r). O navegador não lê caminho de arquivo: envie o vídeo '
+                'para /api/midia e use a URL "/midia/..." que ele devolve.' % (onde, src[:60]))
+    for campo in ("de", "ate"):
+        v = e.get(campo)
+        if v is None:
+            continue
+        if isinstance(v, bool) or not isinstance(v, (int, float)):
+            return ('%s tem "%s": %r, que não é número. São SEGUNDOS do arquivo original: '
+                    '"de": 12.5, "ate": 19.' % (onde, campo, v))
+        if v < 0:
+            return '%s tem "%s": %r — segundo negativo não existe.' % (onde, campo, v)
+    de, ate = e.get("de"), e.get("ate")
+    if isinstance(de, (int, float)) and isinstance(ate, (int, float)) and ate <= de:
+        return ('%s tem "ate": %r antes ou igual a "de": %r. O trecho ficaria com duração zero ou '
+                'negativa e a cena sairia vazia.' % (onde, ate, de))
+    return None
+
+
 def validar_doc(modelo, doc):
     """None quando o doc serve; senão, a frase que ENSINA o formato certo.
 
@@ -772,7 +989,7 @@ def validar_doc(modelo, doc):
     # preto": documento válido na forma, invisível na tela.
     TIPOS_VALIDOS = {"texto", "lista", "cartoes", "numeros", "tabela", "codigo",
                      "citacao", "forma", "imagem", "icone", "grafico", "no", "conector",
-                     "objeto3d"}
+                     "objeto3d", "clipe"}
 
     # Tema inventado tinha o mesmo destino silencioso do tipo inventado: o CSS
     # não casa com [data-tema="noite"], nenhuma cor é definida e a peça sai
@@ -818,6 +1035,12 @@ def validar_doc(modelo, doc):
                 if e.get("tipo") == "texto" and not (e.get("texto") or "").strip():
                     return ('elemento %d da cena %d é "texto" mas o campo "texto" está vazio — o conteúdo '
                             'vai SEMPRE no campo "texto".' % (j + 1, i + 1))
+                # Clipe: o trecho da gravação do usuário. Erra-se em silêncio de
+                # três formas, e as três dão vídeo preto ou corte que não corta.
+                if e.get("tipo") == "clipe":
+                    problema = _clipe_invalido(e, i, j)
+                    if problema:
+                        return problema
     elif modelo == "documento":
         blocos = doc.get("blocos")
         if not isinstance(blocos, list) or not blocos:
@@ -1020,6 +1243,8 @@ class Handler(SimpleHTTPRequestHandler):
             return self.pagina("tool.html")
         if re.fullmatch(r"/v/[^/]+", p):
             return self.pagina("view.html")
+        if p == "/analise":
+            return self.pagina("analise.html")
 
         if p == "/api/manual":
             return self.txt(manual())
@@ -1041,6 +1266,13 @@ class Handler(SimpleHTTPRequestHandler):
         if p == "/api/versao":
             return self.js({"assinatura": ASSINATURA})
 
+        m = re.fullmatch(r"/api/analise/([a-z0-9]+)", p)
+        if m:
+            tarefa = ANALISES.get(m.group(1))
+            if not tarefa:
+                return self.js({"erro": "análise não encontrada"}, 404)
+            return self.js(tarefa)
+
         if p == "/api/voz":
             return self.voz(urlparse(self.path).query)
         if p == "/api/voz/status":
@@ -1351,6 +1583,10 @@ class Handler(SimpleHTTPRequestHandler):
             corpo, status = guardar_midia(self.corpo())
             return self.js(corpo, status)
 
+        if rota == "/api/analise":
+            corpo, status = criar_analise(self.corpo())
+            return self.js(corpo, status)
+
         if rota == "/api/voz/instalar":
             pedido = self.corpo()
             if pedido.get("apagar"):
@@ -1408,19 +1644,39 @@ class Handler(SimpleHTTPRequestHandler):
                 return self.js({"erro": "ferramenta inválida",
                                 "validas": list(POR_SLUG)}, 400)
             base = "http://localhost:%d" % PORTA
-            return self.js({
+            corpo = {
                 "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)
+            }
+            revisao = revisar_monotonia(a.get("doc") or {}, a.get("ferramenta"))
+            if revisao:
+                corpo["podeMelhorar"] = revisao
+            return self.js(corpo, 201)
         return self.js({"erro": "não encontrado"}, 404)
 
     @seguro
     def do_PUT(self):
         if not self.origem_ok():
             return self.js({"erro": "origem não permitida"}, 403)
+
+        # Envio bruto: PUT /api/midia/<nome> com o arquivo no corpo, sem JSON
+        # e sem base64. É por onde passa a gravação do usuário, que é grande
+        # demais para virar texto.
+        m = re.fullmatch(r"/api/midia/([^/]+)", urlparse(self.path).path)
+        if m:
+            corpo, status = guardar_midia_bruta(
+                unquote(m.group(1)), self.rfile,
+                int(self.headers.get("Content-Length") or 0))
+            return self.js(corpo, status)
+
+        m = re.fullmatch(r"/api/analise/([a-z0-9]+)", urlparse(self.path).path)
+        if m:
+            corpo, status = gravar_analise(m.group(1), self.corpo())
+            return self.js(corpo, status)
+
         m = re.fullmatch(r"/api/arquivos/([^/]+)", urlparse(self.path).path)
         if not m:
             return self.js({"erro": "não encontrado"}, 404)

package/studio/web/analise.html

@@ -0,0 +1,52 @@
+<!doctype html>
+<html lang="pt-BR">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>PrimoCode — ouvindo o vídeo</title>
+<link rel="stylesheet" href="/core.css">
+<link rel="stylesheet" href="/fontes.css">
+<style>
+  /* Uma aba que abre sozinha, trabalha e some. Ela não pede nada da pessoa —
+     só conta o que está fazendo, para o segundo de espera não parecer travado. */
+  body {
+    margin: 0; min-height: 100vh;
+    display: flex; align-items: center; justify-content: center;
+    background: var(--c-fundo, #0b0e14); color: var(--c-texto, #e7ecf3);
+    font-family: var(--f-corpo, system-ui, sans-serif);
+  }
+  .caixa { width: min(560px, 92vw); padding: 34px 32px; }
+  h1 { font-size: 21px; font-weight: 640; margin: 0 0 4px; letter-spacing: -.01em; }
+  #qual {
+    display: block; font-size: 13px; opacity: .62;
+    font-family: var(--f-mono, ui-monospace, monospace);
+    margin-bottom: 22px; word-break: break-all;
+  }
+  .trilho { height: 4px; border-radius: 4px; background: rgba(255,255,255,.1); overflow: hidden; }
+  #barra {
+    height: 100%; width: 0;
+    background: linear-gradient(90deg, #2f6df6, #59a0ff);
+    transition: width .45s cubic-bezier(.22,1,.36,1);
+  }
+  [data-estado="erro"] #barra { background: #d9584f; }
+  [data-estado="pronto"] #barra { background: linear-gradient(90deg, #1f9d63, #35c584); }
+  #painel { margin-top: 20px; max-height: 40vh; overflow: auto; }
+  #painel p {
+    margin: 0 0 7px; font-size: 14px; line-height: 1.5; opacity: .88;
+    font-family: var(--f-mono, ui-monospace, monospace);
+  }
+  #painel p:last-child { opacity: 1; }
+</style>
+</head>
+<body>
+
+<div class="caixa">
+  <h1>Ouvindo o vídeo para achar as pausas</h1>
+  <code id="qual"></code>
+  <div class="trilho"><div id="barra"></div></div>
+  <div id="painel"></div>
+</div>
+
+<script src="/js/analise.js"></script>
+</body>
+</html>

package/studio/web/js/analise.js

@@ -0,0 +1,202 @@
+/* Onde estão as pausas — a conta que permite cortá-las.
+ *
+ * "Ele vai cortar as pausas demoradas no vídeo."
+ *
+ * Cortar pausa é escolher trechos, e escolher trechos exige saber onde a fala
+ * para. Ninguém no PrimoCode sabe ler o áudio de um .mp4: o projeto não tem
+ * dependência nenhuma, e o Python da máquina lê WAV e mais nada. O navegador
+ * sabe, desde sempre, em qualquer sistema, sem instalar coisa alguma. Então a
+ * conta acontece aqui e o resultado volta para o agente pelo servidor.
+ *
+ * O método é o de sempre em edição: envelope de energia, limiar relativo ao
+ * que o próprio arquivo tem, e histerese para não picotar a fala.
+ */
+(function () {
+  "use strict";
+
+  var painel = document.getElementById("painel");
+  var barra = document.getElementById("barra");
+
+  function conta(texto) {
+    var p = document.createElement("p");
+    p.textContent = texto;
+    painel.appendChild(p);
+    painel.scrollTop = painel.scrollHeight;
+  }
+
+  function andar(fracao, rotulo) {
+    barra.style.width = Math.round(Math.max(0, Math.min(1, fracao)) * 100) + "%";
+    barra.setAttribute("data-rotulo", rotulo || "");
+  }
+
+  function mmss(s) {
+    s = Math.max(0, s || 0);
+    var m = Math.floor(s / 60);
+    return m + ":" + String(Math.floor(s % 60)).padStart(2, "0");
+  }
+
+  /* ── o envelope ─────────────────────────────────────────────────────────
+     RMS em janelas de 20ms. Pico não serve: um estalo de teclado tem pico de
+     fala e energia de nada, e cortaria a pausa ao meio. */
+  var JANELA = 0.02;
+
+  function envelope(buffer) {
+    var canais = buffer.numberOfChannels;
+    var passo = Math.max(1, Math.round(buffer.sampleRate * JANELA));
+    var quantas = Math.floor(buffer.length / passo);
+    var fora = new Float32Array(quantas);
+    var dados = [];
+    for (var c = 0; c < canais; c++) dados.push(buffer.getChannelData(c));
+
+    for (var j = 0; j < quantas; j++) {
+      var soma = 0;
+      var base = j * passo;
+      for (var c2 = 0; c2 < canais; c2++) {
+        var d = dados[c2];
+        for (var i = 0; i < passo; i++) { var v = d[base + i]; soma += v * v; }
+      }
+      fora[j] = Math.sqrt(soma / (passo * canais));
+    }
+    return fora;
+  }
+
+  /* O limiar sai do PRÓPRIO arquivo. Um número fixo (-40 dB, digamos) trata
+     igual uma gravação de estúdio e um celular num café — e no café ele
+     acharia que não há pausa nenhuma, porque o chão de ruído já passa do
+     limiar. Aqui o chão é a mediana das janelas mais quietas, e a fala é o
+     percentil alto; o corte fica entre os dois, mais perto do chão. */
+  function limiarDe(env) {
+    var ordenado = Float32Array.from(env).sort();
+    var q = function (p) { return ordenado[Math.min(ordenado.length - 1, Math.floor(ordenado.length * p))]; };
+    var chao = q(0.10);
+    var fala = q(0.90);
+    if (!(fala > 0)) return { corte: 0, chao: chao, fala: fala };
+    // Um sexto do caminho entre o silêncio e a fala. Baixo de propósito: é
+    // melhor deixar uma pausa passar do que cortar a última sílaba de uma
+    // frase, que é o defeito que se ouve.
+    return { corte: Math.max(chao * 2.2, chao + (fala - chao) * 0.16), chao: chao, fala: fala };
+  }
+
+  /* Junta as janelas quietas em pausas, com histerese: uma janela alta no meio
+     do silêncio não reabre a fala, e vice-versa. `minimo` é o que conta como
+     "pausa demorada" — abaixo disso é respiração, e cortar respiração deixa a
+     fala robótica. */
+  function acharPausas(env, minimo, corte) {
+    var pausas = [];
+    var inicio = -1;
+    var seguidas = 0;
+    var TOLERA = 3;                    // ~60ms de estalo não encerram a pausa
+    for (var j = 0; j < env.length; j++) {
+      if (env[j] < corte) {
+        if (inicio < 0) inicio = j;
+        seguidas = 0;
+      } else if (inicio >= 0) {
+        seguidas++;
+        if (seguidas > TOLERA) {
+          var fim = j - seguidas;
+          if ((fim - inicio) * JANELA >= minimo) pausas.push([inicio * JANELA, fim * JANELA]);
+          inicio = -1; seguidas = 0;
+        }
+      }
+    }
+    if (inicio >= 0 && (env.length - inicio) * JANELA >= minimo) {
+      pausas.push([inicio * JANELA, env.length * JANELA]);
+    }
+    return pausas;
+  }
+
+  /* O que sobra depois de tirar as pausas — e é isto que o agente usa: a
+     lista de `de`/`ate` para escrever os clipes.
+
+     Cada trecho ganha uma folga nas pontas. Sem ela o corte come o ataque da
+     primeira palavra e a cauda da última, e a edição fica ofegante. */
+  var FOLGA = 0.12;
+
+  function trechosUteis(pausas, duracao) {
+    var trechos = [];
+    var cursor = 0;
+    pausas.forEach(function (p) {
+      var ate = Math.min(duracao, p[0] + FOLGA);
+      if (ate - cursor > 0.35) trechos.push([+cursor.toFixed(2), +ate.toFixed(2)]);
+      cursor = Math.max(0, p[1] - FOLGA);
+    });
+    if (duracao - cursor > 0.35) trechos.push([+cursor.toFixed(2), +duracao.toFixed(2)]);
+    return trechos;
+  }
+
+  /* ── a tarefa ──────────────────────────────────────────────────────────── */
+
+  function responder(id, corpo) {
+    return fetch("/api/analise/" + id, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(corpo),
+    });
+  }
+
+  function rodar(id) {
+    var tarefa;
+    andar(0.05, "buscando o pedido");
+
+    fetch("/api/analise/" + id).then(function (r) {
+      if (!r.ok) throw new Error("este pedido de análise não existe mais");
+      return r.json();
+    }).then(function (t) {
+      tarefa = t;
+      document.getElementById("qual").textContent = t.arquivo;
+      conta("Lendo " + t.arquivo + "…");
+      andar(0.15, "baixando o áudio");
+      return fetch(t.arquivo);
+    }).then(function (r) {
+      if (!r.ok) throw new Error("não consegui abrir o arquivo");
+      return r.arrayBuffer();
+    }).then(function (bruto) {
+      conta((bruto.byteLength / 1048576).toFixed(1) + " MB lidos. Decodificando o áudio…");
+      andar(0.35, "decodificando");
+      var Ctx = window.AudioContext || window.webkitAudioContext;
+      return new Ctx().decodeAudioData(bruto);
+    }).then(function (buffer) {
+      conta("Áudio de " + mmss(buffer.duration) + " a " + buffer.sampleRate + " Hz.");
+      andar(0.6, "medindo a energia");
+
+      var env = envelope(buffer);
+      var lim = limiarDe(env);
+      andar(0.85, "achando as pausas");
+
+      var pausas = acharPausas(env, tarefa.pausa || 0.6, lim.corte);
+      var trechos = trechosUteis(pausas, buffer.duration);
+      var somaTrechos = trechos.reduce(function (s, t) { return s + (t[1] - t[0]); }, 0);
+
+      conta(pausas.length + " pausa(s) de mais de " + (tarefa.pausa || 0.6) + "s.");
+      conta("Sobram " + trechos.length + " trecho(s), somando " + mmss(somaTrechos) +
+        " de " + mmss(buffer.duration) + ".");
+      andar(1, "pronto");
+
+      return responder(id, {
+        duracao: +buffer.duration.toFixed(2),
+        pausas: pausas.map(function (p) { return [+p[0].toFixed(2), +p[1].toFixed(2)]; }),
+        trechos: trechos,
+        cortado: +(buffer.duration - somaTrechos).toFixed(2),
+      }).then(function () {
+        conta("Resultado entregue ao PrimoCode. Pode fechar esta aba.");
+        document.body.setAttribute("data-estado", "pronto");
+        // Fecha sozinha quando foi o CLI que abriu: ninguém pediu uma aba,
+        // pediram um vídeo editado.
+        setTimeout(function () { try { window.close(); } catch (e) {} }, 2500);
+      });
+    }).catch(function (e) {
+      conta("Não deu: " + e.message);
+      document.body.setAttribute("data-estado", "erro");
+      andar(1, "erro");
+      responder(id, { erro: e.message }).catch(function () {});
+    });
+  }
+
+  var id = (location.hash || "").replace(/^#/, "").trim();
+  if (!/^[a-z0-9]+$/.test(id)) {
+    conta("Esta página é aberta pelo PrimoCode quando ele precisa ouvir um vídeo seu.");
+    document.body.setAttribute("data-estado", "erro");
+  } else {
+    rodar(id);
+  }
+})();