primocode 10.13.0 → 10.14.0

package/lib/estudio/maquina-som.js

@@ -0,0 +1,478 @@
+/**
+ * maquina-som.js — o som de verdade do motion: efeitos CC0 reais, escolhidos POR AÇÃO e por assunto.
+ *
+ * Os efeitos sintetizados (sons-leves.js) soavam genéricos. Aqui a biblioteca vem do Openverse
+ * (freesound, licença cc0/pdm), guardada em ~/.primocode/studio/sfx/<categoria>/<id>.mp3 com a licença
+ * ao lado (<id>.licenca.json). O kit JSX escreve o EVENTO ("sino", "notif", "troca"…); o Node decide
+ * QUAL arquivo toca: nunca o mesmo em sequência, nunca o mesmo numa janela de 1,5 s, e o assunto muda
+ * a preferência (padaria: forno e sino; clínica: notificação e toque; app: teclas e clique).
+ *
+ *   prepararBiblioteca({assunto, acoes, pasta, rede, minPorCategoria}) → índice {categoria:[{arquivo,...}]}
+ *   escolherSons(eventos, {assunto, indice, semente})                  → [{t, arquivo|null, tipo, ganho, acao, rate}]
+ *   encaixarNaBatida(sons, batidas, {tolerancia})                      → sons com o t puxado para a batida
+ *   mixar({pasta, mudo, saida, sons, trilha, voz, duracao})            → {ok, video, lufs, eventos, reservas, ...}
+ *
+ * Sem rede e sem cache, `arquivo` vem null e o mixar usa o som leve sintetizado (reserva).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PASTA_PADRAO = () => path.join(os.homedir(), '.primocode', 'studio', 'sfx');
+const API = 'https://api.openverse.org/v1/audio/';
+
+/** Categoria → consultas (em inglês, é como o freesound indexa) e duração máxima do arquivo final. */
+const CATEGORIAS = {
+    whoosh: { q: ['whoosh', 'whoosh transition', 'air whoosh'], max: 0.8 },
+    swoosh: { q: ['swoosh', 'swish', 'fast swipe'], max: 0.7 },
+    pop: { q: ['pop', 'bubble pop', 'cartoon pop'], max: 0.6 },
+    click: { q: ['mouse click', 'ui click', 'button click'], max: 0.4 },
+    tap: { q: ['tap', 'finger tap', 'touch screen tap'], max: 0.5 },
+    typing: { q: ['keyboard typing', 'typing keys', 'typewriter key'], max: 1.6 },
+    notification: { q: ['notification', 'message alert ding', 'phone notification'], max: 1.6 },
+    riser: { q: ['riser', 'build up riser', 'sweep rise'], max: 3.5 },
+    impact: { q: ['impact', 'boom hit', 'cinematic hit'], max: 1.8 },
+    bell: { q: ['bell ding', 'chime', 'service bell'], max: 2.0 },
+    cash: { q: ['cash register', 'coin', 'money cha-ching', 'coin drop', 'coins jingle', 'ka-ching'], max: 1.8 },
+    paper: { q: ['paper rustle', 'paper flip', 'page turn'], max: 1.2 },
+    glass: { q: ['glass clink', 'glass ping', 'glass tap'], max: 1.4 },
+    oven: { q: ['oven timer', 'oven ding timer', 'kitchen timer', 'microwave beep', 'timer bell ring', 'oven door'], max: 2.0 },
+    // o banco de MOTION: o que dá peso a corte, troca e pouso (Kenney CC0 + Freesound CC0)
+    swish: { q: ['swish', 'fast swish', 'cloth swish'], max: 0.6 },
+    transicao: { q: ['transition swoosh', 'whoosh transition fast', 'swoosh impact transition'], max: 1.4 },
+    downlifter: { q: ['downlifter', 'reverse down sweep', 'power down', 'falling sweep', 'descending whoosh'], max: 2.2 },
+    hit: { q: ['hit', 'punch hit', 'cinematic hit short'], max: 1.2 },
+    glitch: { q: ['glitch', 'digital glitch', 'data glitch'], max: 0.9 },
+    subdrop: { q: ['sub drop', 'bass drop impact', 'low boom', 'sub bass hit', 'deep impact boom'], max: 2.2 },
+    shimmer: { q: ['shimmer', 'magic sparkle', 'glitter chime'], max: 1.8 },
+    suave: { q: ['soft thud', 'gentle impact soft', 'soft hit pillow'], max: 0.9 },
+};
+
+/** Ação (o `tipo` do evento SOM do kit) → categorias, da preferida para a reserva. */
+const ACOES = {
+    // SFX de motion são ACENTOS, não bombas: whoosh curto, swish, pop, click, tick, shimmer. Sem sub-drop, sem impacto pesado, sem riser.
+    troca: ['swish', 'whoosh', 'swoosh'], whoosh: ['whoosh', 'swish'], swoosh: ['swoosh', 'swish', 'whoosh'], sopro: ['swish'], swish: ['swish', 'swoosh'],
+    hit: ['suave'], glitch: ['glitch'], shimmer: ['shimmer', 'glass', 'bell'], desce: ['downlifter'],
+    pop: ['pop', 'tap'], bolha: ['pop'], ponto1: ['pop', 'tap'], ponto2: ['pop', 'tap'], ponto3: ['pop', 'tap'], ponto4: ['pop', 'tap'], ponto5: ['pop', 'tap'],
+    clique: ['click', 'tap'], mouse: ['click'], tap: ['tap', 'click'], toque: ['tap', 'pop'],
+    tique: ['click', 'typing'], tick: ['click', 'typing'], digital: ['click', 'typing'], digita: ['typing', 'click'],
+    notif: ['notification', 'bell'], sobe: ['swish'], subida: ['swish'],
+    impacto: ['suave'], sub: ['suave'],
+    brilho: ['shimmer', 'bell', 'glass'], sino: ['bell', 'glass'], caixa: ['cash', 'bell'], papel: ['paper'], vidro: ['glass', 'bell'],
+};
+/** Arquivos que não entram mais (pesados, de motor, laser, explosão, impacto de metal/soco): o Joel achou "explosivo". */
+const BLOQUEADOS = /^k-(space|engine|thruster|door|laser|explosion|lowfrequency|lowdown|impactmetal|impactplate|impactpunch|impactmining|impacttin|impactwood|impactbell|forcefield-00[34]|powerup|phaseup)/;
+
+
+/** O assunto muda a preferência: regex → categorias a garantir na biblioteca e ações que preferem outras categorias. */
+const TEMAS = [
+    { nome: 'padaria', re: /p[aã]o|padaria|forno|confeit|bolo|caf[eé]|cozinha|restaurante|doce|pizza/i, extras: ['oven', 'bell', 'paper'], prefere: { sino: ['bell', 'oven'], brilho: ['bell'], notif: ['bell', 'oven'], pop: ['pop'], toque: ['bell', 'tap'] } },
+    { nome: 'clinica', re: /cl[ií]nica|est[eé]tica|beleza|sal[aã]o|spa|pele|sa[uú]de|m[eé]dic|dent|cliente|agenda/i, extras: ['notification', 'glass', 'bell'], prefere: { notif: ['notification'], brilho: ['glass', 'bell'], sino: ['glass', 'bell'], toque: ['tap', 'notification'], vidro: ['glass'] } },
+    { nome: 'financas', re: /finan|dinheiro|invest|banco|cr[eé]dito|gasto|or[cç]amento|cart[aã]o|poupan|moeda|cash/i, extras: ['cash', 'notification', 'click', 'typing'], prefere: { caixa: ['cash'], brilho: ['cash', 'bell'], sino: ['cash', 'bell'], notif: ['notification'], tique: ['click'], digita: ['typing'] } },
+    { nome: 'software', re: /app\b|saas|software|c[oó]digo|program|tecnolog|\bia\b|intelig|primocode|sistema|plataforma|dados|site|digital|startup/i, extras: ['typing', 'click', 'riser'], prefere: { digita: ['typing'], clique: ['click'], tique: ['click', 'typing'], sobe: ['riser'], brilho: ['glass', 'bell'], sino: ['notification', 'bell'] } },
+];
+const temaDe = (assunto) => TEMAS.find((t) => t.re.test(String(assunto || ''))) || null;
+
+// ── utilidades ───────────────────────────────────────────────────────────
+
+function ff(args, { timeout = 60000 } = {}) {
+    const r = spawnSync('ffmpeg', ['-y', '-hide_banner', '-loglevel', 'error', ...args], { encoding: 'utf8', timeout, maxBuffer: 64 * 1024 * 1024 });
+    return { ok: r.status === 0, saida: ((r.stdout || '') + (r.stderr || '')).trim() };
+}
+function duracaoDe(arq) {
+    const r = spawnSync('ffprobe', ['-v', 'error', '-show_entries', 'format=duration', '-of', 'default=nw=1:nk=1', arq], { encoding: 'utf8' });
+    const d = parseFloat(String(r.stdout || '').trim());
+    return isNaN(d) ? null : d;
+}
+function picoDe(arq) {
+    const r = spawnSync('ffmpeg', ['-hide_banner', '-nostats', '-i', arq, '-af', 'volumedetect', '-f', 'null', '-'], { encoding: 'utf8' });
+    const m = String(r.stderr || '').match(/max_volume:\s*(-?[\d.]+) dB/);
+    return m ? Number(m[1]) : null;
+}
+/** O LUFS integrado do arquivo (ebur128), ou null (silêncio total). */
+function medirLufs(arq) {
+    const r = spawnSync('ffmpeg', ['-hide_banner', '-nostats', '-i', arq, '-vn', '-af', 'ebur128=peak=true', '-f', 'null', '-'], { encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
+    const s = String(r.stderr || '');
+    const m = s.slice(s.lastIndexOf('Summary:')).match(/I:\s+(-?\d+(?:\.\d+)?)\s+LUFS/);
+    return m ? Number(m[1]) : null;
+}
+function mulberry(a) {
+    let s = (a >>> 0) || 1;
+    return () => { s |= 0; s = (s + 0x6D2B79F5) | 0; let t = Math.imul(s ^ (s >>> 15), 1 | s); t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; return ((t ^ (t >>> 14)) >>> 0) / 4294967296; };
+}
+
+// ── a biblioteca ─────────────────────────────────────────────────────────
+
+/** Lê o que há em disco: {categoria:[{arquivo, titulo, autor, licenca, segundos, id}]}. A pasta é a verdade; o indice.json é cópia. */
+function lerIndice(pasta = PASTA_PADRAO()) {
+    const indice = {};
+    if (!fs.existsSync(pasta)) return indice;
+    for (const cat of fs.readdirSync(pasta, { withFileTypes: true })) {
+        if (!cat.isDirectory() || cat.name.startsWith('_')) continue;
+        const dir = path.join(pasta, cat.name);
+        for (const f of fs.readdirSync(dir).sort()) {
+            if (!f.endsWith('.mp3')) continue;
+            let ficha = {};
+            try { ficha = JSON.parse(fs.readFileSync(path.join(dir, f.replace(/\.mp3$/, '.licenca.json')), 'utf8')); } catch { /* sem ficha */ }
+            (indice[cat.name] = indice[cat.name] || []).push({ id: f.replace(/\.mp3$/, ''), arquivo: path.join(dir, f), titulo: ficha.titulo || f, autor: ficha.autor || null, licenca: ficha.licenca || null, segundos: ficha.segundos || duracaoDe(path.join(dir, f)) });
+        }
+    }
+    return indice;
+}
+
+async function pedirJson(url, timeout = 20000) {
+    const r = await fetch(url, { headers: { 'user-agent': 'primocode-estudio' }, signal: AbortSignal.timeout(timeout) });
+    if (!r.ok) throw new Error('HTTP ' + r.status);
+    return r.json();
+}
+async function baixarBytes(url, timeout = 30000) {
+    const r = await fetch(url, { headers: { 'user-agent': 'primocode-estudio' }, redirect: 'follow', signal: AbortSignal.timeout(timeout) });
+    if (!r.ok) throw new Error('HTTP ' + r.status);
+    return Buffer.from(await r.arrayBuffer());
+}
+
+/**
+ * Corta o silêncio do começo, limita a duração, põe fade-out e leva o pico a −3 dB (mono, 48 kHz).
+ * Devolve {ok, segundos} ou {ok:false} quando o arquivo é mudo ou curto demais.
+ */
+function tratar(entrada, saida, max) {
+    const tmp = saida + '.tmp.wav';
+    const a = ff(['-i', entrada, '-ac', '1', '-ar', '48000', '-af', `silenceremove=start_periods=1:start_threshold=-45dB:start_silence=0.02,atrim=0:${max}`, tmp]);
+    if (!a.ok) return { ok: false, error: a.saida.slice(-200) };
+    try {
+        const dur = duracaoDe(tmp), pico = picoDe(tmp);
+        if (!dur || dur < 0.05 || pico == null || pico < -50) return { ok: false, error: 'mudo ou curto demais' };
+        const fade = Math.min(0.25, Math.max(0.04, dur * 0.2));
+        const b = ff(['-i', tmp, '-af', `volume=${(-3 - pico).toFixed(2)}dB,afade=t=out:st=${Math.max(0, dur - fade).toFixed(3)}:d=${fade.toFixed(3)},alimiter=limit=0.708:level=false`, '-ar', '48000', '-ac', '1', '-q:a', '2', saida]);
+        return b.ok ? { ok: true, segundos: Math.round(dur * 100) / 100 } : { ok: false, error: b.saida.slice(-200) };
+    } finally { fs.rmSync(tmp, { force: true }); }
+}
+
+
+// ── Kenney.nl (CC0): o banco de motion de verdade ─────────────────────────
+
+const KENNEY = ['impact-sounds', 'interface-sounds', 'ui-audio', 'sci-fi-sounds', 'digital-audio'];
+/** Nome do arquivo → categoria (a primeira regra que casa; cada arquivo vai para UMA categoria só). */
+const KENNEY_REGRAS = [
+    ['bell', /impactBell/], ['glass', /impactGlass_heavy/], ['shimmer', /^glass_|impactGlass_(light|medium)/],
+    ['subdrop', /lowFrequency_explosion|^lowDown|spaceEngineLow/], ['downlifter', /phaserDown|^highDown|spaceTrash|^powerDown/],
+    ['riser', /phaserUp|powerUp|^highUp|spaceEngineSmall|thrusterFire/],
+    ['glitch', /^glitch_|^scratch_|computerNoise|^lowRandom|zapThreeTone|zapTwoTone/],
+    ['suave', /impactSoft_(medium|heavy)|impactGeneric_light|impactPlank_medium/],
+    ['hit', /impactPunch|impactPlate_(heavy|medium)|impactGeneric|impactSoft_heavy|impactMetal_heavy|impactTin|impactWood_heavy|impactMining/],
+    ['impact', /explosionCrunch|^impactMetal_\d|impactMetal_medium|impactPlank/],
+    ['whoosh', /forceField/],
+    ['swish', /^scroll_|^maximize_|^minimize_|^phaseJump/],
+    ['transicao', /laserLarge|^zap\d|^zap[A-Z]|^back_|^open_|^close_|laserRetro/],
+    ['notification', /^confirmation_|^question_|^threeTone|^bong|^lowThreeTone/],
+    ['click', /^click_|^click\d|mouseclick|mouserelease|^switch_|^switch\d|^toggle_/],
+    ['pop', /^pepSound|^twoTone|^tone1|^pluck/],
+    ['tap', /^select_|^drop_/],
+    ['typing', /^tick_|^rollover/],
+];
+const KENNEY_MAX_POR_CAT = 18;
+
+function listarArquivos(dir, acc = []) {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        const p = path.join(dir, e.name);
+        if (e.isDirectory()) listarArquivos(p, acc); else if (/\.(ogg|wav|mp3)$/i.test(e.name)) acc.push(p);
+    }
+    return acc;
+}
+
+/** Baixa os 5 pacotes do Kenney sob demanda (uma vez), separa por categoria e trata cada arquivo. Sem rede, não faz nada. */
+async function baixarKenney(pasta, { rede = true } = {}) {
+    const marca = path.join(pasta, '_kenney', 'pronto.json');
+    if (fs.existsSync(marca) || !rede) return { ok: fs.existsSync(marca) };
+    const bruto = path.join(pasta, '_kenney');
+    fs.mkdirSync(bruto, { recursive: true });
+    const porCat = {};
+    for (const pacote of KENNEY) {
+        try {
+            const pagina = `https://kenney.nl/assets/${pacote}`;
+            const html = await (await fetch(pagina, { headers: { 'user-agent': 'primocode-estudio' }, signal: AbortSignal.timeout(20000) })).text();
+            const zip = (html.match(/https:\/\/kenney\.nl\/media\/pages\/assets\/[^"']*\.zip/) || [])[0];
+            if (!zip) continue;
+            const dir = path.join(bruto, pacote);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+                const z = path.join(bruto, pacote + '.zip');
+                fs.writeFileSync(z, await baixarBytes(zip, 120000));
+                spawnSync('unzip', ['-oq', z, '-d', dir]);
+                fs.rmSync(z, { force: true });
+            }
+            for (const arq of listarArquivos(dir)) {
+                const nome = path.basename(arq).replace(/\.[a-z0-9]+$/i, '');
+                if (/^preview$/i.test(nome)) continue;
+                const regra = KENNEY_REGRAS.find(([, re]) => re.test(nome));
+                if (regra) (porCat[regra[0]] = porCat[regra[0]] || []).push({ arq, nome, pacote, pagina });
+            }
+        } catch { /* um pacote que falha não derruba os outros */ }
+    }
+    let feitos = 0;
+    for (const [cat, lista] of Object.entries(porCat)) {
+        const def = CATEGORIAS[cat]; if (!def) continue;
+        const passo = Math.max(1, lista.length / KENNEY_MAX_POR_CAT);
+        const escolhidos = []; for (let x = 0; x < lista.length && escolhidos.length < KENNEY_MAX_POR_CAT; x += passo) escolhidos.push(lista[Math.floor(x)]);
+        const dirCat = path.join(pasta, cat); fs.mkdirSync(dirCat, { recursive: true });
+        for (const it of escolhidos) {
+            const id = 'k-' + it.nome.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 30);
+            const destino = path.join(dirCat, id + '.mp3');
+            if (fs.existsSync(destino)) continue;
+            const t = tratar(it.arq, destino, def.max);
+            if (!t.ok) { fs.rmSync(destino, { force: true }); continue; }
+            feitos++;
+            fs.writeFileSync(path.join(dirCat, id + '.licenca.json'), JSON.stringify({ titulo: it.nome, autor: 'Kenney (kenney.nl)', licenca: 'cc0', licencaUrl: 'https://creativecommons.org/publicdomain/zero/1.0/', origem: it.pagina, fonte: 'kenney', categoria: cat, segundos: t.segundos, quando: new Date().toISOString() }, null, 2));
+        }
+    }
+    fs.writeFileSync(marca, JSON.stringify({ feitos, quando: new Date().toISOString() }));
+    return { ok: true, feitos };
+}
+
+async function encherCategoria(cat, pasta, minimo, rede) {
+    const def = CATEGORIAS[cat];
+    const dir = path.join(pasta, cat);
+    fs.mkdirSync(dir, { recursive: true });
+    const tem = () => fs.readdirSync(dir).filter((f) => f.endsWith('.mp3')).length;
+    if (tem() >= minimo || !rede) return;
+    const vistos = new Set(fs.readdirSync(dir).filter((f) => f.endsWith('.licenca.json')).map((f) => { try { return JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8')).origemId; } catch { return null; } }));
+    for (const consulta of def.q) {
+        if (tem() >= minimo) break;
+        let r;
+        try { r = await pedirJson(`${API}?q=${encodeURIComponent(consulta)}&license=cc0,pdm&page_size=20`); } catch { continue; }
+        const lista = (r.results || []).filter((a) => /^(cc0|pdm)$/i.test(a.license || '') && a.url && (!a.duration || a.duration / 1000 <= 4 + 0.001) && !vistos.has(a.id));
+        for (const a of lista) {
+            if (tem() >= minimo) break;
+            vistos.add(a.id);
+            const id = String(a.id).slice(0, 8);
+            const destino = path.join(dir, id + '.mp3');
+            if (fs.existsSync(destino)) continue;
+            const bruto = path.join(dir, id + '.bruto');
+            try {
+                fs.writeFileSync(bruto, await baixarBytes(a.url));
+                const t = tratar(bruto, destino, def.max);
+                if (!t.ok) { fs.rmSync(destino, { force: true }); continue; }
+                fs.writeFileSync(path.join(dir, id + '.licenca.json'), JSON.stringify({
+                    titulo: a.title, autor: a.creator || null, licenca: String(a.license).toLowerCase(), licencaUrl: a.license_url || null,
+                    origem: a.foreign_landing_url || a.url, url: a.url, origemId: a.id, fonte: a.source || a.provider || 'openverse', consulta, categoria: cat,
+                    segundos: t.segundos, quando: new Date().toISOString(),
+                }, null, 2));
+            } catch { /* falha de um arquivo nunca derruba */ } finally { fs.rmSync(bruto, { force: true }); }
+        }
+    }
+}
+
+/**
+ * Garante a biblioteca em disco. `acoes` (opcional) limita às categorias dessas ações; senão vão todas
+ * as básicas + as extras do tema do assunto. Cache: o que já existe não é baixado. Sem rede: devolve o que há.
+ */
+async function prepararBiblioteca({ assunto = '', acoes = null, pasta = PASTA_PADRAO(), rede = true, minPorCategoria = 10 } = {}) {
+    const tema = temaDe(assunto);
+    let cats;
+    if (acoes && acoes.length) cats = new Set(acoes.flatMap((a) => ACOES[a] || []));
+    else cats = new Set(Object.keys(CATEGORIAS).filter((c) => c !== 'oven'));
+    if (tema) tema.extras.forEach((c) => cats.add(c));
+    fs.mkdirSync(pasta, { recursive: true });
+    try { await baixarKenney(pasta, { rede }); } catch { /* sem Kenney: segue com o Openverse */ }
+    const lista = [...cats].filter((c) => CATEGORIAS[c]);
+    // 3 categorias por vez: rápido sem estourar a API
+    for (let i = 0; i < lista.length; i += 3) await Promise.all(lista.slice(i, i + 3).map((c) => encherCategoria(c, pasta, minPorCategoria, rede).catch(() => null)));
+    const indice = lerIndice(pasta);
+    try { fs.writeFileSync(path.join(pasta, 'indice.json'), JSON.stringify(indice, null, 2)); } catch { /* só cópia */ }
+    return indice;
+}
+
+// ── a escolha ────────────────────────────────────────────────────────────
+
+const JANELA_REPETICAO = 1.5;
+const COM_VARIACAO = new Set(['pop', 'click', 'tap', 'typing', 'bell', 'glass', 'paper']);
+
+/**
+ * Cada evento {t, tipo, ganho} vira {t, arquivo, tipo, ganho, acao, rate}. `arquivo` null = sem som real
+ * (o mixar usa o leve do `tipo`). Determinístico pela semente.
+ */
+function escolherSons(eventos, { assunto = '', indice = null, semente = 1 } = {}) {
+    indice = indice || lerIndice();
+    const tema = temaDe(assunto);
+    const rnd = mulberry(semente);
+    const ultimoPorAcao = {};
+    const usados = new Set();
+    const recentes = [];   // [{arquivo, t}]
+    const ordenados = [...(eventos || [])].filter((e) => e && isFinite(e.t)).sort((a, b) => a.t - b.t);
+    return ordenados.map((e) => {
+        const acao = String(e.tipo);
+        const padrao = ACOES[acao] || [];
+        const pref = (tema && tema.prefere[acao]) || null;
+        // a preferência do tema vem primeiro, mas a ordem entre elas varia (não vira sempre o mesmo)
+        let cats = pref ? [...pref, ...padrao.filter((c) => !pref.includes(c))] : padrao.slice();
+        if (pref && pref.length > 1 && rnd() < 0.5) cats = [cats[1], cats[0], ...cats.slice(2)];
+        let arquivo = null, cat = null;
+        // nunca o mesmo arquivo duas vezes no vídeo: o que já tocou sai de todos os pools
+        for (const c of cats) {
+            const opcoes = (indice[c] || []).filter((x) => fs.existsSync(x.arquivo) && !usados.has(x.arquivo) && !BLOQUEADOS.test(path.basename(x.arquivo)));
+            if (!opcoes.length) continue;
+            arquivo = opcoes[Math.floor(rnd() * opcoes.length)].arquivo; cat = c; break;
+        }
+        // biblioteca curta demais para o vídeo: reaproveita o que tocou há MAIS tempo (nunca em sequência, nunca em menos de 1,5 s)
+        if (!arquivo) {
+            for (const c of cats) {
+                const opcoes = (indice[c] || []).filter((x) => fs.existsSync(x.arquivo) && !BLOQUEADOS.test(path.basename(x.arquivo)) && x.arquivo !== ultimoPorAcao[acao] && !recentes.some((r) => r.arquivo === x.arquivo && e.t - r.t < JANELA_REPETICAO));
+                if (!opcoes.length) continue;
+                const quando = (a) => { const u = [...recentes].reverse().find((r) => r.arquivo === a); return u ? u.t : -1; };
+                opcoes.sort((a, b) => quando(a.arquivo) - quando(b.arquivo));
+                arquivo = opcoes[0].arquivo; cat = c; break;
+            }
+        }
+        if (arquivo) { ultimoPorAcao[acao] = arquivo; recentes.push({ arquivo, t: e.t }); usados.add(arquivo); }
+        const db = (rnd() * 3 - 1.5);
+        const ganho = (e.ganho == null ? 1 : e.ganho) * Math.pow(10, db / 20);
+        const rate = arquivo && cat && COM_VARIACAO.has(cat) ? Math.round((0.97 + rnd() * 0.08) * 1000) / 1000 : 1;
+        return { t: e.t, arquivo, tipo: acao, ganho: Math.round(ganho * 1000) / 1000, acao: cat || acao, rate };
+    });
+}
+
+const DE_CORTE = new Set(['troca', 'swoosh', 'whoosh', 'impacto', 'sub', 'sobe', 'subida']);
+/** Puxa os sons de corte/troca/impacto para a batida mais próxima (até `tolerancia` s). `batidas`: array ou {batidas}. */
+function encaixarNaBatida(sons, batidas, { tolerancia = 0.09 } = {}) {
+    const bs = (Array.isArray(batidas) ? batidas : (batidas && batidas.batidas) || []).filter((x) => isFinite(x));
+    if (!bs.length) return sons;
+    return sons.map((s) => {
+        if (!DE_CORTE.has(s.tipo)) return s;
+        // o riser termina na batida (não começa nela): empurra o fim para a batida, via t + duração típica ~1,1 s
+        const alvo = s.tipo === 'sobe' || s.tipo === 'subida' ? s.t + 1.1 : s.t;
+        let melhor = null;
+        for (const b of bs) if (melhor == null || Math.abs(b - alvo) < Math.abs(melhor - alvo)) melhor = b;
+        if (melhor == null || Math.abs(melhor - alvo) > tolerancia) return s;
+        const novo = s.tipo === 'sobe' || s.tipo === 'subida' ? melhor - 1.1 : melhor;
+        return { ...s, t: Math.max(0, Math.round(novo * 1000) / 1000), encaixado: true };
+    });
+}
+
+// ── a mixagem ────────────────────────────────────────────────────────────
+
+const LUFS_ALVO = -14;
+
+/**
+ * SFX nos tempos + trilha (15 dB abaixo da voz) + voz, com ducking, e a normalização em −14 LUFS.
+ * Sem voz, a trilha fica ~10 dB abaixo do barramento de SFX. Devolve {ok, video, lufs, eventos, reservas, mix}.
+ */
+function mixar({ pasta, mudo, saida, sons = [], trilha = null, trilhaInicio = 0, voz = null, duracao, ffmpeg, vol = {} } = {}) {   // vol: {trilha, sfx} em dB, somados aos ganhos medidos
+    if (!pasta || !mudo || !saida || !duracao) return { ok: false, error: 'faltou pasta, vídeo mudo, saída ou duração' };
+    const D = Number(duracao).toFixed(2);
+    const temVoz = !!(voz && fs.existsSync(voz)), temTrilha = !!(trilha && fs.existsSync(trilha));
+    const trab = path.join(pasta, 'mix-tmp'); fs.mkdirSync(trab, { recursive: true });
+    const limpar = () => fs.rmSync(trab, { recursive: true, force: true });
+
+    // 1) resolve os arquivos (real ou reserva leve)
+    let leves = null, reservas = 0;
+    const eventos = [];
+    for (const s of sons.slice(0, 120)) {
+        let arq = s.arquivo && fs.existsSync(s.arquivo) ? s.arquivo : null;
+        if (!arq) {
+            leves = leves || require('./sons-leves.js').preparar(pasta);
+            if (leves[s.tipo]) { arq = path.join(pasta, leves[s.tipo]); reservas++; }
+        }
+        if (arq) eventos.push({ ...s, arq });
+    }
+    if (!eventos.length && !temVoz && !temTrilha) { limpar(); return { ok: false, semAudio: true, video: mudo }; }
+
+    // 2) barramento de SFX
+    let sfx = null;
+    if (eventos.length) {
+        const ent = [], fil = [], nomes = [];
+        eventos.forEach((e, i) => {
+            ent.push('-i', e.arq);
+            const ms = Math.max(0, Math.round(e.t * 1000));
+            const rate = e.rate && e.rate !== 1 ? `,asetrate=${Math.round(48000 * e.rate)},aresample=48000` : '';
+            // acento, não bomba: graves cortados abaixo de 120 Hz, ataque suavizado (fade-in 8 ms) e pico em −18 dBFS (o arquivo vem a −3)
+            const gdb = -15 + 20 * Math.log10(Math.max(0.05, Math.min(1, e.ganho == null ? 1 : e.ganho)));
+            fil.push(`[${i}:a]aresample=48000,aformat=channel_layouts=stereo${rate},highpass=f=120,afade=t=in:st=0:d=0.008,volume=${gdb.toFixed(2)}dB,adelay=${ms}|${ms}[s${i}]`);
+            nomes.push(`[s${i}]`);
+        });
+        fil.push(`${nomes.join('')}amix=inputs=${nomes.length}:normalize=0:duration=longest,apad=whole_dur=${D},atrim=0:${D}[o]`);
+        sfx = path.join(trab, 'sfx.wav');
+        const r = ff([...ent, '-filter_complex', fil.join(';'), '-map', '[o]', '-ar', '48000', '-ac', '2', sfx], { timeout: 240000 });
+        if (!r.ok) { limpar(); return { ok: false, error: 'a mixagem de efeitos falhou: ' + r.saida.slice(-400), video: mudo }; }
+    }
+    // 3) voz e trilha em wav (para medir)
+    let vozW = null, triW = null;
+    if (temVoz) {
+        vozW = path.join(trab, 'voz.wav');
+        ff(['-i', voz, '-af', `aresample=48000,aformat=channel_layouts=stereo,apad=whole_dur=${D},atrim=0:${D}`, '-ar', '48000', vozW]);
+    }
+    if (temTrilha) {
+        triW = path.join(trab, 'trilha.wav');
+        ff(['-ss', String(Math.max(0, trilhaInicio || 0)), '-stream_loop', '-1', '-i', trilha, '-af', `aresample=48000,aformat=channel_layouts=stereo,atrim=0:${D},asetpts=PTS-STARTPTS,afade=t=in:st=0:d=0.8,afade=t=out:st=${Math.max(0, duracao - 1.4).toFixed(2)}:d=1.4`, '-ar', '48000', triW], { timeout: 120000 });
+    }
+    // 4) ganhos pela medição: com voz, a trilha fica 15 dB abaixo dela e os efeitos 10 dB abaixo; sem voz, a trilha vai a −22 LUFS
+    //    (picos ~ −10 dBFS) e os efeitos, com pico em −18, ficam ~8–10 dB abaixo dela
+    const Lv = vozW ? medirLufs(vozW) : null, Lm = triW ? medirLufs(triW) : null, Ls = sfx ? medirLufs(sfx) : null;
+    let gTrilha = 0, difVozTrilha = null;
+    if (triW && Lm != null) {
+        const alvo = Lv != null ? Lv - 15 : -22;
+        gTrilha = alvo - Lm + (vol.trilha || 0); difVozTrilha = Lv != null ? Math.round((Lv - (Lm + gTrilha)) * 10) / 10 : null;
+    }
+    const gSfx = (vozW && Lv != null && Ls != null ? Math.min(0, (Lv - 10) - Ls) : 0) + (vol.sfx || 0);   // só abaixa; nunca sobe acima do pico de −18 dBFS
+    const picoSfx = sfx ? picoDe(sfx) : null;
+
+    // 5) o barramento final, com ducking pela voz
+    const ent = [], fil = [], bus = [];
+    let n = 0;
+    const entrada = (arq) => { ent.push('-i', arq); return n++; };
+    if (vozW) {
+        const iv = entrada(vozW);
+        fil.push(`[${iv}:a]asplit=3[v1][v2][v3]`);
+        bus.push('[v1]');
+        if (triW) {
+            const it = entrada(triW);
+            fil.push(`[${it}:a]volume=${gTrilha.toFixed(2)}dB[mus]`, `[mus][v2]sidechaincompress=threshold=0.02:ratio=9:attack=15:release=450:makeup=1[musd]`);
+            bus.push('[musd]');
+        } else fil.push('[v2]anullsink');
+        if (sfx) {
+            const is = entrada(sfx);
+            fil.push(`[${is}:a]volume=${gSfx.toFixed(2)}dB[sf]`, `[sf][v3]sidechaincompress=threshold=0.04:ratio=2.5:attack=10:release=250:makeup=1[sfd]`);
+            bus.push('[sfd]');
+        } else fil.push('[v3]anullsink');
+    } else {
+        if (triW) { const it = entrada(triW); fil.push(`[${it}:a]volume=${gTrilha.toFixed(2)}dB[mus]`); bus.push('[mus]'); }
+        if (sfx) { const is = entrada(sfx); fil.push(`[${is}:a]anull[sf]`); bus.push('[sf]'); }
+    }
+    fil.push(`${bus.join('')}amix=inputs=${bus.length}:normalize=0:duration=longest,alimiter=limit=0.95:level=false:attack=5:release=80,atrim=0:${D}[mix]`);
+    const bruto = path.join(trab, 'mix-bruto.wav');
+    const m1 = ff([...ent, '-filter_complex', fil.join(';'), '-map', '[mix]', '-ar', '48000', '-ac', '2', bruto], { timeout: 240000 });
+    if (!m1.ok) { limpar(); return { ok: false, error: 'a mixagem falhou: ' + m1.saida.slice(-400), video: mudo }; }
+
+    // 6) loudnorm em 2 passadas → −14 LUFS
+    const alvo = `I=${LUFS_ALVO}:TP=-1.5:LRA=11`;
+    const p1 = spawnSync('ffmpeg', ['-hide_banner', '-nostats', '-i', bruto, '-af', `loudnorm=${alvo}:print_format=json`, '-f', 'null', '-'], { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+    let af = `loudnorm=${alvo}`;
+    const js = String(p1.stderr || '').match(/\{[^{}]*"input_i"[^{}]*\}/);
+    if (js) {
+        try {
+            const d = JSON.parse(js[0]);
+            if (isFinite(d.input_i) && isFinite(d.input_thresh)) af = `loudnorm=${alvo}:measured_I=${d.input_i}:measured_TP=${d.input_tp}:measured_LRA=${d.input_lra}:measured_thresh=${d.input_thresh}:offset=${d.target_offset}:linear=true`;
+        } catch { /* passada única */ }
+    }
+    const fim = ff(['-i', mudo, '-i', bruto, '-map', '0:v', '-map', '1:a', '-c:v', 'copy', '-af', af, '-ar', '48000', '-c:a', 'aac', '-b:a', '192k', '-shortest', saida], { timeout: 240000 });
+    if (fim.ok && fs.existsSync(saida)) {
+        // o loudnorm linear fica abaixo do alvo quando os picos limitam: um ganho a mais, com limiter, fecha a conta
+        const l1 = medirLufs(saida);
+        if (l1 != null && isFinite(l1) && Math.abs(l1 - LUFS_ALVO) > 0.4) {
+            const ganho = (LUFS_ALVO - l1).toFixed(2);
+            const f2 = ff(['-i', mudo, '-i', bruto, '-map', '0:v', '-map', '1:a', '-c:v', 'copy', '-af', `${af},volume=${ganho}dB,alimiter=limit=0.89:level=false`, '-ar', '48000', '-c:a', 'aac', '-b:a', '192k', '-shortest', saida + '.2.mp4'], { timeout: 240000 });
+            if (f2.ok) { const l2 = medirLufs(saida + '.2.mp4'); if (l2 != null && Math.abs(l2 - LUFS_ALVO) < Math.abs(l1 - LUFS_ALVO)) fs.renameSync(saida + '.2.mp4', saida); else fs.rmSync(saida + '.2.mp4', { force: true }); }
+        }
+    }
+    limpar();
+    if (!fim.ok || !fs.existsSync(saida)) return { ok: false, error: 'a normalização falhou: ' + fim.saida.slice(-400), video: mudo };
+    return {
+        ok: true, video: saida, lufs: medirLufs(saida), eventos: eventos.length, reservas,
+        mix: { lufsVoz: Lv, lufsTrilha: Lm, ganhoTrilha: Math.round(gTrilha * 10) / 10, vozMenosTrilha: difVozTrilha, ganhoSfx: Math.round(gSfx * 10) / 10, sfxPicoDbfs: picoSfx == null ? null : Math.round((picoSfx + gSfx) * 10) / 10, sfxLufs: Ls == null ? null : Math.round((Ls + gSfx) * 10) / 10, trilhaLufsNaMix: Lm == null ? null : Math.round((Lm + gTrilha) * 10) / 10 },
+    };
+}
+
+module.exports = { BLOQUEADOS, KENNEY, KENNEY_REGRAS, baixarKenney, CATEGORIAS, ACOES, TEMAS, temaDe, prepararBiblioteca, lerIndice, escolherSons, encaixarNaBatida, mixar, medirLufs, tratar, PASTA_PADRAO };

package/lib/estudio/maquina-trilha.js

@@ -0,0 +1,160 @@
+/**
+ * maquina-trilha.js — a trilha do motion: energia alta ou nada.
+ *
+ * Regras (Joel, 18/10: "a trilha de fundo é horrível"):
+ *   · LISTA NEGRA permanente: as faixas já usadas pela máquina (inclusive Jesse Keller e Josh Woodward) nunca mais voltam.
+ *     Mora no código (PROIBIDAS) e em ~/.primocode/studio/trilhas-proibidas.json (a pessoa acrescenta; as duas somam).
+ *   · ENERGIA ALTA: BPM ≥ 110, batida confiável (batida.js) e volume de música de verdade (LUFS ≥ −17); gênero pelo assunto
+ *     (phonk, trap, electro, house, techno…). Várias candidatas são baixadas e medidas; ganha a de maior nota.
+ *   · CORTE NO DROP: o início da faixa é escolhido (batida.melhorInicio) para o maior acento cair no corte mais pesado.
+ *   · `trilha:` aceita um ARQUIVO da pessoa (mp3/wav/m4a): ele vence a busca (a lista negra não vale para o que ela escolheu).
+ *   · Sem faixa boa → sem música, só sound design.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const ARQUIVO_PROIBIDAS = () => process.env.PRIMOCODE_TRILHAS_PROIBIDAS || path.join(os.homedir(), '.primocode', 'studio', 'trilhas-proibidas.json');
+
+/** Usadas até 18/10/2026 (lidas das fichas .licenca.json dos projetos e dos vídeos de prova) + as que o Joel apontou. */
+const PROIBIDAS = [
+    { autor: 'Jesse Keller', motivo: 'o Joel apontou: horrível' },
+    { autor: 'Josh Woodward', titulo: 'Motionless Land', motivo: 'o Joel apontou: horrível' },
+    { autor: 'Soundrider', titulo: 'Corporate', motivo: 'usada nos vídeos v1' },
+    { autor: 'Tymphony', motivo: 'usada nos vídeos v1' },
+    { autor: 'Tri-Tachyon', motivo: 'usada nos vídeos v1' },
+    { autor: 'Professor Kliq', motivo: 'usada nos vídeos v1' },
+    { autor: 'Adrian Sanchez', motivo: 'usada nos vídeos v1' },
+    { autor: 'Arhur Yul', motivo: 'usada nos vídeos v1' },
+    { autor: 'Hasenchat', motivo: 'usada nos vídeos v1' },
+    { autor: 'Pakii', motivo: 'usada nos vídeos v1' },
+    { autor: 'Alittlebitdrunkguy', motivo: 'usada nos vídeos v1' },
+    { autor: 'Jahzzar', motivo: 'usada nos vídeos v1' },
+    { autor: 'Fragments Of Winter', motivo: 'usada nos vídeos v1' },
+    { trackid: '1670486' }, { trackid: '1670484' }, { trackid: '764950' }, { trackid: '341547' }, { trackid: '925452' }, { trackid: '432009' },
+    { trackid: '1501961' }, { trackid: '1137475' }, { trackid: '992957' }, { trackid: '509068' }, { trackid: '417168' },
+];
+
+/** Garante o arquivo da lista negra (cria com as entradas de fábrica) e devolve a lista somada (código + arquivo). */
+function lerProibidas(arq = ARQUIVO_PROIBIDAS()) {
+    let doArquivo = [];
+    try { doArquivo = JSON.parse(fs.readFileSync(arq, 'utf8')); } catch { /* ainda não existe */ }
+    if (!Array.isArray(doArquivo)) doArquivo = [];
+    if (!fs.existsSync(arq)) { try { fs.mkdirSync(path.dirname(arq), { recursive: true }); fs.writeFileSync(arq, JSON.stringify(PROIBIDAS, null, 2)); } catch { /* sem disco */ } }
+    return [...PROIBIDAS, ...doArquivo];
+}
+const norm = (s) => String(s || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
+/** A faixa (título, autor, url) está na lista negra? */
+function proibida(item, lista = lerProibidas()) {
+    const t = norm(item.titulo || item.title), a = norm(item.autor || item.creator), u = String(item.url || '');
+    return lista.some((p) => {
+        if (p.trackid && new RegExp('trackid=' + p.trackid + '(?!\\d)').test(u)) return true;
+        if (p.url && p.url === u) return true;
+        if (p.autor && a.includes(norm(p.autor)) && (!p.titulo || t.includes(norm(p.titulo)))) return true;
+        if (!p.autor && p.titulo && t.includes(norm(p.titulo))) return true;
+        return false;
+    });
+}
+/** Acrescenta uma faixa à lista negra permanente. */
+function proibir(item, motivo = 'recusada') {
+    const arq = ARQUIVO_PROIBIDAS();
+    let l = []; try { l = JSON.parse(fs.readFileSync(arq, 'utf8')); } catch { /* nova */ }
+    l.push({ autor: item.autor || undefined, titulo: item.titulo || undefined, url: item.url || undefined, motivo, quando: new Date().toISOString() });
+    fs.mkdirSync(path.dirname(arq), { recursive: true });
+    fs.writeFileSync(arq, JSON.stringify(l, null, 2));
+}
+
+/** Os gêneros que a busca tenta, por tipo de assunto (a chave vem de maquina-diretor.achar). */
+const GENEROS = {
+    software: ['electro house', 'techno', 'phonk', 'synthwave'],
+    financas: ['trap beat', 'phonk', 'electro hip hop', 'house'],
+    padaria: ['tropical house', 'funk groove', 'electro swing', 'house'],
+    clinica: ['deep house', 'electro pop', 'chillhop upbeat', 'house'],
+    geral: ['electro house', 'trap', 'phonk', 'house'],
+};
+
+const LIMITE = { bpmMin: 110, confianca: 0.7, lufsMin: -17 };
+
+function ff(args, opts = {}) {
+    const r = spawnSync('ffmpeg', ['-y', '-hide_banner', '-loglevel', 'error', ...args], { encoding: 'utf8', timeout: opts.timeout || 120000 });
+    return r.status === 0;
+}
+function lufsDe(arq, segundos = 60) {
+    const r = spawnSync('ffmpeg', ['-hide_banner', '-nostats', '-t', String(segundos), '-i', arq, '-vn', '-af', 'ebur128=peak=true', '-f', 'null', '-'], { encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
+    const s = String(r.stderr || '');
+    const m = s.slice(s.lastIndexOf('Summary:')).match(/I:\s+(-?\d+(?:\.\d+)?)\s+LUFS/);
+    return m ? Number(m[1]) : null;
+}
+
+/**
+ * A nota de uma faixa analisada (0 se reprovada): andamento entre 120 e 150 vale mais, batida firme, acentos de drop e
+ * volume de música moderna. `a` = {bpm, confianca, acentos, segundos, lufs}.
+ */
+function nota(a, limite = LIMITE) {
+    if (!a || !a.bpm || a.bpm < limite.bpmMin || a.confianca < limite.confianca) return 0;
+    if (a.lufs != null && a.lufs < limite.lufsMin) return 0;
+    const bpm = Math.max(0, 1 - Math.abs(a.bpm - 135) / 60);
+    const loud = a.lufs == null ? 0.5 : Math.min(1, (a.lufs + 17) / 6);
+    return Math.round((0.3 * bpm + 0.3 * a.confianca + 0.2 * Math.min(1, (a.acentos || []).length / 6) + 0.2 * loud) * 1000) / 1000;
+}
+
+/**
+ * Escolhe a trilha. `arquivo` (da pessoa) vence. `deps`: {procurar(termo), baixar(item, pasta), analisar(arq), lufs(arq)} (testes).
+ * Devolve {arquivo, titulo, creditos, bpm, batidas, acentos, confianca, lufs, nota, pessoa} ou {semMusica: true, motivo}.
+ */
+async function escolher({ chave = 'geral', busca = null, arquivo = null, pasta, rede = true, deps = {}, maximo = 8 } = {}) {
+    const batida = require('./batida.js');
+    const analisar = deps.analisar || ((arq) => batida.analisar(arq));
+    const medirLufs = deps.lufs || ((arq) => lufsDe(arq));
+    if (arquivo && fs.existsSync(arquivo)) {
+        const a = await analisar(arquivo).catch(() => null);
+        return { arquivo, titulo: path.basename(arquivo), creditos: null, bpm: a && a.bpm, batidas: a && a.batidas, acentos: a && a.acentos, confianca: a && a.confianca, lufs: medirLufs(arquivo), pessoa: true, nota: 1 };
+    }
+    if (!rede && !deps.procurar) return { semMusica: true, motivo: 'sem rede e sem arquivo' };
+    const assets = deps.procurar ? null : require('./assets.js');
+    const procurar = deps.procurar || ((t) => assets.procurarMusica(t, { quantas: 10, duracaoMin: 25 }));
+    const baixar = deps.baixar || ((item, p) => assets.baixar(item, { pasta: p, nome: 'trilha-' + String(item.titulo || 'x').slice(0, 20), sub: path.join('midia', 'trilhas') }));
+    const lista = lerProibidas();
+    const termos = [busca, ...(GENEROS[chave] || GENEROS.geral)].filter(Boolean).slice(0, 4);
+    const vistos = new Set();
+    const analisadas = [];
+    const recusadas = [];
+    for (const termo of termos) {
+        if (analisadas.length >= maximo) break;
+        let r; try { r = await procurar(termo); } catch { continue; }
+        for (const item of ((r && r.sons) || [])) {
+            if (analisadas.length >= maximo) break;
+            if (!item.url || vistos.has(item.url)) continue;
+            vistos.add(item.url);
+            if (proibida(item, lista)) { recusadas.push(item.titulo); continue; }
+            let b; try { b = await baixar(item, pasta); } catch { continue; }
+            if (!b || !b.ok) continue;
+            const a = await analisar(b.arquivo).catch(() => null);
+            if (!a) continue;
+            const lufs = medirLufs(b.arquivo);
+            const faixa = { arquivo: b.arquivo, titulo: item.titulo, autor: item.autor, creditos: b.creditos || item.creditos || null, genero: termo, bpm: a.bpm, batidas: a.batidas, acentos: a.acentos, confianca: a.confianca, segundos: a.segundos, lufs };
+            faixa.nota = nota(faixa);
+            analisadas.push(faixa);
+        }
+        // uma boa já basta para o primeiro gênero: não gasta rede à toa
+        if (analisadas.some((f) => f.nota >= 0.75)) break;
+    }
+    const boas = analisadas.filter((f) => f.nota > 0).sort((a, b) => b.nota - a.nota);
+    if (!boas.length) return { semMusica: true, motivo: `nenhuma das ${analisadas.length} faixas analisadas tem energia (BPM ≥ ${LIMITE.bpmMin}, batida firme, LUFS ≥ ${LIMITE.lufsMin})`, analisadas: analisadas.map((f) => ({ titulo: f.titulo, bpm: f.bpm, confianca: f.confianca, lufs: f.lufs })), recusadas };
+    return { ...boas[0], analisadas: analisadas.length, recusadas };
+}
+
+/**
+ * O início da faixa (s) que põe o drop no corte mais pesado: `cortes` = [{t, peso}] do vídeo. Devolve {inicio, alinhados, total}.
+ */
+function inicioNoDrop(cortes, faixa, duracaoDoVideo) {
+    const batida = require('./batida.js');
+    const maximo = Math.max(0, (faixa.segundos || 0) - duracaoDoVideo - 1);
+    return batida.melhorInicio(cortes, { batidas: faixa.batidas, acentos: faixa.acentos, confianca: faixa.confianca }, { maximo, tolerancia: 0.06 });
+}
+
+module.exports = { PROIBIDAS, GENEROS, LIMITE, lerProibidas, proibida, proibir, nota, escolher, inicioNoDrop, ARQUIVO_PROIBIDAS };