primocode 10.17.1 → 11.0.0

package/editor/modelo-projeto/build.py

@@ -187,7 +187,20 @@ FORMATOS = {
 CENAS = ('tela_cheia', 'prova', 'moldura', 'tela_verde', 'contida', 'comparar')
 
 # estilos da legenda do modelo. Outros jeitos (a frase se escrevendo à mão, manchete) são cena própria.
-LEGENDA_ESTILOS = ('padrao', 'discreta')
+LEGENDA_ESTILOS = ('padrao', 'discreta', 'cinetica')
+# (PrimoCode) a legenda cinética e o lettering "cinetico": Inter 800, palavra por palavra no começo medido na onda, a
+# palavra-chave do vídeo (legenda.chaves) no degradê da marca ("gradiente": [cor1, cor2]; sem marca, rosa → violeta)
+GRADIENTE_PADRAO = ('#f44f86', '#5b45ec')
+SOMBRA_CINETICA = 'drop-shadow(0 4px 0 rgba(0,0,0,.22)) drop-shadow(0 10px 22px rgba(0,0,0,.3))'   # sombra escura, sem brilho
+LEGENDA_CINETICA_ALTURA = 0.10     # a letra da legenda cinética: 10% da altura do quadro (até 3 palavras, em 1 ou 2 linhas)
+
+
+def gradiente_css(cfg):
+    cores = cfg.get('gradiente') or GRADIENTE_PADRAO
+    if not (isinstance(cores, (list, tuple)) and len(cores) >= 2
+            and all(re.fullmatch(r'#[0-9a-fA-F]{6}', str(c)) for c in cores)):
+        raise Erro(f'"gradiente" é [cor1, cor2] em #rrggbb (pediu {cores!r})')
+    return f'linear-gradient(90deg,{",".join(cores)})'
 LEGENDA_CENA_PROPRIA = ('papelaria', 'impacto', 'manchete', 'escrita', 'mao', 'a_mao')
 
 # Os tokens de cada estilo (as peças, a moldura, a legenda e as cenas do kit leem só daqui; cor fixa no código só
@@ -243,6 +256,19 @@ ESTILOS = {
         carimbo_fundo='rgba(12,13,19,.94)', cel_aro='#3b3c45', cel_corpo='#0b0b0d', item='#21222b',
         polaroide='#15161d', hud_fundo='rgba(10,10,12,.88)', hud_borda='#3b3c45', hud_n='#ff7a1a', hud_tc='#8b8b93',
         texto_atras='#f5f5f7', marca_texto='#ff7a1a', cena_no_fundo_do_estilo=True),
+    # (PrimoCode) limpo, o visual da régua do dono: chão claro com um rosa e um violeta bem leves, cartão branco, texto
+    # quase preto, sombra macia e nenhum brilho; a moldura é um quadro arredondado sobre esse chão
+    'limpo': dict(
+        papel='#ffffff', linha='#ecebef', base='#f44f86', destaque='#5b45ec', tinta='#1d1d1f',
+        verde='#16a34a', vermelho='#e5484d', contorno_leg='#1d1d1f', texto_fundo='#1d1d1f', botao='#1d1d1f',
+        sombra='0 18px 40px rgba(29,29,31,.14), 0 2px 6px rgba(29,29,31,.08)',
+        borda='0 30px 70px rgba(29,29,31,.22), 0 4px 12px rgba(29,29,31,.10)',
+        fundo='background-color:#f1f0ed;background-image:radial-gradient(60% 40% at 78% 84%,rgba(244,79,134,.16),'
+              'rgba(244,79,134,0) 70%),radial-gradient(55% 35% at 16% 14%,rgba(91,69,236,.10),rgba(91,69,236,0) 70%)',
+        sobre_destaque='#ffffff', sobre_base='#ffffff', sobre_verde='#ffffff', sobre_vermelho='#ffffff',
+        carimbo_fundo='rgba(255,255,255,.96)', cel_aro='#ffffff', cel_corpo='#1d1d1f', item='#f6f5f3',
+        polaroide='#ffffff', hud_fundo='rgba(255,255,255,.94)', hud_borda='#e2e0e6', hud_n='#5b45ec', hud_tc='#6b6b73',
+        texto_atras='#ffffff', marca_texto='#f44f86', cena_no_fundo_do_estilo=True),
 }
 
 # tipos de som que as animações pedem (o helpers/plano_sfx.py da skill escolhe o arquivo de cada um) e o nível do
@@ -452,7 +478,7 @@ class Projeto:
         self.W, self.H = self.F['W'], self.F['H']
         self.E = ESTILOS.get(c.get('estilo', 'papelaria'))
         if not self.E:
-            raise Erro('estilo tem que ser "papelaria", "noite" ou "laranja"')
+            raise Erro('estilo tem que ser ' + ', '.join(f'"{e}"' for e in ESTILOS))
         self.video_src = os.path.join(self.edit, c.get('video', 'cut.mp4'))
         tl = self._json('cut_timeline.json')
         self.VDUR = round(tl['duration'], 3)
@@ -2135,8 +2161,10 @@ def peca_lettering(M, p, pid):
     if not str(p.get('principal', '')).strip():
         raise Erro(f'{pid}: falta "principal" (o texto que manda, com *destaque* opcional)')
     estilo = p.get('estilo', 'bloco')
-    if estilo not in ('bloco', 'manuscrito'):
-        raise Erro(f'{pid}: "estilo" do lettering é "bloco" (Montserrat 900) ou "manuscrito" (Caveat, à mão)')
+    if estilo not in ('bloco', 'manuscrito', 'cinetico'):
+        raise Erro(f'{pid}: "estilo" do lettering é "bloco" (Montserrat 900), "manuscrito" (Caveat, à mão) ou '
+                   f'"cinetico" (Inter 800, destaque no degradê)')
+    cin = estilo == 'cinetico'
     posicao = p.get('posicao')
     if posicao not in (None, 'topo', 'meio', 'base'):
         raise Erro(f'{pid}: "posicao" é "topo", "meio" ou "base"')
@@ -2156,12 +2184,14 @@ def peca_lettering(M, p, pid):
     aw = (ax1 - ax0) - 2 * pad
     base_px = min(M.W, M.H)
     caixa_alta = p.get('caixa_alta', estilo == 'bloco')
-    fam_p, peso_p = ('Montserrat', 900) if estilo == 'bloco' else ('Caveat', 700)
-    px_max = int(p.get('tamanho') or round((0.13 if estilo == 'bloco' else 0.16) * base_px))
+    fam_p, peso_p = ('Montserrat', 900) if estilo == 'bloco' else (('Inter', 800) if cin else ('Caveat', 700))
+    px_max = int(p.get('tamanho') or (round(0.11 * M.H) if cin else round((0.13 if estilo == 'bloco' else 0.16) * base_px)))
     px_min = int(F['fonte_leg'] + 12)
     principal = palavras_rico(p['principal'])
     if caixa_alta:
         principal = [(w.upper(), d) for w, d in principal]
+    elif cin and principal:                     # o título cinético começa com maiúscula, como a régua
+        principal[0] = (principal[0][0][:1].upper() + principal[0][0][1:], principal[0][1])
     if len(principal) > 6:
         raise Erro(f'{pid}: o "principal" tem {len(principal)} palavras. Lettering são 2 a 4 expressões por trecho, até '
                    f'3 palavras grandes por vez: encurte, ou use a legenda')
@@ -2196,7 +2226,7 @@ def peca_lettering(M, p, pid):
                 pxc = int(pxc * aw / cw)
                 if pxc < 32:
                     raise Erro(f'{pid}: a "chamada" não cabe: encurte')
-        lhp, lha, hch = round(pxp * (1.18 if estilo == 'bloco' else 1.08)), round(pxa * 1.25), round(pxc * 1.9)
+        lhp, lha, hch = round(pxp * (1.18 if estilo == 'bloco' else (1.04 if cin else 1.08))), round(pxa * 1.25), round(pxc * 1.9)
         g1_, g2_ = round(0.22 * pxp), round(0.40 * pxp)
         fin = len(arr[-1][1]) * lhp + (g1_ + len(lia) * lha if apoio else 0) + (g2_ + hch if chamada else 0)
         amax = max(fin, max(len(li) * lhp for _px, li in arr))
@@ -2208,8 +2238,8 @@ def peca_lettering(M, p, pid):
     def topo_em(onde, lay):
         if b['cena'] == 'moldura' or onde == 'topo':
             return int(ay0 + 10)
-        if onde == 'base':
-            return int(ay1 - 10 - lay['alt_final'])
+        if onde == 'base':                  # cinético: a palavra sobe de baixo (e a perna do p): sobra embaixo
+            return int(ay1 - 10 - lay['alt_final'] - (round(0.32 * lay['px_p']) if cin else 0))
         return int((ay0 + ay1) / 2 - lay['alt_final'] / 2)
 
     gap_rosto = ROSTO_PX * M.H / 1920
@@ -2293,6 +2323,8 @@ def peca_lettering(M, p, pid):
 .lt-p{{font-weight:900;text-shadow:0 10px 28px rgba(0,0,0,.45)}}
 .lt-p.m{{font-family:Caveat;font-weight:700}}
 .lt-p .d{{color:{destaque}}}
+.lt-p.c{{font-family:Inter;font-weight:800;letter-spacing:-.035em;text-shadow:none;filter:{SOMBRA_CINETICA}}}
+.lt-p.c .d .lt-u{{background:{gradiente_css(P.cfg)};-webkit-background-clip:text;background-clip:text;color:transparent}}
 .lt-a{{font-weight:800;text-shadow:0 4px 14px rgba(0,0,0,.55)}}
 .lt-c{{position:absolute;display:flex;align-items:center;justify-content:center;border-radius:999px;background:$botao;
   color:$sobre_destaque;font-weight:900;white-space:nowrap;opacity:0;box-shadow:$sombra}}''')
@@ -2304,7 +2336,7 @@ def peca_lettering(M, p, pid):
         todas = [w for li in linhas for w in li]
         k0 = ini_m[mi]
         ts = [max(tp[k0 + j], tempos_m[mi]) for j in range(len(todas))]
-        unid = revelar_no_tempo(todas, ts, [fala_dur(P, idx_p[k0 + j]) for j in range(len(todas))], por_letra=True)
+        unid = revelar_no_tempo(todas, ts, [fala_dur(P, idx_p[k0 + j]) for j in range(len(todas))], por_letra=not cin)
         por_t = {}
         k = 0
         for li_i, linha in enumerate(linhas):
@@ -2321,18 +2353,19 @@ def peca_lettering(M, p, pid):
                 k += 1
             lid = f'{pid}-m{mi}l{li_i}'
             yy = y_linha0 + li_i * lh_p
-            grupo.append(f'<div class="lt-l lt-p{" m" if estilo == "manuscrito" else ""}" id="{lid}" style="left:{ax0 + pad}px;'
+            chao = f'color:{E["texto_fundo"]};filter:none;' if cin and b['cena'] == 'moldura' else ''
+            grupo.append(f'<div class="lt-l lt-p{" m" if estilo == "manuscrito" else (" c" if cin else "")}" id="{lid}" style="{chao}left:{ax0 + pad}px;'
                          f'top:{yy}px;width:{aw}px;height:{lh_p}px;line-height:{lh_p}px;font-size:{px}px;'
-                         f'-webkit-text-stroke:{max(3, round((0.085 if estilo == "bloco" else 0.05) * px))}px {stroke}">'
+                         f'-webkit-text-stroke:{0 if cin else max(3, round((0.085 if estilo == "bloco" else 0.05) * px))}px {stroke}">'
                          f'{"".join(spans)}</div>')
             ajuste.append((lid, aw))
         for tt, sels in sorted(por_t.items()):
-            M.FT(','.join(sels), {'opacity': 0, 'yPercent': 55},
+            M.FT(','.join(sels), {'opacity': 0, 'yPercent': 25 if cin else 55},
                  {'opacity': 1, 'yPercent': 0, 'duration': DUR_U, 'ease': 'power3.out'}, tt)
         completo = max(por_t) + DUR_U
         fim_m.append(completo)
         ultimo = mi == len(arrumados) - 1
-        if estilo == 'bloco':   # a batida quando a palavra que manda termina de chegar: um pulinho e volta
+        if estilo in ('bloco', 'cinetico'):   # a batida quando a palavra que manda termina de chegar: um pulinho e volta
             M.FT(f'#{pid}-m{mi}', {'y': 0}, {'keyframes': [{'y': -round(0.07 * px), 'duration': 0.1, 'ease': 'power2.out'},
                                                            {'y': 0, 'duration': 0.2, 'ease': 'power2.in'}]},
                  completo - 0.02)
@@ -2566,6 +2599,7 @@ def cenas(M):
         # corte dentro da transição da moldura: usa o enquadramento do bloco novo (senão a moldura mostra o peito)
         M.SET(M.CAM, M.cam(c), c)
     zooms_na_timeline(M)
+    moldura_flutua(M)
     camera_acompanhada(M)
     fundos_desfocados(M, fronteiras)
     fundos_contida(M, fronteiras)
@@ -2619,6 +2653,21 @@ def cenas(M):
                 peca_rotulo(M, dict(id=pid, texto=b['rotulo'], em=em, antecipa=0, sai=b['ate'] - 0.15, onde='topo'), pid)
 
 
+def moldura_flutua(M):
+    """(PrimoCode) nada parado: depois de fechar, o quadro da moldura sobe e desce devagar (uns 14 px), e volta ao lugar
+    antes de abrir de novo. O aro (#borda) anda junto."""
+    amp = round(14 * M.F['escala'])
+    for b in M.blocos:
+        if b['cena'] != 'moldura' or b.get('flutua') is False:
+            continue
+        t0, t1 = max(b.get('_fecha', b['de']), M.T0), min(b['ate'], M.VFIM) - 0.12
+        if t1 - t0 < 1.2:
+            continue
+        meio = round((t1 - t0) / 2, 3)
+        M.FT('#frame, #borda', {'y': 0}, {'keyframes': [{'y': -amp, 'duration': meio, 'ease': 'sine.inOut'},
+                                                          {'y': 0, 'duration': meio, 'ease': 'sine.inOut'}]}, t0)
+
+
 def zooms_na_timeline(M):
     """zoom que anda até o ponto (caixa) ou punch-in no rosto, na palavra; volta ao enquadramento do bloco no ate"""
     for z in M.zooms:
@@ -2827,7 +2876,7 @@ def lado_comparar(b, chave, sufixo):
                 video=video, w=w, h=h)
 
 
-def encaixe_comparar(M, modo, r):
+def encaixe_comparar(M, modo, r, arranjo='auto'):
     """(caixas [(x, y, w, h)], altura do rótulo) na zona segura, na mesma escala para os dois lados"""
     sx0, sy0, sx1, sy1 = M.F['seguro']
     s = M.F['escala']
@@ -2843,7 +2892,8 @@ def encaixe_comparar(M, modo, r):
     # lado a lado: em linha ou empilhado, o que deixar a imagem maior
     lw = min((aw - gap) / 2, (ah - lab) * r)
     cw = min(aw, ((ah - 2 * lab - gap) / 2) * r)
-    if lw >= cw:
+    # (PrimoCode) "arranjo": "lado" ou "empilhado" fixa a escolha; "auto" fica com o que deixa a imagem maior
+    if arranjo == 'lado' or (arranjo != 'empilhado' and lw >= cw):
         fh = lw / r
         cx, y = sx0 + aw / 2, sy0 + lab + (ah - lab - fh) / 2
         return [(cx - gap / 2 - lw, y, lw, fh), (cx + gap / 2, y, lw, fh)], lab
@@ -2908,7 +2958,10 @@ def comparacoes(M):
                 if dur and L['ms'] + dd > dur + 0.05:
                     aviso(f'{nome}: o lado {L["chave"]} ({L["nome"]}) tem {dur:.2f} s e o trecho pede até '
                           f'{L["ms"] + dd:.2f} s: o fim fica parado. Diminua o bloco ou o "inicio"')
-        caixas, lab = encaixe_comparar(M, modo, ra)
+        arranjo = b.get('arranjo', 'auto')
+        if arranjo not in ('auto', 'lado', 'empilhado'):
+            raise Erro(f'{nome}: "arranjo" é "auto" (o padrão), "lado" (um ao lado do outro) ou "empilhado" (um em cima do outro)')
+        caixas, lab = encaixe_comparar(M, modo, ra, arranjo)
         css_midia(M)
         M.css('comparar', '''.cmp-fundo{position:absolute;inset:0;$fundo}
 .cmp-lado{position:absolute;overflow:hidden;border-radius:24px;opacity:0;background:#000;box-shadow:$sombra}''')
@@ -3313,7 +3366,8 @@ def legendas(M):
                 a = P.tempo(pp, 'em') or 0
                 esconder.append((a - 0.1, P.tempo(pp, 'sai', depois=a) or a + 1.5))
         esconder += M.esconder_extra
-    max_l = int(lg.get('max_letras', F['max_letras'] if est == 'padrao' else F['max_letras_discreta']))
+    max_l = int(lg.get('max_letras', 16 if est == 'cinetica' else (F['max_letras'] if est == 'padrao' else F['max_letras_discreta'])))
+    chaves = {norm(str(x)) for x in lg.get('chaves') or []}
     max_p = max(1, int(lg.get('max_palavras', 3)))
 
     def ligada(t):
@@ -3382,6 +3436,14 @@ def legendas(M):
         M.css('legenda', """.cap{position:absolute;left:40px;right:40px;text-align:center;white-space:nowrap;opacity:0;z-index:50}
 .cap span{display:inline-block;font-weight:700;color:#ffffff;line-height:1.25;letter-spacing:.2px;padding:.1em .5em .14em;
   border-radius:.45em;background:rgba(18,14,28,.55);text-shadow:0 1px 2px rgba(0,0,0,.35)}""")
+    elif est == 'cinetica':
+        fs = round(LEGENDA_CINETICA_ALTURA * M.H)  # GIGANTE como a régua: ~10% da altura do quadro (192 px no 9:16)
+        hcap = round(fs * 1.02)
+        M.css('legenda', f""".cap{{position:absolute;text-align:center;opacity:0;z-index:50;
+  font-family:Inter;font-weight:800;color:#ffffff;letter-spacing:-.02em;filter:{SOMBRA_CINETICA}}}
+.cap .cl{{display:block;white-space:nowrap}}
+.cap .cw{{display:inline-block;opacity:0}}
+.cap .ck{{background:{gradiente_css(P.cfg)};-webkit-background-clip:text;background-clip:text;color:transparent}}""")
     else:
         fs = F['fonte_leg']
         hcap = round(fs * 1.3)
@@ -3392,6 +3454,10 @@ def legendas(M):
         a, b = janela(i)
         if b <= M.T0:
             continue
+        if est == 'cinetica':
+            ultimo = legenda_cinetica(M, i, c, a, b, fs, chaves, ultimo)
+            n += 1
+            continue
         caixa = caixa_legenda(M, a)
         texto = ' '.join(x['text'] for x in c).rstrip(',.')
         # a largura da própria legenda (centrada): uma peça no canto não empurra a legenda à toa
@@ -3415,6 +3481,84 @@ def legendas(M):
     return n
 
 
+def legenda_cinetica(M, i, c, a, b, fs, chaves, ultimo):
+    """(PrimoCode) uma legenda cinética: letra gigante (fs), em 1 linha ou empilhada em 2 dentro da largura da zona
+    segura (a letra só desce se nem empilhada couber), palavra por palavra no começo dela, a palavra-chave no degradê.
+    Fica fora do rosto (abaixo dele, senão acima) e dentro da zona segura. Devolve o topo usado."""
+    sx0, sy0, sx1, sy1 = M.F['seguro']
+    aw = sx1 - sx0
+    folga = 0.9 * aw                               # a sombra e o pulo da palavra-chave (escala 1,18) cabem na zona segura
+    ps = [x['text'] for x in c]
+    ps[-1] = ps[-1].rstrip(',.') or ps[-1]
+    ps[0] = ps[0][:1].upper() + ps[0][1:]
+    ks = [j for j, x in enumerate(c) if norm(x['text']) in chaves]
+    kj = max(ks, key=lambda j: len(c[j]['text'])) if ks else None
+
+    def larg(idx, px):
+        return sum(medir_texto(ps[j], 'Inter', 800, px) for j in idx) + 0.26 * px * (len(idx) - 1)
+
+    def orfa(li):                                  # linha só com "a", "o", "de"...: melhor encolher a letra
+        return len(li) == 1 and len(ps[li[0]]) <= 3
+    tudo, px, linhas = list(range(len(ps))), fs, None
+    while linhas is None:
+        if larg(tudo, px) <= folga:
+            linhas = [tudo]
+        else:
+            ops = [[tudo[:k], tudo[k:]] for k in range(1, len(tudo)) if max(larg(tudo[:k], px), larg(tudo[k:], px)) <= folga
+                   and (px <= 0.7 * fs or not (orfa(tudo[:k]) or orfa(tudo[k:])))]
+            if not ops and len(tudo) == 3 and all(larg([j], px) <= folga for j in tudo) and not any(len(ps[j]) <= 3 for j in tudo):
+                ops = [[[0], [1], [2]]]               # três palavras longas: uma por linha, ainda gigantes
+            if ops:
+                linhas = min(ops, key=lambda o: max(larg(li, px) for li in o) - min(larg(li, px) for li in o))
+            elif px <= 0.45 * fs:
+                linhas = [tudo[:1], tudo[1:]] if len(tudo) > 1 else [tudo]
+            else:
+                px = int(px * 0.92)
+    lh = round(px * 1.02)
+    # a perna do p e do g passa da linha (line-height 1,02): a caixa reservada leva essa sobra embaixo
+    h, w = lh * len(linhas) + round(0.16 * px), max(larg(li, px) for li in linhas)
+    y = lugar_cinetica(M, a, b, h, w, ultimo)
+    html = ''.join('<div class="cl">' + ' '.join(f'<span class="cw{" ck" if j == kj else ""}" id="cap{i}w{j}">{escape(ps[j])}</span>'
+                                                 for j in li) + '</div>' for li in linhas)
+    ini = max(a, M.T0)
+    texto = ' '.join(ps)
+    M._HT.append(f'<div class="cap caption-cue clip" id="cap{i}" data-start="{M.rr(ini)}" data-duration="{round(b - ini, 3)}" '
+                 f'data-track-index="{TRILHA_LEGENDA}" data-track-kind="captions" data-timeline-label="Legenda · {escape(texto)}" '
+                 f'style="top:{y}px;left:{sx0}px;width:{aw}px;font-size:{px}px;line-height:{lh}px">{html}</div>')
+    M.SET(f'#cap{i}', {'opacity': 1}, a)
+    for j, x in enumerate(c):                      # cada palavra no começo dela (medido na onda com palavras_onda.json)
+        tj = clamp(x['start'], a, max(a, b - 0.08))
+        M.FT(f'#cap{i}w{j}', {'opacity': 0, 'y': round(0.22 * px), 'scale': 1.18 if j == kj else 0.9},
+             {'opacity': 1, 'y': 0, 'scale': 1, 'duration': 0.24 if j == kj else 0.16, 'ease': 'back.out(2)'}, tj)
+    M.SET(f'#cap{i}', {'opacity': 0}, b)
+    return y
+
+
+def lugar_cinetica(M, a, b, h, w, ultimo=None):
+    """(PrimoCode) o topo da legenda cinética: na mesma altura da anterior se ainda couber, senão logo abaixo do rosto,
+    senão acima dele (com o cabelo), senão na base da zona segura; nunca sobre o rosto nem sobre uma peça"""
+    sx0, sy0, sx1, sy1 = M.F['seguro']
+    cx0, cx1 = M.W / 2 - w / 2, M.W / 2 + w / 2
+    gap = round(28 * M.H / 1920)
+    rostos = [r for r in (M.rosto_tela(t) for t in (a, (a + b) / 2, max(a, b - 0.02))) if r]
+
+    def livre(y):
+        if y < sy0 or y + h > sy1:
+            return False
+        if any(y < r['y1'] + gap and r['topo'] - gap < y + h and r['x0'] < cx1 and cx0 < r['x1'] for r in rostos):
+            return False
+        return not any(t0 < b and a < t1 and y < yy + hh + 10 and yy < y + h + 10 and x < cx1 and cx0 < x + ww
+                       for t0, t1, x, yy, ww, hh in M.retangulos)
+    cands = ([ultimo] if ultimo is not None else []) + \
+        ([max(r['y1'] for r in rostos) + gap, min(r['topo'] for r in rostos) - gap - h] if rostos else []) + \
+        [sy1 - h, M.F['legenda_padrao'], sy0]
+    for y in cands:
+        if livre(int(y)):
+            return int(y)
+    aviso(f'legenda em {a:.2f} s: não coube fora do rosto em letra grande; ficou na base da zona segura')
+    return int(sy1 - h)
+
+
 def dividir_frase(ws, max_p, max_l):
     """uma frase em legendas de até max_p palavras e max_l letras, sem perder palavra. Entre as divisões com menos
     legendas, a que não termina legenda em artigo, preposição ou "não" (vai com a palavra seguinte), não deixa
@@ -3624,6 +3768,7 @@ def sons(M):
 # "../assets" é erro no lint)
 FONTES_CSS = '''@font-face{font-family:Montserrat;src:url("assets/fontes/Montserrat.ttf") format("truetype");font-weight:100 900;font-display:block}
 @font-face{font-family:Caveat;src:url("assets/fontes/Caveat.ttf") format("truetype");font-weight:400 700;font-display:block}
+@font-face{font-family:Inter;src:url("assets/fontes/Inter.ttf") format("truetype");font-weight:100 900;font-display:block}
 @font-face{font-family:Mono;src:url("assets/fontes/JetBrainsMono.ttf") format("truetype");font-weight:100 800;font-display:block}'''
 
 BASE_CSS = '''*{box-sizing:border-box;margin:0;padding:0}
@@ -4757,7 +4902,7 @@ def main(argv):
         if argv[0] == 'hf':
             return cmd_hf(argv[1:])
         if argv[0] == 'novo':
-            uso = 'use: python3 build.py novo <PASTA> [--edit <PASTA_EDIT>] [--estilo papelaria|noite|laranja]'
+            uso = 'use: python3 build.py novo <PASTA> [--edit <PASTA_EDIT>] [--estilo papelaria|noite|laranja|limpo]'
             resto, opcoes = argv[1:], {}
             for flag in ('--edit', '--estilo'):
                 if flag in resto:

package/editor/modelo-projeto/ferramentas/medir_fontes.py

@@ -19,7 +19,7 @@ AQUI = os.path.dirname(os.path.abspath(__file__))
 FONTES = os.path.join(os.path.dirname(AQUI), 'assets', 'fontes')
 EM = 1000
 # arquivo, pesos medidos (o que o modelo usa na tela)
-MEDIR = {'Montserrat': ('Montserrat.ttf', (700, 800, 900)), 'Caveat': ('Caveat.ttf', (700,))}
+MEDIR = {'Montserrat': ('Montserrat.ttf', (700, 800, 900)), 'Caveat': ('Caveat.ttf', (700,)), 'Inter': ('Inter.ttf', (800,))}
 EXTRAS = '–—‘’“”…•€✓→×'
 
 

package/kits/CATALOGO.md

@@ -0,0 +1,65 @@
+# Os 50 estilos (slug · nome · o que é)
+
+## SaaS e tecnologia
+1. apple-tipografico · Apple tipográfico · creme liso, tipografia gigante com a palavra-chave em degradê, fotos reais em cartões com movimento, marca só no fim (o vídeo da Destrava, aprovado em 26/10)
+2. saas-linear · SaaS Linear · fundo grafite, formas de interface nítidas, luz suave, câmera lenta em perspectiva
+3. campos-de-cor · Campos de cor · campos de cor chapada que trocam na batida, palavras gigantes com ponto colorido, formas geométricas (motion1.mp4)
+4. produto-3d · Produto 3D em estúdio · objeto 3D realista em estúdio claro, órbita lenta, peças que se separam (vídeo dos AirPods)
+5. stripe-ondas · Ondas Stripe · ondas de degradê fluindo, tipografia limpa por cima
+6. vercel-mono · Mono Vercel · preto e branco, triângulos e grades, cortes secos
+7. notion-editorial · Notion editorial · creme, traço fino desenhado, serifa
+8. dashboard-dados · Painel de dados · gráficos que crescem, números contando
+9. isometrico · Isométrico · blocos isométricos montando um sistema
+10. vidro-ios · Vidro iOS · cartões de vidro fosco, desfoque, movimento de iPhone
+
+## Tipografia em movimento
+11. suica · Suíço · grade rígida, Helvetica, vermelho e preto
+12. brutalista · Brutalista · mono enorme, preto, branco e amarelo, sem enfeite
+13. cartaz-cinetico · Cartaz cinético · cartazes de tipo que se transformam
+14. jornal · Jornal · papel de jornal, colunas, manchete
+15. revista · Revista · páginas duplas, fotos grandes, serifa elegante
+16. legenda-viva · Legenda viva · fala com legenda animada palavra por palavra
+
+## Retrô
+17. y2k-cromado · Y2K cromado · cromo, bolhas, anos 2000
+18. vhs-90 · VHS anos 90 · ruído de fita, timecode, cor lavada
+19. synthwave · Synthwave · sol listrado, grade roxa, anos 80
+20. retro-70 · Retrô anos 70 · laranja e marrom, tipo arredondado, raios de sol
+21. pixel · Pixel art · 8 bits, sprites, paleta curta
+22. terminal · Terminal hacker · verde no preto, cursor, digitação
+23. memphis · Memphis · rabiscos, formas e cores fortes
+24. bauhaus · Bauhaus · círculo, quadrado e triângulo nas cores primárias
+
+## Feito à mão
+25. papel-recortado · Papel recortado · camadas de papel com sombra
+26. risografia · Risografia · duas tintas, retícula, registro fora
+27. colagem · Colagem · recortes de foto, fita, rasgado
+28. rabisco · Rabisco · desenho à mão, traço tremido
+29. quadro-giz · Quadro de giz · giz no quadro verde
+30. massinha · Massinha · 3D com cara de massa de modelar
+31. aquarela · Aquarela · manchas de tinta, papel texturizado
+32. adesivos · Adesivos · adesivos com borda branca que colam na tela
+
+## 3D e abstrato
+33. metal-liquido · Metal líquido · bolhas cromadas que se fundem
+34. pontos-3d · Campo de pontos · grade e esfera de pontos 3D
+35. tunel · Túnel 3D · voo por um túnel de formas
+36. cubos · Cubos modulares · cubos que se montam e desmontam
+37. neon-cidade · Neon urbano · letreiros neon na noite
+38. aurora · Aurora · faixas de luz suaves, tipo calmo
+
+## Redes sociais
+39. ugc-reels · UGC de Reels · cara de celular, legenda com emoji, cortes rápidos
+40. tiktok-energia · Energia TikTok · zoom, tremor, texto de adesivo, muito corte
+41. corte-podcast · Corte de podcast · onda do áudio, citação grande
+42. depoimento · Depoimento · cartões de depoimento com foto e estrelas
+43. antes-depois · Antes e depois · tela dividida, comparação
+44. tutorial-tela · Tutorial de tela · tela gravada com zoom e cursor
+
+## Marca e evento
+45. convite-evento · Convite de evento · data e lugar como herói
+46. contagem · Contagem regressiva · números grandes contando até o dia
+47. infografico · Infográfico · ícones e setas explicando um processo
+48. mapa · Mapa local · mapa, pino, rota até o lugar
+49. luxo · Luxo · preto e dourado, serifa fina, lentidão
+50. minimal · Minimalista · uma cor, muito espaço, um elemento

package/kits/KITS.md

@@ -0,0 +1,179 @@
+# KITS.md · o formato de um kit de estilo de motion
+
+Um kit **não é template**. É uma pasta que a IA carrega como uma skill: dentro tem a skill (como o estilo
+pensa), as regras em números, os elementos (componentes Remotion com props), os assets e uma receita
+de batidas. A IA monta o motion a partir disso e escreve o roteiro. **O motion nunca vem pronto.**
+
+O kit de referência é `kits/apple-tipografico/`. Na dúvida, copie a forma dele.
+
+## 1. Pasta
+
+```
+kits/<slug>/
+  SKILL.md             frontmatter + o que é o estilo, como montar, o que é proibido
+  regras/              6 MDs curtos, só números: tipografia · cor · movimento · som · ritmo · area-segura
+  elementos/           componentes Remotion (.tsx) com props + base.ts + Montagem.tsx + index.ts
+  assets/              fontes (OFL/Apache), sons (CC0 ou sintetizados), texturas pequenas + ASSETS.md
+  receita.json         as batidas que o estilo aceita, duração, elementos de cada batida, transições
+  exemplos/            roteiro.md + plano.json (como a IA montou a demo) + o conteúdo fictício da demo
+  preview.tsx          a demo: `export const preview = {duracaoEmQuadros, quadroCapa, Componente}`
+  capa.jpg             gerado por scripts/render-kit.mjs (540×960)
+  preview.mp4          gerado por scripts/render-kit.mjs (540×960, ≤ 2 MB, h264 + AAC)
+```
+
+`<slug>` é o do `CATALOGO.md` (ex.: `saas-linear`). Nada fora dessa pasta é do kit.
+
+## 2. SKILL.md
+
+```yaml
+---
+slug: saas-linear
+nome: SaaS Linear                      # igual ao CATALOGO.md
+descricao: fundo grafite, formas de interface nítidas, luz suave, câmera lenta em perspectiva
+familia: SaaS e tecnologia             # exatamente uma das 7 abaixo
+versao: 1                              # suba 1 a cada preview novo que o dono precisa rever
+quando:                                # 3+ pedidos reais em que o kit serve (frases do usuário)
+  - "vídeo de lançamento de SaaS"
+  - "demo de produto com interface"
+  - "anúncio B2B premium"
+nao_serve:                             # opcional: quando mandar pra outro kit
+  - "vídeo divertido ou retrô"
+---
+```
+
+Famílias (iguais às seções do CATALOGO.md): `SaaS e tecnologia` · `Tipografia em movimento` · `Retrô` ·
+`Feito à mão` · `3D e abstrato` · `Redes sociais` · `Marca e evento`.
+
+Corpo, nesta ordem: **o que é o estilo** (1 parágrafo, concreto), **como montar um vídeo** (passos:
+cortar o roteiro em frases → escolher batidas na receita → escrever o plano → renderizar → conferir),
+**tabela de elementos** (elemento · o que faz · batidas), **proibido** (lista curta e específica).
+
+## 3. regras/
+
+Seis arquivos, curtos, com **números e não adjetivos**: px, hex, curvas (`cubic-bezier` ou fórmula),
+quadros, volumes, LUFS. Tela de referência 1080×1920, 30 fps.
+
+| arquivo | tem que ter |
+|---|---|
+| `tipografia.md` | fontes e pesos, tabela papel → tamanho px → máx. caracteres, tracking, line-height, caixa |
+| `cor.md` | tabela token → hex → uso, degradês exatos, sombras, o que o cliente pode trocar |
+| `movimento.md` | curva padrão, tabela movimento → quadros → valores (entrada, saída, câmera, cada elemento) |
+| `som.md` | trilha (arquivo, volume, fade), tabela som → volume → quando, máx. sons/s, alvo −14 LUFS |
+| `ritmo.md` | bpm/batida em quadros, tabela batida → duração s → quadros, tempo mínimo de leitura |
+| `area-segura.md` | limites (padrão 9:16: y 168–1330, x 80–1000), y de referência de cada elemento |
+
+## 4. elementos/
+
+- **Um componente por arquivo**, nome em PascalCase PT-BR (`TituloGigante.tsx`, `CartaoFoto.tsx`).
+  Mínimo **5** elementos visuais além de `Fundo`/`Camera`/`Cena`.
+- **Tudo vem por props**: texto, imagem (`src` como URL), cores de destaque, tempo (`inicio`, `fim`,
+  `intervalo` em quadros). **Nenhum texto de demo fixo** dentro de um elemento.
+- Tempo é **relativo à cena**: os elementos usam `useCurrentFrame()` dentro de `<Cena>` (que é uma
+  `<Sequence>`), e a duração da cena vem de `useDuracaoCena()`.
+- `base.ts`: tokens (cores, fonte, área segura, curvas, `BATIDA`) e o carregamento das fontes com
+  `delayRender`. **Registre a fonte com prefixo do kit** (`"AT Inter"`, `"SL Geist"`…) pra não colidir
+  com outro kit no mesmo estúdio, e proteja com uma flag em `globalThis` pra carregar uma vez só.
+- Texto que pode crescer (copy do cliente) **encolhe sozinho** pra caber na largura útil (veja `caber()`
+  em `apple-tipografico/elementos/base.ts`). Nunca palavra cortada.
+- `Som.tsx`: `Efeito {som, em, volume}` e `Trilha {volume}`; os sons são importados de `../assets/`.
+- `Montagem.tsx`: recebe um `plano` (formato da seção 6) e um mapa `arquivos` (nome → URL importada) e
+  monta `Fundo + Camera + Cena[] + sons + trilha`. Não decide estética, só executa o plano.
+- `index.ts`: exporta tudo.
+- **Imports permitidos**: arquivos da própria pasta do kit, `react`, `remotion`, `@remotion/*` que já
+  estão no `package.json`. Nada de `src/`, de outro kit ou de pacote novo. Asset entra por `import`
+  (`import url from '../assets/sons/pop.mp3'`): o webpack do Remotion devolve a URL. Não existe `public/`.
+
+## 5. assets/
+
+- Fontes: **só OFL ou Apache**, com o texto da licença ao lado (`OFL-<Fonte>.txt`). woff2, subset latino.
+- Sons: **CC0 ou sintetizados**. Caminho fácil: o MotionCraft sintetiza tudo sem samples:
+  `node ~/www/pg/apps/primocode-motioncraft/vendor/motioncraft/scripts/motioncraft.mjs sfx make --cues c.json --duration 2.5 --pack <soft-pop|glass|paper|digital-soft|organic-wood> --out /tmp/x.wav`
+  e `music make` para a trilha (`music presets` lista os presets; em `music make`, `--out` é uma **pasta**
+  e é obrigatório, senão ele cria `audio/` na pasta atual). Rode sempre de um diretório temporário.
+  Converta para mp3 160k. Tipos: `word_pop icon_pop letter_tick check success slot_tick bubble type button whoosh_in whoosh_out swoosh riser impact confetti logo_sting`.
+- Trilha: 8–9 s bastam pro preview. "Trilha forte ou nenhuma": nada de pad morno.
+- Texturas: pequenas (< 300 KB cada), geradas ou CC0.
+- `ASSETS.md`: tabela arquivo · o que é · origem (URL/comando) · licença. **Todo arquivo** de `assets/`
+  aparece nela. Fotos da demo ficam em `exemplos/` e também são listadas (Unsplash/Pexels/CC0).
+
+## 6. receita.json e plano de cenas
+
+`receita.json`:
+
+```json
+{
+  "kit": "<slug>", "fps": 30, "batida_trilha_quadros": 14.4,
+  "batidas": [
+    {"nome": "gancho", "obrigatoria": true, "duracao": [45, 105], "elementos": ["TituloGigante"],
+     "entrada": ["nenhuma"], "sons": ["whoosh-entra"], "nota": "..."}
+  ],
+  "transicoes": [{"nome": "subir", "quadros": 12, "como": "..."}]
+}
+```
+
+Nomes de batida (use os que servem ao estilo, 4+): `gancho` · `problema` · `virada` · `prova` · `lista`
+· `depoimento` · `data` · `oferta` · `cta` · `marca`. `duracao` em quadros [mín, máx]. Todo nome em
+`elementos` tem que existir em `elementos/<Nome>.tsx`.
+
+`exemplos/plano.json` (o que a IA escreve a cada vídeo, e o que a `Montagem` lê):
+
+```json
+{
+  "kit": "<slug>", "duracao": 240, "trilha": {"volume": 0.5},
+  "cenas": [
+    {"batida": "gancho", "de": 0, "ate": 58, "entrada": "nenhuma",
+     "camadas": [{"elemento": "TituloGigante", "props": {"linhas": ["Prazo", "*estourado?*"], "inicio": 0}}],
+     "socos": [31],
+     "sons": [{"som": "whoosh-entra", "em": 0}]}
+  ]
+}
+```
+
+`de`/`ate` absolutos; `inicio`, `socos` e `sons[].em` relativos à cena. Strings de arquivo nas props
+(`"fotos/foto-01.jpg"`) são trocadas pela URL do mapa `arquivos` do `preview.tsx`.
+
+`exemplos/roteiro.md`: o pedido do usuário, a tabela cena · batida · quadros · na tela · elemento · som,
+e 3–4 linhas de "como a IA chegou nisso".
+
+## 7. preview.tsx e a demo
+
+```tsx
+import {Montagem, Plano} from './elementos';
+import plano from './exemplos/plano.json';
+import f1 from './exemplos/fotos/foto-01.jpg';
+const Preview: React.FC = () => <Montagem plano={plano as Plano} arquivos={{'fotos/foto-01.jpg': f1}} />;
+export const preview = {duracaoEmQuadros: plano.duracao, quadroCapa: 88, Componente: Preview};
+```
+
+- 1080×1920, 30 fps, **6 a 8 s** (180–240 quadros). Feito **só** com os elementos do kit.
+- Copy de demo **genérica em PT-BR** sobre produto/evento **fictício**. Nunca a marca Destrava, nem
+  marca real. Logo da demo: um SVG simples desenhado na hora.
+- Mostre no preview o máximo de elementos assinatura do estilo (4+), com som em cada movimento.
+- `quadroCapa`: o quadro que melhor vende o estilo (tipo + destaque + imagem, nada no meio da entrada).
+
+## 8. Comandos
+
+```bash
+npm run studio                                   # abre todos os kits (Kit-<slug>)
+node scripts/render-kit.mjs <slug>               # preview.mp4 + capa.jpg do kit (≈ 15–25 s)
+node scripts/checar-kit.mjs <slug>               # confere este formato; tem que dar "ok"
+node scripts/manifest.mjs                        # reescreve kits/manifest.json
+npx tsc --noEmit                                 # tipos
+```
+
+Depois de renderizar, **olhe os quadros**: `ffmpeg -i kits/<slug>/preview.mp4 -vf "select='not(mod(n\,10))',scale=270:480,tile=8x3" -frames:v 1 /tmp/tile.jpg`
+e abra a imagem. Corrija o que estiver cortado, parado, fora da área segura ou feio, e renderize de novo.
+
+## 9. Trabalho em paralelo (vários agentes, um kit cada)
+
+- Cada agente **só toca `kits/<slug>/`**. Registro do kit é automático (`src/Estudio.tsx` acha todo
+  `kits/*/preview.tsx` com `require.context`): **não existe linha de registro pra editar**.
+- **Não edite** `src/`, `scripts/`, `package.json`, `KITS.md`, `CATALOGO.md`, `galeria/` nem outro kit.
+  Precisa de pacote novo? Não instale: peça a quem coordena.
+- **Não rode `scripts/manifest.mjs` nem commite `kits/manifest.json`** em paralelo: quem coordena roda
+  uma vez no fim (evita conflito no mesmo arquivo).
+- O render empacota só o kit pedido (`.cache/entrada-<slug>.tsx`, `.cache/<slug>/`), então um kit
+  quebrado não derruba os outros. Rodando muitos ao mesmo tempo, use `KIT_CONCORRENCIA=2`.
+- Commit só da sua pasta: `git add kits/<slug> && git commit -m "kit <n>: <slug> ..."`. Nunca `git add -A`.
+  Nunca push.
+- Pronto quando: `checar-kit.mjs <slug>` dá ok, o preview tem ≤ 2 MB com áudio, e você olhou os quadros.