prototipo aba pesquisa

.gitignore

@@ -11,3 +11,6 @@ frontend/dist/
 
 # System
 .DS_Store
+
+# Modelos locais da pesquisa (binários, não versionar)
+backend/app/core/pesquisa/modelos_dai/*.dai

backend/app/api/pesquisa.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Query
+from pydantic import BaseModel
+
+from app.services.pesquisa_service import PesquisaFiltros, gerar_mapa_modelos, listar_modelos
+
+
+router = APIRouter(prefix="/api/pesquisa", tags=["pesquisa"])
+
+
+def _split_csv(value: str | None) -> list[str]:
+    if not value:
+        return []
+    return [item.strip() for item in value.split(",") if item.strip()]
+
+
+class MapaModelosPayload(BaseModel):
+    modelos_ids: list[str]
+
+
+@router.get("/modelos")
+def pesquisar_modelos(
+    somente_contexto: bool = Query(False),
+    otica: str = Query("modelo"),
+    nome: str | None = Query(None),
+    autor: str | None = Query(None),
+    finalidade: str | None = Query(None),
+    finalidade_colunas: str | None = Query(None),
+    bairro: str | None = Query(None),
+    bairros: str | None = Query(None),
+    bairros_colunas: str | None = Query(None),
+    endereco: str | None = Query(None),
+    data_min: str | None = Query(None),
+    data_colunas: str | None = Query(None),
+    data_max: str | None = Query(None),
+    area_min: float | None = Query(None),
+    area_colunas: str | None = Query(None),
+    area_max: float | None = Query(None),
+    rh_min: float | None = Query(None),
+    rh_colunas: str | None = Query(None),
+    rh_max: float | None = Query(None),
+    aval_finalidade: str | None = Query(None),
+    aval_finalidade_colunas: str | None = Query(None),
+    aval_bairro: str | None = Query(None),
+    aval_bairro_colunas: str | None = Query(None),
+    aval_endereco: str | None = Query(None),
+    aval_data: str | None = Query(None),
+    aval_data_colunas: str | None = Query(None),
+    aval_area: float | None = Query(None),
+    aval_area_colunas: str | None = Query(None),
+    aval_area_privativa: float | None = Query(None),
+    aval_area_privativa_colunas: str | None = Query(None),
+    aval_area_total: float | None = Query(None),
+    aval_area_total_colunas: str | None = Query(None),
+    aval_rh: float | None = Query(None),
+    aval_rh_colunas: str | None = Query(None),
+    aval_valor_unitario: float | None = Query(None),
+    aval_valor_unitario_colunas: str | None = Query(None),
+    aval_valor_total: float | None = Query(None),
+    aval_valor_total_colunas: str | None = Query(None),
+    limite: int = Query(300, ge=1, le=2000),
+) -> dict:
+    filtros = PesquisaFiltros(
+        otica=otica,
+        nome=nome,
+        autor=autor,
+        finalidade=finalidade,
+        finalidade_colunas=_split_csv(finalidade_colunas),
+        bairro=bairro,
+        bairros=_split_csv(bairros),
+        bairros_colunas=_split_csv(bairros_colunas),
+        endereco=endereco,
+        data_min=data_min,
+        data_colunas=_split_csv(data_colunas),
+        data_max=data_max,
+        area_min=area_min,
+        area_colunas=_split_csv(area_colunas),
+        area_max=area_max,
+        rh_min=rh_min,
+        rh_colunas=_split_csv(rh_colunas),
+        rh_max=rh_max,
+        aval_finalidade=aval_finalidade,
+        aval_finalidade_colunas=_split_csv(aval_finalidade_colunas),
+        aval_bairro=aval_bairro,
+        aval_bairro_colunas=_split_csv(aval_bairro_colunas),
+        aval_endereco=aval_endereco,
+        aval_data=aval_data,
+        aval_data_colunas=_split_csv(aval_data_colunas),
+        aval_area=aval_area,
+        aval_area_colunas=_split_csv(aval_area_colunas),
+        aval_area_privativa=aval_area_privativa,
+        aval_area_privativa_colunas=_split_csv(aval_area_privativa_colunas),
+        aval_area_total=aval_area_total,
+        aval_area_total_colunas=_split_csv(aval_area_total_colunas),
+        aval_rh=aval_rh,
+        aval_rh_colunas=_split_csv(aval_rh_colunas),
+        aval_valor_unitario=aval_valor_unitario,
+        aval_valor_unitario_colunas=_split_csv(aval_valor_unitario_colunas),
+        aval_valor_total=aval_valor_total,
+        aval_valor_total_colunas=_split_csv(aval_valor_total_colunas),
+    )
+    return listar_modelos(filtros=filtros, limite=limite, somente_contexto=somente_contexto)
+
+
+@router.post("/mapa-modelos")
+def pesquisar_mapa_modelos(payload: MapaModelosPayload) -> dict:
+    return gerar_mapa_modelos(payload.modelos_ids)

backend/app/core/pesquisa/modelos_dai/README.md

@@ -0,0 +1,19 @@
+# Pasta de Modelos da Aba Pesquisa
+
+Coloque nesta pasta os arquivos `.dai` que devem aparecer na aba **Pesquisa**.
+
+## Estrutura
+
+- `NOME_MODELO.dai`
+
+Exemplo:
+
+- `MOD_A_SALA_Z1_006C.dai`
+
+## Como os dados sao lidos
+
+- Nome do modelo: nome do arquivo `.dai`
+- Autor, equacao, R2 e dados estatisticos: lidos do proprio pacote `.dai`
+- Finalidade e bairros: extraidos das colunas do `.dai` (com prioridade para aliases de `NME IMO-FINAL` e `NME BAI`)
+
+Nao ha suporte a arquivo auxiliar `.meta.json` nesta pasta.

backend/app/main.py

@@ -6,7 +6,7 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 
-from app.api import elaboracao, health, session, visualizacao
+from app.api import elaboracao, health, pesquisa, session, visualizacao
 
 
 app = FastAPI(
@@ -27,6 +27,7 @@ app.include_router(health.router)
 app.include_router(session.router)
 app.include_router(elaboracao.router)
 app.include_router(visualizacao.router)
+app.include_router(pesquisa.router)
 
 
 def _mount_frontend_if_exists() -> None:

backend/app/services/pesquisa_service.py

@@ -0,0 +1,1599 @@
+from __future__ import annotations
+
+import math
+import re
+import unicodedata
+from dataclasses import dataclass
+from datetime import date, datetime
+from pathlib import Path
+from threading import Lock
+from typing import Any
+
+import folium
+import pandas as pd
+from fastapi import HTTPException
+from joblib import load
+
+from app.core.elaboracao.core import _migrar_pacote_v1_para_v2
+from app.services.serializers import sanitize_value
+
+MODELOS_DIR = Path(__file__).resolve().parent.parent / "core" / "pesquisa" / "modelos_dai"
+
+AREA_PRIVATIVA_ALIASES = ["APRIV", "ACOPRIV", "AREAPRIV", "AREA_PRIVATIVA", "AREA PRIVATIVA"]
+AREA_TOTAL_ALIASES = ["ATOTAL", "ATOT", "AREA_TOTAL", "AREA TOTAL", "AREA"]
+VALOR_UNITARIO_ALIASES = ["VU", "VUNIT", "VULOC", "VUAPRIV", "VALOR_UNITARIO", "VALOR UNITARIO"]
+VALOR_TOTAL_ALIASES = ["VLOC", "VTOT", "VALOR_TOTAL", "VALOR TOTAL"]
+RH_ALIASES = ["RH", "FATOR_RH", "FATOR RH", "RENDA_HABITACIONAL"]
+DATA_ALIASES = ["DATA", "DT", "ANO", "DATA_AVALIACAO", "DATA AVALIACAO", "COMPETENCIA"]
+BAIRRO_ALIASES = ["BAIRRO", "BAIRROS", "NOME_BAIRRO", "BAIRRO_NOME", "NME BAI", "NME_BAI"]
+FINALIDADE_ALIASES = ["NME IMO-FINAL", "NME_IMO_FINAL", "NME IMO FINAL", "FINALIDADE", "TIPO_IMOVEL", "TIPO IMOVEL"]
+LAT_ALIASES = ["LAT", "LATITUDE", "SIAT_LATITUDE"]
+LON_ALIASES = ["LON", "LONG", "LONGITUDE", "SIAT_LONGITUDE"]
+
+TIPO_POR_TOKEN = {
+    "RECOND": "Residencia em condominio",
+    "RCOMD": "Residencia em condominio",
+    "TCOND": "Terreno em condominio",
+    "LCOM": "Loja",
+    "LOJA": "Loja",
+    "CCOM": "Casa comercial",
+    "DEP": "Deposito",
+    "DEPOS": "Deposito",
+    "RES": "Residencias isoladas / casas",
+    "SALA": "Salas comerciais",
+    "APTO": "Apartamentos residenciais",
+    "APART": "Apartamentos residenciais",
+    "AP": "Apartamentos residenciais",
+    "TERRENO": "Terrenos",
+    "TER": "Terrenos",
+    "EDIF": "Edificio",
+    "CASA": "Residencias isoladas / casas",
+    "GALPAO": "Galpao",
+}
+
+CAMPO_TEXTO_META_FONTES = {
+    "finalidade": [],
+    "bairros": [],
+    "aval_finalidade": [],
+    "aval_bairro": [],
+}
+
+CAMPO_TEXTO_ALIASES_COLUNA = {
+    "finalidade": FINALIDADE_ALIASES,
+    "bairros": BAIRRO_ALIASES,
+    "aval_finalidade": FINALIDADE_ALIASES,
+    "aval_bairro": BAIRRO_ALIASES,
+}
+
+CAMPO_FAIXA_META_FONTES = {
+    "data": [],
+    "area": [],
+    "rh": [],
+    "aval_data": [],
+    "aval_area": [],
+    "aval_area_privativa": [],
+    "aval_area_total": [],
+    "aval_rh": [],
+    "aval_valor_unitario": [],
+    "aval_valor_total": [],
+}
+
+CAMPO_FAIXA_ALIASES_COLUNA = {
+    "data": DATA_ALIASES,
+    "area": AREA_PRIVATIVA_ALIASES + AREA_TOTAL_ALIASES,
+    "rh": RH_ALIASES,
+    "aval_data": DATA_ALIASES,
+    "aval_area": AREA_PRIVATIVA_ALIASES + AREA_TOTAL_ALIASES,
+    "aval_area_privativa": AREA_PRIVATIVA_ALIASES,
+    "aval_area_total": AREA_TOTAL_ALIASES,
+    "aval_rh": RH_ALIASES,
+    "aval_valor_unitario": VALOR_UNITARIO_ALIASES,
+    "aval_valor_total": VALOR_TOTAL_ALIASES,
+}
+
+FONTE_META_LABELS = {
+    "meta:nome_modelo": "Metadado: Nome do modelo",
+    "meta:arquivo": "Metadado: Arquivo",
+    "meta:autor": "Metadado: Autor/Elaborador",
+    "meta:finalidade": "Metadado: Finalidade",
+    "meta:tipo_imovel": "Metadado: Tipo",
+    "meta:finalidades": "Metadado: Finalidades",
+    "meta:bairros": "Metadado: Bairros",
+    "meta:endereco_referencia": "Metadado: Endereco de referencia",
+    "meta:faixa_data": "Metadado: Faixa de data",
+    "meta:faixa_area": "Metadado: Faixa de area",
+    "meta:faixa_rh": "Metadado: Faixa de RH",
+    "meta:faixa_area_privativa": "Metadado: Faixa de area privativa",
+    "meta:faixa_area_total": "Metadado: Faixa de area total",
+    "meta:faixa_valor_unitario": "Metadado: Faixa de valor unitario",
+    "meta:faixa_valor_total": "Metadado: Faixa de valor total",
+}
+
+MAX_COLUNAS_INDEXADAS = 120
+MAX_VALORES_INDEXADOS_POR_COLUNA = 140
+MAX_LINHAS_INDEXACAO = 5000
+
+COMPATIBILIDADE_MAP = {
+    "area_privativa": AREA_PRIVATIVA_ALIASES,
+    "area_total": AREA_TOTAL_ALIASES,
+    "valor_unitario": VALOR_UNITARIO_ALIASES,
+    "valor_total": VALOR_TOTAL_ALIASES,
+}
+
+RANGE_CAMPOS = {
+    "area_privativa": AREA_PRIVATIVA_ALIASES,
+    "area_total": AREA_TOTAL_ALIASES,
+    "valor_unitario": VALOR_UNITARIO_ALIASES,
+    "valor_total": VALOR_TOTAL_ALIASES,
+}
+
+MAP_COLORS = [
+    "#1f77b4",
+    "#d62728",
+    "#2ca02c",
+    "#ff7f0e",
+    "#9467bd",
+    "#17becf",
+    "#8c564b",
+    "#e377c2",
+    "#bcbd22",
+    "#7f7f7f",
+]
+
+
+@dataclass(frozen=True)
+class PesquisaFiltros:
+    otica: str = "modelo"
+    nome: str | None = None
+    autor: str | None = None
+    finalidade: str | None = None
+    finalidade_colunas: list[str] | None = None
+    bairro: str | None = None
+    bairros: list[str] | None = None
+    bairros_colunas: list[str] | None = None
+    endereco: str | None = None
+    data_min: str | None = None
+    data_colunas: list[str] | None = None
+    data_max: str | None = None
+    area_min: float | None = None
+    area_colunas: list[str] | None = None
+    area_max: float | None = None
+    rh_min: float | None = None
+    rh_colunas: list[str] | None = None
+    rh_max: float | None = None
+    aval_finalidade: str | None = None
+    aval_finalidade_colunas: list[str] | None = None
+    aval_bairro: str | None = None
+    aval_bairro_colunas: list[str] | None = None
+    aval_endereco: str | None = None
+    aval_data: str | None = None
+    aval_data_colunas: list[str] | None = None
+    aval_area: float | None = None
+    aval_area_colunas: list[str] | None = None
+    aval_area_privativa: float | None = None
+    aval_area_privativa_colunas: list[str] | None = None
+    aval_area_total: float | None = None
+    aval_area_total_colunas: list[str] | None = None
+    aval_rh: float | None = None
+    aval_rh_colunas: list[str] | None = None
+    aval_valor_unitario: float | None = None
+    aval_valor_unitario_colunas: list[str] | None = None
+    aval_valor_total: float | None = None
+    aval_valor_total_colunas: list[str] | None = None
+
+
+_CACHE_LOCK = Lock()
+_CACHE: dict[str, dict[str, Any]] = {}
+
+
+def ensure_modelos_dir() -> Path:
+    MODELOS_DIR.mkdir(parents=True, exist_ok=True)
+    return MODELOS_DIR
+
+
+def listar_modelos(filtros: PesquisaFiltros, limite: int | None = None, somente_contexto: bool = False) -> dict[str, Any]:
+    pasta = ensure_modelos_dir()
+    modelos = sorted(pasta.glob("*.dai"), key=lambda item: item.name.lower())
+
+    otica = _normalizar_otica(filtros.otica)
+    filtros_exec = PesquisaFiltros(**{**filtros.__dict__, "otica": otica})
+
+    todos = [_carregar_resumo_com_cache(caminho) for caminho in modelos]
+    sugestoes = _extrair_sugestoes(todos)
+    colunas_filtro = _montar_config_colunas_filtro(todos)
+
+    if somente_contexto:
+        return sanitize_value(
+            {
+                "modelos": [],
+                "sugestoes": sugestoes,
+                "colunas_filtro": colunas_filtro,
+                "total_filtrado": 0,
+                "total_geral": len(todos),
+                "modelos_dir": str(pasta),
+                "filtros_aplicados": {
+                    "nome": filtros.nome,
+                    "autor": filtros.autor,
+                    "finalidade": filtros.finalidade,
+                    "finalidade_colunas": filtros.finalidade_colunas or [],
+                    "bairro": filtros.bairro,
+                    "bairros": filtros.bairros or [],
+                    "bairros_colunas": filtros.bairros_colunas or [],
+                    "endereco": filtros.endereco,
+                    "data_min": filtros.data_min,
+                    "data_colunas": filtros.data_colunas or [],
+                    "data_max": filtros.data_max,
+                    "area_min": filtros.area_min,
+                    "area_colunas": filtros.area_colunas or [],
+                    "area_max": filtros.area_max,
+                    "rh_min": filtros.rh_min,
+                    "rh_colunas": filtros.rh_colunas or [],
+                    "rh_max": filtros.rh_max,
+                    "otica": otica,
+                    "aval_finalidade": filtros.aval_finalidade,
+                    "aval_finalidade_colunas": filtros.aval_finalidade_colunas or [],
+                    "aval_bairro": filtros.aval_bairro,
+                    "aval_bairro_colunas": filtros.aval_bairro_colunas or [],
+                    "aval_endereco": filtros.aval_endereco,
+                    "aval_data": filtros.aval_data,
+                    "aval_data_colunas": filtros.aval_data_colunas or [],
+                    "aval_area": filtros.aval_area,
+                    "aval_area_colunas": filtros.aval_area_colunas or [],
+                    "aval_area_privativa": filtros.aval_area_privativa,
+                    "aval_area_privativa_colunas": filtros.aval_area_privativa_colunas or [],
+                    "aval_area_total": filtros.aval_area_total,
+                    "aval_area_total_colunas": filtros.aval_area_total_colunas or [],
+                    "aval_rh": filtros.aval_rh,
+                    "aval_rh_colunas": filtros.aval_rh_colunas or [],
+                    "aval_valor_unitario": filtros.aval_valor_unitario,
+                    "aval_valor_unitario_colunas": filtros.aval_valor_unitario_colunas or [],
+                    "aval_valor_total": filtros.aval_valor_total,
+                    "aval_valor_total_colunas": filtros.aval_valor_total_colunas or [],
+                },
+            }
+        )
+
+    filtrados = [item for item in todos if _aceita_filtros(item, filtros_exec)]
+
+    if otica == "avaliando":
+        filtrados = [_anexar_avaliando_info(item, filtros_exec) for item in filtrados]
+        filtrados = [item for item in filtrados if item.get("avaliando", {}).get("aceito")]
+
+    if limite and limite > 0:
+        filtrados = filtrados[:limite]
+
+    modelos_publicos = [_modelo_publico(item) for item in filtrados]
+
+    return sanitize_value(
+        {
+            "modelos": modelos_publicos,
+            "sugestoes": sugestoes,
+            "colunas_filtro": colunas_filtro,
+            "total_filtrado": len(filtrados),
+            "total_geral": len(todos),
+            "modelos_dir": str(pasta),
+            "filtros_aplicados": {
+                "nome": filtros.nome,
+                "autor": filtros.autor,
+                "finalidade": filtros.finalidade,
+                "finalidade_colunas": filtros.finalidade_colunas or [],
+                "bairro": filtros.bairro,
+                "bairros": filtros.bairros or [],
+                "bairros_colunas": filtros.bairros_colunas or [],
+                "endereco": filtros.endereco,
+                "data_min": filtros.data_min,
+                "data_colunas": filtros.data_colunas or [],
+                "data_max": filtros.data_max,
+                "area_min": filtros.area_min,
+                "area_colunas": filtros.area_colunas or [],
+                "area_max": filtros.area_max,
+                "rh_min": filtros.rh_min,
+                "rh_colunas": filtros.rh_colunas or [],
+                "rh_max": filtros.rh_max,
+                "otica": otica,
+                "aval_finalidade": filtros.aval_finalidade,
+                "aval_finalidade_colunas": filtros.aval_finalidade_colunas or [],
+                "aval_bairro": filtros.aval_bairro,
+                "aval_bairro_colunas": filtros.aval_bairro_colunas or [],
+                "aval_endereco": filtros.aval_endereco,
+                "aval_data": filtros.aval_data,
+                "aval_data_colunas": filtros.aval_data_colunas or [],
+                "aval_area": filtros.aval_area,
+                "aval_area_colunas": filtros.aval_area_colunas or [],
+                "aval_area_privativa": filtros.aval_area_privativa,
+                "aval_area_privativa_colunas": filtros.aval_area_privativa_colunas or [],
+                "aval_area_total": filtros.aval_area_total,
+                "aval_area_total_colunas": filtros.aval_area_total_colunas or [],
+                "aval_rh": filtros.aval_rh,
+                "aval_rh_colunas": filtros.aval_rh_colunas or [],
+                "aval_valor_unitario": filtros.aval_valor_unitario,
+                "aval_valor_unitario_colunas": filtros.aval_valor_unitario_colunas or [],
+                "aval_valor_total": filtros.aval_valor_total,
+                "aval_valor_total_colunas": filtros.aval_valor_total_colunas or [],
+            },
+        }
+    )
+
+
+def gerar_mapa_modelos(modelos_ids: list[str], limite_pontos_por_modelo: int = 4500) -> dict[str, Any]:
+    ids = [str(item).strip() for item in (modelos_ids or []) if str(item).strip()]
+    if not ids:
+        raise HTTPException(status_code=400, detail="Selecione ao menos um modelo para gerar o mapa")
+
+    pasta = ensure_modelos_dir()
+    caminhos_por_id = {caminho.stem: caminho for caminho in pasta.glob("*.dai")}
+
+    selecionados: list[tuple[str, Path]] = []
+    vistos = set()
+    for modelo_id in ids:
+        if modelo_id in vistos:
+            continue
+        caminho = caminhos_por_id.get(modelo_id)
+        if caminho is None:
+            continue
+        vistos.add(modelo_id)
+        selecionados.append((modelo_id, caminho))
+
+    if not selecionados:
+        raise HTTPException(status_code=404, detail="Nenhum modelo selecionado foi encontrado na pasta de pesquisa")
+
+    modelos_plotados: list[dict[str, Any]] = []
+    bounds: list[list[float]] = []
+
+    for idx, (modelo_id, caminho) in enumerate(selecionados):
+        resumo = _carregar_resumo_com_cache(caminho)
+        df = _carregar_dataframe_modelo(caminho)
+        if df is None or df.empty:
+            continue
+
+        pontos = _coletar_pontos_modelo(df, limite_pontos_por_modelo)
+        if not pontos:
+            continue
+
+        cor = MAP_COLORS[idx % len(MAP_COLORS)]
+        nome = str(resumo.get("nome_modelo") or modelo_id)
+
+        modelos_plotados.append(
+            {
+                "id": modelo_id,
+                "nome": nome,
+                "cor": cor,
+                "total_pontos": len(pontos),
+                "pontos": pontos,
+            }
+        )
+        bounds.extend([[ponto["lat"], ponto["lon"]] for ponto in pontos])
+
+    if not modelos_plotados:
+        raise HTTPException(
+            status_code=400,
+            detail="Nao foi possivel gerar o mapa: os modelos selecionados nao possuem coordenadas validas",
+        )
+
+    centro_lat = sum(coord[0] for coord in bounds) / len(bounds)
+    centro_lon = sum(coord[1] for coord in bounds) / len(bounds)
+
+    mapa = folium.Map(
+        location=[centro_lat, centro_lon],
+        zoom_start=12,
+        control_scale=True,
+        tiles="CartoDB positron",
+    )
+
+    total_pontos = 0
+    for modelo in modelos_plotados:
+        total_pontos += int(modelo["total_pontos"])
+        camada = folium.FeatureGroup(name=f'{modelo["nome"]} ({modelo["total_pontos"]})', show=True)
+        for ponto in modelo["pontos"]:
+            folium.CircleMarker(
+                location=[ponto["lat"], ponto["lon"]],
+                radius=3,
+                color=modelo["cor"],
+                fill=True,
+                fill_color=modelo["cor"],
+                fill_opacity=0.72,
+                opacity=0.9,
+                weight=1,
+                tooltip=modelo["nome"],
+            ).add_to(camada)
+        camada.add_to(mapa)
+
+    folium.LayerControl(collapsed=False).add_to(mapa)
+    if bounds:
+        mapa.fit_bounds(bounds, padding=(20, 20))
+
+    return sanitize_value(
+        {
+            "mapa_html": mapa.get_root().render(),
+            "total_modelos_plotados": len(modelos_plotados),
+            "total_pontos": total_pontos,
+            "modelos_plotados": [
+                {
+                    "id": modelo["id"],
+                    "nome": modelo["nome"],
+                    "cor": modelo["cor"],
+                    "total_pontos": modelo["total_pontos"],
+                }
+                for modelo in modelos_plotados
+            ],
+            "status": f"Mapa gerado com {len(modelos_plotados)} modelo(s) e {total_pontos} ponto(s)",
+        }
+    )
+
+
+def _carregar_resumo_com_cache(caminho_modelo: Path) -> dict[str, Any]:
+    assinatura = _assinatura_arquivos(caminho_modelo)
+    cache_key = str(caminho_modelo)
+
+    with _CACHE_LOCK:
+        cached = _CACHE.get(cache_key)
+        if cached and cached.get("assinatura") == assinatura:
+            return dict(cached["resumo"])
+
+    resumo = _construir_resumo_modelo(caminho_modelo)
+
+    with _CACHE_LOCK:
+        _CACHE[cache_key] = {
+            "assinatura": assinatura,
+            "resumo": resumo,
+        }
+
+    return dict(resumo)
+
+
+def _assinatura_arquivos(caminho_modelo: Path) -> tuple[int, int]:
+    stat_modelo = caminho_modelo.stat()
+    return (stat_modelo.st_mtime_ns, stat_modelo.st_size)
+
+
+def _construir_resumo_modelo(caminho_modelo: Path) -> dict[str, Any]:
+    resumo = {
+        "id": caminho_modelo.stem,
+        "arquivo": caminho_modelo.name,
+        "nome_modelo": caminho_modelo.stem,
+        "autor": None,
+        "finalidade": _inferir_finalidade_por_nome(caminho_modelo.stem),
+        "finalidades": [],
+        "tipo_imovel": _inferir_tipo_por_nome(caminho_modelo.stem),
+        "bairros": [],
+        "faixa_area": None,
+        "faixa_rh": None,
+        "faixa_data": None,
+        "total_dados": None,
+        "total_trabalhos": None,
+        "endereco_referencia": None,
+        "equacao": None,
+        "r2": None,
+        "mapa_disponivel": False,
+        "compatibilidade_campos": {chave: [] for chave in COMPATIBILIDADE_MAP},
+        "faixas_por_campo": {chave: None for chave in RANGE_CAMPOS},
+        "variaveis_resumo": [],
+        "status": "ok",
+        "erro_leitura": None,
+        "fonte": {
+            "modelo": "dai",
+        },
+        "_texto_colunas_index": {},
+        "_faixa_colunas_index": {},
+    }
+
+    try:
+        pacote = load(caminho_modelo)
+    except Exception as exc:
+        resumo["status"] = "erro"
+        resumo["erro_leitura"] = f"Falha ao ler .dai: {exc}"
+        return resumo
+
+    if not isinstance(pacote, dict):
+        resumo["status"] = "erro"
+        resumo["erro_leitura"] = "Arquivo .dai invalido (conteudo nao e dict)."
+        return resumo
+
+    if "versao" not in pacote:
+        try:
+            pacote = _migrar_pacote_v1_para_v2(pacote)
+        except Exception:
+            pass
+
+    dados_pacote = pacote.get("dados") if isinstance(pacote.get("dados"), dict) else {}
+    estat_df = _to_dataframe(dados_pacote.get("estatisticas"))
+    df_modelo = _to_dataframe(dados_pacote.get("df_completo"))
+    if df_modelo is None:
+        df_modelo = _to_dataframe(dados_pacote.get("df"))
+
+    if resumo["autor"] is None:
+        resumo["autor"] = _autor_do_pacote(pacote)
+
+    if resumo["equacao"] is None:
+        resumo["equacao"] = _equacao_do_pacote(pacote)
+
+    if resumo["r2"] is None:
+        resumo["r2"] = _r2_do_pacote(pacote)
+
+    if resumo["total_dados"] is None and df_modelo is not None:
+        resumo["total_dados"] = int(len(df_modelo))
+
+    if not resumo["finalidades"] and df_modelo is not None:
+        resumo["finalidades"] = _extrair_finalidades(df_modelo)
+
+    if resumo["finalidade"] is None:
+        resumo["finalidade"] = resumo["finalidades"][0] if resumo["finalidades"] else None
+
+    if not resumo["bairros"] and df_modelo is not None:
+        resumo["bairros"] = _extrair_bairros(df_modelo)
+
+    faixas_por_campo = {
+        chave: _extrair_faixa_por_alias(estat_df, aliases)
+        for chave, aliases in RANGE_CAMPOS.items()
+    }
+    resumo["faixas_por_campo"] = faixas_por_campo
+
+    resumo["faixa_area"] = _merge_ranges(
+        resumo["faixa_area"],
+        _extrair_faixa_por_alias(estat_df, AREA_PRIVATIVA_ALIASES + AREA_TOTAL_ALIASES),
+    )
+    resumo["faixa_rh"] = _merge_ranges(resumo["faixa_rh"], _extrair_faixa_por_alias(estat_df, RH_ALIASES))
+
+    faixa_data_estat = _extrair_faixa_por_alias(estat_df, DATA_ALIASES)
+    if faixa_data_estat is None and df_modelo is not None:
+        faixa_data_estat = _extrair_faixa_data_dataframe(df_modelo)
+    resumo["faixa_data"] = _merge_ranges(resumo["faixa_data"], faixa_data_estat)
+
+    colunas_catalogo = _coletar_colunas_para_catalogo(estat_df, df_modelo)
+    resumo["compatibilidade_campos"] = _mapear_compatibilidade(colunas_catalogo)
+    resumo["variaveis_resumo"] = _resumo_variaveis(estat_df)
+    resumo["mapa_disponivel"] = _tem_colunas_mapa(df_modelo)
+    resumo["_texto_colunas_index"] = _indexar_texto_colunas(df_modelo)
+    resumo["_faixa_colunas_index"] = _indexar_faixas_colunas(df_modelo)
+
+    return resumo
+
+
+def _autor_do_pacote(pacote: dict[str, Any]) -> str | None:
+    elaborador = pacote.get("elaborador")
+    if isinstance(elaborador, dict):
+        return _str_or_none(elaborador.get("nome_completo")) or _str_or_none(elaborador.get("nome"))
+    return None
+
+
+def _equacao_do_pacote(pacote: dict[str, Any]) -> str | None:
+    modelo = pacote.get("modelo") if isinstance(pacote.get("modelo"), dict) else {}
+    diagnosticos = modelo.get("diagnosticos") if isinstance(modelo.get("diagnosticos"), dict) else {}
+    return _str_or_none(diagnosticos.get("equacao"))
+
+
+def _r2_do_pacote(pacote: dict[str, Any]) -> float | None:
+    modelo = pacote.get("modelo") if isinstance(pacote.get("modelo"), dict) else {}
+    diagnosticos = modelo.get("diagnosticos") if isinstance(modelo.get("diagnosticos"), dict) else {}
+    gerais = diagnosticos.get("gerais") if isinstance(diagnosticos.get("gerais"), dict) else {}
+    return _to_float_or_none(gerais.get("r2"))
+
+
+def _to_dataframe(value: Any) -> pd.DataFrame | None:
+    if value is None:
+        return None
+    if isinstance(value, pd.DataFrame):
+        return value.copy()
+    if isinstance(value, list):
+        try:
+            return pd.DataFrame(value)
+        except Exception:
+            return None
+    if isinstance(value, dict):
+        try:
+            return pd.DataFrame(value)
+        except Exception:
+            return None
+    return None
+
+
+def _carregar_dataframe_modelo(caminho_modelo: Path) -> pd.DataFrame | None:
+    try:
+        pacote = load(caminho_modelo)
+    except Exception:
+        return None
+
+    if not isinstance(pacote, dict):
+        return None
+
+    if "versao" not in pacote:
+        try:
+            pacote = _migrar_pacote_v1_para_v2(pacote)
+        except Exception:
+            return None
+
+    dados = pacote.get("dados") if isinstance(pacote.get("dados"), dict) else {}
+    df_modelo = _to_dataframe(dados.get("df_completo"))
+    if df_modelo is None:
+        df_modelo = _to_dataframe(dados.get("df"))
+    return df_modelo
+
+
+def _coletar_pontos_modelo(df_modelo: pd.DataFrame, limite_pontos: int) -> list[dict[str, float]]:
+    if df_modelo is None or df_modelo.empty:
+        return []
+
+    col_lat = _identificar_coluna_por_alias(df_modelo.columns, LAT_ALIASES)
+    col_lon = _identificar_coluna_por_alias(df_modelo.columns, LON_ALIASES)
+    if col_lat is None or col_lon is None:
+        return []
+
+    base = df_modelo[[col_lat, col_lon]].copy()
+    base[col_lat] = pd.to_numeric(base[col_lat], errors="coerce")
+    base[col_lon] = pd.to_numeric(base[col_lon], errors="coerce")
+    base = base.dropna(subset=[col_lat, col_lon])
+    if base.empty:
+        return []
+
+    base = base[(base[col_lat].between(-90, 90)) & (base[col_lon].between(-180, 180))]
+    if base.empty:
+        return []
+
+    if limite_pontos > 0 and len(base) > limite_pontos:
+        passo = max(1, math.ceil(len(base) / limite_pontos))
+        base = base.iloc[::passo].head(limite_pontos)
+
+    pontos: list[dict[str, float]] = []
+    for _, row in base.iterrows():
+        pontos.append({"lat": float(row[col_lat]), "lon": float(row[col_lon])})
+    return pontos
+
+
+def _identificar_coluna_por_alias(colunas: Any, aliases: list[str]) -> str | None:
+    for coluna in colunas:
+        nome = str(coluna)
+        if _has_alias(nome, aliases):
+            return nome
+    return None
+
+
+def _extrair_bairros(df: pd.DataFrame) -> list[str]:
+    candidatos = [col for col in df.columns if _has_alias(str(col), BAIRRO_ALIASES)]
+    bairros: set[str] = set()
+
+    for col in candidatos:
+        serie = df[col]
+        for valor in serie.dropna().head(5000):
+            texto = str(valor).strip()
+            if texto:
+                bairros.add(texto)
+        if len(bairros) >= 30:
+            break
+
+    return sorted(bairros)[:30]
+
+
+def _extrair_finalidades(df: pd.DataFrame) -> list[str]:
+    candidatos = [col for col in df.columns if _has_alias(str(col), FINALIDADE_ALIASES)]
+    finalidades: list[str] = []
+    vistos = set()
+
+    for col in candidatos:
+        serie = df[col]
+        for valor in serie.dropna().head(5000):
+            texto = str(valor).strip()
+            chave = _normalize(texto)
+            if not texto or not chave or chave in vistos:
+                continue
+            vistos.add(chave)
+            finalidades.append(texto)
+            if len(finalidades) >= 20:
+                break
+        if len(finalidades) >= 20:
+            break
+
+    return finalidades
+
+
+def _extrair_faixa_data_dataframe(df: pd.DataFrame) -> dict[str, Any] | None:
+    candidatos = [col for col in df.columns if _has_alias(str(col), DATA_ALIASES)]
+    for col in candidatos:
+        serie = pd.to_datetime(df[col], errors="coerce", dayfirst=True)
+        serie = serie.dropna()
+        if serie.empty:
+            continue
+        return {
+            "min": serie.min().date().isoformat(),
+            "max": serie.max().date().isoformat(),
+        }
+    return None
+
+
+def _extrair_faixa_por_alias(estat_df: pd.DataFrame | None, aliases: list[str]) -> dict[str, Any] | None:
+    if estat_df is None or estat_df.empty:
+        return None
+
+    estat_indexado = estat_df.copy()
+    if "Variável" in estat_indexado.columns:
+        estat_indexado = estat_indexado.set_index("Variável")
+
+    if estat_indexado.empty:
+        return None
+
+    min_col = _buscar_coluna(estat_indexado.columns, ["minimo", "mínimo", "min"])
+    max_col = _buscar_coluna(estat_indexado.columns, ["maximo", "máximo", "max"])
+    if min_col is None or max_col is None:
+        return None
+
+    mins: list[Any] = []
+    maxs: list[Any] = []
+
+    for var, linha in estat_indexado.iterrows():
+        nome = str(var)
+        if not _has_alias(nome, aliases):
+            continue
+        min_val = linha.get(min_col)
+        max_val = linha.get(max_col)
+        if _is_empty(min_val) or _is_empty(max_val):
+            continue
+        mins.append(min_val)
+        maxs.append(max_val)
+
+    if not mins and not maxs:
+        return None
+
+    return {
+        "min": _min_value(mins),
+        "max": _max_value(maxs),
+    }
+
+
+def _resumo_variaveis(estat_df: pd.DataFrame | None, limite: int = 12) -> list[dict[str, Any]]:
+    if estat_df is None or estat_df.empty:
+        return []
+
+    trabalho = estat_df.copy()
+    if "Variável" in trabalho.columns:
+        trabalho = trabalho.set_index("Variável")
+    if trabalho.empty:
+        return []
+
+    min_col = _buscar_coluna(trabalho.columns, ["minimo", "mínimo", "min"])
+    max_col = _buscar_coluna(trabalho.columns, ["maximo", "máximo", "max"])
+    if min_col is None or max_col is None:
+        return []
+
+    linhas: list[dict[str, Any]] = []
+    for var, linha in trabalho.iterrows():
+        min_val = linha.get(min_col)
+        max_val = linha.get(max_col)
+        if _is_empty(min_val) and _is_empty(max_val):
+            continue
+        linhas.append(
+            {
+                "variavel": str(var),
+                "min": sanitize_value(min_val),
+                "max": sanitize_value(max_val),
+            }
+        )
+        if len(linhas) >= limite:
+            break
+
+    return linhas
+
+
+def _coletar_colunas_para_catalogo(estat_df: pd.DataFrame | None, df: pd.DataFrame | None) -> list[str]:
+    nomes: list[str] = []
+    if estat_df is not None and not estat_df.empty:
+        if "Variável" in estat_df.columns:
+            nomes.extend([str(v) for v in estat_df["Variável"].dropna().tolist()])
+        else:
+            nomes.extend([str(v) for v in estat_df.index.tolist()])
+    if df is not None and not df.empty:
+        nomes.extend([str(v) for v in df.columns.tolist()])
+
+    unicos = []
+    vistos = set()
+    for nome in nomes:
+        chave = _normalize(nome)
+        if not chave or chave in vistos:
+            continue
+        vistos.add(chave)
+        unicos.append(nome)
+    return unicos
+
+
+def _mapear_compatibilidade(colunas: list[str]) -> dict[str, list[str]]:
+    out: dict[str, list[str]] = {}
+    for chave, aliases in COMPATIBILIDADE_MAP.items():
+        encontrados = [col for col in colunas if _has_alias(col, aliases)]
+        out[chave] = encontrados
+    return out
+
+
+def _tem_colunas_mapa(df: pd.DataFrame | None) -> bool:
+    if df is None or df.empty:
+        return False
+    nomes = [str(col) for col in df.columns]
+    tem_lat = any(_has_alias(col, LAT_ALIASES) for col in nomes)
+    tem_lon = any(_has_alias(col, LON_ALIASES) for col in nomes)
+    return tem_lat and tem_lon
+
+
+def _aceita_filtros(modelo: dict[str, Any], filtros: PesquisaFiltros) -> bool:
+    if filtros.nome and not _contains_any([modelo.get("nome_modelo"), modelo.get("arquivo")], filtros.nome):
+        return False
+
+    if filtros.autor and not _contains_any([modelo.get("autor")], filtros.autor):
+        return False
+
+    if filtros.finalidade and not _aceita_texto_com_colunas(modelo, filtros.finalidade, "finalidade", filtros.finalidade_colunas):
+        return False
+
+    if filtros.endereco and not _contains_any([modelo.get("endereco_referencia"), ", ".join(modelo.get("bairros") or [])], filtros.endereco):
+        return False
+
+    termos_bairro = _extrair_termos_bairro(filtros)
+    if termos_bairro:
+        for termo in termos_bairro:
+            if not _aceita_texto_com_colunas(modelo, termo, "bairros", filtros.bairros_colunas):
+                return False
+
+    if not _aceita_range_com_colunas(modelo, "area", filtros.area_colunas, filtros.area_min, filtros.area_max):
+        return False
+
+    if not _aceita_range_com_colunas(modelo, "rh", filtros.rh_colunas, filtros.rh_min, filtros.rh_max):
+        return False
+
+    if not _aceita_range_com_colunas(modelo, "data", filtros.data_colunas, filtros.data_min, filtros.data_max):
+        return False
+
+    return True
+
+
+def _normalizar_otica(value: str | None) -> str:
+    return "avaliando" if _normalize(value or "") == "avaliando" else "modelo"
+
+
+def _anexar_avaliando_info(modelo: dict[str, Any], filtros: PesquisaFiltros) -> dict[str, Any]:
+    item = dict(modelo)
+    checks: list[dict[str, Any]] = []
+    rejeicoes: list[str] = []
+
+    def registrar(campo: str, informado: Any, aceito: bool, detalhe: str) -> None:
+        check = {"campo": campo, "informado": sanitize_value(informado), "aceito": bool(aceito), "detalhe": detalhe}
+        checks.append(check)
+        if _is_provided(informado) and not aceito:
+            rejeicoes.append(f"{campo}: {detalhe}")
+
+    finalidade_info = filtros.aval_finalidade
+    if _is_provided(finalidade_info):
+        aceito = _aceita_texto_com_colunas(item, str(finalidade_info), "aval_finalidade", filtros.aval_finalidade_colunas)
+        registrar("finalidade", finalidade_info, aceito, "nao encontrada no modelo")
+
+    bairro_info = filtros.aval_bairro
+    if _is_provided(bairro_info):
+        aceito = _aceita_texto_com_colunas(item, str(bairro_info), "aval_bairro", filtros.aval_bairro_colunas)
+        registrar("bairro", bairro_info, aceito, "bairro fora da cobertura do modelo")
+
+    endereco_info = filtros.aval_endereco
+    if _is_provided(endereco_info):
+        candidatos = [item.get("endereco_referencia"), ", ".join(item.get("bairros") or [])]
+        aceito = _contains_any(candidatos, str(endereco_info))
+        registrar("endereco", endereco_info, aceito, "sem correspondencia textual no modelo")
+
+    faixa_data_ref = _faixa_resumo_com_colunas(item, "aval_data", filtros.aval_data_colunas)
+    registrar(
+        "data",
+        filtros.aval_data,
+        _aceita_valor_com_colunas(item, "aval_data", filtros.aval_data_colunas, filtros.aval_data),
+        f"fora da faixa {formatar_faixa(faixa_data_ref)}",
+    )
+    faixa_rh_ref = _faixa_resumo_com_colunas(item, "aval_rh", filtros.aval_rh_colunas)
+    registrar(
+        "rh",
+        filtros.aval_rh,
+        _aceita_valor_com_colunas(item, "aval_rh", filtros.aval_rh_colunas, filtros.aval_rh),
+        f"fora da faixa {formatar_faixa(faixa_rh_ref)}",
+    )
+    faixa_area_ref = _faixa_resumo_com_colunas(item, "aval_area", filtros.aval_area_colunas)
+    registrar(
+        "area",
+        filtros.aval_area,
+        _aceita_valor_com_colunas(item, "aval_area", filtros.aval_area_colunas, filtros.aval_area),
+        f"fora da faixa {formatar_faixa(faixa_area_ref)}",
+    )
+
+    faixa_area_priv = _faixa_resumo_com_colunas(item, "aval_area_privativa", filtros.aval_area_privativa_colunas)
+    faixa_area_total = _faixa_resumo_com_colunas(item, "aval_area_total", filtros.aval_area_total_colunas)
+    faixa_valor_unit = _faixa_resumo_com_colunas(item, "aval_valor_unitario", filtros.aval_valor_unitario_colunas)
+    faixa_valor_tot = _faixa_resumo_com_colunas(item, "aval_valor_total", filtros.aval_valor_total_colunas)
+
+    registrar(
+        "area_privativa",
+        filtros.aval_area_privativa,
+        _aceita_valor_com_colunas(item, "aval_area_privativa", filtros.aval_area_privativa_colunas, filtros.aval_area_privativa),
+        f"fora da faixa {formatar_faixa(faixa_area_priv)}",
+    )
+    registrar(
+        "area_total",
+        filtros.aval_area_total,
+        _aceita_valor_com_colunas(item, "aval_area_total", filtros.aval_area_total_colunas, filtros.aval_area_total),
+        f"fora da faixa {formatar_faixa(faixa_area_total)}",
+    )
+    registrar(
+        "valor_unitario",
+        filtros.aval_valor_unitario,
+        _aceita_valor_com_colunas(item, "aval_valor_unitario", filtros.aval_valor_unitario_colunas, filtros.aval_valor_unitario),
+        f"fora da faixa {formatar_faixa(faixa_valor_unit)}",
+    )
+    registrar(
+        "valor_total",
+        filtros.aval_valor_total,
+        _aceita_valor_com_colunas(item, "aval_valor_total", filtros.aval_valor_total_colunas, filtros.aval_valor_total),
+        f"fora da faixa {formatar_faixa(faixa_valor_tot)}",
+    )
+
+    checks_informados = [check for check in checks if _is_provided(check.get("informado"))]
+    aceito = all(check.get("aceito") for check in checks_informados) if checks_informados else True
+
+    item["avaliando"] = {
+        "aceito": bool(aceito),
+        "checks": checks,
+        "motivos_rejeicao": rejeicoes,
+        "campos_informados": len(checks_informados),
+    }
+    return item
+
+
+def _extrair_sugestoes(modelos: list[dict[str, Any]], limite: int = 200) -> dict[str, list[str]]:
+    nomes: list[str] = []
+    autores: list[str] = []
+    finalidades: list[str] = []
+    bairros: list[str] = []
+    enderecos: list[str] = []
+
+    for modelo in modelos:
+        nomes.append(str(modelo.get("nome_modelo") or ""))
+        nomes.append(str(modelo.get("arquivo") or ""))
+        autores.append(str(modelo.get("autor") or ""))
+        finalidades.append(str(modelo.get("finalidade") or ""))
+        finalidades.extend([str(item) for item in (modelo.get("finalidades") or [])])
+        bairros.extend([str(item) for item in (modelo.get("bairros") or [])])
+        enderecos.append(str(modelo.get("endereco_referencia") or ""))
+
+    return {
+        "nomes_modelo": _lista_textos_unicos(nomes, limite),
+        "autores": _lista_textos_unicos(autores, limite),
+        "finalidades": _lista_textos_unicos(finalidades, limite),
+        "bairros": _lista_textos_unicos(bairros, limite),
+        "enderecos": _lista_textos_unicos(enderecos, limite),
+    }
+
+
+def _modelo_publico(modelo: dict[str, Any]) -> dict[str, Any]:
+    return {chave: valor for chave, valor in modelo.items() if not str(chave).startswith("_")}
+
+
+def _montar_config_colunas_filtro(modelos: list[dict[str, Any]]) -> dict[str, Any]:
+    todas_colunas_texto = set()
+    todas_colunas_faixa = set()
+    for modelo in modelos:
+        indice_texto = modelo.get("_texto_colunas_index") or {}
+        if isinstance(indice_texto, dict):
+            todas_colunas_texto.update([str(col) for col in indice_texto.keys()])
+        indice_faixa = modelo.get("_faixa_colunas_index") or {}
+        if isinstance(indice_faixa, dict):
+            todas_colunas_faixa.update([str(col) for col in indice_faixa.keys()])
+
+    colunas_texto_ordenadas = sorted(todas_colunas_texto, key=lambda item: item.lower())
+    colunas_faixa_ordenadas = sorted(todas_colunas_faixa, key=lambda item: item.lower())
+    config: dict[str, Any] = {}
+
+    campos = list(CAMPO_TEXTO_META_FONTES.keys()) + [campo for campo in CAMPO_FAIXA_META_FONTES.keys() if campo not in CAMPO_TEXTO_META_FONTES]
+
+    for campo in campos:
+        if campo in CAMPO_TEXTO_META_FONTES:
+            meta_fontes = list(CAMPO_TEXTO_META_FONTES.get(campo, []))
+            aliases = CAMPO_TEXTO_ALIASES_COLUNA.get(campo, [])
+            colunas_ordenadas = colunas_texto_ordenadas
+        else:
+            meta_fontes = list(CAMPO_FAIXA_META_FONTES.get(campo, []))
+            aliases = CAMPO_FAIXA_ALIASES_COLUNA.get(campo, [])
+            colunas_ordenadas = colunas_faixa_ordenadas
+
+        disponiveis = [{"id": fonte, "label": FONTE_META_LABELS.get(fonte, fonte)} for fonte in meta_fontes]
+        disponiveis.extend([{"id": f"col:{col}", "label": col} for col in colunas_ordenadas])
+
+        padrao = list(meta_fontes)
+        for col in colunas_ordenadas:
+            if _has_alias(col, aliases):
+                padrao.append(f"col:{col}")
+
+        config[campo] = {
+            "disponiveis": disponiveis,
+            "padrao": _dedupe_strings(padrao),
+        }
+
+    return config
+
+
+def _dedupe_strings(values: list[str]) -> list[str]:
+    out: list[str] = []
+    seen = set()
+    for value in values:
+        text = str(value).strip()
+        if not text or text in seen:
+            continue
+        seen.add(text)
+        out.append(text)
+    return out
+
+
+def _aceita_texto_com_colunas(modelo: dict[str, Any], consulta: str, campo: str, fontes_selecionadas: list[str] | None) -> bool:
+    fontes = _resolver_fontes_campo(modelo, campo, fontes_selecionadas)
+    candidatos = _valores_para_fontes(modelo, fontes)
+    return _contains_any(candidatos, consulta)
+
+
+def _aceita_range_com_colunas(
+    modelo: dict[str, Any],
+    campo: str,
+    fontes_selecionadas: list[str] | None,
+    filtro_min: Any,
+    filtro_max: Any,
+) -> bool:
+    if filtro_min is None and filtro_max is None:
+        return True
+    faixas = _faixas_para_campo(modelo, campo, fontes_selecionadas)
+    if not faixas:
+        return False
+    return any(_range_overlaps(faixa, filtro_min, filtro_max) for faixa in faixas)
+
+
+def _aceita_valor_com_colunas(
+    modelo: dict[str, Any],
+    campo: str,
+    fontes_selecionadas: list[str] | None,
+    valor: Any,
+) -> bool:
+    if not _is_provided(valor):
+        return True
+    return _aceita_range_com_colunas(modelo, campo, fontes_selecionadas, valor, valor)
+
+
+def _faixa_resumo_com_colunas(modelo: dict[str, Any], campo: str, fontes_selecionadas: list[str] | None) -> dict[str, Any] | None:
+    faixas = _faixas_para_campo(modelo, campo, fontes_selecionadas)
+    return _combinar_faixas(faixas)
+
+
+def _faixas_para_campo(modelo: dict[str, Any], campo: str, fontes_selecionadas: list[str] | None) -> list[dict[str, Any]]:
+    fontes = _resolver_fontes_faixa(modelo, campo, fontes_selecionadas)
+    return _faixas_para_fontes(modelo, fontes)
+
+
+def _resolver_fontes_campo(modelo: dict[str, Any], campo: str, fontes_selecionadas: list[str] | None) -> list[str]:
+    base = _dedupe_strings([str(item) for item in (fontes_selecionadas or [])])
+    if base:
+        return base
+
+    fontes = list(CAMPO_TEXTO_META_FONTES.get(campo, []))
+    aliases = CAMPO_TEXTO_ALIASES_COLUNA.get(campo, [])
+    indice = modelo.get("_texto_colunas_index") or {}
+    if isinstance(indice, dict):
+        for col in indice.keys():
+            col_text = str(col)
+            if _has_alias(col_text, aliases):
+                fontes.append(f"col:{col_text}")
+    return _dedupe_strings(fontes)
+
+
+def _resolver_fontes_faixa(modelo: dict[str, Any], campo: str, fontes_selecionadas: list[str] | None) -> list[str]:
+    base = _dedupe_strings([str(item) for item in (fontes_selecionadas or [])])
+    if base:
+        return base
+
+    fontes = list(CAMPO_FAIXA_META_FONTES.get(campo, []))
+    aliases = CAMPO_FAIXA_ALIASES_COLUNA.get(campo, [])
+    indice = modelo.get("_faixa_colunas_index") or {}
+    if isinstance(indice, dict):
+        for col in indice.keys():
+            col_text = str(col)
+            if _has_alias(col_text, aliases):
+                fontes.append(f"col:{col_text}")
+    return _dedupe_strings(fontes)
+
+
+def _valores_para_fontes(modelo: dict[str, Any], fontes: list[str]) -> list[str]:
+    candidatos: list[str] = []
+    indice_colunas = modelo.get("_texto_colunas_index") or {}
+    if not isinstance(indice_colunas, dict):
+        indice_colunas = {}
+
+    for fonte in fontes:
+        if fonte.startswith("meta:"):
+            candidatos.extend(_valores_meta(modelo, fonte))
+            continue
+        if fonte.startswith("col:"):
+            col = fonte[4:]
+            valores = indice_colunas.get(col) or []
+            candidatos.extend([str(item) for item in valores if _str_or_none(item)])
+
+    return candidatos
+
+
+def _valores_meta(modelo: dict[str, Any], fonte: str) -> list[str]:
+    if fonte == "meta:nome_modelo":
+        return [str(modelo.get("nome_modelo") or "")]
+    if fonte == "meta:arquivo":
+        return [str(modelo.get("arquivo") or "")]
+    if fonte == "meta:autor":
+        return [str(modelo.get("autor") or "")]
+    if fonte == "meta:finalidade":
+        return [str(modelo.get("finalidade") or "")]
+    if fonte == "meta:tipo_imovel":
+        return [str(modelo.get("tipo_imovel") or "")]
+    if fonte == "meta:finalidades":
+        return [str(item) for item in (modelo.get("finalidades") or [])]
+    if fonte == "meta:bairros":
+        return [str(item) for item in (modelo.get("bairros") or [])]
+    if fonte == "meta:endereco_referencia":
+        return [str(modelo.get("endereco_referencia") or "")]
+    return []
+
+
+def _faixas_para_fontes(modelo: dict[str, Any], fontes: list[str]) -> list[dict[str, Any]]:
+    candidatos: list[dict[str, Any]] = []
+    indice_colunas = modelo.get("_faixa_colunas_index") or {}
+    if not isinstance(indice_colunas, dict):
+        indice_colunas = {}
+
+    for fonte in fontes:
+        faixa: dict[str, Any] | None = None
+        if fonte.startswith("meta:"):
+            faixa = _faixa_meta(modelo, fonte)
+        elif fonte.startswith("col:"):
+            faixa = indice_colunas.get(fonte[4:])
+        if not isinstance(faixa, dict):
+            continue
+        if _is_empty(faixa.get("min")) and _is_empty(faixa.get("max")):
+            continue
+        candidatos.append(faixa)
+
+    return candidatos
+
+
+def _faixa_meta(modelo: dict[str, Any], fonte: str) -> dict[str, Any] | None:
+    if fonte == "meta:faixa_data":
+        return modelo.get("faixa_data")
+    if fonte == "meta:faixa_area":
+        return modelo.get("faixa_area")
+    if fonte == "meta:faixa_rh":
+        return modelo.get("faixa_rh")
+
+    faixas_por_campo = modelo.get("faixas_por_campo") or {}
+    if not isinstance(faixas_por_campo, dict):
+        faixas_por_campo = {}
+
+    if fonte == "meta:faixa_area_privativa":
+        return faixas_por_campo.get("area_privativa")
+    if fonte == "meta:faixa_area_total":
+        return faixas_por_campo.get("area_total")
+    if fonte == "meta:faixa_valor_unitario":
+        return faixas_por_campo.get("valor_unitario")
+    if fonte == "meta:faixa_valor_total":
+        return faixas_por_campo.get("valor_total")
+    return None
+
+
+def _combinar_faixas(faixas: list[dict[str, Any]]) -> dict[str, Any] | None:
+    kind: str | None = None
+    min_vals: list[Any] = []
+    max_vals: list[Any] = []
+
+    for faixa in faixas:
+        cmp_min = _to_comparable(faixa.get("min"))
+        cmp_max = _to_comparable(faixa.get("max"))
+        faixa_kind = cmp_min[0] if cmp_min is not None else (cmp_max[0] if cmp_max is not None else None)
+        if faixa_kind is None:
+            continue
+        if kind is None:
+            kind = faixa_kind
+        if faixa_kind != kind:
+            continue
+        if cmp_min is not None:
+            min_vals.append(cmp_min[1])
+        if cmp_max is not None:
+            max_vals.append(cmp_max[1])
+
+    if not min_vals and not max_vals:
+        return None
+
+    minimo = min(min_vals) if min_vals else None
+    maximo = max(max_vals) if max_vals else None
+    return {
+        "min": _formatar_limite_faixa(minimo),
+        "max": _formatar_limite_faixa(maximo),
+    }
+
+
+def _formatar_limite_faixa(valor: Any) -> Any:
+    if valor is None:
+        return None
+    if isinstance(valor, datetime):
+        return valor.date().isoformat()
+    return sanitize_value(valor)
+
+
+def _indexar_texto_colunas(df_modelo: pd.DataFrame | None) -> dict[str, list[str]]:
+    if df_modelo is None or df_modelo.empty:
+        return {}
+
+    indice: dict[str, list[str]] = {}
+    colunas = [str(col) for col in df_modelo.columns[:MAX_COLUNAS_INDEXADAS]]
+    base = df_modelo[colunas].head(MAX_LINHAS_INDEXACAO)
+
+    for coluna in colunas:
+        serie = base[coluna]
+        valores: list[str] = []
+        vistos = set()
+        for valor in serie.dropna().tolist():
+            texto = _str_or_none(valor)
+            if texto is None and isinstance(valor, (int, float)):
+                texto = str(valor)
+            if texto is None:
+                continue
+            chave = _normalize(texto)
+            if not chave or chave in vistos:
+                continue
+            vistos.add(chave)
+            valores.append(texto)
+            if len(valores) >= MAX_VALORES_INDEXADOS_POR_COLUNA:
+                break
+        if valores:
+            indice[coluna] = valores
+
+    return indice
+
+
+def _indexar_faixas_colunas(df_modelo: pd.DataFrame | None) -> dict[str, dict[str, Any]]:
+    if df_modelo is None or df_modelo.empty:
+        return {}
+
+    indice: dict[str, dict[str, Any]] = {}
+    colunas = [str(col) for col in df_modelo.columns[:MAX_COLUNAS_INDEXADAS]]
+    base = df_modelo[colunas].head(MAX_LINHAS_INDEXACAO)
+
+    for coluna in colunas:
+        faixa = _extrair_faixa_serie(base[coluna])
+        if faixa is not None:
+            indice[coluna] = faixa
+
+    return indice
+
+
+def _extrair_faixa_serie(serie: pd.Series) -> dict[str, Any] | None:
+    serie_limpa = serie.dropna()
+    if serie_limpa.empty:
+        return None
+
+    total = len(serie_limpa)
+    minimo_amostras = min(3, total)
+
+    serie_num = pd.to_numeric(serie_limpa, errors="coerce").dropna()
+    if len(serie_num) >= minimo_amostras and (len(serie_num) / total) >= 0.6:
+        return {
+            "min": sanitize_value(serie_num.min()),
+            "max": sanitize_value(serie_num.max()),
+        }
+
+    serie_data = pd.to_datetime(serie_limpa, errors="coerce", dayfirst=True).dropna()
+    if len(serie_data) >= minimo_amostras and (len(serie_data) / total) >= 0.6:
+        return {
+            "min": serie_data.min().date().isoformat(),
+            "max": serie_data.max().date().isoformat(),
+        }
+
+    return None
+
+
+def _lista_textos_unicos(valores: list[str], limite: int) -> list[str]:
+    unicos: list[str] = []
+    vistos = set()
+    for valor in valores:
+        texto = _str_or_none(valor)
+        if not texto:
+            continue
+        chave = _normalize(texto)
+        if not chave or chave in vistos:
+            continue
+        vistos.add(chave)
+        unicos.append(texto)
+        if len(unicos) >= limite:
+            break
+    return sorted(unicos, key=lambda item: item.lower())
+
+
+def _aceita_valor_na_faixa(faixa: dict[str, Any] | None, valor: Any) -> bool:
+    if not _is_provided(valor):
+        return True
+    return _range_overlaps(faixa, valor, valor)
+
+
+def formatar_faixa(faixa: dict[str, Any] | None) -> str:
+    if not faixa:
+        return "nao disponivel"
+    minimo = faixa.get("min")
+    maximo = faixa.get("max")
+    if _is_empty(minimo) and _is_empty(maximo):
+        return "nao disponivel"
+    if not _is_empty(minimo) and not _is_empty(maximo):
+        return f"{minimo} a {maximo}"
+    if not _is_empty(minimo):
+        return f"a partir de {minimo}"
+    return f"ate {maximo}"
+
+
+def _extrair_termos_bairro(filtros: PesquisaFiltros) -> list[str]:
+    termos: list[str] = []
+    if filtros.bairro:
+        termos.extend(_split_terms(filtros.bairro))
+    if filtros.bairros:
+        for entrada in filtros.bairros:
+            termos.extend(_split_terms(entrada))
+
+    limpos = []
+    vistos = set()
+    for termo in termos:
+        chave = _normalize(termo)
+        if not chave or chave in vistos:
+            continue
+        vistos.add(chave)
+        limpos.append(termo)
+    return limpos
+
+
+def _split_terms(texto: str) -> list[str]:
+    if not texto:
+        return []
+    partes = re.split(r"[,;|]", texto)
+    return [parte.strip() for parte in partes if parte.strip()]
+
+
+def _range_overlaps(model_range: dict[str, Any] | None, filtro_min: Any, filtro_max: Any) -> bool:
+    if filtro_min is None and filtro_max is None:
+        return True
+
+    if not model_range:
+        return False
+
+    model_min_cmp = _to_comparable(model_range.get("min"))
+    model_max_cmp = _to_comparable(model_range.get("max"))
+    filtro_min_cmp = _to_comparable(filtro_min) if filtro_min is not None else None
+    filtro_max_cmp = _to_comparable(filtro_max) if filtro_max is not None else None
+
+    if filtro_min_cmp is None and filtro_max_cmp is None:
+        return True
+
+    kinds = {
+        item[0]
+        for item in [model_min_cmp, model_max_cmp, filtro_min_cmp, filtro_max_cmp]
+        if item is not None
+    }
+
+    if len(kinds) != 1:
+        return False
+
+    model_min_val = model_min_cmp[1] if model_min_cmp is not None else None
+    model_max_val = model_max_cmp[1] if model_max_cmp is not None else None
+    filtro_min_val = filtro_min_cmp[1] if filtro_min_cmp is not None else None
+    filtro_max_val = filtro_max_cmp[1] if filtro_max_cmp is not None else None
+
+    if model_min_val is None and model_max_val is None:
+        return False
+
+    if model_min_val is None:
+        model_min_val = model_max_val
+    if model_max_val is None:
+        model_max_val = model_min_val
+
+    if filtro_min_val is not None and model_max_val < filtro_min_val:
+        return False
+
+    if filtro_max_val is not None and model_min_val > filtro_max_val:
+        return False
+
+    return True
+
+
+def _to_comparable(value: Any) -> tuple[str, Any] | None:
+    if value is None:
+        return None
+
+    if isinstance(value, (int, float)):
+        if isinstance(value, float) and (math.isnan(value) or math.isinf(value)):
+            return None
+        return ("num", float(value))
+
+    if isinstance(value, pd.Timestamp):
+        return ("dt", value.to_pydatetime())
+
+    if isinstance(value, datetime):
+        return ("dt", value)
+
+    if isinstance(value, date):
+        return ("dt", datetime(value.year, value.month, value.day))
+
+    texto = str(value).strip()
+    if not texto:
+        return None
+
+    numero = _to_float_or_none(texto)
+    if numero is not None:
+        return ("num", float(numero))
+
+    data_val = _parse_datetime(texto)
+    if data_val is not None:
+        return ("dt", data_val)
+
+    return None
+
+
+def _parse_datetime(texto: str) -> datetime | None:
+    for fmt in ("%Y-%m-%d", "%d/%m/%Y", "%Y/%m/%d", "%Y%m%d", "%Y"):
+        try:
+            return datetime.strptime(texto, fmt)
+        except Exception:
+            continue
+    return None
+
+
+def _contains_any(candidatos: list[Any], consulta: str) -> bool:
+    alvo = _normalize(consulta)
+    if not alvo:
+        return True
+    for item in candidatos:
+        if item is None:
+            continue
+        if alvo in _normalize(str(item)):
+            return True
+    return False
+
+
+def _merge_ranges(preferencial: dict[str, Any] | None, fallback: dict[str, Any] | None) -> dict[str, Any] | None:
+    if not preferencial and not fallback:
+        return None
+    if not preferencial:
+        return fallback
+    if not fallback:
+        return preferencial
+
+    min_final = preferencial.get("min") if not _is_empty(preferencial.get("min")) else fallback.get("min")
+    max_final = preferencial.get("max") if not _is_empty(preferencial.get("max")) else fallback.get("max")
+
+    if _is_empty(min_final) and _is_empty(max_final):
+        return None
+
+    return {"min": sanitize_value(min_final), "max": sanitize_value(max_final)}
+
+
+def _buscar_coluna(colunas: Any, aliases: list[str]) -> Any:
+    for coluna in colunas:
+        if _has_alias(str(coluna), aliases):
+            return coluna
+    return None
+
+
+def _has_alias(nome: str, aliases: list[str]) -> bool:
+    nome_norm = _normalize(nome)
+    if not nome_norm:
+        return False
+
+    for alias in aliases:
+        alias_norm = _normalize(alias)
+        if alias_norm == nome_norm or alias_norm in nome_norm:
+            return True
+    return False
+
+
+def _normalize(value: str) -> str:
+    ascii_text = unicodedata.normalize("NFKD", str(value)).encode("ascii", "ignore").decode("ascii")
+    ascii_text = ascii_text.lower().strip()
+    return re.sub(r"[^a-z0-9]+", "", ascii_text)
+
+
+def _min_value(values: list[Any]) -> Any:
+    comparaveis = [_to_comparable(v) for v in values]
+    comparaveis = [c for c in comparaveis if c is not None]
+    if not comparaveis:
+        return sanitize_value(values[0]) if values else None
+    kind = comparaveis[0][0]
+    valores = [c[1] for c in comparaveis if c[0] == kind]
+    menor = min(valores)
+    if isinstance(menor, datetime):
+        return menor.date().isoformat()
+    return sanitize_value(menor)
+
+
+def _max_value(values: list[Any]) -> Any:
+    comparaveis = [_to_comparable(v) for v in values]
+    comparaveis = [c for c in comparaveis if c is not None]
+    if not comparaveis:
+        return sanitize_value(values[0]) if values else None
+    kind = comparaveis[0][0]
+    valores = [c[1] for c in comparaveis if c[0] == kind]
+    maior = max(valores)
+    if isinstance(maior, datetime):
+        return maior.date().isoformat()
+    return sanitize_value(maior)
+
+
+def _inferir_finalidade_por_nome(nome_arquivo: str) -> str | None:
+    nome_upper = nome_arquivo.upper()
+    if re.search(r"(^|_)A(_|$)", nome_upper) or "ALUG" in nome_upper:
+        return "Aluguel"
+    if re.search(r"(^|_)V(_|$)", nome_upper) or "VENDA" in nome_upper:
+        return "Venda"
+    return None
+
+
+def _inferir_tipo_por_nome(nome_arquivo: str) -> str | None:
+    nome_upper = nome_arquivo.upper()
+    tokens_ordenados = sorted(TIPO_POR_TOKEN.items(), key=lambda item: len(item[0]), reverse=True)
+    for token, tipo in tokens_ordenados:
+        if _contains_tipo_token(nome_upper, token):
+            return tipo
+    return None
+
+
+def _contains_tipo_token(nome_upper: str, token: str) -> bool:
+    padrao = rf"(^|[^A-Z]){re.escape(token)}([^A-Z]|$)"
+    return re.search(padrao, nome_upper) is not None
+
+
+def _to_float_or_none(value: Any) -> float | None:
+    if value is None:
+        return None
+
+    if isinstance(value, bool):
+        return None
+
+    if isinstance(value, (int, float)):
+        if isinstance(value, float) and (math.isnan(value) or math.isinf(value)):
+            return None
+        return float(value)
+
+    texto = str(value).strip()
+    if not texto:
+        return None
+
+    if "," in texto and "." in texto:
+        if texto.rfind(",") > texto.rfind("."):
+            texto = texto.replace(".", "").replace(",", ".")
+        else:
+            texto = texto.replace(",", "")
+    else:
+        texto = texto.replace(",", ".")
+
+    try:
+        return float(texto)
+    except Exception:
+        return None
+
+
+def _str_or_none(value: Any) -> str | None:
+    if value is None:
+        return None
+    texto = str(value).strip()
+    return texto or None
+
+
+def _is_empty(value: Any) -> bool:
+    if value is None:
+        return True
+    if isinstance(value, str) and not value.strip():
+        return True
+    try:
+        if pd.isna(value):
+            return True
+    except Exception:
+        pass
+    return False
+
+
+def _is_provided(value: Any) -> bool:
+    if value is None:
+        return False
+    if isinstance(value, str):
+        return bool(value.strip())
+    return True

frontend/src/App.jsx

@@ -1,10 +1,11 @@
 import React, { useEffect, useState } from 'react'
 import { api } from './api'
 import ElaboracaoTab from './components/ElaboracaoTab'
+import PesquisaTab from './components/PesquisaTab'
 import VisualizacaoTab from './components/VisualizacaoTab'
 
 const TABS = [
-  { key: 'Pesquisa', label: 'Pesquisa', hint: 'Módulo em desenvolvimento' },
+  { key: 'Pesquisa', label: 'Pesquisa', hint: 'Busca inicial de modelos .dai' },
   { key: 'Elaboração/Edição', label: 'Elaboração/Edição', hint: 'Fluxo completo de modelagem' },
   { key: 'Visualização/Avaliação', label: 'Visualização/Avaliação', hint: 'Leitura e avaliação de modelos .dai' },
 ]
@@ -58,18 +59,9 @@ export default function App() {
       {bootError ? <div className="error-line">Falha ao criar sessão: {bootError}</div> : null}
 
       {activeTab === 'Pesquisa' ? (
-        <section className="workflow-section placeholder-section" style={{ '--section-order': 1 }}>
-          <header className="section-head">
-            <span className="section-index">1</span>
-            <div className="section-title-wrap">
-              <h3>Pesquisa</h3>
-              <p>Este módulo segue em desenvolvimento no app original e foi mantido com o mesmo status.</p>
-            </div>
-          </header>
-          <div className="section-body">
-            <div className="empty-box">Aba disponível para expansão futura.</div>
-          </div>
-        </section>
+        <div className="tab-pane">
+          <PesquisaTab />
+        </div>
       ) : null}
 
       <div className="tab-pane" hidden={activeTab !== 'Elaboração/Edição'}>

frontend/src/api.js

@@ -59,6 +59,21 @@ export function downloadBlob(blob, fileName) {
 export const api = {
   createSession: () => postJson('/api/sessions', {}),
 
+  pesquisarModelos(filtros = {}) {
+    const params = new URLSearchParams()
+    Object.entries(filtros).forEach(([key, value]) => {
+      if (value === null || value === undefined) return
+      const text = String(value).trim()
+      if (!text) return
+      params.append(key, text)
+    })
+    const query = params.toString()
+    return getJson(query ? `/api/pesquisa/modelos?${query}` : '/api/pesquisa/modelos')
+  },
+  pesquisarMapaModelos(modelosIds = []) {
+    return postJson('/api/pesquisa/mapa-modelos', { modelos_ids: modelosIds })
+  },
+
   uploadElaboracaoFile(sessionId, file) {
     const form = new FormData()
     form.append('session_id', sessionId)

frontend/src/components/PesquisaTab.jsx

@@ -0,0 +1,1113 @@
+import React, { useEffect, useMemo, useRef, useState } from 'react'
+import { api } from '../api'
+import MapFrame from './MapFrame'
+import SectionBlock from './SectionBlock'
+
+const EMPTY_FILTERS = {
+  otica: 'modelo',
+  nome: '',
+  autor: '',
+  finalidade: '',
+  bairros: '',
+  dataMin: '',
+  dataMax: '',
+  areaMin: '',
+  areaMax: '',
+  rhMin: '',
+  rhMax: '',
+  avalFinalidade: '',
+  avalBairro: '',
+  avalData: '',
+  avalArea: '',
+  avalAreaPrivativa: '',
+  avalAreaTotal: '',
+  avalRh: '',
+  avalValorUnitario: '',
+  avalValorTotal: '',
+}
+
+const RESULT_INITIAL = {
+  modelos: [],
+  sugestoes: {},
+  total_filtrado: 0,
+  total_geral: 0,
+}
+
+const CAMPOS_COLUNAS_FILTRO = [
+  'finalidade',
+  'bairros',
+  'data',
+  'area',
+  'rh',
+  'aval_finalidade',
+  'aval_bairro',
+  'aval_data',
+  'aval_area',
+  'aval_area_privativa',
+  'aval_area_total',
+  'aval_rh',
+  'aval_valor_unitario',
+  'aval_valor_total',
+]
+
+const COLUNAS_FILTRO_INITIAL = {
+  finalidade: [],
+  bairros: [],
+  data: [],
+  area: [],
+  rh: [],
+  aval_finalidade: [],
+  aval_bairro: [],
+  aval_data: [],
+  aval_area: [],
+  aval_area_privativa: [],
+  aval_area_total: [],
+  aval_rh: [],
+  aval_valor_unitario: [],
+  aval_valor_total: [],
+}
+
+const TIPO_SIGLAS = {
+  RECOND: 'Residencia em condominio',
+  RCOMD: 'Residencia em condominio',
+  TCOND: 'Terreno em condominio',
+  SALA: 'Salas comerciais',
+  APTO: 'Apartamentos residenciais',
+  APART: 'Apartamentos residenciais',
+  AP: 'Apartamentos residenciais',
+  TERRENO: 'Terrenos',
+  TER: 'Terrenos',
+  EDIF: 'Edificio',
+  RES: 'Residencias isoladas / casas',
+  CASA: 'Residencias isoladas / casas',
+  LOJA: 'Loja',
+  LCOM: 'Loja',
+  DEP: 'Deposito',
+  DEPOS: 'Deposito',
+  CCOM: 'Casa comercial',
+}
+
+function formatRange(range) {
+  if (!range) return '-'
+  const min = range.min ?? null
+  const max = range.max ?? null
+  if (min === null && max === null) return '-'
+  if (min !== null && max !== null) return `${min} a ${max}`
+  if (min !== null) return `a partir de ${min}`
+  return `ate ${max}`
+}
+
+function formatCount(value) {
+  if (value === null || value === undefined || value === '') return '-'
+  if (typeof value === 'number') {
+    return new Intl.NumberFormat('pt-BR').format(value)
+  }
+  return String(value)
+}
+
+function normalizeTokenText(value) {
+  return String(value || '')
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toUpperCase()
+}
+
+function inferTipoPorNomeModelo(...nomes) {
+  const tokens = Object.keys(TIPO_SIGLAS).sort((a, b) => b.length - a.length)
+  for (const nome of nomes) {
+    const source = normalizeTokenText(nome)
+    if (!source) continue
+    for (const token of tokens) {
+      const re = new RegExp(`(^|[^A-Z])${token}([^A-Z]|$)`)
+      if (re.test(source)) {
+        return TIPO_SIGLAS[token]
+      }
+    }
+  }
+  return ''
+}
+
+function formatTipoImovel(modelo) {
+  const tipoPorNome = inferTipoPorNomeModelo(modelo?.nome_modelo, modelo?.arquivo)
+  if (tipoPorNome) return tipoPorNome
+
+  const text = String(modelo?.tipo_imovel || '').trim()
+  if (!text) return '-'
+
+  const mapped = TIPO_SIGLAS[normalizeTokenText(text)]
+  return mapped || text
+}
+
+function normalizeColunasConfig(rawConfig = {}) {
+  const out = {}
+  CAMPOS_COLUNAS_FILTRO.forEach((campo) => {
+    const config = rawConfig?.[campo] || {}
+    const disponiveis = []
+    const vistos = new Set()
+    ;(Array.isArray(config.disponiveis) ? config.disponiveis : []).forEach((item) => {
+      const id = typeof item === 'string' ? item : item?.id
+      const label = typeof item === 'string' ? item : item?.label || item?.id
+      const idText = String(id || '').trim()
+      if (!idText || vistos.has(idText)) return
+      vistos.add(idText)
+      disponiveis.push({ id: idText, label: String(label || idText) })
+    })
+
+    const padrao = []
+    ;(Array.isArray(config.padrao) ? config.padrao : []).forEach((item) => {
+      const idText = String(item || '').trim()
+      if (!idText || !vistos.has(idText) || padrao.includes(idText)) return
+      padrao.push(idText)
+    })
+
+    out[campo] = { disponiveis, padrao }
+  })
+  return out
+}
+
+function reconciliarColunasSelecionadas(atual, configNormalizada, camposEditados = {}) {
+  const next = { ...COLUNAS_FILTRO_INITIAL, ...atual }
+  CAMPOS_COLUNAS_FILTRO.forEach((campo) => {
+    const configCampo = configNormalizada[campo] || { disponiveis: [], padrao: [] }
+    const idsDisponiveis = new Set((configCampo.disponiveis || []).map((item) => item.id))
+    const selecionadasValidas = (next[campo] || []).filter((id) => idsDisponiveis.has(id))
+    if (camposEditados[campo]) {
+      next[campo] = selecionadasValidas
+      return
+    }
+    const padraoValido = (configCampo.padrao || []).filter((id) => idsDisponiveis.has(id))
+    next[campo] = padraoValido.length ? padraoValido : selecionadasValidas
+  })
+  return next
+}
+
+function buildApiFilters(filters, colunasFiltro = COLUNAS_FILTRO_INITIAL) {
+  if (filters.otica === 'avaliando') {
+    return {
+      otica: filters.otica,
+      aval_finalidade: filters.avalFinalidade,
+      aval_finalidade_colunas: (colunasFiltro.aval_finalidade || []).join(','),
+      aval_bairro: filters.avalBairro,
+      aval_bairro_colunas: (colunasFiltro.aval_bairro || []).join(','),
+      aval_data: filters.avalData,
+      aval_data_colunas: (colunasFiltro.aval_data || []).join(','),
+      aval_area: filters.avalArea,
+      aval_area_colunas: (colunasFiltro.aval_area || []).join(','),
+      aval_area_privativa: filters.avalAreaPrivativa,
+      aval_area_privativa_colunas: (colunasFiltro.aval_area_privativa || []).join(','),
+      aval_area_total: filters.avalAreaTotal,
+      aval_area_total_colunas: (colunasFiltro.aval_area_total || []).join(','),
+      aval_rh: filters.avalRh,
+      aval_rh_colunas: (colunasFiltro.aval_rh || []).join(','),
+      aval_valor_unitario: filters.avalValorUnitario,
+      aval_valor_unitario_colunas: (colunasFiltro.aval_valor_unitario || []).join(','),
+      aval_valor_total: filters.avalValorTotal,
+      aval_valor_total_colunas: (colunasFiltro.aval_valor_total || []).join(','),
+    }
+  }
+
+  return {
+    otica: filters.otica,
+    nome: filters.nome,
+    autor: filters.autor,
+    finalidade: filters.finalidade,
+    finalidade_colunas: (colunasFiltro.finalidade || []).join(','),
+    bairros: filters.bairros,
+    bairros_colunas: (colunasFiltro.bairros || []).join(','),
+    data_min: filters.dataMin,
+    data_colunas: (colunasFiltro.data || []).join(','),
+    data_max: filters.dataMax,
+    area_min: filters.areaMin,
+    area_colunas: (colunasFiltro.area || []).join(','),
+    area_max: filters.areaMax,
+    rh_min: filters.rhMin,
+    rh_colunas: (colunasFiltro.rh || []).join(','),
+    rh_max: filters.rhMax,
+  }
+}
+
+function toInputName(field) {
+  let hash = 0
+  for (let i = 0; i < field.length; i += 1) {
+    hash = (hash * 31 + field.charCodeAt(i)) % 1000000007
+  }
+  return `mesa_${Math.abs(hash)}`
+}
+
+function TextFieldInput({ field, ...props }) {
+  return (
+    <input
+      {...props}
+      data-field={field}
+      name={toInputName(field)}
+      autoComplete="off"
+      autoCorrect="off"
+      autoCapitalize="none"
+      spellCheck={false}
+    />
+  )
+}
+
+function NumberFieldInput({ field, ...props }) {
+  return (
+    <input
+      {...props}
+      type="number"
+      step="any"
+      inputMode="decimal"
+      data-field={field}
+      name={toInputName(field)}
+      autoComplete="off"
+    />
+  )
+}
+
+function DynamicFilterField({
+  label,
+  campoValor,
+  campoColunas,
+  configCampo,
+  selecionadas,
+  onAddColuna,
+  onRemoveColuna,
+  value,
+  onChange,
+  list,
+  placeholder,
+  inputKind = 'text',
+}) {
+  const disponiveis = configCampo?.disponiveis || []
+  const selectedSet = new Set(selecionadas || [])
+  const opcoesAdicionar = disponiveis.filter((item) => !selectedSet.has(item.id))
+  const InputComponent = inputKind === 'number' ? NumberFieldInput : TextFieldInput
+
+  function findLabel(id) {
+    const match = disponiveis.find((item) => item.id === id)
+    return match?.label || id
+  }
+
+  return (
+    <label className="pesquisa-field pesquisa-field-wide">
+      {label ? <span>{label}</span> : null}
+      <div className="pesquisa-dynamic-filter-row">
+        <div className="pesquisa-colunas-box">
+          <div className="pesquisa-colunas-chip-list">
+            {(selecionadas || []).map((id) => (
+              <span key={`${campoColunas}-${id}`} className="pesquisa-coluna-chip">
+                <span>{findLabel(id)}</span>
+                <button type="button" className="pesquisa-coluna-remove" onClick={() => onRemoveColuna(campoColunas, id)} aria-label={`Remover coluna ${findLabel(id)}`}>
+                  x
+                </button>
+              </span>
+            ))}
+            {!(selecionadas || []).length ? <span className="pesquisa-colunas-empty">Nenhuma coluna selecionada.</span> : null}
+          </div>
+        </div>
+
+        <select
+          className="pesquisa-colunas-add"
+          defaultValue=""
+          onChange={(event) => {
+            const selected = String(event.target.value || '').trim()
+            if (!selected) return
+            onAddColuna(campoColunas, selected)
+            event.target.value = ''
+          }}
+        >
+          <option value="">Adicionar coluna...</option>
+          {opcoesAdicionar.map((item) => (
+            <option key={`${campoColunas}-opt-${item.id}`} value={item.id}>{item.label}</option>
+          ))}
+        </select>
+
+        <InputComponent
+          list={list}
+          field={campoValor}
+          value={value}
+          onChange={onChange}
+          placeholder={placeholder}
+        />
+      </div>
+    </label>
+  )
+}
+
+function DynamicRangeFilterField({
+  label,
+  campoColunas,
+  configCampo,
+  selecionadas,
+  onAddColuna,
+  onRemoveColuna,
+  minLabel,
+  minField,
+  minValue,
+  maxLabel,
+  maxField,
+  maxValue,
+  onChange,
+  minPlaceholder,
+  maxPlaceholder,
+  inputKind = 'number',
+}) {
+  const disponiveis = configCampo?.disponiveis || []
+  const selectedSet = new Set(selecionadas || [])
+  const opcoesAdicionar = disponiveis.filter((item) => !selectedSet.has(item.id))
+  const InputComponent = inputKind === 'number' ? NumberFieldInput : TextFieldInput
+
+  function findLabel(id) {
+    const match = disponiveis.find((item) => item.id === id)
+    return match?.label || id
+  }
+
+  return (
+    <div className="pesquisa-field pesquisa-field-wide">
+      {label ? <span>{label}</span> : null}
+      <div className="pesquisa-dynamic-filter-row pesquisa-dynamic-filter-row-range">
+        <div className="pesquisa-colunas-box">
+          <div className="pesquisa-colunas-chip-list">
+            {(selecionadas || []).map((id) => (
+              <span key={`${campoColunas}-${id}`} className="pesquisa-coluna-chip">
+                <span>{findLabel(id)}</span>
+                <button type="button" className="pesquisa-coluna-remove" onClick={() => onRemoveColuna(campoColunas, id)} aria-label={`Remover coluna ${findLabel(id)}`}>
+                  x
+                </button>
+              </span>
+            ))}
+            {!(selecionadas || []).length ? <span className="pesquisa-colunas-empty">Nenhuma coluna selecionada.</span> : null}
+          </div>
+        </div>
+
+        <select
+          className="pesquisa-colunas-add"
+          defaultValue=""
+          onChange={(event) => {
+            const selected = String(event.target.value || '').trim()
+            if (!selected) return
+            onAddColuna(campoColunas, selected)
+            event.target.value = ''
+          }}
+        >
+          <option value="">Adicionar coluna...</option>
+          {opcoesAdicionar.map((item) => (
+            <option key={`${campoColunas}-opt-${item.id}`} value={item.id}>{item.label}</option>
+          ))}
+        </select>
+      </div>
+
+      <div className="pesquisa-range-values-row">
+        <label className="pesquisa-field">
+          {minLabel}
+          <InputComponent field={minField} value={minValue} onChange={onChange} placeholder={minPlaceholder} />
+        </label>
+        <label className="pesquisa-field">
+          {maxLabel}
+          <InputComponent field={maxField} value={maxValue} onChange={onChange} placeholder={maxPlaceholder} />
+        </label>
+      </div>
+    </div>
+  )
+}
+
+function FiltroGroup({ title, children }) {
+  return (
+    <section className="pesquisa-filtro-grupo">
+      <h5>{title}</h5>
+      <div className="pesquisa-filtros-grid">
+        {children}
+      </div>
+    </section>
+  )
+}
+
+export default function PesquisaTab() {
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState('')
+  const [pesquisaInicializada, setPesquisaInicializada] = useState(false)
+
+  const [filters, setFilters] = useState(EMPTY_FILTERS)
+  const [result, setResult] = useState(RESULT_INITIAL)
+
+  const [selectedIds, setSelectedIds] = useState([])
+  const [detailModelId, setDetailModelId] = useState('')
+  const selectAllRef = useRef(null)
+  const [colunasConfig, setColunasConfig] = useState({})
+  const [colunasFiltro, setColunasFiltro] = useState(COLUNAS_FILTRO_INITIAL)
+  const [colunasEditadas, setColunasEditadas] = useState({})
+
+  const [mapaLoading, setMapaLoading] = useState(false)
+  const [mapaError, setMapaError] = useState('')
+  const [mapaStatus, setMapaStatus] = useState('')
+  const [mapaHtml, setMapaHtml] = useState('')
+  const [mapaLegendas, setMapaLegendas] = useState([])
+
+  const usandoOticaAvaliando = filters.otica === 'avaliando'
+  const sugestoes = result.sugestoes || {}
+  const resultIds = useMemo(() => (result.modelos || []).map((modelo) => modelo.id), [result.modelos])
+  const detalheModelo = useMemo(() => (result.modelos || []).find((modelo) => modelo.id === detailModelId) || null, [result.modelos, detailModelId])
+  const todosSelecionados = resultIds.length > 0 && resultIds.every((id) => selectedIds.includes(id))
+  const algunsSelecionados = resultIds.some((id) => selectedIds.includes(id))
+
+  async function buscarModelos(nextFilters = filters, nextColunasFiltro = colunasFiltro, nextColunasEditadas = colunasEditadas) {
+    setLoading(true)
+    setError('')
+    try {
+      const response = await api.pesquisarModelos(buildApiFilters(nextFilters, nextColunasFiltro))
+      const modelos = response.modelos || []
+      const idsNovos = new Set(modelos.map((item) => item.id))
+      const configNormalizada = normalizeColunasConfig(response.colunas_filtro || {})
+
+      setResult({
+        ...RESULT_INITIAL,
+        ...response,
+        modelos,
+        sugestoes: response.sugestoes || {},
+      })
+      setColunasConfig(configNormalizada)
+      setColunasFiltro((current) => reconciliarColunasSelecionadas(current, configNormalizada, nextColunasEditadas))
+
+      setSelectedIds((current) => current.filter((id) => idsNovos.has(id)))
+
+      setMapaHtml('')
+      setMapaStatus('')
+      setMapaLegendas([])
+      setMapaError('')
+      setPesquisaInicializada(true)
+    } catch (err) {
+      setError(err.message)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  async function carregarContextoInicial() {
+    setLoading(true)
+    setError('')
+    try {
+      const response = await api.pesquisarModelos({ somente_contexto: true })
+      const configNormalizada = normalizeColunasConfig(response.colunas_filtro || {})
+
+      setResult({
+        ...RESULT_INITIAL,
+        ...response,
+        modelos: [],
+        sugestoes: response.sugestoes || {},
+      })
+      setColunasConfig(configNormalizada)
+      setColunasFiltro((current) => reconciliarColunasSelecionadas(current, configNormalizada, {}))
+      setSelectedIds([])
+      setMapaHtml('')
+      setMapaStatus('')
+      setMapaLegendas([])
+      setMapaError('')
+      setPesquisaInicializada(false)
+    } catch (err) {
+      setError(err.message)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  useEffect(() => {
+    void carregarContextoInicial()
+  }, [])
+
+  useEffect(() => {
+    if (!selectAllRef.current) return
+    selectAllRef.current.indeterminate = algunsSelecionados && !todosSelecionados
+  }, [algunsSelecionados, todosSelecionados])
+
+  useEffect(() => {
+    if (!detailModelId) return
+    if (!detalheModelo) {
+      setDetailModelId('')
+    }
+  }, [detailModelId, detalheModelo])
+
+  useEffect(() => {
+    if (!detailModelId) return undefined
+    function onEsc(event) {
+      if (event.key === 'Escape') {
+        setDetailModelId('')
+      }
+    }
+    window.addEventListener('keydown', onEsc)
+    return () => window.removeEventListener('keydown', onEsc)
+  }, [detailModelId])
+
+  function onFieldChange(event) {
+    const { value, dataset, name } = event.target
+    const field = dataset.field || name
+    if (!field) return
+    setFilters((prev) => ({ ...prev, [field]: value }))
+  }
+
+  function onChangeOtica(otica) {
+    setFilters((prev) => ({ ...prev, otica }))
+  }
+
+  async function onLimparFiltros() {
+    setFilters(EMPTY_FILTERS)
+    setColunasEditadas({})
+    setColunasFiltro(COLUNAS_FILTRO_INITIAL)
+    await buscarModelos(EMPTY_FILTERS, COLUNAS_FILTRO_INITIAL, {})
+  }
+
+  function onToggleSelecionado(modelId) {
+    setSelectedIds((current) => {
+      if (current.includes(modelId)) {
+        return current.filter((id) => id !== modelId)
+      }
+      return [...current, modelId]
+    })
+  }
+
+  function onToggleSelecionarTodos() {
+    setSelectedIds((current) => {
+      if (todosSelecionados) {
+        const idsAtuais = new Set(resultIds)
+        return current.filter((id) => !idsAtuais.has(id))
+      }
+      const next = new Set(current)
+      resultIds.forEach((id) => next.add(id))
+      return Array.from(next)
+    })
+  }
+
+  function onAbrirDetalhes(modeloId) {
+    setDetailModelId(modeloId)
+  }
+
+  function onFecharDetalhes() {
+    setDetailModelId('')
+  }
+
+  function onAddColunaFiltro(campo, colunaId) {
+    setColunasFiltro((current) => {
+      const atual = current[campo] || []
+      if (atual.includes(colunaId)) return current
+      return { ...current, [campo]: [...atual, colunaId] }
+    })
+    setColunasEditadas((current) => ({ ...current, [campo]: true }))
+  }
+
+  function onRemoveColunaFiltro(campo, colunaId) {
+    setColunasFiltro((current) => ({
+      ...current,
+      [campo]: (current[campo] || []).filter((item) => item !== colunaId),
+    }))
+    setColunasEditadas((current) => ({ ...current, [campo]: true }))
+  }
+
+  async function onGerarMapaSelecionados() {
+    if (!selectedIds.length) {
+      setMapaError('Selecione ao menos um modelo para plotar no mapa.')
+      return
+    }
+
+    setMapaLoading(true)
+    setMapaError('')
+    try {
+      const response = await api.pesquisarMapaModelos(selectedIds)
+      setMapaHtml(response.mapa_html || '')
+      setMapaStatus(response.status || '')
+      setMapaLegendas(response.modelos_plotados || [])
+    } catch (err) {
+      setMapaError(err.message)
+    } finally {
+      setMapaLoading(false)
+    }
+  }
+
+  return (
+    <div className="tab-content">
+      <SectionBlock step="1" title="Filtros de Pesquisa" subtitle="Use a otica do modelo ou do avaliando. Todos os filtros sao cumulativos.">
+        <div className="pesquisa-otica-switch" role="tablist" aria-label="Otica de pesquisa">
+          <button
+            type="button"
+            className={`pesquisa-otica-btn${!usandoOticaAvaliando ? ' active' : ''}`}
+            role="tab"
+            id="pesquisa-otica-modelo"
+            aria-selected={!usandoOticaAvaliando}
+            aria-controls="pesquisa-panel-modelo"
+            tabIndex={!usandoOticaAvaliando ? 0 : -1}
+            onClick={() => onChangeOtica('modelo')}
+          >
+            Otica do modelo
+          </button>
+          <button
+            type="button"
+            className={`pesquisa-otica-btn${usandoOticaAvaliando ? ' active' : ''}`}
+            role="tab"
+            id="pesquisa-otica-avaliando"
+            aria-selected={usandoOticaAvaliando}
+            aria-controls="pesquisa-panel-avaliando"
+            tabIndex={usandoOticaAvaliando ? 0 : -1}
+            onClick={() => onChangeOtica('avaliando')}
+          >
+            Otica do avaliando
+          </button>
+        </div>
+
+        {usandoOticaAvaliando ? (
+          <div id="pesquisa-panel-avaliando" role="tabpanel" aria-labelledby="pesquisa-otica-avaliando" className="pesquisa-filtros-groups">
+            <FiltroGroup title="Finalidade">
+              <DynamicFilterField
+                label="Finalidade do imovel"
+                campoValor="avalFinalidade"
+                campoColunas="aval_finalidade"
+                configCampo={colunasConfig.aval_finalidade}
+                selecionadas={colunasFiltro.aval_finalidade}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                value={filters.avalFinalidade}
+                onChange={onFieldChange}
+                list="pesquisa-finalidades"
+                placeholder="Ex: Apartamento"
+              />
+            </FiltroGroup>
+
+            <FiltroGroup title="Bairro">
+              <DynamicFilterField
+                label="Bairro do imovel"
+                campoValor="avalBairro"
+                campoColunas="aval_bairro"
+                configCampo={colunasConfig.aval_bairro}
+                selecionadas={colunasFiltro.aval_bairro}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                value={filters.avalBairro}
+                onChange={onFieldChange}
+                list="pesquisa-bairros"
+                placeholder="Ex: Centro"
+              />
+            </FiltroGroup>
+
+            <FiltroGroup title="Datas">
+              <DynamicFilterField
+                label="Data de referencia"
+                campoValor="avalData"
+                campoColunas="aval_data"
+                configCampo={colunasConfig.aval_data}
+                selecionadas={colunasFiltro.aval_data}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                value={filters.avalData}
+                onChange={onFieldChange}
+                placeholder="2025-02-27"
+              />
+            </FiltroGroup>
+
+            <FiltroGroup title="Areas">
+              <DynamicFilterField
+                label="Area (generica)"
+                campoValor="avalArea"
+                campoColunas="aval_area"
+                configCampo={colunasConfig.aval_area}
+                selecionadas={colunasFiltro.aval_area}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                value={filters.avalArea}
+                onChange={onFieldChange}
+                placeholder="0"
+                inputKind="number"
+              />
+              <DynamicFilterField
+                label="Area privativa"
+                campoValor="avalAreaPrivativa"
+                campoColunas="aval_area_privativa"
+                configCampo={colunasConfig.aval_area_privativa}
+                selecionadas={colunasFiltro.aval_area_privativa}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                value={filters.avalAreaPrivativa}
+                onChange={onFieldChange}
+                placeholder="0"
+                inputKind="number"
+              />
+              <DynamicFilterField
+                label="Area total"
+                campoValor="avalAreaTotal"
+                campoColunas="aval_area_total"
+                configCampo={colunasConfig.aval_area_total}
+                selecionadas={colunasFiltro.aval_area_total}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                value={filters.avalAreaTotal}
+                onChange={onFieldChange}
+                placeholder="0"
+                inputKind="number"
+              />
+            </FiltroGroup>
+
+            <FiltroGroup title="RH">
+              <DynamicFilterField
+                label="RH do imovel"
+                campoValor="avalRh"
+                campoColunas="aval_rh"
+                configCampo={colunasConfig.aval_rh}
+                selecionadas={colunasFiltro.aval_rh}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                value={filters.avalRh}
+                onChange={onFieldChange}
+                placeholder="0"
+                inputKind="number"
+              />
+            </FiltroGroup>
+
+            <FiltroGroup title="Valores">
+              <DynamicFilterField
+                label="Valor unitario"
+                campoValor="avalValorUnitario"
+                campoColunas="aval_valor_unitario"
+                configCampo={colunasConfig.aval_valor_unitario}
+                selecionadas={colunasFiltro.aval_valor_unitario}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                value={filters.avalValorUnitario}
+                onChange={onFieldChange}
+                placeholder="0"
+                inputKind="number"
+              />
+              <DynamicFilterField
+                label="Valor total"
+                campoValor="avalValorTotal"
+                campoColunas="aval_valor_total"
+                configCampo={colunasConfig.aval_valor_total}
+                selecionadas={colunasFiltro.aval_valor_total}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                value={filters.avalValorTotal}
+                onChange={onFieldChange}
+                placeholder="0"
+                inputKind="number"
+              />
+            </FiltroGroup>
+          </div>
+        ) : (
+          <div id="pesquisa-panel-modelo" role="tabpanel" aria-labelledby="pesquisa-otica-modelo" className="pesquisa-filtros-groups pesquisa-filtros-groups-stack">
+            <FiltroGroup title="Modelo">
+              <label className="pesquisa-field">
+                Nome do modelo
+                <TextFieldInput
+                  list="pesquisa-nomes-modelo"
+                  field="nome"
+                  value={filters.nome}
+                  onChange={onFieldChange}
+                  placeholder="Ex: MOD_A_SALA_Z1"
+                />
+              </label>
+              <label className="pesquisa-field">
+                Autor
+                <TextFieldInput
+                  list="pesquisa-autores"
+                  field="autor"
+                  value={filters.autor}
+                  onChange={onFieldChange}
+                  placeholder="Nome do avaliador"
+                />
+              </label>
+            </FiltroGroup>
+
+            <FiltroGroup title="Finalidade">
+              <DynamicFilterField
+                label=""
+                campoValor="finalidade"
+                campoColunas="finalidade"
+                configCampo={colunasConfig.finalidade}
+                selecionadas={colunasFiltro.finalidade}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                value={filters.finalidade}
+                onChange={onFieldChange}
+                list="pesquisa-finalidades"
+                placeholder="Apartamento, sala, deposito..."
+              />
+            </FiltroGroup>
+
+            <FiltroGroup title="Bairro">
+              <DynamicFilterField
+                label=""
+                campoValor="bairros"
+                campoColunas="bairros"
+                configCampo={colunasConfig.bairros}
+                selecionadas={colunasFiltro.bairros}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                value={filters.bairros}
+                onChange={onFieldChange}
+                list="pesquisa-bairros"
+                placeholder="Centro, Moinhos de Vento"
+              />
+            </FiltroGroup>
+
+            <FiltroGroup title="Datas">
+              <DynamicRangeFilterField
+                label=""
+                campoColunas="data"
+                configCampo={colunasConfig.data}
+                selecionadas={colunasFiltro.data}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                minLabel="Data minima"
+                minField="dataMin"
+                minValue={filters.dataMin}
+                maxLabel="Data maxima"
+                maxField="dataMax"
+                maxValue={filters.dataMax}
+                onChange={onFieldChange}
+                minPlaceholder="2022 ou 2022-01-01"
+                maxPlaceholder="2025 ou 2025-12-31"
+                inputKind="text"
+              />
+            </FiltroGroup>
+
+            <FiltroGroup title="Areas">
+              <DynamicRangeFilterField
+                label=""
+                campoColunas="area"
+                configCampo={colunasConfig.area}
+                selecionadas={colunasFiltro.area}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                minLabel="Area minima"
+                minField="areaMin"
+                minValue={filters.areaMin}
+                maxLabel="Area maxima"
+                maxField="areaMax"
+                maxValue={filters.areaMax}
+                onChange={onFieldChange}
+                minPlaceholder="0"
+                maxPlaceholder="0"
+                inputKind="number"
+              />
+            </FiltroGroup>
+
+            <FiltroGroup title="RH">
+              <DynamicRangeFilterField
+                label=""
+                campoColunas="rh"
+                configCampo={colunasConfig.rh}
+                selecionadas={colunasFiltro.rh}
+                onAddColuna={onAddColunaFiltro}
+                onRemoveColuna={onRemoveColunaFiltro}
+                minLabel="RH minimo"
+                minField="rhMin"
+                minValue={filters.rhMin}
+                maxLabel="RH maximo"
+                maxField="rhMax"
+                maxValue={filters.rhMax}
+                onChange={onFieldChange}
+                minPlaceholder="0"
+                maxPlaceholder="1"
+                inputKind="number"
+              />
+            </FiltroGroup>
+          </div>
+        )}
+
+        <datalist id="pesquisa-nomes-modelo">
+          {(sugestoes.nomes_modelo || []).map((item) => (
+            <option key={`nome-${item}`} value={item} />
+          ))}
+        </datalist>
+        <datalist id="pesquisa-autores">
+          {(sugestoes.autores || []).map((item) => (
+            <option key={`autor-${item}`} value={item} />
+          ))}
+        </datalist>
+        <datalist id="pesquisa-finalidades">
+          {(sugestoes.finalidades || []).map((item) => (
+            <option key={`finalidade-${item}`} value={item} />
+          ))}
+        </datalist>
+        <datalist id="pesquisa-bairros">
+          {(sugestoes.bairros || []).map((item) => (
+            <option key={`bairro-${item}`} value={item} />
+          ))}
+        </datalist>
+
+        <div className="row pesquisa-actions pesquisa-actions-primary">
+          <button type="button" onClick={() => void buscarModelos()} disabled={loading}>
+            {loading ? 'Pesquisando...' : 'Pesquisar'}
+          </button>
+          <button type="button" onClick={() => void onLimparFiltros()} disabled={loading}>
+            Limpar filtros
+          </button>
+        </div>
+
+        {error ? <div className="error-line inline-error">{error}</div> : null}
+      </SectionBlock>
+
+      <SectionBlock
+        step="2"
+        title="Resultados"
+        subtitle={
+          usandoOticaAvaliando
+            ? 'Modelos aceitos para os parametros do avaliando informado.'
+            : 'Lista de modelos encontrados para os filtros atuais.'
+        }
+      >
+        <div className="pesquisa-results-toolbar">
+          <div className="pesquisa-summary-line">
+            <strong>{formatCount(result.total_filtrado)}</strong>{' '}
+            {usandoOticaAvaliando ? 'modelo(s) aceito(s)' : 'modelo(s) exibido(s)'} de <strong>{formatCount(result.total_geral)}</strong>.
+          </div>
+          {resultIds.length ? (
+            <label className="pesquisa-select-all">
+              <input ref={selectAllRef} type="checkbox" checked={todosSelecionados} onChange={onToggleSelecionarTodos} />
+              Selecionar todos os exibidos
+            </label>
+          ) : null}
+        </div>
+
+        {!result.modelos?.length ? (
+          <div className="empty-box">
+            {!pesquisaInicializada
+              ? 'Defina os filtros desejados e clique em Pesquisar.'
+              : usandoOticaAvaliando
+                ? 'Nenhum modelo aceitou os parametros do avaliando informado.'
+                : 'Nenhum modelo encontrado com os filtros atuais.'}
+          </div>
+        ) : (
+          <div className="pesquisa-card-grid">
+            {result.modelos.map((modelo) => {
+              const selecionado = selectedIds.includes(modelo.id)
+              return (
+                <article key={modelo.id} className={`pesquisa-card${selecionado ? ' is-selected' : ''}`}>
+                  <div className="pesquisa-card-top">
+                    <div className="pesquisa-card-head">
+                      <div className="pesquisa-card-head-main">
+                        <h4>{modelo.nome_modelo || modelo.arquivo}</h4>
+                        <p>{modelo.arquivo}</p>
+                        <div className="pesquisa-card-head-actions">
+                          <label className="pesquisa-select-toggle">
+                            <input
+                              type="checkbox"
+                              checked={selecionado}
+                              onChange={() => onToggleSelecionado(modelo.id)}
+                            />
+                            Selecionar
+                          </label>
+                          <button type="button" className="btn-pesquisa-expand" onClick={() => onAbrirDetalhes(modelo.id)}>
+                            Ver mais
+                          </button>
+                        </div>
+                      </div>
+                    </div>
+
+                    {usandoOticaAvaliando ? (
+                      <div className="pesquisa-card-status-row">
+                        <div className="status-pill done">Aceito para o avaliando ({modelo.avaliando?.campos_informados || 0} campo(s) validado(s))</div>
+                      </div>
+                    ) : null}
+                    <div className="pesquisa-card-body">
+                      <div className="pesquisa-card-dados-list">
+                        <div><strong>Finalidades no modelo:</strong> {(modelo.finalidades || []).length ? modelo.finalidades.join(', ') : '-'}</div>
+                        <div><strong>Tipo:</strong> {formatTipoImovel(modelo)}</div>
+                        <div><strong>Autor:</strong> {modelo.autor || '-'}</div>
+                        <div><strong>Dados:</strong> {formatCount(modelo.total_dados)}</div>
+                        <div><strong>Faixa area:</strong> {formatRange(modelo.faixa_area)}</div>
+                        <div><strong>Faixa RH:</strong> {formatRange(modelo.faixa_rh)}</div>
+                        <div><strong>Faixa data:</strong> {formatRange(modelo.faixa_data)}</div>
+                        <div><strong>Bairros:</strong> {(modelo.bairros || []).length ? (modelo.bairros || []).join(', ') : '-'}</div>
+                      </div>
+                    </div>
+                  </div>
+
+                  {modelo.status !== 'ok' ? <div className="inline-error pesquisa-card-error">{modelo.erro_leitura || 'Falha ao ler modelo.'}</div> : null}
+                </article>
+              )
+            })}
+          </div>
+        )}
+      </SectionBlock>
+
+      <SectionBlock step="3" title="Mapa" subtitle="Plote os modelos selecionados com cores distintas e legenda.">
+        <div className="pesquisa-summary-line">
+          <strong>{formatCount(selectedIds.length)}</strong> modelo(s) selecionado(s) para plotagem.
+        </div>
+
+        <div className="row pesquisa-actions">
+          <button type="button" onClick={() => void onGerarMapaSelecionados()} disabled={mapaLoading || !selectedIds.length}>
+            {mapaLoading ? 'Gerando mapa...' : 'Plotar mapa dos selecionados'}
+          </button>
+        </div>
+
+        {mapaStatus ? <div className="status-line">{mapaStatus}</div> : null}
+        {mapaError ? <div className="error-line inline-error">{mapaError}</div> : null}
+
+        {mapaLegendas.length ? (
+          <div className="pesquisa-legenda-grid">
+            {mapaLegendas.map((item) => (
+              <div key={item.id} className="pesquisa-legenda-item">
+                <span className="pesquisa-legenda-color" style={{ backgroundColor: item.cor }} />
+                <span>{item.nome} ({item.total_pontos})</span>
+              </div>
+            ))}
+          </div>
+        ) : null}
+
+        {mapaHtml ? <MapFrame html={mapaHtml} /> : <div className="empty-box">Nenhum mapa gerado ainda.</div>}
+      </SectionBlock>
+
+      {detalheModelo ? (
+        <div className="pesquisa-modal-backdrop" role="presentation" onClick={onFecharDetalhes}>
+          <div className="pesquisa-modal" role="dialog" aria-modal="true" aria-labelledby={`pesquisa-modal-title-${detalheModelo.id}`} onClick={(event) => event.stopPropagation()}>
+            <div className="pesquisa-modal-head">
+              <div>
+                <h4 id={`pesquisa-modal-title-${detalheModelo.id}`}>{detalheModelo.nome_modelo || detalheModelo.arquivo}</h4>
+                <p>{detalheModelo.arquivo}</p>
+              </div>
+              <button type="button" className="pesquisa-modal-close" onClick={onFecharDetalhes}>
+                Fechar
+              </button>
+            </div>
+
+            <div className="pesquisa-modal-body">
+              <div className="pesquisa-card-kpis">
+                <span><strong>Faixa area:</strong> {formatRange(detalheModelo.faixa_area)}</span>
+                <span><strong>Faixa RH:</strong> {formatRange(detalheModelo.faixa_rh)}</span>
+                <span><strong>Faixa data:</strong> {formatRange(detalheModelo.faixa_data)}</span>
+              </div>
+
+              <div className="pesquisa-compare-block">
+                <h5>Equacao</h5>
+                <div className="equation-box">{detalheModelo.equacao || 'Nao disponivel no modelo.'}</div>
+              </div>
+
+              <div className="pesquisa-compare-block">
+                <h5>Faixas de variaveis (min/max)</h5>
+                {detalheModelo.variaveis_resumo?.length ? (
+                  <div className="table-wrapper pesquisa-variaveis-table">
+                    <table>
+                      <thead>
+                        <tr>
+                          <th>Variavel</th>
+                          <th>Min</th>
+                          <th>Max</th>
+                        </tr>
+                      </thead>
+                      <tbody>
+                        {detalheModelo.variaveis_resumo.map((item) => (
+                          <tr key={`${detalheModelo.id}-${item.variavel}`}>
+                            <td>{item.variavel}</td>
+                            <td>{item.min ?? '-'}</td>
+                            <td>{item.max ?? '-'}</td>
+                          </tr>
+                        ))}
+                      </tbody>
+                    </table>
+                  </div>
+                ) : (
+                  <div className="empty-box">Sem estatisticas suficientes para listar variaveis.</div>
+                )}
+              </div>
+            </div>
+          </div>
+        </div>
+      ) : null}
+    </div>
+  )
+}

frontend/src/styles.css

@@ -392,6 +392,631 @@ textarea {
   border-style: solid;
 }
 
+.pesquisa-filtros-groups {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 22px;
+  margin-bottom: 12px;
+}
+
+.pesquisa-filtros-groups.pesquisa-filtros-groups-stack {
+  grid-template-columns: 1fr;
+}
+
+.pesquisa-filtro-grupo {
+  border: 1px solid #c4d6e8;
+  border-radius: 12px;
+  background: linear-gradient(180deg, #ffffff 0%, #f8fbff 100%);
+  padding: 10px 11px 11px;
+  box-shadow:
+    0 1px 0 rgba(255, 255, 255, 0.9),
+    inset 0 0 0 1px rgba(255, 255, 255, 0.74);
+  position: relative;
+}
+
+.pesquisa-filtro-grupo::before {
+  content: '';
+  position: absolute;
+  left: 0;
+  top: 0;
+  bottom: 0;
+  width: 4px;
+  border-radius: 12px 0 0 12px;
+  background: linear-gradient(180deg, #ff9a26 0%, #e67900 100%);
+}
+
+.pesquisa-filtro-grupo h5 {
+  margin: 0 0 9px;
+  padding-bottom: 6px;
+  border-bottom: 1px solid #d4e2ef;
+  color: #2f4b67;
+  font-size: 0.82rem;
+  font-family: 'Sora', sans-serif;
+  letter-spacing: 0.02em;
+  text-transform: uppercase;
+}
+
+.pesquisa-filtros-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 14px;
+  margin-bottom: 0;
+}
+
+.pesquisa-otica-switch {
+  display: flex;
+  align-items: flex-end;
+  gap: 4px;
+  margin-bottom: 18px;
+  border-bottom: 2px solid #c9d9e8;
+  padding-bottom: 0;
+}
+
+.pesquisa-otica-btn {
+  border: 1px solid #cfdbe7;
+  border-bottom-color: transparent;
+  border-radius: 9px 9px 0 0;
+  background: linear-gradient(180deg, #f3f7fb 0%, #eaf1f8 100%);
+  color: #6b7f93;
+  font-weight: 700;
+  padding: 9px 13px 8px;
+  box-shadow: none;
+  margin-bottom: -2px;
+}
+
+.pesquisa-otica-btn.active {
+  border-color: #cf6f00;
+  border-bottom-color: #cf6f00;
+  background: linear-gradient(180deg, #ff9a26 0%, #e67900 100%);
+  color: #ffffff;
+  box-shadow:
+    0 1px 0 rgba(255, 255, 255, 0.25) inset,
+    0 6px 14px rgba(230, 121, 0, 0.28);
+}
+
+button.pesquisa-otica-btn:hover {
+  transform: none;
+  box-shadow: none;
+  color: #445f78;
+  background: linear-gradient(180deg, #f7fbff 0%, #edf4fa 100%);
+}
+
+button.pesquisa-otica-btn.active:hover {
+  color: #ffffff;
+  background: linear-gradient(180deg, #ff9a26 0%, #e67900 100%);
+  box-shadow:
+    0 1px 0 rgba(255, 255, 255, 0.25) inset,
+    0 6px 14px rgba(230, 121, 0, 0.28);
+}
+
+.pesquisa-field {
+  display: grid;
+  gap: 7px;
+  font-size: 0.84rem;
+  align-content: start;
+}
+
+.pesquisa-field-wide {
+  grid-column: 1 / -1;
+}
+
+.pesquisa-field input {
+  width: 100%;
+}
+
+.pesquisa-field input::placeholder {
+  color: #b7c4d2;
+  opacity: 1;
+}
+
+.pesquisa-dynamic-filter-row {
+  display: grid;
+  grid-template-columns: minmax(0, 1.8fr) minmax(190px, 1fr) minmax(220px, 1.2fr);
+  gap: 10px;
+  align-items: start;
+}
+
+.pesquisa-dynamic-filter-row.pesquisa-dynamic-filter-row-range {
+  grid-template-columns: minmax(0, 1.8fr) minmax(190px, 1fr);
+}
+
+.pesquisa-colunas-box {
+  min-height: 38px;
+  border: 1px solid #cfdbe7;
+  border-radius: 10px;
+  background: #fff;
+  padding: 6px 8px;
+}
+
+.pesquisa-colunas-chip-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  align-items: flex-start;
+  max-height: 110px;
+  overflow: auto;
+}
+
+.pesquisa-coluna-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  border: 1px solid #d8e4ef;
+  border-radius: 999px;
+  background: #f6faff;
+  color: #486179;
+  font-size: 0.74rem;
+  line-height: 1.2;
+  padding: 3px 8px;
+}
+
+button.pesquisa-coluna-remove {
+  border: none;
+  background: transparent;
+  color: #5f768c;
+  font-weight: 800;
+  padding: 0;
+  min-height: auto;
+  box-shadow: none;
+  line-height: 1;
+}
+
+button.pesquisa-coluna-remove:hover {
+  transform: none;
+  box-shadow: none;
+  color: #304b63;
+}
+
+.pesquisa-colunas-empty {
+  color: #7c90a4;
+  font-size: 0.75rem;
+  font-style: italic;
+  padding: 2px 0;
+}
+
+.pesquisa-colunas-add {
+  width: 100%;
+  min-height: 38px;
+  padding: 6px 8px;
+  font-size: 0.77rem;
+  background: #fbfdff;
+}
+
+.pesquisa-range-row {
+  grid-column: 1 / -1;
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 16px;
+}
+
+.pesquisa-range-values-row {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 16px;
+  margin-top: 10px;
+}
+
+.pesquisa-range-row.pesquisa-range-row-three {
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+
+.pesquisa-actions {
+  margin-top: 2px;
+  margin-bottom: 10px;
+}
+
+.pesquisa-actions-primary {
+  margin-top: 22px;
+  margin-bottom: 14px;
+}
+
+.btn-pesquisa-expand {
+  --btn-bg-start: #f7fbff;
+  --btn-bg-end: #ecf3fa;
+  --btn-border: #c7d7e6;
+  --btn-shadow-soft: rgba(73, 102, 128, 0.08);
+  --btn-shadow-strong: rgba(73, 102, 128, 0.13);
+  color: #415c74;
+}
+
+.pesquisa-status {
+  margin-top: 2px;
+}
+
+.pesquisa-summary-line {
+  margin-bottom: 10px;
+  color: #4f657a;
+}
+
+.pesquisa-results-toolbar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  flex-wrap: wrap;
+  gap: 10px;
+  margin-bottom: 10px;
+}
+
+.pesquisa-results-toolbar .pesquisa-summary-line {
+  margin: 0;
+}
+
+.pesquisa-select-all {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  border: 1px solid #d9e4ef;
+  border-radius: 999px;
+  background: #f7fbff;
+  color: #3f566b;
+  font-size: 0.82rem;
+  font-weight: 700;
+  padding: 6px 10px;
+  white-space: nowrap;
+}
+
+.pesquisa-select-all input {
+  margin: 0;
+}
+
+.pesquisa-card-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(min(320px, 100%), 1fr));
+  gap: 12px;
+  min-width: 0;
+  align-items: stretch;
+}
+
+.pesquisa-card {
+  border: 1px solid #dbe7f2;
+  border-radius: 14px;
+  background: linear-gradient(180deg, #ffffff 0%, #fcfdff 100%);
+  padding: 12px;
+  display: grid;
+  gap: 10px;
+  min-width: 0;
+  height: 100%;
+  overflow: hidden;
+  box-shadow:
+    0 6px 18px rgba(26, 43, 61, 0.06),
+    inset 0 0 0 1px rgba(255, 255, 255, 0.75);
+  transition: border-color 0.18s ease, box-shadow 0.18s ease, transform 0.18s ease;
+}
+
+.pesquisa-card:hover {
+  transform: translateY(-1px);
+  border-color: #c8dced;
+  box-shadow:
+    0 10px 22px rgba(26, 43, 61, 0.08),
+    inset 0 0 0 1px rgba(255, 255, 255, 0.82);
+}
+
+.pesquisa-card.is-selected {
+  border-color: #ffbe77;
+  box-shadow:
+    0 10px 24px rgba(255, 163, 63, 0.17),
+    0 0 0 1px rgba(255, 163, 63, 0.28);
+}
+
+.pesquisa-card-top {
+  display: grid;
+  gap: 8px;
+  min-width: 0;
+}
+
+.pesquisa-card-head {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 10px;
+  min-width: 0;
+}
+
+.pesquisa-card-head > div {
+  min-width: 0;
+  flex: 1 1 auto;
+}
+
+.pesquisa-card-head-main {
+  display: grid;
+  gap: 6px;
+  min-width: 0;
+}
+
+.pesquisa-card-head h4 {
+  margin: 0;
+  font-family: 'Sora', sans-serif;
+  color: #2e4358;
+  font-size: 0.93rem;
+  line-height: 1.32;
+  overflow-wrap: anywhere;
+}
+
+.pesquisa-card-head p {
+  margin: 3px 0 0;
+  color: #5f758b;
+  font-size: 0.8rem;
+  line-height: 1.35;
+  overflow-wrap: anywhere;
+}
+
+.btn-pesquisa-expand {
+  flex: 0 0 auto;
+  min-width: 84px;
+  padding: 6px 10px;
+}
+
+button.btn-pesquisa-expand:hover {
+  transform: none;
+  box-shadow: 0 4px 10px var(--btn-shadow-strong);
+}
+
+.pesquisa-card-head-actions {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: flex-start;
+  gap: 8px;
+  min-width: 0;
+  margin-top: 2px;
+}
+
+.pesquisa-select-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  border: 1px solid #d8e4ef;
+  border-radius: 9px;
+  background: #f5f9fd;
+  padding: 5px 8px;
+  width: fit-content;
+  max-width: 100%;
+  font-size: 0.8rem;
+  font-weight: 700;
+  color: #48627b;
+}
+
+.pesquisa-select-toggle input {
+  margin: 0;
+}
+
+.pesquisa-card-status-row .status-pill {
+  max-width: 100%;
+  white-space: normal;
+  text-transform: none;
+  letter-spacing: 0.01em;
+  font-size: 0.75rem;
+  padding: 5px 10px;
+}
+
+.pesquisa-card-body {
+  display: grid;
+  gap: 9px;
+  min-width: 0;
+  border-top: 1px solid #e7eef5;
+  padding-top: 9px;
+}
+
+.pesquisa-card-kpis {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(170px, 1fr));
+  gap: 7px 10px;
+  font-size: 0.83rem;
+  color: #41586f;
+}
+
+.pesquisa-card-kpis span {
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.pesquisa-card-dados-list {
+  display: grid;
+  gap: 6px;
+  font-size: 0.82rem;
+  color: #41586f;
+}
+
+.pesquisa-card-dados-list div {
+  min-width: 0;
+  overflow-wrap: anywhere;
+  line-height: 1.34;
+}
+
+.pesquisa-card-bairros {
+  padding-top: 2px;
+  font-size: 0.82rem;
+  color: #4d647b;
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.pesquisa-card-faixas {
+  display: grid;
+  gap: 4px;
+  padding-top: 2px;
+  font-size: 0.81rem;
+  color: #496178;
+}
+
+.pesquisa-card-faixas span {
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.pesquisa-modal-backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 1400;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 20px;
+  background: rgba(19, 30, 43, 0.44);
+  backdrop-filter: blur(2px);
+}
+
+.pesquisa-modal {
+  width: min(980px, 100%);
+  max-height: 90vh;
+  overflow: auto;
+  border: 1px solid #d5e2ef;
+  border-radius: 16px;
+  background: #fff;
+  padding: 16px;
+  box-shadow: 0 20px 44px rgba(18, 31, 46, 0.28);
+}
+
+.pesquisa-modal-head {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.pesquisa-modal-head h4 {
+  margin: 0;
+  color: #2d4358;
+  font-family: 'Sora', sans-serif;
+  font-size: 1rem;
+}
+
+.pesquisa-modal-head p {
+  margin: 3px 0 0;
+  color: #5c7288;
+  font-size: 0.82rem;
+}
+
+.pesquisa-modal-close {
+  --btn-bg-start: #748292;
+  --btn-bg-end: #5f6d7d;
+  --btn-border: #4f5e6f;
+  --btn-shadow-soft: rgba(95, 109, 125, 0.18);
+  --btn-shadow-strong: rgba(95, 109, 125, 0.24);
+  min-width: 82px;
+}
+
+.pesquisa-modal-body {
+  display: grid;
+  gap: 12px;
+  margin-top: 12px;
+}
+
+.pesquisa-card-error {
+  margin-top: 2px;
+}
+
+.btn-pesquisa-compare {
+  min-width: 96px;
+}
+
+.pesquisa-compare-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(360px, 1fr));
+  gap: 12px;
+}
+
+.pesquisa-compare-card {
+  border: 1px solid #d5e2ee;
+  border-radius: 12px;
+  background: #fff;
+  padding: 12px;
+  display: grid;
+  gap: 11px;
+}
+
+.pesquisa-compare-card h4 {
+  margin: 0;
+  font-family: 'Sora', sans-serif;
+  color: #2f4458;
+  font-size: 0.95rem;
+}
+
+.pesquisa-compare-meta {
+  display: grid;
+  gap: 5px;
+  font-size: 0.82rem;
+  color: #4d647b;
+}
+
+.pesquisa-compare-block h5 {
+  margin: 0 0 7px;
+  font-size: 0.85rem;
+  color: #344b60;
+  font-family: 'Sora', sans-serif;
+}
+
+.pesquisa-compat-grid {
+  display: grid;
+  gap: 7px;
+}
+
+.pesquisa-compat-row {
+  display: grid;
+  grid-template-columns: minmax(120px, 0.8fr) minmax(0, 1fr);
+  gap: 7px;
+  border: 1px solid #e0e9f2;
+  border-radius: 9px;
+  padding: 6px 7px;
+  background: #fbfdff;
+  font-size: 0.81rem;
+}
+
+.pesquisa-compat-row span {
+  color: #587087;
+}
+
+.pesquisa-compat-row strong {
+  color: #2f465c;
+  word-break: break-word;
+}
+
+.pesquisa-variaveis-table {
+  max-height: 250px;
+}
+
+.table-wrapper.pesquisa-variaveis-table table {
+  min-width: 360px;
+}
+
+.table-wrapper.pesquisa-variaveis-table th,
+.table-wrapper.pesquisa-variaveis-table td {
+  white-space: nowrap;
+}
+
+.table-wrapper.pesquisa-variaveis-table th:first-child,
+.table-wrapper.pesquisa-variaveis-table td:first-child {
+  white-space: normal;
+  overflow-wrap: anywhere;
+}
+
+.pesquisa-legenda-grid {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin: 10px 0 12px;
+}
+
+.pesquisa-legenda-item {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  border: 1px solid #dce6f1;
+  border-radius: 999px;
+  background: #fbfdff;
+  padding: 5px 10px;
+  color: #3f566b;
+  font-size: 0.8rem;
+  font-weight: 700;
+}
+
+.pesquisa-legenda-color {
+  width: 11px;
+  height: 11px;
+  border-radius: 50%;
+  border: 1px solid rgba(24, 43, 62, 0.22);
+}
+
 .row {
   display: flex;
   align-items: center;
@@ -1882,6 +2507,10 @@ button.btn-upload-select {
     grid-template-columns: 1.2fr 110px minmax(110px, 0.8fr) auto;
   }
 
+  .pesquisa-filtros-groups {
+    grid-template-columns: 1fr;
+  }
+
   .micro-msg-grid-codigo {
     grid-template-columns: repeat(2, minmax(0, 1fr));
   }
@@ -1933,6 +2562,56 @@ button.btn-upload-select {
     grid-template-columns: 1fr;
   }
 
+  .pesquisa-filtros-groups,
+  .pesquisa-filtros-grid,
+  .pesquisa-card-grid,
+  .pesquisa-compare-grid,
+  .pesquisa-compat-row {
+    grid-template-columns: 1fr;
+  }
+
+  .pesquisa-dynamic-filter-row,
+  .pesquisa-range-values-row,
+  .pesquisa-range-row,
+  .pesquisa-range-row.pesquisa-range-row-three {
+    grid-template-columns: 1fr;
+  }
+
+  .pesquisa-otica-switch {
+    overflow-x: auto;
+    scrollbar-width: thin;
+  }
+
+  .pesquisa-card-head {
+    flex-direction: column;
+  }
+
+  .pesquisa-card-head-actions {
+    width: 100%;
+    justify-content: flex-start;
+  }
+
+  .pesquisa-results-toolbar {
+    align-items: flex-start;
+  }
+
+  .pesquisa-select-all {
+    white-space: normal;
+  }
+
+  .pesquisa-modal-backdrop {
+    padding: 10px;
+  }
+
+  .pesquisa-modal {
+    max-height: 95vh;
+    padding: 12px;
+  }
+
+  .pesquisa-modal-head {
+    flex-direction: column;
+  }
+
   .variavel-badge-line {
     grid-template-columns: 1fr;
     gap: 5px;