primocode 10.17.1 → 10.19.0

package/lib/kits-plano.js

@@ -0,0 +1,557 @@
+/**
+ * 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 };