primocode 10.4.7 → 10.6.0

package/lib/estudio/kit.js

@@ -61,9 +61,13 @@ const PECAS = {
     fluido: { precisa: ['partitura'] },
     // O vídeo gravado em 3D (kit/personagem.jsx): o set, os personagens e a câmera (personagem.js).
     personagem: { precisa: ['partitura'] },
+    // O mesmo vídeo gravado, no visual de blocos da referência (kit/voxel.jsx): o padrão desde a 10.5.
+    voxel: { precisa: ['partitura'] },
+    // A animação pronta da biblioteca (kit/animacao.jsx, colecao.js): o Lottie tocado quadro a quadro.
+    animacao: { precisa: ['src'] },
 };
 
-const ARQUIVOS = ['base.jsx', 'vox.jsx', 'marca.jsx', 'tres.jsx', 'gerativo.jsx', 'fluido.jsx', 'personagem.jsx', 'index.jsx'];
+const ARQUIVOS = ['base.jsx', 'vox.jsx', 'marca.jsx', 'tres.jsx', 'gerativo.jsx', 'fluido.jsx', 'personagem.jsx', 'mundo.jsx', 'voxel.jsx', 'animacao.jsx', 'index.jsx'];
 
 /** Os arquivos do kit, para o projeto Remotion: [{nome: 'kit/base.jsx', conteudo}]. */
 function arquivos() {

package/lib/estudio/kokoro.js

@@ -87,11 +87,25 @@ async function narrar(lista, mp3, { voz, uv, espeak = acharEspeak(), executar =
     }
 }
 
-/** A ordem das vozes: pedida → Kokoro e depois o Edge; senão Gemini → Kokoro → Edge.
-    `motorVoz: 'edge'` no roteiro pula as outras. */
+/** A ordem das vozes: pedida → Kokoro e depois o Edge; senão Gemini → Edge → Kokoro.
+    O Edge (vozes neurais da Microsoft, ou a ElevenLabs quando há chave) vem
+    ANTES do Kokoro desde 11/10: com a cota do Gemini no fim, o Kokoro em
+    português era a "voz robótica" que a pessoa ouvia. `motorVoz: 'edge'` no
+    roteiro pula as outras. */
 function ordem(voz, env = process.env, { soEdge = false } = {}) {
     if (soEdge) return ['edge'];
-    return querKokoro(voz, env) ? ['kokoro', 'edge'] : ['gemini', 'kokoro', 'edge'];
+    return querKokoro(voz, env) ? ['kokoro', 'edge'] : ['gemini', 'edge', 'kokoro'];
+}
+
+/* A voz do Gemini no Edge: o narrar.py só conhece antonio, francisca e
+   thalita — o nome do Gemini ("Kore") caía na primeira, e toda fala de mulher
+   saía na voz do Antonio. Mantém o GÊNERO de quem fala. */
+const GEMINI_FEMININAS = new Set(['kore', 'aoede', 'leda', 'zephyr', 'sulafat', 'achird', 'despina', 'erinome', 'laomedeia', 'pulcherrima', 'vindemiatrix', 'callirrhoe', 'autonoe', 'gacrux']);
+function vozNoEdge(voz, reserva = 'thalita') {
+    const v = String(voz || '').trim().toLowerCase();
+    if (['antonio', 'francisca', 'thalita'].includes(v)) return v;
+    if (!v || querKokoro(v, {})) return reserva;
+    return GEMINI_FEMININAS.has(v) ? 'francisca' : 'antonio';
 }
 
 /** Roda a corrente: a primeira voz que der certo ganha; a falha de uma nunca derruba. */
@@ -108,4 +122,4 @@ async function corrente(passos, provedores) {
     return ultimo;
 }
 
-module.exports = { querKokoro, pronuncia, vozKokoro, acharEspeak, comando, narrar, ordem, corrente, DEPS, SCRIPT };
+module.exports = { vozNoEdge, querKokoro, pronuncia, vozKokoro, acharEspeak, comando, narrar, ordem, corrente, DEPS, SCRIPT };

package/lib/estudio/margem.js

@@ -44,7 +44,7 @@ function areaSegura(W, H, m = MARGEM) {
 /* As peças do kit que são o QUADRO inteiro (textura, padrão, o gerativo que
    tem a própria conta) ou enfeite de fundo. */
 const PECAS_FUNDO = new Set(['textura', 'padrao', 'particulas', 'papel', 'grade', 'orbe', 'cromo', 'esfera', 'estrela',
-    'gerativo', 'fluido', 'personagem', 'site']);
+    'gerativo', 'fluido', 'personagem', 'voxel', 'site']);
 
 const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
 

package/lib/estudio/mundo.js

@@ -0,0 +1,305 @@
+/**
+ * mundo.js — o lugar, os bichos e as coisas do vídeo 3D, a partir do PEDIDO.
+ *
+ *   "não quero que ele só troque as falas e os textos ... se eu pedir dois
+ *    humanos ele vai fazer dois humanos, se eu pedir um cachorro ele vai fazer,
+ *    se eu pedir um humano na praia ele vai fazer — vai mudar o cenário, vai
+ *    mudar as coisas, e não é coisa pré-definida" (Joel, 11/10)
+ *
+ * Até a 10.5 o 3D tinha UM set (a parede de telas) e o elenco era gente ou o
+ * mascote. Aqui o set vira um MUNDO montado de peças:
+ *
+ *   · o LUGAR (praia, cidade, floresta, espaço, cozinha…): céu, chão, água,
+ *     luz e hora do dia; vem do texto livre ("numa praia ao pôr do sol");
+ *   · os ELEMENTOS: o que há no lugar. Uma palavra do catálogo (palmeira, carro,
+ *     prédio, foguete…) vira uma peça de blocos desenhada no kit/mundo.jsx; uma
+ *     palavra FORA do catálogo vira um ícone 3D da biblioteca (colecao.js,
+ *     1.595 objetos) transformado em blocos na hora do render — é isso que
+ *     tira o "pré-definido": qualquer coisa que tenha ícone entra na cena;
+ *   · o ELENCO: pessoa, robô/mascote, BICHO (cachorro, gato, cavalo, vaca,
+ *     pinguim, peixe, dinossauro… — o kit/mundo.jsx monta cada espécie) ou
+ *     COISA (um ícone em blocos que fala: "uma pizza conversando com um café").
+ *     E os FIGURANTES: quem está na cena sem falar ("um humano com o cachorro").
+ *
+ * A IA decide (roteiro.cena, roteiro.personagens, parte.cenario); o que ela
+ * não disse sai do texto do pedido e das falas — a mesma regra do resto do
+ * Estúdio: o modelo manda, a leitura do texto só completa. É o que faz um
+ * modelo local pequeno, que só escreve as falas, ainda ganhar a praia que a
+ * pessoa pediu.
+ */
+
+'use strict';
+
+const sem = (s) => String(s || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
+
+/* ── OS LUGARES ─────────────────────────────────────────────────────────
+   ceu: [alto, horizonte] · chao: {tipo, cor, cor2} · agua: cor do mar ·
+   dentro: set fechado (parede no fundo) · props: o que o lugar tem quando a
+   cena não disse. As palavras são lidas sem acento. */
+const LUGARES = {
+    /* A COBERTURA À NOITE (2ª referência do Joel, 11/10): a janela de vidro
+       com a cidade acesa lá fora, as luzes grandes desfocadas (bokeh), o
+       parapeito escuro e os CARTÕES de interface flutuando na frente (o
+       assunto do vídeo, desfocados pela lente). É o set padrão quando o
+       pedido não diz lugar. */
+    cobertura: { palavras: /\b(cobertura|terraco|rooftop|janela|vista da cidade|apartamento alto|predio alto|escritorio a noite)\b/, dentro: true, cobertura: true,
+        parede: '#050816', chao: { tipo: 'madeira', cor: '#2a1f1a', cor2: '#241a16' }, luz: '#ffd2b0', recorte: '#6f8bff', acento: '#ff6a2b', props: [] },
+    telas: { palavras: /\b(estudio|podcast|tecnologia|telas?|set|programa|live|transmissao)\b/, dentro: true, telas: true,
+        parede: '#07061a', chao: { tipo: 'ladrilho', cor: '#4338ca', cor2: '#3b32b8' }, luz: '#ffd2b0', recorte: '#8b7bff', acento: '#ff7a45', props: [] },
+    praia: { palavras: /\b(praia|mar|litoral|beira[ -]mar|areia|orla|surf\w*|ilha)\b/, ceu: ['#3d8fe0', '#c4e8ff'], agua: '#1d8bc9',
+        chao: { tipo: 'areia', cor: '#ead29c', cor2: '#dfc48a' }, luz: '#fff2d6', recorte: '#ffd08a', acento: '#ff7a45', sol: true,
+        props: ['palmeira', 'palmeira', 'guarda-sol', 'cadeira de praia', 'palmeira', 'castelo de areia', 'pedra'] },
+    cidade: { palavras: /\b(cidade|rua|avenida|centro|predios?|esquina|calcada|metropole|urbano)\b/, ceu: ['#5b9be6', '#dbeaff'],
+        chao: { tipo: 'asfalto', cor: '#5b5e67', cor2: '#53565f' }, luz: '#fff1dc', recorte: '#9fc3ff', acento: '#facc15', sol: true,
+        props: ['predio', 'predio', 'predio', 'poste', 'carro', 'arvore', 'predio', 'poste', 'carro', 'predio'] },
+    floresta: { palavras: /\b(floresta|mata|selva|bosque|trilha|acampamento|amazonia)\b/, ceu: ['#6fb3e8', '#dcf2d6'],
+        chao: { tipo: 'grama', cor: '#4f9a3c', cor2: '#468c35' }, luz: '#fff0d0', recorte: '#b6f0a0', acento: '#facc15', sol: true, neblina: 0.6,
+        props: ['arvore', 'pinheiro', 'arvore', 'pinheiro', 'arbusto', 'pedra', 'arvore', 'pinheiro', 'cogumelo', 'arvore'] },
+    parque: { palavras: /\b(parque|jardim|praca|gramado|piquenique)\b/, ceu: ['#58a6ee', '#d9eeff'],
+        chao: { tipo: 'grama', cor: '#5aa845', cor2: '#4f9a3c' }, luz: '#fff2d6', recorte: '#c8f0b0', acento: '#f472b6', sol: true,
+        props: ['arvore', 'banco', 'flor', 'arvore', 'poste', 'flor', 'arbusto', 'arvore', 'flor'] },
+    fazenda: { palavras: /\b(fazenda|sitio|roca|interior|celeiro|curral|plantacao|colheita)\b/, ceu: ['#68aef0', '#f3ecd0'],
+        chao: { tipo: 'grama', cor: '#6aa84f', cor2: '#5e9a44' }, luz: '#fff1d0', recorte: '#ffe0a0', acento: '#dc2626', sol: true,
+        props: ['celeiro', 'cerca', 'cerca', 'arvore', 'feno', 'cerca', 'arvore', 'feno'] },
+    neve: { palavras: /\b(neve|inverno|gelo|polo|nevando|esqui|frio)\b/, ceu: ['#9fbfe6', '#eef4fb'],
+        chao: { tipo: 'neve', cor: '#f4f8fc', cor2: '#e6eef6' }, luz: '#eef4ff', recorte: '#a8c8ff', acento: '#38bdf8', sol: true,
+        props: ['pinheiro nevado', 'pinheiro nevado', 'boneco de neve', 'montanha', 'pinheiro nevado', 'pedra', 'pinheiro nevado'] },
+    deserto: { palavras: /\b(deserto|duna|sertao|saara|oasis)\b/, ceu: ['#f0a35a', '#ffe2ae'],
+        chao: { tipo: 'areia', cor: '#e2b06c', cor2: '#d6a05c' }, luz: '#ffe6c0', recorte: '#ffb070', acento: '#ea580c', sol: true,
+        props: ['cacto', 'cacto', 'pedra', 'montanha', 'cacto', 'pedra'] },
+    espaco: { palavras: /\b(espaco|lua|planeta|galaxia|foguete|astronauta|marte|orbita|estrelas|universo|nave)\b/, ceu: ['#02020f', '#0d0b2c'], estrelas: true,
+        chao: { tipo: 'lua', cor: '#a1a1ad', cor2: '#90909c' }, luz: '#e8ecff', recorte: '#8b7bff', acento: '#a78bfa',
+        props: ['planeta', 'foguete', 'pedra', 'planeta', 'cratera', 'pedra'] },
+    fundo_do_mar: { palavras: /\b(fundo do mar|submarino|oceano|aquario|mergulh\w*|recife|coral)\b/, ceu: ['#022c46', '#0b6f94'], subaquatico: true,
+        chao: { tipo: 'areia', cor: '#c9b98a', cor2: '#bba97a' }, luz: '#bfefff', recorte: '#38bdf8', acento: '#f97316', neblina: 1,
+        props: ['alga', 'coral', 'pedra', 'alga', 'coral', 'bau', 'alga'] },
+    escritorio: { palavras: /\b(escritorio|trabalho|reuniao|empresa|firma|coworking|startup)\b/, dentro: true, parede: '#d8d0c2',
+        chao: { tipo: 'madeira', cor: '#9a7350', cor2: '#8d6846' }, luz: '#fff1dc', recorte: '#ffe2b8', acento: '#2563eb',
+        props: ['mesa', 'computador', 'planta', 'estante', 'cadeira', 'quadro'] },
+    sala: { palavras: /\b(sala|casa|sofa|quarto|lar|apartamento|sala de estar)\b/, dentro: true, parede: '#e6d6c3',
+        chao: { tipo: 'madeira', cor: '#a87b52', cor2: '#9a6e47' }, luz: '#ffe8c8', recorte: '#ffd6a0', acento: '#e11d48',
+        props: ['sofa', 'luminaria', 'planta', 'estante', 'tapete', 'quadro'] },
+    cozinha: { palavras: /\b(cozinha|restaurante|padaria|cafeteria|cafe|lanchonete|confeitaria|pizzaria|bar)\b/, dentro: true, parede: '#efe4d2',
+        chao: { tipo: 'ladrilho', cor: '#e8e1d4', cor2: '#cfc5b4' }, luz: '#fff0d6', recorte: '#ffd9a0', acento: '#dc2626',
+        props: ['balcao', 'mesa', 'cadeira', 'planta', 'estante', 'luminaria'] },
+    escola: { palavras: /\b(escola|sala de aula|aula|professor|faculdade|universidade|colegio)\b/, dentro: true, parede: '#dfe8dc',
+        chao: { tipo: 'madeira', cor: '#b08458', cor2: '#a3794f' }, luz: '#fffaf0', recorte: '#d6f0ff', acento: '#16a34a',
+        props: ['lousa', 'mesa', 'mesa', 'estante', 'planta'] },
+    palco: { palavras: /\b(palco|show|teatro|concerto|festa|balada|evento)\b/, dentro: true, parede: '#0b0612',
+        chao: { tipo: 'madeira', cor: '#3a2a20', cor2: '#33251c' }, luz: '#ffe1f5', recorte: '#ff4fd8', acento: '#22d3ee', holofotes: true,
+        props: ['caixa de som', 'caixa de som', 'luminaria'] },
+    campo: { palavras: /\b(campo|montanhas?|colina|natureza|ao ar livre|vale)\b/, ceu: ['#5aa3ec', '#dcefff'],
+        chao: { tipo: 'grama', cor: '#5ca846', cor2: '#529b3e' }, luz: '#fff2d6', recorte: '#c8f0b0', acento: '#facc15', sol: true,
+        props: ['montanha', 'arvore', 'flor', 'arvore', 'pedra', 'montanha', 'flor'] },
+};
+// O que o set antigo chamava por outro nome.
+const APELIDOS_LUGAR = { neon: 'palco', oceano: 'fundo_do_mar', terra: 'deserto', podcast: 'telas', estudio: 'telas', noite: 'telas' };
+
+const HORAS = {
+    noite: { palavras: /\b(noite|noturn\w*|madrugada|luar|a noite|de noite)\b/, ceu: ['#070b24', '#1c2552'], luz: '#b8c6ff', forca: 0.45, lua: true, estrelas: true },
+    por_do_sol: { palavras: /\b(por do sol|entardecer|fim de tarde|crepusculo|poente|anoitecer)\b/, ceu: ['#46368a', '#ff9a5a'], luz: '#ffb27a', forca: 0.8, solBaixo: true },
+    amanhecer: { palavras: /\b(amanhecer|nascer do sol|alvorada|de manha cedo)\b/, ceu: ['#6a8fd8', '#ffd2a8'], luz: '#ffd9b0', forca: 0.85, solBaixo: true },
+};
+
+/* ── O CATÁLOGO DE PEÇAS (kit/mundo.jsx desenha cada uma) ───────────────
+   A chave é a peça; as palavras são como a pessoa (ou a IA) diz. */
+const PECAS = {
+    palmeira: /\bpalmeiras?|coqueiros?\b/, arvore: /\barvores?|arvorezinha\b/, pinheiro: /\bpinheiros?\b/, 'pinheiro nevado': /\bpinheiros? nevados?\b/,
+    arbusto: /\barbustos?|moitas?\b/, flor: /\bflor(es)?\b/, pedra: /\bpedras?|rochas?\b/, cacto: /\bcactos?\b/, montanha: /\bmontanhas?|morros?\b/,
+    casa: /\bcasas?|casinha\b/, predio: /\bpredios?|edificios?|arranha[- ]ceus?\b/, celeiro: /\bceleiros?\b/, poste: /\bpostes?\b/,
+    carro: /\bcarros?|automove(l|is)\b/, 'guarda-sol': /\bguarda[- ]sois?|guarda[- ]sol\b/, 'cadeira de praia': /\bcadeiras? de praia\b/,
+    'castelo de areia': /\bcastelos? de areia\b/, mesa: /\bmesas?\b/, cadeira: /\bcadeiras?\b/, sofa: /\bsofas?\b/, planta: /\bplantas?|vasos?\b/,
+    estante: /\bestantes?|prateleiras?\b/, computador: /\bcomputador(es)?|notebooks?|pc\b/, luminaria: /\bluminarias?|abajur\b/,
+    quadro: /\bquadros?\b/, lousa: /\blousas?|quadro negro\b/, balcao: /\bbalca(o|oes)\b/, tapete: /\btapetes?\b/, banco: /\bbancos? de praca|banquinhos?\b/,
+    cerca: /\bcercas?\b/, feno: /\bfenos?\b/, 'boneco de neve': /\bbonecos? de neve\b/, foguete: /\bfoguetes?\b/, planeta: /\bplanetas?\b/,
+    cratera: /\bcrateras?\b/, alga: /\balgas?\b/, coral: /\bcorais?|coral\b/, bau: /\bbaus?|tesouros?\b/, cogumelo: /\bcogumelos?\b/,
+    nuvem: /\bnuvens?\b/, fogueira: /\bfogueiras?\b/, barraca: /\bbarracas?|tendas?\b/, barco: /\bbarcos?|canoas?\b/,
+    'caixa de som': /\bcaixas? de som|alto[- ]falantes?\b/,
+};
+
+/* ── AS ESPÉCIES (kit/mundo.jsx monta cada uma de blocos) ────────────── */
+const ESPECIES = {
+    cachorro: /\b(cachorr\w*|cao|caes|cachorrinho|dog|vira[- ]lata|labrador|filhote)\b/, gato: /\b(gat[oa]s?|gatinh\w*|felino)\b/,
+    cavalo: /\b(caval\w*|egua|potro|pônei|ponei)\b/, vaca: /\b(vacas?|boi|bois|touro|bezerro)\b/, porco: /\b(porc\w*|leitao)\b/,
+    ovelha: /\b(ovelhas?|carneiros?|cordeiro)\b/, raposa: /\b(raposas?)\b/, lobo: /\b(lob[oa]s?)\b/, urso: /\b(urs[oa]s?)\b/,
+    panda: /\b(pandas?)\b/, coelho: /\b(coelh\w*)\b/, leao: /\b(leao|leoes|leoa)\b/, tigre: /\b(tigres?)\b/, elefante: /\b(elefantes?)\b/,
+    girafa: /\b(girafas?)\b/, galinha: /\b(galinhas?|galos?|pintinhos?)\b/, pato: /\b(pat[oa]s?|patinho)\b/, pinguim: /\b(pinguins?)\b/,
+    passaro: /\b(passar\w*|ave|aves|passarinho)\b/, papagaio: /\b(papagaios?|arara)\b/, coruja: /\b(corujas?)\b/,
+    peixe: /\b(peixes?|peixinho)\b/, tubarao: /\b(tubara(o|oes))\b/, golfinho: /\b(golfinhos?)\b/, tartaruga: /\b(tartarugas?|jabuti)\b/,
+    dinossauro: /\b(dinossauros?|dino|t[- ]?rex)\b/, sapo: /\b(sapos?|ra)\b/, macaco: /\b(macac\w*)\b/,
+};
+
+const PESSOA = /\b(humanos?|pessoas?|homens?|mulher(es)?|menin[oa]s?|crianc\w*|amig[oa]s?|garot[oa]s?|rapaz|mo[cç][oa]s?|senhor(a|es)?|vov[oóô]|av[oóô]s?|casal|familia|cliente|vendedor\w*|professor\w*|alun[oa]s?|medic[oa]s?|astronautas?|surfistas?|chef|cozinheir[oa]s?)\b/;
+const ROBO = /\b(robo|robos|ia|inteligencia artificial|mascote|claude|chatgpt|gpt|gemini|assistente|bot)\b/;
+const NUMEROS = { um: 1, uma: 1, dois: 2, duas: 2, tres: 3, quatro: 4, cinco: 5, casal: 2, par: 2 };
+
+function contar(texto, re) {
+    // "dois humanos", "3 cachorros", "um casal": o número logo antes da palavra.
+    const s = sem(texto);
+    if (re === PESSOA && /\b(um )?casal\b/.test(s)) return 2;
+    const m = new RegExp(`(\\d+|um|uma|dois|duas|tres|quatro|cinco)\\s+(?:\\w+\\s+)?${re.source.replace(/^\\b|\\b$/g, '')}`).exec(s);
+    if (m) return Math.min(4, Number(m[1]) || NUMEROS[m[1]] || 1);
+    return re.test(s) ? 1 : 0;
+}
+
+/** O lugar e a hora que o texto pede, ou null. */
+function lerLugar(texto) {
+    const s = sem(texto);
+    let lugar = null, onde = -1;
+    // O mais específico primeiro: "fundo do mar" antes de "mar", "sala de aula" antes de "sala".
+    const ordem = ['cobertura', 'fundo_do_mar', 'escola', 'praia', 'espaco', 'neve', 'deserto', 'fazenda', 'floresta', 'parque', 'cidade', 'cozinha', 'escritorio', 'palco', 'sala', 'campo', 'telas'];
+    for (const n of ordem) { const m = LUGARES[n].palavras.exec(s); if (m) { lugar = n; onde = m.index; break; } }
+    /* A hora vale para AQUELE lugar: "na praia, depois na cidade à noite" é
+       praia de dia. Com lugar no texto, só a hora a até 40 letras dele. */
+    let hora = null;
+    for (const [n, h] of Object.entries(HORAS)) {
+        const m = h.palavras.exec(s);
+        if (!m) continue;
+        if (onde < 0) { hora = n; break; }
+        // Outro lugar no meio ("praia, depois vão pra cidade à noite"): a hora é DELE.
+        const entre = s.slice(Math.min(m.index, onde) + 1, Math.max(m.index, onde));
+        const outroLugar = Object.entries(LUGARES).some(([k, L]) => k !== lugar && L.palavras.test(entre));
+        if (!outroLugar && Math.abs(m.index - onde) <= 40) { hora = n; break; }
+    }
+    return { lugar, hora };
+}
+
+/** As peças do catálogo e os bichos que o texto cita (em ordem de aparição). */
+function lerCoisas(texto) {
+    const s = sem(texto);
+    const pecas = [];
+    for (const [nome, re] of Object.entries(PECAS)) {
+        const m = re.exec(s);
+        if (m) pecas.push({ nome, em: m.index });
+    }
+    // "pinheiro nevado" ganha de "pinheiro"; "cadeira de praia" ganha de "cadeira".
+    const filtradas = pecas.filter((p) => !pecas.some((q) => q !== p && q.nome.startsWith(p.nome + ' ') && Math.abs(q.em - p.em) < 3)
+        && !pecas.some((q) => q !== p && q.nome.includes(p.nome) && q.nome !== p.nome && Math.abs(q.em - p.em) < 12));
+    const bichos = [];
+    for (const [esp, re] of Object.entries(ESPECIES)) {
+        const m = re.exec(s);
+        if (m) bichos.push({ especie: esp, em: m.index, quantos: contar(texto, re) || 1 });
+    }
+    return { pecas: filtradas.sort((a, b) => a.em - b.em).map((p) => p.nome), bichos: bichos.sort((a, b) => a.em - b.em) };
+}
+
+/** O que o PEDIDO descreve do elenco: quantas pessoas, que bichos, se há IA. */
+function lerElenco(texto) {
+    const s = sem(texto);
+    const { bichos } = lerCoisas(texto);
+    return { pessoas: contar(texto, PESSOA), robo: ROBO.test(s), bichos };
+}
+
+/* ── O MUNDO MONTADO ────────────────────────────────────────────────────
+   A peça é posta numa faixa ATRÁS e DOS LADOS do elenco, nunca no corredor
+   entre a câmera e quem fala. Com mar, a faixa é a areia antes da água. */
+function rngDe(semente) {
+    let s = (Number(semente) >>> 0) || 1;
+    return () => { s = (Math.imul(s ^ (s >>> 15), 2246822507) + 0x9e3779b9) >>> 0; return s / 4294967296; };
+}
+
+const ehCor = (c) => typeof c === 'string' && /^#[0-9a-f]{6}$/i.test(c);
+
+function posicionar(nomes, { semente = 1, agua = false, dentro = false, largura = 1 } = {}) {
+    const r = rngDe(semente);
+    const out = [];
+    const livre = (x, z, raio) => out.every((p) => Math.hypot(p.x - x, p.z - z) > raio + (p.raio || 0.8));
+    nomes.forEach((nome, i) => {
+        const grande = /predio|montanha|celeiro|planeta|foguete|palmeira|pinheiro|arvore/.test(typeof nome === 'string' ? nome : '');
+        const raio = grande ? 1.3 : 0.75;
+        for (let tent = 0; tent < 40; tent++) {
+            let x, z;
+            if (dentro) {
+                // Encostado na parede do fundo ou nos lados do set.
+                x = (r() * 2 - 1) * 4.6 * largura; z = -3.1 + r() * 0.9;
+                if (Math.abs(x) < 1.7 && tent < 30) continue;
+            } else if (agua) {
+                const lado = i % 2 ? 1 : -1;
+                x = lado * (1.9 + r() * 4.5) * largura; z = -4.2 + r() * 3.6;
+            } else {
+                const lado = i % 2 ? 1 : -1;
+                const longe = grande ? 0.55 + r() * 0.45 : r();
+                x = lado * (1.8 + r() * 5.5) * largura; z = -1.6 - longe * 9;
+                if (r() < 0.25 && !grande) { x = lado * (2.2 + r() * 1.5); z = -0.4 + r() * 1.4; }
+            }
+            if (!livre(x, z, raio) && tent < 39) continue;
+            out.push({ x: Math.round(x * 100) / 100, z: Math.round(z * 100) / 100, raio, giro: Math.round((r() * 2 - 1) * 60) / 100, escala: Math.round((0.85 + r() * 0.35) * 100) / 100 });
+            break;
+        }
+    });
+    return out;
+}
+
+/**
+ * O mundo de um trecho do vídeo.
+ * @param {string|object} pedido  "praia ao pôr do sol" ou {lugar, hora, elementos, ceu, chao, ...}
+ * @param {object} op  {texto (o pedido e as falas: completa o lugar), pedidoTexto (só o
+ *                      pedido da pessoa: as coisas que ele cita entram na cena), semente, nElenco}
+ */
+function mundoDe(pedido, { texto = '', pedidoTexto = '', semente = 1, nElenco = 1 } = {}) {
+    const obj = pedido && typeof pedido === 'object' ? pedido : { lugar: String(pedido || '') };
+    const descr = [obj.lugar, obj.descricao, obj.hora].filter(Boolean).join(' ');
+    let { lugar, hora } = lerLugar(descr);
+    const nomeDireto = sem(obj.lugar).replace(/\s+/g, '_');
+    if (!lugar && LUGARES[nomeDireto]) lugar = nomeDireto;
+    if (!lugar && APELIDOS_LUGAR[nomeDireto]) lugar = APELIDOS_LUGAR[nomeDireto];
+    // Sem lugar no pedido da cena, o texto do vídeo (o pedido da pessoa e as falas) completa.
+    const doTexto = lerLugar(texto);
+    if (!lugar) lugar = doTexto.lugar || 'cobertura';
+    if (!hora) hora = doTexto.hora;
+    if (APELIDOS_LUGAR[lugar]) lugar = APELIDOS_LUGAR[lugar];
+    const L = LUGARES[lugar];
+    const H = hora && !L.dentro ? HORAS[hora] : null;
+
+    // Os elementos: os que a cena listou (qualquer palavra) + os que o texto cita + os do lugar.
+    const pedidos = Array.isArray(obj.elementos) ? obj.elementos.map((e) => (typeof e === 'string' ? e : (e && (e.nome || e.tipo)) || '')).filter(Boolean) : [];
+    // As falas citam coisa de passagem ("comprei um carro"): só o PEDIDO põe coisa na cena.
+    const citados = lerCoisas([descr, pedidoTexto, Array.isArray(obj.elementos) ? '' : String(obj.elementos || '')].join(' ')).pecas;
+    const nomes = [];
+    for (const e of [...pedidos, ...citados]) {
+        const s = sem(e).trim();
+        const peca = Object.keys(PECAS).find((k) => PECAS[k].test(s) || sem(k) === s);
+        nomes.push(peca ? { peca } : { icone: s.slice(0, 40) });
+    }
+    // O lugar completa até 7 peças: a cena nunca fica vazia, e o que a IA pediu vem primeiro.
+    for (const p of L.props) if (nomes.length < 7 || nomes.length < L.props.length) nomes.push({ peca: p });
+    const lugares = posicionar(nomes.map((n) => n.peca || n.icone), { semente, agua: !!L.agua, dentro: !!L.dentro, largura: nElenco > 2 ? 1.25 : 1 });
+    const props = nomes.slice(0, lugares.length).map((n, i) => ({ ...n, ...lugares[i] }));
+
+    const ceu = Array.isArray(obj.ceu) && obj.ceu.every(ehCor) ? obj.ceu : (H ? H.ceu : L.ceu) || null;
+    const chao = { ...L.chao, ...(obj.chao && typeof obj.chao === 'object' ? obj.chao : {}), ...(ehCor(obj.chao) ? { cor: obj.chao, cor2: obj.chao } : {}) };
+    return {
+        nome: lugar + (H ? ':' + hora : ''), lugar, hora: H ? hora : null,
+        dentro: !!L.dentro, telas: !!L.telas, cobertura: !!L.cobertura, parede: ehCor(obj.parede) ? obj.parede : L.parede || null,
+        ceu, chao, agua: L.agua || null, subaquatico: !!L.subaquatico, holofotes: !!L.holofotes,
+        sol: !!(L.sol && !(H && H.lua)), solBaixo: !!(H && H.solBaixo), lua: !!(H && H.lua), estrelas: !!(L.estrelas || (H && H.estrelas)),
+        neblina: L.neblina || 0,
+        luz: ehCor(obj.luz) ? obj.luz : (H ? H.luz : L.luz), forca: H ? H.forca : 1,
+        recorte: L.recorte, acento: ehCor(obj.acento) ? obj.acento : L.acento,
+        props,
+    };
+}
+
+/** Os ícones que o mundo e o elenco precisam baixar (colecao.js) antes do render. */
+function iconesPendentes(partitura) {
+    const out = new Set();
+    for (const m of partitura.mundos || []) for (const p of m.props) if (p.icone && !p.src) out.add(p.icone);
+    for (const e of [...(partitura.elenco || []), ...(partitura.figurantes || [])]) if (e.tipo === 'coisa' && !e.src) out.add(e.icone);
+    return [...out];
+}
+
+/** Põe o PNG baixado em cada peça e personagem que pediu aquele ícone; o que não achou ícone sai da cena. */
+function aplicarIcones(partitura, achados) {
+    for (const m of partitura.mundos || []) {
+        m.props = m.props.filter((p) => !p.icone || achados[p.icone]).map((p) => (p.icone ? { ...p, src: achados[p.icone] } : p));
+    }
+    for (const e of [...(partitura.elenco || []), ...(partitura.figurantes || [])]) {
+        if (e.tipo === 'coisa') {
+            if (achados[e.icone]) e.src = achados[e.icone];
+            else { e.tipo = 'robo'; e.cor = e.cor || '#d97757'; }   // sem ícone, a coisa que fala vira o mascote
+        }
+    }
+    return partitura;
+}
+
+module.exports = { mundoDe, lerLugar, lerCoisas, lerElenco, iconesPendentes, aplicarIcones, LUGARES, HORAS, PECAS, ESPECIES, sem };