primocode 11.0.0 → 11.1.0

package/lib/kits-plano.js

@@ -1,557 +0,0 @@
-/**
- * kits-plano.js — a IA MONTA o vídeo com as peças do kit, uma batida por vez.
- *
- *   "Não é que a IA vai só pegar e trocar os textos — os kits têm skill, regras, elementos, assets;
- *    a IA monta o motion a partir daquilo." (Joel, 26/10)
- *
- * O caminho curto antigo trocava só os textos do filme de demo: um app virava o fone 3D da demo.
- * Agora:
- *   montar   lê a receita.json do kit e escreve o esqueleto (motion/plano.json): as batidas escolhidas, com o
- *            tempo, a entrada, o fundo e os sons do estilo, e SEM conteúdo. Só o cenário puro do estilo (camadas
- *            sem texto, sem arquivo, sem produto: papel de fundo, fita…) vem da demo.
- *   batida   devolve o formulário pequeno de UMA batida (os elementos que a receita permite e as props de cada um,
- *            lidas dos tipos do .tsx) e recebe as camadas dela: confere, conserta o que dá (prop que não existe,
- *            número em texto, opção fora da lista) e barra o que não dá (texto ou arquivo da demo, produto da demo,
- *            arquivo que não existe, campo obrigatório vazio). Devolve já o formulário da próxima.
- *   conferir o plano inteiro, antes do cartão.
- *
- * O formato dos campos vem dos tipos (`export type XProps = {…}`) de cada elemento; o que não dá pra ler vira
- * "livre" (passa como veio). Texto x cor x arquivo: pelo nome do campo e pelo valor da demo.
- */
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const FPS = 30;
-const MIDIA = /\.(png|jpe?g|webp|gif|svg|mp4|webm|mov|mp3|wav|m4a)$/i;
-const NOME_MIDIA = /^(src|logo|foto|fotos|imagem|imagens|quadros|video|audio|avatar|arquivo)$/i;
-const NOME_COR = /^(cor\w*|cores|acento|paleta|tinta|borda|fundo)$|Cor$/;
-const ESTRUTURA = /^(Montagem|Cena|Camera|Fundo|Som)$/;
-/* o produto da demo: um "modelo" pronto do kit só entra se o produto da pessoa for isso */
-const SINONIMOS = { fone: ['fone', 'earbud', 'airpod', 'headphone', 'auricular'], estojo: ['estojo', 'case', 'fone', 'earbud', 'airpod'], ponteira: ['ponteira', 'fone', 'earbud', 'airpod'] };
-
-const semAcento = (s) => String(s || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
-const lerSe = (f) => { try { return fs.readFileSync(f, 'utf8'); } catch { return ''; } };
-const lerJson = (f) => { try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch { return null; } };
-
-// ── os tipos do .tsx viram um formulário ─────────────────────────────────
-
-/** Fecha o bloco que começa em `i` (no caractere de abertura) e devolve o índice do fechamento. */
-function fechar(s, i) {
-    let n = 0;
-    for (let j = i; j < s.length; j++) {
-        if ('{[('.includes(s[j])) n++;
-        else if ('}])'.includes(s[j])) { n--; if (n === 0) return j; }
-    }
-    return s.length - 1;
-}
-
-/** Divide no separador só no nível de fora (fora de {}, [], (), <>). */
-function dividir(s, seps) {
-    const out = []; let n = 0, ini = 0, ang = 0;
-    for (let j = 0; j < s.length; j++) {
-        const c = s[j];
-        if ('{[('.includes(c)) n++; else if ('}])'.includes(c)) n--;
-        else if (c === '<') ang++; else if (c === '>' && s[j - 1] !== '=') ang--;
-        else if (n === 0 && ang <= 0 && seps.includes(c)) { out.push(s.slice(ini, j)); ini = j + 1; }
-    }
-    out.push(s.slice(ini));
-    return out.map((x) => x.trim()).filter(Boolean);
-}
-
-/* os /** doc *\/ dos campos viram marcas @@Dn@@ (sem vírgula nem ponto e vírgula dentro) e voltam no formulário */
-const DOCS = [];
-const tirarComentarios = (s) => s.replace(/\/\*\*([\s\S]*?)\*\//g, (_, d) => { DOCS.push(d.replace(/\s*\n\s*\*?\s*/g, ' ').trim()); return ` @@D${DOCS.length - 1}@@ `; })
-    .replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/[^\n]*/g, '');
-const semDoc = (t) => String(t).replace(/@@D\d+@@/g, '').trim();
-
-/** Todos os `type X = …` / `interface X {…}` dos arquivos do kit: nome → texto do tipo. */
-function tiposDoKit(pastaKit) {
-    const tipos = {};
-    let arqs = [];
-    try { arqs = fs.readdirSync(path.join(pastaKit, 'elementos')).filter((f) => /\.tsx?$/.test(f)); } catch { /* sem elementos */ }
-    for (const f of arqs) {
-        const cod = tirarComentarios(lerSe(path.join(pastaKit, 'elementos', f)));
-        const re = /(?:export\s+)?(?:type\s+(\w+)\s*(?:<[^>]*>)?\s*=|interface\s+(\w+)\s*(?:extends[^{]*)?)\s*/g;
-        let m;
-        while ((m = re.exec(cod))) {
-            const nome = m[1] || m[2];
-            let i = m.index + m[0].length, fim;
-            if (cod[i] === '{' || cod[i] === '[' || cod[i] === '(') {
-                fim = fechar(cod, i);
-                // `{…}[]` ou `{…} | …`: segue até o ; ou fim de linha no nível de fora
-                let j = fim + 1;
-                while (j < cod.length && cod[j] !== ';' && cod[j] !== '\n') j++;
-                tipos[nome] = cod.slice(i, j).trim();
-            } else {
-                let j = i, n = 0;
-                for (; j < cod.length; j++) {
-                    if ('{[('.includes(cod[j])) n++; else if ('}])'.includes(cod[j])) n--;
-                    else if ((cod[j] === ';' || cod[j] === '\n') && n <= 0) break;
-                }
-                tipos[nome] = cod.slice(i, j).trim();
-            }
-        }
-    }
-    // `keyof typeof X` (o nome do modelo, do som, da curva): as chaves do `const X = {…}` viram as opções
-    for (const f of arqs) {
-        const cod = tirarComentarios(lerSe(path.join(pastaKit, 'elementos', f)));
-        const re = /(?:export\s+)?const\s+(\w+)\s*(?::[^=]+)?=\s*\{/g;
-        let m;
-        while ((m = re.exec(cod))) {
-            const ini = m.index + m[0].length - 1, fim = fechar(cod, ini);
-            const corpo = cod.slice(ini + 1, fim);
-            const chaves = dividir(corpo, [',']).map((x) => (x.match(/^['"]?([\w-]+)['"]?\s*(?::|$)/) || [])[1]).filter(Boolean);
-            if (chaves.length) tipos[`keyof typeof ${m[1]}`] = chaves.map((c) => `'${c}'`).join(' | ');
-            re.lastIndex = fim;
-        }
-    }
-    return tipos;
-}
-
-/** Um tipo TS → nó do formulário. `nome` é o nome do campo (decide texto x cor x arquivo). */
-function no(tipo, tipos, nome = '', fundo = 0) {
-    let t = String(tipo || '').trim().replace(/;$/, '').trim();
-    if (t[0] !== '{') t = semDoc(t);
-    if (!t) return { k: 'livre' };
-    if (/^React\./.test(t)) return { k: 'pular' };
-    const uniao = dividir(t, ['|']);
-    if (uniao.length > 1) {
-        if (uniao.every((u) => /^'[^']*'$|^"[^"]*"$/.test(u))) return { k: 'enum', ops: uniao.map((u) => u.slice(1, -1)) };
-        const semFalse = uniao.filter((u) => !/^(false|undefined|null)$/.test(u));
-        if (semFalse.length === 1) return no(semFalse[0], tipos, nome, fundo);
-        return { k: 'livre', txt: t };
-    }
-    if (/\[\]$/.test(t)) return { k: 'lista', de: no(t.slice(0, -2).replace(/^\((.*)\)$/, '$1'), tipos, nome, fundo + 1) };
-    if (/^Array<(.*)>$/.test(t)) return { k: 'lista', de: no(t.replace(/^Array<(.*)>$/, '$1'), tipos, nome, fundo + 1) };
-    if (t[0] === '{') {
-        const corpo = t.slice(1, fechar(t, 0));
-        const campos = {};
-        let pendente = null;
-        for (let parte of dividir(corpo, [';', ',', '\n'])) {
-            let d = parte.match(/^@@D(\d+)@@\s*/);
-            if (d) parte = parte.slice(d[0].length);
-            if (!parte) { pendente = d; continue; }   // o doc numa linha só: vale pro campo seguinte
-            if (!d) { d = pendente; }
-            pendente = null;
-            const m = parte.match(/^(\w+)(\?)?\s*:\s*([\s\S]+)$/);
-            if (!m) continue;
-            const filho = no(m[3], tipos, m[1], fundo + 1);
-            if (filho.k === 'pular') continue;
-            campos[m[1]] = { opc: !!m[2], t: filho, ...(d ? { doc: DOCS[Number(d[1])] } : {}) };
-        }
-        return { k: 'obj', campos };
-    }
-    if (t[0] === '[') return { k: 'tupla', n: dividir(t.slice(1, -1), [',']).length };
-    if (t === 'string') return { k: NOME_MIDIA.test(nome) ? 'midia' : NOME_COR.test(nome) ? 'cor' : 'texto' };
-    if (t === 'number') return { k: 'num' };
-    if (t === 'boolean') return { k: 'bool' };
-    if (/^'[^']*'$/.test(t)) return { k: 'enum', ops: [t.slice(1, -1)] };
-    if (tipos[t] && /^keyof typeof /.test(t)) return no(tipos[t], tipos, nome, fundo + 1);
-    const nomeT = t.replace(/<.*$/, '');
-    if (tipos[nomeT] && fundo < 6) return no(tipos[nomeT], tipos, nome, fundo + 1);
-    return { k: 'livre', txt: t };
-}
-
-/** O formulário de cada elemento do kit (só os que vão em camadas) e o do plano (campos gerais). */
-function esquema(k) {
-    const tipos = tiposDoKit(k.pasta);
-    const elementos = {};
-    let arqs = [];
-    try { arqs = fs.readdirSync(path.join(k.pasta, 'elementos')).filter((f) => f.endsWith('.tsx')).map((f) => f.replace(/\.tsx$/, '')); } catch { /* nada */ }
-    for (const el of arqs) {
-        if (ESTRUTURA.test(el)) continue;
-        const t = tipos[`${el}Props`];
-        elementos[el] = t ? no(t, tipos) : { k: 'obj', campos: {}, livre: true };
-    }
-    const plano = tipos.Plano ? no(tipos.Plano, tipos) : { k: 'obj', campos: {} };
-    const geral = { k: 'obj', campos: {} };
-    for (const [c, v] of Object.entries(plano.campos || {})) if (!/^(kit|duracao|cenas|trilha)$/.test(c)) geral.campos[c] = v;
-    return { elementos, geral };
-}
-
-/** Os campos de texto/arquivo do nó têm o tipo certo também pela demo: "#ff0" é cor, "x.png" é arquivo. */
-function afinarPelaDemo(sch, exemplo) {
-    const andar = (n, v) => {
-        if (!n || v == null) return;
-        if (n.k === 'texto' && typeof v === 'string') { if (/^#[0-9a-f]{3,8}$/i.test(v) || /^(rgb|hsl)a?\(/.test(v)) n.k = 'cor'; else if (MIDIA.test(v)) n.k = 'midia'; }
-        else if (n.k === 'lista' && Array.isArray(v)) v.forEach((x) => andar(n.de, x));
-        else if (n.k === 'obj' && v && typeof v === 'object') for (const [c, x] of Object.entries(v)) if (n.campos[c]) andar(n.campos[c].t, x);
-    };
-    for (const c of (exemplo && exemplo.cenas) || []) for (const cam of c.camadas || []) andar(sch.elementos[cam.elemento], cam.props);
-    if (exemplo) andar(sch.geral, exemplo);
-    return sch;
-}
-
-const temKind = (n, kinds, fundo = 0) => {
-    if (!n || fundo > 8) return false;
-    if (kinds.includes(n.k)) return true;
-    if (n.k === 'lista') return temKind(n.de, kinds, fundo + 1);
-    if (n.k === 'obj') return Object.entries(n.campos).some(([c, v]) => (kinds.includes('produto') && /^(modelo|pecas)$/.test(c)) || temKind(v.t, kinds, fundo + 1));
-    return false;
-};
-/** Cenário puro: o elemento não tem texto, arquivo nem produto (papel de fundo, fita, partícula…). */
-const ehCenario = (sch, el) => !!sch.elementos[el] && !sch.elementos[el].livre && !temKind(sch.elementos[el], ['texto', 'midia', 'produto', 'livre']) && Object.keys(sch.elementos[el].campos || {}).length > 0;
-
-/** O nó em uma linha curta pra IA: {texto*: texto, y: num, alinhar: centro|esquerda}. */
-function mostrar(n, fundo = 0) {
-    if (!n) return '?';
-    switch (n.k) {
-        case 'texto': return 'texto';
-        case 'cor': return 'cor';
-        case 'midia': return 'arquivo';
-        case 'num': return 'num';
-        case 'bool': return 'bool';
-        case 'enum': return n.ops.join('|');
-        case 'tupla': return `[${Array(n.n).fill('num').join(',')}]`;
-        case 'lista': return `[${mostrar(n.de, fundo + 1)}]`;
-        case 'obj': return fundo > 3 ? '{…}' : `{${Object.entries(n.campos).map(([c, v]) => `${c}${v.opc ? '' : '*'}: ${mostrar(v.t, fundo + 1)}${v.doc && fundo > 0 ? ` /* ${v.doc.slice(0, 80)} */` : ''}`).join(', ')}}`;
-        default: return 'livre';
-    }
-}
-
-// ── conferir e consertar o que a IA mandou ───────────────────────────────
-
-/**
- * Conserta `v` pelo nó. `ctx`: {notas, erros, demo (Set de textos da demo), arquivoOk(v)->bool|string, caminho}.
- * Devolve o valor consertado (undefined = tirar o campo).
- */
-function consertar(v, n, ctx, caminho) {
-    if (!n || n.k === 'livre') return v;
-    const onde = caminho.join('.');
-    switch (n.k) {
-        case 'texto': {
-            if (v == null) return v;
-            if (typeof v === 'number') v = String(v);
-            if (typeof v !== 'string') { ctx.erros.push(`${onde}: tem que ser texto`); return undefined; }
-            const s = v.trim();
-            if (s && ctx.demo.has(semAcento(s)) && !ctx.permitidos.has(semAcento(s))) ctx.erros.push(`${onde}: "${s}" é texto da demo do kit, não da pessoa. Escreva o texto do vídeo DELA.`);
-            return v;
-        }
-        case 'cor': return typeof v === 'string' ? v : (ctx.notas.push(`${onde}: tirei (cor tem que ser "#rrggbb")`), undefined);
-        case 'midia': {
-            if (typeof v !== 'string') { ctx.erros.push(`${onde}: tem que ser o caminho de um arquivo`); return undefined; }
-            const r = ctx.arquivoOk(v);
-            if (r !== true) ctx.erros.push(`${onde}: ${r}`);
-            return v;
-        }
-        case 'num': {
-            if (typeof v === 'number' && Number.isFinite(v)) return v;
-            const x = Number(String(v).replace(',', '.').replace(/px$/, ''));
-            if (Number.isFinite(x)) { ctx.notas.push(`${onde}: "${v}" virou ${x}`); return x; }
-            ctx.notas.push(`${onde}: tirei ("${v}" não é número)`); return undefined;
-        }
-        case 'bool': return typeof v === 'boolean' ? v : /^(true|sim|1)$/i.test(String(v));
-        case 'enum': {
-            if (n.ops.includes(v)) return v;
-            const achou = n.ops.find((o) => semAcento(o) === semAcento(v));
-            if (achou) return achou;
-            ctx.notas.push(`${onde}: tirei "${v}" (as opções são ${n.ops.join('|')})`); return undefined;
-        }
-        case 'tupla': return Array.isArray(v) ? v : undefined;
-        case 'lista': {
-            if (v == null) return v;
-            const arr = Array.isArray(v) ? v : [v];
-            return arr.map((x, i) => consertar(x, n.de, ctx, [...caminho, i])).filter((x) => x !== undefined);
-        }
-        case 'obj': {
-            if (!v || typeof v !== 'object' || Array.isArray(v)) { ctx.erros.push(`${onde || 'props'}: tem que ser um objeto {…}`); return undefined; }
-            const out = {};
-            for (const [c, x] of Object.entries(v)) {
-                const campo = n.campos[c];
-                if (!campo) { if (Object.keys(n.campos).length) ctx.notas.push(`${[...caminho, c].join('.')}: tirei (não existe; tem ${Object.keys(n.campos).join(', ')})`); else out[c] = x; continue; }
-                const y = consertar(x, campo.t, ctx, [...caminho, c]);
-                if (y !== undefined) out[c] = y;
-            }
-            for (const [c, campo] of Object.entries(n.campos)) {
-                const vazio = out[c] == null || (typeof out[c] === 'string' && !out[c].trim()) || (Array.isArray(out[c]) && !out[c].length);
-                if (!campo.opc && vazio) ctx.erros.push(`${[...caminho, c].join('.')}: obrigatório (${mostrar(campo.t)})`);
-            }
-            return out;
-        }
-        default: return v;
-    }
-}
-
-/** Os textos que uma cena põe na tela (os campos de texto das camadas dela). */
-function textosDaCena(sch, cena) {
-    const out = [];
-    const andar = (n, v) => {
-        if (!n || v == null) return;
-        if (n.k === 'texto' && typeof v === 'string' && v.trim()) out.push(v.trim());
-        else if (n.k === 'lista' && Array.isArray(v)) v.forEach((x) => andar(n.de, x));
-        else if (n.k === 'obj' && typeof v === 'object') for (const [c, x] of Object.entries(v)) if (n.campos[c] && !/^(grupo|nome|modelo)$/.test(c)) andar(n.campos[c].t, x);
-    };
-    for (const cam of (cena && cena.camadas) || []) andar(sch.elementos[cam.elemento], cam.props);
-    return out;
-}
-
-/** Os textos da demo (pra barrar cópia): todo valor de campo de texto do plano de exemplo. */
-function textosDaDemo(sch, exemplo) {
-    const set = new Set();
-    const andar = (n, v) => {
-        if (!n || v == null) return;
-        if (n.k === 'texto' && typeof v === 'string' && v.trim().length > 2) set.add(semAcento(v.trim()));
-        else if (n.k === 'lista' && Array.isArray(v)) v.forEach((x) => andar(n.de, x));
-        else if (n.k === 'obj' && typeof v === 'object') for (const [c, x] of Object.entries(v)) if (n.campos[c]) andar(n.campos[c].t, x);
-    };
-    for (const c of (exemplo && exemplo.cenas) || []) for (const cam of c.camadas || []) andar(sch.elementos[cam.elemento], cam.props);
-    if (exemplo) andar(sch.geral, exemplo);
-    return set;
-}
-
-// ── o contexto de um kit (esquema + demo + o que a pessoa trouxe) ────────
-
-function contexto(k, pastaProjeto, pessoa = {}) {
-    const exemplo = lerJson(path.join(k.pasta, 'exemplos', 'plano.json'));
-    const receita = lerJson(path.join(k.pasta, 'receita.json')) || { batidas: [] };
-    const sch = afinarPelaDemo(esquema(k), exemplo);
-    const demo = textosDaDemo(sch, exemplo);
-    // frase que está na SKILL.md é do estilo ("Todo novo"), não do produto da demo
-    const skill = semAcento(lerSe(path.join(k.pasta, 'SKILL.md')));
-    const permitidos = new Set([...demo].filter((t) => skill.includes(t)));
-    const arquivosDemo = new Set();
-    try { for (const f of fs.readdirSync(path.join(k.pasta, 'exemplos'), { recursive: true })) arquivosDemo.add(path.basename(String(f))); } catch { /* sem exemplos */ }
-    const arquivoOk = (v) => {
-        if (arquivosDemo.has(path.basename(v)) && !(pessoa.arquivos || []).includes(v)) return `"${v}" é arquivo da demo do kit. Use um arquivo da pessoa${(pessoa.arquivos || []).length ? ` (${pessoa.arquivos.join(', ')})` : ''}, ou tire o campo.`;
-        const cands = path.isAbsolute(v) ? [v] : [path.resolve(pastaProjeto, v), path.join(k.pasta, v)];
-        if (cands.some((c) => { try { return fs.statSync(c).isFile(); } catch { return false; } })) return true;
-        return `"${v}" não existe na pasta do projeto${(pessoa.arquivos || []).length ? ` (a pessoa trouxe: ${pessoa.arquivos.join(', ')})` : ' (a pessoa não trouxe arquivo nenhum: monte com os outros elementos da batida, sem arquivo — ex.: o produto em peças 3D, ou texto)'}`;
-    };
-    // quantos itens cabem numa lista (linhas do painel, etiquetas…): o máximo que a demo usa
-    const listas = {};
-    for (const c of (exemplo && exemplo.cenas) || []) for (const cam of c.camadas || []) for (const [campo, v] of Object.entries(cam.props || {})) {
-        if (!Array.isArray(v) || !v.length || typeof v[0] !== 'object' || Array.isArray(v[0])) continue;
-        const ch = `${cam.elemento}.${campo}`;
-        listas[ch] = Math.max(listas[ch] || 0, v.length);
-    }
-    // quantas vezes o mesmo elemento aparece numa cena da demo (o estilo: "uma linha por plano")
-    const porCena = {};
-    for (const c of (exemplo && exemplo.cenas) || []) {
-        const n = {};
-        for (const cam of c.camadas || []) n[cam.elemento] = (n[cam.elemento] || 0) + 1;
-        for (const [el, q] of Object.entries(n)) porCena[el] = Math.max(porCena[el] || 0, q);
-    }
-    return { k, exemplo, receita, sch, demo, permitidos, arquivoOk, pessoa, listas, porCena };
-}
-
-/** O produto da demo (um modelo pronto do kit) só passa se o produto da pessoa for isso. */
-function produtoDaDemo(props, produto, daDemo) {
-    const usados = [];
-    const andar = (v, chave) => {
-        if (Array.isArray(v)) v.forEach((x) => andar(x, chave));
-        else if (v && typeof v === 'object') { for (const [c, x] of Object.entries(v)) andar(x, c === 'modelo' ? 'modelo' : (chave === 'modelo' && c === 'nome' ? 'modelo' : c)); }
-        else if (chave === 'modelo' && typeof v === 'string') usados.push(v);
-    };
-    andar(props && props.modelo, 'modelo');
-    const p = semAcento(produto);
-    const ruins = usados.filter((m) => !(SINONIMOS[m] || [m]).some((s) => p.includes(s)));
-    return daDemo ? ruins.filter((m) => daDemo.has(m)) : ruins;
-}
-
-/** Os modelos prontos que a demo usa (o produto dela). */
-function modelosDaDemo(exemplo) {
-    const set = new Set();
-    for (const c of (exemplo && exemplo.cenas) || []) for (const cam of c.camadas || []) for (const m of [].concat((cam.props || {}).modelo || [])) { const n = typeof m === 'string' ? m : m && m.nome; if (n) set.add(n); }
-    return set;
-}
-
-/** Confere as camadas de uma batida. Resolve {camadas, notas, erros}. */
-function conferirBatida(ctx, batida, camadas, indice) {
-    const notas = [], erros = [];
-    const c2 = { notas, erros, demo: ctx.demo, permitidos: ctx.permitidos, arquivoOk: ctx.arquivoOk };
-    let lista = camadas;
-    if (lista && !Array.isArray(lista) && typeof lista === 'object') lista = lista.camadas || [lista];
-    if (!Array.isArray(lista) || !lista.length) return { camadas: [], notas, erros: ['mande ao menos uma camada: [{"elemento": "…", "props": {…}}]'] };
-    const pode = new Set([...(batida.elementos || []), ...((batida.cenario || []))]);
-    const out = [];
-    lista.forEach((cam, j) => {
-        const el = cam && (cam.elemento || cam.el || cam.tipo);
-        if (!el || !ctx.sch.elementos[el]) { erros.push(`camada ${j + 1}: o elemento "${el}" não existe no kit (nesta batida: ${[...pode].join(', ')})`); return; }
-        if (!pode.has(el) && !ehCenario(ctx.sch, el)) { erros.push(`camada ${j + 1}: ${el} não vai na batida "${batida.nome}" (a receita põe: ${(batida.elementos || []).join(', ')})`); return; }
-        const props = consertar(cam.props || {}, ctx.sch.elementos[el], c2, [`camada ${j + 1} ${el}`]);
-        if (props === undefined) return;
-        const daDemo = modelosDaDemo(ctx.exemplo);
-        const demo = produtoDaDemo(props, ctx.pessoa.produto || '', daDemo);
-        const outros = produtoDaDemo(props, '', null).filter((m) => !daDemo.has(m));
-        if (outros.length) erros.push(`camada ${j + 1} ${el}: "${outros.join(', ')}" não é modelo pronto do kit${daDemo.size ? ` (os prontos: ${[...daDemo].join(', ')})` : ''}. Monte com "pecas".`);
-        if (demo.length) erros.push(`camada ${j + 1} ${el}: o modelo "${demo.join(', ')}" é o produto da demo, e o da pessoa é "${ctx.pessoa.produto || '?'}". Monte o produto DELA (peças: "pecas"; ou a foto/logo dela) ou use só texto.`);
-        // produto 3D maior que a distância da câmera: a câmera fica dentro dele e o quadro sai preto (E2E do Lume, 27/10)
-        if (Array.isArray(props.pecas) && props.pecas.length && Array.isArray(props.camera)) {
-            const tam = Math.max(...props.pecas.map((pc) => 2 * Math.max(...(pc.tam || [0]).map(Math.abs)) + Math.max(0, ...(pc.pos || [0]).map(Math.abs))));
-            const perto = Math.min(...props.camera.map((c) => Number(c.distancia)).filter((d) => d > 0));
-            const dDemo = (exemploDe(ctx, el).camera || []).map((c) => Number(c.distancia)).filter((d) => d > 0);
-            if (Number.isFinite(perto) && tam * 1.2 > perto) erros.push(`camada ${j + 1} ${el}: o produto mede ~${+tam.toFixed(1)} unidades e a câmera chega a ${perto} — ela fica dentro dele (quadro preto). Na escala do kit o produto tem ~1 a 1,5 unidade (tam são MEIAS medidas: um celular ≈ [0.36, 0.74, 0.04])${dDemo.length ? ` e a câmera fica entre ${Math.min(...dDemo)} e ${Math.max(...dDemo)}` : ''}.`);
-        }
-        for (const [campo, v] of Object.entries(props)) {
-            const teto = ctx.listas && ctx.listas[`${el}.${campo}`];
-            if (teto && Array.isArray(v) && v.length > Math.max(teto + 1, Math.ceil(teto * 1.5))) erros.push(`camada ${j + 1} ${el}.${campo}: ${v.length} itens não cabem na tela (o estilo usa até ${teto}). Corte pro essencial.`);
-        }
-        out.push({ elemento: el, props });
-    });
-    const conta = {};
-    for (const c of out) conta[c.elemento] = (conta[c.elemento] || 0) + 1;
-    for (const [el, q] of Object.entries(conta)) {
-        const teto = ctx.porCena && ctx.porCena[el];
-        if (teto && !ehCenario(ctx.sch, el) && q > teto + 1) erros.push(`${q} ${el} numa cena só: o estilo usa até ${teto} por cena (leia "Proibido" na SKILL). Junte numa ou espalhe pelas outras batidas.`);
-    }
-    if (out.length && out.every((c) => ehCenario(ctx.sch, c.elemento))) erros.push(`batida ${indice}: só tem cenário; ponha o conteúdo (${(batida.elementos || []).filter((e) => !ehCenario(ctx.sch, e)).join(' ou ')})`);
-    return { camadas: out, notas, erros };
-}
-
-// ── o esqueleto ──────────────────────────────────────────────────────────
-
-const CHAVES_QUADRO = new Set(['em', 'de', 'ate', 'entra', 'sai', 'liga', 'desliga', 'desde']);
-/** Escala os quadros absolutos dos campos gerais (câmera do vídeo todo, monitor…). */
-function escalarQuadros(v, f, chave) {
-    if (Array.isArray(v)) {
-        if (chave === 'camera' && v.every((x) => Array.isArray(x) && typeof x[0] === 'number')) return v.map((x) => [Math.round(x[0] * f), ...x.slice(1)]);
-        return v.map((x) => escalarQuadros(x, f, chave));
-    }
-    if (v && typeof v === 'object') return Object.fromEntries(Object.entries(v).map(([c, x]) => [c, CHAVES_QUADRO.has(c) && typeof x === 'number' ? Math.round(x * f) : escalarQuadros(x, f, c)]));
-    return v;
-}
-
-/** As batidas: as pedidas (por nome), ou a ordem sugerida da receita, ou as obrigatórias + opcionais até caber. */
-function escolherBatidas(receita, pedidas, segundos) {
-    const por = new Map((receita.batidas || []).map((b) => [b.nome, b]));
-    if (pedidas && pedidas.length) {
-        const ruins = pedidas.filter((n) => !por.has(n));
-        if (ruins.length) return { erro: `batida(s) ${ruins.join(', ')} não existem na receita (tem: ${[...por.keys()].join(', ')})` };
-        return { lista: pedidas.map((n) => por.get(n)) };
-    }
-    if (Array.isArray(receita.ordem_sugerida) && receita.ordem_sugerida.every((n) => por.has(n))) return { lista: receita.ordem_sugerida.map((n) => por.get(n)) };
-    const meio = (b) => ((b.duracao || [45, 45])[0] + (b.duracao || [45, 45])[1]) / 2;
-    const alvo = (segundos || 8) * FPS;
-    const lista = (receita.batidas || []).filter((b) => b.obrigatoria);
-    let soma = lista.reduce((s, b) => s + meio(b), 0);
-    for (const b of (receita.batidas || []).filter((x) => !x.obrigatoria)) {
-        if (soma + meio(b) > alvo * 1.15) continue;
-        lista.splice((receita.batidas || []).indexOf(b) <= 0 ? 0 : Math.min(lista.length - 1, (receita.batidas || []).indexOf(b)), 0, b);
-        soma += meio(b);
-    }
-    const ordem = new Map((receita.batidas || []).map((b, i) => [b, i]));
-    return { lista: lista.sort((a, b) => ordem.get(a) - ordem.get(b)) };
-}
-
-/** O esqueleto do plano: tempos, entradas, fundos e sons do estilo; as camadas de conteúdo ficam vazias. */
-function esqueleto(ctx, { segundos, batidas } = {}) {
-    const { receita, exemplo, sch } = ctx;
-    const esc = escolherBatidas(receita, batidas, segundos);
-    if (esc.erro) return { erro: esc.erro };
-    const meio = (b) => ((b.duracao || [45, 45])[0] + (b.duracao || [45, 45])[1]) / 2;
-    const soma = esc.lista.reduce((s, b) => s + meio(b), 0);
-    const total = Number(segundos) > 0 ? Math.round(Number(segundos) * FPS) : Math.round(soma);
-    const f = total / soma;
-    const usados = new Set();
-    let t = 0;
-    const cenas = esc.lista.map((b, i) => {
-        const dur = i === esc.lista.length - 1 ? total - t : Math.max(12, Math.round(meio(b) * f));
-        const de = t; t += dur;
-        // a cena da demo com a mesma batida dá o fundo, os sons (relativos) e o cenário puro do estilo
-        const idx = (exemplo && exemplo.cenas || []).findIndex((c, j) => c.batida === b.nome && !usados.has(j));
-        if (idx >= 0) usados.add(idx);
-        const dc = idx >= 0 ? exemplo.cenas[idx] : null;
-        const fator = dc ? dur / Math.max(1, dc.ate - dc.de) : 1;
-        const cena = { batida: b.nome, de, ate: de + dur };
-        const entrada = i === 0 ? (dc && dc.entrada) || (b.entrada || [])[0] : (b.entrada || [])[0] || (dc && dc.entrada);
-        if (entrada) cena.entrada = entrada;
-        const fundo = dc && dc.fundo !== undefined ? dc.fundo : b.fundo;
-        if (fundo !== undefined) cena.fundo = fundo;
-        if (dc && dc.camera) cena.camera = dc.camera;
-        cena.camadas = dc ? (dc.camadas || []).filter((c) => ehCenario(sch, c.elemento)).map((c) => ({ ...c, cenario: true })) : [];
-        const sons = dc && dc.sons ? dc.sons.map((s) => ({ ...s, em: Math.round(s.em * fator) })).filter((s) => s.em < dur) : (b.sons || []).slice(0, 2).map((som, j) => ({ som, em: j * 6 }));
-        if (sons.length) cena.sons = sons;
-        cena.falta = true;
-        return cena;
-    });
-    const plano = { kit: ctx.k.slug, duracao: total };
-    if (exemplo && exemplo.trilha !== undefined) plano.trilha = exemplo.trilha;
-    else if (receita.trilha) plano.trilha = { volume: receita.trilha.volume ?? 0.5 };
-    const fGeral = exemplo && exemplo.duracao ? total / exemplo.duracao : 1;
-    for (const [c, v] of Object.entries(exemplo || {})) if (!/^(kit|duracao|trilha|cenas|roteiro)$/.test(c)) plano[c] = escalarQuadros(v, fGeral, c);
-    plano.cenas = cenas;
-    return { plano };
-}
-
-// ── o formulário de uma batida ───────────────────────────────────────────
-
-const TETO = 4700;
-function formulario(ctx, plano, n) {
-    const cena = plano.cenas[n - 1];
-    const b = (ctx.receita.batidas || []).find((x) => x.nome === cena.batida) || { elementos: [] };
-    const seg = ((cena.ate - cena.de) / FPS).toFixed(1);
-    const linhas = [`## Batida ${n}/${plano.cenas.length}: ${cena.batida} (${seg} s = ${cena.ate - cena.de} quadros; tempos das props contam do começo da cena)`];
-    if (b.nota) linhas.push(`O que é: ${b.nota}`);
-    const cen = cena.camadas.filter((c) => c.cenario).map((c) => c.elemento);
-    if (cen.length) linhas.push(`Cenário do estilo já posto (${cen.join(', ')}); mande só o conteúdo, ele fica.`);
-    linhas.push('Elementos desta batida (* = obrigatório):');
-    const daDemo = modelosDaDemo(ctx.exemplo);
-    const prontoServe = [...daDemo].some((m) => (SINONIMOS[m] || [m]).some((x) => semAcento(ctx.pessoa.produto || '').includes(x)));
-    const skill = lerSe(path.join(ctx.k.pasta, 'SKILL.md'));
-    for (const el of b.elementos || []) {
-        if (ehCenario(ctx.sch, el)) continue;
-        let n = ctx.sch.elementos[el];
-        // os modelos prontos são o produto da demo: se o da pessoa é outro, o campo nem aparece (ela monta com pecas)
-        if (n && n.k === 'obj' && n.campos.modelo && daDemo.size && !prontoServe) {
-            n = { ...n, campos: Object.fromEntries(Object.entries(n.campos).filter(([c]) => c !== 'modelo')) };
-            linhas.push(`- ${el}: (os modelos prontos do kit — ${[...daDemo].join(', ')} — são o produto da demo, não o dela: monte o produto dela com "pecas")`);
-            linhas.push(`  ${el}:${mostrarElemento(n, exemploDe(ctx, el))}`);
-        } else linhas.push(`- ${el}:${mostrarElemento(n, exemploDe(ctx, el))}`);
-        // o que a SKILL.md do kit ensina sobre este elemento (até 2 trechos)
-        const dicas = skill.split(/\n(?=\s*[-*]|\s*\d+\.)|\n\n/).filter((t) => t.includes(`\`${el}\``) && !/^\|/.test(t.trim())).slice(0, 2).map((t) => t.replace(/\s+/g, ' ').trim().slice(0, 380));
-        for (const d of dicas) linhas.push(`  Da SKILL: ${d}`);
-    }
-    const p = ctx.pessoa;
-    const tem = [];
-    if (p.produto) tem.push(`produto: ${p.produto}`);
-    if (p.marca) tem.push(`marca: ${p.marca}`);
-    if ((p.arquivos || []).length) tem.push(`arquivos dela: ${p.arquivos.join(', ')}`);
-    if ((p.cores || []).length) tem.push(`cores dela: ${p.cores.join(', ')}`);
-    linhas.push(`Da pessoa: ${tem.join(' · ') || 'só o pedido'}. Texto, produto e arquivos são DELA; nunca os da demo do kit.`);
-    linhas.push('Números: na escala da demo. Campo que você não sabe, deixe de fora: o padrão do elemento já é o do estilo.');
-    linhas.push(`Mande: primocode kit batida ${n} --camadas '[{"elemento":"…","props":{…}}]'   (ou --arquivo batida${n}.json)`);
-    let s = linhas.join('\n');
-    if (s.length > TETO) s = s.slice(0, TETO) + `\n…(cortado: primocode kit ver ${ctx.k.slug} elementos)`;
-    return s;
-}
-
-/** Um elemento em linhas: um campo por linha, com o que ele é (o /** doc *\/ do .tsx) e a escala da demo nos números. */
-function mostrarElemento(n, ex = {}) {
-    if (!n || n.k !== 'obj' || !Object.keys(n.campos).length) return ' {livre}';
-    return '\n' + Object.entries(n.campos).map(([c, v]) => {
-        let s = `    ${c}${v.opc ? '' : '*'}: ${mostrar(v.t, 1)}`;
-        if (v.doc) s += ` — ${v.doc.slice(0, 110)}`;
-        const e = ex[c];
-        if (e !== undefined && !/^(texto|midia)$/.test(v.t.k) && !/^(modelo|pecas)$/.test(c)) {
-            const j = JSON.stringify(e);
-            if (j && !/[a-z]{3,}"/i.test(j.replace(/"(em|de|ate|pos|rot|pivo|alvo|orbita|elevacao|distancia|grupo|curva)"/g, ''))) s += ` (na demo: ${j.length > 70 ? j.slice(0, 70) + '…' : j})`;
-        }
-        return s;
-    }).join('\n');
-}
-
-/** As props de um elemento na demo (a primeira vez que ele aparece), só pra dar a escala dos números. */
-function exemploDe(ctx, el) {
-    for (const c of (ctx.exemplo && ctx.exemplo.cenas) || []) for (const cam of c.camadas || []) if (cam.elemento === el) return cam.props || {};
-    return {};
-}
-
-/** O que falta no plano inteiro (antes do cartão). */
-function conferirPlano(ctx, plano) {
-    const erros = [];
-    (plano.cenas || []).forEach((c, i) => {
-        if (c.falta) { erros.push(`batida ${i + 1} (${c.batida}): ainda vazia → primocode kit batida ${i + 1}`); return; }
-        const b = (ctx.receita.batidas || []).find((x) => x.nome === c.batida) || { nome: c.batida, elementos: (c.camadas || []).map((x) => x.elemento) };
-        const r = conferirBatida(ctx, b, (c.camadas || []).map(({ elemento, props }) => ({ elemento, props })), i + 1);
-        for (const e of r.erros) erros.push(`batida ${i + 1}: ${e}`);
-    });
-    const c2 = { notas: [], erros: [], demo: ctx.demo, permitidos: ctx.permitidos, arquivoOk: ctx.arquivoOk };
-    const geral = Object.fromEntries(Object.entries(plano).filter(([c]) => ctx.sch.geral.campos[c]));
-    consertar(geral, { k: 'obj', campos: Object.fromEntries(Object.entries(ctx.sch.geral.campos).map(([c, v]) => [c, { ...v, opc: true }])) }, c2, ['geral']);
-    for (const e of c2.erros) erros.push(`${e} → primocode kit batida geral --props '{…}'`);
-    return erros;
-}
-
-module.exports = { textosDaCena, esquema, tiposDoKit, no, mostrar, consertar, contexto, conferirBatida, conferirPlano, esqueleto, formulario, ehCenario, produtoDaDemo, escolherBatidas, textosDaDemo };