primocode 10.1.0 → 10.2.0

package/lib/estudio/kit/fluido.jsx

@@ -23,6 +23,7 @@ import { CURVAS_KIT, alfa } from './base';
 const ed = CURVAS_KIT.editorial, cam = CURVAS_KIT.camera;
 const c01 = (x) => (x < 0 ? 0 : x > 1 ? 1 : x);
 const lerp = (a, b, k) => a + (b - a) * k;
+const lum = (hex) => { const n = parseInt(String(hex).slice(1), 16); return (0.299 * (n >> 16 & 255) + 0.587 * (n >> 8 & 255) + 0.114 * (n & 255)) / 255; };
 const entra = (t) => t * t;
 const SANS = (f) => '"' + f + '", system-ui, sans-serif';
 const SERIF = (f) => '"' + f + '", Georgia, serif';
@@ -52,7 +53,7 @@ function medir(t, tam, peso, serifa, P, mono) {
 
 /* Um bloco de texto: quebra palavra a palavra (largura medida), cada linha
    centrada em cx (ou alinhada à esquerda/direita), o bloco centrado em cy. */
-function bloco(P, f, { tam, peso = 400, max = 1e9, cx, cy, alinha = 'centro', cor, mono = false }) {
+function bloco(P, f, { tam, peso = 400, max = 1e9, cx, cy, alinha = 'centro', cor, corAcento = null, mono = false }) {
   const esp = medir(' ', tam, peso, false, P, mono);
   const ws = f.palavras.map((w) => ({ ...w, w: medir(w.t, w.acento ? tam * 1.14 : tam, peso, w.acento, P, mono) }));
   const linhas = [[]];
@@ -67,7 +68,7 @@ function bloco(P, f, { tam, peso = 400, max = 1e9, cx, cy, alinha = 'centro', co
   const top = cy - h / 2;
   const x0 = alinha === 'centro' ? cx - w / 2 : alinha === 'esq' ? cx : cx - w;
   return {
-    f, tam, peso, cor, esp, lh, w, h, top, cx, cy, mono, left: x0,
+    f, tam, peso, cor, corAcento, esp, lh, w, h, top, cx, cy, mono, left: x0,
     linhas: linhas.map((l, i) => ({ palavras: l, y: top + i * lh, x: alinha === 'centro' ? cx - larg(l) / 2 : alinha === 'esq' ? cx : cx - larg(l) })),
   };
 }
@@ -108,6 +109,60 @@ function leiaute(P) {
       ent = [0.3, 0.8];
     }
     const poe = (bl) => { out.blocos.push(bl); return bl; };
+    /* A IMAGEM (fluido.js escolhe a batida e o jeito): o texto se arruma em
+       volta dela, e o portador vira um ponto discreto enquanto a foto manda. */
+    if (b.imagem && pr) {
+      const j = b.imagem.jeito;
+      const t0 = Math.max(b.de + 0.05, Math.min(...b.frases.map((f) => f.palavras[0].em)));
+      const [sb] = fr('sub');
+      const branco = '#ffffff';
+      let foto, tY;
+      if (j === 'cartao') {
+        const cw = deitado ? W * 0.36 : W * 0.74, ch = deitado ? H * 0.62 : H * 0.42;
+        foto = { x: deitado ? cx + W * 0.2 : cx, y: deitado ? cy : cy + H * 0.12, w: cw, h: ch };
+        tY = deitado ? cy : cy - H * 0.24;
+      } else if (j === 'faixa') {
+        foto = { x: cx, y: deitado ? cy - H * 0.08 : cy - H * 0.06, w: W, h: deitado ? H * 0.46 : H * 0.34 };
+        tY = foto.y + foto.h / 2 + 130 * u;
+      } else { foto = { x: cx, y: cy, w: W, h: H }; tY = j === 'vazado' ? cy : cy + H * (deitado ? 0.22 : 0.2); }
+      const tx2 = j === 'cartao' && deitado ? cx - W * 0.2 : cx;
+      const sobreFoto = j === 'janela' || j === 'circulo';
+      let tam = (j === 'vazado' ? 200 : sobreFoto ? 92 : 76) * u;
+      if (j === 'vazado') {
+        const l100 = pr.palavras.reduce((s2, w) => s2 + medir(w.t, 100, 700, false, P), 0) + medir(' ', 100, 700, false, P) * (pr.palavras.length - 1);
+        tam = Math.min(360 * u, (W * 0.84 / (1 + 0.022 * (bi + 1))) / Math.max(1, l100) * 100);
+      }
+      const larg2 = j === 'cartao' && deitado ? W * 0.34 : W * 0.84;
+      const tb = poe(bloco(P, pr, { tam, peso: j === 'vazado' ? 700 : 400, max: larg2, cx: tx2, cy: tY, cor: sobreFoto ? branco : T, corAcento: sobreFoto ? branco : null }));
+      if (sb) poe(bloco(P, sb, { tam: 34 * u, max: larg2, cx: tx2, cy: tY + tb.h / 2 + 56 * u, cor: sobreFoto ? alfa(branco, 0.82) : S }));
+      out.imagem = { jeito: j, src: b.imagem.src, foto, t0, texto: tb };
+      // O portador: no círculo ele É a foto (cresce); nos outros, vira um ponto e some.
+      if (j === 'circulo') vai(Math.max(0, t0 - 0.5), t0 + 0.2, forma(cx, cy, 0, 0, { solid: 1, ac: 1, op: 0 }));
+      else vai(ent[0], ent[1], forma(tx2, tY - tb.h / 2 - 60 * u, 10 * u, 10 * u, { solid: 1, ac: 1, op: j === 'vazado' ? 1 : 0 }));
+      return out;
+    }
+    /* A PALAVRA GIGANTE (fluido.js marca): a frase curta enche a largura,
+       sem pílula, peso fino. Na VIRADA o portador cresce até cobrir a tela
+       de acento, e o texto troca para a cor que lê sobre ele. */
+    if (b.gigante && pr) {
+      const base = 100;
+      const larguraA100 = pr.palavras.reduce((s2, w) => s2 + medir(w.t, w.acento ? base * 1.14 : base, 300, w.acento, P), 0) + medir(' ', base, 300, false, P) * (pr.palavras.length - 1);
+      // Cabe já descontando o zoom que a câmera terá nesta batida (1 + 0,022 por batida) e a deriva.
+      const zoomAqui = 1 + 0.022 * (bi + 1);
+      const tam = Math.min(330 * u, Math.max(96 * u, (W * 0.8 / zoomAqui) / Math.max(1, larguraA100) * base));
+      const sobre = b.virada ? (lum(pal.acentos[0]) > 0.55 ? pal.fundo[0] : '#ffffff') : T;
+      const acentoSobre = b.virada ? sobre : pal.acentos[0];
+      const g = poe(bloco(P, pr, { tam, peso: 300, max: W * 0.84 / zoomAqui, cx, cy, cor: sobre, corAcento: acentoSobre }));
+      const [sb] = fr('sub');
+      if (sb) poe(bloco(P, sb, { tam: 34 * u, max: W * 0.7, cx, cy: cy + g.h / 2 + 70 * u, cor: b.virada ? sobre : S }));
+      // A virada começa com a PRIMEIRA frase que aparece (a voz pode dizer o sub antes do título).
+      const t0 = Math.max(b.de + 0.1, Math.min(...b.frases.map((f) => f.palavras[0].em)));
+      if (b.virada) {
+        const D = Math.hypot(W, H) * 1.08;
+        vai(Math.max(0, t0 - 0.55), t0 - 0.05, forma(cx, cy, D, D, { solid: 1, ac: 1 }));
+      } else vai(ent[0], ent[1], forma(cx, cy - g.h / 2 - 70 * u, 14 * u, 14 * u, { solid: 1, ac: 1 }));
+      return out;
+    }
     switch (b.tipo) {
       case 'abertura': {
         const t = pr && poe(bloco(P, pr, { tam: (lado === 'centro' ? 96 : 80) * u, max: larg, cx: tx, cy: ty, cor: T }));
@@ -146,7 +201,9 @@ function leiaute(P) {
         out.extra = { pilulas, tt };
         // O portador vira a PRIMEIRA pílula; as outras nascem na ponta da curva.
         const p0 = pilulas[0];
-        if (p0) vai(ent[0], ent[1], forma(p0.x, p0.y, p0.w, p0.h, { fill: 1, stroke: 0.35 }));
+        // A primeira pílula nasce com o primeiro item (antes, ficava vazia e enorme esperando a voz).
+        const i0 = p0 ? p0.f.palavras[0].em : b.de;
+        if (p0) vai(Math.max(ent[0], i0 - 0.4), Math.max(ent[1], i0 + 0.1), forma(p0.x, p0.y, p0.w, p0.h, { fill: 1, stroke: 0.35 }));
         else vai(ent[0], ent[1], forma(cx, cy, 12 * u, 12 * u, { solid: 1, ac: 1 }));
         break;
       }
@@ -220,8 +277,12 @@ function leiaute(P) {
         const h = umaLinha ? (t ? t.tam * 2 : 60 * u) : t.h;
         if (sb) poe(umaLinha ? bloco(P, sb, { tam: 34 * u, max: larg, cx: tx, cy: ty + h / 2 + 62 * u, cor: S })
           : bloco(P, sb, { tam: 34 * u, max: larg, cx: t.left, cy: ty + h / 2 + 50 * u, alinha: 'esq', cor: S }));
-        if (umaLinha) vai(ent[0], ent[1], forma(tx, ty, (t ? t.w : 200 * u) + 110 * u, h, { fill: 1, stroke: 0.35 }));
-        else vai(ent[0], ent[1], forma(t.left - 40 * u, ty, 6 * u, t.h * 0.92, { solid: 1, ac: 1, r: 3 }));
+        /* A pílula nasce com a primeira palavra, não antes: entrando em b.de,
+           ela ficava VAZIA até a voz chegar na frase (teste de 08/10). */
+        const p0 = pr ? pr.palavras[0].em : b.de;
+        const entT = [Math.max(ent[0], p0 - 0.4), Math.max(ent[1], p0 + 0.1)];
+        if (umaLinha) vai(entT[0], entT[1], forma(tx, ty, (t ? t.w : 200 * u) + 110 * u, h, { fill: 1, stroke: 0.35 }));
+        else vai(entT[0], entT[1], forma(t.left - 40 * u, ty, 6 * u, t.h * 0.92, { solid: 1, ac: 1, r: 3 }));
       }
     }
     return out;
@@ -261,7 +322,7 @@ function Palavras({ bl, sai, t, P, op = 1, de = null }) {
             filter: (1 - k) + o > 0.02 ? 'blur(' + ((1 - k) * 8 + o * 6).toFixed(2) + 'px)' : undefined,
             fontFamily: w.acento ? SERIF(P.fontes.serifa) : bl.mono ? MONO(P.fontes.mono) : SANS(P.fontes.texto), fontStyle: w.acento ? 'italic' : 'normal',
             fontWeight: w.acento ? 400 : bl.peso, fontSize: w.acento ? bl.tam * 1.14 : bl.tam, letterSpacing: w.acento || bl.mono ? 0 : '-0.02em',
-            color: w.acento ? pal.acentos[0] : bl.cor,
+            color: w.acento ? (bl.corAcento || pal.acentos[0]) : bl.cor,
           }}>{w.t}</span>
         );
       })}
@@ -340,6 +401,55 @@ function Cartao({ c, ui, de: de0, sai, t, P, u: u0 }) {
   );
 }
 
+// ── a foto: cinco jeitos de entrar, nenhum repetido no vídeo ────────────
+function Foto({ im, b, sai, t, P, u, W, H }) {
+  const k = ed(c01((t - (im.t0 - 0.45)) / 0.75));            // a entrada
+  const o = entra(c01((t - sai) / 0.4));                      // a saída
+  if (k <= 0.001 || o >= 0.999) return null;
+  const vida = c01((t - im.t0) / Math.max(1, b.ate - im.t0)); // o empurrão lento enquanto ela fica
+  const src = staticFile(im.src);
+  const f = im.foto;
+  const img = (extra = {}) => <Img src={src} style={{ position: 'absolute', left: 0, top: 0, width: '100%', height: '100%', objectFit: 'cover', ...extra }} />;
+  const escurece = <div style={{ position: 'absolute', inset: 0, background: 'linear-gradient(180deg, rgba(0,0,0,0.05) 30%, rgba(0,0,0,0.62) 100%)' }} />;
+  if (im.jeito === 'janela') {
+    return <div style={{ position: 'absolute', left: 0, top: 0, width: W, height: H, overflow: 'hidden', opacity: 1 - o,
+      clipPath: 'inset(0 ' + ((1 - k) * 100).toFixed(2) + '% 0 0)' }}>
+      {img({ transform: 'scale(' + (1.14 - 0.08 * vida) + ') translateX(' + ((1 - k) * -6) + '%)' })}{escurece}</div>;
+  }
+  if (im.jeito === 'circulo') {
+    const r = Math.hypot(W, H) * 0.55 * k * (1 - o);
+    return <div style={{ position: 'absolute', left: 0, top: 0, width: W, height: H, overflow: 'hidden',
+      clipPath: 'circle(' + r.toFixed(1) + 'px at ' + W / 2 + 'px ' + H / 2 + 'px)' }}>
+      {img({ transform: 'scale(' + (1.2 - 0.12 * k - 0.05 * vida) + ')' })}{escurece}</div>;
+  }
+  if (im.jeito === 'cartao') {
+    const gira = (1 - k) * -38 + Math.sin(t * 0.6) * 3;
+    return <div style={{ position: 'absolute', left: f.x - f.w / 2, top: f.y - f.h / 2, width: f.w, height: f.h, borderRadius: 28 * u, overflow: 'hidden',
+      opacity: k * (1 - o), boxShadow: '0 ' + 50 * u + 'px ' + 90 * u + 'px -' + 30 * u + 'px rgba(0,0,0,0.55)',
+      transform: 'perspective(' + 1500 * u + 'px) translateY(' + ((1 - k) * 140 * u - o * 60 * u) + 'px) rotateY(' + gira + 'deg) rotateX(' + (6 * (1 - k)) + 'deg) scale(' + (0.86 + 0.14 * k) + ')' }}>
+      {img({ transform: 'scale(' + (1.08 - 0.06 * vida) + ')' })}</div>;
+  }
+  if (im.jeito === 'faixa') {
+    const meio = (1 - k + o) * 50;
+    return <div style={{ position: 'absolute', left: 0, top: f.y - f.h / 2, width: W, height: f.h, overflow: 'hidden',
+      clipPath: 'inset(' + meio.toFixed(2) + '% 0 ' + meio.toFixed(2) + '% 0)' }}>
+      {img({ transform: 'scale(1.12) translateX(' + (-4 + 8 * vida) + '%)' })}</div>;
+  }
+  // vazado: as letras do título, com a foto por dentro (SVG: o texto é o recorte).
+  const tb = im.texto;
+  const id = 'vz' + b.i;
+  const fam = '"' + P.fontes.texto + '", system-ui, sans-serif';
+  return <svg width={W} height={H} style={{ position: 'absolute', left: 0, top: 0, opacity: (1 - o) }}>
+    <defs><clipPath id={id}>{tb.linhas.map((l, li) => (
+      <text key={li} x={l.x} y={l.y + tb.lh * 0.8} fontFamily={fam} fontWeight={700} fontSize={tb.tam} letterSpacing={-0.02 * tb.tam}>
+        {l.palavras.map((w) => w.t).join(' ')}</text>))}</clipPath></defs>
+    <g clipPath={'url(#' + id + ')'} style={{ opacity: k }}>
+      <image href={src} x={-W * 0.06 * (1 - vida)} y={tb.top - tb.h * 0.6} width={W * 1.12} height={tb.h * 2.2} preserveAspectRatio="xMidYMid slice"
+        transform={'translate(0 ' + ((1 - k) * 40 * u) + ')'} />
+    </g>
+  </svg>;
+}
+
 // ── a peça ───────────────────────────────────────────────────────────────
 export function Fluido({ el, t }) {
   const P = el.partitura;
@@ -371,12 +481,13 @@ export function Fluido({ el, t }) {
   const so = P.logo && ult.tipo === 'cta' ? 1 - ed(c01((t - ult.de - 0.65) / 0.5)) : 1;
 
   const camadas = [];
-  L.batidas.forEach(({ b, blocos, extra, risca, cartao, comando }, i) => {
+  L.batidas.forEach(({ b, blocos, extra, risca, cartao, comando, imagem }, i) => {
     const corte = b.transicao === 'corte' || (L.batidas[i + 1] && L.batidas[i + 1].b.transicao === 'corte');
     const ultima = i === L.batidas.length - 1;
     const sai = ultima ? 1e9 : b.ate - (corte ? 0 : 0.15), fimVis = b.ate + (corte ? 0 : 0.4);
     if (t < b.de - 0.3 || t > fimVis || (corte && t >= b.ate && !ultima)) return;
     if (cartao) camadas.push(<Cartao key={'k' + i} c={cartao} ui={b.ui} de={b.de} sai={sai} t={t} P={P} u={u} />);
+    if (imagem) camadas.push(<Foto key={'f' + i} im={imagem} b={b} sai={sai} t={t} P={P} u={u} W={W} H={H} />);
     // A lista: as curvas que se desenham de uma pílula à próxima, e as pílulas que nascem na ponta.
     if (b.tipo === 'lista' && extra) {
       const ps = extra.pilulas;
@@ -398,17 +509,27 @@ export function Fluido({ el, t }) {
             background: sup, border: (1.2 * u) + 'px solid ' + alfa(pal.tinta, 0.2), opacity: kp * o, transform: 'scale(' + (0.7 + 0.3 * kp) + ')',
             boxShadow: pal.escuro ? undefined : '0 14px 34px -14px ' + alfa(pal.tinta, 0.3) }} />);
         }
-        // O ícone de cada pílula: um brilho de quatro pontas que gira ao nascer.
+        /* O marcador de cada pílula muda de vídeo para vídeo (P.marcador): o
+           brilho de quatro pontas em toda lista era vício (08/10). */
         const kd = ed(c01((t - p.f.de) / 0.5));
-        camadas.push(<svg key={'d' + i + j} width={p.ic} height={p.ic} viewBox="-1 -1 2 2" style={{ position: 'absolute', left: p.x - p.w / 2 + 34 * u, top: p.y - p.ic / 2,
+        const mk = P.marcador || 'brilho';
+        const mx0 = p.x - p.w / 2 + 34 * u, my0 = p.y - p.ic / 2;
+        if (mk === 'brilho') camadas.push(<svg key={'d' + i + j} width={p.ic} height={p.ic} viewBox="-1 -1 2 2" style={{ position: 'absolute', left: mx0, top: my0,
           opacity: kd * o, transform: 'rotate(' + ((1 - kd) * -90 + Math.sin(t * 1.3 + j) * 6) + 'deg) scale(' + kd + ')' }}>
           <path d={BRILHO4} fill={pal.acentos[0]} />
         </svg>);
+        else if (mk === 'numero') camadas.push(<div key={'d' + i + j} style={{ position: 'absolute', left: mx0 - 4 * u, top: p.y - p.ic * 0.62, height: p.ic * 1.24, lineHeight: p.ic * 1.24 + 'px',
+          fontFamily: MONO(P.fontes.mono), fontSize: p.ic * 0.78, color: pal.acentos[0], opacity: kd * o, transform: 'translateY(' + (1 - kd) * 10 * u + 'px)' }}>{String(j + 1).padStart(2, '0')}</div>);
+        else if (mk === 'traco') camadas.push(<div key={'d' + i + j} style={{ position: 'absolute', left: mx0, top: p.y - 1.5 * u, width: p.ic * kd, height: 3 * u, borderRadius: 3,
+          background: pal.acentos[0], opacity: o }} />);
+        else if (mk === 'ponto') camadas.push(<div key={'d' + i + j} style={{ position: 'absolute', left: mx0 + p.ic * 0.3, top: p.y - p.ic * 0.2, width: p.ic * 0.4, height: p.ic * 0.4, borderRadius: 99,
+          background: pal.acentos[0], opacity: o, transform: 'scale(' + kd + ')' }} />);
       });
     }
     for (const bl of blocos) {
       const f = bl.f;
       if (b.tipo === 'passos' && extra) continue;
+      if (imagem && imagem.jeito === 'vazado' && bl === imagem.texto) continue;   // as letras são a foto (Foto desenha)
       const op = f.papel === 'nao' && risca ? 1 - 0.55 * ed(c01((t - risca) / 0.4)) : 1;
       if (f.papel === 'numero' && b.numero) {
         const k = ed(c01((t - f.de) / 1.1));

package/lib/estudio/referencias.js

@@ -18,14 +18,17 @@
 
 'use strict';
 
-let ATUAL = { modo: null, escopo: '' };
+let ATUAL = { modo: null, escopo: '', explicito: false };
 
-function definir(modo, escopo = '') {
-    ATUAL = { modo: ['aberto', 'fechado', 'sem'].includes(modo) ? modo : null, escopo: String(escopo || '').trim() };
+function definir(modo, escopo = '', explicito = true) {
+    ATUAL = { modo: ['aberto', 'fechado', 'sem'].includes(modo) ? modo : null, escopo: String(escopo || '').trim(), explicito: !!explicito };
     return ATUAL;
 }
 function atual() { return ATUAL; }
-function limpar() { ATUAL = { modo: null, escopo: '' }; }
+function limpar() { ATUAL = { modo: null, escopo: '', explicito: false }; }
+
+/** Sem foto nem vídeo de fora: o "sem" e também ninguém ter dito nada (o padrão, 07/10). */
+function semImagem({ modo } = ATUAL) { return modo !== 'aberto' && modo !== 'fechado'; }
 
 /** Os termos do escopo fechado: "site:anthropic.com, claude ai, sonnet" → lista. */
 function termos(escopo = ATUAL.escopo) {
@@ -41,33 +44,40 @@ function entender(resposta) {
     return null;
 }
 
-/* O MODO DEDUZIDO DO PEDIDO. Quem diz no pedido não é perguntado:
-     "só motion", "sem referência", "sem foto"          → sem
-     "só do site x.com", "usa apenas anthropic.com e …" → fechado (o escopo)
-     "web aberta", "escopo aberto", "pesquisa à vontade" → aberto
-   O resto volta com `explicito: false` e o terminal pergunta antes de
-   começar: "eu posso pedir um vídeo mas estar me referindo ao motion"
-   (Joel, 02/10) — chutar o aberto fazia vídeo com foto e b-roll quando a
-   pessoa queria só motion. */
+/* O MODO DEDUZIDO DO PEDIDO. O padrão é SEM IMAGEM: "por padrão, NÃO
+   usar imagens. Somente quando o usuário pedir explicitamente" (Joel, 07/10).
+   O menu 1/2/3 do terminal saiu; quem quer imagem diz no pedido:
+     "adicione imagens de apoio", "quero imagens durante o vídeo",
+     "use imagens reais", "web aberta"                    → aberto
+     "só do site x.com", "usa apenas anthropic.com e …"   → fechado (o escopo)
+     "só motion", "sem referência", "sem foto"            → sem (explícito)
+     o resto                                              → sem (o padrão)  */
+const PEDE_IMAGEM = /(adicion|coloc|use|usa|usar|quero|bota|pon|insir|inclu|com)\w*\s+(\w+\s+){0,3}(imagens?|fotos?|b-?roll|videos? de (apoio|banco)|cenas reais)\b|(imagens?|fotos?) (de apoio|reais|durante|para ilustrar|pra ilustrar|da (web|internet))|escopo aberto|web aberta|pesquis\w* (a vontade|na web|na internet)|busc\w* (imagens|fotos|videos) na (web|internet)/;
+const NEGA_IMAGEM = /so (o )?motion|motion puro|sem refer|sem (foto|imagem|imagens|video de banco|pesquisa)|nao (pesquis|busqu)|so anima|(nao|nada de) (quero |use |usar |coloc\w* )?(imagens?|fotos?)/;
+
 function inferir(texto) {
-    const t = String(texto || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
-    if (/so (o )?motion|motion puro|sem refer|sem (foto|imagem|imagens|video de banco|pesquisa)|nao (pesquis|busqu)|so anima/.test(t)) return { modo: 'sem', escopo: '', explicito: true };
+    const t = String(texto || '').toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+    if (NEGA_IMAGEM.test(t)) return { modo: 'sem', escopo: '', explicito: true };
     const dominios = String(texto || '').match(/\b[a-z0-9-]+(\.[a-z0-9-]+)+\.?[a-z]{2,}(\/[^\s,]*)?/gi) || [];
     if (/\b(so|apenas|somente|unicamente)\b[^.]{0,30}\b(site|sites|link|links|fonte|fontes|pagina|de|do|da|em)\b/.test(t) && dominios.length) {
         return { modo: 'fechado', escopo: dominios.join(', '), explicito: true };
     }
-    if (/escopo aberto|web aberta|pesquis\w* (a vontade|na web|na internet)|busc\w* (imagens|fotos|videos) na (web|internet)|com (imagens|fotos) da (web|internet)/.test(t)) {
-        return { modo: 'aberto', escopo: '', explicito: true };
-    }
-    return { modo: 'aberto', escopo: '', explicito: false };
+    if (PEDE_IMAGEM.test(t)) return { modo: 'aberto', escopo: '', explicito: true };
+    return { modo: 'sem', escopo: '', explicito: false };
 }
 
 /** A instrução para o agente, conforme o modo. */
-function instrucao({ modo, escopo } = ATUAL) {
-    if (modo === 'sem') {
+function instrucao({ modo, escopo, explicito } = ATUAL) {
+    // O vídeo sem imagem é motion: o agente escolhe o estilo de motion que serve ao roteiro, não um fixo.
+    const motion = 'O vídeo é MOTION: tipografia, formas, ícones, animação e som. Escolha em roteiro.estilo o motion que serve a este '
+        + 'roteiro (gerativo, fluido, impacto, vox, marca, lancamento) ou deixe vazio para o rodízio — não repita sempre o mesmo.';
+    if (modo === 'sem' && explicito) {
         return '[REFERÊNCIAS: NENHUMA] A pessoa quer SÓ MOTION: não pesquise (nada de pesquisar_referencia nem estudio_site), '
-            + 'não busque foto nem vídeo, não use estudio_midia de banco. Escreva o roteiro com o que o pedido já diz e deixe '
-            + 'o motion gerativo fazer o trabalho (roteiro.estilo "gerativo": a tipografia anima sozinha, sem template).';
+            + 'não busque foto nem vídeo, não use estudio_midia de banco. Escreva o roteiro com o que o pedido já diz. ' + motion;
+    }
+    if (modo === 'sem') {
+        return '[SEM IMAGEM — o padrão] A pessoa não pediu imagem: não busque foto nem vídeo, não use estudio_midia de banco '
+            + 'nem "busca" nas partes. Pesquisar FATOS em texto (pesquisar_referencia) pode, se o assunto pedir. ' + motion;
     }
     if (modo === 'fechado') {
         const t = termos(escopo);
@@ -77,8 +87,9 @@ function instrucao({ modo, escopo } = ATUAL) {
             + `No roteiro, ponha roteiro.busca = ${JSON.stringify(t)} para o b-roll.`;
     }
     if (modo === 'aberto') {
-        return '[REFERÊNCIAS: ESCOPO ABERTO] Pesquise o assunto à vontade (pesquisar_referencia; estudio_site se for de uma marca) '
-            + 'e dê em cada parte do roteiro um "busca" em inglês com o que mostrar de fundo — gente, lugar, tela, objeto de verdade.';
+        return '[REFERÊNCIAS: ESCOPO ABERTO — a pessoa pediu imagens] Pesquise o assunto à vontade (pesquisar_referencia; estudio_site se for de uma marca). '
+            + 'A imagem é um elemento da narrativa, não o vídeo inteiro: dê "busca" (em inglês: gente, lugar, tela, objeto de verdade) '
+            + 'SÓ nas partes em que uma imagem real mostra o que o texto não mostra. Não troque de imagem a cada frase; o resto é motion.';
     }
     return '';
 }
@@ -102,4 +113,4 @@ function filtrar(r, { modo, escopo } = ATUAL) {
     return { ...r, fontes: refs.length, referencias: refs, ...(fora ? { foraDoEscopo: fora } : {}) };
 }
 
-module.exports = { definir, atual, limpar, termos, entender, inferir, instrucao, dominios, filtrar };
+module.exports = { definir, atual, limpar, semImagem, termos, entender, inferir, instrucao, dominios, filtrar };

package/lib/estudio/remotion.js

@@ -719,6 +719,8 @@ export const Video = () => {
                 return vs[vs.length - 1].v; }
             : (plano.audio.trilha.volume ?? 0.18)}
           loop={plano.audio.trilha.loop !== false}
+          /* O início da faixa que casa as batidas com os cortes (batida.js). */
+          startFrom={Math.round((plano.audio.trilha.inicio || 0) * fps)}
         />
       )}
       {/* Os TRECHOS: pedaços de áudio no tempo certo — a narração partida entre

package/lib/estudio/revisor.js

@@ -0,0 +1,117 @@
+/**
+ * revisor.js — a revisão do plano antes do render: o olho de editor que
+ * procura receita, excesso e pressa, e conserta o que dá sem perguntar.
+ *
+ *   "Antes de finalizar, procure padrões repetitivos, escolhas previsíveis,
+ *    templates rígidos, excesso de efeitos, excesso de imagens, cortes
+ *    artificiais, problemas de ritmo." (Joel, 07/10)
+ *
+ * plano.js confere se o plano RODA; este confere se ele está BOM. O que tem
+ * conserto seguro é consertado aqui (e dito); o que pede decisão vira aviso,
+ * que vai para o agente e para as notas do projeto:
+ *   conserta  a mesma transição 3+ vezes seguidas      → a do meio vira corte seco
+ *   conserta  o MESMO efeito sonoro colado nele (< 0,3 s) → fica um (camadas de sons diferentes são desenho, ficam)
+ *   conserta  câmera mexendo em 4 cenas seguidas       → a mais fraca para (respiro)
+ *   avisa     texto que não dá tempo de ler (0,3 s/palavra, mínimo 0,8 s)
+ *   avisa     a mesma sequência de elementos em 4+ cenas seguidas (cara de template)
+ *   avisa     imagem sem a pessoa pedir, ou imagem em mais da metade das cenas
+ *   conserta  efeito sonoro demais (mais de 1 a cada 1,5 s) → ficam os mais altos
+ * Puro: o plano entra, o plano consertado e a lista saem.
+ */
+
+'use strict';
+
+const r2 = (n) => Math.round(n * 100) / 100;
+
+const tipoDaTransicao = (c) => (c && c.transicao ? (c.transicao.tipo || c.transicao) : 'corte');
+const mexe = (cam) => {
+    if (!cam) return false;
+    return Object.values(cam).some((ks) => Array.isArray(ks) && ks.length > 1 && ks.some((k) => Math.abs(Number(k.v) - Number(ks[0].v)) > 0.005));
+};
+const forcaDaCamera = (cam) => Math.max(0, ...Object.values(cam || {}).filter(Array.isArray)
+    .map((ks) => Math.max(...ks.map((k) => Number(k.v) || 0)) - Math.min(...ks.map((k) => Number(k.v) || 0))));
+const palavras = (t) => String(t || '').split(/\s+/).filter(Boolean).length;
+// Imagem ou vídeo DE FORA: o vídeo da própria gravação (deOrigem) e o recorte da pessoa não contam.
+const imagemDeFora = (el) => el && (el.tipo === 'imagem' || (el.tipo === 'video' && el.deOrigem == null && !/pessoa-/.test(el.src || '')));
+
+function revisar(plano, { semImagem = false } = {}) {
+    const consertos = [], avisos = [];
+    const cenas = (plano && plano.cenas) || [];
+    if (!cenas.length) return { plano, consertos, avisos };
+
+    // 1. A mesma transição (que não seja corte seco) 3+ vezes seguidas: receita.
+    for (let i = 2; i < cenas.length; i++) {
+        const t = tipoDaTransicao(cenas[i]);
+        if (t !== 'corte' && t === tipoDaTransicao(cenas[i - 1]) && t === tipoDaTransicao(cenas[i - 2])) {
+            cenas[i - 1].transicao = { tipo: 'corte' };
+            consertos.push(`cena ${i}: "${t}" 3 vezes seguidas — a do meio virou corte seco`);
+        }
+    }
+
+    // 2. Câmera mexendo em 4 cenas seguidas: a de movimento mais fraco para.
+    for (let i = 3; i < cenas.length; i++) {
+        const janela = [i - 3, i - 2, i - 1, i];
+        if (janela.every((k) => mexe(cenas[k].camera))) {
+            const k = janela.filter((j) => j > 0 && !cenas[j].impacto)   // a abertura (o gancho) e o golpe não param
+               
+                // Empate: a mais à frente — parar a primeira da janela fazia a janela seguinte pedir outra, e paravam todas (08/10).
+                .sort((a, b) => forcaDaCamera(cenas[a].camera) - forcaDaCamera(cenas[b].camera) || b - a)[0];
+            if (k == null) continue;
+            const cam = cenas[k].camera;
+            for (const prop of Object.keys(cam)) if (Array.isArray(cam[prop]) && cam[prop].length) cam[prop] = [{ t: 0, v: cam[prop][0].v }, { t: 1, v: cam[prop][0].v }];
+            consertos.push(`cena ${k + 1}: 4 cenas seguidas com a câmera mexendo — esta respira`);
+        }
+    }
+
+    // 3. Efeitos sonoros: colados um no outro, fica o mais alto; e a densidade.
+    const efeitos = ((plano.audio && plano.audio.efeitos) || []).slice().sort((a, b) => (a.t || 0) - (b.t || 0));
+    if (efeitos.length) {
+        const fica = [];
+        for (const e of efeitos) {
+            const ult = fica[fica.length - 1];
+            if (ult && e.src === ult.src && (e.t || 0) - (ult.t || 0) < 0.3) {
+                if ((e.volume ?? 1) > (ult.volume ?? 1)) fica[fica.length - 1] = e;
+                consertos.push(`efeito em ${r2(e.t || 0)}s colado no de ${r2(ult.t || 0)}s — ficou um`);
+            } else fica.push(e);
+        }
+        const total = cenas.reduce((n, c) => n + (Number(c.duracao) || 0), 0);
+        /* Som demais vira ruído: acima de 1 a cada 1,5 s, ficam os mais altos
+           (o desenho de som marca o mais importante com volume), um a cada 0,7 s. */
+        let final = fica;
+        if (total > 0 && fica.length / total > 1 / 1.5) {
+            const teto = Math.max(1, Math.floor(total / 1.5));
+            const guardados = [];
+            for (const e of fica.slice().sort((a, b) => (b.volume ?? 1) - (a.volume ?? 1))) {
+                if (guardados.length >= teto) break;
+                if (guardados.every((g) => Math.abs((g.t || 0) - (e.t || 0)) >= 0.7)) guardados.push(e);
+            }
+            final = guardados.sort((a, b) => (a.t || 0) - (b.t || 0));
+            consertos.push(`${fica.length} efeitos sonoros em ${r2(total)}s eram ruído — ficaram os ${final.length} mais fortes`);
+        }
+        plano.audio.efeitos = final;
+    }
+
+    // 4. Texto que não dá tempo de ler.
+    cenas.forEach((c, i) => {
+        const n = (c.elementos || []).filter((e) => e && e.tipo === 'texto').reduce((s, e) => s + palavras(e.texto), 0);
+        const precisa = Math.max(0.8, 0.3 * n);
+        if (n && Number(c.duracao) < precisa) avisos.push(`cena ${i + 1}: ${n} palavras em ${c.duracao}s (precisa de ${r2(precisa)}s para ler)`);
+    });
+
+    // 5. A mesma sequência de elementos em 4+ cenas seguidas: cara de template.
+    const assinatura = (c) => (c.elementos || []).map((e) => e && (e.tipo + (e.peca ? ':' + e.peca : ''))).join(',');
+    for (let i = 0, j = 1; j <= cenas.length; j++) {
+        if (j < cenas.length && assinatura(cenas[j]) === assinatura(cenas[i])) continue;
+        if (j - i >= 4 && assinatura(cenas[i])) avisos.push(`cenas ${i + 1} a ${j}: a mesma montagem (${assinatura(cenas[i])}) ${j - i} vezes seguidas — varie a composição`);
+        i = j;
+    }
+
+    // 6. Imagem: sem pedido, nenhuma; com pedido, não em toda cena.
+    const comImagem = cenas.filter((c) => (c.elementos || []).some(imagemDeFora) || (c.fundo && (c.fundo.tipo === 'imagem' || c.fundo.tipo === 'video'))).length;
+    if (semImagem && comImagem) avisos.push(`${comImagem} cena(s) com imagem de fora, mas a pessoa não pediu imagem`);
+    else if (cenas.length >= 4 && comImagem / cenas.length > 0.5) avisos.push(`imagem em ${comImagem} de ${cenas.length} cenas — a imagem é um momento, não o vídeo inteiro`);
+
+    return { plano, consertos, avisos };
+}
+
+module.exports = { revisar };

package/lib/estudio/variedade.js

@@ -21,23 +21,75 @@ 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 };
+const MEMORIA = { trilha: 16, sfx: 40, broll: 80, icones: 4, estilo: 8, '3d': 24, 'icone-nome': 30, 'paleta-fluido': 6 };
+
+/* 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);
+        // 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 +99,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 +233,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]}'`);