primocode 11.0.0 → 11.2.0

package/lib/video/analise.js

@@ -1,89 +0,0 @@
-/**
- * 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 };

package/lib/video/auto.js

@@ -1,344 +0,0 @@
-/**
- * auto.js — `primocode video auto`: o vídeo é o pedido.
- *
- *   "Quero que ele leia o que eu falo no vídeo e aplique cada pedido no
- *    momento em que eu digo." (01/10)
- *
- * A pessoa grava falando o que quer ("separe em camadas", "coloca o logo do
- * Claude aqui", "com o estalar de dedos me coloca numa praia") e o editor
- * acha cada pedido na transcrição e o ancora no que o rastro viu: a palavra,
- * a mão que aparece logo depois, o estalo que vem em seguida, o juntar das
- * mãos. Nada de quadro escrito à mão.
- *
- *   planejar(dados) → [{op, args(segundos da origem), motivo}]   pura (o teste roda)
- *   OPS.auto.run    → junta os dados, executa o plano, devolve o que fez
- *
- * Tudo em SEGUNDOS DA ORIGEM até a hora de executar: os cortes (silêncio,
- * fim) vão por último e a legenda depois deles, já nos cortes.
- */
-
-'use strict';
-
-const PED = require('./pedido.js');
-
-const tira = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
-const r2 = (n) => Math.round(n * 100) / 100;
-
-/* O que o Whisper ouve no lugar do que a pessoa disse — visto nos dois
-   primeiros vídeos de verdade: "cloud", "Claudio", "xgbt", "estravar",
-   "instruar de dedos". Normaliza antes de qualquer regra. */
-const OUVIDO = [
-    [/\b(claudio|claudia|cloud|clode|clod|claud|cloude)\b/g, 'claude'],
-    [/\b(x ?gbt|x ?gpt|chat ?gbt|chat ?gpt|chat ?jpt|tchat ?gpt|chatgbt|gbt)\b/g, 'chatgpt'],
-    [/\bgoogle\s+(chrome|drive)\b/g, '$1'],
-    [/\b(estr[ae]l\w*|estrav\w*|estal\w*|instru\w*|estral\w*)\s+(?:os|nos|dos|de|o|do)?\s*dedos?\b/g, 'estalar o dedo'],
-    [/\b(estal\w*|estral\w*)\b/g, 'estalar'],
-];
-function normal(t) {
-    let s = tira(t).replace(/[^a-z0-9 ]/g, ' ').replace(/\s+/g, ' ').trim();
-    for (const [re, por] of OUVIDO) s = s.replace(re, por);
-    return s;
-}
-
-/* "colocar um foguete aqui na palma da minha mão": qualquer coisa na mão, não
-   só as logos. Vira o modelo, se houver, ou a placa com o nome. */
-const NA_MAO = /\b(?:coloc\w*|po[er]\w*|bot\w*|aparec\w*)\s+(?:um|uma|o|a)\s+([a-z]{3,20})(?:\s+[a-z]{3,20})?\s+(?:aqui\s+)?(?:na|em|sobre|nas)\s+(?:a\s+)?(?:palma|mao|maos)\b/g;
-const NAO_OBJETO = /^(logo|imagem|foto|fundo|legenda|praia|cerebro|video|mao|coisa)$/;
-function objetoNaMao(t) {
-    const out = [];
-    let m;
-    NA_MAO.lastIndex = 0;
-    while ((m = NA_MAO.exec(t))) if (!NAO_OBJETO.test(m[1])) out.push({ object: m[1], pos: m.index, mao: null });
-    return out;
-}
-
-/** As palavras viram frases: ponto final, ou pausa de mais de 0,7 s. */
-function frases(palavras) {
-    const out = [];
-    let atual = [];
-    const fecha = () => { if (atual.length) out.push({ ws: atual, de: atual[0].de, ate: atual[atual.length - 1].ate }); atual = []; };
-    palavras.forEach((p, i) => {
-        const ant = palavras[i - 1];
-        if (ant && p.de - ant.ate > 0.7) fecha();
-        atual.push(p);
-        if (/[.!?]$/.test(String(p.texto).trim())) fecha();
-    });
-    fecha();
-    for (const f of out) f.t = normal(f.ws.map((w) => w.texto).join(' '));
-    return out;
-}
-
-/** O segundo em que a frase diz `re` (a primeira palavra que casa), ou o começo dela. */
-function quando(f, re) {
-    for (let i = 0; i < f.ws.length; i++) {
-        const um = normal(f.ws[i].texto);
-        const dois = normal(f.ws.slice(i, i + 3).map((w) => w.texto).join(' '));
-        if (re.test(um) || (re.test(dois) && !re.test(normal(f.ws.slice(i + 1, i + 3).map((w) => w.texto).join(' '))))) return f.ws[i].de;
-    }
-    return f.de;
-}
-
-const RE = {
-    camadas: /\bcamadas?\b|\btres dimens|\b(tir\w*|remov\w*|recort\w*|separ\w*)\s+(?:me\s+)?(?:o\s+|do\s+|meu\s+)?fundo\b|\bme\s+(tir\w*|recort\w*)\s+do\s+fundo\b/,
-    volta: /\bvolt\w*\b|\bnormal\b/,
-    estalo: /\bestalar\b/,
-    juntar: /\bjunt\w*\b|\buni\w*\b/,
-    cerebro: /\bcerebro\b/,
-    silencio: /\bsilencios?\b/,
-    fim: /\b(encerr|acab|termin|finaliz)\w*\b/,
-    legenda: /\blegendas?\b/,
-    acima: /\b(em cima|acima|encima|sobre|por cima)\s+da\s+(?:minha\s+)?cabeca\b|\baqui em cima\b|\bla em cima\b/,
-    imagem: /\b(?:imagem|foto|fundo)\s+(?:de|do|da)\s+(?:(?:um|uma)\s+)?([a-z]{3,20})\b/,
-};
-
-/** O fundo pedido na frase: um lugar conhecido, ou "imagem de um tubarão". */
-function fundoPedido(t) {
-    const l = PED.lugar(t);
-    if (l && !/^(tras|atras|aqui)$/.test(l)) return l;
-    const m = t.match(RE.imagem);
-    return m && !/^(tras|atras|aqui|novo|nova)$/.test(m[1]) ? m[1] : null;
-}
-
-/**
- * dados: {palavras:[{texto,de,ate}], estalos:[{t,score,mao}], juntaAbre:[{junta,abre}],
- *         maos:{left:[[de,ate]],right:[[de,ate]]}, silencios:[{de,ate}], dur}  — tudo em segundos.
- * → {passos:[{op,args,motivo}], legenda:{color?,position?,desde?}}
- */
-function planejar(d) {
-    const fs = frases(d.palavras || []);
-    const passos = [];
-    const bons = (d.estalos || []).filter((e) => e.mao || e.score >= 20);
-    const usados = new Set();
-    /* O estalo da janela é o MAIS FORTE dela, não o primeiro: o dedo que se
-       prepara faz um "tec" fraco antes do estalo de verdade (visto: 10,3 s
-       com 17 antes do 11,8 s com 21). */
-    const estaloDepois = (t, janela) => {
-        const c = bons.filter((x) => x.t >= t - 0.2 && x.t <= t + janela && !usados.has(x.t)).sort((a, b) => b.score - a.score)[0];
-        if (!c) return undefined;
-        usados.add(c.t);
-        return c.t;
-    };
-    const ehPedido = (f) => RE.camadas.test(f.t) || !!fundoPedido(f.t) || PED.objetosCitados(f.t).length || RE.juntar.test(f.t) || RE.silencio.test(f.t) || RE.fim.test(f.t);
-
-    // 1. As camadas em 3D: da palavra até o "volta" (ou o próximo pedido), 2,5–5 s.
-    const iCam = fs.findIndex((f) => RE.camadas.test(f.t) && !fundoPedido(f.t));
-    if (iCam >= 0) {
-        const de = Math.max(0, quando(fs[iCam], /camada|fundo|tir|recort|separ/) - 0.2);
-        const prox = fs.slice(iCam + 1).find((f) => f.de > de + 1 && (RE.volta.test(f.t) || ehPedido(f)));
-        const ate = Math.min(d.dur, de + 5, Math.max(de + 2.5, prox ? prox.de : de + 4));
-        passos.push({ op: 'separate_layers', args: { show3d: true, from: r2(de), to: r2(ate) }, motivo: `"${fs[iCam].t}"` });
-    }
-
-    // 2. Os objetos: na palavra, na mão que aparece logo ali (a outra, se a primeira já tem um).
-    const objetos = [];
-    const maoEm = (t, ocupadas) => {
-        const cand = [];
-        for (const lado of ['left', 'right']) {
-            for (const [a, b] of (d.maos && d.maos[lado]) || []) {
-                if (b < t - 0.2 || a > t + 3) continue;
-                cand.push({ lado, a: Math.max(a, t), b });
-            }
-        }
-        cand.sort((x, y) => (ocupadas.has(x.lado) - ocupadas.has(y.lado)) || x.a - y.a);
-        return cand[0] || null;
-    };
-    for (const f of fs) {
-        for (const o of [...PED.objetosCitados(f.t), ...objetoNaMao(f.t)]) {
-            const nome = o.object === 'chatgpt' ? /chatgpt|gpt/ : new RegExp(o.object.slice(0, 5));
-            const t = quando(f, nome);
-            if (objetos.some((x) => x.object === o.object && Math.abs(x.t - t) < 4)) continue;
-            const ocupadas = new Set(objetos.filter((x) => x.ate === null || x.ate > t).map((x) => x.mao));
-            const m = maoEm(t, ocupadas);
-            const mao = o.mao === 'left' || o.mao === 'right' ? o.mao : m ? m.lado : (ocupadas.has('left') ? 'right' : 'auto');
-            objetos.push({ object: o.object, t, de: m && m.lado === mao ? m.a : t, mao, ate: null, motivo: `"${f.t}"` });
-        }
-    }
-
-    // 3. Juntar as mãos (com objeto na mão): a junção que vem depois da frase; o cérebro se for dito.
-    let fusao = null;
-    if (objetos.length) {
-        const iJ = fs.findIndex((f) => (RE.juntar.test(f.t) || RE.cerebro.test(f.t)) && f.ate > objetos[0].t);
-        if (iJ >= 0) {
-            const f = fs[iJ];
-            const ev = (d.juntaAbre || []).find((e) => e.junta >= f.de - 1.5 && e.junta > objetos[0].de + 0.5);
-            if (ev) {
-                const cerebro = [f, fs[iJ + 1]].some((x) => x && RE.cerebro.test(x.t));
-                fusao = { junta: ev.junta, abre: ev.abre, then: cerebro ? 'brain' : 'none', motivo: `"${f.t}"` };
-            }
-        }
-    }
-    for (const o of objetos) {
-        o.ate = fusao && fusao.junta > o.de ? fusao.junta : Math.min(d.dur, o.de + 4);
-        if (o.ate > o.de + 0.3) passos.push({ op: 'attach_3d', args: { object: o.object, hand: o.mao, from: r2(o.de), to: r2(o.ate) }, motivo: o.motivo });
-    }
-    if (fusao) passos.push({ op: 'merge_on_join', args: { junta: r2(fusao.junta), ...(fusao.abre !== null ? { abre: r2(fusao.abre) } : {}), then: fusao.then }, motivo: fusao.motivo });
-
-    // 4. Fundos novos: no estalo, se a frase (ou a anterior) fala dele, ou se um estalo vem logo depois; senão na palavra.
-    const fundos = [];
-    fs.forEach((f, i) => {
-        const onde = fundoPedido(f.t);
-        if (!onde || !/\b(coloc\w*|poe|pon\w*|bot\w*|lev\w*|troc\w*|mud\w*|fundo|imagem|foto|me\s+em)\b/.test(f.t)) return;
-        const t = quando(f, new RegExp(onde.split(' ')[0].slice(0, 5)));
-        /* Um estalo logo depois do lugar é o gatilho, dito ou não. Se o estalo
-           foi dito ANTES do lugar ("se estalar os dedos ela coloca um
-           tubarão"), ele pode vir uns segundos depois da frase. */
-        const antes = f.t.slice(0, f.t.indexOf(onde.split(' ')[0]));
-        const falaEstalo = RE.estalo.test(antes) || (fs[i - 1] && RE.estalo.test(fs[i - 1].t) && !fundoPedido(fs[i - 1].t));
-        let e = estaloDepois(t, 3);
-        if (e === undefined && falaEstalo) e = estaloDepois(f.de, 10);
-        // "só aqui", "somente aqui": o fundo vale para a frase, depois volta o original.
-        const so = /\b(somente|so|apenas)\s+(aqui|agora|nessa parte|nesse momento)\b/.test(f.t) ? Math.min(d.dur, f.ate + 0.6) : null;
-        fundos.push({ with: onde, at: e !== undefined ? e : t, ...(so ? { ate: so } : {}), motivo: `"${f.t}"` + (e !== undefined ? ' (no estalo)' : '') });
-    });
-    fundos.forEach((b, i) => {
-        const until = b.ate !== undefined ? b.ate : fundos[i + 1] ? fundos[i + 1].at : null;
-        passos.push({ op: 'replace_background', args: { with: b.with, at: r2(b.at), ...(until !== null ? { until: r2(until) } : {}) }, motivo: b.motivo });
-    });
-
-    // 5. Legenda: sempre (é reels); a cor e a posição se forem pedidas, a partir do estalo se ele for citado.
-    const legenda = {};
-    const iL = fs.findIndex((f) => RE.legenda.test(f.t));
-    if (iL >= 0) {
-        const janela = fs.slice(iL, iL + 3);
-        const cor = janela.map((f) => PED.corPedida(f.t)).find(Boolean);
-        if (cor) legenda.color = cor;
-        const fp = janela.find((f) => RE.acima.test(f.t));
-        if (fp) {
-            legenda.position = 'above_head';
-            if (RE.estalo.test(fp.t)) { const e = estaloDepois(fp.de, 8); if (e !== undefined) legenda.desde = e; }
-            // "a legenda que tá aqui… aqui em cima": sobe quando ela diz onde.
-            else if (/\b(aqui|la) em cima\b/.test(fp.t)) legenda.desde = quando(fp, /cima/);
-        } else {
-            /* "a legenda daqui ficar aqui", apontando: o pedido é mudar de lugar, e
-               o lugar que se aponta em quem fala para a câmera é perto do rosto —
-               a legenda sobe para a cabeça no segundo "aqui". (01/10) */
-            const fd = janela.find((f) => /\bdaqui\b[\s\S]*\b(ficar|ir|pra|para)\b[\s\S]*\baqui\b|\b(mud|muda|mover|move|pass)\w*\b[\s\S]*\baqui\b/.test(f.t));
-            if (fd) {
-                legenda.position = 'above_head';
-                const aquis = fd.ws.filter((w) => /^aqui/.test(normal(w.texto)));
-                legenda.desde = (aquis[aquis.length - 1] || fd.ws[0]).de;
-            }
-        }
-    }
-
-    // 6. Cortes, por último: o silêncio que a pessoa cita, e o fim que ela anuncia.
-    const cortes = [];
-    const iS = fs.findIndex((f) => RE.silencio.test(f.t) && /\b(cort\w*|tir\w*|remov\w*|apag\w*|retir\w*)\b/.test(f.t));
-    if (iS >= 0) {
-        const t0 = fs[iS].de;
-        const sil = juntarSilencios(d.silencios || []).filter((s) => s.de >= t0 && s.de <= t0 + 15 && s.ate - s.de >= 1.5)
-            .sort((a, b) => (b.ate - b.de) - (a.ate - a.de))[0];
-        if (sil) cortes.push({ de: r2(sil.de + 0.1), ate: r2(sil.ate - 0.1), motivo: `"${fs[iS].t}" (${r2(sil.ate - sil.de)} s parado)` });
-    }
-    const iF = fs.findIndex((f) => RE.fim.test(f.t) && /\bvideo\b/.test(f.t));
-    if (iF >= 0) {
-        const f = fs[iF];
-        const ultima = fs[fs.length - 1].ate;
-        const e = RE.estalo.test(f.t) ? estaloDepois(f.de, 6) : undefined;
-        const fim = Math.max(ultima, e !== undefined ? e : 0) + 0.4;
-        if (d.dur - fim > 0.8) cortes.push({ de: r2(fim), ate: r2(d.dur), motivo: `"${f.t}"` });
-    }
-    if (cortes.length) passos.push({ op: 'cortes', args: { trechos: cortes.map(({ de, ate }) => [de, ate]) }, motivo: cortes.map((c) => c.motivo).join(' · ') });
-
-    return { passos, legenda };
-}
-
-/** Silêncios separados por um respiro (< 0,4 s) são um só. */
-function juntarSilencios(sil) {
-    const out = [];
-    for (const s of [...sil].sort((a, b) => a.de - b.de)) {
-        const u = out[out.length - 1];
-        if (u && s.de - u.ate < 0.4) u.ate = Math.max(u.ate, s.ate);
-        else out.push({ de: s.de, ate: s.ate });
-    }
-    return out;
-}
-
-/* O que vem depois do auto. Sem pedido falado (15/10: um vídeo do Instagram,
-   "edita pra mim?"), o plano é vazio e só a legenda entra — e o agente
-   exportava assim. Aí a edição volta para ele decidir, com o cardápio. */
-function depois(passos) {
-    if ((passos || []).length) return { semPedido: false, texto: 'inspect para OLHAR os momentos; export renderiza (o 3D sai no export)' };
-    return {
-        semPedido: true,
-        texto: 'A gravação não tem pedido falado: só a legenda entrou, e isso ainda não é a edição. '
-            + 'Se a pessoa pediu para editar, a edição é sua: leia a fala (get_transcript) e decida — por exemplo cortar os silêncios (remove_silence), '
-            + 'zoom nos momentos fortes (auto_zoom), apoio quando ela cita uma coisa (add_clips), cor (grade). Olhe com inspect antes do export.',
-    };
-}
-
-const OPS = {
-    auto: {
-        uso: 'auto {asset?,dryRun?} — O VÍDEO É O PEDIDO: lê o que a pessoa FALA na gravação ("separe em camadas", "coloca o logo do Claude aqui", "com o estalar de dedos me coloca numa praia", "junta e vira um cérebro", "cortou o silêncio", "o vídeo acaba") e aplica cada efeito no momento em que ela diz, ancorado na palavra, na mão, no estalo e no juntar das mãos; legenda sempre. Serve quando a gravação TRAZ pedidos falados. Sem pedido falado (vídeo de outra pessoa, ou só fala), ele põe só a legenda, e o resto da edição é decisão sua',
-        async run(ctx, a) {
-            const T = require('./timeline.js');
-            const C = require('./camadas.js');
-            const R = require('./rastro.js');
-            const RT = require('./rastrear.js');
-            const TR = require('./transcript.js');
-            const FXO = require('./ops-fx.js');
-            const tl = ctx.tl;
-            if (!tl) throw T.erro('nenhum projeto aberto: import {"path":"..."} primeiro');
-            const asset = C.base(tl, a.asset);
-            const inicio = Date.now();
-            // O lento e independente junto: rastreio (MediaPipe em paralelo) e transcrição.
-            const [rs, tr] = await Promise.all([RT.garantir(ctx.p.dir, asset), TR.obter(ctx.p.dir, asset)]);
-            if (!rs.ok) return rs;
-            if (!tr.ok) return { ok: false, error: 'sem a fala não sei o que fazer: ' + tr.error };
-            const fps = rs.rastro.fps;
-            const trilhas = R.trilhasDasMaos(rs.rastro);
-            const trechos = (t) => R.trechosVisiveis(t, Math.round(fps * 0.3)).map(([x, y]) => [x / fps, y / fps]);
-            const dados = {
-                palavras: tr.palavras,
-                estalos: (await FXO.estalosDe(ctx, asset)).map((e) => ({ t: e.t, score: e.score, mao: e.mao })),
-                juntaAbre: R.juntaEAbre(trilhas, { rastro: rs.rastro }).map((e) => ({ junta: e.junta / fps, abre: e.abre === null ? null : e.abre / fps })),
-                maos: { left: trechos(trilhas.left), right: trechos(trilhas.right) },
-                silencios: await require('./render.js').silenciosDe(ctx.p.dir, asset, { threshold: -35, minSilence: 0.8 }),
-                dur: asset.seconds,
-            };
-            const plano = planejar(dados);
-            const q = (s) => C.origemParaQuadro(ctx.tl, asset.id, s);
-            const ver = plano.passos.map((p) => ({ op: p.op, motivo: p.motivo, args: p.args }));
-            if (a.dryRun) return { ok: true, plano: ver, legenda: plano.legenda, segundos: 'da gravação' };
-
-            const { OPS: TODAS } = require('./ops.js');
-            const feitos = [];
-            const roda = async (op, args, motivo) => {
-                const res = await TODAS[op].run(ctx, args);
-                feitos.push({ op, motivo, ok: !!res && res.ok !== false, ...(res && res.ok === false ? { error: res.error } : {}) });
-                return res;
-            };
-            for (const p of plano.passos) {
-                const g = p.args;
-                if (p.op === 'separate_layers') await roda(p.op, { show3d: true, from: q(g.from), to: q(g.to) }, p.motivo);
-                else if (p.op === 'attach_3d') await roda(p.op, { object: g.object, hand: g.hand, from: q(g.from), to: q(g.to) }, p.motivo);
-                else if (p.op === 'merge_on_join') await roda(p.op, { junta: q(g.junta), ...(g.abre !== undefined ? { abre: q(g.abre) } : {}), then: g.then }, p.motivo);
-                else if (p.op === 'replace_background') await roda(p.op, { with: g.with, at: q(g.at), ...(g.until !== undefined ? { until: q(g.until) } : {}) }, p.motivo);
-                else if (p.op === 'cortes') {
-                    const ranges = g.trechos.map(([de, ate]) => [q(de), Math.min(T.duracao(ctx.tl), q(Math.min(ate, asset.seconds - 0.001)) + 1)]).filter(([x, y]) => x !== null && y > x);
-                    if (ranges.length) await roda('ripple_delete_ranges', { ranges }, p.motivo);
-                }
-            }
-            // A legenda, já nos cortes; a posição a partir do estalo, se ele foi citado.
-            await roda('add_captions', { maxWords: 3, animation: 'highlightPop' }, 'legenda (reels)');
-            const L = plano.legenda;
-            if (L.color || L.position) {
-                const leg = T.todosOsClipes(ctx.tl).filter((x) => x.clip.caption).map((x) => x.clip);
-                const desde = L.desde !== undefined ? q(L.desde) : null;
-                if (L.color) await roda('style_captions', { color: L.color }, 'cor pedida');
-                const ids = leg.filter((c) => desde === null || c.startFrame >= desde).map((c) => c.id);
-                if (L.position && ids.length) await roda('style_captions', { ids, position: L.position }, desde !== null ? 'em cima da cabeça, desde o momento dito' : 'em cima da cabeça');
-            }
-            const falhou = feitos.filter((f) => !f.ok);
-            const prox = depois(plano.passos);
-            return { ok: !falhou.length, feitos, tookS: Math.round((Date.now() - inicio) / 100) / 10,
-                ...(falhou.length ? { error: falhou.map((f) => `${f.op}: ${f.error}`).join('; ') } : {}),
-                ...(prox.semPedido ? { semPedido: true } : {}),
-                depois: prox.texto };
-        },
-    },
-};
-
-const EX = { auto: '{}' };
-
-module.exports = { planejar, frases, normal, fundoPedido, juntarSilencios, depois, OPS, EX };