alteracoes nos mapas e no carregamento de planilha

.gitignore

@@ -24,6 +24,7 @@ logs/**/*.jsonl
 backend/local_data/*.sqlite3
 backend/local_data/*.sqlite3-shm
 backend/local_data/*.sqlite3-wal
+backend/local_data/anexos_gerados/
 
 # Local .dai model repository
 backend/app/core/pesquisa/modelos_dai/*.dai

backend/app/api/anexos.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Request
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field
+
+from app.services import anexos_service, auth_service
+from app.services.audit_log_service import log_event
+
+
+router = APIRouter(prefix="/api/anexos", tags=["anexos"])
+
+
+class GerarAnexosPayload(BaseModel):
+    modelo_id: str = Field(..., min_length=1)
+    banco_dados_colunas: list[str] | None = None
+    avaliacao: dict[str, Any] | None = None
+
+
+@router.get("/modelos")
+def modelos(request: Request) -> dict[str, Any]:
+    auth_service.require_user(request)
+    return anexos_service.listar_modelos()
+
+
+@router.get("/modelos/{modelo_id}/columns")
+def modelo_colunas(modelo_id: str, request: Request) -> dict[str, Any]:
+    auth_service.require_user(request)
+    return anexos_service.obter_colunas(modelo_id)
+
+
+@router.post("/generate")
+def gerar(payload: GerarAnexosPayload, request: Request) -> dict[str, Any]:
+    user = auth_service.require_user(request)
+    caminho, avisos = anexos_service.gerar_documento(
+        payload.modelo_id,
+        banco_dados_colunas=payload.banco_dados_colunas,
+        avaliacao=payload.avaliacao,
+    )
+    log_event(
+        "visualizacao",
+        "gerar_anexos_modelo",
+        user=user,
+        request=request,
+        details={
+            "modelo_id": payload.modelo_id,
+            "com_avaliacao": bool(payload.avaliacao),
+            "total_colunas": len(payload.banco_dados_colunas or []),
+        },
+    )
+    return {
+        "message": f"Anexos gerados com sucesso: {caminho.name}",
+        "filename": caminho.name,
+        "statistical_warnings": avisos,
+    }
+
+
+@router.get("/download/{filename}")
+def download(filename: str, request: Request) -> FileResponse:
+    auth_service.require_user(request)
+    caminho = anexos_service.resolver_download(filename)
+    return FileResponse(
+        path=caminho,
+        filename=caminho.name,
+        media_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        headers={"Cache-Control": "no-store"},
+    )

backend/app/api/pesquisa.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
 import json
+import os
 from typing import Any
 
 from fastapi import APIRouter, HTTPException, Query
+from fastapi.responses import FileResponse
 from pydantic import BaseModel
 
 from app.services.pesquisa_service import (
     PesquisaFiltros,
+    exportar_indices_mapa_pesquisa_xlsx,
     gerar_mapa_modelos,
     listar_logradouros_eixos,
     listar_modelos,
@@ -75,6 +78,15 @@ class PesquisaAdminConfigPayload(BaseModel):
     campos: dict[str, list[str]] = {}
 
 
+class MapaIndicesModeloPayload(BaseModel):
+    nome: Any = None
+    indices: list[Any] = []
+
+
+class MapaIndicesExportPayload(BaseModel):
+    modelos: list[MapaIndicesModeloPayload] = []
+
+
 @router.get("/admin-config")
 def pesquisar_admin_config() -> dict:
     return obter_admin_config_pesquisa()
@@ -224,3 +236,15 @@ def pesquisar_mapa_modelos(payload: MapaModelosPayload) -> dict:
         trabalhos_tecnicos_proximidade_modo=proximidade_modo,
         trabalhos_tecnicos_raio_m=payload.trabalhos_tecnicos_raio_m,
     )
+
+
+@router.post("/mapa-indices-selecionados/export")
+def exportar_mapa_indices_selecionados(payload: MapaIndicesExportPayload) -> FileResponse:
+    caminho, nome = exportar_indices_mapa_pesquisa_xlsx(
+        [item.model_dump() for item in payload.modelos]
+    )
+    return FileResponse(
+        path=caminho,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        filename=os.path.basename(nome),
+    )

backend/app/core/anexos/__init__.py

@@ -0,0 +1,6 @@
+"""Geração dos anexos técnicos de modelos de avaliação."""
+
+from .generator import AnexosGenerator
+from .model_loader import load_model, model_data_from_package
+
+__all__ = ["AnexosGenerator", "load_model", "model_data_from_package"]

backend/app/core/anexos/banco_dados.py

@@ -0,0 +1,454 @@
+"""
+Gerador do Anexo de Banco de Dados.
+Gera a tabela com os dados das amostras (Xy_preview).
+"""
+from datetime import date, datetime
+from functools import lru_cache
+from numbers import Number
+from pathlib import Path
+import re
+from typing import Optional, Sequence
+
+import pandas as pd
+from docx import Document
+
+from .model_data import ModelData
+from .formatters import (
+    add_placeholder_text,
+    add_simple_table,
+)
+
+# Hífen que não permite quebra de linha (non-breaking hyphen)
+HIFEN_NAO_QUEBRAVEL = '\u2011'
+COLUNAS_COORDENADAS = {"lat", "lon"}
+PESO_COLUNA_DICOTOMICA = 0.45
+PESO_COLUNA_RH = 0.5
+PESO_COLUNA_DATA = 1.45
+PESO_COLUNA_TEXTO = 2.0
+CASAS_DECIMAIS_COORDENADAS = 5
+FONTE_TABELA_PT = 8
+EMU_POR_POLEGADA = 914400
+DPI_MEDICAO = 96
+FOLGA_CELULA_POLEGADAS = 0.18
+FOLGA_CABECALHO_POLEGADAS = 0.16
+FATOR_SEGURANCA_CABECALHO = 1.1
+LARGURA_MINIMA_COLUNA_POLEGADAS = 0.28
+LARGURA_MINIMA_DATA_POLEGADAS = 0.74
+
+
+def _formatar_numero(
+    val: float,
+    casas_decimais: int = 2,
+    separador_milhar: bool = True,
+) -> str:
+    """
+    Formata número em padrão brasileiro, substituindo hífen por hífen não-quebrável.
+    Evita que o Word quebre a linha entre o sinal negativo e o número.
+    """
+    if separador_milhar:
+        texto = f"{val:,.{casas_decimais}f}".replace(',', 'X').replace('.', ',').replace('X', '.')
+    else:
+        texto = f"{val:.{casas_decimais}f}".replace('.', ',')
+    return texto.replace('-', HIFEN_NAO_QUEBRAVEL)
+
+
+def _polegadas_para_emu(valor: float) -> int:
+    return int(valor * EMU_POR_POLEGADA)
+
+
+def _valor_vazio(val) -> bool:
+    if val is None:
+        return True
+
+    vazio = pd.isna(val)
+    return bool(vazio) if isinstance(vazio, bool) else False
+
+
+def _valores_nao_vazios(series: pd.Series) -> list:
+    return [val for val in series.tolist() if not _valor_vazio(val)]
+
+
+def _nome_coluna_normalizado(col) -> str:
+    return str(col).strip().lower()
+
+
+def _is_coluna_coordenada(col) -> bool:
+    return _nome_coluna_normalizado(col) in COLUNAS_COORDENADAS
+
+
+def _is_coluna_rh(col) -> bool:
+    return _nome_coluna_normalizado(col) == "rh"
+
+
+def _is_numero(val) -> bool:
+    return isinstance(val, Number) and not isinstance(val, bool)
+
+
+def _is_coluna_data(col, series: pd.Series) -> bool:
+    if pd.api.types.is_datetime64_any_dtype(series):
+        return True
+
+    valores = _valores_nao_vazios(series)
+    if not valores:
+        return False
+
+    if all(isinstance(val, (pd.Timestamp, datetime, date)) for val in valores):
+        return True
+
+    if not all(isinstance(val, str) for val in valores):
+        return False
+
+    nome_indica_data = "data" in _nome_coluna_normalizado(col) or "date" in _nome_coluna_normalizado(col)
+    textos_tem_separador_data = any(re.search(r"\d[/-]\d", val) for val in valores)
+    if not nome_indica_data and not textos_tem_separador_data:
+        return False
+
+    datas = pd.to_datetime(pd.Series(valores), errors="coerce", dayfirst=True)
+    return bool(datas.notna().all())
+
+
+def _is_coluna_texto_puro(col, series: pd.Series) -> bool:
+    valores = _valores_nao_vazios(series)
+    return bool(valores) and all(isinstance(val, str) for val in valores) and not _is_coluna_data(col, series)
+
+
+def _formatar_data(val) -> str:
+    data = pd.to_datetime(val, errors="coerce", dayfirst=True)
+    if pd.isna(data):
+        return str(val)
+    return data.strftime("%d/%m/%Y")
+
+
+def _formatar_valor_tabela(val, col, colunas_inteiras: set, colunas_data: set) -> str:
+    if _valor_vazio(val):
+        return ""
+
+    if col in colunas_data:
+        return _formatar_data(val)
+
+    if _is_coluna_coordenada(col) and _is_numero(val):
+        return _formatar_numero(
+            float(val),
+            casas_decimais=CASAS_DECIMAIS_COORDENADAS,
+            separador_milhar=False,
+        )
+
+    if col in colunas_inteiras and _is_numero(val):
+        texto = str(int(val))
+        return texto.replace('-', HIFEN_NAO_QUEBRAVEL)
+
+    if _is_numero(val):
+        return _formatar_numero(float(val), casas_decimais=2)
+
+    return str(val)
+
+
+@lru_cache(maxsize=1)
+def _carregar_fonte_medicao():
+    try:
+        from PIL import ImageFont
+    except ImportError:
+        return None
+
+    tamanho_px = round(FONTE_TABELA_PT * DPI_MEDICAO / 72)
+    caminhos = [
+        Path("/System/Library/Fonts/Supplemental/Arial.ttf"),
+        Path("/Library/Fonts/Arial.ttf"),
+        Path("/usr/share/fonts/truetype/msttcorefonts/Arial.ttf"),
+        Path("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"),
+    ]
+
+    for caminho in caminhos:
+        if caminho.exists():
+            try:
+                return ImageFont.truetype(str(caminho), tamanho_px)
+            except OSError:
+                continue
+
+    try:
+        return ImageFont.load_default()
+    except OSError:
+        return None
+
+
+def _medir_texto_emu_com_folga(texto: str, folga_polegadas: float, minimo_polegadas: float) -> int:
+    texto = str(texto)
+    fonte = _carregar_fonte_medicao()
+
+    if fonte is not None:
+        bbox = fonte.getbbox(texto)
+        largura_px = bbox[2] - bbox[0]
+    else:
+        largura_px = len(texto) * (FONTE_TABELA_PT * 0.58)
+
+    largura_polegadas = largura_px / DPI_MEDICAO + folga_polegadas
+    return max(
+        _polegadas_para_emu(minimo_polegadas),
+        _polegadas_para_emu(largura_polegadas),
+    )
+
+
+def _medir_texto_emu(texto: str) -> int:
+    return _medir_texto_emu_com_folga(
+        texto,
+        FOLGA_CELULA_POLEGADAS,
+        LARGURA_MINIMA_COLUNA_POLEGADAS,
+    )
+
+
+def _medir_cabecalho_emu(texto: str) -> int:
+    largura = _medir_texto_emu_com_folga(texto, FOLGA_CABECALHO_POLEGADAS, 0)
+    return int(largura * FATOR_SEGURANCA_CABECALHO)
+
+
+def _largura_util_pagina_emu(doc: Document) -> int:
+    section = doc.sections[-1]
+    return int(section.page_width - section.left_margin - section.right_margin)
+
+
+def _calcular_larguras_naturais(
+    dados: list[list[str]],
+    colunas_df: Sequence,
+    colunas_data: set,
+) -> list[int]:
+    larguras = []
+
+    for indice, header in enumerate(dados[0]):
+        valores = [row[indice] for row in dados[1:] if row[indice]]
+        if indice == 0:
+            valores = valores or ["1"]
+        else:
+            col = colunas_df[indice - 1]
+            if col in colunas_data:
+                valores.append("00/00/0000")
+
+        largura = max(_medir_texto_emu(valor) for valor in valores) if valores else _medir_texto_emu("")
+
+        if indice > 0 and colunas_df[indice - 1] in colunas_data:
+            largura = max(largura, _polegadas_para_emu(LARGURA_MINIMA_DATA_POLEGADAS))
+
+        larguras.append(largura)
+
+    return larguras
+
+
+def _largura_rh_emu() -> int:
+    return _medir_texto_emu("999")
+
+
+def _aplicar_larguras_especiais(
+    larguras: Sequence[int],
+    dados: list[list[str]],
+    colunas_df: Sequence,
+) -> list[int]:
+    larguras_ajustadas = [int(largura) for largura in larguras]
+
+    valores_id = [row[0] for row in dados[1:] if row[0]]
+    if valores_id:
+        larguras_ajustadas[0] = max(
+            larguras_ajustadas[0],
+            max(_medir_texto_emu(valor) for valor in valores_id),
+        )
+
+    for indice, col in enumerate(colunas_df, start=1):
+        if _is_coluna_rh(col):
+            larguras_ajustadas[indice] = _largura_rh_emu()
+
+    return larguras_ajustadas
+
+
+def _calcular_larguras_fallback(
+    colunas_df: Sequence,
+    colunas_data: set,
+    colunas_texto_puro: set,
+    colunas_dicotomicas: set,
+) -> list[float]:
+    larguras = [0.5]
+    for col in colunas_df:
+        if _is_coluna_rh(col):
+            larguras.append(PESO_COLUNA_RH)
+        elif col in colunas_dicotomicas:
+            larguras.append(PESO_COLUNA_DICOTOMICA)
+        elif col in colunas_texto_puro:
+            larguras.append(PESO_COLUNA_TEXTO)
+        elif col in colunas_data:
+            larguras.append(PESO_COLUNA_DATA)
+        else:
+            larguras.append(1)
+    return larguras
+
+
+def _converter_pesos_para_larguras_absolutas(
+    pesos: Sequence[float],
+    largura_total: int,
+) -> list[int]:
+    total = sum(pesos)
+    return [int(largura_total * peso / total) for peso in pesos]
+
+
+def _calcular_rotacoes_cabecalho(
+    headers: Sequence[str],
+    larguras_finais: Sequence[int],
+    colunas_df: Sequence,
+    colunas_dicotomicas: set,
+) -> list[bool]:
+    rotacoes = []
+    for indice, (header, largura) in enumerate(zip(headers, larguras_finais)):
+        if indice > 0 and (
+            colunas_df[indice - 1] in colunas_dicotomicas
+            or _is_coluna_rh(colunas_df[indice - 1])
+        ):
+            rotacoes.append(True)
+        else:
+            rotacoes.append(len(str(header)) > 4 and _medir_cabecalho_emu(header) > largura)
+    return rotacoes
+
+
+def _colunas_dicotomicas_na_tabela(modelo: ModelData, colunas_df: Sequence) -> set:
+    dicotomicas = {str(col) for col in modelo.variaveis_dicotomicas}
+    return {col for col in colunas_df if str(col) in dicotomicas}
+
+
+def _formatar_cabecalho_coluna(col) -> str:
+    if _is_coluna_coordenada(col):
+        return str(col).upper()
+    return str(col)
+
+
+def _filtrar_dataframe_banco_dados(
+    modelo: Optional[ModelData],
+    colunas: Optional[Sequence[str]] = None,
+) -> Optional[pd.DataFrame]:
+    if modelo is None or modelo.xy_preview.empty:
+        return None
+
+    df = modelo.xy_preview
+    colunas_por_nome = {str(col): col for col in df.columns.tolist()}
+    colunas_disponiveis = list(colunas_por_nome.keys())
+
+    if colunas is None:
+        return df
+
+    colunas_validas = [
+        colunas_por_nome[col]
+        for col in colunas
+        if col in colunas_disponiveis
+    ]
+    if not colunas_validas:
+        return df.iloc[:, 0:0]
+
+    return df.loc[:, colunas_validas]
+
+
+def _montar_dados_tabela(df: pd.DataFrame) -> tuple[list[list[str]], set, set]:
+    colunas_data = {
+        col for col in df.columns if _is_coluna_data(col, df[col])
+    }
+    colunas_texto_puro = {
+        col for col in df.columns if _is_coluna_texto_puro(col, df[col])
+    }
+
+    # Detectar colunas que contêm apenas valores inteiros
+    colunas_inteiras = set()
+    for col in df.columns:
+        valores = _valores_nao_vazios(df[col])
+        if len(valores) > 0 and all(
+            _is_numero(v) and float(v) == int(v)
+            for v in valores
+        ):
+            colunas_inteiras.add(col)
+
+    headers = ["ID"] + [_formatar_cabecalho_coluna(col) for col in df.columns.tolist()]
+    dados = [headers]
+
+    for idx, (_, row) in enumerate(df.iterrows(), start=1):
+        linha = [str(idx)]  # ID da amostra (1-based)
+        for col, val in zip(df.columns, row.values):
+            linha.append(_formatar_valor_tabela(val, col, colunas_inteiras, colunas_data))
+        dados.append(linha)
+
+    return dados, colunas_data, colunas_texto_puro
+
+
+def anexo_banco_dados_cabe_na_largura(
+    modelo: Optional[ModelData],
+    colunas: Optional[Sequence[str]],
+    largura_util: int,
+) -> bool:
+    """Retorna True quando a tabela cabe usando larguras naturais por valor."""
+    df = _filtrar_dataframe_banco_dados(modelo, colunas)
+    if df is None or df.empty:
+        return True
+
+    dados, colunas_data, _ = _montar_dados_tabela(df)
+    larguras_naturais = _calcular_larguras_naturais(dados, df.columns.tolist(), colunas_data)
+    larguras_naturais = _aplicar_larguras_especiais(larguras_naturais, dados, df.columns.tolist())
+    return sum(larguras_naturais) <= largura_util
+
+
+def gerar_anexo_banco_dados(
+    doc: Document,
+    modelo: Optional[ModelData],
+    colunas: Optional[Sequence[str]] = None,
+) -> None:
+    """
+    Gera o conteúdo do Anexo de Banco de Dados.
+    
+    Args:
+        doc: Documento DOCX
+        modelo: Dados do modelo carregado do .dai
+        colunas: Colunas do banco de dados a exibir, na ordem desejada.
+            Quando omitido, todas as colunas são exibidas.
+    """
+    if modelo is None:
+        add_placeholder_text(doc, "[Modelo não selecionado - inserir banco de dados manualmente]")
+        return
+    
+    if modelo.xy_preview.empty:
+        add_placeholder_text(doc, "[Banco de dados não disponível no modelo]")
+        return
+
+    df = _filtrar_dataframe_banco_dados(modelo, colunas)
+    if df is None or df.empty:
+        add_placeholder_text(doc, "[Nenhuma coluna válida selecionada para o banco de dados]")
+        return
+
+    dados, colunas_data, colunas_texto_puro = _montar_dados_tabela(df)
+    headers = dados[0]
+    colunas_df = df.columns.tolist()
+    colunas_dicotomicas = _colunas_dicotomicas_na_tabela(modelo, colunas_df)
+    
+    largura_util = _largura_util_pagina_emu(doc)
+    larguras_naturais = _calcular_larguras_naturais(dados, colunas_df, colunas_data)
+    usar_largura_natural = sum(larguras_naturais) <= largura_util
+
+    if usar_largura_natural:
+        larguras_finais = larguras_naturais
+    else:
+        pesos_fallback = _calcular_larguras_fallback(
+            colunas_df,
+            colunas_data,
+            colunas_texto_puro,
+            colunas_dicotomicas,
+        )
+        larguras_finais = _converter_pesos_para_larguras_absolutas(pesos_fallback, largura_util)
+
+    larguras_finais = _aplicar_larguras_especiais(larguras_finais, dados, colunas_df)
+
+    rotacoes_cabecalho = _calcular_rotacoes_cabecalho(
+        headers,
+        larguras_finais,
+        colunas_df,
+        colunas_dicotomicas,
+    )
+    
+    add_simple_table(
+        doc,
+        dados,
+        header_row=True,
+        largura_colunas=larguras_finais,
+        rotacao_cabecalho=rotacoes_cabecalho,
+        largura_total=largura_util,
+        largura_colunas_absolutas=True,
+        no_quebrar_linha=True,
+    )

backend/app/core/anexos/calculo_valor.py

@@ -0,0 +1,157 @@
+"""Geração do Anexo IV, com preenchimento opcional por uma avaliação da mesa."""
+from __future__ import annotations
+
+from numbers import Number
+from typing import Any
+
+from docx import Document
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+from .formatters import (
+    add_body_text,
+    add_placeholder_text,
+    add_simple_table,
+    add_subsection_title,
+    criar_paragrafo_formatado,
+)
+from .model_data import ModelData
+
+
+def _numero(value: Any) -> float | None:
+    try:
+        numero = float(value)
+    except (TypeError, ValueError):
+        return None
+    return numero
+
+
+def _formatar_numero(value: Any, casas: int = 2) -> str:
+    numero = _numero(value)
+    if numero is None:
+        return "-" if value in (None, "") else str(value)
+    return f"{numero:,.{casas}f}".replace(",", "X").replace(".", ",").replace("X", ".")
+
+
+def _formatar_moeda(value: Any) -> str:
+    numero = _numero(value)
+    return "-" if numero is None else f"R$ {_formatar_numero(numero)}"
+
+
+def _formatar_percentual(value: Any) -> str:
+    numero = _numero(value)
+    return "-" if numero is None else f"{_formatar_numero(numero, 1)}%"
+
+
+def _rotulo_estimado(tipo_y: str) -> tuple[str, str]:
+    if tipo_y == "unitario":
+        return "Valor unitário estimado", "Valor total estimado"
+    if tipo_y == "total":
+        return "Valor total estimado", "Valor unitário estimado"
+    return "Valor estimado", ""
+
+
+def gerar_anexo_calculo(
+    doc: Document,
+    modelo: ModelData | None,
+    avaliacao: dict[str, Any] | None = None,
+) -> None:
+    if modelo is None:
+        add_placeholder_text(doc, "[Modelo não selecionado - inserir cálculo manualmente]")
+        return
+
+    if modelo.equacao:
+        add_subsection_title(doc, "", "Equação do Modelo")
+        criar_paragrafo_formatado(
+            doc,
+            modelo.equacao,
+            tamanho=11,
+            alinhamento=WD_ALIGN_PARAGRAPH.CENTER,
+            espaco_depois=12,
+        )
+
+    if modelo.variaveis:
+        add_subsection_title(doc, "", "Variáveis do Modelo")
+        for variavel in modelo.variaveis:
+            add_body_text(doc, f"• {variavel}")
+
+    doc.add_paragraph()
+
+    if not modelo.tabelas_coef.empty:
+        add_subsection_title(doc, "", "Coeficientes")
+        df = modelo.tabelas_coef
+        coluna_coef = next(
+            (col for col in ("coef", "Coeficiente", "coeficiente") if col in df.columns),
+            None,
+        )
+        if coluna_coef:
+            for indice, row in df.iterrows():
+                coeficiente = row[coluna_coef]
+                texto = f"{float(coeficiente):.6f}" if isinstance(coeficiente, Number) else str(coeficiente)
+                add_body_text(doc, f"• {indice}: {texto}")
+
+    doc.add_paragraph()
+    add_subsection_title(doc, "", "Cálculo do Valor do Imóvel")
+
+    if not avaliacao:
+        add_placeholder_text(doc, "[Inserir valores das variáveis para o imóvel avaliado]")
+        add_placeholder_text(doc, "[Inserir cálculo e resultado final]")
+        return
+
+    _adicionar_avaliacao(doc, avaliacao)
+
+
+def _adicionar_avaliacao(doc: Document, avaliacao: dict[str, Any]) -> None:
+    valores_x = avaliacao.get("valores_x")
+    valores_x = valores_x if isinstance(valores_x, dict) else {}
+    coluna_area = str(avaliacao.get("coluna_area") or "").strip()
+    valor_area = avaliacao.get("valor_area")
+
+    valores_tabela = [["Variável", "Valor informado"]]
+    for variavel, valor in valores_x.items():
+        valores_tabela.append([str(variavel), _formatar_numero(valor)])
+    if coluna_area and coluna_area not in valores_x and valor_area is not None:
+        valores_tabela.append([coluna_area, _formatar_numero(valor_area)])
+
+    add_body_text(doc, "Valores utilizados:", indent=False)
+    if len(valores_tabela) > 1:
+        add_simple_table(doc, valores_tabela, header_row=True)
+
+    tipo_y = str(avaliacao.get("tipo_y") or "").strip().lower()
+    rotulo_principal, rotulo_convertido = _rotulo_estimado(tipo_y)
+    resultado_tabela = [["Resultado", "Valor"]]
+    resultado_tabela.append([rotulo_principal, _formatar_moeda(avaliacao.get("estimado"))])
+
+    if rotulo_convertido:
+        chave_convertida = "estimado_total" if tipo_y == "unitario" else "estimado_unitario"
+        if avaliacao.get(chave_convertida) is not None:
+            resultado_tabela.append([rotulo_convertido, _formatar_moeda(avaliacao.get(chave_convertida))])
+
+    resultado_tabela.extend(
+        [
+            ["Campo de arbítrio -15%", _formatar_moeda(avaliacao.get("ca_inf"))],
+            ["Campo de arbítrio +15%", _formatar_moeda(avaliacao.get("ca_sup"))],
+            [
+                "Intervalo de confiança 80% - inferior",
+                f"{_formatar_moeda(avaliacao.get('ic_inf'))} ({_formatar_percentual(avaliacao.get('perc_inf'))})",
+            ],
+            [
+                "Intervalo de confiança 80% - superior",
+                f"{_formatar_moeda(avaliacao.get('ic_sup'))} ({_formatar_percentual(avaliacao.get('perc_sup'))})",
+            ],
+            ["Amplitude do intervalo", _formatar_percentual(avaliacao.get("amplitude"))],
+            ["Grau de precisão", str(avaliacao.get("precisao") or "-")],
+            ["Grau de fundamentação", str(avaliacao.get("fundamentacao") or "-")],
+        ]
+    )
+
+    if bool(avaliacao.get("houve_extrapolacao")):
+        resultado_tabela.append(
+            ["Quantidade de extrapolações", _formatar_numero(avaliacao.get("qtd_extrapolacoes"), 0)]
+        )
+        if avaliacao.get("fronteira") is not None:
+            resultado_tabela.append(["Valor estimado na fronteira", _formatar_moeda(avaliacao.get("fronteira"))])
+        if avaliacao.get("perc_ext") is not None:
+            resultado_tabela.append(["Impacto da extrapolação", _formatar_percentual(avaliacao.get("perc_ext"))])
+
+    add_subsection_title(doc, "", "Resultado da Avaliação")
+    add_simple_table(doc, resultado_tabela, header_row=True)

backend/app/core/anexos/estatisticas_utils.py

@@ -0,0 +1,114 @@
+"""
+Utilitários para processamento de estatísticas do modelo.
+Funções compartilhadas entre interface_estatisticas e geração de documentos.
+"""
+from typing import Dict, Any, Optional
+import numpy as np
+
+
+def reorganizar_modelos_resumos(resumo_original: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Reorganiza a estrutura do dicionário modelos_resumos para uma
+    estrutura mais organizada com estatísticas gerais e testes separados.
+
+    Parâmetros
+    ----------
+    resumo_original : dict
+        Dicionário original com as chaves do modelo.
+
+    Retorna
+    -------
+    dict
+        Dicionário reorganizado com a nova estrutura.
+    """
+    if not resumo_original:
+        return {}
+
+    return {
+        "estatisticas_gerais": {
+            "n": {
+                "nome": "Número de observações",
+                "valor": resumo_original.get("n")
+            },
+            "k": {
+                "nome": "Número de variáveis independentes",
+                "valor": resumo_original.get("k")
+            },
+            "desvio_padrao_residuos": {
+                "nome": "Desvio padrão dos resíduos",
+                "valor": resumo_original.get("desvio_padrao_residuos")
+            },
+            "mse": {
+                "nome": "MSE",
+                "valor": resumo_original.get("mse")
+            },
+            "r2": {
+                "nome": "R²",
+                "valor": resumo_original.get("r2")
+            },
+            "r2_ajustado": {
+                "nome": "R² ajustado",
+                "valor": resumo_original.get("r2_ajustado")
+            },
+            "r_pearson": {
+                "nome": "Correlação Pearson",
+                "valor": resumo_original.get("r_pearson")
+            }
+        },
+        "teste_f": {
+            "nome": "Teste F",
+            "estatistica": resumo_original.get("Fc"),
+            "pvalor": resumo_original.get("p_valor_F"),
+            "interpretacao": resumo_original.get("Interpretacao_F")
+        },
+        "teste_ks": {
+            "nome": "Teste de Normalidade (Kolmogorov-Smirnov)",
+            "estatistica": resumo_original.get("ks_stat"),
+            "pvalor": resumo_original.get("ks_p"),
+            "interpretacao": resumo_original.get("Interpretacao_KS")
+        },
+        "perc_resid": {
+            "nome": "Teste de Normalidade (Comparação com a Curva Normal)",
+            "valor": resumo_original.get("perc_resid"),
+            "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": resumo_original.get("dw"),
+            "interpretacao": resumo_original.get("Interpretacao_DW")
+        },
+        "teste_bp": {
+            "nome": "Teste de Homocedasticidade (Breusch-Pagan)",
+            "estatistica": resumo_original.get("bp_lm"),
+            "pvalor": resumo_original.get("bp_p"),
+            "interpretacao": resumo_original.get("Interpretacao_BP")
+        },
+        "equacao": resumo_original.get("equacao")
+    }
+
+
+def formatar_numero(valor: Any, casas_decimais: int = 4) -> str:
+    """
+    Formata número com casas decimais específicas.
+
+    Parâmetros
+    ----------
+    valor : Any
+        Valor a ser formatado.
+    casas_decimais : int
+        Número de casas decimais (default: 4).
+
+    Retorna
+    -------
+    str
+        Valor formatado como string.
+    """
+    if valor is None:
+        return "N/A"
+    if isinstance(valor, (int, float, np.floating)):
+        return f"{valor:.{casas_decimais}f}"
+    return str(valor)

backend/app/core/anexos/formatters/__init__.py

@@ -0,0 +1,63 @@
+"""
+Formatadores de documentos DOCX.
+"""
+from .paragraph import (
+    aplicar_cor_run,
+    criar_paragrafo_formatado,
+    add_body_text,
+    add_placeholder_text,
+    add_bullet_text,
+)
+from .heading import (
+    add_heading_custom,
+    add_section_title,
+    add_subsection_title,
+    add_subsubsection_title,
+    add_subsubsubsection_title,
+)
+from .table import (
+    set_cell_shading,
+    formatar_celula_tabela,
+    add_simple_table,
+    configurar_linha_tabela_altura,
+    configurar_linha_cabecalho_repetir,
+    criar_celula_cabecalho_tabela,
+    criar_celula_dados_tabela,
+)
+from .image import (
+    inserir_imagem_de_documento,
+    add_image_placeholder,
+)
+from .section import (
+    iniciar_secao_paisagem,
+    iniciar_secao_retrato,
+)
+
+__all__ = [
+    # Parágrafos
+    'aplicar_cor_run',
+    'criar_paragrafo_formatado',
+    'add_body_text',
+    'add_placeholder_text',
+    'add_bullet_text',
+    # Títulos
+    'add_heading_custom',
+    'add_section_title',
+    'add_subsection_title',
+    'add_subsubsection_title',
+    'add_subsubsubsection_title',
+    # Tabelas
+    'set_cell_shading',
+    'formatar_celula_tabela',
+    'add_simple_table',
+    'configurar_linha_tabela_altura',
+    'configurar_linha_cabecalho_repetir',
+    'criar_celula_cabecalho_tabela',
+    'criar_celula_dados_tabela',
+    # Imagens
+    'inserir_imagem_de_documento',
+    'add_image_placeholder',
+    # Seções
+    'iniciar_secao_paisagem',
+    'iniciar_secao_retrato',
+]

backend/app/core/anexos/formatters/heading.py

@@ -0,0 +1,57 @@
+"""
+Formatadores de títulos e seções.
+"""
+from docx import Document
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+from .paragraph import criar_paragrafo_formatado
+
+
+def add_heading_custom(doc: Document, text: str, level: int = 1):
+    """Adiciona título customizado."""
+    configs = {
+        1: {'tamanho': 14, 'antes': 18, 'depois': 12},
+        2: {'tamanho': 12, 'antes': 12, 'depois': 6},
+    }
+    cfg = configs.get(level, {'tamanho': 11, 'antes': 6, 'depois': 6})
+
+    return criar_paragrafo_formatado(
+        doc, text, negrito=True, sublinhado=True, tamanho=cfg['tamanho'],
+        espaco_antes=cfg['antes'], espaco_depois=cfg['depois'],
+        alinhamento=WD_ALIGN_PARAGRAPH.LEFT
+    )
+
+
+def add_section_title(doc: Document, number: str, text: str):
+    """Adiciona título de seção principal (ex: 1. SOLICITAÇÃO)."""
+    return criar_paragrafo_formatado(
+        doc, f"{number}. {text}", negrito=True, tamanho=12,
+        espaco_antes=18, espaco_depois=12, alinhamento=WD_ALIGN_PARAGRAPH.LEFT
+    )
+
+
+def add_subsection_title(doc: Document, number: str, text: str):
+    """Adiciona título de subseção (ex: 1.1 Considerações)."""
+    return criar_paragrafo_formatado(
+        doc, f"{number} {text}", negrito=True, tamanho=11,
+        espaco_antes=12, espaco_depois=6, recuo_esq=0.3,
+        alinhamento=WD_ALIGN_PARAGRAPH.LEFT
+    )
+
+
+def add_subsubsection_title(doc: Document, number: str, text: str):
+    """Adiciona título de sub-subseção (ex: 3.2.1)."""
+    return criar_paragrafo_formatado(
+        doc, f"{number} {text}", negrito=True, tamanho=11,
+        espaco_antes=10, espaco_depois=4, recuo_esq=0.5,
+        alinhamento=WD_ALIGN_PARAGRAPH.LEFT
+    )
+
+
+def add_subsubsubsection_title(doc: Document, number: str, text: str):
+    """Adiciona título de sub-sub-subseção (ex: 3.2.1.1)."""
+    return criar_paragrafo_formatado(
+        doc, f"{number} {text}", negrito=True, tamanho=10,
+        espaco_antes=8, espaco_depois=4, recuo_esq=0.7,
+        alinhamento=WD_ALIGN_PARAGRAPH.LEFT
+    )

backend/app/core/anexos/formatters/image.py

@@ -0,0 +1,63 @@
+"""
+Formatadores de imagens.
+"""
+from io import BytesIO
+from docx import Document
+from docx.shared import Inches
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from typing import Dict, Any, Optional
+
+
+def inserir_imagem_de_documento(
+    doc: Document,
+    imagem_data: Optional[Dict[str, Any]],
+    largura_inches: float = 5.5
+) -> bool:
+    """
+    Insere uma imagem extraída de outro documento.
+
+    Args:
+        doc: Documento destino
+        imagem_data: Dict com 'paragraph_element' e 'doc' (documento origem)
+        largura_inches: Largura da imagem
+
+    Returns:
+        True se inseriu com sucesso, False caso contrário
+    """
+    if not imagem_data:
+        return False
+
+    try:
+        para_elem = imagem_data['paragraph_element']
+        doc_origem = imagem_data['doc']
+
+        ns_a = '{http://schemas.openxmlformats.org/drawingml/2006/main}'
+        ns_r = '{http://schemas.openxmlformats.org/officeDocument/2006/relationships}'
+
+        for blip in para_elem.iter(f'{ns_a}blip'):
+            embed_id = blip.get(f'{ns_r}embed')
+            if embed_id:
+                try:
+                    image_part = doc_origem.part.related_parts[embed_id]
+                    image_stream = BytesIO(image_part.blob)
+
+                    p = doc.add_paragraph()
+                    p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+                    run = p.add_run()
+                    run.add_picture(image_stream, width=Inches(largura_inches))
+                    return True
+                except Exception as e:
+                    print(f"Erro ao copiar imagem: {e}")
+                    return False
+    except Exception as e:
+        print(f"Erro ao processar imagem: {e}")
+        return False
+
+    return False
+
+
+def add_image_placeholder(doc: Document) -> None:
+    """Adiciona placeholder de imagem."""
+    p = doc.add_paragraph()
+    p.add_run("[IMAGEM]").italic = True
+    p.alignment = WD_ALIGN_PARAGRAPH.CENTER

backend/app/core/anexos/formatters/paragraph.py

@@ -0,0 +1,102 @@
+"""
+Formatadores de parágrafos.
+"""
+from docx import Document
+from docx.shared import Pt, Inches, Cm, RGBColor
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from typing import Optional, Tuple, Union
+
+
+def aplicar_cor_run(run, cor: Optional[Union[Tuple[int, int, int], RGBColor]]) -> None:
+    """
+    Aplica cor RGB a um run.
+
+    Args:
+        run: Run do python-docx
+        cor: tuple (r,g,b) ou RGBColor
+    """
+    if cor:
+        if isinstance(cor, tuple):
+            run.font.color.rgb = RGBColor(cor[0], cor[1], cor[2])
+        else:
+            run.font.color.rgb = cor
+
+
+def criar_paragrafo_formatado(
+    doc: Document,
+    texto: str,
+    negrito: bool = False,
+    sublinhado: bool = False,
+    italico: bool = False,
+    tamanho: int = 11,
+    cor: Optional[Union[Tuple[int, int, int], RGBColor]] = None,
+    alinhamento=WD_ALIGN_PARAGRAPH.JUSTIFY,
+    espaco_antes: int = 0,
+    espaco_depois: int = 6,
+    recuo_esq: float = 0,
+    recuo_primeira_linha: float = 0,
+    fonte: str = 'Arial'
+):
+    """
+    Cria um parágrafo com formatação completa.
+
+    Args:
+        doc: Documento python-docx
+        texto: Texto do parágrafo
+        negrito, sublinhado, italico: Formatação do texto
+        tamanho: Tamanho da fonte em pontos
+        cor: RGBColor ou tuple (r,g,b)
+        alinhamento: WD_ALIGN_PARAGRAPH constant
+        espaco_antes, espaco_depois: Espaçamento em pontos
+        recuo_esq: Recuo esquerdo em inches
+        recuo_primeira_linha: Recuo da primeira linha em cm
+        fonte: Nome da fonte
+
+    Returns:
+        Parágrafo criado
+    """
+    p = doc.add_paragraph()
+    run = p.add_run(texto)
+
+    run.bold = negrito
+    run.underline = sublinhado
+    run.italic = italico
+    run.font.size = Pt(tamanho)
+    run.font.name = fonte
+    aplicar_cor_run(run, cor)
+
+    p.alignment = alinhamento
+    p.paragraph_format.space_before = Pt(espaco_antes)
+    p.paragraph_format.space_after = Pt(espaco_depois)
+    if recuo_esq:
+        p.paragraph_format.left_indent = Inches(recuo_esq)
+    if recuo_primeira_linha:
+        p.paragraph_format.first_line_indent = Cm(recuo_primeira_linha)
+
+    return p
+
+
+def add_body_text(doc: Document, text: str, cor=None, indent: bool = True):
+    """Adiciona texto do corpo com formatação padrão."""
+    return criar_paragrafo_formatado(
+        doc, text, tamanho=11, cor=cor,
+        espaco_depois=6, recuo_esq=0.3 if indent else 0,
+        recuo_primeira_linha=1.25 if indent else 0
+    )
+
+
+def add_placeholder_text(doc: Document, text: str = "[Preencher informações]", indent: bool = True):
+    """Adiciona texto placeholder em vermelho."""
+    return criar_paragrafo_formatado(
+        doc, text, tamanho=11, cor=RGBColor(255, 0, 0),
+        espaco_depois=6, recuo_esq=0.3 if indent else 0,
+        recuo_primeira_linha=1.25 if indent else 0
+    )
+
+
+def add_bullet_text(doc: Document, text: str, indent_level: int = 1):
+    """Adiciona texto com bullet/recuo."""
+    return criar_paragrafo_formatado(
+        doc, f"• {text}", tamanho=11,
+        espaco_depois=3, recuo_esq=0.3 + (indent_level * 0.2)
+    )

backend/app/core/anexos/formatters/section.py

@@ -0,0 +1,59 @@
+"""
+Formatadores de seções e orientação de página.
+"""
+from docx import Document
+from docx.shared import Cm
+from docx.enum.section import WD_ORIENT
+
+
+def iniciar_secao_paisagem(doc: Document) -> None:
+    """
+    Adiciona uma nova seção com orientação paisagem.
+
+    Args:
+        doc: Documento DOCX
+    """
+    # Adicionar quebra de seção
+    new_section = doc.add_section()
+
+    # Configurar orientação paisagem
+    new_section.orientation = WD_ORIENT.LANDSCAPE
+
+    # Trocar largura e altura para paisagem
+    new_width = new_section.page_height
+    new_height = new_section.page_width
+    new_section.page_width = new_width
+    new_section.page_height = new_height
+
+    # Ajustar margens para paisagem
+    new_section.top_margin = Cm(2)
+    new_section.bottom_margin = Cm(2)
+    new_section.left_margin = Cm(2)
+    new_section.right_margin = Cm(2)
+
+
+def iniciar_secao_retrato(doc: Document) -> None:
+    """
+    Adiciona uma nova seção com orientação retrato.
+
+    Args:
+        doc: Documento DOCX
+    """
+    # Adicionar quebra de seção
+    new_section = doc.add_section()
+
+    # Configurar orientação retrato
+    new_section.orientation = WD_ORIENT.PORTRAIT
+
+    # Trocar largura e altura para retrato (se estava em paisagem)
+    if new_section.page_width > new_section.page_height:
+        new_width = new_section.page_height
+        new_height = new_section.page_width
+        new_section.page_width = new_width
+        new_section.page_height = new_height
+
+    # Margens padrão para retrato
+    new_section.top_margin = Cm(2.5)
+    new_section.bottom_margin = Cm(2.5)
+    new_section.left_margin = Cm(3)
+    new_section.right_margin = Cm(2)

backend/app/core/anexos/formatters/table.py

@@ -0,0 +1,295 @@
+"""
+Formatadores de tabelas.
+"""
+from collections.abc import Sequence as SequenceABC
+from docx import Document
+from docx.shared import Pt, Inches, Cm
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.enum.table import WD_TABLE_ALIGNMENT, WD_CELL_VERTICAL_ALIGNMENT
+from docx.oxml.ns import qn
+from docx.oxml import OxmlElement
+from typing import List, Optional, Sequence, Union, Dict, Any
+
+from .paragraph import aplicar_cor_run
+
+WD_ALIGN_VERTICAL = WD_CELL_VERTICAL_ALIGNMENT
+
+
+def set_cell_shading(cell, color: str) -> None:
+    """
+    Define a cor de fundo de uma célula.
+
+    Args:
+        cell: Célula da tabela
+        color: Cor em hex (ex: "E6E6E6")
+    """
+    shading = OxmlElement('w:shd')
+    shading.set(qn('w:fill'), color)
+    cell._tc.get_or_add_tcPr().append(shading)
+
+
+def set_cell_text_rotation(cell, direcao: str = 'btLr') -> None:
+    """
+    Define a direção/rotação do texto em uma célula.
+
+    Args:
+        cell: Célula da tabela
+        direcao: Direção do texto:
+            - 'btLr': bottom-to-top, left-to-right (90° - vertical)
+            - 'tbRl': top-to-bottom, right-to-left (270°)
+    """
+    tcPr = cell._tc.get_or_add_tcPr()
+    textDirection = OxmlElement('w:textDirection')
+    textDirection.set(qn('w:val'), direcao)
+    tcPr.append(textDirection)
+
+
+def set_cell_no_wrap(cell) -> None:
+    """Evita quebra automática de linha em uma célula."""
+    tcPr = cell._tc.get_or_add_tcPr()
+    no_wrap = OxmlElement('w:noWrap')
+    no_wrap.set(qn('w:val'), '1')
+    tcPr.append(no_wrap)
+
+
+def formatar_celula_tabela(cell, texto: str, negrito: bool = False, cor=None,
+                           shading_color: Optional[str] = None, rotacao: bool = False,
+                           no_wrap: bool = False):
+    """
+    Formata uma célula de tabela com configurações padrão.
+
+    Args:
+        cell: Célula da tabela
+        texto: Texto a inserir
+        negrito: Se o texto deve ser negrito
+        cor: Cor do texto (tuple ou RGBColor)
+        shading_color: Cor de fundo da célula (hex string)
+        rotacao: Se True, rotaciona o texto 90° (vertical)
+        no_wrap: Se True, evita quebra automática de linha
+
+    Returns:
+        Run criado
+    """
+    p = cell.paragraphs[0]
+
+    p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    p.paragraph_format.left_indent = Cm(0)
+    p.paragraph_format.right_indent = Cm(0)
+    p.paragraph_format.first_line_indent = Cm(0)
+    p.paragraph_format.space_before = Pt(0)
+    p.paragraph_format.space_after = Pt(0)
+
+    cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
+
+    run = p.add_run(texto)
+    run.font.size = Pt(8)
+    run.font.name = 'Arial'
+    run.bold = negrito
+
+    if cor:
+        aplicar_cor_run(run, cor)
+
+    if shading_color:
+        set_cell_shading(cell, shading_color)
+
+    if rotacao:
+        set_cell_text_rotation(cell)
+
+    if no_wrap:
+        set_cell_no_wrap(cell)
+
+    return run
+
+
+def add_simple_table(
+    doc: Document,
+    dados_tabela: List[List[Union[str, Dict[str, Any]]]],
+    header_row: bool = True,
+    largura_colunas: Optional[List[float]] = None,
+    rotacao_cabecalho: Union[bool, Sequence[bool]] = False,
+    largura_total: Optional[int] = None,
+    largura_colunas_absolutas: bool = False,
+    no_quebrar_linha: bool = False,
+):
+    """
+    Adiciona uma tabela simples ao documento.
+
+    Args:
+        doc: Documento
+        dados_tabela: Lista de listas. Cada célula pode ser string ou dict {'texto', 'cor'}
+        header_row: Se True, primeira linha é cabeçalho (negrito com fundo cinza)
+        largura_colunas: Lista de inteiros representando proporção da largura de cada coluna.
+        rotacao_cabecalho: Se True, rotaciona todos os cabeçalhos 90°.
+            Também aceita lista de booleanos para controlar coluna a coluna.
+        largura_total: Largura total disponível para a tabela. Quando omitida, usa 6.5".
+        largura_colunas_absolutas: Se True, largura_colunas já contém larguras em EMUs.
+        no_quebrar_linha: Se True, evita quebra automática de linha nas células.
+
+    Returns:
+        Tabela criada ou None se dados vazios
+    """
+    if not dados_tabela or not dados_tabela[0]:
+        return None
+
+    num_colunas = len(dados_tabela[0])
+
+    if largura_colunas is None:
+        largura_colunas = [1] * num_colunas
+    elif len(largura_colunas) != num_colunas:
+        raise ValueError("largura_colunas deve ter o mesmo número de colunas de dados_tabela")
+
+    if isinstance(rotacao_cabecalho, SequenceABC) and not isinstance(rotacao_cabecalho, (str, bytes)):
+        if len(rotacao_cabecalho) != num_colunas:
+            raise ValueError("rotacao_cabecalho deve ter o mesmo número de colunas de dados_tabela")
+        rotacoes_cabecalho = [bool(valor) for valor in rotacao_cabecalho]
+    else:
+        rotacoes_cabecalho = [bool(rotacao_cabecalho)] * num_colunas
+
+    if largura_total is None:
+        largura_total = Inches(6.5)
+
+    table = doc.add_table(rows=len(dados_tabela), cols=num_colunas)
+    table.style = 'Table Grid'
+    table.alignment = WD_TABLE_ALIGNMENT.CENTER
+    table.autofit = False
+
+    if largura_colunas_absolutas:
+        larguras_em_colunas = [int(largura) for largura in largura_colunas]
+    else:
+        total = sum(largura_colunas)
+        proporcoes = [x / total for x in largura_colunas]
+        larguras_em_colunas = [int(largura_total * p) for p in proporcoes]
+
+    for j, largura in enumerate(larguras_em_colunas):
+        table.columns[j].width = largura
+
+    for i, row_data in enumerate(dados_tabela):
+        row = table.rows[i]
+        for j, cell_data in enumerate(row_data):
+            if j >= len(row.cells):
+                continue
+
+            cell = row.cells[j]
+
+            if isinstance(cell_data, dict):
+                texto = cell_data.get('texto', '')
+                cor = cell_data.get('cor')
+            else:
+                texto = str(cell_data) if cell_data else ""
+                cor = None
+
+            is_header = header_row and i == 0
+
+            formatar_celula_tabela(
+                cell, texto,
+                negrito=is_header,
+                cor=cor,
+                shading_color="E6E6E6" if is_header else None,
+                rotacao=is_header and rotacoes_cabecalho[j],
+                no_wrap=no_quebrar_linha or is_header,
+            )
+
+            cell.width = larguras_em_colunas[j]
+
+    if header_row and len(dados_tabela) > 1:
+        configurar_linha_cabecalho_repetir(table.rows[0])
+
+    # Ajustar altura do cabeçalho para texto rotacionado
+    if header_row and any(rotacoes_cabecalho) and dados_tabela:
+        # Calcular o maior texto do cabeçalho
+        header_texts = []
+        for j, cell_data in enumerate(dados_tabela[0]):
+            if not rotacoes_cabecalho[j]:
+                continue
+            if isinstance(cell_data, dict):
+                header_texts.append(cell_data.get('texto', ''))
+            else:
+                header_texts.append(str(cell_data) if cell_data else "")
+
+        if header_texts:
+            max_len = max(len(t) for t in header_texts)
+            # Cabeçalhos rotacionados precisam de folga extra no Word; uma
+            # linha justa corta ou força quebra visual do texto renderizado.
+            altura_cm = max(2.8, max_len * 0.25 + 0.9)
+            configurar_linha_tabela_altura(table.rows[0], altura_cm)
+
+    doc.add_paragraph()
+    return table
+
+
+def configurar_linha_tabela_altura(row, altura_cm: float = 0.6) -> None:
+    """
+    Configura altura mínima de uma linha de tabela.
+
+    Args:
+        row: Linha da tabela
+        altura_cm: Altura em centímetros
+    """
+    tr = row._tr
+    trPr = tr.get_or_add_trPr()
+    trHeight = OxmlElement('w:trHeight')
+    trHeight.set(qn('w:val'), str(int(Cm(altura_cm).twips)))
+    trHeight.set(qn('w:hRule'), 'atLeast')
+    trPr.append(trHeight)
+
+
+def configurar_linha_cabecalho_repetir(row) -> None:
+    """
+    Marca a linha como cabeçalho repetível em quebras de página.
+
+    Args:
+        row: Linha de cabeçalho da tabela
+    """
+    tr = row._tr
+    trPr = tr.get_or_add_trPr()
+    tbl_header = OxmlElement('w:tblHeader')
+    tbl_header.set(qn('w:val'), '1')
+    trPr.append(tbl_header)
+
+
+def criar_celula_cabecalho_tabela(cell, texto: str, recuo_primeira_linha_cm: float = 1.0) -> None:
+    """
+    Formata uma célula de cabeçalho de seção na tabela principal.
+
+    Args:
+        cell: Célula da tabela
+        texto: Texto do cabeçalho
+        recuo_primeira_linha_cm: Recuo da primeira linha
+    """
+    cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
+
+    p = cell.paragraphs[0]
+    p.paragraph_format.left_indent = Cm(0)
+    p.paragraph_format.first_line_indent = Cm(recuo_primeira_linha_cm)
+    p.alignment = WD_ALIGN_PARAGRAPH.LEFT
+
+    run = p.add_run(texto)
+    run.bold = True
+    run.underline = True
+    run.font.size = Pt(8)
+    run.font.name = 'Arial'
+
+    set_cell_shading(cell, "E6E6E6")
+
+
+def criar_celula_dados_tabela(cell, texto: str, is_label: bool = False) -> None:
+    """
+    Formata uma célula de dados na tabela principal.
+
+    Args:
+        cell: Célula da tabela
+        texto: Texto da célula
+        is_label: Se True, formata como rótulo (negrito)
+    """
+    cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
+
+    p = cell.paragraphs[0]
+    p.paragraph_format.left_indent = Cm(0)
+    p.paragraph_format.first_line_indent = Cm(0)
+    p.paragraph_format.space_before = Pt(0)
+    p.paragraph_format.space_after = Pt(0)
+
+    run = p.add_run(texto)
+    run.bold = is_label
+    run.font.size = Pt(8)
+    run.font.name = 'Arial'

backend/app/core/anexos/generator.py

@@ -0,0 +1,130 @@
+"""Gerador de documento contendo apenas anexos do modelo selecionado."""
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from io import BytesIO
+from pathlib import Path
+
+from docx import Document
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.shared import Cm
+
+from .banco_dados import anexo_banco_dados_cabe_na_largura, gerar_anexo_banco_dados
+from .calculo_valor import gerar_anexo_calculo
+from .graficos import gerar_anexo_graficos
+from .planilha_calculo import gerar_anexo_planilha
+from .formatters import (
+    criar_paragrafo_formatado,
+    iniciar_secao_paisagem,
+    iniciar_secao_retrato,
+)
+from .model_data import ModelData
+
+
+class AnexosGenerator:
+    """Gera um DOCX com os anexos técnicos de um modelo .dai."""
+
+    def __init__(self, output_dir: Path) -> None:
+        self.output_dir = output_dir
+
+    def gerar(
+        self,
+        modelo: ModelData,
+        banco_dados_colunas: list[str] | None = None,
+        avaliacao: dict | None = None,
+    ) -> Path:
+        doc = Document()
+        self._configurar_margens(doc)
+        self._gerar_anexos(
+            doc,
+            modelo,
+            banco_dados_colunas=banco_dados_colunas,
+            avaliacao=avaliacao,
+        )
+
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        output_path = self._gerar_nome_arquivo(modelo.nome)
+        doc.save(str(output_path))
+        return output_path
+
+    def gerar_em_memoria(
+        self,
+        modelo: ModelData,
+        banco_dados_colunas: list[str] | None = None,
+        avaliacao: dict | None = None,
+    ) -> tuple[bytes, str]:
+        """Gera o DOCX sem persistir o anexo no filesystem."""
+        doc = Document()
+        self._configurar_margens(doc)
+        self._gerar_anexos(
+            doc,
+            modelo,
+            banco_dados_colunas=banco_dados_colunas,
+            avaliacao=avaliacao,
+        )
+
+        buffer = BytesIO()
+        doc.save(buffer)
+        return buffer.getvalue(), self._gerar_nome_arquivo(modelo.nome).name
+
+    def _configurar_margens(self, doc: Document) -> None:
+        for section in doc.sections:
+            section.top_margin = Cm(2.5)
+            section.bottom_margin = Cm(2.5)
+            section.left_margin = Cm(3)
+            section.right_margin = Cm(2)
+
+    def _criar_titulo_anexo(self, doc: Document, titulo: str) -> None:
+        criar_paragrafo_formatado(
+            doc,
+            titulo,
+            negrito=True,
+            sublinhado=True,
+            tamanho=10,
+            espaco_antes=18,
+            espaco_depois=12,
+            alinhamento=WD_ALIGN_PARAGRAPH.CENTER,
+        )
+
+    def _largura_util_secao_atual(self, doc: Document) -> int:
+        section = doc.sections[-1]
+        return int(section.page_width - section.left_margin - section.right_margin)
+
+    def _gerar_anexos(
+        self,
+        doc: Document,
+        modelo: ModelData,
+        banco_dados_colunas: list[str] | None = None,
+        avaliacao: dict | None = None,
+    ) -> None:
+        banco_cabe_em_retrato = anexo_banco_dados_cabe_na_largura(
+            modelo,
+            banco_dados_colunas,
+            self._largura_util_secao_atual(doc),
+        )
+        if not banco_cabe_em_retrato:
+            iniciar_secao_paisagem(doc)
+
+        self._criar_titulo_anexo(doc, "ANEXO I - BANCO DE DADOS")
+        gerar_anexo_banco_dados(doc, modelo, colunas=banco_dados_colunas)
+
+        iniciar_secao_retrato(doc)
+        self._criar_titulo_anexo(
+            doc,
+            "ANEXO II - PLANILHA DE CÁLCULO E RESULTADOS ESTATÍSTICOS",
+        )
+        gerar_anexo_planilha(doc, modelo)
+
+        doc.add_page_break()
+        self._criar_titulo_anexo(doc, "ANEXO III - GRÁFICOS")
+        gerar_anexo_graficos(doc, modelo)
+
+        doc.add_page_break()
+        self._criar_titulo_anexo(doc, "ANEXO IV - CÁLCULO DO VALOR")
+        gerar_anexo_calculo(doc, modelo, avaliacao=avaliacao)
+
+    def _gerar_nome_arquivo(self, modelo_nome: str) -> Path:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+        modelo_safe = re.sub(r"[^\w\-]", "_", modelo_nome)
+        return self.output_dir / f"Anexos_{modelo_safe}_{timestamp}.docx"

backend/app/core/anexos/graficos.py

@@ -0,0 +1,382 @@
+"""
+Gerador do Anexo de Gráficos.
+Insere gráficos de diagnóstico do modelo no documento.
+Usa Matplotlib para geração de imagens sem dependências externas.
+"""
+import io
+from typing import Optional, List, Tuple
+from docx import Document
+from docx.shared import Inches
+
+import numpy as np
+import pandas as pd
+from scipy import stats
+import matplotlib
+matplotlib.use('Agg')  # Backend não-interativo
+import matplotlib.pyplot as plt
+
+from .model_data import ModelData
+from .formatters import (
+    add_placeholder_text,
+)
+
+
+# Cores consistentes com a interface
+COR_PRINCIPAL = '#FF8C00'  # Laranja
+COR_LINHA = '#dc3545'  # Vermelho para linhas de referência
+COR_GRID = '#d3d3d3'  # Cinza claro para grid
+
+
+def _configurar_estilo_grafico(ax, titulo: str, xlabel: str, ylabel: str) -> None:
+    """Aplica estilo consistente aos gráficos."""
+    ax.set_title(titulo, fontsize=14, fontweight='bold', color='black', pad=15)
+    ax.set_xlabel(xlabel, fontsize=11)
+    ax.set_ylabel(ylabel, fontsize=11)
+    ax.set_facecolor('white')
+    ax.grid(True, linestyle='-', linewidth=0.5, color=COR_GRID, alpha=0.7)
+    ax.spines['top'].set_visible(True)
+    ax.spines['right'].set_visible(True)
+    ax.spines['bottom'].set_color('black')
+    ax.spines['left'].set_color('black')
+    ax.spines['top'].set_color('black')
+    ax.spines['right'].set_color('black')
+
+
+def _salvar_figura(fig) -> io.BytesIO:
+    """Salva figura matplotlib em buffer de bytes."""
+    buf = io.BytesIO()
+    fig.savefig(buf, format='png', dpi=150, bbox_inches='tight',
+                facecolor='white', edgecolor='none')
+    buf.seek(0)
+    plt.close(fig)
+    return buf
+
+
+def gerar_anexo_graficos(doc: Document, modelo: Optional[ModelData]) -> None:
+    """
+    Gera o conteúdo do Anexo de Gráficos.
+
+    Args:
+        doc: Documento DOCX
+        modelo: Dados do modelo carregado do .dai
+    """
+    if modelo is None:
+        add_placeholder_text(doc, "[Modelo não selecionado - inserir gráficos manualmente]")
+        return
+
+    graficos_inseridos = 0
+
+    # Tentar gerar gráficos a partir dos dados do modelo
+    if modelo.modelos_sm is not None or not modelo.tabelas_obs_calc.empty:
+        graficos = _gerar_graficos_diagnostico(modelo)
+
+        for titulo, img_buffer in graficos:
+            doc.add_picture(img_buffer, width=Inches(5.5))
+            graficos_inseridos += 1
+
+    if graficos_inseridos == 0:
+        add_placeholder_text(doc, "[Gráficos não disponíveis no modelo]")
+
+
+def _gerar_graficos_diagnostico(modelo: ModelData) -> List[Tuple[str, io.BytesIO]]:
+    """
+    Gera gráficos de diagnóstico do modelo de regressão usando Matplotlib.
+
+    Args:
+        modelo: Dados do modelo
+
+    Returns:
+        Lista de tuplas (título, buffer de imagem)
+    """
+    graficos = []
+
+    # Obter dados para os gráficos
+    obs_calc = modelo.tabelas_obs_calc
+    modelos_sm = modelo.modelos_sm
+
+    # Identificar colunas de valores observados e calculados
+    y_obs = None
+    y_calc = None
+    residuos = None
+
+    if not obs_calc.empty:
+        # Tentar identificar colunas
+        cols_lower = {c.lower(): c for c in obs_calc.columns}
+
+        for nome_obs in ['observado', 'obs', 'y_obs', 'y', 'valor_observado']:
+            if nome_obs in cols_lower:
+                y_obs = obs_calc[cols_lower[nome_obs]].values
+                break
+
+        for nome_calc in ['calculado', 'calc', 'y_calc', 'y_hat', 'previsto', 'predicted', 'valor_calculado']:
+            if nome_calc in cols_lower:
+                y_calc = obs_calc[cols_lower[nome_calc]].values
+                break
+
+        for nome_res in ['residuo', 'residuos', 'resid', 'residual']:
+            if nome_res in cols_lower:
+                residuos = obs_calc[cols_lower[nome_res]].values
+                break
+
+    # Se temos statsmodels result, extrair dados dele
+    if modelos_sm is not None:
+        try:
+            if y_obs is None and hasattr(modelos_sm, 'model') 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
+
+    # Calcular resíduos se temos obs e calc
+    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 arrays numpy se necessário
+    if y_obs is not None:
+        y_obs = np.array(y_obs)
+    if y_calc is not None:
+        y_calc = np.array(y_calc)
+    if residuos is not None:
+        residuos = np.array(residuos)
+
+    # Gráfico 1: Valores Observados vs Calculados
+    if y_obs is not None and y_calc is not None:
+        graf = _criar_grafico_obs_calc(y_obs, y_calc)
+        if graf:
+            graficos.append(("Valores Observados vs Calculados", graf))
+
+    # Gráfico 2: Resíduos vs Valores Ajustados
+    if residuos is not None and y_calc is not None:
+        graf = _criar_grafico_residuos(y_calc, residuos)
+        if graf:
+            graficos.append(("Resíduos vs Valores Ajustados", graf))
+
+    # Gráfico 3: Histograma dos Resíduos
+    if residuos is not None:
+        graf = _criar_histograma_residuos(residuos)
+        if graf:
+            graficos.append(("Distribuição dos Resíduos", graf))
+
+    # Gráfico 4: Distância de Cook
+    if modelos_sm is not None:
+        graf = _criar_grafico_cook(modelos_sm)
+        if graf:
+            graficos.append(("Distância de Cook", graf))
+
+    # Gráfico 5: Matriz de Correlação
+    if modelos_sm is not None:
+        graf = _criar_grafico_correlacao(modelos_sm)
+        if graf:
+            graficos.append(("Matriz de Correlação", graf))
+
+    return graficos
+
+
+def _criar_grafico_obs_calc(y_obs: np.ndarray, y_calc: np.ndarray) -> Optional[io.BytesIO]:
+    """Cria gráfico de valores observados vs calculados."""
+    try:
+        fig, ax = plt.subplots(figsize=(8, 5))
+
+        # Scatter plot
+        ax.scatter(y_calc, y_obs, c=COR_PRINCIPAL, s=60, edgecolors='black',
+                   linewidths=0.5, alpha=0.8, label='Dados', zorder=3)
+
+        # 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
+
+        ax.plot([min_val - margin, max_val + margin],
+                [min_val - margin, max_val + margin],
+                color=COR_LINHA, linestyle='--', linewidth=2,
+                label='Linha de identidade', zorder=2)
+
+        ax.set_xlim(min_val - margin, max_val + margin)
+        ax.set_ylim(min_val - margin, max_val + margin)
+
+        _configurar_estilo_grafico(ax, 'Valores Observados vs Calculados',
+                                   'Valores Calculados', 'Valores Observados')
+        ax.legend(loc='upper left', framealpha=0.9)
+
+        return _salvar_figura(fig)
+    except Exception as e:
+        print(f"Erro ao criar gráfico obs vs calc: {e}")
+        return None
+
+
+def _criar_grafico_residuos(y_calc: np.ndarray, residuos: np.ndarray) -> Optional[io.BytesIO]:
+    """Cria gráfico de resíduos vs valores ajustados."""
+    try:
+        fig, ax = plt.subplots(figsize=(8, 5))
+
+        # Scatter plot
+        ax.scatter(y_calc, residuos, c=COR_PRINCIPAL, s=60, edgecolors='black',
+                   linewidths=0.5, alpha=0.8, zorder=3)
+
+        # Linha horizontal em y=0
+        ax.axhline(y=0, color=COR_LINHA, linestyle='--', linewidth=2, zorder=2)
+
+        _configurar_estilo_grafico(ax, 'Resíduos vs Valores Ajustados',
+                                   'Valores Ajustados', 'Resíduos')
+
+        return _salvar_figura(fig)
+    except Exception as e:
+        print(f"Erro ao criar gráfico de resíduos: {e}")
+        return None
+
+
+def _criar_histograma_residuos(residuos: np.ndarray) -> Optional[io.BytesIO]:
+    """Cria histograma dos resíduos com curva normal."""
+    try:
+        fig, ax = plt.subplots(figsize=(8, 5))
+
+        # Histograma
+        n, bins, patches = ax.hist(residuos, bins='auto', density=True,
+                                    color=COR_PRINCIPAL, edgecolor='black',
+                                    linewidth=0.5, alpha=0.7, label='Resíduos',
+                                    zorder=3)
+
+        # Curva normal ajustada
+        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)
+
+        ax.plot(x_norm, y_norm, color=COR_LINHA, linewidth=3,
+                label='Curva Normal', zorder=4)
+
+        _configurar_estilo_grafico(ax, 'Distribuição dos Resíduos',
+                                   'Resíduos', 'Densidade')
+        ax.legend(loc='upper right', framealpha=0.9)
+
+        return _salvar_figura(fig)
+    except Exception as e:
+        print(f"Erro ao criar histograma: {e}")
+        return None
+
+
+def _criar_grafico_cook(modelos_sm) -> Optional[io.BytesIO]:
+    """Cria gráfico de Distância de Cook."""
+    try:
+        from statsmodels.stats.outliers_influence import OLSInfluence
+
+        influence = OLSInfluence(modelos_sm)
+        cooks_d = influence.cooks_distance[0]
+
+        n = len(cooks_d)
+        indices = np.arange(1, n + 1)
+
+        # Limite de referência: 4/n
+        limite = 4 / n
+
+        fig, ax = plt.subplots(figsize=(8, 5))
+
+        # Cores baseadas no limite
+        cores = np.array([COR_LINHA if v > limite else COR_PRINCIPAL for v in cooks_d])
+
+        # Desenhar linhas verticais (stems) individualmente
+        for i, (idx, valor, cor) in enumerate(zip(indices, cooks_d, cores)):
+            ax.vlines(x=idx, ymin=0, ymax=valor, colors=cor, linewidth=1.5, zorder=2)
+
+        # Adicionar marcadores no topo
+        ax.scatter(indices, cooks_d, c=cores, s=50, edgecolors='black',
+                   linewidths=0.5, zorder=3)
+
+        # Linha de referência horizontal (4/n)
+        ax.axhline(y=limite, color='gray', linestyle='--', linewidth=1.5,
+                   label=f'4/n = {limite:.4f}', zorder=4)
+
+        ax.set_ylim(bottom=0)
+        ax.set_xlim(0, n + 1)
+
+        _configurar_estilo_grafico(ax, 'Distância de Cook',
+                                   'Observação', 'Distância de Cook')
+        ax.legend(loc='upper right', framealpha=0.9)
+
+        return _salvar_figura(fig)
+    except Exception as e:
+        print(f"Erro ao criar gráfico de Cook: {e}")
+        return None
+
+
+def _criar_grafico_correlacao(modelos_sm) -> Optional[io.BytesIO]:
+    """
+    Gera um heatmap de correlação entre a variável dependente e as variáveis explicativas.
+    """
+    try:
+        if 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', 'Var. Dep.')
+
+        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 realmente 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
+
+        # Calcular tamanho da figura baseado no número de variáveis
+        n_vars = len(corr.columns)
+        fig_size = max(8, n_vars * 0.8)
+
+        fig, ax = plt.subplots(figsize=(fig_size, fig_size))
+
+        # Heatmap
+        im = ax.imshow(corr.values, cmap='RdBu_r', vmin=-1, vmax=1, aspect='auto')
+
+        # Adicionar colorbar
+        cbar = fig.colorbar(im, ax=ax, shrink=0.8)
+        cbar.set_label('Correlação', fontsize=11)
+
+        # Configurar ticks
+        ax.set_xticks(np.arange(len(corr.columns)))
+        ax.set_yticks(np.arange(len(corr.columns)))
+        ax.set_xticklabels(corr.columns, rotation=45, ha='right', fontsize=9)
+        ax.set_yticklabels(corr.columns, fontsize=9)
+
+        # Adicionar valores nas células
+        for i in range(len(corr.columns)):
+            for j in range(len(corr.columns)):
+                valor = corr.values[i, j]
+                # Cor do texto baseada no valor
+                cor_texto = 'white' if abs(valor) > 0.5 else 'black'
+                ax.text(j, i, f'{valor:.2f}', ha='center', va='center',
+                        color=cor_texto, fontsize=9)
+
+        ax.set_title('Matriz de Correlação\n(Variável Dependente e Regressoras)',
+                     fontsize=14, fontweight='bold', pad=15)
+
+        plt.tight_layout()
+
+        return _salvar_figura(fig)
+    except Exception as e:
+        print(f"Erro ao criar gráfico de correlação: {e}")
+        return None

backend/app/core/anexos/model_data.py

@@ -0,0 +1,68 @@
+"""
+Dataclass tipada para os dados do modelo de avaliação.
+Os dados são carregados de arquivos .dai (joblib).
+"""
+from dataclasses import dataclass, field
+from typing import Dict, List, Any, Optional
+from pathlib import Path
+
+import pandas as pd
+
+
+@dataclass
+class ModelData:
+    """Representa os dados estatísticos de um modelo de avaliação."""
+
+    nome: str
+    path: Path
+
+    # Dados do banco de dados
+    xy_preview: pd.DataFrame = field(default_factory=pd.DataFrame)
+    top_x_esc: pd.DataFrame = field(default_factory=pd.DataFrame)
+    top_y_esc: pd.Series = field(default_factory=pd.Series)
+
+    # Estatísticas descritivas
+    estatisticas: pd.DataFrame = field(default_factory=pd.DataFrame)
+
+    # Modelo de regressão
+    tabelas_coef: pd.DataFrame = field(default_factory=pd.DataFrame)
+    tabelas_obs_calc: pd.DataFrame = field(default_factory=pd.DataFrame)
+    modelos_resumos: Dict[str, Any] = field(default_factory=dict)
+    modelos_sm: Any = None  # RegressionResultsWrapper
+
+    # Transformações e gráficos
+    formatted_top_transformation_info: List[Any] = field(default_factory=list)
+    variaveis_dicotomicas: List[str] = field(default_factory=list)
+    graf_model: str = ""
+
+    @property
+    def r2(self) -> Optional[float]:
+        """Retorna o coeficiente de determinação R²."""
+        return self.modelos_resumos.get('r2')
+
+    @property
+    def r2_ajustado(self) -> Optional[float]:
+        """Retorna o R² ajustado."""
+        return self.modelos_resumos.get('r2_ajustado')
+
+    @property
+    def equacao(self) -> Optional[str]:
+        """Retorna a equação do modelo."""
+        return self.modelos_resumos.get('equacao')
+
+    @property
+    def variaveis(self) -> List[str]:
+        """Retorna lista de variáveis do modelo."""
+        if self.tabelas_coef.empty:
+            return []
+        return [v for v in self.tabelas_coef.index.tolist() if v != 'const']
+
+    @property
+    def n_amostras(self) -> int:
+        """Retorna número de amostras no banco de dados."""
+        return self.modelos_resumos.get('n', 0)
+
+    @property
+    def n_variaveis(self) -> int:
+        """Retorna número de variáveis do modelo."""
+        return self.modelos_resumos.get('k', 0)

backend/app/core/anexos/model_loader.py

@@ -0,0 +1,266 @@
+"""
+Carregador de modelos de avaliação.
+Carrega arquivos .dai via joblib.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Optional
+
+import joblib
+import pandas as pd
+
+from .model_data import ModelData
+
+
+def _get_first(container: dict[str, Any], *keys: str, default: Any = None) -> Any:
+    """Retorna o primeiro valor não-nulo encontrado nas chaves informadas."""
+    for key in keys:
+        if key in container and container[key] is not None:
+            return container[key]
+    return default
+
+
+def _as_dict(value: Any) -> dict[str, Any]:
+    """Garante retorno como dicionário."""
+    return value if isinstance(value, dict) else {}
+
+
+def _as_dataframe(value: Any) -> pd.DataFrame:
+    """Converte entrada em DataFrame quando possível."""
+    if isinstance(value, pd.DataFrame):
+        return value
+    if isinstance(value, pd.Series):
+        return value.to_frame()
+    return pd.DataFrame()
+
+
+def _as_series(value: Any) -> pd.Series:
+    """Converte entrada em Series quando possível."""
+    if isinstance(value, pd.Series):
+        return value
+    if isinstance(value, pd.DataFrame) and value.shape[1] == 1:
+        return value.iloc[:, 0]
+    return pd.Series(dtype=float)
+
+
+def _as_string_list(value: Any) -> list[str]:
+    """Converte listas/tuplas/índices/séries em lista de strings."""
+    if value is None:
+        return []
+    if isinstance(value, pd.Series):
+        value = value.tolist()
+    elif isinstance(value, pd.Index):
+        value = value.tolist()
+    elif not isinstance(value, (list, tuple, set)):
+        return []
+    return [str(item) for item in value]
+
+
+def _extract_diagnostic_summary(diag: dict[str, Any]) -> dict[str, Any]:
+    """
+    Normaliza estatísticas do bloco de diagnósticos para o formato interno.
+
+    O formato dos .dai pode variar entre versões; esta função tolera aliases
+    comuns sem quebrar o carregamento do modelo.
+    """
+    gerais = _as_dict(_get_first(diag, "gerais", "estatisticas_gerais", default={}))
+    teste_f = _as_dict(_get_first(diag, "teste_f", "f_test", default={}))
+    teste_ks = _as_dict(_get_first(diag, "teste_ks", "ks_test", default={}))
+    teste_normalidade = _as_dict(
+        _get_first(diag, "teste_normalidade", "normalidade", default={})
+    )
+    teste_dw = _as_dict(_get_first(diag, "teste_dw", "durbin_watson", default={}))
+    teste_bp = _as_dict(_get_first(diag, "teste_bp", "breusch_pagan", default={}))
+
+    def stat_from(block: dict[str, Any]) -> Any:
+        return _get_first(block, "estatistica", "stat", "value")
+
+    def pvalue_from(block: dict[str, Any]) -> Any:
+        return _get_first(block, "p_valor", "pvalue", "p_val", "p")
+
+    def interp_from(block: dict[str, Any]) -> Any:
+        return _get_first(block, "interpretacao", "interpretation", "texto")
+
+    return {
+        **gerais,
+        "Fc": stat_from(teste_f),
+        "p_valor_F": pvalue_from(teste_f),
+        "Interpretacao_F": interp_from(teste_f),
+        "ks_stat": stat_from(teste_ks),
+        "ks_p": pvalue_from(teste_ks),
+        "Interpretacao_KS": interp_from(teste_ks),
+        "perc_resid": _get_first(
+            teste_normalidade, "percentuais", "percentis", "percentages"
+        ),
+        "dw": stat_from(teste_dw),
+        "Interpretacao_DW": interp_from(teste_dw),
+        "bp_lm": stat_from(teste_bp),
+        "bp_p": pvalue_from(teste_bp),
+        "Interpretacao_BP": interp_from(teste_bp),
+        "equacao": _get_first(diag, "equacao", "equation", "formula"),
+    }
+
+
+def _build_xy_preview(
+    dados: dict[str, Any], transformacoes: dict[str, Any]
+) -> pd.DataFrame:
+    """
+    Monta DataFrame de preview para o Anexo I.
+
+    Em versões novas, `dados['df']` pode conter o dataset completo (centenas de
+    colunas), o que degrada a geração/abertura no Word. Quando disponível, usa
+    `transformacoes['X'] + y` como preview estável da modelagem.
+    """
+    df_preview = _as_dataframe(
+        _get_first(
+            dados,
+            "xy_preview",
+            "df_preview",
+            "df_modelagem",
+            "preview",
+            "df",
+            default=pd.DataFrame(),
+        )
+    )
+
+    x_df = _as_dataframe(_get_first(transformacoes, "X", "x", default=pd.DataFrame()))
+    y_series = _as_series(_get_first(transformacoes, "y", "Y", default=pd.Series(dtype=float)))
+
+    if not x_df.empty:
+        modelagem_df = x_df.copy()
+
+        if not y_series.empty:
+            y_name = str(y_series.name) if y_series.name else "y"
+            y_alinhado = y_series.reset_index(drop=True)
+            modelagem_df = modelagem_df.reset_index(drop=True)
+            tamanho = min(len(modelagem_df), len(y_alinhado))
+            if tamanho > 0:
+                modelagem_df = modelagem_df.iloc[:tamanho].copy()
+                modelagem_df[y_name] = y_alinhado.iloc[:tamanho].values
+
+        # Se o preview original veio "explodido" (df completo), prioriza modelagem.
+        if df_preview.empty or df_preview.shape[1] > max(40, modelagem_df.shape[1] + 10):
+            return modelagem_df
+
+    return df_preview
+
+
+def model_data_from_package(
+    data: Any,
+    dai_path: Path,
+    nome: str | None = None,
+) -> Optional[ModelData]:
+    """Converte um pacote .dai já carregado para os dados usados nos anexos."""
+    try:
+        data_dict = _as_dict(data)
+        dados = _as_dict(_get_first(data_dict, "dados", "data", default={}))
+        transformacoes = _as_dict(
+            _get_first(data_dict, "transformacoes", "transformations", default={})
+        )
+        modelo_dict = _as_dict(_get_first(data_dict, "modelo", "model", default={}))
+        diag = _as_dict(_get_first(modelo_dict, "diagnosticos", "diagnostics", default={}))
+
+        modelos_resumos = _extract_diagnostic_summary(diag)
+        xy_preview = _build_xy_preview(dados, transformacoes)
+        top_x_esc = _as_dataframe(
+            _get_first(transformacoes, "X", "x", default=pd.DataFrame())
+        )
+        top_y_esc = _as_series(
+            _get_first(transformacoes, "y", "Y", default=pd.Series(dtype=float))
+        )
+        estatisticas = _as_dataframe(
+            _get_first(dados, "estatisticas", "statistics", default=pd.DataFrame())
+        )
+        tabelas_coef = _as_dataframe(
+            _get_first(
+                modelo_dict,
+                "coeficientes",
+                "coeficients",
+                "coefficients",
+                default=pd.DataFrame(),
+            )
+        )
+        for coluna_variavel in ("Variável", "Variavel", "variable"):
+            if coluna_variavel in tabelas_coef.columns:
+                tabelas_coef = tabelas_coef.set_index(coluna_variavel)
+                break
+
+        tabelas_obs_calc = _as_dataframe(
+            _get_first(
+                modelo_dict,
+                "obs_calc",
+                "observado_calculado",
+                "observed_vs_calculated",
+                default=pd.DataFrame(),
+            )
+        )
+        modelos_sm = _get_first(
+            modelo_dict, "sm", "statsmodels", "statsmodels_result", default=None
+        )
+
+        return ModelData(
+            nome=str(nome or dai_path.stem),
+            path=dai_path,
+            xy_preview=xy_preview,
+            top_x_esc=top_x_esc,
+            top_y_esc=top_y_esc,
+            estatisticas=estatisticas,
+            tabelas_coef=tabelas_coef,
+            tabelas_obs_calc=tabelas_obs_calc,
+            modelos_resumos=modelos_resumos,
+            modelos_sm=modelos_sm,
+            formatted_top_transformation_info=transformacoes.get("info", []),
+            variaveis_dicotomicas=_as_string_list(
+                _get_first(
+                    transformacoes,
+                    "dicotomicas",
+                    "dicotômicas",
+                    "dummies",
+                    "dummy",
+                    "binarias",
+                    "binárias",
+                    default=[],
+                )
+            ),
+            graf_model="",
+        )
+    except (KeyError, TypeError, ValueError):
+        return None
+
+
+def load_model(dai_path: Path) -> Optional[ModelData]:
+    """
+    Carrega um modelo de avaliação a partir de um arquivo .dai.
+
+    Args:
+        dai_path: Caminho para o arquivo .dai
+
+    Returns:
+        ModelData com os dados carregados, ou None se falhar
+    """
+    if not dai_path.exists():
+        return None
+
+    try:
+        data = joblib.load(dai_path)
+    except Exception as e:
+        print(f"Erro ao carregar {dai_path}: {e}")
+        return None
+
+    return model_data_from_package(data, dai_path)
+
+
+def load_model_by_name(name: str, models_dir: Path) -> Optional[ModelData]:
+    """
+    Carrega um modelo pelo nome.
+
+    Args:
+        name: Nome do modelo (nome do arquivo .dai sem extensão)
+        models_dir: Diretório dos modelos
+
+    Returns:
+        ModelData com os dados carregados, ou None se não encontrar
+    """
+    dai_path = models_dir / f"{name}.dai"
+    return load_model(dai_path)

backend/app/core/anexos/planilha_calculo.py

@@ -0,0 +1,196 @@
+"""
+Gerador do Anexo de Planilha de Cálculo e Resultados Estatísticos.
+Gera tabelas de coeficientes, valores observados vs calculados e resumo estatístico.
+"""
+from typing import Optional, Dict, Any
+from docx import Document
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+from .model_data import ModelData
+from .formatters import (
+    add_body_text,
+    add_placeholder_text,
+    add_subsection_title,
+    add_simple_table,
+    criar_paragrafo_formatado,
+)
+from .estatisticas_utils import reorganizar_modelos_resumos, formatar_numero
+
+
+def gerar_anexo_planilha(doc: Document, modelo: Optional[ModelData]) -> None:
+    """
+    Gera o conteúdo do Anexo de Planilha de Cálculo e Resultados Estatísticos.
+
+    Args:
+        doc: Documento DOCX
+        modelo: Dados do modelo carregado do .dai
+    """
+    if modelo is None:
+        add_placeholder_text(doc, "[Modelo não selecionado - inserir planilha manualmente]")
+        return
+
+    conteudo_gerado = False
+
+    # 1. RESUMO ESTATÍSTICO (como na aba Resumo do interface_estatisticas)
+    if modelo.modelos_resumos:
+        _adicionar_resumo_estatistico(doc, modelo.modelos_resumos)
+        conteudo_gerado = True
+
+    # 2. Tabela de Coeficientes
+    if not modelo.tabelas_coef.empty:
+        add_subsection_title(doc, "", "Coeficientes do Modelo")
+        _adicionar_tabela_coeficientes(doc, modelo.tabelas_coef)
+        doc.add_paragraph()
+        conteudo_gerado = True
+
+    # 3. Tabela de Valores Observados vs Calculados
+    if not modelo.tabelas_obs_calc.empty:
+        add_subsection_title(doc, "", "Valores Observados vs Calculados")
+        _adicionar_tabela_obs_calc(doc, modelo.tabelas_obs_calc)
+        conteudo_gerado = True
+
+    if not conteudo_gerado:
+        add_placeholder_text(doc, "[Dados de planilha não disponíveis no modelo]")
+
+
+def _adicionar_resumo_estatistico(doc: Document, modelos_resumos: Dict[str, Any]) -> None:
+    """
+    Adiciona o resumo estatístico no formato da aba Resumo do interface_estatisticas.
+    """
+    resumo = reorganizar_modelos_resumos(modelos_resumos)
+
+    # Estatísticas Gerais
+    estat_gerais = resumo.get("estatisticas_gerais", {})
+    if estat_gerais:
+        add_subsection_title(doc, "", "Estatísticas Gerais")
+        dados = [["Indicador", "Valor"]]
+        for chave, info in estat_gerais.items():
+            nome = info.get("nome", chave)
+            valor = info.get("valor")
+            if valor is not None:
+                dados.append([nome, formatar_numero(valor)])
+        if len(dados) > 1:
+            add_simple_table(doc, dados, header_row=True)
+        doc.add_paragraph()
+
+    # Teste F
+    teste_f = resumo.get("teste_f", {})
+    if teste_f.get("estatistica") is not None:
+        add_subsection_title(doc, "", teste_f.get("nome", "Teste F"))
+        dados = [["Indicador", "Valor"]]
+        dados.append(["Estatística F", formatar_numero(teste_f["estatistica"])])
+        if teste_f.get("pvalor") is not None:
+            dados.append(["P-valor", formatar_numero(teste_f["pvalor"])])
+        add_simple_table(doc, dados, header_row=True)
+        if teste_f.get("interpretacao"):
+            _adicionar_interpretacao(doc, teste_f["interpretacao"])
+        doc.add_paragraph()
+
+    # Teste de Normalidade (Kolmogorov-Smirnov)
+    teste_ks = resumo.get("teste_ks", {})
+    if teste_ks.get("estatistica") is not None:
+        add_subsection_title(doc, "", teste_ks.get("nome", "Teste de Normalidade (Kolmogorov-Smirnov)"))
+        dados = [["Indicador", "Valor"]]
+        dados.append(["Estatística KS", formatar_numero(teste_ks["estatistica"])])
+        if teste_ks.get("pvalor") is not None:
+            dados.append(["P-valor", formatar_numero(teste_ks["pvalor"])])
+        add_simple_table(doc, dados, header_row=True)
+        if teste_ks.get("interpretacao"):
+            _adicionar_interpretacao(doc, teste_ks["interpretacao"])
+        doc.add_paragraph()
+
+    # Teste de Normalidade (Comparação com Curva Normal)
+    perc_resid = resumo.get("perc_resid", {})
+    if perc_resid.get("valor"):
+        add_subsection_title(doc, "", perc_resid.get("nome", "Teste de Normalidade (Comparação com a Curva Normal)"))
+        add_body_text(doc, f"Percentuais atingidos: {perc_resid['valor']}")
+        interpretacoes = perc_resid.get("interpretacao", [])
+        if interpretacoes:
+            add_body_text(doc, "Critérios ideais:")
+            for item in interpretacoes:
+                add_body_text(doc, f"  • {item}")
+        doc.add_paragraph()
+
+    # Teste de Autocorrelação (Durbin-Watson)
+    teste_dw = resumo.get("teste_dw", {})
+    if teste_dw.get("estatistica") is not None:
+        add_subsection_title(doc, "", teste_dw.get("nome", "Teste de Autocorrelação (Durbin-Watson)"))
+        dados = [["Indicador", "Valor"]]
+        dados.append(["Estatística DW", formatar_numero(teste_dw["estatistica"])])
+        add_simple_table(doc, dados, header_row=True)
+        if teste_dw.get("interpretacao"):
+            _adicionar_interpretacao(doc, teste_dw["interpretacao"])
+        doc.add_paragraph()
+
+    # Teste de Homocedasticidade (Breusch-Pagan)
+    teste_bp = resumo.get("teste_bp", {})
+    if teste_bp.get("estatistica") is not None:
+        add_subsection_title(doc, "", teste_bp.get("nome", "Teste de Homocedasticidade (Breusch-Pagan)"))
+        dados = [["Indicador", "Valor"]]
+        dados.append(["Estatística LM", formatar_numero(teste_bp["estatistica"])])
+        if teste_bp.get("pvalor") is not None:
+            dados.append(["P-valor", formatar_numero(teste_bp["pvalor"])])
+        add_simple_table(doc, dados, header_row=True)
+        if teste_bp.get("interpretacao"):
+            _adicionar_interpretacao(doc, teste_bp["interpretacao"])
+        doc.add_paragraph()
+
+    # Equação do Modelo
+    equacao = resumo.get("equacao")
+    if equacao:
+        add_subsection_title(doc, "", "Equação do Modelo")
+        criar_paragrafo_formatado(
+            doc,
+            equacao,
+            tamanho=11,
+            alinhamento=WD_ALIGN_PARAGRAPH.CENTER,
+            espaco_antes=6,
+            espaco_depois=6,
+        )
+        doc.add_paragraph()
+
+
+def _adicionar_interpretacao(doc: Document, texto: str) -> None:
+    """Adiciona texto de interpretação em itálico."""
+    criar_paragrafo_formatado(
+        doc,
+        f"Interpretação: {texto}",
+        italico=True,
+        tamanho=10,
+        espaco_antes=3,
+        espaco_depois=3,
+    )
+
+
+def _adicionar_tabela_coeficientes(doc: Document, df) -> None:
+    """Adiciona tabela de coeficientes."""
+    headers = ["Variável"] + [str(col) for col in df.columns.tolist()]
+    dados = [headers]
+
+    for idx, row in df.iterrows():
+        linha = [str(idx)]
+        for val in row.values:
+            if isinstance(val, float):
+                linha.append(f"{val:.6f}")
+            else:
+                linha.append(str(val) if val is not None else "")
+        dados.append(linha)
+
+    add_simple_table(doc, dados, header_row=True, rotacao_cabecalho=True)
+
+
+def _adicionar_tabela_obs_calc(doc: Document, df) -> None:
+    """Adiciona tabela de valores observados vs calculados (todos os dados com ID)."""
+    headers = ["ID"] + [str(col) for col in df.columns.tolist()]
+    dados = [headers]
+
+    for idx, (_, row) in enumerate(df.iterrows(), start=1):
+        linha = [str(idx)]  # ID da amostra (1-based)
+        for val in row.values:
+            if isinstance(val, float):
+                linha.append(f"{val:.2f}")
+            else:
+                linha.append(str(val) if val is not None else "")
+        dados.append(linha)
+
+    add_simple_table(doc, dados, header_row=True, rotacao_cabecalho=True)

backend/app/main.py

@@ -7,7 +7,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from fastapi.staticfiles import StaticFiles
 
-from app.api import auth, elaboracao, health, logs, pesquisa, repositorio, session, trabalhos_tecnicos, visualizacao
+from app.api import anexos, auth, elaboracao, health, logs, pesquisa, repositorio, session, trabalhos_tecnicos, visualizacao
 from app.runtime_paths import resolve_frontend_dist_dir
 from app.services import auth_service, visualizacao_service
 
@@ -55,6 +55,7 @@ app.include_router(pesquisa.router)
 app.include_router(repositorio.router)
 app.include_router(trabalhos_tecnicos.router)
 app.include_router(logs.router)
+app.include_router(anexos.router)
 
 
 @app.on_event("startup")

backend/app/services/anexos_service.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Sequence
+
+from fastapi import HTTPException
+from joblib import load
+
+from app.core.anexos import AnexosGenerator, model_data_from_package
+from app.core.elaboracao.core import _migrar_pacote_v1_para_v2
+from app.runtime_paths import resolve_local_data_path
+from app.services import model_repository
+from app.services.serializers import sanitize_value
+
+
+OUTPUT_DIR = resolve_local_data_path("anexos_gerados")
+AVALIACAO_KEYS = {
+    "valores_x",
+    "extrapolacoes",
+    "estimado",
+    "tipo_y",
+    "coluna_area",
+    "valor_area",
+    "estimado_unitario",
+    "estimado_total",
+    "conversao_disponivel",
+    "motivo_conversao_indisponivel",
+    "ca_inf",
+    "ca_sup",
+    "ic_inf",
+    "ic_sup",
+    "perc_inf",
+    "perc_sup",
+    "amplitude",
+    "precisao",
+    "houve_extrapolacao",
+    "fronteira",
+    "perc_ext",
+    "qtd_extrapolacoes",
+    "fundamentacao",
+}
+
+
+def listar_modelos() -> dict[str, Any]:
+    return sanitize_value(model_repository.list_repository_models())
+
+
+def _carregar_modelo(modelo_id: str):
+    caminho = model_repository.resolve_model_file(modelo_id)
+    try:
+        pacote = load(caminho)
+    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:
+        try:
+            pacote = _migrar_pacote_v1_para_v2(pacote)
+        except Exception as exc:
+            raise HTTPException(status_code=400, detail=f"Falha ao migrar arquivo .dai: {exc}") from exc
+
+    modelo = model_data_from_package(pacote, caminho, nome=caminho.stem)
+    if modelo is None or modelo.xy_preview.empty:
+        raise HTTPException(status_code=400, detail="Modelo sem dados suficientes para gerar anexos")
+    return modelo
+
+
+def obter_colunas(modelo_id: str) -> dict[str, Any]:
+    modelo = _carregar_modelo(modelo_id)
+    return {
+        "modelo_id": modelo.nome,
+        "columns": [str(coluna) for coluna in modelo.xy_preview.columns.tolist()],
+    }
+
+
+def _validar_colunas(modelo, colunas: Sequence[str] | None) -> list[str] | None:
+    if colunas is None:
+        return None
+
+    disponiveis = [str(coluna) for coluna in modelo.xy_preview.columns.tolist()]
+    selecionadas: list[str] = []
+    vistas: set[str] = set()
+    for coluna in colunas:
+        nome = str(coluna)
+        if nome in vistas:
+            continue
+        vistas.add(nome)
+        selecionadas.append(nome)
+
+    invalidas = [coluna for coluna in selecionadas if coluna not in disponiveis]
+    if invalidas:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Colunas inválidas para o banco de dados: {', '.join(invalidas)}",
+        )
+    if not selecionadas:
+        raise HTTPException(status_code=400, detail="Selecione ao menos uma coluna para o banco de dados")
+    return selecionadas
+
+
+def _avisos_estatisticos(modelo) -> list[str]:
+    resumo = modelo.modelos_resumos or {}
+    avisos: list[str] = []
+    testes = (
+        ("Teste F", resumo.get("Interpretacao_F")),
+        ("Teste de Normalidade (Kolmogorov-Smirnov)", resumo.get("Interpretacao_KS")),
+        ("Teste de Autocorrelação (Durbin-Watson)", resumo.get("Interpretacao_DW")),
+        ("Teste de Homocedasticidade (Breusch-Pagan)", resumo.get("Interpretacao_BP")),
+    )
+    for nome, interpretacao in testes:
+        texto = str(interpretacao or "").strip()
+        if texto and ("❌" in texto or "⚠" in texto):
+            avisos.append(f"{nome}: {texto}")
+    return avisos
+
+
+def _normalizar_avaliacao(avaliacao: dict[str, Any] | None) -> dict[str, Any] | None:
+    if not isinstance(avaliacao, dict):
+        return None
+    payload = {
+        chave: valor
+        for chave, valor in avaliacao.items()
+        if chave in AVALIACAO_KEYS
+    }
+    return sanitize_value(payload)
+
+
+def gerar_documento(
+    modelo_id: str,
+    banco_dados_colunas: Sequence[str] | None = None,
+    avaliacao: dict[str, Any] | None = None,
+) -> tuple[Path, list[str]]:
+    modelo = _carregar_modelo(modelo_id)
+    colunas = _validar_colunas(modelo, banco_dados_colunas)
+    avaliacao_normalizada = _normalizar_avaliacao(avaliacao)
+    try:
+        caminho = AnexosGenerator(OUTPUT_DIR).gerar(
+            modelo,
+            banco_dados_colunas=colunas,
+            avaliacao=avaliacao_normalizada,
+        )
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Erro ao gerar anexos: {exc}") from exc
+    return caminho, _avisos_estatisticos(modelo)
+
+
+def resolver_download(filename: str) -> Path:
+    nome_seguro = Path(str(filename or "")).name
+    if not nome_seguro or nome_seguro != filename or not nome_seguro.lower().endswith(".docx"):
+        raise HTTPException(status_code=400, detail="Nome de arquivo inválido")
+    caminho = OUTPUT_DIR / nome_seguro
+    if not caminho.is_file():
+        raise HTTPException(status_code=404, detail="Arquivo de anexos não encontrado")
+    return caminho

backend/app/services/pesquisa_service.py

@@ -4,13 +4,16 @@ from branca.element import Element
 import json
 from html import escape
 import math
+import os
 import re
+import tempfile
 import unicodedata
 from dataclasses import dataclass
 from datetime import date, datetime
 from pathlib import Path
 from threading import Event, Lock
 from typing import Any
+from uuid import uuid4
 
 import folium
 from folium import plugins
@@ -18,6 +21,7 @@ import numpy as np
 import pandas as pd
 from fastapi import HTTPException
 from joblib import load
+from openpyxl import Workbook
 
 from app.core.elaboracao import geocodificacao
 from app.core.shapefile_runtime import load_attribute_records
@@ -1229,11 +1233,33 @@ def _tooltip_mapa_modelo_html(modelo: dict[str, Any]) -> str:
     )
 
 
-def _tooltip_mapa_modelo_ponto_html(modelo: dict[str, Any], total_no_local: int) -> str:
+def _indices_mapa_modelo_display(pontos_no_local: list[dict[str, Any]]) -> list[str]:
+    indices: list[str] = []
+    for ponto in pontos_no_local:
+        indice = str(ponto.get("indice") or "").strip()
+        if indice:
+            indices.append(indice)
+    return indices
+
+
+def _indices_mapa_modelo_badge(indices_no_local: list[str], limite: int = 28) -> str:
+    texto = ", ".join(str(item).strip() for item in indices_no_local if str(item).strip())
+    if len(texto) <= limite:
+        return texto
+    return texto[: max(0, limite - 1)].rstrip(" ,") + "…"
+
+
+def _tooltip_mapa_modelo_ponto_html(modelo: dict[str, Any], indices_no_local: list[str] | None = None) -> str:
     tooltip = _tooltip_mapa_modelo_html(modelo)
-    if total_no_local <= 1:
+    indices = [str(item).strip() for item in (indices_no_local or []) if str(item).strip()]
+    total_no_local = len(indices)
+    if total_no_local <= 0:
         return tooltip
-    detalhe = f"<br><span style='color:#555;'>Dados neste local:</span> <b>{total_no_local}</b>"
+    detalhe = ""
+    detalhe += (
+        f"<br><span style='color:#555;'>{'Índices' if total_no_local > 1 else 'Índice'}:</span> "
+        f"<b>{escape(', '.join(indices))}</b>"
+    )
     if tooltip.endswith("</div>"):
         return f"{tooltip[:-6]}{detalhe}</div>"
     return f"{tooltip}{detalhe}"
@@ -1250,23 +1276,38 @@ def _chave_coordenada_ponto(ponto: dict[str, Any], precisao: int = 7) -> tuple[f
     return (round(lat, precisao), round(lon, precisao))
 
 
-def _contagens_coordenadas_modelos(modelos_plotados: list[dict[str, Any]]) -> dict[tuple[float, float], int]:
-    contagens: dict[tuple[float, float], int] = {}
-    for modelo in modelos_plotados:
-        for ponto in modelo.get("pontos") or []:
-            chave = _chave_coordenada_ponto(ponto)
-            if chave is None:
-                continue
-            contagens[chave] = contagens.get(chave, 0) + 1
-    return contagens
+def _agrupar_pontos_modelo_por_coordenada(
+    modelo: dict[str, Any],
+) -> list[tuple[tuple[float, float], list[dict[str, Any]]]]:
+    grupos: dict[tuple[float, float], list[dict[str, Any]]] = {}
+    for ponto in modelo.get("pontos") or []:
+        chave = _chave_coordenada_ponto(ponto)
+        if chave is None:
+            continue
+        grupos.setdefault(chave, []).append(ponto)
+    return list(grupos.items())
+
+
+def _build_marker_html_indice_modelo(indices_display: list[str]) -> str:
+    return (
+        '<div style="transform: translate(10px, -14px);display:inline-block;background: rgba(255, 255, 255, 0.9);'
+        + 'border: 1px solid rgba(28, 45, 66, 0.45);border-radius: 10px;padding: 1px 6px;font-size: 11px;'
+        + 'font-weight: 700;line-height: 1.2;color: #1f2f44;white-space: nowrap;box-shadow: 0 1px 2px rgba(0, 0, 0, 0.18);'
+        + 'pointer-events: none;">'
+        + escape(_indices_mapa_modelo_badge(indices_display))
+        + "</div>"
+    )
 
 
 def _ponto_mapa_modelo_payload_item(
     modelo: dict[str, Any],
     ponto: dict[str, Any],
-    total_no_local: int = 1,
+    pontos_no_local: list[dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
     cor = str(modelo.get("cor") or "#1f77b4")
+    pontos_agrupados = pontos_no_local if pontos_no_local is not None else [ponto]
+    indices_display = _indices_mapa_modelo_display(pontos_agrupados)
+    total_no_local = len(indices_display) or 1
     item: dict[str, Any] = {
         "lat": float(ponto["lat"]),
         "lon": float(ponto["lon"]),
@@ -1275,16 +1316,28 @@ def _ponto_mapa_modelo_payload_item(
         "stroke_color": cor,
         "stroke_weight": 1.0,
         "fill_opacity": 0.72,
-        "tooltip_html": _tooltip_mapa_modelo_ponto_html(modelo, total_no_local),
+        "tooltip_html": _tooltip_mapa_modelo_ponto_html(modelo, indices_display),
+        "selection_model_id": str(modelo.get("id") or ""),
+        "selection_model_name": str(modelo.get("nome") or modelo.get("id") or "Modelo"),
+        "selection_indices": indices_display,
     }
     if total_no_local > 1:
         item.update(
             {
                 "grouped": True,
                 "count": total_no_local,
-                "group_title": f"{total_no_local} dados neste local",
+                "hide_count": True,
+                "group_title": "Dados neste local",
+                "hide_group_count": True,
                 "pane": "mesa-market-group-pane",
                 "tooltip_sticky": False,
+                "group_items": [
+                    {
+                        "indice": indice,
+                        "label": f"Índice {indice}",
+                    }
+                    for indice in indices_display
+                ],
             }
         )
     return item
@@ -1292,7 +1345,6 @@ def _ponto_mapa_modelo_payload_item(
 
 def _pontos_mapa_modelo_payload(
     modelo: dict[str, Any],
-    contagens_coordenadas: dict[tuple[float, float], int] | None = None,
     agrupar_pontos_mercado: bool = False,
 ) -> list[dict[str, Any]]:
     if not agrupar_pontos_mercado:
@@ -1300,24 +1352,41 @@ def _pontos_mapa_modelo_payload(
         for ponto in modelo.get("pontos") or []:
             if _chave_coordenada_ponto(ponto) is None:
                 continue
-            pontos_payload.append(_ponto_mapa_modelo_payload_item(modelo, ponto))
+            pontos_payload.append(_ponto_mapa_modelo_payload_item(modelo, ponto, [ponto]))
         return pontos_payload
 
-    grupos: dict[tuple[float, float], list[dict[str, Any]]] = {}
-    for ponto in modelo.get("pontos") or []:
-        chave = _chave_coordenada_ponto(ponto)
-        if chave is None:
-            continue
-        grupos.setdefault(chave, []).append(ponto)
-
     pontos_payload: list[dict[str, Any]] = []
-    for chave, pontos_no_local in grupos.items():
+    for _chave, pontos_no_local in _agrupar_pontos_modelo_por_coordenada(modelo):
         ponto = pontos_no_local[0]
-        total_no_local = max(len(pontos_no_local), int((contagens_coordenadas or {}).get(chave) or 0))
-        pontos_payload.append(_ponto_mapa_modelo_payload_item(modelo, ponto, total_no_local))
+        pontos_payload.append(_ponto_mapa_modelo_payload_item(modelo, ponto, pontos_no_local))
     return pontos_payload
 
 
+def _indices_mapa_modelo_payload(modelo: dict[str, Any]) -> list[dict[str, Any]]:
+    payloads: list[dict[str, Any]] = []
+    for _chave, pontos_no_local in _agrupar_pontos_modelo_por_coordenada(modelo):
+        if not pontos_no_local:
+            continue
+        ponto = pontos_no_local[0]
+        indices_display = _indices_mapa_modelo_display(pontos_no_local)
+        if not indices_display:
+            continue
+        payloads.append(
+            {
+                "lat": float(ponto["lat"]),
+                "lon": float(ponto["lon"]),
+                "marker_html": _build_marker_html_indice_modelo(indices_display),
+                "icon_size": [96 if len(indices_display) > 1 else 72, 24],
+                "icon_anchor": [0, 0],
+                "class_name": "mesa-indice-label",
+                "interactive": False,
+                "keyboard": False,
+                "tooltip_html": _tooltip_mapa_modelo_ponto_html(modelo, indices_display),
+            }
+        )
+    return payloads
+
+
 def _marker_payloads_avaliandos(avaliandos_geo: list[dict[str, Any]]) -> list[dict[str, Any]]:
     payloads: list[dict[str, Any]] = []
     for idx, avaliando in enumerate(avaliandos_geo):
@@ -1477,15 +1546,10 @@ def _build_mapa_modelos_payload(
         if avaliandos_tecnicos_proximos is not None
         else []
     )
-    contagens_pontos = (
-        _contagens_coordenadas_modelos(modelos_plotados)
-        if modo_exibicao == "pontos" and agrupar_pontos_mercado
-        else {}
-    )
-
     for modelo in modelos_plotados:
+        modelo_id = str(modelo.get("id") or "")
         layer: dict[str, Any] = {
-            "id": str(modelo.get("id") or ""),
+            "id": modelo_id,
             "label": str(modelo.get("nome") or "Modelo"),
             "show": True,
             "hover_highlight_group": "pesquisa-modelos",
@@ -1493,12 +1557,23 @@ def _build_mapa_modelos_payload(
         if modo_exibicao == "pontos":
             layer["points"] = _pontos_mapa_modelo_payload(
                 modelo,
-                contagens_pontos,
                 agrupar_pontos_mercado=agrupar_pontos_mercado,
             )
         else:
             layer["shapes"] = _shapes_modelo_payload(modelo, aval_lat, aval_lon)
         overlay_layers.append(layer)
+        if modo_exibicao == "pontos":
+            indices_markers = _indices_mapa_modelo_payload(modelo)
+            if indices_markers:
+                overlay_layers.append(
+                    {
+                        "id": f"{modelo_id}__indices",
+                        "label": f"Índices • {str(modelo.get('nome') or 'Modelo')}",
+                        "show": False,
+                        "required_overlay_ids": [modelo_id],
+                        "markers": indices_markers,
+                    }
+                )
 
     if trabalhos_tecnicos_modelos:
         overlay_layers.append(
@@ -1561,10 +1636,66 @@ def _build_mapa_modelos_payload(
 
     payload = build_leaflet_payload(bounds=bounds, overlay_layers=overlay_layers, show_bairros=True)
     if payload and isinstance(payload.get("controls"), dict):
-        payload["controls"]["layer_control_collapsed"] = False
+        payload["controls"]["market_lasso"] = modo_exibicao == "pontos"
+        payload["controls"]["layer_control_collapsed"] = True
     return payload
 
 
+def _normalizar_nome_aba_xlsx(nome: Any, fallback: str) -> str:
+    texto = str(nome or "").strip() or fallback
+    for char in ["\\", "/", "*", "?", ":", "[", "]"]:
+        texto = texto.replace(char, " ")
+    texto = re.sub(r"\s+", " ", texto).strip("' ").strip()
+    return (texto or fallback)[:31]
+
+
+def exportar_indices_mapa_pesquisa_xlsx(modelos: list[dict[str, Any]] | None) -> tuple[str, str]:
+    itens = []
+    for idx, modelo in enumerate(modelos or [], start=1):
+        if not isinstance(modelo, dict):
+            continue
+        nome = str(modelo.get("nome") or modelo.get("name") or modelo.get("modelo") or "").strip()
+        indices = []
+        vistos = set()
+        for valor in modelo.get("indices") or []:
+            texto = str(valor or "").strip()
+            if not texto or texto in vistos:
+                continue
+            vistos.add(texto)
+            indices.append(texto)
+        if indices:
+            itens.append({"nome": nome or f"Modelo {idx}", "indices": indices})
+
+    if not itens:
+        raise HTTPException(status_code=400, detail="Nenhum indice selecionado para exportar.")
+
+    workbook = Workbook()
+    worksheet = workbook.active
+    nomes_usados: set[str] = set()
+    for idx, item in enumerate(itens):
+        sheet_name_base = _normalizar_nome_aba_xlsx(item["nome"], f"Modelo {idx + 1}")
+        sheet_name = sheet_name_base
+        suffix = 2
+        while sheet_name.casefold() in nomes_usados:
+            tail = f" {suffix}"
+            sheet_name = f"{sheet_name_base[:31 - len(tail)]}{tail}"
+            suffix += 1
+        nomes_usados.add(sheet_name.casefold())
+        if idx == 0:
+            worksheet.title = sheet_name
+        else:
+            worksheet = workbook.create_sheet(sheet_name)
+        worksheet.append(["INDICE"])
+        for indice in item["indices"]:
+            worksheet.append([indice])
+        worksheet.column_dimensions["A"].width = 18
+
+    nome_arquivo = f"indices_mapa_pesquisa_{uuid4().hex[:8]}.xlsx"
+    caminho = os.path.join(tempfile.gettempdir(), nome_arquivo)
+    workbook.save(caminho)
+    return caminho, nome_arquivo
+
+
 def _renderizar_mapa_modelos(
     modelos_plotados: list[dict[str, Any]],
     bounds: list[list[float]],

backend/app/services/serializers.py

@@ -27,14 +27,14 @@ def sanitize_value(value: Any) -> Any:
         return [sanitize_value(item) for item in value.tolist()]
     if isinstance(value, np.generic):
         return sanitize_value(value.item())
+    if isinstance(value, (np.bool_, bool)):
+        return bool(value)
     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):

backend/requirements.txt

@@ -16,3 +16,6 @@ pyshp
 geopandas
 fiona
 huggingface_hub>=0.30.0
+python-docx
+Pillow
+matplotlib

frontend/src/api.js

@@ -407,6 +407,15 @@ export const api = {
   }),
   exportEquationViz: (sessionId, mode = 'excel') => getBlob(`/api/visualizacao/equation/export?session_id=${encodeURIComponent(sessionId)}&mode=${encodeURIComponent(String(mode || 'excel'))}`),
 
+  anexosModelos: () => getJson('/api/anexos/modelos'),
+  anexosModeloColunas: (modeloId) => getJson(`/api/anexos/modelos/${encodeURIComponent(String(modeloId || ''))}/columns`),
+  anexosGerar: (modeloId, bancoDadosColunas, avaliacao = null) => postJson('/api/anexos/generate', {
+    modelo_id: modeloId,
+    banco_dados_colunas: bancoDadosColunas,
+    avaliacao,
+  }),
+  anexosDownload: (filename) => getBlob(`/api/anexos/download/${encodeURIComponent(String(filename || ''))}`),
+
   repositorioListar: () => getJson('/api/repositorio/modelos'),
   repositorioUpload(files = [], { confirmarSubstituicao = false } = {}) {
     const form = new FormData()

frontend/src/components/AnexosModal.jsx

@@ -0,0 +1,317 @@
+import React, { useEffect, useMemo, useState } from 'react'
+import { api, downloadBlob } from '../api'
+
+function normalizarChave(value) {
+  return String(value || '')
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .trim()
+    .replace(/\.dai$/i, '')
+}
+
+function resolverModeloId(chave, modelos) {
+  const normalizada = normalizarChave(chave)
+  if (!normalizada) return ''
+  for (const modelo of modelos || []) {
+    const candidatos = [modelo?.id, modelo?.arquivo, modelo?.nome_modelo]
+      .map(normalizarChave)
+      .filter(Boolean)
+    if (candidatos.includes(normalizada)) return String(modelo.id || '')
+  }
+  return ''
+}
+
+function formatarFonte(fonte) {
+  if (!fonte || typeof fonte !== 'object') return ''
+  if (String(fonte.provider || '').toLowerCase() === 'hf_dataset') {
+    const repo = String(fonte.repo_id || '').trim()
+    const revisao = String(fonte.revision || '').trim()
+    return `HF Dataset${repo ? ` (${repo})` : ''}${revisao ? ` | revisão ${revisao.slice(0, 8)}` : ''}`
+  }
+  return 'Pasta local'
+}
+
+export default function AnexosModal({
+  open,
+  defaultModeloId = '',
+  avaliacao = null,
+  lockModelo = false,
+  title = 'Gerar anexos',
+  onClose,
+}) {
+  const [modelos, setModelos] = useState([])
+  const [fonte, setFonte] = useState(null)
+  const [modeloSelecionado, setModeloSelecionado] = useState('')
+  const [colunas, setColunas] = useState([])
+  const [loadingModelos, setLoadingModelos] = useState(false)
+  const [loadingColunas, setLoadingColunas] = useState(false)
+  const [generating, setGenerating] = useState(false)
+  const [downloading, setDownloading] = useState(false)
+  const [error, setError] = useState('')
+  const [result, setResult] = useState(null)
+
+  const colunasSelecionadas = useMemo(
+    () => colunas.filter((item) => item.selected).map((item) => item.name),
+    [colunas],
+  )
+  const busy = loadingModelos || loadingColunas || generating || downloading
+  const blocking = generating || downloading
+  const canGenerate = Boolean(modeloSelecionado && colunasSelecionadas.length && !busy)
+
+  useEffect(() => {
+    if (!open) return undefined
+    let active = true
+    setLoadingModelos(true)
+    setError('')
+    setResult(null)
+    setColunas([])
+    setModeloSelecionado('')
+
+    api.anexosModelos()
+      .then((response) => {
+        if (!active) return
+        const lista = Array.isArray(response?.modelos) ? response.modelos : []
+        const resolvido = resolverModeloId(defaultModeloId, lista)
+        setModelos(lista)
+        setFonte(response?.fonte || null)
+        if (lockModelo && defaultModeloId && !resolvido) {
+          setModeloSelecionado('')
+          setError('O modelo usado nesta avaliação não foi encontrado no repositório configurado.')
+          return
+        }
+        setModeloSelecionado(resolvido || String(lista[0]?.id || ''))
+      })
+      .catch((err) => {
+        if (!active) return
+        setModelos([])
+        setModeloSelecionado('')
+        setError(err?.message || 'Não foi possível carregar os modelos.')
+      })
+      .finally(() => {
+        if (active) setLoadingModelos(false)
+      })
+
+    return () => {
+      active = false
+    }
+  }, [open, defaultModeloId, lockModelo])
+
+  useEffect(() => {
+    if (!open || !modeloSelecionado) {
+      setColunas([])
+      return undefined
+    }
+    let active = true
+    setLoadingColunas(true)
+    setError('')
+    setResult(null)
+
+    api.anexosModeloColunas(modeloSelecionado)
+      .then((response) => {
+        if (!active) return
+        setColunas((response?.columns || []).map((name) => ({ name, selected: true })))
+      })
+      .catch((err) => {
+        if (!active) return
+        setColunas([])
+        setError(err?.message || 'Não foi possível carregar as colunas do modelo.')
+      })
+      .finally(() => {
+        if (active) setLoadingColunas(false)
+      })
+
+    return () => {
+      active = false
+    }
+  }, [open, modeloSelecionado])
+
+  if (!open) return null
+
+  function toggleColuna(nome) {
+    setColunas((current) => current.map((item) => (
+      item.name === nome ? { ...item, selected: !item.selected } : item
+    )))
+    setResult(null)
+  }
+
+  function moverColuna(index, direction) {
+    setColunas((current) => {
+      const destino = index + direction
+      if (destino < 0 || destino >= current.length) return current
+      const next = [...current]
+      ;[next[index], next[destino]] = [next[destino], next[index]]
+      return next
+    })
+    setResult(null)
+  }
+
+  async function gerar(event) {
+    event.preventDefault()
+    if (!canGenerate) return
+    setGenerating(true)
+    setError('')
+    setResult(null)
+    try {
+      const response = await api.anexosGerar(
+        modeloSelecionado,
+        colunasSelecionadas,
+        avaliacao,
+      )
+      setResult(response)
+    } catch (err) {
+      setError(err?.message || 'Falha ao gerar os anexos.')
+    } finally {
+      setGenerating(false)
+    }
+  }
+
+  async function baixar() {
+    const filename = String(result?.filename || '').trim()
+    if (!filename) return
+    setDownloading(true)
+    setError('')
+    try {
+      const blob = await api.anexosDownload(filename)
+      downloadBlob(blob, filename)
+    } catch (err) {
+      setError(err?.message || 'Falha ao baixar os anexos.')
+    } finally {
+      setDownloading(false)
+    }
+  }
+
+  function fechar() {
+    if (!blocking && typeof onClose === 'function') onClose()
+  }
+
+  return (
+    <div className="pesquisa-modal-backdrop" onClick={(event) => {
+      if (event.target === event.currentTarget) fechar()
+    }}>
+      <div className="pesquisa-modal anexos-modal" role="dialog" aria-modal="true" aria-label={title}>
+        <div className="pesquisa-modal-head">
+          <div>
+            <h4>{title}</h4>
+            {fonte ? <p>Fonte: {formatarFonte(fonte)}</p> : null}
+          </div>
+          <button type="button" className="pesquisa-modal-close" onClick={fechar} disabled={blocking}>
+            Fechar
+          </button>
+        </div>
+
+        <form className="pesquisa-modal-body anexos-modal-body" onSubmit={gerar}>
+          <label className="anexos-modal-model-field">
+            Modelo de avaliação
+            <select
+              value={modeloSelecionado}
+              onChange={(event) => setModeloSelecionado(event.target.value)}
+              disabled={busy || lockModelo || !modelos.length}
+            >
+              {!modelos.length ? <option value="">Nenhum modelo encontrado</option> : null}
+              {modelos.map((modelo) => (
+                <option key={String(modelo.id)} value={String(modelo.id)}>
+                  {modelo.nome_modelo || modelo.arquivo || modelo.id}
+                </option>
+              ))}
+            </select>
+          </label>
+
+          <section className="anexos-columns-section">
+            <div className="anexos-columns-head">
+              <div>
+                <strong>Colunas do banco de dados</strong>
+                <span>{colunasSelecionadas.length} selecionadas</span>
+              </div>
+              <div className="anexos-columns-actions">
+                <button
+                  type="button"
+                  onClick={() => setColunas((current) => current.map((item) => ({ ...item, selected: true })))}
+                  disabled={busy}
+                >
+                  Todas
+                </button>
+                <button
+                  type="button"
+                  onClick={() => setColunas((current) => current.map((item) => ({ ...item, selected: false })))}
+                  disabled={busy}
+                >
+                  Nenhuma
+                </button>
+              </div>
+            </div>
+
+            {loadingColunas ? (
+              <div className="section1-empty-hint">Carregando colunas...</div>
+            ) : (
+              <div className="anexos-columns-list">
+                {colunas.map((coluna, index) => (
+                  <div className="anexos-column-row" key={coluna.name}>
+                    <label>
+                      <input
+                        type="checkbox"
+                        checked={coluna.selected}
+                        onChange={() => toggleColuna(coluna.name)}
+                        disabled={busy}
+                      />
+                      <span>{coluna.name}</span>
+                    </label>
+                    <div className="anexos-reorder-actions">
+                      <button
+                        type="button"
+                        title="Mover para cima"
+                        aria-label={`Mover ${coluna.name} para cima`}
+                        onClick={() => moverColuna(index, -1)}
+                        disabled={busy || index === 0}
+                      >
+                        ↑
+                      </button>
+                      <button
+                        type="button"
+                        title="Mover para baixo"
+                        aria-label={`Mover ${coluna.name} para baixo`}
+                        onClick={() => moverColuna(index, 1)}
+                        disabled={busy || index === colunas.length - 1}
+                      >
+                        ↓
+                      </button>
+                    </div>
+                  </div>
+                ))}
+              </div>
+            )}
+          </section>
+
+          {error ? <div className="error-line inline-error">{error}</div> : null}
+
+          {result?.statistical_warnings?.length ? (
+            <div className="anexos-warning-panel">
+              <strong>Atenção</strong>
+              <ul>
+                {result.statistical_warnings.map((warning) => <li key={warning}>{warning}</li>)}
+              </ul>
+            </div>
+          ) : null}
+
+          {result ? (
+            <div className="anexos-result-panel">
+              <div>
+                <strong>{result.message}</strong>
+                <span>{result.filename}</span>
+              </div>
+              <button type="button" onClick={() => void baixar()} disabled={downloading}>
+                {downloading ? 'Baixando...' : 'Baixar DOCX'}
+              </button>
+            </div>
+          ) : null}
+
+          <div className="anexos-modal-footer">
+            <button type="submit" disabled={!canGenerate}>
+              {generating ? 'Gerando...' : 'Gerar DOCX'}
+            </button>
+          </div>
+        </form>
+      </div>
+    </div>
+  )
+}

frontend/src/components/AvaliacaoTab.jsx

@@ -3,6 +3,7 @@ import { api, downloadBlob } from '../api'
 import { buildCsvBlob } from '../csv'
 import { buildAvaliacaoModeloLink } from '../deepLinks'
 import LoadingOverlay from './LoadingOverlay'
+import AnexosModal from './AnexosModal'
 import MapFrame from './MapFrame'
 import ModeloObservacaoCard from './ModeloObservacaoCard'
 import ShareLinkButton from './ShareLinkButton'
@@ -585,6 +586,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
   const [repoFonteModelos, setRepoFonteModelos] = useState('')
 
   const [modeloAtualNome, setModeloAtualNome] = useState('')
+  const [modeloAtualId, setModeloAtualId] = useState('')
   const [camposAvaliacao, setCamposAvaliacao] = useState([])
   const [equacaoSab, setEquacaoSab] = useState('')
   const valoresAvaliacaoRef = useRef({})
@@ -605,6 +607,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
   const [confirmarExclusaoCardId, setConfirmarExclusaoCardId] = useState('')
   const [avaliacaoPopup, setAvaliacaoPopup] = useState(null)
   const [avaliacaoInfoModal, setAvaliacaoInfoModal] = useState(null)
+  const [anexosCardModal, setAnexosCardModal] = useState(null)
   const [knnDetalheAberto, setKnnDetalheAberto] = useState(false)
   const [knnDetalheLoading, setKnnDetalheLoading] = useState(false)
   const [knnDetalheErro, setKnnDetalheErro] = useState('')
@@ -921,12 +924,13 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
     setAvaliacaoFormVersion((prev) => prev + 1)
   }
 
-  function aplicarRespostaExibicao(resp, nomeModelo) {
+  function aplicarRespostaExibicao(resp, nomeModelo, modeloId = '') {
     const campos = resp?.campos_avaliacao || []
     setCamposAvaliacao(campos)
     resetCamposAvaliacao(campos)
     setEquacaoSab(String(resp?.equacoes?.excel_sab || ''))
     setModeloAtualNome(String(nomeModelo || '').trim())
+    setModeloAtualId(String(modeloId || nomeModelo || '').trim())
     setModeloObservacao(String(resp?.meta_modelo?.observacao_modelo || '').trim())
   }
 
@@ -990,7 +994,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
       setBadgeHtml(removerObservacaoDoBadgeHtml(uploadResp?.badge_html || ''))
       const nomeModelo = uploadResp?.nome_modelo || arquivoUpload.name || ''
       const contextoResp = await api.evaluationContextViz(sessionId)
-      aplicarRespostaExibicao(contextoResp, nomeModelo)
+      aplicarRespostaExibicao(contextoResp, nomeModelo, uploadResp?.nome_modelo || arquivoUpload.name)
       if (typeof onRouteChange === 'function') {
         onRouteChange({ tab: 'avaliacao' })
       }
@@ -1018,7 +1022,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
       const modeloSelecionado = repoModeloOptions.find((item) => item.value === modeloIdUsado)
       const nomeModelo = uploadResp?.nome_modelo || modeloSelecionado?.label || ''
       const contextoResp = await api.evaluationContextViz(sessionId)
-      aplicarRespostaExibicao(contextoResp, nomeModelo)
+      aplicarRespostaExibicao(contextoResp, nomeModelo, modeloIdUsado)
       setUploadedFile(null)
       if (typeof onRouteChange === 'function') {
         onRouteChange({
@@ -1162,6 +1166,7 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
       const card = {
         id: `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
         modelo: modeloAtualNome || 'Modelo sem nome',
+        modeloId: modeloAtualId || modeloAtualNome,
         createdAt: new Date().toISOString(),
         avaliacao: ultima,
       }
@@ -1839,6 +1844,18 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
                               <span>{item.modelo}</span>
                             </div>
                             <div className="avaliacao-modelos-card-actions">
+                              <button
+                                type="button"
+                                className="avaliacao-modelos-anexo-btn"
+                                onClick={() => setAnexosCardModal({
+                                  modeloId: item.modeloId || item.modelo,
+                                  avaliacao: aval,
+                                  titulo: `Gerar anexo da Aval. ${idx + 1}`,
+                                })}
+                                disabled={loading}
+                              >
+                                Gerar anexo
+                              </button>
                               {!exclusaoPendente ? (
                                 <button
                                   type="button"
@@ -2014,7 +2031,20 @@ export default function AvaliacaoTab({ sessionId, quickLoadRequest = null, onRou
         )}
       </div>
 
-      <LoadingOverlay show={loading} label="Processando dados..." />
+      <LoadingOverlay
+        show={loading || avaliandoLocalizacaoLoading}
+        label={avaliandoLocalizacaoLoading
+          ? (avaliandoLocalizacaoModo === 'endereco' ? 'Buscando endereço...' : 'Buscando localização...')
+          : 'Processando dados...'}
+      />
+      <AnexosModal
+        open={Boolean(anexosCardModal)}
+        defaultModeloId={anexosCardModal?.modeloId || ''}
+        avaliacao={anexosCardModal?.avaliacao || null}
+        lockModelo
+        title={anexosCardModal?.titulo || 'Gerar anexo da avaliação'}
+        onClose={() => setAnexosCardModal(null)}
+      />
       {avaliacaoPopup?.html ? (
         <div
           className="avaliacao-popup-overlay"

frontend/src/components/ElaboracaoTab.jsx

@@ -1596,8 +1596,6 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
   const [importPreview, setImportPreview] = useState(null)
   const [importSelectedColumns, setImportSelectedColumns] = useState([])
   const [requiresImportColumnSelection, setRequiresImportColumnSelection] = useState(false)
-  const [firstColumnsCount, setFirstColumnsCount] = useState('')
-  const [firstColumnsChecked, setFirstColumnsChecked] = useState(false)
   const [elaborador, setElaborador] = useState(null)
   const [modeloCarregadoInfo, setModeloCarregadoInfo] = useState(null)
   const [repoModelos, setRepoModelos] = useState([])
@@ -3476,16 +3474,15 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     setSheetOptions(resp.sheets || [])
     const proximaImportPreview = resp?.import_preview || null
     const proximaSelecaoColunasPendente = Boolean(resp?.requires_column_selection)
+    const proximaColunasImportacao = Array.isArray(proximaImportPreview?.columns)
+      ? proximaImportPreview.columns.map((item) => String(item))
+      : []
     setImportPreview(proximaImportPreview)
     setRequiresImportColumnSelection(proximaSelecaoColunasPendente)
     if (proximaImportPreview && proximaSelecaoColunasPendente) {
-      setImportSelectedColumns([])
-      setFirstColumnsCount('')
-      setFirstColumnsChecked(false)
+      setImportSelectedColumns(proximaColunasImportacao)
     } else if (!proximaImportPreview) {
       setImportSelectedColumns([])
-      setFirstColumnsCount('')
-      setFirstColumnsChecked(false)
     }
     const nomeModeloCarregado = String(resp?.nome_modelo || '').trim()
     if (Boolean(resp.requires_sheet)) {
@@ -3609,8 +3606,6 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
       setImportPreview(null)
       setImportSelectedColumns([])
       setRequiresImportColumnSelection(false)
-      setFirstColumnsCount('')
-      setFirstColumnsChecked(false)
       const nomeArquivo = String(arquivoUpload?.name || '').toLowerCase()
       const uploadEhDai = nomeArquivo.endsWith('.dai')
       setTipoFonteDados(uploadEhDai ? 'dai' : 'tabular')
@@ -3649,8 +3644,6 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
       setImportPreview(null)
       setImportSelectedColumns([])
       setRequiresImportColumnSelection(false)
-      setFirstColumnsCount('')
-      setFirstColumnsChecked(false)
       setUploadedFile(null)
       setTipoFonteDados('tabular')
       const resp = await api.pasteElaboracaoTable(sessionId, textoColado)
@@ -3693,8 +3686,6 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
       setImportPreview(null)
       setImportSelectedColumns([])
       setRequiresImportColumnSelection(false)
-      setFirstColumnsCount('')
-      setFirstColumnsChecked(false)
       setTipoFonteDados('dai')
       const resp = await api.elaboracaoRepositorioCarregar(sessionId, modeloId)
       aplicarRespostaCarregamento(resp, 'dai', { source: 'repo' })
@@ -3784,7 +3775,6 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
   function onToggleImportColumn(coluna) {
     const valor = String(coluna || '').trim()
     if (!valor) return
-    setFirstColumnsChecked(false)
     setImportSelectedColumns((prev) => {
       const next = prev.includes(valor)
         ? prev.filter((item) => item !== valor)
@@ -3794,40 +3784,8 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
     setRequiresImportColumnSelection(true)
   }
 
-  function getFirstImportColumnsQuantity(value = firstColumnsCount) {
-    const limite = importPreviewColumns.length
-    const parsed = Number.parseInt(String(value || '0'), 10)
-    return Number.isFinite(parsed) ? Math.max(0, Math.min(limite, parsed)) : 0
-  }
-
-  function onFirstColumnsCountChange(value) {
-    setFirstColumnsCount(value)
-    if (!firstColumnsChecked) return
-    const quantidade = getFirstImportColumnsQuantity(value)
-    setImportSelectedColumns(importPreviewColumns.slice(0, quantidade))
-    setRequiresImportColumnSelection(true)
-    setImportacaoErro('')
-  }
-
-  function onToggleFirstImportColumns(event) {
-    const checked = event.target.checked
-    setFirstColumnsChecked(checked)
-    const quantidade = getFirstImportColumnsQuantity()
-    const primeiras = importPreviewColumns.slice(0, quantidade)
-    if (checked) {
-      setFirstColumnsCount(String(quantidade))
-      setImportSelectedColumns(primeiras)
-    } else {
-      const primeirasSet = new Set(primeiras)
-      setImportSelectedColumns((prev) => prev.filter((coluna) => !primeirasSet.has(coluna)))
-    }
-    setRequiresImportColumnSelection(true)
-    setImportacaoErro('')
-  }
-
   function onClearImportColumns() {
     setImportSelectedColumns([])
-    setFirstColumnsChecked(false)
     setRequiresImportColumnSelection(true)
     setImportacaoErro('')
   }
@@ -5683,26 +5641,6 @@ export default function ElaboracaoTab({ sessionId, authUser, quickLoadRequest =
                   </div>
 
                   <div className="import-preview-tools">
-                    <label className="import-preview-first-columns-toggle">
-                      <input
-                        type="checkbox"
-                        checked={firstColumnsChecked}
-                        onChange={onToggleFirstImportColumns}
-                        disabled={loading || importPreviewColumns.length === 0}
-                      />
-                      Selecionar primeiras
-                    </label>
-                    <label className="import-preview-first-columns-field">
-                      <input
-                        type="number"
-                        min="0"
-                        max={importPreviewColumns.length}
-                        value={firstColumnsCount}
-                        onChange={(event) => onFirstColumnsCountChange(event.target.value)}
-                        disabled={loading || importPreviewColumns.length === 0}
-                      />
-                      colunas
-                    </label>
                     <button
                       type="button"
                       className="import-preview-clear-btn"

frontend/src/components/LeafletMapFrame.jsx

@@ -43,6 +43,18 @@ function normalizeCssColor(value, fallback = '#607d8b') {
   return fallback
 }
 
+function isTrueFlag(value) {
+  return value === true || value === 1 || value === '1'
+}
+
+function isFalseFlag(value) {
+  return value === false || value === 0 || value === '0'
+}
+
+function naturalCompare(a, b) {
+  return String(a ?? '').localeCompare(String(b ?? ''), 'pt-BR', { numeric: true, sensitivity: 'base' })
+}
+
 function buildGroupedMarketMarkerHtml(item, size = 22) {
   const count = Math.max(2, Number(item?.count) || 2)
   const color = normalizeCssColor(item?.color || item?.fill_color || '#607d8b')
@@ -50,9 +62,12 @@ function buildGroupedMarketMarkerHtml(item, size = 22) {
   const fontSize = Math.max(9, Math.min(12, markerSize * 0.38))
   const borderSize = markerSize >= 24 ? 3 : 2
   const haloSize = markerSize >= 24 ? 4 : 2
+  const labelHtml = isTrueFlag(item?.hide_count)
+    ? ''
+    : `<span>${escapeHtml(count > 99 ? '99+' : count)}</span>`
   return (
     `<div class="mesa-market-group-marker" style="--mesa-group-color:${color};--mesa-group-size:${markerSize}px;--mesa-group-font:${fontSize}px;--mesa-group-border:${borderSize}px;--mesa-group-halo:${haloSize}px;">`
-    + `<span>${escapeHtml(count > 99 ? '99+' : count)}</span>`
+    + labelHtml
     + '</div>'
   )
 }
@@ -318,6 +333,21 @@ function formatDistance(distanceMeters) {
   return `${value.toLocaleString('pt-BR', { maximumFractionDigits: 1 })} m`
 }
 
+function pointInPolygon(point, polygon) {
+  if (!point || !Array.isArray(polygon) || polygon.length < 3) return false
+  let inside = false
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i, i += 1) {
+    const xi = polygon[i].x
+    const yi = polygon[i].y
+    const xj = polygon[j].x
+    const yj = polygon[j].y
+    const intersects = ((yi > point.y) !== (yj > point.y))
+      && (point.x < ((xj - xi) * (point.y - yi)) / ((yj - yi) || Number.EPSILON) + xi)
+    if (intersects) inside = !inside
+  }
+  return inside
+}
+
 function computePolygonArea(latlngs) {
   if (!Array.isArray(latlngs) || latlngs.length < 3) return 0
   const d2r = Math.PI / 180
@@ -1156,6 +1186,7 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
     })
     mapRef.current = map
     let restoreMapInteractions = null
+    let cleanupLasso = null
     const bairrosPane = map.createPane('mesa-bairros-pane')
     const marketPane = map.createPane('mesa-market-pane')
     const marketGroupPane = map.createPane('mesa-market-group-pane')
@@ -1451,26 +1482,11 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
       })
     }
 
-    function updateHoverLegendState(groupKey, activeId) {
-      const metas = hoverHighlightMetas.filter((entry) => entry.groupKey === groupKey)
-      metas.forEach((meta) => {
-        const label = meta.labelElement
-        if (!label) return
-        const isActive = Boolean(activeId) && meta.id === activeId
-        label.style.cursor = 'pointer'
-        label.style.transition = 'opacity 0.16s ease, color 0.16s ease, font-weight 0.16s ease'
-        label.style.opacity = activeId ? (isActive ? '1' : '0.42') : ''
-        label.style.color = isActive ? '#123b63' : ''
-        label.style.fontWeight = isActive ? '700' : ''
-      })
-    }
-
     function clearHoverHighlight(groupKey) {
       const metas = hoverHighlightMetas.filter((entry) => entry.groupKey === groupKey)
       metas.forEach((meta) => {
         applyGroupState(meta, 'normal')
       })
-      updateHoverLegendState(groupKey, null)
     }
 
     function setHoveredHighlight(groupKey, activeId) {
@@ -1488,47 +1504,6 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
         }
         applyGroupState(meta, meta.id === activeId ? 'highlight' : 'dim')
       })
-      updateHoverLegendState(groupKey, activeId)
-    }
-
-    function bindLayerControlHover(layerControl) {
-      const container = layerControl?.getContainer?.()
-      if (!container) return
-      const labels = Array.from(container.querySelectorAll('.leaflet-control-layers-overlays label'))
-      if (!labels.length) return
-
-      const metaByLayerId = new Map()
-      hoverHighlightMetas.forEach((meta) => {
-        if (!meta?.layerGroup) return
-        metaByLayerId.set(String(L.Util.stamp(meta.layerGroup)), meta)
-      })
-
-      labels.forEach((label) => {
-        const input = label.querySelector('input')
-        const layerId = String(input?.layerId || '')
-        const meta = metaByLayerId.get(layerId)
-        if (!meta) return
-        meta.labelElement = label
-        if (label.dataset.mesaModelHoverBound === '1') return
-        label.dataset.mesaModelHoverBound = '1'
-        const onEnter = () => setHoveredHighlight(meta.groupKey, meta.id)
-        const onLeave = (event) => {
-          const nextTarget = event?.relatedTarget || null
-          if (nextTarget && label.contains(nextTarget)) return
-          clearHoverHighlight(meta.groupKey)
-        }
-        label.addEventListener('mouseenter', onEnter)
-        label.addEventListener('mouseover', onEnter)
-        label.addEventListener('mouseleave', onLeave)
-        label.addEventListener('mouseout', onLeave)
-      })
-
-      hoverHighlightMetas.forEach((meta) => {
-        if (meta.labelElement) {
-          meta.labelElement.style.cursor = 'pointer'
-          meta.labelElement.style.transition = 'opacity 0.16s ease, color 0.16s ease, font-weight 0.16s ease'
-        }
-      })
     }
 
     function addPointMarkers(layerGroup, items) {
@@ -1538,6 +1513,42 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
         const latlng = parseLatLonPair(item?.lat, item?.lon)
         if (!latlng) return
         if (item?.grouped) {
+          if (isTrueFlag(item?.hide_count)) {
+            const marker = L.circleMarker(latlng, {
+              renderer: canvasRenderer,
+              pane: String(item?.pane || 'mesa-market-pane'),
+              radius: Number(item?.base_radius) || 4,
+              color: String(item?.stroke_color || '#000000'),
+              weight: Number.isFinite(Number(item?.stroke_weight))
+                ? Number(item.stroke_weight)
+                : (Number(item?.base_radius) > 4 ? 1 : 0.8),
+              fill: item?.fill !== false,
+              fillColor: String(item?.color || item?.fill_color || '#FF8C00'),
+              fillOpacity: Number.isFinite(Number(item?.fill_opacity)) ? Number(item.fill_opacity) : 0.68,
+              interactive: item?.interactive !== false,
+              bubblingMouseEvents: false,
+            })
+            marker.options.mesaBaseRadius = Number(item?.base_radius) || 4
+            const tooltipHtml = String(item?.tooltip_html || '').trim()
+            if (tooltipHtml) {
+              marker.bindTooltip(tooltipHtml, { sticky: item?.tooltip_sticky !== false })
+            }
+            marker.on('click', () => {
+              map.closePopup()
+              marker.unbindPopup()
+              const groupItems = Array.isArray(item?.group_items) ? item.group_items : []
+              if (!groupItems.length) return
+              groupSelectionMarkerRef.current = marker
+              setGroupSelection({
+                title: String(item?.group_title || 'Dados neste local'),
+                count: Number(item?.count) || groupItems.length,
+                hideCount: isTrueFlag(item?.hide_group_count),
+                items: groupItems,
+              })
+            })
+            layerGroup.addLayer(marker)
+            return
+          }
           const marker = L.marker(latlng, {
             icon: buildGroupedMarketIcon(item, 16),
             pane: String(item?.pane || 'mesa-market-group-pane'),
@@ -1561,6 +1572,7 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
             setGroupSelection({
               title: String(item?.group_title || `${groupItems.length} dados neste local`),
               count: Number(item?.count) || groupItems.length,
+              hideCount: isTrueFlag(item?.hide_group_count),
               items: groupItems,
             })
           })
@@ -1797,7 +1809,7 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
       if (specId) {
         overlayGroupsById.set(specId, layerGroup)
       }
-      if (spec?.show !== false) {
+      if (!isFalseFlag(spec?.show)) {
         layerGroup.addTo(map)
       }
       if (spec?.geojson_url || spec?.geojson_data) {
@@ -1823,7 +1835,6 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
           id: specId,
           groupKey: hoverGroup,
           layerGroup,
-          labelElement: null,
         })
       }
     })
@@ -1833,14 +1844,118 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
       map.on('overlayremove', refreshDependencyAwareOverlays)
     }
 
+    function syncInitialOverlayVisibility(layerControl = null) {
+      overlaySpecs.forEach((spec) => {
+        const label = String(spec?.label || spec?.id || '').trim()
+        if (!label) return
+        const layerGroup = overlayLayers[label]
+        if (!layerGroup) return
+        if (isFalseFlag(spec?.show)) {
+          map.removeLayer(layerGroup)
+        }
+      })
+
+      const container = layerControl?.getContainer?.()
+      if (!container) return
+      const inputs = Array.from(container.querySelectorAll('.leaflet-control-layers-overlays input[type="checkbox"]'))
+      inputs.forEach((input) => {
+        const layerId = String(input?.layerId || '')
+        const matchingLabel = Object.entries(overlayLayers).find(([, layer]) => String(L.Util.stamp(layer)) === layerId)?.[0]
+        if (!matchingLabel) return
+        const spec = overlaySpecs.find((item) => String(item?.label || item?.id || '').trim() === matchingLabel)
+        if (isFalseFlag(spec?.show)) {
+          input.checked = false
+        }
+      })
+    }
+
+    function addLayerControlCloseButton(layerControl) {
+      const container = layerControl?.getContainer?.()
+      if (!container || container.querySelector('.mesa-layer-control-close')) return
+      const button = L.DomUtil.create('button', 'mesa-layer-control-close', container)
+      button.type = 'button'
+      button.setAttribute('aria-label', 'Fechar camadas')
+      button.title = 'Fechar camadas'
+      button.textContent = 'Fechar'
+      L.DomEvent.disableClickPropagation(button)
+      L.DomEvent.on(button, 'click', (event) => {
+        L.DomEvent.stop(event)
+        setLayerControlOpen(layerControl, false)
+      })
+    }
+
+    function updateLayerControlToggleState(layerControl) {
+      const container = layerControl?.getContainer?.()
+      const toggle = layerControl?._layersLink || container?.querySelector?.('.leaflet-control-layers-toggle')
+      if (!container || !toggle) return
+      toggle.setAttribute('aria-expanded', container.classList.contains('leaflet-control-layers-expanded') ? 'true' : 'false')
+    }
+
+    function setLayerControlOpen(layerControl, open) {
+      const container = layerControl?.getContainer?.()
+      if (!container) return
+      if (open && typeof layerControl.expand === 'function') {
+        layerControl.expand()
+      } else if (!open && typeof layerControl.collapse === 'function') {
+        layerControl.collapse()
+      } else {
+        container.classList.toggle('leaflet-control-layers-expanded', !!open)
+      }
+      updateLayerControlToggleState(layerControl)
+    }
+
+    function enableLayerControlClickToggle(layerControl) {
+      const container = layerControl?.getContainer?.()
+      if (!container) return
+      container.classList.add('mesa-layer-control-click-toggle')
+      if (layerControl?._map && typeof layerControl.collapse === 'function') {
+        layerControl._map.off('click', layerControl.collapse, layerControl)
+      }
+      if (typeof layerControl?._expandSafely === 'function') {
+        L.DomEvent.off(container, 'mouseenter', layerControl._expandSafely, layerControl)
+      }
+      if (typeof layerControl?.collapse === 'function') {
+        L.DomEvent.off(container, 'mouseleave', layerControl.collapse, layerControl)
+      }
+
+      const currentToggle = layerControl?._layersLink || container.querySelector('.leaflet-control-layers-toggle')
+      if (!currentToggle || currentToggle.dataset.mesaClickToggle === '1') {
+        updateLayerControlToggleState(layerControl)
+        return
+      }
+
+      const toggle = currentToggle.cloneNode(true)
+      toggle.dataset.mesaClickToggle = '1'
+      toggle.href = '#'
+      toggle.title = 'Camadas'
+      toggle.setAttribute('role', 'button')
+      toggle.setAttribute('aria-label', 'Abrir ou fechar camadas')
+      currentToggle.parentNode.replaceChild(toggle, currentToggle)
+      layerControl._layersLink = toggle
+
+      const togglePanel = (event) => {
+        L.DomEvent.stop(event)
+        const expanded = container.classList.contains('leaflet-control-layers-expanded')
+        setLayerControlOpen(layerControl, !expanded)
+      }
+
+      L.DomEvent.disableClickPropagation(toggle)
+      L.DomEvent.on(toggle, 'click', togglePanel)
+      L.DomEvent.on(toggle, 'keydown', (event) => {
+        if (event.key !== 'Enter' && event.key !== ' ' && event.keyCode !== 13 && event.keyCode !== 32) return
+        togglePanel(event)
+      })
+      updateLayerControlToggleState(layerControl)
+    }
+
+    syncInitialOverlayVisibility()
+
     if (payload.controls?.layer_control) {
-      const collapsed = payload.controls?.layer_control_collapsed !== false
+      const collapsed = !isFalseFlag(payload.controls?.layer_control_collapsed)
       const layerControl = L.control.layers(baseLayers, overlayLayers, { collapsed }).addTo(map)
-      if (hoverHighlightMetas.length) {
-        window.requestAnimationFrame(() => bindLayerControlHover(layerControl))
-        window.setTimeout(() => bindLayerControlHover(layerControl), 40)
-        window.setTimeout(() => bindLayerControlHover(layerControl), 180)
-      }
+      enableLayerControlClickToggle(layerControl)
+      addLayerControlCloseButton(layerControl)
+      syncInitialOverlayVisibility(layerControl)
     }
     if (payload.controls?.measure) {
       const disableInteractionsForMeasure = () => {
@@ -2103,6 +2218,357 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
       measureControl.addTo(map)
     }
 
+    if (payload.controls?.market_lasso) {
+      const lassoLayerGroup = L.layerGroup().addTo(map)
+      const lassoState = {
+        panelOpen: false,
+        active: false,
+        drawing: false,
+        points: [],
+        selectedModels: [],
+        error: '',
+        downloading: false,
+      }
+
+      let lassoRoot = null
+      let lassoInteraction = null
+      let lassoHint = null
+      let lassoResults = null
+      let lassoStartButton = null
+      let lassoCancelButton = null
+      let lassoDownloadButton = null
+      let lassoCloseButton = null
+
+      function disableInteractionsForLasso() {
+        if (restoreMapInteractions) return
+        const states = {
+          dragging: !!map.dragging?.enabled?.(),
+          doubleClickZoom: !!map.doubleClickZoom?.enabled?.(),
+          boxZoom: !!map.boxZoom?.enabled?.(),
+          keyboard: !!map.keyboard?.enabled?.(),
+          touchZoom: !!map.touchZoom?.enabled?.(),
+          scrollWheelZoom: !!map.scrollWheelZoom?.enabled?.(),
+        }
+        map.dragging?.disable?.()
+        map.doubleClickZoom?.disable?.()
+        map.boxZoom?.disable?.()
+        map.keyboard?.disable?.()
+        map.touchZoom?.disable?.()
+        map.scrollWheelZoom?.disable?.()
+        if (map.getContainer()) {
+          map.getContainer().style.cursor = 'crosshair'
+        }
+        restoreMapInteractions = () => {
+          if (states.dragging) map.dragging?.enable?.()
+          if (states.doubleClickZoom) map.doubleClickZoom?.enable?.()
+          if (states.boxZoom) map.boxZoom?.enable?.()
+          if (states.keyboard) map.keyboard?.enable?.()
+          if (states.touchZoom) map.touchZoom?.enable?.()
+          if (states.scrollWheelZoom) map.scrollWheelZoom?.enable?.()
+          if (map.getContainer()) {
+            map.getContainer().style.cursor = ''
+          }
+          restoreMapInteractions = null
+        }
+      }
+
+      function renderLassoGeometry() {
+        lassoLayerGroup.clearLayers()
+        if (!lassoState.points.length) return
+        if (lassoState.points.length >= 2) {
+          L.polyline(lassoState.points, {
+            color: '#0f766e',
+            weight: 2.6,
+            opacity: 0.95,
+            dashArray: lassoState.drawing ? '7 5' : undefined,
+          }).addTo(lassoLayerGroup)
+        }
+        if (!lassoState.drawing && lassoState.points.length >= 3) {
+          L.polygon(lassoState.points, {
+            color: '#0f766e',
+            weight: 2,
+            opacity: 0.95,
+            fillColor: '#0f766e',
+            fillOpacity: 0.12,
+          }).addTo(lassoLayerGroup)
+        }
+      }
+
+      function getSelectedMarketModels(points) {
+        if (!Array.isArray(points) || points.length < 3) return []
+        const polygonPoints = points.map((latlng) => map.latLngToLayerPoint(latlng))
+        const selectedByModel = new Map()
+
+        overlaySpecs.forEach((spec) => {
+          const specId = String(spec?.id || '').trim()
+          const modelLayer = specId ? overlayGroupsById.get(specId) : null
+          if (!Array.isArray(spec?.points) || !spec.points.length) return
+          if (modelLayer && !map.hasLayer(modelLayer)) return
+
+          spec.points.forEach((item) => {
+            const latlng = parseLatLonPair(item?.lat, item?.lon)
+            if (!latlng) return
+            const layerPoint = map.latLngToLayerPoint(L.latLng(latlng[0], latlng[1]))
+            if (!pointInPolygon(layerPoint, polygonPoints)) return
+
+            const modelKey = String(item?.selection_model_id || specId || spec?.label || 'modelo')
+            const modelName = String(item?.selection_model_name || spec?.label || modelKey)
+            const indices = Array.isArray(item?.selection_indices) && item.selection_indices.length
+              ? item.selection_indices
+              : [item?.indice]
+            const entry = selectedByModel.get(modelKey) || {
+              nome: modelName,
+              indices: [],
+              seen: new Set(),
+            }
+            indices.forEach((indice) => {
+              const text = String(indice ?? '').trim()
+              if (!text || entry.seen.has(text)) return
+              entry.seen.add(text)
+              entry.indices.push(text)
+            })
+            selectedByModel.set(modelKey, entry)
+          })
+        })
+
+        return Array.from(selectedByModel.values())
+          .map((entry) => ({
+            nome: entry.nome,
+            indices: entry.indices.sort(naturalCompare),
+          }))
+          .filter((entry) => entry.indices.length)
+      }
+
+      function selectedTotal(models) {
+        return (models || []).reduce((total, item) => total + (item.indices?.length || 0), 0)
+      }
+
+      function renderLassoPanel() {
+        if (!lassoRoot || !lassoInteraction || !lassoHint || !lassoResults) return
+        lassoRoot.classList.toggle('leaflet-control-measure-expanded', lassoState.panelOpen)
+        lassoRoot.classList.toggle('is-active', lassoState.active)
+        lassoInteraction.style.display = lassoState.panelOpen ? 'block' : 'none'
+        if (!lassoState.panelOpen) return
+
+        const total = selectedTotal(lassoState.selectedModels)
+        const hasSelection = total > 0
+        const hasAttempt = lassoState.points.length > 0 || !!lassoState.error
+
+        if (lassoState.error) {
+          lassoHint.textContent = lassoState.error
+        } else if (lassoState.active) {
+          lassoHint.textContent = 'Arraste no mapa para contornar os dados. Solte para concluir.'
+        } else if (lassoState.selectedModels.length) {
+          lassoHint.textContent = `${total.toLocaleString('pt-BR')} índice(s) selecionado(s).`
+        } else {
+          lassoHint.textContent = 'Crie um laço sobre os dados de mercado.'
+        }
+
+        lassoResults.innerHTML = lassoState.selectedModels.length
+          ? lassoState.selectedModels.map((item) => (
+            '<div class="mesa-leaflet-measure-row">'
+            + `<strong>${escapeHtml(item.nome)}</strong>`
+            + `<span>${escapeHtml(String(item.indices.length))} índice(s)</span>`
+            + '</div>'
+          )).join('')
+          : ''
+        lassoResults.style.display = lassoState.selectedModels.length ? 'block' : 'none'
+        lassoStartButton.style.display = lassoState.active ? 'none' : 'inline-flex'
+        lassoStartButton.textContent = hasSelection ? 'Novo laço' : (hasAttempt ? 'Tentar novamente' : 'Criar laço')
+        lassoStartButton.disabled = lassoState.downloading
+        lassoStartButton.style.order = hasSelection ? '2' : '1'
+        lassoCancelButton.style.display = lassoState.active ? 'inline-flex' : 'none'
+        lassoCancelButton.textContent = 'Cancelar'
+        lassoCancelButton.disabled = lassoState.downloading
+        lassoCancelButton.style.order = '1'
+        lassoDownloadButton.style.display = hasSelection && !lassoState.active ? 'inline-flex' : 'none'
+        lassoDownloadButton.disabled = lassoState.downloading
+        lassoDownloadButton.textContent = lassoState.downloading ? 'Baixando...' : 'Baixar XLSX'
+        lassoDownloadButton.style.order = '1'
+        lassoCloseButton.style.display = !lassoState.active ? 'inline-flex' : 'none'
+        lassoCloseButton.disabled = lassoState.downloading
+        lassoCloseButton.style.order = '3'
+      }
+
+      function resetLassoState({ closePanel = false } = {}) {
+        lassoState.active = false
+        lassoState.drawing = false
+        lassoState.points = []
+        lassoState.selectedModels = []
+        lassoState.error = ''
+        lassoLayerGroup.clearLayers()
+        restoreMapInteractions?.()
+        if (closePanel) {
+          lassoState.panelOpen = false
+        }
+        renderLassoPanel()
+      }
+
+      function startLasso() {
+        lassoState.panelOpen = true
+        lassoState.active = true
+        lassoState.drawing = false
+        lassoState.points = []
+        lassoState.selectedModels = []
+        lassoState.error = ''
+        lassoLayerGroup.clearLayers()
+        disableInteractionsForLasso()
+        renderLassoPanel()
+      }
+
+      function finishLasso() {
+        if (!lassoState.active) return
+        lassoState.active = false
+        lassoState.drawing = false
+        restoreMapInteractions?.()
+        if (lassoState.points.length < 3) {
+          lassoState.error = 'Desenhe uma área maior para selecionar.'
+          lassoState.selectedModels = []
+          renderLassoGeometry()
+          renderLassoPanel()
+          return
+        }
+        lassoState.selectedModels = getSelectedMarketModels(lassoState.points)
+        if (!lassoState.selectedModels.length) {
+          lassoState.error = 'Nenhum dado de mercado selecionado.'
+        }
+        renderLassoGeometry()
+        renderLassoPanel()
+      }
+
+      function onLassoMouseDown(event) {
+        if (!lassoState.active || !event?.latlng) return
+        L.DomEvent.stop(event)
+        lassoState.drawing = true
+        lassoState.points = [event.latlng]
+        lassoState.selectedModels = []
+        lassoState.error = ''
+        renderLassoGeometry()
+        renderLassoPanel()
+      }
+
+      function onLassoMouseMove(event) {
+        if (!lassoState.active || !lassoState.drawing || !event?.latlng) return
+        const lastPoint = lassoState.points[lassoState.points.length - 1]
+        if (lastPoint && map.distance(lastPoint, event.latlng) < 2) return
+        lassoState.points = [...lassoState.points, event.latlng]
+        renderLassoGeometry()
+      }
+
+      function onLassoMouseUp(event) {
+        if (!lassoState.active || !lassoState.drawing) return
+        L.DomEvent.stop(event)
+        finishLasso()
+      }
+
+      async function downloadLassoSelection() {
+        if (!lassoState.selectedModels.length || lassoState.downloading) return
+        lassoState.downloading = true
+        lassoState.error = ''
+        renderLassoPanel()
+        try {
+          const response = await fetch(apiUrl('/api/pesquisa/mapa-indices-selecionados/export'), {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              ...(getAuthToken() ? { 'X-Auth-Token': getAuthToken() } : {}),
+            },
+            body: JSON.stringify({ modelos: lassoState.selectedModels }),
+          })
+          if (!response.ok) {
+            const payloadResp = await readJsonSafely(response)
+            throw new Error(String(payloadResp?.detail || 'Falha ao exportar seleção.'))
+          }
+          const blob = await response.blob()
+          downloadBlob(blob, 'indices_mapa_pesquisa.xlsx')
+        } catch (error) {
+          lassoState.error = error?.message || 'Falha ao exportar seleção.'
+        } finally {
+          lassoState.downloading = false
+          renderLassoPanel()
+        }
+      }
+
+      map.on('mousedown', onLassoMouseDown)
+      map.on('mousemove', onLassoMouseMove)
+      map.on('mouseup', onLassoMouseUp)
+      cleanupLasso = () => {
+        map.off('mousedown', onLassoMouseDown)
+        map.off('mousemove', onLassoMouseMove)
+        map.off('mouseup', onLassoMouseUp)
+        lassoLayerGroup.clearLayers()
+      }
+
+      const lassoControl = L.control({ position: 'topright' })
+      lassoControl.onAdd = () => {
+        lassoRoot = L.DomUtil.create('div', 'leaflet-control-measure mesa-leaflet-lasso leaflet-bar leaflet-control')
+        lassoRoot.setAttribute('aria-haspopup', 'true')
+
+        const toggle = L.DomUtil.create('a', 'leaflet-control-measure-toggle mesa-leaflet-lasso-toggle', lassoRoot)
+        toggle.href = '#'
+        toggle.title = 'Selecionar dados por laço'
+        toggle.setAttribute('aria-label', 'Selecionar dados por laço')
+        toggle.innerHTML = '<span class="mesa-sr-only">Selecionar dados por laço</span>'
+
+        lassoInteraction = L.DomUtil.create('div', 'leaflet-control-measure-interaction mesa-leaflet-measure-interaction', lassoRoot)
+        lassoInteraction.style.display = 'none'
+
+        const title = L.DomUtil.create('h3', 'mesa-leaflet-measure-title', lassoInteraction)
+        title.textContent = 'Selecionar por laço'
+
+        lassoHint = L.DomUtil.create('p', 'mesa-leaflet-measure-hint', lassoInteraction)
+        lassoResults = L.DomUtil.create('div', 'mesa-leaflet-measure-results', lassoInteraction)
+
+        const actions = L.DomUtil.create('div', 'mesa-leaflet-measure-actions', lassoInteraction)
+        lassoStartButton = L.DomUtil.create('button', 'mesa-leaflet-measure-btn is-primary', actions)
+        lassoStartButton.type = 'button'
+        lassoStartButton.textContent = 'Criar laço'
+
+        lassoCancelButton = L.DomUtil.create('button', 'mesa-leaflet-measure-btn', actions)
+        lassoCancelButton.type = 'button'
+        lassoCancelButton.textContent = 'Cancelar'
+
+        lassoDownloadButton = L.DomUtil.create('button', 'mesa-leaflet-measure-btn is-primary', actions)
+        lassoDownloadButton.type = 'button'
+        lassoDownloadButton.textContent = 'Baixar XLSX'
+
+        lassoCloseButton = L.DomUtil.create('button', 'mesa-leaflet-measure-btn', actions)
+        lassoCloseButton.type = 'button'
+        lassoCloseButton.textContent = 'Fechar'
+
+        L.DomEvent.disableClickPropagation(lassoRoot)
+        L.DomEvent.disableScrollPropagation(lassoRoot)
+        L.DomEvent.on(toggle, 'click', (event) => {
+          L.DomEvent.stop(event)
+          if (lassoState.active) return
+          lassoState.panelOpen = !lassoState.panelOpen
+          renderLassoPanel()
+        })
+        L.DomEvent.on(lassoStartButton, 'click', (event) => {
+          L.DomEvent.stop(event)
+          startLasso()
+        })
+        L.DomEvent.on(lassoCancelButton, 'click', (event) => {
+          L.DomEvent.stop(event)
+          resetLassoState()
+        })
+        L.DomEvent.on(lassoDownloadButton, 'click', (event) => {
+          L.DomEvent.stop(event)
+          void downloadLassoSelection()
+        })
+        L.DomEvent.on(lassoCloseButton, 'click', (event) => {
+          L.DomEvent.stop(event)
+          if (lassoState.active) return
+          lassoState.panelOpen = false
+          renderLassoPanel()
+        })
+
+        renderLassoPanel()
+        return lassoRoot
+      }
+      lassoControl.addTo(map)
+    }
+
     if (payload.controls?.fullscreen) {
       addFullscreenControl(map, onToggleFullscreen)
     }
@@ -2142,6 +2608,7 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
       }
       disposed = true
       restoreMapInteractions?.()
+      cleanupLasso?.()
       if (popupLoaderRef.current === carregarPopupRegistro) {
         popupLoaderRef.current = null
       }
@@ -2169,7 +2636,9 @@ const LeafletMapFrame = forwardRef(function LeafletMapFrame({ payload, sessionId
             <div className="leaflet-market-group-modal-head">
               <div>
                 <strong>{groupSelection.title}</strong>
-                <span>{Number(groupSelection.count) || groupSelection.items?.length || 0} registros sobrepostos</span>
+                {!groupSelection.hideCount ? (
+                  <span>{Number(groupSelection.count) || groupSelection.items?.length || 0} registros sobrepostos</span>
+                ) : null}
               </div>
               <button type="button" onClick={closeGroupSelection} aria-label="Fechar">×</button>
             </div>

frontend/src/components/PesquisaTab.jsx

@@ -1033,7 +1033,6 @@ export default function PesquisaTab({
   const [mapaHtmls, setMapaHtmls] = useState({ pontos: '', cobertura: '' })
   const [mapaPayloads, setMapaPayloads] = useState({ pontos: null, cobertura: null })
   const [mapaModoExibicao, setMapaModoExibicao] = useState('pontos')
-  const [mapaAgruparPontosMercado, setMapaAgruparPontosMercado] = useState(false)
   const [mapaTrabalhosTecnicosModelosModo, setMapaTrabalhosTecnicosModelosModo] = useState('selecionados_e_outras_versoes')
   const [mapaTrabalhosTecnicosProximidadeModo, setMapaTrabalhosTecnicosProximidadeModo] = useState('sem_proximidade')
   const [mapaTrabalhosTecnicosRaio, setMapaTrabalhosTecnicosRaio] = useState(1000)
@@ -1163,7 +1162,6 @@ export default function PesquisaTab({
     setMapaStatus('')
     setMapaError('')
     setMapaModoExibicao('pontos')
-    setMapaAgruparPontosMercado(false)
     mapaTrabalhosTecnicosConfigRef.current = ''
   }
 
@@ -1194,7 +1192,6 @@ export default function PesquisaTab({
   async function carregarMapaPesquisa(ids, overrides = {}) {
     const idsValidos = (ids || []).map((item) => String(item || '').trim()).filter(Boolean)
     const modoExibicaoSolicitado = String(overrides.modoExibicao || mapaModoExibicao || 'pontos')
-    const agruparPontosMercadoSolicitado = Boolean(overrides.agruparPontosMercado ?? mapaAgruparPontosMercado)
     const trabalhosTecnicosConfig = getMapaTrabalhosTecnicosRequestConfig(overrides)
 
     if (!idsValidos.length) {
@@ -1217,7 +1214,7 @@ export default function PesquisaTab({
         trabalhosTecnicosConfig.modelosModo,
         trabalhosTecnicosConfig.proximidadeModo,
         trabalhosTecnicosConfig.raio,
-        agruparPontosMercadoSolicitado,
+        true,
       )
       const mapaHtmlSolicitado = String(
         response.mapa_html
@@ -1785,18 +1782,6 @@ export default function PesquisaTab({
     void carregarMapaPesquisa(selectedIds, { modoExibicao: nextModo })
   }
 
-  function onMapaAgrupamentoPontosChange(event) {
-    const nextAgrupar = String(event?.target?.value || 'individual') === 'agrupado'
-    setMapaAgruparPontosMercado(nextAgrupar)
-    setMapaHtmls((prev) => ({ ...prev, pontos: '' }))
-    setMapaPayloads((prev) => ({ ...prev, pontos: null }))
-    if (!mapaFoiGerado || mapaLoading || !selectedIds.length || mapaModoExibicao !== 'pontos') return
-    void carregarMapaPesquisa(selectedIds, {
-      modoExibicao: 'pontos',
-      agruparPontosMercado: nextAgrupar,
-    })
-  }
-
   async function onAdminConfigSalva() {
     if (pesquisaInicializada) {
       await buscarModelos(filters, avaliandosGeolocalizados)
@@ -2576,21 +2561,6 @@ export default function PesquisaTab({
                 </select>
               </label>
 
-              {mapaModoExibicao === 'pontos' ? (
-                <label className="pesquisa-field pesquisa-mapa-agrupamento-field">
-                  Pontos sobrepostos
-                  <select
-                    {...buildSelectAutofillProps('mapaAgrupamentoPontos')}
-                    value={mapaAgruparPontosMercado ? 'agrupado' : 'individual'}
-                    onChange={onMapaAgrupamentoPontosChange}
-                    disabled={mapaLoading || !selectedIds.length}
-                  >
-                    <option value="individual">Mostrar individualmente</option>
-                    <option value="agrupado">Agrupar por coordenada</option>
-                  </select>
-                </label>
-              ) : null}
-
               <label className="pesquisa-field pesquisa-mapa-trabalhos-field">
                 Exibição dos trabalhos técnicos
                 <select
@@ -2649,7 +2619,12 @@ export default function PesquisaTab({
         </SectionBlock>
       </div>
 
-      <LoadingOverlay show={searchLoading} label="Pesquisando modelos..." />
+      <LoadingOverlay
+        show={searchLoading || localizacaoLoading}
+        label={localizacaoLoading
+          ? (localizacaoModo === 'endereco' ? 'Buscando endereço...' : 'Buscando localização...')
+          : 'Pesquisando modelos...'}
+      />
       <LoadingOverlay show={modeloAbertoLoading} label="Carregando modelo..." />
     </div>
   )

frontend/src/components/RepositorioTab.jsx

@@ -7,6 +7,7 @@ import {
   normalizeMapPointRadiusRange,
 } from '../mapPointSizing'
 import DataTable from './DataTable'
+import AnexosModal from './AnexosModal'
 import EquationFormatsPanel from './EquationFormatsPanel'
 import ListPagination from './ListPagination'
 import LoadingOverlay from './LoadingOverlay'
@@ -211,6 +212,7 @@ export default function RepositorioTab({
   const [modeloAbertoPlotCorr, setModeloAbertoPlotCorr] = useState(null)
   const [modeloAbertoLoadedTabs, setModeloAbertoLoadedTabs] = useState({})
   const [modeloAbertoLoadingTabs, setModeloAbertoLoadingTabs] = useState({})
+  const [anexosModalOpen, setAnexosModalOpen] = useState(false)
   const lastOpenRequestKeyRef = useRef('')
   const pendingTabRequestsRef = useRef({})
   const modeloOpenVersionRef = useRef(0)
@@ -581,6 +583,7 @@ export default function RepositorioTab({
     setModeloAbertoError('')
     setModeloAbertoActiveTab('mapa')
     setModeloAbertoLoading(false)
+    setAnexosModalOpen(false)
     limparConteudoModeloAberto()
     if (typeof onRouteChange === 'function') {
       onRouteChange(nextIntent)
@@ -684,6 +687,14 @@ export default function RepositorioTab({
             </div>
             <div className="pesquisa-opened-model-actions">
               <ShareLinkButton href={shareHref} />
+              <button
+                type="button"
+                className="pesquisa-opened-model-action-btn pesquisa-opened-model-action-btn-primary"
+                onClick={() => setAnexosModalOpen(true)}
+                disabled={modeloAbertoLoading}
+              >
+                Gerar anexos
+              </button>
               {typeof onUsarModeloEmAvaliacao === 'function' ? (
                 <button
                   type="button"
@@ -879,6 +890,11 @@ export default function RepositorioTab({
           {modeloAbertoError ? <div className="error-line inline-error">{modeloAbertoError}</div> : null}
         </div>
         <LoadingOverlay show={modeloAbertoLoading || activeTabLoading} label={modeloLoadingLabel} />
+        <AnexosModal
+          open={anexosModalOpen}
+          defaultModeloId={modeloAbertoMeta?.id || ''}
+          onClose={() => setAnexosModalOpen(false)}
+        />
       </div>
     )
   }

frontend/src/components/TrabalhosTecnicosTab.jsx

@@ -1443,10 +1443,12 @@ export default function TrabalhosTecnicosTab({
           ) : null}
         </div>
         <LoadingOverlay
-          show={trabalhoLoading || salvando}
-          label={salvando
+          show={trabalhoLoading || salvando || trabalhoGeoLoading}
+          label={trabalhoGeoLoading
+            ? (trabalhoGeoModo === 'endereco' ? 'Buscando endereço...' : 'Buscando localização...')
+            : (salvando
             ? (cadastrando ? 'Cadastrando trabalho técnico...' : 'Salvando trabalho técnico...')
-            : 'Abrindo trabalho técnico...'}
+            : 'Abrindo trabalho técnico...')}
         />
       </div>
     )
@@ -1855,10 +1857,12 @@ export default function TrabalhosTecnicosTab({
         )}
       </div>
       <LoadingOverlay
-        show={loading || mapaLoading || trabalhoLoading}
-        label={trabalhoLoading
+        show={loading || mapaLoading || trabalhoLoading || localizacaoLoading}
+        label={localizacaoLoading
+          ? (localizacaoModo === 'endereco' ? 'Buscando endereço...' : 'Buscando localização...')
+          : (trabalhoLoading
           ? 'Abrindo trabalho técnico...'
-          : (mapaLoading ? 'Gerando mapa dos trabalhos técnicos...' : 'Carregando trabalhos técnicos...')}
+          : (mapaLoading ? 'Gerando mapa dos trabalhos técnicos...' : 'Carregando trabalhos técnicos...'))}
       />
     </div>
   )

frontend/src/styles.css

@@ -3754,6 +3754,175 @@ button.pesquisa-coluna-remove:hover {
   margin-top: 12px;
 }
 
+.anexos-modal {
+  width: min(760px, 100%);
+}
+
+.anexos-modal-body {
+  gap: 14px;
+}
+
+.anexos-modal-model-field {
+  display: grid;
+  gap: 6px;
+  color: #334b61;
+  font-size: 0.84rem;
+  font-weight: 700;
+}
+
+.anexos-modal-model-field select {
+  width: 100%;
+  min-width: 0;
+}
+
+.anexos-columns-section {
+  display: grid;
+  gap: 8px;
+  padding-top: 12px;
+  border-top: 1px solid #dbe5ef;
+}
+
+.anexos-columns-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.anexos-columns-head > div:first-child {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  min-width: 0;
+}
+
+.anexos-columns-head strong {
+  color: #334b61;
+  font-size: 0.84rem;
+}
+
+.anexos-columns-head span {
+  color: #687d91;
+  font-size: 0.75rem;
+}
+
+.anexos-columns-actions,
+.anexos-reorder-actions {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.anexos-columns-actions button,
+.anexos-reorder-actions button {
+  min-height: 28px;
+  padding: 3px 8px;
+  font-size: 0.75rem;
+}
+
+.anexos-reorder-actions button {
+  width: 30px;
+  min-width: 30px;
+  padding: 0;
+  font-size: 0.95rem;
+}
+
+.anexos-columns-list {
+  display: grid;
+  max-height: 310px;
+  overflow: auto;
+  border: 1px solid #d5e0ea;
+  border-radius: 8px;
+  background: #f7f9fb;
+}
+
+.anexos-column-row {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 8px;
+  min-height: 40px;
+  padding: 4px 8px 4px 10px;
+  border-bottom: 1px solid #e2e9f0;
+  background: #fff;
+}
+
+.anexos-column-row:last-child {
+  border-bottom: 0;
+}
+
+.anexos-column-row > label {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr);
+  align-items: center;
+  gap: 9px;
+  min-width: 0;
+  color: #30485e;
+  font-size: 0.82rem;
+  font-weight: 600;
+}
+
+.anexos-column-row input {
+  width: 16px;
+  height: 16px;
+  margin: 0;
+}
+
+.anexos-column-row span {
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.anexos-warning-panel,
+.anexos-result-panel {
+  border-radius: 8px;
+  padding: 10px 12px;
+  font-size: 0.81rem;
+}
+
+.anexos-warning-panel {
+  border: 1px solid #e4bd55;
+  background: #fff8df;
+  color: #654b0c;
+}
+
+.anexos-warning-panel ul {
+  margin: 6px 0 0;
+  padding-left: 18px;
+}
+
+.anexos-result-panel {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 10px;
+  border: 1px solid #aed3b8;
+  background: #f2faf4;
+  color: #235b32;
+}
+
+.anexos-result-panel > div {
+  display: grid;
+  gap: 3px;
+  min-width: 0;
+}
+
+.anexos-result-panel span {
+  color: #486b51;
+  overflow-wrap: anywhere;
+}
+
+.anexos-modal-footer {
+  display: flex;
+  justify-content: flex-end;
+  padding-top: 12px;
+  border-top: 1px solid #dbe5ef;
+}
+
+.anexos-modal-footer button {
+  min-width: 150px;
+}
+
 .pesquisa-card-values-modal {
   width: min(920px, calc(100vw - 40px));
   max-width: min(920px, calc(100vw - 40px));
@@ -4090,9 +4259,24 @@ button.pesquisa-coluna-remove:hover {
 .avaliacao-modelos-card-actions {
   display: inline-flex;
   align-items: center;
+  justify-content: flex-end;
+  gap: 6px;
+  flex-wrap: wrap;
   flex: 0 0 auto;
 }
 
+.avaliacao-modelos-anexo-btn {
+  min-height: 28px;
+  padding: 3px 8px;
+  font-size: 0.74rem;
+  --btn-bg-start: #eaf3fb;
+  --btn-bg-end: #dceaf7;
+  --btn-border: #afc9df;
+  --btn-shadow-soft: rgba(47, 121, 184, 0.1);
+  --btn-shadow-strong: rgba(47, 121, 184, 0.16);
+  color: #285b85;
+}
+
 .avaliacao-card-delete-confirm {
   display: inline-flex;
   align-items: center;
@@ -5013,38 +5197,6 @@ button.paste-excel-clear-btn {
   gap: 8px;
 }
 
-.import-preview-first-columns-field {
-  display: inline-flex;
-  align-items: center;
-  gap: 7px;
-  color: #33485d;
-  font-size: 0.86rem;
-  font-weight: 700;
-}
-
-.import-preview-first-columns-toggle {
-  display: inline-flex;
-  align-items: center;
-  gap: 7px;
-  min-height: 34px;
-  border: 1px solid #c8d8e8;
-  border-radius: 8px;
-  background: #f6f9fc;
-  color: #33485d;
-  font-size: 0.86rem;
-  font-weight: 800;
-  padding: 6px 9px;
-}
-
-.import-preview-first-columns-toggle input {
-  width: auto;
-  margin: 0;
-}
-
-.import-preview-first-columns-field input {
-  width: 78px;
-}
-
 button.import-preview-apply-btn {
   --btn-bg-start: #ff8c00;
   --btn-bg-end: #e67900;
@@ -5952,10 +6104,6 @@ button.import-preview-clear-btn {
   background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath fill='%2324405b' d='M12 2 3 7l9 5 9-5-9-5Zm-7.5 8.6L12 15l7.5-4.4L21 12l-9 5-9-5 1.5-1.4Zm0 4.8L12 19.8l7.5-4.4L21 17l-9 5-9-5 1.5-1.6Z'/%3E%3C/svg%3E");
 }
 
-.leaflet-map-host .leaflet-control-layers-toggle:hover {
-  background-color: #eef5fb;
-}
-
 .leaflet-map-host .leaflet-control-layers-expanded {
   padding: 6px 9px;
   min-width: 220px;
@@ -5988,17 +6136,10 @@ button.import-preview-clear-btn {
   font-weight: 500;
   color: #27445f;
   cursor: pointer;
-  transition: background-color 0.18s ease, color 0.18s ease;
   line-height: 1.12;
   white-space: normal;
 }
 
-.leaflet-map-host .leaflet-control-layers label:hover {
-  background: #f3f7fb;
-  transform: none;
-  color: #1f5f9f;
-}
-
 .leaflet-map-host .leaflet-control-layers input {
   accent-color: #1f6fb2;
   width: 16px;
@@ -6033,6 +6174,29 @@ button.import-preview-clear-btn {
   border-top-color: rgba(207, 217, 227, 0.95);
 }
 
+.leaflet-map-host .mesa-layer-control-close {
+  display: none;
+  width: 100%;
+  margin: 7px 0 0;
+  padding: 7px 10px;
+  appearance: none;
+  border: 1px solid #c8d6e4;
+  border-radius: 8px;
+  background: #fff;
+  color: #24405b;
+  font: inherit;
+  font-size: 0.73rem;
+  font-weight: 600;
+  line-height: 1;
+  cursor: pointer;
+}
+
+.leaflet-map-host .leaflet-control-layers-expanded .mesa-layer-control-close {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+
 .leaflet-map-host .mesa-leaflet-fullscreen,
 .leaflet-map-host .leaflet-control-measure {
   border: none;
@@ -6057,7 +6221,8 @@ button.import-preview-clear-btn {
   color: #24405b;
 }
 
-.leaflet-map-host .mesa-leaflet-measure {
+.leaflet-map-host .mesa-leaflet-measure,
+.leaflet-map-host .mesa-leaflet-lasso {
   background: transparent;
   border: none;
   box-shadow: none;
@@ -6101,7 +6266,8 @@ button.import-preview-clear-btn {
   background: #eef5fb;
 }
 
-.leaflet-map-host .mesa-leaflet-measure .mesa-leaflet-measure-toggle {
+.leaflet-map-host .mesa-leaflet-measure .mesa-leaflet-measure-toggle,
+.leaflet-map-host .mesa-leaflet-lasso .mesa-leaflet-lasso-toggle {
   width: 38px;
   height: 38px;
   position: relative;
@@ -6112,6 +6278,11 @@ button.import-preview-clear-btn {
   box-shadow: 0 10px 24px rgba(27, 48, 72, 0.16);
 }
 
+.leaflet-map-host .mesa-leaflet-lasso.is-active .mesa-leaflet-lasso-toggle {
+  background: #e6f6f4;
+  border-color: #91cfc6;
+}
+
 .leaflet-map-host .mesa-leaflet-measure .mesa-leaflet-measure-toggle::before {
   content: '';
   position: absolute;
@@ -6125,7 +6296,21 @@ button.import-preview-clear-btn {
   background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath fill='%2324405b' d='M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25Zm2.92 2.33H5v-.92l8.12-8.12.92.92-8.12 8.12ZM20.71 7.04a1.003 1.003 0 0 0 0-1.42l-2.34-2.33a1.003 1.003 0 0 0-1.42 0l-1.83 1.83 3.75 3.75 1.84-1.83Z'/%3E%3C/svg%3E");
 }
 
-.leaflet-map-host .mesa-leaflet-measure .mesa-leaflet-measure-toggle:hover {
+.leaflet-map-host .mesa-leaflet-lasso .mesa-leaflet-lasso-toggle::before {
+  content: '';
+  position: absolute;
+  inset: 0;
+  margin: auto;
+  width: 20px;
+  height: 20px;
+  background-repeat: no-repeat;
+  background-position: center;
+  background-size: 20px 20px;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'%3E%3Cpath fill='none' stroke='%2324405b' stroke-width='2' stroke-linecap='round' stroke-linejoin='round' d='M5 9c0-3 3.1-5 7-5s7 2 7 5-3.1 5-7 5-7-2-7-5Zm10.8 4.2 4.2 4.8m0 0-3.2-.5m3.2.5-.6-3.3M8 18c2.5 1.4 5.5 1.4 8 0'/%3E%3C/svg%3E");
+}
+
+.leaflet-map-host .mesa-leaflet-measure .mesa-leaflet-measure-toggle:hover,
+.leaflet-map-host .mesa-leaflet-lasso .mesa-leaflet-lasso-toggle:hover {
   background: #eef5fb;
 }
 
@@ -6202,6 +6387,15 @@ button.import-preview-clear-btn {
   background: #f3f7fb;
 }
 
+.leaflet-map-host .mesa-leaflet-measure-btn:disabled {
+  opacity: 0.62;
+  cursor: wait;
+}
+
+.leaflet-map-host .mesa-leaflet-measure-btn:disabled:hover {
+  background: #fff;
+}
+
 .leaflet-map-host .mesa-leaflet-measure-btn.is-primary {
   background: #1f6fb2;
   border-color: #1f6fb2;
@@ -6212,6 +6406,10 @@ button.import-preview-clear-btn {
   background: #175a90;
 }
 
+.leaflet-map-host .mesa-leaflet-measure-btn.is-primary:disabled:hover {
+  background: #1f6fb2;
+}
+
 .table-wrapper {
   overflow: auto;
   border: 1px solid #d8e2ec;
@@ -8556,6 +8754,21 @@ button.btn-download-subtle {
     flex-direction: column;
   }
 
+  .anexos-columns-head,
+  .anexos-result-panel {
+    grid-template-columns: 1fr;
+  }
+
+  .anexos-columns-head {
+    align-items: flex-start;
+    flex-direction: column;
+  }
+
+  .anexos-result-panel button,
+  .anexos-modal-footer button {
+    width: 100%;
+  }
+
   .avaliacao-localizacao-map-modal-actions {
     width: 100%;
     justify-content: flex-end;