@semacode/cli 1.0.0 → 1.2.0

package/dist/drift.js

@@ -5,6 +5,7 @@ import { extrairSimbolosCpp } from "./cpp-symbols.js";
 import { extrairRotasDotnet, extrairSimbolosDotnet } from "./dotnet-http.js";
 import { extrairRotasGo, extrairSimbolosGo } from "./go-http.js";
 import { extrairRotasJava, extrairSimbolosJava } from "./java-http.js";
+import { extrairSimbolosLua } from "./lua-symbols.js";
 import { contarIndentacaoPython, extrairRotasFlaskDecoradas, normalizarCaminhoFlask } from "./python-http.js";
 import { extrairRotasRust, extrairSimbolosRust } from "./rust-http.js";
 import { extrairRotasTypeScriptHttp } from "./typescript-http.js";
@@ -291,6 +292,335 @@ function registrarSimboloTypeScript(simbolos, basesSimbolicas, arquivo, nome, no
         });
     }
 }
+function normalizarRelacaoConsumer(relacaoArquivo) {
+    return relacaoArquivo.replace(/\\/g, "/");
+}
+function normalizarSegmentoRotaConsumer(segmento) {
+    const opcionalCatchAll = segmento.match(/^\[\[\.\.\.([A-Za-z_]\w*)\]\]$/);
+    if (opcionalCatchAll) {
+        return `{${opcionalCatchAll[1]}}`;
+    }
+    const catchAll = segmento.match(/^\[\.\.\.([A-Za-z_]\w*)\]$/);
+    if (catchAll) {
+        return `{${catchAll[1]}}`;
+    }
+    const dinamico = segmento.match(/^\[([A-Za-z_]\w*)\]$/);
+    if (dinamico) {
+        return `{${dinamico[1]}}`;
+    }
+    return segmento;
+}
+function montarRotaConsumer(partes) {
+    const filtradas = partes
+        .filter((segmento) => segmento && segmento !== "index" && !/^\(.*\)$/.test(segmento) && !segmento.startsWith("@"))
+        .map(normalizarSegmentoRotaConsumer);
+    return filtradas.length > 0 ? `/${filtradas.join("/")}`.replace(/\/+/g, "/") : "/";
+}
+function arquivoEhBridgeNextJsConsumer(relacaoArquivo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?lib\/(?:sema_consumer_bridge|sema\/.+)\.(?:ts|tsx|js|jsx)$/i.test(relacao);
+}
+function arquivoEhBridgeReactViteConsumer(relacaoArquivo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?lib\/(?:sema_consumer_bridge|sema\/.+)\.(?:ts|tsx|js|jsx)$/i.test(relacao);
+}
+function arquivoEhBridgeAngularConsumer(relacaoArquivo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?app\/(?:sema_consumer_bridge|sema\/.+)\.(?:ts|js)$/i.test(relacao);
+}
+function arquivoEhSuperficieNextJsConsumer(relacaoArquivo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?app\/(?:(?!api\/).)*?(?:page|layout|loading|error)\.(?:ts|tsx|js|jsx)$/i.test(relacao);
+}
+function arquivoEhSuperficieReactViteConsumer(relacaoArquivo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    return /^(?:src\/)?pages\/.+\.(?:ts|tsx|js|jsx)$/i.test(relacao)
+        || /^(?:src\/)?App\.(?:ts|tsx|js|jsx)$/i.test(relacao);
+}
+function arquivoEhRotasReactViteConsumer(relacaoArquivo, codigo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?(?:app\/)?(?:router|routes)\.(?:ts|tsx|js|jsx)$/i.test(relacao)
+        || /from\s+["']react-router-dom["']|createBrowserRouter|RouterProvider|useRoutes\s*\(|<Routes\b|<Route\b/.test(codigo ?? "");
+}
+function arquivoEhRotasAngularConsumer(relacaoArquivo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?app(?:\/.+)?\/[^/]+\.routes\.(?:ts|js)$/i.test(relacao);
+}
+function arquivoEhRotasAngularConsumerRaiz(relacaoArquivo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    return /(?:^|\/)(?:src\/)?app\/[^/]+\.routes\.(?:ts|js)$/i.test(relacao);
+}
+function arquivoEhBridgeFlutterConsumer(relacaoArquivo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    return /(?:^|\/)(?:lib\/)?(?:sema_consumer_bridge|api\/sema_contract_bridge|sema\/.+)\.dart$/i.test(relacao);
+}
+function arquivoEhSuperficieFlutterConsumer(relacaoArquivo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    return /(?:^|\/)(?:lib\/)?(?:screens|pages)\/.+\.dart$/i.test(relacao)
+        || /(?:^|\/)(?:lib\/)?main\.dart$/i.test(relacao);
+}
+function arquivoEhRotasFlutterConsumer(relacaoArquivo, codigo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    return /(?:^|\/)(?:lib\/)?(?:router|app_router|routes)\.dart$/i.test(relacao)
+        || /MaterialApp(?:\.router)?\s*\(|CupertinoApp(?:\.router)?\s*\(|GoRouter\s*\(/.test(codigo ?? "");
+}
+function inferirRotaNextJsConsumer(relacaoArquivo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    const segmentos = relacao.split("/");
+    const indiceSrcApp = segmentos.findIndex((segmento, indice) => segmento === "src" && segmentos[indice + 1] === "app");
+    const indiceApp = segmentos.findIndex((segmento) => segmento === "app");
+    const inicioApp = indiceSrcApp >= 0 ? indiceSrcApp + 2 : indiceApp >= 0 ? indiceApp + 1 : -1;
+    if (inicioApp < 0) {
+        return undefined;
+    }
+    const arquivoFinal = segmentos.at(-1) ?? "";
+    const tipoArquivo = arquivoFinal.match(/^(page|layout|loading|error)\.(?:ts|tsx|js|jsx)$/)?.[1];
+    if (!tipoArquivo) {
+        return undefined;
+    }
+    const caminhoAteArquivo = segmentos.slice(inicioApp, -1);
+    if (caminhoAteArquivo[0] === "api") {
+        return undefined;
+    }
+    return {
+        rota: montarRotaConsumer(caminhoAteArquivo),
+        arquivo: relacaoArquivo,
+        tipoArquivo,
+    };
+}
+function inferirRotaReactViteConsumer(relacaoArquivo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    if (/(?:^|\/)(?:src\/)?App\.(?:ts|tsx|js|jsx)$/i.test(relacao)) {
+        return {
+            rota: "/",
+            arquivo: relacaoArquivo,
+            tipoArquivo: "app",
+        };
+    }
+    const segmentos = relacao.split("/");
+    const indiceSrcPages = segmentos.findIndex((segmento, indice) => segmento === "src" && segmentos[indice + 1] === "pages");
+    const indicePages = segmentos.findIndex((segmento) => segmento === "pages");
+    const inicioPages = indiceSrcPages >= 0 ? indiceSrcPages + 2 : indicePages >= 0 ? indicePages + 1 : -1;
+    if (inicioPages < 0) {
+        return undefined;
+    }
+    const arquivoFinal = segmentos.at(-1) ?? "";
+    const nomeBase = arquivoFinal.replace(/\.(?:ts|tsx|js|jsx)$/i, "");
+    return {
+        rota: montarRotaConsumer([...segmentos.slice(inicioPages, -1), nomeBase]),
+        arquivo: relacaoArquivo,
+        tipoArquivo: "page",
+    };
+}
+function inferirRotaFlutterConsumer(relacaoArquivo) {
+    const relacao = normalizarRelacaoConsumer(relacaoArquivo);
+    if (!arquivoEhSuperficieFlutterConsumer(relacao)) {
+        return undefined;
+    }
+    if (/(?:^|\/)(?:lib\/)?main\.dart$/i.test(relacao)) {
+        return {
+            rota: "/",
+            arquivo: relacaoArquivo,
+            tipoArquivo: "app",
+        };
+    }
+    const segmentos = relacao.split("/");
+    const indiceLibScreens = segmentos.findIndex((segmento, indice) => segmento === "lib" && ["screens", "pages"].includes(segmentos[indice + 1] ?? ""));
+    const indiceScreens = segmentos.findIndex((segmento) => segmento === "screens" || segmento === "pages");
+    const inicio = indiceLibScreens >= 0 ? indiceLibScreens + 2 : indiceScreens >= 0 ? indiceScreens + 1 : -1;
+    if (inicio < 0) {
+        return undefined;
+    }
+    const arquivoFinal = segmentos.at(-1) ?? "";
+    const nomeBase = arquivoFinal
+        .replace(/\.(?:dart)$/i, "")
+        .replace(/_(screen|page)$/i, "");
+    return {
+        rota: montarRotaConsumer([...segmentos.slice(inicio, -1), nomeBase]),
+        arquivo: relacaoArquivo,
+        tipoArquivo: "screen",
+    };
+}
+function normalizarRotaDeclaradaConsumer(caminhoCru, prefixo = "/") {
+    const partesPrefixo = prefixo.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
+    const partesCaminho = (caminhoCru ?? "").trim().replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
+    return montarRotaConsumer([...partesPrefixo, ...partesCaminho]);
+}
+function resolverImportRelativoConsumer(relacaoArquivoBase, especificador) {
+    if (!especificador.startsWith(".")) {
+        return undefined;
+    }
+    const baseDir = path.posix.dirname(normalizarRelacaoConsumer(relacaoArquivoBase));
+    for (const sufixo of ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.js"]) {
+        const candidato = path.posix.normalize(path.posix.join(baseDir, `${especificador}${sufixo}`));
+        if (/\.(?:ts|tsx|js|jsx)$/i.test(candidato)) {
+            return candidato;
+        }
+    }
+    return undefined;
+}
+function extrairImportsTypeScriptConsumer(relacaoArquivo, codigo) {
+    const imports = new Map();
+    for (const match of codigo.matchAll(/import\s*\{\s*([^}]+)\s*\}\s*from\s*["']([^"']+)["']/g)) {
+        const arquivoImportado = resolverImportRelativoConsumer(relacaoArquivo, match[2]);
+        if (!arquivoImportado) {
+            continue;
+        }
+        for (const bruto of match[1].split(",")) {
+            const local = bruto.trim().split(/\s+as\s+/i).at(-1)?.trim();
+            if (local) {
+                imports.set(local, arquivoImportado);
+            }
+        }
+    }
+    for (const match of codigo.matchAll(/import\s+([A-Za-z_]\w*)\s+from\s*["']([^"']+)["']/g)) {
+        const arquivoImportado = resolverImportRelativoConsumer(relacaoArquivo, match[2]);
+        const local = match[1]?.trim();
+        if (arquivoImportado && local) {
+            imports.set(local, arquivoImportado);
+        }
+    }
+    return imports;
+}
+function extrairRotasReactViteConsumer(relacaoArquivo, codigo) {
+    const imports = extrairImportsTypeScriptConsumer(relacaoArquivo, codigo);
+    const rotas = new Map();
+    const registrar = (caminhoCru, componente) => {
+        const rota = normalizarRotaDeclaradaConsumer(caminhoCru);
+        const chave = `${rota}:${normalizarRelacaoConsumer(relacaoArquivo)}:${componente ?? "router"}`;
+        rotas.set(chave, {
+            rota,
+            arquivoRotas: normalizarRelacaoConsumer(relacaoArquivo),
+            arquivoComponente: componente ? imports.get(componente) : undefined,
+        });
+    };
+    for (const match of codigo.matchAll(/(?:path\s*:\s*["'`]([^"'`]*)["'`]|index\s*:\s*true)[\s\S]{0,260}?(?:element\s*:\s*<\s*([A-Za-z_]\w*)|Component\s*:\s*([A-Za-z_]\w*))/g)) {
+        const caminhoCru = match[1] ?? "";
+        const componente = match[2] ?? match[3];
+        registrar(caminhoCru, componente);
+    }
+    for (const match of codigo.matchAll(/<Route\b[^>]*?(?:path=["'`]([^"'`]*)["'`][^>]*?)?(index\b)?[^>]*?(?:element=\{\s*<\s*([A-Za-z_]\w*)|Component=\{\s*([A-Za-z_]\w*))/g)) {
+        const caminhoCru = match[2] ? "" : (match[1] ?? "");
+        const componente = match[3] ?? match[4];
+        registrar(caminhoCru, componente);
+    }
+    return [...rotas.values()];
+}
+function normalizarRotaDeclaradaFlutter(caminhoCru) {
+    return montarRotaConsumer((caminhoCru ?? "").trim().replace(/^\/+|\/+$/g, "").split("/").filter(Boolean));
+}
+function extrairRotasFlutterConsumer(relacaoArquivo, codigo) {
+    const rotas = new Map();
+    const registrar = (caminhoCru) => {
+        const rota = normalizarRotaDeclaradaFlutter(caminhoCru);
+        rotas.set(`${rota}:${normalizarRelacaoConsumer(relacaoArquivo)}`, {
+            rota,
+            arquivoRotas: normalizarRelacaoConsumer(relacaoArquivo),
+        });
+    };
+    for (const match of codigo.matchAll(/GoRoute\s*\([\s\S]{0,220}?path\s*:\s*["'`]([^"'`]+)["'`]/g)) {
+        registrar(match[1] ?? "");
+    }
+    for (const match of codigo.matchAll(/["'`]([^"'`]+)["'`]\s*:\s*\([^)]*\)\s*=>/g)) {
+        registrar(match[1] ?? "");
+    }
+    if (/home\s*:\s*(?:const\s+)?[A-Za-z_]\w*\(/.test(codigo)) {
+        registrar("/");
+    }
+    return [...rotas.values()];
+}
+function extrairRotasAngularConsumerDiretas(relacaoArquivo, codigo, prefixo = "/") {
+    const imports = extrairImportsTypeScriptConsumer(relacaoArquivo, codigo);
+    const rotas = [];
+    for (const match of codigo.matchAll(/path\s*:\s*["'`]([^"'`]*)["'`][\s\S]{0,320}?component\s*:\s*([A-Za-z_]\w*)/g)) {
+        const caminhoCru = (match[1] ?? "").trim();
+        const componente = match[2];
+        rotas.push({
+            rota: normalizarRotaDeclaradaConsumer(caminhoCru, prefixo),
+            arquivoRotas: normalizarRelacaoConsumer(relacaoArquivo),
+            componente,
+            arquivoComponente: imports.get(componente),
+        });
+    }
+    for (const match of codigo.matchAll(/path\s*:\s*["'`]([^"'`]*)["'`][\s\S]{0,320}?loadComponent\s*:\s*\(\s*\)\s*=>\s*import\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g)) {
+        const caminhoCru = (match[1] ?? "").trim();
+        const arquivoComponente = resolverImportRelativoConsumer(relacaoArquivo, match[2] ?? "");
+        rotas.push({
+            rota: normalizarRotaDeclaradaConsumer(caminhoCru, prefixo),
+            arquivoRotas: normalizarRelacaoConsumer(relacaoArquivo),
+            arquivoComponente,
+        });
+    }
+    for (const match of codigo.matchAll(/path\s*:\s*["'`]([^"'`]*)["'`][\s\S]{0,360}?loadChildren\s*:\s*\(\s*\)\s*=>\s*import\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g)) {
+        const caminhoCru = (match[1] ?? "").trim();
+        const arquivoRotasFilhas = resolverImportRelativoConsumer(relacaoArquivo, match[2] ?? "");
+        rotas.push({
+            rota: normalizarRotaDeclaradaConsumer(caminhoCru, prefixo),
+            arquivoRotas: normalizarRelacaoConsumer(relacaoArquivo),
+            arquivoRotasFilhas,
+        });
+    }
+    return rotas;
+}
+async function extrairRotasAngularConsumer(diretorioBase, relacaoArquivo, prefixo = "/", visitados = new Set()) {
+    const relacaoNormalizada = normalizarRelacaoConsumer(relacaoArquivo);
+    if (visitados.has(relacaoNormalizada)) {
+        return [];
+    }
+    visitados.add(relacaoNormalizada);
+    let codigo = "";
+    try {
+        codigo = await readFile(path.join(diretorioBase, relacaoNormalizada), "utf8");
+    }
+    catch {
+        return [];
+    }
+    const rotas = extrairRotasAngularConsumerDiretas(relacaoNormalizada, codigo, prefixo);
+    const filhas = [];
+    for (const rota of rotas) {
+        if (!rota.arquivoRotasFilhas) {
+            continue;
+        }
+        filhas.push(...await extrairRotasAngularConsumer(diretorioBase, rota.arquivoRotasFilhas, rota.rota, visitados));
+    }
+    return [...rotas, ...filhas];
+}
+function simboloEhBridgeConsumer(caminho, arquivo) {
+    return arquivoEhBridgeNextJsConsumer(arquivo)
+        || arquivoEhBridgeReactViteConsumer(arquivo)
+        || arquivoEhBridgeAngularConsumer(arquivo)
+        || arquivoEhBridgeFlutterConsumer(arquivo)
+        || /(?:^|\.)(?:src\.)?lib\.(?:sema_consumer_bridge|sema\.)/i.test(caminho)
+        || /(?:^|\.)(?:src\.)?app\.(?:sema_consumer_bridge|sema\.)/i.test(caminho)
+        || /(?:^|\.)(?:lib\.)?(?:sema_consumer_bridge|api\.sema_contract_bridge|sema\.)/i.test(caminho);
+}
+function inferirConsumerFrameworkPrincipal(fontesLegado, consumerSurfaces, consumerBridges) {
+    const arquivos = [
+        ...consumerSurfaces.map((item) => item.arquivo),
+        ...consumerBridges.map((item) => item.arquivo),
+    ].map(normalizarRelacaoConsumer);
+    if (arquivos.some((arquivo) => /(?:^|\/)(?:src\/)?app\/(?:(?!api\/).)*?(?:page|layout|loading|error)\.(?:ts|tsx|js|jsx)$/i.test(arquivo))) {
+        return "nextjs-consumer";
+    }
+    if (arquivos.some((arquivo) => /^(?:src\/)?pages\/.+\.(?:ts|tsx|js|jsx)$/i.test(arquivo)
+        || /^(?:src\/)?App\.(?:ts|tsx|js|jsx)$/i.test(arquivo)
+        || /(?:^|\/)(?:src\/)?(?:app\/)?(?:router|routes)\.(?:ts|tsx|js|jsx)$/i.test(arquivo))) {
+        return "react-vite-consumer";
+    }
+    if (arquivos.some((arquivo) => /(?:^|\/)(?:src\/)?app\/.+\.component\.(?:ts|js)$/i.test(arquivo) || arquivoEhRotasAngularConsumer(arquivo))) {
+        return "angular-consumer";
+    }
+    if (arquivos.some((arquivo) => /(?:^|\/)(?:lib\/)?(?:screens|pages)\/.+\.dart$/i.test(arquivo)
+        || /(?:^|\/)(?:lib\/)?(?:router|app_router|routes|main)\.dart$/i.test(arquivo))) {
+        return "flutter-consumer";
+    }
+    for (const framework of ["nextjs-consumer", "react-vite-consumer", "angular-consumer", "flutter-consumer"]) {
+        if (fontesLegado.includes(framework)) {
+            return framework;
+        }
+    }
+    return null;
+}
 function extrairColecoesFirebase(arquivo, codigo) {
     const recursos = new Map();
     const registrar = (nome) => {
@@ -322,11 +652,17 @@ async function indexarTypeScript(diretorios) {
     const simbolos = new Map();
     const rotas = [];
     const recursos = new Map();
+    const consumerSurfaces = new Map();
     for (const diretorio of diretorios) {
         const arquivos = (await listarArquivosRecursivos(diretorio, [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]))
             .filter((arquivo) => !arquivo.endsWith(".d.ts")
             && !arquivo.endsWith(".spec.ts")
             && !arquivo.endsWith(".test.ts"));
+        const arquivosRotasAngular = arquivos.filter((arquivo) => arquivoEhRotasAngularConsumer(path.relative(diretorio, arquivo)));
+        const arquivosRotasAngularRaiz = new Set(arquivosRotasAngular
+            .filter((arquivo) => arquivoEhRotasAngularConsumerRaiz(path.relative(diretorio, arquivo)))
+            .map((arquivo) => path.resolve(arquivo)));
+        const usarApenasRotasAngularRaiz = arquivosRotasAngularRaiz.size > 0;
         for (const arquivo of arquivos) {
             const codigo = await readFile(arquivo, "utf8");
             const scriptKind = arquivo.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
@@ -345,6 +681,89 @@ async function indexarTypeScript(diretorios) {
                     simbolo: rota.simbolo,
                 });
             }
+            const superficieNextJs = arquivoEhSuperficieNextJsConsumer(relacao)
+                ? inferirRotaNextJsConsumer(relacao)
+                : undefined;
+            if (superficieNextJs) {
+                consumerSurfaces.set(`${superficieNextJs.rota}:${arquivo}:${superficieNextJs.tipoArquivo}`, {
+                    rota: superficieNextJs.rota,
+                    arquivo,
+                    tipoArquivo: superficieNextJs.tipoArquivo,
+                });
+                rotas.push({
+                    origem: "nextjs-consumer",
+                    metodo: "VIEW",
+                    caminho: superficieNextJs.rota,
+                    arquivo,
+                    simbolo: superficieNextJs.tipoArquivo,
+                });
+            }
+            const superficieReact = arquivoEhSuperficieReactViteConsumer(relacao)
+                ? inferirRotaReactViteConsumer(relacao)
+                : undefined;
+            if (superficieReact) {
+                consumerSurfaces.set(`${superficieReact.rota}:${arquivo}:${superficieReact.tipoArquivo}`, {
+                    rota: superficieReact.rota,
+                    arquivo,
+                    tipoArquivo: superficieReact.tipoArquivo,
+                });
+                rotas.push({
+                    origem: "react-vite-consumer",
+                    metodo: "VIEW",
+                    caminho: superficieReact.rota,
+                    arquivo,
+                    simbolo: superficieReact.tipoArquivo,
+                });
+            }
+            if (arquivoEhRotasReactViteConsumer(relacao, codigo)) {
+                for (const rotaReact of extrairRotasReactViteConsumer(relacao, codigo)) {
+                    consumerSurfaces.set(`${rotaReact.rota}:${arquivo}:router`, {
+                        rota: rotaReact.rota,
+                        arquivo,
+                        tipoArquivo: "router",
+                    });
+                    rotas.push({
+                        origem: "react-vite-consumer",
+                        metodo: "VIEW",
+                        caminho: rotaReact.rota,
+                        arquivo,
+                        simbolo: "router",
+                    });
+                    if (rotaReact.arquivoComponente) {
+                        const arquivoComponente = path.join(diretorio, rotaReact.arquivoComponente);
+                        consumerSurfaces.set(`${rotaReact.rota}:${arquivoComponente}:page`, {
+                            rota: rotaReact.rota,
+                            arquivo: arquivoComponente,
+                            tipoArquivo: "page",
+                        });
+                    }
+                }
+            }
+            if (arquivoEhRotasAngularConsumer(relacao) && (!usarApenasRotasAngularRaiz || arquivosRotasAngularRaiz.has(path.resolve(arquivo)))) {
+                for (const rotaAngular of await extrairRotasAngularConsumer(diretorio, relacao)) {
+                    const arquivoRotasAngular = path.join(diretorio, rotaAngular.arquivoRotas);
+                    consumerSurfaces.set(`${rotaAngular.rota}:${arquivoRotasAngular}:routes`, {
+                        rota: rotaAngular.rota,
+                        arquivo: arquivoRotasAngular,
+                        tipoArquivo: "routes",
+                    });
+                    rotas.push({
+                        origem: "angular-consumer",
+                        metodo: "VIEW",
+                        caminho: rotaAngular.rota,
+                        arquivo: arquivoRotasAngular,
+                        simbolo: rotaAngular.componente ?? "routes",
+                    });
+                    if (rotaAngular.arquivoComponente) {
+                        const arquivoComponente = path.join(diretorio, rotaAngular.arquivoComponente);
+                        consumerSurfaces.set(`${rotaAngular.rota}:${arquivoComponente}:component`, {
+                            rota: rotaAngular.rota,
+                            arquivo: arquivoComponente,
+                            tipoArquivo: "component",
+                        });
+                    }
+                }
+            }
             for (const node of sourceFile.statements) {
                 if (ts.isFunctionDeclaration(node) && node.name) {
                     registrarSimboloTypeScript(simbolos, basesSimbolicas, arquivo, node.name.text);
@@ -396,7 +815,14 @@ async function indexarTypeScript(diretorios) {
             }
         }
     }
-    return { simbolos: [...simbolos.values()], rotas, recursos: [...recursos.values()] };
+    return {
+        simbolos: [...simbolos.values()],
+        rotas,
+        recursos: [...recursos.values()],
+        consumerSurfaces: [...consumerSurfaces.values()].sort((a, b) => a.rota.localeCompare(b.rota, "pt-BR")
+            || a.tipoArquivo.localeCompare(b.tipoArquivo, "pt-BR")
+            || a.arquivo.localeCompare(b.arquivo, "pt-BR")),
+    };
 }
 function registrarSimboloPython(simbolos, basesSimbolicas, arquivo, nome, nomeClasse) {
     for (const baseSimbolica of basesSimbolicas) {
@@ -493,12 +919,15 @@ async function indexarPython(diretorios) {
 }
 async function indexarDart(diretorios) {
     const simbolos = new Map();
+    const rotas = [];
+    const consumerSurfaces = new Map();
     for (const diretorio of diretorios) {
         const arquivos = (await listarArquivosRecursivos(diretorio, [".dart"]))
             .filter((arquivo) => !arquivo.endsWith(".g.dart") && !arquivo.endsWith(".freezed.dart"));
         for (const arquivo of arquivos) {
             const texto = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
+            const relacao = path.relative(diretorio, arquivo);
             for (const match of texto.matchAll(/(?:Future<[^\n]+>|[\w?<>.,\s]+)\s+(\w+)\(([^)]*)\)\s*(?:async\s*)?\{/g)) {
                 const nome = match[1];
                 if (["build", "toString"].includes(nome)) {
@@ -509,9 +938,62 @@ async function indexarDart(diretorios) {
                     simbolos.set(caminho, { origem: "dart", caminho, arquivo, simbolo: nome });
                 }
             }
+            const superficieFlutter = inferirRotaFlutterConsumer(relacao);
+            if (superficieFlutter) {
+                consumerSurfaces.set(`${superficieFlutter.rota}:${arquivo}:${superficieFlutter.tipoArquivo}`, {
+                    rota: superficieFlutter.rota,
+                    arquivo,
+                    tipoArquivo: superficieFlutter.tipoArquivo,
+                });
+                rotas.push({
+                    origem: "flutter-consumer",
+                    metodo: "VIEW",
+                    caminho: superficieFlutter.rota,
+                    arquivo,
+                    simbolo: superficieFlutter.tipoArquivo,
+                });
+            }
+            if (arquivoEhRotasFlutterConsumer(relacao, texto)) {
+                for (const rotaFlutter of extrairRotasFlutterConsumer(relacao, texto)) {
+                    consumerSurfaces.set(`${rotaFlutter.rota}:${arquivo}:router`, {
+                        rota: rotaFlutter.rota,
+                        arquivo,
+                        tipoArquivo: "router",
+                    });
+                    rotas.push({
+                        origem: "flutter-consumer",
+                        metodo: "VIEW",
+                        caminho: rotaFlutter.rota,
+                        arquivo,
+                        simbolo: "router",
+                    });
+                }
+            }
         }
     }
-    return [...simbolos.values()];
+    return {
+        simbolos: [...simbolos.values()],
+        rotas,
+        consumerSurfaces: [...consumerSurfaces.values()].sort((a, b) => a.rota.localeCompare(b.rota, "pt-BR")
+            || a.tipoArquivo.localeCompare(b.tipoArquivo, "pt-BR")
+            || a.arquivo.localeCompare(b.arquivo, "pt-BR")),
+    };
+}
+async function indexarLua(diretorios) {
+    const simbolos = new Map();
+    for (const diretorio of diretorios) {
+        const arquivos = (await listarArquivosRecursivos(diretorio, [".lua"]))
+            .filter((arquivo) => !/(^|[\\/])(spec|specs|test|tests)([\\/]|$)/i.test(arquivo))
+            .filter((arquivo) => !/[_-](spec|test)\.lua$/i.test(arquivo));
+        for (const arquivo of arquivos) {
+            const texto = await readFile(arquivo, "utf8");
+            const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
+            for (const simbolo of extrairSimbolosLua(texto)) {
+                registrarSimboloGenerico(simbolos, "lua", basesSimbolicas, arquivo, simbolo.simbolo);
+            }
+        }
+    }
+    return { simbolos: [...simbolos.values()], rotas: [] };
 }
 function registrarSimboloGenerico(simbolos, origem, basesSimbolicas, arquivo, simbolo) {
     for (const baseSimbolica of basesSimbolicas) {
@@ -863,6 +1345,7 @@ export async function analisarDriftLegado(contexto) {
     const indexTs = await indexarTypeScript(contexto.diretoriosCodigo);
     const indexPy = await indexarPython(contexto.diretoriosCodigo);
     const indexDart = await indexarDart(contexto.diretoriosCodigo);
+    const indexLua = await indexarLua(contexto.diretoriosCodigo);
     const indexDotnet = await indexarDotnet(contexto.diretoriosCodigo);
     const indexJava = await indexarJava(contexto.diretoriosCodigo);
     const indexGo = await indexarGo(contexto.diretoriosCodigo);
@@ -871,7 +1354,8 @@ export async function analisarDriftLegado(contexto) {
     const todosSimbolos = [
         ...indexTs.simbolos,
         ...indexPy.simbolos,
-        ...indexDart,
+        ...indexDart.simbolos,
+        ...indexLua.simbolos,
         ...indexDotnet.simbolos,
         ...indexJava.simbolos,
         ...indexGo.simbolos,
@@ -881,7 +1365,8 @@ export async function analisarDriftLegado(contexto) {
     const mapaImpl = new Map([
         ...indexTs.simbolos.map((item) => [item.caminho, item]),
         ...indexPy.simbolos.map((item) => [item.caminho, item]),
-        ...indexDart.map((item) => [item.caminho, item]),
+        ...indexDart.simbolos.map((item) => [item.caminho, item]),
+        ...indexLua.simbolos.map((item) => [item.caminho, item]),
         ...indexDotnet.simbolos.map((item) => [item.caminho, item]),
         ...indexJava.simbolos.map((item) => [item.caminho, item]),
         ...indexGo.simbolos.map((item) => [item.caminho, item]),
@@ -892,6 +1377,7 @@ export async function analisarDriftLegado(contexto) {
     const todasRotasIndexadas = [
         ...indexTs.rotas,
         ...indexPy.rotas,
+        ...indexDart.rotas,
         ...indexDotnet.rotas,
         ...indexJava.rotas,
         ...indexGo.rotas,
@@ -1051,7 +1537,11 @@ export async function analisarDriftLegado(contexto) {
             if (!esperadas.length || !route.metodo || !route.caminho) {
                 continue;
             }
-            const encontradas = todasRotasIndexadas.filter((rotaResolvida) => esperadas.includes(rotaResolvida.origem));
+            const encontradas = todasRotasIndexadas.filter((rotaResolvida) => rotaResolvida.origem !== "nextjs-consumer"
+                && rotaResolvida.origem !== "react-vite-consumer"
+                && rotaResolvida.origem !== "angular-consumer"
+                && rotaResolvida.origem !== "flutter-consumer"
+                && esperadas.includes(rotaResolvida.origem));
             const combina = encontradas.some((rotaResolvida) => rotaResolvida.metodo === route.metodo
                 && normalizarCaminhoRota(rotaResolvida.caminho) === normalizarCaminhoRota(route.caminho));
             if (!combina) {
@@ -1197,9 +1687,30 @@ export async function analisarDriftLegado(contexto) {
                 resumo.lacunas.includes("vinculo_quebrado") ? "corrigir vinculos rastreaveis" : "",
             ].filter(Boolean))];
     }
+    const consumerSurfaces = [...indexTs.consumerSurfaces, ...indexDart.consumerSurfaces].sort((a, b) => a.rota.localeCompare(b.rota, "pt-BR")
+        || a.tipoArquivo.localeCompare(b.tipoArquivo, "pt-BR")
+        || a.arquivo.localeCompare(b.arquivo, "pt-BR"));
+    const consumerBridges = [...new Map([...indexTs.simbolos, ...indexDart.simbolos]
+            .filter((simbolo) => simboloEhBridgeConsumer(simbolo.caminho, simbolo.arquivo))
+            .map((simbolo) => [
+            `${simbolo.caminho}:${simbolo.arquivo}:${simbolo.simbolo}`,
+            {
+                caminho: simbolo.caminho,
+                arquivo: simbolo.arquivo,
+                simbolo: simbolo.simbolo,
+            },
+        ])).values()].sort((a, b) => a.caminho.localeCompare(b.caminho, "pt-BR")
+        || a.arquivo.localeCompare(b.arquivo, "pt-BR"));
+    const appRoutes = [...new Set(consumerSurfaces.map((surface) => surface.rota))]
+        .sort((a, b) => a.localeCompare(b, "pt-BR"));
+    const consumerFramework = inferirConsumerFrameworkPrincipal(contexto.fontesLegado, consumerSurfaces, consumerBridges);
     const payloadBase = {
         comando: "drift",
         sucesso: implsQuebrados.length === 0 && rotasDivergentes.length === 0 && recursosDivergentes.length === 0 && vinculosQuebrados.length === 0,
+        consumerFramework,
+        appRoutes,
+        consumerSurfaces,
+        consumerBridges,
         modulos: contexto.modulosSelecionados.map((item) => ({
             caminho: item.caminho,
             modulo: item.resultado.ir?.nome ?? item.resultado.modulo?.nome ?? null,