@semacode/cli 4.1.0 → 4.1.1

package/dist/geracaoCore.d.ts

@@ -18,6 +18,8 @@ export interface ResumoAlvoVerificacao {
     estrutura: EstruturaSaida;
     testesExecutados: boolean;
     origem?: "executado" | "cache";
+    tipoEvidencia?: "andaime_demonstrativo";
+    implementacaoExternaExecutada?: boolean;
 }
 export interface ResumoModuloVerificacao {
     modulo: string;

package/dist/index.part07.js

@@ -226,6 +226,11 @@ export async function comandoVerificar(entrada, baseSaida, cwd = process.cwd(),
     const alvos = opcoes.alvo
         ? [opcoes.alvo]
         : resolverAlvosVerificacao(contextoProjeto.configCarregada);
+    const testesNaoExecutaveis = diagnosticos.filter(item => item.codigo === "SEM125");
+    if (alvos.includes("python") && testesNaoExecutaveis.length > 0) {
+        console.error(formatarDiagnosticos(testesNaoExecutaveis));
+        return 1;
+    }
     const avisoEscopo = avisoEscopoStackVerificacao(contextoProjeto.configCarregada?.config.fontesLegado, alvos);
     if (avisoEscopo) {
         console.warn(avisoEscopo);
@@ -279,6 +284,7 @@ export async function comandoVerificar(entrada, baseSaida, cwd = process.cwd(),
                     estrutura,
                     testesExecutados: false,
                     origem: "cache",
+                    ...(alvo === "python" ? { tipoEvidencia: "andaime_demonstrativo", implementacaoExternaExecutada: false } : {}),
                 });
                 if (!emCache.sucesso) {
                     imprimirResumoVerificacao([...resumos, resumoModulo]);
@@ -313,6 +319,7 @@ export async function comandoVerificar(entrada, baseSaida, cwd = process.cwd(),
                 estrutura,
                 testesExecutados,
                 origem: "executado",
+                ...(alvo === "python" ? { tipoEvidencia: "andaime_demonstrativo", implementacaoExternaExecutada: false } : {}),
             });
             if (execucao.codigoSaida !== 0) {
                 imprimirResumoVerificacao([...resumos, resumoModulo]);
@@ -347,6 +354,18 @@ export async function comandoVerificarJson(entrada, baseSaida, cwd = process.cwd
     const alvos = opcoes.alvo
         ? [opcoes.alvo]
         : resolverAlvosVerificacao(contextoProjeto.configCarregada);
+    const testesNaoExecutaveis = diagnosticos.filter(item => item.codigo === "SEM125");
+    if (alvos.includes("python") && testesNaoExecutaveis.length > 0) {
+        console.log(JSON.stringify({
+            comando: "verificar",
+            sucesso: false,
+            erro: "Casos de teste não executáveis em Python: substitua texto descritivo por entidades estruturadas.",
+            diagnosticos: testesNaoExecutaveis,
+            modulos: [],
+            totais: { modulos: 0, alvos: 0, arquivos: 0, testes: 0 },
+        }, null, 2));
+        return 1;
+    }
     const avisoEscopo = avisoEscopoStackVerificacao(contextoProjeto.configCarregada?.config.fontesLegado, alvos);
     const configuracoesAlvo = alvos.map((alvo) => ({
         alvo,
@@ -411,6 +430,7 @@ export async function comandoVerificarJson(entrada, baseSaida, cwd = process.cwd
                     estrutura,
                     testesExecutados: false,
                     origem: "cache",
+                    ...(alvo === "python" ? { tipoEvidencia: "andaime_demonstrativo", implementacaoExternaExecutada: false } : {}),
                 });
                 resumoModulo.saidaTestes.push({ alvo, stdout: "", stderr: `resultado reutilizado do cache de verificacao (chave ${chave.slice(0, 12)})` });
                 if (!emCache.sucesso) {
@@ -444,6 +464,7 @@ export async function comandoVerificarJson(entrada, baseSaida, cwd = process.cwd
                 estrutura,
                 testesExecutados,
                 origem: "executado",
+                ...(alvo === "python" ? { tipoEvidencia: "andaime_demonstrativo", implementacaoExternaExecutada: false } : {}),
             });
             resumoModulo.saidaTestes.push({ alvo, stdout: execucao.saidaPadrao, stderr: execucao.saidaErro });
             if (execucao.codigoSaida !== 0) {

package/docs/testing.md

@@ -148,3 +148,24 @@ Native generator evidence is mandatory when changing C#/.NET or C++ support.
 The `dotnet` smoke must compile and execute through the local .NET SDK. The
 `cpp` smoke must compile and execute through GCC, Clang, or MSVC; checking only
 for generated files is not sufficient.
+
+Python verification must execute the generated code and inspect every declared
+output expectation, including nested fields. A mismatching `expect` must fail;
+the generator must never initialize an output from that expectation. Numeric
+demonstration values respect comparison operators and simultaneous bounds.
+Contradictory guarantees fail explicitly instead of being removed. Nested
+paths preserve every segment and work with both JSON dictionaries and entities.
+
+`SEM125` identifies descriptive scalar fixtures used where an entity or
+structured type is declared. Contract analysis emits a compatibility warning
+for historical declarative examples; executable Python generation rejects
+them before running tests. Replace the scalar with a structured `given` block.
+The regression suite is `testes/integracao/gerador-python-verificacao.test.ts`.
+
+Generated Python functions are demonstration scaffolds. Their metadata declares
+`origem_execucao: andaime_demonstrativo` and
+`implementacao_externa_executada: false`. A linked `impl` is not executed by
+this scaffold: its tests and guarantees cannot establish production behavior.
+Use the application's real tests and drift evidence for that claim. Generated
+failure cases currently retain the explicit synthetic error context and are
+not evidence that the real implementation produces those errors.

package/exemplos/python_verificacao.sema

@@ -0,0 +1,68 @@
+module exemplos.python_verificacao {
+  docs {
+    resumo: "Regressao executavel Python para garantias numericas, formulario tipado, status e metadados aninhados."
+  }
+  entity FormularioEntrega {
+    fields {
+      tipo: Texto
+    }
+  }
+  entity MetaTemplate {
+    fields {
+      original_campaign_id: Texto
+    }
+  }
+  entity Template {
+    fields {
+      _template_meta: MetaTemplate
+    }
+  }
+  entity Status {
+    fields {
+      desired_action: Texto
+    }
+  }
+  task preparar {
+    input {
+      formulario: FormularioEntrega required
+    }
+    output {
+      poolSize: Inteiro
+      workersAplicados: Inteiro
+      template: Template
+      status: Status
+    }
+    rules {
+      formulario.tipo existe
+    }
+    guarantees {
+      poolSize > 0
+      workersAplicados >= 2
+      template._template_meta existe
+      template._template_meta.original_campaign_id em ["campanha_1"]
+      status.desired_action em ["iniciar", "parar"]
+    }
+    tests {
+      caso "verifica cada saida" {
+        given {
+          formulario {
+            tipo: "entrega"
+          }
+        }
+        expect {
+          sucesso: verdadeiro
+          poolSize: 1
+          workersAplicados: 2
+          template {
+            _template_meta {
+              original_campaign_id: "campanha_1"
+            }
+          }
+          status {
+            desired_action: "iniciar"
+          }
+        }
+      }
+    }
+  }
+}

package/node_modules/@sema/gerador-python/dist/expectativas.d.ts

@@ -0,0 +1,3 @@
+import type { IrBlocoDeclarativo, IrTask } from "@sema/nucleo";
+export declare function validarEntradasTestePython(bloco: IrBlocoDeclarativo, campos: Map<string, string>, tipos: Map<string, Map<string, string>>, contexto: string): void;
+export declare function gerarExpectativasPython(task: IrTask, bloco: IrBlocoDeclarativo, tipos: Map<string, Map<string, string>>, prefixo?: string): string[];

package/node_modules/@sema/gerador-python/dist/expectativas.js

@@ -0,0 +1,37 @@
+import { formatarLiteralTestePython } from "./index.part01.js";
+import { acessoPython } from "./valores.js";
+export function validarEntradasTestePython(bloco, campos, tipos, contexto) {
+    for (const campo of bloco.campos) {
+        const tipo = campos.get(campo.nome);
+        if (tipo && tipos.has(tipo) && campo.tipo !== "nulo") {
+            throw new Error(`SEM125: ${contexto}.${campo.nome} exige ${tipo}; forneça bloco estruturado, não texto descritivo.`);
+        }
+    }
+    for (const filho of bloco.blocos) {
+        const tipo = campos.get(filho.nome);
+        if (tipo && tipos.has(tipo))
+            validarEntradasTestePython(filho.conteudo, tipos.get(tipo), tipos, `${contexto}.${filho.nome}`);
+    }
+}
+export function gerarExpectativasPython(task, bloco, tipos, prefixo = "") {
+    const linhas = [];
+    for (const campo of bloco.campos) {
+        const caminho = prefixo ? `${prefixo}.${campo.nome}` : campo.nome;
+        const raiz = caminho.split(".")[0];
+        const saida = task.output.find(item => item.nome === raiz);
+        if (!saida && caminho === "sucesso") {
+            linhas.push(`    assert (resultado is not None) == ${formatarLiteralTestePython(campo.tipo, "Booleano")}, "Expectativa de sucesso divergente"`);
+            continue;
+        }
+        if (!saida)
+            throw new Error(`Expectativa "${caminho}" da task "${task.nome}" não corresponde a campo do output.`);
+        let tipo = saida.tipo;
+        for (const filho of caminho.split(".").slice(1))
+            tipo = tipos.get(tipo)?.get(filho) ?? "Json";
+        linhas.push(`    assert ${acessoPython("resultado", caminho)} == ${formatarLiteralTestePython(campo.tipo, tipo)}, ${JSON.stringify(`Expectativa divergente: ${caminho}`)}`);
+    }
+    for (const filho of bloco.blocos)
+        linhas.push(...gerarExpectativasPython(task, filho.conteudo, tipos, prefixo ? `${prefixo}.${filho.nome}` : filho.nome));
+    return linhas;
+}
+//# sourceMappingURL=expectativas.js.map

package/node_modules/@sema/gerador-python/dist/index.part01.d.ts

@@ -25,4 +25,4 @@ export declare function gerarMapaLiteralPython(campos: Array<{
 export declare function coletarTiposCompostos(modulo: IrModulo): Map<string, Map<string, string>>;
 export declare function gerarLiteralBlocoTestePython(bloco: IrBlocoDeclarativo, tiposCompostos?: Map<string, Map<string, string>>, tiposDeclarados?: Map<string, string>, tipoAtual?: string): string;
 export declare function paraPascalCase(valor: string): string;
-export declare function gerarPreparacaoSaida(task: IrTask): string;
+export declare function gerarPreparacaoSaida(task: IrTask, tipos?: Map<string, Map<string, string>>): string;

package/node_modules/@sema/gerador-python/dist/index.part01.js

@@ -1,5 +1,6 @@
 // SEMA-GOVERNED: sema.geradores_codigo_governado
 // Descricao: modulo particionado; consulte contratos/sema/geradores_codigo_governado.sema antes de editar.
+import { acessoPython, prepararSaidaPython } from "./valores.js";
 import { extrairTiposNomeados, mapearTipoParaPython, } from "@sema/padroes";
 export function mapearCampoParaPython(campo) {
     let anotacao;
@@ -79,7 +80,7 @@ export function gerarMapaErrosPython(erros) {
     return `{\n${entradas.map(([nome, mensagem]) => `    ${JSON.stringify(nome)}: ${JSON.stringify(mensagem)},`).join("\n")}\n}`;
 }
 export function formatarValorPython(valor, camposConhecidos, variavel) {
-    const texto = valor.trim();
+    const texto = valor.trim().replace(/^-\s+(?=\d)/u, "-").replace(/^(-?\d+)\s*\.\s*(\d+)$/u, "$1.$2");
     if (/^-?\d+(?:\.\d+)?$/.test(texto)) {
         return texto;
     }
@@ -93,7 +94,7 @@ export function formatarValorPython(valor, camposConhecidos, variavel) {
         return "None";
     }
     if (camposConhecidos.has(texto.split(".")[0] ?? texto)) {
-        return `${variavel}.${texto}`;
+        return acessoPython(variavel, texto);
     }
     return JSON.stringify(texto);
 }
@@ -106,23 +107,20 @@ export function extrairReferenciaCampoConhecido(valor, camposConhecidos) {
     return camposConhecidos.has(partes[0] ?? "") ? partes : null;
 }
 export function gerarInicializacaoReferenciaSaida(partes) {
-    const [raiz, filho] = partes;
-    if (!raiz || !filho) {
+    if (partes.length === 0)
         return [];
-    }
     return [
-        `    if saida.${raiz} is None:\n        saida.${raiz} = SimpleNamespace()`,
-        `    if getattr(saida.${raiz}, "${filho}", None) is None:\n        saida.${raiz}.${filho} = "valor_garantido"`,
+        `    if ${acessoPython("saida", partes.join("."))} is None:\n        sema_set(saida, ${JSON.stringify(partes)}, "valor_garantido")`,
     ];
 }
 export function resolverExpressaoPython(expressao, camposConhecidos, variavel) {
     switch (expressao.tipo) {
         case "existe":
-            return `${variavel}.${expressao.alvo} is not None`;
+            return `${acessoPython(variavel, expressao.alvo)} is not None`;
         case "comparacao":
-            return `${variavel}.${expressao.alvo} ${expressao.operador} ${formatarValorPython(expressao.valor, camposConhecidos, variavel)}`;
+            return `${acessoPython(variavel, expressao.alvo)} ${expressao.operador} ${formatarValorPython(expressao.valor, camposConhecidos, variavel)}`;
         case "pertencimento":
-            return `${variavel}.${expressao.alvo} in [${(expressao.valores ?? []).map((valor) => formatarValorPython(valor, camposConhecidos, variavel)).join(", ")}]`;
+            return `${acessoPython(variavel, expressao.alvo)} in [${(expressao.valores ?? []).map((valor) => formatarValorPython(valor, camposConhecidos, variavel)).join(", ")}]`;
         case "predicado":
             return "True";
         case "composta":
@@ -253,7 +251,7 @@ export function resolverTipoItemTeste(tipoDeclarado) {
     return undefined;
 }
 export function formatarLiteralTestePython(valor, tipoDeclarado) {
-    const bruto = valor.trim();
+    const bruto = valor.trim().replace(/^-\s+(?=\d)/u, "-").replace(/^(-?\d+)\s*\.\s*(\d+)$/u, "$1.$2");
     if (bruto.startsWith("[") && bruto.endsWith("]")) {
         const interior = bruto.slice(1, -1).trim();
         const tipoItem = resolverTipoItemTeste(tipoDeclarado);
@@ -348,36 +346,7 @@ export function paraPascalCase(valor) {
         .map((parte) => parte[0].toUpperCase() + parte.slice(1))
         .join("");
 }
-export function gerarPreparacaoSaida(task) {
-    const camposSaida = new Set(task.output.map((campo) => campo.nome));
-    const argumentos = task.output.map((campo) => `${campo.nome}=${valorPadraoPython(campo)}`).join(", ");
-    const ajustes = [];
-    for (const garantia of task.garantiasEstruturadas) {
-        if (garantia.tipo === "pertencimento" && garantia.valores && camposSaida.has(garantia.alvo)) {
-            ajustes.push(`    saida.${garantia.alvo} = ${formatarValorPython(garantia.valores[0] ?? "", camposSaida, "saida")}`);
-        }
-        if (garantia.tipo === "comparacao" && garantia.valor && camposSaida.has(garantia.alvo.split(".")[0] ?? garantia.alvo) && !garantia.alvo.includes(".")) {
-            ajustes.push(`    saida.${garantia.alvo} = ${formatarValorPython(garantia.valor, camposSaida, "saida")}`);
-        }
-        if (garantia.tipo === "comparacao" && garantia.valor && garantia.alvo.includes(".")) {
-            const [raiz, filho] = garantia.alvo.split(".", 2);
-            if (raiz && filho && camposSaida.has(raiz)) {
-                const referenciaValor = extrairReferenciaCampoConhecido(garantia.valor, camposSaida);
-                if (referenciaValor) {
-                    ajustes.push(...gerarInicializacaoReferenciaSaida(referenciaValor));
-                }
-                ajustes.push(`    if saida.${raiz} is None:\n        saida.${raiz} = SimpleNamespace()`);
-                ajustes.push(`    saida.${raiz}.${filho} = ${formatarValorPython(garantia.valor, camposSaida, "saida")}`);
-            }
-        }
-        if (garantia.tipo === "existe" && garantia.alvo.includes(".")) {
-            const [raiz, filho] = garantia.alvo.split(".", 2);
-            if (raiz && filho && camposSaida.has(raiz)) {
-                ajustes.push(`    if saida.${raiz} is None:\n        saida.${raiz} = SimpleNamespace()`);
-                ajustes.push(`    if getattr(saida.${raiz}, "${filho}", None) is None:\n        saida.${raiz}.${filho} = "valor_garantido"`);
-            }
-        }
-    }
-    return `    saida = ${task.nome}Saida(${argumentos})\n${ajustes.join("\n")}`;
+export function gerarPreparacaoSaida(task, tipos = new Map()) {
+    return prepararSaidaPython(task, tipos);
 }
 //# sourceMappingURL=index.part01.js.map

package/node_modules/@sema/gerador-python/dist/index.part02.js

@@ -1,8 +1,11 @@
 // SEMA-GOVERNED: sema.geradores_codigo_governado
 // Descricao: modulo particionado; consulte contratos/sema/geradores_codigo_governado.sema antes de editar.
 import path from "node:path";
+import { prepararSaidaPython } from "./valores.js";
+import { RUNTIME_PYTHON } from "./runtime.js";
+import { gerarExpectativasPython, validarEntradasTestePython } from "./expectativas.js";
 import { descreverEstruturaModulo, normalizarNomeModulo, normalizarNomeParaSimbolo, } from "@sema/padroes";
-import { coletarTiposCompostos, coletarTiposExternos, formatarLiteralTestePython, gerarComentarioInvariantesPython, gerarDataclass, gerarListaCamposPython, gerarLiteralBlocoTestePython, gerarMapaErrosPython, gerarPreparacaoSaida, mapearCampoParaPython, paraPascalCase, resolverExpressaoPython } from "./index.part01.js";
+import { coletarTiposCompostos, coletarTiposExternos, formatarLiteralTestePython, gerarComentarioInvariantesPython, gerarDataclass, gerarListaCamposPython, gerarLiteralBlocoTestePython, gerarMapaErrosPython, mapearCampoParaPython, paraPascalCase, resolverExpressaoPython } from "./index.part01.js";
 export function finalizarBlocoPython(linhas) {
     if (linhas.length === 0) {
         return "    pass";
@@ -48,6 +51,8 @@ export function gerarMetadadosTask(task) {
     "impl": ${implementacoes},
     "errors": ${gerarMapaErrosPython(task.errors)},
     "guarantees": ${JSON.stringify(task.guarantees, null, 2)},
+    "origem_execucao": "andaime_demonstrativo",
+    "implementacao_externa_executada": False,
 }
 `;
 }
@@ -191,7 +196,7 @@ ${erroAutorizacao ? `    if contexto_execucao["erro_esperado"] == "${erroAutoriz
 ${task.stateContract ? `    # Vinculo de estado: ${task.stateContract.nomeEstado ?? "nao_definido"}\n    # Transicoes declaradas pela task: ${task.stateContract.transicoes.map((transicao) => `${transicao.origem}->${transicao.destino}`).join(", ") || "nenhuma"}` : ""}
 ${implementacoes}
 ${efeitos}
-${gerarPreparacaoSaida(task)}
+${prepararSaidaPython(task, tiposCompostos)}
 ${garantias}
 `;
 }
@@ -202,6 +207,7 @@ export function gerarTestes(modulo) {
         const nomeFuncao = `executar_${normalizarNomeParaSimbolo(task.nome)}`;
         const tiposEntrada = new Map(task.input.map((campo) => [campo.nome, campo.tipo]));
         for (const caso of task.tests) {
+            validarEntradasTestePython(caso.given, tiposEntrada, tiposCompostos, `given da task ${task.nome}, caso ${caso.nome}`);
             const argumentos = [
                 ...caso.given.campos
                     .filter((campo) => tiposEntrada.has(campo.nome))
@@ -222,14 +228,15 @@ export function gerarTestes(modulo) {
                 linhas.push(`def test_${normalizarNomeParaSimbolo(task.nome)}_${normalizarNomeParaSimbolo(caso.nome)}() -> None:\n    entrada = ${task.nome}Entrada(${argumentos})\n    contexto = { ${contextoLinhas.join(", ")} }\n    with pytest.raises(${task.nome}_${tipoErro}Erro):\n        ${nomeFuncao}(entrada, contexto)\n`);
                 continue;
             }
-            linhas.push(`def test_${normalizarNomeParaSimbolo(task.nome)}_${normalizarNomeParaSimbolo(caso.nome)}() -> None:\n    entrada = ${task.nome}Entrada(${argumentos})\n    resultado = ${nomeFuncao}(entrada)\n    assert resultado is not None\n`);
+            const expectativas = gerarExpectativasPython(task, caso.expect, tiposCompostos);
+            linhas.push(`def test_${normalizarNomeParaSimbolo(task.nome)}_${normalizarNomeParaSimbolo(caso.nome)}() -> None:\n    entrada = ${task.nome}Entrada(${argumentos})\n    resultado = ${nomeFuncao}(entrada)\n${expectativas.length ? expectativas.join("\n") : "    assert resultado is not None"}\n`);
         }
     }
     return linhas.join("\n");
 }
 export function gerarCabecalhoSemaPython(modulo, tipo = "contrato") {
     const descricoes = {
-        contrato: "artefato Python gerado para executar e revisar as regras declaradas no contrato Sema.",
+        contrato: "andaime Python demonstrativo para revisar regras; não constitui prova de execução da implementação externa.",
         teste: "testes Python gerados a partir dos casos do contrato Sema.",
         schemas: "schemas FastAPI derivados do contrato Sema para entrada e saída públicas.",
         service: "service FastAPI que conecta o scaffold do framework às tasks governadas pelo contrato Sema.",
@@ -262,7 +269,7 @@ export function gerarPythonBase(modulo) {
     const tiposCompostos = coletarTiposCompostos(modulo);
     const tasks = modulo.tasks.map((task) => gerarTask(task, tiposCompostos)).join("\n");
     const contratosPublicos = gerarRotas(modulo);
-    const codigo = `${gerarCabecalhoSemaPython(modulo)}from __future__ import annotations\n${interoperabilidades ? `${interoperabilidades}\n` : ""}\nfrom dataclasses import dataclass\nfrom types import SimpleNamespace\n\n${tiposExternos}\n${tipos}\n${enums}\n${entidades}\n${states}\n${flows}\n${routes}\n${tasks}\n${contratosPublicos}\n`;
+    const codigo = `${gerarCabecalhoSemaPython(modulo)}from __future__ import annotations\n${interoperabilidades ? `${interoperabilidades}\n` : ""}\nfrom dataclasses import dataclass\nfrom types import SimpleNamespace\n${RUNTIME_PYTHON}\n${tiposExternos}\n${tipos}\n${enums}\n${entidades}\n${states}\n${flows}\n${routes}\n${tasks}\n${contratosPublicos}\n`;
     const testes = `${gerarCabecalhoSemaPython(modulo, "teste")}${gerarTestes(modulo)}`;
     return [
         { caminhoRelativo: `${nomeBase}.py`, conteudo: codigo },

package/node_modules/@sema/gerador-python/dist/runtime.d.ts

@@ -0,0 +1 @@
+export declare const RUNTIME_PYTHON = "\nimport math\n\ndef sema_get(objeto, caminho):\n    for campo in caminho:\n        if objeto is None:\n            return None\n        objeto = objeto.get(campo) if isinstance(objeto, dict) else getattr(objeto, campo, None)\n    return objeto\n\ndef sema_set(objeto, caminho, valor):\n    for campo in caminho[:-1]:\n        filho = sema_get(objeto, [campo])\n        if filho is None:\n            filho = {} if isinstance(objeto, dict) else SimpleNamespace()\n            if isinstance(objeto, dict):\n                objeto[campo] = filho\n            else:\n                setattr(objeto, campo, filho)\n        if not isinstance(filho, dict) and not hasattr(filho, \"__dict__\"):\n            raise ValueError(f\"Caminho de objeto incompat\u00EDvel: {campo}\")\n        objeto = filho\n    if isinstance(objeto, dict):\n        objeto[caminho[-1]] = valor\n    else:\n        setattr(objeto, caminho[-1], valor)\n\ndef sema_sintetizar(atual, restricoes, inteiro=False):\n    # Apenas valores demonstrativos: expect nunca participa desta s\u00EDntese.\n    def aceita(valor):\n        for operador, limite in restricoes:\n            if operador == \"existe\" and valor is None:\n                return False\n            if operador == \"in\" and valor not in limite:\n                return False\n            try:\n                if operador == \"==\" and valor != limite: return False\n                if operador == \"!=\" and valor == limite: return False\n                if operador == \">\" and not valor > limite: return False\n                if operador == \">=\" and not valor >= limite: return False\n                if operador == \"<\" and not valor < limite: return False\n                if operador == \"<=\" and not valor <= limite: return False\n            except TypeError:\n                return False\n        return True\n\n    candidatos = [atual]\n    numeros = []\n    for operador, limite in restricoes:\n        if operador == \"in\":\n            candidatos.extend(limite)\n        elif operador != \"existe\":\n            candidatos.append(limite)\n            if isinstance(limite, (int, float)) and not isinstance(limite, bool):\n                numeros.append(limite)\n                candidatos.extend([limite - 1, limite + 1, math.floor(limite), math.ceil(limite)])\n    numeros.sort()\n    candidatos.extend((a + b) / 2 for a, b in zip(numeros, numeros[1:]))\n    candidatos.extend([1, 0, -1, True, False, \"valor_garantido\", \"outro_valor\"])\n    for candidato in candidatos:\n        if inteiro and (not isinstance(candidato, int) or isinstance(candidato, bool)):\n            continue\n        if aceita(candidato):\n            return candidato\n    raise ValueError(\"N\u00E3o foi poss\u00EDvel sintetizar sa\u00EDda demonstrativa compat\u00EDvel com as garantias; forne\u00E7a implementa\u00E7\u00E3o real.\")\n";

package/node_modules/@sema/gerador-python/dist/runtime.js

@@ -0,0 +1,70 @@
+// SEMA-GOVERNED: sema.produto.gerador_python_verificacao
+// Contrato: contratos/sema/gerador_python_verificacao.sema
+// Descrição: acesso uniforme a mapas e entidades e síntese demonstrativa de garantias.
+export const RUNTIME_PYTHON = `
+import math
+
+def sema_get(objeto, caminho):
+    for campo in caminho:
+        if objeto is None:
+            return None
+        objeto = objeto.get(campo) if isinstance(objeto, dict) else getattr(objeto, campo, None)
+    return objeto
+
+def sema_set(objeto, caminho, valor):
+    for campo in caminho[:-1]:
+        filho = sema_get(objeto, [campo])
+        if filho is None:
+            filho = {} if isinstance(objeto, dict) else SimpleNamespace()
+            if isinstance(objeto, dict):
+                objeto[campo] = filho
+            else:
+                setattr(objeto, campo, filho)
+        if not isinstance(filho, dict) and not hasattr(filho, "__dict__"):
+            raise ValueError(f"Caminho de objeto incompatível: {campo}")
+        objeto = filho
+    if isinstance(objeto, dict):
+        objeto[caminho[-1]] = valor
+    else:
+        setattr(objeto, caminho[-1], valor)
+
+def sema_sintetizar(atual, restricoes, inteiro=False):
+    # Apenas valores demonstrativos: expect nunca participa desta síntese.
+    def aceita(valor):
+        for operador, limite in restricoes:
+            if operador == "existe" and valor is None:
+                return False
+            if operador == "in" and valor not in limite:
+                return False
+            try:
+                if operador == "==" and valor != limite: return False
+                if operador == "!=" and valor == limite: return False
+                if operador == ">" and not valor > limite: return False
+                if operador == ">=" and not valor >= limite: return False
+                if operador == "<" and not valor < limite: return False
+                if operador == "<=" and not valor <= limite: return False
+            except TypeError:
+                return False
+        return True
+
+    candidatos = [atual]
+    numeros = []
+    for operador, limite in restricoes:
+        if operador == "in":
+            candidatos.extend(limite)
+        elif operador != "existe":
+            candidatos.append(limite)
+            if isinstance(limite, (int, float)) and not isinstance(limite, bool):
+                numeros.append(limite)
+                candidatos.extend([limite - 1, limite + 1, math.floor(limite), math.ceil(limite)])
+    numeros.sort()
+    candidatos.extend((a + b) / 2 for a, b in zip(numeros, numeros[1:]))
+    candidatos.extend([1, 0, -1, True, False, "valor_garantido", "outro_valor"])
+    for candidato in candidatos:
+        if inteiro and (not isinstance(candidato, int) or isinstance(candidato, bool)):
+            continue
+        if aceita(candidato):
+            return candidato
+    raise ValueError("Não foi possível sintetizar saída demonstrativa compatível com as garantias; forneça implementação real.")
+`;
+//# sourceMappingURL=runtime.js.map

package/node_modules/@sema/gerador-python/dist/valores.d.ts

@@ -0,0 +1,4 @@
+import type { IrTask } from "@sema/nucleo";
+export declare function acessoPython(variavel: string, caminho: string): string;
+export declare function valorCompostoPython(tipo: string, tipos: Map<string, Map<string, string>>, vistos?: Set<string>): string;
+export declare function prepararSaidaPython(task: IrTask, tipos: Map<string, Map<string, string>>): string;

package/node_modules/@sema/gerador-python/dist/valores.js

@@ -0,0 +1,72 @@
+import { formatarValorPython } from "./index.part01.js";
+export function acessoPython(variavel, caminho) {
+    return `sema_get(${variavel}, ${JSON.stringify(caminho.split("."))})`;
+}
+export function valorCompostoPython(tipo, tipos, vistos = new Set()) {
+    if (/^(Lista|Mapa)</u.test(tipo) || /\[\]$/u.test(tipo))
+        return tipo.startsWith("Mapa") ? "{}" : "[]";
+    if (tipo.startsWith("Opcional<") || tipo.endsWith("?"))
+        return "None";
+    if (["Numero", "Inteiro", "Decimal"].includes(tipo))
+        return "1";
+    if (tipo === "Booleano")
+        return "False";
+    if (["Json", "Objeto"].includes(tipo))
+        return "{}";
+    if (!tipos.has(tipo))
+        return ["Texto", "Id", "Email", "Url", "Data", "DataHora", "Timestamp"].includes(tipo) ? '"valor_garantido"' : "SimpleNamespace()";
+    if (vistos.has(tipo))
+        return "None";
+    const proximos = new Set(vistos).add(tipo);
+    return `${tipo}(${[...tipos.get(tipo)].map(([nome, filho]) => `${nome}=${valorCompostoPython(filho, tipos, proximos)}`).join(", ")})`;
+}
+function termosConjuntos(expressao) {
+    return expressao.tipo === "composta" && expressao.operadorLogico === "e"
+        ? expressao.termos.flatMap(termosConjuntos) : [expressao];
+}
+export function prepararSaidaPython(task, tipos) {
+    const campos = new Set(task.output.map(campo => campo.nome));
+    const grupos = new Map();
+    for (const regra of task.garantiasEstruturadas.flatMap(termosConjuntos)) {
+        if (!("alvo" in regra) || !campos.has(regra.alvo.split(".")[0]))
+            continue;
+        if (!["comparacao", "pertencimento", "existe"].includes(regra.tipo))
+            continue;
+        grupos.set(regra.alvo, [...(grupos.get(regra.alvo) ?? []), regra]);
+    }
+    const argumentos = task.output.map(campo => `${campo.nome}=${campo.opcional ? "None" : valorCompostoPython(campo.tipo, tipos)}`);
+    const linhas = [`    # Andaime demonstrativo; não executa a implementação externa vinculada.`, `    saida = ${task.nome}Saida(${argumentos.join(", ")})`];
+    // Inicialize folhas antes de suas referências e preserve nós que são pais.
+    const referencias = new Set();
+    for (const regras of grupos.values())
+        for (const regra of regras) {
+            if (regra.tipo === "comparacao" && campos.has(regra.valor.split(".")[0]))
+                referencias.add(regra.valor);
+        }
+    for (const referencia of referencias) {
+        if (!grupos.has(referencia))
+            grupos.set(referencia, [{ tipo: "existe", alvo: referencia, textoOriginal: `${referencia} existe` }]);
+    }
+    const caminhos = [...grupos.keys()].sort((a, b) => Number(referencias.has(b)) - Number(referencias.has(a)) || a.split(".").length - b.split(".").length);
+    for (const caminho of caminhos) {
+        const regras = grupos.get(caminho);
+        let tipo = task.output.find(campo => campo.nome === caminho.split(".")[0])?.tipo ?? "Json";
+        for (const segmento of caminho.split(".").slice(1))
+            tipo = tipos.get(tipo)?.get(segmento) ?? "Json";
+        const restricoes = regras.map(regra => {
+            if (regra.tipo === "comparacao")
+                return `(${JSON.stringify(regra.operador)}, ${formatarValorPython(regra.valor, campos, "saida")})`;
+            if (regra.tipo === "pertencimento")
+                return `("in", [${(regra.valores ?? []).map(valor => formatarValorPython(valor, campos, "saida")).join(", ")}])`;
+            return '("existe", None)';
+        });
+        if (regras.every(regra => regra.tipo === "existe") && caminhos.some(outro => outro.startsWith(`${caminho}.`))) {
+            linhas.push(`    if ${acessoPython("saida", caminho)} is None:`, `        sema_set(saida, ${JSON.stringify(caminho.split("."))}, ${valorCompostoPython(tipo, tipos) === "None" ? "SimpleNamespace()" : valorCompostoPython(tipo, tipos)})`);
+        }
+        else {
+            linhas.push(`    sema_set(saida, ${JSON.stringify(caminho.split("."))}, sema_sintetizar(${acessoPython("saida", caminho)}, [${restricoes.join(", ")}], inteiro=${tipo === "Inteiro" ? "True" : "False"}))`);
+        }
+    }
+    return linhas.join("\n");
+}
+//# sourceMappingURL=valores.js.map

package/node_modules/@sema/nucleo/dist/semantico/analisador.part08.js

@@ -8,6 +8,7 @@ import { validarFlow, validarInvariantesDeCampos, validarState } from "./analisa
 import { validarStatusTextoComState, validarTask } from "./analisador.part07.js";
 import { validarGuardrailsSeguranca, validarRoute } from "./analisador.part06.js";
 import { validarDatabase } from "./analisador.part02.js";
+import { validarTiposEstruturadosTestes } from "./testesTipos.js";
 export function analisarSemantica(modulo, opcoes = {}) {
     const diagnosticos = [];
     const simbolos = new Map();
@@ -177,6 +178,7 @@ export function analisarSemantica(modulo, opcoes = {}) {
     for (const task of modulo.tasks) {
         validarTask(task, tiposConhecidos, statesConhecidos, diagnosticos);
     }
+    validarTiposEstruturadosTestes(modulo, diagnosticos);
     for (const flow of modulo.flows) {
         validarFlow(flow, tasksConhecidas, tarefasDetalhadas, diagnosticos);
     }

package/node_modules/@sema/nucleo/dist/semantico/testesTipos.d.ts

@@ -0,0 +1,3 @@
+import type { ModuloAst } from "../ast/tipos.js";
+import { type Diagnostico } from "../diagnosticos/index.js";
+export declare function validarTiposEstruturadosTestes(modulo: ModuloAst, diagnosticos: Diagnostico[]): void;

package/node_modules/@sema/nucleo/dist/semantico/testesTipos.js

@@ -0,0 +1,35 @@
+import { criarDiagnostico } from "../diagnosticos/index.js";
+export function validarTiposEstruturadosTestes(modulo, diagnosticos) {
+    const tipos = new Map();
+    for (const item of [...modulo.types, ...modulo.entities]) {
+        const fields = item.corpo.blocos.find(bloco => bloco.tipo === "bloco_generico" && bloco.palavraChave === "fields");
+        tipos.set(item.nome, fields?.tipo === "bloco_generico" ? fields.campos : item.corpo.campos);
+    }
+    function conferir(bloco, campos, contexto) {
+        for (const valor of bloco.campos) {
+            const declarado = campos.find(campo => campo.nome === valor.nome);
+            if (!declarado || !tipos.has(declarado.valor))
+                continue;
+            if (valor.valor === "nulo" && !declarado.modificadores.includes("required"))
+                continue;
+            diagnosticos.push(criarDiagnostico("SEM125", `${contexto}: "${valor.nome}" exige ${declarado.valor}, mas recebeu literal escalar; caso não executável.`, "aviso", valor.intervalo, `Use ${valor.nome} { ... } com os campos de ${declarado.valor}; texto descritivo não é uma entidade.`));
+        }
+        for (const filho of bloco.blocos) {
+            if (filho.tipo !== "bloco_generico")
+                continue;
+            const tipo = campos.find(campo => campo.nome === filho.nome)?.valor;
+            if (tipo && tipos.has(tipo))
+                conferir(filho, tipos.get(tipo), `${contexto}.${filho.nome}`);
+        }
+    }
+    for (const task of modulo.tasks)
+        for (const caso of task.tests?.blocos ?? []) {
+            if (caso.tipo !== "caso_teste")
+                continue;
+            if (caso.given)
+                conferir(caso.given, task.input?.campos ?? [], `given do caso "${caso.nome}" da task "${task.nome}"`);
+            if (caso.expect)
+                conferir(caso.expect, task.output?.campos ?? [], `expect do caso "${caso.nome}" da task "${task.nome}"`);
+        }
+}
+//# sourceMappingURL=testesTipos.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semacode/cli",
-  "version": "4.1.0",
+  "version": "4.1.1",
   "description": "Local-first semantic governance CLI for AI agents, proven with Claude, Codex, zCode (GLM) and Kimi: contracts, drift, impact, docs gates, and code generation.",
   "type": "module",
   "icon": "logo.png",