primocode 8.38.1 → 8.40.0

package/studio/arquivos/tela-motion-d6150.json

@@ -0,0 +1,135 @@
+{
+  "id": "tela-motion-d6150",
+  "ferramenta": "tela",
+  "titulo": "motion",
+  "doc": {
+    "tema": "meia-noite",
+    "largura": 1920,
+    "altura": 1080,
+    "cenas": [
+      {
+        "layout": "livre",
+        "duracao": 6,
+        "fundo": "aurora",
+        "elementos": [
+          {
+            "tipo": "forma",
+            "forma": "circulo",
+            "x": 1250,
+            "y": 120,
+            "l": 520,
+            "a": 520,
+            "preenchimento": "#ff5a36",
+            "opacidade": 0.9
+          },
+          {
+            "tipo": "forma",
+            "forma": "retangulo",
+            "material": "vidro",
+            "x": 120,
+            "y": 140,
+            "l": 860,
+            "a": 420,
+            "raio": 36,
+            "preenchimento": "#22d3ee"
+          },
+          {
+            "tipo": "texto",
+            "x": 170,
+            "y": 190,
+            "l": 760,
+            "a": 120,
+            "texto": "Liquid glass de verdade",
+            "tamanho": 74,
+            "peso": 750
+          },
+          {
+            "tipo": "texto",
+            "x": 170,
+            "y": 330,
+            "l": 760,
+            "a": 60,
+            "texto": "desfoca o que está atrás, bisel em cima",
+            "tamanho": 34,
+            "cor": "#bfe9f4"
+          },
+          {
+            "tipo": "texto",
+            "material": "vidro",
+            "x": 170,
+            "y": 430,
+            "l": 420,
+            "a": 70,
+            "texto": "pílula de vidro",
+            "tamanho": 32
+          },
+          {
+            "tipo": "icone",
+            "nome": "foguete",
+            "estilo": "app",
+            "x": 1130,
+            "y": 640,
+            "tamanho": 220,
+            "fundo": "#8b5cf6",
+            "som": "pop"
+          },
+          {
+            "tipo": "icone",
+            "nome": "raio",
+            "estilo": "vidro",
+            "x": 1400,
+            "y": 640,
+            "tamanho": 220,
+            "cor": "#ffb03a"
+          },
+          {
+            "tipo": "objeto3d",
+            "forma": "cubo",
+            "x": 620,
+            "y": 620,
+            "tamanho": 260,
+            "girar": 0,
+            "faces": [
+              "IA",
+              "3D",
+              "Motion",
+              "Vidro",
+              "Som",
+              "Marca"
+            ]
+          },
+          {
+            "tipo": "texto",
+            "x": 120,
+            "y": 700,
+            "l": 400,
+            "a": 100,
+            "texto": "chaves 3D",
+            "tamanho": 60,
+            "peso": 700,
+            "chaves": [
+              {
+                "t": 0,
+                "giroY": -60,
+                "opacidade": 0,
+                "x": -200
+              },
+              {
+                "t": 0.4,
+                "giroY": 0,
+                "opacidade": 1,
+                "x": 0
+              },
+              {
+                "t": 1,
+                "giroY": 20
+              }
+            ],
+            "suavizar": "elastico"
+          }
+        ]
+      }
+    ]
+  },
+  "atualizado": "2026-09-09T12:31:01+00:00"
+}

package/studio/edge.py

@@ -117,32 +117,81 @@ def disponivel():
     return _verificado
 
 
+# Por que a instalação falhava calada, e o vídeo saía com a voz do Google:
+# `pip install --user` é recusado pelo Python do sistema em Debian/Ubuntu e
+# no do Homebrew ("externally-managed-environment", PEP 668), e em máquina
+# sem pip o `-m pip` nem existe. Um `pip install` só, em segundo plano, com a
+# saída jogada fora, era exatamente a falha que ninguém vê. Agora são várias
+# tentativas, em ordem, e a última linha do erro de cada uma fica guardada
+# para o status contar o que houve.
+ESTRATEGIAS = [
+    ["-m", "pip", "install", "--user", "--quiet", "edge-tts"],
+    ["-m", "pip", "install", "--user", "--quiet", "--break-system-packages", "edge-tts"],
+    ["-m", "pip", "install", "--quiet", "edge-tts"],
+    ["-m", "pip", "install", "--quiet", "--break-system-packages", "edge-tts"],
+]
+_ultimo_erro = ""
+_thread = None
+
+
 def _rotina_instalar():
-    global _instalando, _verificado
+    global _instalando, _verificado, _ultimo_erro
     try:
-        subprocess.run(
-            [sys.executable, "-m", "pip", "install", "--user", "--quiet", "edge-tts"],
-            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=180)
-    except Exception as e:
-        sys.stderr.write("[edge] pip install falhou: %s\n" % e)
+        # Sem pip, primeiro o ensurepip — é o que o python.org e a Apple
+        # trazem para o caso.
+        try:
+            r = subprocess.run([sys.executable, "-m", "pip", "--version"],
+                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=30)
+            if r.returncode != 0:
+                subprocess.run([sys.executable, "-m", "ensurepip", "--user", "--default-pip"],
+                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=120)
+        except Exception:
+            pass
+        for args in ESTRATEGIAS:
+            try:
+                r = subprocess.run([sys.executable] + args, stdout=subprocess.DEVNULL,
+                                   stderr=subprocess.PIPE, timeout=240)
+            except Exception as e:
+                _ultimo_erro = str(e)[-200:]
+                continue
+            _verificado = None
+            if r.returncode == 0 and disponivel():
+                _ultimo_erro = ""
+                sys.stderr.write("[edge] edge-tts instalado (%s)\n" % " ".join(args[2:]))
+                return
+            _ultimo_erro = (r.stderr or b"").decode("utf-8", "replace").strip().splitlines()[-1:][0][-200:] \
+                if (r.stderr or b"").strip() else "pip devolveu %s" % r.returncode
+        sys.stderr.write("[edge] não consegui instalar o edge-tts: %s\n" % _ultimo_erro)
     finally:
         _verificado = None          # força nova checagem
         with _tranca:
             _instalando = False
 
 
-def instalar():
-    """Tenta trazer o pacote em segundo plano, uma vez. Não bloqueia: quem
-    pediu narração agora ouve o próximo motor da corrente, e a partir da
-    próxima vez o Edge já responde."""
-    global _instalando
+def instalar(esperar=0):
+    """Traz o pacote — em segundo plano por padrão; com `esperar` (segundos),
+    quem chamou fica aguardando até esse teto.
+
+    Esperar existe porque a narração de um vídeo NÃO pode sair pela voz de
+    reserva só porque o pip ainda estava rodando: quem pede voz agora e tem
+    internet merece a voz neural agora. Meio minuto de pip é menos ruim que
+    um vídeo inteiro com voz de robô."""
+    global _instalando, _thread
     if disponivel():
-        return
+        return True
     with _tranca:
-        if _instalando:
-            return
-        _instalando = True
-    threading.Thread(target=_rotina_instalar, daemon=True).start()
+        if not _instalando:
+            _instalando = True
+            _thread = threading.Thread(target=_rotina_instalar, daemon=True)
+            _thread.start()
+        t = _thread
+    if t and esperar:
+        t.join(esperar)
+    return disponivel()
+
+
+def ultimo_erro():
+    return _ultimo_erro
 
 
 def _dur_do_vtt(caminho):
@@ -215,6 +264,7 @@ def estado():
         "motor": "edge",
         "disponivel": disponivel(),
         "instalando": inst,
+        "erro": _ultimo_erro or None,
         "precisa_internet": True,
         "vozes": [{"id": v["id"], "nome": v["nome"], "genero": v["genero"],
                    "padrao": bool(v.get("padrao"))} for v in CATALOGO],

package/studio/ferramentas/01-modelos.md

@@ -89,12 +89,22 @@ um elemento flutuando por cima do layout.
 // path SVG numa caixa 24×24 (string ou lista de strings), no traço da casa
 { "tipo":"icone", "nome":"raio", "tamanho":120, "cor":"#ffb03a" }
 { "tipo":"icone", "caminho":"M3 6h18l-2 10H5zM8 20h.01M16 20h.01", "tamanho":96 }
+// como OBJETO: estilo "app" (azulejo de aplicativo) ou "vidro" (liquid glass)
+{ "tipo":"icone", "nome":"foguete", "estilo":"app", "tamanho":200, "fundo":"#8b5cf6" }
 
 // FORMA
 { "tipo":"forma", "forma":"retangulo", "x":200,"y":200,"l":400,"a":220,
   "preenchimento":"#ff5a36", "raio":24, "rotacao":-4, "opacidade":0.9 }
 // forma: retangulo | circulo | triangulo | linha | seta
 
+// MATERIAL — em qualquer elemento: "vidro" é o liquid glass (desfoca o que
+// está atrás, bisel de luz, reflexo). Na forma, preenchimento vira a tinta.
+{ "tipo":"forma", "forma":"retangulo", "material":"vidro", "raio":32, "x":100,"y":100,"l":800,"a":400 }
+
+// SOM — no elemento, toca quando ele entra: whoosh | impacto | click | pop |
+// ding | subida | tique | brilho, ou {"arquivo":"/midia/x.mp3","volume":0.8}
+{ "tipo":"numeros", "itens":["+38% | em 12 meses"], "contar":true, "som":"ding" }
+
 // CÓDIGO
 { "tipo":"codigo", "texto":"npm install primocode" }
 
@@ -186,8 +196,16 @@ completa em segundos (`0` deixa parado no `angulo` dado), `inclinar` levanta
 ou baixa a câmera, `cores` pinta face a face.
 
 Aceita `chaves` como qualquer elemento: dá para o cubo atravessar a cena
-girando. Use **um** por cena — dois objetos girando disputam o olho. Uma cena com tema diferente no meio cria respiro —
-use uma vez, não cinco.
+girando. Use **um** por cena — dois objetos girando disputam o olho.
+
+### Chaves de animação (motion)
+
+`chaves` em qualquer elemento: instantes de `t` 0 a 1 com `x`, `y`
+(deslocamento), `escala`, `escalaX`, `escalaY`, `giro`, **`giroX`, `giroY`,
+`prof`** (3D: vira em profundidade, aproxima da câmera), `opacidade`,
+`desfoque`. No elemento: `suavizar` (`suave` · `linear` · `entrada` · `saida`
+· `elastico` · `salto` · `degrau`), `repetir`, `vaiEVolta`. A spec do Corte
+tem os exemplos.
 
 ### Mídia do computador
 

package/studio/ferramentas/corte.md

@@ -181,40 +181,63 @@ narração, e uma disputa com quem fala em qualquer outro caso.
 `src` vem de `POST /api/midia` (upload) ou é uma URL direta de áudio.
 `inicio` pula os primeiros segundos da faixa.
 
-**Não baixe áudio de YouTube, Spotify ou similares** — quebra os termos dessas
-plataformas e o direito autoral da faixa. Use música do próprio usuário, faixa
-livre de direitos, ou uma das trilhas geradas acima.
+### Música da internet, com licença (`buscar_audio`)
 
----
+Uma faixa de verdade, tocada por gente, sem o usuário ter arquivo nenhum:
+`buscar_audio` procura no Openverse (Jamendo, Freesound, Wikimedia — licenças
+Creative Commons que permitem uso, inclusive comercial), **baixa** a melhor e
+devolve a URL `/midia/…` pronta:
 
-## Studio ou Remotion?
+```
+buscar_audio { "consulta": "upbeat corporate", "duracao": 30 }
+→ url "/midia/corporate-succes-8c2911.mp3", licenca "CC BY-SA",
+  credito "Corporate Succes — Arkadii Kaplan (CC BY-SA 3.0, via jamendo)"
+```
 
-**O padrão é o Studio.** Ele exporta o MP4 num clique, em segundos, sem
-instalar nada. Não ofereça Remotion sem motivo — trocar um clique por
-`npm install` de 250 MB é piorar a vida de quem só quer o vídeo.
+```json
+"trilha": { "tipo": "arquivo", "src": "/midia/corporate-succes-8c2911.mp3", "volume": 0.55, "repetir": true }
+```
 
-Chame `remotion_projeto` (com o `id` da peça) em três casos, e só neles:
+Consulta **em inglês**, pelo clima: `upbeat corporate`, `calm piano`, `epic
+cinematic`, `lofi chill`, `acoustic warm`. `duracao` é a do vídeo, para a faixa
+combinar. Para efeitos, `"tipo": "efeito"` (`whoosh`, `click`, `ding`,
+`swoosh`, `pop`) — a URL vai em `som: {"arquivo": …}`.
 
-1. **O usuário pediu Remotion pelo nome.** Não discuta, faça.
-2. **A peça precisa do que o Studio não dá:** render determinístico (o mesmo
-   arquivo em qualquer máquina, sem depender de a aba estar em foco), vídeo
-   muito longo, fps ou codec específico (ProRes, canal alfa), renderização em
-   servidor.
-3. **O usuário quer mexer no código.** O projeto que nasce é React, é dele, e
-   entra no git.
+**O crédito faz parte da peça.** Licença `CC BY`/`BY-SA` pede o crédito: ponha
+a linha `credito` da resposta na assinatura ou numa legenda pequena da última
+cena. `CC0` e domínio público não pedem nada. A resposta diz qual é o caso.
+Quando a busca não acha nada, use a trilha **gerada** — nunca um "parecido"
+de YouTube.
 
-A peça é a MESMA — `remotion_projeto` parte do documento que você já criou
-com `studio_criar`. Não existe um segundo formato para aprender: crie a peça
-normalmente, veja no navegador, e só então gere o projeto se fizer sentido.
+**Não baixe áudio de YouTube, Spotify ou similares** — quebra os termos dessas
+plataformas e o direito autoral da faixa. Use `buscar_audio`, música do próprio
+usuário ou uma das trilhas geradas acima.
 
-O projeto nasce sem `node_modules`. **Não rode `renderizar: true` antes de o
-`npm install` ter sido feito** — diga ao usuário os dois comandos e deixe ele
-decidir se quer esperar.
+---
 
-**Licença:** Remotion é grátis para pessoa física e empresa de até três
-pessoas; acima disso a empresa precisa de licença paga. Avise ao oferecer —
-descobrir isso depois de montar o fluxo de trabalho em cima seria péssimo.
-Isso vale para o projeto do usuário, não para o PrimoCode.
+## Studio E Remotion — os dois, mesclados
+
+**Não é uma escolha.** O Studio é quem AUTORA e mostra: a cena, o motion, a
+narração, a trilha gerada, os efeitos — o link "ver" é o vídeo, na hora. Quando
+o usuário pede o ARQUIVO (`studio_exportar`), o PrimoCode renderiza a mesma
+peça quadro a quadro pelo **Remotion** (instalado uma vez, sozinho, em
+`~/.primocode/remotion`) — determinístico, sem perder quadro, com todas as
+animações, chaves 3D, contagem e clipes no instante certo — e **mistura o
+áudio do Studio** (narração, trilha, efeitos sintetizados) no MP4 final. Você
+não escolhe motor: chama `studio_exportar` e recebe o arquivo.
+
+O primeiro vídeo que saiu só do Remotion estava **mudo e parado** — animações
+desligadas, só `trilha.src` como som. Foi por isso que a mescla existe: o
+Remotion sozinho não tem a narração nem a trilha gerada; o Studio sozinho
+grava em tempo real. Juntos, o arquivo sai como a prévia.
+
+`remotion_projeto` (com o `id` da peça) é OUTRA coisa: gera o **projeto React**
+na pasta do usuário, com as cenas, a mídia e o motion, para quem quer mexer no
+código, versionar no git ou renderizar em servidor. Só quando o usuário pedir
+isso — não é o jeito de gerar o arquivo. O projeto nasce sem `node_modules`;
+diga os dois comandos (`npm install`, `npm run render`) e deixe ele decidir. A
+trilha **gerada** e os sons **sintetizados** não existem no projeto solto
+(são WebAudio ao vivo): lá, use `buscar_audio` para ter a trilha em arquivo.
 
 ---
 
@@ -242,6 +265,15 @@ número, botão, detalhe, o cartão — e libera o fundo `"marca"`:
 "tema": "claro"
 ```
 
+**De onde vêm a cor e a logo: do site da empresa.** Antes de escrever a peça,
+chame `marca_da_empresa { "nome": "PicPay" }` (ou `"site": "https://…"`). Ela
+lê o site, baixa a logo para o estúdio e devolve `marca: {cor, logo}` pronta
+para colar, mais a paleta, as fontes e a frase da empresa. Não chute cor de
+marca nem peça o arquivo ao usuário antes de tentar isso — a logo está no
+site. Só quando a tool não achar (site montado por JavaScript, sem logo
+baixável) é que se pede o arquivo (`studio_midia`) ou se assina com o nome em
+texto.
+
 Tema CLARO na maioria dos anúncios de marca. O escuro é para a cena de
 produto e para a vitrine; o resto da peça respira no branco.
 
@@ -423,11 +455,38 @@ cena e a série ganha movimento sem esforço. `opcoes` marca a alternativa
 `certa` com ✓ (não escreva o ✓ no texto: ele vem sozinho). Alternativa faz o
 espectador pensar antes da resposta, e pensar é o que segura alguém no vídeo.
 
-### Vidro
+### Vidro — o liquid glass, em qualquer elemento
 
-`"estilo": "vidro"` em `cartoes` dá painel translúcido com bisel de luz em
-cima e sombra embaixo — o "liquid glass". Funciona em tema escuro; em tema
-claro use os cartões normais.
+`"material": "vidro"` em **qualquer** elemento: texto vira pílula de vidro,
+`forma` vira painel, `imagem` ganha moldura, `lista`/`cartoes`/`numeros`
+ganham fundo. É vidro de verdade: **desfoca o que está atrás** (o fundo
+`aurora`, a foto, o círculo colorido), tem o bisel de luz em cima e a sombra
+embaixo, e o reflexo diagonal atravessa devagar durante a cena.
+
+```json
+{ "tipo": "forma", "forma": "retangulo", "material": "vidro", "raio": 36,
+  "x": 120, "y": 140, "l": 860, "a": 420, "preenchimento": "#22d3ee" }
+{ "tipo": "texto", "material": "vidro", "texto": "pílula de vidro", "tamanho": 32 }
+```
+
+Na forma, `preenchimento` vira a **tinta** do vidro (fraca) — não pinta o
+fundo. `raio` arredonda (padrão 28). **Ponha algo atrás**: vidro sobre fundo
+liso é só um retângulo claro; sobre `aurora`, `brilho`, uma foto ou uma forma
+colorida, é o efeito. `"estilo": "vidro"` em `cartoes` continua valendo.
+
+### Ícone como objeto (`estilo: "app"` / `"vidro"`)
+
+```json
+{ "tipo": "icone", "nome": "foguete", "estilo": "app",   "tamanho": 220, "fundo": "#8b5cf6" }
+{ "tipo": "icone", "nome": "raio",    "estilo": "vidro", "tamanho": 220, "cor": "#ffb03a" }
+```
+
+`app` é o azulejo de aplicativo: gradiente da cor, brilho na metade de cima,
+sombra colorida embaixo, o traço branco. `vidro` é o mesmo azulejo em liquid
+glass. `fundo` pinta o azulejo (sem ele, a cor do tema). Um ícone de traço
+sozinho é sinal; no azulejo vira **coisa** — é o que se usa para "o app", "o
+produto", "o recurso" numa cena de lançamento. Combina com `som: "pop"` na
+entrada e com `chaves` de `giroY` para ele virar ao pousar.
 
 ---
 
@@ -647,11 +706,33 @@ Para controlar:
 
 ```json
 "sfx": false                  // no documento: desliga todos os efeitos
-{ "transicao": "deslizar", "sfx": "impacto" }   // na cena: força um efeito
+{ "transicao": "deslizar", "som": "impacto" }   // na cena: força um efeito
+```
+
+Valores: `"whoosh"` · `"impacto"` · `"click"` · `"pop"` · `"ding"` ·
+`"subida"` · `"tique"` · `"brilho"` · `"nenhum"`. (`sfx` na cena ainda vale;
+`som` é o nome novo, o mesmo dos elementos.)
+
+### Som por elemento — o que faz motion soar motion
+
+`"som"` num **elemento** toca no instante em que ele entra (o mesmo atraso da
+animação de entrada). É a diferença entre um slide animado e uma peça de
+motion: o número faz **ding** ao aparecer, o ícone faz **pop** ao pousar, a
+barra sobe com a **subida** (o riser) e o texto final chega com **brilho**.
+
+```json
+{ "tipo": "numeros", "itens": ["+38% | em 12 meses"], "contar": true, "som": "ding" }
+{ "tipo": "icone", "nome": "foguete", "estilo": "app", "som": "pop" }
+{ "tipo": "texto", "texto": "Agora.", "som": { "arquivo": "/midia/little-whoosh-3.mp3", "volume": 0.8 } }
+{ "tipo": "texto", "texto": "3, 2, 1", "som": { "nome": "tique", "em": 1.5 } }
 ```
 
-Valores por cena: `"whoosh"` · `"impacto"` · `"click"` · `"nenhum"`.
-O padrão (sem declarar nada) já é o certo para a maioria dos vídeos.
+`som` aceita o nome, ou `{ "arquivo": "/midia/…", "volume": 0–1 }` para um
+efeito baixado com `buscar_audio` (tipo `"efeito"`) ou enviado pelo usuário;
+`"em"` (segundos na cena) força o instante. O arquivo entra no mesmo grafo da
+trilha, então vai junto para o MP4. Regra: **um som por ideia, não por
+elemento** — três ou quatro por vídeo; tudo apitando é ruído, e a narração
+tem de continuar por cima.
 
 ---
 
@@ -684,8 +765,32 @@ Campos de uma chave, todos opcionais: `x` e `y` (**deslocamento** em pixels a
 partir de onde o elemento está — não é posição absoluta), `escala` (1 = tamanho
 normal), `giro` (graus), `opacidade` (0 a 1) e `desfoque` (pixels).
 
-No elemento: `"repetir": true` roda sem parar, e `"suavizar": false` dá
-movimento constante em vez de acelerar e frear.
+**Em 3D:** `giroY` e `giroX` (graus — o elemento vira em profundidade, como um
+cartão girando na mão), `prof` (pixels — aproxima ou afasta da câmera) e
+`escalaX`/`escalaY` (achatar num eixo só: a gota que pousa e se espalha).
+
+```json
+{ "tipo": "icone", "nome": "foguete", "estilo": "app", "tamanho": 220,
+  "chaves": [
+    { "t": 0,   "giroY": -90, "prof": -400, "opacidade": 0 },
+    { "t": 0.35, "giroY": 0,  "prof": 0,    "opacidade": 1 },
+    { "t": 1,   "giroY": 12 }
+  ], "suavizar": "elastico", "som": "pop" }
+```
+
+**A curva** (`suavizar`, no elemento): `"suave"` (padrão) · `"linear"` ·
+`"entrada"` (acelera) · `"saida"` (freia) · `"elastico"` (passa do ponto e
+volta — o pouso de app) · `"salto"` (recua, dispara e assenta) · `"degrau"`
+(quadro a quadro, stop-motion). Aceita também um `cubic-bezier(…)` cru.
+`"repetir": true` roda sem parar; com `"vaiEVolta": true` ele vai e volta em
+vez de recomeçar — é a levitação de um objeto.
+
+Um exemplo de cada coisa que motion pede — **entrar de lado, respirar, sair**:
+
+```json
+"chaves": [ { "t": 0, "x": -300, "opacidade": 0 }, { "t": 0.2, "x": 0, "opacidade": 1 },
+            { "t": 0.85, "x": 0, "opacidade": 1 }, { "t": 1, "x": 120, "opacidade": 0 } ]
+```
 
 Duas chaves já bastam. Quem tem `chaves` ignora `anim` — as duas disputariam o
 mesmo movimento, e a chave é mais específica. Use em **um ou dois** elementos

package/studio/ferramentas/tela.md

@@ -61,6 +61,27 @@ você controla cada `x`, `y`, `l`, `a` em pixels da tela.
 `globo` `chave` `presente` `sino` `mapa` `dinheiro` `crescimento` `grafico` `balao`
 `pasta` `livro` `play2` `check` `imagem` `codigo` `tabela` `lista`
 
+## Vidro e ícone-objeto
+
+`"material": "vidro"` em qualquer elemento é o liquid glass: painel
+translúcido que **desfoca o que está atrás**, com bisel de luz em cima e
+reflexo diagonal. Precisa de algo atrás (gradiente, forma colorida, foto) para
+aparecer. Na forma, `preenchimento` vira a tinta do vidro.
+
+```json
+{ "tipo": "forma", "forma": "retangulo", "material": "vidro", "raio": 32,
+  "x": 86, "y": 300, "l": 908, "a": 380, "preenchimento": "#ff5a36" }
+```
+
+`"estilo": "app"` no ícone faz o azulejo de aplicativo (gradiente da cor,
+brilho, sombra, traço branco); `"estilo": "vidro"` faz o mesmo azulejo em
+vidro. `fundo` pinta o azulejo. É o ícone de produto para capa e post de
+lançamento:
+
+```json
+{ "tipo": "icone", "nome": "foguete", "estilo": "app", "x": 86, "y": 120, "tamanho": 200, "fundo": "#8b5cf6" }
+```
+
 ## Várias artes no mesmo arquivo
 
 Cada item de `cenas` é uma prancha independente. Um carrossel de Instagram é um