primocode 11.3.3 → 11.5.0

package/lib/plugin/estudio/kit-ae/destrava.jsx

@@ -0,0 +1,211 @@
+/*  destrava.jsx — as PEÇAS do vídeo do Destrava (Remotion, destrava-essencial-pc/video/src/scenes/Kinetic.tsx) como componentes do motor.
+
+    O plano de motion (motion-plano) aciona cada peça por cena com `d.dz`:
+      frase  texto que se monta palavra a palavra na hora da fala; a palavra-chave em DEGRADÊ (P.ac -> P.ac2) letra a letra.
+             d.modo: suave (palavra-a-palavra: sobe + desfoca, como o Word.tsx) · escala (nasce grande e assenta) · mascara (a linha varre).
+      cor    quadro de cor cheia: o círculo de cor cresce do centro (clip circle do S8), com a frase por cima.
+      foto   cartão de foto arredondado (raio 36, sombra funda): voa em 3D e passeia; com 2+ fotos vira carrossel.
+      marca  o fecho: a marca REAL (logo do kit ou o nome) em degradê, só na última cena.
+    Tudo lê a pele da cena (P: bg, fg, ac, ac2, fontes), nunca cor fixa. Tempos e curvas vêm do style.json / Kinetic.tsx do Destrava:
+    palavra: 12 quadros, desfoque 10, sobe 0,28·tam, mola (11, 140, 0,7); cartão: 24 quadros, sobe, gira 12°, escala de 0,92. */
+
+function kDCor2(P) { return P.ac2 || P.ac; }
+/* a palavra em degradê: uma camada por letra, cada uma da cor do degradê naquele ponto (o After Effects do kit não pinta texto com rampa) */
+function kDLetras(comp, str, o) {
+    var tam = o.tam, fonte = o.fonte, x0 = o.x - o.w / 2, i, cam = [], advAnt = 0, n = str.length;
+    var xRef = kMedir(comp, 'x', fonte, tam, o.trk);
+    for (i = 0; i < n; i++) {
+        var advFim = kMedir(comp, str.substr(0, i + 1) + 'x', fonte, tam, o.trk) - xRef;
+        var xc = x0 + (advAnt + advFim) / 2, cor = kMisturar(o.c1, o.c2, n > 1 ? i / (n - 1) : 0);
+        var L = comp.layers.addText(str.charAt(i)); L.name = 'dz-letra ' + str.charAt(i);
+        if (o.parent) kPai(L, o.parent);
+        kDoc(L, fonte, tam, cor, { tracking: o.trk });
+        kP(L).setValue([xc, o.y]);
+        cam.push({ L: L, x: xc, w: advFim - advAnt });
+        advAnt = advFim;
+    }
+    return cam;
+}
+/* escurece a cor até ler sobre o fundo (contraste ≥ 3,5): o degradê sobre o centro claro do quadro de cor */
+function kDLegivel(cor, fundo) { var k = 0; while (k < 0.9 && kContr(kMisturar(cor, '#000000', k), fundo) < 3.5) k += 0.1; return kMisturar(cor, '#000000', k); }
+function kDEntra(comp, L, modo, ti, x, y, w, tam, idx, txt) {
+    kMarcaEntrada(ti);
+    L.comment = ti.toFixed(3);
+    if (modo == 'mascara') { kAnimaPalavra(comp, L, 'mascara', ti, x, y, w, tam, 0, idx, txt); return; }
+    if (modo == 'escala') {
+        mola(kS(L), ti, [165, 165], [100, 100], { quique: 0.35, dur: 0.7 });
+        curva(kO(L), [[ti, 0, null, 30], [ti + 0.2, 100, 60, null]]);
+        kBlur(L, 9, 0, ti, 0.42);
+        return;
+    }
+    // suave: cinza -> tinta não existe aqui (a cor já é a final); sobe 0,28·tam numa mola mansa e sai do desfoque em ~0,4 s
+    mola(kP(L), ti, [x, y + tam * 0.28], [x, y], { quique: 0.2, dur: 0.62 });
+    curva(kO(L), [[ti, 0, null, 30], [ti + 0.4, 100, 60, null]]);
+    kBlur(L, 10, 0, ti, 0.4);
+}
+/* kDFrase(comp, P, str, o): {cx, cy, tam, maxW, parent, t0, modo, cor, passo, maxLinhas}. Devolve {fim, h, tam, tempos}. */
+function kDFrase(comp, P, str, o) {
+    var fonte = P.fonteTitulo, trk = -20, pal = kPalavras(str), i, tam = o.tam, ws, sw, linhas, tent = 0, ts = [], kwMais = 1.18, tamMax = tam;
+    if (!pal.length) return { fim: o.t0 || 0, h: 0, tam: tam, tempos: [] };
+    var maxW = o.maxW, maxLin = o.maxLinhas || 3;
+    for (;;) {
+        // a palavra-chave é maior que o resto da frase (o herói do Destrava); frase de uma palavra só fica como está
+        ts = []; tamMax = tam; for (i = 0; i < pal.length; i++) { ts.push(pal[i].kw && pal.length > 1 ? Math.min(tam * Math.min(kwMais, Math.max(1, 0.98 * maxW / Math.max(1, kMedir(comp, pal[i].t, fonte, tam, trk)))), 410 * (o.u || 1)) : tam); if (ts[i] > tamMax) tamMax = ts[i]; }
+        ws = []; for (i = 0; i < pal.length; i++) ws.push(kMedir(comp, pal[i].t, fonte, ts[i], trk));
+        sw = Math.max(tam * 0.27, kMedir(comp, 'a a', fonte, tam, trk) - kMedir(comp, 'aa', fonte, tam, trk));
+        var mx = 0; for (i = 0; i < ws.length; i++) if (ws[i] > mx) mx = ws[i];
+        linhas = kQuebra(ws, sw, maxW);
+        if (linhas.length > 1) {   // linhas de tamanho parecido
+            var tot = 0; for (i = 0; i < ws.length; i++) tot += ws[i] + sw;
+            var l2 = kQuebra(ws, sw, Math.min(maxW, Math.max(mx, tot / linhas.length * 1.12)));
+            if (l2.length <= linhas.length) linhas = l2;
+        }
+        if ((mx <= maxW && linhas.length <= maxLin) || tent > 16 || tam * 0.92 < (o.min || 40)) break;
+        tam *= 0.92; tent++;
+    }
+    var lh = tamMax * 1.12, bloco = linhas.length * lh, l, k, idx = 0, lastT = o.t0 || 0, tempos = [], fim = o.t0 || 0, passo = o.passo || 0.16;
+    for (l = 0; l < linhas.length; l++) {
+        var lw = 0; for (k = 0; k < linhas[l].length; k++) lw += ws[linhas[l][k]] + (k ? sw : 0);
+        var xs = o.cx - lw / 2, yb = o.cy - bloco / 2 + lh * l + lh * 0.5 + tamMax * 0.33;
+        for (k = 0; k < linhas[l].length; k++) {
+            var j = linhas[l][k], w = ws[j], xc = xs + w / 2; xs += w + sw;
+            var ti = (o.t0 || 0) + idx * passo;
+            if (KIT.voz) { var tv = kFalaBusca(pal[j].t); ti = tv != null ? tv : Math.max(lastT + 0.08, 0.25); }
+            lastT = ti;
+            if (pal[j].kw) {
+                var ls = kDLetras(comp, pal[j].t, { tam: ts[j], fonte: fonte, x: xc, y: yb, w: w, parent: o.parent, c1: o.c1 || P.ac, c2: o.c2 || kDCor2(P), trk: trk }), q;
+                for (q = 0; q < ls.length; q++) kDEntra(comp, ls[q].L, o.modo, ti + (o.modo == 'mascara' ? 0 : q * 0.022), ls[q].x, yb, ls[q].w, ts[j], idx, pal[j].t.charAt(q));
+            } else {
+                var L = comp.layers.addText(pal[j].t); L.name = 'dz-palavra ' + pal[j].t;
+                if (o.parent) kPai(L, o.parent);
+                kDoc(L, fonte, tam, o.cor || P.fg, { tracking: trk });
+                kP(L).setValue([xc, yb]);
+                kDEntra(comp, L, o.modo, ti, xc, yb, w, ts[j], idx, pal[j].t);
+            }
+            tempos.push(ti); fim = Math.max(fim, ti + 0.45); idx++;
+        }
+    }
+    var wMax = 0; for (l = 0; l < linhas.length; l++) { var lw2 = 0; for (k = 0; k < linhas[l].length; k++) lw2 += ws[linhas[l][k]] + (k ? sw : 0); if (lw2 > wMax) wMax = lw2; }
+    return { fim: fim, h: bloco, w: wMax, tam: tam, tamMax: tamMax, tempos: tempos };
+}
+function kDPasso(comp, n) { return Math.max(0.12, Math.min(0.3, (comp.duration * 0.5) / Math.max(1, n))); }
+/* o brilho rosado sutil do fundo creme (a pele do Destrava): um círculo de luz do destaque, bem fraco, embaixo; só quando a pele é a do Destrava */
+function kDBrilho(comp, P, g) {
+    if (!(KIT.pele == 'destrava')) return;
+    var s = comp.layers.addSolid(kCor(P.bg), 'brilho-creme', g.W, g.H, 1);
+    try {
+        var rp = kFx(s, 'ADBE Ramp');
+        rp.property('ADBE Ramp-0001').setValue([g.cx, g.H * 0.8]); rp.property('ADBE Ramp-0002').setValue(kCor(kMisturar(P.bg, P.ac, 0.09)));
+        rp.property('ADBE Ramp-0003').setValue([g.cx, g.H * 0.8 + Math.max(g.W, g.H) * 0.62]); rp.property('ADBE Ramp-0004').setValue(kCor(P.bg));
+        rp.property('ADBE Ramp-0005').setValue(2);
+    } catch (e) { }
+}
+function kDModo(d) { return d.modo == 'mascara' || d.modo == 'escala' ? d.modo : 'suave'; }
+function kDTam(d, g) { return Math.max(70, Math.min(430, (d.tam || 200) * g.u)); }
+
+// ---------------------------------------------------------------- frase
+function cenaDFrase(comp, P, d) {
+    var g = kPre(comp, P), W = g.W, H = g.H, cam = g.cam, n = kPalavras(d.titulo || '').length;
+    kDBrilho(comp, P, g);
+    var r = kDFrase(comp, P, d.titulo || '', { cx: g.cx, cy: g.v ? H * 0.44 : g.cy, tam: kDTam(d, g), min: Math.min(kDTam(d, g), 150 * g.u), u: g.u, maxW: W * (1 - 2 * KIT.MX) * 0.98, parent: cam.no, t0: 0.14, modo: kDModo(d), passo: kDPasso(comp, n) });
+    if (r.tempos.length) { som(r.tempos[0], 'pop', 0.5); if (r.tempos.length > 3) som(r.tempos[r.tempos.length - 1], 'tique', 0.35); }
+    KIT.rects.push({ espaco: 't', cena: KIT.cenaIdx, x0: g.cx - r.w / 2, x1: g.cx + r.w / 2, y0: (g.v ? H * 0.44 : g.cy) - r.h / 2, y1: (g.v ? H * 0.44 : g.cy) + r.h / 2, t0: 0, t1: 1, tam: r.tam, texto: false, livre: true, sobrepoe: true, nome: 'frase' });
+    cam.empurra(0.6, 0, 0, 1.0).empurra(comp.duration - 0.2, 0, 0, 1.06);
+    fecha(comp);
+}
+
+// ---------------------------------------------------------------- quadro de cor cheia (o círculo de cor cresce, como o card do S8)
+function cenaDCor(comp, P, d) {
+    var g = kPre(comp, P), W = g.W, H = g.H, cam = g.cam, cy = g.v ? H * 0.44 : g.cy, n = kPalavras(d.titulo || '').length;
+    var centro = kMisturar(P.ac, '#FFFFFF', 0.82), borda = kMisturar(kDCor2(P), '#000000', 0.18);
+    var s = comp.layers.addSolid(kCor(P.ac), 'fundo-cor', W, H, 1);
+    try {
+        var rp = kFx(s, 'ADBE Ramp');
+        rp.property('ADBE Ramp-0001').setValue([g.cx, cy]); rp.property('ADBE Ramp-0002').setValue(centro);
+        rp.property('ADBE Ramp-0003').setValue([g.cx, cy + Math.max(W, H) * 0.62]); rp.property('ADBE Ramp-0004').setValue(borda);
+        rp.property('ADBE Ramp-0005').setValue(2);
+    } catch (e) { }
+    var m = s.property('ADBE Mask Parade').addProperty('ADBE Mask Atom'), mp = m.property('ADBE Mask Shape'), R = Math.sqrt(W * W + H * H);
+    mp.setValueAtTime(kFrame(0.05), kCircShape(g.cx, cy, 4)); mp.setValueAtTime(kFrame(0.05) + 0.55, kCircShape(g.cx, cy, R * 0.62));
+    var ink = kContr(centro, P.fg) >= 4.5 ? P.fg : (kLum(centro) > 0.5 ? '#14110F' : '#FFFFFF');
+    var r = kDFrase(comp, P, d.titulo || '', { cx: g.cx, cy: cy, tam: kDTam(d, g), min: Math.min(kDTam(d, g), 150 * g.u), u: g.u, maxW: W * (1 - 2 * KIT.MX) * 0.98, parent: cam.no, t0: 0.4, modo: d.modo == 'mascara' ? 'mascara' : 'escala', cor: ink, c1: kDLegivel(P.ac, centro), c2: kDLegivel(kDCor2(P), centro), passo: kDPasso(comp, n) });
+    som(0.1, 'sobe', 0.5); if (r.tempos.length) som(r.tempos[0], 'pop', 0.6);
+    cam.empurra(0.6, 0, 0, 1.0).empurra(comp.duration - 0.2, 0, 0, 1.05);
+    fecha(comp);
+}
+
+// ---------------------------------------------------------------- cartão de foto arredondado (+ carrossel)
+function kDCartao(comp, P, arq, w, h, u, t0, dur, zoomDe, zoomPara) {
+    var it = kFotoImp(arq);
+    if (!it) return null;
+    var inner = novaComp('dz-foto ' + KIT.cenaIdx + ' ' + Math.round(w), Math.round(w), Math.round(h), dur, KIT.fps), ease = [60, 60];
+    var im = inner.layers.add(it); im.name = 'foto-img';
+    var ki = Math.max(w / it.width, h / it.height) * 100;
+    kP(im).setValue([w / 2, h / 2]);
+    curva(kS(im), [[0, [ki * zoomDe, ki * zoomDe], ease[0], ease[1]], [dur, [ki * zoomPara, ki * zoomPara], ease[0], ease[1]]]);
+    var card = comp.layers.add(inner); card.name = 'dz-cartao';
+    kMascaraRect(card, 0, 0, w, h, 36 * u);
+    return card;
+}
+function cenaDFoto(comp, P, d) {
+    var g = kPre(comp, P), W = g.W, H = g.H, u = g.u, cam = g.cam, dur = comp.duration, F = d.foto, T0 = 0.1, i, sg = d.sentido || 1;
+    kDBrilho(comp, P, g);
+    if (!F || !F.arquivo) { KIT.avisos.push('cena ' + KIT.cenaIdx + ': sem foto, a cena virou frase'); return cenaDFrase(comp, P, d); }
+    var todas = [F], outras = KIT.fotos || [];
+    for (i = 0; i < outras.length && todas.length < 4; i++) if (outras[i] && outras[i].arquivo && outras[i].arquivo != F.arquivo) todas.push(outras[i]);
+    var carrossel = todas.length >= 2, cw = g.v ? W * (carrossel ? 0.7 : 0.88) : W * 0.4, ch = g.v ? H * (carrossel ? 0.4 : 0.5) : H * 0.62, cy = g.v ? H * 0.4 : g.cy;
+    var gap = cw * 1.1, x0 = g.cx, cards = [], c;
+    for (i = 0; i < todas.length; i++) {
+        c = kDCartao(comp, P, todas[i].arquivo, cw, ch, u, T0, dur, 1.04, 1.1 + 0.02 * i);
+        if (!c) continue;
+        kPai(c, cam.no); kS(c).setValue([100, 100]);
+        var sombra = forma(comp, 'retangulo', { x: 0, y: 0, w: cw, h: ch, r: 36 * u, cor: '#000000', alfa: 38, parent: cam.no, nome: 'sombra-foto' });
+        kFx(sombra, 'ADBE Gaussian Blur 2').property('ADBE Gaussian Blur 2-0001').setValue(38 * u);
+        cards.push({ c: c, s: sombra, i: i });
+    }
+    for (i = 0; i < cards.length; i++) {
+        c = cards[i];
+        var xa = x0 + (i - 0) * gap * sg, xb = x0 + (i - (cards.length - 1) * 0.0) * gap * sg;
+        if (carrossel) {   // o carrossel anda: cada cartão passa pelo centro, ease, sem parar
+            var passo = (cards.length - 1) * gap, ini = x0 + i * gap, fim = ini - passo * 0.62;
+            curva(kP(c.c), [[0, [ini * 1, cy], 60, 60], [dur, [fim, cy], 60, 60]]);
+            curva(kP(c.s), [[0, [ini, cy + 34 * u], 60, 60], [dur, [fim, cy + 34 * u], 60, 60]]);
+        } else {
+            // um cartão: voa de longe (X +300, Y 8°, gira -38°) e assenta; depois a câmera cresce 5% (S4)
+            mola(kP(c.c), T0, [x0 + W * 0.3, cy], [x0, cy], { quique: 0.3, dur: 0.75 });
+            kP(c.s).setValue([x0, cy + 34 * u]);
+            curva(kO(c.s), [[T0, 0, null, 30], [T0 + 0.5, 38, 60, null]]);
+            curva(kS(c.c), [[T0, [92, 92], 60, 60], [T0 + 0.7, [100, 100], 60, 60], [dur, [105, 105], 60, 60]]);
+        }
+        curva(kO(c.c), [[T0, 0, null, 30], [T0 + 0.28, 100, 60, null]]);
+        try {
+            c.c.threeDLayer = true;
+            if (carrossel) curva(kRot(c.c, 'Y'), [[0, -16 * sg, 60, 60], [dur, 16 * sg, 60, 60]]);
+            else { curva(kRot(c.c, 'Y'), [[T0, -38 * sg, 60, 60], [T0 + 0.8, 0, 60, 60]]); curva(kRot(c.c, 'X'), [[T0, 8, 60, 60], [T0 + 0.8, 0, 60, 60]]); }
+        } catch (e) { KIT.avisos.push('cena ' + KIT.cenaIdx + ': 3D da foto indisponível'); }
+    }
+    som(T0, 'impacto', 0.5); som(T0 + 0.45, 'sobe', 0.4);
+    var n = kPalavras(d.titulo || '').length;
+    if (d.titulo) kDFrase(comp, P, d.titulo, { cx: g.cx, cy: g.v ? H * 0.76 : g.cy, tam: Math.min(kDTam(d, g), 150 * u), min: 56 * u, u: u, maxW: g.v ? W * 0.84 : W * 0.4, parent: cam.no, t0: T0 + 0.5, modo: 'suave', passo: kDPasso(comp, n), maxLinhas: 2 });
+    cam.empurra(0.8, 0, 0, 1.0).empurra(comp.duration - 0.2, 0, 0, 1.04);
+    fecha(comp);
+}
+
+// ---------------------------------------------------------------- fecho com a marca real
+function cenaDMarca(comp, P, d) {
+    var g = kPre(comp, P), W = g.W, H = g.H, u = g.u, cam = g.cam, marca = d.botao || '', T0 = 0.15, yM = g.v ? H * 0.4 : g.cy * 0.8;
+    kDBrilho(comp, P, g);
+    var fimM = T0;
+    if (d.logo) {   // a logo real do kit de marca, revelada por varredura (S9)
+        imagem(comp, d.logo, { x: g.cx, y: yM, w: W * 0.7, h: W * 0.7 * 0.35, parent: cam.no, nome: 'dz-logo', entrada: 'sobe', t0: T0 });
+        fimM = T0 + 0.6;
+    } else if (marca) {
+        var rm = kDFrase(comp, P, '*' + marca.replace(/\*/g, '') + '*', { cx: g.cx, cy: yM, tam: 260 * u, maxW: W * 0.84, parent: cam.no, t0: T0, modo: 'mascara', maxLinhas: 2, passo: 0.2 });
+        fimM = rm.fim;
+    }
+    var n = kPalavras(d.titulo || '').length, sem = d.titulo ? d.titulo.replace(/\*/g, '') : '';
+    if (sem) kDFrase(comp, P, sem, { cx: g.cx, cy: g.v ? H * 0.62 : g.cy * 1.3, tam: 110 * u, min: 56 * u, u: u, maxW: W * 0.84, parent: cam.no, t0: Math.max(T0 + 0.5, fimM * 0.7), modo: 'suave', cor: P.fg, passo: kDPasso(comp, n), maxLinhas: 2 });
+    som(T0, 'pop', 0.6);
+    cam.empurra(0.6, 0, 0, 1.0).empurra(comp.duration - 0.2, 0, 0, 1.05);
+    fecha(comp);
+}

package/lib/plugin/estudio/maquina-diretor.js

@@ -354,7 +354,7 @@ function montarDirecao({ args, assunto, meta, duracao, hist, rnd, temElemento })
         cenas.push({ c, tipo, papel });
     });
     // a FOTO do pedido: pelo menos uma cena "foto" (a de abertura e/ou a de destaque), nunca duas coladas
-    if (nFotosPedido > 0) colocarFotos(cenas, nFotosPedido);
+    if (nFotosPedido > 0 && !args._planoDasEtapas) colocarFotos(cenas, nFotosPedido);   // com o plano das etapas, quem põe foto é o plano
     // o assunto aparece em OBJETOS: pelo menos 2 cenas com primitiva que usa o elemento real (as que o modelo fixou ficam como estão)
     if (temElemento) {
         const nao = new Set(meta.nao || []);

package/lib/plugin/estudio/maquina-elementos.js

@@ -105,7 +105,7 @@ function termosDoAssunto({ assunto, pedidos = [], meta = null }) {
  * Reúne `minimo` a `max` elementos reais. `deps.icone3d/animacao` são injetáveis (testes). Nunca lança.
  * Devolve {ok, elementos, creditos, faltou}.
  */
-async function reunir({ assunto, pedidos = [], meta = null, pasta, minimo = 3, max = 6, rede = true, logos = [], site = null, animados = true, deps = {} } = {}) {
+async function reunir({ assunto, pedidos = [], meta = null, pasta, minimo = 3, max = 6, rede = true, logos = [], site = null, animados = true, reserva = true, deps = {} } = {}) {
     if (!pasta) return { ok: false, error: 'faltou a pasta do projeto.', elementos: [] };
     const ic3 = deps.icone3d || icone3d, an = deps.animacao || animacao;
     const termos = termosDoAssunto({ assunto, pedidos, meta });
@@ -122,7 +122,7 @@ async function reunir({ assunto, pedidos = [], meta = null, pasta, minimo = 3, m
         if (animados && rede && meta && meta.animado) {
             for (const t of meta.animado.slice(0, 1)) { const e = await an(t, pasta).catch(() => null); if (tem(e) && elementos.length < max + 1) elementos.push(e); }
         }
-        for (const t of ['sparkles', 'star', 'check mark button', 'light bulb']) {   // última reserva: ainda é "real", só menos específico
+        for (const t of (reserva ? ['sparkles', 'star', 'check mark button', 'light bulb'] : [])) {   // reserva: false = nada de enfeite sem relação com o assunto   // última reserva: ainda é "real", só menos específico
             if (elementos.length >= minimo) break;
             const e = await ic3(t, pasta).catch(() => null); if (tem(e)) elementos.push(e);
         }

package/lib/plugin/estudio/maquina.js

@@ -87,20 +87,33 @@ function cartaoDestaque(bg, fg, ac, brilho) {
     return { cardAc: cor, sobreCardAc: melhorCor(cor, [fg, bg, '#FFFFFF', '#14110F']) };
 }
 
+/** O segundo tom do degradê (palavra-chave): o destaque com o matiz girado ~-40°, igual magenta → índigo do Destrava; sem contraste de leitura, cai no meio-termo com a tinta. */
+function segundoTom(ac, bg, fg) {
+    const c = (rgb(ac) || [255, 255, 255]).map((v) => v / 255), mx = Math.max(...c), mn = Math.min(...c), l = (mx + mn) / 2, d = mx - mn;
+    if (d < 0.02) return misturar(ac, fg, 0.5);                       // cinza: sem matiz pra girar
+    const s = d / (1 - Math.abs(2 * l - 1));
+    let h = mx === c[0] ? ((c[1] - c[2]) / d) % 6 : mx === c[1] ? (c[2] - c[0]) / d + 2 : (c[0] - c[1]) / d + 4;
+    h = (((h * 60 - 40) % 360) + 360) % 360;
+    const k = (1 - Math.abs(2 * l - 1)) * s, x = k * (1 - Math.abs(((h / 60) % 2) - 1)), m = l - k / 2;
+    const [r, g, b] = h < 60 ? [k, x, 0] : h < 120 ? [x, k, 0] : h < 180 ? [0, k, x] : h < 240 ? [0, x, k] : h < 300 ? [x, 0, k] : [k, 0, x];
+    const out = hex([(r + m) * 255, (g + m) * 255, (b + m) * 255]);
+    return contraste(out, bg) >= 3 ? out : misturar(ac, fg, 0.5);
+}
+
 /** As 3 variações da paleta: normal, fundo profundo e fundo de destaque, sempre com contraste de leitura. */
 function variacoes(base) {
     const fundo = base.fundo, tinta = base.tinta, dest = base.destaque;
     const claroBg = luminancia(fundo) >= luminancia(tinta) ? fundo : tinta;
     const escuroBg = claroBg === fundo ? tinta : fundo;
-    const fix = (bg, fg, ac) => {
+    const fix = (bg, fg, ac, ac2Dado) => {
         if (contraste(fg, bg) < 4.5) fg = melhorCor(bg, ['#FFFFFF', '#111111']);
-        if (contraste(ac, bg) < 3) ac = melhorCor(bg, [dest, fg, tinta, fundo]);
+        if (contraste(ac, bg) < 3 && !(base.destaque2 && ac === dest)) ac = melhorCor(bg, [dest, fg, tinta, fundo]);   // a pele do Destrava (destaque2) mantém o rosa dela: 2,8:1 no creme, em texto enorme
         const mudo = misturar(bg, fg, 0.66);
         const brilho = misturar(bg, ac, 0.32);
-        return { bg, fg, ac, mudo: contraste(mudo, bg) >= 3 ? mudo : fg, card: misturar(bg, fg, 0.1), brilho, ...cartaoDestaque(bg, fg, ac, brilho) };
+        return { bg, fg, ac, ac2: ac2Dado && contraste(ac2Dado, bg) >= 3 ? ac2Dado : segundoTom(ac, bg, fg), mudo: contraste(mudo, bg) >= 3 ? mudo : fg, card: misturar(bg, fg, 0.1), brilho, ...cartaoDestaque(bg, fg, ac, brilho) };
     };
     return {
-        normal: fix(fundo, tinta, dest),
+        normal: fix(fundo, tinta, dest, base.destaque2),
         fundo: fix(escuroBg, claroBg, dest),
         destaque: (() => { const fg = melhorCor(dest, [claroBg, escuroBg]), ac = melhorCor(dest, [escuroBg, claroBg]); return fix(dest, contraste(fg, dest) >= 3 ? fg : melhorCor(dest, ['#FFFFFF', '#111111']), contraste(ac, dest) >= 3 ? ac : melhorCor(dest, ['#FFFFFF', '#111111'])); })(),
     };
@@ -171,6 +184,7 @@ function plano(args = {}, opc = {}) {
         fundo: rgb(cores.fundo) ? cores.fundo : base.fundo,
         tinta: rgb(cores.tinta) ? cores.tinta : base.tinta,
         destaque: rgb(cores.destaque) ? cores.destaque : base.destaque,
+        ...(args.pele === 'destrava' && rgb(cores.destaque2) ? { destaque2: cores.destaque2 } : {}),
     };
     const v = variacoes(paleta);
     // o ciclo de fundos: o fundo da marca domina; o de destaque e o invertido entram de contraponto (nunca iguais em fila)
@@ -183,6 +197,7 @@ function plano(args = {}, opc = {}) {
         if (i === cenas.length - 1 && cenas.length > 3) p = i > 0 && cenas[i - 1].pal.bg === F.bg ? (cenas[i - 1].pal.bg !== N.bg ? N : D) : F;   // o CTA fecha no fundo invertido, a não ser que a cena anterior já o use
         c.pal = { ...p };
     });
+    if (args.pele === 'destrava') cenas.forEach((c) => { c.pal = { ...N }; });   // a pele do Destrava: todo quadro no creme; a cor entra só no quadro de cor cheia e no degradê
     cenas.forEach((c, i) => { if (cenas[i + 1]) c.proxBg = cenas[i + 1].pal.bg; });
 
     const tip = diretor.TIPOGRAFIAS[dir.tipografia];
@@ -193,7 +208,7 @@ function plano(args = {}, opc = {}) {
     cenas.forEach((c) => { const e = (diretor.PRIMITIVAS[c.tipo] || {}).entra || 2; c.f = Math.round(Math.max(1, Math.min(2.2, e / (0.36 * c.dur))) * 100) / 100; c.elemento = !!(diretor.PRIMITIVAS[c.tipo] || {}).elemento; });
     const duracao = Math.round(cenas.reduce((s, c) => s + c.dur, 0) * 100) / 100;
     cenas.forEach((c, i) => { c.inicio = Math.round(cenas.slice(0, i).reduce((s, x) => s + x.dur, 0) * 1000) / 1000; });
-    return { w, h, fps: 30, formato, fontes, tipo, paleta, trocas: dir.trocas, cenas, ajuste: 1, receita: receita ? receita.id : null, duracao,
+    return { w, h, fps: 30, formato, fontes, tipo, paleta, pele: args.pele === 'destrava' ? 'destrava' : null, trocas: dir.trocas, cenas, ajuste: 1, receita: receita ? receita.id : null, duracao,
         camera: dir.camera, elementos, fotos, bpm: 0, voz: null, legenda: null, direcao: dir.assinatura, semente: dir.semente, variacoes: v };
 }
 
@@ -253,7 +268,7 @@ function ajustarCortes(pl, batidas, { tolerancia = 0.28 } = {}) {
 const lerKit = (n) => fs.readFileSync(path.join(KIT, n), 'utf8');
 /** O JSX completo: o kit, a guarda de layout, as primitivas, as cenas e a chamada `montar(PLANO)`. */
 function script(pl) {
-    return lerKit('base.jsx') + '\n' + lerKit('guarda.jsx') + '\n' + lerKit('primitivas.jsx') + '\n' + lerKit('cenas.jsx') + '\nmontar(' + JSON.stringify(pl) + ');\n';
+    return lerKit('base.jsx') + '\n' + lerKit('guarda.jsx') + '\n' + lerKit('primitivas.jsx') + '\n' + lerKit('destrava.jsx') + '\n' + lerKit('cenas.jsx') + '\nmontar(' + JSON.stringify(pl) + ');\n';
 }
 /** Os tempos medidos de cada cena (início de cada uma e o instante de conferir). */
 function tempos(pl) {
@@ -354,6 +369,7 @@ async function acharTrilha(pasta, busca) {
 /** As fontes para o render: o peso que a família tem (as de peso único vão em 400). */
 const SO_400 = new Set(['Anton', 'Archivo Black', 'Instrument Serif', 'Bebas Neue', 'Caveat']);
 function fontesDoPlano(pl) {
+    if (pl.pele === 'destrava') return [{ familia: 'Inter', peso: 800 }];     // a pele do Destrava é Inter 800 em tudo (o arquivo vai embutido, sem rede)
     const f = pl.fontes, it = pl.tipo && pl.tipo.realce === 'italico';
     const so = (fam) => SO_400.has(fam);
     return [
@@ -408,7 +424,9 @@ async function motion(args = {}, { pasta, receita = null, deps = {} } = {}) {
     const meta = diretor.achar(assunto + ' ' + (args.metafora || ''));
     const pedidos = Array.isArray(args.elementos) ? args.elementos : (args.elementos ? [args.elementos] : []);
     const reunir = deps.elementos || require('./maquina-elementos.js').reunir;
-    const el = await reunir({ assunto, pedidos, meta, pasta, rede: !semRede, logos: args.logos, site: args.site, minimo: 3, max: 6 });
+    // com o plano das etapas só entra elemento que o usuário pediu (elementos, logos, site): enfeite sem relação com o assunto (a estrela 3D de "última reserva") não entra
+    const soPedido = !!args._planoDasEtapas && !pedidos.length && !(args.logos && args.logos.length) && !args.site;
+    const el = soPedido ? { elementos: [] } : await reunir({ assunto, pedidos, meta, pasta, rede: !semRede, logos: args.logos, site: args.site, minimo: args._planoDasEtapas ? 0 : 3, max: 6, reserva: !args._planoDasEtapas });
     const elementos = (el && el.elementos) || [];
 
     // 2. a direção (primitivas, transições, câmera, tipografia, paleta) com semente e conferência de assinatura
@@ -418,7 +436,7 @@ async function motion(args = {}, { pasta, receita = null, deps = {} } = {}) {
     let pl = plano({ ...args, assunto, gosto: gostoP }, { receita, historico, elementos, fotos });
     const avisosDeMotor = fotosRecusadas.map((x) => 'foto recusada: ' + x.motivo);
     if (fotos.length && !pl.cenas.some((c) => c.tipo === 'foto')) avisosDeMotor.push('as fotos não entraram em nenhuma cena (o roteiro fixou todas as cenas com outro tipo).');
-    if (elementos.length < 3) avisosDeMotor.push(`só ${elementos.length} elemento(s) real(is) do assunto (o pedido é ≥ 3)`);
+    if (elementos.length < 3 && !soPedido) avisosDeMotor.push(`só ${elementos.length} elemento(s) real(is) do assunto (o pedido é ≥ 3)`);
 
     // 3. a narração (opcional) manda no tempo
     let voz = null;

package/lib/plugin/estudio/motion-plano/ajustar.js

@@ -0,0 +1,139 @@
+/**
+ * ajustar.js — etapa 1 do motion: AJUSTAR O PEDIDO.
+ *
+ * O pedido do usuário ("faz um motion pra minha barbearia") vira {objetivo, publico, tom, virada, fatos}.
+ * A virada é a frase que quebra a expectativa. Se falta algo essencial
+ * (foto real do assunto, marca, data), sai até 4 perguntas no formato do `perguntar` (pergunta + 2 a 4
+ * opções); quem responde é `ctx.escolher` (o mesmo picker do terminal). Sem terminal ou pulou: segue com o que tem.
+ */
+'use strict';
+
+const { pedirJson } = require('./llm.js');
+const Fatos = require('./fatos.js');
+
+const MAX_PERGUNTAS = 4;
+
+const SISTEMA = `Você é o diretor de criação de um estúdio de motion graphics em PT-BR. Recebe o pedido cru de um usuário leigo e o reescreve como briefing.
+Responda SÓ JSON:
+{"objetivo":"o que o vídeo precisa fazer acontecer (1 frase)",
+ "publico":"quem vai ver (1 frase)",
+ "tom":"3 a 5 palavras (ex.: direto, bem-humorado, confiante)",
+ "virada":"UMA frase curta que quebra a expectativa. Padrão: a pergunta que o público faria (ou o clichê do assunto) -> a resposta que quebra essa expectativa, específica DESTE assunto. Escreva a pergunta e a resposta juntas, com ' -> '. Invente a virada a partir do pedido; não reaproveite frase pronta.",
+ "fatos":{"datas":[],"nomes":[],"marca":"","local":"","oferta":"","outros":[]},
+ "faltando":[{"campo":"foto|marca|data|local|oferta|outro","pergunta":"pergunta curta em PT-BR","opcoes":[{"label":"resposta curta","desc":"o que acontece se escolher"}]}]}
+Regras:
+- "fatos" só leva o que o usuário DISSE. Nunca invente data, nome, preço, endereço ou número. O que não foi dito fica vazio.
+- "virada" vira a DOR ou o clichê do público, nunca afirma coisa nova sobre o negócio: NÃO diga que está cheio, que é o melhor, que tem fila, promoção ou qualidade. A resposta da virada nunca inventa lotação, preço, data, número ou diferencial.
+- "faltando": só o que é ESSENCIAL e muda o vídeo (foto real do assunto, nome da marca, data/hora, local). No máximo ${MAX_PERGUNTAS} itens, cada um com 2 a 4 opções (a primeira é a recomendada). Se o pedido já tem tudo, [].
+- Não pergunte gosto estético (cor, fonte): isso a gente decide.`;
+
+const lista = (v) => (Array.isArray(v) ? v : v ? [v] : []).map((x) => String(x || '').trim()).filter(Boolean).slice(0, 8);
+const txt = (v, n) => String(v || '').replace(/\s+/g, ' ').trim().slice(0, n);
+
+/** Confere e limpa a resposta do modelo. Puro. */
+function normalizar(j, pedido) {
+    j = j && typeof j === 'object' ? j : {};
+    const f = j.fatos && typeof j.fatos === 'object' ? j.fatos : {};
+    const faltando = (Array.isArray(j.faltando) ? j.faltando : []).map((q) => {
+        const opcoes = (Array.isArray(q && q.opcoes) ? q.opcoes : []).map((o) => (typeof o === 'string' ? { label: o, desc: '' } : { label: txt(o && o.label, 60), desc: txt(o && o.desc, 90) })).filter((o) => o.label).slice(0, 4);
+        return { campo: txt(q && q.campo, 20) || 'outro', pergunta: txt(q && q.pergunta, 120), opcoes };
+    }).filter((q) => q.pergunta && q.opcoes.length >= 2).slice(0, MAX_PERGUNTAS);
+    return {
+        pedido: txt(pedido, 600),
+        objetivo: txt(j.objetivo, 200), publico: txt(j.publico, 200), tom: txt(j.tom, 80),
+        virada: txt(j.virada, 160),
+        fatos: { datas: lista(f.datas), nomes: lista(f.nomes), marca: txt(f.marca, 60), local: txt(f.local, 80), oferta: txt(f.oferta, 120), outros: lista(f.outros) },
+        faltando,
+    };
+}
+
+/** A resposta da virada com fato que o usuário não disse (número, data, preço, nome, superlativo): devolve a lista ou []. Puro. */
+function fatoNaVirada(b, pedido) {
+    const resp = String(b.virada || '').split(/->|→/)[1] || '';
+    return Fatos.limpar(resp, Fatos.fonte(pedido)).removidos;
+}
+
+/** O que falta de verdade no briefing (para teste e para o aviso final). */
+function validar(b) {
+    const erros = [];
+    if (!b.objetivo) erros.push('sem objetivo');
+    if (!b.publico) erros.push('sem público');
+    if (!b.tom) erros.push('sem tom');
+    if (!b.virada || b.virada.length < 6) erros.push('sem virada');
+    else if (!/->|→/.test(b.virada)) erros.push('virada sem seta (pergunta -> resposta)');
+    else if (b.virada.split(/->|→/)[1].trim().split(/\s+/).length > 4) erros.push('virada com resposta longa (máx. 4 palavras, sem fato novo)');
+    return erros;
+}
+
+/** Faz as perguntas (uma por vez, no formato do `perguntar`). Devolve [{campo, pergunta, resposta}] só do que foi respondido. */
+async function perguntar(faltando, escolher) {
+    const out = [];
+    if (typeof escolher !== 'function') return out;
+    for (const q of faltando) {
+        let r = null;
+        try { r = await escolher(q.pergunta, q.opcoes.map((o) => o.label), { livre: true }); } catch { r = null; }
+        if (r == null) continue;                                  // pulou: segue com o que tem
+        const resposta = typeof r === 'number' ? q.opcoes[r] && q.opcoes[r].label : String(r).trim();
+        if (resposta) out.push({ campo: q.campo, pergunta: q.pergunta, resposta });
+    }
+    return out;
+}
+
+/** Junta as respostas nos fatos. Puro. */
+function aplicarRespostas(b, respostas) {
+    const fatos = { ...b.fatos, datas: [...b.fatos.datas], nomes: [...b.fatos.nomes], outros: [...b.fatos.outros] };
+    for (const r of respostas) {
+        if (r.campo === 'data') fatos.datas.push(r.resposta);
+        else if (r.campo === 'marca') fatos.marca = fatos.marca || r.resposta;
+        else if (r.campo === 'local') fatos.local = fatos.local || r.resposta;
+        else if (r.campo === 'oferta') fatos.oferta = fatos.oferta || r.resposta;
+        else fatos.outros.push(`${r.campo}: ${r.resposta}`);
+    }
+    return { ...b, fatos, respostas };
+}
+
+/**
+ * @param {string} pedido
+ * @param {object} deps { llm, escolher, fotos }   `fotos` = caminhos já achados no pedido (referencias.imagens())
+ * @returns {{ok, briefing, perguntas, respostas}}
+ */
+async function ajustarPedido(pedido, deps = {}) {
+    const llm = deps.llm;
+    if (!llm) return { ok: false, error: 'sem modelo para ajustar o pedido.' };
+    const fotos = lista(deps.fotos);
+    const j = await pedirJson(llm, [
+        { role: 'system', content: SISTEMA },
+        { role: 'user', content: `Pedido do usuário: "${txt(pedido, 600)}"\n${fotos.length ? `Fotos que o usuário já mandou: ${fotos.length}.` : 'O usuário não mandou foto nenhuma.'}` },
+    ], { temperatura: 0.7 });
+    let b = normalizar(j, pedido);
+    // virada comprida costuma carregar fato inventado: pede de novo UMA vez, com o defeito dito
+    const fato = fatoNaVirada(b, pedido);
+    const defeito = validar(b).find((e) => /virada/.test(e) && e !== 'sem virada') || (fato.length ? `a resposta da virada traz fato que o usuário não disse (${fato.join(', ')}); sem número, data, preço, nome ou promessa` : null);
+    if (defeito) {
+        const j2 = await pedirJson(llm, [
+            { role: 'system', content: SISTEMA },
+            { role: 'user', content: `Pedido do usuário: "${txt(pedido, 600)}"` },
+            { role: 'assistant', content: JSON.stringify(j) },
+            { role: 'user', content: `Defeito: ${defeito}. A resposta da virada tem de 1 a 4 palavras e não afirma nada novo sobre o negócio (uma palavra que quebra a expectativa daquele assunto). Devolva o JSON inteiro de novo.` },
+        ], { temperatura: 0.5 }).catch(() => null);
+        if (j2) b = normalizar(j2, pedido);
+        // ainda sujo: a resposta fica só com o que sobra depois do filtro (ou o briefing cai)
+        const ainda = fatoNaVirada(b, pedido);
+        if (ainda.length) {
+            const [perg, resp] = b.virada.split(/->|→/);
+            const l = Fatos.limpar(resp, Fatos.fonte(pedido));
+            if (l.frase) b.virada = `${perg.trim()} -> ${l.frase.replace(/\*/g, '')}`;
+            else return { ok: false, error: `briefing incompleto: virada com fato inventado (${ainda.join(', ')})`, briefing: b };
+        }
+    }
+    if (fotos.length) b.faltando = b.faltando.filter((q) => q.campo !== 'foto');
+    const erros = validar(b);
+    if (erros.some((e) => /virada|objetivo/.test(e))) return { ok: false, error: `briefing incompleto: ${erros.join(', ')}`, briefing: b };
+    const perguntas = b.faltando;
+    const respostas = await perguntar(perguntas, deps.escolher);
+    if (respostas.length) b = aplicarRespostas(b, respostas);
+    b.fotos = fotos;
+    return { ok: true, briefing: b, perguntas, respostas, puladas: perguntas.length - respostas.length };
+}
+
+module.exports = { fatoNaVirada, ajustarPedido, normalizar, validar, perguntar, aplicarRespostas, MAX_PERGUNTAS, SISTEMA };

package/lib/plugin/estudio/motion-plano/critico.js

@@ -0,0 +1,59 @@
+/**
+ * critico.js — só a parte MECÂNICA do crítico do motion 2.0 (copiada de primocode-motion-2, motion2/critico.js,
+ * sem depender daquela branch): folha de contato, flash branco e imagem parada. O olho de visão não veio.
+ */
+'use strict';
+
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+const ffmpeg = () => process.env.FFMPEG_PATH || 'ffmpeg';
+const ffprobe = () => (process.env.FFMPEG_PATH ? process.env.FFMPEG_PATH.replace(/ffmpeg$/, 'ffprobe') : 'ffprobe');
+
+function duracaoDe(video) {
+    const r = spawnSync(ffprobe(), ['-v', 'error', '-show_entries', 'format=duration', '-of', 'csv=p=0', video], { encoding: 'utf8' });
+    return parseFloat(r.stdout) || 0;
+}
+
+/** n quadros igualmente espaçados num mosaico (2 linhas). */
+function folha(video, saida, { n = 8, largura = 270 } = {}) {
+    const d = duracaoDe(video);
+    if (!d) return { ok: false, error: 'não consegui medir o vídeo' };
+    const cols = Math.ceil(n / 2);
+    const r = spawnSync(ffmpeg(), ['-v', 'error', '-y', '-i', video, '-vf', `fps=${n}/${d.toFixed(3)},scale=${largura}:-1,tile=${cols}x2`, '-frames:v', '1', saida], { encoding: 'utf8' });
+    return { ok: r.status === 0 && fs.existsSync(saida), arquivo: saida, duracao: d, error: r.stderr };
+}
+
+/** quadros 24x42 em cinza a 6 por segundo */
+function luminancias(video, fps = 6) {
+    const r = spawnSync(ffmpeg(), ['-v', 'error', '-i', video, '-vf', `fps=${fps},scale=24:42,format=gray`, '-f', 'rawvideo', '-'], { maxBuffer: 1 << 28 });
+    const buf = r.stdout || Buffer.alloc(0), T = 24 * 42, q = [];
+    for (let i = 0; i + T <= buf.length; i += T) q.push(buf.subarray(i, i + T));
+    return q;
+}
+
+/** Contas sobre os quadros (puro, testável): flash branco (média > 235) e imagem parada por mais de 1 s. */
+function contas(q, fps = 6) {
+    const motivos = [];
+    if (!q.length) return { ok: false, motivos: ['não li o vídeo'], quadros: 0 };
+    const media = (b) => b.reduce((a, v) => a + v, 0) / b.length;
+    // flash = quadro quase branco que se destaca dos outros: na pele creme do Destrava (≈ 239) TODO quadro é claro, e isso não é flash
+    const ms = q.map(media), ord = [...ms].sort((a, b) => a - b), mediana = ord[Math.floor(ord.length / 2)];
+    const brancos = ms.map((m, i) => (m > 235 && m - mediana > 8 ? i : -1)).filter((i) => i >= 0);
+    if (brancos.length) motivos.push(`flash branco perto de ${(brancos[0] / fps).toFixed(1)} s`);
+    let parado = 0, pior = 0;
+    for (let i = 3; i < q.length; i++) {
+        const a = q[i - 3], b = q[i];
+        let dif = 0;
+        for (let k = 0; k < a.length; k++) dif += Math.abs(a[k] - b[k]);
+        dif /= a.length;
+        parado = dif < 0.6 ? parado + 1 / fps : 0;
+        pior = Math.max(pior, parado);
+    }
+    if (pior > 1) motivos.push(`imagem parada por ${pior.toFixed(1)} s`);
+    return { ok: !motivos.length, motivos, quadros: q.length };
+}
+
+const mecanico = (video) => contas(luminancias(video));
+
+module.exports = { folha, mecanico, contas, luminancias, duracaoDe };