primocode 10.1.0 → 10.3.0-beta.0

package/lib/estudio/variedade.js

@@ -20,24 +20,84 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
-const PASTA = path.join(os.homedir(), '.primocode', 'studio');
-const MEMORIA = { trilha: 16, sfx: 40, broll: 80, icones: 4, estilo: 8, '3d': 24 };
-
-function arquivo(tipo) { return path.join(PASTA, `${tipo}-usadas.json`); }
+/* A pasta é lida a cada uso (não no require): o teste troca o HOME depois de
+   carregar o módulo e a memória de verdade fica intocada. */
+const PASTA = () => path.join(os.homedir(), '.primocode', 'studio');
+/* Os tipos do gerativo e do fluido (09/10): "vício em cores, músicas, fontes"
+   — a paleta, as fontes e o gênero saíam só da semente, sem lembrar do vídeo
+   anterior. Agora passam por aqui como o resto. */
+const MEMORIA = { trilha: 16, sfx: 40, broll: 80, icones: 4, estilo: 8, '3d': 24, 'icone-nome': 30, 'paleta-fluido': 6,
+    'fonte-fluido': 4, 'humor-gerativo': 4, 'paleta-gerativo': 10, 'fonte-gerativo': 18, 'genero-gerativo': 8,
+    'arranjo-icone': 10, 'material-icone': 4, 'heroi-gerativo': 8, 'composicao-gerativo': 12,
+    'moldura-gerativo': 4, 'ambiente-gerativo': 4, 'acento-gerativo': 3 };
+
+/* A DIVERSIDADE POR PONTOS (07/10): "o sistema não deve simplesmente proibir
+   repetição; escolhas usadas recentemente recebem penalidade, as muito usadas
+   recebem penalidade maior, as antigas podem voltar, e o que é adequado ao
+   conteúdo continua tendo prioridade" (Joel). Antes era uma janela fixa: o
+   que saía da janela voltava como se nunca tivesse sido usado.
+     pontos = PESO_ADEQUACAO × adequação − recência − frequência
+   - recência: 1 para a última usada, cai pela metade a cada MEIA_VIDA_USOS
+     escolhas do mesmo tipo (exp), e some quando sai da lista;
+   - frequência: log2(1 + usos), com os usos perdendo metade a cada
+     MEIA_VIDA_DIAS — o muito usado pesa mais, e o tempo perdoa;
+   - adequação: 0 a 1, de quem chama (o clima, o assunto). Com peso 2, o que
+     serve ao roteiro ganha do que só é novo: a variedade não quebra a coerência. */
+const PESO_ADEQUACAO = 2;
+const PESO_FREQUENCIA = 0.25;
+const MEIA_VIDA_DIAS = 21;
+const EMPATE = 0.05;   // dentro disso, é sorteio
+
+function arquivo(tipo) { return path.join(PASTA(), `${tipo}-usadas.json`); }
+function arquivoHistorico(tipo) { return path.join(PASTA(), `${tipo}-historico.json`); }
 
 function usadas(tipo) {
     try { const l = JSON.parse(fs.readFileSync(arquivo(tipo), 'utf8')); return Array.isArray(l) ? l : []; } catch { return []; }
 }
 
-function marcar(tipo, id) {
+/** { id: { n: usos, t: ms da última } } — a frequência, que a lista de recentes não guarda. */
+function historico(tipo) {
+    try { const h = JSON.parse(fs.readFileSync(arquivoHistorico(tipo), 'utf8')); return h && typeof h === 'object' && !Array.isArray(h) ? h : {}; } catch { return {}; }
+}
+
+const usosHoje = (reg, agora) => (reg ? reg.n * Math.pow(0.5, Math.max(0, agora - reg.t) / (MEIA_VIDA_DIAS * 864e5)) : 0);
+
+function marcar(tipo, id, agora = Date.now()) {
     if (!id) return;
     try {
-        fs.mkdirSync(PASTA, { recursive: true });
-        const l = [id, ...usadas(tipo).filter((x) => x !== id)].slice(0, MEMORIA[tipo] || 20);
+        fs.mkdirSync(PASTA(), { recursive: true });
+        // A lista de recentes é maior que a janela de antes: a recência decai, não corta.
+        const l = [id, ...usadas(tipo).filter((x) => x !== id)].slice(0, (MEMORIA[tipo] || 20) * 2);
         fs.writeFileSync(arquivo(tipo), JSON.stringify(l));
+        const h = historico(tipo);
+        h[id] = { n: usosHoje(h[id], agora) + 1, t: agora };
+        // Guarda os 400 mais recentes, para o arquivo não crescer sem fim.
+        const ids = Object.keys(h).sort((x, y) => h[y].t - h[x].t).slice(0, 400);
+        fs.writeFileSync(arquivoHistorico(tipo), JSON.stringify(Object.fromEntries(ids.map((k) => [k, h[k]]))));
     } catch { /* sem memória: só perde a garantia de não repetir */ }
 }
 
+/** Quanto pesa ter usado `id`: recência + frequência. 0 = nunca usado. */
+function penalidade(id, tipo, { lista = usadas(tipo), hist = historico(tipo), agora = Date.now() } = {}) {
+    const pos = lista.indexOf(id);
+    const meiaVida = Math.max(1, (MEMORIA[tipo] || 20) / 4);
+    const recencia = pos < 0 ? 0 : Math.pow(0.5, pos / meiaVida);
+    return recencia + PESO_FREQUENCIA * Math.log2(1 + usosHoje(hist[id], agora));
+}
+
+/**
+ * Os pontos de cada opção: adequação menos penalidade. `adequacao` é uma
+ * função (opção → 0..1) ou um objeto {id: 0..1}; sem ela, tudo serve igual (1).
+ */
+function pontuar(opcoes, tipo, { prefixo = '', adequacao = null, chave = (o) => o, agora = Date.now() } = {}) {
+    const lista = usadas(tipo), hist = historico(tipo);
+    const fit = (o) => {
+        const v = typeof adequacao === 'function' ? adequacao(o) : adequacao && typeof adequacao === 'object' ? adequacao[chave(o)] : 1;
+        return Number.isFinite(v) ? Math.max(0, Math.min(1, v)) : 0;
+    };
+    return opcoes.map((o) => ({ opcao: o, pontos: PESO_ADEQUACAO * fit(o) - penalidade(prefixo + chave(o), tipo, { lista, hist, agora }) }));
+}
+
 function embaralhar(lista, aleatorio = Math.random) {
     const a = [...lista];
     for (let i = a.length - 1; i > 0; i--) {
@@ -47,25 +107,27 @@ function embaralhar(lista, aleatorio = Math.random) {
     return a;
 }
 
-/** Os itens da busca na ordem de tentar: os nunca usados primeiro (sorteados), os usados no fim. */
-function ordenar(itens, tipo, aleatorio = Math.random) {
-    const ja = new Set(usadas(tipo));
+/** Os itens da busca na ordem de tentar: mais pontos primeiro; quase empatados, sorteados. */
+function ordenar(itens, tipo, aleatorio = Math.random, adequacao = null) {
     const validos = (itens || []).filter((x) => x && x.url);
-    return [...embaralhar(validos.filter((x) => !ja.has(x.url)), aleatorio), ...validos.filter((x) => ja.has(x.url))];
+    return pontuar(validos, tipo, { adequacao, chave: (x) => x.url })
+        .map((p) => ({ ...p, pontos: p.pontos + aleatorio() * EMPATE }))
+        .sort((a, b) => b.pontos - a.pontos)
+        .map((p) => p.opcao);
 }
 
 /**
- * Uma das opções, sem repetir as últimas: as nunca usadas primeiro (sorteadas),
- * depois a usada há mais tempo. Marca a escolhida na memória do tipo. Com
- * `prefixo`, várias listas dividem o mesmo arquivo ('acabamento:fosco').
+ * Uma das opções, pelos pontos: as nunca usadas primeiro, a recente e a muito
+ * usada por último, e a adequada (opcional) acima de todas. Entre as quase
+ * empatadas, sorteia. Marca a escolhida na memória do tipo. Com `prefixo`,
+ * várias listas dividem o mesmo arquivo ('acabamento:fosco').
  */
-function sortear(opcoes, tipo, { prefixo = '', aleatorio = Math.random } = {}) {
+function sortear(opcoes, tipo, { prefixo = '', aleatorio = Math.random, adequacao = null } = {}) {
     if (!opcoes || !opcoes.length) return null;
-    const ja = usadas(tipo);
-    const idade = (o) => ja.indexOf(prefixo + o);   // 0 = a última usada
-    const novas = embaralhar(opcoes.filter((o) => idade(o) < 0), aleatorio);
-    const velhas = opcoes.filter((o) => idade(o) >= 0).sort((a, b) => idade(b) - idade(a));
-    const escolha = [...novas, ...velhas][0];
+    const pts = pontuar(opcoes, tipo, { prefixo, adequacao });
+    const melhor = Math.max(...pts.map((p) => p.pontos));
+    const quase = pts.filter((p) => p.pontos >= melhor - EMPATE).map((p) => p.opcao);
+    const escolha = quase[Math.floor(aleatorio() * quase.length) % quase.length];
     marcar(tipo, prefixo + escolha);
     return escolha;
 }
@@ -179,5 +241,5 @@ function trocarIcones(plano, troca = {}) {
     return n;
 }
 
-module.exports = { usadas, marcar, embaralhar, ordenar, sortear, climaDe, termosTrilha, termosSfx, termosBroll, buscarSemRepetir,
+module.exports = { usadas, historico, marcar, penalidade, pontuar, embaralhar, ordenar, sortear, climaDe, termosTrilha, termosSfx, termosBroll, buscarSemRepetir,
     colecaoIcones, iconesTrocaveis, trocarIcones, CLIMAS, SFX, JEITOS, FAMILIAS_ICONE };

package/lib/video/filters.js

@@ -224,7 +224,12 @@ function montarGrafo(tl, { from = 0, to, camadasDeTexto = {}, escala = 1, audio
                 else f.push(`scale=${bw}:${bh}:force_original_aspect_ratio=increase`, `crop=${bw}:${bh}`);
                 f.push('setsar=1');
                 const zoom = expressao(c.keyframes.zoom, X, fps);
-                if (zoom) f.push(`zoompan=z='max(1,${zoom})':x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)':d=1:s=${bw}x${bh}:fps=${fps}`);
+                // O foco do zoom (fx,fy) é o ponto do clipe que fica no meio; a vista nunca sai do quadro.
+                const fx = expressao(c.keyframes.fx, X, fps);
+                const fy = expressao(c.keyframes.fy, X, fps);
+                const zx = fx ? `max(0,min(iw-iw/zoom,(${fx})*iw-iw/zoom/2))` : 'iw/2-(iw/zoom/2)';
+                const zy = fy ? `max(0,min(ih-ih/zoom,(${fy})*ih-ih/zoom/2))` : 'ih/2-(ih/zoom/2)';
+                if (zoom) f.push(`zoompan=z='max(1,${zoom})':x='${zx}':y='${zy}':d=1:s=${bw}x${bh}:fps=${fps}`);
                 for (const e of c.effects) f.push(...filtrosDoEfeito(e));
                 f.push('format=yuva420p');
                 const op = expressao(c.keyframes.opacity, Xt, fps);

package/lib/video/ops.js

@@ -184,7 +184,7 @@ const OPS = {
         },
     },
     set_keyframes: {
-        uso: 'set_keyframes {id,prop(zoom|cx|cy|rotation|opacity|volume),keys:[{frame(timeline),value,interp?:ease|linear|hold}]} — keys:[] limpa',
+        uso: 'set_keyframes {id,prop(zoom|fx|fy|cx|cy|rotation|opacity|volume),keys:[{frame(timeline),value,interp?:ease|linear|hold}]} — keys:[] limpa',
         async run(ctx, a) { precisaProjeto(ctx); return mutar(ctx, 'set_keyframes', (tl) => { E.keyframes(tl, a.id, a.prop, a.keys); }); },
     },
     apply_layout: {
@@ -273,7 +273,8 @@ const OPS = {
 const FXO = require('./ops-fx.js');
 const PED = require('./pedido.js');
 const AUTO = require('./auto.js');
-Object.assign(OPS, FXO.OPS, PED.OPS, AUTO.OPS);
+const ZOOM = require('./zoom.js');   // o zoom que segue o cursor (gravação de tela): fica na ajuda principal
+Object.assign(OPS, FXO.OPS, PED.OPS, AUTO.OPS, ZOOM.OPS);
 
 const ALIAS = { timeline: 'get_timeline', transcript: 'get_transcript', captions: 'add_captions', texts: 'add_texts', render: 'export', pedido: 'do', analyze: 'track' };
 
@@ -310,7 +311,7 @@ const EFEITOS = new Set([...Object.keys(FXO.OPS), ...Object.keys(PED.OPS), ...Ob
 /* A ajuda principal fica curta (o modelo a lê inteira a cada tarefa): os
    efeitos entram num resumo de três linhas, e o detalhe em `help efeitos`. */
 function ajuda(secao) {
-    Object.assign(EX, FXO.EX, PED.EX, AUTO.EX);
+    Object.assign(EX, FXO.EX, PED.EX, AUTO.EX, ZOOM.EX);
     const linha = (nome, o, linhas) => {
         linhas.push('  ' + o.uso);
         if (EX[nome]) linhas.push(`      ex: primocode video ${nome} --json '${EX[nome]}'`);

package/lib/video/timeline.js

@@ -29,7 +29,7 @@ const CABE = { video: ['video', 'image'], audio: ['audio'], text: ['text'] };
 
 const TRANSFORM_PADRAO = { cx: 0.5, cy: 0.5, w: 1, h: 1, rotation: 0 };
 const CROP_PADRAO = { l: 0, t: 0, r: 0, b: 0 };
-const PROPS_ANIMAVEIS = ['zoom', 'cx', 'cy', 'rotation', 'opacity', 'volume'];
+const PROPS_ANIMAVEIS = ['zoom', 'fx', 'fy', 'cx', 'cy', 'rotation', 'opacity', 'volume'];   // fx,fy = foco do zoom (0–1 do clipe)
 const INTERP = ['linear', 'ease', 'hold'];
 
 function novo({ nome = 'video', width = 1080, height = 1920, fps = 30 } = {}) {

package/lib/video/zoom.js

@@ -0,0 +1,275 @@
+/**
+ * zoom.js — o zoom que segue o cursor numa gravação de tela.
+ *
+ * Três peças, como conta pura e testável sem vídeo nenhum:
+ *
+ *   · os FOCOS: o clique, quando há registro dele; sem clique, o lugar onde
+ *     o movimento PARA (o cursor anda, assenta e alguém vai clicar ali);
+ *   · os TRECHOS: focos próximos no tempo viram um zoom só; uma pausa longa
+ *     ou um salto para longe (com tempo de sobra) fecham o zoom e abrem outro;
+ *   · a CÂMERA: dentro do trecho ela fica parada enquanto o cursor anda numa
+ *     zona morta no meio da vista, e só anda quando ele sai dali — puxada por
+ *     uma mola criticamente amortecida, sem tremer e sem passar do ponto.
+ *
+ * Reimplementação independente da ideia (curva, regra de clique e mola):
+ * nenhuma linha vem de outro projeto.
+ *
+ * Saída: keyframes de zoom e do FOCO do zoom (fx, fy: 0–1 do clipe), que o
+ * filters.js já sabe desenhar no zoompan.
+ */
+
+'use strict';
+
+const { spawn } = require('child_process');
+
+const lim = (v, a, b) => Math.max(a, Math.min(b, v));
+
+// ── medir: onde a tela mexeu (quando ninguém gravou o cursor) ────────────
+
+/**
+ * Quadros cinza (Uint8Array w*h, um por amostra) → [{t, x, y, move}].
+ * x,y = centro do que mudou desde o quadro anterior (o cursor, numa tela
+ * parada). Mudança grande demais (rolagem, troca de janela) não é cursor.
+ */
+function movimento(quadros, w, h, fps, { limiar = 24, maxFracao = 0.2 } = {}) {
+    const out = [];
+    for (let i = 1; i < quadros.length; i++) {
+        const a = quadros[i - 1];
+        const b = quadros[i];
+        let n = 0;
+        let sx = 0;
+        let sy = 0;
+        for (let k = 0; k < w * h; k++) {
+            if (Math.abs(a[k] - b[k]) > limiar) { n++; sx += k % w; sy += Math.floor(k / w); }
+        }
+        const t = i / fps;
+        if (n < 2 || n > maxFracao * w * h) out.push({ t, x: null, y: null, move: false });
+        else out.push({ t, x: (sx / n + 0.5) / w, y: (sy / n + 0.5) / h, move: true });
+    }
+    return out;
+}
+
+/** Trilha de cursor [{t,x,y,click?}] → amostras com `move` (andou desde a anterior). */
+function doCursor(cursor, { parado = 0.004 } = {}) {
+    const c = cursor.filter((p) => Number.isFinite(p.t) && Number.isFinite(p.x) && Number.isFinite(p.y)).sort((a, b) => a.t - b.t);
+    return c.map((p, i) => ({ ...p, move: i > 0 && Math.hypot(p.x - c[i - 1].x, p.y - c[i - 1].y) > parado }));
+}
+
+/**
+ * Os focos: os cliques, se houver; senão, onde o movimento para — andou por
+ * `minAndou` s e depois ficou parado por `minParado` s. [{t, x, y}].
+ */
+function focos(amostras, { minAndou = 0.15, minParado = 0.3 } = {}) {
+    const cliques = amostras.filter((a) => a.click);
+    if (cliques.length) return cliques.map(({ t, x, y }) => ({ t, x, y }));
+    const out = [];
+    let ini = null;
+    let ult = null;
+    for (const a of amostras) {
+        if (a.move) { if (ini === null) ini = a.t; ult = a; continue; }
+        if (ult && ini !== null && ult.t - ini >= minAndou - 1e-9 && a.t - ult.t >= minParado - 1e-9) {
+            out.push({ t: ult.t, x: ult.x, y: ult.y });
+            ini = null;
+            ult = null;
+        }
+    }
+    return out;
+}
+
+// ── os trechos e a câmera ────────────────────────────────────────────────
+
+/**
+ * Focos (t em QUADROS do clipe) → trechos [{de, ate, focos}]. Fecha o trecho
+ * na pausa maior que `juntar` ou no salto maior que `longe` quando há tempo
+ * de sair e voltar (2 rampas); salto rápido fica no mesmo trecho e vira pan.
+ */
+function trechos(fs, { fps, juntar = 2.5, longe = 0.35, antes = 0.4, segura = 1.2, rampa = 0.5 } = {}) {
+    const out = [];
+    const R = rampa * fps;
+    for (const f of [...fs].sort((a, b) => a.t - b.t)) {
+        const u = out[out.length - 1];
+        const ult = u && u.focos[u.focos.length - 1];
+        const gap = ult ? f.t - ult.t : Infinity;
+        if (u && gap <= juntar * fps && !(Math.hypot(f.x - ult.x, f.y - ult.y) > longe && gap > 2 * R + segura * fps)) { u.focos.push(f); continue; }
+        out.push({ focos: [f] });
+    }
+    for (const s of out) {
+        s.de = Math.max(0, Math.round(s.focos[0].t - antes * fps - R));
+        s.ate = Math.round(s.focos[s.focos.length - 1].t + segura * fps);
+    }
+    // Um trecho não invade a saída do anterior.
+    for (let i = 1; i < out.length; i++) out[i - 1].ate = Math.max(out[i - 1].focos[out[i - 1].focos.length - 1].t, Math.min(out[i - 1].ate, out[i].de - R));
+    return out;
+}
+
+/**
+ * A câmera, quadro a quadro: [{z, x, y}] para `dur` quadros. `pos(f)` = onde
+ * o cursor está no quadro f (ou null). Zona morta = fração da meia-vista.
+ */
+function camera(dur, ts, pos, { fps, zoom = 1.8, rampa = 0.5, zonaMorta = 0.45, hz = 1.4 } = {}) {
+    const R = Math.max(1, Math.round(rampa * fps));
+    const out = [];
+    const w = 2 * Math.PI * hz;
+    const dt = 1 / fps;
+    let cam = { x: 0.5, y: 0.5 };
+    let vel = { x: 0, y: 0 };
+    let alvo = { ...cam };
+    let s = null;
+    for (let f = 0; f < dur; f++) {
+        const novo = ts.find((t) => f >= t.de && f < t.ate + R);
+        if (novo !== s) {
+            s = novo;
+            if (s) { cam = { x: s.focos[0].x, y: s.focos[0].y }; alvo = { ...cam }; vel = { x: 0, y: 0 }; }
+        }
+        let z = 1;
+        if (s) {
+            const p = f < s.de + R ? (f - s.de) / R : f >= s.ate ? 1 - (f - s.ate) / R : 1;
+            z = 1 + (zoom - 1) * p * p * (3 - 2 * p);
+            // Segue o cursor só entre o primeiro e o último foco: antes, mira o foco; depois, segura.
+            const c = f >= s.focos[0].t && f <= s.focos[s.focos.length - 1].t ? pos(f) : null;
+            const meia = 0.5 / zoom;
+            if (c) {
+                for (const k of ['x', 'y']) {
+                    const d = c[k] - alvo[k];
+                    const zm = zonaMorta * meia;
+                    if (Math.abs(d) > zm) alvo[k] = c[k] - Math.sign(d) * zm;
+                    alvo[k] = lim(alvo[k], meia, 1 - meia);
+                }
+            }
+            for (const k of ['x', 'y']) {
+                vel[k] += (w * w * (alvo[k] - cam[k]) - 2 * w * vel[k]) * dt;   // mola crítica: chega sem passar
+                cam[k] += vel[k] * dt;
+            }
+        }
+        const meiaZ = 0.5 / z;
+        out.push({ z, x: lim(cam.x, meiaZ, 1 - meiaZ), y: lim(cam.y, meiaZ, 1 - meiaZ) });
+    }
+    return out;
+}
+
+/** Ramer–Douglas–Peucker numa série: os quadros que bastam para a reta não errar mais que `tol`. */
+function enxugar(v, tol) {
+    const manter = new Set([0, v.length - 1]);
+    const pilha = [[0, v.length - 1]];
+    while (pilha.length) {
+        const [a, b] = pilha.pop();
+        let pior = -1;
+        let max = tol;
+        for (let i = a + 1; i < b; i++) {
+            const d = Math.abs(v[i] - (v[a] + ((v[b] - v[a]) * (i - a)) / (b - a)));
+            if (d > max) { max = d; pior = i; }
+        }
+        if (pior >= 0) { manter.add(pior); pilha.push([a, pior], [pior, b]); }
+    }
+    return [...manter].sort((x, y) => x - y);
+}
+
+/** Câmera → keyframes {zoom, fx, fy} em quadros do clipe ({frame, value, interp}). */
+function keyframes(cam, { tol = 0.002 } = {}) {
+    const out = {};
+    for (const [prop, k] of [['zoom', 'z'], ['fx', 'x'], ['fy', 'y']]) {
+        const v = cam.map((c) => c[k]);
+        out[prop] = enxugar(v, prop === 'zoom' ? 0.01 : tol).map((f) => ({ frame: f, value: Math.round(v[f] * 10000) / 10000, interp: 'linear' }));
+    }
+    return out;
+}
+
+/**
+ * Tudo junto. `amostras` com t em QUADROS do clipe e x,y em 0–1 do clipe.
+ * Devolve {focos, trechos, cam, keys}.
+ */
+function planejar(amostras, dur, opts) {
+    const fs = focos(amostras.map((a) => ({ ...a, t: a.t / opts.fps })), opts).map((f) => ({ ...f, t: Math.round(f.t * opts.fps) }));
+    const ts = trechos(fs, opts);
+    const comPos = amostras.filter((a) => a.x !== null && a.x !== undefined);
+    let i = 0;
+    const pos = (f) => {   // a última posição conhecida até f (f só cresce)
+        while (i + 1 < comPos.length && comPos[i + 1].t <= f) i++;
+        return comPos[i] && comPos[i].t <= f ? comPos[i] : null;
+    };
+    const cam = camera(dur, ts, pos, opts);
+    return { focos: fs, trechos: ts, cam, keys: keyframes(cam) };
+}
+
+// ── o ffmpeg mede ────────────────────────────────────────────────────────
+
+/** Quadros cinza pequenos da origem [de, ate) segundos, a `fps` por segundo. */
+function quadrosCinza(arquivo, de, ate, { fps = 15, w = 160, h = 90 } = {}) {
+    const video = require('../estudio/video.js');
+    return new Promise((resolve, reject) => {
+        const p = spawn(video.ffmpeg(), ['-hide_banner', '-loglevel', 'error', '-ss', String(de), '-t', String(ate - de), '-i', arquivo,
+            '-vf', `fps=${fps},scale=${w}:${h}:flags=area,format=gray`, '-f', 'rawvideo', '-']);
+        const partes = [];
+        p.stdout.on('data', (d) => partes.push(d));
+        p.on('error', reject);
+        p.on('close', (code) => {
+            if (code !== 0) return reject(new Error('não consegui ler os quadros'));
+            const b = Buffer.concat(partes);
+            const out = [];
+            for (let k = 0; k + w * h <= b.length; k += w * h) out.push(b.subarray(k, k + w * h));
+            resolve(out);
+        });
+    });
+}
+
+// ── a operação do editor ─────────────────────────────────────────────────
+
+/** Ponto da ORIGEM (0–1) → ponto do clipe (0–1), depois do encaixe (cover/contain). */
+function paraClipe(tl, clip, asset, x, y) {
+    if (clip.fit === 'stretch') return { x, y };
+    const bw = clip.transform.w * tl.width;
+    const bh = clip.transform.h * tl.height;
+    const aw = asset.width || bw;
+    const ah = asset.height || bh;
+    const esc = clip.fit === 'contain' ? Math.min(bw / aw, bh / ah) : Math.max(bw / aw, bh / ah);
+    return { x: lim(0.5 + ((x - 0.5) * aw * esc) / bw, 0, 1), y: lim(0.5 + ((y - 0.5) * ah * esc) / bh, 0, 1) };
+}
+
+const OPS = {
+    auto_zoom: {
+        uso: 'auto_zoom {id?,zoom?:1.8,cursor?:[{t(s da origem),x,y(0–1),click?}]|cursorFile?,deadZone?:0.45,remove?} — gravação de tela: entra no clique (sem cursor: onde o movimento para), segue com zona morta e mola, sai na pausa',
+        async run(ctx, a) {
+            const T = require('./timeline.js');
+            const E = require('./edits.js');
+            const { mutar } = require('./ops.js');
+            if (!ctx.tl) throw T.erro('nenhum projeto aberto: comece com import {"path":"..."}');
+            const primeiro = T.todosOsClipes(ctx.tl).find((x) => x.clip.type === 'video');
+            if (!a.id && !primeiro) throw T.erro('não há clipe de vídeo');
+            const { clip } = T.achar(ctx.tl, a.id || primeiro.clip.id);
+            if (a.remove) return mutar(ctx, 'auto_zoom', (tl) => { for (const p of ['zoom', 'fx', 'fy']) E.keyframes(tl, clip.id, p, []); });
+            const asset = ctx.tl.assets[clip.asset];
+            const fps = ctx.tl.fps;
+            const { de, ate } = T.janelaOrigem(ctx.tl, clip);
+            let cru;
+            let fonte;
+            if (a.cursor || a.cursorFile) {
+                cru = doCursor(a.cursor || JSON.parse(require('fs').readFileSync(a.cursorFile, 'utf8')));
+                fonte = cru.some((x) => x.click) ? 'cliques' : 'cursor';
+            } else {
+                const mfps = 15;
+                const h = 2 * Math.round((80 * (asset.height || 9)) / (asset.width || 16));
+                cru = movimento(await quadrosCinza(asset.path, de, ate, { fps: mfps, w: 160, h }), 160, h, mfps).map((x) => ({ ...x, t: x.t + de }));
+                fonte = 'movimento';
+            }
+            const amostras = [];
+            for (const x of cru) {
+                const f = T.origemParaQuadro(ctx.tl, clip, x.t);
+                if (f === null) continue;
+                const p = x.x === null ? { x: null, y: null } : paraClipe(ctx.tl, clip, asset, x.x, x.y);
+                amostras.push({ ...x, ...p, t: f - clip.startFrame });
+            }
+            const pl = planejar(amostras, clip.durationFrames, { fps, zoom: lim(Number(a.zoom) || 1.8, 1.1, 3), zonaMorta: a.deadZone ?? 0.45 });
+            const zooms = pl.trechos.map((t) => [t.de + clip.startFrame, t.ate + clip.startFrame]);
+            if (!pl.focos.length) return { ok: true, nada: true, fonte, focos: 0, aviso: 'nenhum clique nem parada do cursor: nada para aproximar' };
+            return mutar(ctx, 'auto_zoom', (tl) => {
+                for (const [p, ks] of Object.entries(pl.keys)) E.keyframes(tl, clip.id, p, ks.map((k) => ({ ...k, frame: k.frame + clip.startFrame })));
+                return { fonte, focos: pl.focos.length, zooms };
+            });
+        },
+    },
+};
+
+// Sem linha de exemplo: a ajuda principal cabe em 60 linhas, e o `uso` já mostra a forma.
+const EX = {};
+
+module.exports = { movimento, doCursor, focos, trechos, camera, enxugar, keyframes, planejar, quadrosCinza, paraClipe, OPS, EX };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "10.1.0",
+  "version": "10.3.0-beta.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/casar.test.js && node test/recado.test.js && node test/releitura.test.js && node test/snapshot.test.js && node test/video.test.js && node test/limpeza.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js && node test/acervo-site.test.js && node test/impacto.test.js && node test/cinema.test.js && node test/producao.test.js && node test/ende.test.js && node test/capa.test.js && node test/broll.test.js && node test/morfar.test.js && node test/motion.test.js && node test/motion-roteiro.test.js && node test/kit-motion.test.js && node test/gerativo.test.js && node test/hibrido.test.js && node test/biblioteca.test.js && node test/mcp.test.js && node test/personas.test.js && node test/efeitos.test.js && node test/auto.test.js && node test/colar.test.js && node test/orquestra.test.js && node test/shell-limpo.test.js && node test/editar-remotion.test.js && node test/variacao3d.test.js && node test/portao-skill.test.js && node test/clones.test.js && node test/kokoro.test.js && node test/fluido.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/casar.test.js && node test/recado.test.js && node test/releitura.test.js && node test/snapshot.test.js && node test/video.test.js && node test/limpeza.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js && node test/acervo-site.test.js && node test/impacto.test.js && node test/cinema.test.js && node test/producao.test.js && node test/ende.test.js && node test/capa.test.js && node test/broll.test.js && node test/morfar.test.js && node test/motion.test.js && node test/motion-roteiro.test.js && node test/kit-motion.test.js && node test/gerativo.test.js && node test/gerativo-identidade.test.js && node test/gerativo-moldura.test.js && node test/gerativo-heroi.test.js && node test/gerativo-ambiente.test.js && node test/hibrido.test.js && node test/batida.test.js && node test/estudio-acervo.test.js && node test/estudio-diretor.test.js && node test/estudio-marca.test.js && node test/estudio-novo-projeto.test.js && node test/estudio-plano.test.js && node test/estudio-slides.test.js && node test/estudio-video.test.js && node test/revisor.test.js && node test/assinatura.test.js && node test/biblioteca.test.js && node test/mcp.test.js && node test/personas.test.js && node test/efeitos.test.js && node test/auto.test.js && node test/colar.test.js && node test/orquestra.test.js && node test/shell-limpo.test.js && node test/editar-remotion.test.js && node test/variacao3d.test.js && node test/portao-skill.test.js && node test/clones.test.js && node test/kokoro.test.js && node test/fluido.test.js && node test/zoom.test.js"
   },
   "engines": {
     "node": ">=18.17.0"

package/skills/motion-de-primeira/SKILL.md

@@ -57,11 +57,9 @@ Em vídeo de produto, anúncio e vinheta, escreva **uma cena de 8 a 15 s** no
 - **A troca é no mesmo lugar e instante**: o foguete some onde o ícone nasce; o
   app nasce do tamanho e da COR do ícone.
 
-Por roteiro, o padrão é `hibrido` (dê `busca` em inglês por parte); `gerativo` (o motion), `vox` (explicar; dê
-`destaque` e `fonte`), `marca`, `lancamento` pelo nome; `visual` troca a peça de uma parte.
-
-Pedido de motion (ou sem referências): `estilo: "gerativo"`, só o roteiro
-(`fala`, `destaque`); `roteiro.semente` sorteia outro, `modelo3d` traz o 3D.
+Sem imagem é o padrão (foto só se pedirem). Decida `clima`, o impacto (`destaque`, ≤1 em 3 partes), o
+respiro e o `estilo` deste roteiro: `gerativo`, `fluido`, `impacto`, `vox`, `marca`, `lancamento`; vazio, gira.
+`hibrido` só com imagem pedida. Leia os avisos da revisão.
 
 ## Cor e tipo