@semacode/cli 3.0.0 → 3.8.0

package/dist/projetoLegado.js

@@ -17,6 +17,18 @@ export async function inferirFontesLegado(diretoriosCodigo, baseProjeto, configC
         if (/@nestjs\/common|@nestjs\/core/.test(packageJsonRaiz)) {
             encontrados.add("nestjs");
         }
+        if (/"express"\s*:/.test(packageJsonRaiz)) {
+            encontrados.add("express");
+            encontrados.add("typescript");
+        }
+        if (/"fastify"\s*:/.test(packageJsonRaiz)) {
+            encontrados.add("fastify");
+            encontrados.add("typescript");
+        }
+        if (/"koa"\s*:|@koa\/router|"koa-router"/.test(packageJsonRaiz)) {
+            encontrados.add("koa");
+            encontrados.add("typescript");
+        }
         if (/typescript/.test(packageJsonRaiz)) {
             encontrados.add("typescript");
         }
@@ -43,6 +55,8 @@ export async function inferirFontesLegado(diretoriosCodigo, baseProjeto, configC
         const arquivosJava = await listarArquivosRecursivosLimitado(diretorio, [".java"], 5, 20);
         const arquivosGo = await listarArquivosRecursivosLimitado(diretorio, [".go"], 5, 20);
         const arquivosRust = await listarArquivosRecursivosLimitado(diretorio, [".rs"], 5, 20);
+        const arquivosVueSvelte = await listarArquivosRecursivosLimitado(diretorio, [".vue", ".svelte"], 5, 40);
+        const relacoesVueSvelte = arquivosVueSvelte.map((arquivo) => path.relative(diretorio, arquivo).replace(/\\/g, "/"));
         const arquivosCppBrutos = await listarArquivosRecursivosLimitado(diretorio, [".cpp", ".cc", ".cxx", ".hpp", ".h"], 5, 30);
         const arquivosCpp = arquivosCppBrutos.filter((arquivo) => !/(^|[\\/])(windows|linux|macos|runner|flutter|ephemeral|build|vendor)([\\/]|$)/i.test(arquivo));
         const arquivosPhp = (await listarArquivosRecursivosLimitado(diretorio, [".php"], 5, 30))
@@ -64,6 +78,12 @@ export async function inferirFontesLegado(diretoriosCodigo, baseProjeto, configC
             const relacoesTs = arquivosTsJs.map((arquivo) => path.relative(diretorio, arquivo).replace(/\\/g, "/"));
             const temNest = textosPackage.some((texto) => /@nestjs\/common|@nestjs\/core/.test(texto ?? ""))
                 || amostrasTs.some((texto) => /@nestjs\/common|@nestjs\/core|@Controller\(|@Get\(|@Post\(|@Put\(|@Patch\(|@Delete\(/.test(texto ?? ""));
+            const temExpress = textosPackage.some((texto) => /"express"\s*:/.test(texto ?? ""))
+                || amostrasTs.some((texto) => /(?:from\s+["']express["']|require\(\s*["']express["']\s*\)|\bexpress\s*\(\s*\))/.test(texto ?? ""));
+            const temFastify = textosPackage.some((texto) => /"fastify"\s*:/.test(texto ?? ""))
+                || amostrasTs.some((texto) => /(?:from\s+["']fastify["']|require\(\s*["']fastify["']\s*\)|\bfastify\s*\(\s*\{)/.test(texto ?? ""));
+            const temKoa = textosPackage.some((texto) => /"koa"\s*:|@koa\/router|"koa-router"/.test(texto ?? ""))
+                || amostrasTs.some((texto) => /(?:from\s+["'](?:@koa\/router|koa-router|koa)["']|require\(\s*["'](?:@koa\/router|koa-router|koa)["']\s*\)|new\s+Router\s*\()/.test(texto ?? ""));
             const temNext = textosPackage.some((texto) => /"next"\s*:/.test(texto ?? ""))
                 || nextConfigs.length > 0
                 || relacoesTs.some((relacao) => /(?:^|\/)(?:src\/)?app\/api\/.+\/route\.(?:ts|tsx|js|jsx)$/.test(relacao));
@@ -77,6 +97,11 @@ export async function inferirFontesLegado(diretoriosCodigo, baseProjeto, configC
             const temSuperficieAngularConsumer = relacoesTs.some((relacao) => /(?:^|\/)(?:src\/)?app\/.+\.component\.(?:ts|js)$/.test(relacao))
                 || relacoesTs.some((relacao) => /(?:^|\/)(?:src\/)?app(?:\/.+)?\/[^/]+\.routes\.(?:ts|js)$/.test(relacao));
             const temBridgeAngularConsumer = relacoesTs.some((relacao) => /(?:^|\/)(?:src\/)?app\/(?:sema_consumer_bridge|sema\/.+)\.(?:ts|js)$/.test(relacao));
+            const temSvelteKitConsumer = relacoesVueSvelte.some((relacao) => /(?:^|\/)(?:src\/)?routes\/(?:[^/]+\/)*\+(?:page|layout|error|server)\.svelte$/i.test(relacao))
+                || relacoesTs.some((relacao) => /(?:^|\/)(?:src\/)?routes\/(?:[^/]+\/)*\+(?:page|server)\.(?:ts|js)$/i.test(relacao))
+                || textosPackage.some((texto) => /@sveltejs\/kit/.test(texto ?? ""));
+            const temNuxtConsumer = relacoesVueSvelte.some((relacao) => /^(?:app\/)?pages\/.+\.vue$/i.test(relacao))
+                || textosPackage.some((texto) => /"nuxt"\s*:/.test(texto ?? ""));
             const temAngularConsumer = temSuperficieAngularConsumer
                 || ((textosPackage.some((texto) => /@angular\/core|@angular\/router/.test(texto ?? "")) || angularConfigs.length > 0) && temBridgeAngularConsumer);
             const temFirebase = marcadoresFirebaseProjeto.length > 0
@@ -86,6 +111,15 @@ export async function inferirFontesLegado(diretoriosCodigo, baseProjeto, configC
             if (temNest) {
                 encontrados.add("nestjs");
             }
+            if (temExpress) {
+                encontrados.add("express");
+            }
+            if (temFastify) {
+                encontrados.add("fastify");
+            }
+            if (temKoa) {
+                encontrados.add("koa");
+            }
             if (temNext) {
                 encontrados.add("nextjs");
             }
@@ -98,6 +132,12 @@ export async function inferirFontesLegado(diretoriosCodigo, baseProjeto, configC
             if (temAngularConsumer) {
                 encontrados.add("angular-consumer");
             }
+            if (temSvelteKitConsumer) {
+                encontrados.add("sveltekit-consumer");
+            }
+            if (temNuxtConsumer) {
+                encontrados.add("nuxt-consumer");
+            }
             if (temFirebase) {
                 encontrados.add("firebase");
             }

package/dist/tipos.d.ts

@@ -1,3 +1,3 @@
 export type EstruturaSaida = "flat" | "modulos" | "backend";
-export type FonteLegado = "nestjs" | "fastapi" | "flask" | "nextjs" | "nextjs-consumer" | "react-vite-consumer" | "angular-consumer" | "flutter-consumer" | "firebase" | "typescript" | "javascript" | "python" | "dart" | "lua" | "dotnet" | "java" | "go" | "rust" | "cpp" | "php";
+export type FonteLegado = "nestjs" | "express" | "fastify" | "koa" | "fastapi" | "flask" | "nextjs" | "nextjs-consumer" | "react-vite-consumer" | "angular-consumer" | "flutter-consumer" | "sveltekit-consumer" | "nuxt-consumer" | "firebase" | "typescript" | "javascript" | "python" | "dart" | "lua" | "dotnet" | "java" | "go" | "rust" | "cpp" | "php";
 export type ModoAdocao = "incremental";

package/dist/typescript-http-body.js

@@ -8,6 +8,15 @@ export function resolverMetadadosOrigemBody(expr, sourceFile, requestNames, body
     if (ts.isIdentifier(normalizado) && bodyAliases.has(normalizado.text)) {
         return bodyAliases.get(normalizado.text);
     }
+    if (ts.isPropertyAccessExpression(normalizado)
+        && normalizado.name.text === "body"
+        && ts.isIdentifier(normalizado.expression)
+        && requestNames.has(normalizado.expression.text)) {
+        return {
+            tipoTexto: typeNodeDeclarado?.getText(sourceFile),
+            campos: [],
+        };
+    }
     if (ehCallRequest(expr, requestNames, "json")) {
         return extrairMetadadosTipoExplicito(expr, sourceFile, typeNodeDeclarado);
     }

package/dist/typescript-http-modelos.d.ts

@@ -4,7 +4,7 @@ export interface ParametroRotaTypeScript {
     tipoSema: "Texto" | "Inteiro" | "Decimal" | "Id";
 }
 export interface RotaTypeScriptExtraida {
-    origem: "nextjs" | "firebase";
+    origem: "nextjs" | "firebase" | "express" | "fastify" | "koa";
     metodo: string;
     caminho: string;
     simbolo: string;

package/dist/typescript-http-rotas.d.ts

@@ -6,4 +6,5 @@ export declare function inferirCaminhoNext(relacaoArquivo: string): {
 } | undefined;
 export declare function identificarRotasNodeHttp(sourceFile: ts.SourceFile, nomeSimbolo: string, corpo: ts.Block): RotaTypeScriptExtraida[];
 export declare function extrairRotasNodeWorker(sourceFile: ts.SourceFile, relacaoArquivo: string): RotaTypeScriptExtraida[];
+export declare function extrairRotasExpressFastify(sourceFile: ts.SourceFile): RotaTypeScriptExtraida[];
 export declare function extrairRotasTypeScriptHttp(sourceFile: ts.SourceFile, relacaoArquivo: string): RotaTypeScriptExtraida[];

package/dist/typescript-http-rotas.js

@@ -109,6 +109,203 @@ export function extrairRotasNodeWorker(sourceFile, relacaoArquivo) {
     }
     return deduplicarRotas(rotas);
 }
+function combinarCaminhoPrefixo(base, sufixo) {
+    const prefixo = (base ?? "").replace(/\/+$/u, "");
+    const caminho = sufixo.startsWith("/") ? sufixo : `/${sufixo}`;
+    const combinado = `${prefixo}${caminho}`.replace(/\/{2,}/gu, "/");
+    return combinado.length > 1 && combinado.endsWith("/") ? combinado.slice(0, -1) : combinado;
+}
+function extrairPrefixoRegister(node) {
+    const opcoes = node.arguments[1];
+    if (!opcoes || !ts.isObjectLiteralExpression(opcoes)) {
+        return undefined;
+    }
+    for (const propriedade of opcoes.properties) {
+        if (ts.isPropertyAssignment(propriedade)
+            && ts.isIdentifier(propriedade.name)
+            && propriedade.name.text === "prefix"
+            && propriedade.initializer
+            && ts.isStringLiteralLike(propriedade.initializer)) {
+            return propriedade.initializer.text;
+        }
+    }
+    return undefined;
+}
+export function extrairRotasExpressFastify(sourceFile) {
+    const textoArquivo = sourceFile.getFullText();
+    const importouExpress = /(?:from\s+["']express["']|require\(\s*["']express["']\s*\))/.test(textoArquivo);
+    const importouFastify = /(?:from\s+["']fastify["']|require\(\s*["']fastify["']\s*\))/.test(textoArquivo);
+    const importouKoa = /(?:from\s+["'](?:@koa\/router|koa-router|koa)["']|require\(\s*["'](?:@koa\/router|koa-router|koa)["']\s*\))/.test(textoArquivo);
+    if (!importouExpress && !importouFastify && !importouKoa) {
+        return [];
+    }
+    const arestasMontagem = [];
+    const prefixoDireto = new Map();
+    const prefixoPorParametro = new Map();
+    const prefixoResolvido = new Map();
+    const resolverPrefixo = (receptor, profundidade = 0) => {
+        if (prefixoResolvido.has(receptor)) {
+            return prefixoResolvido.get(receptor);
+        }
+        if (profundidade > 8) {
+            return "";
+        }
+        let prefixo = prefixoDireto.get(receptor) ?? "";
+        const aresta = arestasMontagem.find((item) => item.filho === receptor);
+        if (aresta) {
+            prefixo = combinarCaminhoPrefixo(resolverPrefixo(aresta.pai, profundidade + 1), aresta.prefixo);
+        }
+        prefixoResolvido.set(receptor, prefixo);
+        return prefixo;
+    };
+    const visitarMontagens = (node) => {
+        if (ts.isVariableStatement(node)) {
+            for (const declaracao of node.declarationList.declarations) {
+                if (!ts.isIdentifier(declaracao.name) || !declaracao.initializer) {
+                    continue;
+                }
+                const init = declaracao.initializer;
+                const argumentoFastify = ts.isCallExpression(init)
+                    && ts.isIdentifier(init.expression)
+                    && /fastify/i.test(init.expression.text)
+                    && init.arguments[0]
+                    && ts.isObjectLiteralExpression(init.arguments[0])
+                    ? init.arguments[0]
+                    : undefined;
+                if (argumentoFastify) {
+                    for (const propriedade of argumentoFastify.properties) {
+                        if (ts.isPropertyAssignment(propriedade)
+                            && ts.isIdentifier(propriedade.name)
+                            && propriedade.name.text === "prefix"
+                            && propriedade.initializer
+                            && ts.isStringLiteralLike(propriedade.initializer)) {
+                            prefixoDireto.set(declaracao.name.text, propriedade.initializer.text);
+                        }
+                    }
+                }
+            }
+        }
+        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression)) {
+            const receptor = node.expression.expression.text;
+            const nomeMetodo = node.expression.name.text.toLowerCase();
+            if (nomeMetodo === "use"
+                && node.arguments[0]
+                && ts.isStringLiteralLike(node.arguments[0])
+                && node.arguments[0].text.startsWith("/")
+                && node.arguments[1]
+                && ts.isIdentifier(node.arguments[1])) {
+                arestasMontagem.push({ pai: receptor, filho: node.arguments[1].text, prefixo: node.arguments[0].text });
+            }
+            else if (nomeMetodo === "prefix"
+                && node.arguments[0]
+                && ts.isStringLiteralLike(node.arguments[0])
+                && node.arguments[0].text.startsWith("/")) {
+                prefixoDireto.set(receptor, combinarCaminhoPrefixo(node.arguments[0].text, prefixoDireto.get(receptor) ?? ""));
+            }
+            else if (nomeMetodo === "register" && importouFastify) {
+                const prefixo = extrairPrefixoRegister(node);
+                const alvo = node.arguments[0];
+                if (prefixo && alvo) {
+                    const funcao = ts.isFunctionExpression(alvo) || ts.isArrowFunction(alvo) ? alvo : undefined;
+                    const parametro = funcao?.parameters[0];
+                    if (parametro && ts.isIdentifier(parametro.name)) {
+                        prefixoPorParametro.set(parametro.name.text, prefixo);
+                    }
+                }
+            }
+        }
+        node.forEachChild(visitarMontagens);
+    };
+    visitarMontagens(sourceFile);
+    const rotas = [];
+    const escolherOrigemChamada = (receptor) => {
+        if (/fastify/i.test(receptor)) {
+            return "fastify";
+        }
+        if (importouExpress) {
+            return "express";
+        }
+        if (importouKoa) {
+            return "koa";
+        }
+        if (importouFastify || prefixoPorParametro.has(receptor)) {
+            return "fastify";
+        }
+        return undefined;
+    };
+    const visitar = (node) => {
+        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression)) {
+            const receptor = node.expression.expression.text;
+            const nomeMetodo = node.expression.name.text.toLowerCase();
+            const prefixoReceptor = prefixoPorParametro.get(receptor) ?? resolverPrefixo(receptor);
+            if (nomeMetodo === "route" && node.arguments[0] && ts.isObjectLiteralExpression(node.arguments[0]) && importouFastify) {
+                let metodo;
+                let caminho;
+                for (const propriedade of node.arguments[0].properties) {
+                    if (!ts.isPropertyAssignment(propriedade) || !ts.isIdentifier(propriedade.name)) {
+                        continue;
+                    }
+                    const valor = propriedade.initializer && ts.isStringLiteralLike(propriedade.initializer)
+                        ? propriedade.initializer.text
+                        : undefined;
+                    if (propriedade.name.text === "method" && valor) {
+                        metodo = valor.toUpperCase();
+                    }
+                    if (propriedade.name.text === "url" && valor) {
+                        caminho = valor;
+                    }
+                }
+                if (metodo && caminho?.startsWith("/") && METODOS_HTTP.has(metodo)) {
+                    rotas.push({
+                        origem: "fastify",
+                        metodo,
+                        caminho: converterCaminhoParametros(combinarCaminhoPrefixo(prefixoReceptor, caminho)),
+                        simbolo: receptor,
+                        parametros: extrairParametrosCaminhoDoisPontos(caminho),
+                    });
+                }
+            }
+            else if (nomeMetodo === "all" || nomeMetodo === "del" || METODOS_HTTP.has(nomeMetodo.toUpperCase())) {
+                const caminho = node.arguments[0] && ts.isStringLiteralLike(node.arguments[0])
+                    ? node.arguments[0].text
+                    : undefined;
+                const origem = escolherOrigemChamada(receptor);
+                const handler = node.arguments[1] && ts.isIdentifier(node.arguments[1]) ? node.arguments[1].text : undefined;
+                if (caminho?.startsWith("/") && origem) {
+                    const metodos = nomeMetodo === "all"
+                        ? ["GET", "POST", "PUT", "PATCH", "DELETE"]
+                        : [nomeMetodo === "del" ? "DELETE" : nomeMetodo.toUpperCase()];
+                    for (const metodo of metodos) {
+                        rotas.push({
+                            origem,
+                            metodo,
+                            caminho: converterCaminhoParametros(combinarCaminhoPrefixo(prefixoReceptor, caminho)),
+                            simbolo: handler ?? receptor,
+                            parametros: extrairParametrosCaminhoDoisPontos(combinarCaminhoPrefixo(prefixoReceptor, caminho)),
+                        });
+                    }
+                }
+            }
+        }
+        node.forEachChild(visitar);
+    };
+    visitar(sourceFile);
+    return deduplicarRotas(rotas);
+}
+function converterCaminhoParametros(caminho) {
+    return caminho.replace(/:([A-Za-z_]\w*)/g, "{$1}");
+}
+function extrairParametrosCaminhoDoisPontos(caminho) {
+    const parametros = [];
+    for (const correspondencia of caminho.matchAll(/:([A-Za-z_]\w*)/g)) {
+        const nome = correspondencia[1];
+        parametros.push({
+            nome,
+            tipoSema: /(^|_)id$/i.test(nome) ? "Id" : "Texto",
+        });
+    }
+    return parametros;
+}
 export function extrairRotasTypeScriptHttp(sourceFile, relacaoArquivo) {
     const rotas = [];
     const caminhoNext = inferirCaminhoNext(relacaoArquivo);
@@ -124,6 +321,7 @@ export function extrairRotasTypeScriptHttp(sourceFile, relacaoArquivo) {
         }
     }
     rotas.push(...extrairRotasNodeWorker(sourceFile, relacaoArquivo));
+    rotas.push(...extrairRotasExpressFastify(sourceFile));
     return deduplicarRotas(rotas);
 }
 //# sourceMappingURL=typescript-http-rotas.js.map

package/dist/typescript-http-semantica.d.ts

@@ -1,11 +1,11 @@
 import ts from "typescript";
 import { type CampoInferidoTypeScriptHttp, type ExportacaoTypeScriptHttp, type SemanticaHandlerTypeScriptHttp, type ValorLocalTypeScriptHttp } from "./typescript-http-modelos.js";
-export declare function localizarExportacaoEmStatement(statement: ts.Statement, nomeExportado: string, sourceFile: ts.SourceFile): ExportacaoTypeScriptHttp | undefined;
+export declare function localizarExportacaoEmStatement(statement: ts.Statement, nomeExportado: string, sourceFile: ts.SourceFile, permitirNaoExportada?: boolean): ExportacaoTypeScriptHttp | undefined;
 export declare function inferirTipoPorContexto(node: ts.Node, nomeCampo: string): string | undefined;
 export declare function extrairRetornoHttp(expr: ts.Expression, sourceFile: ts.SourceFile, valoresLocais: Map<string, ValorLocalTypeScriptHttp>): {
     campos: CampoInferidoTypeScriptHttp[];
     tipoTexto?: string;
     status?: number;
 } | undefined;
-export declare function localizarExportacaoTypeScriptHttp(sourceFile: ts.SourceFile, nomeExportado: string): ExportacaoTypeScriptHttp | undefined;
-export declare function inferirSemanticaHandlerTypeScriptHttp(sourceFile: ts.SourceFile, nomeExportado: string): SemanticaHandlerTypeScriptHttp | undefined;
+export declare function localizarExportacaoTypeScriptHttp(sourceFile: ts.SourceFile, nomeExportado: string, permitirNaoExportada?: boolean): ExportacaoTypeScriptHttp | undefined;
+export declare function inferirSemanticaHandlerTypeScriptHttp(sourceFile: ts.SourceFile, nomeExportado: string, permitirNaoExportada?: boolean): SemanticaHandlerTypeScriptHttp | undefined;

package/dist/typescript-http-semantica.js

@@ -4,8 +4,10 @@ import ts from "typescript";
 import { deduplicarCampos, deduplicarNumeros, desembrulharExpressao, } from "./typescript-http-modelos.js";
 import { ehCallRequest, ehNewUrl, ehSearchParamsSource, extrairCamposObjetoLiteral, extrairMetadadosTipoExplicito, extrairStatusHttp, obterNomeSchema, tipoInferidoPorNomeCampo, } from "./typescript-http-expressoes.js";
 import { extrairCamposBindingPattern, extrairSchemasZodLocais, resolverMetadadosOrigemBody, } from "./typescript-http-body.js";
-export function localizarExportacaoEmStatement(statement, nomeExportado, sourceFile) {
-    if (ts.isFunctionDeclaration(statement) && statement.name?.text === nomeExportado && statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+export function localizarExportacaoEmStatement(statement, nomeExportado, sourceFile, permitirNaoExportada = false) {
+    const declarada = (statement) => permitirNaoExportada
+        || statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) === true;
+    if (ts.isFunctionDeclaration(statement) && statement.name?.text === nomeExportado && declarada(statement)) {
         return {
             corpo: statement.body,
             retorno: statement.type?.getText(sourceFile),
@@ -13,7 +15,7 @@ export function localizarExportacaoEmStatement(statement, nomeExportado, sourceF
             declaracao: statement,
         };
     }
-    if (!ts.isVariableStatement(statement) || !statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+    if (!ts.isVariableStatement(statement) || !declarada(statement)) {
         return undefined;
     }
     for (const declaracao of statement.declarationList.declarations) {
@@ -110,17 +112,17 @@ export function extrairRetornoHttp(expr, sourceFile, valoresLocais) {
     }
     return undefined;
 }
-export function localizarExportacaoTypeScriptHttp(sourceFile, nomeExportado) {
+export function localizarExportacaoTypeScriptHttp(sourceFile, nomeExportado, permitirNaoExportada = false) {
     for (const node of sourceFile.statements) {
-        const localizada = localizarExportacaoEmStatement(node, nomeExportado, sourceFile);
+        const localizada = localizarExportacaoEmStatement(node, nomeExportado, sourceFile, permitirNaoExportada);
         if (localizada) {
             return localizada;
         }
     }
     return undefined;
 }
-export function inferirSemanticaHandlerTypeScriptHttp(sourceFile, nomeExportado) {
-    const exportacao = localizarExportacaoTypeScriptHttp(sourceFile, nomeExportado);
+export function inferirSemanticaHandlerTypeScriptHttp(sourceFile, nomeExportado, permitirNaoExportada = false) {
+    const exportacao = localizarExportacaoTypeScriptHttp(sourceFile, nomeExportado, permitirNaoExportada);
     if (!exportacao?.corpo) {
         return undefined;
     }
@@ -139,6 +141,12 @@ export function inferirSemanticaHandlerTypeScriptHttp(sourceFile, nomeExportado)
             requestNames.add(parametro.name.text);
         }
     }
+    const responseNames = new Set();
+    for (const [indice, parametro] of exportacao.parametros.entries()) {
+        if (indice > 0 && ts.isIdentifier(parametro.name)) {
+            responseNames.add(parametro.name.text);
+        }
+    }
     const visitarDeclaracoes = (node) => {
         if (ts.isVariableDeclaration(node) && node.initializer) {
             const inicializadorNormalizado = desembrulharExpressao(node.initializer);
@@ -256,6 +264,56 @@ export function inferirSemanticaHandlerTypeScriptHttp(sourceFile, nomeExportado)
         bodyTipoTexto ??= tipoTexto;
     };
     const visitarSemantica = (node) => {
+        if (ts.isPropertyAccessExpression(node)
+            && ts.isPropertyAccessExpression(node.expression)
+            && ts.isIdentifier(node.expression.expression)
+            && requestNames.has(node.expression.expression.text)) {
+            const origemAcesso = node.expression.name.text;
+            const nomeCampo = node.name.text;
+            const ehQuery = origemAcesso === "query" || origemAcesso === "params"
+                || (origemAcesso === "request" && (nomeCampo === "query" || nomeCampo === "searchParams"));
+            const ehBody = origemAcesso === "body" || (origemAcesso === "request" && nomeCampo === "body");
+            if (ehQuery && origemAcesso !== "params") {
+                query.push({
+                    nome: nomeCampo,
+                    tipoTexto: inferirTipoPorContexto(node, nomeCampo) ?? "string",
+                    obrigatorio: false,
+                });
+            }
+            else if (ehBody) {
+                body.push({
+                    nome: nomeCampo,
+                    tipoTexto: inferirTipoPorContexto(node, nomeCampo) ?? "string",
+                    obrigatorio: false,
+                });
+            }
+        }
+        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "json") {
+            let alvo = node.expression.expression;
+            let status;
+            if (ts.isCallExpression(alvo)
+                && ts.isPropertyAccessExpression(alvo.expression)
+                && alvo.expression.name.text === "status"
+                && alvo.arguments[0]
+                && ts.isNumericLiteral(alvo.arguments[0])) {
+                status = Number(alvo.arguments[0].text);
+                alvo = alvo.expression.expression;
+            }
+            if (ts.isIdentifier(alvo) && responseNames.has(alvo.text)) {
+                const argumento = node.arguments[0];
+                const campos = argumento && ts.isObjectLiteralExpression(argumento)
+                    ? extrairCamposObjetoLiteral(argumento, sourceFile)
+                    : argumento && ts.isIdentifier(argumento) && valoresLocais.has(argumento.text)
+                        ? valoresLocais.get(argumento.text).campos
+                        : [];
+                if (typeof status === "number") {
+                    statuses.push(status);
+                }
+                if (status === undefined || status < 400) {
+                    response.push(...campos);
+                }
+            }
+        }
         if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
             const alvo = node.expression.expression;
             const metodo = node.expression.name.text;

package/dist/typescript-http.d.ts

@@ -1,3 +1,3 @@
 export type { CampoInferidoTypeScriptHttp, ExportacaoTypeScriptHttp, ParametroRotaTypeScript, RotaTypeScriptExtraida, SemanticaHandlerTypeScriptHttp, } from "./typescript-http-modelos.js";
-export { extrairRotasTypeScriptHttp } from "./typescript-http-rotas.js";
+export { extrairRotasExpressFastify, extrairRotasTypeScriptHttp } from "./typescript-http-rotas.js";
 export { inferirSemanticaHandlerTypeScriptHttp, localizarExportacaoTypeScriptHttp, } from "./typescript-http-semantica.js";

package/dist/typescript-http.js

@@ -1,5 +1,5 @@
 // SEMA-GOVERNED: sema.governanca_ia_contexto
 // Descricao: fachada de extracao HTTP TypeScript; consulte contratos/sema/governanca_ia_contexto.sema antes de editar.
-export { extrairRotasTypeScriptHttp } from "./typescript-http-rotas.js";
+export { extrairRotasExpressFastify, extrairRotasTypeScriptHttp } from "./typescript-http-rotas.js";
 export { inferirSemanticaHandlerTypeScriptHttp, localizarExportacaoTypeScriptHttp, } from "./typescript-http-semantica.js";
 //# sourceMappingURL=typescript-http.js.map

package/dist/verificacaoCache.d.ts

@@ -0,0 +1,25 @@
+export declare const SCHEMA_CACHE_VERIFICACAO = "sema.verificacao-cache/v1";
+export interface EntradaCacheVerificacao {
+    schemaVersion: typeof SCHEMA_CACHE_VERIFICACAO;
+    chave: string;
+    versaoCli: string;
+    alvo: string;
+    modulo: string;
+    sucesso: boolean;
+    quantidadeTestes: number;
+    testesExecutados: boolean;
+    arquivosGerados: string[];
+    geradoEm: string;
+}
+export declare function calcularChaveVerificacao(entradas: {
+    versaoCli: string;
+    versaoNode: string;
+    modulo: string;
+    alvo: string;
+    framework: string;
+    estrutura: string;
+    conteudoContrato: string;
+}): string;
+export declare function carregarCacheVerificacao(chave: string, pastaAlvo: string, raizCache?: string): Promise<EntradaCacheVerificacao | undefined>;
+export declare function carregarManifestoVerificacao(chave: string, raizCache?: string): Promise<EntradaCacheVerificacao | undefined>;
+export declare function gravarCacheVerificacao(entrada: EntradaCacheVerificacao, raizCache?: string): Promise<void>;

package/dist/verificacaoCache.js

@@ -0,0 +1,80 @@
+// SEMA-GOVERNED: sema.produto.cli_verificacao
+// Descrição: cache incremental de verificação fora do workspace, endereçado por conteúdo do contrato.
+import { createHash } from "node:crypto";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { resolverRaizCacheSema } from "./driftCacheFilesystem.js";
+export const SCHEMA_CACHE_VERIFICACAO = "sema.verificacao-cache/v1";
+export function calcularChaveVerificacao(entradas) {
+    return createHash("sha256")
+        .update(JSON.stringify({
+        schemaVersion: SCHEMA_CACHE_VERIFICACAO,
+        versaoCli: entradas.versaoCli,
+        versaoNode: entradas.versaoNode,
+        modulo: entradas.modulo,
+        alvo: entradas.alvo,
+        framework: entradas.framework,
+        estrutura: entradas.estrutura,
+        conteudoContrato: entradas.conteudoContrato,
+    }))
+        .digest("hex");
+}
+function resolverPastaCacheVerificacao(raizCache) {
+    const resolucao = resolverRaizCacheSema(raizCache ? { raizCache } : {});
+    return resolucao.disponivel ? path.join(resolucao.raiz, "verificacao") : undefined;
+}
+export async function carregarCacheVerificacao(chave, pastaAlvo, raizCache) {
+    const pasta = resolverPastaCacheVerificacao(raizCache);
+    if (!pasta) {
+        return undefined;
+    }
+    let entrada;
+    try {
+        entrada = JSON.parse(await readFile(path.join(pasta, `${chave}.json`), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    if (entrada.schemaVersion !== SCHEMA_CACHE_VERIFICACAO || entrada.chave !== chave) {
+        return undefined;
+    }
+    for (const relativo of entrada.arquivosGerados) {
+        try {
+            await stat(path.join(pastaAlvo, relativo));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return entrada;
+}
+export async function carregarManifestoVerificacao(chave, raizCache) {
+    const pasta = resolverPastaCacheVerificacao(raizCache);
+    if (!pasta) {
+        return undefined;
+    }
+    try {
+        const entrada = JSON.parse(await readFile(path.join(pasta, `${chave}.json`), "utf8"));
+        if (entrada.schemaVersion !== SCHEMA_CACHE_VERIFICACAO || entrada.chave !== chave) {
+            return undefined;
+        }
+        return entrada;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function gravarCacheVerificacao(entrada, raizCache) {
+    const pasta = resolverPastaCacheVerificacao(raizCache);
+    if (!pasta) {
+        return;
+    }
+    try {
+        await mkdir(pasta, { recursive: true });
+        await writeFile(path.join(pasta, `${entrada.chave}.json`), `${JSON.stringify(entrada, null, 2)}\n`, "utf8");
+    }
+    catch {
+        // Cache é aceleração: falha de gravação nunca derruba a verificação.
+    }
+}
+//# sourceMappingURL=verificacaoCache.js.map

package/docs/syntax.md

@@ -87,6 +87,20 @@ impl {
 
 `sema compilar --alvo javascript` defines a generation target. `impl { js: ... }` defines the live-code origin linked to the contract. They are different layers and both are valid.
 
+## Layered `impl` Roles
+
+Layered code (route + service + persistence in the same language) can declare one `impl` per role. Append a supported role to the origin: `rota`, `servico`, `persistencia` or `repositorio`.
+
+```sema
+impl {
+  ts_rota: server.routes.monitores.criarMonitor
+  ts_servico: server.services.monitores.criarMonitor
+  ts_persistencia: server.repositories.monitores.criar
+}
+```
+
+Each origin-plus-role pair must appear at most once; the bare origin (for example `ts`) stays valid for single-layer tasks, and drift resolves every role independently.
+
 ## Small Canonical Lists
 
 - `effects`: `persistencia`, `consulta`, `evento`, `auditoria`, `db.write`, `queue.publish`, `fs.write`, `network.egress`, `secret.read`, `shell.exec`.