primocode 10.5.0 → 10.7.0

package/lib/estudio/movimentos.js

@@ -0,0 +1,212 @@
+/**
+ * movimentos.js — a biblioteca de MOVIMENTOS prontos: entradas, saídas,
+ * ênfases e loops, cada um com nome, que viram quadros-chave do `anima`.
+ *
+ *   "preciso que você deixe os motions com + de 100 tipos de animações …
+ *    além da IA poder criar os próprios e pesquisar" (Joel, 12/10)
+ *
+ * Até aqui todo movimento era escrito à mão pelo modelo, quadro a quadro
+ * (`anima: {opacidade: [{t, v}]}`). Modelo grátis escreve sempre os mesmos
+ * dois: esmaecer e subir. Com nome, ele PROCURA ("quique", "desfoque",
+ * "saída para a esquerda"), escolhe e escreve uma palavra:
+ *
+ *   elemento.movimento = "quicar-de-baixo"
+ *   elemento.movimento = {nome: "sair-girando", em: 2.4, duracao: 0.5}
+ *   elemento.movimento = ["surgir-desfocado", {nome: "flutuar", em: 0.6}]
+ *
+ * O plano expande isso em `anima` antes de conferir (plano.js). O que a IA
+ * escreveu em `anima` vence o movimento pronto na mesma propriedade — e ela
+ * continua livre para inventar o seu, quadro a quadro.
+ *
+ * Os números: x/y/z são DESLOCAMENTOS em px (o render soma à posição), as
+ * rotações em graus, o desfoque em px, opacidade/escala/brilho/saturação em
+ * fração. Todo movimento de entrada termina no repouso (0 de deslocamento,
+ * escala 1, opacidade 1); toda saída começa nele.
+ */
+
+'use strict';
+
+// Cada quadro: [fração do tempo 0..1, valor, suavização até ele].
+const DIRECOES = {
+    'de-baixo': { eixo: 'y', sinal: 1 }, 'de-cima': { eixo: 'y', sinal: -1 },
+    'da-esquerda': { eixo: 'x', sinal: -1 }, 'da-direita': { eixo: 'x', sinal: 1 },
+};
+const PARA = { 'de-baixo': 'para-baixo', 'de-cima': 'para-cima', 'da-esquerda': 'para-a-esquerda', 'da-direita': 'para-a-direita' };
+
+/* As entradas com direção: cada estilo × as quatro direções. */
+const ESTILOS_DIRECAO = {
+    deslizar: { d: 0.6, desc: 'desliza e aparece', f: (e, s) => ({ [e]: [[0, 80 * s], [1, 0, 'saida']], opacidade: [[0, 0], [0.6, 1, 'suave']] }) },
+    'deslizar-desfocado': { d: 0.7, desc: 'desliza saindo do desfoque', f: (e, s) => ({ [e]: [[0, 70 * s], [1, 0, 'saida']], opacidade: [[0, 0], [0.5, 1]], desfoque: [[0, 18], [1, 0, 'saida']] }) },
+    'chegar-elastico': { d: 0.9, desc: 'chega passando do ponto e volta, como mola', f: (e, s) => ({ [e]: [[0, 220 * s], [1, 0, 'elastico']], opacidade: [[0, 0], [0.25, 1]] }) },
+    quicar: { d: 0.9, desc: 'cai e quica', f: (e, s) => ({ [e]: [[0, 260 * s], [1, 0, 'salto']], opacidade: [[0, 0], [0.2, 1]] }) },
+    varrer: { d: 0.8, desc: 'atravessa rápido de longe e freia', f: (e, s) => ({ [e]: [[0, 900 * s], [1, 0, 'arrasto']], opacidade: [[0, 0], [0.3, 1]] }) },
+    'girar-entrando': { d: 0.8, desc: 'entra girando', f: (e, s) => ({ [e]: [[0, 160 * s], [1, 0, 'saida']], rotacao: [[0, -90 * s], [1, 0, 'saida']], opacidade: [[0, 0], [0.4, 1]] }) },
+};
+
+/* As entradas sem direção. */
+const ENTRADAS = {
+    surgir: { d: 0.5, desc: 'só aparece (esmaecer)', f: () => ({ opacidade: [[0, 0], [1, 1, 'suave']] }) },
+    crescer: { d: 0.6, desc: 'cresce do nada', f: () => ({ escala: [[0, 0], [1, 1, 'saida']], opacidade: [[0, 0], [0.3, 1]] }) },
+    'crescer-elastico': { d: 0.9, desc: 'cresce como mola', f: () => ({ escala: [[0, 0], [1, 1, 'elastico']] }) },
+    'pular-pra-dentro': { d: 0.6, desc: 'cresce, passa um pouco e assenta', f: () => ({ escala: [[0, 0], [0.7, 1.15, 'saida'], [1, 1, 'suave']], opacidade: [[0, 0], [0.3, 1]] }) },
+    'encolher-pra-dentro': { d: 0.6, desc: 'vem grande e encolhe até o lugar', f: () => ({ escala: [[0, 1.8], [1, 1, 'saida']], opacidade: [[0, 0], [0.5, 1]] }) },
+    'surgir-desfocado': { d: 0.7, desc: 'sai do desfoque', f: () => ({ desfoque: [[0, 24], [1, 0, 'saida']], opacidade: [[0, 0], [0.6, 1]] }) },
+    'virar-de-lado': { d: 0.7, desc: 'vira em Y como carta', f: () => ({ rotacaoY: [[0, 90], [1, 0, 'saida']], opacidade: [[0, 0], [0.3, 1]] }) },
+    'virar-de-cima': { d: 0.7, desc: 'tomba em X, de cima para baixo', f: () => ({ rotacaoX: [[0, -90], [1, 0, 'saida']], opacidade: [[0, 0], [0.3, 1]] }) },
+    'girar-crescendo': { d: 0.8, desc: 'cresce dando meia volta', f: () => ({ rotacao: [[0, -180], [1, 0, 'saida']], escala: [[0, 0], [1, 1, 'saida']] }) },
+    'vir-do-fundo': { d: 0.8, desc: 'avança da profundidade (3D)', f: () => ({ z: [[0, -700], [1, 0, 'saida']], opacidade: [[0, 0], [0.4, 1]] }) },
+    'cair-do-alto': { d: 0.8, desc: 'cai do topo e assenta com um quique', f: () => ({ y: [[0, -500], [1, 0, 'salto']], rotacao: [[0, -12], [1, 0, 'saida']] }) },
+    'estourar-de-luz': { d: 0.6, desc: 'acende estourado e assenta', f: () => ({ brilho: [[0, 3], [1, 1, 'saida']], opacidade: [[0, 0], [0.3, 1]] }) },
+    'ganhar-cor': { d: 0.8, desc: 'sai do cinza para a cor', f: () => ({ saturacao: [[0, 0], [1, 1, 'suave']], opacidade: [[0, 0], [0.4, 1]] }) },
+    'abrir-letras': { d: 0.8, desc: 'as letras chegam juntas de longe (texto)', f: () => ({ espacamento: [[0, 40], [1, 0, 'saida']], opacidade: [[0, 0], [0.5, 1]] }) },
+    'esticar-de-lado': { d: 0.6, desc: 'estica na horizontal', f: () => ({ escalaX: [[0, 0], [1, 1, 'saida']] }) },
+    'esticar-de-pe': { d: 0.6, desc: 'estica na vertical', f: () => ({ escalaY: [[0, 0], [1, 1, 'saida']] }) },
+    'carimbo': { d: 0.35, desc: 'bate na tela como carimbo', f: () => ({ escala: [[0, 2.4], [1, 1, 'entrada']], opacidade: [[0, 0], [0.2, 1]] }) },
+    'aproximar-editorial': { d: 0.9, desc: 'entra devagar, como revista', f: () => ({ y: [[0, 24], [1, 0, 'editorial']], escala: [[0, 0.96], [1, 1, 'editorial']], opacidade: [[0, 0], [1, 1, 'editorial']] }) },
+};
+
+/* As ênfases: o elemento já está lá e chama atenção (começam e terminam no repouso). */
+const ENFASES = {
+    pulsar: { d: 0.5, desc: 'cresce e volta uma vez', f: () => ({ escala: [[0, 1], [0.5, 1.12, 'suave'], [1, 1, 'suave']] }) },
+    tremer: { d: 0.5, desc: 'treme de lado (erro, negação)', f: () => ({ x: [[0, 0], [0.15, -14], [0.3, 12], [0.45, -10], [0.6, 8], [0.75, -4], [1, 0]] }) },
+    balancar: { d: 0.8, desc: 'balança como pêndulo', f: () => ({ rotacao: [[0, 0], [0.25, 12, 'suave'], [0.5, -8, 'suave'], [0.75, 4, 'suave'], [1, 0, 'suave']] }) },
+    piscar: { d: 0.6, desc: 'pisca duas vezes', f: () => ({ opacidade: [[0, 1], [0.25, 0.1], [0.5, 1], [0.75, 0.1], [1, 1]] }) },
+    'dar-uma-volta': { d: 0.8, desc: 'gira 360°', f: () => ({ rotacao: [[0, 0], [1, 360, 'suave']] }) },
+    'virar-moeda': { d: 0.8, desc: 'gira em Y como moeda', f: () => ({ rotacaoY: [[0, 0], [1, 360, 'suave']] }) },
+    'pular': { d: 0.6, desc: 'dá um pulinho', f: () => ({ y: [[0, 0], [0.4, -40, 'saida'], [1, 0, 'salto']] }) },
+    'tada': { d: 0.9, desc: 'cresce e chacoalha (conquista)', f: () => ({ escala: [[0, 1], [0.2, 0.9], [0.4, 1.12], [0.9, 1.12], [1, 1]], rotacao: [[0, 0], [0.3, -4], [0.45, 4], [0.6, -4], [0.75, 4], [1, 0]] }) },
+    'borracha': { d: 0.8, desc: 'amassa e estica como borracha', f: () => ({ escalaX: [[0, 1], [0.3, 1.25], [0.4, 0.75], [0.5, 1.15], [0.65, 0.95], [1, 1]], escalaY: [[0, 1], [0.3, 0.75], [0.4, 1.25], [0.5, 0.85], [0.65, 1.05], [1, 1]] }) },
+    'gelatina': { d: 0.9, desc: 'treme mole', f: () => ({ escalaX: [[0, 1], [0.2, 1.1], [0.4, 0.92], [0.6, 1.04], [0.8, 0.98], [1, 1]], escalaY: [[0, 1], [0.2, 0.92], [0.4, 1.08], [0.6, 0.97], [0.8, 1.01], [1, 1]] }) },
+    'acenar': { d: 0.8, desc: 'balança curto, como aceno', f: () => ({ rotacao: [[0, 0], [0.2, 14], [0.4, -8], [0.6, 14], [0.8, -4], [1, 0]] }) },
+    'acender': { d: 0.6, desc: 'brilha e apaga uma vez', f: () => ({ brilho: [[0, 1], [0.4, 1.8, 'suave'], [1, 1, 'suave']] }) },
+    'inclinar-3d': { d: 0.9, desc: 'inclina em 3D e volta', f: () => ({ rotacaoX: [[0, 0], [0.5, 18, 'suave'], [1, 0, 'suave']], rotacaoY: [[0, 0], [0.5, -14, 'suave'], [1, 0, 'suave']] }) },
+    'cabecear': { d: 0.6, desc: 'acena com a cabeça (sim)', f: () => ({ rotacaoX: [[0, 0], [0.3, 20], [0.6, -6], [1, 0]] }) },
+    'empurrao': { d: 0.4, desc: 'leva um soco e volta', f: () => ({ escala: [[0, 1], [0.25, 0.86, 'entrada'], [1, 1, 'elastico']] }) },
+    'sublinhar-luz': { d: 0.7, desc: 'fica vivo por um instante', f: () => ({ saturacao: [[0, 1], [0.4, 1.8, 'suave'], [1, 1, 'suave']], brilho: [[0, 1], [0.4, 1.3, 'suave'], [1, 1]] }) },
+};
+
+/* Os loops: repetem pela duração inteira (o padrão é a cena toda, 4 s). */
+const LOOPS = {
+    flutuar: { d: 4, ciclo: 2.4, desc: 'sobe e desce devagar', f: () => ({ y: [[0, 0], [0.5, -16, 'suave'], [1, 0, 'suave']] }) },
+    respirar: { d: 4, ciclo: 2, desc: 'cresce e encolhe de leve', f: () => ({ escala: [[0, 1], [0.5, 1.05, 'suave'], [1, 1, 'suave']] }) },
+    'girar-sem-parar': { d: 4, ciclo: 4, desc: 'gira sem parar', f: () => ({ rotacao: [[0, 0], [1, 360, 'linear']] }) },
+    'oscilar': { d: 4, ciclo: 1.6, desc: 'balança de leve sem parar', f: () => ({ rotacao: [[0, -5], [0.5, 5, 'suave'], [1, -5, 'suave']] }) },
+    'batimento': { d: 4, ciclo: 1, desc: 'pulsa como coração', f: () => ({ escala: [[0, 1], [0.15, 1.12], [0.3, 1], [0.45, 1.08], [0.6, 1], [1, 1]] }) },
+    'piscar-devagar': { d: 4, ciclo: 1.6, desc: 'some e volta devagar', f: () => ({ opacidade: [[0, 1], [0.5, 0.35, 'suave'], [1, 1, 'suave']] }) },
+    'orbitar': { d: 4, ciclo: 3, desc: 'anda em círculo pequeno', f: () => ({ x: [[0, 20], [0.25, 0, 'suave'], [0.5, -20, 'suave'], [0.75, 0, 'suave'], [1, 20, 'suave']], y: [[0, 0], [0.25, 20, 'suave'], [0.5, 0, 'suave'], [0.75, -20, 'suave'], [1, 0, 'suave']] }) },
+    'deriva': { d: 4, ciclo: 4, desc: 'anda de lado bem devagar', f: () => ({ x: [[0, -12], [0.5, 12, 'suave'], [1, -12, 'suave']] }) },
+    'girar-3d': { d: 4, ciclo: 5, desc: 'gira em Y sem parar, como vitrine', f: () => ({ rotacaoY: [[0, 0], [1, 360, 'linear']] }) },
+    'brilho-vivo': { d: 4, ciclo: 2, desc: 'o brilho respira', f: () => ({ brilho: [[0, 1], [0.5, 1.25, 'suave'], [1, 1, 'suave']] }) },
+    'balanco-3d': { d: 4, ciclo: 3, desc: 'inclina em 3D de um lado para o outro', f: () => ({ rotacaoY: [[0, -12], [0.5, 12, 'suave'], [1, -12, 'suave']] }) },
+    'tremor-leve': { d: 4, ciclo: 0.3, desc: 'vibra o tempo todo (tensão, alerta)', f: () => ({ x: [[0, 0], [0.25, -2], [0.5, 2], [0.75, -1], [1, 0]] }) },
+};
+
+/* A SAÍDA é a entrada ao contrário: o mesmo desenho, tempo invertido. */
+function inverter(gerado) {
+    const out = {};
+    for (const [prop, qs] of Object.entries(gerado)) {
+        const ordem = [...qs].reverse();
+        // A suavização de um quadro vale ATÉ ele; invertida, passa ao vizinho.
+        out[prop] = ordem.map(([f, v], i) => [1 - f, v, i > 0 ? inverterE(ordem[i - 1][2]) : undefined]);
+    }
+    return out;
+}
+const inverterE = (e) => ({ saida: 'entrada', entrada: 'saida', arrasto: 'acelera', acelera: 'arrasto', elastico: 'entrada', salto: 'entrada' }[e] || e);
+const nomeDaSaida = (n) => n.replace(/^surgir/, 'sumir').replace(/^crescer/, 'encolher-sumindo').replace(/^chegar/, 'partir')
+    .replace(/^vir-do-fundo/, 'ir-pro-fundo').replace(/^cair-do-alto/, 'cair-pra-fora').replace(/^ganhar-cor/, 'perder-cor')
+    .replace(/^abrir-letras/, 'espalhar-letras').replace(/^estourar-de-luz/, 'apagar-estourando');
+
+function montarCatalogo() {
+    const cat = {};
+    const pore = (nome, categoria, def, gerar) => { cat[nome] = { nome, categoria, descricao: def.desc, duracao: def.d, ciclo: def.ciclo, gerar }; };
+    for (const [estilo, def] of Object.entries(ESTILOS_DIRECAO)) {
+        for (const [dir, { eixo, sinal }] of Object.entries(DIRECOES)) {
+            const gerar = () => def.f(eixo, sinal);
+            pore(`${estilo}-${dir}`, 'entrada', { ...def, desc: `${def.desc}, vindo ${dir.replace('-', ' ')}` }, gerar);
+            pore(`${estilo}-${PARA[dir]}`.replace(/^deslizar-desfocado/, 'sair-desfocando').replace(/^deslizar/, 'sair-deslizando')
+                .replace(/^chegar-elastico/, 'sair-elastico').replace(/^quicar/, 'sair-quicando').replace(/^varrer/, 'sair-varrendo')
+                .replace(/^girar-entrando/, 'sair-girando'), 'saida', { ...def, desc: `sai: ${def.desc.split(',')[0]}, ${PARA[dir].replace(/-/g, ' ')}` },
+            () => inverter(def.f(eixo, sinal)));
+        }
+    }
+    for (const [nome, def] of Object.entries(ENTRADAS)) {
+        pore(nome, 'entrada', def, def.f);
+        pore(nomeDaSaida(nome) === nome ? `${nome}-saindo` : nomeDaSaida(nome), 'saida', { ...def, desc: `sai: ${def.desc}` }, () => inverter(def.f()));
+    }
+    for (const [nome, def] of Object.entries(ENFASES)) pore(nome, 'enfase', def, def.f);
+    for (const [nome, def] of Object.entries(LOOPS)) pore(nome, 'loop', def, def.f);
+    return cat;
+}
+const CATALOGO = montarCatalogo();
+
+const r3 = (n) => Math.round(n * 1000) / 1000;
+const semAcento = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+
+/** Os quadros-chave de um movimento, a partir de `em` segundos. */
+const achar = (nome) => CATALOGO[semAcento(nome).trim().replace(/\s+/g, '-')] || null;
+
+function quadros(nome, { em = 0, duracao } = {}) {
+    const m = achar(nome);
+    if (!m) return null;
+    const d = Number(duracao) > 0 ? Number(duracao) : m.duracao;
+    const gerado = m.gerar();
+    const anima = {};
+    if (m.categoria === 'loop') {
+        const ciclo = Math.min(m.ciclo || d, d);
+        const voltas = Math.max(1, Math.round(d / ciclo));
+        for (const [prop, qs] of Object.entries(gerado)) {
+            const lista = [];
+            for (let k = 0; k < voltas; k++) {
+                for (const [f, v, e] of qs) {
+                    if (k > 0 && f === 0) continue;   // o fim de uma volta é o começo da próxima
+                    // o giro sem parar soma: a 2ª volta vai de 360 a 720
+                    const soma = /rotacao/.test(prop) && qs[qs.length - 1][1] === 360 ? 360 * k : 0;
+                    lista.push({ t: r3(em + (k + f) * ciclo), v: v + soma, ...(e ? { e } : {}) });
+                }
+            }
+            anima[prop] = lista;
+        }
+        return anima;
+    }
+    for (const [prop, qs] of Object.entries(gerado)) anima[prop] = qs.map(([f, v, e]) => ({ t: r3(em + f * d), v, ...(e ? { e } : {}) }));
+    return anima;
+}
+
+/** Procura por palavra (no nome ou na descrição) e por categoria. Sem termo, devolve um pouco de cada. */
+function procurar({ termo = '', categoria = '', limite = 30 } = {}) {
+    const palavras = semAcento(termo).split(/[^a-z0-9]+/).filter(Boolean);
+    const cat = semAcento(categoria).replace('ê', 'e');
+    const lista = Object.values(CATALOGO).filter((m) => (!cat || m.categoria === cat.replace(/s$/, ''))
+        && palavras.every((p) => semAcento(m.nome + ' ' + m.descricao).includes(p)));
+    return {
+        ok: true, total: Object.keys(CATALOGO).length, achados: lista.length,
+        movimentos: lista.slice(0, limite).map((m) => ({ nome: m.nome, categoria: m.categoria, faz: m.descricao, duracao: m.duracao })),
+        comoUsar: 'no elemento do plano: movimento:"<nome>" ou {nome, em (s), duracao (s)} ou uma lista deles. O que você escrever em anima vence na mesma propriedade; pode inventar o seu em anima, quadro a quadro.',
+    };
+}
+
+/**
+ * Troca `movimento` por `anima` em todos os elementos do plano. Muda o plano
+ * no lugar e devolve os nomes que não existem (o plano.js vira problema).
+ */
+function expandir(plano) {
+    const desconhecidos = [];
+    for (const [i, cena] of ((plano && plano.cenas) || []).entries()) {
+        for (const [j, el] of ((cena && cena.elementos) || []).entries()) {
+            if (!el || el.movimento == null) continue;
+            const pedidos = (Array.isArray(el.movimento) ? el.movimento : [el.movimento]).map((m) => (typeof m === 'string' ? { nome: m } : m || {}));
+            const juntado = {};
+            for (const p of pedidos) {
+                const a = quadros(p.nome, { em: Number(p.em) || 0, duracao: p.duracao ?? ((achar(p.nome) || {}).categoria === 'loop' ? cena.duracao : undefined) });
+                if (!a) { desconhecidos.push({ onde: `cenas[${i}].elementos[${j}].movimento`, nome: String(p.nome) }); continue; }
+                // Dois movimentos na mesma propriedade: os quadros se somam na linha do tempo.
+                for (const [prop, qs] of Object.entries(a)) juntado[prop] = [...(juntado[prop] || []), ...qs].sort((x, y) => x.t - y.t);
+            }
+            el.anima = { ...juntado, ...(el.anima || {}) };
+            delete el.movimento;
+        }
+    }
+    return desconhecidos;
+}
+
+module.exports = { CATALOGO, quadros, procurar, expandir, inverter };

package/lib/estudio/mundo.js

@@ -0,0 +1,328 @@
+/**
+ * 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 } = {}) {
+    let obj = pedido && typeof pedido === 'object' ? pedido : { lugar: String(pedido || '') };
+    /* Um cenário que a IA criou e a pessoa deixou salvar (cenarios.js): o
+       nome dele no lugar traz tudo de volta; o que a cena disser por cima vence. */
+    const salvo = require('./cenarios.js').ler(obj.cenario || obj.lugar);
+    if (salvo) obj = { ...salvo, ...obj, lugar: salvo.base, hora: obj.hora || salvo.hora, elementos: obj.elementos || salvo.elementos };
+    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;
+}
+
+/**
+ * As peças que a IA TROUXE para a cena: a logo, o botão ou o produto recortado
+ * do site (estudio_midia acao:elemento), um PNG sem fundo que vira blocos como
+ * os ícones 3D. "Imagens e parte de sites devem entrar no motion como ícone
+ * 3D" (Joel, 12/10). Ficam na frente, no centro, um pouco maiores que o resto
+ * do lugar: é o assunto. No máximo três, para não virar vitrine.
+ */
+function adicionarObjetos(partitura, objetos) {
+    const lista = (Array.isArray(objetos) ? objetos : []).filter((o) => o && o.src).slice(0, 3);
+    if (!lista.length) return partitura;
+    for (const m of partitura.mundos || []) {
+        lista.forEach((o, i) => {
+            const x = (i - (lista.length - 1) / 2) * 2.4;
+            m.props.push({ icone: String(o.nome || 'objeto').slice(0, 40), src: o.src, x, z: -1.6, raio: 1, giro: 0, escala: 1.35, trazido: true });
+        });
+    }
+    return partitura;
+}
+
+module.exports = { mundoDe, lerLugar, lerCoisas, lerElenco, iconesPendentes, aplicarIcones, adicionarObjetos, LUGARES, HORAS, PECAS, ESPECIES, sem };