primocode 9.10.0 → 10.0.9

package/lib/video/ops-fx.js

@@ -0,0 +1,453 @@
+/**
+ * ops-fx.js — as operações "de efeito" do editor: rastrear, separar em
+ * camadas, trocar o fundo no estalo, objeto 3D na mão, fusão ao juntar as
+ * mãos, cortar o silêncio do estalo e a legenda que segue a cabeça.
+ *
+ * Toda operação aqui escreve RECEITA na timeline (segundos da origem) e
+ * passa pelo mesmo `mutar` das outras: foto de antes, validação, delta,
+ * undo. O que é pesado — rastrear (uma vez por mídia, em paralelo) e
+ * renderizar o 3D (no export, pelo hash) — fica fora do caminho da edição.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const T = require('./timeline.js');
+const E = require('./edits.js');
+const C = require('./camadas.js');
+const R = require('./rastro.js');
+const RT = require('./rastrear.js');
+const TR = require('./transcript.js');
+const FX = require('./fx3d.js');
+const video = require('../estudio/video.js');
+
+const r = () => require('./render.js');
+const lista = (v) => (v === undefined ? [] : Array.isArray(v) ? v : [v]);
+const r2 = T.r2;
+
+// ── medidas (com cache) ──────────────────────────────────────────────────
+
+async function rastro(ctx, asset) {
+    const rs = await RT.garantir(ctx.p.dir, asset);
+    if (!rs.ok) throw Object.assign(T.erro(rs.error), { extra: rs });
+    return rs;
+}
+
+/** As palavras da gravação (a transcrição em cache; transcreve se faltar). */
+async function palavras(ctx, asset, { obrigatorio = false } = {}) {
+    const t = await TR.obter(ctx.p.dir, asset);
+    if (!t.ok) { if (obrigatorio) throw T.erro(t.error); return []; }
+    return t.palavras;
+}
+
+/** Os estalos da gravação (segundos), melhor primeiro. */
+async function estalosDe(ctx, asset) {
+    const cache = path.join(ctx.p.dir, 'midia', `estalos-${asset.id}.json`);
+    let cands;
+    if (fs.existsSync(cache)) cands = JSON.parse(fs.readFileSync(cache, 'utf8'));
+    else {
+        const taxa = 22050;
+        cands = R.estalos(await r().amostras(asset.path, taxa), taxa);
+        fs.mkdirSync(path.dirname(cache), { recursive: true });
+        fs.writeFileSync(cache, JSON.stringify(cands));
+    }
+    const arq = RT.arquivos(ctx.p.dir, asset).rastro;
+    const trilhas = fs.existsSync(arq) ? R.trilhasDasMaos(RT.lerRastro(arq)) : null;
+    return R.escolherEstalos(cands, trilhas, trilhas ? RT.lerRastro(arq).fps : 30);
+}
+
+/**
+ * "snap" | "snap:2" | "junta" | "abre" | "palavra:camadas" | quadro (número)
+ * → segundo da ORIGEM da gravação.
+ */
+async function momento(ctx, asset, valor) {
+    if (valor === undefined || valor === null) return null;
+    if (typeof valor === 'number' || /^\d+$/.test(String(valor))) {
+        const s = C.quadroParaOrigem(ctx.tl, asset.id, Number(valor));
+        if (s === null) throw T.erro(`o quadro ${valor} não cai na gravação ${asset.id}`);
+        return s;
+    }
+    const v = String(valor).trim().toLowerCase();
+    let m = v.match(/^(snap|estalo|palma|clap)(?::(\d+))?$/);
+    if (m) {
+        const e = await estalosDe(ctx, asset);
+        if (!e.length) throw T.erro('não achei estalo no áudio (um "tec" curto e agudo). Diga o quadro: {"at":<quadro>}');
+        const n = Number(m[2] || 0);
+        const porTempo = [...e].filter((x) => x.total >= e[0].total - 12).sort((a, b) => a.t - b.t);
+        return n ? (porTempo[n - 1] || porTempo[porTempo.length - 1]).t : e[0].t;
+    }
+    m = v.match(/^(junta|join|abre|open)(?::(\d+))?$/);
+    if (m) {
+        const rs = await rastro(ctx, asset);
+        const ev = R.juntaEAbre(R.trilhasDasMaos(rs.rastro), { rastro: rs.rastro });
+        const k = ev[Number(m[2] || 1) - 1];
+        const f = k && (/junta|join/.test(m[1]) ? k.junta : k.abre);
+        if (f === null || f === undefined) throw T.erro('não vi as mãos se juntarem e abrirem; diga os quadros: {"junta":<quadro>,"abre":<quadro>}');
+        return f / rs.rastro.fps;
+    }
+    m = v.match(/^(?:palavra|word):(.+)$/);
+    if (m) {
+        const p = C.acharPalavra(await palavras(ctx, asset, { obrigatorio: true }), m[1]);
+        if (!p) throw T.erro(`a palavra "${m[1]}" não aparece na fala`);
+        return p.de;
+    }
+    throw T.erro(`momento "${valor}" (use um quadro, "snap", "junta", "abre" ou "palavra:<texto>")`);
+}
+
+const quadro = (ctx, asset, seg) => (seg === null ? null : C.origemParaQuadro(ctx.tl, asset.id, seg));
+
+/** A cor média de uma imagem/vídeo (0..1 por canal), pelo ffmpeg reduzindo a 1 pixel. */
+async function corMedia(arq, seg = 0) {
+    const out = await new Promise((resolve) => {
+        const { spawn } = require('child_process');
+        const p = spawn(video.ffmpeg(), ['-hide_banner', '-loglevel', 'error', ...(seg ? ['-ss', String(seg)] : []), '-i', arq, '-frames:v', '1', '-vf', 'scale=1:1:flags=area', '-f', 'rawvideo', '-pix_fmt', 'rgb24', '-']);
+        const partes = [];
+        p.stdout.on('data', (d) => partes.push(d));
+        p.on('close', () => resolve(Buffer.concat(partes)));
+        p.on('error', () => resolve(Buffer.alloc(0)));
+    });
+    return out.length >= 3 ? [out[0] / 255, out[1] / 255, out[2] / 255] : null;
+}
+
+/** O ganho por canal que aproxima a cor da pessoa da luz do fundo novo (de leve). */
+function ganhoDeCor(pessoa, fundo, forca = 0.18) {
+    if (!pessoa || !fundo) return null;
+    const norm = (c) => { const m = (c[0] + c[1] + c[2]) / 3 || 1; return c.map((x) => x / m); };
+    const [p, f] = [norm(pessoa), norm(fundo)];
+    const g = p.map((x, i) => Math.max(0.92, Math.min(1.08, 1 + forca * (f[i] - x))));
+    const m = (x) => Math.round(x * 1000) / 1000;
+    return { r: m(g[0]), g: m(g[1]), b: m(g[2]) };
+}
+
+// ── as receitas na timeline ──────────────────────────────────────────────
+
+function fxDe(tl, assetId) {
+    tl.fx = tl.fx || {};
+    tl.fx[assetId] = tl.fx[assetId] || { objetos: [] };
+    return tl.fx[assetId];
+}
+
+/** Refaz a camada dos objetos a partir da receita (troca o asset gerado e os clipes). */
+function regerarObjetos(ctx, asset, rs) {
+    const tl = ctx.tl;
+    const fx = fxDe(tl, asset.id);
+    C.limparPapel(tl, 'objetos', asset.id);
+    C.limparGerados(tl);
+    if (!fx.objetos.length) return null;
+    let de = Math.min(...fx.objetos.map((o) => o.de));
+    let ate = Math.max(...fx.objetos.map((o) => o.ate));
+    if (fx.fusao && fx.fusao.depoisAte) ate = Math.max(ate, fx.fusao.depoisAte);
+    de = Math.max(0, de);
+    ate = Math.min(asset.seconds, ate);
+    const receita = { tipo: 'objetos', base: asset.id, de: r2(de * 1000) / 1000, ate: r2(ate * 1000) / 1000, objetos: fx.objetos, fusao: fx.fusao || null };
+    const h = FX.hash({ receita, rastro: [rs.rastro.n, rs.rastro.versao, rs.rastro.segmentador], fps: tl.fps, w: tl.width, h: tl.height, v: FX.versao() });
+    const id = T.novoAssetId(tl);
+    tl.assets[id] = { id, kind: 'video', nome: `objetos-3d-${asset.id}`, path: path.join(ctx.p.dir, 'midia', 'gerado', `objetos-${h}.mov`),
+        seconds: r2(ate - de), width: tl.width, height: tl.height, fps: tl.fps, hasAudio: false, gerado: receita };
+    const ti = C.faixa(tl, 'objetos');
+    return { asset: id, clips: C.espelhar(tl, asset.id, ti, { de, ate, asset: id, origemDe: de, papel: 'objetos' }).map((c) => c.id) };
+}
+
+/** A pessoa recortada sobre a gravação (cria se não houver). */
+function camadaDaPessoa(tl, asset, rs, { feather = 1.2, choke = 1 } = {}) {
+    C.limparPapel(tl, 'pessoa', asset.id);
+    const ti = C.faixa(tl, 'pessoa');
+    return C.espelhar(tl, asset.id, ti, { papel: 'pessoa', props: { } }).map((c) => {
+        c.effects = [{ type: 'key.matte', params: { matte: rs.arquivos.matte, feather, choke } }];
+        return c;
+    });
+}
+
+function temPessoa(tl, assetId) { return T.todosOsClipes(tl).some((x) => x.clip.papel === 'pessoa' && x.clip.base === assetId); }
+
+/** O trecho [de, ate) em que uma mão está na tela (juntando buracos de até `folga` s), a partir de `desde`. */
+function trechoDaMao(trilha, fps, desde, { folga = 1.5 } = {}) {
+    const runs = R.trechosVisiveis(trilha, Math.round(fps * 0.3));
+    const juntos = [];
+    for (const [a, b] of runs) {
+        const u = juntos[juntos.length - 1];
+        if (u && a - u[1] <= folga * fps) u[1] = b;
+        else juntos.push([a, b]);
+    }
+    const f = Math.round(desde * fps);
+    const k = juntos.find(([a, b]) => b > f + fps * 0.3);
+    return k ? [Math.max(k[0], f) / fps, k[1] / fps] : null;
+}
+
+// ── as operações ─────────────────────────────────────────────────────────
+
+const OPS = {
+    track: {
+        uso: 'track {asset?,force?} — rastreia pessoa/rosto/mãos (MediaPipe, em paralelo, 1 vez por mídia) e acha estalos; devolve trechos e eventos em QUADROS',
+        async run(ctx, a) {
+            const asset = C.base(ctx.tl, a.asset);
+            const rs = await RT.garantir(ctx.p.dir, asset, { force: a.force });
+            if (!rs.ok) return rs;
+            const tr = R.trilhasDasMaos(rs.rastro);
+            const fps = rs.rastro.fps;
+            const q = (fr) => quadro(ctx, asset, fr / fps);
+            const trechos = (t) => R.trechosVisiveis(t, Math.round(fps * 0.3)).map(([x, y]) => [q(x), q(Math.max(x, y - 1))]).filter(([x, y]) => x !== null && y !== null);
+            const est = await estalosDe(ctx, asset);
+            return {
+                ok: true, asset: asset.id, cache: !!rs.cache, ...(rs.tookS !== undefined ? { tookS: rs.tookS, partes: rs.partes, trabalhadores: rs.trabalhadores } : {}),
+                segmentador: rs.rastro.segmentador, rosto: r2(rs.rastro.quadros.filter((x) => x.f).length / rs.rastro.n),
+                maos: { left: trechos(tr.left), right: trechos(tr.right) },
+                snaps: est.slice(0, 4).map((e) => ({ at: quadro(ctx, asset, e.t), s: e.t, score: e.score, mao: e.mao })),
+                juntaAbre: R.juntaEAbre(tr, { rastro: rs.rastro }).map((e) => ({ junta: q(e.junta), abre: e.abre === null ? null : q(e.abre) })),
+            };
+        },
+    },
+    separate_layers: {
+        uso: 'separate_layers {asset?,show3d?:false,from?,to?(quadros)|at?("palavra:camadas"),labels?:true} — pessoa recortada (alfa) numa faixa sobre o fundo; show3d = momento 3D das camadas se afastando',
+        async run(ctx, a) {
+            const asset = C.base(ctx.tl, a.asset);
+            const rs = await rastro(ctx, asset);
+            let de = null;
+            let ate = null;
+            if (a.show3d) {
+                if (a.from !== undefined) de = await momento(ctx, asset, a.from);
+                else {
+                    const alvo = a.at || 'palavra:camada';
+                    try { de = Math.max(0, (await momento(ctx, asset, alvo)) - 0.3); } catch { de = Math.min(1, asset.seconds / 4); }
+                }
+                ate = a.to !== undefined ? await momento(ctx, asset, a.to) : de + 2.8;
+                ate = Math.min(asset.seconds, ate);
+                if (!(ate > de + 0.5)) throw T.erro('o momento 3D precisa de pelo menos meio segundo');
+            }
+            return require('./ops.js').mutar(ctx, 'separate_layers', (tl) => {
+                const pessoa = camadaDaPessoa(tl, asset, rs);
+                const out = { layers: { pessoa: pessoa.length, fundo: 'a gravação embaixo' } };
+                if (a.show3d !== undefined) { C.limparPapel(tl, 'camadas3d', asset.id); C.limparGerados(tl); }
+                if (a.show3d) {
+                    const rotulos = a.labels === false ? null : { fundo: 'FUNDO', pessoa: 'VOCÊ' };
+                    const receita = { tipo: 'camadas', base: asset.id, de: r2(de * 1000) / 1000, ate: r2(ate * 1000) / 1000, rotulos };
+                    const h = FX.hash({ receita, w: tl.width, h: tl.height, fps: tl.fps, n: rs.rastro.n, v: FX.versao() });
+                    const id = T.novoAssetId(tl);
+                    tl.assets[id] = { id, kind: 'video', nome: `camadas-3d-${asset.id}`, path: path.join(ctx.p.dir, 'midia', 'gerado', `camadas-${h}.mp4`),
+                        seconds: r2(ate - de), width: tl.width, height: tl.height, fps: tl.fps, hasAudio: false, gerado: receita };
+                    const ti = C.faixa(tl, 'camadas3d');
+                    const cl = C.espelhar(tl, asset.id, ti, { de, ate, asset: id, origemDe: de, papel: 'camadas3d' });
+                    out.show3d = { from: quadro(ctx, asset, de), to: quadro(ctx, asset, ate), clips: cl.map((c) => c.id), render: 'no export (Remotion)' };
+                }
+                C.arrumar(tl);
+                return out;
+            });
+        },
+    },
+    replace_background: {
+        uso: 'replace_background {with:"praia"|"beach"|termo|arquivo,at?:"snap"|quadro|"palavra:x",until?(quadro),asset?} — fundo novo atrás da pessoa a partir do momento (busca a foto se for termo)',
+        async run(ctx, a) {
+            const asset = C.base(ctx.tl, a.asset);
+            const rs = await rastro(ctx, asset);
+            const pedido = a.with || a.image || a.bg;
+            if (!pedido) throw T.erro('faltou "with" (ex.: "praia" ou um arquivo)');
+            let arquivo = null;
+            let creditos = null;
+            if (fs.existsSync(path.resolve(String(pedido)))) arquivo = path.resolve(String(pedido));
+            else {
+                const ass = require('../estudio/assets.js');
+                const termo = C.termoDeFundo(pedido);
+                const vert = ctx.tl.height > ctx.tl.width;
+                const busca = await ass.procurarImagens(termo, { quantas: 6, orientacao: vert ? 'portrait' : 'landscape' });
+                const boas = (busca.imagens || []).filter((x) => !x.largura || (vert ? x.altura >= x.largura : x.largura >= x.altura));
+                const item = boas[0] || (busca.imagens || [])[0];
+                if (!item) throw T.erro(`não achei foto de fundo para "${termo}" (sem rede?). Passe um arquivo: {"with":"fundo.jpg"}`);
+                const b = await ass.baixar(item, { pasta: ctx.p.dir, nome: `fundo-${C.sem(pedido)}`, sub: path.join('midia', 'fundos') });
+                if (!b.ok) throw T.erro(b.error);
+                arquivo = b.arquivo;
+                creditos = b.creditos;
+            }
+            const seg = a.at === undefined ? await momento(ctx, asset, 'snap').catch(() => 0) : await momento(ctx, asset, a.at);
+            const medido = await r().medirAsset(ctx.tl, arquivo);
+            const ganho = ganhoDeCor(await corMedia(rs.arquivos.fundo), await corMedia(arquivo));
+            return require('./ops.js').mutar(ctx, 'replace_background', (tl) => {
+                if (!temPessoa(tl, asset.id)) camadaDaPessoa(tl, asset, rs);
+                const F = quadro({ tl }, asset, seg) ?? 0;
+                const fim = a.until !== undefined ? Math.round(Number(a.until)) : T.duracao(tl);
+                if (!(fim > F)) throw T.erro(`o fundo começaria em ${F} e terminaria em ${fim}`);
+                medido.id = T.novoAssetId(tl);
+                tl.assets[medido.id] = medido;
+                const ti = C.faixa(tl, 'fundo');
+                // Trocar de novo no mesmo trecho substitui (não empilha), sem ripple.
+                tl.tracks[ti].clips = tl.tracks[ti].clips.flatMap((c) => {
+                    if (T.fim(c) <= F || c.startFrame >= fim) return [c];
+                    if (c.startFrame < F) { c.durationFrames = F - c.startFrame; return [c]; }
+                    if (T.fim(c) > fim) { const corte = fim - c.startFrame; c.trimStartFrame += c.type === 'image' ? 0 : corte; c.startFrame = fim; c.durationFrames -= corte; return [c]; }
+                    return [];
+                });
+                const tiAgora = ti;
+                const durMax = medido.kind === 'video' ? Math.floor(medido.seconds * tl.fps) : Infinity;
+                const c = T.clipe(tl, { type: medido.kind === 'video' ? 'video' : 'image', asset: medido.id, startFrame: F, durationFrames: Math.min(fim - F, durMax), volume: 0 });
+                // Um desfoque leve, de lente: fundo nítido demais atrás de quem fala é o que denuncia a montagem.
+                if (a.blur !== 0) c.effects.push({ type: 'blur.gaussian', params: { sigma: a.blur ?? 2.5 } });
+                c.papel = 'fundo';
+                c.base = asset.id;
+                tl.tracks[tiAgora].clips.push(c);
+                // A pessoa ganha a cor do fundo novo só dali em diante.
+                const pessoas = () => T.todosOsClipes(tl).filter((x) => x.clip.papel === 'pessoa' && x.clip.base === asset.id).map((x) => x.clip);
+                for (const p of pessoas()) if (F > p.startFrame && F < T.fim(p)) E.dividir(tl, p.id, F);
+                if (fim < T.duracao(tl)) for (const p of pessoas()) if (fim > p.startFrame && fim < T.fim(p)) E.dividir(tl, p.id, fim);
+                if (ganho) for (const p of pessoas()) {
+                    if (p.startFrame >= F && T.fim(p) <= fim) p.effects = p.effects.filter((e) => e.type !== 'color.match').concat({ type: 'color.match', params: ganho });
+                }
+                T.ordenar(tl);
+                C.arrumar(tl);
+                return { background: { asset: medido.id, at: F, until: fim, arquivo: path.basename(arquivo), ...(creditos ? { creditos } : {}), ...(ganho ? { corDaPessoa: ganho } : {}) } };
+            });
+        },
+    },
+    attach_3d: {
+        uso: 'attach_3d {object:"chatgpt"|"claude"|"brain"|texto,hand?:"auto"|"left"|"right"|"other"(lado da TELA),from?,to?(quadros),color?,asset?} — objeto 3D flutuando na palma, seguindo a mão; sem from: quando o nome é dito, senão quando a mão aparece',
+        async run(ctx, a) {
+            const asset = C.base(ctx.tl, a.asset);
+            const rs = await rastro(ctx, asset);
+            const fps = rs.rastro.fps;
+            const tr = R.trilhasDasMaos(rs.rastro);
+            const fx = (ctx.tl.fx && ctx.tl.fx[asset.id]) || { objetos: [] };   // só leitura: mudar fora do mutar escaparia do undo
+            const nome = String(a.object || a.objeto || '').trim();
+            if (!nome) throw T.erro('faltou "object" (chatgpt, claude, brain ou um texto curto)');
+            const modelo = C.modeloDe(nome) || 'texto';
+            const anterior = fx.objetos[fx.objetos.length - 1];
+            let de;
+            if (a.from !== undefined) de = await momento(ctx, asset, a.from);
+            else {
+                const dito = C.acharPalavra(await palavras(ctx, asset), modelo === 'texto' ? nome : ({ chatgpt: 'chatgpt', claude: 'claude', cerebro: 'cerebro' })[modelo] || nome, { desde: anterior ? anterior.de : 0 });
+                de = dito ? dito.de : null;
+            }
+            let mao = String(a.hand || 'auto').toLowerCase();
+            if (/^(other|outra)$/.test(mao)) mao = anterior ? (anterior.mao === 'left' ? 'right' : 'left') : 'auto';
+            if (/^(esquerda|left)$/.test(mao)) mao = 'left';
+            if (/^(direita|right)$/.test(mao)) mao = 'right';
+            if (mao === 'auto') {
+                const ocupadas = new Set(fx.objetos.filter((o) => de === null || (o.de <= de && o.ate > de)).map((o) => o.mao));
+                const opcoes = ['left', 'right'].filter((m) => !ocupadas.has(m));
+                const desde = de === null ? (anterior ? anterior.de : 0) : de;
+                const cand = (opcoes.length ? opcoes : ['left', 'right']).map((m) => ({ m, t: trechoDaMao(tr[m], fps, desde) })).filter((x) => x.t);
+                cand.sort((x, y) => Math.max(x.t[0], desde) - Math.max(y.t[0], desde));
+                if (!cand.length) throw T.erro('não vi nenhuma mão livre na tela depois desse ponto (rode track para ver os trechos)');
+                mao = cand[0].m;
+            }
+            if (!['left', 'right'].includes(mao)) throw T.erro(`hand "${a.hand}" (use auto, left, right ou other)`);
+            const t = trechoDaMao(tr[mao], fps, de === null ? (anterior ? anterior.de : 0) : de);
+            if (!t) throw T.erro(`a mão ${mao} não aparece depois desse ponto`);
+            if (de === null) de = t[0];
+            const ate = a.to !== undefined ? await momento(ctx, asset, a.to) : Math.min(asset.seconds, Math.max(t[1] + 0.3, de + 1.5));
+            if (!(ate > de)) throw T.erro('"to" antes de "from"');
+            return require('./ops.js').mutar(ctx, 'attach_3d', (tl) => {
+                const f = fxDe(tl, asset.id);
+                const o = { id: `o${f.objetos.length + 1}`, modelo, mao, de: r2(de * 1000) / 1000, ate: r2(ate * 1000) / 1000 };
+                if (a.color) o.cor = C.cor(a.color);
+                if (modelo === 'texto') o.texto = nome.slice(0, 14);
+                f.objetos.push(o);
+                const g = regerarObjetos({ tl, p: ctx.p }, asset, rs);
+                C.arrumar(tl);
+                return { object: { id: o.id, modelo, hand: mao, from: quadro({ tl }, asset, o.de), to: quadro({ tl }, asset, o.ate) }, layer: g && g.asset, render: 'no export (Remotion)' };
+            });
+        },
+    },
+    merge_on_join: {
+        uso: 'merge_on_join {junta?,abre?(quadros; sem eles, os do rastro),then?:"brain"|"none",until?(quadro|"palavra:x"; padrão: 3 s depois de abrir),asset?} — ao juntar as mãos os objetos voam e se fundem num clarão; ao abrir nasce o cérebro',
+        async run(ctx, a) {
+            const asset = C.base(ctx.tl, a.asset);
+            const rs = await rastro(ctx, asset);
+            const fps = rs.rastro.fps;
+            const fx = (ctx.tl.fx && ctx.tl.fx[asset.id]) || { objetos: [] };   // só leitura: mudar fora do mutar escaparia do undo
+            if (!fx.objetos.length) throw T.erro('não há objeto na mão para fundir: rode attach_3d antes');
+            let junta = a.junta !== undefined ? await momento(ctx, asset, a.junta) : null;
+            let abre = a.abre !== undefined ? await momento(ctx, asset, a.abre) : null;
+            if (junta === null) {
+                const desde = Math.max(...fx.objetos.map((o) => o.de));
+                const ev = R.juntaEAbre(R.trilhasDasMaos(rs.rastro), { rastro: rs.rastro, desde: Math.round(desde * fps) });
+                if (!ev.length) throw T.erro('não vi as mãos se juntarem depois dos objetos; diga os quadros: {"junta":<quadro>,"abre":<quadro>}');
+                junta = ev[0].junta / fps;
+                if (abre === null && ev[0].abre !== null) abre = ev[0].abre / fps;
+            }
+            const ateFusao = a.until !== undefined ? await momento(ctx, asset, a.until) : null;
+            const depois = a.then === 'none' || a.then === false ? null : C.modeloDe(a.then || 'brain') || 'cerebro';
+            return require('./ops.js').mutar(ctx, 'merge_on_join', (tl) => {
+                const f = fxDe(tl, asset.id);
+                // Os objetos vivos na junção ficam até ela (e se fundem).
+                for (const o of f.objetos) if (o.de < junta && o.ate < junta + 0.5) o.ate = r2((junta + 0.6) * 1000) / 1000;
+                // O cérebro é o fecho do gesto, não o resto do vídeo: 3 s, ou até o `until`.
+                const nasce = abre === null ? junta + 0.7 : abre;
+                const depoisAte = Math.min(asset.seconds, ateFusao !== null ? ateFusao : nasce + 3);
+                f.fusao = { junta: r2(junta * 1000) / 1000, abre: abre === null ? null : r2(abre * 1000) / 1000, depois, depoisAte: r2(depoisAte * 1000) / 1000 };
+                const g = regerarObjetos({ tl, p: ctx.p }, asset, rs);
+                C.arrumar(tl);
+                return { merge: { junta: quadro({ tl }, asset, junta), abre: abre === null ? null : quadro({ tl }, asset, abre), then: depois }, layer: g && g.asset };
+            });
+        },
+    },
+    cut_silence_at: {
+        uso: 'cut_silence_at {event?:"snap"|quadro|"palavra:x",asset?,threshold?:-35,minSilence?:0.4,padding?:0.1,window?:1(s)} — ripple no silêncio que vem logo depois do momento',
+        async run(ctx, a) {
+            const asset = C.base(ctx.tl, a.asset);
+            const seg = await momento(ctx, asset, a.event === undefined ? 'snap' : a.event);
+            const sil = await r().silenciosDe(ctx.p.dir, asset, { threshold: a.threshold ?? -35, minSilence: a.minSilence ?? 0.4 });
+            const janela = a.window ?? 1;
+            const pad = a.padding ?? 0.1;
+            const s = sil.find((x) => x.ate > seg + 0.2 && x.de >= seg - 0.6 && x.de <= seg + janela);
+            if (!s) return { ok: false, error: `não há silêncio logo depois de ${r2(seg)} s (silêncios: ${sil.slice(0, 6).map((x) => `${r2(x.de)}-${r2(x.ate)}`).join(', ')})` };
+            const de = Math.max(seg + 0.12, s.de + pad);
+            const ate = s.ate >= asset.seconds - 0.05 ? s.ate : s.ate - pad;
+            if (!(ate > de)) return { ok: false, error: 'o silêncio depois do momento é curto demais para cortar' };
+            const ranges = [];
+            for (const c of C.clipesBase(ctx.tl, asset.id)) {
+                const j = T.janelaOrigem(ctx.tl, c);
+                const i0 = Math.max(j.de, de);
+                const i1 = Math.min(j.ate, ate);
+                if (i1 > i0) ranges.push([T.origemParaQuadro(ctx.tl, c, i0), T.origemParaQuadro(ctx.tl, c, i1)]);
+            }
+            if (!ranges.length) return { ok: false, error: 'esse silêncio já foi cortado' };
+            return require('./ops.js').mutar(ctx, 'cut_silence_at', (tl) => ({ silence: { de: r2(de), ate: r2(ate) }, ...E.apagarTrechos(tl, ranges) }));
+        },
+    },
+    style_captions: {
+        uso: 'style_captions {ids?:"all"|[..],at?(quadro: a legenda ali),color?,textColor?,size?,position?:"above_head"|"bottom"|"top"|"center",follow?} — color = o que está colorido (o destaque; sem destaque, o texto)',
+        async run(ctx, a) {
+            const tl = ctx.tl;
+            const leg = T.todosOsClipes(tl).filter((x) => x.clip.type === 'text').map((x) => x.clip);
+            let alvo;
+            if (a.at !== undefined) alvo = leg.filter((c) => a.at >= c.startFrame && a.at < T.fim(c));
+            else if (a.ids === undefined || a.ids === 'all' || a.ids === 'current') alvo = leg.filter((c) => c.caption).length ? leg.filter((c) => c.caption) : leg;
+            else alvo = lista(a.ids).map((id) => T.achar(tl, id).clip);
+            if (!alvo.length) throw T.erro('não há legenda para mudar: rode add_captions antes');
+            const pos = a.position ? String(a.position).toLowerCase() : null;
+            const seguir = pos === 'above_head' || pos === 'acima_da_cabeca' || a.follow === true;
+            let asset = null;
+            if (seguir) {
+                asset = C.base(tl, a.asset);
+                await rastro(ctx, asset);
+            }
+            const CY = { bottom: 0.78, baixo: 0.78, top: 0.14, topo: 0.14, center: 0.5, centro: 0.5, middle: 0.5 };
+            if (pos && !seguir && CY[pos] === undefined) throw T.erro(`position "${a.position}" (use above_head, bottom, top ou center)`);
+            const corPedida = a.color !== undefined ? C.cor(a.color) : undefined;
+            return require('./ops.js').mutar(ctx, 'style_captions', (t) => {
+                for (const ref of alvo) {
+                    const c = T.achar(t, ref.id).clip;
+                    const st = { ...(c.text.style || {}) };
+                    if (corPedida) { if (c.text.animation === 'highlightPop') st.highlight = corPedida; else st.color = corPedida; }
+                    if (a.textColor !== undefined) st.color = C.cor(a.textColor);
+                    if (a.size !== undefined) st.size = Number(a.size);
+                    c.text.style = st;
+                    if (seguir) c.text.follow = { asset: asset.id, alvo: 'cabeca' };
+                    else if (pos) { delete c.text.follow; c.transform.cy = CY[pos]; }
+                }
+                return { captions: alvo.length, ...(corPedida ? { color: corPedida } : {}), ...(seguir ? { follow: 'cabeça' } : pos ? { cy: CY[pos] } : {}) };
+            });
+        },
+    },
+};
+
+const EX = {
+    track: '{}',
+    separate_layers: '{"show3d":true}',
+    replace_background: '{"with":"praia","at":"snap"}',
+    attach_3d: '{"object":"chatgpt","hand":"auto"}',
+    merge_on_join: '{"then":"brain"}',
+    cut_silence_at: '{"event":"snap"}',
+    style_captions: '{"color":"azul","position":"above_head"}',
+};
+
+module.exports = { OPS, EX, momento, estalosDe, ganhoDeCor, trechoDaMao, regerarObjetos, palavras };