primocode 9.10.0 → 10.0.9

package/lib/tools.js

@@ -61,6 +61,8 @@ async function clicarPeloCursor(x, y, { botao = 'left', duplo = false, rotulo }
         () => (duplo ? desktop.doubleClick(nx, ny) : desktop.click(nx, ny, botao)));
 }
 const referencia = require('./referencia');
+const snapshot = require('./snapshot');
+const casar = require('./casar');
 const estudio = require('./estudio');
 const cfg = require('./config');
 
@@ -85,7 +87,8 @@ function resolveInProject(rawPath, projectDir) {
     }
     const target = path.resolve(base, rawPath || '.');
     const rel = path.relative(base, target);
-    if (rel.startsWith('..') || path.isAbsolute(rel)) {
+    // `..` como SEGMENTO, não como começo de nome: "..rascunho" é legítimo.
+    if (rel === '..' || rel.startsWith('..' + path.sep) || rel.startsWith('../') || path.isAbsolute(rel)) {
         throw new Error(`Caminho fora da pasta de trabalho: ${rawPath}`);
     }
     return target;
@@ -100,7 +103,10 @@ function treeDir(dir, maxDepth = 2, currentDepth = 0, prefix = '') {
         for (const item of items) {
             if (item.startsWith('.') && item !== '.env') continue;
             if (IGNORAR.has(item)) continue;
-            (fs.statSync(path.join(dir, item)).isDirectory() ? dirs : files).push(item);
+            // Link quebrado não derruba a listagem inteira: entra como arquivo.
+            let ehPasta = false;
+            try { ehPasta = fs.statSync(path.join(dir, item)).isDirectory(); } catch { ehPasta = false; }
+            (ehPasta ? dirs : files).push(item);
         }
         dirs.sort(); files.sort();
         const all = [...dirs, ...files];
@@ -109,7 +115,7 @@ function treeDir(dir, maxDepth = 2, currentDepth = 0, prefix = '') {
             const isLast = i === all.length - 1;
             result += prefix + (isLast ? '└── ' : '├── ') + item + '\n';
             const full = path.join(dir, item);
-            if (fs.statSync(full).isDirectory() && currentDepth < maxDepth) {
+            if (dirs.includes(item) && currentDepth < maxDepth) {
                 result += treeDir(full, maxDepth, currentDepth + 1, prefix + (isLast ? '    ' : '│   '));
             }
         }
@@ -262,7 +268,19 @@ async function runInNewTerminal(command, cwd) {
            como ~/Documents/Meus Projetos virava dois argumentos e o cd falhava
            calado: o terminal abria na pasta errada e o comando rodava no lugar
            errado, que é pior que não abrir. */
-        cmd = `osascript -e 'tell application "Terminal" to do script "cd ${pastaAlvo.replace(/ /g, '\\\\ ')} && ${command}"'`;
+        /* Sem shell no meio: o script vai como UM argumento do osascript
+           (execFile), e dentro dele a string do AppleScript é escapada (\\ e
+           \"). Antes o comando entrava cru entre aspas duplas dentro de aspas
+           simples — `node server.js --name="x"` quebrava o AppleScript. A
+           pasta vai entre aspas simples para o shell do Terminal (a aspa
+           simples está barrada acima). */
+        const doTerminal = `cd '${pastaAlvo}' && ${command}`;
+        const script = `tell application "Terminal" to do script "${doTerminal.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+        return new Promise((resolve) => {
+            execFile('osascript', ['-e', script], { timeout: 60000 }, (erro, _o, stderr) => {
+                resolve(erro ? { ok: false, error: String(stderr || erro.message).trim() || 'falhou' } : { ok: true, opener: 'osascript' });
+            });
+        });
     } else if (p === 'win32') {
         // Aspas em volta do caminho: "C:\Users\Joel Silva\..." é comum, e sem
         // elas o cmd corta no espaço. A aspa dupla já está barrada acima, então
@@ -273,7 +291,8 @@ async function runInNewTerminal(command, cwd) {
            o caminho não precisa entrar na string de shell nenhuma. É a solução
            mais segura das três: o que não é interpolado não pode ser mal
            escapado. */
-        cmd = `x-terminal-emulator -e "bash -c '${command}; exec bash'"`;
+        // A aspa simples do comando fecharia o `bash -c '…'`: vira '\''.
+        cmd = `x-terminal-emulator -e "bash -c '${String(command).replace(/'/g, "'\\''")}; exec bash'"`;
         pastaDoProcesso = pastaAlvo;
     }
     const r = await runShell(cmd, 60000, pastaDoProcesso);
@@ -315,7 +334,19 @@ function editFile({ path: rawPath, old_string, new_string, replace_all }, projec
     const original = fs.readFileSync(filePath, 'utf-8');
     const ocorrencias = original.split(old_string).length - 1;
 
+    // Não bateu letra por letra: o casador frouxo (lib/casar.js) acha o
+    // trecho com o espaço, a indentação ou o número de linha errados — desde
+    // que seja UM lugar só. Poupa a volta "não achei → relê → edita de novo".
+    let casado = null;
     if (ocorrencias === 0) {
+        const r = casar.achar(original, old_string);
+        if (r.erro === 'varios') {
+            return { ok: false, error: `Trecho aparece ${r.vezes} vezes (${r.como}). Inclua mais linhas em volta para ficar único.` };
+        }
+        if (!r.erro) casado = r;
+    }
+
+    if (ocorrencias === 0 && !casado) {
         // Erro seco faz o modelo chutar de novo. Devolvendo o que EXISTE no
         // arquivo, ele acerta na segunda tentativa.
         return {
@@ -329,15 +360,18 @@ function editFile({ path: rawPath, old_string, new_string, replace_all }, projec
         return { ok: false, error: `Trecho aparece ${ocorrencias} vezes. Inclua mais linhas em volta para ficar único, ou use replace_all.` };
     }
 
-    const atualizado = replace_all
-        ? original.split(old_string).join(new_string ?? '')
-        : original.replace(old_string, new_string ?? '');
+    const atualizado = casado
+        ? original.slice(0, casado.inicio) + (new_string ?? '') + original.slice(casado.fim)
+        : replace_all
+            ? original.split(old_string).join(new_string ?? '')
+            : original.replace(old_string, () => new_string ?? '');
 
     fs.writeFileSync(filePath, atualizado, 'utf-8');
     return {
         ok: true,
         path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
-        substituicoes: replace_all ? ocorrencias : 1,
+        substituicoes: replace_all && !casado ? ocorrencias : 1,
+        casouPor: casado ? casado.como : undefined,
         linhasAntes: original.split('\n').length,
         linhasDepois: atualizado.split('\n').length,
         // As duas versões, para a TELA desenhar o diff. O `_` na frente marca
@@ -368,6 +402,13 @@ function readFile({ path: rawPath, offset, limit }, projectDir) {
         };
     }
 
+    /* Arquivo pequeno vem INTEIRO, mesmo pedido aos pedaços: o modelo lia um
+       app.js de 393 linhas de 50 em 50, cada pedaço uma ida ao servidor
+       (teste da loja, 01/10). Inteiro, uma vez, custa menos. */
+    if (todas.length <= 400 && bruto.length <= 40000) {
+        return { ok: true, content: todas.map((l, i) => `${i + 1}\t${l}`).join('\n'), linhas: todas.length, bytes: bruto.length,
+            inteiro: true, dica: 'arquivo pequeno: veio inteiro, com o número das linhas — não precisa ler de novo' };
+    }
     const inicio = Math.max(0, (offset || 1) - 1);
     const fim = Math.min(todas.length, inicio + (limit || 200));
     const recorte = todas.slice(inicio, fim).map((l, i) => `${inicio + i + 1}\t${l}`).join('\n');
@@ -391,12 +432,21 @@ function multiEdit({ path: rawPath, edits }, projectDir) {
         if (old_string === new_string) return { ok: false, error: `edit ${i + 1}: old_string e new_string são iguais` };
         const ocorrencias = conteudo.split(old_string).length - 1;
         if (ocorrencias === 0) {
-            return { ok: false, error: `edit ${i + 1}: trecho não encontrado`, trechosParecidos: trechosParecidos(conteudo, old_string) };
+            const r = casar.achar(conteudo, old_string);
+            if (r.erro === 'varios') {
+                return { ok: false, error: `edit ${i + 1}: trecho aparece ${r.vezes}x (${r.como}) — inclua mais contexto para torná-lo único` };
+            }
+            if (r.erro) {
+                return { ok: false, error: `edit ${i + 1}: trecho não encontrado`, trechosParecidos: trechosParecidos(conteudo, old_string) };
+            }
+            conteudo = conteudo.slice(0, r.inicio) + (new_string ?? '') + conteudo.slice(r.fim);
+            substituicoes++;
+            continue;
         }
         if (ocorrencias > 1 && !replace_all) {
             return { ok: false, error: `edit ${i + 1}: trecho aparece ${ocorrencias}x — use replace_all ou inclua mais contexto para torná-lo único` };
         }
-        conteudo = replace_all ? conteudo.split(old_string).join(new_string ?? '') : conteudo.replace(old_string, new_string ?? '');
+        conteudo = replace_all ? conteudo.split(old_string).join(new_string ?? '') : conteudo.replace(old_string, () => new_string ?? '');
         substituicoes++;
     }
 
@@ -517,6 +567,14 @@ async function despachar(name, args, ctx) {
                 const alvo = /^https?:\/\//i.test(args.target || '')
                     ? args.target
                     : resolveInProject(args.target, projectDir);
+                /* Site da web abre À VISTA no Chrome controlado (o cursor vai na
+                   barra e digita). Arquivo do projeto continua no navegador padrão. */
+                if (/^https?:/i.test(alvo) && process.env.PRIMOCODE_BROWSER_HEADLESS !== '1' && require('./cursor').disponivel()) {
+                    try {
+                        const r = await browser.abrirVisivel(alvo);
+                        if (r && r.ok !== false) return { ok: true, opener: 'chrome à vista', url: r.url, pagina: await browser.retrato(40), comoUsar: snapshot.COMO_USAR };
+                    } catch { /* cai no navegador padrão */ }
+                }
                 return openInBrowser(alvo);
             }
             case 'multi_edit':
@@ -527,11 +585,14 @@ async function despachar(name, args, ctx) {
             // Pesquisa de referência: abre documentação e exemplos sobre o
             // pedido e devolve o TEXTO para o modelo aprender antes de
             // escrever. Aparece no terminal, com as fontes — nada oculto.
-            case 'pesquisar_referencia':
-                return referencia.pesquisar({
+            case 'pesquisar_referencia': {
+                const r = await referencia.pesquisar({
                     consulta: args.consulta || args.query || '',
                     paginas: Math.max(1, Math.min(5, Number(args.paginas) || 3)),
                 });
+                // Escopo fechado ("só do site x.com"): o buscador devolve o mundo; aqui só passa o site.
+                return require('./estudio/referencias.js').filtrar(r);
+            }
 
             // memory-geral.md fica FORA da pasta do projeto — write_file/edit_file
             // não alcançam por design (resolveInProject bloqueia ../ de propósito).
@@ -544,24 +605,41 @@ async function despachar(name, args, ctx) {
             }
 
             // ── Navegador controlado (CDP) — o agente age numa página real ──
+            /* O navegador fala em REFS (lib/snapshot.js): abrir e clicar já
+               devolvem o retrato da página com "@e3 [button] Entrar", e o
+               selector aceita "@e3". Uma leitura a menos por passo, e nenhum
+               seletor CSS chutado. */
             case 'browser_open': {
                 const alvo = /^https?:\/\//i.test(args.url || '')
                     ? args.url
                     : 'file://' + resolveInProject(args.url, projectDir);
-                return browser.open(alvo);
+                // Endereço da web abre À VISTA: o cursor vai na barra e digita (browser.abrirVisivel).
+                const r = /^https?:/i.test(alvo) ? await browser.abrirVisivel(alvo) : await browser.open(alvo);
+                return r && r.ok !== false ? { ...r, pagina: await browser.retrato(40), comoUsar: snapshot.COMO_USAR } : r;
+            }
+            case 'browser_click': {
+                let r;
+                if (args.selector || snapshot.ehRef(args.text)) r = await browser.clickSelector(snapshot.seletorDaRef(args.selector || args.text));
+                else if (args.text) r = await browser.clickText(args.text);
+                else if (args.x != null && args.y != null) r = await browser.click(args.x, args.y);
+                else return { ok: false, error: 'browser_click precisa de selector (ou a ref "@e3"), text ou x/y' };
+                // O clique quase sempre muda a página: o retrato novo vai junto.
+                await new Promise((ok) => setTimeout(ok, 500));
+                return r && r.ok !== false ? { ...r, pagina: await browser.retrato(40) } : r;
             }
-            case 'browser_click':
-                if (args.selector) return browser.clickSelector(args.selector);
-                if (args.text) return browser.clickText(args.text);
-                if (args.x != null && args.y != null) return browser.click(args.x, args.y);
-                return { ok: false, error: 'browser_click precisa de selector, text ou x/y' };
             case 'browser_type':
-                if (args.selector) return browser.typeInSelector(args.selector, args.text || '', args.clear !== false);
+                if (args.selector) return browser.typeInSelector(snapshot.seletorDaRef(args.selector), args.text || '', args.clear !== false);
                 return browser.type(args.text || '');
             case 'browser_key':
                 return browser.key(args.key);
             case 'browser_read': {
-                const sel = args.selector ? `document.querySelector(${JSON.stringify(args.selector)})` : 'document.body';
+                if (!args.selector) {
+                    const pagina = await browser.retrato(80);
+                    const texto = await browser.evaluate('(function(){return document.body?document.body.innerText.slice(0,2500):null;})()');
+                    if (!pagina && texto == null) return { ok: false, error: 'nada na página — ela pode não ter carregado' };
+                    return { ok: true, pagina, text: texto || '', comoUsar: snapshot.COMO_USAR };
+                }
+                const sel = `document.querySelector(${JSON.stringify(snapshot.seletorDaRef(args.selector))})`;
                 const texto = await browser.evaluate(`(function(){const e=${sel};return e?e.innerText.slice(0,6000):null;})()`);
                 return texto == null ? { ok: false, error: 'nada na página (ou seletor não encontrado)' } : { ok: true, text: texto };
             }
@@ -573,7 +651,7 @@ async function despachar(name, args, ctx) {
             case 'browser_scroll':
                 return browser.scroll(args.dy != null ? args.dy : 600);
             case 'browser_wait':
-                return browser.waitFor(args.selector, args.timeout_ms || 15000);
+                return browser.waitFor(snapshot.seletorDaRef(args.selector), args.timeout_ms || 15000);
             case 'browser_eval':
                 return { ok: true, value: await browser.evaluate(args.js || 'null') };
 

package/lib/ui.js

@@ -310,11 +310,11 @@ const TIPS = [
 ];
 
 const NEWS = [
-    'Vídeo com DIRETOR: roteiro, narração e voz decididos antes de produzir',
-    'Ele busca e baixa imagem, logo e música — com a licença junto do arquivo',
-    '/voice abre o Primo Code Voice · /marketplace instala skills',
-    'Do "high" para cima ele PESQUISA referências antes de escrever',
-    'Esc Esc a qualquer momento para o agente no meio do trabalho',
+    'A IA decide o caminho: skills e equipe num cardápio, ela escolhe o que usa',
+    'Até 8 agentes em paralelo, cada um volta com uma entrega — e passa a vez',
+    'Edite falando no vídeo: primocode video auto aplica o que você diz, na hora',
+    'Colou texto grande? Vira etiqueta [Colado #1 · N linhas] na caixa',
+    'Escopo fechado de verdade: "só do site x.com" filtra a pesquisa',
 ];
 
 // ── Cabeçalho ────────────────────────────────────────────────────────────
@@ -413,29 +413,70 @@ class Spinner {
         this.text = this.textos[0];
         this.frames = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
         this.i = 0; this.timer = null; this.desde = 0; this.largura = 0;
+        this.detalhe = '';   // o que está chegando agora (act.js atualiza)
     }
     start() {
         // Fora de um terminal (pipe, CI) a animação só sujaria a saída.
         if (!process.stdout.isTTY) return this;
         this.desde = Date.now();
+        /* Com a caixa de digitar no ar, o spinner desenha DENTRO dela (ver
+           mostrarSpinner em lib/entrada.js): escrever "\r" por cima apagava
+           a caixa e a barra de status enquanto ele girava. */
+        const caixa = Spinner.caixa;
+        if (caixa && caixa.mostrarSpinner && caixa.desenhado !== undefined) {
+            this.naCaixa = caixa;
+            this.timer = setInterval(() => {
+                if (this.textos.length > 1) this.text = this.textos[Math.floor((Date.now() - this.desde) / 4000) % this.textos.length];
+                const seg = Math.floor((Date.now() - this.desde) / 1000);
+                const extra = (seg >= 3 ? ` · ${seg}s` : '') + (this.detalhe ? ` · ${this.detalhe}` : '');
+                caixa.mostrarSpinner(`${c.muted(this.frames[this.i])} ${c.muted(this.text)}${c.dim(extra)}`);
+                this.i = (this.i + 1) % this.frames.length;
+            }, 120);
+            return this;
+        }
         this.timer = setInterval(() => {
             // Com mais de uma frase, troca a cada 4s. A frase nova pode ser mais
             // curta que a anterior: o resto da linha velha ficaria na tela, então
             // a linha é sempre preenchida até a maior largura já escrita.
             if (this.textos.length > 1) this.text = this.textos[Math.floor((Date.now() - this.desde) / 4000) % this.textos.length];
-            const cru = `  ${this.frames[this.i]} ${this.text}`;
+            /* O relógio e o que está chegando. "Parece travado" era isto: a
+               mesma frase girando por um minuto inteiro enquanto o modelo
+               escrevia um arquivo grande. Com os segundos contando (e o que
+               já chegou, quando há), quem olha sabe que está andando. */
+            const seg = Math.floor((Date.now() - this.desde) / 1000);
+            const extra = (seg >= 3 ? ` · ${seg}s` : '') + (this.detalhe ? ` · ${this.detalhe}` : '');
+            const cru = `  ${this.frames[this.i]} ${this.text}${extra}`;
             const falta = Math.max(0, this.largura - cru.length);
             this.largura = Math.max(this.largura, cru.length);
-            process.stdout.write(`\r  ${c.muted(this.frames[this.i])} ${c.muted(this.text)}${' '.repeat(falta)}`);
+            process.stdout.write(`\r  ${c.muted(this.frames[this.i])} ${c.muted(this.text)}${c.dim(extra)}${' '.repeat(falta)}`);
             this.i = (this.i+1) % this.frames.length;
         }, 80);
         return this;
     }
     stop() {
+        if (this.naCaixa) {
+            if (this.timer) { clearInterval(this.timer); this.timer = null; }
+            this.naCaixa.mostrarSpinner('');
+            this.naCaixa = null;
+            return;
+        }
         if (this.timer) { clearInterval(this.timer); this.timer = null; process.stdout.write(`\r${' '.repeat(Math.max(80, this.largura + 4))}\r`); }
     }
 }
 
+/* O TÍTULO DO TERMINAL: é por ele que o Orca (e qualquer terminal com abas)
+   sabe que este painel é um agente e se está trabalhando. O Orca lê o glifo
+   de spinner em braile como "trabalhando" e o nome como identidade — então
+   "⠋ PrimoCode — tarefa" enquanto trabalha, "PrimoCode" parado. Vai pelo
+   canal cru da caixa: pelo stdout embrulhado, um escape sem quebra de linha
+   deixaria a caixa apagada (o mesmo defeito do spinner). */
+function titulo(texto) {
+    if (!process.stdout.isTTY || process.env.PRIMOCODE_SEM_TITULO === '1') return;
+    const limpo = String(texto || '').replace(/[\x00-\x1f\x7f]/g, ' ').slice(0, 80);
+    const escrever = Spinner.caixa && Spinner.caixa.escreverCru ? Spinner.caixa.escreverCru : (s) => process.stdout.write(s);
+    try { escrever(`\x1b]0;${limpo}\x07`); } catch { /* terminal fechado */ }
+}
+
 // O rótulo de cada tool na tela — o que a pessoa lê no lugar do nome interno.
 const ROTULOS = {
         read_file:'Read', write_file:'Write', edit_file:'Edit', multi_edit:'MultiEdit',
@@ -609,4 +650,5 @@ function friendlyError(raw) {
 }
 
 
-module.exports = { c, mascot, MASCOTES, resolverMascote, mascoteInfo, galeriaMascotes, reacao, welcomeBox, Spinner, PENSANDO, actionHeader, friendlyError, visibleWidth, stripAnsi, truncate, padRight };
+module.exports = {
+    titulo, c, mascot, MASCOTES, resolverMascote, mascoteInfo, galeriaMascotes, reacao, welcomeBox, Spinner, PENSANDO, actionHeader, friendlyError, visibleWidth, stripAnsi, truncate, padRight };

package/lib/video/analise.js

@@ -0,0 +1,89 @@
+/**
+ * analise.js — silêncio e batida, como conta pura sobre números medidos.
+ *
+ * O ffmpeg mede (onde o áudio fica abaixo do limiar; as amostras cruas), e
+ * as decisões ficam aqui, testáveis sem áudio nenhum:
+ *
+ *   · o SILÊNCIO vira trecho da linha do tempo com `padding` de respiro em
+ *     cada ponta — cortar no exato instante em que a voz volta é o que faz
+ *     corte automático soar como máquina (lib/estudio/video.js conta a mesma
+ *     história). O silêncio no começo e no fim do arquivo sai inteiro;
+ *   · a BATIDA é o pico de subida de energia (onset), com limiar que se
+ *     adapta ao volume da música em volta. Não é um detector de tempo de
+ *     estúdio; é o bastante para cortar no ritmo.
+ */
+
+'use strict';
+
+const T = require('./timeline.js');
+
+/**
+ * Os trechos (quadros da linha do tempo) a apagar, dados os silêncios de
+ * cada mídia em segundos da origem: {assetId: [{de, ate}]}.
+ */
+function trechosDeSilencio(tl, clipes, silencios, { padding = 0.15, minimo = 2 } = {}) {
+    const ranges = [];
+    for (const c of clipes) {
+        const lista = silencios[c.asset] || [];
+        const dur = (tl.assets[c.asset] || {}).seconds || Infinity;
+        const { de, ate } = T.janelaOrigem(tl, c);
+        for (const s of lista) {
+            const a = s.de <= 0.05 ? s.de : s.de + padding;
+            const b = s.ate >= dur - 0.05 ? s.ate : s.ate - padding;
+            const ia = Math.max(a, de);
+            const ib = Math.min(b, ate);
+            if (ib <= ia) continue;
+            const fa = T.origemParaQuadro(tl, c, ia);
+            const fb = T.origemParaQuadro(tl, c, ib);
+            if (fb - fa >= minimo) ranges.push([fa, fb]);
+        }
+    }
+    return ranges;
+}
+
+/** Amostras (Float32, mono) → {bpm, beats: [segundos]}. */
+function batidas(amostras, taxa, { sensibilidade = 1.4, minimoEntre = 0.22 } = {}) {
+    const hop = Math.max(64, Math.round(taxa * 0.0116));      // ~11,6 ms
+    const janela = hop * 2;
+    const energia = [];
+    for (let i = 0; i + janela <= amostras.length; i += hop) {
+        let s = 0;
+        for (let j = i; j < i + janela; j++) s += amostras[j] * amostras[j];
+        energia.push(Math.log(1e-9 + s / janela));
+    }
+    const onset = energia.map((e, i) => (i ? Math.max(0, e - energia[i - 1]) : 0));
+    const porSeg = taxa / hop;
+    const raio = Math.round(porSeg * 0.5);
+    const beats = [];
+    let ultimo = -Infinity;
+    for (let i = 1; i < onset.length - 1; i++) {
+        const a = Math.max(0, i - raio);
+        const b = Math.min(onset.length, i + raio);
+        let soma = 0;
+        let soma2 = 0;
+        for (let j = a; j < b; j++) { soma += onset[j]; soma2 += onset[j] * onset[j]; }
+        const n = b - a;
+        const media = soma / n;
+        const dp = Math.sqrt(Math.max(0, soma2 / n - media * media));
+        const limiar = media + sensibilidade * dp;
+        let pico = onset[i] > limiar && onset[i] > 0.3;
+        for (let j = Math.max(0, i - 3); pico && j <= Math.min(onset.length - 1, i + 3); j++) if (onset[j] > onset[i]) pico = false;
+        const t = (i * hop) / taxa;
+        if (pico && t - ultimo >= minimoEntre) { beats.push(Math.round(t * 1000) / 1000); ultimo = t; }
+    }
+    return { bpm: bpmDe(beats), beats };
+}
+
+function bpmDe(beats) {
+    if (beats.length < 4) return null;
+    const iv = [];
+    for (let i = 1; i < beats.length; i++) iv.push(beats[i] - beats[i - 1]);
+    iv.sort((a, b) => a - b);
+    let med = iv[Math.floor(iv.length / 2)];
+    let bpm = 60 / med;
+    while (bpm < 70) bpm *= 2;
+    while (bpm > 180) bpm /= 2;
+    return Math.round(bpm);
+}
+
+module.exports = { trechosDeSilencio, batidas, bpmDe };