primocode 9.10.0 → 10.0.0

package/lib/video/projeto.js

@@ -0,0 +1,133 @@
+/**
+ * projeto.js — onde a edição mora: `<pasta atual>/video/<id>/`.
+ *
+ *   timeline.json   o projeto (lib/video/timeline.js)
+ *   history/        uma foto da timeline ANTES de cada edição (o undo)
+ *   log.jsonl       o caderno: que operação, quando, com que resultado
+ *   midia/          transcrição e silêncio medidos (cache por mídia)
+ *   cache/          os pngs do texto e os quadros do inspect
+ *   saida/          o mp4 exportado e a folha do inspect
+ *
+ * A pasta fica NA PASTA DO TRABALHO, e não em ~/.primocode como os projetos
+ * do Estúdio: a gravação é da pessoa, está ali, e o vídeo editado tem que
+ * aparecer ao lado dela. O id segue a convenção do Estúdio (data na frente,
+ * apelido depois), para "o de semana passada" ser achado pela ordem.
+ *
+ * ── POR QUE O UNDO É FOTO E NÃO OPERAÇÃO INVERSA ─────────────────────────
+ * Desfazer um ripple de quarenta clipes com a conta inversa é reescrever o
+ * ripple ao contrário, com os mesmos defeitos. A foto do json custa alguns
+ * kB e desfaz qualquer coisa, inclusive o que for criado amanhã. É o que
+ * deixa o agente editar sem pedir licença a cada passo.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const T = require('./timeline.js');
+const { apelidar } = require('../estudio/projeto.js');
+
+const MAX_HISTORICO = 100;
+
+function raiz(cwd = process.cwd()) {
+    return process.env.PRIMOCODE_VIDEO_DIR || path.join(cwd, 'video');
+}
+
+function escreverAtomico(arq, texto) {
+    const tmp = `${arq}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, texto);
+    fs.renameSync(tmp, arq);
+}
+
+function criar({ nome = 'video', width, height, fps, cwd } = {}) {
+    const base = raiz(cwd);
+    const dia = new Date().toISOString().slice(0, 10);
+    const semente = `${dia}-${apelidar(nome)}`;
+    let id = semente;
+    for (let n = 2; fs.existsSync(path.join(base, id)); n++) id = `${semente}-${n}`;
+    const dir = path.join(base, id);
+    for (const sub of ['history', 'midia', 'cache', 'saida']) fs.mkdirSync(path.join(dir, sub), { recursive: true });
+    const tl = T.novo({ nome: apelidar(nome), width, height, fps });
+    const p = { id, dir };
+    salvar(p, tl);
+    fs.writeFileSync(path.join(base, '.atual'), id);
+    return { p, tl };
+}
+
+function atual(cwd) {
+    try { return fs.readFileSync(path.join(raiz(cwd), '.atual'), 'utf8').trim() || null; } catch { return null; }
+}
+
+function abrir(id, cwd) {
+    const base = raiz(cwd);
+    const alvo = id || atual(cwd);
+    if (!alvo) return null;
+    let dir = path.join(base, alvo);
+    if (!fs.existsSync(path.join(dir, 'timeline.json'))) {
+        // Aceita o começo do id ("2026-09-29-aula") como no clipe.
+        const casa = listar(cwd).filter((x) => x.id.startsWith(alvo) || x.id.endsWith(alvo));
+        if (casa.length !== 1) return null;
+        dir = path.join(base, casa[0].id);
+    }
+    const tl = JSON.parse(fs.readFileSync(path.join(dir, 'timeline.json'), 'utf8'));
+    return { p: { id: path.basename(dir), dir }, tl };
+}
+
+function usar(id, cwd) { fs.writeFileSync(path.join(raiz(cwd), '.atual'), id); }
+
+function listar(cwd) {
+    const base = raiz(cwd);
+    if (!fs.existsSync(base)) return [];
+    return fs.readdirSync(base).filter((n) => fs.existsSync(path.join(base, n, 'timeline.json'))).sort().map((id) => {
+        let tl = null;
+        try { tl = JSON.parse(fs.readFileSync(path.join(base, id, 'timeline.json'), 'utf8')); } catch {}
+        return { id, s: tl ? T.r2(T.duracao(tl) / tl.fps) : null, clips: tl ? T.todosOsClipes(tl).length : null };
+    });
+}
+
+function salvar(p, tl) {
+    escreverAtomico(path.join(p.dir, 'timeline.json'), JSON.stringify(tl));
+}
+
+function historico(p) {
+    const dir = path.join(p.dir, 'history');
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir).filter((n) => /^\d+\.json$/.test(n)).sort();
+}
+
+/** Guarda a foto de ANTES da edição. */
+function fotografar(p, antes, op) {
+    const lista = historico(p);
+    const n = lista.length ? Number(lista[lista.length - 1].slice(0, -5)) + 1 : 1;
+    fs.mkdirSync(path.join(p.dir, 'history'), { recursive: true });
+    fs.writeFileSync(path.join(p.dir, 'history', `${String(n).padStart(6, '0')}.json`), JSON.stringify({ op, tl: antes }));
+    for (const velho of lista.slice(0, Math.max(0, lista.length + 1 - MAX_HISTORICO))) {
+        try { fs.unlinkSync(path.join(p.dir, 'history', velho)); } catch {}
+    }
+}
+
+/** Volta `passos` edições. Devolve {tl, desfeitas:[ops]} ou erro. */
+function desfazer(p, passos = 1) {
+    const lista = historico(p);
+    if (!lista.length) throw T.erro('não há nada para desfazer');
+    // "abc" daria NaN, e slice(-NaN) é o histórico INTEIRO.
+    const n = Math.max(1, Math.min(lista.length, Math.round(Number(passos)) || 1));
+    const alvo = lista.slice(-n);
+    const desfeitas = [];
+    let tl = null;
+    for (const arq of [...alvo].reverse()) {
+        const foto = JSON.parse(fs.readFileSync(path.join(p.dir, 'history', arq), 'utf8'));
+        desfeitas.push(foto.op);
+        tl = foto.tl;
+        fs.unlinkSync(path.join(p.dir, 'history', arq));
+    }
+    return { tl, desfeitas, restam: lista.length - n };
+}
+
+function anotar(p, op, resumo) {
+    try {
+        fs.appendFileSync(path.join(p.dir, 'log.jsonl'), JSON.stringify({ q: new Date().toISOString(), op, ...resumo }) + '\n');
+    } catch { /* o caderno não pode derrubar a edição */ }
+}
+
+module.exports = { raiz, criar, abrir, atual, usar, listar, salvar, fotografar, desfazer, historico, anotar, MAX_HISTORICO };

package/lib/video/render.js

@@ -0,0 +1,221 @@
+/**
+ * render.js — onde o editor encosta no mundo: ffmpeg, Pillow e disco.
+ *
+ * Tudo que decide mora nos módulos puros (filters, texto, analise). Aqui só
+ * se mede, desenha e roda. O ffmpeg é achado pelo mesmo lib/estudio/video.js
+ * do Estúdio — um lugar só sabe onde o ffmpeg está e como instalar.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, execFileSync } = require('child_process');
+const T = require('./timeline.js');
+const F = require('./filters.js');
+const TX = require('./texto.js');
+const video = require('../estudio/video.js');
+const { rodarPython } = require('./transcript.js');
+
+const TEXTO_PY = path.join(__dirname, '..', '..', 'studio', 'texto.py');
+const IMAGEM = /\.(png|jpe?g|webp|bmp|gif|tiff?)$/i;
+
+// ── o que o ffmpeg desta máquina sabe ────────────────────────────────────
+
+let _versao = null;
+function versaoMaior() {
+    if (_versao !== null) return _versao;
+    try {
+        const v = execFileSync(video.ffmpeg(), ['-version'], { stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 }).toString();
+        const m = v.match(/ffmpeg version n?(\d+)\./);
+        _versao = m ? Number(m[1]) : 99;   // build do git ("N-12345") é recente
+    } catch { _versao = 99; }
+    return _versao;
+}
+
+let _codec = null;
+function codecDeVideo() {
+    if (_codec) return _codec;
+    let lista = '';
+    try { lista = execFileSync(video.ffmpeg(), ['-hide_banner', '-encoders'], { stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 }).toString(); } catch {}
+    for (const c of ['libx264', 'libopenh264', 'h264_videotoolbox', 'h264_mf', 'mpeg4']) {
+        if (new RegExp(`\\s${c}\\s`).test(lista)) { _codec = c; return c; }
+    }
+    return (_codec = 'mpeg4');
+}
+
+function argsDoCodec(codec, crf) {
+    if (codec === 'libx264') return ['-c:v', 'libx264', '-preset', 'veryfast', '-crf', String(crf)];
+    if (codec === 'h264_videotoolbox') return ['-c:v', codec, '-b:v', '8M'];
+    return ['-c:v', codec, '-b:v', '8M'];
+}
+
+function conferir() { return video.conferir(); }
+
+// ── importar ─────────────────────────────────────────────────────────────
+
+async function medirAsset(tl, arquivo) {
+    const abs = path.resolve(arquivo);
+    if (!fs.existsSync(abs)) throw T.erro(`arquivo não existe: ${abs}`);
+    const m = await video.medir(abs);
+    if (!m.ok) throw T.erro(m.error);
+    const imagem = IMAGEM.test(abs);
+    const kind = imagem ? 'image' : m.largura ? 'video' : 'audio';
+    return {
+        id: T.novoAssetId(tl), path: abs, nome: path.basename(abs), kind,
+        seconds: imagem ? 0 : T.r2(m.segundos), width: m.largura || 0, height: m.altura || 0,
+        fps: m.fps || 0, hasAudio: !!m.temAudio,
+    };
+}
+
+// ── o texto em png ───────────────────────────────────────────────────────
+
+let _pillow = null;
+function python() { return require('../voz.js').python(); }
+
+async function temPillow() {
+    if (_pillow !== null) return _pillow;
+    const py = python();
+    _pillow = py ? !!(await rodarPython(py, [TEXTO_PY, 'conferir'], { cwd: path.dirname(TEXTO_PY), timeout: 30000 })).ok : false;
+    return _pillow;
+}
+
+/** As camadas de texto da janela: {índiceDaFaixa: arquivo .ffconcat}. */
+async function camadasDeTexto(pasta, tl, { from, to, escala }) {
+    const faixas = tl.tracks.map((t, i) => ({ t, i })).filter(({ t }) => t.type === 'text' && t.clips.length && !t.hidden);
+    if (!faixas.length) return { camadas: {}, avisos: [] };
+    if (!(await temPillow())) {
+        return { camadas: {}, avisos: ['os textos NÃO foram desenhados: falta o Pillow (python3 -m pip install pillow)'] };
+    }
+    const W = T.par(tl.width * escala);
+    const H = T.par(tl.height * escala);
+    const dir = path.join(pasta, 'cache', 'texto', `${W}x${H}`);
+    fs.mkdirSync(dir, { recursive: true });
+    const vazio = path.join(dir, 'vazio.png');
+    const arquivoDe = (chave) => (chave === 'vazio' ? vazio : path.join(dir, `${chave}.png`));
+    const estados = [];
+    const camadas = {};
+    for (const { t, i } of faixas) {
+        const { segmentos, desenhos } = TX.estadosDaFaixa(tl, t, { from, to, escala });
+        if (!Object.keys(desenhos).length) continue;
+        for (const [chave, items] of Object.entries(desenhos)) {
+            if (!fs.existsSync(arquivoDe(chave)) && !estados.some((e) => e.chave === chave)) estados.push({ chave, file: arquivoDe(chave), items });
+        }
+        const arq = path.join(dir, `faixa${i}-${from}-${to}.ffconcat`);
+        fs.writeFileSync(arq, TX.ffconcat(segmentos, tl.fps, arquivoDe));
+        camadas[i] = arq;
+    }
+    if (estados.length || !fs.existsSync(vazio)) {
+        const job = path.join(dir, `job-${process.pid}.json`);
+        fs.writeFileSync(job, JSON.stringify({ width: W, height: H, estados: estados.map(({ file, items }) => ({ file, items })), vazio }));
+        const r = await rodarPython(python(), [TEXTO_PY, 'estados', job], { cwd: path.dirname(TEXTO_PY) });
+        try { fs.unlinkSync(job); } catch {}
+        if (!r.ok) return { camadas: {}, avisos: [`os textos não foram desenhados: ${r.error}`] };
+    }
+    return { camadas, avisos: [], estados: estados.length };
+}
+
+// ── rodar o ffmpeg ───────────────────────────────────────────────────────
+
+async function rodarGrafo(pasta, g, saida) {
+    const arq = path.join(pasta, 'cache', `grafo-${process.pid}.txt`);
+    fs.mkdirSync(path.dirname(arq), { recursive: true });
+    fs.writeFileSync(arq, g.grafo);
+    // O grafo vai por arquivo: com cinquenta clipes ele passa do teto de
+    // linha de comando do Windows (32 mil caracteres).
+    const flag = versaoMaior() >= 7 ? ['-/filter_complex', arq] : ['-filter_complex_script', arq];
+    const args = ['-hide_banner', '-loglevel', 'error', '-y', ...g.inputs.flat(), ...flag, ...saida];
+    const r = await video.rodar(video.ffmpeg(), args, { timeout: 60 * 60000 });
+    if (r.ok) { try { fs.unlinkSync(arq); } catch {} }
+    return { ...r, grafo: arq };
+}
+
+async function exportar(pasta, tl, { out, from = 0, to, preview = false, crf = 20 } = {}) {
+    const c = conferir();
+    if (!c.ok) return c;
+    const escala = preview ? 0.5 : 1;
+    const ate = to === undefined ? T.duracao(tl) : Number(to);
+    const tx = await camadasDeTexto(pasta, tl, { from, to: ate, escala });
+    const g = F.montarGrafo(tl, { from, to: ate, camadasDeTexto: tx.camadas, escala });
+    const destino = path.resolve(out || path.join(pasta, 'saida', `${tl.nome || 'video'}${preview ? '-preview' : ''}.mp4`));
+    fs.mkdirSync(path.dirname(destino), { recursive: true });
+    const inicio = Date.now();
+    const r = await rodarGrafo(pasta, g, [
+        '-map', g.saidaV, '-map', g.saidaA, '-t', F.num(g.segundos), '-r', String(tl.fps),
+        ...argsDoCodec(codecDeVideo(), crf), '-pix_fmt', 'yuv420p', '-c:a', 'aac', '-b:a', '192k', '-movflags', '+faststart', destino,
+    ]);
+    if (!r.ok) return { ok: false, error: 'o ffmpeg falhou', detalhe: r.erro.slice(-600), grafo: r.grafo };
+    return { ok: true, file: destino, s: T.r2(g.segundos), size: `${g.W}x${g.H}`, mb: T.r2(fs.statSync(destino).size / 1048576),
+        tookS: Math.round((Date.now() - inicio) / 100) / 10, ...(tx.avisos.length ? { avisos: tx.avisos } : {}) };
+}
+
+/** Os quadros pedidos, com a grade 0–1 e o número do quadro, numa folha só. */
+async function inspecionar(pasta, tl, { frames, escala = 0.5, out } = {}) {
+    const c = conferir();
+    if (!c.ok) return c;
+    const dur = T.duracao(tl);
+    const lista = [...new Set(frames.map((f) => Math.max(0, Math.min(dur - 1, Math.round(Number(f))))))].slice(0, 12);
+    const dir = path.join(pasta, 'cache', 'inspect');
+    fs.mkdirSync(dir, { recursive: true });
+    const pngs = [];
+    const avisos = new Set();
+    for (const f of lista) {
+        const tx = await camadasDeTexto(pasta, tl, { from: f, to: f + 1, escala });
+        tx.avisos.forEach((a) => avisos.add(a));
+        const g = F.montarGrafo(tl, { from: f, to: f + 1, camadasDeTexto: tx.camadas, escala, audio: false });
+        const png = path.join(dir, `f${f}.png`);
+        const r = await rodarGrafo(pasta, g, ['-map', g.saidaV, '-frames:v', '1', '-update', '1', png]);
+        if (!r.ok) return { ok: false, error: `o quadro ${f} falhou`, detalhe: r.erro.slice(-500), grafo: r.grafo };
+        pngs.push({ png, frame: f, tempo: f / tl.fps });
+    }
+    const destino = path.resolve(out || path.join(pasta, 'saida', 'inspect.png'));
+    fs.mkdirSync(path.dirname(destino), { recursive: true });
+    if (await temPillow()) {
+        const job = path.join(dir, 'grade.json');
+        fs.writeFileSync(job, JSON.stringify({ frames: pngs, out: destino, altura: lista.length > 1 ? 640 : 960 }));
+        const r = await rodarPython(python(), [TEXTO_PY, 'grade', job], { cwd: path.dirname(TEXTO_PY) });
+        if (r.ok) return { ok: true, png: destino, frames: lista, ...(avisos.size ? { avisos: [...avisos] } : {}) };
+        avisos.add(`sem grade: ${r.error}`);
+    }
+    return { ok: true, pngs: pngs.map((p) => p.png), frames: lista, avisos: [...avisos, 'sem Pillow: quadros sem grade'] };
+}
+
+// ── medir áudio ──────────────────────────────────────────────────────────
+
+async function silenciosDe(pasta, asset, { threshold = -35, minSilence = 0.5 } = {}) {
+    const cache = path.join(pasta, 'midia', `silencio-${asset.id}-${threshold}-${minSilence}.json`);
+    if (fs.existsSync(cache)) { try { return JSON.parse(fs.readFileSync(cache, 'utf8')); } catch {} }
+    const r = await video.rodar(video.ffmpeg(), ['-hide_banner', '-i', asset.path, '-vn',
+        '-af', `silencedetect=noise=${threshold}dB:d=${minSilence}`, '-f', 'null', '-']);
+    if (!r.ok) throw T.erro(`o silencedetect falhou: ${r.erro.slice(-200)}`);
+    const lista = [];
+    let inicio = null;
+    for (const linha of r.erro.split('\n')) {
+        const i = linha.match(/silence_start:\s*(-?[\d.]+)/);
+        if (i) { inicio = Math.max(0, Number(i[1])); continue; }
+        const f = linha.match(/silence_end:\s*([\d.]+)/);
+        if (f && inicio !== null) { lista.push({ de: inicio, ate: Number(f[1]) }); inicio = null; }
+    }
+    // Silêncio que vai até o fim do arquivo não tem "silence_end": fecha no fim.
+    if (inicio !== null && inicio < asset.seconds) lista.push({ de: inicio, ate: asset.seconds });
+    fs.mkdirSync(path.dirname(cache), { recursive: true });
+    fs.writeFileSync(cache, JSON.stringify(lista));
+    return lista;
+}
+
+/** As amostras cruas (mono, Float32) — para achar batida. */
+function amostras(arquivo, taxa = 22050) {
+    return new Promise((resolve, reject) => {
+        const p = spawn(video.ffmpeg(), ['-hide_banner', '-loglevel', 'error', '-i', arquivo, '-vn', '-ac', '1', '-ar', String(taxa), '-f', 'f32le', '-']);
+        const partes = [];
+        p.stdout.on('data', (d) => partes.push(d));
+        p.on('error', reject);
+        p.on('close', (code) => {
+            if (code !== 0) return reject(T.erro('não consegui ler o áudio'));
+            const b = Buffer.concat(partes);
+            resolve(new Float32Array(b.buffer, b.byteOffset, Math.floor(b.length / 4)));
+        });
+    });
+}
+
+module.exports = { conferir, medirAsset, temPillow, camadasDeTexto, exportar, inspecionar, silenciosDe, amostras, codecDeVideo, versaoMaior };

package/lib/video/texto.js

@@ -0,0 +1,142 @@
+/**
+ * texto.js — o que cada faixa de texto mostra em cada quadro.
+ *
+ * O ffmpeg que vem no Homebrew não tem mais drawtext nem libass (conferido
+ * em 29/09/2026, ffmpeg 9.0.1): contar com eles é contar com um vídeo sem
+ * legenda na máquina de metade das pessoas. Então o texto é desenhado FORA
+ * do ffmpeg — em PNG transparente, pelo studio/texto.py (Pillow) — e entra
+ * como uma camada por faixa.
+ *
+ * A animação (popIn, typewriter, wordReveal, highlightPop) é decidida AQUI,
+ * quadro a quadro, como dado: "neste quadro a palavra 3 está amarela e 18%
+ * maior". Quadros com o mesmo estado viram UM png com duração; uma legenda de
+ * três palavras com destaque vira uns quinze pngs, não noventa. O Python só
+ * desenha o que recebe — e por isso a animação é testável sem Pillow.
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const T = require('./timeline.js');
+
+const ESTILO_PADRAO = {
+    font: 'bold', size: 0.048, color: '#FFFFFF', stroke: '#000000', strokeWidth: 0.14,
+    highlight: '#FFD400', bg: null, upper: false, align: 'center',
+};
+
+const r3 = (n) => Math.round(n * 1000) / 1000;
+
+/** As palavras com tempo (quadros relativos ao clipe). Sem tempo: divide igual. */
+function palavrasDo(c) {
+    const ws = (c.text.words || []).filter((w) => w && w.t);
+    if (ws.length) return ws;
+    const partes = String(c.text.content || '').split(/\s+/).filter(Boolean);
+    const passo = c.durationFrames / Math.max(1, partes.length);
+    return partes.map((t, i) => ({ t, f: Math.round(i * passo), e: Math.round((i + 1) * passo) }));
+}
+
+/** O estado de UM clipe de texto no quadro local `lf` — ou null (não aparece). */
+function estado(tl, c, lf) {
+    const st = { ...ESTILO_PADRAO, ...(c.text.style || {}) };
+    const d = c.durationFrames;
+    const anim = c.text.animation || 'none';
+    const up = (s) => (st.upper ? String(s).toUpperCase() : String(s));
+    let scale = 1;
+    let alpha = c.opacity;
+    let words = palavrasDo(c).map((w) => ({ t: up(w.t) }));
+    const tempos = palavrasDo(c);
+
+    const entrada = (quadros) => Math.min(1, (lf + 1) / quadros);
+    if (anim === 'fade') alpha *= Math.min(entrada(6), (d - lf) / 6);
+    if (anim === 'popIn' || anim === 'highlightPop') {
+        if (lf < 3) scale = 0.6 + 0.55 * ((lf + 1) / 3);
+        else if (lf < 6) scale = 1.15 - 0.05 * (lf - 2);
+        alpha *= entrada(2);
+    }
+    if (anim === 'typewriter') {
+        const total = words.reduce((s, w) => s + w.t.length, 0);
+        const porLetra = Math.max(0.5, Math.min(2, (0.7 * d) / Math.max(1, total)));
+        let sobra = Math.floor((lf + 1) / porLetra);
+        words = words.map((w) => {
+            const mostra = Math.max(0, Math.min(w.t.length, sobra));
+            sobra -= w.t.length;
+            return mostra === w.t.length ? w : { ...w, show: w.t.slice(0, mostra) };
+        });
+    }
+    if (anim === 'wordReveal') {
+        words = words.map((w, i) => {
+            const k = lf - tempos[i].f;
+            if (k < 0) return { ...w, a: 0 };
+            return k < 3 ? { ...w, s: r3(1.25 - 0.08 * k) } : w;
+        });
+    }
+    if (anim === 'highlightPop') {
+        let ativa = -1;
+        tempos.forEach((w, i) => { if (lf >= w.f) ativa = i; });
+        if (ativa >= 0 && lf < tempos[ativa].e + 6) {
+            const k = lf - tempos[ativa].f;
+            words[ativa] = { ...words[ativa], c: st.highlight, s: r3(k <= 2 ? 1 + 0.1 * (k + 1) : 1.22) };
+        }
+    }
+    if (c.fadeIn && lf < c.fadeIn) alpha *= (lf + 1) / c.fadeIn;
+    if (c.fadeOut && lf >= d - c.fadeOut) alpha *= (d - lf) / c.fadeOut;
+    if (alpha <= 0.01) return null;
+
+    const W = tl.width;
+    const H = tl.height;
+    const item = {
+        cx: r3(c.transform.cx * W), cy: r3(c.transform.cy * H), w: Math.round(c.transform.w * W),
+        size: Math.round(st.size * H), font: st.font, color: st.color, align: st.align,
+        stroke: st.stroke, sw: Math.round(st.strokeWidth * st.size * H), bg: st.bg,
+        scale: r3(scale), alpha: Math.round(alpha * 100) / 100, words,
+    };
+    if (c.transform.rotation) item.rot = c.transform.rotation;
+    return item;
+}
+
+/**
+ * Os estados de uma faixa na janela [from, to): segmentos consecutivos com o
+ * mesmo desenho viram um só. Devolve {segmentos:[{dur, chave}], desenhos}.
+ */
+function estadosDaFaixa(tl, faixa, { from = 0, to, escala = 1 } = {}) {
+    const ate = to === undefined ? T.duracao(tl) : to;
+    const clips = faixa.clips.filter((c) => !c.hidden && T.fim(c) > from && c.startFrame < ate);
+    const escalar = (it) => (escala === 1 ? it : {
+        ...it, cx: r3(it.cx * escala), cy: r3(it.cy * escala), w: Math.round(it.w * escala),
+        size: Math.max(4, Math.round(it.size * escala)), sw: Math.round(it.sw * escala),
+    });
+    const segmentos = [];
+    const desenhos = {};
+    let k = 0;
+    for (let f = from; f < ate; f++) {
+        while (k < clips.length && T.fim(clips[k]) <= f) k++;
+        const itens = [];
+        for (let j = k; j < clips.length && clips[j].startFrame <= f; j++) {
+            const c = clips[j];
+            if (f >= T.fim(c)) continue;
+            const it = estado(tl, c, f - c.startFrame);
+            if (it) itens.push(escalar(it));
+        }
+        const json = JSON.stringify(itens);
+        const chave = itens.length ? crypto.createHash('sha1').update(json).digest('hex').slice(0, 14) : 'vazio';
+        if (itens.length) desenhos[chave] = itens;
+        const ult = segmentos[segmentos.length - 1];
+        if (ult && ult.chave === chave) ult.dur++;
+        else segmentos.push({ dur: 1, chave });
+    }
+    return { segmentos, desenhos };
+}
+
+/** O .ffconcat da faixa: cada estado com a duração dele. */
+function ffconcat(segmentos, fps, arquivoDe) {
+    const linhas = ['ffconcat version 1.0'];
+    for (const s of segmentos) {
+        linhas.push(`file '${arquivoDe(s.chave).replace(/'/g, "'\\''")}'`);
+        linhas.push(`duration ${(s.dur / fps).toFixed(6)}`);
+    }
+    // O concat ignora a duração do último arquivo sem uma linha a mais dele.
+    if (segmentos.length) linhas.push(`file '${arquivoDe(segmentos[segmentos.length - 1].chave).replace(/'/g, "'\\''")}'`);
+    return linhas.join('\n') + '\n';
+}
+
+module.exports = { ESTILO_PADRAO, palavrasDo, estado, estadosDaFaixa, ffconcat };