primocode 10.19.0 → 11.1.0

package/lib/estudio/editor.js

@@ -1,290 +0,0 @@
-/**
- * editor.js — o editor de vídeo por comando: `estudio_editar` reabre o plano que a máquina de motion usou
- * (cenas.json, salvo junto do vídeo), aplica as mudanças, re-renderiza e guarda a versão (v1, v2…).
- *
- * Operações (cada mudança é {op, ...}; o modelo traduz o pedido em linguagem natural):
- *   texto {cena, campo?='titulo', valor} · texto {de, para}   cor {fundo?, destaque?, tinta?} · cor {paleta}
- *   fonte {titulo?, texto?, destaque?}   ritmo {fator} (0.8 = mais rápido) · duracao {cena, segundos} · duracao {total}
- *   remover {cena} · mover {cena, para} · duplicar {cena, para?}   (cena = 1, 2, 3…)
- *   trilha {valor: false | "busca" | caminho}   volume {alvo: voz|trilha|sfx, db}   formato {valor: 9:16|1:1|16:9}
- * Com narração, o tempo é da voz: ritmo, duração, remover, mover e duplicar ficam de fora (avisa).
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const maq = () => require('./maquina.js');
-const dir = () => require('./maquina-diretor.js');
-const ler = (f) => JSON.parse(fs.readFileSync(f, 'utf8'));
-const gravar = (f, o) => { fs.mkdirSync(path.dirname(f), { recursive: true }); fs.writeFileSync(f, JSON.stringify(o)); };
-const ARQ = (pasta) => path.join(pasta, 'cenas.json');
-const IDX = (pasta) => path.join(pasta, 'versoes', 'indice.json');
-const arred = (v, n = 100) => Math.round(v * n) / n;
-
-// ── versões ──────────────────────────────────────────────────────────────
-
-function indice(pasta) {
-    try { return ler(IDX(pasta)); } catch { return { atual: 0, versoes: [] }; }
-}
-function registrarVersao(pasta, spec, video, resumo) {
-    const ix = indice(pasta);
-    const n = ix.versoes.reduce((m, v) => Math.max(m, v.n), 0) + 1;
-    const d = path.join(pasta, 'versoes', 'v' + n);
-    fs.mkdirSync(d, { recursive: true });
-    gravar(path.join(d, 'cenas.json'), spec);
-    let arq = null;
-    if (video && fs.existsSync(video)) { arq = path.join(d, 'video.mp4'); fs.copyFileSync(video, arq); }
-    ix.versoes.push({ n, resumo: resumo || '', previa: !!spec.previa, video: arq ? path.relative(pasta, arq) : null });
-    ix.atual = n;
-    gravar(IDX(pasta), ix);
-    gravar(ARQ(pasta), spec);
-    return n;
-}
-
-/** Gancho da máquina: guarda o plano e abre a versão. Prévia só guarda o plano (sem versão). */
-function salvarSpec(pasta, { pl, args = {}, trilha = null, voz = null, video, previa = false }) {
-    const { saida, ...resto } = args;
-    const spec = { pl, args: resto, trilha, voz, volumes: {}, previa: !!previa };
-    if (previa) {
-        gravar(ARQ(pasta), spec);
-        let v = video;
-        if (video && fs.existsSync(video)) { v = path.join(pasta, 'video-previa.mp4'); if (v !== video) fs.copyFileSync(video, v); }
-        return { video: v, versao: null };
-    }
-    fs.rmSync(path.join(pasta, 'versoes'), { recursive: true, force: true });
-    return { versao: registrarVersao(pasta, spec, video, 'original'), video };
-}
-
-// ── operações sobre o plano ──────────────────────────────────────────────
-
-function refluir(pl) {
-    let t = 0;
-    pl.cenas.forEach((c, i) => { c.inicio = arred(t, 1000); t += c.dur; if (pl.cenas[i + 1]) c.proxBg = null; });
-    pl.cenas.forEach((c, i) => { if (pl.cenas[i + 1]) c.proxBg = pl.cenas[i + 1].pal.bg; else delete c.proxBg; });
-    pl.duracao = arred(t);
-}
-const idx = (pl, n) => { const i = Number(n) - 1; return Number.isInteger(i) && i >= 0 && i < pl.cenas.length ? i : -1; };
-const limpo = (s) => String(s == null ? '' : s).replace(/[\r\n]+/g, ' ').trim().slice(0, 200);
-const hexOk = (h) => /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.test(String(h || ''));
-const hex = (h) => (String(h).startsWith('#') ? String(h) : '#' + h);
-
-function recolorir(pl, paleta) {
-    const velho = pl.variacoes || {};
-    const novo = maq().variacoes(paleta);
-    pl.cenas.forEach((c) => {
-        const chave = ['normal', 'fundo', 'destaque'].find((k) => velho[k] && velho[k].bg === (c.pal && c.pal.bg)) || 'normal';
-        c.pal = { ...novo[chave] };
-    });
-    pl.paleta = paleta; pl.variacoes = novo;
-    if (pl.legenda) {
-        const ac = paleta.destaque, C = maq().contraste;
-        pl.legenda.corDestaque = C(ac, '#000000') >= 4.5 ? ac : (C(paleta.tinta, '#000000') >= 4.5 ? paleta.tinta : '#FFD54A');
-    }
-}
-
-const ESTRUTURAIS = new Set(['ritmo', 'duracao', 'remover', 'mover', 'duplicar']);
-
-/** Aplica uma mudança ao spec. Devolve {ok, resumo} ou {ok:false, error}. */
-function aplicar(spec, m, ctx = {}) {
-    const pl = spec.pl;
-    const op = String(m && m.op || '').toLowerCase().replace(/-/g, '_');
-    if (spec.voz && ESTRUTURAIS.has(op)) return { ok: false, error: `com narração o tempo é da voz: "${op}" não se aplica (gere de novo sem voz, ou mude só texto, cor, fonte, trilha e volume).` };
-    const falta = (n) => ({ ok: false, error: `não existe a cena ${n} (o vídeo tem ${pl.cenas.length}).` });
-    switch (op) {
-        case 'texto': {
-            if (m.de != null) {
-                let n = 0;
-                const tr = (o) => { for (const k of Object.keys(o)) { if (typeof o[k] === 'string' && o[k].includes(m.de)) { o[k] = o[k].split(m.de).join(String(m.para == null ? '' : m.para)); n++; } else if (Array.isArray(o[k])) o[k] = o[k].map((x) => (typeof x === 'string' && x.includes(m.de) ? (n++, x.split(m.de).join(String(m.para == null ? '' : m.para))) : x)); } };
-                pl.cenas.forEach((c) => tr(c));
-                return n ? { ok: true, resumo: `"${m.de}" → "${m.para}" em ${n} campo(s)` } : { ok: false, error: `não achei "${m.de}" no texto das cenas.` };
-            }
-            const i = idx(pl, m.cena); if (i < 0) return falta(m.cena);
-            const campo = String(m.campo || 'titulo');
-            if (!/^(titulo|sub|texto|autor|botao|rotulo|valor|antes|depois|tela|fala)$/.test(campo) && !(campo in pl.cenas[i])) return { ok: false, error: 'campo desconhecido: ' + campo };
-            pl.cenas[i][campo] = Array.isArray(m.valor) ? m.valor.map(limpo) : limpo(m.valor);
-            return { ok: true, resumo: `cena ${m.cena}: ${campo} = "${String(m.valor).slice(0, 40)}"` };
-        }
-        case 'cor': case 'paleta': {
-            let p = { ...pl.paleta };
-            if (m.paleta || (m.valor && !m.fundo && !m.destaque && !m.tinta)) {
-                const nome = String(m.paleta || m.valor).toLowerCase();
-                const base = dir().PALETAS[nome];
-                if (!base) return { ok: false, error: 'paleta desconhecida: ' + nome + ' (' + Object.keys(dir().PALETAS).join(', ') + ')' };
-                p = { fundo: base.fundo, tinta: base.tinta, destaque: base.destaque };
-                if (pl.direcao) pl.direcao.paleta = nome;
-            }
-            for (const k of ['fundo', 'tinta', 'destaque']) if (m[k] != null) { if (!hexOk(m[k])) return { ok: false, error: `cor inválida em ${k}: ${m[k]}` }; p[k] = hex(m[k]); }
-            recolorir(pl, p);
-            return { ok: true, resumo: `cores: fundo ${p.fundo}, tinta ${p.tinta}, destaque ${p.destaque}` };
-        }
-        case 'fonte': {
-            let n = 0;
-            for (const k of ['titulo', 'texto', 'destaque']) if (m[k]) { pl.fontes[k] = limpo(m[k]).slice(0, 40); n++; }
-            if (m.valor && !n) { pl.fontes.titulo = pl.fontes.texto = pl.fontes.destaque = limpo(m.valor).slice(0, 40); n = 1; }
-            if (pl.legenda) { pl.legenda.fonte = pl.fontes.texto; pl.legenda.fonteDestaque = pl.fontes.destaque; }
-            return n ? { ok: true, resumo: 'fontes: ' + JSON.stringify(pl.fontes) } : { ok: false, error: 'fonte pede titulo, texto ou destaque.' };
-        }
-        case 'ritmo': {
-            const f = Number(m.fator);
-            if (!(f > 0.2 && f < 5)) return { ok: false, error: 'ritmo pede fator entre 0.2 e 5 (0.8 = 20% mais rápido).' };
-            pl.cenas.forEach((c) => { c.dur = arred(Math.max(1.2, Math.min(7.5, c.dur * f))); });
-            refluir(pl);
-            return { ok: true, resumo: `ritmo ×${f}: ${pl.duracao}s` };
-        }
-        case 'duracao': {
-            if (m.total != null) {
-                const k = Number(m.total) / pl.duracao;
-                if (!(k > 0.2 && k < 5)) return { ok: false, error: 'duração total fora do limite.' };
-                pl.cenas.forEach((c) => { c.dur = arred(Math.max(1.2, Math.min(7.5, c.dur * k))); });
-            } else {
-                const i = idx(pl, m.cena); if (i < 0) return falta(m.cena);
-                const s = Number(m.segundos); if (!(s >= 1 && s <= 10)) return { ok: false, error: 'segundos entre 1 e 10.' };
-                pl.cenas[i].dur = arred(s);
-            }
-            refluir(pl);
-            return { ok: true, resumo: `duração: ${pl.duracao}s` };
-        }
-        case 'remover': {
-            const i = idx(pl, m.cena); if (i < 0) return falta(m.cena);
-            if (pl.cenas.length < 2) return { ok: false, error: 'o vídeo precisa de ao menos 1 cena.' };
-            pl.cenas.splice(i, 1); pl.trocas.splice(Math.max(0, i - 1), 1);
-            refluir(pl);
-            return { ok: true, resumo: `cena ${m.cena} removida (${pl.cenas.length} cenas, ${pl.duracao}s)` };
-        }
-        case 'mover': {
-            const i = idx(pl, m.cena), j = idx(pl, m.para);
-            if (i < 0) return falta(m.cena); if (j < 0) return falta(m.para);
-            const [c] = pl.cenas.splice(i, 1); pl.cenas.splice(j, 0, c);
-            refluir(pl);
-            return { ok: true, resumo: `cena ${m.cena} → posição ${m.para}` };
-        }
-        case 'duplicar': {
-            const i = idx(pl, m.cena); if (i < 0) return falta(m.cena);
-            const para = m.para == null ? i + 1 : Math.max(0, Math.min(pl.cenas.length, Number(m.para) - 1));
-            pl.cenas.splice(para, 0, JSON.parse(JSON.stringify(pl.cenas[i])));
-            pl.trocas.splice(Math.max(0, para - 1), 0, pl.trocas[Math.min(pl.trocas.length - 1, Math.max(0, para - 1))] || 'corte');
-            refluir(pl);
-            return { ok: true, resumo: `cena ${m.cena} duplicada (${pl.cenas.length} cenas, ${pl.duracao}s)` };
-        }
-        case 'trilha': {
-            const v = m.valor;
-            if (v === false || v === 0 || /^(nenhuma|sem|sem_trilha|false|off|nao|não)$/i.test(String(v))) { spec.trilha = null; spec.semTrilha = true; pl.bpm = 0; return { ok: true, resumo: 'sem trilha' }; }
-            if (typeof v === 'string' && fs.existsSync(v)) { spec.trilha = { arquivo: v, inicio: 0 }; spec.semTrilha = false; return { ok: true, resumo: 'trilha: ' + path.basename(v) }; }
-            spec.buscaTrilha = typeof v === 'string' && v !== 'true' ? v : null; spec.semTrilha = false; spec.trilha = null; spec.trocarTrilha = true;
-            return { ok: true, resumo: 'trilha nova' + (spec.buscaTrilha ? ': ' + spec.buscaTrilha : '') };
-        }
-        case 'volume': {
-            const alvo = String(m.alvo || '').toLowerCase();
-            if (!['voz', 'trilha', 'sfx'].includes(alvo)) return { ok: false, error: 'volume pede alvo voz, trilha ou sfx.' };
-            const db = m.mudo ? -60 : Number(m.db);
-            if (!isFinite(db) || db < -60 || db > 12) return { ok: false, error: 'volume pede db entre -60 e 12 (0 = como a máquina mixou).' };
-            spec.volumes = { ...(spec.volumes || {}), [alvo]: db };
-            return { ok: true, resumo: `volume ${alvo}: ${db} dB` };
-        }
-        case 'formato': {
-            const f = maq().FORMATOS[String(m.valor)]; if (!f) return { ok: false, error: 'formato: 9:16, 1:1 ou 16:9.' };
-            pl.w = f[0]; pl.h = f[1]; pl.formato = String(m.valor);
-            if (pl.legenda) { pl.legenda.tamanho = pl.h > pl.w ? 52 : 44; pl.legenda.y = pl.h > pl.w ? 0.91 : 0.9; }
-            return { ok: true, resumo: 'formato ' + m.valor };
-        }
-        default:
-            return { ok: false, error: 'mudança desconhecida: "' + op + '" (texto, cor, fonte, ritmo, duracao, remover, mover, duplicar, trilha, volume, formato).' };
-    }
-}
-
-// ── render ───────────────────────────────────────────────────────────────
-
-async function renderizarSpec(spec, pasta, { previa = false, deps = {}, semRede = false } = {}) {
-    const M = maq();
-    const pl = spec.pl;
-    const renderizar = deps.renderizar || require('./effectcraft.js').renderizar;
-    const tm = M.tempos(pl);
-    const r = await renderizar({ pasta, script: M.script(pl), comp: 'MAIN', fontes: M.fontesDoPlano(pl), conferir: previa ? [] : tm.map((x) => x.conferir), previa });
-    if (!r.ok) return r;
-    if (previa) {
-        const v = path.join(pasta, 'video-previa.mp4');
-        fs.copyFileSync(r.video, v);
-        return { ok: true, video: v, quadros: r.quadros || [], mix: null };
-    }
-    const som = require('./maquina-som.js');
-    const eventos = M.lerSons(r.saida);
-    const final = path.join(pasta, 'video-motion.mp4');
-    let mix = { ok: false, video: r.video }, sons = [];
-    try {
-        const vol = spec.volumes || {};
-        const indice = deps.sfxIndice || await som.prepararBiblioteca({ assunto: spec.args && spec.args.assunto || '', acoes: [...new Set(eventos.map((e) => e.tipo))], rede: !semRede });
-        sons = som.escolherSons(eventos, { assunto: spec.args && spec.args.assunto || '', indice, semente: pl.semente || 1 });
-        // a voz mais alta = o resto mais baixo (o final fecha em −14 LUFS, então só a diferença conta)
-        const dv = vol.voz || 0;
-        const mixar = deps.mixar || som.mixar;
-        mix = mixar({ pasta, mudo: r.video, saida: final, sons, trilha: spec.trilha && spec.trilha.arquivo, trilhaInicio: spec.trilha ? spec.trilha.inicio || 0 : 0, voz: spec.voz && spec.voz.mp3, duracao: pl.duracao, vol: { trilha: (vol.trilha || 0) - dv, sfx: (vol.sfx || 0) - dv } });
-    } catch (e) { mix = { ok: false, error: e.message, video: r.video }; }
-    let video = mix.ok ? mix.video : r.video;
-    if (video !== final && fs.existsSync(video)) { fs.copyFileSync(video, final); video = final; }
-    return { ok: true, video, quadros: r.quadros || [], mix, lufs: mix.ok ? mix.lufs : null, aviso: mix.ok ? undefined : 'o vídeo saiu sem a mixagem de áudio: ' + (mix.error || 'sem ffmpeg') };
-}
-
-// ── a ferramenta ─────────────────────────────────────────────────────────
-
-/**
- * estudio_editar. `args`: {mudancas:[...], voltar_para?, previa?, final?, listar?}. `deps`: renderizar, mixar, sfxIndice, trilha, semRede.
- */
-async function editar(args = {}, { pasta, deps = {} } = {}) {
-    if (!pasta) return { ok: false, error: 'faltou a pasta do projeto.' };
-    const ix = indice(pasta);
-    if (!fs.existsSync(ARQ(pasta))) return { ok: false, error: 'esse vídeo não tem cenas.json: só dá para editar o que a máquina de motion (estudio_motion) gerou.' };
-    const lista = () => ix.versoes.map((v) => ({ n: v.n, resumo: v.resumo, previa: v.previa || undefined, atual: v.n === ix.atual || undefined }));
-    if (args.listar) return { ok: true, atual: ix.atual, versoes: lista() };
-
-    if (args.voltar_para != null) {
-        const v = ix.versoes.find((x) => x.n === Number(args.voltar_para));
-        if (!v) return { ok: false, error: `não existe a v${args.voltar_para} (há ${ix.versoes.map((x) => 'v' + x.n).join(', ') || 'nenhuma'}).` };
-        const spec = ler(path.join(pasta, 'versoes', 'v' + v.n, 'cenas.json'));
-        gravar(ARQ(pasta), spec);
-        ix.atual = v.n; gravar(IDX(pasta), ix);
-        let video = v.video ? path.join(pasta, v.video) : null;
-        if (video && fs.existsSync(video)) { const f = path.join(pasta, 'video-motion.mp4'); fs.copyFileSync(video, f); video = f; }
-        return { ok: true, versao: v.n, video, versoes: lista(), nota: `voltou para a v${v.n}; a próxima mudança vira a v${ix.versoes.reduce((m, x) => Math.max(m, x.n), 0) + 1}.` };
-    }
-
-    // O plano limita as edições guardadas por vídeo (grátis 3). Prévia e a versão original não contam.
-    const gastas = indice(pasta).versoes.filter((v) => !v.previa && v.resumo !== 'original').length;
-    const lim = await (deps.cabeMais ? deps.cabeMais(gastas) : require('../limites.js').cabeMais('versoesEditor', gastas));
-    if (!lim.ok && !args.previa) return { ok: false, error: lim.error + ' Dá para voltar a uma versão (voltar_para) ou ver as prévias.' };
-
-    const spec = ler(ARQ(pasta));
-    const mudancas = Array.isArray(args.mudancas) ? args.mudancas : [];
-    if (!mudancas.length && !args.final) return { ok: false, error: 'mudancas está vazio (ou use final:true para renderizar a prévia em qualidade final).' };
-    const feitas = [], recusadas = [];
-    for (const m of mudancas) {
-        const r = aplicar(spec, m, { pasta });
-        (r.ok ? feitas : recusadas).push(r.ok ? r.resumo : r.error);
-    }
-    if (!feitas.length && !args.final) return { ok: false, error: 'nenhuma mudança valeu: ' + recusadas.join(' | ') };
-
-    if (spec.trocarTrilha) {   // trilha nova por busca
-        const semRede = !!(deps.semRede || args.semRede);
-        try {
-            let r;
-            if (deps.trilha) { const t0 = await deps.trilha(pasta, spec.buscaTrilha); r = t0 && t0.arquivo ? t0 : null; }
-            else { r = await require('./maquina-trilha.js').escolher({ chave: dir().achar(String(spec.args && spec.args.assunto || '')).chave, busca: spec.buscaTrilha, pasta, rede: !semRede }); if (!(r && r.arquivo)) r = null; }
-            if (r) { spec.trilha = { arquivo: r.arquivo, inicio: 0 }; spec.pl.bpm = r.bpm || 0; }
-            else recusadas.push('não achei trilha nova; o vídeo fica sem música.');
-        } catch (e) { recusadas.push('trilha: ' + e.message); }
-        delete spec.trocarTrilha;
-    }
-
-    const previa = !!args.previa;
-    spec.previa = previa;
-    const r = await renderizarSpec(spec, pasta, { previa, deps, semRede: !!(deps.semRede || args.semRede) });
-    if (!r.ok) return r;
-    const resumo = feitas.join('; ') || 'render final';
-    // versão: a prévia também entra (marcada), pra dar pra voltar
-    const versao = registrarVersao(pasta, spec, r.video, resumo);
-    return { ok: true, versao, previa, video: r.video, quadros: r.quadros, duracao: spec.pl.duracao, cenas: spec.pl.cenas.length, feitas, recusadas, versoes: lista2(pasta), lufs: r.lufs, aviso: r.aviso };
-}
-const lista2 = (pasta) => indice(pasta).versoes.map((v) => ({ n: v.n, resumo: v.resumo, previa: v.previa || undefined }));
-
-module.exports = { salvarSpec, aplicar, editar, indice, renderizarSpec, registrarVersao };

package/lib/estudio/gosto-descrever.js

@@ -1,87 +0,0 @@
-/**
- * gosto-descrever.js — o modelo olha o vídeo que a pessoa curtiu e descreve no vocabulário do diretor.
- *
- * A medida (gosto-medir.js) dá os números; aqui um mosaico de 12 quadros vai ao servidor (POST /api/gosto/descrever,
- * Gemini com visão) e volta com câmeras, trocas e tipografias do vocabulário + 2 ou 3 frases do que se vê.
- * A tela mostra isso e a pessoa corrige antes de salvar: a IA decide, a pessoa confere.
- *
- *   mosaico(arquivo, {duracao, saida})                12 quadros num JPEG só (ffmpeg), abaixo de ~1 MB
- *   descrever(arquivo, medida, {api, servidor, token}) → {ok, descricao} | {ok:false, motivo}. Nunca lança.
- *   filtrarDescricao(d, vocabulario)                  só ids do vocabulário, até 3 por grupo, até 3 frases de 160
- *   vocabulario()                                     {cameras, trocas, tipografias} do maquina-diretor.js
- */
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-
-const LIMITE_MOSAICO = 1024 * 1024;   // o servidor recusa base64 acima de 1,5 MB: 1 MB de jpeg vira ~1,37 MB
-const MAX_FRASES = 3;
-const MAX_FRASE = 160;
-const GRUPOS = ['cameras', 'trocas', 'tipografias'];
-
-/** O vocabulário do diretor: o que o modelo pode escolher. */
-function vocabulario() {
-    const d = require('./maquina-diretor.js');
-    return { cameras: [...d.CAMERAS], trocas: [...d.TRANSICOES], tipografias: Object.keys(d.TIPOGRAFIAS) };
-}
-
-/** Só ids do vocabulário (sem repetir), até 3 por grupo; até 3 frases curtas, sem caractere de controle. */
-function filtrarDescricao(d, vocab) {
-    const o = d && typeof d === 'object' ? d : {};
-    const v = vocab || vocabulario();
-    const out = {};
-    for (const g of GRUPOS) {
-        const ok = new Set(Array.isArray(v[g]) ? v[g] : []);
-        out[g] = [...new Set(Array.isArray(o[g]) ? o[g] : [])].filter((x) => typeof x === 'string' && ok.has(x)).slice(0, 3);
-    }
-    out.frases = (Array.isArray(o.frases) ? o.frases : [])
-        .map((f) => String(f == null ? '' : f).replace(/[\u0000-\u001f\u007f]+/g, ' ').replace(/\s+/g, ' ').trim().slice(0, MAX_FRASE))
-        .filter(Boolean).slice(0, MAX_FRASES);
-    return out;
-}
-
-/** 12 quadros espaçados num JPEG 4x3 (mesma ideia da folhaDeContato do maquina-layout). Devolve o caminho ou null. */
-async function mosaico(arquivo, { duracao, saida } = {}) {
-    const dur = Math.max(1, Number(duracao) || 15);
-    const destino = saida || path.join(os.tmpdir(), `primocode-mosaico-${process.pid}-${Date.now()}.jpg`);
-    // qualidade 5 costuma bastar; se passar de 1 MB, baixa até caber
-    for (const q of [5, 9, 14, 20]) {
-        const r = spawnSync('ffmpeg', ['-y', '-v', 'error', '-i', arquivo, '-vf', `fps=12/${dur.toFixed(3)},scale=320:-2,tile=4x3`, '-frames:v', '1', '-q:v', String(q), destino], { encoding: 'utf8' });
-        if (r.status !== 0 || !fs.existsSync(destino)) return null;
-        if (fs.statSync(destino).size < LIMITE_MOSAICO) return destino;
-    }
-    try { fs.unlinkSync(destino); } catch { /* ok */ }
-    return null;
-}
-
-/**
- * Monta o mosaico, pergunta ao servidor e devolve {ok:true, descricao} (já filtrada aqui: não confia no servidor)
- * ou {ok:false, motivo}. `api` é injetável: { request(servidor, endpoint, payload, token) }.
- */
-async function descrever(arquivo, medida, { api, servidor, token } = {}) {
-    let jpg = null;
-    try {
-        jpg = await mosaico(arquivo, { duracao: medida && medida.segundos });
-        if (!jpg) return { ok: false, motivo: 'sem_mosaico' };
-        let cliente = api, url = servidor, tk = token;
-        if (!cliente || !url) {
-            const cfg = require('../config.js').loadConfig();
-            cliente = cliente || require('../api.js');
-            url = url || cfg.server;
-            tk = tk !== undefined ? tk : cfg.token;
-        }
-        const vocab = vocabulario();
-        const r = await cliente.request(url, '/api/gosto/descrever', { imagem: fs.readFileSync(jpg).toString('base64'), medida: medida || {}, vocabulario: vocab }, tk);
-        if (!r || r.ok !== true || !r.descricao) return { ok: false, motivo: r && r.semVisao ? 'sem_visao' : String((r && (r.error || r.erro)) || 'sem_resposta').slice(0, 200) };
-        return { ok: true, descricao: filtrarDescricao(r.descricao, vocab) };
-    } catch (e) {
-        return { ok: false, motivo: String((e && e.message) || e).slice(0, 200) };
-    } finally {
-        if (jpg) { try { fs.unlinkSync(jpg); } catch { /* ok */ } }
-    }
-}
-
-module.exports = { mosaico, descrever, filtrarDescricao, vocabulario };