primocode 10.5.0 → 10.6.0

package/lib/estudio/producao.js

@@ -22,11 +22,22 @@
  * provedor nenhum.
  *
  * Puro de propósito: a rede e o disco moram nos provedores, então o teste roda
- * sem chave e sem internet.
+ * sem chave e sem internet. A exceção é o cacheDe(pasta), que guarda o que já
+ * foi produzido num projeto.
+ *
+ * ── UMA NECESSIDADE, UMA CORRENTE ────────────────────────────────────────
+ *   produzirUma(pedido, provedores, { escolha, cache })  a mesma corrente para
+ *       a voz, a trilha e os efeitos do index.js. `escolha` (do roteiro:
+ *       `provedores: { voz: 'kokoro' }`) passa um provedor para a frente.
+ *       O cache é por necessidade + provedor: trocar a voz só refaz a voz.
  */
 
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
 // Quantas fotos cada tipo de parte do cinema costuma consumir.
 const FOTOS = { montagem: 3, climax: 4, numeros: 2, escada: 2, dia: 1 };
 
@@ -63,28 +74,107 @@ function necessidades(roteiro, { falaDe = textoPadrao } = {}) {
     return pedidos;
 }
 
+/** O provedor escolhido no roteiro vai para a frente; o resto segue na ordem. */
+function ordenar(provedores, escolha) {
+    const lista = (provedores || []).filter(Boolean);
+    const i = escolha ? lista.findIndex((pv) => pv.nome === String(escolha).toLowerCase()) : -1;
+    return i > 0 ? [lista[i], ...lista.slice(0, i), ...lista.slice(i + 1)] : lista;
+}
+
+/** A chave do cache: o que a cena pede (pedido.chave, ou o pedido todo) + quem gera. */
+function chaveDe(pedido, nome) {
+    const { destino, ...resto } = pedido || {};
+    const quer = resto.chave !== undefined ? [resto.tipo, resto.chave] : resto;
+    return crypto.createHash('sha1').update(JSON.stringify([quer, nome])).digest('hex').slice(0, 16);
+}
+
+/**
+ * Uma necessidade pela corrente: o primeiro provedor que entrega ganha. Erro,
+ * null ou { ok: false } cai no próximo; indisponível nem é chamado. Antes de
+ * gerar, cada provedor olha o cache dele (a mesma necessidade, o mesmo provedor).
+ */
+async function produzirUma(pedido, provedores, { escolha, cache, log = () => {} } = {}) {
+    const tentou = [];
+    let ultimo = null;
+    for (const pv of ordenar(provedores, escolha)) {
+        if (pv.disponivel && !pv.disponivel()) continue;
+        const chave = chaveDe(pedido, pv.nome);
+        const guardado = cache && cache.ler(chave, pedido);
+        if (guardado) return { ...pedido, ...guardado, ok: true, quem: pv.nome, doCache: true, tentou };
+        let r;
+        try {
+            r = await pv.gerar(pedido);
+            if (r && r.ok !== false) {
+                if (cache && !r.naoGuardar) cache.gravar(chave, r);
+                return { ...pedido, ...r, ok: true, quem: pv.nome, tentou };
+            }
+            tentou.push({ nome: pv.nome, motivo: (r && r.error) || 'não devolveu nada' });
+        } catch (e) {
+            tentou.push({ nome: pv.nome, motivo: (e && e.message) || String(e) });
+        }
+        if (r) ultimo = r;
+        log(`${pedido.tipo}: ${pv.nome} falhou, próximo`);
+    }
+    return { ...pedido, ...(ultimo || {}), ok: false, error: (ultimo && ultimo.error) || `ninguém produziu ${pedido.tipo}`, tentou };
+}
+
 /** Cada pedido pela corrente dos provedores do tipo dele, na ordem da lista. */
-async function produzir(pedidos, provedores, { log = () => {} } = {}) {
+async function produzir(pedidos, provedores, { log = () => {}, escolhas = {}, cache } = {}) {
     const itens = [];
     for (const pedido of pedidos || []) {
-        const tentou = [];
-        let feito = null;
-        for (const pv of (provedores || []).filter((x) => x && x.tipo === pedido.tipo)) {
-            if (pv.disponivel && !pv.disponivel()) continue;
-            try {
-                const r = await pv.gerar(pedido);
-                if (r) { feito = { ...pedido, ...r, ok: true, quem: pv.nome, tentou }; break; }
-                tentou.push({ nome: pv.nome, motivo: 'não devolveu nada' });
-            } catch (e) {
-                tentou.push({ nome: pv.nome, motivo: (e && e.message) || String(e) });
-            }
-            log(`${pedido.tipo}: ${pv.nome} falhou, próximo`);
-        }
-        itens.push(feito || { ...pedido, ok: false, tentou });
+        const daqui = (provedores || []).filter((x) => x && x.tipo === pedido.tipo);
+        itens.push(await produzirUma(pedido, daqui, { escolha: escolhas[pedido.tipo], cache, log }));
     }
     return { itens, faltou: itens.filter((i) => !i.ok) };
 }
 
+/** Os créditos (licença aberta pede atribuição) de tudo o que foi produzido. */
+function creditos(itens) {
+    return [...new Set((itens || []).filter((i) => i && i.ok).map((i) => i.credito).filter(Boolean))];
+}
+
+/** A linha do caderno: quem produziu cada coisa, e se veio do cache. */
+function linhaCaderno(item) {
+    if (!item.ok) return `${item.tipo}: ninguém produziu (${(item.tentou || []).map((t) => t.nome).join(', ') || 'sem provedor'})`;
+    const antes = (item.tentou || []).length ? `; antes falhou: ${item.tentou.map((t) => t.nome).join(', ')}` : '';
+    return `${item.tipo}: ${item.quem} (${item.doCache ? 'do cache' : 'gerou'}${antes})${item.credito ? ' — ' + item.credito : ''}`;
+}
+
+/**
+ * O cache de um projeto: midia/producao/cache.json. O arquivo de `r.arquivo`
+ * (a voz, que depois é acelerada no lugar) é copiado para lá e volta para o
+ * `pedido.destino` no acerto. Caminho "midia/..." que sumiu do disco é erro.
+ */
+function cacheDe(pasta) {
+    const dir = path.join(pasta, 'midia', 'producao');
+    const arq = path.join(dir, 'cache.json');
+    const ler = () => { try { return JSON.parse(fs.readFileSync(arq, 'utf8')); } catch { return {}; } };
+    const caminhos = (v) => (typeof v === 'string' ? (/^midia\//.test(v) ? [v] : [])
+        : v && typeof v === 'object' ? Object.values(v).flatMap(caminhos) : []);
+    return {
+        ler(chave, pedido = {}) {
+            const e = ler()[chave];
+            if (!e) return null;
+            const { arquivoCache, ...r } = e;
+            if (caminhos(r).some((c) => !fs.existsSync(path.join(pasta, c)))) return null;
+            if (arquivoCache) {
+                if (!pedido.destino || !fs.existsSync(path.join(dir, arquivoCache))) return null;
+                fs.copyFileSync(path.join(dir, arquivoCache), pedido.destino);
+            }
+            return r;
+        },
+        gravar(chave, r) {
+            try {
+                fs.mkdirSync(dir, { recursive: true });
+                const { arquivo, ...resto } = r;
+                const e = { ...resto };
+                if (arquivo && fs.existsSync(arquivo)) { e.arquivoCache = chave + path.extname(arquivo); fs.copyFileSync(arquivo, path.join(dir, e.arquivoCache)); }
+                fs.writeFileSync(arq, JSON.stringify({ ...ler(), [chave]: e }));
+            } catch { /* sem cache */ }
+        },
+    };
+}
+
 /** O resultado no formato que o montarCinema já recebe. */
 function paraCinema({ itens = [] } = {}) {
     const ok = itens.filter((i) => i.ok);
@@ -103,4 +193,4 @@ function paraCinema({ itens = [] } = {}) {
     };
 }
 
-module.exports = { necessidades, produzir, paraCinema, FOTOS };
+module.exports = { necessidades, produzir, produzirUma, ordenar, chaveDe, creditos, linhaCaderno, cacheDe, paraCinema, FOTOS };

package/lib/estudio/projeto.js

@@ -39,10 +39,13 @@ const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
 
+const { nomeCurto, semColisao } = require('../nome-curto.js');
+
 const CASA = path.join(os.homedir(), '.primocode', 'studio');
 const PROJETOS = path.join(CASA, 'projetos');
 
-/** Nome de pasta a partir do que a pessoa pediu. */
+/* Nome de ARQUIVO (o mp4, o pdf da saída). A pasta do projeto não usa mais
+   isto: ver `criar` e lib/nome-curto.js. */
 function apelidar(bruto) {
     return String(bruto || '')
         .normalize('NFD').replace(/[̀-ͯ]/g, '')
@@ -59,23 +62,64 @@ function garantirCasa() {
     return PROJETOS;
 }
 
-/**
- * Abre um projeto novo.
+/* ── ONDE MORA CADA PROJETO ──────────────────────────────────────────────
+ * Antes: `projetos/2026-10-11-claude-e-humano-conversam-sobre-o-segund`. A
+ * data na frente servia para a lista sair em ordem, e o resto era a frase
+ * cortada no meio. O dono: "essa estrutura de pastas está horrível".
+ *
+ * Agora: `projetos/2026-10/claude-segundo-cerebro`. O MÊS vira pasta (a
+ * ordem cronológica continua de graça, e um mês cabe numa tela), e o nome é
+ * curto e legível (lib/nome-curto.js). O dia exato fica no projeto.json.
  *
- * O id leva a DATA na frente. Não é enfeite: a pasta é listada em ordem
- * alfabética por quase tudo que lê disco, e com a data na frente essa ordem
- * já é a cronológica — que é como se procura um vídeo ("o de semana
- * passada"), não por nome.
+ * O id continua sendo SÓ o nome da pasta — sem o mês. É ele que o modelo
+ * escreve, que vai na memória e que a pessoa cita; pôr barra nele faria o
+ * `pastaDe` recusar (e com razão). Por isso o nome é único entre TODOS os
+ * meses, e quem acha a pasta pelo id é o `pastaDe`, que olha os meses.
+ *
+ * Os projetos antigos (`projetos/2026-09-25-...`) ficam onde estão: nada é
+ * renomeado, e o id antigo continua abrindo o mesmo projeto. */
+const MES = /^\d{4}-\d{2}$/;
+
+function mesDe(data = new Date()) {
+    return `${data.getFullYear()}-${String(data.getMonth() + 1).padStart(2, '0')}`;
+}
+
+/** As pastas de mês que existem, da mais nova para a mais velha. */
+function meses() {
+    try {
+        return fs.readdirSync(PROJETOS, { withFileTypes: true })
+            .filter((d) => d.isDirectory() && MES.test(d.name)).map((d) => d.name).sort().reverse();
+    } catch { return []; }
+}
+
+/** Todos os ids que existem, antigos (soltos) e novos (dentro do mês). */
+function idsTomados() {
+    const ids = [];
+    try {
+        for (const d of fs.readdirSync(PROJETOS, { withFileTypes: true })) {
+            if (d.isDirectory() && !MES.test(d.name)) ids.push(d.name);
+        }
+    } catch { /* casa vazia */ }
+    for (const m of meses()) {
+        try {
+            for (const d of fs.readdirSync(path.join(PROJETOS, m), { withFileTypes: true })) {
+                if (d.isDirectory()) ids.push(d.name);
+            }
+        } catch { /* mês sumiu no meio */ }
+    }
+    return ids;
+}
+
+/**
+ * Abre um projeto novo, em `projetos/<AAAA-MM>/<nome-curto>`.
  */
 function criar({ titulo, pedido, formato = 'video' }) {
     garantirCasa();
-    const dia = new Date().toISOString().slice(0, 10);
-    const base = `${dia}-${apelidar(titulo || pedido)}`;
-    let id = base;
-    let n = 2;
-    while (fs.existsSync(path.join(PROJETOS, id))) { id = `${base}-${n}`; n++; }
+    const texto = titulo || pedido;
+    const base = nomeCurto(texto) || 'projeto';
+    const id = semColisao(base, idsTomados(), `${titulo || ''} ${pedido || ''}`);
 
-    const pasta = path.join(PROJETOS, id);
+    const pasta = path.join(PROJETOS, mesDe(), id);
     for (const sub of ['midia', 'saida', 'entrada']) {
         fs.mkdirSync(path.join(pasta, sub), { recursive: true });
     }
@@ -125,7 +169,18 @@ function pastaDe(id) {
     if (typeof id !== 'string' || !id.trim()) return null;
     const limpo = id.trim();
     if (limpo.includes('/') || limpo.includes('\\') || limpo.includes('..')) return null;
-    return path.join(PROJETOS, limpo);
+    // Um mês não é projeto: "2026-10" como id abriria a pasta do mês inteiro.
+    if (MES.test(limpo)) return null;
+    // O antigo, solto na casa (`2026-09-25-...`), continua valendo.
+    const solto = path.join(PROJETOS, limpo);
+    if (fs.existsSync(solto)) return solto;
+    for (const m of meses()) {
+        const dentro = path.join(PROJETOS, m, limpo);
+        if (fs.existsSync(dentro)) return dentro;
+    }
+    // Não existe ainda: o lugar de antes. Quem precisa que exista (`ler`)
+    // confere o projeto.json; este caminho só serve para dizer onde seria.
+    return solto;
 }
 
 /** O meta de um projeto, ou null. */
@@ -147,14 +202,13 @@ function salvar(id, mudancas) {
 }
 
 /** Todos, do mais novo para o mais velho. */
+/* A ordem vinha do nome (a data na frente). Sem data no nome, ela vem do
+   `criado` do projeto.json — que todo projeto, velho ou novo, tem. */
 function listar({ limite = 50 } = {}) {
     garantirCasa();
-    let nomes = [];
-    try {
-        nomes = fs.readdirSync(PROJETOS, { withFileTypes: true })
-            .filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
-    } catch { return []; }
-    return nomes.slice(0, limite).map(ler).filter(Boolean);
+    const todos = idsTomados().map(ler).filter(Boolean);
+    todos.sort((a, b) => String(b.criado || '').localeCompare(String(a.criado || '')) || (a.id < b.id ? 1 : -1));
+    return todos.slice(0, limite);
 }
 
 // ── o caderno ────────────────────────────────────────────────────────────
@@ -216,7 +270,8 @@ function procurar(texto, { limite = 5 } = {}) {
         return { projeto: p, pontos };
     }).filter((x) => x.pontos > 0);
 
-    pontuados.sort((a, b) => b.pontos - a.pontos || (a.projeto.id < b.projeto.id ? 1 : -1));
+    pontuados.sort((a, b) => b.pontos - a.pontos
+        || String(b.projeto.criado || '').localeCompare(String(a.projeto.criado || '')));
     return pontuados.slice(0, limite).map((x) => x.projeto);
 }
 
@@ -278,7 +333,7 @@ function caminhoDeMidia(id, nome) {
 
 module.exports = {
     CASA, PROJETOS,
-    criar, ler, salvar, listar, procurar, pastaDe, apelidar,
+    criar, ler, salvar, listar, procurar, pastaDe, apelidar, mesDe,
     anotar, caderno,
     lerPlano, salvarPlano, versoes, voltarPara,
     caminhoDeMidia, escreverJSON, lerJSON,

package/lib/leitura.js

@@ -0,0 +1,176 @@
+/**
+ * leitura.js — ler uma página FORA do modelo, em cascata, com teste de tamanho.
+ *
+ * Ideia levada do `ax` (yusukebe/ax, "curl pra agente"): o modelo não precisa
+ * do HTML, precisa da ESTRUTURA — título, subtítulos, o texto principal, os
+ * links. Extrair isso aqui, de graça e de forma determinística, poupa a janela
+ * de contexto de um modelo gratuito, que é curta.
+ *
+ * A cascata para no primeiro passo que basta:
+ *   1. busca simples + extração local (sem navegador, sem modelo);
+ *   2. se saiu pouco texto (página que só existe depois do JavaScript), o
+ *      navegador escondido de lib/browser.js renderiza e a extração roda de novo;
+ *   3. o que vai pro modelo cabe num orçamento de caracteres: corta por seção,
+ *      e os subtítulos ficam todos — o modelo sabe o que existe na página
+ *      mesmo quando o texto de uma seção não coube.
+ *
+ * A regra que vale mais que a ferramenta: o teste de "leu" é o TAMANHO do que
+ * saiu, não o status 200. Página que devolve 85 caracteres "deu certo" e não
+ * leu nada.
+ */
+
+'use strict';
+
+// 400, o mesmo piso da pesquisa: casca de SPA deixa 200-300 caracteres de menu.
+const MINIMO = 400;
+const ORCAMENTO = 4500;
+const MAX_LINKS = 12;
+
+const ENTIDADES = { nbsp: ' ', amp: '&', lt: '<', gt: '>', quot: '"', '#39': "'", apos: "'" };
+function desentidade(s) {
+    return String(s || '')
+        .replace(/&(nbsp|amp|lt|gt|quot|#39|apos);/g, (_, k) => ENTIDADES[k])
+        .replace(/&#(\d+);/g, (_, n) => { try { return String.fromCodePoint(Number(n)); } catch { return ' '; } });
+}
+const limpo = (s) => desentidade(String(s || '').replace(/<[^>]+>/g, ' ')).replace(/\s+/g, ' ').trim();
+
+function atributo(tag, nome) {
+    const m = tag.match(new RegExp(`\\b${nome}\\s*=\\s*("([^"]*)"|'([^']*)'|([^\\s>]+))`, 'i'));
+    return m ? desentidade(m[2] ?? m[3] ?? m[4] ?? '') : '';
+}
+
+/** O conteúdo da primeira tag `nome` que tiver texto de verdade (main, article). */
+function regiao(html, nome) {
+    const re = new RegExp(`<${nome}\\b[^>]*>([\\s\\S]*?)<\\/${nome}>`, 'gi');
+    let m;
+    while ((m = re.exec(html))) if (limpo(m[1]).length >= 200) return m[1];
+    return null;
+}
+
+/**
+ * HTML → estrutura legível. Sem dependência: expressão regular basta para o
+ * que o modelo precisa (não é um parser, e não tenta ser).
+ * @returns {{titulo:string, descricao:string, secoes:Array<{titulo:string,texto:string}>, texto:string, links:Array<{texto:string,url:string}>}}
+ */
+function estruturaDe(html, base) {
+    const bruto = String(html || '').replace(/<!--[\s\S]*?-->/g, ' ')
+        .replace(/<(script|style|noscript|svg|template|iframe)\b[\s\S]*?<\/\1>/gi, ' ');
+    const titulo = limpo((bruto.match(/<title[^>]*>([\s\S]*?)<\/title>/i) || [])[1]);
+    const meta = (bruto.match(/<meta\b[^>]*(name|property)\s*=\s*["'](description|og:description)["'][^>]*>/i) || [])[0] || '';
+    const descricao = atributo(meta, 'content').trim();
+
+    // O miolo: <main>, senão <article>, senão o <body> sem menu, rodapé e lateral.
+    let corpo = regiao(bruto, 'main') || regiao(bruto, 'article')
+        || ((bruto.match(/<body\b[^>]*>([\s\S]*)<\/body>/i) || [])[1] ?? bruto);
+    corpo = corpo.replace(/<(nav|footer|header|aside)\b[\s\S]*?<\/\1>/gi, ' ');
+
+    const links = [];
+    const vistos = new Set();
+    corpo.replace(/<a\b([^>]*)>([\s\S]*?)<\/a>/gi, (_, attrs, dentro) => {
+        const href = atributo(attrs, 'href');
+        const texto = limpo(dentro);
+        if (!href || !texto || /^(#|javascript:|mailto:)/i.test(href) || links.length >= MAX_LINKS) return '';
+        let url = href;
+        try { url = new URL(href, base || undefined).href; } catch { /* fica relativo */ }
+        if (!vistos.has(url)) { vistos.add(url); links.push({ texto: texto.slice(0, 80), url }); }
+        return '';
+    });
+
+    // Subtítulo vira marcador; bloco vira quebra de linha; o resto some.
+    const marcado = corpo
+        .replace(/<h([1-3])\b[^>]*>([\s\S]*?)<\/h\1>/gi, (_, n, t) => `\n\u0001${limpo(t)}\n`)
+        .replace(/<(br|\/p|\/li|\/div|\/section|\/tr|\/h[4-6]|\/pre|\/blockquote)\b[^>]*>/gi, '\n')
+        .replace(/<li\b[^>]*>/gi, '\n- ')
+        .replace(/<[^>]+>/g, ' ');
+    const secoes = [{ titulo: '', texto: '' }];
+    for (const linhaCrua of desentidade(marcado).split('\n')) {
+        const linha = linhaCrua.replace(/\s+/g, ' ').trim();
+        if (!linha || linha === '-') continue;
+        if (linha.startsWith('\u0001')) secoes.push({ titulo: linha.slice(1).trim(), texto: '' });
+        else secoes[secoes.length - 1].texto += (secoes[secoes.length - 1].texto ? '\n' : '') + linha;
+    }
+    const uteis = secoes.filter((s) => s.titulo || s.texto);
+    const texto = uteis.map((s) => [s.titulo, s.texto].filter(Boolean).join('\n')).join('\n');
+    return { titulo, descricao, secoes: uteis, texto, links };
+}
+
+function cortar(texto, max) {
+    if (texto.length <= max) return texto;
+    if (max < 20) return '';
+    const corte = texto.slice(0, max - 1);
+    const espaco = corte.lastIndexOf(' ');
+    return (espaco > max * 0.6 ? corte.slice(0, espaco) : corte) + '…';
+}
+
+/**
+ * Passo 3: o que vai pro modelo cabe em `orcamento` caracteres. Os subtítulos
+ * ficam TODOS; o texto de cada seção divide o que sobra por igual, e seção
+ * curta devolve a sobra pras outras (enchimento por nível).
+ */
+function caber(est, orcamento = ORCAMENTO) {
+    const cabeca = [est.titulo && `# ${est.titulo}`, est.descricao && `> ${est.descricao}`].filter(Boolean).join('\n');
+    const listaLinks = est.links.length
+        ? '\nLinks:\n' + est.links.map((l) => `- ${l.texto} — ${l.url}`).join('\n') : '';
+    const linksCabem = cortar(listaLinks, Math.floor(orcamento * 0.15));
+    const titulos = est.secoes.reduce((n, s) => n + (s.titulo ? s.titulo.length + 5 : 0) + 1, 0);
+    let livre = Math.max(0, orcamento - cabeca.length - linksCabem.length - titulos - 2);
+
+    const cotas = new Array(est.secoes.length).fill(0);
+    let pendentes = est.secoes.map((_, i) => i).filter((i) => est.secoes[i].texto);
+    while (pendentes.length && livre > 0) {
+        const parte = Math.floor(livre / pendentes.length);
+        const curtas = pendentes.filter((i) => est.secoes[i].texto.length <= parte);
+        if (!curtas.length) { pendentes.forEach((i) => { cotas[i] = parte; }); break; }
+        curtas.forEach((i) => { cotas[i] = est.secoes[i].texto.length; livre -= cotas[i]; });
+        pendentes = pendentes.filter((i) => !curtas.includes(i));
+    }
+    let cortado = linksCabem.length < listaLinks.length;
+    const corpo = est.secoes.map((s, i) => {
+        const t = cortar(s.texto, cotas[i]);
+        if (t.length < s.texto.length) cortado = true;
+        return [s.titulo && `## ${s.titulo}`, t].filter(Boolean).join('\n');
+    }).join('\n');
+    const conteudo = [cabeca, corpo].filter(Boolean).join('\n\n') + linksCabem;
+    // A cerca final: nenhum caminho passa do orçamento.
+    return { conteudo: conteudo.slice(0, orcamento), cortado: cortado || conteudo.length > orcamento };
+}
+
+const bastante = (est, minimo) => !!est && est.texto.length >= minimo;
+
+/**
+ * A cascata inteira. `pegar(url)` devolve o HTML da busca simples; `navegador(url)`
+ * devolve o HTML depois do JavaScript (opcional). `html` pula o passo 1 de rede
+ * quando quem chama já baixou a página.
+ * @returns {Promise<{ok:boolean, passo:number, como:string, chars:number, enviados:number, cortado:boolean, conteudo:string, titulo:string, texto:string}>}
+ */
+async function ler(url, { pegar, navegador, html, orcamento = ORCAMENTO, minimo = MINIMO } = {}) {
+    const monta = (passo, como, est) => {
+        const { conteudo, cortado } = caber(est, orcamento);
+        return { ok: true, url, passo, como, chars: est.texto.length, enviados: conteudo.length,
+            cortado, conteudo, titulo: est.titulo, texto: est.texto };
+    };
+    let e1 = null;
+    let semScript = false;
+    try {
+        const h = html != null ? html : (pegar ? await pegar(url) : null);
+        if (h) { e1 = estruturaDe(h, url); semScript = !/<script\b/i.test(h); }
+    } catch { /* passo 1 falhou: o navegador tenta */ }
+    if (bastante(e1, minimo)) return monta(1, 'busca simples', e1);
+
+    // Página sem nenhum <script> é curta de verdade: o navegador não acharia mais nada.
+    let e2 = null;
+    if (navegador && !semScript) {
+        try {
+            const h = await navegador(url);
+            if (h) e2 = estruturaDe(h, url);
+        } catch { /* sem navegador: fica o que o passo 1 trouxe */ }
+        if (bastante(e2, minimo)) return monta(2, 'navegador (a página precisa de JavaScript)', e2);
+    }
+    const melhor = [e1, e2].filter(Boolean).sort((a, b) => b.texto.length - a.texto.length)[0];
+    return { ok: false, url, passo: e2 ? 2 : 1, como: 'nenhum passo leu o bastante',
+        chars: melhor ? melhor.texto.length : 0, enviados: 0, cortado: false, conteudo: '',
+        titulo: melhor ? melhor.titulo : '', texto: melhor ? melhor.texto : '',
+        error: `a página deu ${melhor ? melhor.texto.length : 0} caracteres de texto (o mínimo é ${minimo})` };
+}
+
+module.exports = { ler, estruturaDe, caber, MINIMO, ORCAMENTO };