Initial commit for HF Space

.dockerignore

@@ -0,0 +1,8 @@
+.DS_Store
+**/.DS_Store
+**/__pycache__
+**/.pytest_cache
+**/.venv
+frontend/node_modules
+frontend/dist
+backend/.venv

.gitignore

@@ -0,0 +1,13 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.venv/
+
+# Node
+node_modules/
+frontend/dist/
+
+# System
+.DS_Store

Dockerfile

@@ -0,0 +1,47 @@
+FROM node:20-bookworm-slim AS frontend-builder
+
+WORKDIR /src/frontend
+
+COPY frontend/package*.json ./
+RUN npm ci
+
+COPY frontend/ ./
+ARG VITE_API_BASE=.
+ENV VITE_API_BASE=${VITE_API_BASE}
+RUN npm run build
+
+
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+      build-essential \
+      gdal-bin \
+      libgdal-dev \
+      libgeos-dev \
+      libproj-dev \
+      proj-bin \
+      proj-data \
+      libspatialindex-dev && \
+    rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app/backend
+
+COPY backend/requirements.txt ./
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+COPY backend/ ./
+COPY --from=frontend-builder /src/frontend/dist /app/frontend/dist
+
+RUN useradd -m -u 1000 user && \
+    chown -R user:user /app
+
+USER user
+
+EXPOSE 7860
+
+CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}"]

README.md

@@ -1,4 +1,5 @@
 ---
+<<<<<<< HEAD
 title: Mesa React
 emoji: 🌖
 colorFrom: purple
@@ -8,3 +9,70 @@ pinned: false
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+=======
+title: mesa-frame
+sdk: docker
+app_port: 7860
+---
+
+# MESA Frame (FastAPI + React)
+
+Rearquitetura do app MESA com:
+
+- `backend/` em FastAPI
+- `frontend/` em React (Vite)
+- Reuso do core estatistico e de negocio original (elaboracao + visualizacao)
+
+## Estrutura
+
+- `backend/app/main.py`: inicializacao da API
+- `backend/app/api/`: rotas de sessao, elaboracao e visualizacao
+- `backend/app/services/`: orquestracao dos fluxos
+- `backend/app/core/elaboracao`: core de elaboracao reaproveitado
+- `backend/app/core/visualizacao`: core de visualizacao reaproveitado
+- `frontend/src`: interface React
+
+## Backend
+
+```bash
+cd backend
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+./run_backend.sh
+```
+
+API: `http://localhost:8000`
+Swagger: `http://localhost:8000/docs`
+
+## Frontend
+
+```bash
+cd frontend
+npm install
+npm run dev
+```
+
+Frontend: `http://localhost:5173`
+
+Para apontar para outro backend:
+
+```bash
+VITE_API_BASE=http://localhost:8000 npm run dev
+```
+
+## Funcionalidades cobertas
+
+- Upload CSV/Excel/.dai
+- Selecao de aba Excel
+- Mapeamento manual de coordenadas
+- Geocodificacao e correcoes
+- Selecao de variaveis Y/X
+- Busca/adocao de transformacoes
+- Ajuste de modelo OLS e diagnosticos
+- Filtros, iteracao e historico de outliers
+- Avaliacao individual e exportacao de avaliacoes
+- Exportacao de modelo `.dai` e base `.csv`
+- Visualizacao completa de modelo salvo `.dai`
+- Avaliacao individual na aba de visualizacao
+>>>>>>> 6e64df9 (Initial commit for HF Space)

backend/app/__init__.py

@@ -0,0 +1 @@
+# App package

backend/app/api/__init__.py

@@ -0,0 +1 @@
+# API routers package

backend/app/api/elaboracao.py

@@ -0,0 +1,341 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from fastapi import APIRouter, File, Form, UploadFile
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field
+
+from app.services import elaboracao_service
+from app.services.session_store import session_store
+
+
+router = APIRouter(prefix="/api/elaboracao", tags=["elaboracao"])
+
+
+class SessionPayload(BaseModel):
+    session_id: str
+
+
+class ConfirmSheetPayload(SessionPayload):
+    sheet_name: str
+
+
+class MapCoordsPayload(SessionPayload):
+    col_lat: str
+    col_lon: str
+
+
+class GeocodePayload(SessionPayload):
+    col_cdlog: str
+    col_num: str
+    auto_200: bool = False
+
+
+class CorrecaoGeo(BaseModel):
+    linha: int
+    numero_corrigido: str | None = None
+
+
+class GeocodeCorrecaoPayload(SessionPayload):
+    correcoes: list[CorrecaoGeo] = Field(default_factory=list)
+    auto_200: bool = False
+
+
+class ApplySelectionPayload(SessionPayload):
+    coluna_y: str
+    colunas_x: list[str]
+    dicotomicas: list[str] = Field(default_factory=list)
+    codigo_alocado: list[str] = Field(default_factory=list)
+    percentuais: list[str] = Field(default_factory=list)
+    outliers_anteriores: list[int] = Field(default_factory=list)
+    grau_min_coef: int = 1
+    grau_min_f: int = 0
+
+
+class ClassificarXPayload(SessionPayload):
+    colunas_x: list[str] = Field(default_factory=list)
+
+
+class SearchTransformPayload(SessionPayload):
+    grau_min_coef: int = 1
+    grau_min_f: int = 0
+
+
+class AdoptSuggestionPayload(SessionPayload):
+    indice: int
+
+
+class FitModelPayload(SessionPayload):
+    transformacao_y: str
+    transformacoes_x: dict[str, str] = Field(default_factory=dict)
+    dicotomicas: list[str] = Field(default_factory=list)
+    codigo_alocado: list[str] = Field(default_factory=list)
+    percentuais: list[str] = Field(default_factory=list)
+
+
+class DispersaoPayload(SessionPayload):
+    tipo: str
+
+
+class OutlierFiltro(BaseModel):
+    variavel: str
+    operador: str
+    valor: float
+
+
+class OutlierFilterPayload(SessionPayload):
+    filtros: list[OutlierFiltro] = Field(default_factory=list)
+
+
+class OutlierRestartPayload(SessionPayload):
+    outliers_texto: str | None = None
+    reincluir_texto: str | None = None
+    grau_min_coef: int = 3
+    grau_min_f: int = 3
+
+
+class OutlierSummaryPayload(SessionPayload):
+    outliers_texto: str | None = None
+    reincluir_texto: str | None = None
+
+
+class AvaliacaoPayload(SessionPayload):
+    valores_x: dict[str, Any]
+    indice_base: str | None = None
+
+
+class AvaliacaoDeletePayload(SessionPayload):
+    indice: str | None = None
+    indice_base: str | None = None
+
+
+class AvaliacaoBasePayload(SessionPayload):
+    indice_base: str | None = None
+
+
+class ExportModeloPayload(SessionPayload):
+    nome_arquivo: str
+    elaborador: dict[str, Any] | None = None
+
+
+class UpdateMapaPayload(SessionPayload):
+    variavel_mapa: str | None = None
+
+
+@router.post("/upload")
+async def upload_file(
+    session_id: str = Form(...),
+    file: UploadFile = File(...),
+) -> dict[str, Any]:
+    session = session_store.get(session_id)
+    conteudo = await file.read()
+    elaboracao_service.save_uploaded_file(session, file.filename, conteudo)
+    return elaboracao_service.load_uploaded_file(session)
+
+
+@router.post("/confirm-sheet")
+def confirm_sheet(payload: ConfirmSheetPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.load_uploaded_file(session, selected_sheet=payload.sheet_name)
+
+
+@router.post("/map-coords")
+def map_coords(payload: MapCoordsPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.mapear_coordenadas_manualmente(session, payload.col_lat, payload.col_lon)
+
+
+@router.post("/geocodificar")
+def geocodificar(payload: GeocodePayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.geocodificar(session, payload.col_cdlog, payload.col_num, auto_200=payload.auto_200)
+
+
+@router.post("/geocodificar-correcoes")
+def geocodificar_correcoes(payload: GeocodeCorrecaoPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    correcoes = [item.model_dump() for item in payload.correcoes]
+    return elaboracao_service.aplicar_correcoes_geocodificacao(session, correcoes, auto_200=payload.auto_200)
+
+
+@router.post("/apply-selection")
+def apply_selection(payload: ApplySelectionPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.apply_selection(
+        session,
+        coluna_y=payload.coluna_y,
+        colunas_x=payload.colunas_x,
+        dicotomicas=payload.dicotomicas,
+        codigo_alocado=payload.codigo_alocado,
+        percentuais=payload.percentuais,
+        outliers_anteriores=payload.outliers_anteriores,
+        grau_min_coef=payload.grau_min_coef,
+        grau_min_f=payload.grau_min_f,
+    )
+
+
+@router.post("/classify-x")
+def classify_x(payload: ClassificarXPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.classificar_tipos_variaveis_x(session, payload.colunas_x)
+
+
+@router.post("/search-transformations")
+def search_transformations(payload: SearchTransformPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.search_transformacoes(
+        session,
+        grau_min_coef=payload.grau_min_coef,
+        grau_min_f=payload.grau_min_f,
+    )
+
+
+@router.post("/adopt-suggestion")
+def adopt_suggestion(payload: AdoptSuggestionPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.adotar_sugestao(session, payload.indice)
+
+
+@router.post("/fit-model")
+def fit_model(payload: FitModelPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.fit_model(
+        session,
+        transformacao_y=payload.transformacao_y,
+        transformacoes_x=payload.transformacoes_x,
+        dicotomicas=payload.dicotomicas,
+        codigo_alocado=payload.codigo_alocado,
+        percentuais=payload.percentuais,
+    )
+
+
+@router.post("/model-dispersao")
+def model_dispersao(payload: DispersaoPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.gerar_grafico_dispersao_modelo(session, payload.tipo)
+
+
+@router.post("/outliers/apply-filters")
+def outliers_apply_filters(payload: OutlierFilterPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    filtros = [item.model_dump() for item in payload.filtros]
+    return elaboracao_service.apply_outlier_filters(session, filtros)
+
+
+@router.post("/outliers/restart")
+def outliers_restart(payload: OutlierRestartPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.reiniciar_iteracao(
+        session,
+        outliers_texto=payload.outliers_texto,
+        reincluir_texto=payload.reincluir_texto,
+        grau_min_coef=payload.grau_min_coef,
+        grau_min_f=payload.grau_min_f,
+    )
+
+
+@router.post("/outliers/summary")
+def outliers_summary(payload: OutlierSummaryPayload) -> dict[str, str]:
+    session = session_store.get(payload.session_id)
+    texto = elaboracao_service.resumir_outliers(
+        session.outliers_anteriores,
+        payload.outliers_texto,
+        payload.reincluir_texto,
+    )
+    return {"resumo": texto}
+
+
+@router.post("/outliers/clear-history")
+def outliers_clear_history(payload: SessionPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.limpar_historico_outliers(session)
+
+
+@router.post("/evaluation/fields")
+def evaluation_fields(payload: SessionPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return {"campos": elaboracao_service.build_campos_avaliacao(session)}
+
+
+@router.post("/evaluation/calculate")
+def evaluation_calculate(payload: AvaliacaoPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.calcular_avaliacao_elaboracao(session, payload.valores_x, payload.indice_base)
+
+
+@router.post("/evaluation/clear")
+def evaluation_clear(payload: SessionPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.limpar_avaliacoes_elaboracao(session)
+
+
+@router.post("/evaluation/delete")
+def evaluation_delete(payload: AvaliacaoDeletePayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.excluir_avaliacao_elaboracao(session, payload.indice, payload.indice_base)
+
+
+@router.post("/evaluation/base")
+def evaluation_base(payload: AvaliacaoBasePayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.atualizar_base_avaliacao_elaboracao(session, payload.indice_base)
+
+
+@router.get("/evaluation/export")
+def evaluation_export(session_id: str) -> FileResponse:
+    session = session_store.get(session_id)
+    caminho = elaboracao_service.exportar_avaliacoes_elaboracao(session)
+    return FileResponse(
+        path=caminho,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        filename=os.path.basename(caminho),
+    )
+
+
+@router.get("/avaliadores")
+def listar_avaliadores() -> dict[str, Any]:
+    return {"avaliadores": elaboracao_service.list_avaliadores()}
+
+
+@router.post("/export-model")
+def export_model(payload: ExportModeloPayload) -> FileResponse:
+    session = session_store.get(payload.session_id)
+    caminho, _ = elaboracao_service.exportar_modelo(session, payload.nome_arquivo, elaborador=payload.elaborador)
+    return FileResponse(
+        path=caminho,
+        media_type="application/octet-stream",
+        filename=os.path.basename(caminho),
+    )
+
+
+@router.get("/export-base")
+def export_base(session_id: str, filtered: bool = True) -> FileResponse:
+    session = session_store.get(session_id)
+    caminho = elaboracao_service.exportar_base(session, usar_filtrado=filtered)
+    return FileResponse(
+        path=caminho,
+        media_type="text/csv",
+        filename=os.path.basename(caminho),
+    )
+
+
+@router.post("/map/update")
+def map_update(payload: UpdateMapaPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return elaboracao_service.atualizar_mapa(session, payload.variavel_mapa)
+
+
+@router.get("/context")
+def context(session_id: str) -> dict[str, Any]:
+    session = session_store.get(session_id)
+    return {
+        "coluna_y": session.coluna_y,
+        "colunas_x": session.colunas_x,
+        "dicotomicas": session.dicotomicas,
+        "codigo_alocado": session.codigo_alocado,
+        "percentuais": session.percentuais,
+        "outliers_anteriores": session.outliers_anteriores,
+        "iteracao": session.iteracao,
+    }

backend/app/api/health.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+
+router = APIRouter(tags=["health"])
+
+
+@router.get("/api/health")
+def health() -> dict[str, str]:
+    return {"status": "ok"}

backend/app/api/session.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+from app.services.session_store import session_store
+
+
+router = APIRouter(prefix="/api/sessions", tags=["sessions"])
+
+
+@router.post("")
+def create_session() -> dict[str, str]:
+    session = session_store.create()
+    return {"session_id": session.session_id}
+
+
+@router.delete("/{session_id}")
+def delete_session(session_id: str) -> dict[str, str]:
+    session_store.delete(session_id)
+    return {"status": "ok"}

backend/app/api/visualizacao.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from fastapi import APIRouter, File, Form, UploadFile
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+
+from app.services import elaboracao_service, visualizacao_service
+from app.services.session_store import session_store
+
+
+router = APIRouter(prefix="/api/visualizacao", tags=["visualizacao"])
+
+
+class SessionPayload(BaseModel):
+    session_id: str
+
+
+class MapaPayload(SessionPayload):
+    variavel_mapa: str | None = None
+
+
+class AvaliacaoPayload(SessionPayload):
+    valores_x: dict[str, Any]
+    indice_base: str | None = None
+
+
+class AvaliacaoDeletePayload(SessionPayload):
+    indice: str | None = None
+    indice_base: str | None = None
+
+
+class AvaliacaoBasePayload(SessionPayload):
+    indice_base: str | None = None
+
+
+@router.post("/upload")
+async def upload_file(
+    session_id: str = Form(...),
+    file: UploadFile = File(...),
+) -> dict[str, Any]:
+    session = session_store.get(session_id)
+    conteudo = await file.read()
+    caminho = elaboracao_service.save_uploaded_file(session, file.filename, conteudo)
+    return visualizacao_service.carregar_modelo(session, caminho)
+
+
+@router.post("/exibir")
+def exibir(payload: SessionPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return visualizacao_service.exibir_modelo(session)
+
+
+@router.post("/map/update")
+def map_update(payload: MapaPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return visualizacao_service.atualizar_mapa(session, payload.variavel_mapa)
+
+
+@router.post("/evaluation/fields")
+def evaluation_fields(payload: SessionPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return {"campos": visualizacao_service.campos_avaliacao(session)}
+
+
+@router.post("/evaluation/calculate")
+def evaluation_calculate(payload: AvaliacaoPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return visualizacao_service.calcular_avaliacao(session, payload.valores_x, payload.indice_base)
+
+
+@router.post("/evaluation/clear")
+def evaluation_clear(payload: SessionPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return visualizacao_service.limpar_avaliacoes(session)
+
+
+@router.post("/evaluation/delete")
+def evaluation_delete(payload: AvaliacaoDeletePayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return visualizacao_service.excluir_avaliacao(session, payload.indice, payload.indice_base)
+
+
+@router.post("/evaluation/base")
+def evaluation_base(payload: AvaliacaoBasePayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return visualizacao_service.atualizar_base(session, payload.indice_base)
+
+
+@router.get("/evaluation/export")
+def evaluation_export(session_id: str) -> FileResponse:
+    session = session_store.get(session_id)
+    caminho = visualizacao_service.exportar_avaliacoes(session)
+    return FileResponse(
+        path=caminho,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        filename=os.path.basename(caminho),
+    )
+
+
+@router.post("/clear")
+def clear(payload: SessionPayload) -> dict[str, Any]:
+    session = session_store.get(payload.session_id)
+    return visualizacao_service.limpar_tudo_visualizacao(session)

backend/app/core/dados/EixosLogradouros.cpg

@@ -0,0 +1 @@
+UTF-8

backend/app/core/dados/EixosLogradouros.dbf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf668c9b7bbcac420d23188cfb3101b7dcee2bc4b4873b8220d73afd4257f4f6
+size 6432720

backend/app/core/dados/EixosLogradouros.prj

@@ -0,0 +1 @@
+PROJCS["TM-POA",GEOGCS["GCS_SIRGAS_2000",DATUM["D_SIRGAS_2000",SPHEROID["GRS_1980",6378137.0,298.257222101]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]],PROJECTION["Transverse_Mercator"],PARAMETER["False_Easting",300000.0],PARAMETER["False_Northing",5000000.0],PARAMETER["Central_Meridian",-51.0],PARAMETER["Scale_Factor",0.999995],PARAMETER["Latitude_Of_Origin",0.0],UNIT["Meter",1.0]]

backend/app/core/dados/EixosLogradouros.shp

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:718687b7eff9723d63eee89749c7a338a7fe00c1cae4cb8bc952f967d5b47d23
+size 10248444

backend/app/core/dados/EixosLogradouros.shp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<metadata xml:lang="pt"><Esri><CreaDate>20241119</CreaDate><CreaTime>11233400</CreaTime><ArcGISFormat>1.0</ArcGISFormat><SyncOnce>FALSE</SyncOnce><DataProperties><itemProps><itemName Sync="TRUE">EixosLogradouros</itemName><imsContentType Sync="TRUE">002</imsContentType><itemSize Sync="TRUE">0.000</itemSize><itemLocation><linkage Sync="TRUE">file://\\pmpa-fs3\smams-usig$\Publicação Site PDDUA\PDDUA_shp\EixoLogradouro\EixosLogradouros.shp</linkage><protocol Sync="TRUE">Local Area Network</protocol></itemLocation></itemProps><coordRef><type Sync="TRUE">Projected</type><geogcsn Sync="TRUE">GCS_SIRGAS_2000</geogcsn><csUnits Sync="TRUE">Linear Unit: Meter (1.000000)</csUnits><projcsn Sync="TRUE">TM-POA</projcsn><peXml Sync="TRUE">&lt;ProjectedCoordinateSystem xsi:type='typens:ProjectedCoordinateSystem' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:typens='http://www.esri.com/schemas/ArcGIS/10.7'&gt;&lt;WKT&gt;PROJCS[&amp;quot;TM-POA&amp;quot;,GEOGCS[&amp;quot;GCS_SIRGAS_2000&amp;quot;,DATUM[&amp;quot;D_SIRGAS_2000&amp;quot;,SPHEROID[&amp;quot;GRS_1980&amp;quot;,6378137.0,298.257222101]],PRIMEM[&amp;quot;Greenwich&amp;quot;,0.0],UNIT[&amp;quot;Degree&amp;quot;,0.0174532925199433]],PROJECTION[&amp;quot;Transverse_Mercator&amp;quot;],PARAMETER[&amp;quot;False_Easting&amp;quot;,300000.0],PARAMETER[&amp;quot;False_Northing&amp;quot;,5000000.0],PARAMETER[&amp;quot;Central_Meridian&amp;quot;,-51.0],PARAMETER[&amp;quot;Scale_Factor&amp;quot;,0.999995],PARAMETER[&amp;quot;Latitude_Of_Origin&amp;quot;,0.0],UNIT[&amp;quot;Meter&amp;quot;,1.0]]&lt;/WKT&gt;&lt;XOrigin&gt;-5323100&lt;/XOrigin&gt;&lt;YOrigin&gt;-5002100&lt;/YOrigin&gt;&lt;XYScale&gt;450265407.00157917&lt;/XYScale&gt;&lt;ZOrigin&gt;-100000&lt;/ZOrigin&gt;&lt;ZScale&gt;10000&lt;/ZScale&gt;&lt;MOrigin&gt;-100000&lt;/MOrigin&gt;&lt;MScale&gt;10000&lt;/MScale&gt;&lt;XYTolerance&gt;0.001&lt;/XYTolerance&gt;&lt;ZTolerance&gt;0.001&lt;/ZTolerance&gt;&lt;MTolerance&gt;0.001&lt;/MTolerance&gt;&lt;HighPrecision&gt;true&lt;/HighPrecision&gt;&lt;/ProjectedCoordinateSystem&gt;</peXml></coordRef><lineage><Process ToolSource="c:\program files (x86)\arcgis\desktop10.7\ArcToolbox\Toolboxes\Conversion Tools.tbx\FeatureClassToFeatureClass" Date="20241119" Time="112349">FeatureClassToFeatureClass "Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV" "Y:\Publicação Site PDDUA\PDDUA_shp\EixoLogradouro" EixosLogradouros.shp # "CDLOG "CDLOG" true true false 4 Long 0 7 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,CDLOG,-1,-1;CDSEG "CDSEG" true true false 4 Long 0 6 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,CDSEG,-1,-1;NRIMPINI "NRIMPINI" true true false 4 Long 0 5 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,NRIMPINI,-1,-1;NRIMPFIN "NRIMPFIN" true true false 4 Long 0 5 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,NRIMPFIN,-1,-1;NRPARINI "NRPARINI" true true false 4 Long 0 5 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,NRPARINI,-1,-1;NRPARFIN "NRPARFIN" true true false 4 Long 0 5 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,NRPARFIN,-1,-1;MTORIGEM "MTORIGEM" true true false 20 Text 0 0 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,MTORIGEM,-1,-1;MTQUAL "MTQUAL" true true false 10 Text 0 0 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,MTQUAL,-1,-1;CDTIPO "CDTIPO" true true false 2 Short 0 2 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,CDTIPO,-1,-1;MTVETOR "MTVETOR" true true false 26 Text 0 0 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,MTVETOR,-1,-1;FGCOMP "FGCOMP" true true false 8 Double 2 13 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,FGCOMP,-1,-1;SEL "SEL" true true false 2 Short 0 2 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,SEL,-1,-1;LABEL "LABEL" true true false 2 Short 0 4 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,LABEL,-1,-1;CDIDELOG "CDIDELOG" true false false 4 Long 0 7 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,CDIDELOG,-1,-1;NMIDELOG "NMIDELOG" true false false 37 Text 0 0 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,NMIDELOG,-1,-1;CDIDECAT "CDIDECAT" true false false 5 Text 0 0 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,CDIDECAT,-1,-1;NMIDEPRE "NMIDEPRE" true false false 3 Text 0 0 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,NMIDEPRE,-1,-1;NMIDEABR "NMIDEABR" true false false 16 Text 0 0 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,NMIDEABR,-1,-1;GEOM_LEN "GEOM_LEN" false false true 0 Double 0 0 ,First,#,Database Connections\GEOEIXOS.sde\GEOSMURB.EIXOS_CONV_VIEW\GEOSMURB.EIXOS_VIEW_CONV,GEOM.LEN,-1,-1" #</Process></lineage></DataProperties><SyncDate>20241119</SyncDate><SyncTime>11233400</SyncTime><ModDate>20241119</ModDate><ModTime>11233400</ModTime></Esri><dataIdInfo><envirDesc Sync="TRUE"> Version 6.2 (Build 9200) ; Esri ArcGIS 10.7.0.10348</envirDesc><dataLang><languageCode value="por" Sync="TRUE"></languageCode><countryCode value="BRA" Sync="TRUE"></countryCode></dataLang><idCitation><resTitle Sync="TRUE">EixosLogradouros</resTitle><presForm><PresFormCd value="005" Sync="TRUE"></PresFormCd></presForm></idCitation><spatRpType><SpatRepTypCd value="001" Sync="TRUE"></SpatRepTypCd></spatRpType></dataIdInfo><mdLang><languageCode value="por" Sync="TRUE"></languageCode><countryCode value="BRA" Sync="TRUE"></countryCode></mdLang><mdChar><CharSetCd value="004" Sync="TRUE"></CharSetCd></mdChar><distInfo><distFormat><formatName Sync="TRUE">Shapefile</formatName></distFormat><distTranOps><transSize Sync="TRUE">0.000</transSize></distTranOps></distInfo><mdHrLv><ScopeCd value="005" Sync="TRUE"></ScopeCd></mdHrLv><mdHrLvName Sync="TRUE">dataset</mdHrLvName><refSysInfo><RefSystem><refSysID><identCode code="0" Sync="TRUE"></identCode></refSysID></RefSystem></refSysInfo><spatRepInfo><VectSpatRep><geometObjs Name="EixosLogradouros"><geoObjTyp><GeoObjTypCd value="002" Sync="TRUE"></GeoObjTypCd></geoObjTyp><geoObjCnt Sync="TRUE">0</geoObjCnt></geometObjs><topLvl><TopoLevCd value="001" Sync="TRUE"></TopoLevCd></topLvl></VectSpatRep></spatRepInfo><spdoinfo><ptvctinf><esriterm Name="EixosLogradouros"><efeatyp Sync="TRUE">Simple</efeatyp><efeageom code="3" Sync="TRUE"></efeageom><esritopo Sync="TRUE">FALSE</esritopo><efeacnt Sync="TRUE">0</efeacnt><spindex Sync="TRUE">FALSE</spindex><linrefer Sync="TRUE">FALSE</linrefer></esriterm></ptvctinf></spdoinfo><eainfo><detailed Name="EixosLogradouros"><enttyp><enttypl Sync="TRUE">EixosLogradouros</enttypl><enttypt Sync="TRUE">Feature Class</enttypt><enttypc Sync="TRUE">0</enttypc></enttyp><attr><attrlabl Sync="TRUE">FID</attrlabl><attalias Sync="TRUE">FID</attalias><attrtype Sync="TRUE">OID</attrtype><attwidth Sync="TRUE">4</attwidth><atprecis Sync="TRUE">0</atprecis><attscale Sync="TRUE">0</attscale><attrdef Sync="TRUE">Internal feature number.</attrdef><attrdefs Sync="TRUE">Esri</attrdefs><attrdomv><udom Sync="TRUE">Sequential unique whole numbers that are automatically generated.</udom></attrdomv></attr><attr><attrlabl Sync="TRUE">Shape</attrlabl><attalias Sync="TRUE">Shape</attalias><attrtype Sync="TRUE">Geometry</attrtype><attwidth Sync="TRUE">0</attwidth><atprecis Sync="TRUE">0</atprecis><attscale Sync="TRUE">0</attscale><attrdef Sync="TRUE">Feature geometry.</attrdef><attrdefs Sync="TRUE">Esri</attrdefs><attrdomv><udom Sync="TRUE">Coordinates defining the features.</udom></attrdomv></attr><attr><attrlabl Sync="TRUE">CDLOG</attrlabl><attalias Sync="TRUE">CDLOG</attalias><attrtype Sync="TRUE">Integer</attrtype><attwidth Sync="TRUE">7</attwidth><atprecis Sync="TRUE">7</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">CDSEG</attrlabl><attalias Sync="TRUE">CDSEG</attalias><attrtype Sync="TRUE">Integer</attrtype><attwidth Sync="TRUE">6</attwidth><atprecis Sync="TRUE">6</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">NRIMPINI</attrlabl><attalias Sync="TRUE">NRIMPINI</attalias><attrtype Sync="TRUE">Integer</attrtype><attwidth Sync="TRUE">5</attwidth><atprecis Sync="TRUE">5</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">NRIMPFIN</attrlabl><attalias Sync="TRUE">NRIMPFIN</attalias><attrtype Sync="TRUE">Integer</attrtype><attwidth Sync="TRUE">5</attwidth><atprecis Sync="TRUE">5</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">NRPARINI</attrlabl><attalias Sync="TRUE">NRPARINI</attalias><attrtype Sync="TRUE">Integer</attrtype><attwidth Sync="TRUE">5</attwidth><atprecis Sync="TRUE">5</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">NRPARFIN</attrlabl><attalias Sync="TRUE">NRPARFIN</attalias><attrtype Sync="TRUE">Integer</attrtype><attwidth Sync="TRUE">5</attwidth><atprecis Sync="TRUE">5</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">MTORIGEM</attrlabl><attalias Sync="TRUE">MTORIGEM</attalias><attrtype Sync="TRUE">String</attrtype><attwidth Sync="TRUE">20</attwidth><atprecis Sync="TRUE">0</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">MTQUAL</attrlabl><attalias Sync="TRUE">MTQUAL</attalias><attrtype Sync="TRUE">String</attrtype><attwidth Sync="TRUE">10</attwidth><atprecis Sync="TRUE">0</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">CDTIPO</attrlabl><attalias Sync="TRUE">CDTIPO</attalias><attrtype Sync="TRUE">SmallInteger</attrtype><attwidth Sync="TRUE">2</attwidth><atprecis Sync="TRUE">2</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">MTVETOR</attrlabl><attalias Sync="TRUE">MTVETOR</attalias><attrtype Sync="TRUE">String</attrtype><attwidth Sync="TRUE">26</attwidth><atprecis Sync="TRUE">0</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">FGCOMP</attrlabl><attalias Sync="TRUE">FGCOMP</attalias><attrtype Sync="TRUE">Double</attrtype><attwidth Sync="TRUE">14</attwidth><atprecis Sync="TRUE">13</atprecis><attscale Sync="TRUE">2</attscale></attr><attr><attrlabl Sync="TRUE">SEL</attrlabl><attalias Sync="TRUE">SEL</attalias><attrtype Sync="TRUE">SmallInteger</attrtype><attwidth Sync="TRUE">2</attwidth><atprecis Sync="TRUE">2</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">LABEL</attrlabl><attalias Sync="TRUE">LABEL</attalias><attrtype Sync="TRUE">SmallInteger</attrtype><attwidth Sync="TRUE">4</attwidth><atprecis Sync="TRUE">4</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">CDIDELOG</attrlabl><attalias Sync="TRUE">CDIDELOG</attalias><attrtype Sync="TRUE">Integer</attrtype><attwidth Sync="TRUE">7</attwidth><atprecis Sync="TRUE">7</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">NMIDELOG</attrlabl><attalias Sync="TRUE">NMIDELOG</attalias><attrtype Sync="TRUE">String</attrtype><attwidth Sync="TRUE">37</attwidth><atprecis Sync="TRUE">0</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">CDIDECAT</attrlabl><attalias Sync="TRUE">CDIDECAT</attalias><attrtype Sync="TRUE">String</attrtype><attwidth Sync="TRUE">5</attwidth><atprecis Sync="TRUE">0</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">NMIDEPRE</attrlabl><attalias Sync="TRUE">NMIDEPRE</attalias><attrtype Sync="TRUE">String</attrtype><attwidth Sync="TRUE">3</attwidth><atprecis Sync="TRUE">0</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">NMIDEABR</attrlabl><attalias Sync="TRUE">NMIDEABR</attalias><attrtype Sync="TRUE">String</attrtype><attwidth Sync="TRUE">16</attwidth><atprecis Sync="TRUE">0</atprecis><attscale Sync="TRUE">0</attscale></attr><attr><attrlabl Sync="TRUE">GEOM_LEN</attrlabl><attalias Sync="TRUE">GEOM_LEN</attalias><attrtype Sync="TRUE">Double</attrtype><attwidth Sync="TRUE">19</attwidth><atprecis Sync="TRUE">0</atprecis><attscale Sync="TRUE">0</attscale></attr></detailed></eainfo><mdDateSt Sync="TRUE">20241119</mdDateSt></metadata>

backend/app/core/dados/EixosLogradouros.shx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee0d38b37aba5823e51880dbcf6244c881397fa0e92b765806a28472388f36c1
+size 258676

backend/app/core/elaboracao/app.py

@@ -0,0 +1,1910 @@
+# -*- coding: utf-8 -*-
+"""
+app.py - Interface Gradio para elaboração de modelos estatísticos.
+
+Contém criar_aba() (construção de UI + event wiring) e callbacks auxiliares pequenos.
+Lógica de negócio delegada a módulos: modelo.py, carregamento.py, outliers.py, formatadores.py.
+"""
+
+import gradio as gr
+import pandas as pd
+import os
+import json
+
+_avaliadores_path = os.path.join(os.path.dirname(__file__), "avaliadores.json")
+with open(_avaliadores_path, encoding="utf-8") as _f:
+    _avaliadores_raw = json.load(_f)
+_avaliadores_lista = _avaliadores_raw.get("avaliadores", [])
+_avaliadores_nomes = [a["nome_completo"] for a in _avaliadores_lista]
+_avaliadores_dict = {a["nome_completo"]: a for a in _avaliadores_lista}
+
+# Módulos locais — lógica de negócio
+from .core import (
+    obter_colunas_numericas,
+    exportar_base_csv,
+    TRANSFORMACOES,
+)
+from .charts import criar_mapa
+
+# Módulos locais — formatação
+from .formatadores import TITULO, carregar_css, criar_header_secao
+
+# Módulos locais — callbacks de domínio
+from .modelo import (
+    MAX_VARS_X,
+    ao_mudar_tipo_grafico,
+    ao_mudar_y_sem_estatisticas,
+    aplicar_selecao_callback,
+    buscar_transformacoes_callback,
+    ajustar_modelo_callback,
+    _atualizar_campos_transformacoes_com_flag,
+    adotar_sugestao,
+    exportar_modelo_callback,
+    popular_campos_avaliacao_callback,
+    avaliar_imovel_callback,
+    limpar_avaliacoes_callback,
+    excluir_avaliacao_callback,
+    atualizar_base_avaliacao_callback,
+    exportar_avaliacoes_excel_callback,
+    atualizar_interativo_dicotomicas,
+    popular_dicotomicas_callback,
+)
+from .carregamento import (
+    ao_carregar_arquivo,
+    confirmar_aba_callback,
+    limpar_historico_callback,
+)
+from .geocodificacao import (
+    padronizar_coords,
+    geocodificar,
+    aplicar_correcoes_e_regeodificar,
+    formatar_status_geocodificacao,
+    preparar_display_falhas,
+)
+from .outliers import (
+    aplicar_filtros_callback,
+    adicionar_filtro_callback,
+    remover_ultimo_filtro_callback,
+    limpar_filtros_callback,
+    reiniciar_iteracao_callback,
+    atualizar_resumo_outliers,
+)
+
+
+# ============================================================
+# CALLBACKS AUXILIARES (pequenos, diretamente ligados ao event wiring)
+# ============================================================
+
+def download_tabela_callback(df, prefixo="tabela"):
+    """Callback genérico para download de DataFrame como CSV."""
+    if df is None:
+        return gr.update(value=None, visible=False)
+
+    try:
+        import tempfile
+
+        if isinstance(df, pd.DataFrame):
+            if df.empty:
+                return gr.update(value=None, visible=False)
+
+            fd, caminho = tempfile.mkstemp(suffix=".csv", prefix=f"{prefixo}_")
+            os.close(fd)
+            df.to_csv(caminho, index=True, encoding="utf-8-sig", sep=";", decimal=",")
+            return gr.update(value=caminho, visible=True)
+        else:
+            return gr.update(value=None, visible=False)
+    except Exception as e:
+        print(f"Erro ao exportar tabela: {e}")
+        return gr.update(value=None, visible=False)
+
+
+def _extrair_var_mapa(var_mapa):
+    """Retorna None se for 'Visualização Padrão' ou vazio, senão retorna o nome da variável."""
+    if not var_mapa or var_mapa == "Visualização Padrão":
+        return None
+    return var_mapa
+
+
+def ao_clicar_tabela(df, var_mapa, evt: gr.SelectData):
+    """Callback quando clica em linha da tabela."""
+    if df is None or evt is None:
+        return "<p>Carregue dados para ver o mapa.</p>"
+
+    # Pega o índice da linha clicada
+    indice = evt.index[0] + 1  # Ajusta para índice baseado em 1
+
+    return criar_mapa(df, indice_destacado=indice, tamanho_col=_extrair_var_mapa(var_mapa))
+
+
+def atualizar_mapa_callback(df_filtrado, df_original, var_mapa):
+    """Callback quando a variável de dimensionamento do mapa é alterada."""
+    df = df_filtrado if df_filtrado is not None else df_original
+    if df is None:
+        return "<p>Carregue dados para ver o mapa.</p>"
+    return criar_mapa(df, tamanho_col=_extrair_var_mapa(var_mapa))
+
+
+MAX_FALHAS_GEO = 20  # Slots pré-alocados para correção individual de falhas de geocodificação
+
+# ============================================================
+# CALLBACKS DE RESOLUÇÃO DE COORDENADAS (Seção 1 — painel lat/lon)
+# ============================================================
+
+def _revelar_secao_2(df, mapa):
+    """Retorna os 9 valores comuns a todos os callbacks de resolução de coords."""
+    from datetime import datetime, timezone, timedelta
+    gmt_minus_3 = timezone(timedelta(hours=-3))
+    ts = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
+    return (
+        df,                                                                        # estado_df
+        df,                                                                        # estado_df_filtrado
+        mapa,                                                                      # mapa_html
+        gr.update(visible=False),                                                  # row_coords_panel
+        gr.update(visible=True, value=criar_header_secao(2, "Visualizar Dados", ts)),  # header_secao_2
+        gr.update(visible=True, open=True),                                        # accordion_secao_2
+        gr.update(visible=True),                                                   # header_secao_3
+        gr.update(visible=True, open=True),                                        # accordion_secao_3
+    )
+
+
+def confirmar_mapeamento_callback(df, col_lat, col_lon):
+    """Opção 1: copia col_lat → 'lat' e col_lon → 'lon', libera Seção 2.
+
+    CONTRACT: 10 itens — html_erro_mapeamento + 8 de _revelar_secao_2 + status
+
+    Valida 4 aspectos antes de aceitar as colunas:
+      1. Conversibilidade numérica (≥50% dos valores)
+      2. Limites teóricos (lat −90/+90, lon −180/+180, ≥80%)
+      3. Inversão entre colunas (lat parece lon e vice-versa)
+      4. Casas decimais (coordenadas geográficas raramente são inteiros exatos)
+    """
+    def _erro_mapeamento(linhas_html):
+        html = (
+            '<div style="color:#c0392b;margin-top:6px;padding:8px 12px;'
+            'background:#fdf2f2;border-radius:6px;border-left:3px solid #c0392b">'
+            '<strong>⚠ Diagnóstico das colunas selecionadas:</strong><br>'
+            + linhas_html +
+            '</div>'
+        )
+        return (
+            gr.update(value=html),
+            gr.update(), gr.update(), gr.update(),
+            gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
+            gr.update(),
+        )
+
+    if df is None or not col_lat or not col_lon:
+        return _erro_mapeamento("Selecione as colunas de latitude e longitude antes de confirmar.")
+
+    n_total = len(df)
+    if n_total == 0:
+        return _erro_mapeamento("O DataFrame está vazio.")
+
+    # Aspecto 1 — Conversibilidade numérica
+    lat_num = pd.to_numeric(df[col_lat], errors="coerce")
+    lon_num = pd.to_numeric(df[col_lon], errors="coerce")
+    lat_vals = lat_num.dropna()
+    lon_vals = lon_num.dropna()
+    lat_conv = len(lat_vals) / n_total
+    lon_conv = len(lon_vals) / n_total
+
+    erros_conv = []
+    if lat_conv < 0.5:
+        erros_conv.append(
+            f"• <strong>{col_lat}</strong>: apenas {lat_conv:.0%} dos valores são numéricos "
+            f"— a coluna provavelmente não contém coordenadas."
+        )
+    if lon_conv < 0.5:
+        erros_conv.append(
+            f"• <strong>{col_lon}</strong>: apenas {lon_conv:.0%} dos valores são numéricos "
+            f"— a coluna provavelmente não contém coordenadas."
+        )
+    if erros_conv:
+        return _erro_mapeamento("<br>".join(erros_conv))
+
+    # Aspecto 2 — Limites teóricos
+    lat_in_range = ((lat_vals >= -90) & (lat_vals <= 90)).mean()
+    lon_in_range = ((lon_vals >= -180) & (lon_vals <= 180)).mean()
+
+    # Aspecto 3 — Inversão de colunas
+    lat_in_lon_range = ((lat_vals >= -180) & (lat_vals <= 180)).mean()
+    lon_in_lat_range = ((lon_vals >= -90) & (lon_vals <= 90)).mean()
+    inversao = lat_in_range < 0.5 and lat_in_lon_range > 0.8 and lon_in_lat_range > 0.8
+
+    # Aspecto 4 — Casas decimais
+    lat_tem_decimais = (lat_vals % 1 != 0).mean() if len(lat_vals) > 0 else 0.0
+    lon_tem_decimais = (lon_vals % 1 != 0).mean() if len(lon_vals) > 0 else 0.0
+
+    linhas = []
+
+    if inversao:
+        linhas.append(
+            f"• As colunas parecem estar <strong>invertidas</strong>: "
+            f"<strong>{col_lat}</strong> tem {1 - lat_in_range:.0%} dos valores fora de −90 a +90 "
+            f"(fora do intervalo de latitude), mas dentro de −180 a +180 (intervalo de longitude). "
+            f"<strong>{col_lon}</strong> tem {lon_in_lat_range:.0%} dos valores em −90 a +90 "
+            f"(faixa típica de latitude). Tente trocar as colunas."
+        )
+    else:
+        if lat_in_range < 0.8:
+            linhas.append(
+                f"• <strong>{col_lat}</strong>: apenas {lat_in_range:.0%} dos valores estão "
+                f"em −90 a +90 (esperado para latitude)."
+            )
+        if lon_in_range < 0.8:
+            linhas.append(
+                f"• <strong>{col_lon}</strong>: apenas {lon_in_range:.0%} dos valores estão "
+                f"em −180 a +180 (esperado para longitude)."
+            )
+
+    # Aspecto 4 só é avaliado se não há outros problemas (seria ruído adicional)
+    if not linhas:
+        if lat_tem_decimais < 0.1:
+            linhas.append(
+                f"• <strong>{col_lat}</strong>: {lat_tem_decimais:.0%} dos valores têm casas decimais "
+                f"— coordenadas geográficas normalmente são valores de ponto flutuante, não inteiros exatos."
+            )
+        if lon_tem_decimais < 0.1:
+            linhas.append(
+                f"• <strong>{col_lon}</strong>: {lon_tem_decimais:.0%} dos valores têm casas decimais "
+                f"— coordenadas geográficas normalmente são valores de ponto flutuante, não inteiros exatos."
+            )
+
+    if linhas:
+        return _erro_mapeamento("<br>".join(linhas))
+
+    df_novo = padronizar_coords(df, col_lat, col_lon)
+    mapa = criar_mapa(df_novo)
+    return (
+        gr.update(value=""),  # html_erro_mapeamento — limpar
+    ) + _revelar_secao_2(df_novo, mapa) + ("Coordenadas mapeadas. Seção 2 liberada.",)
+
+
+def geocodificar_callback(df, col_cdlog, col_num, auto_200):
+    """Opção 3: executa geocodificação por interpolação em eixos.
+
+    CONTRACT: 65 itens —
+      estado_geo_temp, estado_df_falhas, html_geo_status,
+      20×falha_rows, 20×falha_htmls, 20×falha_inputs,
+      btn_aplicar_correcoes_geo, btn_usar_coords_geo
+    """
+    N = MAX_FALHAS_GEO
+    _no_slots = (
+        *[gr.update(visible=False)] * N,
+        *[gr.update(value="")] * N,
+        *[gr.update(value=None)] * N,
+    )
+
+    if df is None or not col_cdlog or not col_num:
+        return (
+            None, None,
+            "<p>Selecione as colunas CDLOG e Número Predial.</p>",
+            *_no_slots,
+            gr.update(visible=False), gr.update(visible=False),
+        )
+    try:
+        df_resultado, df_falhas, ajustados = geocodificar(df, col_cdlog, col_num, auto_200)
+    except RuntimeError as e:
+        return (
+            None, None,
+            f'<div style="color:red;padding:8px">{e}</div>',
+            *_no_slots,
+            gr.update(visible=False), gr.update(visible=False),
+        )
+
+    html_status = formatar_status_geocodificacao(df_resultado, df_falhas, ajustados)
+    n_falhas = len(df_falhas)
+    tem_coords = df_resultado["lat"].notna().any() if "lat" in df_resultado.columns else False
+    completo = n_falhas == 0 and tem_coords
+
+    if n_falhas > N:
+        html_status += (
+            f'<div style="color:#c0392b;margin-top:6px">⚠ {n_falhas} falhas excedem o limite '
+            f'de {N} correções manuais. Corrija os endereços na planilha-fonte e recarregue.</div>'
+        )
+        return (
+            df_resultado, None,
+            html_status,
+            *_no_slots,
+            gr.update(visible=False), gr.update(visible=False),
+        )
+
+    # Monta atualizações para os N slots
+    row_updates, html_updates, num_updates = [], [], []
+    for i in range(N):
+        if i < n_falhas:
+            row = df_falhas.iloc[i]
+            sugestoes = row.get("sugestoes", "")
+            linha = row["_idx"]
+            row_updates.append(gr.update(visible=True))
+            html_updates.append(gr.update(value=(
+                f'<div style="padding:4px 8px;background:#fff8f0;border-left:3px solid #f39c12;'
+                f'border-radius:4px;font-size:0.9em">'
+                f'<strong>Linha {linha}</strong> · CDLOG {row["cdlog"]} · '
+                f'Nº atual: <strong>{row["numero_atual"]}</strong> · {row["motivo"]}'
+                + (f'<br><span style="color:#555">Sugestões: {sugestoes}</span>' if sugestoes else '')
+                + '</div>'
+            )))
+            num_updates.append(gr.update(value=None, label=f"Nº Corrigido (linha {linha})"))
+        else:
+            row_updates.append(gr.update(visible=False))
+            html_updates.append(gr.update(value=""))
+            num_updates.append(gr.update(value=None))
+
+    return (
+        df_resultado,                                    # estado_geo_temp
+        df_falhas if n_falhas > 0 else None,             # estado_df_falhas
+        html_status,                                     # html_geo_status
+        *row_updates,                                    # 20 falha_rows
+        *html_updates,                                   # 20 falha_htmls
+        *num_updates,                                    # 20 falha_inputs
+        gr.update(visible=n_falhas > 0),                 # btn_aplicar_correcoes_geo
+        gr.update(visible=completo),                     # btn_usar_coords_geo
+    )
+
+
+def aplicar_correcoes_geo_callback(df_original, df_falhas, *args):
+    """Opção 3: aplica correções manuais e re-geocodifica.
+
+    CONTRACT: inputs = estado_geo_temp (1) + estado_df_falhas (1) + 20 falha_inputs + 3 params = 25.
+    CONTRACT: 65 itens retornados (mesmo formato de geocodificar_callback).
+    """
+    N = MAX_FALHAS_GEO
+    correcoes_vals = list(args[:N])
+    col_cdlog, col_num, auto_200 = args[N], args[N + 1], args[N + 2]
+
+    _no_slots = (
+        *[gr.update(visible=False)] * N,
+        *[gr.update(value="")] * N,
+        *[gr.update(value=None)] * N,
+    )
+
+    if df_original is None or df_falhas is None or not col_cdlog or not col_num:
+        return (
+            None, None,
+            "<p>Sem dados para processar.</p>",
+            *_no_slots,
+            gr.update(visible=False), gr.update(visible=False),
+        )
+
+    # Monta coluna "numero_corrigido" a partir dos valores dos gr.Number
+    df_falhas_fmt = df_falhas.copy()
+    num_corrigidos = []
+    for i, val in enumerate(correcoes_vals[:len(df_falhas_fmt)]):
+        if val is not None and not (isinstance(val, float) and pd.isna(val)):
+            num_corrigidos.append(str(int(val)))
+        else:
+            num_corrigidos.append("")
+    # Preenche com "" os slots além do tamanho real de df_falhas
+    num_corrigidos += [""] * max(0, len(df_falhas_fmt) - len(num_corrigidos))
+    df_falhas_fmt["numero_corrigido"] = num_corrigidos
+
+    try:
+        df_resultado, df_falhas_novas, ajustados, manuais = aplicar_correcoes_e_regeodificar(
+            df_original, df_falhas_fmt, col_cdlog, col_num, auto_200
+        )
+    except RuntimeError as e:
+        return (
+            None, None,
+            f'<div style="color:red;padding:8px">{e}</div>',
+            *_no_slots,
+            gr.update(visible=False), gr.update(visible=False),
+        )
+
+    html_status = formatar_status_geocodificacao(df_resultado, df_falhas_novas, ajustados, manuais)
+    n_falhas = len(df_falhas_novas)
+    tem_coords = df_resultado["lat"].notna().any() if "lat" in df_resultado.columns else False
+    completo = n_falhas == 0 and tem_coords
+
+    if n_falhas > N:
+        html_status += (
+            f'<div style="color:#c0392b;margin-top:6px">⚠ {n_falhas} falhas excedem o limite '
+            f'de {N} correções manuais. Corrija os endereços na planilha-fonte e recarregue.</div>'
+        )
+        return (
+            df_resultado, None,
+            html_status,
+            *_no_slots,
+            gr.update(visible=False), gr.update(visible=False),
+        )
+
+    row_updates, html_updates, num_updates = [], [], []
+    for i in range(N):
+        if i < n_falhas:
+            row = df_falhas_novas.iloc[i]
+            sugestoes = row.get("sugestoes", "")
+            linha = row["_idx"]
+            row_updates.append(gr.update(visible=True))
+            html_updates.append(gr.update(value=(
+                f'<div style="padding:4px 8px;background:#fff8f0;border-left:3px solid #f39c12;'
+                f'border-radius:4px;font-size:0.9em">'
+                f'<strong>Linha {linha}</strong> · CDLOG {row["cdlog"]} · '
+                f'Nº atual: <strong>{row["numero_atual"]}</strong> · {row["motivo"]}'
+                + (f'<br><span style="color:#555">Sugestões: {sugestoes}</span>' if sugestoes else '')
+                + '</div>'
+            )))
+            num_updates.append(gr.update(value=None, label=f"Nº Corrigido (linha {linha})"))
+        else:
+            row_updates.append(gr.update(visible=False))
+            html_updates.append(gr.update(value=""))
+            num_updates.append(gr.update(value=None))
+
+    return (
+        df_resultado,
+        df_falhas_novas if n_falhas > 0 else None,
+        html_status,
+        *row_updates,
+        *html_updates,
+        *num_updates,
+        gr.update(visible=n_falhas > 0),             # btn_aplicar_correcoes_geo
+        gr.update(visible=completo),                  # btn_usar_coords_geo
+    )
+
+
+def confirmar_geocodificacao_callback(df_geo):
+    """Opção 3: confirma uso das coords geocodificadas e libera Seção 2."""
+    if df_geo is None:
+        return (
+            gr.update(), gr.update(), gr.update(),
+            gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
+            "Sem dados geocodificados.",
+        )
+    mapa = criar_mapa(df_geo)
+    return _revelar_secao_2(df_geo, mapa) + ("Geocodificação concluída. Seção 2 liberada.",)
+
+
+def confirmar_sem_coords_callback(df):
+    """Prossegue para Seção 2 sem coordenadas completas (decisão explícita do usuário)."""
+    if df is None:
+        return (
+            gr.update(), gr.update(), gr.update(),
+            gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
+            "Sem dados carregados.",
+        )
+    mapa = criar_mapa(df)
+    return _revelar_secao_2(df, mapa) + ("Seção 2 liberada sem coordenadas completas.",)
+
+
+# ============================================================
+# INTERFACE GRADIO
+# ============================================================
+
+def criar_aba():
+    """Cria conteúdo da aba de elaboração (sem wrapper gr.Blocks)."""
+
+    # Estados
+    estado_df = gr.State(None)
+    estado_modelo = gr.State(None)
+    estado_estatisticas = gr.State(None)
+    estado_outliers_anteriores = gr.State([])  # Lista de índices excluídos em iterações anteriores
+    estado_iteracao = gr.State(1)  # Contador de iterações
+    estado_avaliacoes = gr.State([])  # Lista de avaliações acumuladas
+
+    # ========================================
+    # SEÇÃO 1: IMPORTAR DADOS (sempre visível e aberta)
+    # ========================================
+    # Estado para armazenar o arquivo temporariamente (usado quando há múltiplas abas)
+    estado_arquivo_temp = gr.State(None)
+    estado_flag_carregamento = gr.State(False)
+    estado_geo_temp = gr.State(None)    # DataFrame durante geocodificação (antes de confirmar)
+    estado_df_falhas = gr.State(None)   # df_falhas mais recente (geocodificação)
+
+    header_secao_1 = gr.HTML(criar_header_secao(1, "Importar Dados"))
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        elem_classes="section-accordion"
+    ) as accordion_secao_1:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_1:
+            # Estado A: Upload (visível inicialmente)
+            with gr.Row(visible=True) as row_upload:
+                upload = gr.File(
+                    label="Carregar arquivo (Excel, CSV ou Modelo .dai)",
+                    scale=2
+                )
+                status = gr.Textbox(
+                    label="Status",
+                    interactive=False,
+                    scale=2
+                )
+
+            # Estado B: Seleção de aba — apenas para Excel multi-aba (oculto inicialmente)
+            with gr.Group(visible=False) as row_selecao_aba:
+                with gr.Row():
+                    dropdown_aba = gr.Dropdown(
+                        label="Selecionar Aba",
+                        choices=[],
+                        interactive=True,
+                    )
+                with gr.Row():
+                    btn_confirmar_aba = gr.Button("Selecionar Aba", variant="primary")
+
+            # Estado C: Pós-carregamento (oculto inicialmente)
+            with gr.Row(visible=False) as row_pos_carga:
+                with gr.Column(scale=5):
+                    html_nome_arquivo_carregado = gr.HTML(value="")
+                with gr.Column(scale=2):
+                    btn_reiniciar_app = gr.Button(
+                        "Reiniciar Aplicação",
+                        variant="danger"
+                    )
+                    html_aviso_reiniciar = gr.HTML(value=(
+                        '<div style="background-color:#fff3cd; border:1px solid #ffc107; '
+                        'border-radius:8px; padding:8px 12px; margin-top:8px; font-size:1em;">'
+                        '<strong>Atenção:</strong> Ao reiniciar, toda a aplicação MESA será '
+                        'recarregada e <strong>o conteúdo de todas as abas será perdido</strong>. '
+                        'Para iniciar uma nova sessão MESA sem perder o trabalho atual, '
+                        'abra uma <strong>nova aba do navegador</strong>.'
+                        '</div>'
+                    ))
+
+            # Estado D: Resolução de Coordenadas (oculto inicialmente)
+            with gr.Row(visible=False) as row_coords_panel:
+                with gr.Column():
+                    html_aviso_coords = gr.HTML(value="")
+
+                    # Tela de escolha (visível inicialmente)
+                    with gr.Row() as row_escolha_opcao:
+                        with gr.Column():
+                            with gr.Row():
+                                btn_escolher_mapear = gr.Button(
+                                    "Mapear colunas existentes para lat/lon",
+                                    variant="primary",
+                                    scale=10,
+                                )
+                                gr.HTML(
+                                    '<div style="align-self:center;text-align:center;'
+                                    'min-width:36px">'
+                                    '<span style="display:inline-block;font-size:0.75rem;'
+                                    'font-weight:600;color:#9ca3af;letter-spacing:0.05em;'
+                                    'text-transform:uppercase;background:#f3f4f6;'
+                                    'border-radius:999px;padding:3px 8px">ou</span>'
+                                    '</div>',
+                                    scale=1,
+                                )
+                                btn_escolher_geocodificar = gr.Button(
+                                    "Geocodificar automaticamente",
+                                    variant="primary",
+                                    scale=10,
+                                )
+                                gr.HTML(
+                                    '<div style="align-self:center;text-align:center;'
+                                    'min-width:36px">'
+                                    '<span style="display:inline-block;font-size:0.75rem;'
+                                    'font-weight:600;color:#9ca3af;letter-spacing:0.05em;'
+                                    'text-transform:uppercase;background:#f3f4f6;'
+                                    'border-radius:999px;padding:3px 8px">ou</span>'
+                                    '</div>',
+                                    scale=1,
+                                )
+                                btn_prosseguir_sem_coords = gr.Button(
+                                    "Prosseguir sem mapear coordenadas",
+                                    variant="primary",
+                                    scale=10,
+                                )
+                            with gr.Row(visible=False) as row_confirmacao_prosseguir:
+                                with gr.Column():
+                                    gr.HTML(
+                                        '<div style="background:#fff3cd;border:1px solid #ffc107;'
+                                        'border-radius:8px;padding:8px 12px;margin-top:4px">'
+                                        '<strong>Atenção:</strong> Funcionalidades dependentes de '
+                                        'geolocalização (mapa, análises espaciais) não funcionarão '
+                                        'para registros sem coordenadas ou apresentarão resultados '
+                                        'incompletos. Deseja prosseguir mesmo assim?'
+                                        '</div>'
+                                    )
+                                    btn_confirmar_prosseguir = gr.Button(
+                                        "Confirmar — prosseguir mesmo assim",
+                                        variant="stop",
+                                    )
+
+                    # Painel Mapear (oculto — botão Voltar no topo)
+                    with gr.Row(visible=False) as row_opcao_mapear:
+                        with gr.Column():
+                            btn_voltar_mapear = gr.Button("← Voltar", variant="secondary", size="sm")
+                            with gr.Row():
+                                dropdown_col_lat_manual = gr.Dropdown(
+                                    label="Coluna → lat",
+                                    choices=[],
+                                    interactive=True,
+                                )
+                                dropdown_col_lon_manual = gr.Dropdown(
+                                    label="Coluna → lon",
+                                    choices=[],
+                                    interactive=True,
+                                )
+                            html_erro_mapeamento = gr.HTML(value="")
+                            btn_confirmar_mapeamento = gr.Button(
+                                "Confirmar mapeamento",
+                                variant="primary",
+                            )
+
+                    # Painel Geocodificar (oculto — botão Voltar no topo)
+                    with gr.Row(visible=False) as row_opcao_geocodificar:
+                        with gr.Column():
+                            btn_voltar_geocodificar = gr.Button("← Voltar", variant="secondary", size="sm")
+                            with gr.Row():
+                                dropdown_cdlog_geo = gr.Dropdown(
+                                    label="Coluna CDLOG (código do logradouro)",
+                                    choices=[],
+                                    interactive=True,
+                                )
+                                dropdown_num_geo = gr.Dropdown(
+                                    label="Coluna Número Predial",
+                                    choices=[],
+                                    interactive=True,
+                                )
+                            checkbox_auto_200 = gr.Checkbox(
+                                label=(
+                                    "Permitir correção automática de ofício para números cuja "
+                                    "diferença do intervalo válido mais próximo seja ≤ 200"
+                                ),
+                                value=True,
+                            )
+                            btn_geocodificar = gr.Button("Geocodificar", variant="primary")
+                            html_geo_status = gr.HTML(value="<div style='min-height:40px'></div>")
+
+                            # 20 slots de correção individual (ocultos inicialmente)
+                            falha_rows = []
+                            falha_htmls = []
+                            falha_inputs = []
+                            for i in range(MAX_FALHAS_GEO):
+                                with gr.Row(visible=False) as _fr:
+                                    with gr.Column(scale=3):
+                                        _fh = gr.HTML(value="")
+                                    with gr.Column(scale=1):
+                                        _fi = gr.Number(label="Nº Corrigido", precision=0, value=None)
+                                falha_rows.append(_fr)
+                                falha_htmls.append(_fh)
+                                falha_inputs.append(_fi)
+
+                            btn_aplicar_correcoes_geo = gr.Button(
+                                "Aplicar correções e re-geocodificar",
+                                visible=False,
+                            )
+                            btn_usar_coords_geo = gr.Button(
+                                "Confirmar",
+                                variant="primary",
+                                visible=False,
+                            )
+
+
+    # ========================================
+    # SEÇÃO 2: VISUALIZAR DADOS (ativada ao carregar arquivo)
+    # ========================================
+    header_secao_2 = gr.HTML(criar_header_secao(2, "Visualizar Dados"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_2:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_2:
+            with gr.Accordion("Outliers Excluídos", open=True, visible=False) as accordion_outliers_anteriores:
+                html_outliers_anteriores = gr.HTML(value="")
+                btn_limpar_historico = gr.Button("Limpar Histórico e Reiniciar do Zero", variant="secondary")
+
+            with gr.Accordion("Dados de Mercado", open=True):
+                tabela_dados = gr.Dataframe(
+                    label="",
+                    interactive=False,
+                    max_height=400
+                )
+                with gr.Row():
+                    btn_download_dados = gr.Button("Baixar Dados (CSV)", variant="secondary", size="sm")
+                    download_dados_file = gr.File(label="", visible=False)
+
+            dropdown_mapa_var = gr.Dropdown(
+                label="Variável para dimensionar pontos no mapa",
+                choices=["Visualização Padrão"],
+                value="Visualização Padrão",
+                interactive=True,
+                allow_custom_value=False
+            )
+
+            with gr.Accordion("Mapa", open=True):
+                mapa_html = gr.HTML(
+                    value="<p>Carregue dados para ver o mapa.</p>",
+                    label=""
+                )
+
+    # ========================================
+    # SEÇÃO 3: SELECIONAR VARIÁVEL DEPENDENTE (ativada ao carregar arquivo)
+    # ========================================
+    header_secao_3 = gr.HTML(criar_header_secao(3, "Selecionar Variável Dependente"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_3:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_3:
+            with gr.Row():
+                dropdown_y = gr.Dropdown(
+                    label="Variável Dependente (y)",
+                    choices=[],
+                    interactive=True,
+                    scale=2
+                )
+            with gr.Row():
+                btn_aplicar_y = gr.Button("Aplicar Seleção", variant="primary", scale=1)
+
+    # ========================================
+    # SEÇÃO 4: SELECIONAR VARIÁVEIS INDEPENDENTES (ativada ao selecionar Y)
+    # ========================================
+    header_secao_4 = gr.HTML(criar_header_secao(4, "Selecionar Variáveis Independentes"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_4:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_4:
+            with gr.Row(elem_classes="checkbox-selecionar-todos"):
+                checkbox_selecionar_todos = gr.Checkbox(
+                    label="Marcar ou desmarcar todas as variáveis",
+                    value=True,
+                    interactive=True
+                )
+            with gr.Row():
+                checkboxes_x = gr.CheckboxGroup(
+                    label="Variáveis Independentes (X)",
+                    choices=[],
+                    interactive=True
+                )
+            with gr.Row():
+                checkboxes_dicotomicas = gr.CheckboxGroup(
+                    label="Variáveis Dicotômicas (0/1)",
+                    choices=[], value=[], visible=False, interactive=True,
+                    info="Transformação fixa em (x). Avaliação: apenas 0 ou 1."
+                )
+            with gr.Row():
+                checkboxes_codigo_alocado = gr.CheckboxGroup(
+                    label="Variáveis de Código Alocado/Ajustado",
+                    choices=[], value=[], visible=False, interactive=True,
+                    info="Transformação livre. Avaliação: apenas inteiros no intervalo observado."
+                )
+            with gr.Row():
+                checkboxes_percentuais = gr.CheckboxGroup(
+                    label="Variáveis Percentuais (0 a 1)",
+                    choices=[], value=[], visible=False, interactive=True,
+                    info="Transformação fixa em (x). Avaliação: apenas valores entre 0 e 1."
+                )
+            with gr.Row():
+                btn_aplicar_selecao_x = gr.Button("Aplicar Seleção", variant="primary", scale=1)
+            html_aviso_multicolinearidade = gr.HTML("", visible=False)
+
+    # Estados para outliers (usados na seção de Análise de Outliers após o modelo)
+    estado_metricas = gr.State(None)
+    estado_df_filtrado = gr.State(None)
+
+    # ========================================
+    # SEÇÃO 5: ESTATÍSTICAS DAS VARIÁVEIS SELECIONADAS (ativada por Aplicar Seleção)
+    # ========================================
+    header_secao_5 = gr.HTML(criar_header_secao(5, "Estatísticas das Variáveis Selecionadas"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_5:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_5:
+            tabela_estatisticas = gr.Dataframe(
+                label="",
+                interactive=False,
+                value=None,
+                wrap=True
+            )
+            with gr.Row():
+                btn_download_estatisticas = gr.Button("Baixar Estatísticas (CSV)", variant="secondary", size="sm")
+                download_estatisticas_file = gr.File(label="", visible=False)
+
+    # ========================================
+    # SEÇÃO 6: TESTE DE MICRONUMEROSIDADE (ativada por Aplicar Seleção)
+    # ========================================
+    header_secao_6 = gr.HTML(criar_header_secao(6, "Teste de Micronumerosidade"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_6:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_6:
+            html_micronumerosidade = gr.HTML(value="")
+
+    # ========================================
+    # SEÇÃO 7: GRÁFICOS DE DISPERSÃO (ativada por Aplicar Seleção)
+    # ========================================
+    header_secao_7 = gr.HTML(criar_header_secao(7, "Gráficos de Dispersão das Variáveis Independentes"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_7:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_7:
+            plot_dispersao = gr.Plot(label="")
+
+    # ========================================
+    # SEÇÃO 8: TRANSFORMAÇÕES SUGERIDAS (ativada por Aplicar Seleção)
+    # ========================================
+    # Estado para armazenar resultados da busca
+    estado_resultados_busca = gr.State([])
+
+    header_secao_8 = gr.HTML(criar_header_secao(8, "Transformações Sugeridas"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_8:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_8:
+            with gr.Row():
+                slider_grau_coef = gr.Radio(
+                    choices=[("Sem enquadramento", 0), ("Grau I (p≤30%)", 1), ("Grau II (p≤20%)", 2), ("Grau III (p≤10%)", 3)],
+                    value=3,
+                    label="Grau mínimo de significância dos coeficientes",
+                    type="value"
+                )
+                slider_grau_f = gr.Radio(
+                    choices=[("Sem enquadramento", 0), ("Grau I (α=5%)", 1), ("Grau II (α=2%)", 2), ("Grau III (α=1%)", 3)],
+                    value=3,
+                    label="Grau mínimo do Teste F",
+                    type="value"
+                )
+            busca_html = gr.HTML(value="")
+
+    # ========================================
+    # SEÇÃO 9: APLICAÇÃO DAS TRANSFORMAÇÕES (ativada por Aplicar Seleção)
+    # ========================================
+    header_secao_9 = gr.HTML(criar_header_secao(9, "Aplicação das Transformações"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_9:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_9:
+            # Área destacada para botões de adoção
+            gr.HTML("""
+                <div class="adotar-header">
+                    <span class="adotar-titulo">Adote uma das otimizações de transformação sugeridas na seção anterior</span>
+                </div>
+            """)
+            with gr.Row(elem_classes="adotar-row"):
+                btn_adotar_1 = gr.Button("✓ Adotar #1", visible=False, elem_classes="btn-adotar", variant="primary")
+                btn_adotar_2 = gr.Button("✓ Adotar #2", visible=False, elem_classes="btn-adotar", variant="primary")
+                btn_adotar_3 = gr.Button("✓ Adotar #3", visible=False, elem_classes="btn-adotar", variant="primary")
+                btn_adotar_4 = gr.Button("✓ Adotar #4", visible=False, elem_classes="btn-adotar", variant="primary")
+                btn_adotar_5 = gr.Button("✓ Adotar #5", visible=False, elem_classes="btn-adotar", variant="primary")
+
+            gr.HTML("<div class='adotar-separator'><span>ou configure manualmente</span></div>")
+
+            gr.Markdown("*Selecione a transformação para cada variável (dicotômicas ficam fixas em (x))*", elem_classes="transf-instrucao")
+
+            # Cards: os 3 gr.Row são transparentes (display:contents via CSS) e fluem
+            # num único container flex (.transf-all-cards), garantindo distribuição uniforme
+            # 3 linhas × 8 = 24 slots; apenas os 20 primeiros são rastreados
+            # Card Y fica antes dos cards X (mesmo container flex)
+            transf_x_rows = []
+            transf_x_columns = []
+            transf_x_labels = []
+            transf_x_dropdowns = []
+
+            with gr.Column(elem_classes="transf-all-cards"):
+                # Card da variável dependente Y (borda azul, label dinâmico com nome + "(Y)")
+                with gr.Row(visible=False, elem_classes="transf-cards-row") as transf_y_row:
+                    with gr.Column(scale=1, min_width=110, elem_classes="transf-card transf-card-y", visible=False) as transf_y_col:
+                        transf_y_label = gr.HTML(value="", visible=False, elem_classes="transf-card-label")
+                        transformacao_y = gr.Dropdown(
+                            choices=TRANSFORMACOES,
+                            value="(x)",
+                            label="",
+                            show_label=False,
+                            interactive=True,
+                            visible=True,
+                        )
+
+                for i in range((MAX_VARS_X + 7) // 8):  # 3 rows
+                    row = gr.Row(visible=False, elem_classes="transf-cards-row")
+                    with row:
+                        for j in range(8):
+                            k = i * 8 + j
+                            col = gr.Column(scale=1, min_width=110, elem_classes="transf-card", visible=False)
+                            with col:
+                                label = gr.HTML(value="", visible=False, elem_classes="transf-card-label")
+                                dropdown = gr.Dropdown(
+                                    choices=TRANSFORMACOES,
+                                    value="(x)",
+                                    label="",
+                                    show_label=False,
+                                    interactive=True,
+                                    visible=False,
+                                )
+                            if k < MAX_VARS_X:
+                                transf_x_columns.append(col)
+                                transf_x_labels.append(label)
+                                transf_x_dropdowns.append(dropdown)
+                    transf_x_rows.append(row)
+
+            with gr.Row():
+                btn_ajustar = gr.Button("Aplicar transformações e ajustar modelo", variant="primary", scale=1)
+
+    # ========================================
+    # SEÇÃO 10: GRÁFICOS DE DISPERSÃO (VARIÁVEIS TRANSFORMADAS) (ativada por Ajustar Modelo)
+    # ========================================
+    header_secao_10 = gr.HTML(criar_header_secao(10, "Gráficos de Dispersão (Variáveis Transformadas)"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_10:
+        with gr.Column(elem_classes="section-content") as conteudo_secao_10:
+            dropdown_tipo_grafico_dispersao = gr.Dropdown(
+                choices=[
+                    "Variáveis Independentes Transformadas X Variável Dependente Transformada",
+                    "Variáveis Independentes Transformadas X Resíduo Padronizado"
+                ],
+                value="Variáveis Independentes Transformadas X Variável Dependente Transformada",
+                label="Tipo de Gráfico",
+                interactive=True,
+                visible=True,
+                elem_id="dropdown_dispersao"
+            )
+            plot_dispersao_transf = gr.Plot(label="", visible=True)
+
+    # ========================================
+    # SEÇÃO 11: DIAGNÓSTICO DE MODELO (ativada por Ajustar Modelo)
+    # ========================================
+    header_secao_11 = gr.HTML(criar_header_secao(11, "Diagnóstico de Modelo"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_11:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_11:
+            diagnosticos_html = gr.HTML(value="")
+
+            with gr.Row():
+                with gr.Accordion("Tabela de Coeficientes", open=True):
+                    tabela_coef = gr.Dataframe(
+                        label="",
+                        interactive=False,
+                        max_height=400
+                    )
+                    with gr.Row():
+                        btn_download_coef = gr.Button("Baixar Coeficientes (CSV)", variant="secondary", size="sm")
+                        download_coef_file = gr.File(label="", visible=False)
+
+                with gr.Accordion("Valores Observados vs Calculados", open=True):
+                    tabela_obs_calc = gr.Dataframe(
+                        label="",
+                        interactive=False,
+                        max_height=400
+                    )
+                    with gr.Row():
+                        btn_download_obs_calc = gr.Button("Baixar Obs vs Calc (CSV)", variant="secondary", size="sm")
+                        download_obs_calc_file = gr.File(label="", visible=False)
+
+    # ========================================
+    # SEÇÃO 12: GRÁFICOS DE DIAGNÓSTICO DO MODELO (ativada por Ajustar Modelo)
+    # ========================================
+    header_secao_12 = gr.HTML(criar_header_secao(12, "Gráficos de Diagnóstico do Modelo"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_12:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_12:
+            with gr.Row():
+                plot_obs_calc = gr.Plot(label="Observados vs Calculados")
+                plot_residuos = gr.Plot(label="Resíduos")
+
+            with gr.Row():
+                plot_hist = gr.Plot(label="Histograma dos Resíduos")
+                plot_cook = gr.Plot(label="Distância de Cook")
+
+            with gr.Row():
+                plot_corr = gr.Plot(label="Matriz de Correlação")
+
+    # ========================================
+    # SEÇÃO 13: ANALISAR OUTLIERS (ativada por Ajustar Modelo)
+    # ========================================
+    # Estado para armazenar o número de filtros visíveis
+    estado_n_filtros = gr.State(2)  # Começa com 2 filtros padrão
+
+    # Opções de operadores
+    OPERADORES = ["<=", ">=", "<", ">", "="]
+    # Opções base de variáveis (serão atualizadas dinamicamente)
+    VARIAVEIS_BASE = ["Resíduo Pad.", "Resíduo Stud.", "Cook"]
+
+    header_secao_13 = gr.HTML(criar_header_secao(13, "Analisar Outliers"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_13:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_13:
+            gr.HTML('<div class="outlier-subheader">Métricas de Outliers</div>')
+            gr.HTML('<div class="outlier-dica">Métricas calculadas com base no modelo ajustado (resíduos com transformações aplicadas)</div>')
+
+            tabela_metricas = gr.Dataframe(
+                label="Métricas para identificação de outliers",
+                interactive=False,
+                max_height=300
+            )
+            with gr.Row():
+                btn_download_metricas = gr.Button("Baixar Métricas (CSV)", variant="secondary", size="sm")
+                download_metricas_file = gr.File(label="", visible=False)
+
+    # ========================================
+    # SEÇÃO 14: EXCLUSÃO DE OUTLIERS (ativada por Ajustar Modelo)
+    # ========================================
+    header_secao_14 = gr.HTML(criar_header_secao(14, "Exclusão ou Reinclusão de Outliers"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_14:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_14:
+            html_outliers_sec14 = gr.HTML(value="")
+            gr.HTML('<div class="outlier-subheader">Filtrar Outliers</div>')
+            gr.HTML('<div class="outlier-dica">Outliers = linhas que satisfazem QUALQUER filtro (lógica OR / União)</div>')
+
+            # Filtros dinâmicos (máximo 4 filtros)
+            filtro_rows = []
+            filtro_vars = []
+            filtro_ops = []
+            filtro_vals = []
+
+            for i in range(4):
+                visible = i < 2  # Filtros 1 e 2 visíveis por padrão
+                # Só define valores padrão para os filtros visíveis (0 e 1)
+                # Filtros ocultos (2 e 3) começam com None para não serem aplicados
+                if i == 0:
+                    valor_padrao = -2.0
+                    operador_padrao = "<="
+                    var_padrao = "Resíduo Pad."
+                elif i == 1:
+                    valor_padrao = 2.0
+                    operador_padrao = ">="
+                    var_padrao = "Resíduo Pad."
+                else:
+                    valor_padrao = None
+                    operador_padrao = None
+                    var_padrao = None
+
+                with gr.Row(visible=visible, elem_classes="filtro-row") as row:
+                    var_dropdown = gr.Dropdown(
+                        label=f"Variável {i+1}",
+                        choices=VARIAVEIS_BASE,
+                        value=var_padrao,
+                        scale=2
+                    )
+                    op_dropdown = gr.Dropdown(
+                        label="Operador",
+                        choices=OPERADORES,
+                        value=operador_padrao,
+                        scale=1
+                    )
+                    val_input = gr.Number(
+                        label="Valor",
+                        value=valor_padrao,
+                        scale=1
+                    )
+
+                filtro_rows.append(row)
+                filtro_vars.append(var_dropdown)
+                filtro_ops.append(op_dropdown)
+                filtro_vals.append(val_input)
+
+            with gr.Row(elem_classes="btn-filtro-acao-row"):
+                btn_adicionar_filtro = gr.Button("+", variant="secondary", scale=0, min_width=50, elem_classes="btn-filtro-acao btn-adicionar-filtro")
+                btn_remover_ultimo = gr.Button("−", variant="secondary", scale=0, min_width=50, elem_classes="btn-filtro-acao btn-remover-filtro")
+                btn_resetar_filtros = gr.Button("↺", variant="secondary", scale=0, min_width=50, elem_classes="btn-filtro-acao btn-voltar-padrao")
+
+            with gr.Row():
+                btn_aplicar_filtro = gr.Button("Aplicar Filtros", variant="primary", scale=1)
+
+            gr.HTML('<div class="outlier-divider"><span class="arrow">▼</span></div>')
+            gr.HTML('<div class="outlier-subheader">Confirmar Filtros Selecionados ou Ajustar Manualmente</div>')
+            gr.HTML('<div class="outlier-dica">Edite os índices manualmente ou confirme os resultados dos filtros acima</div>')
+
+            with gr.Row():
+                outliers_texto = gr.Textbox(
+                    label="Índices a Excluir",
+                    placeholder="Ex: 5, 12, 23",
+                    scale=3
+                )
+                reincluir_texto = gr.Textbox(
+                    label="Índices a Reincluir",
+                    placeholder="Ex: 5, 12",
+                    scale=3
+                )
+
+            with gr.Row():
+                txt_resumo_outliers = gr.Textbox(
+                    label="Resumo",
+                    value="Excluídos: 0 | A excluir: 0 | A reincluir: 0 | Total: 0",
+                    interactive=False,
+                    elem_classes="resumo-outliers"
+                )
+
+            with gr.Row():
+                btn_reiniciar_iteracao = gr.Button(
+                    "Atualizar Modelo (Excluir/Reincluir Outliers)",
+                    variant="primary",
+                    scale=2,
+                    elem_classes="btn-reiniciar-iteracao"
+                )
+                btn_download_base = gr.Button("Baixar Base Tratada (CSV)", variant="secondary", scale=1)
+                download_base_file = gr.File(label="", visible=False)
+
+    # ========================================
+    # SEÇÃO 15: AVALIAÇÃO DE IMÓVEL (ativada por Ajustar Modelo)
+    # ========================================
+    N_COLS_AVAL = 4
+    N_ROWS_AVAL = MAX_VARS_X // N_COLS_AVAL  # 5
+
+    header_secao_15 = gr.HTML(criar_header_secao(15, "Avaliação de Imóvel"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_15:
+        with gr.Group(elem_classes="section-content"):
+            # Grid de inputs (5 rows × 4 cols = 20 inputs pré-criados) — visual de cards
+            aval_rows = []
+            aval_inputs = []
+            with gr.Column(elem_classes="aval-all-cards"):
+                for i in range(N_ROWS_AVAL):
+                    with gr.Row(visible=False, elem_classes="aval-cards-row") as aval_row:
+                        for j in range(N_COLS_AVAL):
+                            inp = gr.Number(label="", visible=False, interactive=True, elem_classes="aval-card")
+                            aval_inputs.append(inp)
+                    aval_rows.append(aval_row)
+
+            with gr.Row():
+                btn_calcular_avaliacao = gr.Button("Calcular Avaliação", variant="primary", scale=2)
+                btn_limpar_avaliacoes = gr.Button("Limpar Avaliações", variant="secondary", scale=1)
+            with gr.Row():
+                dropdown_base_avaliacao = gr.Dropdown(
+                    label="Base p/ comparação",
+                    choices=[],
+                    value=None,
+                    interactive=True,
+                    scale=1,
+                )
+
+            resultado_avaliacao_html = gr.HTML("")
+            excluir_aval_trigger = gr.Textbox(
+                label="", elem_id="excluir-aval-elab", container=False,
+                elem_classes="trigger-hidden"
+            )
+
+            with gr.Row():
+                btn_exportar_avaliacoes = gr.Button("Salvar Avaliações em Excel", variant="secondary")
+                download_avaliacoes_file = gr.File(label="", visible=False)
+
+    # ========================================
+    # SEÇÃO 16: EXPORTAR MODELO (ativada por Ajustar Modelo)
+    # ========================================
+    header_secao_16 = gr.HTML(criar_header_secao(16, "Exportar Modelo"), visible=True)
+    with gr.Accordion(
+        label="▼ Mostrar / Ocultar",
+        open=True,
+        visible=False,
+        elem_classes="section-accordion"
+    ) as accordion_secao_16:
+        with gr.Group(elem_classes="section-content") as conteudo_secao_16:
+            with gr.Row():
+                nome_arquivo = gr.Textbox(
+                    label="Nome do arquivo",
+                    placeholder="modelo_01",
+                    scale=2
+                )
+                dropdown_elaborador = gr.Dropdown(
+                    label="Elaborador",
+                    choices=_avaliadores_nomes,
+                    value=None,
+                    scale=2
+                )
+                btn_exportar = gr.Button("Exportar .dai", variant="primary", scale=1)
+
+            status_exportar = gr.Textbox(
+                label="Status da exportação",
+                interactive=False
+            )
+
+            download_modelo_file = gr.File(
+                label="",
+                visible=False
+            )
+
+    # ========================================
+    # EVENTOS
+    # ========================================
+
+    # --- Output lists compartilhadas ---
+
+    # CONTRACT: 196 itens — usada por upload.upload e btn_confirmar_aba.click
+    # Se alterar, atualizar: carregamento.py (5 funções retornam 196 itens)
+    _outputs_carregar = [
+        estado_df,
+        status,
+        dropdown_aba,
+        dropdown_y,
+        tabela_dados,
+        tabela_estatisticas,
+        checkboxes_x,
+        mapa_html,
+        estado_df_filtrado,
+        estado_outliers_anteriores,
+        estado_iteracao,
+        accordion_outliers_anteriores,
+        html_outliers_anteriores,
+        estado_arquivo_temp,
+        # Seções 2 e 3
+        header_secao_2,
+        accordion_secao_2,
+        dropdown_mapa_var,
+        header_secao_3,
+        accordion_secao_3,
+        # Reset seções 4-16 (states)
+        estado_modelo, estado_metricas, estado_resultados_busca, estado_avaliacoes,
+        # Headers, accordions e conteúdo das seções 4-16
+        header_secao_4, accordion_secao_4, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais,
+        html_aviso_multicolinearidade,
+        header_secao_5, accordion_secao_5,
+        header_secao_6, accordion_secao_6, html_micronumerosidade,
+        header_secao_7, accordion_secao_7, plot_dispersao,
+        header_secao_8, accordion_secao_8, slider_grau_coef, slider_grau_f, busca_html,
+        header_secao_9, accordion_secao_9, transformacao_y,
+        btn_adotar_1, btn_adotar_2, btn_adotar_3, btn_adotar_4, btn_adotar_5,
+    ] + [transf_y_row, transf_y_col, transf_y_label] + transf_x_rows + transf_x_columns + transf_x_labels + transf_x_dropdowns + [
+        header_secao_10, accordion_secao_10, dropdown_tipo_grafico_dispersao, plot_dispersao_transf,
+        header_secao_11, accordion_secao_11, diagnosticos_html, tabela_coef, tabela_obs_calc,
+        header_secao_12, accordion_secao_12, plot_obs_calc, plot_residuos, plot_hist, plot_cook, plot_corr,
+        header_secao_13, accordion_secao_13, tabela_metricas,
+        header_secao_14, accordion_secao_14, html_outliers_sec14, outliers_texto, reincluir_texto, txt_resumo_outliers,
+        # Seção 15: Avaliação de Imóvel
+        header_secao_15, accordion_secao_15,
+    ] + aval_rows + aval_inputs + [
+        resultado_avaliacao_html, dropdown_base_avaliacao, excluir_aval_trigger, download_avaliacoes_file,
+        # Seção 16: Exportar Modelo
+        header_secao_16, accordion_secao_16, nome_arquivo, status_exportar,
+        # Controles de visibilidade da seção 1 (pós-carregamento)
+        row_upload, row_selecao_aba, row_pos_carga, html_nome_arquivo_carregado,
+        # Flag para evitar que dropdown_y.change() sobrescreva valores durante carregamento
+        estado_flag_carregamento,
+    ] + filtro_vars + [  # 4 dropdowns de variável dos filtros (choices atualizados no fluxo .dai)
+        # Painel de coordenadas (Seção 1, Estado D) — itens 184-192
+        row_coords_panel,         # 184
+        html_aviso_coords,        # 185
+        dropdown_col_lat_manual,  # 186
+        dropdown_col_lon_manual,  # 187
+        dropdown_cdlog_geo,       # 188
+        dropdown_num_geo,         # 189
+        row_escolha_opcao,        # 190
+        row_opcao_mapear,         # 191
+        row_opcao_geocodificar,   # 192
+    ]
+
+    # CONTRACT: 33 itens — usada por btn_ajustar.click e btn_reiniciar_iteracao.then
+    # Se alterar, atualizar: modelo.py (ajustar_modelo_callback retorna 33 itens)
+    _outputs_ajustar = [
+        estado_modelo,
+        diagnosticos_html,
+        tabela_coef,
+        tabela_obs_calc,
+        plot_dispersao_transf,
+        dropdown_tipo_grafico_dispersao,
+        plot_obs_calc,
+        plot_residuos,
+        plot_hist,
+        plot_cook,
+        plot_corr,
+        tabela_metricas,
+        estado_metricas,
+        txt_resumo_outliers,
+        estado_avaliacoes,
+        # Seções 10-16
+        header_secao_10, accordion_secao_10,
+        header_secao_11, accordion_secao_11,
+        header_secao_12, accordion_secao_12,
+        header_secao_13, accordion_secao_13,
+        header_secao_14, accordion_secao_14,
+        header_secao_15, accordion_secao_15,
+        header_secao_16, accordion_secao_16,
+    ] + filtro_vars
+
+    # CONTRACT: 27 itens — usada por .then() após ajustar/reiniciar para popular campos de avaliação
+    _outputs_popular_avaliacao = aval_rows + aval_inputs + [resultado_avaliacao_html, dropdown_base_avaliacao]
+
+    # --- Inputs compartilhados para ajustar modelo ---
+    _inputs_ajustar = [
+        estado_df_filtrado, estado_df, dropdown_y, checkboxes_x,
+        transformacao_y, estado_outliers_anteriores, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais
+    ] + transf_x_dropdowns
+
+    # Upload de arquivo
+    upload.upload(
+        ao_carregar_arquivo,
+        inputs=[upload],
+        outputs=_outputs_carregar
+    ).then(
+        popular_campos_avaliacao_callback,
+        inputs=[estado_modelo, tabela_estatisticas],
+        outputs=_outputs_popular_avaliacao
+    ).then(
+        popular_dicotomicas_callback,
+        inputs=[estado_modelo, checkboxes_x, estado_df],
+        outputs=[checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais]
+    )
+
+    # Confirmação de aba (para Excel multi-aba)
+    btn_confirmar_aba.click(
+        confirmar_aba_callback,
+        inputs=[estado_arquivo_temp, dropdown_aba],
+        outputs=_outputs_carregar
+    ).then(
+        popular_campos_avaliacao_callback,
+        inputs=[estado_modelo, tabela_estatisticas],
+        outputs=_outputs_popular_avaliacao
+    ).then(
+        popular_dicotomicas_callback,
+        inputs=[estado_modelo, checkboxes_x, estado_df],
+        outputs=[checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais]
+    )
+
+    # Reiniciar aplicação (reload da página)
+    btn_reiniciar_app.click(
+        fn=None,
+        inputs=None,
+        outputs=None,
+        js="() => { window.location.reload(); }"
+    )
+
+    # ---- Painel de coordenadas (Seção 1, Estado D) ----
+
+    # Tela de escolha → entrar no painel Mapear
+    btn_escolher_mapear.click(
+        fn=lambda: (gr.update(visible=False), gr.update(visible=True)),
+        outputs=[row_escolha_opcao, row_opcao_mapear],
+    )
+
+    # Tela de escolha → entrar no painel Geocodificar
+    btn_escolher_geocodificar.click(
+        fn=lambda: (gr.update(visible=False), gr.update(visible=True)),
+        outputs=[row_escolha_opcao, row_opcao_geocodificar],
+    )
+
+    # Voltar do painel Mapear (limpa erro, reseta confirmação, volta à escolha)
+    btn_voltar_mapear.click(
+        fn=lambda: (gr.update(visible=False), gr.update(visible=True), gr.update(value=""), gr.update(visible=False)),
+        outputs=[row_opcao_mapear, row_escolha_opcao, html_erro_mapeamento, row_confirmacao_prosseguir],
+    )
+
+    # Voltar do painel Geocodificar (reset completo do estado de geocodificação — 68 itens)
+    N = MAX_FALHAS_GEO
+    btn_voltar_geocodificar.click(
+        fn=lambda: (
+            None, None, "",
+            *[gr.update(visible=False)] * N,
+            *[gr.update(value="")] * N,
+            *[gr.update(value=None)] * N,
+            gr.update(visible=False), gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False), gr.update(visible=True),
+        ),
+        outputs=(
+            [estado_geo_temp, estado_df_falhas, html_geo_status]
+            + falha_rows + falha_htmls + falha_inputs
+            + [btn_aplicar_correcoes_geo, btn_usar_coords_geo,
+               row_confirmacao_prosseguir,
+               row_opcao_geocodificar, row_escolha_opcao]
+        ),
+    )
+
+    # Opção 1: confirmar mapeamento manual de colunas
+    btn_confirmar_mapeamento.click(
+        fn=confirmar_mapeamento_callback,
+        inputs=[estado_df, dropdown_col_lat_manual, dropdown_col_lon_manual],
+        outputs=[
+            html_erro_mapeamento,
+            estado_df, estado_df_filtrado, mapa_html,
+            row_coords_panel, header_secao_2, accordion_secao_2,
+            header_secao_3, accordion_secao_3, status,
+        ]
+    )
+
+    # Opção 3: geocodificar por eixos (CONTRACT: 67 itens)
+    _outputs_geo = (
+        [estado_geo_temp, estado_df_falhas, html_geo_status]
+        + falha_rows + falha_htmls + falha_inputs
+        + [btn_aplicar_correcoes_geo, btn_usar_coords_geo]
+    )
+
+    btn_geocodificar.click(
+        fn=geocodificar_callback,
+        inputs=[estado_df, dropdown_cdlog_geo, dropdown_num_geo, checkbox_auto_200],
+        outputs=_outputs_geo,
+        show_progress="full",
+    )
+
+    btn_aplicar_correcoes_geo.click(
+        fn=aplicar_correcoes_geo_callback,
+        inputs=(
+            [estado_geo_temp, estado_df_falhas]
+            + falha_inputs
+            + [dropdown_cdlog_geo, dropdown_num_geo, checkbox_auto_200]
+        ),
+        outputs=_outputs_geo,
+        show_progress="full",
+    )
+
+    btn_usar_coords_geo.click(
+        fn=confirmar_geocodificacao_callback,
+        inputs=[estado_geo_temp],
+        outputs=[
+            estado_df, estado_df_filtrado, mapa_html,
+            row_coords_panel, header_secao_2, accordion_secao_2,
+            header_secao_3, accordion_secao_3, status,
+        ]
+    )
+
+    # Prosseguir sem coordenadas completas (dois cliques: exibe aviso → confirma)
+    btn_prosseguir_sem_coords.click(
+        fn=lambda: gr.update(visible=True),
+        outputs=[row_confirmacao_prosseguir]
+    )
+
+    btn_confirmar_prosseguir.click(
+        fn=lambda geo_df, orig_df: confirmar_sem_coords_callback(geo_df if geo_df is not None else orig_df),
+        inputs=[estado_geo_temp, estado_df],
+        outputs=[
+            estado_df, estado_df_filtrado, mapa_html,
+            row_coords_panel, header_secao_2, accordion_secao_2,
+            header_secao_3, accordion_secao_3, status,
+        ]
+    )
+
+    # Mudança de y (NÃO mostra seção 4, NÃO atualiza estatísticas - só atualiza checkboxes)
+    dropdown_y.change(
+        ao_mudar_y_sem_estatisticas,
+        inputs=[estado_df, dropdown_y, estado_flag_carregamento],
+        outputs=[checkboxes_x, header_secao_4, accordion_secao_4, estado_flag_carregamento]
+    ).then(
+        popular_dicotomicas_callback,
+        inputs=[estado_modelo, checkboxes_x, estado_df],
+        outputs=[checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais]
+    )
+
+    # Selecionar/Desselecionar todos via checkbox
+    def toggle_selecionar_todos(selecionar, df, coluna_y):
+        """Marca ou desmarca todas as variáveis independentes."""
+        if selecionar:
+            # Marcar todos
+            colunas_x = [col for col in obter_colunas_numericas(df) if col != coluna_y] if df is not None and coluna_y else []
+            return gr.update(value=colunas_x)
+        else:
+            # Desmarcar todos
+            return gr.update(value=[])
+
+    checkbox_selecionar_todos.change(
+        toggle_selecionar_todos,
+        inputs=[checkbox_selecionar_todos, estado_df, dropdown_y],
+        outputs=[checkboxes_x]
+    )
+
+    # Clique na tabela -> atualiza mapa
+    tabela_dados.select(
+        ao_clicar_tabela,
+        inputs=[estado_df, dropdown_mapa_var],
+        outputs=[mapa_html]
+    )
+
+    # Mudança de variável no dropdown do mapa -> atualiza mapa
+    dropdown_mapa_var.input(
+        atualizar_mapa_callback,
+        inputs=[estado_df_filtrado, estado_df, dropdown_mapa_var],
+        outputs=[mapa_html]
+    )
+
+    # Seleção de X -> atualiza campos de transformação (preview)
+    checkboxes_x.change(
+        _atualizar_campos_transformacoes_com_flag,
+        inputs=[estado_df, checkboxes_x, estado_flag_carregamento, dropdown_y],
+        outputs=[transf_y_row, transf_y_col, transf_y_label] + transf_x_rows + transf_x_columns + transf_x_labels + transf_x_dropdowns + [estado_flag_carregamento, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais]
+    )
+
+    # Mudança de qualquer checkbox de tipo -> atualiza interactive dos dropdowns de transformação
+    _inputs_interativo = [checkboxes_x, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais, estado_df]
+    checkboxes_dicotomicas.change(
+        atualizar_interativo_dicotomicas,
+        inputs=_inputs_interativo,
+        outputs=transf_x_dropdowns
+    )
+    checkboxes_codigo_alocado.change(
+        atualizar_interativo_dicotomicas,
+        inputs=_inputs_interativo,
+        outputs=transf_x_dropdowns
+    )
+    checkboxes_percentuais.change(
+        atualizar_interativo_dicotomicas,
+        inputs=_inputs_interativo,
+        outputs=transf_x_dropdowns
+    )
+
+    # Aplicar seleção de Y -> atualiza X disponíveis e MOSTRA seção 4 (NÃO atualiza estatísticas)
+    btn_aplicar_y.click(
+        lambda df, y: ao_mudar_y_sem_estatisticas(df, y, mostrar_secao_x=True),
+        inputs=[estado_df, dropdown_y],
+        outputs=[checkboxes_x, header_secao_4, accordion_secao_4, estado_flag_carregamento]
+    ).then(
+        popular_dicotomicas_callback,
+        inputs=[estado_modelo, checkboxes_x, estado_df],
+        outputs=[checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais]
+    )
+
+    # Aplicar seleção de variáveis X -> atualiza estatísticas, busca transformações, dispersão e micronumerosidade
+    btn_aplicar_selecao_x.click(
+        aplicar_selecao_callback,
+        inputs=[estado_df, dropdown_y, checkboxes_x, estado_outliers_anteriores, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais],
+        outputs=[
+            estado_df_filtrado,
+            tabela_estatisticas,
+            html_micronumerosidade,
+            plot_dispersao,
+            slider_grau_coef, slider_grau_f,
+            busca_html,
+            estado_resultados_busca,
+            btn_adotar_1, btn_adotar_2, btn_adotar_3, btn_adotar_4, btn_adotar_5,
+            # Seções 5-9
+            header_secao_5, accordion_secao_5,
+            header_secao_6, accordion_secao_6,
+            header_secao_7, accordion_secao_7,
+            header_secao_8, accordion_secao_8,
+            header_secao_9, accordion_secao_9,
+        ] + [transf_y_row, transf_y_col, transf_y_label] + transf_x_rows + transf_x_columns + transf_x_labels + transf_x_dropdowns + [html_aviso_multicolinearidade]
+    )
+
+    # Re-executar busca ao alterar grau (modo manual, sem fallback)
+    def _rebuscar_transformacoes(df, coluna_y, colunas_x, dicotomicas, codigo_alocado, percentuais, grau_coef, grau_f):
+        if df is None or coluna_y is None or not colunas_x:
+            return (gr.update(), gr.update(), *[gr.update()] * 5)
+        html, resultados, _, *btn_updates = buscar_transformacoes_callback(
+            df, coluna_y, colunas_x, dicotomicas, codigo_alocado, percentuais, int(grau_coef), int(grau_f)
+        )
+        return (html, resultados, *btn_updates)
+
+    _inputs_rebuscar = [estado_df_filtrado, dropdown_y, checkboxes_x, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais, slider_grau_coef, slider_grau_f]
+    _outputs_rebuscar = [busca_html, estado_resultados_busca,
+                         btn_adotar_1, btn_adotar_2, btn_adotar_3, btn_adotar_4, btn_adotar_5]
+
+    slider_grau_coef.change(
+        _rebuscar_transformacoes,
+        inputs=_inputs_rebuscar,
+        outputs=_outputs_rebuscar
+    )
+
+    slider_grau_f.change(
+        _rebuscar_transformacoes,
+        inputs=_inputs_rebuscar,
+        outputs=_outputs_rebuscar
+    )
+
+    # Aplicar filtros de outliers
+    btn_aplicar_filtro.click(
+        aplicar_filtros_callback,
+        inputs=[estado_metricas, estado_n_filtros] + filtro_vars + filtro_ops + filtro_vals,
+        outputs=[outliers_texto]
+    )
+
+    # Adicionar filtro
+    btn_adicionar_filtro.click(
+        adicionar_filtro_callback,
+        inputs=[estado_n_filtros],
+        outputs=[estado_n_filtros] + filtro_rows
+    )
+
+    # Remover último filtro
+    btn_remover_ultimo.click(
+        remover_ultimo_filtro_callback,
+        inputs=[estado_n_filtros],
+        outputs=[estado_n_filtros] + filtro_rows
+    )
+
+    # Resetar filtros ao padrão
+    btn_resetar_filtros.click(
+        limpar_filtros_callback,
+        inputs=[],
+        outputs=[estado_n_filtros] + filtro_rows + filtro_vars + filtro_ops + filtro_vals + [outliers_texto]
+    )
+
+    # Atualizar resumo de outliers quando usuário edita os campos
+    outliers_texto.change(
+        atualizar_resumo_outliers,
+        inputs=[estado_outliers_anteriores, outliers_texto, reincluir_texto],
+        outputs=[txt_resumo_outliers]
+    )
+
+    reincluir_texto.change(
+        atualizar_resumo_outliers,
+        inputs=[estado_outliers_anteriores, outliers_texto, reincluir_texto],
+        outputs=[txt_resumo_outliers]
+    )
+
+    # Aplicar filtro também atualiza o resumo
+    btn_aplicar_filtro.click(
+        atualizar_resumo_outliers,
+        inputs=[estado_outliers_anteriores, outliers_texto, reincluir_texto],
+        outputs=[txt_resumo_outliers]
+    )
+
+    # Download da base tratada (CSV)
+    def download_base_callback(df_filtrado, df_original):
+        """Callback para download da base tratada."""
+        # Usa df_filtrado se disponível, senão usa df_original
+        df_para_exportar = df_filtrado if df_filtrado is not None else df_original
+
+        if df_para_exportar is None:
+            return gr.update(value=None, visible=False)
+
+        try:
+            if hasattr(df_para_exportar, 'empty') and df_para_exportar.empty:
+                return gr.update(value=None, visible=False)
+
+            caminho = exportar_base_csv(df_para_exportar)
+            if caminho:
+                return gr.update(value=caminho, visible=True)
+            else:
+                return gr.update(value=None, visible=False)
+        except Exception as e:
+            print(f"Erro ao exportar CSV: {e}")
+            return gr.update(value=None, visible=False)
+
+    btn_download_base.click(
+        download_base_callback,
+        inputs=[estado_df_filtrado, estado_df],
+        outputs=[download_base_file]
+    )
+
+    # Botões "Adotar Sugestão"
+    btn_adotar_1.click(
+        lambda res, cols_x: adotar_sugestao(0, res, cols_x),
+        inputs=[estado_resultados_busca, checkboxes_x],
+        outputs=[transformacao_y] + transf_x_dropdowns
+    )
+    btn_adotar_2.click(
+        lambda res, cols_x: adotar_sugestao(1, res, cols_x),
+        inputs=[estado_resultados_busca, checkboxes_x],
+        outputs=[transformacao_y] + transf_x_dropdowns
+    )
+    btn_adotar_3.click(
+        lambda res, cols_x: adotar_sugestao(2, res, cols_x),
+        inputs=[estado_resultados_busca, checkboxes_x],
+        outputs=[transformacao_y] + transf_x_dropdowns
+    )
+    btn_adotar_4.click(
+        lambda res, cols_x: adotar_sugestao(3, res, cols_x),
+        inputs=[estado_resultados_busca, checkboxes_x],
+        outputs=[transformacao_y] + transf_x_dropdowns
+    )
+    btn_adotar_5.click(
+        lambda res, cols_x: adotar_sugestao(4, res, cols_x),
+        inputs=[estado_resultados_busca, checkboxes_x],
+        outputs=[transformacao_y] + transf_x_dropdowns
+    )
+
+    # Ajustar modelo (usa dados filtrados se disponíveis) e calcula métricas de outliers
+    dropdown_tipo_grafico_dispersao.change(
+        fn=ao_mudar_tipo_grafico,
+        inputs=[dropdown_tipo_grafico_dispersao, estado_modelo],
+        outputs=[plot_dispersao_transf]
+    )
+
+    btn_ajustar.click(
+        lambda df_filt, df_orig, col_y, cols_x, transf_y, outliers_ant, dicot, cod_aloc, perc, *dd_vals: ajustar_modelo_callback(
+            df_filt if df_filt is not None else df_orig, col_y, cols_x, transf_y, outliers_ant, dicot, cod_aloc, perc, *dd_vals
+        ),
+        inputs=_inputs_ajustar,
+        outputs=_outputs_ajustar
+    ).then(
+        popular_campos_avaliacao_callback,
+        inputs=[estado_modelo, tabela_estatisticas],
+        outputs=_outputs_popular_avaliacao
+    )
+
+    # Reiniciar iteração (combina outliers e recomeça) e depois ajusta o modelo
+    btn_reiniciar_iteracao.click(
+        reiniciar_iteracao_callback,
+        inputs=[
+            estado_df, estado_outliers_anteriores, outliers_texto, reincluir_texto,
+            estado_iteracao, dropdown_y, checkboxes_x, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais, slider_grau_coef, slider_grau_f
+        ],
+        outputs=[
+            estado_outliers_anteriores,
+            estado_iteracao,
+            estado_df_filtrado,
+            tabela_dados,
+            tabela_estatisticas,
+            header_secao_5,
+            html_outliers_anteriores,
+            html_outliers_sec14,
+            accordion_outliers_anteriores,
+            outliers_texto,
+            reincluir_texto,
+            tabela_metricas,
+            estado_metricas,
+            header_secao_13,
+            txt_resumo_outliers,
+            mapa_html,
+            # Novos outputs para seções 2, 6, 7, 8
+            header_secao_2,
+            html_micronumerosidade,
+            header_secao_6,
+            plot_dispersao,
+            header_secao_7,
+            busca_html,
+            estado_resultados_busca,
+            header_secao_8,
+            btn_adotar_1, btn_adotar_2, btn_adotar_3, btn_adotar_4, btn_adotar_5,
+            slider_grau_coef,
+            slider_grau_f,
+        ]
+    ).then(
+        # Após reiniciar, ajusta modelo automaticamente para calcular métricas de outliers
+        lambda df_filt, df_orig, col_y, cols_x, transf_y, outliers_ant, dicot, cod_aloc, perc, *dd_vals: ajustar_modelo_callback(
+            df_filt if df_filt is not None else df_orig, col_y, cols_x, transf_y, outliers_ant, dicot, cod_aloc, perc, *dd_vals
+        ),
+        inputs=_inputs_ajustar,
+        outputs=_outputs_ajustar
+    ).then(
+        popular_campos_avaliacao_callback,
+        inputs=[estado_modelo, tabela_estatisticas],
+        outputs=_outputs_popular_avaliacao
+    ).then(
+        fn=None,
+        inputs=None,
+        outputs=None,
+        js="""() => {
+            if ('parentIFrame' in window) {
+                window.parentIFrame.scrollTo({top: 0, behavior: 'smooth'});
+            } else {
+                window.scrollTo({top: 0, behavior: 'smooth'});
+            }
+        }"""
+    )
+
+    # Limpar histórico de outliers
+    btn_limpar_historico.click(
+        limpar_historico_callback,
+        inputs=[estado_df],
+        outputs=[
+            estado_outliers_anteriores,
+            estado_iteracao,
+            estado_df_filtrado,
+            tabela_dados,
+            tabela_estatisticas,
+            mapa_html,
+            html_outliers_anteriores,
+            accordion_outliers_anteriores,
+            header_secao_2,
+            # Reset seções 4-16 (states)
+            estado_modelo, estado_metricas, estado_resultados_busca, estado_avaliacoes,
+            # Headers, accordions e conteúdo das seções 4-16
+            header_secao_4, accordion_secao_4, checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais,
+            html_aviso_multicolinearidade,
+            header_secao_5, accordion_secao_5,
+            header_secao_6, accordion_secao_6, html_micronumerosidade,
+            header_secao_7, accordion_secao_7, plot_dispersao,
+            header_secao_8, accordion_secao_8, slider_grau_coef, slider_grau_f, busca_html,
+            header_secao_9, accordion_secao_9, transformacao_y,
+            btn_adotar_1, btn_adotar_2, btn_adotar_3, btn_adotar_4, btn_adotar_5,
+        ] + transf_x_rows + transf_x_columns + transf_x_labels + transf_x_dropdowns + [
+            header_secao_10, accordion_secao_10, dropdown_tipo_grafico_dispersao, plot_dispersao_transf,
+            header_secao_11, accordion_secao_11, diagnosticos_html, tabela_coef, tabela_obs_calc,
+            header_secao_12, accordion_secao_12, plot_obs_calc, plot_residuos, plot_hist, plot_cook, plot_corr,
+            header_secao_13, accordion_secao_13, tabela_metricas,
+            header_secao_14, accordion_secao_14, html_outliers_sec14, outliers_texto, reincluir_texto, txt_resumo_outliers,
+            # Seção 15: Avaliação de Imóvel
+            header_secao_15, accordion_secao_15,
+        ] + aval_rows + aval_inputs + [
+            resultado_avaliacao_html, dropdown_base_avaliacao, excluir_aval_trigger, download_avaliacoes_file,
+            # Seção 16: Exportar Modelo
+            header_secao_16, accordion_secao_16, nome_arquivo, status_exportar,
+        ] + filtro_vars
+    )
+
+    # Exportar (usa dados filtrados se disponíveis)
+    btn_exportar.click(
+        lambda res_modelo, df_filt, df_orig, stats, nome, elab_nome, outliers: exportar_modelo_callback(
+            res_modelo, df_filt if df_filt is not None else df_orig, df_orig, stats, nome,
+            _avaliadores_dict.get(elab_nome) if elab_nome else None,
+            outliers or []
+        ),
+        inputs=[estado_modelo, estado_df_filtrado, estado_df, tabela_estatisticas, nome_arquivo, dropdown_elaborador, estado_outliers_anteriores],
+        outputs=[status_exportar, download_modelo_file]
+    )
+
+    # Avaliação de imóvel (seção 15)
+    btn_calcular_avaliacao.click(
+        avaliar_imovel_callback,
+        inputs=[estado_modelo, tabela_estatisticas, estado_avaliacoes, dropdown_base_avaliacao] + aval_inputs,
+        outputs=[resultado_avaliacao_html, estado_avaliacoes, dropdown_base_avaliacao]
+    )
+
+    btn_limpar_avaliacoes.click(
+        limpar_avaliacoes_callback,
+        inputs=[],
+        outputs=[resultado_avaliacao_html, estado_avaliacoes, dropdown_base_avaliacao]
+    )
+
+    excluir_aval_trigger.change(
+        excluir_avaliacao_callback,
+        inputs=[excluir_aval_trigger, estado_avaliacoes, dropdown_base_avaliacao],
+        outputs=[resultado_avaliacao_html, estado_avaliacoes, dropdown_base_avaliacao, excluir_aval_trigger]
+    )
+
+    dropdown_base_avaliacao.change(
+        atualizar_base_avaliacao_callback,
+        inputs=[estado_avaliacoes, dropdown_base_avaliacao],
+        outputs=[resultado_avaliacao_html]
+    )
+
+    btn_exportar_avaliacoes.click(
+        exportar_avaliacoes_excel_callback,
+        inputs=[estado_avaliacoes],
+        outputs=[download_avaliacoes_file]
+    )
+
+    # Downloads de tabelas
+    btn_download_estatisticas.click(
+        lambda df: download_tabela_callback(df, "estatisticas"),
+        inputs=[tabela_estatisticas],
+        outputs=[download_estatisticas_file]
+    )
+
+    btn_download_dados.click(
+        lambda df: download_tabela_callback(df, "dados"),
+        inputs=[tabela_dados],
+        outputs=[download_dados_file]
+    )
+
+    btn_download_coef.click(
+        lambda df: download_tabela_callback(df, "coeficientes"),
+        inputs=[tabela_coef],
+        outputs=[download_coef_file]
+    )
+
+    btn_download_obs_calc.click(
+        lambda df: download_tabela_callback(df, "obs_calc"),
+        inputs=[tabela_obs_calc],
+        outputs=[download_obs_calc_file]
+    )
+
+    btn_download_metricas.click(
+        lambda df: download_tabela_callback(df, "metricas"),
+        inputs=[tabela_metricas],
+        outputs=[download_metricas_file]
+    )
+
+
+
+# ============================================================
+# MAIN
+# ============================================================
+
+if __name__ == "__main__":
+    css = carregar_css()
+    with gr.Blocks(title="Elaboração de Modelos", css=css) as app:
+        gr.Markdown(TITULO)
+        criar_aba()
+    app.queue().launch()

backend/app/core/elaboracao/avaliadores.json

@@ -0,0 +1,74 @@
+{
+  "avaliadores": [
+    {
+      "nome_completo": "David Schuch Bertoglio",
+      "titulo": "Coordenador da Equipe de Suporte, Judiciais e Locações",
+      "cargo": "Engenheiro",
+      "conselho": "CREA",
+      "numero_conselho": "114.44",
+      "estado_conselho": "RS",
+      "matricula_sem_digito": "95654801",
+      "lotacao": "SMF/RM/DAI/ESJL"
+    },
+    {
+      "nome_completo": "Jéssica Lange",
+      "titulo": "Auxiliar da Equipe de Avaliações",
+      "cargo": "Arquiteta",
+      "conselho": "CAU",
+      "numero_conselho": "A64935-0",
+      "estado_conselho": "RS",
+      "matricula_sem_digito": "1279688",
+      "lotacao": "EAV/DAI/RM/SMF"
+    },
+    {
+      "nome_completo": "Debora Fonseca Alves",
+      "titulo": "Auxiliar da Equipe de Avaliações",
+      "cargo": "Engenheira",
+      "conselho": "CREA",
+      "numero_conselho": "190.257",
+      "estado_conselho": "RS",
+      "matricula_sem_digito": "1507850",
+      "lotacao": "SMF/RM/DAI/EAV"
+    },
+    {
+      "nome_completo": "Vanessa Staats Basso",
+      "titulo": "Auxiliar da Equipe de Avaliações",
+      "cargo": "Engenheira",
+      "conselho": "CREA",
+      "numero_conselho": "194.957",
+      "estado_conselho": "RS",
+      "matricula_sem_digito": "1507540",
+      "lotacao": "SMF/RM/DAI/EAV"
+    },
+    {
+      "nome_completo": "Fernanda Pontel",
+      "titulo": "Auxiliar da Equipe de Suporte, Judiciais e Locações",
+      "cargo": "Arquiteta",
+      "conselho": "CAU",
+      "numero_conselho": "A50731-8",
+      "estado_conselho": "RS",
+      "matricula_sem_digito": "1036130",
+      "lotacao": "SMF/RM/DAI/ESJL"
+    },
+    {
+      "nome_completo": "Adriana Kirsch Bissigo",
+      "titulo": "Auxiliar da Equipe de Suporte, Judiciais e Locações",
+      "cargo": "Engenheira",
+      "conselho": "CREA_RS",
+      "numero_conselho": "69342",
+      "estado_conselho": "RS",
+      "matricula_sem_digito": "188661",
+      "lotacao": "SMF/RM/DAI/ESJL"
+    },
+    {
+      "nome_completo": "Roberta Brenner Ayub",
+      "titulo": "Arquiteta da Equipe de Suporte, Judiciais e Locações",
+      "cargo": "Arquiteta",
+      "conselho": "CAU",
+      "numero_conselho": "A29665-1",
+      "estado_conselho": "RS",
+      "matricula_sem_digito": "370440",
+      "lotacao": "SMF/RM/DAI/ESJL"
+    }
+  ]
+}

backend/app/core/elaboracao/carregamento.py

@@ -0,0 +1,623 @@
+# -*- coding: utf-8 -*-
+"""
+carregamento.py - Carga de arquivos, reset de estado e inicialização.
+
+Callbacks que lidam com upload de CSV/Excel/.dai,
+seleção de aba Excel, reset de seções e limpar histórico.
+"""
+
+import gradio as gr
+import os
+from datetime import datetime, timezone, timedelta
+
+from .formatadores import arredondar_df, criar_header_secao, formatar_lista_variaveis_html
+from .modelo import (
+    aplicar_selecao_callback,
+    ajustar_modelo_callback,
+    MAX_VARS_X,
+)
+from .core import (
+    detectar_abas_excel,
+    carregar_arquivo,
+    carregar_dai,
+    obter_colunas_numericas,
+    identificar_coluna_y_padrao,
+    formatar_transformacao,
+)
+from .charts import criar_mapa
+from .geocodificacao import verificar_coords, auto_detectar_colunas_geo, padronizar_coords
+
+
+# ============================================================
+# RESET DE SEÇÕES
+# ============================================================
+
+def _valores_reset_secoes_4_a_16():
+    """Valores de reset para seções 4-16 (headers, accordions e conteúdo).
+
+    Headers são resetados para remover timestamps. Accordions são fechados.
+    Usado por carregar_dados_do_arquivo e limpar_historico_callback para limpar
+    todas as seções quando um novo arquivo é carregado ou o histórico é resetado.
+
+    CONTRACT: Retorna 156 itens.
+    Se alterar, atualizar: TODAS as funções neste arquivo que retornam 193 itens
+    (ao_carregar_arquivo, _resultado_selecao_aba, confirmar_aba_callback,
+    carregar_dados_de_dai, carregar_dados_do_arquivo) + limpar_historico_callback.
+    """
+    n_rows = (MAX_VARS_X + 7) // 8  # 3
+    return (
+        # States
+        None,   # estado_modelo
+        None,   # estado_metricas
+        [],     # estado_resultados_busca
+        [],     # estado_avaliacoes
+        # Section 4
+        gr.update(value=criar_header_secao(4, "Selecionar Variáveis Independentes")),  # header_secao_4
+        gr.update(visible=False),  # accordion_secao_4
+        gr.update(choices=[], value=[], visible=False),  # checkboxes_dicotomicas
+        gr.update(choices=[], value=[], visible=False),  # checkboxes_codigo_alocado
+        gr.update(choices=[], value=[], visible=False),  # checkboxes_percentuais
+        gr.update(value="", visible=False),              # html_aviso_multicolinearidade
+        # Section 5
+        gr.update(value=criar_header_secao(5, "Estatísticas das Variáveis Selecionadas")),  # header_secao_5
+        gr.update(visible=False),  # accordion_secao_5
+        # Section 6
+        gr.update(value=criar_header_secao(6, "Teste de Micronumerosidade (NBR 14.653-2)")),  # header_secao_6
+        gr.update(visible=False),  # accordion_secao_6
+        "",  # html_micronumerosidade
+        # Section 7
+        gr.update(value=criar_header_secao(7, "Gráficos de Dispersão das Variáveis Independentes")),  # header_secao_7
+        gr.update(visible=False),  # accordion_secao_7
+        None,  # plot_dispersao
+        # Section 8
+        gr.update(value=criar_header_secao(8, "Transformações Sugeridas")),  # header_secao_8
+        gr.update(visible=False),  # accordion_secao_8
+        gr.update(value=3),  # slider_grau_coef
+        gr.update(value=3),  # slider_grau_f
+        "",  # busca_html
+        # Section 9
+        gr.update(value=criar_header_secao(9, "Aplicação das Transformações")),  # header_secao_9
+        gr.update(visible=False),  # accordion_secao_9
+        gr.update(value="(x)"),  # transformacao_y
+        *[gr.update(visible=False) for _ in range(5)],  # btn_adotar 1-5
+        gr.update(visible=False),                         # transf_y_row
+        gr.update(visible=False),                         # transf_y_col
+        gr.update(value="", visible=False),               # transf_y_label
+        # transf_x_rows, transf_x_columns, transf_x_labels, transf_x_dropdowns (63 itens)
+        *[gr.update(visible=False) for _ in range(n_rows)],
+        *[gr.update(visible=False) for _ in range(MAX_VARS_X)],
+        *[gr.update(value="", visible=False) for _ in range(MAX_VARS_X)],
+        *[gr.update(value="(x)", interactive=True, visible=False) for _ in range(MAX_VARS_X)],
+        # Section 10
+        gr.update(value=criar_header_secao(10, "Gráficos de Dispersão (Variáveis Transformadas)")),  # header_secao_10
+        gr.update(visible=False),  # accordion_secao_10
+        gr.update(value="Variáveis Independentes Transformadas X Variável Dependente Transformada", visible=False),  # dropdown_tipo_grafico_dispersao
+        None,  # plot_dispersao_transf
+        # Section 11
+        gr.update(value=criar_header_secao(11, "Diagnóstico de Modelo")),  # header_secao_11
+        gr.update(visible=False),  # accordion_secao_11
+        "",  # diagnosticos_html
+        None,  # tabela_coef
+        None,  # tabela_obs_calc
+        # Section 12
+        gr.update(value=criar_header_secao(12, "Gráficos de Diagnóstico do Modelo")),  # header_secao_12
+        gr.update(visible=False),  # accordion_secao_12
+        None, None, None, None, None,  # plots: obs_calc, residuos, hist, cook, corr
+        # Section 13
+        gr.update(value=criar_header_secao(13, "Analisar Outliers")),  # header_secao_13
+        gr.update(visible=False),  # accordion_secao_13
+        None,  # tabela_metricas
+        # Section 14 (exclusão)
+        gr.update(value=criar_header_secao(14, "Exclusão ou Reinclusão de Outliers")),  # header_secao_14
+        gr.update(visible=False),  # accordion_secao_14
+        "",  # html_outliers_sec14
+        "",  # outliers_texto
+        "",  # reincluir_texto
+        "Excluídos: 0 | A excluir: 0 | A reincluir: 0 | Total: 0",  # txt_resumo_outliers
+        # Section 15 (Avaliação de Imóvel)
+        gr.update(value=criar_header_secao(15, "Avaliação de Imóvel")),  # header_secao_15
+        gr.update(visible=False),  # accordion_secao_15
+        *[gr.update(visible=False) for _ in range(MAX_VARS_X // 4)],  # aval_rows (5)
+        *[gr.update(visible=False, value=None, label="") for _ in range(MAX_VARS_X)],  # aval_inputs (20)
+        "",  # resultado_avaliacao_html
+        gr.update(choices=[], value=None),  # dropdown_base_avaliacao
+        "",  # excluir_aval_trigger
+        gr.update(value=None, visible=False),  # download_avaliacoes_file
+        # Section 16 (Exportar Modelo)
+        gr.update(value=criar_header_secao(16, "Exportar Modelo")),  # header_secao_16
+        gr.update(visible=False),  # accordion_secao_16
+        gr.update(value=""),  # nome_arquivo
+        gr.update(value=""),  # status_exportar
+    )
+
+
+# ============================================================
+# CALLBACKS DE CARREGAMENTO
+# ============================================================
+
+def ao_carregar_arquivo(arquivo):
+    """Callback quando arquivo é carregado. Detecta se há múltiplas abas no Excel.
+
+    CONTRACT: Retorna 193 itens para _outputs_carregar (app.py:criar_aba).
+    Se alterar, atualizar: _outputs_carregar em app.py + TODAS as 5 funções neste arquivo.
+    """
+    caminho_arquivo = arquivo.name if hasattr(arquivo, 'name') else str(arquivo)
+    nome_exibicao = "Arquivo carregado: " + os.path.basename(caminho_arquivo)
+
+    # Se for arquivo .dai, carrega modelo completo
+    if caminho_arquivo.endswith('.dai'):
+        return carregar_dados_de_dai(caminho_arquivo)
+
+    # Detecta abas do Excel
+    abas, msg_abas, sucesso_abas = detectar_abas_excel(caminho_arquivo)
+
+    # Se há múltiplas abas, mostra seletor de aba (não carrega dados ainda)
+    if sucesso_abas and len(abas) > 1:
+        return _resultado_selecao_aba(caminho_arquivo, abas)
+
+    # Se não há múltiplas abas, carrega diretamente
+    return carregar_dados_do_arquivo(caminho_arquivo, None,
+                                     nome_arquivo_exibicao=nome_exibicao)
+
+
+def _resultado_selecao_aba(caminho_arquivo, abas):
+    """Retorna tupla para estado B: mostra seletor de aba, não carrega dados ainda.
+
+    CONTRACT: Retorna 193 itens para _outputs_carregar (app.py:criar_aba).
+    """
+    return (
+        None,  # estado_df (sem dados ainda)
+        "Arquivo com múltiplas abas detectado. Selecione uma aba e confirme.",  # status
+        gr.update(choices=abas, value=abas[0]),  # dropdown_aba
+        gr.update(choices=[], value=None),  # dropdown_y
+        None,  # tabela_dados
+        None,  # tabela_estatisticas
+        gr.update(choices=[]),  # checkboxes_x
+        "<p>Carregue um arquivo para ver o mapa.</p>",  # mapa
+        None,  # estado_df_filtrado
+        [],    # estado_outliers_anteriores
+        1,     # estado_iteracao
+        gr.update(visible=False),  # accordion_outliers_anteriores
+        "",                        # html_outliers_anteriores
+        caminho_arquivo,  # estado_arquivo_temp (manter caminho para confirmar_aba)
+        # Seções 2 e 3 - ocultas
+        gr.update(visible=False),  # header_secao_2
+        gr.update(visible=False),  # accordion_secao_2
+        gr.update(choices=["Visualização Padrão"], value="Visualização Padrão"),  # dropdown_mapa_var
+        gr.update(visible=False),  # header_secao_3
+        gr.update(visible=False),  # accordion_secao_3
+        # Reset seções 4-16
+        *_valores_reset_secoes_4_a_16(),
+        # Controles de visibilidade da seção 1
+        gr.update(visible=False),   # row_upload (ocultar upload)
+        gr.update(visible=True),    # row_selecao_aba (mostrar seletor de aba)
+        gr.update(visible=False),   # row_pos_carga (ocultar restart)
+        gr.update(value=""),        # html_nome_arquivo_carregado
+        False,                      # estado_flag_carregamento
+        *[gr.update()] * 4,         # filtro_vars (no-op)
+        # Painel de coordenadas (no-op — dados ainda não carregados)
+        gr.update(visible=False), gr.update(value=""),
+        gr.update(choices=[]), gr.update(choices=[]),
+        gr.update(choices=[], value=None), gr.update(choices=[], value=None),
+        gr.update(visible=True),   # row_escolha_opcao — reset para tela de escolha
+        gr.update(visible=False),  # row_opcao_mapear
+        gr.update(visible=False),  # row_opcao_geocodificar
+    )
+
+
+def confirmar_aba_callback(caminho_arquivo, nome_aba):
+    """Callback quando usuário confirma seleção de aba para Excel multi-aba.
+
+    CONTRACT: Retorna 193 itens para _outputs_carregar (app.py:criar_aba).
+    """
+    if caminho_arquivo is None or nome_aba is None:
+        return (
+            None, "Erro: arquivo não encontrado. Recarregue a página.",
+            gr.update(choices=[], value=None),  # dropdown_aba
+            gr.update(choices=[], value=None),  # dropdown_y
+            None, None, gr.update(choices=[]),
+            "<p>Carregue um arquivo para ver o mapa.</p>",
+            None, [], 1, gr.update(visible=False),
+            "", None,
+            gr.update(visible=False), gr.update(visible=False),
+            gr.update(choices=["Visualização Padrão"], value="Visualização Padrão"),
+            gr.update(visible=False), gr.update(visible=False),
+            *_valores_reset_secoes_4_a_16(),
+            # Volta ao estado de upload em caso de erro
+            gr.update(visible=True),   # row_upload
+            gr.update(visible=False),  # row_selecao_aba
+            gr.update(visible=False),  # row_pos_carga
+            gr.update(value=""),       # html_nome_arquivo_carregado
+            False,                     # estado_flag_carregamento
+            *[gr.update()] * 4,        # filtro_vars (no-op)
+            # Painel de coordenadas (no-op — erro)
+            gr.update(visible=False), gr.update(value=""),
+            gr.update(choices=[]), gr.update(choices=[]),
+            gr.update(choices=[], value=None), gr.update(choices=[], value=None),
+            gr.update(visible=True),   # row_escolha_opcao — reset para tela de escolha
+            gr.update(visible=False),  # row_opcao_mapear
+            gr.update(visible=False),  # row_opcao_geocodificar
+        )
+
+    nome_exibicao = "Arquivo carregado: "+os.path.basename(caminho_arquivo)
+    nome_exibicao_completo = f"{nome_exibicao} — Aba: {nome_aba}"
+    return carregar_dados_do_arquivo(caminho_arquivo, nome_aba,
+                                     nome_arquivo_exibicao=nome_exibicao_completo)
+
+
+def carregar_dados_de_dai(caminho_arquivo):
+    """Carrega arquivo .dai e popula toda a interface com o modelo reconstruído.
+
+    Executa o mesmo fluxo que o usuário faria manualmente:
+    1. Carrega dados (como carregar_dados_do_arquivo)
+    2. Aplica seleção de variáveis (como aplicar_selecao_callback)
+    3. Sobrescreve transformações com valores do .dai
+    4. Ajusta modelo (como ajustar_modelo_callback)
+
+    CONTRACT: Retorna 196 itens para _outputs_carregar (app.py:criar_aba).
+    Consome aplicar_selecao_callback por índice (r[0], r[1], ..., r[23:]).
+    Consome ajustar_modelo_callback por índice (m[0], ..., m[32]).
+    """
+    df, coluna_y, colunas_x, transformacao_y, transformacoes_x, dicotomicas, codigo_alocado, percentuais, msg, sucesso, elaborador, outliers_excluidos = carregar_dai(caminho_arquivo)
+
+    nome_exibicao = os.path.basename(caminho_arquivo)
+    html_nome = f"<h2 style='margin:0 0 12px 0; font-size:1.4em;'>{nome_exibicao}</h2>"
+    if elaborador:
+        nome_elab = elaborador.get("nome_completo", "")
+        cargo = elaborador.get("cargo", "")
+        conselho = elaborador.get("conselho", "")
+        num_conselho = elaborador.get("numero_conselho", "")
+        estado_conselho = elaborador.get("estado_conselho", "")
+        matricula = elaborador.get("matricula_sem_digito", "")
+        lotacao = elaborador.get("lotacao", "")
+        linha2 = f"{cargo} · {conselho}/{estado_conselho} {num_conselho}" if cargo else ""
+        linha3 = f"Matrícula: {matricula} · {lotacao}" if matricula else ""
+        if nome_elab:
+            info_variaveis = (
+                [f"{coluna_y}: {formatar_transformacao(transformacao_y, is_y=True)}"]
+                + [f"{col}: {formatar_transformacao(transformacoes_x.get(col, '(x)'))}"
+                   for col in colunas_x]
+            )
+            variaveis_lado_direito = formatar_lista_variaveis_html(info_variaveis)
+            html_nome += (
+                '<div style="display:flex; justify-content:space-between; align-items:flex-start; '
+                'gap:24px; background:#e9ecef; border-left:5px solid #6c757d; '
+                'border-radius:6px; padding:14px 18px; color:#495057; line-height:1.8; margin-top:8px;">'
+                '<div>'
+                f'<span style="display:block; font-size:1.15em; font-weight:600; color:#212529; margin-bottom:4px;">{nome_elab}</span>'
+                + (f'<span style="display:block; font-size:1em;">{linha2}</span>' if linha2 else '')
+                + (f'<span style="display:block; font-size:0.95em; color:#6c757d;">{linha3}</span>' if linha3 else '')
+                + '</div>'
+                + f'<div>{variaveis_lado_direito}</div>'
+                + '</div>'
+            )
+
+    if outliers_excluidos:
+        lista_str = ", ".join(map(str, sorted(outliers_excluidos)))
+        n = len(outliers_excluidos)
+        html_outliers_content = (
+            '<div style="display:flex; gap:16px; align-items:baseline; padding:10px 16px; '
+            'background:var(--background-fill-secondary,#f8f9fa); border-radius:8px; '
+            'border:1px solid var(--border-color-primary,#e2e8f0); flex-wrap:wrap;">'
+            f'<span style="font-weight:600; color:var(--body-text-color,#495057); white-space:nowrap;">'
+            f'{n} outlier(s) excluídos do modelo ajustado</span>'
+            f'<span style="color:var(--body-text-color-subdued,#6c757d); font-size:0.92em;">'
+            f'Índices: {lista_str}</span>'
+            '</div>'
+        )
+    else:
+        html_outliers_content = ""
+
+    if not sucesso:
+        return (
+            None, msg, gr.update(), gr.update(choices=[], value=None),
+            None, None, gr.update(choices=[]), "<p>Erro ao carregar modelo.</p>",
+            None, [], 1, gr.update(visible=False),
+            "", None,
+            gr.update(visible=False), gr.update(visible=False),
+            gr.update(choices=["Visualização Padrão"], value="Visualização Padrão"),
+            gr.update(visible=False), gr.update(visible=False),
+            *_valores_reset_secoes_4_a_16(),
+            # Volta ao estado de upload em caso de erro
+            gr.update(visible=True),   # row_upload
+            gr.update(visible=False),  # row_selecao_aba
+            gr.update(visible=False),  # row_pos_carga
+            gr.update(value=""),       # html_nome_arquivo_carregado
+            False,                     # estado_flag_carregamento
+            *[gr.update()] * 4,        # filtro_vars (no-op)
+            # Painel de coordenadas (no-op — .dai isento)
+            gr.update(visible=False), gr.update(value=""),
+            gr.update(choices=[]), gr.update(choices=[]),
+            gr.update(choices=[], value=None), gr.update(choices=[], value=None),
+            gr.update(visible=True),   # row_escolha_opcao — reset para tela de escolha
+            gr.update(visible=False),  # row_opcao_mapear
+            gr.update(visible=False),  # row_opcao_geocodificar
+        )
+
+    colunas_numericas = obter_colunas_numericas(df)
+    gmt_minus_3 = timezone(timedelta(hours=-3))
+    timestamp = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
+    mapa_html_val = criar_mapa(df)
+
+    # --- Passo 2: Simula "Aplicar Seleção" (seções 5-9) ---
+    r = aplicar_selecao_callback(df, coluna_y, colunas_x, outliers_excluidos, dicotomicas, codigo_alocado, percentuais)
+    # r: [df_filtrado, tabela_est, html_micro, plot_disp, slider_coef, slider_f,
+    #     busca_html, resultados, btn1-5(5), secoes5-9 headers/accordions(10), campos_transf(66)]
+
+    # --- Passo 3: Sobrescreve dropdowns de transformação com valores do .dai ---
+    campos_transf = list(r[23:89])  # 66 itens: y_row(1)+y_col(1)+y_label(1)+rows(3)+columns(20)+labels(20)+dropdowns(20)
+    n_rows = (MAX_VARS_X + 7) // 8
+    dropdown_offset = 3 + n_rows + MAX_VARS_X + MAX_VARS_X  # 3 + 3 + 20 + 20 = 46
+    for i, col in enumerate(colunas_x):
+        if i < MAX_VARS_X:
+            # Dicotômicas e percentuais: travar. Código alocado: livre.
+            travar = col in dicotomicas or col in percentuais
+            campos_transf[dropdown_offset + i] = gr.update(
+                value=transformacoes_x.get(col, "(x)"),
+                interactive=not travar,
+                visible=True
+            )
+
+    # --- Passo 4: Simula "Ajustar Modelo" (seções 10-16) ---
+    df_para_ajuste = r[0] if r[0] is not None else df  # df filtrado (sem outliers excluídos)
+    dropdown_vals = [transformacoes_x.get(colunas_x[i], "(x)") if i < len(colunas_x) else "(x)"
+                     for i in range(MAX_VARS_X)]
+    m = ajustar_modelo_callback(df_para_ajuste, coluna_y, colunas_x, transformacao_y, outliers_excluidos, dicotomicas, codigo_alocado, percentuais, *dropdown_vals)
+    # m[0]:resultado  [1]:diag  [2]:coef  [3]:obs_calc  [4]:plot_disp  [5]:dropdown
+    # m[6-10]:plots  [11]:metricas  [12]:est_metricas  [13]:resumo
+    # m[14]:estado_avaliacoes
+    # m[15-16]:h10,a10  [17-18]:h11,a11  [19-20]:h12,a12  [21-22]:h13,a13
+    # m[23-24]:h14,a14  [25-26]:h15_aval,a15_aval  [27-28]:h16_exp,a16_exp
+    # m[29-32]:filtro_vars
+
+    n_aval_rows = MAX_VARS_X // 4  # 5
+
+    return (
+        # --- Seções 1-3: dados básicos ---
+        df,                                                     # estado_df
+        msg,                                                    # status
+        gr.update(),                                            # dropdown_aba (no-op)
+        gr.update(choices=colunas_numericas, value=coluna_y),   # dropdown_y
+        arredondar_df(df),                                      # tabela_dados
+        r[1],                                                   # tabela_estatisticas (de aplicar_selecao)
+        gr.update(choices=colunas_numericas, value=colunas_x),  # checkboxes_x
+        mapa_html_val,                                          # mapa
+        r[0],                                                   # estado_df_filtrado (de aplicar_selecao)
+        outliers_excluidos,                                     # estado_outliers_anteriores
+        1,                                                      # estado_iteracao
+        gr.update(visible=bool(outliers_excluidos)),             # accordion_outliers_anteriores
+        html_outliers_content,                                  # html_outliers_anteriores
+        None,                                                   # estado_arquivo_temp
+        gr.update(visible=True, value=criar_header_secao(2, "Visualizar Dados", timestamp)),
+        gr.update(visible=True, open=True),                     # accordion_secao_2
+        gr.update(choices=["Visualização Padrão"] + colunas_numericas, value="Visualização Padrão"),
+        gr.update(visible=True),                                # header_secao_3
+        gr.update(visible=True, open=True),                     # accordion_secao_3
+        # --- States seções 4-16 ---
+        m[0],                                                   # estado_modelo (de ajustar)
+        m[12],                                                  # estado_metricas (de ajustar)
+        r[7],                                                   # estado_resultados_busca (de aplicar_selecao)
+        m[14],                                                  # estado_avaliacoes (de ajustar — reset [])
+        # --- Seção 4: seleção de variáveis ---
+        gr.update(visible=True, value=criar_header_secao(4, "Selecionar Variáveis Independentes", timestamp)),
+        gr.update(visible=True, open=True),                     # accordion_secao_4
+        gr.update(choices=list(colunas_x), value=list(dicotomicas), visible=True),           # checkboxes_dicotomicas
+        gr.update(choices=list(colunas_x), value=list(codigo_alocado), visible=True),      # checkboxes_codigo_alocado
+        gr.update(choices=list(colunas_x), value=list(percentuais), visible=True),         # checkboxes_percentuais
+        gr.update(value="", visible=False),                                                  # html_aviso_multicolinearidade
+        # --- Seções 5-9: headers/accordions (de aplicar_selecao) ---
+        r[13], r[14],                                           # header_secao_5, accordion_secao_5
+        r[15], r[16],                                           # header_secao_6, accordion_secao_6
+        r[2],                                                   # html_micronumerosidade
+        r[17], r[18],                                           # header_secao_7, accordion_secao_7
+        r[3],                                                   # plot_dispersao
+        r[19], r[20],                                           # header_secao_8, accordion_secao_8
+        r[4], r[5],                                             # slider_grau_coef, slider_grau_f
+        r[6],                                                   # busca_html
+        r[21], r[22],                                           # header_secao_9, accordion_secao_9
+        gr.update(value=transformacao_y),                        # transformacao_y dropdown (do .dai)
+        r[8], r[9], r[10], r[11], r[12],                       # btn_adotar 1-5
+        # --- Campos de transformação (com dropdowns sobrescritos) ---
+        *campos_transf,
+        # --- Seções 10-16 (de ajustar_modelo_callback) ---
+        m[15], m[16],                                           # header_secao_10, accordion_secao_10
+        m[5],                                                   # dropdown_tipo_grafico_dispersao
+        m[4],                                                   # plot_dispersao_transf
+        m[17], m[18],                                           # header_secao_11, accordion_secao_11
+        m[1],                                                   # diagnosticos_html
+        m[2],                                                   # tabela_coef
+        m[3],                                                   # tabela_obs_calc
+        m[19], m[20],                                           # header_secao_12, accordion_secao_12
+        m[6], m[7], m[8], m[9], m[10],                         # plots: obs_calc, resid, hist, cook, corr
+        m[21], m[22],                                           # header_secao_13, accordion_secao_13
+        m[11],                                                  # tabela_metricas
+        m[23], m[24],                                           # header_secao_14, accordion_secao_14
+        html_outliers_content,                                  # html_outliers_sec14
+        "",                                                     # outliers_texto
+        "",                                                     # reincluir_texto
+        m[13],                                                  # txt_resumo_outliers
+        # --- Seção 15: Avaliação de Imóvel ---
+        m[25], m[26],                                           # header_secao_15, accordion_secao_15
+        *[gr.update(visible=False) for _ in range(n_aval_rows)],  # aval_rows (populados pelo .then)
+        *[gr.update(visible=False, value=None, label="") for _ in range(MAX_VARS_X)],  # aval_inputs (populados pelo .then)
+        "",                                                     # resultado_avaliacao_html
+        gr.update(choices=[], value=None),                      # dropdown_base_avaliacao
+        "",                                                     # excluir_aval_trigger
+        gr.update(value=None, visible=False),                   # download_avaliacoes_file
+        # --- Seção 16: Exportar Modelo ---
+        m[27], m[28],                                           # header_secao_16, accordion_secao_16
+        gr.update(value=""),                                    # nome_arquivo
+        gr.update(value=""),                                    # status_exportar
+        # Transição para estado C (pós-carregamento)
+        gr.update(visible=False),                               # row_upload
+        gr.update(visible=False),                               # row_selecao_aba
+        gr.update(visible=True),                                # row_pos_carga
+        gr.update(value=html_nome),                                 # html_nome_arquivo_carregado
+        2,                                                      # estado_flag_carregamento (contador: 2 side-effects esperados)
+        m[29], m[30], m[31], m[32],                             # filtro_vars (choices com colunas originais)
+        # Painel de coordenadas (no-op — .dai isento)
+        gr.update(visible=False), gr.update(value=""),
+        gr.update(choices=[]), gr.update(choices=[]),
+        gr.update(choices=[], value=None), gr.update(choices=[], value=None),
+        gr.update(visible=True),   # row_escolha_opcao — reset para tela de escolha
+        gr.update(visible=False),  # row_opcao_mapear
+        gr.update(visible=False),  # row_opcao_geocodificar
+    )
+
+
+def carregar_dados_do_arquivo(caminho_arquivo, nome_aba, nome_arquivo_exibicao=""):
+    """Carrega dados de um arquivo, opcionalmente de uma aba específica.
+
+    Args:
+        caminho_arquivo: Caminho do arquivo a carregar
+        nome_aba: Nome da aba a carregar (apenas para Excel)
+        nome_arquivo_exibicao: Nome do arquivo para exibir na interface pós-carregamento
+
+    CONTRACT: Retorna 193 itens para _outputs_carregar (app.py:criar_aba).
+    """
+    df, msg, sucesso = carregar_arquivo(caminho_arquivo, nome_aba)
+
+    if not sucesso:
+        return (
+            None,  # estado_df
+            msg,   # status
+            gr.update(),  # dropdown_aba
+            gr.update(choices=[], value=None),  # dropdown_y
+            None,  # tabela_dados
+            None,  # tabela_estatisticas
+            gr.update(choices=[]),  # checkboxes_x
+            "<p>Carregue um arquivo para ver o mapa.</p>",  # mapa
+            None,  # estado_df_filtrado
+            [],    # estado_outliers_anteriores
+            1,     # estado_iteracao
+            gr.update(visible=False),  # accordion_outliers_anteriores
+            "",                        # html_outliers_anteriores
+            None,  # estado_arquivo_temp
+            # Seções 2 e 3 - ocultas quando erro
+            gr.update(visible=False),  # header_secao_2
+            gr.update(visible=False),  # accordion_secao_2
+            gr.update(choices=["Visualização Padrão"], value="Visualização Padrão"),  # dropdown_mapa_var
+            gr.update(visible=False),  # header_secao_3
+            gr.update(visible=False),  # accordion_secao_3
+            # Reset seções 4-16
+            *_valores_reset_secoes_4_a_16(),
+            # Volta ao estado de upload em caso de erro
+            gr.update(visible=True),   # row_upload
+            gr.update(visible=False),  # row_selecao_aba
+            gr.update(visible=False),  # row_pos_carga
+            gr.update(value=""),       # html_nome_arquivo_carregado
+            False,                     # estado_flag_carregamento
+            *[gr.update()] * 4,        # filtro_vars (no-op)
+            # Painel de coordenadas (no-op — erro)
+            gr.update(visible=False), gr.update(value=""),
+            gr.update(choices=[]), gr.update(choices=[]),
+            gr.update(choices=[], value=None), gr.update(choices=[], value=None),
+            gr.update(visible=True),   # row_escolha_opcao — reset para tela de escolha
+            gr.update(visible=False),  # row_opcao_mapear
+            gr.update(visible=False),  # row_opcao_geocodificar
+        )
+
+    # Verificar e padronizar coordenadas
+    tem_coords, col_lat, col_lon = verificar_coords(df)
+    todas_colunas = df.columns.tolist()
+
+    if tem_coords:
+        df = padronizar_coords(df, col_lat, col_lon)
+        aviso_coords_html = ""
+        cdlog_auto = None
+        num_auto = None
+    else:
+        cdlog_auto, num_auto = auto_detectar_colunas_geo(df)
+        n = len(df)
+        aviso_coords_html = (
+            '<div style="background:#f8d7da;border:1px solid #f5c2c7;border-radius:8px;'
+            f'padding:10px 14px;margin-bottom:8px"><strong>⚠️ Colunas lat/lon não '
+            f'encontradas</strong> — {n} registro(s) sem coordenadas padronizadas.<br>'
+            '</div>'
+        )
+
+    # Identifica colunas (após padronização de coords)
+    colunas_numericas = obter_colunas_numericas(df)
+    coluna_y_padrao = identificar_coluna_y_padrao(df)
+
+    # Variáveis X padrão: todas exceto Y
+    colunas_x_padrao = [col for col in colunas_numericas if col != coluna_y_padrao]
+
+    # NÃO calcula estatísticas no carregamento - apenas ao clicar em "Aplicar Seleção"
+
+    # Mapa
+    mapa_html = criar_mapa(df)
+
+    # Timestamp para seção 2
+    gmt_minus_3 = timezone(timedelta(hours=-3))
+    timestamp = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
+
+    return (
+        df,  # estado_df
+        msg,  # status
+        gr.update(),  # dropdown_aba (no-op)
+        gr.update(choices=colunas_numericas, value=coluna_y_padrao),  # dropdown_y
+        arredondar_df(df),  # tabela_dados
+        gr.update(value=None),  # tabela_estatisticas - NÃO mostra até clicar em Aplicar Seleção
+        gr.update(choices=colunas_numericas, value=[]),  # checkboxes_x (nenhuma marcada por padrão)
+        mapa_html,  # mapa
+        df,  # estado_df_filtrado (inicia com dados completos)
+        [],  # estado_outliers_anteriores
+        1,   # estado_iteracao
+        gr.update(visible=False),  # accordion_outliers_anteriores
+        "",                        # html_outliers_anteriores
+        None,  # estado_arquivo_temp
+        # Seções 2 e 3 — header sempre visível; accordion oculto até coords resolvidas
+        gr.update(visible=True, value=criar_header_secao(2, "Visualizar Dados", timestamp) if tem_coords else criar_header_secao(2, "Visualizar Dados")),  # header_secao_2
+        gr.update(visible=tem_coords, open=True),  # accordion_secao_2
+        gr.update(choices=["Visualização Padrão"] + colunas_numericas, value="Visualização Padrão"),  # dropdown_mapa_var
+        gr.update(visible=True),                   # header_secao_3
+        gr.update(visible=tem_coords, open=True),  # accordion_secao_3
+        # Reset seções 4-16
+        *_valores_reset_secoes_4_a_16(),
+        # Transição para estado C (pós-carregamento)
+        gr.update(visible=False),   # row_upload
+        gr.update(visible=False),   # row_selecao_aba
+        gr.update(visible=True),    # row_pos_carga
+        gr.update(value=f"<h3>{nome_arquivo_exibicao}</h3>"),  # html_nome_arquivo_carregado
+        2,                          # estado_flag_carregamento (contador: 2 side-effects esperados)
+        *[gr.update()] * 4,         # filtro_vars (no-op — seções 13-14 ocultas)
+        # Painel de coordenadas (Estado D) — mostrado apenas se coords ausentes
+        gr.update(visible=not tem_coords),                                                      # row_coords_panel
+        gr.update(value=aviso_coords_html),                                                     # html_aviso_coords
+        gr.update(choices=todas_colunas if not tem_coords else []),                             # dropdown_col_lat_manual
+        gr.update(choices=todas_colunas if not tem_coords else []),                             # dropdown_col_lon_manual
+        gr.update(choices=todas_colunas if not tem_coords else [], value=cdlog_auto),           # dropdown_cdlog_geo
+        gr.update(choices=todas_colunas if not tem_coords else [], value=num_auto),             # dropdown_num_geo
+        gr.update(visible=True),                                                                # row_escolha_opcao — reset para tela de escolha
+        gr.update(visible=False),                                                               # row_opcao_mapear
+        gr.update(visible=False),                                                               # row_opcao_geocodificar
+    )
+
+
+# ============================================================
+# LIMPAR HISTÓRICO
+# ============================================================
+
+def limpar_historico_callback(df_original):
+    """Limpa o histórico de outliers e reinicia do zero.
+    Reseta tudo como se o arquivo tivesse acabado de ser carregado.
+
+    CONTRACT: Retorna 169 itens para btn_limpar_historico.click (app.py:criar_aba).
+    Se alterar, atualizar: app.py (outputs de btn_limpar_historico.click).
+    """
+    mapa = criar_mapa(df_original)
+
+    return (
+        [],                       # estado_outliers_anteriores (vazio)
+        1,                        # estado_iteracao (reinicia)
+        df_original,              # estado_df_filtrado (dados originais)
+        arredondar_df(df_original),     # tabela_dados
+        gr.update(value=None),    # tabela_estatisticas (limpa)
+        mapa,                     # mapa_html
+        "",                       # html_outliers_anteriores
+        gr.update(visible=False), # accordion_outliers_anteriores (esconde)
+        gr.update(value=criar_header_secao(2, "Visualizar Dados")),  # header_secao_2
+        *_valores_reset_secoes_4_a_16(),  # reset completo seções 4-15
+        *[gr.update()] * 4,         # filtro_vars (no-op — seções ocultas após reset)
+    )

backend/app/core/elaboracao/charts.py

@@ -0,0 +1,745 @@
+# -*- coding: utf-8 -*-
+"""
+charts.py - Gráficos Plotly e mapa Folium para elaboração de modelos
+"""
+
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from scipy import stats
+import folium
+from folium import plugins
+import branca.colormap as cm
+
+# ============================================================
+# CONSTANTES DE ESTILO
+# ============================================================
+
+COR_PRINCIPAL = '#FF8C00'  # Laranja
+COR_LINHA = '#dc3545'      # Vermelho
+COR_PONTOS = '#6c757d'     # Cinza
+COR_FUNDO = '#f8f9fa'      # Cinza claro
+COR_GRADE = '#e0e0e0'      # Grade
+
+
+# ============================================================
+# GRÁFICOS DE DISPERSÃO X vs Y
+# ============================================================
+
+def criar_graficos_dispersao(X, y, max_por_linha=3):
+    """
+    Cria gráficos de dispersão de cada coluna de X contra y.
+    Inclui reta de regressão e coeficiente de correlação.
+
+    Retorna figura Plotly.
+    """
+    if X is None or y is None or X.empty:
+        return None
+
+    n_colunas = min(max_por_linha, len(X.columns))
+    n_linhas = (len(X.columns) + n_colunas - 1) // n_colunas
+
+    y_nome = y.name if hasattr(y, 'name') and y.name else "y"
+    y_vals = pd.to_numeric(pd.Series(y), errors="coerce").to_numpy()
+
+    titulos = [f"{col} × {y_nome}" for col in X.columns]
+
+    fig = make_subplots(
+        rows=n_linhas,
+        cols=n_colunas,
+        subplot_titles=titulos,
+        horizontal_spacing=0.05,
+        vertical_spacing=0.06,
+    )
+
+    indices_x = X.index.values
+
+    for idx, coluna in enumerate(X.columns):
+        x_vals = pd.to_numeric(X[coluna], errors="coerce").to_numpy()
+
+        mask = np.isfinite(x_vals) & np.isfinite(y_vals)
+        x_valid = x_vals[mask]
+        y_valid = y_vals[mask]
+        indices_valid = indices_x[mask]
+
+        if len(x_valid) < 2:
+            continue
+
+        row = (idx // n_colunas) + 1
+        col = (idx % n_colunas) + 1
+
+        x_unicos = np.unique(x_valid)
+        eh_dicotomica = len(x_unicos) <= 2
+
+        fig.add_trace(
+            go.Scatter(
+                x=x_valid,
+                y=y_valid,
+                mode='markers',
+                name=coluna,
+                marker=dict(size=7, color=COR_PONTOS, opacity=0.78),
+                customdata=indices_valid,
+                showlegend=False,
+                cliponaxis=False,
+                hovertemplate=f"<b>Índice:</b> %{{customdata}}<br><b>{coluna}:</b> %{{x:.2f}}<br><b>{y_nome}:</b> %{{y:.2f}}<extra></extra>",
+            ),
+            row=row,
+            col=col,
+        )
+
+        corr = np.nan
+        if np.nanstd(x_valid) > 0 and np.nanstd(y_valid) > 0:
+            corr = float(np.corrcoef(x_valid, y_valid)[0, 1])
+
+        # Para variáveis dicotômicas, não desenha reta de regressão no gráfico de inspeção.
+        if not eh_dicotomica and len(x_valid) >= 3 and np.nanstd(x_valid) > 0:
+            a, b = np.polyfit(x_valid, y_valid, 1)
+            x_sorted = np.sort(x_valid)
+            y_linha = a * x_sorted + b
+            fig.add_trace(
+                go.Scatter(
+                    x=x_sorted,
+                    y=y_linha,
+                    mode='lines',
+                    name=f'Regressão {coluna}',
+                    line=dict(color=COR_PRINCIPAL, width=2),
+                    showlegend=False,
+                    hoverinfo='skip',
+                ),
+                row=row,
+                col=col,
+            )
+
+        if fig.layout.annotations and idx < len(fig.layout.annotations):
+            titulo = f"{coluna} × {y_nome}"
+            if np.isfinite(corr):
+                titulo = f"{titulo}<br>r = {corr:.3f}"
+            fig.layout.annotations[idx].text = titulo
+
+        x_min, x_max = float(np.min(x_valid)), float(np.max(x_valid))
+        if np.isclose(x_min, x_max):
+            x_pad = max(abs(x_min) * 0.15, 0.5)
+        elif eh_dicotomica:
+            x_pad = max((x_max - x_min) * 0.35, 0.30)
+        else:
+            x_pad = max((x_max - x_min) * 0.08, 0.05)
+
+        y_min, y_max = float(np.min(y_valid)), float(np.max(y_valid))
+        if np.isclose(y_min, y_max):
+            y_pad = max(abs(y_min) * 0.15, 0.5)
+        else:
+            y_pad = max((y_max - y_min) * 0.08, 0.05)
+
+        fig.update_xaxes(range=[x_min - x_pad, x_max + x_pad], row=row, col=col)
+        fig.update_yaxes(range=[y_min - y_pad, y_max + y_pad], row=row, col=col)
+
+    fig.update_layout(
+        height=max(380, 380 * n_linhas),
+        showlegend=False,
+        plot_bgcolor=COR_FUNDO,
+        paper_bgcolor='white',
+        margin=dict(t=78, r=20, b=48, l=54),
+    )
+    fig.update_annotations(showarrow=False)
+
+    fig.update_xaxes(showgrid=True, gridcolor=COR_GRADE)
+    fig.update_yaxes(showgrid=True, gridcolor=COR_GRADE)
+
+    return fig
+
+
+# ============================================================
+# GRÁFICOS DE DIAGNÓSTICO DO MODELO
+# ============================================================
+
+def criar_grafico_obs_calc(y_obs, y_calc, indices=None):
+    """Gráfico de valores observados vs calculados."""
+    if y_obs is None or y_calc is None:
+        return None
+
+    y_obs = np.array(y_obs)
+    y_calc = np.array(y_calc)
+
+    fig = go.Figure()
+
+    # Pontos
+    scatter_args = dict(
+        x=y_calc,
+        y=y_obs,
+        mode='markers',
+        marker=dict(color=COR_PRINCIPAL, size=10, line=dict(color='black', width=1)),
+        name='Dados',
+    )
+
+    if indices is not None:
+        scatter_args['customdata'] = indices
+        scatter_args['hovertemplate'] = "<b>Índice:</b> %{customdata}<br><b>Calculado:</b> %{x:.2f}<br><b>Observado:</b> %{y:.2f}<extra></extra>"
+    else:
+        scatter_args['hovertemplate'] = "<b>Calculado:</b> %{x:.2f}<br><b>Observado:</b> %{y:.2f}<extra></extra>"
+
+    fig.add_trace(go.Scatter(**scatter_args))
+
+    # Linha de identidade
+    min_val = min(y_obs.min(), y_calc.min())
+    max_val = max(y_obs.max(), y_calc.max())
+    margin = (max_val - min_val) * 0.05
+
+    fig.add_trace(go.Scatter(
+        x=[min_val - margin, max_val + margin],
+        y=[min_val - margin, max_val + margin],
+        mode='lines',
+        line=dict(color=COR_LINHA, dash='dash', width=2),
+        name='Linha de identidade'
+    ))
+
+    fig.update_layout(
+        title=dict(text='Observados vs Calculados', x=0.5),
+        xaxis_title='Valores Calculados',
+        yaxis_title='Valores Observados',
+        showlegend=True,
+        plot_bgcolor='white',
+        height=400
+    )
+
+    fig.update_xaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
+    fig.update_yaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
+
+    return fig
+
+
+def criar_grafico_residuos(y_calc, residuos, indices=None):
+    """Gráfico de resíduos vs valores ajustados."""
+    if y_calc is None or residuos is None:
+        return None
+
+    y_calc = np.array(y_calc)
+    residuos = np.array(residuos)
+
+    fig = go.Figure()
+
+    scatter_args = dict(
+        x=y_calc,
+        y=residuos,
+        mode='markers',
+        marker=dict(color=COR_PRINCIPAL, size=10, line=dict(color='black', width=1)),
+        name='Resíduos',
+    )
+
+    if indices is not None:
+        scatter_args['customdata'] = indices
+        scatter_args['hovertemplate'] = "<b>Índice:</b> %{customdata}<br><b>Ajustado:</b> %{x:.2f}<br><b>Resíduo:</b> %{y:.4f}<extra></extra>"
+    else:
+        scatter_args['hovertemplate'] = "<b>Ajustado:</b> %{x:.2f}<br><b>Resíduo:</b> %{y:.4f}<extra></extra>"
+
+    fig.add_trace(go.Scatter(**scatter_args))
+
+    # Linhas de referência
+    fig.add_hline(y=0, line_dash="dash", line_color=COR_LINHA, line_width=2)
+    fig.add_hline(y=2, line_dash="dot", line_color='gray', line_width=1)
+    fig.add_hline(y=-2, line_dash="dot", line_color='gray', line_width=1)
+
+    fig.update_layout(
+        title=dict(text='Resíduos vs Valores Ajustados', x=0.5),
+        xaxis_title='Valores Ajustados',
+        yaxis_title='Resíduos Padronizados',
+        showlegend=False,
+        plot_bgcolor='white',
+        height=400
+    )
+
+    fig.update_xaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
+    fig.update_yaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
+
+    return fig
+
+
+def criar_histograma_residuos(residuos):
+    """Histograma dos resíduos com curva normal."""
+    if residuos is None:
+        return None
+
+    residuos = np.array(residuos)
+
+    fig = go.Figure()
+
+    # Histograma
+    fig.add_trace(go.Histogram(
+        x=residuos,
+        histnorm='probability density',
+        marker=dict(color=COR_PRINCIPAL, line=dict(color='black', width=1)),
+        opacity=0.7,
+        name='Resíduos'
+    ))
+
+    # Curva normal
+    mu, sigma = np.mean(residuos), np.std(residuos)
+    x_norm = np.linspace(residuos.min() - sigma, residuos.max() + sigma, 100)
+    y_norm = stats.norm.pdf(x_norm, mu, sigma)
+
+    fig.add_trace(go.Scatter(
+        x=x_norm,
+        y=y_norm,
+        mode='lines',
+        line=dict(color=COR_LINHA, width=3),
+        name='Curva Normal'
+    ))
+
+    fig.update_layout(
+        title=dict(text='Distribuição dos Resíduos', x=0.5),
+        xaxis_title='Resíduos',
+        yaxis_title='Densidade',
+        showlegend=True,
+        plot_bgcolor='white',
+        barmode='overlay',
+        height=400
+    )
+
+    fig.update_xaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
+    fig.update_yaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
+
+    return fig
+
+def criar_graficos_dispersao_residuos(X, residuos, max_por_linha=3):
+    """
+    Cria gráficos de dispersão de cada coluna de X contra os resíduos padronizados.
+    Inclui linhas de referência em 0 e ±2.
+    
+    Retorna figura Plotly.
+    """
+    if X is None or residuos is None or X.empty:
+        return None
+
+    n_colunas = min(max_por_linha, len(X.columns))
+    n_linhas = (len(X.columns) + n_colunas - 1) // n_colunas
+    
+    # Nome dos resíduos
+    y_nome = "Resíduo Padronizado"
+    y_vals = residuos
+
+    titulos = [f"{col} × {y_nome}" for col in X.columns]
+
+    fig = make_subplots(
+        rows=n_linhas,
+        cols=n_colunas,
+        subplot_titles=titulos,
+        horizontal_spacing=0.05,
+        vertical_spacing=0.06,
+    )
+
+    # Obtém índices do DataFrame X
+    indices_x = X.index.values
+
+    for idx, coluna in enumerate(X.columns):
+        x_vals = X[coluna].values
+
+        # Alinha dados válidos
+        mask = ~(np.isnan(x_vals) | np.isnan(y_vals))
+        x_valid = x_vals[mask]
+        y_valid = y_vals[mask]
+        indices_valid = indices_x[mask]
+
+        if len(x_valid) < 1:
+            continue
+
+        row = (idx // n_colunas) + 1
+        col = (idx % n_colunas) + 1
+
+        # Pontos
+        fig.add_trace(
+            go.Scatter(
+                x=x_valid,
+                y=y_valid,
+                mode='markers',
+                name=coluna,
+                marker=dict(size=7, color=COR_PONTOS),
+                customdata=indices_valid,
+                showlegend=False,
+                hovertemplate=f"<b>Índice:</b> %{{customdata}}<br><b>{coluna}:</b> %{{x:.2f}}<br><b>Resíduo:</b> %{{y:.2f}}<extra></extra>"
+            ),
+            row=row, col=col
+        )
+        
+        # Linha horizontal em 0
+        fig.add_hline(y=0, line_dash="dash", line_color=COR_LINHA, line_width=2, row=row, col=col)
+        # Linhas em ±2
+        fig.add_hline(y=2, line_dash="dot", line_color='gray', line_width=1, row=row, col=col)
+        fig.add_hline(y=-2, line_dash="dot", line_color='gray', line_width=1, row=row, col=col)
+
+    fig.update_layout(
+        height=max(380, 380 * n_linhas),
+        showlegend=False,
+        plot_bgcolor=COR_FUNDO,
+        paper_bgcolor='white',
+        margin=dict(t=78, r=20, b=48, l=54),
+    )
+    fig.update_annotations(showarrow=False)
+
+    fig.update_xaxes(showgrid=True, gridcolor=COR_GRADE)
+    fig.update_yaxes(showgrid=True, gridcolor=COR_GRADE)
+
+    return fig
+
+def criar_grafico_cook(cook_distances, indices=None, limite=None):
+    """Gráfico de Distância de Cook."""
+    if cook_distances is None:
+        return None
+
+    cook = np.array(cook_distances)
+    n = len(cook)
+
+    # Usa índices fornecidos ou gera sequenciais
+    if indices is None:
+        indices = np.arange(1, n + 1)
+    else:
+        indices = np.array(indices)
+
+    if limite is None:
+        limite = 4 / n
+
+    fig = go.Figure()
+
+    # Hastes (usa posição sequencial para o eixo X, mas guarda índice real)
+    x_pos = np.arange(len(cook))
+    for i, (idx, valor) in enumerate(zip(indices, cook)):
+        cor = COR_LINHA if valor > limite else COR_PRINCIPAL
+        fig.add_trace(go.Scatter(
+            x=[i, i],
+            y=[0, valor],
+            mode='lines',
+            line=dict(color=cor, width=1.5),
+            showlegend=False,
+            hoverinfo='skip'
+        ))
+
+    # Pontos
+    cores = [COR_LINHA if v > limite else COR_PRINCIPAL for v in cook]
+    fig.add_trace(go.Scatter(
+        x=x_pos,
+        y=cook,
+        mode='markers',
+        marker=dict(color=cores, size=8, line=dict(color='black', width=1)),
+        name='Distância de Cook',
+        showlegend=False,
+        customdata=indices,
+        hovertemplate='<b>Índice:</b> %{customdata}<br><b>Cook:</b> %{y:.4f}<extra></extra>'
+    ))
+
+    # Linha de corte
+    fig.add_hline(
+        y=limite,
+        line_dash="dash",
+        line_color='gray',
+        annotation_text=f"4/n = {limite:.4f}",
+        annotation_position="top right"
+    )
+
+    fig.update_layout(
+        title=dict(text='Distância de Cook', x=0.5),
+        xaxis_title='Observação (ver índice no hover)',
+        yaxis_title='Distância de Cook',
+        showlegend=False,
+        plot_bgcolor='white',
+        height=400
+    )
+
+    fig.update_xaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black', showticklabels=False)
+    fig.update_yaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
+
+    return fig
+
+
+def criar_matriz_correlacao(df, colunas=None):
+    """
+    Heatmap de correlação com estilo premium: 
+    Diagonal limpa, linha divisória e cores customizadas.
+    """
+    if df is None or df.empty:
+        return None
+
+    # Seleção de colunas e limpeza de dados constantes
+    if colunas:
+        df_corr = df[colunas].select_dtypes(include=[np.number])
+    else:
+        df_corr = df.select_dtypes(include=[np.number])
+
+    if df_corr.shape[1] < 2:
+        return None
+
+    # Garantir que não existam colunas com variância zero (evita NaNs na correlação)
+    variancias = df_corr.var(ddof=0)
+    df_corr = df_corr.loc[:, variancias.fillna(0) > 0]
+
+    if df_corr.shape[1] < 2:
+        return None
+
+    # Cálculo da correlação
+    corr = df_corr.corr()
+
+    # --- LÓGICA DE ESTILO DA PRIMEIRA FUNÇÃO ---
+    
+    # 1. Remover diagonal (substitui por NaN para não colorir o Heatmap)
+    mask = np.eye(len(corr), dtype=bool)
+    corr_masked = corr.where(~mask)
+
+    # 2. Preparar texto (esconder NaNs da diagonal)
+    text = np.where(
+        np.isnan(corr_masked.values),
+        "",
+        np.round(corr_masked.values, 2).astype(str)
+    )
+
+    # 3. Definição da Colorscale customizada (Divergente com centro branco largo)
+    custom_colorscale = [
+        [0.00, "rgb(103,0,31)"], [0.08, "rgb(178,24,43)"],
+        [0.16, "rgb(214,96,77)"], [0.24, "rgb(244,165,130)"],
+        [0.32, "rgb(253,219,199)"],
+        [0.45, "rgb(255,255,255)"], [0.55, "rgb(255,255,255)"], # Branco neutro
+        [0.68, "rgb(209,229,240)"], [0.76, "rgb(146,197,222)"],
+        [0.84, "rgb(67,147,195)"], [0.92, "rgb(33,102,172)"],
+        [1.00, "rgb(5,48,97)"]
+    ]
+
+    fig = go.Figure(data=go.Heatmap(
+        z=corr_masked.values,
+        x=corr.columns,
+        y=corr.index,
+        text=text,
+        texttemplate="%{text}",
+        textfont=dict(size=10),
+        zmin=-1, zmax=1, zmid=0,
+        colorscale=custom_colorscale,
+        colorbar=dict(title='Correlação'),
+        hovertemplate="%{x} × %{y}<br>ρ = %{z:.3f}<extra></extra>"
+    ))
+
+    # 4. Adicionar a linha diagonal visual
+    fig.add_shape(
+        type="line",
+        xref="paper", yref="paper",
+        x0=0, y0=1, x1=1, y1=0,
+        line=dict(color="rgba(0,0,0,0.35)", width=1),
+        layer="above"
+    )
+
+    fig.update_layout(
+        title=dict(text="Matriz de Correlação", x=0.5),
+        height=600,
+        template='plotly_white',
+        xaxis=dict(tickangle=45, showgrid=False),
+        yaxis=dict(autorange='reversed', showgrid=False)
+    )
+
+    return fig
+
+# ============================================================
+# GRÁFICOS COMBINADOS DE DIAGNÓSTICO
+# ============================================================
+
+def criar_painel_diagnostico(resultado_modelo):
+    """
+    Cria painel com todos os gráficos de diagnóstico.
+    Retorna dict com figuras individuais.
+    """
+    if resultado_modelo is None:
+        return {}
+
+    tabela = resultado_modelo.get("tabela_obs_calc")
+    if tabela is None:
+        return {}
+
+    # Extrai índices da tabela
+    indices = tabela["Índice"].values if "Índice" in tabela.columns else None
+
+    y_obs = tabela["Observado"].values if "Observado" in tabela.columns else None
+    y_calc = tabela["Calculado"].values if "Calculado" in tabela.columns else None
+    residuos_pad = tabela["Resíduo Pad."].values if "Resíduo Pad." in tabela.columns else None
+    cook = tabela["Cook"].values if "Cook" in tabela.columns else None
+
+    return {
+        "obs_calc": criar_grafico_obs_calc(y_obs, y_calc, indices),
+        "residuos": criar_grafico_residuos(y_calc, residuos_pad, indices),
+        "histograma": criar_histograma_residuos(residuos_pad),
+        "cook": criar_grafico_cook(cook, indices)
+    }
+
+
+# ============================================================
+# MAPA FOLIUM
+# ============================================================
+
+def criar_mapa(df, lat_col="lat", lon_col="lon", cor_col=None, indice_destacado=None, tamanho_col=None):
+    """
+    Cria mapa Folium com os dados.
+
+    Parâmetros:
+        df: DataFrame com os dados
+        lat_col: nome da coluna de latitude
+        lon_col: nome da coluna de longitude
+        cor_col: coluna para colorir os pontos (opcional)
+        indice_destacado: índice do ponto a destacar (opcional)
+        tamanho_col: coluna numérica para dimensionar os círculos (opcional)
+
+    Retorna:
+        HTML do mapa
+    """
+    # Verifica se colunas existem
+    cols_lower = {str(c).lower(): c for c in df.columns}
+
+    lat_real = None
+    lon_real = None
+
+    for nome in ["lat", "latitude", "siat_latitude"]:
+        if nome in cols_lower:
+            lat_real = cols_lower[nome]
+            break
+
+    for nome in ["lon", "longitude", "long", "siat_longitude"]:
+        if nome in cols_lower:
+            lon_real = cols_lower[nome]
+            break
+
+    if lat_real is None or lon_real is None:
+        return "<p>Coordenadas (lat/lon) não encontradas nos dados.</p>"
+
+    # Filtra dados válidos
+    df_mapa = df.dropna(subset=[lat_real, lon_real]).copy()
+    if df_mapa.empty:
+        return "<p>Sem coordenadas válidas para exibir.</p>"
+
+    # Cria mapa
+    centro_lat = df_mapa[lat_real].mean()
+    centro_lon = df_mapa[lon_real].mean()
+
+    m = folium.Map(
+        location=[centro_lat, centro_lon],
+        zoom_start=12,
+        tiles=None
+    )
+
+    # Camadas base
+    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True).add_to(m)
+    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True).add_to(m)
+
+    # Se tamanho_col fornecido mas cor_col não, usa mesma variável para cor
+    if tamanho_col and not cor_col:
+        cor_col = tamanho_col
+
+    # Colormap se houver coluna de cor (verde → vermelho)
+    colormap = None
+    if cor_col and cor_col in df_mapa.columns:
+        vmin = df_mapa[cor_col].min()
+        vmax = df_mapa[cor_col].max()
+        colormap = cm.LinearColormap(
+            colors=["#2ecc71", "#a8e06c", "#f1c40f", "#e67e22", "#e74c3c"],
+            vmin=vmin,
+            vmax=vmax,
+            caption=cor_col
+        )
+        colormap.add_to(m)
+
+    # Escala de tamanho proporcional
+    raio_min, raio_max = 3, 18
+    tamanho_func = None
+    if tamanho_col and tamanho_col in df_mapa.columns:
+        t_min = df_mapa[tamanho_col].min()
+        t_max = df_mapa[tamanho_col].max()
+        if t_max > t_min:
+            tamanho_func = lambda v, _min=t_min, _max=t_max: raio_min + (v - _min) / (_max - _min) * (raio_max - raio_min)
+        else:
+            tamanho_func = lambda v: (raio_min + raio_max) / 2
+
+    # Camada de índices (oculta por padrão, ativável pelo controle de camadas)
+    camada_indices = folium.FeatureGroup(name="Índices", show=False)
+
+    # Adiciona pontos
+    for idx, row in df_mapa.iterrows():
+        # Cor do ponto
+        if colormap and cor_col:
+            cor = colormap(row[cor_col])
+        else:
+            cor = COR_PRINCIPAL
+
+        # Calcula raio
+        if idx == indice_destacado:
+            raio = raio_max + 4
+        elif tamanho_func:
+            raio = tamanho_func(row[tamanho_col])
+        else:
+            raio = 4
+        peso = 3 if idx == indice_destacado else 1
+
+        # Popup com informações
+        popup_html = f"<b>Índice: {idx}</b><br>"
+        for col in df_mapa.columns:
+            if str(col).lower() not in ['lat', 'latitude', 'lon', 'longitude']:
+                val = row[col]
+                if isinstance(val, (int, float)):
+                    popup_html += f"{col}: {val:.2f}<br>"
+                else:
+                    popup_html += f"{col}: {val}<br>"
+
+        # Tooltip (hover): índice + variável selecionada no dropdown
+        tooltip_html = (
+            "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:14px;"
+            " line-height:1.7; padding:2px 4px;'>"
+            f"<b>Índice {idx}</b>"
+        )
+        if tamanho_col and tamanho_col in df_mapa.columns:
+            val_t = row[tamanho_col]
+            val_str = f"{val_t:.2f}" if isinstance(val_t, (int, float)) else str(val_t)
+            tooltip_html += (
+                f"<br><span style='color:#555;'>{tamanho_col}:</span>"
+                f" <b>{val_str}</b>"
+            )
+        tooltip_html += "</div>"
+
+        folium.CircleMarker(
+            location=[row[lat_real], row[lon_real]],
+            radius=raio,
+            popup=folium.Popup(popup_html, max_width=300),
+            tooltip=folium.Tooltip(tooltip_html, sticky=True),
+            color='black',
+            weight=peso,
+            fill=True,
+            fillColor=cor,
+            fillOpacity=0.8 if idx == indice_destacado else 0.6
+        ).add_to(m)
+
+        # Label com índice (na camada togglável)
+        folium.Marker(
+            location=[row[lat_real], row[lon_real]],
+            icon=folium.DivIcon(
+                html=f'<div style="font-size:16px; font-weight:bold; color:#333; text-align:center; line-height:{int(raio*2)}px; width:{int(raio*2)}px; margin-left:-{int(raio)}px; margin-top:-{int(raio)}px;">{idx}</div>',
+                icon_size=(int(raio*2), int(raio*2)),
+                icon_anchor=(int(raio), int(raio))
+            )
+        ).add_to(camada_indices)
+
+    camada_indices.add_to(m)
+
+    # Controles
+    folium.LayerControl().add_to(m)
+    plugins.Fullscreen().add_to(m)
+    plugins.MeasureControl(
+        primary_length_unit='meters',
+        secondary_length_unit='kilometers',
+        primary_area_unit='sqmeters',
+        secondary_area_unit='hectares'
+    ).add_to(m)
+
+    # Ajusta bounds
+    bounds = [
+        [df_mapa[lat_real].min(), df_mapa[lon_real].min()],
+        [df_mapa[lat_real].max(), df_mapa[lon_real].max()]
+    ]
+    m.fit_bounds(bounds)
+
+    return m._repr_html_()
+
+
+def criar_mapa_simples(df):
+    """
+    Versão simplificada do mapa sem destaque.
+    """
+    return criar_mapa(df, indice_destacado=None)

backend/app/core/elaboracao/core.py

@@ -0,0 +1,2077 @@
+# -*- coding: utf-8 -*-
+"""
+core.py - Lógica de negócio para elaboração de modelos estatísticos
+Contém: carregamento de dados, estatísticas, transformações, modelo OLS, diagnósticos
+"""
+
+import os
+import pandas as pd
+# Desabilita StringDtype para compatibilidade entre versões do pandas
+pd.set_option('future.infer_string', False)
+import numpy as np
+import statsmodels.api as sm
+from statsmodels.stats.diagnostic import het_breuschpagan
+from statsmodels.stats.stattools import durbin_watson
+from statsmodels.stats.outliers_influence import OLSInfluence
+from scipy.stats import kstest
+from itertools import product
+from joblib import dump, load
+import io
+
+
+# ============================================================
+# CONSTANTES
+# ============================================================
+
+TRANSFORMACOES = ["(x)", "1/(x)", "ln(x)", "exp(x)", "(x)^2", "raiz(x)", "1/raiz(x)"]
+
+# Nomes comuns para identificar colunas especiais
+NOMES_VUNIT = {"vunit", "vu", "valor_unitario", "vuloc", "vupriv", "vuaconst", "vuapriv", "valor unitário"}
+NOMES_LAT = {"lat", "latitude", "y", "siat_latitude"}
+NOMES_LON = {"lon", "longitude", "long", "x", "siat_longitude"}
+
+# Tabela Durbin-Watson
+DW_TABLE = {
+    0.05: {
+        1: {"n": [25, 50, 100, 200], "dL": [1.10, 1.32, 1.49, 1.57], "dU": [1.54, 1.62, 1.70, 1.75]},
+        2: {"n": [25, 50, 100, 200], "dL": [1.06, 1.30, 1.47, 1.55], "dU": [1.50, 1.60, 1.69, 1.74]},
+        3: {"n": [25, 50, 100, 200], "dL": [1.02, 1.28, 1.45, 1.54], "dU": [1.47, 1.58, 1.68, 1.73]},
+        4: {"n": [25, 50, 100, 200], "dL": [0.98, 1.26, 1.43, 1.52], "dU": [1.44, 1.56, 1.66, 1.72]},
+    },
+    0.01: {
+        1: {"n": [25, 50, 100, 200], "dL": [1.05, 1.32, 1.52, 1.66], "dU": [1.21, 1.40, 1.56, 1.68]},
+        2: {"n": [25, 50, 100, 200], "dL": [0.98, 1.28, 1.50, 1.65], "dU": [1.30, 1.45, 1.58, 1.69]},
+        3: {"n": [25, 50, 100, 200], "dL": [0.90, 1.24, 1.48, 1.64], "dU": [1.41, 1.49, 1.60, 1.70]},
+        4: {"n": [25, 50, 100, 200], "dL": [0.83, 1.20, 1.46, 1.63], "dU": [1.52, 1.54, 1.63, 1.72]},
+    },
+}
+
+
+# ============================================================
+# CARREGAMENTO DE DADOS
+# ============================================================
+
+def detectar_abas_excel(arquivo):
+    """
+    Detecta as abas (sheets) de um arquivo Excel.
+
+    Args:
+        arquivo: Pode ser um objeto de arquivo ou um caminho (string)
+
+    Retorna:
+        tuple: (lista_abas, mensagem, sucesso)
+    """
+    if arquivo is None:
+        return [], "Nenhum arquivo enviado.", False
+
+    try:
+        # Obtém o caminho/nome do arquivo
+        caminho = arquivo.name if hasattr(arquivo, 'name') else str(arquivo)
+
+        if caminho.endswith(('.xlsx', '.xls')):
+            # Usa o caminho para abrir o arquivo (funciona com path ou file object)
+            excel_file = pd.ExcelFile(caminho)
+            abas = excel_file.sheet_names
+            return abas, f"Arquivo com {len(abas)} aba(s) detectada(s)", True
+        else:
+            # CSV não tem abas
+            return [], "Arquivo CSV (sem abas)", True
+
+    except Exception as e:
+        return [], f"Erro ao detectar abas: {str(e)}", False
+
+
+def carregar_arquivo(arquivo, nome_aba=None):
+    """
+    Carrega arquivo Excel ou CSV e retorna DataFrame.
+    Detecta automaticamente o separador do CSV.
+
+    Args:
+        arquivo: Arquivo a ser carregado (objeto de arquivo ou caminho string)
+        nome_aba: Nome da aba a carregar (apenas para Excel). Se None, carrega a primeira.
+
+    Retorna:
+        tuple: (df, mensagem, sucesso)
+    """
+    if arquivo is None:
+        return None, "Nenhum arquivo enviado.", False
+
+    try:
+        # Obtém o caminho do arquivo
+        caminho = arquivo.name if hasattr(arquivo, 'name') else str(arquivo)
+
+        if caminho.endswith(('.xlsx', '.xls')):
+            # Carrega aba específica ou a primeira (usa caminho para poder reabrir)
+            df = pd.read_excel(caminho, sheet_name=nome_aba if nome_aba else 0)
+            aba_info = f" (aba: {nome_aba})" if nome_aba else ""
+        elif caminho.endswith('.csv'):
+            # Tenta detectar separador
+            with open(caminho, 'rb') as f:
+                content = f.read()
+
+            # Tenta diferentes separadores
+            for sep in [',', ';', '\t']:
+                try:
+                    df = pd.read_csv(io.BytesIO(content), sep=sep)
+                    if len(df.columns) > 1:
+                        break
+                except:
+                    continue
+            else:
+                df = pd.read_csv(io.BytesIO(content))
+            aba_info = ""
+        else:
+            return None, "Formato de arquivo não suportado.", False
+
+        # Reinicia índice começando em 1
+        df = df.reset_index(drop=True)
+        df.index = df.index + 1
+
+        # Garante nomes de colunas como string (evita mismatch com colunas numéricas, ex: anos)
+        df.columns = df.columns.astype(str)
+
+        return df, f"Arquivo carregado: {os.path.basename(caminho)}{aba_info} ({len(df)} linhas, {len(df.columns)} colunas)", True
+
+    except Exception as e:
+        return None, f"Erro ao carregar arquivo: {str(e)}", False
+
+
+def _migrar_pacote_v1_para_v2(pacote):
+    """Converte pacote .dai v1 (flat) para estrutura v2 (nested)."""
+    resumo = pacote.get("modelos_resumos", {})
+    return {
+        "versao": 2,
+        "dados": {
+            "df": pacote["Xy_preview_out_coords"],
+            "estatisticas": pacote["estatisticas"],
+        },
+        "transformacoes": {
+            "info": pacote["formatted_top_transformation_info"],
+            "X": pacote["top_X_esc"],
+            "y": pacote["top_y_esc"],
+            "dicotomicas": pacote.get("dicotomicas", []),
+        },
+        "modelo": {
+            "sm": pacote["modelos_sm"],
+            "coeficientes": pacote["tabelas_coef"],
+            "obs_calc": pacote["tabelas_obs_calc"],
+            "diagnosticos": {
+                "gerais": {
+                    "n": resumo.get("n"),
+                    "k": resumo.get("k"),
+                    "desvio_padrao_residuos": resumo.get("desvio_padrao_residuos"),
+                    "mse": resumo.get("mse"),
+                    "r2": resumo.get("r2"),
+                    "r2_ajustado": resumo.get("r2_ajustado"),
+                    "r_pearson": resumo.get("r_pearson"),
+                },
+                "teste_f": {
+                    "estatistica": resumo.get("Fc"),
+                    "p_valor": resumo.get("p_valor_F"),
+                    "interpretacao": resumo.get("Interpretacao_F"),
+                },
+                "teste_ks": {
+                    "estatistica": resumo.get("ks_stat"),
+                    "p_valor": resumo.get("ks_p"),
+                    "interpretacao": resumo.get("Interpretacao_KS"),
+                },
+                "teste_normalidade": {
+                    "percentuais": resumo.get("perc_resid"),
+                },
+                "teste_dw": {
+                    "estatistica": resumo.get("dw"),
+                    "interpretacao": resumo.get("Interpretacao_DW"),
+                },
+                "teste_bp": {
+                    "estatistica": resumo.get("bp_lm"),
+                    "p_valor": resumo.get("bp_p"),
+                    "interpretacao": resumo.get("Interpretacao_BP"),
+                },
+                "equacao": resumo.get("equacao"),
+            },
+        },
+    }
+
+
+def carregar_dai(caminho):
+    """
+    Carrega arquivo .dai e extrai DataFrame, variáveis e transformações.
+
+    Retorna:
+        tuple: (df, coluna_y, colunas_x, transformacao_y, transformacoes_x, dicotomicas, codigo_alocado, percentuais, mensagem, sucesso)
+    """
+    try:
+        pacote = load(caminho)
+
+        # Retrocompatibilidade: converte v1 (flat) para v2 (nested)
+        if "versao" not in pacote:
+            pacote = _migrar_pacote_v1_para_v2(pacote)
+
+        # Extrai novos campos (se existirem)
+        df_completo = pacote["dados"].get("df_completo", None)
+        outliers_excluidos = pacote["dados"].get("outliers_excluidos", [])
+
+        # Extrai DataFrame — preserva índices originais se df_completo disponível
+        if df_completo is not None:
+            # .dai novo: usa DataFrame completo com índices originais (sem reset!)
+            df = df_completo.copy()
+        else:
+            # .dai antigo: usa df filtrado e renumera índices (retrocompat)
+            df = pacote["dados"]["df"].copy()
+            df = df.reset_index(drop=True)
+            df.index = df.index + 1
+
+        # Normaliza nomes de colunas para string (evita mismatch com colunas numéricas, ex: anos)
+        df.columns = df.columns.astype(str)
+
+        # Parseia transformações
+        info_transf = pacote["transformacoes"]["info"]
+
+        # Primeiro elemento: Y (ex: "VUNIT: ln(y)")
+        nome_y, transf_y = info_transf[0].split(": ", 1)
+        coluna_y = nome_y.strip()
+        transformacao_y = transf_y.strip().replace("(y)", "(x)")
+
+        # Demais: X (ex: "Area: ln(x)")
+        colunas_x = []
+        transformacoes_x = {}
+        for item in info_transf[1:]:
+            nome_x, transf_x = item.split(": ", 1)
+            nome_x = nome_x.strip()
+            colunas_x.append(nome_x)
+            transformacoes_x[nome_x] = transf_x.strip()
+
+        # Extrai dicotômicas, código alocado e percentuais (3 listas separadas)
+        dicotomicas = pacote["transformacoes"].get("dicotomicas", None)
+        codigo_alocado_salvo = pacote["transformacoes"].get("codigo_alocado", None)
+        percentuais_salvo = pacote["transformacoes"].get("percentuais", None)
+
+        # Normaliza para string (colunas numéricas ficam como inteiros quando serializadas diretamente)
+        if dicotomicas is not None:
+            dicotomicas = [str(c) for c in dicotomicas]
+        if codigo_alocado_salvo is not None:
+            codigo_alocado_salvo = [str(c) for c in codigo_alocado_salvo]
+        if percentuais_salvo is not None:
+            percentuais_salvo = [str(c) for c in percentuais_salvo]
+
+        if dicotomicas is None:
+            # Retrocompat: .dai antigos sem nenhuma info
+            dicotomicas = [col for col in colunas_x
+                           if set(df[col].dropna().unique()).issubset({0, 1, 0.0, 1.0})]
+            codigo_alocado_salvo = detectar_codigo_alocado(df, colunas_x)
+            percentuais_salvo = detectar_percentuais(df, colunas_x)
+        elif codigo_alocado_salvo is None:
+            # Retrocompat: .dai com "dicotomicas" misturadas (dic+cod), sem separação
+            reais_01 = [c for c in dicotomicas if set(df[c].dropna().unique()).issubset({0, 1, 0.0, 1.0})]
+            codigo_alocado_salvo = [c for c in dicotomicas if c not in reais_01]
+            dicotomicas = reais_01
+            percentuais_salvo = detectar_percentuais(df, colunas_x)
+
+        elaborador = pacote.get("elaborador", None)
+        msg = f"Modelo .dai carregado: {os.path.basename(caminho)} ({len(df)} dados, Y={coluna_y}, {len(colunas_x)} variáveis X)"
+        return df, coluna_y, colunas_x, transformacao_y, transformacoes_x, dicotomicas, codigo_alocado_salvo or [], percentuais_salvo or [], msg, True, elaborador, outliers_excluidos
+
+    except Exception as e:
+        return None, None, None, None, None, [], [], [], f"Erro ao carregar .dai: {str(e)}", False, None, []
+
+
+def identificar_coluna_y_padrao(df):
+    """
+    Identifica a coluna padrão para variável dependente (y).
+    Prioriza VUNIT se existir.
+    """
+    colunas_lower = {str(col).lower(): col for col in df.columns}
+
+    for nome in NOMES_VUNIT:
+        if nome in colunas_lower:
+            return colunas_lower[nome]
+
+    # Se não encontrar, retorna primeira coluna numérica
+    numericas = df.select_dtypes(include=[np.number]).columns.tolist()
+    return numericas[0] if numericas else None
+
+
+def identificar_colunas_coords(df):
+    """
+    Identifica colunas de latitude e longitude.
+    Retorna tuple (lat_col, lon_col) ou (None, None).
+    """
+    colunas_lower = {str(col).lower(): col for col in df.columns}
+
+    lat_col = None
+    lon_col = None
+
+    for nome in NOMES_LAT:
+        if nome in colunas_lower:
+            lat_col = colunas_lower[nome]
+            break
+
+    for nome in NOMES_LON:
+        if nome in colunas_lower:
+            lon_col = colunas_lower[nome]
+            break
+
+    return lat_col, lon_col
+
+
+def obter_colunas_numericas(df, excluir_coords=True):
+    """
+    Retorna lista de colunas numéricas.
+    Opcionalmente exclui lat/lon.
+    """
+    numericas = df.select_dtypes(include=[np.number]).columns.tolist()
+
+    if excluir_coords:
+        lat_col, lon_col = identificar_colunas_coords(df)
+        if lat_col and lat_col in numericas:
+            numericas.remove(lat_col)
+        if lon_col and lon_col in numericas:
+            numericas.remove(lon_col)
+
+    return numericas
+
+
+# ============================================================
+# ESTATÍSTICAS
+# ============================================================
+
+def calcular_estatisticas_variaveis(df, coluna_y=None, indices_usar=None, colunas=None):
+    """
+    Calcula estatísticas para cada coluna numérica.
+    Se coluna_y for especificada, inclui correlação com y.
+    Se colunas for especificada, calcula apenas para essas colunas.
+
+    Parâmetros:
+        df: DataFrame com os dados
+        coluna_y: nome da coluna da variável dependente (opcional)
+        indices_usar: lista de índices a incluir (se None, usa todos)
+        colunas: lista de colunas a calcular (se None, usa todas numéricas)
+
+    Retorna DataFrame com estatísticas.
+    """
+    # Filtra por índices se especificado
+    df_calc = df.copy()
+    if indices_usar is not None:
+        df_calc = df_calc.loc[indices_usar]
+
+    # Usa colunas especificadas ou todas numéricas
+    if colunas is not None:
+        numericas = [c for c in colunas if c in df_calc.columns and pd.api.types.is_numeric_dtype(df_calc[c])]
+    else:
+        numericas = obter_colunas_numericas(df_calc)
+
+    estatisticas = []
+
+    for col in numericas:
+        serie = df_calc[col].dropna()
+
+        stats = {
+            "Variável": col,
+            "Contagem": len(serie),
+            "Média": serie.mean(),
+            "Mediana": serie.median(),
+            "Mínimo": serie.min(),
+            "Máximo": serie.max(),
+            "Desvio Padrão": serie.std(),
+        }
+
+        # Coeficiente de variação
+        if stats["Média"] != 0:
+            stats["CV (%)"] = abs(stats["Desvio Padrão"] / stats["Média"]) * 100
+        else:
+            stats["CV (%)"] = np.nan
+
+        # Correlação com y
+        if coluna_y and col != coluna_y:
+            y_serie = df_calc[coluna_y].dropna()
+            comum = serie.index.intersection(y_serie.index)
+            if len(comum) > 2:
+                stats["Correlação (y)"] = np.corrcoef(serie.loc[comum], y_serie.loc[comum])[0, 1]
+            else:
+                stats["Correlação (y)"] = np.nan
+        else:
+            stats["Correlação (y)"] = np.nan if col != coluna_y else 1.0
+
+        # Detecta se é dicotômica
+        valores_unicos = set(serie.unique())
+        stats["Dicotômica"] = valores_unicos.issubset({0, 1, 0.0, 1.0})
+
+        estatisticas.append(stats)
+
+    df_stats = pd.DataFrame(estatisticas)
+
+    # Ordena por correlação absoluta (maiores primeiro)
+    if coluna_y:
+        df_stats["_abs_corr"] = df_stats["Correlação (y)"].abs()
+        df_stats = df_stats.sort_values("_abs_corr", ascending=False)
+        df_stats = df_stats.drop(columns=["_abs_corr"])
+
+    return df_stats.reset_index(drop=True)
+
+
+# ============================================================
+# ANÁLISE DE OUTLIERS
+# ============================================================
+
+def calcular_metricas_outliers(df, coluna_y, colunas_x, indices_participantes=None):
+    """
+    Ajusta modelo simples (sem transformações) para calcular métricas de outliers.
+
+    Parâmetros:
+        df: DataFrame com os dados
+        coluna_y: nome da coluna da variável dependente
+        colunas_x: lista de nomes das colunas independentes
+        indices_participantes: lista de índices a incluir (se None, usa todos)
+
+    Retorna:
+        DataFrame com métricas: Índice, Observado, Calculado, Resíduo,
+        Resíduo Pad., Resíduo Stud., Cook
+    """
+    if not colunas_x:
+        return None
+
+    # Filtra por participantes
+    df_calc = df.copy()
+    if indices_participantes is not None:
+        df_calc = df_calc.loc[indices_participantes]
+
+    # Prepara y (sem transformação)
+    y = df_calc[coluna_y].values
+
+    # Prepara X (sem transformação)
+    X = df_calc[colunas_x].copy()
+
+    # Remove linhas com NaN ou Inf
+    mask = ~(np.isnan(y) | np.isinf(y))
+    for col in X.columns:
+        mask &= ~(np.isnan(X[col]) | np.isinf(X[col]))
+
+    y_final = y[mask]
+    X_final = X.loc[mask.values if hasattr(mask, 'values') else mask]
+    indices_final = df_calc.index[mask]
+
+    if len(y_final) < len(colunas_x) + 2:
+        return None
+
+    try:
+        # Ajusta modelo simples
+        X_sm = sm.add_constant(X_final)
+        modelo = sm.OLS(y_final, X_sm).fit()
+
+        # Calcula métricas
+        residuos = modelo.resid
+        n = len(y_final)
+        k = len(colunas_x)
+        desvio_padrao = np.sqrt(np.sum(residuos**2) / (n - k - 1))
+        residuos_pad = residuos / desvio_padrao
+
+        influence = OLSInfluence(modelo)
+        residuos_stud = influence.resid_studentized
+        cook = influence.cooks_distance[0]
+
+        # Monta DataFrame
+        df_metricas = pd.DataFrame({
+            "Índice": indices_final,
+            "Observado": y_final,
+            "Calculado": modelo.predict(),
+            "Resíduo": residuos,
+            "Resíduo Pad.": residuos_pad,
+            "Resíduo Stud.": residuos_stud,
+            "Cook": cook
+        })
+        df_metricas = df_metricas.set_index("Índice")
+
+        return df_metricas
+
+    except Exception as e:
+        print(f"Erro ao calcular métricas de outliers: {e}")
+        return None
+
+
+def sugerir_outliers(df_metricas, coluna, valor):
+    """
+    Aplica filtro simétrico e retorna lista de índices sugeridos como outliers.
+    Filtra: coluna <= -valor OU coluna >= +valor
+
+    Parâmetros:
+        df_metricas: DataFrame com métricas de outliers
+        coluna: nome da coluna para filtro (ex: "Resíduo Pad.")
+        valor: valor absoluto do limite (ex: 2.0 significa <= -2 OU >= +2)
+
+    Retorna:
+        Lista de índices sugeridos como outliers
+    """
+    if df_metricas is None or df_metricas.empty:
+        return []
+
+    if coluna not in df_metricas.columns:
+        return []
+
+    # Filtro simétrico: <= -valor OU >= +valor
+    mask = (df_metricas[coluna] <= -valor) | (df_metricas[coluna] >= valor)
+    indices = df_metricas[mask].index.tolist()
+
+    return sorted(indices)
+
+
+# ============================================================
+# TRANSFORMAÇÕES
+# ============================================================
+
+def aplicar_transformacao(data, transformacao):
+    """
+    Aplica uma transformação matemática aos dados.
+    """
+    data = np.asarray(data, dtype=float)
+
+    # Evita overflow em exp
+    if transformacao == "exp(x)" and (data > 50).any():
+        return data
+
+    if transformacao == "(x)":
+        return data
+    elif transformacao == "1/(x)":
+        return 1 / (data + 0.001)
+    elif transformacao == "ln(x)":
+        return np.log(np.maximum(data, 0.001))
+    elif transformacao == "exp(x)":
+        return np.exp(data)
+    elif transformacao == "(x)^2":
+        return data ** 2
+    elif transformacao == "raiz(x)":
+        return np.sqrt(np.maximum(data, 0))
+    elif transformacao == "1/raiz(x)":
+        return 1 / (np.sqrt(np.maximum(data, 0)) + 0.001)
+    else:
+        return data
+
+
+def inverter_transformacao_y(data, transformacao):
+    """
+    Inverte a transformação aplicada em y para obter valores na escala original.
+    """
+    data = np.asarray(data, dtype=float)
+
+    if transformacao in ["(y)", "(x)", "direct"]:
+        return data
+    elif transformacao in ["ln(y)", "ln(x)"]:
+        return np.exp(data)
+    elif transformacao in ["1/(y)", "1/(x)"]:
+        return 1 / (data + 0.001)
+    elif transformacao in ["exp(y)", "exp(x)"]:
+        return np.log(np.maximum(data, 0.001))
+    elif transformacao in ["(y)^2", "(x)^2"]:
+        return np.sqrt(np.maximum(data, 0))
+    elif transformacao in ["raiz(y)", "raiz(x)"]:
+        return data ** 2
+    elif transformacao in ["1/raiz(y)", "1/raiz(x)"]:
+        return 1 / (data ** 2 + 0.001)
+    else:
+        return data
+
+
+def formatar_transformacao(transformacao, is_y=False):
+    """
+    Formata a string da transformação para exibição.
+    """
+    if transformacao == "(x)":
+        return "(y)" if is_y else "(x)"
+    elif transformacao == "1/(x)":
+        return "1/(y)" if is_y else "1/(x)"
+    elif transformacao == "ln(x)":
+        return "ln(y)" if is_y else "ln(x)"
+    elif transformacao == "exp(x)":
+        return "exp(y)" if is_y else "exp(x)"
+    elif transformacao == "(x)^2":
+        return "(y)^2" if is_y else "(x)^2"
+    elif transformacao == "raiz(x)":
+        return "raiz(y)" if is_y else "raiz(x)"
+    elif transformacao == "1/raiz(x)":
+        return "1/raiz(y)" if is_y else "1/raiz(x)"
+    else:
+        return transformacao
+
+
+def detectar_dicotomicas(df, colunas):
+    """
+    Detecta quais colunas são dicotômicas (apenas 0 e 1).
+    Retorna lista de nomes de colunas dicotômicas.
+    """
+    dicotomicas = []
+    for col in colunas:
+        valores = set(df[col].dropna().unique())
+        if valores.issubset({0, 1, 0.0, 1.0}):
+            dicotomicas.append(col)
+    return dicotomicas
+
+
+def detectar_codigo_alocado(df, colunas):
+    """
+    Detecta variáveis de código alocado/ajustado.
+    Critérios: todos os valores são inteiros, ≥3 valores distintos, nenhum zero.
+    Exclui variáveis já detectadas como dicotômicas (0/1).
+    Retorna lista de nomes de colunas de código alocado.
+    """
+    resultado = []
+    for col in colunas:
+        valores = df[col].dropna().unique()
+        valores_set = set(valores)
+        # Pelo menos 3 valores distintos
+        if len(valores_set) < 3:
+            continue
+        # Todos devem ser inteiros
+        try:
+            if not all(float(v) == int(float(v)) for v in valores):
+                continue
+        except (ValueError, TypeError):
+            continue
+        # Nenhum valor zero
+        if any(float(v) == 0 for v in valores):
+            continue
+        resultado.append(col)
+    return resultado
+
+
+def detectar_percentuais(df, colunas):
+    """
+    Detecta variáveis percentuais (todos valores entre 0 e 1, com decimais ou >2 distintos).
+    Exclui variáveis já detectadas como dicotômicas puras (só {0, 1}).
+    Retorna lista de nomes de colunas percentuais.
+    """
+    resultado = []
+    for col in colunas:
+        valores = df[col].dropna().unique()
+        if len(valores) < 2:
+            continue
+        # Todos devem estar entre 0 e 1
+        try:
+            if not all(0 <= float(v) <= 1 for v in valores):
+                continue
+        except (ValueError, TypeError):
+            continue
+        # Não pode ser dicotômica pura (só {0,1})
+        if set(valores).issubset({0, 1, 0.0, 1.0}):
+            continue
+        resultado.append(col)
+    return resultado
+
+
+# ============================================================
+# VERIFICAÇÃO DE MULTICOLINEARIDADE
+# ============================================================
+
+def verificar_multicolinearidade(df, colunas_x):
+    """Verifica multicolinearidade na matriz de regressoras (dados brutos, sem transformação).
+
+    Calcula o posto da matriz (X + intercepto) para detectar dependência linear exata
+    e o VIF de cada variável para detectar colinearidade forte (mas não perfeita).
+
+    Retorna dict com:
+        'perfeita': bool — posto deficiente (matriz singular)
+        'alta': bool — alguma variável com VIF > 10
+        'vif': dict {col: float} — VIF de cada variável (vazio se perfeita ou < 2 vars)
+        'vars_alta': list — variáveis com VIF > 10
+        'posto': int — posto efetivo da matriz aumentada
+        'ncolunas': int — número de colunas da matriz aumentada
+    """
+    from statsmodels.stats.outliers_influence import variance_inflation_factor
+
+    n_vars = len(colunas_x)
+    vazio = {'perfeita': False, 'alta': False, 'vif': {}, 'vars_alta': [], 'posto': 0, 'ncolunas': 0}
+
+    if n_vars < 2:
+        return vazio
+
+    try:
+        X_df = df[list(colunas_x)].dropna()
+        if len(X_df) == 0:
+            return vazio
+        X = X_df.values.astype(float)
+
+        # Remove colunas com variância zero (constantes puras — capturadas como dependência com intercepto)
+        std = X.std(axis=0)
+        X = X[:, std > 0]
+        cols_validas = [c for c, s in zip(colunas_x, std) if s > 0]
+
+        if len(cols_validas) < 2:
+            return vazio
+
+        X_const = np.column_stack([np.ones(len(X)), X])
+        posto = int(np.linalg.matrix_rank(X_const))
+        ncolunas = X_const.shape[1]
+
+        if posto < ncolunas:
+            return {
+                'perfeita': True, 'alta': True, 'vif': {}, 'vars_alta': [],
+                'posto': posto, 'ncolunas': ncolunas,
+            }
+
+        # Calcula VIF apenas quando n > k (amostra suficiente)
+        if len(X_const) <= ncolunas:
+            return vazio
+
+        vif = {}
+        for i, col in enumerate(cols_validas):
+            try:
+                v = float(variance_inflation_factor(X_const, i + 1))  # +1 pula intercepto
+                vif[col] = v
+            except Exception:
+                vif[col] = float('inf')  # OLS interno singular → colinearidade exata para esta variável
+
+        # Verifica se algum VIF é infinito (colinearidade que o rank numérico não capturou)
+        if any(np.isinf(v) for v in vif.values()):
+            vars_inf = [c for c, v in vif.items() if np.isinf(v)]
+            vif_finito = {c: v for c, v in vif.items() if not np.isinf(v)}
+            return {
+                'perfeita': True, 'alta': True,
+                'vif': vif_finito, 'vars_alta': vars_inf,
+                'posto': posto, 'ncolunas': ncolunas,
+            }
+
+        vars_alta = [c for c, v in vif.items() if v > 10]
+        return {
+            'perfeita': False,
+            'alta': len(vars_alta) > 0,
+            'vif': vif,
+            'vars_alta': vars_alta,
+            'posto': posto,
+            'ncolunas': ncolunas,
+        }
+    except Exception:
+        return vazio
+
+
+# ============================================================
+# MODELO OLS E DIAGNÓSTICOS
+# ============================================================
+
+def ajustar_modelo(df, coluna_y, colunas_x, transformacao_y, transformacoes_x, indices_usar=None):
+    """
+    Ajusta modelo OLS com as transformações especificadas.
+
+    Parâmetros:
+        df: DataFrame com os dados
+        coluna_y: nome da coluna da variável dependente
+        colunas_x: lista de nomes das colunas independentes
+        transformacao_y: transformação para y
+        transformacoes_x: dict {coluna: transformação} para X
+        indices_usar: lista de índices a incluir (se None, usa todos)
+
+    Retorna:
+        dict com resultados do modelo ou None se falhar
+    """
+    if not colunas_x:
+        return None
+
+    # Filtra por índices se especificado
+    df_modelo = df.copy()
+    if indices_usar is not None:
+        df_modelo = df_modelo.loc[indices_usar]
+
+    # Prepara y transformado
+    y = df_modelo[coluna_y].values
+    y_transf = aplicar_transformacao(y, transformacao_y)
+
+    # Prepara X transformado
+    X_transf = pd.DataFrame(index=df_modelo.index)
+    for col in colunas_x:
+        transf = transformacoes_x.get(col, "(x)")
+        X_transf[col] = aplicar_transformacao(df_modelo[col].values, transf)
+
+    # Remove linhas com NaN ou Inf
+    mask = ~(np.isnan(y_transf) | np.isinf(y_transf))
+    for col in X_transf.columns:
+        mask &= ~(np.isnan(X_transf[col]) | np.isinf(X_transf[col]))
+
+    y_final = y_transf[mask]
+    X_final = X_transf.loc[mask.values if hasattr(mask, 'values') else mask]
+    indices_final = df_modelo.index[mask]
+
+    if len(y_final) < len(colunas_x) + 2:
+        return None
+
+    try:
+        # Ajusta modelo
+        X_sm = sm.add_constant(X_final)
+        modelo = sm.OLS(y_final, X_sm).fit()
+
+        # Calcula diagnósticos
+        diagnosticos = calcular_diagnosticos(modelo, X_final, y_final, coluna_y, transformacao_y, transformacoes_x)
+
+        # Tabela de coeficientes
+        tabela_coef = pd.DataFrame({
+            "Variável": modelo.params.index,
+            "Coeficiente": modelo.params.values,
+            "Erro Padrão": modelo.bse.values,
+            "t-Student": modelo.tvalues.values,
+            "p-valor": modelo.pvalues.values,
+            "Significância": [classificar_significancia(p) for p in modelo.pvalues.values]
+        })
+
+        # Tabela obs vs calc
+        y_obs = y_final
+        y_calc = modelo.predict()
+        residuos = modelo.resid
+        residuos_pad = residuos / diagnosticos["desvio_padrao_residuos"]
+
+        influence = OLSInfluence(modelo)
+        residuos_stud = influence.resid_studentized
+        cook = influence.cooks_distance[0]
+
+        tabela_obs_calc = pd.DataFrame({
+            "Índice": indices_final,
+            "Observado": y_obs,
+            "Calculado": y_calc,
+            "Resíduo": residuos,
+            "Resíduo Pad.": residuos_pad,
+            "Resíduo Stud.": residuos_stud,
+            "Cook": cook
+        })
+
+        # Dados transformados
+        X_esc_info = [f"{col}: {formatar_transformacao(transformacoes_x.get(col, '(x)'))}" for col in colunas_x]
+        y_esc_info = f"{coluna_y}: {formatar_transformacao(transformacao_y, is_y=True)}"
+
+        return {
+            "modelo_sm": modelo,
+            "diagnosticos": diagnosticos,
+            "tabela_coef": tabela_coef,
+            "tabela_obs_calc": tabela_obs_calc,
+            "X_transformado": X_final,
+            "y_transformado": pd.Series(y_final, index=indices_final, name=coluna_y),
+            "transformacoes_x": transformacoes_x.copy(),
+            "transformacao_y": transformacao_y,
+            "colunas_x": colunas_x.copy(),
+            "coluna_y": coluna_y,
+            "X_esc_info": X_esc_info,
+            "y_esc_info": y_esc_info,
+            "indices_usados": indices_final.tolist()
+        }
+
+    except Exception as e:
+        print(f"Erro ao ajustar modelo: {e}")
+        return None
+
+
+def calcular_diagnosticos(modelo, X, y, coluna_y, transformacao_y, transformacoes_x):
+    """
+    Calcula todos os diagnósticos do modelo.
+    """
+    n = len(y)
+    k = X.shape[1]
+    residuos = modelo.resid
+
+    desvio_padrao_residuos = np.sqrt(np.sum(residuos**2) / (n - k - 1))
+    residuos_pad = residuos / desvio_padrao_residuos
+
+    # Métricas básicas
+    mse = np.mean(residuos**2)
+    r2 = modelo.rsquared
+    r2_ajustado = modelo.rsquared_adj
+    r_pearson = np.corrcoef(y, modelo.predict())[0, 1]
+    Fc = modelo.fvalue
+    p_valor_F = modelo.f_pvalue
+
+    # Interpretação F
+    if p_valor_F < 0.01:
+        interp_F = "✅ Fc > Ft: Significante ao nível de 1% (α = 1%) — Grau III"
+    elif p_valor_F < 0.02:
+        interp_F = "✅ Fc > Ft: Significante ao nível de 2% (α = 2%) — Grau II"
+    elif p_valor_F < 0.05:
+        interp_F = "✅ Fc > Ft: Significante ao nível de 5% (α = 5%) — Grau I"
+    else:
+        interp_F = "❌ Fc < Ft: Não significante ao nível de 5%"
+
+    # Teste KS (normalidade)
+    ks_stat, ks_p = kstest(residuos, "norm", args=(np.mean(residuos), np.std(residuos, ddof=1)))
+    if ks_p >= 0.05:
+        interp_KS = "✅ Não foi identificada evidência estatística de violação da normalidade dos resíduos (α = 5%)"
+    elif ks_p >= 0.02:
+        interp_KS = "❌ Rejeita-se a hipótese de normalidade dos resíduos (α = 5%)"
+    elif ks_p >= 0.01:
+        interp_KS = "❌ Rejeita-se a hipótese de normalidade dos resíduos (α = 2%)"
+    else:
+        interp_KS = "❌ Rejeita-se a hipótese de normalidade dos resíduos (α = 1%)"
+
+    # Percentuais da curva normal (formato compatível com .dai)
+    intervalos = [(-1.00, 1.00), (-1.64, 1.64), (-1.96, 1.96)]
+    percentuais = []
+    for min_int, max_int in intervalos:
+        count = np.sum((residuos_pad >= min_int) & (residuos_pad <= max_int))
+        perc = round(count / len(residuos) * 100, 0)
+        percentuais.append(f"{perc:.0f}%")
+    perc_resid = ", ".join(percentuais)
+
+    # Durbin-Watson
+    dw = durbin_watson(residuos)
+    k_dw = min(max(1, k), 4)
+
+    # Limites críticos a 5% (referência padrão)
+    tab5 = DW_TABLE[0.05][k_dw]
+    dL = np.interp(n, tab5["n"], tab5["dL"])
+    dU = np.interp(n, tab5["n"], tab5["dU"])
+
+    # Limites críticos a 1% (para escalonamento)
+    tab1 = DW_TABLE[0.01][k_dw]
+    dL_01 = np.interp(n, tab1["n"], tab1["dL"])
+
+    if dw < dL:
+        if dw < dL_01:
+            interp_DW = f"❌ Autocorrelação positiva (DW < dL = {dL_01:.4f}, α = 1%)"
+        else:
+            interp_DW = f"❌ Autocorrelação positiva (DW < dL = {dL:.4f}, α = 5%)"
+    elif dw > 4 - dL:
+        if dw > 4 - dL_01:
+            interp_DW = f"❌ Autocorrelação negativa (DW > 4−dL = {4-dL_01:.4f}, α = 1%)"
+        else:
+            interp_DW = f"❌ Autocorrelação negativa (DW > 4−dL = {4-dL:.4f}, α = 5%)"
+    elif dU < dw < 4 - dU:
+        interp_DW = f"✅ Não foi identificada evidência estatística de autocorrelação dos resíduos (dU = {dU:.4f} < DW < 4−dU = {4-dU:.4f})"
+    else:
+        interp_DW = f"⚠️ Região inconclusiva (dL = {dL:.4f}, dU = {dU:.4f})"
+
+    # Breusch-Pagan
+    bp_lm, bp_p, bp_f, bp_fp = het_breuschpagan(residuos, sm.add_constant(X))
+    if bp_p >= 0.05:
+        interp_BP = "✅ Não foi identificada evidência estatística de heterocedasticidade  (α = 5%)"
+    elif bp_p >= 0.02:
+        interp_BP = "❌ Rejeita-se a hipótese de homocedasticidade (α = 5%)"
+    elif bp_p >= 0.01:
+        interp_BP = "❌ Rejeita-se a hipótese de homocedasticidade (α = 2%)"
+    else:
+        interp_BP = "❌ Rejeita-se a hipótese de homocedasticidade (α = 1%)"
+
+    # Equação do modelo
+    equacao = formatar_equacao(modelo, coluna_y, transformacao_y, transformacoes_x, list(X.columns))
+
+    # Gera formatted_output para compatibilidade com .dai
+    formatted_output = f"""Número de observações: {n}
+Número de variáveis independentes: {k}
+Desvio padrão dos resíduos: {desvio_padrao_residuos:.4f}
+MSE: {mse:.4f}
+R²: {r2:.4f}
+R² ajustado: {r2_ajustado:.4f}
+Correlação Pearson: {r_pearson:.4f}
+Estatística F: {Fc:.4f} (p-valor: {p_valor_F:.4f}) -> {interp_F}
+----------------------------------------------------------------------
+Teste de Normalidade (Kolmogorov-Smirnov):
+ Estatística KS: {ks_stat:.4f}, p-valor: {ks_p:.4f} -> {interp_KS}
+Teste de Normalidade (Comparação com a curva normal) – percentuais atingidos: {perc_resid}
+  • Ideal 68%  → aceitável entre 64% e 75%
+  • Ideal 90%  → aceitável entre 88% e 95%
+  • Ideal 95%  → aceitável entre 95% e 100%
+----------------------------------------------------------------------
+Teste de Autocorrelação (Durbin-Watson):
+ DW: {dw:.4f} (dL = {dL:.4f}, dU = {dU:.4f}) -> {interp_DW}
+----------------------------------------------------------------------
+Teste de Homocedasticidade (Breusch-Pagan):
+ Estatística LM: {bp_lm:.4f}, p-valor: {bp_p:.4f}
+ {interp_BP}
+----------------------------------------------------------------------
+
+Equação do Modelo:
+ {equacao}"""
+
+    return {
+        "n": n,
+        "k": k,
+        "desvio_padrao_residuos": desvio_padrao_residuos,
+        "mse": mse,
+        "r2": r2,
+        "r2_ajustado": r2_ajustado,
+        "r_pearson": r_pearson,
+        "Fc": Fc,
+        "p_valor_F": p_valor_F,
+        "interp_F": interp_F,
+        "ks_stat": ks_stat,
+        "ks_p": ks_p,
+        "interp_KS": interp_KS,
+        "perc_resid": perc_resid,
+        "dw": dw,
+        "interp_DW": interp_DW,
+        "bp_lm": bp_lm,
+        "bp_p": bp_p,
+        "interp_BP": interp_BP,
+        "equacao": equacao,
+        "formatted_output": formatted_output
+    }
+
+
+def classificar_significancia(p_valor):
+    """Classifica significância segundo NBR 14.653-2."""
+    if p_valor <= 0.10:
+        return "Grau III"
+    elif p_valor <= 0.20:
+        return "Grau II"
+    elif p_valor <= 0.30:
+        return "Grau I"
+    else:
+        return "Sem enquadramento"
+
+
+def formatar_equacao(modelo, coluna_y, transformacao_y, transformacoes_x, colunas_x):
+    """Formata a equação do modelo."""
+    equacao = f"{modelo.params['const']:.6f}"
+
+    for col in colunas_x:
+        coef = modelo.params[col]
+        transf = transformacoes_x.get(col, "(x)")
+
+        if transf == "ln(x)":
+            termo = f"ln({col})"
+        elif transf == "1/(x)":
+            termo = f"1/{col}"
+        elif transf == "(x)^2":
+            termo = f"({col})²"
+        elif transf == "raiz(x)":
+            termo = f"√({col})"
+        elif transf == "1/raiz(x)":
+            termo = f"1/√({col})"
+        elif transf == "exp(x)":
+            termo = f"exp({col})"
+        else:
+            termo = col
+
+        sinal = "+" if coef >= 0 else "-"
+        equacao += f" {sinal} {abs(coef):.6f} × {termo}"
+
+    # Aplica inversão de y
+    if transformacao_y == "ln(x)":
+        equacao = f"exp({equacao})"
+    elif transformacao_y == "(x)^2":
+        equacao = f"√({equacao})"
+    elif transformacao_y == "1/(x)":
+        equacao = f"1/({equacao})"
+    elif transformacao_y == "raiz(x)":
+        equacao = f"({equacao})²"
+    elif transformacao_y == "1/raiz(x)":
+        equacao = f"1/({equacao})²"
+
+    return f"{coluna_y} = {equacao}"
+
+
+# ============================================================
+# BUSCA AUTOMÁTICA DE TRANSFORMAÇÕES (OTIMIZADA)
+# ============================================================
+
+def _calcular_r2_numpy(X, y):
+    """
+    Calcula R² usando operações matriciais diretas (mais rápido que statsmodels).
+    """
+    n = len(y)
+    if n == 0:
+        return -np.inf
+
+    # Adiciona constante
+    X_const = np.column_stack([np.ones(n), X])
+
+    try:
+        # OLS: beta = (X'X)^-1 X'y
+        XtX = X_const.T @ X_const
+        Xty = X_const.T @ y
+        beta = np.linalg.solve(XtX, Xty)
+
+        # R²
+        y_pred = X_const @ beta
+        ss_res = np.sum((y - y_pred) ** 2)
+        ss_tot = np.sum((y - np.mean(y)) ** 2)
+
+        if ss_tot == 0:
+            return -np.inf
+
+        return 1 - (ss_res / ss_tot)
+    except:
+        return -np.inf
+
+
+def _calcular_pvalores_numpy(X, y):
+    """
+    Calcula p-valores dos coeficientes X e p-valor do teste F usando operações matriciais.
+    Retorna (p_valores_coeficientes, p_valor_f) ou (None, None) se falhar.
+    p_valores_coeficientes inclui a constante (intercepto) no índice 0.
+    """
+    from scipy.stats import t as t_dist, f as f_dist
+    n = len(y)
+    X_const = np.column_stack([np.ones(n), X])
+    k = X_const.shape[1]  # inclui constante
+    if n <= k:
+        return None, None
+    try:
+        XtX = X_const.T @ X_const
+        XtX_inv = np.linalg.inv(XtX)
+        beta = XtX_inv @ (X_const.T @ y)
+        y_pred = X_const @ beta
+        residuals = y - y_pred
+        ss_res = np.sum(residuals ** 2)
+        sigma2 = ss_res / (n - k)
+        if sigma2 <= 0:
+            return None, None
+        diag_vals = np.diag(sigma2 * XtX_inv)
+        if np.any(diag_vals < 0):
+            return None, None  # matriz mal-condicionada (multicolinearidade)
+        se = np.sqrt(diag_vals)
+        if np.any(se == 0):
+            return None, None
+        t_stats = beta / se
+        p_valores = 2 * t_dist.sf(np.abs(t_stats), df=n - k)
+
+        # Teste F: (SS_reg / (k-1)) / (SS_res / (n-k))
+        y_mean = np.mean(y)
+        ss_tot = np.sum((y - y_mean) ** 2)
+        ss_reg = ss_tot - ss_res
+        df_reg = k - 1  # graus de liberdade da regressão (exclui constante)
+        df_res = n - k
+        if df_reg > 0 and df_res > 0 and ss_res > 0:
+            f_stat = (ss_reg / df_reg) / (ss_res / df_res)
+            p_valor_f = f_dist.sf(f_stat, df_reg, df_res)
+        else:
+            p_valor_f = 1.0
+
+        return p_valores, p_valor_f  # inclui constante (intercepto) no índice 0
+    except:
+        return None, None
+
+
+def _precomputar_transformacoes(df, colunas):
+    """
+    Pré-computa todas as transformações válidas para as colunas.
+    Retorna dict: {(coluna, transformacao): array}
+    """
+    cache = {}
+
+    for col in colunas:
+        valores = df[col].values.astype(float)
+        for transf in TRANSFORMACOES:
+            dados_transf = aplicar_transformacao(valores, transf)
+
+            # Só armazena se válido
+            if not (np.isnan(dados_transf).any() or np.isinf(dados_transf).any()):
+                cache[(col, transf)] = dados_transf
+
+    return cache
+
+
+def _buscar_stepwise(colunas_x, colunas_livres, transformacoes_fixas, y_transf, x_cache, df_busca):
+    """
+    Busca stepwise: otimiza uma variável por vez.
+    Mais rápido para muitas variáveis (O(7*n) em vez de O(7^n)).
+    """
+    # Inicializa com transformação (x) para todas
+    transf_x_atuais = {col: "(x)" for col in colunas_livres}
+
+    # Para cada variável X, encontrar melhor transformação
+    for col in colunas_livres:
+        melhor_transf = "(x)"
+        melhor_r2 = -np.inf
+
+        for transf in TRANSFORMACOES:
+            if (col, transf) not in x_cache:
+                continue
+
+            # Testa com esta transformação
+            transf_teste = transf_x_atuais.copy()
+            transf_teste[col] = transf
+
+            # Monta matriz X
+            X_arrays = []
+            valido = True
+            for c in colunas_x:
+                if c in transformacoes_fixas:
+                    t = transformacoes_fixas[c]
+                else:
+                    t = transf_teste.get(c, "(x)")
+
+                if (c, t) in x_cache:
+                    X_arrays.append(x_cache[(c, t)])
+                else:
+                    valido = False
+                    break
+
+            if not valido or not X_arrays:
+                continue
+
+            X = np.column_stack(X_arrays)
+            r2 = _calcular_r2_numpy(X, y_transf)
+
+            if r2 > melhor_r2:
+                melhor_r2 = r2
+                melhor_transf = transf
+
+        transf_x_atuais[col] = melhor_transf
+
+    # Calcula R² final
+    transf_x_final = {**transformacoes_fixas, **transf_x_atuais}
+    X_arrays = []
+    for c in colunas_x:
+        t = transf_x_final.get(c, "(x)")
+        if (c, t) in x_cache:
+            X_arrays.append(x_cache[(c, t)])
+
+    if X_arrays:
+        X = np.column_stack(X_arrays)
+        r2_final = _calcular_r2_numpy(X, y_transf)
+    else:
+        r2_final = -np.inf
+
+    return transf_x_final, r2_final
+
+
+def _buscar_exaustivo_numpy(colunas_x, colunas_livres, transformacoes_fixas, y_transf, x_cache, top_n):
+    """
+    Busca exaustiva usando numpy para cálculo rápido de R².
+    Para uso quando o número de combinações é pequeno (<= 5000).
+    """
+    n_livres = len(colunas_livres)
+    resultados_transf = []
+
+    for combo in product(TRANSFORMACOES, repeat=n_livres):
+        # Monta dict de transformações
+        transf_x = transformacoes_fixas.copy()
+        for i, col in enumerate(colunas_livres):
+            transf_x[col] = combo[i]
+
+        # Monta matriz X
+        X_arrays = []
+        valido = True
+        for col in colunas_x:
+            t = transf_x.get(col, "(x)")
+            if (col, t) in x_cache:
+                X_arrays.append(x_cache[(col, t)])
+            else:
+                valido = False
+                break
+
+        if not valido or not X_arrays:
+            continue
+
+        X = np.column_stack(X_arrays)
+        r2 = _calcular_r2_numpy(X, y_transf)
+
+        if r2 > -np.inf:
+            resultados_transf.append((r2, transf_x.copy()))
+
+    # Ordena e retorna top
+    resultados_transf.sort(key=lambda x: x[0], reverse=True)
+    return resultados_transf[:top_n]
+
+
+def _classificar_grau_coef(p):
+    """Classifica p-valor de coeficiente em grau de enquadramento (0-3)."""
+    if p is None or p > 0.30:
+        return 0
+    if p > 0.20:
+        return 1
+    if p > 0.10:
+        return 2
+    return 3
+
+
+def _classificar_grau_f(p):
+    """Classifica p-valor do teste F em grau de enquadramento (0-3)."""
+    if p is None or p > 0.05:
+        return 0
+    if p > 0.02:
+        return 1
+    if p > 0.01:
+        return 2
+    return 3
+
+
+def buscar_melhores_transformacoes(df, coluna_y, colunas_x, transformacoes_fixas=None, transformacao_y_fixa=None,
+                                    indices_usar=None, top_n=5,
+                                    grau_min_coef=3, grau_min_f=3):
+    """
+    Busca otimizada das melhores combinações de transformações para maximizar R².
+
+    Usa estratégia híbrida:
+    - Para poucos combos (<=5000): busca exaustiva com numpy (rápida)
+    - Para muitos combos (>5000): busca stepwise (O(7*n) em vez de O(7^n))
+
+    Parâmetros:
+        df: DataFrame
+        coluna_y: variável dependente
+        colunas_x: lista de variáveis independentes
+        transformacoes_fixas: dict {coluna: transformação} para variáveis com transformação fixa
+        transformacao_y_fixa: transformação fixa para y (ou None para testar todas)
+        indices_usar: lista de índices a incluir (se None, usa todos)
+        top_n: número de melhores modelos a retornar
+        grau_min_coef: grau mínimo de significância dos coeficientes (3=Grau III p≤10%, 2=Grau II p≤20%, 1=Grau I p≤30%, 0=sem filtro)
+        grau_min_f: grau mínimo do teste F (3=Grau III α=1%, 2=Grau II α=2%, 1=Grau I α=5%, 0=sem filtro)
+
+    Retorna:
+        Lista de dicts com informações dos top N modelos
+    """
+    if transformacoes_fixas is None:
+        transformacoes_fixas = {}
+
+    # Filtra por índices se especificado
+    df_busca = df.copy()
+    if indices_usar is not None:
+        df_busca = df_busca.loc[indices_usar]
+
+    # Detecta dicotômicas e percentuais e fixa em (x) (código alocado fica livre)
+    dicotomicas = detectar_dicotomicas(df_busca, colunas_x)
+    percentuais = detectar_percentuais(df_busca, colunas_x)
+    for col in dicotomicas + percentuais:
+        if col not in transformacoes_fixas:
+            transformacoes_fixas[col] = "(x)"
+
+    # Identifica colunas livres (não fixas)
+    colunas_livres = [col for col in colunas_x if col not in transformacoes_fixas]
+    n_livres = len(colunas_livres)
+
+    # Define transformações de Y a testar
+    if transformacao_y_fixa:
+        transformacoes_y = [transformacao_y_fixa]
+    else:
+        transformacoes_y = TRANSFORMACOES
+
+    # Pré-computa todas as transformações de X (apenas colunas livres)
+    x_cache = _precomputar_transformacoes(df_busca, colunas_livres)
+
+    # Adiciona transformações fixas ao cache
+    for col, transf in transformacoes_fixas.items():
+        if col in colunas_x:
+            dados = aplicar_transformacao(df_busca[col].values.astype(float), transf)
+            if not (np.isnan(dados).any() or np.isinf(dados).any()):
+                x_cache[(col, transf)] = dados
+
+    # Calcula número total de combinações
+    total_combos = len(TRANSFORMACOES) ** n_livres if n_livres > 0 else 1
+    usar_stepwise = total_combos > 5000
+
+    # Mapeamento de grau para limiar de p-valor
+    _LIMIARES_COEF = {3: 0.10, 2: 0.20, 1: 0.30}
+    _LIMIARES_F = {3: 0.01, 2: 0.02, 1: 0.05}
+    limiar_coef = _LIMIARES_COEF.get(grau_min_coef)
+    limiar_f = _LIMIARES_F.get(grau_min_f)
+
+    # Coleta mais candidatos quando vai filtrar
+    tem_filtro = limiar_coef is not None or limiar_f is not None
+    top_n_interno = top_n * 10 if tem_filtro else top_n
+
+    resultados = []
+
+    for transf_y in transformacoes_y:
+        # Pré-computa Y transformado
+        y_transf = aplicar_transformacao(df_busca[coluna_y].values.astype(float), transf_y)
+
+        # Se y_transf tem problemas, pula
+        if np.isnan(y_transf).any() or np.isinf(y_transf).any():
+            continue
+
+        if n_livres == 0:
+            # Todas as variáveis são fixas, só calcula R²
+            X_arrays = [x_cache[(col, transformacoes_fixas[col])]
+                        for col in colunas_x if (col, transformacoes_fixas.get(col, "(x)")) in x_cache]
+            if X_arrays:
+                X = np.column_stack(X_arrays)
+                r2 = _calcular_r2_numpy(X, y_transf)
+                if r2 > -np.inf:
+                    resultados.append({
+                        "r2": r2,
+                        "transformacao_y": transf_y,
+                        "transformacoes_x": transformacoes_fixas.copy()
+                    })
+        elif usar_stepwise:
+            # Busca stepwise para muitas variáveis
+            transf_x, r2 = _buscar_stepwise(
+                colunas_x, colunas_livres, transformacoes_fixas,
+                y_transf, x_cache, df_busca
+            )
+            if r2 > -np.inf:
+                resultados.append({
+                    "r2": r2,
+                    "transformacao_y": transf_y,
+                    "transformacoes_x": transf_x
+                })
+        else:
+            # Busca exaustiva para poucas variáveis
+            top_combos = _buscar_exaustivo_numpy(
+                colunas_x, colunas_livres, transformacoes_fixas,
+                y_transf, x_cache, top_n_interno
+            )
+            for r2, transf_x in top_combos:
+                resultados.append({
+                    "r2": r2,
+                    "transformacao_y": transf_y,
+                    "transformacoes_x": transf_x
+                })
+
+    # Ordena por R²
+    resultados = sorted(resultados, key=lambda x: x["r2"], reverse=True)
+
+    # Filtra por significância dos coeficientes e/ou teste F
+    if tem_filtro and resultados:
+        resultados_filtrados = []
+        for r in resultados:
+            transf_y = r["transformacao_y"]
+            transf_x = r["transformacoes_x"]
+
+            # Monta Y transformado
+            y_transf = aplicar_transformacao(df_busca[coluna_y].values.astype(float), transf_y)
+            if np.isnan(y_transf).any() or np.isinf(y_transf).any():
+                continue
+
+            # Monta X transformado
+            X_arrays = []
+            valido = True
+            for col in colunas_x:
+                t = transf_x.get(col, "(x)")
+                if (col, t) in x_cache:
+                    X_arrays.append(x_cache[(col, t)])
+                else:
+                    valido = False
+                    break
+
+            if not valido or not X_arrays:
+                continue
+
+            X = np.column_stack(X_arrays)
+            p_valores_coef, p_valor_f = _calcular_pvalores_numpy(X, y_transf)
+
+            # Filtro de significância dos coeficientes
+            if limiar_coef is not None:
+                if p_valores_coef is None or not all(p <= limiar_coef for p in p_valores_coef):
+                    continue
+
+            # Filtro do teste F
+            if limiar_f is not None:
+                if p_valor_f is None or p_valor_f >= limiar_f:
+                    continue
+
+            resultados_filtrados.append(r)
+
+            if len(resultados_filtrados) >= top_n:
+                break
+
+        resultados = resultados_filtrados
+
+    resultados = resultados[:top_n]
+
+    # Adiciona ranking
+    for i, r in enumerate(resultados):
+        r["rank"] = i + 1
+
+    # Enriquece resultados com graus de enquadramento por variável e teste F
+    for r in resultados:
+        y_tc = aplicar_transformacao(df_busca[coluna_y].values.astype(float), r["transformacao_y"])
+        X_arrs, valido = [], True
+        for col in colunas_x:
+            t = r["transformacoes_x"].get(col, "(x)")
+            if (col, t) in x_cache:
+                X_arrs.append(x_cache[(col, t)])
+            else:
+                valido = False
+                break
+        if valido and X_arrs and not (np.isnan(y_tc).any() or np.isinf(y_tc).any()):
+            p_vals, p_f = _calcular_pvalores_numpy(np.column_stack(X_arrs), y_tc)
+            if p_vals is not None:
+                r["graus_coef"] = {col: _classificar_grau_coef(float(p_vals[i + 1]))
+                                   for i, col in enumerate(colunas_x)}
+            else:
+                r["graus_coef"] = {col: 0 for col in colunas_x}
+            r["grau_f"] = _classificar_grau_f(p_f) if p_f is not None else 0
+        else:
+            r["graus_coef"] = {col: 0 for col in colunas_x}
+            r["grau_f"] = 0
+
+    return resultados
+
+
+# ============================================================
+# MICRONUMEROSIDADE (NBR 14.653-2)
+# ============================================================
+
+def _testar_frequencia_coluna(df, coluna, n):
+    """Testa critérios de frequência mínima por categoria para uma coluna.
+
+    Retorna dict com 'valido' (bool) e 'mensagens' (list).
+    """
+    if coluna not in df.columns:
+        return {"valido": True, "mensagens": []}
+
+    frequencia = df[coluna].value_counts()
+    ni_valido = True
+    mensagens = []
+
+    for categoria, ni in frequencia.items():
+        if n <= 30:
+            if ni < 3:
+                ni_valido = False
+                mensagens.append(f"ni={ni} < 3 na categoria {categoria}")
+            else:
+                mensagens.append(f"ni={ni} ≥ 3 na categoria {categoria}")
+        elif 30 < n <= 100:
+            if ni < 0.1 * n:
+                ni_valido = False
+                mensagens.append(f"ni={ni} < {int(0.1 * n)} (10% de n) na categoria {categoria}")
+            else:
+                mensagens.append(f"ni={ni} ≥ {int(0.1 * n)} (10% de n) na categoria {categoria}")
+        elif n > 100:
+            if ni <= 10:
+                ni_valido = False
+                mensagens.append(f"ni={ni} ≤ 10 na categoria {categoria}")
+            else:
+                mensagens.append(f"ni={ni} > 10 na categoria {categoria}")
+
+    return {"valido": ni_valido, "mensagens": mensagens}
+
+
+def testar_micronumerosidade(df, colunas_x, dicotomicas=None, codigo_alocado=None):
+    """
+    Testa critérios de micronumerosidade da NBR 14.653-2.
+
+    Usa as listas de dicotômicas e códigos alocados dos checkboxes (não auto-detecta por dtype).
+    """
+    dicotomicas = dicotomicas or []
+    codigo_alocado = codigo_alocado or []
+
+    n = len(df)
+    k = len(colunas_x)
+
+    # Condição geral: n >= 3*(k+1)
+    condicao_geral = n >= 3 * (k + 1)
+
+    resultados_dicotomicas = {}
+    for coluna in dicotomicas:
+        resultados_dicotomicas[coluna] = _testar_frequencia_coluna(df, coluna, n)
+
+    resultados_codigo_alocado = {}
+    for coluna in codigo_alocado:
+        resultados_codigo_alocado[coluna] = _testar_frequencia_coluna(df, coluna, n)
+
+    return {
+        "n": n,
+        "k": k,
+        "condicao_geral_ok": condicao_geral,
+        "dicotomicas": resultados_dicotomicas,
+        "codigo_alocado": resultados_codigo_alocado,
+    }
+
+
+# ============================================================
+# EXPORTAR BASE TRATADA (CSV)
+# ============================================================
+
+def exportar_base_csv(df):
+    """
+    Exporta DataFrame para arquivo CSV temporário.
+
+    Parâmetros:
+        df: DataFrame a exportar
+
+    Retorna:
+        str: Caminho do arquivo CSV gerado
+    """
+    import tempfile
+    import os
+
+    if df is None or df.empty:
+        return None
+
+    # Cria arquivo temporário
+    fd, caminho = tempfile.mkstemp(suffix=".csv", prefix="base_tratada_")
+    os.close(fd)
+
+    # Salva CSV
+    df.to_csv(caminho, index=True, encoding="utf-8-sig", sep=";", decimal=",")
+
+    return caminho
+
+
+# ============================================================
+# EXPORTAR MODELO (.dai)
+# ============================================================
+
+def exportar_modelo_dai(resultado_modelo, df_original, df_completo=None, estatisticas=None,
+                        nome_arquivo="", elaborador=None, outliers_excluidos=None):
+    """
+    Exporta o modelo em formato .dai v2 (estrutura nested).
+
+    Parâmetros:
+        resultado_modelo: dict com resultado do ajuste
+        df_original: DataFrame filtrado (sem outliers) usado no ajuste
+        df_completo: DataFrame original completo (com outliers) — para restauração futura
+        estatisticas: DataFrame com estatísticas (mantido como DataFrame)
+        nome_arquivo: nome do arquivo de saída
+        elaborador: dict com dados do avaliador (ou None)
+        outliers_excluidos: lista de índices excluídos como outliers (ou None)
+
+    Retorna:
+        tuple: (caminho_arquivo, mensagem)
+    """
+    import tempfile
+
+    if resultado_modelo is None:
+        return None, "Nenhum modelo para exportar"
+
+    try:
+        # Função auxiliar para converter StringDtype para object e limpar DataFrame
+        def limpar_df_para_export(df):
+            """Converte StringDtype para object e remove colunas Unnamed."""
+            df_clean = df.copy()
+            # Remove colunas 'Unnamed: X'
+            cols_unnamed = [c for c in df_clean.columns if str(c).startswith('Unnamed')]
+            if cols_unnamed:
+                df_clean = df_clean.drop(columns=cols_unnamed)
+            # Converte StringDtype para object (compatibilidade entre versões do pandas)
+            for col in df_clean.columns:
+                if pd.api.types.is_string_dtype(df_clean[col]):
+                    df_clean[col] = df_clean[col].astype(object)
+            # Converte index se for string dtype (compatibilidade com .dai)
+            if pd.api.types.is_string_dtype(df_clean.index):
+                df_clean.index = df_clean.index.astype(object)
+            return df_clean
+
+        # Monta pacote
+        lat_col, lon_col = identificar_colunas_coords(df_original)
+
+        # DataFrame com coords para o mapa
+        df_coords = limpar_df_para_export(df_original)
+        if lat_col:
+            df_coords = df_coords.rename(columns={lat_col: "lat"})
+        if lon_col:
+            df_coords = df_coords.rename(columns={lon_col: "lon"})
+
+        # Filtra apenas índices usados no modelo
+        indices_modelo = resultado_modelo["indices_usados"]
+        df_modelo = df_coords.loc[indices_modelo] if indices_modelo else df_coords
+        df_modelo.index.name = None  # Remove nome do índice
+
+        # Prepara df_completo (DataFrame original com todos os dados, inclusive outliers)
+        if df_completo is not None:
+            df_completo_export = limpar_df_para_export(df_completo)
+            if lat_col:
+                df_completo_export = df_completo_export.rename(columns={lat_col: "lat"})
+            if lon_col:
+                df_completo_export = df_completo_export.rename(columns={lon_col: "lon"})
+            df_completo_export.index.name = None
+        else:
+            df_completo_export = None
+
+        # Prepara tabela_coef no formato compatível (índice = Variável, sem coluna "Variável")
+        tabela_coef_export = limpar_df_para_export(resultado_modelo["tabela_coef"])
+        if "Variável" in tabela_coef_export.columns:
+            tabela_coef_export = tabela_coef_export.set_index("Variável")
+        tabela_coef_export.index.name = None  # Remove nome do índice
+        # Converte index para object após set_index (compatibilidade .dai)
+        if pd.api.types.is_string_dtype(tabela_coef_export.index):
+            tabela_coef_export.index = tabela_coef_export.index.astype(object)
+        # Renomeia p-valor para p-value
+        tabela_coef_export = tabela_coef_export.rename(columns={"p-valor": "p-value"})
+
+        # Prepara tabela_obs_calc no formato compatível
+        tabela_obs_calc_export = limpar_df_para_export(resultado_modelo["tabela_obs_calc"])
+        # Move Índice para o index do DataFrame
+        if "Índice" in tabela_obs_calc_export.columns:
+            tabela_obs_calc_export = tabela_obs_calc_export.set_index("Índice")
+        tabela_obs_calc_export.index.name = None  # Remove nome do índice
+        # Renomeia colunas para formato compatível
+        tabela_obs_calc_export = tabela_obs_calc_export.rename(columns={
+            "Resíduo Pad.": "Resíduo Padronizado",
+            "Resíduo Stud.": "Resíduo Studentizado",
+            "Cook": "Distância de Cook"
+        })
+
+        # Extrai diagnosticos do resultado do modelo
+        diag = resultado_modelo["diagnosticos"].copy()
+
+        # Prepara estatisticas no formato compatível (índice = Variável)
+        estatisticas_df = estatisticas if isinstance(estatisticas, pd.DataFrame) else pd.DataFrame(estatisticas)
+        estatisticas_export = limpar_df_para_export(estatisticas_df)
+        if "Variável" in estatisticas_export.columns:
+            estatisticas_export = estatisticas_export.set_index("Variável")
+        estatisticas_export.index.name = None  # Remove nome do índice
+        # Converte index para object após set_index (compatibilidade .dai)
+        if pd.api.types.is_string_dtype(estatisticas_export.index):
+            estatisticas_export.index = estatisticas_export.index.astype(object)
+        # Adiciona coluna Tipo (dtype) se não existir
+        if "Tipo" not in estatisticas_export.columns:
+            # Obtém tipos das colunas do DataFrame original
+            tipos = {}
+            for var in estatisticas_export.index:
+                if var in df_original.columns:
+                    tipos[var] = str(df_original[var].dtype)
+                else:
+                    tipos[var] = "unknown"
+            estatisticas_export.insert(0, "Tipo", pd.Series(tipos))
+        # Mantém apenas colunas compatíveis (na ordem correta)
+        colunas_manter = ["Tipo", "Contagem", "Média", "Mediana", "Mínimo", "Máximo", "Desvio Padrão"]
+        colunas_existentes = [c for c in colunas_manter if c in estatisticas_export.columns]
+        estatisticas_export = estatisticas_export[colunas_existentes]
+
+        # Converte dtypes para compatibilidade com formato .dai
+        if "Contagem" in estatisticas_export.columns:
+            estatisticas_export["Contagem"] = estatisticas_export["Contagem"].astype(str).astype(object)
+        if "Tipo" in estatisticas_export.columns:
+            estatisticas_export["Tipo"] = estatisticas_export["Tipo"].astype(object)
+
+        # Limpa top_X_esc e top_y_esc
+        top_X_esc_export = limpar_df_para_export(resultado_modelo["X_transformado"])
+        top_X_esc_export.index.name = None  # Remove nome do índice
+        top_y_esc_export = resultado_modelo["y_transformado"].copy()
+        top_y_esc_export.index.name = None  # Remove nome do índice
+
+        pacote = {
+            "versao": 2,
+            "elaborador": elaborador,
+            "dados": {
+                "df": df_modelo,
+                "df_completo": df_completo_export,
+                "outliers_excluidos": outliers_excluidos or [],
+                "estatisticas": estatisticas_export,
+            },
+            "transformacoes": {
+                "info": [resultado_modelo["y_esc_info"]] + resultado_modelo["X_esc_info"],
+                "X": top_X_esc_export,
+                "y": top_y_esc_export,
+                "dicotomicas": resultado_modelo.get("dicotomicas", []),
+                "codigo_alocado": resultado_modelo.get("codigo_alocado", []),
+                "percentuais": resultado_modelo.get("percentuais", []),
+            },
+            "modelo": {
+                "sm": resultado_modelo["modelo_sm"],
+                "coeficientes": tabela_coef_export,
+                "obs_calc": tabela_obs_calc_export,
+                "diagnosticos": {
+                    "gerais": {
+                        "n": diag.get("n"),
+                        "k": diag.get("k"),
+                        "desvio_padrao_residuos": diag.get("desvio_padrao_residuos"),
+                        "mse": diag.get("mse"),
+                        "r2": diag.get("r2"),
+                        "r2_ajustado": diag.get("r2_ajustado"),
+                        "r_pearson": diag.get("r_pearson"),
+                    },
+                    "teste_f": {
+                        "estatistica": diag.get("Fc"),
+                        "p_valor": diag.get("p_valor_F"),
+                        "interpretacao": diag.get("interp_F"),
+                    },
+                    "teste_ks": {
+                        "estatistica": diag.get("ks_stat"),
+                        "p_valor": diag.get("ks_p"),
+                        "interpretacao": diag.get("interp_KS"),
+                    },
+                    "teste_normalidade": {
+                        "percentuais": diag.get("perc_resid"),
+                    },
+                    "teste_dw": {
+                        "estatistica": diag.get("dw"),
+                        "interpretacao": diag.get("interp_DW"),
+                    },
+                    "teste_bp": {
+                        "estatistica": diag.get("bp_lm"),
+                        "p_valor": diag.get("bp_p"),
+                        "interpretacao": diag.get("interp_BP"),
+                    },
+                    "equacao": diag.get("equacao"),
+                },
+            },
+        }
+
+        # Função para converter recursivamente StringDtype para object (compatibilidade HF)
+        def converter_para_serializacao(obj):
+            """Converte recursivamente todos os StringDtype para object dtype."""
+            if isinstance(obj, pd.DataFrame):
+                df = obj.copy()
+                if pd.api.types.is_string_dtype(df.index):
+                    df.index = df.index.astype(object)
+                for col in df.columns:
+                    if pd.api.types.is_string_dtype(df[col]):
+                        df[col] = df[col].astype(object)
+                return df
+            elif isinstance(obj, pd.Series):
+                s = obj.copy()
+                if pd.api.types.is_string_dtype(s):
+                    s = s.astype(object)
+                if pd.api.types.is_string_dtype(s.index):
+                    s.index = s.index.astype(object)
+                return s
+            elif isinstance(obj, dict):
+                return {k: converter_para_serializacao(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [converter_para_serializacao(v) for v in obj]
+            else:
+                return obj
+
+        # Converte todo o pacote para garantir compatibilidade entre versões do pandas
+        pacote = converter_para_serializacao(pacote)
+
+        # Cria arquivo no diretório temporário com o nome exato dado pelo usuário
+        nome_base = nome_arquivo.replace(".dai", "") if nome_arquivo.endswith(".dai") else nome_arquivo
+        caminho = os.path.join(tempfile.gettempdir(), f"{nome_base}.dai")
+
+        dump(pacote, caminho)
+
+        return caminho, f"Modelo pronto para download"
+
+    except Exception as e:
+        return None, f"Erro ao exportar: {str(e)}"
+
+
+# ============================================================
+# EXPORTAÇÃO DE AVALIAÇÕES EM EXCEL
+# ============================================================
+
+def exportar_avaliacoes_excel(avaliacoes_lista):
+    """Exporta lista de avaliações como arquivo Excel.
+
+    Args:
+        avaliacoes_lista: lista de dicts retornados por avaliar_imovel().
+
+    Returns:
+        str caminho do arquivo temporário, ou None se lista vazia.
+    """
+    import tempfile
+    import pandas as pd
+
+    if not avaliacoes_lista:
+        return None
+
+    n = len(avaliacoes_lista)
+    colunas_x = list(avaliacoes_lista[0]["valores_x"].keys())
+
+    # Montar dados: linhas = variáveis + métricas, colunas = avaliações
+    dados = {}
+    for i, aval in enumerate(avaliacoes_lista):
+        col_name = f"Aval. {i + 1}"
+        valores = []
+        # Variáveis X
+        for var in colunas_x:
+            valores.append(aval["valores_x"].get(var, ""))
+        # Métricas
+        valores.append(aval["estimado"])
+        valores.append(aval["ca_inf"])
+        valores.append(aval["ca_sup"])
+        valores.append(aval["ic_inf"])
+        valores.append(aval["ic_sup"])
+        valores.append(f'{aval["perc_inf"]:.1f}%')
+        valores.append(f'{aval["perc_sup"]:.1f}%')
+        valores.append(f'{aval["amplitude"]:.1f}%')
+        valores.append(aval["precisao"])
+        valores.append(aval["fundamentacao"])
+        dados[col_name] = valores
+
+    indice = colunas_x + [
+        "Estimado", "CA −15%", "CA +15%",
+        "IC 80% Inf.", "IC 80% Sup.",
+        "% Inf.", "% Sup.", "Amplitude",
+        "Precisão", "Fundamentação",
+    ]
+
+    df = pd.DataFrame(dados, index=indice)
+    caminho = os.path.join(tempfile.gettempdir(), "avaliacoes_mesa.xlsx")
+    df.to_excel(caminho, index=True)
+    return caminho
+
+
+# ============================================================
+# AVALIAÇÃO DE IMÓVEL
+# ============================================================
+
+def avaliar_imovel(modelo_sm, valores_x, colunas_x, transformacoes_x, transformacao_y, estatisticas_df, dicotomicas=None, codigo_alocado=None, percentuais=None):
+    """
+    Avalia um imóvel com base no modelo ajustado, incluindo verificação de
+    extrapolação e cálculo da fronteira amostral conforme NBR 14.653-2.
+
+    Args:
+        modelo_sm: Objeto OLSResults do statsmodels.
+        valores_x: dict {coluna: valor} com os valores de entrada.
+        colunas_x: list de nomes das variáveis X (na ordem do modelo).
+        transformacoes_x: dict {coluna: transformacao} para cada X.
+        transformacao_y: str com a transformação aplicada em Y.
+        estatisticas_df: DataFrame com colunas Variável, Mínimo, Máximo (entre outras).
+        dicotomicas: list de nomes de colunas dicotômicas (0/1).
+        codigo_alocado: list de nomes de colunas de código alocado/ajustado.
+        percentuais: list de nomes de colunas percentuais (0 a 1).
+
+    Returns:
+        dict com resultado da avaliação ou None em caso de erro.
+    """
+    try:
+        # --------------------------------------------------------
+        # 1. MONTAR X_aval
+        # --------------------------------------------------------
+        X_aval = pd.DataFrame([[valores_x[col] for col in colunas_x]], columns=colunas_x)
+        X_fronteira = X_aval.copy()
+
+        # --------------------------------------------------------
+        # 2. VERIFICAR EXTRAPOLAÇÃO
+        # --------------------------------------------------------
+        # Obter limites das estatísticas
+        if "Variável" in estatisticas_df.columns:
+            limites = estatisticas_df.set_index("Variável")[["Mínimo", "Máximo"]].copy()
+        else:
+            limites = estatisticas_df[["Mínimo", "Máximo"]].copy()
+
+        for col in limites.columns:
+            limites[col] = pd.to_numeric(limites[col], errors="coerce")
+
+        extrapolacoes = {}
+        houve_extrapolacao = False
+        qtd_extrapolacoes = 0
+        qtd_extrapolacoes_acima_limites = 0
+        qtd_extrapolacoes_dentro_limites = 0
+
+        for col in colunas_x:
+            val = float(X_aval[col].values[0])
+            X_fronteira[col] = val
+            extrapolacoes[col] = {"status": "ok", "percentual": 0.0, "direcao": "ok"}
+
+            if col not in limites.index:
+                continue
+
+            min_val = float(limites.loc[col, "Mínimo"])
+            max_val = float(limites.loc[col, "Máximo"])
+
+            # Dicotômica, código alocado ou percentual — validação já feita no callback
+            if col in (dicotomicas or []):
+                extrapolacoes[col] = {"status": "dicotomica", "percentual": 0.0, "direcao": "ok"}
+                continue
+            if col in (codigo_alocado or []):
+                extrapolacoes[col] = {"status": "codigo_alocado", "percentual": 0.0, "direcao": "ok"}
+                continue
+            if col in (percentuais or []):
+                extrapolacoes[col] = {"status": "percentual", "percentual": 0.0, "direcao": "ok"}
+                continue
+
+            # Acima do máximo
+            if val > max_val:
+                houve_extrapolacao = True
+                qtd_extrapolacoes += 1
+                X_fronteira[col] = max_val
+                percentual = round(((val / max_val) - 1) * 100, 1) if max_val != 0 else 0.0
+
+                if percentual > 100:
+                    qtd_extrapolacoes_acima_limites += 1
+                    extrapolacoes[col] = {"status": "grave", "percentual": percentual, "direcao": "acima"}
+                else:
+                    qtd_extrapolacoes_dentro_limites += 1
+                    extrapolacoes[col] = {"status": "warning", "percentual": percentual, "direcao": "acima"}
+
+            # Abaixo do mínimo
+            elif val < min_val:
+                houve_extrapolacao = True
+                qtd_extrapolacoes += 1
+                X_fronteira[col] = min_val
+                percentual = round((1 - (val / min_val)) * 100, 1) if min_val != 0 else 0.0
+
+                if percentual > 50:
+                    qtd_extrapolacoes_acima_limites += 1
+                    extrapolacoes[col] = {"status": "grave", "percentual": percentual, "direcao": "abaixo"}
+                else:
+                    qtd_extrapolacoes_dentro_limites += 1
+                    extrapolacoes[col] = {"status": "warning", "percentual": percentual, "direcao": "abaixo"}
+
+        # --------------------------------------------------------
+        # 3. APLICAR TRANSFORMAÇÕES
+        # --------------------------------------------------------
+        X_aval_transf = X_aval.copy()
+        for col in colunas_x:
+            transf = transformacoes_x.get(col, "(x)")
+            X_aval_transf[col] = aplicar_transformacao(X_aval_transf[col], transf)
+
+        # --------------------------------------------------------
+        # 4. ADICIONAR CONSTANTE E PREVER
+        # --------------------------------------------------------
+        X_aval_const = sm.add_constant(X_aval_transf, has_constant="add")
+        X_aval_const = X_aval_const[modelo_sm.model.exog_names]
+
+        pred = modelo_sm.get_prediction(X_aval_const)
+        y_mean = pred.predicted_mean
+        alpha = 0.20  # IC 80% (NBR 14.653-2)
+        ic = pred.conf_int(alpha=alpha)
+
+        # --------------------------------------------------------
+        # 5. INVERTER TRANSFORMAÇÃO Y
+        # --------------------------------------------------------
+        y_pred = inverter_transformacao_y(y_mean, transformacao_y)
+        y_ic_inf = inverter_transformacao_y(ic[:, 0], transformacao_y)
+        y_ic_sup = inverter_transformacao_y(ic[:, 1], transformacao_y)
+
+        estimado = float(y_pred[0])
+        ic_inf = float(y_ic_inf[0])
+        ic_sup = float(y_ic_sup[0])
+
+        # --------------------------------------------------------
+        # 6. CAMPO DE ARBÍTRIO (±15%, NBR 14.653-2)
+        # --------------------------------------------------------
+        ca_inf = estimado * 0.85
+        ca_sup = estimado * 1.15
+
+        # --------------------------------------------------------
+        # 7. AMPLITUDE E PRECISÃO (NBR 14.653-2 tabela 2)
+        # --------------------------------------------------------
+        perc_inf = ((estimado - ic_inf) / estimado) * 100 if estimado != 0 else 0.0
+        perc_sup = ((ic_sup - estimado) / estimado) * 100 if estimado != 0 else 0.0
+        amplitude = perc_inf + perc_sup
+
+        if amplitude > 50:
+            precisao = "Sem enquadramento"
+        elif amplitude > 40:
+            precisao = "Grau I"
+        elif amplitude > 30:
+            precisao = "Grau II"
+        else:
+            precisao = "Grau III"
+
+        # --------------------------------------------------------
+        # 8. FRONTEIRA AMOSTRAL (se houve extrapolação)
+        # --------------------------------------------------------
+        fronteira = None
+        perc_ext = None
+        fundamentacao = "Grau III"
+
+        if houve_extrapolacao:
+            X_front_transf = X_fronteira.copy()
+            for col in colunas_x:
+                transf = transformacoes_x.get(col, "(x)")
+                X_front_transf[col] = aplicar_transformacao(X_front_transf[col], transf)
+
+            X_front_const = sm.add_constant(X_front_transf, has_constant="add")
+            X_front_const = X_front_const[modelo_sm.model.exog_names]
+
+            pred_front = modelo_sm.get_prediction(X_front_const)
+            y_fronteira = inverter_transformacao_y(pred_front.predicted_mean, transformacao_y)
+            fronteira = float(y_fronteira[0])
+
+            perc_ext = float(abs(((fronteira - estimado) / fronteira) * 100)) if fronteira != 0 else 0.0
+
+            # --------------------------------------------------------
+            # 9. FUNDAMENTAÇÃO (NBR 14.653-2 tabela 1)
+            # --------------------------------------------------------
+            if qtd_extrapolacoes == 0:
+                fundamentacao = "Grau III"
+            elif qtd_extrapolacoes_acima_limites > 0:
+                fundamentacao = "Sem enquadramento"
+            elif perc_ext > 20:
+                fundamentacao = "Sem enquadramento"
+            elif qtd_extrapolacoes == 1:
+                fundamentacao = "Grau I" if perc_ext > 15 else "Grau II"
+            else:  # >1 extrapolação, sem grave, impacto ≤20%
+                fundamentacao = "Grau I"
+
+        return {
+            "valores_x": {col: float(valores_x[col]) for col in colunas_x},
+            "extrapolacoes": extrapolacoes,
+            "estimado": estimado,
+            "ca_inf": ca_inf,
+            "ca_sup": ca_sup,
+            "ic_inf": ic_inf,
+            "ic_sup": ic_sup,
+            "perc_inf": round(perc_inf, 2),
+            "perc_sup": round(perc_sup, 2),
+            "amplitude": round(amplitude, 2),
+            "precisao": precisao,
+            "houve_extrapolacao": houve_extrapolacao,
+            "fronteira": fronteira,
+            "perc_ext": round(perc_ext, 2) if perc_ext is not None else None,
+            "qtd_extrapolacoes": qtd_extrapolacoes,
+            "fundamentacao": fundamentacao,
+        }
+
+    except Exception as e:
+        print(f"Erro ao avaliar imóvel: {e}")
+        return None

backend/app/core/elaboracao/formatadores.py

@@ -0,0 +1,764 @@
+# -*- coding: utf-8 -*-
+"""
+formatadores.py - Formatação HTML e helpers de exibição para a aba Elaboração.
+
+Funções puras: recebem dados, retornam strings HTML/texto.
+Sem dependência de Gradio.
+"""
+
+import os
+import numpy as np
+import pandas as pd
+
+
+# ============================================================
+# CONSTANTES
+# ============================================================
+
+TITULO = """
+# ELABORAÇÃO DE MODELOS ESTATÍSTICOS
+### Divisão de Avaliação de Imóveis
+---
+"""
+
+
+# ============================================================
+# FUNÇÕES DE FORMATAÇÃO
+# ============================================================
+
+def arredondar_df(df, decimais=4):
+    """Arredonda apenas colunas numéricas de um DataFrame e adiciona coluna Índice."""
+    if df is None:
+        return None
+    df_copy = df.copy()
+    # Adiciona índice como primeira coluna (se não existir)
+    if "Índice" not in df_copy.columns:
+        df_copy.insert(0, "Índice", df_copy.index)
+    colunas_numericas = df_copy.select_dtypes(include=[np.number]).columns
+    # Não arredonda a coluna Índice
+    colunas_numericas = [c for c in colunas_numericas if c != "Índice"]
+    df_copy[colunas_numericas] = df_copy[colunas_numericas].round(decimais)
+    return df_copy
+
+
+def carregar_css():
+    """Carrega CSS externo."""
+    css_path = os.path.join(os.path.dirname(__file__), "styles.css")
+    try:
+        with open(css_path, "r", encoding="utf-8") as f:
+            return f.read()
+    except FileNotFoundError:
+        return ""
+
+
+def criar_header_secao(numero: int, titulo: str, timestamp: str = "") -> str:
+    """Cria um header HTML estilizado para seções, opcionalmente com timestamp."""
+    timestamp_html = f' <span class="section-timestamp">(Atualizado às {timestamp})</span>' if timestamp else ""
+    return f'''
+    <div class="section-header">
+        <span class="section-number">{numero}</span>
+        <h2 class="section-title">{titulo}{timestamp_html}</h2>
+    </div>
+    '''
+
+
+def formatar_lista_variaveis_html(info_variaveis):
+    """Gera o bloco HTML da lista de variáveis (dependente + independentes).
+
+    info_variaveis: lista de strings no formato ["Y_NOME: transf", "X1: transf", ...]
+    Retorna HTML pronto para ser inserido como lado direito do badge do elaborador.
+    """
+    if not info_variaveis:
+        return ""
+
+    y_str = info_variaveis[0]
+    y_parts = y_str.split(": ", 1)
+    y_nome = y_parts[0].strip()
+    y_transf = y_parts[1].strip() if len(y_parts) > 1 else ""
+    y_transf_display = "" if y_transf in ("(y)", "(x)", "y", "x", "") else y_transf
+    y_badge = (
+        "<span style='background:#cce5ff;color:#004085;border-radius:4px;"
+        f"padding:3px 10px;font-size:1em;font-weight:600;'>{y_nome}"
+        + (f" <span style='font-weight:400;font-size:1em;'>{y_transf_display}</span>"
+           if y_transf_display else "")
+        + "</span>"
+    )
+
+    x_badges = []
+    for item in info_variaveis[1:]:
+        parts = item.split(": ", 1)
+        nome = parts[0].strip()
+        transf = parts[1].strip() if len(parts) > 1 else ""
+        transf_display = "" if transf in ("(x)", "(y)", "x", "y", "") else transf
+        badge = (
+            "<span style='background:#ced4da;color:#343a40;border-radius:4px;"
+            f"padding:3px 8px;font-size:1em;display:inline-block;margin:2px 3px 2px 0;'>{nome}"
+            + (f" <span style='color:#6c757d;font-size:1em;'>{transf_display}</span>"
+               if transf_display else "")
+            + "</span>"
+        )
+        x_badges.append(badge)
+
+    return (
+        "<div style='font-size:0.9em;line-height:2;'>"
+        "<div><span style='font-weight:600;color:#495057;margin-right:8px;font-size:1.1em;'>Variável Dependente:</span>"
+        + y_badge + "</div>"
+        "<div style='margin-top:4px;'>"
+        "<span style='font-weight:600;color:#495057;margin-right:8px;font-size:1.1em;'>Variáveis Independentes:</span>"
+        + "".join(x_badges) + "</div>"
+        "</div>"
+    )
+
+
+def formatar_diagnosticos_html(diagnosticos):
+    """Formata diagnósticos como HTML no estilo field-row do MODELOS_DAI."""
+    if not diagnosticos:
+        return "<p>Nenhum modelo ajustado.</p>"
+
+    html = '<div class="dai-card">'
+
+    # Estatísticas Gerais
+    html += '<div class="section-title-orange">Estatísticas Gerais</div>'
+    html += f'''<div class="field-row"><span class="field-row-label">Número de observações</span><span class="field-row-value">{diagnosticos["n"]}</span></div>'''
+    html += f'''<div class="field-row"><span class="field-row-label">Número de variáveis independentes</span><span class="field-row-value">{diagnosticos["k"]}</span></div>'''
+    html += f'''<div class="field-row"><span class="field-row-label">Desvio padrão dos resíduos</span><span class="field-row-value">{diagnosticos["desvio_padrao_residuos"]:.4f}</span></div>'''
+    html += f'''<div class="field-row"><span class="field-row-label">MSE</span><span class="field-row-value">{diagnosticos["mse"]:.4f}</span></div>'''
+    html += f'''<div class="field-row"><span class="field-row-label">R²</span><span class="field-row-value">{diagnosticos["r2"]:.4f}</span></div>'''
+    html += f'''<div class="field-row"><span class="field-row-label">R² ajustado</span><span class="field-row-value">{diagnosticos["r2_ajustado"]:.4f}</span></div>'''
+    html += f'''<div class="field-row"><span class="field-row-label">Correlação Pearson</span><span class="field-row-value">{diagnosticos["r_pearson"]:.4f}</span></div>'''
+
+    # Teste F
+    html += '<div class="section-title-orange">Teste F</div>'
+    html += f'''<div class="field-row"><span class="field-row-label">Estatística F</span><span class="field-row-value">{diagnosticos["Fc"]:.4f}</span></div>'''
+    html += f'''<div class="field-row"><span class="field-row-label">P-valor</span><span class="field-row-value">{diagnosticos["p_valor_F"]:.4f}</span></div>'''
+    html += f'''<div class="field-row"><span class="field-row-label">Interpretação</span><span class="field-row-value">{diagnosticos["interp_F"]}</span></div>'''
+
+    # Teste de Normalidade (KS)
+    html += '<div class="section-title-orange">Teste de Normalidade (Kolmogorov-Smirnov)</div>'
+    html += f'''<div class="field-row"><span class="field-row-label">Estatística KS</span><span class="field-row-value">{diagnosticos["ks_stat"]:.4f}</span></div>'''
+    html += f'''<div class="field-row"><span class="field-row-label">P-valor</span><span class="field-row-value">{diagnosticos["ks_p"]:.4f}</span></div>'''
+    html += f'''<div class="field-row"><span class="field-row-label">Interpretação</span><span class="field-row-value">{diagnosticos["interp_KS"]}</span></div>'''
+
+    # Teste de Normalidade (Curva Normal)
+    html += '<div class="section-title-orange">Teste de Normalidade (Comparação com a Curva Normal)</div>'
+    html += f'''<div class="field-row"><span class="field-row-label">Percentuais Atingidos</span><span class="field-row-value">{diagnosticos["perc_resid"]}</span></div>'''
+    html += '<div class="interpretation-label">Interpretação</div>'
+    html += '<div class="interpretation-item">• Ideal 68% → aceitável entre 64% e 75%</div>'
+    html += '<div class="interpretation-item">• Ideal 90% → aceitável entre 88% e 95%</div>'
+    html += '<div class="interpretation-item">• Ideal 95% → aceitável entre 95% e 100%</div>'
+
+    # Teste de Autocorrelação (Durbin-Watson)
+    html += '<div class="section-title-orange">Teste de Autocorrelação (Durbin-Watson)</div>'
+    html += f'''<div class="field-row"><span class="field-row-label">Estatística DW</span><span class="field-row-value">{diagnosticos["dw"]:.4f}</span></div>'''
+    html += f'''<div class="field-row"><span class="field-row-label">Interpretação</span><span class="field-row-value">{diagnosticos["interp_DW"]}</span></div>'''
+
+    # Teste de Homocedasticidade (Breusch-Pagan)
+    html += '<div class="section-title-orange">Teste de Homocedasticidade (Breusch-Pagan)</div>'
+    html += f'''<div class="field-row"><span class="field-row-label">Estatística LM</span><span class="field-row-value">{diagnosticos["bp_lm"]:.4f}</span></div>'''
+    html += f'''<div class="field-row"><span class="field-row-label">P-valor</span><span class="field-row-value">{diagnosticos["bp_p"]:.4f}</span></div>'''
+    html += f'''<div class="field-row"><span class="field-row-label">Interpretação</span><span class="field-row-value">{diagnosticos["interp_BP"]}</span></div>'''
+
+    # Equação do Modelo
+    html += '<div class="section-title-orange">Equação do Modelo</div>'
+    html += f'<div class="equation-box">{diagnosticos["equacao"]}</div>'
+
+    html += '</div>'
+    return html
+
+
+def formatar_busca_html(resultados_busca):
+    """Formata resultados da busca automática como HTML, incluindo graus de enquadramento."""
+    if not resultados_busca:
+        return "<p>Execute a busca automática para ver resultados.</p>"
+
+    _GRAU_LABEL = {3: "Grau III", 2: "Grau II", 1: "Grau I", 0: "Sem enq."}
+    _GRAU_COR = {3: "#2e7d32", 2: "#1565c0", 1: "#e65100", 0: "#b71c1c"}
+
+    html = '<div class="busca-container">'
+
+    for r in resultados_busca:
+        graus_coef = r.get("graus_coef", {})
+        grau_f = r.get("grau_f", 0)
+        grau_f_label = _GRAU_LABEL.get(grau_f, "Sem enq.")
+        grau_f_cor = _GRAU_COR.get(grau_f, "#b71c1c")
+
+        html += f'''
+        <div class="modelo-card" style="border: 1px solid #ddd; border-radius: 8px; padding: 12px; margin: 8px 0; background: #f9f9f9;">
+            <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;">
+                <span class="modelo-rank" style="font-weight: bold; font-size: 1.1em;">#{r["rank"]}</span>
+                <span class="modelo-r2" style="background: #e3f2fd; padding: 4px 8px; border-radius: 4px;">R² = {r["r2"]:.4f}</span>
+            </div>
+            <div class="modelo-transf" style="font-size: 0.95em;">
+                <b>y:</b> {r["transformacao_y"]}<br>
+        '''
+        for col, transf in r["transformacoes_x"].items():
+            grau = graus_coef.get(col, 0)
+            label = _GRAU_LABEL.get(grau, "Sem enq.")
+            cor = _GRAU_COR.get(grau, "#b71c1c")
+            html += (f'<b>{col}:</b> {transf}'
+                     f' &mdash; <span style="color:{cor}; font-weight:bold; font-size:0.85em;">{label}</span><br>')
+
+        html += f'''
+            </div>
+            <div style="margin-top: 6px; padding-top: 6px; border-top: 1px solid #e0e0e0; font-size: 0.85em;">
+                Teste F: <span style="color:{grau_f_cor}; font-weight:bold;">{grau_f_label}</span>
+            </div>
+        </div>
+        '''
+
+    html += '</div>'
+    return html
+
+
+def _renderizar_secao_micro(titulo, resultados_dict):
+    """Renderiza uma seção de micronumerosidade (dicotômicas ou códigos alocados)."""
+    if not resultados_dict:
+        return ""
+
+    html = f'<div class="section-title-orange">{titulo}</div>'
+    html += '<div class="micro-grid">'
+
+    for coluna, info in resultados_dict.items():
+        status = "✅" if info["valido"] else "⚠️"
+        status_class = "micro-ok" if info["valido"] else "micro-warn"
+        mensagens_lista = info["mensagens"]
+        mensagens_html = "".join(f'<div class="micro-msg">{msg}</div>' for msg in mensagens_lista)
+
+        html += f'''
+        <div class="teste-item micro-card {status_class}">
+            <div class="micro-card-head">
+                <span class="teste-nome micro-title">{coluna}</span>
+                <span class="teste-valor micro-status">{status}</span>
+            </div>
+            <div class="micro-msg-grid">
+                {mensagens_html}
+            </div>
+        </div>
+        '''
+
+    html += '</div>'
+    return html
+
+
+def formatar_micronumerosidade_html(resultado):
+    """Formata resultado do teste de micronumerosidade como HTML."""
+
+    if not resultado:
+        return "<p>Clique em 'Aplicar Seleção' para verificar micronumerosidade.</p>"
+
+    html = '<div class="diagnosticos-container">'
+    html += '<div class="section-title-orange">Teste de Micronumerosidade (NBR 14.653-2)</div>'
+
+    # =========================
+    # Condição Geral
+    # =========================
+    n, k = resultado["n"], resultado["k"]
+    condicao_ok = resultado["condicao_geral_ok"]
+    req = 3 * (k + 1)
+
+    status_geral = (
+        f"✅ n = {n} ≥ 3(k+1) = {req}"
+        if condicao_ok
+        else f"❌ n = {n} < 3(k+1) = {req}"
+    )
+
+    html += f'''
+    <div class="micro-summary-grid">
+        <div class="stat-item micro-summary-card">
+            <span class="stat-label">n (observações)</span>
+            <span class="stat-value micro-summary-value">{n}</span>
+        </div>
+        <div class="stat-item micro-summary-card">
+            <span class="stat-label">k (variáveis)</span>
+            <span class="stat-value micro-summary-value">{k}</span>
+        </div>
+        <div class="stat-item micro-summary-card micro-summary-wide">
+            <span class="stat-label">Condição geral</span>
+            <span class="stat-value micro-summary-status">{status_geral}</span>
+        </div>
+    </div>
+    '''
+
+    # =========================
+    # Seções separadas: Dicotômicas e Códigos Alocados
+    # =========================
+    dic_html = _renderizar_secao_micro("Variáveis Dicotômicas", resultado.get("dicotomicas", {}))
+    cod_html = _renderizar_secao_micro("Códigos Ajustados/Alocados", resultado.get("codigo_alocado", {}))
+
+    if dic_html or cod_html:
+        html += dic_html + cod_html
+    else:
+        html += '''
+        <p style="color: #6c757d; font-style: italic; margin-top: 8px;">
+            Nenhuma variável dicotômica ou de código alocado selecionada.
+        </p>
+        '''
+
+    html += '</div>'
+    return html
+
+def formatar_outliers_anteriores_html(n_outliers, lista_indices):
+    """Formata informações de outliers excluídos como HTML card."""
+    lista_str = lista_indices if lista_indices else "Nenhum"
+    return f'''
+    <div style="display: flex; gap: 16px; align-items: baseline;
+                padding: 10px 16px; background: var(--background-fill-secondary, #f8f9fa);
+                border-radius: 8px; border: 1px solid var(--border-color-primary, #e2e8f0);
+                flex-wrap: wrap;">
+        <span style="font-weight: 600; color: var(--body-text-color, #495057); white-space: nowrap;">
+            {n_outliers} outlier(s) excluídos do modelo ajustado
+        </span>
+        <span style="color: var(--body-text-color-subdued, #6c757d); font-size: 0.92em;">
+            Índices: {lista_str}
+        </span>
+    </div>'''
+
+
+# ============================================================
+# AVALIAÇÃO DE IMÓVEL
+# ============================================================
+
+_CORES_GRAU = {
+    "Grau III": "#28a745",
+    "Grau II": "#17a2b8",
+    "Grau I": "#e67e00",
+    "Sem enquadramento": "#dc3545",
+}
+
+
+def _formatar_brl(valor):
+    """Formata n��mero no padrão brasileiro: R$ 350.000,00."""
+    if valor is None or (isinstance(valor, float) and np.isnan(valor)):
+        return "—"
+    s = f"{valor:,.2f}"
+    s = s.replace(",", "X").replace(".", ",").replace("X", ".")
+    return f"R$ {s}"
+
+
+def _popup_grau(conteudo_html):
+    """Gera ícone ⓘ com popup estilizado no hover.
+
+    Args:
+        conteudo_html: HTML interno do popup.
+
+    Returns:
+        str HTML do ícone + popup.
+    """
+    return (
+        '<span style="position: relative; display: inline-block; cursor: help;" '
+        'class="mesa-popup-wrap">'
+        '<span style="font-size: 0.85em; opacity: 0.7;">ⓘ</span>'
+        '<span class="mesa-popup-content" style="'
+        'display: none; position: absolute; bottom: calc(100% + 8px); right: 0;'
+        ' z-index: 1000; width: 520px;'
+        ' background: #fff; border: 1px solid #dee2e6; border-radius: 8px;'
+        ' box-shadow: 0 4px 16px rgba(0,0,0,0.15); padding: 10px 14px;'
+        ' font-size: 12px; font-weight: 400; color: #333; text-align: left;'
+        ' line-height: 1.4; white-space: normal;">'
+        f'{conteudo_html}'
+        '</span>'
+        '</span>'
+    )
+
+
+def _popup_precisao_html(aval):
+    """Gera conteúdo HTML do popup para o grau de Precisão."""
+    amplitude = aval["amplitude"]
+    grau = aval["precisao"]
+
+    regras = [
+        ("≤30%", "Grau III", "#28a745"),
+        ("≤40%", "Grau II", "#17a2b8"),
+        ("≤50%", "Grau I", "#e67e00"),
+        (">50%", "Sem enquadramento", "#dc3545"),
+    ]
+
+    html = (
+        '<div style="font-weight: 600; margin-bottom: 4px; color: #495057;">'
+        'Precisão — NBR 14.653-2, Tabela 2'
+        '<span style="font-weight: 400; font-size: 11px; color: #6c757d; margin-left: 8px;">'
+        'Amplitude do IC 80% em relação ao estimado.</span></div>'
+        '<div style="display: flex; align-items: baseline; gap: 12px; margin-bottom: 6px;">'
+        f'<span>Amplitude do IC 80%: <b>{amplitude:.1f}%</b></span>'
+        '</div>'
+        '<table style="width: 100%; border-collapse: collapse; font-size: 11px;">'
+        '<tr style="border-bottom: 1px solid #e9ecef;">'
+        '<th style="text-align: left; padding: 2px 6px; color: #6c757d;">Amplitude</th>'
+        '<th style="text-align: left; padding: 2px 6px; color: #6c757d;">Grau</th>'
+        '</tr>'
+    )
+    for faixa, nome, cor in regras:
+        ativo = (nome == grau)
+        bg = f'background: {cor}11;' if ativo else ''
+        fw = 'font-weight: 600;' if ativo else ''
+        marca = ' ◀' if ativo else ''
+        html += (
+            f'<tr style="border-bottom: 1px solid #f0f0f0; {bg}">'
+            f'<td style="padding: 2px 6px; {fw}">{faixa}</td>'
+            f'<td style="padding: 2px 6px; color: {cor}; {fw}">{nome}{marca}</td>'
+            '</tr>'
+        )
+    html += '</table>'
+    return html
+
+
+def _popup_fundamentacao_html(aval):
+    """Gera conteúdo HTML do popup para o grau de Fundamentação."""
+    grau = aval["fundamentacao"]
+    cor_grau = _CORES_GRAU.get(grau, "#495057")
+
+    _header = (
+        '<div style="font-weight: 600; margin-bottom: 4px; color: #495057;">'
+        'Fundamentação — NBR 14.653-2, Tabela 1</div>'
+        '<div style="font-size: 11px; color: #6c757d; margin-bottom: 6px; line-height: 1.45;">'
+        'Depende de quantas variáveis extrapolam os limites amostrais e do '
+        '<b style="color:#333;">impacto no valor estimado</b>. '
+        'O impacto é calculado aplicando o modelo duas vezes: uma com os valores informados '
+        '(incluindo os extrapolados) e outra simulando as variáveis extrapoladas no seu limite '
+        'amostral mais próximo (mínimo ou máximo, conforme o caso). A diferença percentual entre '
+        'os dois valores unitários resultantes é o impacto no estimado. '
+        'É esse impacto — e não a % de extrapolação individual de cada variável — que define o grau, '
+        'exceto no caso de extrapolação grave'
+        ' (variável >100% acima do máximo amostral, >50% abaixo do mínimo amostral, ou valor '
+        'inválido em dicotômica), que resulta automaticamente em Sem enquadramento.'
+        '</div>'
+    )
+
+    if not aval["houve_extrapolacao"]:
+        return (
+            f'{_header}'
+            '<div>Nenhuma variável extrapolou os limites amostrais. '
+            f'<span style="color: #28a745; font-weight: 600;">→ {grau}</span></div>'
+        )
+
+    n = aval["qtd_extrapolacoes"]
+    perc = aval.get("perc_ext", 0) or 0
+    tem_grave = any(
+        info["status"] == "grave"
+        for info in aval["extrapolacoes"].values()
+    )
+
+    # Motivo conciso
+    if tem_grave:
+        motivo = "Extrapolação grave (>100% do máx., >50% abaixo do mín., ou dicotômica inválida)."
+    elif perc > 20:
+        motivo = f"Impacto de {perc:.1f}% no estimado, acima do limite de 20%."
+    elif n >= 2:
+        motivo = f"{n} variáveis extrapoladas, impacto de {perc:.1f}% no estimado."
+    elif n == 1 and perc > 15:
+        motivo = f"1 variável extrapolada, impacto de {perc:.1f}% no estimado (>15%)."
+    else:
+        motivo = f"1 variável extrapolada, impacto de {perc:.1f}% no estimado (≤15%)."
+
+    # Variáveis extrapoladas inline
+    vars_items = []
+    for col, info in aval["extrapolacoes"].items():
+        st = info.get("status", "ok")
+        if st in ("warning", "grave"):
+            p = info.get("percentual", 0)
+            direcao = info.get("direcao", "")
+            icone = '⚠️' if st == "warning" else '❌'
+            if direcao == "acima":
+                desc = f'{p:.1f}% acima do máx.'
+            elif direcao == "abaixo":
+                desc = f'{p:.1f}% abaixo do mín.'
+            elif info.get("valor_invalido"):
+                desc = 'valor inválido (dicot.)'
+            else:
+                desc = f'{p:.1f}% fora'
+            vars_items.append(f'{icone} <b>{col}</b>: {desc}')
+
+    # Regras
+    regras = [
+        ("Nenhuma extrapolação", "Grau III"),
+        ("1 variável extrapolada, impacto ≤15% no estimado", "Grau II"),
+        ("1 variável extrapolada c/ impacto >15% e ≤20%, ou >1 variável extrapolada c/ impacto ≤20%", "Grau I"),
+        ("Impacto >20% no estimado, ou extrapolação grave", "Sem enq."),
+    ]
+
+    html = _header
+
+    # Resumo + variáveis numa linha compacta
+    resumo = f'{n} variável(is) extrapolada(s)'
+    if perc is not None and perc > 0:
+        resumo += f', impacto de <b>{perc:.1f}%</b> no estimado'
+    html += f'<div style="margin-bottom: 3px;">{resumo}.</div>'
+
+    if vars_items:
+        vars_str = ' &nbsp;│&nbsp; '.join(vars_items)
+        html += (
+            f'<div style="background: #f8f9fa; border-radius: 4px; padding: 4px 8px;'
+            f' margin-bottom: 4px; font-size: 11px;">{vars_str}</div>'
+        )
+
+    html += (
+        f'<div style="margin-bottom: 4px; font-size: 11px; color: #495057;">'
+        f'{motivo} <span style="color: {cor_grau}; font-weight: 600;">→ {grau}</span></div>'
+    )
+
+    # Tabela compacta
+    html += (
+        '<table style="width: 100%; border-collapse: collapse; font-size: 11px;">'
+        '<tr style="border-bottom: 1px solid #e9ecef;">'
+        '<th style="text-align: left; padding: 2px 6px; color: #6c757d;">Condição</th>'
+        '<th style="text-align: left; padding: 2px 6px; color: #6c757d;">Grau</th>'
+        '</tr>'
+    )
+    for cond, nome in regras:
+        ativo = (nome == grau) or (nome == "Sem enq." and grau == "Sem enquadramento")
+        bg = f'background: {cor_grau}11;' if ativo else ''
+        fw = 'font-weight: 600;' if ativo else ''
+        marca = ' ◀' if ativo else ''
+        html += (
+            f'<tr style="border-bottom: 1px solid #f0f0f0; {bg}">'
+            f'<td style="padding: 2px 6px; {fw}">{cond}</td>'
+            f'<td style="padding: 2px 6px; {fw}">{nome}{marca}</td>'
+            '</tr>'
+        )
+    html += '</table>'
+    return html
+
+
+def formatar_avaliacao_html(avaliacoes_lista, indice_base=0, elem_id_excluir="excluir-aval-elab"):
+    """Formata resultados de avaliação como tabela HTML acumulada.
+
+    Mostra tabela desde a 1ª avaliação. Cada coluna = 1 avaliação.
+    Extrapolação com % ao lado do ícone. Tooltips nos graus.
+    Linha "Estimado / Base" compara cada avaliação com a base.
+    Linha "Excluir" com ícone de lixeira por coluna.
+
+    Args:
+        avaliacoes_lista: lista de dicts retornados por core.avaliar_imovel().
+        indice_base: índice (0-based) da avaliação base para comparação.
+        elem_id_excluir: elem_id do Textbox hidden que recebe o índice a excluir.
+
+    Returns:
+        str HTML.
+    """
+    if not avaliacoes_lista:
+        return ""
+
+    n = len(avaliacoes_lista)
+
+    # Corrigir índice base se fora de range
+    if indice_base < 0 or indice_base >= n:
+        indice_base = 0
+
+    # Estilos reutilizáveis
+    _td = 'style="padding: 6px 12px; border-bottom: 1px solid #f0f0f0;"'
+    _td_r = 'style="text-align: right; padding: 6px 12px; border-bottom: 1px solid #f0f0f0;"'
+    _td_bold = 'style="padding: 8px 12px; border-bottom: 1px solid #dee2e6; font-weight: 600;"'
+    _td_bold_r = 'style="text-align: right; padding: 8px 12px; border-bottom: 1px solid #dee2e6; font-weight: 600;"'
+
+    html = (
+        '<style>'
+        '.mesa-popup-wrap:hover .mesa-popup-content { display: block !important; }'
+        '</style>'
+        '<div style="overflow-x: auto;">'
+    )
+    html += '<table style="width: 100%; border-collapse: collapse; font-size: 13px;">'
+
+    # Header
+    html += '<tr style="background: #f8f9fa;">'
+    html += '<th style="text-align: left; padding: 8px 12px; border-bottom: 2px solid #dee2e6; font-weight: 600; color: #495057;"></th>'
+    for i in range(n):
+        html += f'<th style="text-align: right; padding: 8px 12px; border-bottom: 2px solid #dee2e6; font-weight: 600; color: #495057;">Aval. {i+1}</th>'
+    html += '</tr>'
+
+    # Variáveis X
+    colunas_x = list(avaliacoes_lista[0]["valores_x"].keys())
+    for col in colunas_x:
+        html += '<tr>'
+        html += f'<td {_td} style="padding: 6px 12px; border-bottom: 1px solid #f0f0f0; font-weight: 500; color: #495057;">{col}</td>'
+        for aval in avaliacoes_lista:
+            val = aval["valores_x"].get(col, 0)
+            ext = aval["extrapolacoes"].get(col, {})
+            status = ext.get("status", "ok")
+            perc = ext.get("percentual", 0)
+            val_fmt = f"{val:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+
+            if status == "ok":
+                celula = f'{val_fmt} ✅'
+            elif status in ("dicotomica", "codigo_alocado", "percentual"):
+                celula = f'{val_fmt} \u2014'
+            elif status == "warning":
+                celula = f'{val_fmt} \u26a0\ufe0f {perc:.1f}%'
+            elif ext.get("valor_invalido"):
+                celula = f'{val_fmt} \u274c'
+            else:  # grave
+                celula = f'{val_fmt} \u274c {perc:.1f}%'
+
+            html += f'<td {_td_r}>{celula}</td>'
+        html += '</tr>'
+
+    # Estimado
+    html += '<tr style="background: #f8f9fa; font-weight: 600;">'
+    html += f'<td {_td_bold}>Estimado</td>'
+    for aval in avaliacoes_lista:
+        html += f'<td {_td_bold_r} style="text-align: right; padding: 8px 12px; border-bottom: 1px solid #dee2e6; font-weight: 600;">{_formatar_brl(aval["estimado"])}</td>'
+    html += '</tr>'
+
+    # Estimado / Base (só se houver mais de 1 avaliação)
+    if n > 1:
+        estimado_base = avaliacoes_lista[indice_base]["estimado"]
+        html += '<tr style="background: #fff8f0; font-size: 12px;">'
+        html += f'<td style="padding: 4px 12px; border-bottom: 1px solid #f0f0f0; font-weight: 500; color: #6c757d; font-style: italic;">Estimado / Base (Aval. {indice_base + 1})</td>'
+        for i, aval in enumerate(avaliacoes_lista):
+            if i == indice_base:
+                celula = '<span style="color: #FF8C00; font-weight: 600;">Base</span>'
+            else:
+                if estimado_base != 0:
+                    diff_perc = ((aval["estimado"] / estimado_base) - 1) * 100
+                    sinal = "+" if diff_perc >= 0 else "\u2212"
+                    cor = "#28a745" if diff_perc >= 0 else "#dc3545"
+                    celula = f'<span style="color: {cor}; font-weight: 600;">{sinal}{abs(diff_perc):.1f}%</span>'
+                else:
+                    celula = '\u2014'
+            html += f'<td style="text-align: right; padding: 4px 12px; border-bottom: 1px solid #f0f0f0;">{celula}</td>'
+        html += '</tr>'
+
+    # CA
+    html += f'<tr><td {_td}>CA \u221215%</td>'
+    for aval in avaliacoes_lista:
+        html += f'<td {_td_r}>{_formatar_brl(aval["ca_inf"])}</td>'
+    html += '</tr>'
+    html += f'<tr><td {_td}>CA +15%</td>'
+    for aval in avaliacoes_lista:
+        html += f'<td {_td_r}>{_formatar_brl(aval["ca_sup"])}</td>'
+    html += '</tr>'
+
+    # IC
+    html += f'<tr><td {_td}>IC 80% Inf.</td>'
+    for aval in avaliacoes_lista:
+        html += f'<td {_td_r}>{_formatar_brl(aval["ic_inf"])} (\u2212{aval["perc_inf"]:.1f}%)</td>'
+    html += '</tr>'
+    html += f'<tr><td {_td}>IC 80% Sup.</td>'
+    for aval in avaliacoes_lista:
+        html += f'<td {_td_r}>{_formatar_brl(aval["ic_sup"])} (+{aval["perc_sup"]:.1f}%)</td>'
+    html += '</tr>'
+
+    # Amplitude
+    html += f'<tr><td {_td}>Amplitude</td>'
+    for aval in avaliacoes_lista:
+        html += f'<td {_td_r}>{aval["amplitude"]:.1f}%</td>'
+    html += '</tr>'
+
+    # Precisão (negrito, cor, popup)
+    html += '<tr style="background: #f8f9fa;">'
+    html += f'<td {_td_bold}>Precisão</td>'
+    for aval in avaliacoes_lista:
+        cor = _CORES_GRAU.get(aval["precisao"], "#495057")
+        popup = _popup_grau(_popup_precisao_html(aval))
+        html += (
+            f'<td {_td_bold_r} style="text-align: right; padding: 8px 12px; '
+            f'border-bottom: 1px solid #dee2e6; color: {cor}; font-weight: 600;">'
+            f'{aval["precisao"]} {popup}'
+            f'</td>'
+        )
+    html += '</tr>'
+
+    # Fundamentação (negrito, cor, popup)
+    html += '<tr style="background: #f8f9fa;">'
+    html += f'<td {_td_bold}>Fundamentação</td>'
+    for aval in avaliacoes_lista:
+        cor = _CORES_GRAU.get(aval["fundamentacao"], "#495057")
+        popup = _popup_grau(_popup_fundamentacao_html(aval))
+        html += (
+            f'<td {_td_bold_r} style="text-align: right; padding: 8px 12px; '
+            f'border-bottom: 1px solid #dee2e6; color: {cor}; font-weight: 600;">'
+            f'{aval["fundamentacao"]} {popup}'
+            f'</td>'
+        )
+    html += '</tr>'
+
+    # Excluir (linha com lixeiras → botão vermelho temporário)
+    # JS inline em cada onclick (scripts via innerHTML não são executados)
+    _js_trigger = (
+        "var el=document.querySelector('#{eid} textarea')"
+        "||document.querySelector('#{eid} input');"
+        "if(el){{el.value=String({idx});"
+        "el.dispatchEvent(new Event('input',{{bubbles:true}}));"
+        "el.dispatchEvent(new Event('change',{{bubbles:true}}));}}"
+    )
+    html += '<tr style="background: #fff5f5;">'
+    html += f'<td style="padding: 6px 12px; border-bottom: 1px solid #f0f0f0; font-weight: 500; color: #dc3545; font-size: 12px;">Excluir</td>'
+    for i in range(n):
+        idx_1 = i + 1
+        uid = f'{elem_id_excluir}-{idx_1}'
+        # Clicar lixeira → mostra botão vermelho por 10s
+        onclick_trash = (
+            f"document.getElementById('{uid}-trash').style.display='none';"
+            f"document.getElementById('{uid}-btn').style.display='inline-block';"
+            f"clearTimeout(window['_t_{uid}']);"
+            f"window['_t_{uid}']=setTimeout(function(){{"
+            f"document.getElementById('{uid}-btn').style.display='none';"
+            f"document.getElementById('{uid}-trash').style.display='inline';"
+            f"}},10000);"
+        )
+        # Clicar botão vermelho → dispara exclusão inline
+        onclick_btn = (
+            f"clearTimeout(window['_t_{uid}']);"
+            + _js_trigger.format(eid=elem_id_excluir, idx=idx_1)
+        )
+        html += (
+            f'<td style="text-align: right; padding: 6px 12px; border-bottom: 1px solid #f0f0f0;">'
+            f'<span id="{uid}-trash" onclick="{onclick_trash}" '
+            f'style="cursor: pointer; color: #dc3545; font-size: 18px;" '
+            f'title="Excluir Avaliação {idx_1}">'
+            f'\U0001f5d1\ufe0f</span>'
+            f'<span id="{uid}-btn" onclick="{onclick_btn}" '
+            f'style="display:none; cursor:pointer; background:#dc3545; color:white; '
+            f'padding:2px 10px; border-radius:4px; font-size:12px; font-weight:600;">'
+            f'Excluir</span>'
+            f'</td>'
+        )
+    html += '</tr>'
+
+    html += '</table></div>'
+
+    return html
+
+
+def formatar_aviso_multicolinearidade(resultado):
+    """Formata HTML de aviso de multicolinearidade para exibição na seção 4.
+
+    Args:
+        resultado: dict retornado por core.verificar_multicolinearidade, ou None
+
+    Returns:
+        tuple (html: str, visible: bool)
+    """
+    if not resultado or (not resultado.get('perfeita') and not resultado.get('alta')):
+        return "", False
+
+    if resultado.get('perfeita'):
+        posto = resultado.get('posto', '?')
+        ncolunas = resultado.get('ncolunas', '?')
+        html = (
+            '<div style="margin-top:12px; padding:12px 16px; background:#fdecea; '
+            'border-left:4px solid #c0392b; border-radius:6px; color:#7b1a1a;">'
+            '<strong>⛔ Multicolinearidade Perfeita Detectada</strong><br>'
+            f'<span style="font-size:0.93em;">A matriz de regressoras tem dependência linear exata entre variáveis '
+            f'(posto {posto} &lt; {ncolunas} colunas). '
+            'O modelo OLS <strong>não poderá ser estimado</strong> com as variáveis selecionadas. '
+            'Verifique se há dummies em excesso, variáveis redundantes ou combinações lineares exatas.</span>'
+            '</div>'
+        )
+        return html, True
+
+    # Alta (VIF > 10)
+    vif = resultado.get('vif', {})
+    vars_alta = resultado.get('vars_alta', [])
+    itens = ", ".join(
+        f"<strong>{c}</strong> (VIF={vif[c]:.1f})" for c in vars_alta if c in vif
+    )
+    html = (
+        '<div style="margin-top:12px; padding:12px 16px; background:#fff8e1; '
+        'border-left:4px solid #f39c12; border-radius:6px; color:#7d5a00;">'
+        '<strong>⚠️ Multicolinearidade Alta Detectada</strong><br>'
+        f'<span style="font-size:0.93em;">Variáveis com VIF &gt; 10: {itens}. '
+        'A alta colinearidade pode causar instabilidade nos coeficientes estimados. '
+        'Considere remover variáveis redundantes antes da estimação.</span>'
+        '</div>'
+    )
+    return html, True

backend/app/core/elaboracao/geocodificacao.py

@@ -0,0 +1,458 @@
+# -*- coding: utf-8 -*-
+"""
+geocodificacao.py - Verificação, padronização e geocodificação de coordenadas geográficas.
+
+Integrado na Seção 1 do MESA: verifica se lat/lon existem no DataFrame carregado
+e, caso contrário, oferece geocodificação por interpolação em eixos de logradouros
+(shapefile EixosLogradouros - Porto Alegre/RS - SIRGAS 2000 → EPSG:4326).
+"""
+
+import os
+import pandas as pd
+
+from .core import NOMES_LAT, NOMES_LON
+
+# ============================================================
+# CAMINHO DO SHAPEFILE
+# ============================================================
+
+_BASE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # raiz MESA/
+_SHAPEFILE = os.path.join(_BASE, "dados", "EixosLogradouros.shp")
+
+# Cache em módulo — carregado uma vez por sessão
+_gdf_eixos = None
+
+
+def carregar_eixos():
+    """Carrega e cacheia o GeoDataFrame dos eixos de logradouros.
+
+    Retorna None e registra aviso se geopandas/fiona não estiverem disponíveis
+    ou se o shapefile não for encontrado.
+    """
+    global _gdf_eixos
+    if _gdf_eixos is not None:
+        return _gdf_eixos
+
+    try:
+        import geopandas as gpd
+    except ImportError:
+        print("[geocodificacao] AVISO: geopandas não instalado — geocodificação indisponível.")
+        return None
+
+    if not os.path.exists(_SHAPEFILE):
+        print(f"[geocodificacao] AVISO: shapefile não encontrado em {_SHAPEFILE}")
+        return None
+
+    gdf = gpd.read_file(_SHAPEFILE, engine="fiona")
+    gdf = gdf.to_crs("EPSG:4326")
+    _gdf_eixos = gdf
+    return _gdf_eixos
+
+
+# ============================================================
+# VERIFICAÇÃO E PADRONIZAÇÃO DE COORDENADAS
+# ============================================================
+
+def verificar_coords(df):
+    """Verifica se o DataFrame possui colunas de lat e lon com ao menos 1 valor não-nulo.
+
+    Reutiliza NOMES_LAT / NOMES_LON de core.py (busca case-insensitive).
+
+    Retorna:
+        (True, col_lat, col_lon)  — se encontradas e válidas
+        (False, None, None)       — caso contrário
+    """
+    colunas_lower = {str(col).lower(): col for col in df.columns}
+
+    col_lat = None
+    for nome in NOMES_LAT:
+        if nome in colunas_lower:
+            col_lat = colunas_lower[nome]
+            break
+
+    col_lon = None
+    for nome in NOMES_LON:
+        if nome in colunas_lower:
+            col_lon = colunas_lower[nome]
+            break
+
+    if col_lat is None or col_lon is None:
+        return False, None, None
+
+    # Verifica se há ao menos 1 valor não-nulo em cada coluna
+    lat_ok = pd.to_numeric(df[col_lat], errors="coerce").notna().any()
+    lon_ok = pd.to_numeric(df[col_lon], errors="coerce").notna().any()
+
+    if lat_ok and lon_ok:
+        return True, col_lat, col_lon
+
+    return False, None, None
+
+
+def padronizar_coords(df, col_lat, col_lon):
+    """Cria (ou mantém) as colunas 'lat' e 'lon' no DataFrame.
+
+    Se col_lat/col_lon já são 'lat'/'lon', não faz nada além de garantir
+    que os valores são numéricos. Caso contrário, copia os valores
+    e remove as colunas originais.
+
+    Retorna:
+        DataFrame com colunas 'lat' e 'lon' padronizadas.
+    """
+    df = df.copy()
+
+    if col_lat != "lat":
+        df["lat"] = pd.to_numeric(df[col_lat], errors="coerce")
+        df = df.drop(columns=[col_lat])
+    else:
+        df["lat"] = pd.to_numeric(df["lat"], errors="coerce")
+
+    if col_lon != "lon":
+        df["lon"] = pd.to_numeric(df[col_lon], errors="coerce")
+        df = df.drop(columns=[col_lon])
+    else:
+        df["lon"] = pd.to_numeric(df["lon"], errors="coerce")
+
+    return df
+
+
+# ============================================================
+# AUTO-DETECÇÃO DE COLUNAS PARA GEOCODIFICAÇÃO
+# ============================================================
+
+def auto_detectar_colunas_geo(df):
+    """Tenta identificar automaticamente as colunas de CDLOG e número predial.
+
+    Retorna:
+        (col_cdlog, col_num) — strings ou None se não detectado
+    """
+    colunas_upper = {str(c).upper(): c for c in df.columns}
+
+    # CDLOG
+    col_cdlog = colunas_upper.get("CDLOG") or colunas_upper.get("CTM")
+
+    # Número predial — em ordem de prioridade
+    col_num = None
+    for nome in ["Nº GEO", "NUM_GEO", "NUM", "NUMERO"]:
+        if nome in colunas_upper:
+            col_num = colunas_upper[nome]
+            break
+
+    return col_cdlog, col_num
+
+
+# ============================================================
+# GEOCODIFICAÇÃO POR INTERPOLAÇÃO EM EIXOS
+# ============================================================
+
+def geocodificar(df, col_cdlog, col_num, auto_200=False):
+    """Geocodifica registros do DataFrame usando interpolação em eixos de logradouros.
+
+    Para cada linha:
+      1. Localiza segmentos do logradouro pelo CDLOG no shapefile
+      2. Determina lado par/ímpar do número predial
+      3. Encontra segmento cujo intervalo contenha o número
+      4. Se encontrado: interpola o ponto na fração ao longo da geometria LineString
+      5. Se não encontrado:
+         - Gera sugestões dos números mais próximos (5 pares + 5 ímpares)
+         - Se diferença ≤ 200 e auto_200=True: corrige automaticamente e interpola
+         - Senão: registra na tabela de falhas
+
+    Args:
+        df:          DataFrame com col_cdlog e col_num (pode ter _idx; criado se ausente)
+        col_cdlog:   Nome da coluna com o código do logradouro (CDLOG/CTM)
+        col_num:     Nome da coluna com o número predial
+        auto_200:    Se True, corrige automaticamente números com diferença ≤ 200
+
+    Retorna:
+        df_resultado:  DataFrame completo com colunas 'lat' e 'lon' (None para falhas)
+        df_falhas:     DataFrame com falhas para correção manual
+        ajustados:     Lista de dicts {idx, numero_original, numero_usado} auto-corrigidos
+    """
+    gdf_eixos = carregar_eixos()
+    if gdf_eixos is None:
+        raise RuntimeError(
+            "Shapefile de eixos não disponível. "
+            "Verifique se geopandas e fiona estão instalados e se o arquivo "
+            f"'{_SHAPEFILE}' existe."
+        )
+
+    df = df.copy()
+
+    # Garante coluna _idx para rastreamento
+    if "_idx" not in df.columns:
+        df["_idx"] = range(len(df))
+
+    df[col_num] = pd.to_numeric(df[col_num], errors="coerce").fillna(0).astype(int)
+
+    lats = []
+    lons = []
+    falhas = []
+    ajustados = []
+
+    for _, row in df.iterrows():
+        idx = row["_idx"]
+        cdlog = row[col_cdlog]
+        numero = int(row[col_num])
+
+        # --- Passo 1: buscar segmentos do CDLOG ---
+        segmentos = gdf_eixos[gdf_eixos["CDLOG"] == cdlog]
+
+        if segmentos.empty:
+            lats.append(None)
+            lons.append(None)
+            falhas.append({
+                "_idx": idx,
+                "cdlog": cdlog,
+                "numero_atual": numero,
+                "motivo": "CDLOG não encontrado",
+                "sugestoes": "",
+                "numero_corrigido": "",
+            })
+            continue
+
+        # --- Passo 2: determinar lado par/ímpar ---
+        lado = "Par" if numero % 2 == 0 else "Ímpar"
+        ini_col, fim_col = (
+            ("NRPARINI", "NRPARFIN") if lado == "Par" else ("NRIMPINI", "NRIMPFIN")
+        )
+
+        segmentos = segmentos.copy()
+        segmentos[ini_col] = pd.to_numeric(segmentos[ini_col], errors="coerce")
+        segmentos[fim_col] = pd.to_numeric(segmentos[fim_col], errors="coerce")
+        segmentos = segmentos.dropna(subset=[ini_col, fim_col])
+
+        # --- Passo 3: encontrar segmento com intervalo válido ---
+        cond = (segmentos[ini_col] <= numero) & (segmentos[fim_col] >= numero)
+        segmentos_validos = segmentos[cond]
+
+        if segmentos_validos.empty:
+            # --- Passo 5: intervalo não encontrado — gera sugestões ---
+            sugestoes_str = ""
+            numero_para_interpolar = None
+
+            if not segmentos.empty:
+                diffs = (segmentos[ini_col] - numero).abs()
+                min_index = diffs.idxmin()
+                linha_proxima = segmentos.loc[min_index]
+
+                ini = linha_proxima[ini_col]
+                fim = linha_proxima[fim_col]
+
+                if pd.notna(ini) and pd.notna(fim):
+                    ini_i, fim_i = int(ini), int(fim)
+                    todos = list(range(ini_i, fim_i + 1))
+                    pares = sorted([n for n in todos if n % 2 == 0], key=lambda x: abs(x - numero))
+                    impares = sorted([n for n in todos if n % 2 != 0], key=lambda x: abs(x - numero))
+                    sugestoes = sorted(pares[:5] + impares[:5], key=lambda x: abs(x - numero))
+                    sugestoes_str = ", ".join(map(str, sugestoes))
+
+                    # Auto-correção ≤ 200
+                    if sugestoes and auto_200:
+                        melhor = sugestoes[0]
+                        diferenca = abs(numero - melhor)
+                        if diferenca <= 200:
+                            numero_para_interpolar = melhor
+                            ajustados.append({
+                                "idx": idx,
+                                "numero_original": numero,
+                                "numero_usado": melhor,
+                            })
+
+            if numero_para_interpolar is not None:
+                # Interpola com o número corrigido automaticamente
+                cond2 = (segmentos[ini_col] <= numero_para_interpolar) & \
+                        (segmentos[fim_col] >= numero_para_interpolar)
+                seg2 = segmentos[cond2]
+                if seg2.empty:
+                    # Usa segmento mais próximo mesmo assim
+                    seg2 = segmentos.loc[[min_index]]
+
+                linha = seg2.iloc[0]
+                geom = linha.geometry
+                ini_v = linha[ini_col]
+                fim_v = linha[fim_col]
+
+                if fim_v == ini_v:
+                    lats.append(None)
+                    lons.append(None)
+                else:
+                    frac = (numero_para_interpolar - ini_v) / (fim_v - ini_v)
+                    frac = max(0.0, min(1.0, frac))
+                    ponto = geom.interpolate(geom.length * frac)
+                    lons.append(ponto.x)
+                    lats.append(ponto.y)
+            else:
+                lats.append(None)
+                lons.append(None)
+                falhas.append({
+                    "_idx": idx,
+                    "cdlog": cdlog,
+                    "numero_atual": numero,
+                    "motivo": "Numeração fora do intervalo",
+                    "sugestoes": sugestoes_str,
+                    "numero_corrigido": "",
+                })
+            continue
+
+        # --- Passo 4: interpolação normal ---
+        linha = segmentos_validos.iloc[0]
+        geom = linha.geometry
+        ini = linha[ini_col]
+        fim = linha[fim_col]
+
+        if fim == ini:
+            lats.append(None)
+            lons.append(None)
+            continue
+
+        frac = (numero - ini) / (fim - ini)
+        frac = max(0.0, min(1.0, frac))
+        ponto = geom.interpolate(geom.length * frac)
+        lons.append(ponto.x)
+        lats.append(ponto.y)
+
+    df["lat"] = lats
+    df["lon"] = lons
+
+    df_falhas = pd.DataFrame(
+        falhas,
+        columns=["_idx", "cdlog", "numero_atual", "motivo", "sugestoes", "numero_corrigido"]
+    ) if falhas else pd.DataFrame(
+        columns=["_idx", "cdlog", "numero_atual", "motivo", "sugestoes", "numero_corrigido"]
+    )
+
+    return df, df_falhas, ajustados
+
+
+def aplicar_correcoes_e_regeodificar(df_original, df_falhas, col_cdlog, col_num, auto_200=False):
+    """Aplica correções manuais da tabela de falhas e re-executa a geocodificação.
+
+    Args:
+        df_original:  DataFrame acumulado da rodada anterior (com coluna _idx e col_num já corrigido)
+        df_falhas:    DataFrame editável com coluna 'numero_corrigido' preenchida pelo usuário
+        col_cdlog:    Nome da coluna CDLOG
+        col_num:      Nome da coluna número predial
+        auto_200:     Repassado para geocodificar()
+
+    Retorna:
+        (df_resultado, df_falhas_novas, ajustados, manuais)
+        manuais: lista de _idx que receberam correção manual nesta rodada
+    """
+    df = df_original.copy()
+
+    # Garante coluna _idx (mesma lógica de geocodificar)
+    if "_idx" not in df.columns:
+        df["_idx"] = range(len(df))
+
+    # Aplica correções e rastreia quais _idx foram corrigidos manualmente
+    manuais = []
+    for _, row in df_falhas.iterrows():
+        corrigido = str(row.get("numero_corrigido", "")).strip()
+        if corrigido and corrigido not in ("", "nan"):
+            try:
+                novo_num = int(float(corrigido))
+                idx = row["_idx"]
+                df.loc[df["_idx"] == idx, col_num] = novo_num
+                manuais.append(idx)
+            except (ValueError, TypeError):
+                pass
+
+    df_resultado, df_falhas_novas, ajustados = geocodificar(df, col_cdlog, col_num, auto_200)
+    return df_resultado, df_falhas_novas, ajustados, manuais
+
+
+# ============================================================
+# FORMATAÇÃO HTML DO STATUS DE GEOCODIFICAÇÃO
+# ============================================================
+
+def formatar_status_geocodificacao(df_resultado, df_falhas, ajustados, manuais=None):
+    """Gera HTML de resumo do resultado da geocodificação.
+
+    Args:
+        df_resultado: DataFrame com colunas lat/lon
+        df_falhas:    DataFrame de falhas restantes
+        ajustados:    Lista de registros auto-corrigidos
+        manuais:      Lista de _idx corrigidos manualmente nesta rodada (opcional)
+
+    Retorna:
+        String HTML com resumo colorido.
+    """
+    total = len(df_resultado)
+    n_falhas = len(df_falhas)
+    n_ajustados = len(ajustados)
+    n_manuais = len(manuais) if manuais else 0
+    n_ok = total - n_falhas
+
+    linhas = [
+        '<div style="background:#f0f4ff;border:1px solid #c0d0f0;border-radius:8px;'
+        'padding:10px 14px;margin-top:8px">',
+        f'<strong>Resultado da geocodificação</strong> — {total} registros processados<br>',
+        f'<span style="color:#1a7a1a">✔ {n_ok} geocodificados com sucesso</span><br>',
+    ]
+
+    if n_ajustados > 0:
+        linhas.append(
+            f'<span style="color:#7a5a00">✏ {n_ajustados} corrigidos automaticamente '
+            f'(diferença ≤ 200)</span><br>'
+        )
+
+    if n_manuais > 0:
+        linhas.append(
+            f'<span style="color:#2980b9">✎ {n_manuais} corrigidos manualmente</span><br>'
+        )
+
+    if n_falhas > 0:
+        linhas.append(
+            f'<span style="color:#c0392b">✘ {n_falhas} com falha — '
+            f'preencha "Nº Corrigido" na tabela abaixo e aplique as correções</span>'
+        )
+    else:
+        linhas.append('<span style="color:#1a7a1a">Nenhuma falha restante.</span>')
+
+    linhas.append("</div>")
+    return "".join(linhas)
+
+
+def preparar_display_falhas(df_falhas):
+    """Prepara exibição de falhas: tabela HTML descritiva + DataFrame mínimo para correção.
+
+    Args:
+        df_falhas: DataFrame com colunas [_idx, cdlog, numero_atual, motivo, sugestoes]
+
+    Retorna:
+        html_str:     Tabela HTML legível (read-only) com as falhas
+        df_correcoes: DataFrame com colunas ["Nº Linha", "Nº Corrigido"] para edição pelo usuário
+    """
+    if df_falhas is None or df_falhas.empty:
+        return "", pd.DataFrame(columns=["Nº Linha", "Nº Corrigido"])
+
+    linhas = [
+        '<div style="overflow-x:auto;margin-top:8px">',
+        '<table style="width:100%;border-collapse:collapse;font-size:0.9em">',
+        '<thead><tr style="background:#f0f4ff">',
+        '<th style="border:1px solid #c0d0f0;padding:6px 10px;text-align:left">Nº Linha</th>',
+        '<th style="border:1px solid #c0d0f0;padding:6px 10px;text-align:left">CDLOG</th>',
+        '<th style="border:1px solid #c0d0f0;padding:6px 10px;text-align:left">Nº Atual</th>',
+        '<th style="border:1px solid #c0d0f0;padding:6px 10px;text-align:left">Motivo</th>',
+        '<th style="border:1px solid #c0d0f0;padding:6px 10px;text-align:left">Sugestões</th>',
+        '</tr></thead><tbody>',
+    ]
+    for _, row in df_falhas.iterrows():
+        linhas.append(
+            f'<tr>'
+            f'<td style="border:1px solid #dde;padding:5px 10px">{row["_idx"]}</td>'
+            f'<td style="border:1px solid #dde;padding:5px 10px">{row["cdlog"]}</td>'
+            f'<td style="border:1px solid #dde;padding:5px 10px">{row["numero_atual"]}</td>'
+            f'<td style="border:1px solid #dde;padding:5px 10px">{row["motivo"]}</td>'
+            f'<td style="border:1px solid #dde;padding:5px 10px">{row["sugestoes"]}</td>'
+            f'</tr>'
+        )
+    linhas.append('</tbody></table></div>')
+
+    df_correcoes = pd.DataFrame({
+        "Nº Linha": df_falhas["_idx"].tolist(),
+        "Nº Corrigido": [""] * len(df_falhas),
+    })
+
+    return "".join(linhas), df_correcoes

backend/app/core/elaboracao/modelo.py

@@ -0,0 +1,991 @@
+# -*- coding: utf-8 -*-
+"""
+modelo.py - Ajuste de modelo OLS, transformações e seleção de variáveis.
+
+Callbacks que lidam com a lógica do modelo estatístico:
+seleção X/Y, ajuste OLS, busca de transformações, exportação.
+"""
+
+import gradio as gr
+import pandas as pd
+from datetime import datetime, timezone, timedelta
+
+from .formatadores import (
+    criar_header_secao,
+    formatar_diagnosticos_html,
+    formatar_busca_html,
+    formatar_micronumerosidade_html,
+    formatar_aviso_multicolinearidade,
+)
+from .core import (
+    obter_colunas_numericas,
+    calcular_estatisticas_variaveis,
+    ajustar_modelo,
+    buscar_melhores_transformacoes,
+    testar_micronumerosidade,
+    detectar_dicotomicas,
+    detectar_codigo_alocado,
+    detectar_percentuais,
+    exportar_modelo_dai,
+    avaliar_imovel,
+    exportar_avaliacoes_excel,
+    verificar_multicolinearidade,
+)
+from .formatadores import formatar_avaliacao_html
+from .charts import (
+    criar_graficos_dispersao,
+    criar_graficos_dispersao_residuos,
+    criar_painel_diagnostico,
+    criar_matriz_correlacao,
+)
+
+
+# ============================================================
+# CONSTANTES
+# ============================================================
+
+MAX_VARS_X = 20
+
+
+# ============================================================
+# UTILITÁRIOS DE TRANSFORMAÇÃO
+# ============================================================
+
+def obter_transformacoes_dos_dropdowns(colunas_x, *valores_dropdowns):
+    """Coleta transformações dos valores dos dropdowns."""
+    transformacoes = {}
+    for i, col in enumerate(colunas_x):
+        if i < len(valores_dropdowns) and valores_dropdowns[i]:
+            transformacoes[col] = valores_dropdowns[i]
+        else:
+            transformacoes[col] = "(x)"
+    return transformacoes
+
+
+def atualizar_campos_transformacoes(df, colunas_x, dicotomicas=None, coluna_y=None):
+    """Atualiza visibilidade e valores dos campos de transformação.
+
+    CONTRACT: Retorna 66 itens para transf_y_row(1) + transf_y_col(1) + transf_y_label(1)
+    + transf_x_rows(3) + transf_x_columns(20) + transf_x_labels(20) + transf_x_dropdowns(20).
+    Se alterar, atualizar: app.py (outputs de checkboxes_x.change e btn_aplicar_selecao_x.click)
+    + _atualizar_campos_transformacoes_com_flag (neste arquivo)
+    + aplicar_selecao_callback (neste arquivo, campos_vazios).
+    """
+    n_rows = (MAX_VARS_X + 7) // 8  # 3 rows (8 cards por linha)
+
+    # Y card updates
+    if coluna_y and df is not None and colunas_x:
+        y_label_html = f'<span class="transf-label-text transf-label-y">{coluna_y} (Y)</span>'
+        y_updates = [
+            gr.update(visible=True),                            # transf_y_row
+            gr.update(visible=True),                            # transf_y_col
+            gr.update(value=y_label_html, visible=True),        # transf_y_label
+        ]
+    else:
+        y_updates = [
+            gr.update(visible=False),                           # transf_y_row
+            gr.update(visible=False),                           # transf_y_col
+            gr.update(value="", visible=False),                 # transf_y_label
+        ]
+
+    if df is None or not colunas_x:
+        # Esconde todos
+        row_updates = [gr.update(visible=False)] * n_rows
+        column_updates = [gr.update(visible=False)] * MAX_VARS_X
+        label_updates = [gr.update(value="", visible=False)] * MAX_VARS_X
+        dropdown_updates = [gr.update(value="(x)", interactive=True, visible=False)] * MAX_VARS_X
+        return y_updates + row_updates + column_updates + label_updates + dropdown_updates
+
+    if dicotomicas is None:
+        dicotomicas = detectar_dicotomicas(df, colunas_x)
+
+    # Updates para rows (visibilidade) - 8 por linha
+    row_updates = []
+    for i in range(n_rows):
+        idx_base = i * 8
+        visivel = idx_base < len(colunas_x)
+        row_updates.append(gr.update(visible=visivel))
+
+    # Updates para columns, labels e dropdowns
+    column_updates = []
+    label_updates = []
+    dropdown_updates = []
+
+    for i in range(MAX_VARS_X):
+        if i < len(colunas_x):
+            col = colunas_x[i]
+            eh_marcada = col in dicotomicas
+            # Só trava transformação se variável marcada E tem valores zero (dicotômica 0/1)
+            travar = False
+            if eh_marcada and col in df.columns:
+                valores_col = set(df[col].dropna().unique())
+                travar = 0 in valores_col or 0.0 in valores_col
+            column_updates.append(gr.update(visible=True))
+            label_updates.append(gr.update(value=f'<span class="transf-label-text">{col}</span>', visible=True))
+            dropdown_updates.append(gr.update(
+                value="(x)",
+                interactive=not travar,
+                visible=True
+            ))
+        else:
+            column_updates.append(gr.update(visible=False))
+            label_updates.append(gr.update(value="", visible=False))
+            dropdown_updates.append(gr.update(value="(x)", interactive=True, visible=False))
+
+    return y_updates + row_updates + column_updates + label_updates + dropdown_updates
+
+
+def _atualizar_campos_transformacoes_com_flag(df, colunas_x, flag_carregamento, coluna_y=None):
+    """Wrapper que pula reset de transformações durante carregamento programático.
+
+    CONTRACT: Retorna 70 itens (66 campos + estado_flag_carregamento + 3 checkboxes).
+    Se alterar, atualizar: app.py (outputs de checkboxes_x.change).
+    """
+    # Flag é um contador inteiro: decrementa a cada side-effect processado
+    if flag_carregamento:
+        n_items = 3 + (MAX_VARS_X + 7) // 8 + MAX_VARS_X + MAX_VARS_X + MAX_VARS_X  # 66
+        return [gr.update() for _ in range(n_items)] + [max(0, int(flag_carregamento) - 1), gr.update(), gr.update(), gr.update()]
+
+    if df is not None and colunas_x:
+        dicotomicas_01 = detectar_dicotomicas(df, colunas_x)
+        codigo_alocado = detectar_codigo_alocado(df, colunas_x)
+        percentuais = detectar_percentuais(df, colunas_x)
+    else:
+        dicotomicas_01 = []
+        codigo_alocado = []
+        percentuais = []
+
+    todas_marcadas = dicotomicas_01 + codigo_alocado + percentuais
+    campos = atualizar_campos_transformacoes(df, colunas_x, todas_marcadas, coluna_y=coluna_y)
+    choices = list(colunas_x) if colunas_x else []
+    vis = bool(colunas_x)
+    return campos + [
+        False,
+        gr.update(choices=choices, value=dicotomicas_01, visible=vis),
+        gr.update(choices=choices, value=codigo_alocado, visible=vis),
+        gr.update(choices=choices, value=percentuais, visible=vis),
+    ]
+
+
+# ============================================================
+# HANDLERS DE MUDANÇA DE SELEÇÃO
+# ============================================================
+
+def ao_mudar_tipo_grafico(tipo, resultado_modelo):
+    """Atualiza o gráfico de dispersão com base na seleção do dropdown."""
+    if not resultado_modelo:
+        return None
+
+    try:
+        X_transf = resultado_modelo["X_transformado"]
+
+        if "Resíduo" in tipo:
+            # Gráfico X vs Resíduos
+            tabela = resultado_modelo.get("tabela_obs_calc")
+            if tabela is not None and "Resíduo Pad." in tabela.columns:
+                residuos = tabela["Resíduo Pad."].values
+                return criar_graficos_dispersao_residuos(X_transf, residuos)
+            else:
+                return None
+        else:
+            # Gráfico X vs Y (Padrão)
+            y_transf = resultado_modelo["y_transformado"]
+            return criar_graficos_dispersao(X_transf, y_transf)
+
+    except Exception as e:
+        print(f"Erro ao atualizar gráfico: {e}")
+        return None
+
+
+def ao_mudar_y_sem_estatisticas(df, coluna_y, flag_carregamento=False, mostrar_secao_x=False):
+    """Callback quando variável y é alterada (sem calcular estatísticas).
+
+    Apenas atualiza os checkboxes de X disponíveis.
+    As estatísticas são calculadas apenas ao clicar em 'Aplicar Seleção' na seção 4.
+
+    Args:
+        df: DataFrame com os dados
+        coluna_y: Nome da coluna Y selecionada
+        flag_carregamento: Se True, mudança veio de carregamento programático (skip reset)
+        mostrar_secao_x: Se True, mostra a seção 4 (usado pelo botão Aplicar da seção 3)
+    """
+    # Se mudança veio de carregamento programático, não sobrescrever valores
+    # Flag é um contador inteiro: decrementa a cada side-effect processado
+    if flag_carregamento:
+        return (
+            gr.update(),            # checkboxes_x — manter valor do carregamento
+            gr.update(),            # header_secao_4 — manter visibilidade
+            gr.update(),            # accordion_secao_4 — manter visibilidade
+            max(0, int(flag_carregamento) - 1),  # estado_flag_carregamento — decrementar
+        )
+
+    if df is None or coluna_y is None:
+        return (
+            gr.update(choices=[]),     # checkboxes_x
+            gr.update(visible=False),  # header_secao_4
+            gr.update(visible=False),  # accordion_secao_4
+            False,                     # estado_flag_carregamento
+        )
+
+    # Lista de X disponíveis (exclui y) - todas marcadas por padrão
+    colunas_x = [col for col in obter_colunas_numericas(df) if col != coluna_y]
+
+    return (
+        gr.update(choices=colunas_x, value=colunas_x),  # checkboxes_x
+        gr.update(visible=mostrar_secao_x),             # header_secao_4
+        gr.update(visible=mostrar_secao_x, open=mostrar_secao_x),  # accordion_secao_4
+        False,                                          # estado_flag_carregamento
+    )
+
+
+# ============================================================
+# ESTATÍSTICAS
+# ============================================================
+
+def atualizar_estatisticas_auto(df_filtrado, coluna_y, colunas_x):
+    """Recalcula estatísticas automaticamente e retorna timestamp.
+
+    CONTRACT: Retorna 2 itens (estatisticas, timestamp).
+    Se alterar, atualizar: outliers.py (reiniciar_iteracao_callback, destructuring).
+    """
+    if df_filtrado is None or coluna_y is None:
+        return None, None
+
+    # Filtra apenas colunas selecionadas + Y
+    colunas_usar = [coluna_y] + list(colunas_x) if colunas_x else [coluna_y]
+    colunas_disponiveis = [c for c in colunas_usar if c in df_filtrado.columns]
+
+    if not colunas_disponiveis:
+        return None, None
+
+    estatisticas = calcular_estatisticas_variaveis(df_filtrado, coluna_y, colunas=colunas_disponiveis)
+    gmt_minus_3 = timezone(timedelta(hours=-3))
+    timestamp = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
+
+    return estatisticas.round(4), timestamp
+
+
+# ============================================================
+# CALLBACKS PRINCIPAIS
+# ============================================================
+
+def ajustar_modelo_callback(df, coluna_y, colunas_x, transformacao_y, outliers_anteriores, dicotomicas, codigo_alocado, percentuais, *valores_dropdowns):
+    """Callback para ajustar o modelo e calcular métricas de outliers.
+
+    CONTRACT: Retorna 33 itens para _outputs_ajustar (app.py:criar_aba).
+    Se alterar, atualizar: _outputs_ajustar em app.py + carregamento.py (indices em carregar_dados_de_dai).
+    """
+    # Variáveis disponíveis para filtro (métricas + todas as colunas originais do DataFrame)
+    colunas_metricas = {"Observado", "Calculado", "Resíduo", "Resíduo Pad.", "Resíduo Stud.", "Cook"}
+    colunas_originais = [c for c in df.columns if c not in colunas_metricas] if df is not None else []
+    variaveis_filtro = ["Resíduo Pad.", "Resíduo Stud.", "Cook"] + colunas_originais
+    filtro_var_updates = [gr.update(choices=variaveis_filtro)] * 4
+
+    # Updates para seções 10-16 ocultas (7 seções × 2 = 14 itens)
+    secoes_ocultas = (
+        gr.update(visible=False), gr.update(visible=False),  # header_secao_10, accordion_secao_10
+        gr.update(visible=False), gr.update(visible=False),  # header_secao_11, accordion_secao_11
+        gr.update(visible=False), gr.update(visible=False),  # header_secao_12, accordion_secao_12
+        gr.update(visible=False), gr.update(visible=False),  # header_secao_13, accordion_secao_13
+        gr.update(visible=False), gr.update(visible=False),  # header_secao_14, accordion_secao_14
+        gr.update(visible=False), gr.update(visible=False),  # header_secao_15, accordion_secao_15 (Avaliação)
+        gr.update(visible=False), gr.update(visible=False),  # header_secao_16, accordion_secao_16 (Exportar)
+    )
+
+    if df is None or coluna_y is None or not colunas_x:
+        return (
+            None,  # estado_modelo
+            "",  # diagnosticos_html
+            None,  # tabela_coef
+            None,  # tabela_obs_calc
+            None,  # plot_dispersao_transf
+            gr.update(visible=False),  # dropdown_tipo_grafico_dispersao
+            None, None, None, None, None,  # gráficos
+            None,  # tabela_metricas
+            None,  # estado_metricas
+            f"Excluídos: {len(outliers_anteriores) if outliers_anteriores else 0} | A excluir: 0 | A reincluir: 0 | Total: {len(outliers_anteriores) if outliers_anteriores else 0}",  # txt_resumo_outliers
+            [],  # estado_avaliacoes (reset)
+            *secoes_ocultas,  # seções 10-16 ocultas
+            *filtro_var_updates  # atualiza dropdowns de filtro
+        )
+
+    # Extrai transformações dos dropdowns
+    transformacoes_x = obter_transformacoes_dos_dropdowns(colunas_x, *valores_dropdowns)
+
+    # Ajusta modelo
+    resultado = ajustar_modelo(
+        df, coluna_y, colunas_x,
+        transformacao_y, transformacoes_x
+    )
+
+    if resultado is None:
+        return (
+            None,  # estado_modelo
+            "",  # diagnosticos_html
+            None,  # tabela_coef
+            None,  # tabela_obs_calc
+            None,  # plot_dispersao_transf
+            gr.update(visible=False),  # dropdown_tipo_grafico_dispersao
+            None, None, None, None, None,  # gráficos
+            None,  # tabela_metricas
+            None,  # estado_metricas
+            f"Outliers anteriores: {len(outliers_anteriores) if outliers_anteriores else 0} | Excluir: 0 | Reincluir: 0 | Total: {len(outliers_anteriores) if outliers_anteriores else 0}",
+            [],  # estado_avaliacoes (reset)
+            *secoes_ocultas,  # seções 10-16 ocultas
+            *filtro_var_updates  # atualiza dropdowns de filtro
+        )
+
+    # Formata diagnósticos
+    diagnosticos_html = formatar_diagnosticos_html(resultado["diagnosticos"])
+    gmt_minus_3 = timezone(timedelta(hours=-3))
+    timestamp = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
+
+    # Gráficos de dispersão com variáveis transformadas
+    try:
+        X_transf = resultado["X_transformado"]
+        y_transf = resultado["y_transformado"]
+        fig_dispersao_transf = criar_graficos_dispersao(X_transf, y_transf)
+    except Exception as e:
+        print(f"Erro ao gerar gráficos de dispersão transformados: {e}")
+        fig_dispersao_transf = None
+
+    # Gr��ficos de diagnóstico
+    graficos = criar_painel_diagnostico(resultado)
+
+    # Correlação (com variáveis transformadas)
+    try:
+        X_transf_corr = resultado["X_transformado"].copy()
+        y_transf_corr = resultado["y_transformado"].copy()
+
+        # Cria DataFrame temporário para correlação
+        df_corr_temp = X_transf_corr
+        # Adiciona y (garantindo nome correto)
+        df_corr_temp[coluna_y] = y_transf_corr
+
+        colunas_corr = [coluna_y] + list(colunas_x)
+        fig_corr = criar_matriz_correlacao(df_corr_temp, colunas_corr)
+    except Exception as e:
+        print(f"Erro ao gerar matriz de correlação transformada: {e}")
+        fig_corr = None
+
+    # Extrai métricas de outliers da tabela_obs_calc (já contém resíduos, Cook, etc.)
+    tabela_metricas = resultado["tabela_obs_calc"].copy()
+
+    # Para o estado de filtros:
+    # 1. Usa set_index para que o índice do DataFrame seja os índices originais
+    # 2. Adiciona as variáveis X para permitir filtros por variáveis
+    tabela_metricas_estado = tabela_metricas.set_index("Índice")
+
+    # Adiciona todas as colunas originais ao estado para filtros
+    indices_usados = resultado["indices_usados"]
+    df_filtrado = df.loc[indices_usados]
+    colunas_novas = {
+        col: df_filtrado[col].values
+        for col in df.columns
+        if col not in tabela_metricas_estado.columns
+    }
+    if colunas_novas:
+        tabela_metricas_estado = pd.concat(
+            [tabela_metricas_estado, pd.DataFrame(colunas_novas, index=tabela_metricas_estado.index)],
+            axis=1
+        )
+
+    # Resumo de outliers
+    n_anteriores = len(outliers_anteriores) if outliers_anteriores else 0
+    resumo = f"Excluídos: {n_anteriores} | A excluir: 0 | A reincluir: 0 | Total: {n_anteriores}"
+
+    # Updates para seções 10-16 visíveis com timestamp nos headers (7 seções × 2 = 14 itens)
+    secoes_visiveis = (
+        gr.update(visible=True, value=criar_header_secao(10, "Gráficos de Dispersão com Modelo Ajustado", timestamp)),  # header_secao_10
+        gr.update(visible=True, open=True),  # accordion_secao_10
+        gr.update(visible=True, value=criar_header_secao(11, "Diagnóstico de Modelo", timestamp)),  # header_secao_11
+        gr.update(visible=True, open=True),  # accordion_secao_11
+        gr.update(visible=True, value=criar_header_secao(12, "Gráficos de Diagnóstico do Modelo", timestamp)),  # header_secao_12
+        gr.update(visible=True, open=True),  # accordion_secao_12
+        gr.update(visible=True, value=criar_header_secao(13, "Analisar Outliers", timestamp)),  # header_secao_13
+        gr.update(visible=True, open=True),  # accordion_secao_13
+        gr.update(visible=True, value=criar_header_secao(14, "Exclusão ou Reinclusão de Outliers", timestamp)),  # header_secao_14
+        gr.update(visible=True, open=True),  # accordion_secao_14
+        gr.update(visible=True, value=criar_header_secao(15, "Avaliação de Imóvel", timestamp)),  # header_secao_15
+        gr.update(visible=True, open=True),  # accordion_secao_15
+        gr.update(visible=True, value=criar_header_secao(16, "Exportar Modelo", timestamp)),  # header_secao_16
+        gr.update(visible=True, open=True),  # accordion_secao_16
+    )
+
+    resultado["dicotomicas"] = list(dicotomicas) if dicotomicas else []
+    resultado["codigo_alocado"] = list(codigo_alocado) if codigo_alocado else []
+    resultado["percentuais"] = list(percentuais) if percentuais else []
+
+    return (
+        resultado,
+        diagnosticos_html,
+        resultado["tabela_coef"].round(4),
+        resultado["tabela_obs_calc"].round(4),
+        fig_dispersao_transf,  # plot_dispersao_transf
+        gr.update(value="Variáveis Independentes Transformadas X Variável Dependente Transformada", visible=True),  # dropdown_tipo_grafico_dispersao
+        graficos.get("obs_calc"),
+        graficos.get("residuos"),
+        graficos.get("histograma"),
+        graficos.get("cook"),
+        fig_corr,
+        tabela_metricas.round(4),  # tabela_metricas (para exibição - com coluna Índice)
+        tabela_metricas_estado,  # estado_metricas (com set_index - para filtros)
+        resumo,  # txt_resumo_outliers
+        [],  # estado_avaliacoes (reset ao re-ajustar)
+        *secoes_visiveis,  # seções 10-16 visíveis
+        *filtro_var_updates  # atualiza dropdowns de filtro
+    )
+
+
+def buscar_transformacoes_callback(df, coluna_y, colunas_x, dicotomicas=None, codigo_alocado=None, percentuais=None, grau_min_coef=1, grau_min_f=0):
+    """Callback para busca automática de transformações.
+
+    CONTRACT: Retorna 8 itens (html, resultados, timestamp, btn1..btn5).
+    Se alterar, atualizar: outliers.py (reiniciar_iteracao_callback, destructuring)
+    + app.py (outputs de btn_buscar_transf.click).
+    """
+    btn_hidden = [gr.update(visible=False)] * 5
+
+    if df is None or coluna_y is None or not colunas_x:
+        return ("<p>Selecione as variáveis primeiro.</p>", [], "", *btn_hidden)
+
+    # Verifica se colunas têm dados válidos (não 100% NaN)
+    colunas_vazias = []
+    for col in colunas_x:
+        if col in df.columns and df[col].isna().all():
+            colunas_vazias.append(col)
+
+    if colunas_vazias:
+        msg = f"<p style='color: red;'><b>Erro:</b> As seguintes colunas estão completamente vazias (sem dados): <b>{', '.join(colunas_vazias)}</b></p>"
+        msg += "<p>Selecione apenas variáveis que contenham dados válidos.</p>"
+        return (msg, [], "", *btn_hidden)
+
+    # Verifica se Y tem dados válidos
+    if coluna_y in df.columns and df[coluna_y].isna().all():
+        msg = f"<p style='color: red;'><b>Erro:</b> A variável dependente <b>{coluna_y}</b> está completamente vazia.</p>"
+        return (msg, [], "", *btn_hidden)
+
+    # Fixa dicotômicas e percentuais em (x) — código alocado fica livre
+    transformacoes_fixas = {}
+    if dicotomicas is None:
+        dicotomicas = detectar_dicotomicas(df, colunas_x)
+    if percentuais is None:
+        percentuais = detectar_percentuais(df, colunas_x)
+    for col in (dicotomicas or []) + (percentuais or []):
+        transformacoes_fixas[col] = "(x)"
+
+    # Busca melhores transformações
+    resultados = buscar_melhores_transformacoes(
+        df, coluna_y, colunas_x,
+        transformacoes_fixas=transformacoes_fixas,
+        top_n=5,
+        grau_min_coef=int(grau_min_coef),
+        grau_min_f=int(grau_min_f)
+    )
+
+    if not resultados:
+        msg = (
+            "<p style='color: orange;'><b>Aviso:</b> Nenhuma combinação de transformações resultou "
+            "em todos os coeficientes com ao menos Grau I de significância (p&nbsp;≤&nbsp;30%).</p>"
+            "<p>Considere revisar as variáveis selecionadas ou verificar a qualidade dos dados.</p>"
+        )
+        return (msg, [], "", *btn_hidden)
+
+    html = formatar_busca_html(resultados)
+    gmt_minus_3 = timezone(timedelta(hours=-3))
+    timestamp = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
+
+    # Atualiza visibilidade dos botões "Adotar"
+    btn_updates = [gr.update(visible=(i < len(resultados))) for i in range(5)]
+
+    return (html, resultados, timestamp, *btn_updates)
+
+
+def aplicar_selecao_callback(df, coluna_y, colunas_x, outliers_anteriores, dicotomicas=None, codigo_alocado=None, percentuais=None):
+    """Aplica seleção de variáveis, atualiza estatísticas e busca transformações automaticamente.
+
+    NÃO calcula métricas de outliers aqui - isso é feito ao ajustar o modelo.
+    Filtra dados excluindo outliers de iterações anteriores.
+    Gera gráficos de dispersão e teste de micronumerosidade.
+    Busca transformações com fallback automático (começa em Grau III/III e reduz se necessário).
+
+    CONTRACT: Retorna 90 itens para btn_aplicar_selecao_x.click (app.py:criar_aba).
+    Se alterar, atualizar: app.py (outputs) + carregamento.py (indices em carregar_dados_de_dai).
+    """
+    n_rows = (MAX_VARS_X + 7) // 8  # 3 rows (8 por linha)
+
+    # Valores padrão quando não há dados
+    campos_vazios = (
+        [gr.update(visible=False)] * 3 +                                   # 3: transf_y_row, transf_y_col, transf_y_label
+        [gr.update(visible=False)] * n_rows +                              # 3: transf_x_rows
+        [gr.update(visible=False)] * MAX_VARS_X +                          # 20: transf_x_columns
+        [gr.update(value="", visible=False)] * MAX_VARS_X +                # 20: transf_x_labels
+        [gr.update(value="(x)", interactive=True, visible=False)] * MAX_VARS_X  # 20: transf_x_dropdowns
+    )
+
+    # Botões de adotar escondidos por padrão
+    btn_hidden = [gr.update(visible=False)] * 5
+
+    # Valores padrão para dispersão e micronumerosidade
+    dispersao_vazio = None
+    micro_vazio = "<p>Clique em 'Aplicar Seleção' para verificar micronumerosidade.</p>"
+
+    # Updates para seções 5-9 ocultas
+    secoes_ocultas = (
+        gr.update(visible=False), gr.update(visible=False),  # header_secao_5, accordion_secao_5
+        gr.update(visible=False), gr.update(visible=False),  # header_secao_6, accordion_secao_6
+        gr.update(visible=False), gr.update(visible=False),  # header_secao_7, accordion_secao_7
+        gr.update(visible=False), gr.update(visible=False),  # header_secao_8, accordion_secao_8
+        gr.update(visible=False), gr.update(visible=False),  # header_secao_9, accordion_secao_9
+    )
+
+    if df is None or coluna_y is None:
+        return (
+            None,  # estado_df_filtrado
+            gr.update(value=None),  # tabela_estatisticas
+            micro_vazio,  # html_micronumerosidade
+            dispersao_vazio,  # plot_dispersao
+            gr.update(),  # slider_grau_coef (no-op)
+            gr.update(),  # slider_grau_f (no-op)
+            "",  # busca_html
+            [],  # estado_resultados_busca
+            *btn_hidden,  # botões adotar
+            *secoes_ocultas,  # seções 5-9 ocultas
+            *campos_vazios,  # campos de transformação
+            gr.update(value="", visible=False),  # html_aviso_multicolinearidade
+        )
+
+    if not colunas_x:
+        return (
+            df,
+            gr.update(value=None),  # tabela_estatisticas
+            micro_vazio,  # html_micronumerosidade
+            dispersao_vazio,  # plot_dispersao
+            gr.update(),  # slider_grau_coef (no-op)
+            gr.update(),  # slider_grau_f (no-op)
+            "",  # busca_html
+            [],  # estado_resultados_busca
+            *btn_hidden,  # botões adotar
+            *secoes_ocultas,  # seções 5-9 ocultas
+            *campos_vazios,  # campos de transformação
+            gr.update(value="", visible=False),  # html_aviso_multicolinearidade
+        )
+
+    # Filtra dados excluindo outliers de iterações anteriores
+    df_filtrado = df.copy()
+    if outliers_anteriores:
+        df_filtrado = df_filtrado.drop(index=outliers_anteriores, errors='ignore')
+
+    # Calcula estatísticas com dados filtrados
+    estatisticas, _ = atualizar_estatisticas_auto(df_filtrado, coluna_y, colunas_x)
+
+    # Timestamp para as novas seções
+    gmt_minus_3 = timezone(timedelta(hours=-3))
+    timestamp = datetime.now(gmt_minus_3).strftime("%H:%M:%S")
+
+    # Teste de micronumerosidade
+    try:
+        resultado_micro = testar_micronumerosidade(df_filtrado, list(colunas_x),
+            dicotomicas=dicotomicas, codigo_alocado=codigo_alocado)
+        html_micro = formatar_micronumerosidade_html(resultado_micro)
+    except Exception as e:
+        print(f"Erro ao testar micronumerosidade: {e}")
+        html_micro = f"<p style='color: red;'>Erro ao calcular micronumerosidade: {e}</p>"
+
+    # Gera gráficos de dispersão
+    try:
+        X = df_filtrado[list(colunas_x)]
+        y = df_filtrado[coluna_y]
+        fig_dispersao = criar_graficos_dispersao(X, y)
+    except Exception as e:
+        print(f"Erro ao gerar gráficos de dispersão: {e}")
+        fig_dispersao = None
+
+    # Atualiza campos de transformação (junta todas as marcadas para lock)
+    todas_marcadas = (dicotomicas or []) + (codigo_alocado or []) + (percentuais or [])
+    campos_updates = atualizar_campos_transformacoes(df, colunas_x, todas_marcadas, coluna_y=coluna_y)
+
+    # Busca automática de transformações: critério mínimo (Grau I nos coeficientes, sem filtro F)
+    busca_html_result, resultados_busca, _, *btn_updates = buscar_transformacoes_callback(
+        df_filtrado, coluna_y, colunas_x, dicotomicas, codigo_alocado, percentuais,
+        grau_min_coef=1, grau_min_f=0
+    )
+
+    # Radio buttons refletem o grau mínimo REAL presente nos resultados
+    if resultados_busca:
+        grau_coef_usado = min(
+            min(r.get("graus_coef", {}).values(), default=0)
+            for r in resultados_busca
+        )
+        grau_f_usado = min(r.get("grau_f", 0) for r in resultados_busca)
+    else:
+        grau_coef_usado = 1
+        grau_f_usado = 0
+
+    # Updates para seções 5-9 visíveis com timestamp nos headers
+    secoes_visiveis = (
+        gr.update(visible=True, value=criar_header_secao(5, "Estatísticas das Variáveis Selecionadas", timestamp)),  # header_secao_5
+        gr.update(visible=True, open=True),  # accordion_secao_5
+        gr.update(visible=True, value=criar_header_secao(6, "Teste de Micronumerosidade (NBR 14.653-2)", timestamp)),  # header_secao_6
+        gr.update(visible=True, open=True),  # accordion_secao_6
+        gr.update(visible=True, value=criar_header_secao(7, "Gráficos de Dispersão das Variáveis Independentes", timestamp)),  # header_secao_7
+        gr.update(visible=True, open=True),  # accordion_secao_7
+        gr.update(visible=True, value=criar_header_secao(8, "Transformações Sugeridas", timestamp)),  # header_secao_8
+        gr.update(visible=True, open=True),  # accordion_secao_8
+        gr.update(visible=True, value=criar_header_secao(9, "Aplicação das Transformações", timestamp)),  # header_secao_9
+        gr.update(visible=True, open=True),  # accordion_secao_9
+    )
+
+    # Verifica multicolinearidade (dados brutos, antes das transformações da seção 9)
+    resultado_multi = verificar_multicolinearidade(df_filtrado, list(colunas_x))
+    html_multi, visivel_multi = formatar_aviso_multicolinearidade(resultado_multi)
+
+    return (
+        df_filtrado,  # estado_df_filtrado
+        gr.update(value=estatisticas),  # tabela_estatisticas
+        html_micro,  # html_micronumerosidade
+        fig_dispersao,  # plot_dispersao
+        gr.update(value=grau_coef_usado),  # slider_grau_coef
+        gr.update(value=grau_f_usado),  # slider_grau_f
+        busca_html_result,  # busca_html
+        resultados_busca,  # estado_resultados_busca
+        *btn_updates,  # botões adotar
+        *secoes_visiveis,  # seções 5-9 visíveis
+        *campos_updates,  # campos de transformação
+        gr.update(value=html_multi, visible=visivel_multi),  # html_aviso_multicolinearidade (item 90)
+    )
+
+
+def adotar_sugestao(indice, resultados, colunas_x):
+    """Preenche os dropdowns com a sugestão selecionada.
+
+    CONTRACT: Retorna 21 itens (1 transf_y + 20 transf_x_dropdowns).
+    Se alterar, atualizar: app.py (outputs de btn_adotar_N.click).
+    """
+    if not resultados or indice >= len(resultados):
+        return [gr.update()] * (1 + MAX_VARS_X)
+
+    sugestao = resultados[indice]
+
+    # Update para transformação de Y
+    updates = [gr.update(value=sugestao["transformacao_y"])]
+
+    # Updates para transformações de X
+    transf_x = sugestao["transformacoes_x"]
+    for i in range(MAX_VARS_X):
+        if i < len(colunas_x):
+            col = colunas_x[i]
+            updates.append(gr.update(value=transf_x.get(col, "(x)")))
+        else:
+            updates.append(gr.update())
+
+    return updates
+
+
+# ============================================================
+# CALLBACKS DE AVALIAÇÃO (Seção 15)
+# ============================================================
+
+N_AVAL_ROWS = MAX_VARS_X // 4  # 5 rows (4 inputs por linha)
+
+
+def popular_campos_avaliacao_callback(estado_modelo, tabela_estatisticas):
+    """Popula inputs da seção 15 com labels dinâmicos após ajuste.
+
+    Chamado via .then() após ajustar_modelo_callback ou carregar .dai.
+
+    CONTRACT: Retorna 27 itens (5 aval_rows + 20 aval_inputs + resultado_html + dropdown_base).
+    Se alterar, atualizar: app.py (_outputs_popular_avaliacao).
+    """
+    rows_hidden = [gr.update(visible=False)] * N_AVAL_ROWS
+    inputs_hidden = [gr.update(visible=False, value=None, label="")] * MAX_VARS_X
+    dropdown_reset = gr.update(choices=[], value=None)
+
+    if estado_modelo is None:
+        return (*rows_hidden, *inputs_hidden, "", dropdown_reset)
+
+    try:
+        colunas_x = estado_modelo["colunas_x"]
+        n_vars = len(colunas_x)
+
+        # Extrair min/max das estatísticas
+        import pandas as pd
+        if tabela_estatisticas is not None and isinstance(tabela_estatisticas, pd.DataFrame):
+            if "Variável" in tabela_estatisticas.columns:
+                est_idx = tabela_estatisticas.set_index("Variável")
+            else:
+                est_idx = tabela_estatisticas
+        else:
+            est_idx = pd.DataFrame()
+
+        # Rows visíveis
+        import math
+        n_rows_vis = math.ceil(n_vars / 4)
+        rows_updates = [gr.update(visible=(r < n_rows_vis)) for r in range(N_AVAL_ROWS)]
+
+        # Inputs com labels dinâmicos
+        dicotomicas = estado_modelo.get("dicotomicas", [])
+        codigo_alocado = estado_modelo.get("codigo_alocado", [])
+        percentuais = estado_modelo.get("percentuais", [])
+        inputs_updates = []
+        for i in range(MAX_VARS_X):
+            if i < n_vars:
+                col = colunas_x[i]
+                if col in dicotomicas:
+                    placeholder = "0 ou 1"
+                elif col in codigo_alocado and col in est_idx.index:
+                    min_val = est_idx.loc[col, "Mínimo"]
+                    max_val = est_idx.loc[col, "Máximo"]
+                    placeholder = f"cód. {int(min_val)} a {int(max_val)}"
+                elif col in percentuais:
+                    placeholder = "0 a 1"
+                elif col in est_idx.index:
+                    min_val = est_idx.loc[col, "Mínimo"]
+                    max_val = est_idx.loc[col, "Máximo"]
+                    placeholder = f"{min_val} — {max_val}"
+                else:
+                    placeholder = ""
+                inputs_updates.append(gr.update(visible=True, value=None, label=col, placeholder=placeholder, interactive=True))
+            else:
+                inputs_updates.append(gr.update(visible=False, value=None, label="", placeholder=""))
+
+        return (*rows_updates, *inputs_updates, "", dropdown_reset)
+
+    except Exception as e:
+        print(f"Erro ao popular campos de avaliação: {e}")
+        return (*rows_hidden, *inputs_hidden, "", dropdown_reset)
+
+
+def avaliar_imovel_callback(estado_modelo, tabela_estatisticas, estado_avaliacoes, indice_base_str, *aval_inputs):
+    """Avalia um imóvel usando o modelo ajustado (seção 15).
+
+    CONTRACT: Retorna 3 itens (resultado_html, estado_avaliacoes, dropdown_update).
+    Se alterar, atualizar: app.py (outputs de btn_calcular_avaliacao.click).
+    """
+    _err = lambda msg: (msg, estado_avaliacoes or [], gr.update())
+    if estado_modelo is None:
+        return _err("Ajuste um modelo primeiro.")
+
+    import pandas as pd
+    colunas_x = estado_modelo["colunas_x"]
+    n_vars = len(colunas_x)
+
+    # Extrair valores dos inputs
+    valores_x = {}
+    for i, col in enumerate(colunas_x):
+        if i >= len(aval_inputs) or aval_inputs[i] is None:
+            return _err("Preencha todos os campos antes de calcular.")
+        valores_x[col] = float(aval_inputs[i])
+
+    # Extrair transformações do resultado do modelo
+    transformacoes_x = estado_modelo.get("transformacoes_x", {})
+    transformacao_y = estado_modelo.get("transformacao_y", "(x)")
+
+    # Obter estatísticas
+    if tabela_estatisticas is not None and isinstance(tabela_estatisticas, pd.DataFrame):
+        estatisticas_df = tabela_estatisticas
+    else:
+        return _err("Estatísticas não disponíveis.")
+
+    # Validar variáveis dicotômicas, código alocado e percentuais ANTES de avaliar
+    dicotomicas = estado_modelo.get("dicotomicas", [])
+    codigo_alocado = estado_modelo.get("codigo_alocado", [])
+    percentuais = estado_modelo.get("percentuais", [])
+
+    if "Variável" in estatisticas_df.columns:
+        est_idx = estatisticas_df.set_index("Variável")
+    else:
+        est_idx = estatisticas_df
+
+    for col in colunas_x:
+        val = valores_x[col]
+        if col in dicotomicas:
+            if val not in (0, 0.0, 1, 1.0):
+                return _err(f"<p style='color:red;'><b>Erro:</b> A variável <b>{col}</b> é dicotômica e aceita apenas valores 0 ou 1. "
+                        f"Valor informado: {val}</p>")
+        elif col in codigo_alocado and col in est_idx.index:
+            min_val = float(est_idx.loc[col, "Mínimo"])
+            max_val = float(est_idx.loc[col, "Máximo"])
+            eh_inteiro = (float(val) == int(float(val)))
+            if not eh_inteiro or val < min_val or val > max_val:
+                return _err(f"<p style='color:red;'><b>Erro:</b> A variável <b>{col}</b> é de código alocado/ajustado e aceita apenas "
+                        f"valores inteiros de {int(min_val)} a {int(max_val)}. Valor informado: {val}</p>")
+        elif col in percentuais:
+            if val < 0 or val > 1:
+                return _err(f"<p style='color:red;'><b>Erro:</b> A variável <b>{col}</b> é percentual e aceita apenas "
+                        f"valores entre 0 e 1. Valor informado: {val}</p>")
+
+    resultado = avaliar_imovel(
+        modelo_sm=estado_modelo["modelo_sm"],
+        valores_x=valores_x,
+        colunas_x=colunas_x,
+        transformacoes_x=transformacoes_x,
+        transformacao_y=transformacao_y,
+        estatisticas_df=estatisticas_df,
+        dicotomicas=dicotomicas,
+        codigo_alocado=codigo_alocado,
+        percentuais=percentuais,
+    )
+
+    if resultado is None:
+        return _err("Erro ao calcular avaliação.")
+
+    # Acumular resultado
+    nova_lista = list(estado_avaliacoes or []) + [resultado]
+    indice_base = int(indice_base_str) - 1 if indice_base_str else 0
+    html = formatar_avaliacao_html(nova_lista, indice_base=indice_base, elem_id_excluir="excluir-aval-elab")
+
+    # Atualizar choices do dropdown de base
+    choices = [str(i + 1) for i in range(len(nova_lista))]
+    # Se é a primeira avaliação, setar base como "1"
+    base_val = indice_base_str if indice_base_str else "1"
+
+    return html, nova_lista, gr.update(choices=choices, value=base_val)
+
+
+def limpar_avaliacoes_callback():
+    """Limpa o histórico de avaliações da seção 15.
+
+    CONTRACT: Retorna 3 itens (resultado_html, estado_avaliacoes, dropdown_update).
+    Se alterar, atualizar: app.py (outputs de btn_limpar_avaliacoes.click).
+    """
+    return "", [], gr.update(choices=[], value=None)
+
+
+def excluir_avaliacao_callback(indice_str, estado_avaliacoes, indice_base_str):
+    """Exclui uma avaliação da lista (seção 15).
+
+    CONTRACT: Retorna 4 itens (resultado_html, estado_avaliacoes, dropdown_update, trigger_reset).
+    """
+    if not indice_str or not indice_str.strip() or not estado_avaliacoes:
+        return gr.update(), estado_avaliacoes or [], gr.update(), ""
+
+    try:
+        idx = int(indice_str.strip()) - 1
+    except ValueError:
+        return gr.update(), estado_avaliacoes or [], gr.update(), ""
+
+    if idx < 0 or idx >= len(estado_avaliacoes):
+        return gr.update(), estado_avaliacoes or [], gr.update(), ""
+
+    nova_lista = [a for i, a in enumerate(estado_avaliacoes) if i != idx]
+
+    if not nova_lista:
+        return "", [], gr.update(choices=[], value=None), ""
+
+    # Ajustar índice base
+    base = int(indice_base_str) - 1 if indice_base_str else 0
+    if base >= len(nova_lista):
+        base = len(nova_lista) - 1
+    if base < 0:
+        base = 0
+
+    choices = [str(i + 1) for i in range(len(nova_lista))]
+    html = formatar_avaliacao_html(nova_lista, indice_base=base, elem_id_excluir="excluir-aval-elab")
+    return html, nova_lista, gr.update(choices=choices, value=str(base + 1)), ""
+
+
+def atualizar_base_avaliacao_callback(estado_avaliacoes, indice_base_str):
+    """Re-renderiza HTML quando o dropdown de base muda (seção 15).
+
+    CONTRACT: Retorna 1 item (resultado_html).
+    """
+    if not estado_avaliacoes:
+        return ""
+    indice = int(indice_base_str) - 1 if indice_base_str else 0
+    return formatar_avaliacao_html(estado_avaliacoes, indice_base=indice, elem_id_excluir="excluir-aval-elab")
+
+
+def exportar_avaliacoes_excel_callback(estado_avaliacoes):
+    """Exporta avaliações para Excel (seção 15).
+
+    CONTRACT: Retorna 1 item (download_file_update).
+    """
+    if not estado_avaliacoes:
+        return gr.update(value=None, visible=False)
+    caminho = exportar_avaliacoes_excel(estado_avaliacoes)
+    if caminho:
+        return gr.update(value=caminho, visible=True)
+    return gr.update(value=None, visible=False)
+
+
+def exportar_modelo_callback(resultado_modelo, df, df_completo, estatisticas,
+                              nome_arquivo, elaborador=None, outliers_excluidos=None):
+    """Callback para exportar modelo com download."""
+    if resultado_modelo is None:
+        return "Nenhum modelo para exportar. Ajuste o modelo primeiro.", gr.update(value=None, visible=False)
+
+    if not nome_arquivo or not nome_arquivo.strip():
+        return "Informe o nome do arquivo.", gr.update(value=None, visible=False)
+
+    caminho, msg = exportar_modelo_dai(
+        resultado_modelo, df, df_completo, estatisticas, nome_arquivo.strip(),
+        elaborador=elaborador, outliers_excluidos=outliers_excluidos or []
+    )
+
+    if caminho:
+        return msg, gr.update(value=caminho, visible=True)
+    else:
+        return msg, gr.update(value=None, visible=False)
+
+
+# ============================================================
+# CALLBACKS DE DICOTÔMICAS
+# ============================================================
+
+def atualizar_interativo_dicotomicas(colunas_x, dicotomicas, codigo_alocado, percentuais, df):
+    """Atualiza interactive dos dropdowns de transformação conforme os 3 tipos.
+
+    Dicotômicas e percentuais: transformação travada em (x).
+    Código alocado: transformação livre.
+
+    Handler para checkboxes_dicotomicas.change(), checkboxes_codigo_alocado.change(),
+    checkboxes_percentuais.change().
+
+    CONTRACT: Retorna 20 itens (transf_x_dropdowns).
+    Se alterar, atualizar: app.py (outputs dos .change dos 3 checkboxes).
+    """
+    updates = []
+    for i in range(MAX_VARS_X):
+        if i < len(colunas_x):
+            col = colunas_x[i]
+            if col in (dicotomicas or []) or col in (percentuais or []):
+                updates.append(gr.update(interactive=False, value="(x)"))
+            else:
+                updates.append(gr.update(interactive=True))
+        else:
+            updates.append(gr.update())
+    return updates
+
+
+def popular_dicotomicas_callback(estado_modelo, colunas_x, estado_df):
+    """Popula os 3 checkboxes: dicotômicas, código alocado e percentuais.
+
+    Para .dai: usa listas salvas no modelo.
+    Para CSV/Excel: auto-detecta os 3 tipos.
+
+    CONTRACT: Retorna 3 itens (checkboxes_dicotomicas, checkboxes_codigo_alocado, checkboxes_percentuais).
+    Se alterar, atualizar: app.py (outputs do .then de popular_dicotomicas).
+    """
+    empty = gr.update(choices=[], value=[], visible=False)
+    if not colunas_x:
+        return empty, empty, empty
+
+    choices = list(colunas_x)
+
+    if estado_modelo is not None:
+        dic = estado_modelo.get("dicotomicas", [])
+        cod = estado_modelo.get("codigo_alocado", [])
+        perc = estado_modelo.get("percentuais", [])
+    elif estado_df is not None:
+        dic = detectar_dicotomicas(estado_df, colunas_x)
+        cod = detectar_codigo_alocado(estado_df, colunas_x)
+        perc = detectar_percentuais(estado_df, colunas_x)
+    else:
+        return empty, empty, empty
+
+    return (
+        gr.update(choices=choices, value=dic, visible=True),
+        gr.update(choices=choices, value=cod, visible=True),
+        gr.update(choices=choices, value=perc, visible=True),
+    )

backend/app/core/elaboracao/outliers.py

@@ -0,0 +1,301 @@
+# -*- coding: utf-8 -*-
+"""
+outliers.py - Filtros dinâmicos, exclusão/reinclusão e iteração de outliers.
+
+Callbacks que lidam com filtros de outliers, exclusão,
+reinclusão e reinício de iteração do modelo.
+"""
+
+import gradio as gr
+
+from .formatadores import (
+    arredondar_df,
+    criar_header_secao,
+    formatar_micronumerosidade_html,
+    formatar_outliers_anteriores_html,
+)
+from .modelo import buscar_transformacoes_callback, atualizar_estatisticas_auto
+from .core import testar_micronumerosidade
+from .charts import criar_graficos_dispersao, criar_mapa
+
+
+# ============================================================
+# FILTROS
+# ============================================================
+
+def aplicar_filtros_callback(metricas_estado, n_filtros, *args):
+    """Aplica múltiplos filtros de outliers.
+
+    n_filtros: número de filtros visíveis (apenas esses serão aplicados)
+    args: var1, var2, var3, var4, op1, op2, op3, op4, val1, val2, val3, val4
+    Retorna lista de índices que satisfazem QUALQUER filtro (OR lógico).
+    """
+    if metricas_estado is None:
+        return ""
+
+    # Extrai filtros dos argumentos (apenas os filtros visíveis)
+    # Ordem: [4 vars] + [4 ops] + [4 vals]
+    filtros = []
+    for i in range(n_filtros):  # Só processa os filtros visíveis
+        var = args[i]           # vars estão nos índices 0-3
+        op = args[i + 4]        # ops estão nos índices 4-7
+        val = args[i + 8]       # vals estão nos índices 8-11
+        if var is not None and op is not None and val is not None:
+            # Converte valor para float (pode vir como string)
+            try:
+                val_float = float(val)
+            except (ValueError, TypeError):
+                continue
+            filtros.append({"variavel": var, "operador": op, "valor": val_float})
+
+    if not filtros:
+        return ""
+
+    # Aplica filtros com lógica OR
+    indices_outliers = set()
+
+    for filtro in filtros:
+        var = filtro["variavel"]
+        op = filtro["operador"]
+        val = filtro["valor"]
+
+        if var not in metricas_estado.columns:
+            continue
+
+        # Aplica operador
+        if op == "<=":
+            mask = metricas_estado[var] <= val
+        elif op == ">=":
+            mask = metricas_estado[var] >= val
+        elif op == "<":
+            mask = metricas_estado[var] < val
+        elif op == ">":
+            mask = metricas_estado[var] > val
+        elif op == "=":
+            mask = metricas_estado[var] == val
+        else:
+            continue
+
+        # Usa o índice do DataFrame (que agora são os índices originais dos dados via set_index)
+        indices_filtro = metricas_estado[mask].index.tolist()
+        indices_outliers.update(indices_filtro)
+
+    # Converte para inteiros e ordena
+    indices_ordenados = sorted([int(i) for i in indices_outliers])
+    return ", ".join(map(str, indices_ordenados))
+
+
+def adicionar_filtro_callback(n_filtros_atual):
+    """Callback para adicionar um novo filtro (mostra a próxima row oculta).
+
+    CONTRACT: Retorna 5 itens (n_filtros + 4 row updates).
+    Se alterar, atualizar: app.py (outputs de btn_adicionar_filtro.click).
+    """
+    n_novo = min(n_filtros_atual + 1, 4)
+
+    # Retorna: novo estado + 4 updates de visibilidade para rows
+    updates = [n_novo]
+    for i in range(4):
+        updates.append(gr.update(visible=(i < n_novo)))
+
+    return tuple(updates)
+
+
+def remover_ultimo_filtro_callback(n_filtros_atual):
+    """Remove o último filtro visível.
+
+    CONTRACT: Retorna 5 itens (n_filtros + 4 row updates).
+    Se alterar, atualizar: app.py (outputs de btn_remover_filtro.click).
+    """
+    n_novo = max(0, n_filtros_atual - 1)
+    return (n_novo,) + tuple(gr.update(visible=(i < n_novo)) for i in range(4))
+
+
+def limpar_filtros_callback():
+    """Limpa todos os filtros e restaura os padrões.
+
+    CONTRACT: Retorna 18 itens (n_filtros + 4 rows + 4 vars + 4 ops + 4 vals + outliers_texto).
+    Se alterar, atualizar: app.py (outputs de btn_limpar_filtros.click).
+    """
+    return (
+        2,  # estado_n_filtros (volta para 2 filtros padrão)
+        gr.update(visible=True),  # row 0
+        gr.update(visible=True),  # row 1
+        gr.update(visible=False),  # row 2
+        gr.update(visible=False),  # row 3
+        gr.update(value="Resíduo Pad."),  # var 0
+        gr.update(value="Resíduo Pad."),  # var 1
+        gr.update(value="Resíduo Pad."),  # var 2
+        gr.update(value="Resíduo Pad."),  # var 3
+        gr.update(value="<="),  # op 0
+        gr.update(value=">="),  # op 1
+        gr.update(value=">="),  # op 2
+        gr.update(value=">="),  # op 3
+        gr.update(value=-2.0),  # val 0
+        gr.update(value=2.0),  # val 1
+        gr.update(value=0.0),  # val 2
+        gr.update(value=0.0),  # val 3
+        ""  # outliers_texto
+    )
+
+
+# ============================================================
+# ITERAÇÃO DE OUTLIERS
+# ============================================================
+
+def reiniciar_iteracao_callback(df_original, outliers_anteriores, outliers_texto, reincluir_texto, iteracao_atual, coluna_y, colunas_x, dicotomicas, codigo_alocado, percentuais, grau_min_coef=3, grau_min_f=3):
+    """Combina outliers anteriores com novos (excluindo reincluídos), atualiza estado e reinicia análise.
+    Recalcula todas as seções (2 em diante) considerando a ausência dos outliers.
+
+    CONTRACT: Retorna 30 itens para btn_reiniciar_iteracao.click (app.py:criar_aba).
+    Se alterar, atualizar: app.py (outputs de btn_reiniciar_iteracao.click).
+    Consome buscar_transformacoes_callback por destructuring (html, resultados, _, *btns).
+    Consome atualizar_estatisticas_auto por destructuring (stats, timestamp).
+    """
+    # Parse dos novos outliers
+    novos_outliers = []
+    if outliers_texto and outliers_texto.strip():
+        try:
+            novos_outliers = [int(x.strip()) for x in outliers_texto.split(",") if x.strip()]
+        except:
+            pass
+
+    # Parse dos índices a reincluir
+    reincluir = []
+    if reincluir_texto and reincluir_texto.strip():
+        try:
+            reincluir = [int(x.strip()) for x in reincluir_texto.split(",") if x.strip()]
+        except:
+            pass
+
+    # Remove reincluídos dos anteriores, depois combina com novos (sem duplicatas)
+    anteriores_atualizados = [i for i in (outliers_anteriores or []) if i not in reincluir]
+    outliers_combinados = list(set(anteriores_atualizados + novos_outliers))
+    outliers_combinados.sort()
+
+    # Incrementa iteração
+    nova_iteracao = (iteracao_atual or 1) + 1
+
+    # Cria DataFrame filtrado
+    df_filtrado = df_original.copy()
+    if outliers_combinados:
+        df_filtrado = df_filtrado.drop(index=outliers_combinados, errors='ignore')
+
+    # Recalcula estatísticas (seção 5)
+    estatisticas, timestamp = atualizar_estatisticas_auto(df_filtrado, coluna_y, colunas_x)
+
+    # Recalcula micronumerosidade (seção 6)
+    try:
+        resultado_micro = testar_micronumerosidade(df_filtrado, list(colunas_x),
+            dicotomicas=dicotomicas, codigo_alocado=codigo_alocado)
+        html_micro = formatar_micronumerosidade_html(resultado_micro)
+    except Exception as e:
+        html_micro = f"<p style='color: red;'>Erro ao calcular micronumerosidade: {e}</p>"
+
+    # Recalcula gráficos de dispersão originais (seção 7)
+    try:
+        X = df_filtrado[list(colunas_x)]
+        y = df_filtrado[coluna_y]
+        print(f"[reiniciar_iteracao] Criando gráfico dispersão com {len(df_filtrado)} pontos (excluídos: {outliers_combinados})")
+        fig_dispersao = criar_graficos_dispersao(X, y)
+    except Exception as e:
+        print(f"Erro ao gerar gráficos de dispersão: {e}")
+        fig_dispersao = None
+
+    # Recalcula busca de transformações (seção 8)
+    try:
+        busca_html_result, resultados_busca, _, *btn_updates = buscar_transformacoes_callback(
+            df_filtrado, coluna_y, colunas_x, dicotomicas, codigo_alocado, percentuais, int(grau_min_coef), int(grau_min_f)
+        )
+    except Exception as e:
+        busca_html_result = f"<p style='color: red;'>Erro na busca: {e}</p>"
+        resultados_busca = []
+        btn_updates = [gr.update(visible=False) for _ in range(5)]
+
+    # Radio buttons coerentes com os novos resultados
+    if resultados_busca:
+        grau_coef_min = min(
+            min(r.get("graus_coef", {}).values(), default=0)
+            for r in resultados_busca
+        )
+        grau_f_min = min(r.get("grau_f", 0) for r in resultados_busca)
+    else:
+        grau_coef_min = int(grau_min_coef)
+        grau_f_min = int(grau_min_f)
+
+    # Atualiza textos
+    html_outliers_ant = formatar_outliers_anteriores_html(
+        len(outliers_combinados),
+        ", ".join(map(str, outliers_combinados)) if outliers_combinados else ""
+    )
+
+    # Visibilidade do accordion
+    accordion_visivel = len(outliers_combinados) > 0
+
+    # Mapa atualizado
+    mapa_html = criar_mapa(df_filtrado)
+
+    # Header updates com timestamp
+    header_2_update = gr.update(value=criar_header_secao(2, "Visualizar Dados", timestamp))
+    header_5_update = gr.update(value=criar_header_secao(5, "Estatísticas das Variáveis Selecionadas", timestamp))
+    header_6_update = gr.update(value=criar_header_secao(6, "Teste de Micronumerosidade (NBR 14.653-2)", timestamp))
+    header_7_update = gr.update(value=criar_header_secao(7, "Gráficos de Dispersão das Variáveis Independentes", timestamp))
+    header_8_update = gr.update(value=criar_header_secao(8, "Transformações Sugeridas", timestamp))
+
+    return (
+        outliers_combinados,      # estado_outliers_anteriores
+        nova_iteracao,            # estado_iteracao
+        df_filtrado,              # estado_df_filtrado
+        arredondar_df(df_filtrado),     # tabela_dados
+        estatisticas,             # tabela_estatisticas
+        header_5_update,          # header_secao_5
+        html_outliers_ant,        # html_outliers_anteriores
+        html_outliers_ant,        # html_outliers_sec14
+        gr.update(visible=accordion_visivel),  # accordion_outliers_anteriores
+        "",                       # outliers_texto (limpo)
+        "",                       # reincluir_texto (limpo)
+        None,                     # tabela_metricas (limpa)
+        None,                     # estado_metricas (limpo)
+        gr.update(value=criar_header_secao(13, "Analisar Outliers")),  # header_secao_13
+        f"Excluídos: {len(outliers_combinados)} | A excluir: 0 | A reincluir: 0 | Total: {len(outliers_combinados)}",  # txt_resumo_outliers
+        mapa_html,                # mapa_html atualizado
+        # Novos outputs para seções 2, 6, 7, 8
+        header_2_update,          # header_secao_2
+        html_micro,               # html_micronumerosidade
+        header_6_update,          # header_secao_6
+        fig_dispersao,            # plot_dispersao
+        header_7_update,          # header_secao_7
+        busca_html_result,        # busca_html
+        resultados_busca,         # estado_resultados_busca
+        header_8_update,          # header_secao_8
+        *btn_updates,             # botões adotar (5 botões)
+        gr.update(value=grau_coef_min),  # slider_grau_coef
+        gr.update(value=grau_f_min),     # slider_grau_f
+    )
+
+
+def atualizar_resumo_outliers(outliers_anteriores, outliers_texto, reincluir_texto):
+    """Atualiza o resumo de outliers quando o usuário edita os campos."""
+    n_anteriores = len(outliers_anteriores) if outliers_anteriores else 0
+
+    novos_outliers = []
+    if outliers_texto and outliers_texto.strip():
+        try:
+            novos_outliers = [int(x.strip()) for x in outliers_texto.split(",") if x.strip()]
+        except:
+            pass
+
+    reincluir = []
+    if reincluir_texto and reincluir_texto.strip():
+        try:
+            reincluir = [int(x.strip()) for x in reincluir_texto.split(",") if x.strip()]
+        except:
+            pass
+
+    n_novos = len(novos_outliers)
+    n_reincluir = len(reincluir)
+    # Calcula total: anteriores menos reincluídos, mais novos
+    anteriores_atualizados = [i for i in (outliers_anteriores or []) if i not in reincluir]
+    n_total = len(set(anteriores_atualizados + novos_outliers))
+
+    return f"Excluídos: {n_anteriores} | A excluir: {n_novos} | A reincluir: {n_reincluir} | Total: {n_total}"

backend/app/core/visualizacao/app.py

@@ -0,0 +1,1477 @@
+# ============================================================
+# IMPORTAÇÕES
+# ============================================================
+import gradio as gr
+import pandas as pd
+import numpy as np
+import folium
+from folium import plugins
+from joblib import load
+import os
+import re
+import traceback
+
+
+# Importações para gráficos (trazidas de graficos.py)
+from scipy import stats
+import plotly.graph_objects as go
+from statsmodels.stats.outliers_influence import OLSInfluence
+import branca.colormap as cm
+import math
+
+from app.core.elaboracao.core import avaliar_imovel, _migrar_pacote_v1_para_v2, exportar_avaliacoes_excel
+from app.core.elaboracao.formatadores import formatar_avaliacao_html
+
+# ============================================================
+# CONSTANTES
+# ============================================================
+CHAVES_ESPERADAS = ["versao", "dados", "transformacoes", "modelo"]
+
+# Constantes para avaliação
+MAX_VARS_AVAL = 20
+N_COLS_AVAL = 2
+N_ROWS_AVAL = MAX_VARS_AVAL // N_COLS_AVAL  # 10
+
+# Cores consistentes (trazidas de graficos.py)
+COR_PRINCIPAL = '#FF8C00'  # Laranja
+COR_LINHA = '#dc3545'  # Vermelho para linhas de referência
+
+# ============================================================
+# FUNÇÃO: CARREGAR CSS EXTERNO
+# ============================================================
+def carregar_css():
+    """Carrega o arquivo CSS externo."""
+    css_path = os.path.join(os.path.dirname(__file__), "styles.css")
+    try:
+        with open(css_path, "r", encoding="utf-8") as f:
+            return f.read()
+    except FileNotFoundError:
+        print(f"Aviso: Arquivo CSS não encontrado em {css_path}")
+        return ""
+
+# ============================================================
+# LÓGICA DE GERAÇÃO DE GRÁFICOS (ADAPTADA DE GRAFICOS.PY)
+# ============================================================
+
+def _criar_grafico_obs_calc(y_obs, y_calc, indices=None):
+    """Cria gráfico de valores observados vs calculados (Plotly Figure)."""
+    try:
+        fig = go.Figure()
+
+        scatter_args = dict(
+            x=y_calc,
+            y=y_obs,
+            mode='markers',
+            marker=dict(
+                color=COR_PRINCIPAL,
+                size=10,
+                line=dict(color='black', width=1)
+            ),
+            name='Dados',
+        )
+        if indices is not None:
+            scatter_args['customdata'] = indices
+            scatter_args['hovertemplate'] = "<b>Índice:</b> %{customdata}<br><b>Calculado:</b> %{x:.2f}<br><b>Observado:</b> %{y:.2f}<extra></extra>"
+        else:
+            scatter_args['hovertemplate'] = "<b>Calculado:</b> %{x:.2f}<br><b>Observado:</b> %{y:.2f}<extra></extra>"
+
+        # Scatter plot
+        fig.add_trace(go.Scatter(**scatter_args))
+
+        # Linha de identidade (45 graus)
+        min_val = min(min(y_obs), min(y_calc))
+        max_val = max(max(y_obs), max(y_calc))
+        margin = (max_val - min_val) * 0.05
+
+        fig.add_trace(go.Scatter(
+            x=[min_val - margin, max_val + margin],
+            y=[min_val - margin, max_val + margin],
+            mode='lines',
+            line=dict(color=COR_LINHA, dash='dash', width=2),
+            name='Linha de identidade'
+        ))
+
+        fig.update_layout(
+            title=dict(text='Valores Observados vs Calculados', x=0.5),
+            xaxis_title='Valores Calculados',
+            yaxis_title='Valores Observados',
+            showlegend=True,
+            plot_bgcolor='white',
+            margin=dict(l=60, r=40, t=60, b=60)
+        )
+
+        fig.update_xaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
+        fig.update_yaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
+
+        return fig
+    except Exception as e:
+        print(f"Erro ao criar gráfico obs vs calc: {e}")
+        return None
+
+def _criar_grafico_residuos(y_calc, residuos, indices=None):
+    """Cria gráfico de resíduos vs valores ajustados (Plotly Figure)."""
+    try:
+        fig = go.Figure()
+
+        scatter_args = dict(
+            x=y_calc,
+            y=residuos,
+            mode='markers',
+            marker=dict(
+                color=COR_PRINCIPAL,
+                size=10,
+                line=dict(color='black', width=1)
+            ),
+            name='Resíduos',
+        )
+        if indices is not None:
+            scatter_args['customdata'] = indices
+            scatter_args['hovertemplate'] = "<b>Índice:</b> %{customdata}<br><b>Ajustado:</b> %{x:.2f}<br><b>Resíduo:</b> %{y:.4f}<extra></extra>"
+        else:
+            scatter_args['hovertemplate'] = "<b>Ajustado:</b> %{x:.2f}<br><b>Resíduo:</b> %{y:.4f}<extra></extra>"
+
+        fig.add_trace(go.Scatter(**scatter_args))
+
+        fig.add_hline(y=0, line_dash="dash", line_color=COR_LINHA, line_width=2)
+
+        fig.update_layout(
+            title=dict(text='Resíduos vs Valores Ajustados', x=0.5),
+            xaxis_title='Valores Ajustados',
+            yaxis_title='Resíduos',
+            showlegend=False,
+            plot_bgcolor='white',
+            margin=dict(l=60, r=40, t=60, b=60)
+        )
+
+        fig.update_xaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
+        fig.update_yaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
+
+        return fig
+    except Exception as e:
+        print(f"Erro ao criar gráfico de resíduos: {e}")
+        return None
+
+def _criar_histograma_residuos(residuos):
+    """Cria histograma dos resíduos com curva normal (Plotly Figure)."""
+    try:
+        fig = go.Figure()
+
+        fig.add_trace(go.Histogram(
+            x=residuos,
+            histnorm='probability density',
+            marker=dict(color=COR_PRINCIPAL, line=dict(color='black', width=1)),
+            opacity=0.7,
+            name='Resíduos'
+        ))
+
+        mu, sigma = np.mean(residuos), np.std(residuos)
+        x_norm = np.linspace(min(residuos) - sigma, max(residuos) + sigma, 100)
+        y_norm = stats.norm.pdf(x_norm, mu, sigma)
+
+        fig.add_trace(go.Scatter(
+            x=x_norm,
+            y=y_norm,
+            mode='lines',
+            line=dict(color=COR_LINHA, width=3),
+            name='Curva Normal'
+        ))
+
+        fig.update_layout(
+            title=dict(text='Distribuição dos Resíduos', x=0.5),
+            xaxis_title='Resíduos',
+            yaxis_title='Densidade',
+            showlegend=True,
+            plot_bgcolor='white',
+            barmode='overlay',
+            margin=dict(l=60, r=40, t=60, b=60)
+        )
+
+        fig.update_xaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
+        fig.update_yaxes(showgrid=True, gridcolor='lightgray', showline=True, linecolor='black')
+
+        return fig
+    except Exception as e:
+        print(f"Erro ao criar histograma: {e}")
+        return None
+
+
+def _criar_grafico_cook(modelos_sm):
+    """Cria gráfico de Distância de Cook (Plotly Figure)."""
+    try:
+        if modelos_sm is None: return None
+
+        influence = OLSInfluence(modelos_sm)
+        cooks_d = influence.cooks_distance[0]
+
+        n = len(cooks_d)
+        indices = np.arange(1, n + 1)
+        limite = 4 / n
+
+        fig = go.Figure()
+
+        # Hastes (linhas verticais)
+        for idx, valor in zip(indices, cooks_d):
+            cor = COR_LINHA if valor > limite else COR_PRINCIPAL
+            fig.add_trace(
+                go.Scatter(x=[idx, idx],
+                           y=[0, valor],
+                           mode='lines',
+                           line=dict(color=cor, width=1.5),
+                           showlegend=False,
+                           hoverinfo='skip'))
+
+        # Pontos
+        cores_pontos = [
+            COR_LINHA if v > limite else COR_PRINCIPAL for v in cooks_d
+        ]
+        fig.add_trace(
+            go.Scatter(
+                x=indices,
+                y=cooks_d,
+                mode='markers',
+                marker=dict(color=cores_pontos,
+                            size=8,
+                            line=dict(color='black', width=1)),
+                name='Distância de Cook',
+                hovertemplate='Obs: %{x}<br>Cook: %{y:.4f}<extra></extra>'))
+
+        fig.add_hline(y=limite,
+                      line_dash="dash",
+                      line_color='gray',
+                      annotation_text=f"4/n = {limite:.4f}",
+                      annotation_position="top right")
+
+        fig.update_layout(title=dict(text='Distância de Cook', x=0.5),
+                          xaxis_title='Observação',
+                          yaxis_title='Distância de Cook',
+                          plot_bgcolor='white',
+                          margin=dict(l=60, r=40, t=60, b=60))
+
+        fig.update_xaxes(showgrid=True,
+                         gridcolor='lightgray',
+                         showline=True,
+                         linecolor='black')
+        fig.update_yaxes(showgrid=True,
+                         gridcolor='lightgray',
+                         showline=True,
+                         linecolor='black')
+
+        return fig
+    except Exception as e:
+        print(f"Erro ao criar gráfico de Cook: {e}")
+        return None
+
+def _criar_grafico_correlacao(modelos_sm):
+    """Gera heatmap de correlação com cores customizadas e diagonal limpa."""
+    try:
+        if modelos_sm is None or not hasattr(modelos_sm, 'model'):
+            return None
+
+        model = modelos_sm.model
+        X = model.exog
+        X_names = model.exog_names
+        y = model.endog
+        y_name = getattr(model, 'endog_names', 'Variável Dependente')
+
+        df_X = pd.DataFrame(X, columns=X_names)
+        df_X = df_X.drop(
+            columns=[c for c in df_X.columns if str(c).lower() in ('const', 'intercept')],
+            errors='ignore'
+        )
+
+        df_y = pd.DataFrame({y_name: y})
+        df = pd.concat([df_y, df_X], axis=1)
+
+        # garantir numérico
+        df = df.apply(pd.to_numeric, errors='coerce')
+
+        # remover colunas constantes
+        variancias = df.var(ddof=0)
+        df = df.loc[:, variancias.fillna(0) > 0]
+
+        if df.shape[1] < 2:
+            return None
+
+        # ✅ CRIAR corr
+        corr = df.corr()
+
+        if corr.isnull().values.all():
+            return None
+
+        # ✅ remover diagonal (SEM numpy in-place)
+        mask = np.eye(len(corr), dtype=bool)
+        corr = corr.where(~mask)
+
+        # texto
+        text = np.where(
+            np.isnan(corr.values),
+            "",
+            np.round(corr.values, 2).astype(str)
+        )
+
+        fig = go.Figure(go.Heatmap(
+            z=corr.values,
+            x=corr.columns,
+            y=corr.index,
+            text=text,
+            texttemplate="%{text}",
+            textfont=dict(size=10),
+            zmin=-1,
+            zmax=1,
+            zmid=0,
+            colorscale = [
+                [0.00, "rgb(103,0,31)"],
+                [0.08, "rgb(178,24,43)"],
+                [0.16, "rgb(214,96,77)"],
+                [0.24, "rgb(244,165,130)"],
+                [0.32, "rgb(253,219,199)"],
+
+                # faixa branca larga (inalterada)
+                [0.45, "rgb(255,255,255)"],
+                [0.55, "rgb(255,255,255)"],
+
+                [0.68, "rgb(209,229,240)"],
+                [0.76, "rgb(146,197,222)"],
+                [0.84, "rgb(67,147,195)"],
+                [0.92, "rgb(33,102,172)"],
+                [1.00, "rgb(5,48,97)"]
+            ],
+            colorbar=dict(title='Correlação'),
+            hovertemplate="%{x} × %{y}<br>ρ = %{z:.3f}<extra></extra>"
+        ))
+
+        # ✅ diagonal VISUAL (robusta)
+        fig.add_shape(
+            type="line",
+            xref="paper",
+            yref="paper",
+            x0=0, y0=1,
+            x1=1, y1=0,
+            line=dict(color="rgba(0,0,0,0.35)", width=1),
+            layer="above"
+        )
+
+        fig.update_layout(
+            title=dict(text="Matriz de Correlação", x=0.5),
+            height=600,
+            template='plotly_white',
+            xaxis=dict(tickangle=45, showgrid=False),
+            yaxis=dict(autorange='reversed', showgrid=False)
+        )
+
+        return fig
+
+    except Exception as e:
+        print(f"Erro na geração do gráfico: {e}")
+        traceback.print_exc()
+        return None
+
+# def _criar_grafico_correlacao(modelos_sm):
+#     """Gera heatmap de correlação (Plotly Figure)."""
+#     try:
+#         if modelos_sm is None or not hasattr(modelos_sm, 'model'):
+#             return None
+
+#         model = modelos_sm.model
+#         if not hasattr(model, 'exog') or not hasattr(model, 'endog'):
+#             return None
+
+#         X = model.exog
+#         X_names = model.exog_names
+#         y = model.endog
+#         y_name = getattr(model, 'endog_names', 'Variável Dependente')
+
+#         df_X = pd.DataFrame(X, columns=X_names)
+
+#         # Remover constantes explícitas
+#         df_X = df_X.drop(
+#             columns=[c for c in df_X.columns if c.lower() in ('const', 'intercept')],
+#             errors='ignore'
+#         )
+
+#         df_y = pd.DataFrame({y_name: y})
+#         df = pd.concat([df_y, df_X], axis=1)
+
+#         # Remover colunas constantes
+#         variancias = df.var(ddof=0)
+#         df = df.loc[:, variancias.fillna(0) > 0]
+
+#         if df.shape[1] < 2: return None
+
+#         corr = df.corr()
+#         if corr.isnull().values.all(): return None
+
+#         text = np.round(corr.values, 2).astype(str)
+
+#         fig = go.Figure(data=go.Heatmap(
+#             z=corr.values,
+#             x=corr.columns,
+#             y=corr.index,
+#             text=text,
+#             texttemplate="%{text}",
+#             textfont=dict(size=10),
+#             zmin=-1, zmax=1,
+#             colorscale = [
+#                 [0.0,  "rgb(178,24,43)"],   # red
+#                 [0.35, "rgb(178,24,43)"],
+
+#                 [0.45, "rgb(255,255,255)"], # start white
+#                 [0.55, "rgb(255,255,255)"], # end white
+
+#                 [0.65, "rgb(33,102,172)"],
+#                 [1.0,  "rgb(33,102,172)"]   # blue
+#             ],
+#             colorbar=dict(title='Correlação')
+#         ))
+
+#         fig.update_layout(
+#             title=dict(text="Matriz de Correlação", x=0.5),
+#             height=600,
+#             template='plotly_white',
+#             xaxis=dict(tickangle=45, showgrid=False),
+#             yaxis=dict(autorange='reversed', showgrid=True)
+#         )
+
+#         return fig
+#     except Exception:
+#         return None
+
+def gerar_todos_graficos(pacote):
+    """Orquestra a geração de todos os gráficos a partir do pacote."""
+    graficos = {
+        "obs_calc": None,
+        "residuos": None,
+        "hist": None,
+        "cook": None,
+        "corr": None
+    }
+
+    obs_calc = pacote["modelo"]["obs_calc"]
+    modelos_sm = pacote["modelo"]["sm"]
+
+    # Identificar vetores
+    y_obs = None
+    y_calc = None
+    residuos = None
+    indices = None
+
+    # Tenta pegar do DataFrame obs_calc
+    if obs_calc is not None and not obs_calc.empty:
+        cols_lower = {str(c).lower(): c for c in obs_calc.columns}
+
+        # Extrair índices do DataFrame
+        indices = obs_calc.index.values if obs_calc.index is not None else None
+
+        # Encontrar coluna observada
+        for nome in ['observado', 'obs', 'y_obs', 'y', 'valor_observado']:
+            if nome in cols_lower:
+                y_obs = obs_calc[cols_lower[nome]].values
+                break
+
+        # Encontrar coluna calculada
+        for nome in ['calculado', 'calc', 'y_calc', 'y_hat', 'previsto']:
+            if nome in cols_lower:
+                y_calc = obs_calc[cols_lower[nome]].values
+                break
+
+        # Encontrar coluna resíduos
+        for nome in ['residuo', 'residuos', 'resid']:
+            if nome in cols_lower:
+                residuos = obs_calc[cols_lower[nome]].values
+                break
+
+    # Fallback para o objeto statsmodels
+    if modelos_sm is not None:
+        try:
+            if y_obs is None and hasattr(modelos_sm.model, 'endog'):
+                y_obs = modelos_sm.model.endog
+            if y_calc is None and hasattr(modelos_sm, 'fittedvalues'):
+                y_calc = modelos_sm.fittedvalues
+            if residuos is None and hasattr(modelos_sm, 'resid'):
+                residuos = modelos_sm.resid
+        except Exception:
+            pass
+
+    # Cálculo manual se necessário
+    if residuos is None and y_obs is not None and y_calc is not None:
+        residuos = np.array(y_obs) - np.array(y_calc)
+
+    # Converter para numpy
+    y_obs = np.array(y_obs) if y_obs is not None else None
+    y_calc = np.array(y_calc) if y_calc is not None else None
+    residuos = np.array(residuos) if residuos is not None else None
+
+    # Gerar cada gráfico
+    if y_obs is not None and y_calc is not None:
+        graficos["obs_calc"] = _criar_grafico_obs_calc(y_obs, y_calc, indices)
+
+    if residuos is not None and y_calc is not None:
+        graficos["residuos"] = _criar_grafico_residuos(y_calc, residuos, indices)
+
+    if residuos is not None:
+        graficos["hist"] = _criar_histograma_residuos(residuos)
+
+    if modelos_sm is not None:
+        graficos["cook"] = _criar_grafico_cook(modelos_sm)
+        graficos["corr"] = _criar_grafico_correlacao(modelos_sm)
+
+    return graficos
+
+# ============================================================
+# FUNÇÃO: REORGANIZAR DIAGNOSTICOS PARA EXIBIÇÃO
+# ============================================================
+def reorganizar_modelos_resumos(diagnosticos):
+    """
+    Converte diagnosticos v2 (já agrupado) para formato de exibição HTML.
+    """
+    gerais = diagnosticos.get("gerais", {})
+    return {
+        "estatisticas_gerais": {
+            "n": {"nome": "Número de observações", "valor": gerais.get("n")},
+            "k": {"nome": "Número de variáveis independentes", "valor": gerais.get("k")},
+            "desvio_padrao_residuos": {"nome": "Desvio padrão dos resíduos", "valor": gerais.get("desvio_padrao_residuos")},
+            "mse": {"nome": "MSE", "valor": gerais.get("mse")},
+            "r2": {"nome": "R²", "valor": gerais.get("r2")},
+            "r2_ajustado": {"nome": "R² ajustado", "valor": gerais.get("r2_ajustado")},
+            "r_pearson": {"nome": "Correlação Pearson", "valor": gerais.get("r_pearson")}
+        },
+        "teste_f": {
+            "nome": "Teste F",
+            "estatistica": diagnosticos.get("teste_f", {}).get("estatistica"),
+            "pvalor": diagnosticos.get("teste_f", {}).get("p_valor"),
+            "interpretacao": diagnosticos.get("teste_f", {}).get("interpretacao")
+        },
+        "teste_ks": {
+            "nome": "Teste de Normalidade (Kolmogorov-Smirnov)",
+            "estatistica": diagnosticos.get("teste_ks", {}).get("estatistica"),
+            "pvalor": diagnosticos.get("teste_ks", {}).get("p_valor"),
+            "interpretacao": diagnosticos.get("teste_ks", {}).get("interpretacao")
+        },
+        "perc_resid": {
+            "nome": "Teste de Normalidade (Comparação com a Curva Normal)",
+            "valor": diagnosticos.get("teste_normalidade", {}).get("percentuais"),
+            "interpretacao": [
+                "Ideal 68% → aceitável entre 64% e 75%",
+                "Ideal 90% → aceitável entre 88% e 95%",
+                "Ideal 95% → aceitável entre 95% e 100%"
+            ]
+        },
+        "teste_dw": {
+            "nome": "Teste de Autocorrelação (Durbin-Watson)",
+            "estatistica": diagnosticos.get("teste_dw", {}).get("estatistica"),
+            "interpretacao": diagnosticos.get("teste_dw", {}).get("interpretacao")
+        },
+        "teste_bp": {
+            "nome": "Teste de Homocedasticidade (Breusch-Pagan)",
+            "estatistica": diagnosticos.get("teste_bp", {}).get("estatistica"),
+            "pvalor": diagnosticos.get("teste_bp", {}).get("p_valor"),
+            "interpretacao": diagnosticos.get("teste_bp", {}).get("interpretacao")
+        },
+        "equacao": diagnosticos.get("equacao")
+    }
+
+# ============================================================
+# FUNÇÃO: FORMATAR VALOR MONETÁRIO
+# ============================================================
+def formatar_monetario(valor):
+    if pd.isna(valor): return "N/A"
+    return f"R$ {valor:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+
+# ============================================================
+# FUNÇÃO: FORMATAR RESUMO COMO HTML
+# ============================================================
+def formatar_resumo_html(resumo_reorganizado):
+
+    def criar_titulo_secao(titulo):
+        return f'<div class="section-title-orange-solid">{titulo}</div>'
+
+    def criar_linha_campo(campo, valor):
+        return f"""<div class="field-row"><span class="field-row-label">{campo}</span><span class="field-row-value">{valor}</span></div>"""
+
+    def criar_linha_interpretacao(interpretacao):
+        return f"""<div class="field-row"><span class="field-row-label">Interpretação</span><span class="field-row-value-italic">{interpretacao}</span></div>"""
+
+    def formatar_numero(valor, casas_decimais=4):
+        if valor is None: return "N/A"
+        if isinstance(valor, (int, float, np.floating)): return f"{valor:.{casas_decimais}f}"
+        return str(valor)
+
+    linhas_html = []
+
+    # 1. Estatísticas Gerais
+    estat_gerais = resumo_reorganizado.get("estatisticas_gerais", {})
+    if estat_gerais:
+        linhas_html.append(criar_titulo_secao("Estatísticas Gerais"))
+        for chave, dados in estat_gerais.items():
+            linhas_html.append(criar_linha_campo(dados.get("nome", chave), formatar_numero(dados.get("valor"))))
+
+    # 2. Testes (ordem: F, KS, Curva Normal, DW, BP)
+    for chave_teste, label in [("teste_f", "Estatística F"), ("teste_ks", "Estatística KS")]:
+        teste = resumo_reorganizado.get(chave_teste, {})
+        if teste.get("estatistica") is not None:
+            linhas_html.append(criar_titulo_secao(teste.get("nome")))
+            linhas_html.append(criar_linha_campo(label, formatar_numero(teste["estatistica"])))
+            if teste.get("pvalor") is not None:
+                linhas_html.append(criar_linha_campo("P-valor", formatar_numero(teste["pvalor"])))
+            if teste.get("interpretacao"):
+                linhas_html.append(criar_linha_interpretacao(teste["interpretacao"]))
+
+    # Percentuais (Comparação com a Curva Normal — logo após KS)
+    perc_resid = resumo_reorganizado.get("perc_resid", {})
+    if perc_resid.get("valor") is not None:
+        linhas_html.append(criar_titulo_secao(perc_resid.get("nome")))
+        linhas_html.append(criar_linha_campo("Percentuais Atingidos", perc_resid["valor"]))
+        if perc_resid.get("interpretacao"):
+            linhas_html.append('<div class="interpretation-label">Interpretação</div>')
+            for ideal in perc_resid["interpretacao"]:
+                linhas_html.append(f'<div class="interpretation-item">• {ideal}</div>')
+
+    for chave_teste, label in [("teste_dw", "Estatística DW"), ("teste_bp", "Estatística LM")]:
+        teste = resumo_reorganizado.get(chave_teste, {})
+        if teste.get("estatistica") is not None:
+            linhas_html.append(criar_titulo_secao(teste.get("nome")))
+            linhas_html.append(criar_linha_campo(label, formatar_numero(teste["estatistica"])))
+            if teste.get("pvalor") is not None:
+                linhas_html.append(criar_linha_campo("P-valor", formatar_numero(teste["pvalor"])))
+            if teste.get("interpretacao"):
+                linhas_html.append(criar_linha_interpretacao(teste["interpretacao"]))
+
+    # Equação
+    equacao = resumo_reorganizado.get("equacao")
+    if equacao:
+        linhas_html.append(criar_titulo_secao("Equação do Modelo"))
+        linhas_html.append(f'<div class="equation-box">{equacao}</div>')
+
+    return f"""<div class="dai-card scrollable-container">{"".join(linhas_html)}</div>"""
+
+# ============================================================
+# FUNÇÃO: CRIAR TÍTULO DE SEÇÃO ESTILIZADO
+# ============================================================
+def criar_titulo_secao_html(titulo):
+    return f'<div class="section-title-orange">{titulo}</div>'
+
+# ============================================================
+# FUNÇÃO: FORMATAR ESCALAS/TRANSFORMAÇÕES
+# ============================================================
+def formatar_escalas_html(escalas_raw):
+    if isinstance(escalas_raw, pd.DataFrame): itens = escalas_raw.iloc[:, 0].tolist()
+    elif isinstance(escalas_raw, list): itens = escalas_raw
+    else: itens = [str(escalas_raw)]
+
+    itens = [str(item) for item in itens if item and str(item).strip()]
+    if not itens: return "<p style='color: #6c757d; font-style: italic;'>Nenhuma transformação disponível.</p>"
+
+    max_chars = max(len(item) for item in itens)
+    largura_min = max(150, max_chars * 7 + 28)
+    cards_html = ""
+    for item in itens:
+        if ":" in item:
+            partes = item.split(":", 1)
+            conteudo = f"""<span style="font-weight: 600; color: #495057;">{partes[0].strip()}:</span><span style="font-weight: 400; color: #6c757d; margin-left: 4px;">{partes[1].strip()}</span>"""
+        else:
+            conteudo = f"""<span style="font-weight: 600; color: #495057;">{item}</span>"""
+        cards_html += f"""<div class="dai-card-light" style="min-width: {largura_min}px;">{conteudo}</div>"""
+
+    return f"""<div class="dai-card">{criar_titulo_secao_html("Escalas / Transformações")}<div class="dai-cards-grid" style="grid-template-columns: repeat(auto-fill, minmax({largura_min}px, 1fr));">{cards_html}</div></div>"""
+
+# ============================================================
+# FUNÇÃO: GERAR MAPA FOLIUM (com suporte a dimensionamento por variável)
+# ============================================================
+def criar_mapa(df, lat_col="lat", lon_col="lon", cor_col=None, tamanho_col=None, col_y=None):
+    """
+    Cria mapa Folium com os dados, com suporte a dimensionamento proporcional.
+
+    Parâmetros:
+        df: DataFrame com os dados
+        lat_col: nome da coluna de latitude
+        lon_col: nome da coluna de longitude
+        cor_col: coluna para colorir os pontos (opcional)
+        tamanho_col: coluna numérica para dimensionar os círculos (opcional)
+
+    Retorna:
+        HTML do mapa
+    """
+    # Verifica se colunas existem
+    cols_lower = {str(c).lower(): c for c in df.columns}
+
+    lat_real = None
+    lon_real = None
+
+    for nome in ["lat", "latitude", "siat_latitude"]:
+        if nome in cols_lower:
+            lat_real = cols_lower[nome]
+            break
+
+    for nome in ["lon", "longitude", "long", "siat_longitude"]:
+        if nome in cols_lower:
+            lon_real = cols_lower[nome]
+            break
+
+    if lat_real is None or lon_real is None:
+        return "<p>Coordenadas (lat/lon) não encontradas nos dados.</p>"
+
+    # Filtra dados válidos
+    df_mapa = df.dropna(subset=[lat_real, lon_real]).copy()
+    if df_mapa.empty:
+        return "<p>Sem coordenadas válidas para exibir.</p>"
+
+    # Cria mapa
+    centro_lat = df_mapa[lat_real].mean()
+    centro_lon = df_mapa[lon_real].mean()
+
+    m = folium.Map(
+        location=[centro_lat, centro_lon],
+        zoom_start=12,
+        tiles=None
+    )
+
+    # Camadas base
+    folium.TileLayer(tiles="OpenStreetMap", name="OpenStreetMap", control=True).add_to(m)
+    folium.TileLayer(tiles="CartoDB positron", name="Positron", control=True).add_to(m)
+
+    # Se tamanho_col fornecido mas cor_col não, usa mesma variável para cor
+    if tamanho_col and tamanho_col != "Visualização Padrão" and not cor_col:
+        cor_col = tamanho_col
+
+    # Colormap se houver coluna de cor (verde → vermelho)
+    colormap = None
+    if cor_col and cor_col in df_mapa.columns:
+        vmin = df_mapa[cor_col].min()
+        vmax = df_mapa[cor_col].max()
+        colormap = cm.LinearColormap(
+            colors=["#2ecc71", "#a8e06c", "#f1c40f", "#e67e22", "#e74c3c"],
+            vmin=vmin,
+            vmax=vmax,
+            caption=cor_col
+        )
+        colormap.add_to(m)
+
+    # Escala de tamanho proporcional
+    raio_min, raio_max = 3, 18
+    tamanho_func = None
+    if tamanho_col and tamanho_col != "Visualização Padrão" and tamanho_col in df_mapa.columns:
+        t_min = df_mapa[tamanho_col].min()
+        t_max = df_mapa[tamanho_col].max()
+        if t_max > t_min:
+            tamanho_func = lambda v, _min=t_min, _max=t_max: raio_min + (v - _min) / (_max - _min) * (raio_max - raio_min)
+        else:
+            tamanho_func = lambda v: (raio_min + raio_max) / 2
+
+    # Adiciona pontos
+    for idx, row in df_mapa.iterrows():
+        # Cor do ponto
+        if colormap and cor_col:
+            cor = colormap(row[cor_col])
+        else:
+            cor = COR_PRINCIPAL
+
+        # Calcula raio
+        if tamanho_func:
+            raio = tamanho_func(row[tamanho_col])
+        else:
+            raio = 8
+
+        # Popup com informações
+        itens = []
+        for col, val in row.items():
+            if str(col).lower() not in ['lat', 'latitude', 'lon', 'longitude']:
+                col_norm = str(col).lower()
+                if isinstance(val, (int, float, np.floating)):
+                    if any(k in col_norm for k in ["valor", "preco", "vu", "vunit"]):
+                        val_fmt = formatar_monetario(val)
+                    else:
+                        val_fmt = f"{val:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                else:
+                    val_fmt = str(val)
+                itens.append((col, val_fmt))
+
+        MAX_ITENS = 8
+        colunas_html = []
+        for i in range(0, len(itens), MAX_ITENS):
+            chunk = itens[i:i+MAX_ITENS]
+            trs = "".join([f"<tr style='border-bottom: 1px solid #e9ecef;'><td style='padding:4px 8px 4px 0; color:#6c757d; font-weight:500;'>{c}</td><td style='padding:4px 0; text-align:right; color:#495057;'>{v}</td></tr>" for c, v in chunk])
+            style = "border-left: 2px solid #dee2e6; padding-left: 20px;" if i > 0 else ""
+            colunas_html.append(f"<div style='flex: 0 0 auto; {style}'><table style='border-collapse:collapse; font-size:12px;'>{trs}</table></div>")
+
+        popup_html = f"""<div style="font-family:'Segoe UI'; border-radius:8px; overflow:hidden;"><div style="background:#6c757d; color:white; padding:10px 15px; font-weight:600;">Dados do Registro</div><div style="padding:12px 15px; background:#f8f9fa;"><div style="display:flex; gap:20px;">{"".join(colunas_html)}</div></div></div>"""
+
+        # Tooltip (hover): índice + variável selecionada no dropdown (ou dependente como fallback)
+        tooltip_col = (
+            tamanho_col if (tamanho_col and tamanho_col != "Visualização Padrão"
+                            and tamanho_col in df_mapa.columns)
+            else (col_y if col_y and col_y in df_mapa.columns else None)
+        )
+        # Usa coluna "index" (original, gerada pelo reset_index) quando disponível
+        idx_display = int(row["index"]) if "index" in row.index else idx
+        tooltip_html = (
+            "<div style='font-family:\"Segoe UI\",Arial,sans-serif; font-size:14px;"
+            " line-height:1.7; padding:2px 4px;'>"
+            f"<b>Índice {idx_display}</b>"
+        )
+        if tooltip_col and tooltip_col in row.index:
+            val_t = row[tooltip_col]
+            col_norm = str(tooltip_col).lower()
+            if isinstance(val_t, (int, float, np.floating)):
+                if any(k in col_norm for k in ["valor", "preco", "vu", "vunit"]):
+                    val_str = formatar_monetario(val_t)
+                else:
+                    val_str = f"{val_t:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+            else:
+                val_str = str(val_t)
+            tooltip_html += (
+                f"<br><span style='color:#555;'>{tooltip_col}:</span>"
+                f" <b>{val_str}</b>"
+            )
+        tooltip_html += "</div>"
+
+        folium.CircleMarker(
+            location=[row[lat_real], row[lon_real]],
+            radius=raio,
+            popup=folium.Popup(popup_html, max_width=280 * len(colunas_html)),
+            tooltip=folium.Tooltip(tooltip_html, sticky=True),
+            color='black',
+            weight=1,
+            fill=True,
+            fillColor=cor,
+            fillOpacity=0.7
+        ).add_to(m)
+
+    # Controles
+    folium.LayerControl().add_to(m)
+    plugins.Fullscreen().add_to(m)
+    plugins.MeasureControl(
+        primary_length_unit='meters',
+        secondary_length_unit='kilometers',
+        primary_area_unit='sqmeters',
+        secondary_area_unit='hectares'
+    ).add_to(m)
+
+    # Ajusta bounds
+    bounds = [
+        [df_mapa[lat_real].min(), df_mapa[lon_real].min()],
+        [df_mapa[lat_real].max(), df_mapa[lon_real].max()]
+    ]
+    m.fit_bounds(bounds)
+
+    return m._repr_html_()
+
+# ============================================================
+# FUNÇÃO: CARREGAR + VALIDAR MODELO (.dai)
+# ============================================================
+def carregar_modelo_gradio(arquivo):
+    if arquivo is None: return None, "Nenhum arquivo enviado."
+    try:
+        pacote = load(arquivo.name)
+        if not isinstance(pacote, dict): return None, "Arquivo inválido."
+        # Retrocompatibilidade: converte v1 (flat) para v2 (nested)
+        if "versao" not in pacote:
+            pacote = _migrar_pacote_v1_para_v2(pacote)
+        faltantes = [k for k in CHAVES_ESPERADAS if k not in pacote]
+        if faltantes: return None, f"Pacote incompleto. Faltando: {faltantes}"
+        return pacote, f"Modelo carregado: {os.path.basename(arquivo.name)}"
+    except Exception as e: return None, f"Erro: {e}"
+
+# ============================================================
+# FUNÇÃO: DESEMPACOTAR + EXIBIR CONTEÚDO
+# ============================================================
+def exibir_modelo(pacote):
+    # Retorna Nones se pacote vazio. Total de outputs = 14 (+ dropdown choices)
+    if pacote is None:
+        return [None] * 13 + [gr.update(choices=["Visualização Padrão"])]
+
+    # 1. Dados
+    dados = pacote["dados"]["df"].reset_index()
+    for col in dados.columns:
+        if str(col).lower() in ["lat", "lon"]: dados[col] = dados[col].round(6)
+        elif pd.api.types.is_numeric_dtype(dados[col]): dados[col] = dados[col].round(2)
+
+    # 2. Estatísticas
+    estat = pd.DataFrame(pacote["dados"]["estatisticas"])
+    if not isinstance(estat.index, pd.RangeIndex):
+        estat.insert(0, "Variável", estat.index.astype(str))
+        estat = estat.reset_index(drop=True)
+    estat = estat.round(2)
+
+    # 3. Escalas
+    escalas_html = formatar_escalas_html(pacote["transformacoes"]["info"])
+
+    # 4. X e y
+    X = pacote["transformacoes"]["X"].reset_index()
+    y = pacote["transformacoes"]["y"].reset_index()
+    if 'index' in y.columns and 'index' in X.columns: y = y.drop(columns=['index'])
+    df_X_y = pd.concat([X, y], axis=1).loc[:, ~pd.concat([X, y], axis=1).columns.duplicated()].round(2)
+
+    # 5. Resumo
+    resumo_html = formatar_resumo_html(reorganizar_modelos_resumos(pacote["modelo"]["diagnosticos"]))
+
+    # 6. Coeficientes
+    tab_coef = pd.DataFrame(pacote["modelo"]["coeficientes"])
+    if not isinstance(tab_coef.index, pd.RangeIndex):
+        tab_coef.insert(0, "Variável", tab_coef.index.astype(str))
+        tab_coef = tab_coef.reset_index(drop=True)
+    mask = tab_coef["Variável"].str.lower().isin(["intercept", "const", "(intercept)"])
+    if mask.any(): tab_coef = pd.concat([tab_coef[mask], tab_coef[~mask]], ignore_index=True)
+    tab_coef = tab_coef.round(2)
+
+    # 7. Obs x Calc
+    tab_obs_calc = pacote["modelo"]["obs_calc"].reset_index().round(2)
+
+    # 8. Gráficos (GERAÇÃO DINÂMICA)
+    figs_dict = gerar_todos_graficos(pacote)
+
+    # 9. Mapa
+    info_transf = pacote["transformacoes"]["info"]
+    nome_y = info_transf[0].split(": ", 1)[0].strip() if info_transf else None
+    mapa_html = criar_mapa(dados, col_y=nome_y)
+
+    # 10. Dropdown de variáveis para o mapa
+    colunas_numericas = [col for col in dados.select_dtypes(include=[np.number]).columns
+                         if str(col).lower() not in ['lat', 'lon', 'latitude', 'longitude', 'index']]
+    choices_mapa = ["Visualização Padrão"] + colunas_numericas
+
+    return (
+        dados,
+        estat,
+        escalas_html,
+        df_X_y,
+        resumo_html,
+        tab_coef,
+        tab_obs_calc,
+        figs_dict["obs_calc"],  # Plot 1
+        figs_dict["residuos"],  # Plot 2
+        figs_dict["hist"],      # Plot 3
+        figs_dict["cook"],      # Plot 4
+        figs_dict["corr"],      # Plot 5
+        mapa_html,
+        gr.update(choices=choices_mapa, value="Visualização Padrão")  # Dropdown update
+    )
+
+
+def atualizar_mapa_callback(dados, var_mapa, pacote):
+    """Atualiza o mapa quando a variável de dimensionamento é alterada."""
+    if dados is None or dados.empty:
+        return "<p>Carregue dados para ver o mapa.</p>"
+
+    tamanho_col = None if var_mapa == "Visualização Padrão" else var_mapa
+    nome_y = None
+    if pacote:
+        info_transf = pacote["transformacoes"]["info"]
+        nome_y = info_transf[0].split(": ", 1)[0].strip() if info_transf else None
+    return criar_mapa(dados, tamanho_col=tamanho_col, col_y=nome_y)
+
+def popular_inputs_avaliacao(pacote):
+    """Popula campos de avaliação a partir do pacote .dai carregado.
+
+    CONTRACT: Retorna 30 itens (N_ROWS_AVAL + MAX_VARS_AVAL).
+    """
+    rows_hidden = [gr.update(visible=False)] * N_ROWS_AVAL
+    inputs_hidden = [gr.update(visible=False, value=None, label="")] * MAX_VARS_AVAL
+
+    if pacote is None:
+        return (*rows_hidden, *inputs_hidden)
+
+    info_transf = pacote["transformacoes"]["info"]
+    estatisticas = pacote["dados"]["estatisticas"]
+    # Normaliza para string — colunas_x vem de split de strings, mas listas do DAI
+    # podem ter inteiros se o CSV original tinha colunas numéricas (ex: anos 2015, 2016...)
+    dicotomicas = [str(d) for d in (pacote["transformacoes"].get("dicotomicas", []) or [])]
+    codigo_alocado = [str(c) for c in (pacote["transformacoes"].get("codigo_alocado", []) or [])]
+    percentuais = [str(p) for p in (pacote["transformacoes"].get("percentuais", []) or [])]
+
+    colunas_x = []
+    for item in info_transf[1:]:
+        nome_x, _ = item.split(": ", 1)
+        colunas_x.append(nome_x.strip())
+
+    n_vars = len(colunas_x)
+    n_rows_vis = math.ceil(n_vars / N_COLS_AVAL)
+
+    if estatisticas is not None:
+        est = pd.DataFrame(estatisticas)
+        if "Variável" in est.columns:
+            est_idx = est.set_index("Variável")
+        elif not isinstance(est.index, pd.RangeIndex):
+            est_idx = est
+        else:
+            est_idx = pd.DataFrame()
+        # Normaliza index para string (mesmo motivo das listas acima)
+        if not est_idx.empty:
+            est_idx.index = est_idx.index.map(str)
+    else:
+        est_idx = pd.DataFrame()
+
+    rows_updates = [gr.update(visible=(r < n_rows_vis)) for r in range(N_ROWS_AVAL)]
+
+    inputs_updates = []
+    for i in range(MAX_VARS_AVAL):
+        if i < n_vars:
+            col = colunas_x[i]
+            if col in dicotomicas:
+                placeholder = "0 ou 1"
+            elif col in codigo_alocado and col in est_idx.index:
+                min_val = est_idx.loc[col, "Mínimo"]
+                max_val = est_idx.loc[col, "Máximo"]
+                placeholder = f"cód. {int(min_val)} a {int(max_val)}"
+            elif col in percentuais:
+                placeholder = "0 a 1"
+            elif col in est_idx.index:
+                min_val = est_idx.loc[col, "Mínimo"]
+                max_val = est_idx.loc[col, "Máximo"]
+                placeholder = f"{min_val} — {max_val}"
+            else:
+                placeholder = ""
+            inputs_updates.append(gr.update(visible=True, value=None, label=col, placeholder=placeholder, interactive=True))
+        else:
+            inputs_updates.append(gr.update(visible=False, value=None, label="", placeholder=""))
+
+    return (*rows_updates, *inputs_updates)
+
+
+def calcular_avaliacao_viz(pacote, estado_avaliacoes, indice_base_str, *aval_inputs):
+    """Calcula avaliação usando o modelo carregado na aba Visualização.
+
+    CONTRACT: Retorna 3 itens (resultado_html, estado_avaliacoes, dropdown_update).
+    """
+    _err = lambda msg: (msg, estado_avaliacoes or [], gr.update())
+    if pacote is None:
+        return _err("Carregue e exiba um modelo primeiro.")
+
+    info_transf = pacote["transformacoes"]["info"]
+    nome_y, transf_y = info_transf[0].split(": ", 1)
+    transformacao_y = transf_y.strip().replace("(y)", "(x)")
+
+    colunas_x = []
+    transformacoes_x = {}
+    for item in info_transf[1:]:
+        nome_x, transf_x = item.split(": ", 1)
+        nome_x = nome_x.strip()
+        colunas_x.append(nome_x)
+        transformacoes_x[nome_x] = transf_x.strip()
+
+    valores_x = {}
+    for i, col in enumerate(colunas_x):
+        if i >= len(aval_inputs) or aval_inputs[i] is None:
+            return _err("Preencha todos os campos.")
+        valores_x[col] = float(aval_inputs[i])
+
+    # Validar variáveis dicotômicas, código alocado e percentuais ANTES de avaliar
+    dicotomicas = pacote["transformacoes"].get("dicotomicas", [])
+    codigo_alocado = pacote["transformacoes"].get("codigo_alocado", [])
+    percentuais = pacote["transformacoes"].get("percentuais", [])
+    estatisticas_df = pacote["dados"]["estatisticas"]
+    import pandas as pd
+    if isinstance(estatisticas_df, pd.DataFrame):
+        if "Variável" in estatisticas_df.columns:
+            est_idx = estatisticas_df.set_index("Variável")
+        else:
+            est_idx = estatisticas_df
+    else:
+        est_idx = pd.DataFrame()
+
+    for col in colunas_x:
+        val = valores_x[col]
+        if col in (dicotomicas or []):
+            if val not in (0, 0.0, 1, 1.0):
+                return _err(f"<p style='color:red;'><b>Erro:</b> A variável <b>{col}</b> é dicotômica e aceita apenas valores 0 ou 1. "
+                        f"Valor informado: {val}</p>")
+        elif col in (codigo_alocado or []) and col in est_idx.index:
+            min_val = float(est_idx.loc[col, "Mínimo"])
+            max_val = float(est_idx.loc[col, "Máximo"])
+            eh_inteiro = (float(val) == int(float(val)))
+            if not eh_inteiro or val < min_val or val > max_val:
+                return _err(f"<p style='color:red;'><b>Erro:</b> A variável <b>{col}</b> é de código alocado/ajustado e aceita apenas "
+                        f"valores inteiros de {int(min_val)} a {int(max_val)}. Valor informado: {val}</p>")
+        elif col in (percentuais or []):
+            if val < 0 or val > 1:
+                return _err(f"<p style='color:red;'><b>Erro:</b> A variável <b>{col}</b> é percentual e aceita apenas "
+                        f"valores entre 0 e 1. Valor informado: {val}</p>")
+
+    resultado = avaliar_imovel(
+        modelo_sm=pacote["modelo"]["sm"],
+        valores_x=valores_x,
+        colunas_x=colunas_x,
+        transformacoes_x=transformacoes_x,
+        transformacao_y=transformacao_y,
+        estatisticas_df=estatisticas_df,
+        dicotomicas=dicotomicas,
+        codigo_alocado=codigo_alocado,
+        percentuais=percentuais,
+    )
+
+    if resultado is None:
+        return _err("Erro ao calcular avaliação.")
+
+    nova_lista = list(estado_avaliacoes or []) + [resultado]
+    indice_base = int(indice_base_str) - 1 if indice_base_str else 0
+    html = formatar_avaliacao_html(nova_lista, indice_base=indice_base, elem_id_excluir="excluir-aval-viz")
+    choices = [str(i + 1) for i in range(len(nova_lista))]
+    base_val = indice_base_str if indice_base_str else "1"
+    return html, nova_lista, gr.update(choices=choices, value=base_val)
+
+
+def excluir_avaliacao_viz(indice_str, estado_avaliacoes, indice_base_str):
+    """Exclui uma avaliação (Visualização).
+
+    CONTRACT: Retorna 4 itens (resultado_html, estado_avaliacoes, dropdown_update, trigger_reset).
+    """
+    if not indice_str or not indice_str.strip() or not estado_avaliacoes:
+        return gr.update(), estado_avaliacoes or [], gr.update(), ""
+    try:
+        idx = int(indice_str.strip()) - 1
+    except ValueError:
+        return gr.update(), estado_avaliacoes or [], gr.update(), ""
+    if idx < 0 or idx >= len(estado_avaliacoes):
+        return gr.update(), estado_avaliacoes or [], gr.update(), ""
+
+    nova_lista = [a for i, a in enumerate(estado_avaliacoes) if i != idx]
+    if not nova_lista:
+        return "", [], gr.update(choices=[], value=None), ""
+
+    base = int(indice_base_str) - 1 if indice_base_str else 0
+    if base >= len(nova_lista):
+        base = len(nova_lista) - 1
+    if base < 0:
+        base = 0
+
+    choices = [str(i + 1) for i in range(len(nova_lista))]
+    html = formatar_avaliacao_html(nova_lista, indice_base=base, elem_id_excluir="excluir-aval-viz")
+    return html, nova_lista, gr.update(choices=choices, value=str(base + 1)), ""
+
+
+def atualizar_base_avaliacao_viz(estado_avaliacoes, indice_base_str):
+    """Re-renderiza HTML quando o dropdown de base muda (Visualização)."""
+    if not estado_avaliacoes:
+        return ""
+    indice = int(indice_base_str) - 1 if indice_base_str else 0
+    return formatar_avaliacao_html(estado_avaliacoes, indice_base=indice, elem_id_excluir="excluir-aval-viz")
+
+
+def exportar_avaliacoes_excel_viz(estado_avaliacoes):
+    """Exporta avaliações para Excel (Visualização)."""
+    if not estado_avaliacoes:
+        return gr.update(value=None, visible=False)
+    caminho = exportar_avaliacoes_excel(estado_avaliacoes)
+    if caminho:
+        return gr.update(value=caminho, visible=True)
+    return gr.update(value=None, visible=False)
+
+
+def _formatar_badge_completo(pacote):
+    """Retorna HTML do badge combinado: elaborador (esquerda) + variáveis (direita) com flex space-between."""
+    if not pacote:
+        return ""
+
+    # --- Lado direito: lista de variáveis ---
+    variaveis_html = ""
+    info = pacote.get("transformacoes", {}).get("info")
+    if info:
+        y_str = info[0]
+        y_parts = y_str.split(": ", 1)
+        y_nome = y_parts[0].strip()
+        y_transf = y_parts[1].strip() if len(y_parts) > 1 else ""
+        y_transf_display = "" if y_transf in ("(y)", "(x)", "y", "x", "") else y_transf
+        y_badge = (
+            "<span style='background:#cce5ff;color:#004085;border-radius:4px;"
+            f"padding:3px 10px;font-size:1em;font-weight:600;'>{y_nome}"
+            + (f" <span style='font-weight:400;font-size:0.85em;'>{y_transf_display}</span>"
+               if y_transf_display else "")
+            + "</span>"
+        )
+        x_badges = []
+        for item in info[1:]:
+            parts = item.split(": ", 1)
+            nome = parts[0].strip()
+            transf = parts[1].strip() if len(parts) > 1 else ""
+            transf_display = "" if transf in ("(x)", "(y)", "x", "y", "") else transf
+            badge = (
+                "<span style='background:#ced4da;color:#343a40;border-radius:4px;"
+                f"padding:3px 8px;font-size:1em;display:inline-block;margin:2px 3px 2px 0;'>{nome}"
+                + (f" <span style='color:#6c757d;font-size:1em;'>{transf_display}</span>"
+                   if transf_display else "")
+                + "</span>"
+            )
+            x_badges.append(badge)
+        variaveis_html = (
+            "<div style='font-size:0.9em;line-height:2;'>"
+            "<div><span style='font-weight:600;color:#495057;margin-right:8px;font-size:1.1em;'>Variável Dependente:</span>"
+            + y_badge + "</div>"
+            "<div style='margin-top:4px;'>"
+            "<span style='font-weight:600;color:#495057;margin-right:8px;font-size:1.1em;'>Variáveis Independentes:</span>"
+            + "".join(x_badges) + "</div>"
+            "</div>"
+        )
+
+    # --- Lado esquerdo: elaborador ---
+    elaborador = pacote.get("elaborador")
+    nome = elaborador.get("nome_completo", "") if elaborador else ""
+    if not nome:
+        # Sem elaborador: só exibe variáveis (sem flex desnecessário)
+        if not variaveis_html:
+            return ""
+        return (
+            '<div style="background:#e9ecef; border-left:5px solid #6c757d; border-radius:6px; '
+            'padding:14px 18px; margin-top:8px;">'
+            + variaveis_html
+            + '</div>'
+        )
+
+    cargo = elaborador.get("cargo", "")
+    conselho = elaborador.get("conselho", "")
+    num = elaborador.get("numero_conselho", "")
+    estado = elaborador.get("estado_conselho", "")
+    matricula = elaborador.get("matricula_sem_digito", "")
+    lotacao = elaborador.get("lotacao", "")
+    linha2 = f"{cargo} · {conselho}/{estado} {num}".strip(" ·") if cargo else ""
+    linha3 = f"Matrícula: {matricula} · {lotacao}".strip(" ·") if matricula else ""
+
+    elab_html = (
+        '<div style="line-height:1.8;">'
+        f'<span style="display:block; font-size:1.05em; font-weight:600; color:#212529; margin-bottom:4px;">{nome}</span>'
+        + (f'<span style="display:block; font-size:0.95em;">{linha2}</span>' if linha2 else '')
+        + (f'<span style="display:block; font-size:0.9em; color:#6c757d;">{linha3}</span>' if linha3 else '')
+        + '</div>'
+    )
+
+    return (
+        '<div style="background:#e9ecef; border-left:5px solid #6c757d; border-radius:6px; '
+        'padding:14px 18px; color:#495057; margin-top:8px; display:flex; '
+        'justify-content:space-between; align-items:flex-start; gap:24px;">'
+        + elab_html
+        + (f'<div>{variaveis_html}</div>' if variaveis_html else '')
+        + '</div>'
+    )
+
+
+def limpar_tudo():
+    return (
+        None, "", None, None, None, "", None, "", None, None,
+        None, None, None, None, None, # 5 gráficos nulos
+        "", None,
+        gr.update(choices=["Visualização Padrão"], value="Visualização Padrão"),  # Dropdown reset
+        # Reset avaliação
+        *[gr.update(visible=False) for _ in range(N_ROWS_AVAL)],
+        *[gr.update(visible=False, value=None, label="") for _ in range(MAX_VARS_AVAL)],
+        "",  # resultado_aval_html
+        [],  # estado_avaliacoes
+        gr.update(choices=[], value=None),  # dropdown_base_aval
+        "",  # excluir_aval_trigger_viz
+        gr.update(value=None, visible=False),  # download_aval_file
+        "",  # elaborador_badge
+    )
+
+# ============================================================
+# INTERFACE GRADIO
+# ============================================================
+
+description = f"""
+# <p style="text-align: center;">MODELOS ESTATÍSTICOS</p>
+<p style="text-align: center;">Divisão de Avaliação de Imóveis</p>
+<hr style="color: #333; background-color: #333; height: 1px; border: none;">
+"""
+
+def criar_aba():
+    """Cria conteúdo da aba de visualização (sem wrapper gr.Blocks)."""
+    # --------------------------------------------------------
+    # ESTADO
+    # --------------------------------------------------------
+    estado_pacote = gr.State(None)
+    estado_dados = gr.State(None)  # Armazena os dados para atualizar o mapa
+
+    # --------------------------------------------------------
+    # CONTROLES (TOPO)
+    # --------------------------------------------------------
+    with gr.Group(elem_classes="upload-area"):
+        upload = gr.File(label="Enviar modelo salvo (.dai)", file_types=[".dai"], scale=1)
+        with gr.Row(equal_height=True):
+            status = gr.Textbox(show_label=False, interactive=False, scale=4, lines=1)
+        elaborador_badge = gr.HTML("")
+        with gr.Row(equal_height=True):
+            btn_exibir = gr.Button("Exibir modelo", scale=2, variant="primary")
+            btn_limpar = gr.Button("Limpar tudo", scale=1, variant="secondary")
+
+    # --------------------------------------------------------
+    # MAPA (RETRÁTIL VIA ACCORDION)
+    # --------------------------------------------------------
+    with gr.Accordion("Mapa de Distribuição dos Dados", open=True, elem_classes="map-accordion"):
+        dropdown_mapa_var = gr.Dropdown(
+            label="Variável para dimensionar pontos no mapa",
+            choices=["Visualização Padrão"],
+            value="Visualização Padrão",
+            interactive=True,
+            allow_custom_value=False
+        )
+        out_mapa = gr.HTML(label="", elem_id="map-frame")
+
+    # --------------------------------------------------------
+    # CONTEÚDO (LARGURA TOTAL)
+    # --------------------------------------------------------
+    with gr.Column(elem_classes="content-panel"):
+            with gr.Tabs(elem_classes="tabs-container"):
+                with gr.Tab("Dados"):
+                    gr.HTML(criar_titulo_secao_html("Dados Utilizados"))
+                    out_dados = gr.Dataframe(show_label=False, max_height=300)
+                    gr.HTML(criar_titulo_secao_html("Estatísticas"))
+                    out_estat = gr.Dataframe(show_label=False, max_height=300)
+
+                with gr.Tab("Transformações"):
+                    out_escalas = gr.HTML()
+                    gr.HTML(criar_titulo_secao_html("X e y Transformados"))
+                    out_df_xy = gr.Dataframe(show_label=False, max_height=400)
+
+                with gr.Tab("Resumo"):
+                    out_resumo = gr.HTML()
+
+                with gr.Tab("Coeficientes"):
+                    gr.HTML(criar_titulo_secao_html("Tabela de Coeficientes"))
+                    out_coef = gr.Dataframe(show_label=False, max_height=700)
+
+                with gr.Tab("Obs x Calc"):
+                    gr.HTML(criar_titulo_secao_html("Tabela Obs x Calc"))
+                    out_obs = gr.Dataframe(show_label=False, max_height=600)
+
+                with gr.Tab("Gráficos") as tab_graficos:
+                    with gr.Group():
+                        # Linha 1 — dois gráficos, 50% / 50%
+                        with gr.Row():
+                            out_plot_obs = gr.Plot(label="Obs vs Calc")
+                            out_plot_res = gr.Plot(label="Resíduos vs Ajustados")
+
+                        # Linha 2 — dois gráficos, 50% / 50%
+                        with gr.Row():
+                            out_plot_hist = gr.Plot(label="Histograma Resíduos")
+                            out_plot_cook = gr.Plot(label="Distância de Cook")
+
+                        # Linha 3 — gráfico sozinho, largura máxima
+                        with gr.Row():
+                            out_plot_corr = gr.Plot(label="Correlação")
+
+                with gr.Tab("Avaliação"):
+                    gr.HTML(criar_titulo_secao_html("Avaliação Individual"))
+                    aval_rows = []
+                    aval_inputs = []
+                    with gr.Column(elem_classes="aval-all-cards"):
+                        for _i_row in range(N_ROWS_AVAL):
+                            with gr.Row(visible=False, elem_classes="aval-cards-row") as _aval_row:
+                                for _j_col in range(N_COLS_AVAL):
+                                    _inp = gr.Number(label="", visible=False, interactive=True, elem_classes="aval-card")
+                                    aval_inputs.append(_inp)
+                            aval_rows.append(_aval_row)
+                    with gr.Row():
+                        btn_calcular_aval = gr.Button("Calcular", variant="primary", scale=2)
+                        btn_limpar_aval = gr.Button("Limpar", variant="secondary", scale=1)
+                        dropdown_base_aval = gr.Dropdown(
+                            label="Base p/ comparação",
+                            choices=[],
+                            value=None,
+                            interactive=True,
+                            scale=1,
+                        )
+                    resultado_aval_html = gr.HTML("")
+                    excluir_aval_trigger_viz = gr.Textbox(
+                        label="", elem_id="excluir-aval-viz", container=False,
+                        elem_classes="trigger-hidden"
+                    )
+                    estado_avaliacoes = gr.State([])
+                    with gr.Row():
+                        btn_exportar_aval = gr.Button("Salvar Avaliações em Excel", variant="secondary")
+                        download_aval_file = gr.File(label="", visible=False)
+
+                with gr.Tab("Avaliação em Massa"):
+                    gr.HTML(criar_titulo_secao_html("Avaliação em Lote"))
+                    gr.HTML("""<div class="placeholder-alert"><p>Módulo em desenvolvimento</p></div>""")
+
+    # --------------------------------------------------------
+    # EVENTOS
+    # --------------------------------------------------------
+    upload.upload(
+        carregar_modelo_gradio, inputs=upload, outputs=[estado_pacote, status]
+    ).then(
+        _formatar_badge_completo, inputs=estado_pacote, outputs=elaborador_badge
+    )
+
+    btn_exibir.click(
+        exibir_modelo,
+        inputs=estado_pacote,
+        outputs=[
+            out_dados, out_estat, out_escalas, out_df_xy, out_resumo, out_coef, out_obs,
+            out_plot_obs, out_plot_res, out_plot_hist, out_plot_cook, out_plot_corr,
+            out_mapa, dropdown_mapa_var
+        ],
+    ).then(
+        popular_inputs_avaliacao,
+        inputs=estado_pacote,
+        outputs=aval_rows + aval_inputs
+    ).then(
+        lambda x: x,  # Copia out_dados para estado_dados
+        inputs=out_dados,
+        outputs=estado_dados
+    )
+
+    # Atualiza mapa quando dropdown muda
+    dropdown_mapa_var.change(
+        atualizar_mapa_callback,
+        inputs=[estado_dados, dropdown_mapa_var, estado_pacote],
+        outputs=out_mapa
+    )
+
+    btn_limpar.click(
+        limpar_tudo,
+        outputs=[
+            estado_pacote, status, upload,
+            out_dados, out_estat, out_escalas, out_df_xy, out_resumo, out_coef, out_obs,
+            out_plot_obs, out_plot_res, out_plot_hist, out_plot_cook, out_plot_corr,
+            out_mapa, estado_dados,
+            dropdown_mapa_var,
+        ] + aval_rows + aval_inputs + [resultado_aval_html, estado_avaliacoes,
+            dropdown_base_aval, excluir_aval_trigger_viz, download_aval_file,
+            elaborador_badge]
+    )
+
+    # Avaliação individual
+    btn_calcular_aval.click(
+        calcular_avaliacao_viz,
+        inputs=[estado_pacote, estado_avaliacoes, dropdown_base_aval] + aval_inputs,
+        outputs=[resultado_aval_html, estado_avaliacoes, dropdown_base_aval]
+    )
+
+    btn_limpar_aval.click(
+        lambda: ("", [], gr.update(choices=[], value=None)),
+        outputs=[resultado_aval_html, estado_avaliacoes, dropdown_base_aval]
+    )
+
+    excluir_aval_trigger_viz.change(
+        excluir_avaliacao_viz,
+        inputs=[excluir_aval_trigger_viz, estado_avaliacoes, dropdown_base_aval],
+        outputs=[resultado_aval_html, estado_avaliacoes, dropdown_base_aval, excluir_aval_trigger_viz]
+    )
+
+    dropdown_base_aval.change(
+        atualizar_base_avaliacao_viz,
+        inputs=[estado_avaliacoes, dropdown_base_aval],
+        outputs=[resultado_aval_html]
+    )
+
+    btn_exportar_aval.click(
+        exportar_avaliacoes_excel_viz,
+        inputs=[estado_avaliacoes],
+        outputs=[download_aval_file]
+    )
+
+    # Força Plotly a recalcular tamanho quando a tab Gráficos é selecionada
+    tab_graficos.select(
+        fn=None,
+        inputs=None,
+        outputs=None,
+        js="() => { setTimeout(() => window.dispatchEvent(new Event('resize')), 100) }"
+    )
+
+
+# ============================================================
+# EXECUÇÃO
+# ============================================================
+if __name__ == "__main__":
+    custom_css = carregar_css()
+    with gr.Blocks(css=custom_css) as app:
+        gr.Markdown(description)
+        criar_aba()
+    app.launch()

backend/app/main.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from app.api import elaboracao, health, session, visualizacao
+
+
+app = FastAPI(
+    title="MESA Frame API",
+    version="1.0.0",
+    description="Backend FastAPI para o app MESA (Elaboracao + Visualizacao)",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(health.router)
+app.include_router(session.router)
+app.include_router(elaboracao.router)
+app.include_router(visualizacao.router)
+
+
+def _mount_frontend_if_exists() -> None:
+    frontend_dist = Path(__file__).resolve().parents[2] / "frontend" / "dist"
+    index_file = frontend_dist / "index.html"
+    if not index_file.exists():
+        return
+
+    app.mount("/assets", StaticFiles(directory=frontend_dist / "assets"), name="assets")
+
+    @app.get("/{full_path:path}", include_in_schema=False)
+    def serve_spa(full_path: str) -> FileResponse:
+        return FileResponse(index_file)
+
+
+_mount_frontend_if_exists()

backend/app/models/__init__.py

@@ -0,0 +1 @@
+# Models package

backend/app/models/session.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+
+@dataclass
+class SessionState:
+    session_id: str
+    workdir: Path
+
+    uploaded_file_path: str | None = None
+    uploaded_filename: str | None = None
+    available_sheets: list[str] = field(default_factory=list)
+
+    df_original: pd.DataFrame | None = None
+    df_filtrado: pd.DataFrame | None = None
+
+    coluna_y: str | None = None
+    colunas_x: list[str] = field(default_factory=list)
+    dicotomicas: list[str] = field(default_factory=list)
+    codigo_alocado: list[str] = field(default_factory=list)
+    percentuais: list[str] = field(default_factory=list)
+
+    transformacao_y: str = "(x)"
+    transformacoes_x: dict[str, str] = field(default_factory=dict)
+
+    resultados_busca: list[dict[str, Any]] = field(default_factory=list)
+    resultado_modelo: dict[str, Any] | None = None
+
+    tabela_estatisticas: pd.DataFrame | None = None
+    tabela_metricas_estado: pd.DataFrame | None = None
+
+    outliers_anteriores: list[int] = field(default_factory=list)
+    iteracao: int = 1
+
+    avaliacoes_elaboracao: list[dict[str, Any]] = field(default_factory=list)
+
+    geo_falhas_df: pd.DataFrame | None = None
+    geo_col_cdlog: str | None = None
+    geo_col_num: str | None = None
+
+    pacote_visualizacao: dict[str, Any] | None = None
+    dados_visualizacao: pd.DataFrame | None = None
+    avaliacoes_visualizacao: list[dict[str, Any]] = field(default_factory=list)
+
+    elaborador: dict[str, Any] | None = None
+
+    def reset_modelo(self) -> None:
+        self.resultados_busca = []
+        self.resultado_modelo = None
+        self.tabela_estatisticas = None
+        self.tabela_metricas_estado = None
+        self.avaliacoes_elaboracao = []
+        self.transformacao_y = "(x)"
+        self.transformacoes_x = {}
+
+    def reset_visualizacao(self) -> None:
+        self.pacote_visualizacao = None
+        self.dados_visualizacao = None
+        self.avaliacoes_visualizacao = []

backend/app/services/__init__.py

@@ -0,0 +1 @@
+# Service layer package

backend/app/services/elaboracao_service.py

@@ -0,0 +1,1124 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from fastapi import HTTPException
+
+from app.core.elaboracao import charts, geocodificacao
+from app.core.elaboracao.core import (
+    TRANSFORMACOES,
+    ajustar_modelo,
+    buscar_melhores_transformacoes,
+    calcular_estatisticas_variaveis,
+    carregar_arquivo,
+    carregar_dai,
+    detectar_abas_excel,
+    detectar_codigo_alocado,
+    detectar_dicotomicas,
+    detectar_percentuais,
+    exportar_avaliacoes_excel,
+    exportar_base_csv,
+    exportar_modelo_dai,
+    identificar_coluna_y_padrao,
+    obter_colunas_numericas,
+    avaliar_imovel,
+    testar_micronumerosidade,
+    verificar_multicolinearidade,
+)
+from app.core.elaboracao.formatadores import (
+    formatar_avaliacao_html,
+    formatar_aviso_multicolinearidade,
+    formatar_busca_html,
+    formatar_diagnosticos_html,
+    formatar_micronumerosidade_html,
+    formatar_outliers_anteriores_html,
+)
+from app.models.session import SessionState
+from app.services.serializers import dataframe_to_payload, figure_to_payload, sanitize_value
+
+_AVALIADORES_PATH = Path(__file__).resolve().parent.parent / "core" / "elaboracao" / "avaliadores.json"
+_AVALIADORES_CACHE: list[dict[str, Any]] | None = None
+
+
+def list_avaliadores() -> list[dict[str, Any]]:
+    global _AVALIADORES_CACHE
+    if _AVALIADORES_CACHE is not None:
+        return _AVALIADORES_CACHE
+
+    try:
+        raw = json.loads(_AVALIADORES_PATH.read_text(encoding="utf-8"))
+        avaliadores = raw.get("avaliadores", [])
+        if isinstance(avaliadores, list):
+            _AVALIADORES_CACHE = [sanitize_value(item) for item in avaliadores if isinstance(item, dict)]
+        else:
+            _AVALIADORES_CACHE = []
+    except Exception:
+        _AVALIADORES_CACHE = []
+
+    return _AVALIADORES_CACHE
+
+
+def _clean_int_list(values: list[Any] | None) -> list[int]:
+    if not values:
+        return []
+    out: list[int] = []
+    for value in values:
+        try:
+            out.append(int(value))
+        except Exception:
+            continue
+    return sorted(set(out))
+
+
+def _parse_indices_text(text: str | None) -> list[int]:
+    if not text:
+        return []
+    items = [piece.strip() for piece in text.split(",") if piece.strip()]
+    out: list[int] = []
+    for item in items:
+        try:
+            out.append(int(item))
+        except Exception:
+            continue
+    return sorted(set(out))
+
+
+def _selection_context(session: SessionState) -> dict[str, Any]:
+    return {
+        "coluna_y": session.coluna_y,
+        "colunas_x": list(session.colunas_x),
+        "dicotomicas": list(session.dicotomicas),
+        "codigo_alocado": list(session.codigo_alocado),
+        "percentuais": list(session.percentuais),
+        "outliers_anteriores": list(session.outliers_anteriores),
+    }
+
+
+def classificar_tipos_variaveis_x(session: SessionState, colunas_x: list[str] | None) -> dict[str, Any]:
+    df = session.df_original if session.df_original is not None else session.df_filtrado
+    if df is None:
+        raise HTTPException(status_code=400, detail="Carregue uma base antes de classificar as variaveis X")
+
+    coluna_y = str(session.coluna_y) if session.coluna_y else None
+    colunas_validas: list[str] = []
+    for col in colunas_x or []:
+        nome = str(col)
+        if nome not in df.columns:
+            continue
+        if coluna_y and nome == coluna_y:
+            continue
+        colunas_validas.append(nome)
+
+    if not colunas_validas:
+        session.dicotomicas = []
+        session.codigo_alocado = []
+        session.percentuais = []
+        return {
+            "dicotomicas": [],
+            "codigo_alocado": [],
+            "percentuais": [],
+        }
+
+    dicotomicas = detectar_dicotomicas(df, colunas_validas)
+    codigo_alocado = detectar_codigo_alocado(df, colunas_validas)
+    percentuais = detectar_percentuais(df, colunas_validas)
+
+    session.dicotomicas = list(dicotomicas)
+    session.codigo_alocado = list(codigo_alocado)
+    session.percentuais = list(percentuais)
+
+    return {
+        "dicotomicas": sanitize_value(dicotomicas),
+        "codigo_alocado": sanitize_value(codigo_alocado),
+        "percentuais": sanitize_value(percentuais),
+    }
+
+
+def _build_coords_payload(df: pd.DataFrame, tem_coords: bool) -> dict[str, Any]:
+    todas_colunas = [str(c) for c in df.columns]
+    if tem_coords:
+        return {
+            "tem_coords": True,
+            "aviso_html": "",
+            "colunas_disponiveis": [],
+            "cdlog_auto": None,
+            "num_auto": None,
+        }
+
+    cdlog_auto, num_auto = geocodificacao.auto_detectar_colunas_geo(df)
+    aviso_html = (
+        '<div style="background:#f8d7da;border:1px solid #f5c2c7;border-radius:8px;'
+        f'padding:10px 14px;margin-bottom:8px"><strong>Colunas lat/lon nao encontradas</strong> — {len(df)} registro(s).'
+        "</div>"
+    )
+    return {
+        "tem_coords": False,
+        "aviso_html": aviso_html,
+        "colunas_disponiveis": todas_colunas,
+        "cdlog_auto": cdlog_auto,
+        "num_auto": num_auto,
+    }
+
+
+def _set_dataframe_base(session: SessionState, df: pd.DataFrame, clear_models: bool = True) -> dict[str, Any]:
+    tem_coords, col_lat, col_lon = geocodificacao.verificar_coords(df)
+    if tem_coords and col_lat and col_lon:
+        df = geocodificacao.padronizar_coords(df, col_lat, col_lon)
+
+    session.df_original = df.copy()
+    session.df_filtrado = df.copy()
+    session.geo_falhas_df = None
+    session.geo_col_cdlog = None
+    session.geo_col_num = None
+
+    if clear_models:
+        session.reset_modelo()
+        session.coluna_y = None
+        session.colunas_x = []
+        session.dicotomicas = []
+        session.codigo_alocado = []
+        session.percentuais = []
+        session.outliers_anteriores = []
+        session.iteracao = 1
+
+    colunas_numericas = [str(c) for c in obter_colunas_numericas(df)]
+    coluna_y_padrao = identificar_coluna_y_padrao(df)
+    mapa_html = charts.criar_mapa(df)
+
+    return {
+        "dados": dataframe_to_payload(df, decimals=4),
+        "mapa_html": mapa_html,
+        "colunas_numericas": colunas_numericas,
+        "coluna_y_padrao": coluna_y_padrao,
+        "coords": _build_coords_payload(df, tem_coords),
+    }
+
+
+def save_uploaded_file(session: SessionState, filename: str, content: bytes) -> str:
+    safe_name = os.path.basename(filename)
+    destino = session.workdir / safe_name
+    destino.write_bytes(content)
+    session.uploaded_file_path = str(destino)
+    session.uploaded_filename = safe_name
+    return str(destino)
+
+
+def load_uploaded_file(session: SessionState, selected_sheet: str | None = None) -> dict[str, Any]:
+    if not session.uploaded_file_path:
+        raise HTTPException(status_code=400, detail="Nenhum arquivo enviado")
+
+    caminho = session.uploaded_file_path
+    ext = Path(caminho).suffix.lower()
+
+    if ext == ".dai":
+        return load_dai_for_elaboracao(session, caminho)
+
+    abas, msg_abas, sucesso_abas = detectar_abas_excel(caminho)
+    if sucesso_abas and len(abas) > 1 and selected_sheet is None:
+        session.available_sheets = abas
+        return {
+            "status": msg_abas,
+            "requires_sheet": True,
+            "sheets": abas,
+            "sheet_selected": abas[0],
+        }
+
+    df, msg, sucesso = carregar_arquivo(caminho, selected_sheet)
+    if not sucesso or df is None:
+        raise HTTPException(status_code=400, detail=msg)
+
+    base = _set_dataframe_base(session, df, clear_models=True)
+    return {
+        "status": msg,
+        "requires_sheet": False,
+        "sheets": [],
+        **base,
+        "contexto": _selection_context(session),
+    }
+
+
+def load_dai_for_elaboracao(session: SessionState, caminho_arquivo: str) -> dict[str, Any]:
+    (
+        df,
+        coluna_y,
+        colunas_x,
+        transformacao_y,
+        transformacoes_x,
+        dicotomicas,
+        codigo_alocado,
+        percentuais,
+        msg,
+        sucesso,
+        elaborador,
+        outliers_excluidos,
+    ) = carregar_dai(caminho_arquivo)
+
+    if not sucesso or df is None:
+        raise HTTPException(status_code=400, detail=msg)
+
+    session.elaborador = elaborador
+    session.outliers_anteriores = _clean_int_list(outliers_excluidos)
+
+    base = _set_dataframe_base(session, df, clear_models=True)
+
+    selection_payload = apply_selection(
+        session,
+        coluna_y=coluna_y,
+        colunas_x=[str(c) for c in colunas_x],
+        dicotomicas=[str(c) for c in (dicotomicas or [])],
+        codigo_alocado=[str(c) for c in (codigo_alocado or [])],
+        percentuais=[str(c) for c in (percentuais or [])],
+        outliers_anteriores=session.outliers_anteriores,
+        grau_min_coef=1,
+        grau_min_f=0,
+    )
+
+    fit_payload = fit_model(
+        session,
+        transformacao_y=transformacao_y,
+        transformacoes_x={str(k): str(v) for k, v in (transformacoes_x or {}).items()},
+        dicotomicas=[str(c) for c in (dicotomicas or [])],
+        codigo_alocado=[str(c) for c in (codigo_alocado or [])],
+        percentuais=[str(c) for c in (percentuais or [])],
+    )
+
+    html_outliers = ""
+    if session.outliers_anteriores:
+        lista = ", ".join(str(v) for v in session.outliers_anteriores)
+        html_outliers = formatar_outliers_anteriores_html(len(session.outliers_anteriores), lista)
+
+    return {
+        "status": msg,
+        "tipo": "dai",
+        **base,
+        "selection": selection_payload,
+        "fit": fit_payload,
+        "outliers_html": html_outliers,
+        "contexto": _selection_context(session),
+        "elaborador": sanitize_value(elaborador),
+    }
+
+
+def apply_selection(
+    session: SessionState,
+    coluna_y: str,
+    colunas_x: list[str],
+    dicotomicas: list[str] | None = None,
+    codigo_alocado: list[str] | None = None,
+    percentuais: list[str] | None = None,
+    outliers_anteriores: list[int] | None = None,
+    grau_min_coef: int = 1,
+    grau_min_f: int = 0,
+) -> dict[str, Any]:
+    df = session.df_original
+    if df is None:
+        raise HTTPException(status_code=400, detail="Carregue um arquivo primeiro")
+
+    if coluna_y not in df.columns:
+        raise HTTPException(status_code=400, detail="Variavel Y invalida")
+
+    colunas_x_validas = [c for c in colunas_x if c in df.columns and c != coluna_y]
+    if not colunas_x_validas:
+        raise HTTPException(status_code=400, detail="Selecione ao menos uma variavel X")
+
+    outliers = _clean_int_list(outliers_anteriores if outliers_anteriores is not None else session.outliers_anteriores)
+    df_filtrado = df.copy()
+    if outliers:
+        df_filtrado = df_filtrado.drop(index=outliers, errors="ignore")
+
+    session.df_filtrado = df_filtrado
+    session.coluna_y = coluna_y
+    session.colunas_x = colunas_x_validas
+
+    dicotomicas = [c for c in (dicotomicas or []) if c in colunas_x_validas]
+    codigo_alocado = [c for c in (codigo_alocado or []) if c in colunas_x_validas]
+    percentuais = [c for c in (percentuais or []) if c in colunas_x_validas]
+
+    session.dicotomicas = dicotomicas
+    session.codigo_alocado = codigo_alocado
+    session.percentuais = percentuais
+    session.outliers_anteriores = outliers
+    session.iteracao = max(1, session.iteracao)
+    session.resultado_modelo = None
+    session.tabela_metricas_estado = None
+    session.avaliacoes_elaboracao = []
+
+    estatisticas = calcular_estatisticas_variaveis(df_filtrado, coluna_y, colunas=[coluna_y] + colunas_x_validas)
+    estatisticas = estatisticas.round(4)
+    session.tabela_estatisticas = estatisticas
+
+    resultado_micro = testar_micronumerosidade(
+        df_filtrado,
+        colunas_x_validas,
+        dicotomicas=dicotomicas,
+        codigo_alocado=codigo_alocado,
+    )
+    micro_html = formatar_micronumerosidade_html(resultado_micro)
+
+    try:
+        fig_dispersao = charts.criar_graficos_dispersao(df_filtrado[colunas_x_validas], df_filtrado[coluna_y])
+    except Exception:
+        fig_dispersao = None
+
+    busca_payload = search_transformacoes(session, grau_min_coef=grau_min_coef, grau_min_f=grau_min_f)
+
+    resultado_multi = verificar_multicolinearidade(df_filtrado, colunas_x_validas)
+    aviso_multi_html, aviso_multi_visivel = formatar_aviso_multicolinearidade(resultado_multi)
+
+    n_out = len(outliers)
+    resumo_outliers = f"Excluidos: {n_out} | A excluir: 0 | A reincluir: 0 | Total: {n_out}"
+    outliers_html = formatar_outliers_anteriores_html(
+        n_out,
+        ", ".join(str(i) for i in outliers) if outliers else "",
+    )
+
+    transform_fields = []
+    existing = session.transformacoes_x if session.transformacoes_x else {}
+    for col in colunas_x_validas:
+        locked = col in dicotomicas or col in percentuais
+        transform_fields.append(
+            {
+                "coluna": col,
+                "locked": locked,
+                "valor": existing.get(col, "(x)"),
+                "choices": TRANSFORMACOES,
+            }
+        )
+
+    return {
+        "estatisticas": dataframe_to_payload(estatisticas, decimals=4),
+        "micronumerosidade_html": micro_html,
+        "grafico_dispersao": figure_to_payload(fig_dispersao),
+        "busca": busca_payload,
+        "resumo_outliers": resumo_outliers,
+        "outliers_html": outliers_html,
+        "aviso_multicolinearidade": {
+            "html": aviso_multi_html,
+            "visible": aviso_multi_visivel,
+        },
+        "transformacao_y": session.transformacao_y,
+        "transform_fields": transform_fields,
+        "mapa_html": charts.criar_mapa(df_filtrado),
+        "contexto": _selection_context(session),
+    }
+
+
+def search_transformacoes(session: SessionState, grau_min_coef: int = 1, grau_min_f: int = 0) -> dict[str, Any]:
+    df = session.df_filtrado if session.df_filtrado is not None else session.df_original
+    if df is None or not session.coluna_y or not session.colunas_x:
+        raise HTTPException(status_code=400, detail="Selecione variaveis antes de buscar transformacoes")
+
+    transformacoes_fixas: dict[str, str] = {}
+    for col in (session.dicotomicas or []) + (session.percentuais or []):
+        transformacoes_fixas[col] = "(x)"
+
+    resultados = buscar_melhores_transformacoes(
+        df,
+        session.coluna_y,
+        session.colunas_x,
+        transformacoes_fixas=transformacoes_fixas,
+        top_n=5,
+        grau_min_coef=int(grau_min_coef),
+        grau_min_f=int(grau_min_f),
+    )
+
+    session.resultados_busca = sanitize_value(resultados)
+
+    if not resultados:
+        html = (
+            "<p style='color: orange;'><b>Aviso:</b> Nenhuma combinacao encontrada com os criterios atuais.</p>"
+        )
+        return {
+            "html": html,
+            "resultados": [],
+            "grau_coef": int(grau_min_coef),
+            "grau_f": int(grau_min_f),
+        }
+
+    html = formatar_busca_html(resultados)
+
+    grau_coef_usado = min(
+        min(resultado.get("graus_coef", {}).values(), default=0) for resultado in resultados
+    )
+    grau_f_usado = min(resultado.get("grau_f", 0) for resultado in resultados)
+
+    return {
+        "html": html,
+        "resultados": sanitize_value(resultados),
+        "grau_coef": int(grau_coef_usado),
+        "grau_f": int(grau_f_usado),
+    }
+
+
+def adotar_sugestao(session: SessionState, indice: int) -> dict[str, Any]:
+    if not session.resultados_busca:
+        raise HTTPException(status_code=400, detail="Nao ha sugestoes carregadas")
+
+    if indice < 0 or indice >= len(session.resultados_busca):
+        raise HTTPException(status_code=400, detail="Indice de sugestao invalido")
+
+    sugestao = session.resultados_busca[indice]
+    session.transformacao_y = str(sugestao.get("transformacao_y", "(x)"))
+    transf = sugestao.get("transformacoes_x", {}) or {}
+    session.transformacoes_x = {str(k): str(v) for k, v in transf.items()}
+
+    return {
+        "transformacao_y": session.transformacao_y,
+        "transformacoes_x": session.transformacoes_x,
+    }
+
+
+def fit_model(
+    session: SessionState,
+    transformacao_y: str,
+    transformacoes_x: dict[str, str] | None,
+    dicotomicas: list[str] | None = None,
+    codigo_alocado: list[str] | None = None,
+    percentuais: list[str] | None = None,
+) -> dict[str, Any]:
+    if session.df_filtrado is None:
+        raise HTTPException(status_code=400, detail="Aplique a selecao antes de ajustar")
+    if not session.coluna_y or not session.colunas_x:
+        raise HTTPException(status_code=400, detail="Variaveis Y/X nao definidas")
+
+    session.transformacao_y = transformacao_y or "(x)"
+
+    transf_map: dict[str, str] = {}
+    incoming = transformacoes_x or {}
+    for col in session.colunas_x:
+        transf_map[col] = str(incoming.get(col, "(x)"))
+    session.transformacoes_x = transf_map
+
+    session.dicotomicas = [c for c in (dicotomicas or session.dicotomicas) if c in session.colunas_x]
+    session.codigo_alocado = [c for c in (codigo_alocado or session.codigo_alocado) if c in session.colunas_x]
+    session.percentuais = [c for c in (percentuais or session.percentuais) if c in session.colunas_x]
+
+    resultado = ajustar_modelo(
+        session.df_filtrado,
+        session.coluna_y,
+        session.colunas_x,
+        session.transformacao_y,
+        session.transformacoes_x,
+    )
+    if resultado is None:
+        raise HTTPException(status_code=400, detail="Nao foi possivel ajustar o modelo")
+
+    resultado["dicotomicas"] = list(session.dicotomicas)
+    resultado["codigo_alocado"] = list(session.codigo_alocado)
+    resultado["percentuais"] = list(session.percentuais)
+
+    session.resultado_modelo = resultado
+    session.avaliacoes_elaboracao = []
+
+    diagnosticos_html = formatar_diagnosticos_html(resultado["diagnosticos"])
+
+    try:
+        fig_dispersao_transf = charts.criar_graficos_dispersao(
+            resultado["X_transformado"],
+            resultado["y_transformado"],
+        )
+    except Exception:
+        fig_dispersao_transf = None
+
+    fig_corr = None
+    try:
+        df_corr = resultado["X_transformado"].copy()
+        df_corr[session.coluna_y] = resultado["y_transformado"]
+        fig_corr = charts.criar_matriz_correlacao(df_corr, [session.coluna_y] + list(session.colunas_x))
+    except Exception:
+        fig_corr = None
+
+    graficos = charts.criar_painel_diagnostico(resultado)
+
+    tabela_metricas = resultado["tabela_obs_calc"].copy()
+    tabela_metricas_estado = tabela_metricas.set_index("Índice")
+
+    indices_usados = resultado.get("indices_usados", [])
+    if indices_usados:
+        df_base = session.df_filtrado.loc[indices_usados]
+    else:
+        df_base = session.df_filtrado
+
+    colunas_novas = {
+        col: df_base[col].values
+        for col in df_base.columns
+        if col not in tabela_metricas_estado.columns
+    }
+    if colunas_novas:
+        tabela_metricas_estado = pd.concat(
+            [
+                tabela_metricas_estado,
+                pd.DataFrame(colunas_novas, index=tabela_metricas_estado.index),
+            ],
+            axis=1,
+        )
+
+    session.tabela_metricas_estado = tabela_metricas_estado
+
+    colunas_originais = [c for c in session.df_filtrado.columns if c not in {"Observado", "Calculado", "Resíduo", "Resíduo Pad.", "Resíduo Stud.", "Cook"}]
+    variaveis_filtro = ["Resíduo Pad.", "Resíduo Stud.", "Cook"] + [str(c) for c in colunas_originais]
+
+    n_out = len(session.outliers_anteriores)
+    resumo = f"Excluidos: {n_out} | A excluir: 0 | A reincluir: 0 | Total: {n_out}"
+
+    return {
+        "diagnosticos_html": diagnosticos_html,
+        "tabela_coef": dataframe_to_payload(resultado["tabela_coef"], decimals=4),
+        "tabela_obs_calc": dataframe_to_payload(resultado["tabela_obs_calc"], decimals=4),
+        "grafico_dispersao_modelo": figure_to_payload(fig_dispersao_transf),
+        "grafico_obs_calc": figure_to_payload(graficos.get("obs_calc")),
+        "grafico_residuos": figure_to_payload(graficos.get("residuos")),
+        "grafico_histograma": figure_to_payload(graficos.get("histograma")),
+        "grafico_cook": figure_to_payload(graficos.get("cook")),
+        "grafico_correlacao": figure_to_payload(fig_corr),
+        "tabela_metricas": dataframe_to_payload(tabela_metricas, decimals=4),
+        "variaveis_filtro": variaveis_filtro,
+        "resumo_outliers": resumo,
+        "avaliacao_campos": build_campos_avaliacao(session),
+        "contexto": _selection_context(session),
+    }
+
+
+def gerar_grafico_dispersao_modelo(session: SessionState, tipo: str) -> dict[str, Any]:
+    if not session.resultado_modelo:
+        raise HTTPException(status_code=400, detail="Ajuste um modelo primeiro")
+
+    try:
+        if "Residuo" in tipo or "Resíduo" in tipo:
+            tabela = session.resultado_modelo.get("tabela_obs_calc")
+            residuos = tabela["Resíduo Pad."].values if tabela is not None and "Resíduo Pad." in tabela.columns else None
+            fig = charts.criar_graficos_dispersao_residuos(session.resultado_modelo["X_transformado"], residuos)
+        else:
+            fig = charts.criar_graficos_dispersao(
+                session.resultado_modelo["X_transformado"],
+                session.resultado_modelo["y_transformado"],
+            )
+    except Exception:
+        fig = None
+
+    return {"grafico": figure_to_payload(fig)}
+
+
+def apply_outlier_filters(session: SessionState, filtros: list[dict[str, Any]]) -> dict[str, Any]:
+    metricas = session.tabela_metricas_estado
+    if metricas is None:
+        raise HTTPException(status_code=400, detail="Ajuste o modelo para gerar metricas")
+
+    if not filtros:
+        return {"indices": [], "texto": ""}
+
+    indices_outliers: set[int] = set()
+
+    for filtro in filtros:
+        var = str(filtro.get("variavel", "")).strip()
+        op = str(filtro.get("operador", "")).strip()
+        val = filtro.get("valor")
+
+        if not var or var not in metricas.columns:
+            continue
+        if val is None:
+            continue
+
+        try:
+            val_num = float(val)
+        except Exception:
+            continue
+
+        if op == "<=":
+            mask = metricas[var] <= val_num
+        elif op == ">=":
+            mask = metricas[var] >= val_num
+        elif op == "<":
+            mask = metricas[var] < val_num
+        elif op == ">":
+            mask = metricas[var] > val_num
+        elif op == "=":
+            mask = metricas[var] == val_num
+        else:
+            continue
+
+        matched = metricas[mask].index.tolist()
+        for idx in matched:
+            try:
+                indices_outliers.add(int(idx))
+            except Exception:
+                continue
+
+    indices = sorted(indices_outliers)
+    texto = ", ".join(str(i) for i in indices)
+    return {"indices": indices, "texto": texto}
+
+
+def resumir_outliers(outliers_anteriores: list[int], outliers_texto: str | None, reincluir_texto: str | None) -> str:
+    anteriores = _clean_int_list(outliers_anteriores)
+    novos = _parse_indices_text(outliers_texto)
+    reincluir = _parse_indices_text(reincluir_texto)
+
+    anteriores_atualizados = [i for i in anteriores if i not in reincluir]
+    total = sorted(set(anteriores_atualizados + novos))
+    return (
+        f"Excluidos: {len(anteriores)} | A excluir: {len(novos)} | "
+        f"A reincluir: {len(reincluir)} | Total: {len(total)}"
+    )
+
+
+def reiniciar_iteracao(
+    session: SessionState,
+    outliers_texto: str | None,
+    reincluir_texto: str | None,
+    grau_min_coef: int = 3,
+    grau_min_f: int = 3,
+) -> dict[str, Any]:
+    if session.df_original is None:
+        raise HTTPException(status_code=400, detail="Carregue dados primeiro")
+    if not session.coluna_y or not session.colunas_x:
+        raise HTTPException(status_code=400, detail="Selecione variaveis primeiro")
+
+    novos = _parse_indices_text(outliers_texto)
+    reincluir = _parse_indices_text(reincluir_texto)
+
+    anteriores_atualizados = [i for i in session.outliers_anteriores if i not in reincluir]
+    outliers_combinados = sorted(set(anteriores_atualizados + novos))
+
+    session.outliers_anteriores = outliers_combinados
+    session.iteracao = (session.iteracao or 1) + 1
+
+    selection = apply_selection(
+        session,
+        coluna_y=session.coluna_y,
+        colunas_x=session.colunas_x,
+        dicotomicas=session.dicotomicas,
+        codigo_alocado=session.codigo_alocado,
+        percentuais=session.percentuais,
+        outliers_anteriores=outliers_combinados,
+        grau_min_coef=int(grau_min_coef),
+        grau_min_f=int(grau_min_f),
+    )
+
+    html_outliers = formatar_outliers_anteriores_html(
+        len(outliers_combinados),
+        ", ".join(str(i) for i in outliers_combinados) if outliers_combinados else "",
+    )
+
+    selection.update(
+        {
+            "outliers_anteriores": outliers_combinados,
+            "iteracao": session.iteracao,
+            "outliers_html": html_outliers,
+            "resumo_outliers": resumir_outliers(outliers_combinados, "", ""),
+        }
+    )
+
+    return selection
+
+
+def build_campos_avaliacao(session: SessionState) -> list[dict[str, Any]]:
+    if session.resultado_modelo is None or session.tabela_estatisticas is None:
+        return []
+
+    colunas_x = list(session.resultado_modelo.get("colunas_x", []))
+
+    est = session.tabela_estatisticas
+    if "Variável" in est.columns:
+        est_idx = est.set_index("Variável")
+    else:
+        est_idx = est
+
+    campos: list[dict[str, Any]] = []
+    for col in colunas_x:
+        placeholder = ""
+        if col in session.dicotomicas:
+            placeholder = "0 ou 1"
+            tipo = "dicotomica"
+        elif col in session.codigo_alocado and col in est_idx.index:
+            min_v = est_idx.loc[col, "Mínimo"]
+            max_v = est_idx.loc[col, "Máximo"]
+            placeholder = f"cod. {int(min_v)} a {int(max_v)}"
+            tipo = "codigo_alocado"
+        elif col in session.percentuais:
+            placeholder = "0 a 1"
+            tipo = "percentual"
+        elif col in est_idx.index:
+            min_v = est_idx.loc[col, "Mínimo"]
+            max_v = est_idx.loc[col, "Máximo"]
+            placeholder = f"{min_v} — {max_v}"
+            tipo = "numerica"
+        else:
+            tipo = "numerica"
+
+        campos.append(
+            {
+                "coluna": col,
+                "placeholder": placeholder,
+                "tipo": tipo,
+            }
+        )
+
+    return sanitize_value(campos)
+
+
+def calcular_avaliacao_elaboracao(
+    session: SessionState,
+    valores_x: dict[str, Any],
+    indice_base: str | None,
+) -> dict[str, Any]:
+    if session.resultado_modelo is None:
+        raise HTTPException(status_code=400, detail="Ajuste um modelo primeiro")
+    if session.tabela_estatisticas is None:
+        raise HTTPException(status_code=400, detail="Estatisticas indisponiveis")
+
+    colunas_x = list(session.resultado_modelo.get("colunas_x", []))
+    if not colunas_x:
+        raise HTTPException(status_code=400, detail="Modelo sem variaveis")
+
+    entradas: dict[str, float] = {}
+    for col in colunas_x:
+        if col not in valores_x:
+            raise HTTPException(status_code=400, detail=f"Valor ausente para {col}")
+        try:
+            entradas[col] = float(valores_x[col])
+        except Exception as exc:
+            raise HTTPException(status_code=400, detail=f"Valor invalido para {col}") from exc
+
+    est = session.tabela_estatisticas
+    if "Variável" in est.columns:
+        est_idx = est.set_index("Variável")
+    else:
+        est_idx = est
+
+    for col in colunas_x:
+        valor = entradas[col]
+        if col in session.dicotomicas and valor not in (0, 0.0, 1, 1.0):
+            raise HTTPException(status_code=400, detail=f"{col} aceita apenas 0 ou 1")
+        if col in session.codigo_alocado and col in est_idx.index:
+            min_v = float(est_idx.loc[col, "Mínimo"])
+            max_v = float(est_idx.loc[col, "Máximo"])
+            if float(valor) != int(float(valor)) or valor < min_v or valor > max_v:
+                raise HTTPException(status_code=400, detail=f"{col} aceita inteiros de {int(min_v)} a {int(max_v)}")
+        if col in session.percentuais and (valor < 0 or valor > 1):
+            raise HTTPException(status_code=400, detail=f"{col} aceita valores entre 0 e 1")
+
+    resultado = avaliar_imovel(
+        modelo_sm=session.resultado_modelo["modelo_sm"],
+        valores_x=entradas,
+        colunas_x=colunas_x,
+        transformacoes_x=session.resultado_modelo.get("transformacoes_x", {}),
+        transformacao_y=session.resultado_modelo.get("transformacao_y", "(x)"),
+        estatisticas_df=session.tabela_estatisticas,
+        dicotomicas=session.dicotomicas,
+        codigo_alocado=session.codigo_alocado,
+        percentuais=session.percentuais,
+    )
+    if resultado is None:
+        raise HTTPException(status_code=400, detail="Erro ao calcular avaliacao")
+
+    session.avaliacoes_elaboracao.append(resultado)
+    idx_base = int(indice_base) - 1 if indice_base else 0
+    html = formatar_avaliacao_html(session.avaliacoes_elaboracao, indice_base=idx_base, elem_id_excluir="excluir-aval-elab")
+
+    choices = [str(i + 1) for i in range(len(session.avaliacoes_elaboracao))]
+    base = indice_base if indice_base else "1"
+
+    return {
+        "resultado_html": html,
+        "avaliacoes": sanitize_value(session.avaliacoes_elaboracao),
+        "base_choices": choices,
+        "base_value": base,
+    }
+
+
+def limpar_avaliacoes_elaboracao(session: SessionState) -> dict[str, Any]:
+    session.avaliacoes_elaboracao = []
+    return {
+        "resultado_html": "",
+        "avaliacoes": [],
+        "base_choices": [],
+        "base_value": None,
+    }
+
+
+def excluir_avaliacao_elaboracao(session: SessionState, indice_str: str | None, indice_base_str: str | None) -> dict[str, Any]:
+    if not indice_str or not session.avaliacoes_elaboracao:
+        return {
+            "resultado_html": None,
+            "avaliacoes": sanitize_value(session.avaliacoes_elaboracao),
+            "base_choices": [str(i + 1) for i in range(len(session.avaliacoes_elaboracao))],
+            "base_value": indice_base_str,
+        }
+
+    try:
+        idx = int(indice_str.strip()) - 1
+    except Exception:
+        return {
+            "resultado_html": None,
+            "avaliacoes": sanitize_value(session.avaliacoes_elaboracao),
+            "base_choices": [str(i + 1) for i in range(len(session.avaliacoes_elaboracao))],
+            "base_value": indice_base_str,
+        }
+
+    if idx < 0 or idx >= len(session.avaliacoes_elaboracao):
+        return {
+            "resultado_html": None,
+            "avaliacoes": sanitize_value(session.avaliacoes_elaboracao),
+            "base_choices": [str(i + 1) for i in range(len(session.avaliacoes_elaboracao))],
+            "base_value": indice_base_str,
+        }
+
+    nova_lista = [a for i, a in enumerate(session.avaliacoes_elaboracao) if i != idx]
+    session.avaliacoes_elaboracao = nova_lista
+
+    if not nova_lista:
+        return {
+            "resultado_html": "",
+            "avaliacoes": [],
+            "base_choices": [],
+            "base_value": None,
+        }
+
+    base = int(indice_base_str) - 1 if indice_base_str else 0
+    if base >= len(nova_lista):
+        base = len(nova_lista) - 1
+    if base < 0:
+        base = 0
+
+    html = formatar_avaliacao_html(nova_lista, indice_base=base, elem_id_excluir="excluir-aval-elab")
+    choices = [str(i + 1) for i in range(len(nova_lista))]
+
+    return {
+        "resultado_html": html,
+        "avaliacoes": sanitize_value(nova_lista),
+        "base_choices": choices,
+        "base_value": str(base + 1),
+    }
+
+
+def atualizar_base_avaliacao_elaboracao(session: SessionState, indice_base_str: str | None) -> dict[str, Any]:
+    if not session.avaliacoes_elaboracao:
+        return {"resultado_html": ""}
+    indice = int(indice_base_str) - 1 if indice_base_str else 0
+    html = formatar_avaliacao_html(session.avaliacoes_elaboracao, indice_base=indice, elem_id_excluir="excluir-aval-elab")
+    return {"resultado_html": html}
+
+
+def exportar_avaliacoes_elaboracao(session: SessionState) -> str:
+    caminho = exportar_avaliacoes_excel(session.avaliacoes_elaboracao)
+    if not caminho:
+        raise HTTPException(status_code=400, detail="Sem avaliacoes para exportar")
+    return caminho
+
+
+def exportar_modelo(session: SessionState, nome_arquivo: str, elaborador: dict[str, Any] | None = None) -> tuple[str, str]:
+    if session.resultado_modelo is None:
+        raise HTTPException(status_code=400, detail="Ajuste um modelo antes de exportar")
+    if session.df_filtrado is None or session.df_original is None:
+        raise HTTPException(status_code=400, detail="Dados nao disponiveis para exportacao")
+
+    if not nome_arquivo or not nome_arquivo.strip():
+        raise HTTPException(status_code=400, detail="Informe o nome do arquivo")
+
+    caminho, msg = exportar_modelo_dai(
+        session.resultado_modelo,
+        session.df_filtrado,
+        session.df_original,
+        session.tabela_estatisticas,
+        nome_arquivo.strip(),
+        elaborador=elaborador,
+        outliers_excluidos=session.outliers_anteriores,
+    )
+
+    if not caminho:
+        raise HTTPException(status_code=400, detail=msg)
+
+    return caminho, msg
+
+
+def exportar_base(session: SessionState, usar_filtrado: bool = True) -> str:
+    df = session.df_filtrado if usar_filtrado else session.df_original
+    caminho = exportar_base_csv(df)
+    if not caminho:
+        raise HTTPException(status_code=400, detail="Base indisponivel")
+    return caminho
+
+
+def atualizar_mapa(session: SessionState, var_mapa: str | None) -> dict[str, Any]:
+    df = session.df_filtrado if session.df_filtrado is not None else session.df_original
+    if df is None:
+        raise HTTPException(status_code=400, detail="Carregue dados primeiro")
+
+    tamanho_col = None if not var_mapa or var_mapa == "Visualizacao Padrao" or var_mapa == "Visualização Padrão" else var_mapa
+    mapa_html = charts.criar_mapa(df, tamanho_col=tamanho_col)
+    return {"mapa_html": mapa_html}
+
+
+def mapear_coordenadas_manualmente(session: SessionState, col_lat: str, col_lon: str) -> dict[str, Any]:
+    df = session.df_original
+    if df is None:
+        raise HTTPException(status_code=400, detail="Carregue dados primeiro")
+    if not col_lat or not col_lon:
+        raise HTTPException(status_code=400, detail="Selecione latitude e longitude")
+
+    n_total = len(df)
+    if n_total == 0:
+        raise HTTPException(status_code=400, detail="DataFrame vazio")
+
+    lat_num = pd.to_numeric(df[col_lat], errors="coerce")
+    lon_num = pd.to_numeric(df[col_lon], errors="coerce")
+    lat_vals = lat_num.dropna()
+    lon_vals = lon_num.dropna()
+
+    lat_conv = len(lat_vals) / n_total
+    lon_conv = len(lon_vals) / n_total
+
+    erros: list[str] = []
+    if lat_conv < 0.5:
+        erros.append(f"{col_lat}: apenas {lat_conv:.0%} numericos")
+    if lon_conv < 0.5:
+        erros.append(f"{col_lon}: apenas {lon_conv:.0%} numericos")
+
+    if not erros:
+        lat_in_range = ((lat_vals >= -90) & (lat_vals <= 90)).mean()
+        lon_in_range = ((lon_vals >= -180) & (lon_vals <= 180)).mean()
+        lat_in_lon_range = ((lat_vals >= -180) & (lat_vals <= 180)).mean()
+        lon_in_lat_range = ((lon_vals >= -90) & (lon_vals <= 90)).mean()
+
+        inversao = lat_in_range < 0.5 and lat_in_lon_range > 0.8 and lon_in_lat_range > 0.8
+        if inversao:
+            erros.append("As colunas parecem invertidas")
+        else:
+            if lat_in_range < 0.8:
+                erros.append(f"{col_lat}: baixa aderencia ao intervalo de latitude")
+            if lon_in_range < 0.8:
+                erros.append(f"{col_lon}: baixa aderencia ao intervalo de longitude")
+
+    if not erros:
+        lat_tem_decimais = (lat_vals % 1 != 0).mean() if len(lat_vals) > 0 else 0.0
+        lon_tem_decimais = (lon_vals % 1 != 0).mean() if len(lon_vals) > 0 else 0.0
+        if lat_tem_decimais < 0.1:
+            erros.append(f"{col_lat}: poucos valores com casas decimais")
+        if lon_tem_decimais < 0.1:
+            erros.append(f"{col_lon}: poucos valores com casas decimais")
+
+    if erros:
+        raise HTTPException(status_code=400, detail="; ".join(erros))
+
+    df_novo = geocodificacao.padronizar_coords(df, col_lat, col_lon)
+    session.df_original = df_novo
+
+    df_filtrado = df_novo.copy()
+    if session.outliers_anteriores:
+        df_filtrado = df_filtrado.drop(index=session.outliers_anteriores, errors="ignore")
+    session.df_filtrado = df_filtrado
+
+    return {
+        "status": "Coordenadas mapeadas com sucesso",
+        "mapa_html": charts.criar_mapa(df_filtrado),
+        "dados": dataframe_to_payload(df_filtrado, decimals=4),
+        "coords": _build_coords_payload(df_novo, True),
+    }
+
+
+def geocodificar(session: SessionState, col_cdlog: str, col_num: str, auto_200: bool = False) -> dict[str, Any]:
+    if session.df_original is None:
+        raise HTTPException(status_code=400, detail="Carregue dados primeiro")
+
+    try:
+        df_resultado, df_falhas, ajustados = geocodificacao.geocodificar(session.df_original, col_cdlog, col_num, auto_200=auto_200)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    session.df_original = df_resultado
+    session.df_filtrado = df_resultado.drop(index=session.outliers_anteriores, errors="ignore")
+    session.geo_falhas_df = df_falhas
+    session.geo_col_cdlog = col_cdlog
+    session.geo_col_num = col_num
+
+    status_html = geocodificacao.formatar_status_geocodificacao(df_resultado, df_falhas, ajustados)
+    falhas_html, df_correcoes = geocodificacao.preparar_display_falhas(df_falhas)
+
+    return {
+        "status_html": status_html,
+        "falhas_html": falhas_html,
+        "falhas_para_correcao": dataframe_to_payload(df_correcoes, decimals=None),
+        "mapa_html": charts.criar_mapa(session.df_filtrado),
+        "dados": dataframe_to_payload(session.df_filtrado, decimals=4),
+        "coords": _build_coords_payload(session.df_original, True),
+    }
+
+
+def aplicar_correcoes_geocodificacao(
+    session: SessionState,
+    correcoes: list[dict[str, Any]],
+    auto_200: bool = False,
+) -> dict[str, Any]:
+    if session.df_original is None:
+        raise HTTPException(status_code=400, detail="Carregue dados primeiro")
+    if session.geo_falhas_df is None:
+        raise HTTPException(status_code=400, detail="Nao ha falhas de geocodificacao pendentes")
+    if not session.geo_col_cdlog or not session.geo_col_num:
+        raise HTTPException(status_code=400, detail="Contexto de geocodificacao ausente")
+
+    df_falhas = session.geo_falhas_df.copy()
+    mapa_correcao = {
+        int(item.get("linha")): str(item.get("numero_corrigido", "")).strip()
+        for item in correcoes
+        if item.get("linha") is not None
+    }
+
+    if "numero_corrigido" not in df_falhas.columns:
+        df_falhas["numero_corrigido"] = ""
+
+    for idx, row in df_falhas.iterrows():
+        linha = int(row.get("_idx"))
+        valor = mapa_correcao.get(linha, "")
+        df_falhas.at[idx, "numero_corrigido"] = valor
+
+    try:
+        df_resultado, df_falhas_novas, ajustados, manuais = geocodificacao.aplicar_correcoes_e_regeodificar(
+            session.df_original,
+            df_falhas,
+            session.geo_col_cdlog,
+            session.geo_col_num,
+            auto_200=auto_200,
+        )
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    session.df_original = df_resultado
+    session.df_filtrado = df_resultado.drop(index=session.outliers_anteriores, errors="ignore")
+    session.geo_falhas_df = df_falhas_novas
+
+    status_html = geocodificacao.formatar_status_geocodificacao(df_resultado, df_falhas_novas, ajustados, manuais=manuais)
+    falhas_html, df_correcoes = geocodificacao.preparar_display_falhas(df_falhas_novas)
+
+    return {
+        "status_html": status_html,
+        "falhas_html": falhas_html,
+        "falhas_para_correcao": dataframe_to_payload(df_correcoes, decimals=None),
+        "mapa_html": charts.criar_mapa(session.df_filtrado),
+        "dados": dataframe_to_payload(session.df_filtrado, decimals=4),
+        "coords": _build_coords_payload(session.df_original, True),
+    }
+
+
+def limpar_historico_outliers(session: SessionState) -> dict[str, Any]:
+    if session.df_original is None:
+        raise HTTPException(status_code=400, detail="Carregue dados primeiro")
+
+    session.outliers_anteriores = []
+    session.iteracao = 1
+    session.df_filtrado = session.df_original.copy()
+    session.reset_modelo()
+
+    return {
+        "dados": dataframe_to_payload(session.df_filtrado, decimals=4),
+        "mapa_html": charts.criar_mapa(session.df_filtrado),
+        "outliers_html": "",
+        "resumo_outliers": "Excluidos: 0 | A excluir: 0 | A reincluir: 0 | Total: 0",
+        "contexto": _selection_context(session),
+    }

backend/app/services/serializers.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import math
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+
+def sanitize_value(value: Any) -> Any:
+    if isinstance(value, np.ndarray):
+        return [sanitize_value(item) for item in value.tolist()]
+    if isinstance(value, np.generic):
+        return sanitize_value(value.item())
+    if isinstance(value, (np.floating, float)):
+        if math.isnan(value) or math.isinf(value):
+            return None
+        return float(value)
+    if isinstance(value, (np.integer, int)):
+        return int(value)
+    if isinstance(value, (np.bool_, bool)):
+        return bool(value)
+    if isinstance(value, pd.Timestamp):
+        return value.isoformat()
+    if isinstance(value, pd.Timedelta):
+        return str(value)
+    if isinstance(value, pd.Series):
+        return [sanitize_value(item) for item in value.tolist()]
+    if isinstance(value, pd.Index):
+        return [sanitize_value(item) for item in value.tolist()]
+    if isinstance(value, pd.DataFrame):
+        return sanitize_value(value.to_dict(orient="records"))
+    if isinstance(value, Path):
+        return str(value)
+    if value is None:
+        return None
+    if isinstance(value, str):
+        return value
+    if isinstance(value, dict):
+        return {str(k): sanitize_value(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple, set)):
+        return [sanitize_value(v) for v in value]
+    try:
+        if pd.isna(value):
+            return None
+    except Exception:
+        pass
+    return value
+
+
+def dataframe_to_payload(df: pd.DataFrame | None, decimals: int | None = None, max_rows: int = 5000) -> dict[str, Any] | None:
+    if df is None:
+        return None
+
+    df_work = df.copy()
+    if decimals is not None:
+        numeric_cols = df_work.select_dtypes(include=[np.number]).columns
+        df_work[numeric_cols] = df_work[numeric_cols].round(decimals)
+
+    total_rows = len(df_work)
+    truncated = total_rows > max_rows
+    if truncated:
+        df_work = df_work.head(max_rows)
+
+    rows: list[dict[str, Any]] = []
+    for idx, row in df_work.iterrows():
+        payload_row = {"_index": sanitize_value(idx)}
+        for col, value in row.items():
+            payload_row[str(col)] = sanitize_value(value)
+        rows.append(payload_row)
+
+    columns = ["_index"] + [str(c) for c in df_work.columns]
+    return {
+        "columns": columns,
+        "rows": rows,
+        "total_rows": total_rows,
+        "returned_rows": len(rows),
+        "truncated": truncated,
+    }
+
+
+def figure_to_payload(fig: Any) -> dict[str, Any] | None:
+    if fig is None:
+        return None
+    try:
+        return sanitize_value(fig.to_plotly_json())
+    except Exception:
+        return None

backend/app/services/session_store.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import shutil
+import tempfile
+import uuid
+from pathlib import Path
+
+from fastapi import HTTPException
+
+from app.models.session import SessionState
+
+
+class SessionStore:
+    def __init__(self) -> None:
+        self._sessions: dict[str, SessionState] = {}
+
+    def create(self) -> SessionState:
+        session_id = uuid.uuid4().hex
+        workdir = Path(tempfile.mkdtemp(prefix=f"mesa_{session_id[:8]}_"))
+        state = SessionState(session_id=session_id, workdir=workdir)
+        self._sessions[session_id] = state
+        return state
+
+    def get(self, session_id: str) -> SessionState:
+        state = self._sessions.get(session_id)
+        if state is None:
+            raise HTTPException(status_code=404, detail="Sessao nao encontrada")
+        return state
+
+    def delete(self, session_id: str) -> None:
+        state = self._sessions.pop(session_id, None)
+        if state is None:
+            return
+        shutil.rmtree(state.workdir, ignore_errors=True)
+
+
+session_store = SessionStore()

backend/app/services/visualizacao_service.py

@@ -0,0 +1,380 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from fastapi import HTTPException
+from joblib import load
+
+from app.core.visualizacao import app as viz_app
+from app.core.elaboracao.core import _migrar_pacote_v1_para_v2, avaliar_imovel, exportar_avaliacoes_excel
+from app.core.elaboracao.formatadores import formatar_avaliacao_html
+from app.models.session import SessionState
+from app.services.serializers import dataframe_to_payload, figure_to_payload, sanitize_value
+
+
+CHAVES_ESPERADAS = ["versao", "dados", "transformacoes", "modelo"]
+
+
+def carregar_modelo(session: SessionState, caminho_arquivo: str) -> dict[str, Any]:
+    try:
+        pacote = load(caminho_arquivo)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=f"Falha ao ler arquivo .dai: {exc}") from exc
+
+    if not isinstance(pacote, dict):
+        raise HTTPException(status_code=400, detail="Arquivo .dai invalido")
+
+    if "versao" not in pacote:
+        pacote = _migrar_pacote_v1_para_v2(pacote)
+
+    faltantes = [k for k in CHAVES_ESPERADAS if k not in pacote]
+    if faltantes:
+        raise HTTPException(status_code=400, detail=f"Pacote incompleto: {faltantes}")
+
+    session.pacote_visualizacao = pacote
+    session.dados_visualizacao = None
+    session.avaliacoes_visualizacao = []
+
+    status = f"Modelo carregado: {os.path.basename(caminho_arquivo)}"
+    badge_html = viz_app._formatar_badge_completo(pacote)
+
+    return {
+        "status": status,
+        "badge_html": badge_html,
+    }
+
+
+def _tabela_estatisticas(pacote: dict[str, Any]) -> pd.DataFrame:
+    estat = pd.DataFrame(pacote["dados"]["estatisticas"])
+    if not isinstance(estat.index, pd.RangeIndex):
+        estat.insert(0, "Variável", estat.index.astype(str))
+        estat = estat.reset_index(drop=True)
+    return estat
+
+
+def _extrair_modelo_info(pacote: dict[str, Any]) -> dict[str, Any]:
+    info_transf = pacote["transformacoes"]["info"]
+    nome_y, transf_y = info_transf[0].split(": ", 1)
+    transformacao_y = transf_y.strip().replace("(y)", "(x)")
+
+    colunas_x: list[str] = []
+    transformacoes_x: dict[str, str] = {}
+    for item in info_transf[1:]:
+        nome_x, transf_x = item.split(": ", 1)
+        nome_x = nome_x.strip()
+        colunas_x.append(nome_x)
+        transformacoes_x[nome_x] = transf_x.strip()
+
+    dicotomicas = [str(v) for v in (pacote["transformacoes"].get("dicotomicas", []) or [])]
+    codigo_alocado = [str(v) for v in (pacote["transformacoes"].get("codigo_alocado", []) or [])]
+    percentuais = [str(v) for v in (pacote["transformacoes"].get("percentuais", []) or [])]
+
+    return {
+        "nome_y": nome_y.strip(),
+        "transformacao_y": transformacao_y,
+        "colunas_x": colunas_x,
+        "transformacoes_x": transformacoes_x,
+        "dicotomicas": dicotomicas,
+        "codigo_alocado": codigo_alocado,
+        "percentuais": percentuais,
+    }
+
+
+def exibir_modelo(session: SessionState) -> dict[str, Any]:
+    pacote = session.pacote_visualizacao
+    if pacote is None:
+        raise HTTPException(status_code=400, detail="Carregue um modelo primeiro")
+
+    dados = pacote["dados"]["df"].reset_index()
+    for col in dados.columns:
+        if str(col).lower() in ["lat", "lon"]:
+            dados[col] = dados[col].round(6)
+        elif pd.api.types.is_numeric_dtype(dados[col]):
+            dados[col] = dados[col].round(2)
+
+    estat = _tabela_estatisticas(pacote).round(2)
+
+    escalas_html = viz_app.formatar_escalas_html(pacote["transformacoes"]["info"])
+
+    X = pacote["transformacoes"]["X"].reset_index()
+    y = pacote["transformacoes"]["y"].reset_index()
+    if "index" in y.columns and "index" in X.columns:
+        y = y.drop(columns=["index"])
+    df_xy = pd.concat([X, y], axis=1)
+    df_xy = df_xy.loc[:, ~df_xy.columns.duplicated()].round(2)
+
+    resumo_html = viz_app.formatar_resumo_html(viz_app.reorganizar_modelos_resumos(pacote["modelo"]["diagnosticos"]))
+
+    tab_coef = pd.DataFrame(pacote["modelo"]["coeficientes"])
+    if not isinstance(tab_coef.index, pd.RangeIndex):
+        tab_coef.insert(0, "Variável", tab_coef.index.astype(str))
+        tab_coef = tab_coef.reset_index(drop=True)
+    mask = tab_coef["Variável"].astype(str).str.lower().isin(["intercept", "const", "(intercept)"])
+    if mask.any():
+        tab_coef = pd.concat([tab_coef[mask], tab_coef[~mask]], ignore_index=True)
+    tab_coef = tab_coef.round(2)
+
+    tab_obs_calc = pacote["modelo"]["obs_calc"].reset_index().round(2)
+
+    figs = viz_app.gerar_todos_graficos(pacote)
+
+    info = _extrair_modelo_info(pacote)
+    mapa_html = viz_app.criar_mapa(dados, col_y=info["nome_y"])
+
+    colunas_numericas = [
+        str(col)
+        for col in dados.select_dtypes(include=[np.number]).columns
+        if str(col).lower() not in ["lat", "lon", "latitude", "longitude", "index"]
+    ]
+    choices_mapa = ["Visualização Padrão"] + colunas_numericas
+
+    session.dados_visualizacao = dados
+
+    return {
+        "dados": dataframe_to_payload(dados, decimals=2),
+        "estatisticas": dataframe_to_payload(estat, decimals=2),
+        "escalas_html": escalas_html,
+        "dados_transformados": dataframe_to_payload(df_xy, decimals=2),
+        "resumo_html": resumo_html,
+        "coeficientes": dataframe_to_payload(tab_coef, decimals=2),
+        "obs_calc": dataframe_to_payload(tab_obs_calc, decimals=2),
+        "grafico_obs_calc": figure_to_payload(figs.get("obs_calc")),
+        "grafico_residuos": figure_to_payload(figs.get("residuos")),
+        "grafico_histograma": figure_to_payload(figs.get("hist")),
+        "grafico_cook": figure_to_payload(figs.get("cook")),
+        "grafico_correlacao": figure_to_payload(figs.get("corr")),
+        "mapa_html": mapa_html,
+        "mapa_choices": choices_mapa,
+        "campos_avaliacao": campos_avaliacao(session),
+        "meta_modelo": sanitize_value(info),
+    }
+
+
+def atualizar_mapa(session: SessionState, variavel_mapa: str | None) -> dict[str, Any]:
+    pacote = session.pacote_visualizacao
+    dados = session.dados_visualizacao
+    if pacote is None or dados is None or dados.empty:
+        raise HTTPException(status_code=400, detail="Exiba o modelo antes de atualizar o mapa")
+
+    info = _extrair_modelo_info(pacote)
+    tamanho_col = None
+    if variavel_mapa and variavel_mapa != "Visualização Padrão":
+        tamanho_col = variavel_mapa
+
+    mapa_html = viz_app.criar_mapa(dados, tamanho_col=tamanho_col, col_y=info["nome_y"])
+    return {"mapa_html": mapa_html}
+
+
+def campos_avaliacao(session: SessionState) -> list[dict[str, Any]]:
+    pacote = session.pacote_visualizacao
+    if pacote is None:
+        return []
+
+    info = _extrair_modelo_info(pacote)
+    colunas_x = info["colunas_x"]
+    dicotomicas = info["dicotomicas"]
+    codigo_alocado = info["codigo_alocado"]
+    percentuais = info["percentuais"]
+
+    estat = pacote["dados"]["estatisticas"]
+    if isinstance(estat, pd.DataFrame):
+        estat_df = estat.copy()
+    else:
+        estat_df = pd.DataFrame(estat)
+
+    if "Variável" in estat_df.columns:
+        est_idx = estat_df.set_index("Variável")
+    elif not isinstance(estat_df.index, pd.RangeIndex):
+        est_idx = estat_df
+    else:
+        est_idx = pd.DataFrame()
+
+    if not est_idx.empty:
+        est_idx.index = est_idx.index.map(str)
+
+    campos: list[dict[str, Any]] = []
+    for col in colunas_x:
+        placeholder = ""
+        if col in dicotomicas:
+            placeholder = "0 ou 1"
+            tipo = "dicotomica"
+        elif col in codigo_alocado and col in est_idx.index:
+            min_v = est_idx.loc[col, "Mínimo"]
+            max_v = est_idx.loc[col, "Máximo"]
+            placeholder = f"cod. {int(min_v)} a {int(max_v)}"
+            tipo = "codigo_alocado"
+        elif col in percentuais:
+            placeholder = "0 a 1"
+            tipo = "percentual"
+        elif col in est_idx.index:
+            min_v = est_idx.loc[col, "Mínimo"]
+            max_v = est_idx.loc[col, "Máximo"]
+            placeholder = f"{min_v} — {max_v}"
+            tipo = "numerica"
+        else:
+            tipo = "numerica"
+
+        campos.append({"coluna": col, "placeholder": placeholder, "tipo": tipo})
+
+    return sanitize_value(campos)
+
+
+def calcular_avaliacao(session: SessionState, valores_x: dict[str, Any], indice_base: str | None) -> dict[str, Any]:
+    pacote = session.pacote_visualizacao
+    if pacote is None:
+        raise HTTPException(status_code=400, detail="Carregue um modelo primeiro")
+
+    info = _extrair_modelo_info(pacote)
+    colunas_x = info["colunas_x"]
+
+    entradas: dict[str, float] = {}
+    for col in colunas_x:
+        if col not in valores_x:
+            raise HTTPException(status_code=400, detail=f"Valor ausente para {col}")
+        try:
+            entradas[col] = float(valores_x[col])
+        except Exception as exc:
+            raise HTTPException(status_code=400, detail=f"Valor invalido para {col}") from exc
+
+    estatisticas_df = pacote["dados"]["estatisticas"]
+    if isinstance(estatisticas_df, pd.DataFrame):
+        est_df = estatisticas_df
+    else:
+        est_df = pd.DataFrame(estatisticas_df)
+
+    if "Variável" in est_df.columns:
+        est_idx = est_df.set_index("Variável")
+    else:
+        est_idx = est_df
+
+    for col in colunas_x:
+        valor = entradas[col]
+        if col in info["dicotomicas"] and valor not in (0, 0.0, 1, 1.0):
+            raise HTTPException(status_code=400, detail=f"{col} aceita apenas 0 ou 1")
+        if col in info["codigo_alocado"] and col in est_idx.index:
+            min_v = float(est_idx.loc[col, "Mínimo"])
+            max_v = float(est_idx.loc[col, "Máximo"])
+            if float(valor) != int(float(valor)) or valor < min_v or valor > max_v:
+                raise HTTPException(status_code=400, detail=f"{col} aceita inteiros de {int(min_v)} a {int(max_v)}")
+        if col in info["percentuais"] and (valor < 0 or valor > 1):
+            raise HTTPException(status_code=400, detail=f"{col} aceita valores entre 0 e 1")
+
+    resultado = avaliar_imovel(
+        modelo_sm=pacote["modelo"]["sm"],
+        valores_x=entradas,
+        colunas_x=colunas_x,
+        transformacoes_x=info["transformacoes_x"],
+        transformacao_y=info["transformacao_y"],
+        estatisticas_df=est_df,
+        dicotomicas=info["dicotomicas"],
+        codigo_alocado=info["codigo_alocado"],
+        percentuais=info["percentuais"],
+    )
+
+    if resultado is None:
+        raise HTTPException(status_code=400, detail="Erro ao calcular avaliacao")
+
+    session.avaliacoes_visualizacao.append(resultado)
+
+    indice = int(indice_base) - 1 if indice_base else 0
+    html = formatar_avaliacao_html(session.avaliacoes_visualizacao, indice_base=indice, elem_id_excluir="excluir-aval-viz")
+    choices = [str(i + 1) for i in range(len(session.avaliacoes_visualizacao))]
+    base_value = indice_base if indice_base else "1"
+
+    return {
+        "resultado_html": html,
+        "avaliacoes": sanitize_value(session.avaliacoes_visualizacao),
+        "base_choices": choices,
+        "base_value": base_value,
+    }
+
+
+def limpar_avaliacoes(session: SessionState) -> dict[str, Any]:
+    session.avaliacoes_visualizacao = []
+    return {
+        "resultado_html": "",
+        "avaliacoes": [],
+        "base_choices": [],
+        "base_value": None,
+    }
+
+
+def excluir_avaliacao(session: SessionState, indice_str: str | None, indice_base_str: str | None) -> dict[str, Any]:
+    if not indice_str or not session.avaliacoes_visualizacao:
+        return {
+            "resultado_html": None,
+            "avaliacoes": sanitize_value(session.avaliacoes_visualizacao),
+            "base_choices": [str(i + 1) for i in range(len(session.avaliacoes_visualizacao))],
+            "base_value": indice_base_str,
+        }
+
+    try:
+        idx = int(indice_str.strip()) - 1
+    except Exception:
+        return {
+            "resultado_html": None,
+            "avaliacoes": sanitize_value(session.avaliacoes_visualizacao),
+            "base_choices": [str(i + 1) for i in range(len(session.avaliacoes_visualizacao))],
+            "base_value": indice_base_str,
+        }
+
+    if idx < 0 or idx >= len(session.avaliacoes_visualizacao):
+        return {
+            "resultado_html": None,
+            "avaliacoes": sanitize_value(session.avaliacoes_visualizacao),
+            "base_choices": [str(i + 1) for i in range(len(session.avaliacoes_visualizacao))],
+            "base_value": indice_base_str,
+        }
+
+    nova_lista = [a for i, a in enumerate(session.avaliacoes_visualizacao) if i != idx]
+    session.avaliacoes_visualizacao = nova_lista
+
+    if not nova_lista:
+        return {
+            "resultado_html": "",
+            "avaliacoes": [],
+            "base_choices": [],
+            "base_value": None,
+        }
+
+    base = int(indice_base_str) - 1 if indice_base_str else 0
+    if base >= len(nova_lista):
+        base = len(nova_lista) - 1
+    if base < 0:
+        base = 0
+
+    html = formatar_avaliacao_html(nova_lista, indice_base=base, elem_id_excluir="excluir-aval-viz")
+    choices = [str(i + 1) for i in range(len(nova_lista))]
+
+    return {
+        "resultado_html": html,
+        "avaliacoes": sanitize_value(nova_lista),
+        "base_choices": choices,
+        "base_value": str(base + 1),
+    }
+
+
+def atualizar_base(session: SessionState, indice_base_str: str | None) -> dict[str, Any]:
+    if not session.avaliacoes_visualizacao:
+        return {"resultado_html": ""}
+    indice = int(indice_base_str) - 1 if indice_base_str else 0
+    html = formatar_avaliacao_html(session.avaliacoes_visualizacao, indice_base=indice, elem_id_excluir="excluir-aval-viz")
+    return {"resultado_html": html}
+
+
+def exportar_avaliacoes(session: SessionState) -> str:
+    caminho = exportar_avaliacoes_excel(session.avaliacoes_visualizacao)
+    if not caminho:
+        raise HTTPException(status_code=400, detail="Sem avaliacoes para exportar")
+    return caminho
+
+
+def limpar_tudo_visualizacao(session: SessionState) -> dict[str, Any]:
+    session.reset_visualizacao()
+    return {
+        "status": "",
+        "badge_html": "",
+    }

backend/requirements.txt

@@ -0,0 +1,16 @@
+fastapi>=0.111.0
+uvicorn[standard]>=0.30.0
+python-multipart>=0.0.9
+pydantic>=2.7.0
+pandas
+numpy
+statsmodels
+scipy
+plotly
+folium
+branca
+joblib
+openpyxl
+geopandas
+fiona
+gradio>=4.0

backend/run_backend.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload

frontend/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="pt-BR">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>MESA Frame</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "mesa-frame-frontend",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "plotly.js-dist-min": "^2.35.2",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-plotly.js": "^2.6.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.3.1",
+    "vite": "^5.4.8"
+  }
+}

frontend/src/App.jsx

@@ -0,0 +1,79 @@
+import React, { useEffect, useState } from 'react'
+import { api } from './api'
+import ElaboracaoTab from './components/ElaboracaoTab'
+import VisualizacaoTab from './components/VisualizacaoTab'
+
+const TABS = [
+  { key: 'Pesquisa', label: 'Pesquisa', hint: 'Módulo em desenvolvimento' },
+  { key: 'Elaboração/Edição', label: 'Elaboração/Edição', hint: 'Fluxo completo de modelagem' },
+  { key: 'Visualização/Avaliação', label: 'Visualização/Avaliação', hint: 'Leitura e avaliação de modelos .dai' },
+]
+
+export default function App() {
+  const [activeTab, setActiveTab] = useState(TABS[0].key)
+  const [sessionId, setSessionId] = useState('')
+  const [bootError, setBootError] = useState('')
+
+  useEffect(() => {
+    let mounted = true
+
+    api.createSession()
+      .then((resp) => {
+        if (mounted) setSessionId(resp.session_id)
+      })
+      .catch((err) => {
+        if (mounted) setBootError(err.message)
+      })
+
+    return () => {
+      mounted = false
+    }
+  }, [])
+
+  return (
+    <div className="app-shell">
+      <header className="app-header app-header-logo-only">
+        <div className="brand-mark" aria-hidden="true">
+          <img src="/logo_mesa.png" alt="MESA" />
+        </div>
+      </header>
+
+      <nav className="tabs" aria-label="Navegação principal">
+        {TABS.map((tab) => {
+          const active = tab.key === activeTab
+          return (
+            <button
+              key={tab.key}
+              className={active ? 'tab-pill active' : 'tab-pill'}
+              onClick={() => setActiveTab(tab.key)}
+              type="button"
+            >
+              <strong>{tab.label}</strong>
+              <small>{tab.hint}</small>
+            </button>
+          )
+        })}
+      </nav>
+
+      {bootError ? <div className="error-line">Falha ao criar sessão: {bootError}</div> : null}
+
+      {activeTab === 'Pesquisa' ? (
+        <section className="workflow-section placeholder-section" style={{ '--section-order': 1 }}>
+          <header className="section-head">
+            <span className="section-index">1</span>
+            <div className="section-title-wrap">
+              <h3>Pesquisa</h3>
+              <p>Este módulo segue em desenvolvimento no app original e foi mantido com o mesmo status.</p>
+            </div>
+          </header>
+          <div className="section-body">
+            <div className="empty-box">Aba disponível para expansão futura.</div>
+          </div>
+        </section>
+      ) : null}
+
+      {activeTab === 'Elaboração/Edição' ? <ElaboracaoTab sessionId={sessionId} /> : null}
+      {activeTab === 'Visualização/Avaliação' ? <VisualizacaoTab sessionId={sessionId} /> : null}
+    </div>
+  )
+}

frontend/src/api.js

@@ -0,0 +1,165 @@
+const API_BASE = import.meta.env.VITE_API_BASE || 'http://localhost:8000'
+
+async function handleResponse(response) {
+  if (!response.ok) {
+    let detail = 'Erro inesperado'
+    try {
+      const data = await response.json()
+      detail = data.detail || detail
+    } catch {
+      detail = response.statusText || detail
+    }
+    throw new Error(detail)
+  }
+  return response
+}
+
+async function postJson(path, body) {
+  const response = await fetch(`${API_BASE}${path}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+  await handleResponse(response)
+  return response.json()
+}
+
+async function postForm(path, formData) {
+  const response = await fetch(`${API_BASE}${path}`, {
+    method: 'POST',
+    body: formData,
+  })
+  await handleResponse(response)
+  return response.json()
+}
+
+async function getJson(path) {
+  const response = await fetch(`${API_BASE}${path}`)
+  await handleResponse(response)
+  return response.json()
+}
+
+async function getBlob(path) {
+  const response = await fetch(`${API_BASE}${path}`)
+  await handleResponse(response)
+  return response.blob()
+}
+
+export function downloadBlob(blob, fileName) {
+  const url = URL.createObjectURL(blob)
+  const a = document.createElement('a')
+  a.href = url
+  a.download = fileName
+  document.body.appendChild(a)
+  a.click()
+  a.remove()
+  URL.revokeObjectURL(url)
+}
+
+export const api = {
+  createSession: () => postJson('/api/sessions', {}),
+
+  uploadElaboracaoFile(sessionId, file) {
+    const form = new FormData()
+    form.append('session_id', sessionId)
+    form.append('file', file)
+    return postForm('/api/elaboracao/upload', form)
+  },
+
+  confirmSheet: (sessionId, sheetName) => postJson('/api/elaboracao/confirm-sheet', { session_id: sessionId, sheet_name: sheetName }),
+  mapCoords: (sessionId, colLat, colLon) => postJson('/api/elaboracao/map-coords', { session_id: sessionId, col_lat: colLat, col_lon: colLon }),
+  geocodificar: (sessionId, colCdlog, colNum, auto200) => postJson('/api/elaboracao/geocodificar', { session_id: sessionId, col_cdlog: colCdlog, col_num: colNum, auto_200: auto200 }),
+  geocodificarCorrecoes: (sessionId, correcoes, auto200) => postJson('/api/elaboracao/geocodificar-correcoes', { session_id: sessionId, correcoes, auto_200: auto200 }),
+
+  applySelection(payload) {
+    return postJson('/api/elaboracao/apply-selection', payload)
+  },
+  classifyElaboracaoX: (sessionId, colunasX) => postJson('/api/elaboracao/classify-x', { session_id: sessionId, colunas_x: colunasX }),
+
+  searchTransformations: (sessionId, grauCoef, grauF) => postJson('/api/elaboracao/search-transformations', {
+    session_id: sessionId,
+    grau_min_coef: grauCoef,
+    grau_min_f: grauF,
+  }),
+
+  adoptSuggestion: (sessionId, indice) => postJson('/api/elaboracao/adopt-suggestion', { session_id: sessionId, indice }),
+
+  fitModel(payload) {
+    return postJson('/api/elaboracao/fit-model', payload)
+  },
+
+  updateModelDispersao: (sessionId, tipo) => postJson('/api/elaboracao/model-dispersao', { session_id: sessionId, tipo }),
+
+  applyOutlierFilters: (sessionId, filtros) => postJson('/api/elaboracao/outliers/apply-filters', { session_id: sessionId, filtros }),
+  restartOutlierIteration: (sessionId, outliersTexto, reincluirTexto, grauCoef, grauF) => postJson('/api/elaboracao/outliers/restart', {
+    session_id: sessionId,
+    outliers_texto: outliersTexto,
+    reincluir_texto: reincluirTexto,
+    grau_min_coef: grauCoef,
+    grau_min_f: grauF,
+  }),
+  outlierSummary: (sessionId, outliersTexto, reincluirTexto) => postJson('/api/elaboracao/outliers/summary', {
+    session_id: sessionId,
+    outliers_texto: outliersTexto,
+    reincluir_texto: reincluirTexto,
+  }),
+  clearOutlierHistory: (sessionId) => postJson('/api/elaboracao/outliers/clear-history', { session_id: sessionId }),
+
+  evaluationFieldsElab: (sessionId) => postJson('/api/elaboracao/evaluation/fields', { session_id: sessionId }),
+  evaluationCalculateElab: (sessionId, valoresX, indiceBase) => postJson('/api/elaboracao/evaluation/calculate', {
+    session_id: sessionId,
+    valores_x: valoresX,
+    indice_base: indiceBase,
+  }),
+  evaluationClearElab: (sessionId) => postJson('/api/elaboracao/evaluation/clear', { session_id: sessionId }),
+  evaluationDeleteElab: (sessionId, indice, indiceBase) => postJson('/api/elaboracao/evaluation/delete', {
+    session_id: sessionId,
+    indice,
+    indice_base: indiceBase,
+  }),
+  getAvaliadores: () => getJson('/api/elaboracao/avaliadores'),
+  evaluationBaseElab: (sessionId, indiceBase) => postJson('/api/elaboracao/evaluation/base', {
+    session_id: sessionId,
+    indice_base: indiceBase,
+  }),
+  exportEvaluationElab: async (sessionId) => getBlob(`/api/elaboracao/evaluation/export?session_id=${encodeURIComponent(sessionId)}`),
+  exportModel: async (sessionId, nomeArquivo, elaborador) => {
+    const response = await fetch(`${API_BASE}/api/elaboracao/export-model`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ session_id: sessionId, nome_arquivo: nomeArquivo, elaborador }),
+    })
+    await handleResponse(response)
+    return response.blob()
+  },
+  exportBase: (sessionId, filtered = true) => getBlob(`/api/elaboracao/export-base?session_id=${encodeURIComponent(sessionId)}&filtered=${String(filtered)}`),
+  updateElaboracaoMap: (sessionId, variavelMapa) => postJson('/api/elaboracao/map/update', { session_id: sessionId, variavel_mapa: variavelMapa }),
+  getContext: (sessionId) => getJson(`/api/elaboracao/context?session_id=${encodeURIComponent(sessionId)}`),
+
+  uploadVisualizacaoFile(sessionId, file) {
+    const form = new FormData()
+    form.append('session_id', sessionId)
+    form.append('file', file)
+    return postForm('/api/visualizacao/upload', form)
+  },
+  exibirVisualizacao: (sessionId) => postJson('/api/visualizacao/exibir', { session_id: sessionId }),
+  updateVisualizacaoMap: (sessionId, variavelMapa) => postJson('/api/visualizacao/map/update', { session_id: sessionId, variavel_mapa: variavelMapa }),
+  evaluationFieldsViz: (sessionId) => postJson('/api/visualizacao/evaluation/fields', { session_id: sessionId }),
+  evaluationCalculateViz: (sessionId, valoresX, indiceBase) => postJson('/api/visualizacao/evaluation/calculate', {
+    session_id: sessionId,
+    valores_x: valoresX,
+    indice_base: indiceBase,
+  }),
+  evaluationClearViz: (sessionId) => postJson('/api/visualizacao/evaluation/clear', { session_id: sessionId }),
+  evaluationDeleteViz: (sessionId, indice, indiceBase) => postJson('/api/visualizacao/evaluation/delete', {
+    session_id: sessionId,
+    indice,
+    indice_base: indiceBase,
+  }),
+  evaluationBaseViz: (sessionId, indiceBase) => postJson('/api/visualizacao/evaluation/base', {
+    session_id: sessionId,
+    indice_base: indiceBase,
+  }),
+  exportEvaluationViz: (sessionId) => getBlob(`/api/visualizacao/evaluation/export?session_id=${encodeURIComponent(sessionId)}`),
+  clearVisualizacao: (sessionId) => postJson('/api/visualizacao/clear', { session_id: sessionId }),
+}

frontend/src/components/DataTable.jsx

@@ -0,0 +1,33 @@
+import React from 'react'
+
+export default function DataTable({ table, maxHeight = 320 }) {
+  if (!table || !table.columns || !table.rows) {
+    return <div className="empty-box">Sem dados.</div>
+  }
+
+  return (
+    <div className="table-wrapper" style={{ maxHeight }}>
+      <table>
+        <thead>
+          <tr>
+            {table.columns.map((col) => (
+              <th key={col}>{col}</th>
+            ))}
+          </tr>
+        </thead>
+        <tbody>
+          {table.rows.map((row, i) => (
+            <tr key={i}>
+              {table.columns.map((col) => (
+                <td key={`${i}-${col}`}>{String(row[col] ?? '')}</td>
+              ))}
+            </tr>
+          ))}
+        </tbody>
+      </table>
+      {table.truncated ? (
+        <div className="table-hint">Mostrando {table.returned_rows} de {table.total_rows} linhas.</div>
+      ) : null}
+    </div>
+  )
+}

frontend/src/components/ElaboracaoTab.jsx

@@ -0,0 +1,1331 @@
+import React, { useEffect, useMemo, useRef, useState } from 'react'
+import { api, downloadBlob } from '../api'
+import DataTable from './DataTable'
+import MapFrame from './MapFrame'
+import PlotFigure from './PlotFigure'
+import SectionBlock from './SectionBlock'
+
+const OPERADORES = ['<=', '>=', '<', '>', '=']
+const GRAUS_COEF = [
+  { value: 0, label: 'Sem enquadramento' },
+  { value: 1, label: 'Grau I (p<=30%)' },
+  { value: 2, label: 'Grau II (p<=20%)' },
+  { value: 3, label: 'Grau III (p<=10%)' },
+]
+const GRAUS_F = [
+  { value: 0, label: 'Sem enquadramento' },
+  { value: 1, label: 'Grau I (alpha=5%)' },
+  { value: 2, label: 'Grau II (alpha=2%)' },
+  { value: 3, label: 'Grau III (alpha=1%)' },
+]
+const GRAU_LABEL_CURTO = {
+  0: 'Sem enq.',
+  1: 'Grau I',
+  2: 'Grau II',
+  3: 'Grau III',
+}
+
+function grauBadgeClass(value) {
+  const grau = Number(value)
+  if (grau >= 3) return 'grau-badge grau-3'
+  if (grau === 2) return 'grau-badge grau-2'
+  if (grau === 1) return 'grau-badge grau-1'
+  return 'grau-badge grau-0'
+}
+
+function defaultFiltros() {
+  return [
+    { variavel: 'Resíduo Pad.', operador: '<=', valor: -2 },
+    { variavel: 'Resíduo Pad.', operador: '>=', valor: 2 },
+  ]
+}
+
+function joinSelection(values) {
+  return values.join(', ')
+}
+
+function formatConselhoRegistro(elaborador) {
+  if (!elaborador) return ''
+  const conselho = String(elaborador.conselho || '').trim()
+  const estado = String(elaborador.estado_conselho || '').trim()
+  const numero = String(elaborador.numero_conselho || '').trim()
+  if (conselho && estado && numero) return `${conselho}/${estado} ${numero}`
+  return [conselho, numero, estado].filter(Boolean).join(' ')
+}
+
+function formatTransformacaoBadge(transformacao) {
+  const valor = String(transformacao || '').trim()
+  if (!valor || valor === '(x)' || valor === '(y)' || valor === 'x' || valor === 'y') return ''
+  return valor
+}
+
+export default function ElaboracaoTab({ sessionId }) {
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState('')
+  const [status, setStatus] = useState('')
+
+  const [uploadedFile, setUploadedFile] = useState(null)
+  const [requiresSheet, setRequiresSheet] = useState(false)
+  const [sheetOptions, setSheetOptions] = useState([])
+  const [selectedSheet, setSelectedSheet] = useState('')
+  const [elaborador, setElaborador] = useState(null)
+
+  const [dados, setDados] = useState(null)
+  const [mapaHtml, setMapaHtml] = useState('')
+  const [mapaVariavel, setMapaVariavel] = useState('Visualização Padrão')
+
+  const [coordsInfo, setCoordsInfo] = useState(null)
+  const [manualLat, setManualLat] = useState('')
+  const [manualLon, setManualLon] = useState('')
+  const [geoCdlog, setGeoCdlog] = useState('')
+  const [geoNum, setGeoNum] = useState('')
+  const [geoAuto200, setGeoAuto200] = useState(false)
+  const [geoStatusHtml, setGeoStatusHtml] = useState('')
+  const [geoFalhasHtml, setGeoFalhasHtml] = useState('')
+  const [geoCorrecoes, setGeoCorrecoes] = useState([])
+  const [manualMapError, setManualMapError] = useState('')
+  const [geoProcessError, setGeoProcessError] = useState('')
+  const [coordsMode, setCoordsMode] = useState('menu')
+
+  const [colunasNumericas, setColunasNumericas] = useState([])
+  const [colunaY, setColunaY] = useState('')
+  const [colunasX, setColunasX] = useState([])
+  const [dicotomicas, setDicotomicas] = useState([])
+  const [codigoAlocado, setCodigoAlocado] = useState([])
+  const [percentuais, setPercentuais] = useState([])
+
+  const [outliersAnteriores, setOutliersAnteriores] = useState([])
+  const [iteracao, setIteracao] = useState(1)
+
+  const [selection, setSelection] = useState(null)
+  const [grauCoef, setGrauCoef] = useState(1)
+  const [grauF, setGrauF] = useState(0)
+
+  const [transformacaoY, setTransformacaoY] = useState('(x)')
+  const [transformacoesX, setTransformacoesX] = useState({})
+
+  const [fit, setFit] = useState(null)
+  const [tipoDispersao, setTipoDispersao] = useState('Variáveis Independentes Transformadas X Variável Dependente Transformada')
+
+  const [filtros, setFiltros] = useState(defaultFiltros())
+  const [outliersTexto, setOutliersTexto] = useState('')
+  const [reincluirTexto, setReincluirTexto] = useState('')
+  const [resumoOutliers, setResumoOutliers] = useState('Excluidos: 0 | A excluir: 0 | A reincluir: 0 | Total: 0')
+  const [outliersHtml, setOutliersHtml] = useState('')
+
+  const [camposAvaliacao, setCamposAvaliacao] = useState([])
+  const [valoresAvaliacao, setValoresAvaliacao] = useState({})
+  const [resultadoAvaliacaoHtml, setResultadoAvaliacaoHtml] = useState('')
+  const [baseChoices, setBaseChoices] = useState([])
+  const [baseValue, setBaseValue] = useState('')
+  const [deleteAvalIndex, setDeleteAvalIndex] = useState('')
+
+  const [nomeArquivoExport, setNomeArquivoExport] = useState('modelo_mesa')
+  const [avaliadores, setAvaliadores] = useState([])
+  const [avaliadorSelecionado, setAvaliadorSelecionado] = useState('')
+  const [tipoFonteDados, setTipoFonteDados] = useState('')
+  const marcarTodasXRef = useRef(null)
+  const classificarXReqRef = useRef(0)
+
+  const mapaChoices = useMemo(() => ['Visualização Padrão', ...colunasNumericas], [colunasNumericas])
+  const colunasXDisponiveis = useMemo(
+    () => colunasNumericas.filter((coluna) => coluna !== colunaY),
+    [colunasNumericas, colunaY],
+  )
+  const todasXMarcadas = useMemo(
+    () => colunasXDisponiveis.length > 0 && colunasXDisponiveis.every((coluna) => colunasX.includes(coluna)),
+    [colunasXDisponiveis, colunasX],
+  )
+  const algumaXMarcada = useMemo(
+    () => colunasX.some((coluna) => colunasXDisponiveis.includes(coluna)),
+    [colunasX, colunasXDisponiveis],
+  )
+  const conselhoRegistro = useMemo(() => formatConselhoRegistro(elaborador), [elaborador])
+  const elaboradorMeta = useMemo(() => {
+    if (!elaborador) return []
+    return [elaborador.cargo, conselhoRegistro, elaborador.matricula_sem_digito ? `Matricula ${elaborador.matricula_sem_digito}` : '', elaborador.lotacao].filter(Boolean)
+  }, [elaborador, conselhoRegistro])
+  const transformacaoYBadge = useMemo(() => formatTransformacaoBadge(transformacaoY), [transformacaoY])
+  const variaveisIndependentesBadge = useMemo(() => {
+    return colunasX.map((coluna) => ({
+      coluna,
+      transformacao: formatTransformacaoBadge(transformacoesX[coluna]),
+    }))
+  }, [colunasX, transformacoesX])
+  const showCoordsPanel = Boolean(
+    coordsInfo && (
+      !coordsInfo.tem_coords ||
+      coordsMode === 'geocodificar' ||
+      geoStatusHtml ||
+      geoFalhasHtml ||
+      geoCorrecoes.length > 0 ||
+      manualMapError ||
+      geoProcessError
+    ),
+  )
+
+  useEffect(() => {
+    if (coordsInfo && !coordsInfo.tem_coords) {
+      setCoordsMode('menu')
+    }
+  }, [coordsInfo])
+
+  useEffect(() => {
+    if (marcarTodasXRef.current) {
+      marcarTodasXRef.current.indeterminate = algumaXMarcada && !todasXMarcadas
+    }
+  }, [algumaXMarcada, todasXMarcadas])
+
+  useEffect(() => {
+    if (!sessionId || tipoFonteDados === 'dai') return undefined
+
+    const selecionadas = colunasXDisponiveis.filter((coluna) => colunasX.includes(coluna))
+    if (selecionadas.length === 0) {
+      setDicotomicas([])
+      setCodigoAlocado([])
+      setPercentuais([])
+      return undefined
+    }
+
+    classificarXReqRef.current += 1
+    const requestId = classificarXReqRef.current
+    let ativo = true
+
+    api.classifyElaboracaoX(sessionId, selecionadas)
+      .then((resp) => {
+        if (!ativo || requestId !== classificarXReqRef.current) return
+        setDicotomicas(resp.dicotomicas || [])
+        setCodigoAlocado(resp.codigo_alocado || [])
+        setPercentuais(resp.percentuais || [])
+      })
+      .catch(() => {
+        if (!ativo || requestId !== classificarXReqRef.current) return
+        setDicotomicas((prev) => prev.filter((item) => selecionadas.includes(item)))
+        setCodigoAlocado((prev) => prev.filter((item) => selecionadas.includes(item)))
+        setPercentuais((prev) => prev.filter((item) => selecionadas.includes(item)))
+      })
+
+    return () => {
+      ativo = false
+    }
+  }, [sessionId, tipoFonteDados, colunasX, colunasXDisponiveis])
+
+  useEffect(() => {
+    let ativo = true
+    if (!sessionId) return () => {
+      ativo = false
+    }
+
+    async function carregarAvaliadores() {
+      try {
+        const resp = await api.getAvaliadores()
+        if (!ativo) return
+        setAvaliadores(resp.avaliadores || [])
+      } catch {
+        if (!ativo) return
+        setAvaliadores([])
+      }
+    }
+
+    carregarAvaliadores()
+    return () => {
+      ativo = false
+    }
+  }, [sessionId])
+
+  async function withBusy(fn) {
+    setLoading(true)
+    setError('')
+    try {
+      await fn()
+    } catch (err) {
+      setError(err.message)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  function parseCorrecoes(table) {
+    if (!table?.rows) return []
+    return table.rows.map((row) => {
+      const linha = row['Nº Linha'] ?? row['No Linha'] ?? row['linha'] ?? row['_index']
+      return {
+        linha: Number(linha),
+        numero_corrigido: row['Nº Corrigido'] ?? row['No Corrigido'] ?? '',
+      }
+    })
+  }
+
+  function applyBaseResponse(resp, options = {}) {
+    const resetXSelection = Boolean(options.resetXSelection)
+    if (resp.status) setStatus(resp.status)
+    if (resp.dados) setDados(resp.dados)
+    if (resp.mapa_html) setMapaHtml(resp.mapa_html)
+    if (resp.colunas_numericas) setColunasNumericas(resp.colunas_numericas)
+    if (resp.coluna_y_padrao) setColunaY(resp.coluna_y_padrao)
+
+    if (resp.contexto && !resetXSelection) {
+      setColunaY(resp.contexto.coluna_y || resp.coluna_y_padrao || '')
+      setColunasX(resp.contexto.colunas_x || [])
+      setDicotomicas(resp.contexto.dicotomicas || [])
+      setCodigoAlocado(resp.contexto.codigo_alocado || [])
+      setPercentuais(resp.contexto.percentuais || [])
+      setOutliersAnteriores(resp.contexto.outliers_anteriores || [])
+      setIteracao(resp.contexto.iteracao || 1)
+    } else if (resetXSelection) {
+      setColunasX([])
+      setDicotomicas([])
+      setCodigoAlocado([])
+      setPercentuais([])
+      setTransformacaoY('(x)')
+      setTransformacoesX({})
+      setOutliersAnteriores([])
+      setIteracao(1)
+      setSelection(null)
+      setFit(null)
+      setCamposAvaliacao([])
+      setResultadoAvaliacaoHtml('')
+      setOutliersHtml('')
+    }
+
+    if (resp.coords) {
+      setCoordsInfo(resp.coords)
+      setManualLat(resp.coords.colunas_disponiveis?.[0] || '')
+      setManualLon(resp.coords.colunas_disponiveis?.[1] || '')
+      setGeoCdlog(resp.coords.cdlog_auto || '')
+      setGeoNum(resp.coords.num_auto || '')
+    }
+
+    if (resp.selection && !resetXSelection) {
+      applySelectionResponse(resp.selection)
+    }
+
+    if (resp.fit && !resetXSelection) {
+      applyFitResponse(resp.fit)
+    }
+  }
+
+  function applySelectionResponse(resp) {
+    setSelection(resp)
+    if (resp.transformacao_y) {
+      setTransformacaoY(resp.transformacao_y)
+    }
+
+    const map = {}
+    ;(resp.transform_fields || []).forEach((field) => {
+      map[field.coluna] = field.valor || '(x)'
+    })
+    setTransformacoesX(map)
+
+    if (resp.busca) {
+      setGrauCoef(resp.busca.grau_coef ?? 1)
+      setGrauF(resp.busca.grau_f ?? 0)
+    }
+
+    if (resp.resumo_outliers) {
+      setResumoOutliers(resp.resumo_outliers)
+    }
+    if (typeof resp.outliers_html !== 'undefined') {
+      setOutliersHtml(resp.outliers_html || '')
+    }
+
+    if (resp.mapa_html) {
+      setMapaHtml(resp.mapa_html)
+    }
+  }
+
+  function applyFitResponse(resp) {
+    setFit(resp)
+    setResumoOutliers(resp.resumo_outliers || resumoOutliers)
+    setCamposAvaliacao(resp.avaliacao_campos || [])
+    const init = {}
+    ;(resp.avaliacao_campos || []).forEach((campo) => {
+      init[campo.coluna] = ''
+    })
+    setValoresAvaliacao(init)
+    setResultadoAvaliacaoHtml('')
+    setBaseChoices([])
+    setBaseValue('')
+  }
+
+  async function onUploadClick() {
+    if (!uploadedFile || !sessionId) return
+    await withBusy(async () => {
+      const nomeArquivo = String(uploadedFile?.name || '').toLowerCase()
+      const uploadEhDai = nomeArquivo.endsWith('.dai')
+      setTipoFonteDados(uploadEhDai ? 'dai' : 'tabular')
+      const resp = await api.uploadElaboracaoFile(sessionId, uploadedFile)
+      setManualMapError('')
+      setGeoProcessError('')
+      setGeoStatusHtml('')
+      setGeoFalhasHtml('')
+      setGeoCorrecoes([])
+      setElaborador(resp.elaborador || null)
+      setAvaliadorSelecionado(resp.elaborador?.nome_completo || '')
+      setRequiresSheet(Boolean(resp.requires_sheet))
+      setSheetOptions(resp.sheets || [])
+      setSelectedSheet(resp.sheet_selected || '')
+      if (!resp.requires_sheet) {
+        const origemResp = String(resp.tipo || '').toLowerCase()
+        setTipoFonteDados(origemResp === 'dai' ? 'dai' : 'tabular')
+        const resetXSelection = String(resp.tipo || '').toLowerCase() !== 'dai'
+        applyBaseResponse(resp, { resetXSelection })
+      } else if (resp.status) {
+        setTipoFonteDados('tabular')
+        setSelection(null)
+        setFit(null)
+        setColunasX([])
+        setDicotomicas([])
+        setCodigoAlocado([])
+        setPercentuais([])
+        setTransformacaoY('(x)')
+        setTransformacoesX({})
+        setCamposAvaliacao([])
+        setResultadoAvaliacaoHtml('')
+        setStatus(resp.status)
+      }
+    })
+  }
+
+  async function onConfirmSheet() {
+    if (!selectedSheet || !sessionId) return
+    await withBusy(async () => {
+      const resp = await api.confirmSheet(sessionId, selectedSheet)
+      setTipoFonteDados('tabular')
+      setManualMapError('')
+      setGeoProcessError('')
+      setGeoStatusHtml('')
+      setGeoFalhasHtml('')
+      setGeoCorrecoes([])
+      setElaborador(resp.elaborador || null)
+      setAvaliadorSelecionado(resp.elaborador?.nome_completo || '')
+      setRequiresSheet(false)
+      applyBaseResponse(resp, { resetXSelection: true })
+    })
+  }
+
+  async function onMapCoords() {
+    if (!manualLat || !manualLon || !sessionId) return
+    setLoading(true)
+    setError('')
+    setManualMapError('')
+    setGeoProcessError('')
+    try {
+      const resp = await api.mapCoords(sessionId, manualLat, manualLon)
+      setStatus(resp.status)
+      setMapaHtml(resp.mapa_html)
+      setDados(resp.dados)
+      setCoordsInfo(resp.coords)
+      setGeoStatusHtml('')
+      setGeoFalhasHtml('')
+      setGeoCorrecoes([])
+    } catch (err) {
+      setManualMapError(err.message || 'Falha ao mapear coordenadas.')
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  async function onGeocodificar() {
+    if (!geoCdlog || !geoNum || !sessionId) return
+    setLoading(true)
+    setError('')
+    setManualMapError('')
+    setGeoProcessError('')
+    try {
+      const resp = await api.geocodificar(sessionId, geoCdlog, geoNum, geoAuto200)
+      setGeoStatusHtml(resp.status_html || '')
+      setGeoFalhasHtml(resp.falhas_html || '')
+      setGeoCorrecoes(parseCorrecoes(resp.falhas_para_correcao))
+      setMapaHtml(resp.mapa_html || '')
+      setDados(resp.dados || null)
+      setCoordsInfo(resp.coords || null)
+      setCoordsMode('geocodificar')
+    } catch (err) {
+      setGeoProcessError(err.message || 'Falha ao geocodificar.')
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  async function onAplicarCorrecoesGeo() {
+    if (!sessionId) return
+    setLoading(true)
+    setError('')
+    setManualMapError('')
+    setGeoProcessError('')
+    try {
+      const resp = await api.geocodificarCorrecoes(sessionId, geoCorrecoes, geoAuto200)
+      setGeoStatusHtml(resp.status_html || '')
+      setGeoFalhasHtml(resp.falhas_html || '')
+      setGeoCorrecoes(parseCorrecoes(resp.falhas_para_correcao))
+      setMapaHtml(resp.mapa_html || '')
+      setDados(resp.dados || null)
+      setCoordsInfo(resp.coords || null)
+      setCoordsMode('geocodificar')
+    } catch (err) {
+      setGeoProcessError(err.message || 'Falha ao aplicar correções.')
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  async function onApplySelection() {
+    if (!sessionId || !colunaY || colunasX.length === 0) return
+    await withBusy(async () => {
+      const resp = await api.applySelection({
+        session_id: sessionId,
+        coluna_y: colunaY,
+        colunas_x: colunasX,
+        dicotomicas: dicotomicas,
+        codigo_alocado: codigoAlocado,
+        percentuais: percentuais,
+        outliers_anteriores: outliersAnteriores,
+        grau_min_coef: grauCoef,
+        grau_min_f: grauF,
+      })
+      applySelectionResponse(resp)
+      setFit(null)
+      setCamposAvaliacao([])
+      setResultadoAvaliacaoHtml('')
+    })
+  }
+
+  async function onSearchTransform() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const busca = await api.searchTransformations(sessionId, grauCoef, grauF)
+      setSelection((prev) => ({ ...prev, busca }))
+      setGrauCoef(busca.grau_coef ?? grauCoef)
+      setGrauF(busca.grau_f ?? grauF)
+    })
+  }
+
+  async function onAdoptSuggestion(idx) {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.adoptSuggestion(sessionId, idx)
+      setTransformacaoY(resp.transformacao_y || '(x)')
+      setTransformacoesX(resp.transformacoes_x || {})
+    })
+  }
+
+  async function onFitModel() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.fitModel({
+        session_id: sessionId,
+        transformacao_y: transformacaoY,
+        transformacoes_x: transformacoesX,
+        dicotomicas,
+        codigo_alocado: codigoAlocado,
+        percentuais,
+      })
+      applyFitResponse(resp)
+    })
+  }
+
+  async function onTipoDispersaoChange(nextTipo) {
+    setTipoDispersao(nextTipo)
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.updateModelDispersao(sessionId, nextTipo)
+      setFit((prev) => ({ ...prev, grafico_dispersao_modelo: resp.grafico }))
+    })
+  }
+
+  async function onApplyOutlierFilters() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const filtrosValidos = filtros.filter((f) => f.variavel && f.operador)
+      const resp = await api.applyOutlierFilters(sessionId, filtrosValidos)
+      setOutliersTexto(resp.texto || '')
+    })
+  }
+
+  async function onSummaryOutliers() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.outlierSummary(sessionId, outliersTexto, reincluirTexto)
+      setResumoOutliers(resp.resumo)
+    })
+  }
+
+  async function onRestartIteration() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.restartOutlierIteration(sessionId, outliersTexto, reincluirTexto, grauCoef, grauF)
+      applySelectionResponse(resp)
+      setOutliersAnteriores(resp.outliers_anteriores || [])
+      setIteracao(resp.iteracao || iteracao)
+      setOutliersTexto('')
+      setReincluirTexto('')
+      setFit(null)
+      setResultadoAvaliacaoHtml('')
+      setResumoOutliers(resp.resumo_outliers || resumoOutliers)
+      if (typeof window !== 'undefined') {
+        window.scrollTo({ top: 0, behavior: 'smooth' })
+      }
+    })
+  }
+
+  async function onClearHistory() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.clearOutlierHistory(sessionId)
+      setDados(resp.dados)
+      setMapaHtml(resp.mapa_html)
+      setResumoOutliers(resp.resumo_outliers || 'Excluidos: 0 | A excluir: 0 | A reincluir: 0 | Total: 0')
+      setOutliersAnteriores([])
+      setIteracao(1)
+      setSelection(null)
+      setFit(null)
+      setCamposAvaliacao([])
+      setResultadoAvaliacaoHtml('')
+      setOutliersHtml(resp.outliers_html || '')
+    })
+  }
+
+  async function onCalculateAvaliacao() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.evaluationCalculateElab(sessionId, valoresAvaliacao, baseValue || null)
+      setResultadoAvaliacaoHtml(resp.resultado_html || '')
+      setBaseChoices(resp.base_choices || [])
+      setBaseValue(resp.base_value || '')
+    })
+  }
+
+  async function onClearAvaliacao() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.evaluationClearElab(sessionId)
+      setResultadoAvaliacaoHtml(resp.resultado_html || '')
+      setBaseChoices(resp.base_choices || [])
+      setBaseValue(resp.base_value || '')
+    })
+  }
+
+  async function onDeleteAvaliacao() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.evaluationDeleteElab(sessionId, deleteAvalIndex, baseValue || null)
+      setResultadoAvaliacaoHtml(resp.resultado_html || '')
+      setBaseChoices(resp.base_choices || [])
+      setBaseValue(resp.base_value || '')
+      setDeleteAvalIndex('')
+    })
+  }
+
+  async function onBaseChange(value) {
+    setBaseValue(value)
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.evaluationBaseElab(sessionId, value)
+      setResultadoAvaliacaoHtml(resp.resultado_html || '')
+    })
+  }
+
+  async function onExportAvaliacoes() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const blob = await api.exportEvaluationElab(sessionId)
+      downloadBlob(blob, 'avaliacoes_mesa.xlsx')
+    })
+  }
+
+  async function onExportModel() {
+    if (!sessionId || !nomeArquivoExport) return
+    await withBusy(async () => {
+      const avaliadorEscolhido = avaliadores.find((item) => item.nome_completo === avaliadorSelecionado) || null
+      const blob = await api.exportModel(sessionId, nomeArquivoExport, avaliadorEscolhido || elaborador || null)
+      downloadBlob(blob, `${nomeArquivoExport.replace(/\.dai$/i, '')}.dai`)
+    })
+  }
+
+  async function onExportBase() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const blob = await api.exportBase(sessionId, true)
+      downloadBlob(blob, 'base_tratada.csv')
+    })
+  }
+
+  async function onMapVarChange(value) {
+    setMapaVariavel(value)
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.updateElaboracaoMap(sessionId, value)
+      setMapaHtml(resp.mapa_html || '')
+    })
+  }
+
+  function toggleSelection(setter, value) {
+    setter((prev) => {
+      if (prev.includes(value)) return prev.filter((item) => item !== value)
+      return [...prev, value]
+    })
+  }
+
+  function onToggleColunaX(coluna) {
+    const novaLista = colunasX.includes(coluna)
+      ? colunasX.filter((item) => item !== coluna)
+      : [...colunasX, coluna]
+    setColunasX(novaLista)
+    setDicotomicas((prev) => prev.filter((item) => novaLista.includes(item)))
+    setCodigoAlocado((prev) => prev.filter((item) => novaLista.includes(item)))
+    setPercentuais((prev) => prev.filter((item) => novaLista.includes(item)))
+  }
+
+  function onToggleTodasX(event) {
+    const checked = event.target.checked
+    if (checked) {
+      setColunasX(colunasXDisponiveis)
+      setDicotomicas((prev) => prev.filter((item) => colunasXDisponiveis.includes(item)))
+      setCodigoAlocado((prev) => prev.filter((item) => colunasXDisponiveis.includes(item)))
+      setPercentuais((prev) => prev.filter((item) => colunasXDisponiveis.includes(item)))
+      return
+    }
+    setColunasX([])
+    setDicotomicas([])
+    setCodigoAlocado([])
+    setPercentuais([])
+  }
+
+  return (
+    <div className="tab-content">
+      {status ? <div className="status-line">{status}</div> : null}
+
+      <SectionBlock step="1" title="Importar Dados" subtitle="Upload de CSV, Excel ou .dai com recuperação do fluxo.">
+        <div className="section1-groups">
+          <div className="subpanel section1-group">
+            <h4>Carregar modelo</h4>
+            <div className="row">
+              <input type="file" onChange={(e) => setUploadedFile(e.target.files?.[0] ?? null)} />
+              <button onClick={onUploadClick} disabled={!uploadedFile || loading || !sessionId}>Carregar arquivo</button>
+            </div>
+
+            {requiresSheet ? (
+              <div className="row">
+                <select value={selectedSheet} onChange={(e) => setSelectedSheet(e.target.value)}>
+                  {sheetOptions.map((sheet) => (
+                    <option key={sheet} value={sheet}>{sheet}</option>
+                  ))}
+                </select>
+                <button onClick={onConfirmSheet} disabled={loading || !selectedSheet}>Confirmar aba</button>
+              </div>
+            ) : null}
+          </div>
+
+          <div className="subpanel section1-group">
+            <h4>Informações do modelo</h4>
+            {elaborador?.nome_completo ? (
+              <div className="modelo-cabecalho-grid">
+                <div className="elaborador-badge">
+                  <div className="elaborador-badge-title">Modelo elaborado por:</div>
+                  <div className="elaborador-badge-name">{elaborador.nome_completo}</div>
+                  {elaboradorMeta.length > 0 ? (
+                    <div className="elaborador-badge-meta">{elaboradorMeta.join(' | ')}</div>
+                  ) : null}
+                </div>
+
+                {colunaY || variaveisIndependentesBadge.length > 0 ? (
+                  <div className="modelo-variaveis-box">
+                    <div className="elaborador-badge-title">Variáveis do modelo carregado</div>
+                    {colunaY ? (
+                      <div className="variavel-badge-line">
+                        <span className="variavel-badge-label">Dependente:</span>
+                        <span className="variavel-chip variavel-chip-y">
+                          {colunaY}
+                          {transformacaoYBadge ? <span className="variavel-chip-transform">{` ${transformacaoYBadge}`}</span> : null}
+                        </span>
+                      </div>
+                    ) : null}
+                    {variaveisIndependentesBadge.length > 0 ? (
+                      <div className="variavel-badge-line">
+                        <span className="variavel-badge-label">Independentes:</span>
+                        <div className="variavel-chip-wrap">
+                          {variaveisIndependentesBadge.map((item) => (
+                            <span key={`ind-${item.coluna}`} className="variavel-chip">
+                              {item.coluna}
+                              {item.transformacao ? <span className="variavel-chip-transform">{` ${item.transformacao}`}</span> : null}
+                            </span>
+                          ))}
+                        </div>
+                      </div>
+                    ) : null}
+                  </div>
+                ) : null}
+              </div>
+            ) : (
+              <div className="section1-empty-hint">Carregue um modelo .dai para visualizar os badges do elaborador.</div>
+            )}
+          </div>
+
+          <div className="subpanel section1-group">
+            <h4>Resolver coordenadas</h4>
+            {showCoordsPanel && coordsMode !== 'skipped' ? (
+              <>
+                {coordsInfo?.aviso_html ? <div dangerouslySetInnerHTML={{ __html: coordsInfo.aviso_html }} /> : null}
+
+                {coordsMode === 'menu' ? (
+                  <div className="coords-choice-row">
+                    <button
+                      onClick={() => {
+                        setManualMapError('')
+                        setGeoProcessError('')
+                        setCoordsMode('mapear')
+                      }}
+                      disabled={loading}
+                    >
+                      Mapear colunas existentes para lat/lon
+                    </button>
+                    <span className="coords-choice-separator">ou</span>
+                    <button
+                      onClick={() => {
+                        setManualMapError('')
+                        setGeoProcessError('')
+                        setCoordsMode('geocodificar')
+                      }}
+                      disabled={loading}
+                    >
+                      Geocodificar automaticamente
+                    </button>
+                    <span className="coords-choice-separator">ou</span>
+                    <button
+                      onClick={() => {
+                        setManualMapError('')
+                        setGeoProcessError('')
+                        setCoordsMode('confirmar-sem-coords')
+                      }}
+                      disabled={loading}
+                    >
+                      Prosseguir sem mapear coordenadas
+                    </button>
+                  </div>
+                ) : null}
+
+                {coordsMode === 'confirmar-sem-coords' ? (
+                  <div className="subpanel warning">
+                    <p>
+                      Funcionalidades dependentes de geolocalização podem apresentar resultados incompletos sem coordenadas.
+                      Deseja prosseguir mesmo assim?
+                    </p>
+                    <div className="row">
+                      <button
+                        onClick={() => {
+                          setCoordsMode('skipped')
+                          setStatus('Seção 1 liberada sem coordenadas completas.')
+                        }}
+                        disabled={loading}
+                      >
+                        Confirmar e prosseguir
+                      </button>
+                      <button
+                        onClick={() => {
+                          setManualMapError('')
+                          setGeoProcessError('')
+                          setCoordsMode('menu')
+                        }}
+                        disabled={loading}
+                      >
+                        Voltar
+                      </button>
+                    </div>
+                  </div>
+                ) : null}
+
+                {coordsMode === 'mapear' ? (
+                  <div className="subpanel">
+                    <div className="row">
+                      <button
+                        onClick={() => {
+                          setManualMapError('')
+                          setCoordsMode('menu')
+                        }}
+                        disabled={loading}
+                      >
+                        Voltar
+                      </button>
+                    </div>
+                    <h4>Mapeamento manual</h4>
+                    <div className="row">
+                      <select value={manualLat} onChange={(e) => setManualLat(e.target.value)}>
+                        <option value="">Coluna Latitude</option>
+                        {(coordsInfo?.colunas_disponiveis || []).map((col) => (
+                          <option key={`lat-${col}`} value={col}>{col}</option>
+                        ))}
+                      </select>
+                      <select value={manualLon} onChange={(e) => setManualLon(e.target.value)}>
+                        <option value="">Coluna Longitude</option>
+                        {(coordsInfo?.colunas_disponiveis || []).map((col) => (
+                          <option key={`lon-${col}`} value={col}>{col}</option>
+                        ))}
+                      </select>
+                      <button onClick={onMapCoords} disabled={loading || !manualLat || !manualLon}>Confirmar mapeamento</button>
+                    </div>
+                    {manualMapError ? <div className="error-line inline-error">{manualMapError}</div> : null}
+                  </div>
+                ) : null}
+
+                {coordsMode === 'geocodificar' ? (
+                  <div className="subpanel">
+                    <div className="row">
+                      <button
+                        onClick={() => {
+                          setGeoStatusHtml('')
+                          setGeoFalhasHtml('')
+                          setGeoCorrecoes([])
+                          setGeoProcessError('')
+                          setCoordsMode('menu')
+                        }}
+                        disabled={loading}
+                      >
+                        Voltar
+                      </button>
+                    </div>
+                    <h4>Geocodificação por eixo</h4>
+                    <div className="row">
+                      <select value={geoCdlog} onChange={(e) => setGeoCdlog(e.target.value)}>
+                        <option value="">Coluna CDLOG/CTM</option>
+                        {(coordsInfo?.colunas_disponiveis || []).map((col) => (
+                          <option key={`cdlog-${col}`} value={col}>{col}</option>
+                        ))}
+                      </select>
+                      <select value={geoNum} onChange={(e) => setGeoNum(e.target.value)}>
+                        <option value="">Coluna Número</option>
+                        {(coordsInfo?.colunas_disponiveis || []).map((col) => (
+                          <option key={`num-${col}`} value={col}>{col}</option>
+                        ))}
+                      </select>
+                      <label>
+                        <input type="checkbox" checked={geoAuto200} onChange={(e) => setGeoAuto200(e.target.checked)} />
+                        Auto ajustar {'<='} 200
+                      </label>
+                      <button onClick={onGeocodificar} disabled={loading || !geoCdlog || !geoNum}>Geocodificar</button>
+                    </div>
+                    {geoProcessError ? <div className="error-line inline-error">{geoProcessError}</div> : null}
+                    {geoStatusHtml ? <div dangerouslySetInnerHTML={{ __html: geoStatusHtml }} /> : null}
+                    {geoFalhasHtml ? <div dangerouslySetInnerHTML={{ __html: geoFalhasHtml }} /> : null}
+                    {geoCorrecoes.length > 0 ? (
+                      <div>
+                        <h5>Correções manuais</h5>
+                        <div className="geo-correcoes">
+                          {geoCorrecoes.map((item, idx) => (
+                            <div className="row" key={`cor-${item.linha}-${idx}`}>
+                              <span>Linha {item.linha}</span>
+                              <input
+                                type="text"
+                                value={item.numero_corrigido || ''}
+                                onChange={(e) => {
+                                  const next = [...geoCorrecoes]
+                                  next[idx] = { ...next[idx], numero_corrigido: e.target.value }
+                                  setGeoCorrecoes(next)
+                                }}
+                                placeholder="Número corrigido"
+                              />
+                            </div>
+                          ))}
+                        </div>
+                        <button onClick={onAplicarCorrecoesGeo} disabled={loading}>Aplicar correções</button>
+                      </div>
+                    ) : null}
+                  </div>
+                ) : null}
+              </>
+            ) : (
+              <div className="section1-empty-hint">Coordenadas já disponíveis ou etapa concluída.</div>
+            )}
+          </div>
+        </div>
+      </SectionBlock>
+
+      <SectionBlock
+        step="2"
+        title="Visualizar Dados"
+        subtitle="Mapa interativo e tabela prévia da base carregada."
+        aside={(
+          <div className="row compact">
+            <label>Variável no mapa</label>
+            <select value={mapaVariavel} onChange={(e) => onMapVarChange(e.target.value)}>
+              {mapaChoices.map((choice) => (
+                <option key={choice} value={choice}>{choice}</option>
+              ))}
+            </select>
+          </div>
+        )}
+      >
+        <div className="pane">
+          <MapFrame html={mapaHtml} />
+        </div>
+        <div className="stack-block">
+          <h4>Dados de mercado</h4>
+          <DataTable table={dados} maxHeight={540} />
+        </div>
+      </SectionBlock>
+
+      <SectionBlock step="3" title="Selecionar Variável Dependente" subtitle="Defina a variável dependente (Y).">
+        <div className="row">
+          <label>Variável Dependente (Y)</label>
+          <select value={colunaY} onChange={(e) => setColunaY(e.target.value)}>
+            <option value="">Selecione</option>
+            {colunasNumericas.map((col) => (
+              <option key={col} value={col}>{col}</option>
+            ))}
+          </select>
+        </div>
+      </SectionBlock>
+
+      <SectionBlock step="4" title="Selecionar Variáveis Independentes" subtitle="Escolha regressoras e grupos de tipologia.">
+        <div className="compact-option-group">
+          <h4>Variáveis Independentes (X)</h4>
+          <div className="checkbox-inline-wrap checkbox-inline-wrap-tools">
+            <label className="compact-checkbox compact-checkbox-toggle-all">
+              <input
+                ref={marcarTodasXRef}
+                type="checkbox"
+                checked={todasXMarcadas}
+                onChange={onToggleTodasX}
+                disabled={colunasXDisponiveis.length === 0}
+              />
+              {todasXMarcadas ? 'Desmarcar todas' : 'Marcar todas'}
+            </label>
+            <span className="compact-selection-count">
+              {colunasX.length}/{colunasXDisponiveis.length} selecionadas
+            </span>
+          </div>
+          <div className="checkbox-inline-wrap">
+            {colunasXDisponiveis.map((col) => (
+              <label key={`x-${col}`} className="compact-checkbox">
+                <input
+                  type="checkbox"
+                  checked={colunasX.includes(col)}
+                  onChange={() => onToggleColunaX(col)}
+                />
+                {col}
+              </label>
+            ))}
+          </div>
+        </div>
+
+        <div className="compact-option-group">
+          <h4>Variáveis Dicotômicas (0/1)</h4>
+          <div className="checkbox-inline-wrap">
+            {colunasX.map((col) => (
+              <label key={`d-${col}`} className="compact-checkbox">
+                <input type="checkbox" checked={dicotomicas.includes(col)} onChange={() => toggleSelection(setDicotomicas, col)} />
+                {col}
+              </label>
+            ))}
+          </div>
+        </div>
+
+        <div className="compact-option-group">
+          <h4>Variáveis de Código Alocado/Ajustado</h4>
+          <div className="checkbox-inline-wrap">
+            {colunasX.map((col) => (
+              <label key={`c-${col}`} className="compact-checkbox">
+                <input type="checkbox" checked={codigoAlocado.includes(col)} onChange={() => toggleSelection(setCodigoAlocado, col)} />
+                {col}
+              </label>
+            ))}
+          </div>
+        </div>
+
+        <div className="compact-option-group">
+          <h4>Variáveis Percentuais (0 a 1)</h4>
+          <div className="checkbox-inline-wrap">
+            {colunasX.map((col) => (
+              <label key={`p-${col}`} className="compact-checkbox">
+                <input type="checkbox" checked={percentuais.includes(col)} onChange={() => toggleSelection(setPercentuais, col)} />
+                {col}
+              </label>
+            ))}
+          </div>
+        </div>
+
+        <div className="row">
+          <button onClick={onApplySelection} disabled={loading || !colunaY || colunasX.length === 0}>Aplicar seleção</button>
+        </div>
+      </SectionBlock>
+
+      {selection ? (
+        <>
+          <SectionBlock step="5" title="Estatísticas das Variáveis Selecionadas" subtitle="Resumo estatístico para Y e regressoras.">
+            <DataTable table={selection.estatisticas} />
+          </SectionBlock>
+
+          <SectionBlock step="6" title="Teste de Micronumerosidade" subtitle="Validação de amostra mínima para variáveis selecionadas.">
+            <div dangerouslySetInnerHTML={{ __html: selection.micronumerosidade_html || '' }} />
+            {selection.aviso_multicolinearidade?.visible ? (
+              <div dangerouslySetInnerHTML={{ __html: selection.aviso_multicolinearidade.html }} />
+            ) : null}
+          </SectionBlock>
+
+          <SectionBlock step="7" title="Gráficos de Dispersão das Variáveis Independentes" subtitle="Leitura visual entre X e Y no conjunto filtrado.">
+            <PlotFigure
+              figure={selection.grafico_dispersao}
+              title="Dispersão (dados filtrados)"
+              forceHideLegend
+              className="plot-stretch"
+            />
+          </SectionBlock>
+
+          <SectionBlock step="8" title="Transformações Sugeridas" subtitle="Busca automática de combinações por R² e enquadramento.">
+            <div className="row">
+              <label>Grau mínimo dos coeficientes</label>
+              <select value={grauCoef} onChange={(e) => setGrauCoef(Number(e.target.value))}>
+                {GRAUS_COEF.map((item) => (
+                  <option key={`coef-${item.value}`} value={item.value}>{item.label}</option>
+                ))}
+              </select>
+              <label>Grau mínimo do teste F</label>
+              <select value={grauF} onChange={(e) => setGrauF(Number(e.target.value))}>
+                {GRAUS_F.map((item) => (
+                  <option key={`f-${item.value}`} value={item.value}>{item.label}</option>
+                ))}
+              </select>
+              <button onClick={onSearchTransform} disabled={loading}>Buscar transformações</button>
+            </div>
+            {(selection.busca?.resultados || []).length > 0 ? (
+              <div className="transform-suggestions-grid">
+                {(selection.busca?.resultados || []).map((item, idx) => (
+                  <div key={`sug-${item.rank || idx + 1}`} className="transform-suggestion-card">
+                    <div className="transform-suggestion-head">
+                      <span className="transform-suggestion-rank">#{item.rank || idx + 1}</span>
+                      <span className="transform-suggestion-r2">R² = {Number(item.r2 ?? 0).toFixed(4)}</span>
+                    </div>
+                    <div className="transform-suggestion-line"><strong>Y:</strong> {item.transformacao_y}</div>
+                    <div className="transform-suggestion-list">
+                      {Object.entries(item.transformacoes_x || {}).map(([coluna, transf]) => {
+                        const grau = Number(item.graus_coef?.[coluna] ?? 0)
+                        return (
+                          <div key={`scol-${item.rank || idx}-${coluna}`} className="transform-suggestion-item">
+                            <span className="transform-suggestion-col">{coluna}</span>
+                            <span className="transform-suggestion-fn">{transf}</span>
+                            <span className={grauBadgeClass(grau)}>{GRAU_LABEL_CURTO[grau] || 'Sem enq.'}</span>
+                          </div>
+                        )
+                      })}
+                    </div>
+                    <div className="transform-suggestion-foot">
+                      <span className={grauBadgeClass(Number(item.grau_f ?? 0))}>
+                        Teste F: {GRAU_LABEL_CURTO[Number(item.grau_f ?? 0)] || 'Sem enq.'}
+                      </span>
+                    </div>
+                    <button onClick={() => onAdoptSuggestion(idx)} disabled={loading}>
+                      Adotar sugestão #{item.rank || idx + 1}
+                    </button>
+                  </div>
+                ))}
+              </div>
+            ) : (
+              <div dangerouslySetInnerHTML={{ __html: selection.busca?.html || '' }} />
+            )}
+          </SectionBlock>
+
+          <SectionBlock step="9" title="Aplicação das Transformações" subtitle="Configuração manual para ajuste do modelo.">
+            <div className="row">
+              <label>Transformação de Y</label>
+              <select value={transformacaoY} onChange={(e) => setTransformacaoY(e.target.value)}>
+                {['(x)', '1/(x)', 'ln(x)', 'exp(x)', '(x)^2', 'raiz(x)', '1/raiz(x)'].map((item) => (
+                  <option key={`y-${item}`} value={item}>{item}</option>
+                ))}
+              </select>
+            </div>
+
+            <div className="transform-grid">
+              {(selection.transform_fields || []).map((field) => (
+                <div key={`tf-${field.coluna}`} className="transform-card">
+                  <span>{field.coluna}</span>
+                  <select
+                    value={transformacoesX[field.coluna] || '(x)'}
+                    onChange={(e) => setTransformacoesX((prev) => ({ ...prev, [field.coluna]: e.target.value }))}
+                    disabled={field.locked}
+                  >
+                    {(field.choices || []).map((choice) => (
+                      <option key={`${field.coluna}-${choice}`} value={choice}>{choice}</option>
+                    ))}
+                  </select>
+                </div>
+              ))}
+            </div>
+
+            <button onClick={onFitModel} disabled={loading}>Aplicar transformações e ajustar modelo</button>
+          </SectionBlock>
+        </>
+      ) : null}
+
+      {fit ? (
+        <>
+          <SectionBlock step="10" title="Gráficos de Dispersão (Variáveis Transformadas)" subtitle="Dispersão com variáveis já transformadas.">
+            <div className="row">
+              <label>Tipo de dispersão</label>
+              <select value={tipoDispersao} onChange={(e) => onTipoDispersaoChange(e.target.value)}>
+                <option value="Variáveis Independentes Transformadas X Variável Dependente Transformada">X transformado x Y transformado</option>
+                <option value="Variáveis Independentes Transformadas X Resíduo Padronizado">X transformado x Resíduo</option>
+              </select>
+            </div>
+            <PlotFigure figure={fit.grafico_dispersao_modelo} title="Dispersão do modelo" forceHideLegend className="plot-stretch" />
+          </SectionBlock>
+
+          <SectionBlock step="11" title="Diagnóstico de Modelo" subtitle="Resumo diagnóstico e tabelas principais do ajuste.">
+            <div dangerouslySetInnerHTML={{ __html: fit.diagnosticos_html || '' }} />
+            <div className="two-col diagnostic-tables">
+              <div className="pane">
+                <h4>Tabela de Coeficientes</h4>
+                <DataTable table={fit.tabela_coef} maxHeight={460} />
+              </div>
+              <div className="pane">
+                <h4>Valores Observados x Calculados</h4>
+                <DataTable table={fit.tabela_obs_calc} maxHeight={460} />
+              </div>
+            </div>
+          </SectionBlock>
+
+          <SectionBlock step="12" title="Gráficos de Diagnóstico do Modelo" subtitle="Obs x calc, resíduos, histograma, Cook e correlação.">
+            <div className="plot-grid-2-fixed">
+              <PlotFigure figure={fit.grafico_obs_calc} title="Obs x Calc" />
+              <PlotFigure figure={fit.grafico_residuos} title="Resíduos" />
+              <PlotFigure figure={fit.grafico_histograma} title="Histograma" />
+              <PlotFigure figure={fit.grafico_cook} title="Cook" forceHideLegend />
+            </div>
+            <div className="plot-full-width">
+              <PlotFigure figure={fit.grafico_correlacao} title="Matriz de correlação" className="plot-correlation-card" />
+            </div>
+          </SectionBlock>
+
+          <SectionBlock step="13" title="Analisar Outliers" subtitle="Métricas para identificação de observações influentes.">
+            <DataTable table={fit.tabela_metricas} maxHeight={320} />
+          </SectionBlock>
+
+          <SectionBlock step="14" title="Exclusão ou Reinclusão de Outliers" subtitle="Filtre índices, revise e atualize o modelo.">
+            {outliersAnteriores.length > 0 && outliersHtml ? (
+              <div className="outliers-html-box" dangerouslySetInnerHTML={{ __html: outliersHtml }} />
+            ) : null}
+            <div className="outlier-subheader">Filtrar outliers</div>
+            <div className="outlier-dica">Outliers = linhas que satisfazem qualquer filtro (lógica OR / união).</div>
+            <div className="filtros-stack">
+              {filtros.map((filtro, idx) => (
+                <div key={`filtro-${idx}`} className="filtro-row-react">
+                  <select
+                    value={filtro.variavel}
+                    onChange={(e) => {
+                      const next = [...filtros]
+                      next[idx] = { ...next[idx], variavel: e.target.value }
+                      setFiltros(next)
+                    }}
+                  >
+                    {(fit.variaveis_filtro || []).map((varItem) => (
+                      <option key={`vf-${idx}-${varItem}`} value={varItem}>{varItem}</option>
+                    ))}
+                  </select>
+                  <select
+                    value={filtro.operador}
+                    onChange={(e) => {
+                      const next = [...filtros]
+                      next[idx] = { ...next[idx], operador: e.target.value }
+                      setFiltros(next)
+                    }}
+                  >
+                    {OPERADORES.map((op) => (
+                      <option key={`op-${idx}-${op}`} value={op}>{op}</option>
+                    ))}
+                  </select>
+                  <input
+                    type="number"
+                    value={filtro.valor}
+                    onChange={(e) => {
+                      const next = [...filtros]
+                      next[idx] = { ...next[idx], valor: Number(e.target.value) }
+                      setFiltros(next)
+                    }}
+                  />
+                </div>
+              ))}
+            </div>
+            <div className="outlier-actions-row">
+              <button onClick={onApplyOutlierFilters} disabled={loading}>Aplicar filtros</button>
+            </div>
+
+            <div className="outlier-divider"><span className="arrow">→</span></div>
+            <div className="outlier-subheader">Excluir ou reincluir índices</div>
+            <div className="outlier-inputs-grid">
+              <div className="outlier-input-card">
+                <label>A excluir</label>
+                <input type="text" value={outliersTexto} onChange={(e) => setOutliersTexto(e.target.value)} placeholder="ex: 5, 12, 30" />
+              </div>
+              <div className="outlier-input-card">
+                <label>A reincluir</label>
+                <input type="text" value={reincluirTexto} onChange={(e) => setReincluirTexto(e.target.value)} placeholder="ex: 5" />
+              </div>
+            </div>
+
+            <div className="outlier-actions-row">
+              <button onClick={onRestartIteration} disabled={loading} className="btn-reiniciar-iteracao">
+                Atualizar Modelo (Excluir/Reincluir Outliers)
+              </button>
+            </div>
+            <div className="resumo-outliers-box">Iteração: {iteracao} | {resumoOutliers}</div>
+            <div className="resumo-outliers-box">Outliers anteriores: {joinSelection(outliersAnteriores) || '-'}</div>
+          </SectionBlock>
+
+          <SectionBlock step="15" title="Avaliação de Imóvel" subtitle="Cálculo individual e comparação entre avaliações.">
+            <div className="avaliacao-grid">
+              {camposAvaliacao.map((campo) => (
+                <div key={`aval-${campo.coluna}`} className="avaliacao-card">
+                  <label>{campo.coluna}</label>
+                  <input
+                    type="number"
+                    value={valoresAvaliacao[campo.coluna] ?? ''}
+                    placeholder={campo.placeholder || ''}
+                    onChange={(e) => setValoresAvaliacao((prev) => ({ ...prev, [campo.coluna]: e.target.value }))}
+                  />
+                </div>
+              ))}
+            </div>
+            <div className="row-wrap avaliacao-actions-row">
+              <button onClick={onCalculateAvaliacao} disabled={loading}>Calcular</button>
+              <button onClick={onClearAvaliacao} disabled={loading}>Limpar</button>
+              <button onClick={onExportAvaliacoes} disabled={loading}>Exportar avaliações (Excel)</button>
+            </div>
+            <div className="row avaliacao-base-row">
+              <label>Base comparação</label>
+              <select value={baseValue || ''} onChange={(e) => onBaseChange(e.target.value)}>
+                <option value="">Selecione</option>
+                {baseChoices.map((choice) => (
+                  <option key={`base-${choice}`} value={choice}>{choice}</option>
+                ))}
+              </select>
+              <label>Excluir avaliação #</label>
+              <input type="text" value={deleteAvalIndex} onChange={(e) => setDeleteAvalIndex(e.target.value)} />
+              <button onClick={onDeleteAvaliacao} disabled={loading}>Excluir</button>
+            </div>
+            <div className="avaliacao-resultado-box" dangerouslySetInnerHTML={{ __html: resultadoAvaliacaoHtml }} />
+          </SectionBlock>
+
+          <SectionBlock step="16" title="Exportar Modelo" subtitle="Geração do pacote .dai e download da base tratada.">
+            <div className="row">
+              <label>Nome do arquivo (.dai)</label>
+              <input type="text" value={nomeArquivoExport} onChange={(e) => setNomeArquivoExport(e.target.value)} />
+              <label>Avaliador</label>
+              <select value={avaliadorSelecionado} onChange={(e) => setAvaliadorSelecionado(e.target.value)}>
+                <option value="">Manter elaborador do modelo (se houver)</option>
+                {avaliadores.map((item) => (
+                  <option key={`aval-exp-${item.nome_completo}`} value={item.nome_completo}>
+                    {item.nome_completo}
+                  </option>
+                ))}
+              </select>
+              <button onClick={onExportModel} disabled={loading || !nomeArquivoExport}>Exportar modelo</button>
+              <button onClick={onExportBase} disabled={loading}>Exportar base CSV</button>
+            </div>
+          </SectionBlock>
+        </>
+      ) : null}
+
+      {loading ? <div className="status-line">Processando...</div> : null}
+      {error ? <div className="error-line">{error}</div> : null}
+    </div>
+  )
+}

frontend/src/components/MapFrame.jsx

@@ -0,0 +1,16 @@
+import React from 'react'
+
+export default function MapFrame({ html }) {
+  if (!html) {
+    return <div className="empty-box">Mapa indisponivel.</div>
+  }
+
+  return (
+    <iframe
+      title="mapa"
+      className="map-frame"
+      srcDoc={html}
+      sandbox="allow-scripts allow-same-origin allow-popups"
+    />
+  )
+}

frontend/src/components/PlotFigure.jsx

@@ -0,0 +1,48 @@
+import React from 'react'
+import Plot from 'react-plotly.js'
+import Plotly from 'plotly.js-dist-min'
+
+export default function PlotFigure({ figure, title, forceHideLegend = false, className = '' }) {
+  if (!figure) {
+    return <div className="empty-box">Grafico indisponivel.</div>
+  }
+
+  const data = (figure.data || []).map((trace) => {
+    if (!forceHideLegend) return trace
+    return { ...trace, showlegend: false }
+  })
+
+  const baseLayout = figure.layout || {}
+  const { width: _ignoreWidth, ...layoutNoWidth } = baseLayout
+  const safeAnnotations = Array.isArray(baseLayout.annotations)
+    ? baseLayout.annotations.map((annotation) => {
+        const { ax, ay, axref, ayref, arrowhead, arrowsize, arrowwidth, arrowcolor, standoff, ...clean } = annotation || {}
+        return { ...clean, showarrow: false }
+      })
+    : baseLayout.annotations
+  const layout = {
+    ...layoutNoWidth,
+    autosize: true,
+    annotations: safeAnnotations,
+    margin: baseLayout.margin || { t: 40, r: 20, b: 50, l: 50 },
+  }
+  if (forceHideLegend) {
+    layout.showlegend = false
+  }
+  const plotHeight = layout.height ? `${layout.height}px` : '100%'
+  const cardClassName = `plot-card ${className}`.trim()
+
+  return (
+    <div className={cardClassName}>
+      {title ? <h4>{title}</h4> : null}
+      <Plot
+        data={data}
+        layout={layout}
+        config={{ responsive: true, displaylogo: false }}
+        style={{ width: '100%', height: plotHeight, minHeight: '320px' }}
+        useResizeHandler
+        plotly={Plotly}
+      />
+    </div>
+  )
+}

frontend/src/components/SectionBlock.jsx

@@ -0,0 +1,23 @@
+import React from 'react'
+
+export default function SectionBlock({
+  step,
+  title,
+  subtitle,
+  aside,
+  children,
+}) {
+  return (
+    <section className="workflow-section" style={{ '--section-order': Number(step) || 1 }}>
+      <header className="section-head">
+        <span className="section-index">{step}</span>
+        <div className="section-title-wrap">
+          <h3>{title}</h3>
+          {subtitle ? <p>{subtitle}</p> : null}
+        </div>
+        {aside ? <div className="section-head-aside">{aside}</div> : null}
+      </header>
+      <div className="section-body">{children}</div>
+    </section>
+  )
+}

frontend/src/components/VisualizacaoTab.jsx

@@ -0,0 +1,351 @@
+import React, { useState } from 'react'
+import { api, downloadBlob } from '../api'
+import DataTable from './DataTable'
+import MapFrame from './MapFrame'
+import PlotFigure from './PlotFigure'
+import SectionBlock from './SectionBlock'
+
+const INNER_TABS = [
+  { key: 'mapa', label: 'Mapa' },
+  { key: 'dados', label: 'Dados' },
+  { key: 'transformacoes', label: 'Transformações' },
+  { key: 'resumo', label: 'Resumo' },
+  { key: 'coeficientes', label: 'Coeficientes' },
+  { key: 'obs_calc', label: 'Obs x Calc' },
+  { key: 'graficos', label: 'Gráficos' },
+  { key: 'avaliacao', label: 'Avaliação' },
+  { key: 'avaliacao_massa', label: 'Avaliação em Massa' },
+]
+
+export default function VisualizacaoTab({ sessionId }) {
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState('')
+  const [status, setStatus] = useState('')
+  const [badgeHtml, setBadgeHtml] = useState('')
+
+  const [uploadedFile, setUploadedFile] = useState(null)
+
+  const [dados, setDados] = useState(null)
+  const [estatisticas, setEstatisticas] = useState(null)
+  const [escalasHtml, setEscalasHtml] = useState('')
+  const [dadosTransformados, setDadosTransformados] = useState(null)
+  const [resumoHtml, setResumoHtml] = useState('')
+  const [coeficientes, setCoeficientes] = useState(null)
+  const [obsCalc, setObsCalc] = useState(null)
+
+  const [plotObsCalc, setPlotObsCalc] = useState(null)
+  const [plotResiduos, setPlotResiduos] = useState(null)
+  const [plotHistograma, setPlotHistograma] = useState(null)
+  const [plotCook, setPlotCook] = useState(null)
+  const [plotCorr, setPlotCorr] = useState(null)
+
+  const [mapaHtml, setMapaHtml] = useState('')
+  const [mapaChoices, setMapaChoices] = useState(['Visualização Padrão'])
+  const [mapaVar, setMapaVar] = useState('Visualização Padrão')
+
+  const [camposAvaliacao, setCamposAvaliacao] = useState([])
+  const [valoresAvaliacao, setValoresAvaliacao] = useState({})
+  const [resultadoAvaliacaoHtml, setResultadoAvaliacaoHtml] = useState('')
+  const [baseChoices, setBaseChoices] = useState([])
+  const [baseValue, setBaseValue] = useState('')
+  const [deleteAvalIndex, setDeleteAvalIndex] = useState('')
+
+  const [activeInnerTab, setActiveInnerTab] = useState('mapa')
+
+  const statusFluxo = [
+    { label: 'Modelo carregado', done: Boolean(status) },
+    { label: 'Dados exibidos', done: Boolean(dados) },
+    { label: 'Gráficos prontos', done: Boolean(plotObsCalc) },
+    { label: 'Avaliação ativa', done: camposAvaliacao.length > 0 },
+  ]
+
+  function resetConteudoVisualizacao() {
+    setDados(null)
+    setEstatisticas(null)
+    setEscalasHtml('')
+    setDadosTransformados(null)
+    setResumoHtml('')
+    setCoeficientes(null)
+    setObsCalc(null)
+
+    setPlotObsCalc(null)
+    setPlotResiduos(null)
+    setPlotHistograma(null)
+    setPlotCook(null)
+    setPlotCorr(null)
+
+    setMapaHtml('')
+    setMapaChoices(['Visualização Padrão'])
+    setMapaVar('Visualização Padrão')
+
+    setCamposAvaliacao([])
+    setValoresAvaliacao({})
+    setResultadoAvaliacaoHtml('')
+    setBaseChoices([])
+    setBaseValue('')
+    setDeleteAvalIndex('')
+
+    setActiveInnerTab('mapa')
+  }
+
+  function applyExibicaoResponse(resp) {
+    setDados(resp.dados || null)
+    setEstatisticas(resp.estatisticas || null)
+    setEscalasHtml(resp.escalas_html || '')
+    setDadosTransformados(resp.dados_transformados || null)
+    setResumoHtml(resp.resumo_html || '')
+    setCoeficientes(resp.coeficientes || null)
+    setObsCalc(resp.obs_calc || null)
+
+    setPlotObsCalc(resp.grafico_obs_calc || null)
+    setPlotResiduos(resp.grafico_residuos || null)
+    setPlotHistograma(resp.grafico_histograma || null)
+    setPlotCook(resp.grafico_cook || null)
+    setPlotCorr(resp.grafico_correlacao || null)
+
+    setMapaHtml(resp.mapa_html || '')
+    setMapaChoices(resp.mapa_choices || ['Visualização Padrão'])
+    setMapaVar('Visualização Padrão')
+
+    setCamposAvaliacao(resp.campos_avaliacao || [])
+    const values = {}
+    ;(resp.campos_avaliacao || []).forEach((campo) => {
+      values[campo.coluna] = ''
+    })
+    setValoresAvaliacao(values)
+    setResultadoAvaliacaoHtml('')
+    setBaseChoices([])
+    setBaseValue('')
+  }
+
+  async function withBusy(fn) {
+    setLoading(true)
+    setError('')
+    try {
+      await fn()
+    } catch (err) {
+      setError(err.message)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  async function onUploadModel() {
+    if (!sessionId || !uploadedFile) return
+    await withBusy(async () => {
+      resetConteudoVisualizacao()
+      const uploadResp = await api.uploadVisualizacaoFile(sessionId, uploadedFile)
+      setStatus(uploadResp.status || '')
+      setBadgeHtml(uploadResp.badge_html || '')
+
+      const exibirResp = await api.exibirVisualizacao(sessionId)
+      applyExibicaoResponse(exibirResp)
+    })
+  }
+
+  async function onMapChange(value) {
+    setMapaVar(value)
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.updateVisualizacaoMap(sessionId, value)
+      setMapaHtml(resp.mapa_html || '')
+    })
+  }
+
+  async function onCalcularAvaliacao() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.evaluationCalculateViz(sessionId, valoresAvaliacao, baseValue || null)
+      setResultadoAvaliacaoHtml(resp.resultado_html || '')
+      setBaseChoices(resp.base_choices || [])
+      setBaseValue(resp.base_value || '')
+    })
+  }
+
+  async function onClearAvaliacao() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.evaluationClearViz(sessionId)
+      setResultadoAvaliacaoHtml(resp.resultado_html || '')
+      setBaseChoices(resp.base_choices || [])
+      setBaseValue(resp.base_value || '')
+    })
+  }
+
+  async function onDeleteAvaliacao() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.evaluationDeleteViz(sessionId, deleteAvalIndex, baseValue || null)
+      setResultadoAvaliacaoHtml(resp.resultado_html || '')
+      setBaseChoices(resp.base_choices || [])
+      setBaseValue(resp.base_value || '')
+      setDeleteAvalIndex('')
+    })
+  }
+
+  async function onBaseChange(value) {
+    setBaseValue(value)
+    if (!sessionId) return
+    await withBusy(async () => {
+      const resp = await api.evaluationBaseViz(sessionId, value)
+      setResultadoAvaliacaoHtml(resp.resultado_html || '')
+    })
+  }
+
+  async function onExportAvaliacoes() {
+    if (!sessionId) return
+    await withBusy(async () => {
+      const blob = await api.exportEvaluationViz(sessionId)
+      downloadBlob(blob, 'avaliacoes_visualizacao.xlsx')
+    })
+  }
+
+  return (
+    <div className="tab-content">
+      <div className="status-strip">
+        {statusFluxo.map((item) => (
+          <span key={item.label} className={item.done ? 'status-pill done' : 'status-pill'}>
+            {item.label}
+          </span>
+        ))}
+      </div>
+
+      <SectionBlock step="1" title="Carregar Modelo .dai" subtitle="Carregue o arquivo e o conteúdo será exibido automaticamente.">
+        <div className="row">
+          <input type="file" onChange={(e) => setUploadedFile(e.target.files?.[0] ?? null)} />
+          <button onClick={onUploadModel} disabled={!uploadedFile || loading || !sessionId}>Carregar Modelo</button>
+        </div>
+        {status ? <div className="status-line">{status}</div> : null}
+        {badgeHtml ? <div dangerouslySetInnerHTML={{ __html: badgeHtml }} /> : null}
+      </SectionBlock>
+
+      {dados ? (
+        <SectionBlock step="2" title="Conteúdo do Modelo" subtitle="Carregue o modelo no topo e navegue pelas abas internas abaixo.">
+          <div className="inner-tabs" role="tablist" aria-label="Abas internas de visualização">
+            {INNER_TABS.map((tab) => (
+              <button
+                key={tab.key}
+                type="button"
+                className={activeInnerTab === tab.key ? 'inner-tab-pill active' : 'inner-tab-pill'}
+                onClick={() => setActiveInnerTab(tab.key)}
+              >
+                {tab.label}
+              </button>
+            ))}
+          </div>
+
+          <div className="inner-tab-panel">
+            {activeInnerTab === 'mapa' ? (
+              <>
+                <div className="row compact">
+                  <label>Variável no mapa</label>
+                  <select value={mapaVar} onChange={(e) => onMapChange(e.target.value)}>
+                    {mapaChoices.map((choice) => (
+                      <option key={choice} value={choice}>{choice}</option>
+                    ))}
+                  </select>
+                </div>
+                <MapFrame html={mapaHtml} />
+              </>
+            ) : null}
+
+            {activeInnerTab === 'dados' ? (
+              <div className="two-col">
+                <div className="pane">
+                  <h4>Dados</h4>
+                  <DataTable table={dados} maxHeight={520} />
+                </div>
+                <div className="pane">
+                  <h4>Estatísticas</h4>
+                  <DataTable table={estatisticas} maxHeight={520} />
+                </div>
+              </div>
+            ) : null}
+
+            {activeInnerTab === 'transformacoes' ? (
+              <>
+                <div dangerouslySetInnerHTML={{ __html: escalasHtml }} />
+                <DataTable table={dadosTransformados} />
+              </>
+            ) : null}
+
+            {activeInnerTab === 'resumo' ? (
+              <div dangerouslySetInnerHTML={{ __html: resumoHtml }} />
+            ) : null}
+
+            {activeInnerTab === 'coeficientes' ? (
+              <DataTable table={coeficientes} maxHeight={620} />
+            ) : null}
+
+            {activeInnerTab === 'obs_calc' ? (
+              <DataTable table={obsCalc} maxHeight={620} />
+            ) : null}
+
+            {activeInnerTab === 'graficos' ? (
+              <>
+                <div className="plot-grid-2-fixed">
+                  <PlotFigure figure={plotObsCalc} title="Obs x Calc" />
+                  <PlotFigure figure={plotResiduos} title="Resíduos" />
+                  <PlotFigure figure={plotHistograma} title="Histograma" />
+                  <PlotFigure figure={plotCook} title="Cook" forceHideLegend />
+                </div>
+                <div className="plot-full-width">
+                  <PlotFigure figure={plotCorr} title="Correlação" className="plot-correlation-card" />
+                </div>
+              </>
+            ) : null}
+
+            {activeInnerTab === 'avaliacao' ? (
+              <>
+                <div className="avaliacao-grid">
+                  {camposAvaliacao.map((campo) => (
+                    <div key={`campo-${campo.coluna}`} className="avaliacao-card">
+                      <label>{campo.coluna}</label>
+                      <input
+                        type="number"
+                        value={valoresAvaliacao[campo.coluna] ?? ''}
+                        placeholder={campo.placeholder || ''}
+                        onChange={(e) => setValoresAvaliacao((prev) => ({ ...prev, [campo.coluna]: e.target.value }))}
+                      />
+                    </div>
+                  ))}
+                </div>
+
+                <div className="row-wrap avaliacao-actions-row">
+                  <button onClick={onCalcularAvaliacao} disabled={loading}>Calcular</button>
+                  <button onClick={onClearAvaliacao} disabled={loading}>Limpar</button>
+                  <button onClick={onExportAvaliacoes} disabled={loading}>Exportar avaliações</button>
+                </div>
+
+                <div className="row avaliacao-base-row">
+                  <label>Base comparação</label>
+                  <select value={baseValue || ''} onChange={(e) => onBaseChange(e.target.value)}>
+                    <option value="">Selecione</option>
+                    {baseChoices.map((choice) => (
+                      <option key={`base-${choice}`} value={choice}>{choice}</option>
+                    ))}
+                  </select>
+
+                  <label>Excluir avaliação #</label>
+                  <input type="text" value={deleteAvalIndex} onChange={(e) => setDeleteAvalIndex(e.target.value)} />
+                  <button onClick={onDeleteAvaliacao} disabled={loading}>Excluir</button>
+                </div>
+
+                <div className="avaliacao-resultado-box" dangerouslySetInnerHTML={{ __html: resultadoAvaliacaoHtml }} />
+              </>
+            ) : null}
+
+            {activeInnerTab === 'avaliacao_massa' ? (
+              <div className="empty-box">Módulo em desenvolvimento.</div>
+            ) : null}
+          </div>
+        </SectionBlock>
+      ) : (
+        <div className="empty-box">Carregue um modelo para navegar nas abas internas da Visualização/Avaliação.</div>
+      )}
+
+      {loading ? <div className="status-line">Processando...</div> : null}
+      {error ? <div className="error-line">{error}</div> : null}
+    </div>
+  )
+}