@neetru/cli 2.33.0 → 2.34.0

package/dist/lib/build-targets.js

@@ -230,25 +230,65 @@ export function comandoExecBin(pm, bin, args) {
 }
 /** Profundidade máxima de varredura dentro do standalone à procura do server.js. */
 const MAX_PROFUNDIDADE_STANDALONE = 6;
+/**
+ * Lê `relativeAppDir` de `<appDir>/.next/required-server-files.json`.
+ *
+ * bug_678ddc98 (comportamento esperado do relato): é o Next.js que decide onde o
+ * `server.js` cai dentro do standalone, e ele grava essa decisão neste arquivo
+ * no MESMO build — `relativeAppDir = path.relative(outputFileTracingRoot,
+ * appDir)`, a mesma conta que ele usa pra escrever
+ * `.next/standalone/<relativeAppDir>/server.js`. Ler a declaração dispensa
+ * adivinhar pela árvore.
+ *
+ * Num build feito no Windows o valor vem com `\`; aqui sai sempre com `/`, que
+ * é o formato do membro no tar e do `entrypoint` no deploy.
+ */
+export function lerRelativeAppDir(appDir) {
+    const json = lerJson(path.join(appDir, '.next', 'required-server-files.json'));
+    const bruto = json?.relativeAppDir;
+    if (typeof bruto !== 'string')
+        return { tipo: 'ausente' };
+    const posix = bruto.replace(/\\/g, '/');
+    if (posix.startsWith('/') || /^[A-Za-z]:/.test(posix))
+        return { tipo: 'invalido', valor: bruto };
+    const partes = posix.split('/').filter((p) => p !== '' && p !== '.');
+    if (partes.includes('..'))
+        return { tipo: 'invalido', valor: bruto };
+    return { tipo: 'declarado', prefixo: partes.join('/') };
+}
+function ehArquivo(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Acha ONDE o `server.js` do Next.js ficou dentro de `.next/standalone`.
  *
  * Em repo de app único ele está na raiz; em monorepo o Next.js aninha o app sob
  * o caminho dele relativo ao `outputFileTracingRoot` (`apps/web/server.js`).
  * Não dá pra deduzir esse prefixo do `next.config` (o `outputFileTracingRoot`
- * pode ser implícito, vindo da detecção de workspace do próprio Next.js), então
- * a verdade é a árvore PÓS-BUILD — a mesma lógica do `isStandaloneBuildDir`.
+ * pode ser implícito, vindo da detecção de workspace do próprio Next.js).
  *
- * Varredura em largura, pulando `node_modules` (pacote dependente pode ter um
- * `server.js` qualquer e envenenar a busca). Entre candidatos, ganha o que
- * TAMBÉM tem um diretório `.next` ao lado — é o par que o Next.js sempre emite
- * junto (`server.js` + `.next/` com os chunks de servidor). Empate real resolve
- * pelo mais raso e, em seguida, por ordem alfabética (determinismo: dois builds
- * da mesma árvore têm que dar o mesmo tarball).
+ * 1. Primeiro vale o que o Next.js DECLAROU (`relativeAppDir` em
+ *    `.next/required-server-files.json`, ver `lerRelativeAppDir`). Se ele
+ *    declarou um lugar e o `server.js` não está lá — ou declarou um lugar fora
+ *    da raiz de tracing — devolve `null`: o build está incoerente e escolher
+ *    outro `server.js` da árvore empacotaria o app errado.
+ * 2. Sem a declaração (Next.js antigo), a verdade é a árvore PÓS-BUILD — a
+ *    mesma lógica do `isStandaloneBuildDir`. Varredura em largura, pulando
+ *    `node_modules` (pacote dependente pode ter um `server.js` qualquer e
+ *    envenenar a busca). Entre candidatos, ganha o que TAMBÉM tem um diretório
+ *    `.next` ao lado — é o par que o Next.js sempre emite junto (`server.js` +
+ *    `.next/` com os chunks de servidor). Empate real resolve pelo mais raso e,
+ *    em seguida, por ordem alfabética (determinismo: dois builds da mesma árvore
+ *    têm que dar o mesmo tarball).
  *
  * Devolve `null` quando não há standalone nenhum (build não-standalone) ou
- * quando há standalone mas nenhum `server.js` — nesse segundo caso quem chama
- * precisa FALHAR, nunca empacotar um tarball sem entrypoint.
+ * quando há standalone mas nenhum `server.js` no lugar certo — nesse segundo
+ * caso quem chama precisa FALHAR, nunca empacotar um tarball sem entrypoint.
  */
 export function resolveStandaloneLayout(appDir) {
     const standaloneDir = path.join(appDir, '.next', 'standalone');
@@ -259,6 +299,20 @@ export function resolveStandaloneLayout(appDir) {
     catch {
         return null;
     }
+    const declarado = lerRelativeAppDir(appDir);
+    if (declarado.tipo === 'invalido')
+        return null;
+    if (declarado.tipo === 'declarado') {
+        const prefixo = declarado.prefixo;
+        const server = path.join(standaloneDir, ...prefixo.split('/').filter(Boolean), 'server.js');
+        if (!ehArquivo(server))
+            return null;
+        return {
+            standaloneDir,
+            appPrefix: prefixo,
+            entrypoint: prefixo ? `${prefixo}/server.js` : 'server.js',
+        };
+    }
     const candidatos = [];
     const fila = [
         { dir: standaloneDir, prefix: '', profundidade: 0 },

package/dist/lib/cli-write.js

@@ -308,14 +308,17 @@ export async function resolveStepUp(opts) {
         // P105: o comando alternativo (`neetru auth mfa-session`) também só é
         // citado se existe na árvore do Commander.
         const sessao = (withCommand, withoutCommand) => adviseCommand({ command: 'auth mfa-session', withCommand, withoutCommand });
+        // Etapa 1 do bug_89d2497e: o texto dizia "modo --json/não-interativo", e
+        // `vm provision` e `agent release` chegam aqui sem declarar --json. O
+        // ramo é o não-interativo (`--json` é um caso dele), e é isso que se diz.
         const msg = adviseFlag({
             flag: '--mfa-token',
             withFlag: sessao('Operação destrutiva top-tier exige step-up MFA: passe --mfa-token <código TOTP> ' +
-                '(modo --json/não-interativo) ou rode `neetru auth mfa-session` para obter uma sessão de 1h.', 'Operação destrutiva top-tier exige step-up MFA: passe --mfa-token <código TOTP> ' +
-                '(modo --json/não-interativo).'),
+                '(modo não-interativo) ou rode `neetru auth mfa-session` para obter uma sessão de 1h.', 'Operação destrutiva top-tier exige step-up MFA: passe --mfa-token <código TOTP> ' +
+                '(modo não-interativo).'),
             withoutFlag: sessao('Operação destrutiva top-tier exige step-up MFA: rode `neetru auth mfa-session` ' +
                 'para obter uma sessão de 1h e repita o comando.', 'Operação destrutiva top-tier exige step-up MFA, e esta CLI não tem, neste comando, ' +
-                'como enviá-lo em modo --json/não-interativo.'),
+                'como enviá-lo em modo não-interativo.'),
         });
         exitWithCliError(new NeetruCliError(msg, { code: 'mfa_required', exit: EXIT_CODES.client }), opts.json);
         return { headers }; // safeExit não retorna em prod; satisfaz o tipo + testes

package/dist/lib/code-agent-gateway.d.ts

@@ -16,8 +16,8 @@ export declare function callGateway(settings: CodeSettings, messages: CodeMessag
  * resposta se o AI Gateway suportar"). Mesmo padrão de `streamGateway` em
  * `src/lib/ai/orchestrator.ts` (fetch direto + `readSseLines` compartilhado) —
  * não passa por `apiRequest`/`apiStream` porque nenhum dos dois fala SSE, e
- * não importa o orchestrator inteiro só por essa função (ele carrega
- * @anthropic-ai/sdk + openai, que `neetru code` não precisa).
+ * não importa o orchestrator inteiro só por essa função (ele carrega o SDK
+ * `openai`, que `neetru code` não precisa).
  *
  * Acumula os deltas e retorna o texto completo — o protocolo
  * `NEETRU_TOOL`/`NEETRU_PATCH` só pode ser parseado sobre a resposta inteira,

package/dist/lib/code-agent-gateway.js

@@ -34,8 +34,8 @@ export async function callGateway(settings, messages, signal) {
  * resposta se o AI Gateway suportar"). Mesmo padrão de `streamGateway` em
  * `src/lib/ai/orchestrator.ts` (fetch direto + `readSseLines` compartilhado) —
  * não passa por `apiRequest`/`apiStream` porque nenhum dos dois fala SSE, e
- * não importa o orchestrator inteiro só por essa função (ele carrega
- * @anthropic-ai/sdk + openai, que `neetru code` não precisa).
+ * não importa o orchestrator inteiro só por essa função (ele carrega o SDK
+ * `openai`, que `neetru code` não precisa).
  *
  * Acumula os deltas e retorna o texto completo — o protocolo
  * `NEETRU_TOOL`/`NEETRU_PATCH` só pode ser parseado sobre a resposta inteira,

package/dist/lib/code-agent-settings.d.ts

@@ -1,3 +1,4 @@
+import { type ProvedorIa } from './ai/provedores.js';
 export declare const DEFAULT_CODE_MODEL = "llama-3.3-70b-versatile";
 export declare const DEFAULT_CODE_MAX_TURNS = 8;
 export declare const DEFAULT_CODE_MAX_TOKENS = 4096;
@@ -24,8 +25,7 @@ export interface ResolvedCodeModel {
 }
 export declare function isAnthropicModel(model: string | undefined): boolean;
 export declare function resolveCodeModel(input: ResolveCodeModelInput): ResolvedCodeModel;
-declare const KNOWN_CATALOG_PROVIDERS: readonly ["groq", "nvidia", "openai"];
-type CatalogProvider = (typeof KNOWN_CATALOG_PROVIDERS)[number];
+type CatalogProvider = ProvedorIa;
 /**
  * GAP-M1-16 (2026-07-10): resolve o provider a forçar no request — prioridade
  * `--provider` (flag explícita da tarefa) sobre `gatewayProvider` configurado

package/dist/lib/code-agent-settings.js

@@ -1,3 +1,4 @@
+import { ehProvedorIa } from './ai/provedores.js';
 export const DEFAULT_CODE_MODEL = 'llama-3.3-70b-versatile';
 export const DEFAULT_CODE_MAX_TURNS = 8;
 export const DEFAULT_CODE_MAX_TOKENS = 4096;
@@ -37,7 +38,6 @@ export function resolveCodeModel(input) {
     }
     return { model: DEFAULT_CODE_MODEL };
 }
-const KNOWN_CATALOG_PROVIDERS = ['groq', 'nvidia', 'openai'];
 /**
  * Nomes de modelo NATIVOS de um único provider do catálogo curado
  * (model-catalog.ts no Core, GAP-M1-16) — duplicados aqui de propósito pra
@@ -68,9 +68,7 @@ const NATIVE_MODEL_PROVIDER = {
 export function resolveCodeProvider(cliProvider, configuredProvider, model) {
     const explicit = firstNonEmpty(cliProvider, configuredProvider);
     if (explicit) {
-        return KNOWN_CATALOG_PROVIDERS.includes(explicit)
-            ? explicit
-            : undefined;
+        return ehProvedorIa(explicit) ? explicit : undefined;
     }
     // Nenhum dos dois informado — tenta inferir do nome do modelo antes de
     // desistir pro WRRR livre (ver doc de NATIVE_MODEL_PROVIDER acima).

package/dist/lib/code-agent-types.d.ts

@@ -3,6 +3,7 @@
  * (code.ts, code-agent-ui.ts, code-agent-gateway.ts, code-agent-tools.ts,
  * code-agent-session.ts) — evita import circular de tipo entre eles.
  */
+import type { ProvedorIa } from './ai/provedores.js';
 export type CodeRole = 'system' | 'user' | 'assistant';
 export interface CodeMessage {
     role: CodeRole;
@@ -33,7 +34,8 @@ export interface CodeSettings {
     files: string[];
     model: string;
     /** GAP-M1-16 (2026-07-10) — `neetru ai models` lista as opções; ausente = WRRR entre todos. */
-    provider?: 'groq' | 'nvidia' | 'openai';
+    provider?: ProvedorIa;
+    /** Aviso mostrado ao abrir: modelo trocado e/ou `--provider` fora da lista (uma linha cada). */
     modelWarning?: string;
     maxTurns: number;
     maxTokens: number;

package/dist/lib/config.d.ts

@@ -1,25 +1,22 @@
 import Conf from 'conf';
+import { type ModeloDoAi, type ProvedorIa } from './ai/provedores.js';
 interface NeetruConfig {
-    anthropicApiKey?: string;
     openaiApiKey?: string;
-    geminiApiKey?: string;
     groqApiKey?: string;
     nvidiaApiKey?: string;
     groqModel?: string;
     nvidiaModel?: string;
-    claudeModel?: string;
     openaiModel?: string;
-    geminiModel?: string;
     gatewayModel?: string;
-    gatewayProvider?: 'groq' | 'nvidia' | 'openai';
+    gatewayProvider?: ProvedorIa;
     gatewayEffort?: 'low' | 'medium' | 'high';
     neetruApiKey?: string;
     neetruApiUrl: string;
-    defaultModel: 'claude' | 'openai' | 'gemini' | 'groq' | 'nvidia' | 'gateway' | 'auto';
+    defaultModel: ModeloDoAi;
     projectName?: string;
     'telemetry.enabled'?: boolean;
 }
 export declare const config: Conf<NeetruConfig>;
 export declare function getKey(name: keyof NeetruConfig): string | boolean | undefined;
-export declare function requireKey(name: 'anthropicApiKey' | 'openaiApiKey' | 'geminiApiKey' | 'neetruApiKey'): string;
+export declare function requireKey(name: 'openaiApiKey' | 'neetruApiKey'): string;
 export {};

package/dist/lib/config.js

@@ -1,4 +1,5 @@
 import Conf from 'conf';
+import { PROVEDORES_IA } from './ai/provedores.js';
 const defaults = {
     neetruApiUrl: 'https://api.neetru.com',
     defaultModel: 'auto',
@@ -13,24 +14,26 @@ export const config = new Conf({
     configFileMode: 0o600,
     defaults,
     schema: {
-        anthropicApiKey: { type: 'string' },
         openaiApiKey: { type: 'string' },
-        geminiApiKey: { type: 'string' },
         groqApiKey: { type: 'string' },
         nvidiaApiKey: { type: 'string' },
         groqModel: { type: 'string' },
         nvidiaModel: { type: 'string' },
-        claudeModel: { type: 'string' },
         openaiModel: { type: 'string' },
-        geminiModel: { type: 'string' },
         gatewayModel: { type: 'string' },
-        gatewayProvider: { type: 'string', enum: ['groq', 'nvidia', 'openai'] },
+        gatewayProvider: { type: 'string', enum: [...PROVEDORES_IA] },
         gatewayEffort: { type: 'string', enum: ['low', 'medium', 'high'] },
         neetruApiKey: { type: 'string' },
         neetruApiUrl: { type: 'string', default: 'https://api.neetru.com' },
+        // SEM `enum` de propósito (bug_19d312f3): o `conf` valida o arquivo inteiro
+        // em TODA leitura, e um config.json com `defaultModel: "claude"` ou
+        // `"gemini"` (gravado por versão antiga) derrubaria qualquer comando da CLI
+        // com "Config schema violation". Quem confere o valor: `neetru config set
+        // defaultModel` (recusa o que não está em `MODELOS_DO_AI`), o `neetru ai`
+        // sem `-m` (`runAiRepl` sai com 1 e diz como voltar ao `auto`) e o `chat()`
+        // do orchestrator, para quem o chama sem modelo.
         defaultModel: {
             type: 'string',
-            enum: ['claude', 'openai', 'gemini', 'groq', 'nvidia', 'gateway', 'auto'],
             default: 'auto',
         },
         'telemetry.enabled': { type: 'boolean' },

package/dist/lib/deploy-recusa-de-destino.d.ts

@@ -0,0 +1,9 @@
+/** O que dizer sobre a recusa, em linhas. Exportado para teste. */
+export declare function explicacaoDaRecusaDeDestino(productSlug: string, ambiente: string, destinoAtual: string, destinoPedido: string): string[];
+/**
+ * Se `err` é a recusa de destino do Core, devolve o mesmo erro canônico do
+ * `handleApiError` (mesmo código, mesmo exit, mesmo `message`) com a explicação
+ * no texto humano e, no `--json`, em `hint` — mais `ambiente`, `destinoAtual` e
+ * `destinoPedido`. Qualquer outro erro volta intacto.
+ */
+export declare function explicarRecusaDeDestino(err: unknown, productSlug: string): unknown;

package/dist/lib/deploy-recusa-de-destino.js

@@ -0,0 +1,98 @@
+/**
+ * Recusa do Core "Ambiente <x> tem destino '<a>', não '<b>'" — o que a CLI diz
+ * ao dev quando o deploy esbarra nela.
+ *
+ * ORIGEM — bug_6d92ef71 (rodada 4) e bug_fe30f035 (Core, aberto).
+ *
+ * O aviso do `--port` e o `neetru deploy --help` (`deploy-vm-um-app.ts`)
+ * ensinam que dois apps na VM são dois produtos: `neetru products create` e o
+ * deploy de cada um com o seu `--product`. A revisão da cli#99 mediu no Core
+ * (origin/main dc45be28; conferido de novo em f60ea772) que esse caminho
+ * esbarra, hoje, num defeito do Core:
+ *  - `_createProductCore` (`_products-core.ts`) cria staging e prod chamando
+ *    `_ensureEnvironmentCore` sem `target`, e o padrão é 'workspace';
+ *  - `_deployToVmCore` (e `_deployToCloudRunCore`) chama `_ensureEnvironmentCore`
+ *    pedindo o próprio destino, mas o destino só vale na CRIAÇÃO: o ambiente que
+ *    já existe volta como está, e o deploy lança "Ambiente prod tem destino
+ *    'workspace', não 'vm'. Migre o destino antes (changeEnvironmentTarget) ou
+ *    use o destino atual." — a rota `/api/cli/v1/deploy` responde 400
+ *    (`vm_deploy_failed` / `cloud_run_deploy_failed`) com esse texto;
+ *  - `changeEnvironmentTarget` não tem rota `/api/cli/v1`, e a CLI não tem
+ *    comando que troque o destino de um ambiente.
+ * Ou seja: o 1º deploy na VM de um produto criado pelo `neetru products create`
+ * é recusado, e o recado manda o dev para um caminho que ele não tem.
+ *
+ * O conserto do destino é do Core (bug_fe30f035). Aqui a CLI só deixa de largar
+ * o dev diante do recado: reconhece a recusa e diz o que aconteceu e o que dá
+ * para fazer. Só age quando o Core recusa DE FATO — quando o Core for
+ * consertado, o produto novo deixa de cair aqui e este texto não fica dizendo
+ * coisa velha. Se o Core mudar o recado, o reconhecimento falha fechado: o erro
+ * segue como sempre seguiu (`handleApiError`, com o texto do Core).
+ *
+ * Conferido de novo em 24/10 na main do Core (582124ab): a mesma cadeia. O
+ * conserto proposto (core#791, aberto) faz o deploy trocar o destino de um
+ * ambiente que nunca serviu e, para o que já serviu, troca o recado por outro
+ * sem a cauda `changeEnvironmentTarget` — que esta regex exige. Com ele no ar,
+ * nada cai aqui e o erro do Core passa como veio.
+ */
+import { CliApiError } from './api-client.js';
+import { NeetruCliError } from '../cli-kit/errors.js';
+import { cliErrorFromApiError } from './api-error.js';
+/**
+ * O recado do Core, de `_vm-deploy-core.ts` e `_cloud-run-deploy-core.ts`.
+ * A cauda `Migre o destino antes (changeEnvironmentTarget)` faz parte do
+ * reconhecimento de propósito: é ela que manda o dev para o caminho que ele não
+ * tem. A recusa do workspace (`… A Fase 1 do fluxo de ambientes só publica no
+ * destino workspace.`) não a traz e fica de fora.
+ */
+const RECUSA_DE_DESTINO = /Ambiente (\S+) tem destino '([^']+)', não '([^']+)'\. Migre o destino antes \(changeEnvironmentTarget\)/;
+/** Destinos em que um app roda — os únicos que vale sugerir em `--target`. */
+const DESTINOS_DE_APP = new Set(['vm', 'cloud-run']);
+/** O que dizer sobre a recusa, em linhas. Exportado para teste. */
+export function explicacaoDaRecusaDeDestino(productSlug, ambiente, destinoAtual, destinoPedido) {
+    const linhas = [
+        `O ambiente ${ambiente} de ${productSlug} está com destino '${destinoAtual}', e este deploy pediu '${destinoPedido}'.`,
+        'A CLI não tem comando para trocar o destino de um ambiente (o changeEnvironmentTarget do recado acima',
+        'não está ao alcance dela).',
+    ];
+    if (destinoAtual === 'workspace') {
+        linhas.push('Produto criado pelo `neetru products create` nasce com staging e prod no destino workspace, e hoje o', '1º deploy dele na VM ou no Cloud Run é recusado assim. É defeito do Core (bug_fe30f035): até o conserto,', 'este deploy não segue pela CLI — leve o caso a um admin do Core.');
+    }
+    else if (DESTINOS_DE_APP.has(destinoAtual)) {
+        linhas.push(`Para seguir no destino atual, refaça o deploy com --target ${destinoAtual}; para trocar o destino,`, 'leve o caso a um admin do Core.');
+    }
+    else {
+        linhas.push('Para trocar o destino, leve o caso a um admin do Core.');
+    }
+    return linhas;
+}
+/**
+ * Se `err` é a recusa de destino do Core, devolve o mesmo erro canônico do
+ * `handleApiError` (mesmo código, mesmo exit, mesmo `message`) com a explicação
+ * no texto humano e, no `--json`, em `hint` — mais `ambiente`, `destinoAtual` e
+ * `destinoPedido`. Qualquer outro erro volta intacto.
+ */
+export function explicarRecusaDeDestino(err, productSlug) {
+    if (!(err instanceof CliApiError) || err.status !== 400)
+        return err;
+    const achado = RECUSA_DE_DESTINO.exec(err.message);
+    if (!achado)
+        return err;
+    const [, ambiente, destinoAtual, destinoPedido] = achado;
+    const linhas = explicacaoDaRecusaDeDestino(productSlug, ambiente, destinoAtual, destinoPedido);
+    const canonico = cliErrorFromApiError(err);
+    return new NeetruCliError(canonico.message, {
+        code: canonico.code,
+        exit: canonico.exit,
+        cause: err,
+        details: {
+            ...canonico.details,
+            ambiente,
+            destinoAtual,
+            destinoPedido,
+            hint: linhas.join(' '),
+        },
+        human: [canonico.human, ...linhas.map((l) => `  ${l}`)].join('\n'),
+    });
+}
+//# sourceMappingURL=deploy-recusa-de-destino.js.map

package/dist/lib/deploy-render-probe.d.ts

@@ -0,0 +1,117 @@
+/** Veredito da checagem da página inicial. */
+export type RenderVerdict = 'ok' | 'inline_scripts_blocked' | 'unverifiable';
+export interface RenderCheck {
+    verdict: RenderVerdict;
+    /** URL final conferida (depois de redirects na mesma origem). */
+    url: string;
+    httpStatus: number | null;
+    /** Scripts embutidos executáveis achados no HTML lido. */
+    inlineScripts: number;
+    /** Quantos deles a CSP bloqueia. */
+    blockedInlineScripts: number;
+    /** Diretiva que bloqueou (ex.: `script-src 'self'`), cortada. */
+    blockingDirective: string | null;
+    /** Por que não deu pra conferir (só em `unverifiable`). */
+    reason: string | null;
+}
+/** Resultado bruto de UMA requisição à página inicial. */
+export type RenderProbeInput = {
+    kind: 'response';
+    httpStatus: number;
+    contentType: string | null;
+    /** Valores crus de `Content-Security-Policy` (o fetch junta repetidos com ", "). */
+    cspHeaderValues: string[];
+    html: string;
+} | {
+    kind: 'network_error';
+    error: string;
+};
+/** Teto de bytes lidos do HTML (os scripts do Next aparecem já no começo do body). */
+export declare const RENDER_BODY_MAX_BYTES: number;
+/** Redirects seguidos dentro da MESMA origem (ex.: `/` → `/pt-BR`). */
+export declare const RENDER_MAX_REDIRECTS = 2;
+/** Uma política CSP: diretiva (minúscula) → lista de fontes. */
+export interface CspPolicy {
+    directives: Map<string, string[]>;
+}
+/**
+ * Lê UMA política serializada (`a b; c d`). Diretiva repetida: vale a primeira
+ * (CSP3 §2.2.1). Nome de diretiva inválido é ignorado. PURA.
+ */
+export declare function parseCspPolicy(text: string): CspPolicy;
+/**
+ * Lê o valor de um cabeçalho `Content-Security-Policy`: várias políticas vêm
+ * separadas por vírgula (cabeçalhos repetidos também chegam assim, juntados
+ * pelo fetch). Política vazia é descartada. PURA.
+ */
+export declare function parseCspHeader(value: string): CspPolicy[];
+/**
+ * Lista de fontes que governa um `<script>` embutido: `script-src-elem`, senão
+ * `script-src`, senão `default-src`. `undefined` = a política não restringe
+ * script. PURA.
+ */
+export declare function scriptElementSources(policy: CspPolicy): {
+    name: string;
+    sources: string[];
+} | undefined;
+export interface InlineScript {
+    nonce: string | null;
+    content: string;
+}
+/**
+ * Este `<script>` embutido roda sob esta lista de fontes? Regras do navegador
+ * (CSP3 "Does element match source list for type and source"):
+ *  - nonce do elemento igual a um `'nonce-…'` da lista → roda;
+ *  - hash do conteúdo igual a um `'sha256|384|512-…'` → roda;
+ *  - `'unsafe-inline'` → roda, MAS só se a lista não tem nonce, hash nem
+ *    `'strict-dynamic'` (com qualquer um deles o navegador ignora o unsafe-inline);
+ *  - o resto (`'self'`, hosts, `'none'`, lista vazia) NÃO libera script embutido.
+ * PURA.
+ */
+export declare function inlineScriptAllowed(script: InlineScript, sources: readonly string[]): boolean;
+/** Scripts embutidos executáveis do HTML (sem `src`, conteúdo não vazio). PURA. */
+export declare function extractInlineScripts(html: string): InlineScript[];
+/** Políticas de `<meta http-equiv="Content-Security-Policy" content="…">`. PURA. */
+export declare function extractMetaCspPolicies(html: string): CspPolicy[];
+export interface InlineScriptCspAnalysis {
+    inlineScripts: number;
+    blockedInlineScripts: number;
+    blockingDirective: string | null;
+}
+/**
+ * Quantos scripts embutidos a CSP efetiva bloqueia. Um script só roda se TODAS
+ * as políticas em vigor (cabeçalhos + meta) deixarem. PURA.
+ */
+export declare function analyzeInlineScriptCsp(input: {
+    cspHeaderValues: readonly string[];
+    html: string;
+}): InlineScriptCspAnalysis;
+/**
+ * Classifica a resposta da página inicial. PURA.
+ *  - rede/não-2xx/não-HTML → `unverifiable` (não é prova de nada);
+ *  - HTML com script embutido que a CSP bloqueia → `inline_scripts_blocked`;
+ *  - o resto (sem CSP, CSP que libera, sem script embutido) → `ok`.
+ */
+export declare function classifyRenderProbe(url: string, input: RenderProbeInput): RenderCheck;
+/** URL da página inicial do domínio publicado. `null` se o domínio não forma URL. PURA. */
+export declare function buildRenderProbeUrl(domain: string): string | null;
+export interface RenderProbeDeps {
+    fetchImpl: (url: string, init: RequestInit) => Promise<Response>;
+    /** Timeout por requisição, cobrindo a leitura do corpo (ms). */
+    timeoutMs: number;
+    maxRedirects?: number;
+}
+/**
+ * Abre a página inicial e classifica. Uma tentativa por salto (a saúde acabou
+ * de passar — não é hora de esperar app subir). `redirect:'manual'`: segue no
+ * máximo `RENDER_MAX_REDIRECTS` saltos e só na MESMA origem; redirect pra fora
+ * (login de terceiro, outro host) → `unverifiable`. Nunca lança.
+ */
+export declare function runRenderProbe(url: string, deps: RenderProbeDeps): Promise<RenderCheck>;
+/** O que foi bloqueado, em uma frase (vai no `detail` do JSON e na tela). PURA. */
+export declare function describeRenderBlock(render: RenderCheck): string;
+/**
+ * O efeito e onde se conserta — mesma frase do alerta do Core
+ * (`renderBlockedExplanation`), sem o prefixo da saúde. PURA.
+ */
+export declare const RENDER_BLOCKED_FIX: string;