otimizacoes de funcoes

backend/app/core/elaboracao/geocodificacao.py

@@ -8,6 +8,7 @@ e, caso contrário, oferece geocodificação por interpolação em eixos de logr
 """
 
 import os
+import numpy as np
 import pandas as pd
 
 from .core import NOMES_LAT, NOMES_LON
@@ -214,20 +215,23 @@ def geocodificar(df, col_cdlog, col_num, auto_200=False):
     df["__geo_cdlog"] = obter_serie_coluna(df, col_cdlog)
     df["__geo_num"] = pd.to_numeric(obter_serie_coluna(df, col_num), errors="coerce").fillna(0).astype(int)
 
+    # Pré-processa segmentos dos eixos apenas uma vez por execução.
+    eixos = gdf_eixos.copy()
+    for col in ("NRPARINI", "NRPARFIN", "NRIMPINI", "NRIMPFIN"):
+        if col in eixos.columns:
+            eixos[col] = pd.to_numeric(eixos[col], errors="coerce")
+    segmentos_por_cdlog = {cdlog: grupo.reset_index(drop=True) for cdlog, grupo in eixos.groupby("CDLOG", sort=False)}
+
     lats = []
     lons = []
     falhas = []
     ajustados = []
 
-    for _, row in df.iterrows():
-        idx = row["_idx"]
-        cdlog = row["__geo_cdlog"]
-        numero = int(row["__geo_num"])
-
-        # --- Passo 1: buscar segmentos do CDLOG ---
-        segmentos = gdf_eixos[gdf_eixos["CDLOG"] == cdlog]
+    for idx, cdlog, numero_raw in df[["_idx", "__geo_cdlog", "__geo_num"]].itertuples(index=False, name=None):
+        numero = int(numero_raw)
+        segmentos = segmentos_por_cdlog.get(cdlog)
 
-        if segmentos.empty:
+        if segmentos is None or segmentos.empty:
             lats.append(None)
             lons.append(None)
             falhas.append({
@@ -240,106 +244,116 @@ def geocodificar(df, col_cdlog, col_num, auto_200=False):
             })
             continue
 
-        # --- Passo 2: determinar lado par/ímpar ---
         lado = "Par" if numero % 2 == 0 else "Ímpar"
         ini_col, fim_col = (
             ("NRPARINI", "NRPARFIN") if lado == "Par" else ("NRIMPINI", "NRIMPFIN")
         )
 
-        segmentos = segmentos.copy()
-        segmentos[ini_col] = pd.to_numeric(segmentos[ini_col], errors="coerce")
-        segmentos[fim_col] = pd.to_numeric(segmentos[fim_col], errors="coerce")
-        segmentos = segmentos.dropna(subset=[ini_col, fim_col])
+        if ini_col not in segmentos.columns or fim_col not in segmentos.columns:
+            lats.append(None)
+            lons.append(None)
+            falhas.append({
+                "_idx": idx,
+                "cdlog": cdlog,
+                "numero_atual": numero,
+                "motivo": "Numeração fora do intervalo",
+                "sugestoes": "",
+                "numero_corrigido": "",
+            })
+            continue
+
+        ini_vals = segmentos[ini_col].to_numpy(dtype=float, copy=False)
+        fim_vals = segmentos[fim_col].to_numpy(dtype=float, copy=False)
+        valid_mask = np.isfinite(ini_vals) & np.isfinite(fim_vals)
 
         # --- Passo 3: encontrar segmento com intervalo válido ---
-        cond = (segmentos[ini_col] <= numero) & (segmentos[fim_col] >= numero)
-        segmentos_validos = segmentos[cond]
-
-        if segmentos_validos.empty:
-            # --- Passo 5: intervalo não encontrado — gera sugestões ---
-            sugestoes_str = ""
-            numero_para_interpolar = None
-
-            if not segmentos.empty:
-                diffs = (segmentos[ini_col] - numero).abs()
-                min_index = diffs.idxmin()
-                linha_proxima = segmentos.loc[min_index]
-
-                ini = linha_proxima[ini_col]
-                fim = linha_proxima[fim_col]
-
-                if pd.notna(ini) and pd.notna(fim):
-                    ini_i, fim_i = int(ini), int(fim)
-                    todos = list(range(ini_i, fim_i + 1))
-                    pares = sorted([n for n in todos if n % 2 == 0], key=lambda x: abs(x - numero))
-                    impares = sorted([n for n in todos if n % 2 != 0], key=lambda x: abs(x - numero))
-                    sugestoes = sorted(pares[:5] + impares[:5], key=lambda x: abs(x - numero))
-                    sugestoes_str = ", ".join(map(str, sugestoes))
-
-                    # Auto-correção ≤ 200
-                    if sugestoes and auto_200:
-                        melhor = sugestoes[0]
-                        diferenca = abs(numero - melhor)
-                        if diferenca <= 200:
-                            numero_para_interpolar = melhor
-                            ajustados.append({
-                                "idx": idx,
-                                "numero_original": numero,
-                                "numero_usado": melhor,
-                            })
-
-            if numero_para_interpolar is not None:
-                # Interpola com o número corrigido automaticamente
-                cond2 = (segmentos[ini_col] <= numero_para_interpolar) & \
-                        (segmentos[fim_col] >= numero_para_interpolar)
-                seg2 = segmentos[cond2]
-                if seg2.empty:
-                    # Usa segmento mais próximo mesmo assim
-                    seg2 = segmentos.loc[[min_index]]
-
-                linha = seg2.iloc[0]
-                geom = linha.geometry
-                ini_v = linha[ini_col]
-                fim_v = linha[fim_col]
-
-                if fim_v == ini_v:
-                    lats.append(None)
-                    lons.append(None)
-                else:
-                    frac = (numero_para_interpolar - ini_v) / (fim_v - ini_v)
-                    frac = max(0.0, min(1.0, frac))
-                    ponto = geom.interpolate(geom.length * frac)
-                    lons.append(ponto.x)
-                    lats.append(ponto.y)
-            else:
+        cond = valid_mask & (ini_vals <= numero) & (fim_vals >= numero)
+
+        if cond.any():
+            pos = int(np.flatnonzero(cond)[0])
+            linha = segmentos.iloc[pos]
+            geom = linha.geometry
+            ini = ini_vals[pos]
+            fim = fim_vals[pos]
+
+            if fim == ini:
                 lats.append(None)
                 lons.append(None)
-                falhas.append({
-                    "_idx": idx,
-                    "cdlog": cdlog,
-                    "numero_atual": numero,
-                    "motivo": "Numeração fora do intervalo",
-                    "sugestoes": sugestoes_str,
-                    "numero_corrigido": "",
-                })
+                continue
+
+            frac = (numero - ini) / (fim - ini)
+            frac = max(0.0, min(1.0, frac))
+            ponto = geom.interpolate(geom.length * frac)
+            lons.append(ponto.x)
+            lats.append(ponto.y)
             continue
 
-        # --- Passo 4: interpolação normal ---
-        linha = segmentos_validos.iloc[0]
-        geom = linha.geometry
-        ini = linha[ini_col]
-        fim = linha[fim_col]
+        # --- Passo 5: intervalo não encontrado — gera sugestões ---
+        sugestoes_str = ""
+        numero_para_interpolar = None
+        min_pos = None
+        valid_positions = np.flatnonzero(valid_mask)
+
+        if valid_positions.size > 0:
+            ini_valid = ini_vals[valid_positions]
+            diffs = np.abs(ini_valid - numero)
+            min_pos = int(valid_positions[int(np.argmin(diffs))])
+
+            ini = ini_vals[min_pos]
+            fim = fim_vals[min_pos]
+
+            if pd.notna(ini) and pd.notna(fim):
+                ini_i, fim_i = int(ini), int(fim)
+                todos = list(range(ini_i, fim_i + 1))
+                pares = sorted([n for n in todos if n % 2 == 0], key=lambda x: abs(x - numero))
+                impares = sorted([n for n in todos if n % 2 != 0], key=lambda x: abs(x - numero))
+                sugestoes = sorted(pares[:5] + impares[:5], key=lambda x: abs(x - numero))
+                sugestoes_str = ", ".join(map(str, sugestoes))
+
+                if sugestoes and auto_200:
+                    melhor = sugestoes[0]
+                    diferenca = abs(numero - melhor)
+                    if diferenca <= 200:
+                        numero_para_interpolar = melhor
+                        ajustados.append({
+                            "idx": idx,
+                            "numero_original": numero,
+                            "numero_usado": melhor,
+                        })
+
+        if numero_para_interpolar is not None and min_pos is not None:
+            cond2 = valid_mask & (ini_vals <= numero_para_interpolar) & (fim_vals >= numero_para_interpolar)
+            if cond2.any():
+                pos2 = int(np.flatnonzero(cond2)[0])
+            else:
+                pos2 = min_pos
 
-        if fim == ini:
-            lats.append(None)
-            lons.append(None)
+            linha = segmentos.iloc[pos2]
+            geom = linha.geometry
+            ini_v = ini_vals[pos2]
+            fim_v = fim_vals[pos2]
+
+            if fim_v == ini_v:
+                lats.append(None)
+                lons.append(None)
+            else:
+                frac = (numero_para_interpolar - ini_v) / (fim_v - ini_v)
+                frac = max(0.0, min(1.0, frac))
+                ponto = geom.interpolate(geom.length * frac)
+                lons.append(ponto.x)
+                lats.append(ponto.y)
             continue
 
-        frac = (numero - ini) / (fim - ini)
-        frac = max(0.0, min(1.0, frac))
-        ponto = geom.interpolate(geom.length * frac)
-        lons.append(ponto.x)
-        lats.append(ponto.y)
+        lats.append(None)
+        lons.append(None)
+        falhas.append({
+            "_idx": idx,
+            "cdlog": cdlog,
+            "numero_atual": numero,
+            "motivo": "Numeração fora do intervalo",
+            "sugestoes": sugestoes_str,
+            "numero_corrigido": "",
+        })
 
     df["lat"] = lats
     df["lon"] = lons
@@ -408,18 +422,21 @@ def aplicar_correcoes_e_regeodificar(df_original, df_falhas, col_cdlog, col_num,
     if "_idx" not in df.columns:
         df["_idx"] = range(len(df))
 
-    # Aplica correções e rastreia quais _idx foram corrigidos manualmente
-    manuais = []
-    for _, row in df_falhas.iterrows():
-        corrigido = str(row.get("numero_corrigido", "")).strip()
-        if corrigido and corrigido not in ("", "nan"):
-            try:
-                novo_num = int(float(corrigido))
-                idx = row["_idx"]
-                df.loc[df["_idx"] == idx, col_num] = novo_num
-                manuais.append(idx)
-            except (ValueError, TypeError):
-                pass
+    # Aplica correções de forma vetorizada por _idx.
+    manuais: list[int] = []
+    if isinstance(df_falhas, pd.DataFrame) and not df_falhas.empty and "_idx" in df_falhas.columns:
+        correcoes = df_falhas.loc[:, ["_idx", "numero_corrigido"]].copy()
+        correcoes["__novo_num"] = pd.to_numeric(correcoes["numero_corrigido"], errors="coerce")
+        correcoes = correcoes.dropna(subset=["_idx", "__novo_num"])
+        if not correcoes.empty:
+            correcoes["__novo_num"] = correcoes["__novo_num"].astype(int)
+            manuais = correcoes["_idx"].tolist()
+
+            mapa = correcoes.drop_duplicates(subset=["_idx"], keep="last").set_index("_idx")["__novo_num"]
+            novos = df["_idx"].map(mapa)
+            mask = novos.notna()
+            if mask.any():
+                df.loc[mask, col_num] = novos[mask].astype(int).to_numpy()
 
     df_resultado, df_falhas_novas, ajustados = geocodificar(df, col_cdlog, col_num, auto_200)
     return df_resultado, df_falhas_novas, ajustados, manuais

backend/app/services/elaboracao_service.py

@@ -1408,11 +1408,12 @@ def aplicar_correcoes_geocodificacao(
 
     if "numero_corrigido" not in df_falhas.columns:
         df_falhas["numero_corrigido"] = ""
-
-    for idx, row in df_falhas.iterrows():
-        linha = int(row.get("_idx"))
-        valor = mapa_correcao.get(linha, "")
-        df_falhas.at[idx, "numero_corrigido"] = valor
+    if mapa_correcao:
+        linhas_ref = pd.to_numeric(df_falhas["_idx"], errors="coerce")
+        valores_corrigidos = linhas_ref.map(mapa_correcao).fillna("")
+        df_falhas["numero_corrigido"] = valores_corrigidos.astype(str)
+    else:
+        df_falhas["numero_corrigido"] = ""
 
     try:
         df_resultado, df_falhas_novas, ajustados, manuais = geocodificacao.aplicar_correcoes_e_regeodificar(

backend/app/services/pesquisa_service.py

@@ -11,6 +11,7 @@ from threading import Lock
 from typing import Any
 
 import folium
+import numpy as np
 import pandas as pd
 from fastapi import HTTPException
 from joblib import load
@@ -741,10 +742,9 @@ def _coletar_pontos_modelo(df_modelo: pd.DataFrame, limite_pontos: int) -> list[
         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
+    lat_vals = base[col_lat].to_numpy(dtype=float, copy=False)
+    lon_vals = base[col_lon].to_numpy(dtype=float, copy=False)
+    return [{"lat": float(lat), "lon": float(lon)} for lat, lon in zip(lat_vals, lon_vals)]
 
 
 def _identificar_coluna_por_alias(colunas: Any, aliases: list[str]) -> str | None:
@@ -873,19 +873,17 @@ def _extrair_faixa_por_alias(estat_df: pd.DataFrame | None, aliases: list[str])
     if min_col is None or max_col is None:
         return None
 
-    mins: list[Any] = []
-    maxs: list[Any] = []
+    nomes = estat_indexado.index.astype(str).tolist()
+    if not nomes:
+        return None
 
-    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)
+    mask_alias = np.fromiter((_has_alias(nome, aliases) for nome in nomes), dtype=bool, count=len(nomes))
+    if not mask_alias.any():
+        return None
+
+    trabalho = estat_indexado.loc[mask_alias, [min_col, max_col]]
+    mins = [valor for valor in trabalho[min_col].tolist() if not _is_empty(valor)]
+    maxs = [valor for valor in trabalho[max_col].tolist() if not _is_empty(valor)]
 
     if not mins and not maxs:
         return None
@@ -912,14 +910,15 @@ def _resumo_variaveis(estat_df: pd.DataFrame | None, limite: int = 12) -> list[d
         return []
 
     linhas: list[dict[str, Any]] = []
-    for var, linha in trabalho.iterrows():
-        min_val = linha.get(min_col)
-        max_val = linha.get(max_col)
+    nomes = trabalho.index.astype(str).tolist()
+    mins = trabalho[min_col].tolist()
+    maxs = trabalho[max_col].tolist()
+    for var, min_val, max_val in zip(nomes, mins, maxs):
         if _is_empty(min_val) and _is_empty(max_val):
             continue
         linhas.append(
             {
-                "variavel": str(var),
+                "variavel": var,
                 "min": sanitize_value(min_val),
                 "max": sanitize_value(max_val),
             }
@@ -1605,13 +1604,15 @@ def _indexar_faixas_variaveis(estat_df: pd.DataFrame | None, variaveis_modelo: l
     variaveis_norm = {_normalize(item) for item in (variaveis_modelo or []) if _str_or_none(item)}
     indice: dict[str, dict[str, Any]] = {}
 
-    for variavel, linha in trabalho.iterrows():
-        nome = str(variavel)
+    nomes = trabalho.index.astype(str).tolist()
+    mins = trabalho[min_col].tolist()
+    maxs = trabalho[max_col].tolist()
+    for nome, min_bruto, max_bruto in zip(nomes, mins, maxs):
         if variaveis_norm and _normalize(nome) not in variaveis_norm:
             continue
 
-        min_val = sanitize_value(linha.get(min_col))
-        max_val = sanitize_value(linha.get(max_col))
+        min_val = sanitize_value(min_bruto)
+        max_val = sanitize_value(max_bruto)
         if _is_empty(min_val) and _is_empty(max_val):
             continue
         indice[nome] = {

backend/app/services/serializers.py

@@ -67,7 +67,8 @@ def dataframe_to_payload(df: pd.DataFrame | None, decimals: int | None = None, m
     if df is None:
         return None
 
-    df_work = df.copy()
+    # Evita cópia quando não há transformação necessária.
+    df_work = df if decimals is None else df.copy()
     if decimals is not None:
         numeric_cols = [
             col
@@ -82,16 +83,18 @@ def dataframe_to_payload(df: pd.DataFrame | None, decimals: int | None = None, m
     if truncated:
         df_work = df_work.head(max_rows)
 
+    columns = [str(c) for c in df_work.columns]
     rows: list[dict[str, Any]] = []
-    for idx, row in df_work.iterrows():
-        payload_row = {"_index": sanitize_value(idx)}
-        for col, value in row.items():
-            payload_row[str(col)] = sanitize_value(value)
+    # itertuples é significativamente mais leve que iterrows para payloads grandes.
+    for tuple_row in df_work.itertuples(index=True, name=None):
+        payload_row = {"_index": sanitize_value(tuple_row[0])}
+        for col, value in zip(columns, tuple_row[1:]):
+            payload_row[col] = sanitize_value(value)
         rows.append(payload_row)
 
-    columns = ["_index"] + [str(c) for c in df_work.columns]
+    columns_payload = ["_index"] + columns
     return {
-        "columns": columns,
+        "columns": columns_payload,
         "rows": rows,
         "total_rows": total_rows,
         "returned_rows": len(rows),

frontend/src/App.jsx

@@ -64,11 +64,9 @@ export default function App() {
         <InicioTab />
       </div>
 
-      {activeTab === 'Pesquisa' ? (
-        <div className="tab-pane">
-          <PesquisaTab />
-        </div>
-      ) : null}
+      <div className="tab-pane" hidden={activeTab !== 'Pesquisa'}>
+        <PesquisaTab />
+      </div>
 
       <div className="tab-pane" hidden={activeTab !== 'Elaboração/Edição'}>
         <ElaboracaoTab sessionId={sessionId} />

frontend/src/components/ElaboracaoTab.jsx

@@ -1,5 +1,6 @@
 import React, { useEffect, useMemo, useRef, useState } from 'react'
 import { api, downloadBlob } from '../api'
+import Plotly from 'plotly.js-dist-min'
 import DataTable from './DataTable'
 import LoadingOverlay from './LoadingOverlay'
 import MapFrame from './MapFrame'
@@ -45,6 +46,355 @@ function joinSelection(values) {
   return values.join(', ')
 }
 
+function normalizeSnapshotArray(values) {
+  if (!Array.isArray(values)) return []
+  return [...new Set(values.map((item) => String(item).trim()).filter(Boolean))].sort()
+}
+
+function buildSelectionSnapshot(payload = {}) {
+  return JSON.stringify({
+    coluna_y: String(payload.coluna_y || '').trim(),
+    colunas_x: normalizeSnapshotArray(payload.colunas_x),
+    dicotomicas: normalizeSnapshotArray(payload.dicotomicas),
+    codigo_alocado: normalizeSnapshotArray(payload.codigo_alocado),
+    percentuais: normalizeSnapshotArray(payload.percentuais),
+  })
+}
+
+function buildGrauSnapshot(grauCoef, grauF) {
+  return `${Number(grauCoef) || 0}|${Number(grauF) || 0}`
+}
+
+function buildTransformacoesSnapshot(transformacaoY, transformacoesX) {
+  const transformacoesOrdenadas = Object.entries(transformacoesX || {})
+    .map(([coluna, valor]) => [String(coluna), String(valor || '(x)')])
+    .sort(([a], [b]) => a.localeCompare(b, 'pt-BR'))
+  return JSON.stringify({
+    transformacao_y: String(transformacaoY || '(x)'),
+    transformacoes_x: transformacoesOrdenadas,
+  })
+}
+
+function buildFiltrosSnapshot(filtros) {
+  if (!Array.isArray(filtros)) return '[]'
+  return JSON.stringify(
+    filtros.map((item) => ({
+      variavel: String(item?.variavel || ''),
+      operador: String(item?.operador || ''),
+      valor: Number(item?.valor ?? 0),
+    })),
+  )
+}
+
+function buildOutlierTextSnapshot(outliersTexto, reincluirTexto) {
+  return JSON.stringify({
+    outliers: String(outliersTexto || '').trim(),
+    reincluir: String(reincluirTexto || '').trim(),
+  })
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => {
+    window.setTimeout(resolve, ms)
+  })
+}
+
+function toCsvCell(value, separator = ';') {
+  const text = String(value ?? '')
+  const escaped = text.replace(/"/g, '""')
+  if (escaped.includes('"') || escaped.includes('\n') || escaped.includes('\r') || escaped.includes(separator)) {
+    return `"${escaped}"`
+  }
+  return escaped
+}
+
+function tableToCsvBlob(table) {
+  if (!table || !Array.isArray(table.columns) || !Array.isArray(table.rows) || table.columns.length === 0) return null
+
+  const separator = ';'
+  const header = table.columns.map((col) => toCsvCell(col, separator)).join(separator)
+  const lines = [header]
+
+  table.rows.forEach((row) => {
+    const values = table.columns.map((col) => toCsvCell(row?.[col], separator))
+    lines.push(values.join(separator))
+  })
+
+  const csv = `\uFEFF${lines.join('\n')}`
+  return new Blob([csv], { type: 'text/csv;charset=utf-8;' })
+}
+
+function sanitizeFileName(name, fallback = 'arquivo') {
+  const safe = String(name || '')
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[^A-Za-z0-9._-]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+  return safe || fallback
+}
+
+function buildFigureForExport(figure, forceHideLegend = false) {
+  if (!figure || typeof figure !== 'object') return null
+
+  const data = (figure.data || []).map((trace) => {
+    if (!forceHideLegend) return trace
+    return { ...trace, showlegend: false }
+  })
+
+  const baseLayout = figure.layout || {}
+  const { width: _ignoreWidth, ...layoutNoWidth } = baseLayout
+  const safeAnnotations = Array.isArray(baseLayout.annotations)
+    ? baseLayout.annotations.map((annotation) => {
+        const {
+          ax,
+          ay,
+          axref,
+          ayref,
+          arrowhead,
+          arrowsize,
+          arrowwidth,
+          arrowcolor,
+          standoff,
+          ...clean
+        } = annotation || {}
+        return { ...clean, showarrow: false }
+      })
+    : baseLayout.annotations
+
+  const width = Math.max(1100, Number(baseLayout.width) || 1100)
+  const height = Math.max(640, Number(baseLayout.height) || 640)
+  const layout = {
+    ...layoutNoWidth,
+    autosize: false,
+    width,
+    height,
+    annotations: safeAnnotations,
+    margin: baseLayout.margin || { t: 40, r: 20, b: 50, l: 50 },
+  }
+  if (forceHideLegend) {
+    layout.showlegend = false
+  }
+
+  return { data, layout, width, height }
+}
+
+function normalizeAxisRef(axisRef, axisType) {
+  const raw = String(axisRef || '').trim().toLowerCase()
+  if (!raw || raw === axisType) return `${axisType}axis`
+  if (raw.startsWith(`${axisType}axis`)) return raw
+  if (raw.startsWith(axisType)) return `${axisType}axis${raw.slice(axisType.length)}`
+  return `${axisType}axis`
+}
+
+function axisKeyToToken(axisKey, axisType) {
+  const normalized = normalizeAxisRef(axisKey, axisType)
+  if (normalized === `${axisType}axis`) return axisType
+  return `${axisType}${normalized.replace(`${axisType}axis`, '')}`
+}
+
+function getAxisTitleText(axisObj) {
+  if (!axisObj || typeof axisObj !== 'object') return ''
+  const title = axisObj.title
+  if (typeof title === 'string') return String(title).trim()
+  if (title && typeof title === 'object') {
+    return String(title.text || '').trim()
+  }
+  return ''
+}
+
+function stripHtmlText(value) {
+  return String(value || '')
+    .replace(/<br\s*\/?>/gi, ' ')
+    .replace(/<[^>]*>/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+function parsePanelHeading(tituloHtml, fallbackTitle) {
+  const raw = String(tituloHtml || '').trim()
+  const fallback = String(fallbackTitle || '').trim() || 'Gráfico'
+  if (!raw) {
+    return { title: fallback, subtitle: '' }
+  }
+
+  const parts = raw
+    .split(/<br\s*\/?>|\n/gi)
+    .map((part) => stripHtmlText(part))
+    .filter(Boolean)
+
+  if (parts.length === 0) {
+    return { title: fallback, subtitle: '' }
+  }
+
+  const [first, ...rest] = parts
+  const subtitleRaw = rest.join(' • ').trim()
+  const subtitle = /^r\s*=/i.test(subtitleRaw)
+    ? `Correlação (${subtitleRaw.replace(/\s+/g, ' ').replace(/^r\s*=/i, 'r =').trim()})`
+    : subtitleRaw
+
+  return {
+    title: first || fallback,
+    subtitle,
+  }
+}
+
+function matchesShapeAxisRef(ref, token) {
+  const text = String(ref || '').trim().toLowerCase()
+  if (!text) return false
+  return text === token || text === `${token} domain`
+}
+
+function filterShapesForPanel(layoutShapes, xToken, yToken) {
+  if (!Array.isArray(layoutShapes)) return []
+  return layoutShapes.filter((shape) => {
+    const xref = String(shape?.xref || '').trim().toLowerCase()
+    const yref = String(shape?.yref || '').trim().toLowerCase()
+    const hasX = matchesShapeAxisRef(xref, xToken)
+    const hasY = matchesShapeAxisRef(yref, yToken)
+
+    if (hasX && hasY) return true
+    if (hasX && !yref) return true
+    if (hasY && !xref) return true
+    return false
+  })
+}
+
+function stylePanelTrace(trace) {
+  const mode = String(trace?.mode || '')
+  const traceName = String(trace?.name || '').toLowerCase()
+  const hasMarkers = mode.includes('markers')
+  const hasLines = mode.includes('lines')
+  const next = { ...trace, showlegend: false }
+
+  if (hasMarkers) {
+    next.marker = {
+      ...(trace?.marker || {}),
+      color: '#FF8C00',
+      size: Number(trace?.marker?.size) || 8,
+      opacity: trace?.marker?.opacity ?? 0.84,
+      line: {
+        color: '#1f2933',
+        width: 1,
+        ...(trace?.marker?.line || {}),
+      },
+    }
+  }
+
+  if (hasLines) {
+    const currentDash = String(trace?.line?.dash || '').trim()
+    next.line = {
+      ...(trace?.line || {}),
+      color: trace?.line?.color || '#dc3545',
+      width: Number(trace?.line?.width) || 2,
+      dash: currentDash || (traceName.includes('regress') ? 'solid' : 'dash'),
+    }
+  }
+
+  return next
+}
+
+function buildScatterPanels(figure, options = {}) {
+  if (!figure || typeof figure !== 'object') return []
+  const data = Array.isArray(figure.data) ? figure.data : []
+  const rawLayout = figure.layout || {}
+  const { title: _ignoreTitle, ...layout } = rawLayout
+  if (data.length === 0) return []
+
+  const grouped = new Map()
+  data.forEach((trace, index) => {
+    const xKey = normalizeAxisRef(trace?.xaxis, 'x')
+    const yKey = normalizeAxisRef(trace?.yaxis, 'y')
+    const groupKey = `${xKey}|${yKey}`
+    const current = grouped.get(groupKey) || []
+    current.push({ trace, index, xKey, yKey })
+    grouped.set(groupKey, current)
+  })
+
+  const keys = Array.from(grouped.keys())
+  return keys.map((groupKey, idx) => {
+    const traces = grouped.get(groupKey) || []
+    const markerTrace = traces.find((item) => String(item?.trace?.mode || '').includes('markers'))?.trace || {}
+    const xKey = traces[0]?.xKey || 'xaxis'
+    const yKey = traces[0]?.yKey || 'yaxis'
+    const xToken = axisKeyToToken(xKey, 'x')
+    const yToken = axisKeyToToken(yKey, 'y')
+    const axisX = layout[xKey] || layout.xaxis || {}
+    const axisY = layout[yKey] || layout.yaxis || {}
+    const xTitle = getAxisTitleText(axisX)
+    const yTitle = getAxisTitleText(axisY)
+    const markerName = String(markerTrace?.name || '').replace(/^Regress[aã]o\s+/i, '').trim()
+    const xName = xTitle || markerName || `Gráfico ${idx + 1}`
+    const yName = String(options.yLabel || yTitle || 'Y').trim()
+    const annotationTitleHtml = String(layout?.annotations?.[idx]?.text || '').trim()
+    const tituloHtml = annotationTitleHtml || `${xName} × ${yName}`
+    const heading = parsePanelHeading(tituloHtml, `${xName} × ${yName}`)
+
+    const label = xName
+    const panelTraces = traces.map((item) => stylePanelTrace({
+      ...item.trace,
+      xaxis: 'x',
+      yaxis: 'y',
+    }))
+
+    const panelFigure = {
+      data: panelTraces,
+      layout: {
+        ...layout,
+        showlegend: false,
+        autosize: true,
+        height: options.height || 360,
+        plot_bgcolor: 'white',
+        paper_bgcolor: 'white',
+        margin: { t: 18, r: 18, b: 44, l: 56 },
+        annotations: [],
+        shapes: filterShapesForPanel(layout.shapes, xToken, yToken),
+        xaxis: {
+          ...axisX,
+          domain: undefined,
+          anchor: undefined,
+          matches: undefined,
+          scaleanchor: undefined,
+          scaleratio: undefined,
+          overlaying: undefined,
+          position: undefined,
+          side: axisX.side || 'bottom',
+          showgrid: true,
+          gridcolor: '#d7dde3',
+          showline: true,
+          linecolor: '#1f2933',
+          zeroline: false,
+        },
+        yaxis: {
+          ...axisY,
+          domain: undefined,
+          anchor: undefined,
+          matches: undefined,
+          scaleanchor: undefined,
+          scaleratio: undefined,
+          overlaying: undefined,
+          position: undefined,
+          side: axisY.side || 'left',
+          showgrid: true,
+          gridcolor: '#d7dde3',
+          showline: true,
+          linecolor: '#1f2933',
+          zeroline: false,
+        },
+      },
+    }
+
+    const legenda = [heading.title, heading.subtitle].filter(Boolean).join(' - ')
+    return {
+      id: `${groupKey}-${idx}`,
+      label,
+      title: heading.title,
+      subtitle: heading.subtitle,
+      legenda,
+      figure: panelFigure,
+    }
+  })
+}
+
 function formatConselhoRegistro(elaborador) {
   if (!elaborador) return ''
   const conselho = String(elaborador.conselho || '').trim()
@@ -144,6 +494,7 @@ function obterLabelGrau(listaGraus, valor) {
 
 export default function ElaboracaoTab({ sessionId }) {
   const [loading, setLoading] = useState(false)
+  const [downloadingAssets, setDownloadingAssets] = useState(false)
   const [error, setError] = useState('')
   const [status, setStatus] = useState('')
 
@@ -175,6 +526,7 @@ export default function ElaboracaoTab({ sessionId }) {
 
   const [colunasNumericas, setColunasNumericas] = useState([])
   const [colunaY, setColunaY] = useState('')
+  const [colunaYDraft, setColunaYDraft] = useState('')
   const [colunasX, setColunasX] = useState([])
   const [dicotomicas, setDicotomicas] = useState([])
   const [codigoAlocado, setCodigoAlocado] = useState([])
@@ -182,6 +534,7 @@ export default function ElaboracaoTab({ sessionId }) {
   const [colunasDataMercado, setColunasDataMercado] = useState([])
   const [colunaDataMercadoSugerida, setColunaDataMercadoSugerida] = useState('')
   const [colunaDataMercado, setColunaDataMercado] = useState('')
+  const [colunaDataMercadoAplicada, setColunaDataMercadoAplicada] = useState('')
   const [periodoDadosMercado, setPeriodoDadosMercado] = useState(null)
   const [periodoDadosMercadoPreview, setPeriodoDadosMercadoPreview] = useState(null)
   const [dataMercadoError, setDataMercadoError] = useState('')
@@ -214,6 +567,7 @@ export default function ElaboracaoTab({ sessionId }) {
   const [camposAvaliacao, setCamposAvaliacao] = useState([])
   const valoresAvaliacaoRef = useRef({})
   const [avaliacaoFormVersion, setAvaliacaoFormVersion] = useState(0)
+  const [avaliacaoPendente, setAvaliacaoPendente] = useState(false)
   const [resultadoAvaliacaoHtml, setResultadoAvaliacaoHtml] = useState('')
   const [baseChoices, setBaseChoices] = useState([])
   const [baseValue, setBaseValue] = useState('')
@@ -222,6 +576,11 @@ export default function ElaboracaoTab({ sessionId }) {
   const [avaliadores, setAvaliadores] = useState([])
   const [avaliadorSelecionado, setAvaliadorSelecionado] = useState('')
   const [tipoFonteDados, setTipoFonteDados] = useState('')
+  const [selectionAppliedSnapshot, setSelectionAppliedSnapshot] = useState(() => buildSelectionSnapshot())
+  const [buscaTransformAppliedSnapshot, setBuscaTransformAppliedSnapshot] = useState(() => buildGrauSnapshot(0, 0))
+  const [manualTransformAppliedSnapshot, setManualTransformAppliedSnapshot] = useState(() => buildTransformacoesSnapshot('(x)', {}))
+  const [outlierFiltrosAplicadosSnapshot, setOutlierFiltrosAplicadosSnapshot] = useState(() => buildFiltrosSnapshot(defaultFiltros()))
+  const [outlierTextosAplicadosSnapshot, setOutlierTextosAplicadosSnapshot] = useState(() => buildOutlierTextSnapshot('', ''))
   const marcarTodasXRef = useRef(null)
   const classificarXReqRef = useRef(0)
   const deleteConfirmTimersRef = useRef({})
@@ -229,7 +588,7 @@ export default function ElaboracaoTab({ sessionId }) {
 
   const mapaChoices = useMemo(() => ['Visualização Padrão', ...colunasNumericas], [colunasNumericas])
   const colunasXDisponiveis = useMemo(
-    () => colunasNumericas.filter((coluna) => coluna !== colunaY),
+    () => (colunaY ? colunasNumericas.filter((coluna) => coluna !== colunaY) : []),
     [colunasNumericas, colunaY],
   )
   const todasXMarcadas = useMemo(
@@ -269,6 +628,65 @@ export default function ElaboracaoTab({ sessionId }) {
     () => formatPeriodoDadosMercado(periodoDadosMercadoPreview),
     [periodoDadosMercadoPreview],
   )
+  const pendingWarningText = 'Há alterações em campos que ainda não foram aplicadas.'
+  const dataMercadoPendente = useMemo(
+    () => String(colunaDataMercado || '') !== String(colunaDataMercadoAplicada || ''),
+    [colunaDataMercado, colunaDataMercadoAplicada],
+  )
+  const dependentePendente = useMemo(
+    () => String(colunaYDraft || '') !== String(colunaY || ''),
+    [colunaYDraft, colunaY],
+  )
+  const selectionSnapshotAtual = useMemo(
+    () => buildSelectionSnapshot({
+      coluna_y: colunaY,
+      colunas_x: colunasX,
+      dicotomicas,
+      codigo_alocado: codigoAlocado,
+      percentuais,
+    }),
+    [colunaY, colunasX, dicotomicas, codigoAlocado, percentuais],
+  )
+  const selecaoTemDados = useMemo(
+    () => Boolean(colunaY) && colunasX.length > 0,
+    [colunaY, colunasX],
+  )
+  const selecaoPendente = useMemo(
+    () => selecaoTemDados && selectionSnapshotAtual !== selectionAppliedSnapshot,
+    [selecaoTemDados, selectionSnapshotAtual, selectionAppliedSnapshot],
+  )
+  const buscaTransformSnapshotAtual = useMemo(
+    () => buildGrauSnapshot(grauCoef, grauF),
+    [grauCoef, grauF],
+  )
+  const buscaTransformPendente = useMemo(
+    () => Boolean(selection) && buscaTransformSnapshotAtual !== buscaTransformAppliedSnapshot,
+    [selection, buscaTransformSnapshotAtual, buscaTransformAppliedSnapshot],
+  )
+  const manualTransformSnapshotAtual = useMemo(
+    () => buildTransformacoesSnapshot(transformacaoY, transformacoesX),
+    [transformacaoY, transformacoesX],
+  )
+  const manualTransformPendente = useMemo(
+    () => Boolean(selection) && Boolean(section10ManualOpen) && manualTransformSnapshotAtual !== manualTransformAppliedSnapshot,
+    [selection, section10ManualOpen, manualTransformSnapshotAtual, manualTransformAppliedSnapshot],
+  )
+  const outlierFiltrosSnapshotAtual = useMemo(
+    () => buildFiltrosSnapshot(filtros),
+    [filtros],
+  )
+  const outlierFiltrosPendentes = useMemo(
+    () => Boolean(fit) && outlierFiltrosSnapshotAtual !== outlierFiltrosAplicadosSnapshot,
+    [fit, outlierFiltrosSnapshotAtual, outlierFiltrosAplicadosSnapshot],
+  )
+  const outlierTextosSnapshotAtual = useMemo(
+    () => buildOutlierTextSnapshot(outliersTexto, reincluirTexto),
+    [outliersTexto, reincluirTexto],
+  )
+  const outlierTextosPendentes = useMemo(
+    () => Boolean(fit) && outlierTextosSnapshotAtual !== outlierTextosAplicadosSnapshot,
+    [fit, outlierTextosSnapshotAtual, outlierTextosAplicadosSnapshot],
+  )
   const transformacaoAplicadaYBadge = useMemo(
     () => formatTransformacaoBadge(transformacoesAplicadas?.transformacao_y),
     [transformacoesAplicadas],
@@ -297,6 +715,32 @@ export default function ElaboracaoTab({ sessionId }) {
     }
     return ''
   }, [origemTransformacoes])
+  const graficosSecao9 = useMemo(
+    () => buildScatterPanels(selection?.grafico_dispersao, {
+      singleLabel: 'Dispersão',
+      height: 360,
+      yLabel: colunaY || 'Y',
+    }),
+    [selection?.grafico_dispersao, colunaY],
+  )
+  const colunasGraficosSecao9 = useMemo(
+    () => Math.max(1, Math.min(3, graficosSecao9.length || 1)),
+    [graficosSecao9.length],
+  )
+  const graficosSecao12 = useMemo(
+    () => buildScatterPanels(fit?.grafico_dispersao_modelo, {
+      singleLabel: 'Dispersão do modelo',
+      height: 360,
+      yLabel: tipoDispersao.includes('Resíduo')
+        ? 'Resíduo Padronizado'
+        : `${colunaY || 'Y'} (transformada)`,
+    }),
+    [fit?.grafico_dispersao_modelo, tipoDispersao, colunaY],
+  )
+  const colunasGraficosSecao12 = useMemo(
+    () => Math.max(1, Math.min(3, graficosSecao12.length || 1)),
+    [graficosSecao12.length],
+  )
   const showCoordsPanel = Boolean(
     coordsInfo && (
       !coordsInfo.tem_coords ||
@@ -408,6 +852,7 @@ export default function ElaboracaoTab({ sessionId }) {
 
   function applyBaseResponse(resp, options = {}) {
     const resetXSelection = Boolean(options.resetXSelection)
+    const colunaYPadrao = String(resp.coluna_y_padrao || '')
     setDataMercadoError('')
     if (resp.status) setStatus(resp.status)
     if (resp.dados) setDados(resp.dados)
@@ -420,44 +865,74 @@ export default function ElaboracaoTab({ sessionId }) {
       setColunaDataMercadoSugerida(String(resp.coluna_data_mercado_sugerida || ''))
     }
     if (Object.prototype.hasOwnProperty.call(resp, 'coluna_data_mercado')) {
-      setColunaDataMercado(String(resp.coluna_data_mercado || ''))
+      const colunaData = String(resp.coluna_data_mercado || '')
+      setColunaDataMercado(colunaData)
+      setColunaDataMercadoAplicada(colunaData)
     }
     if (Object.prototype.hasOwnProperty.call(resp, 'periodo_dados_mercado')) {
       const periodo = normalizePeriodoDadosMercado(resp.periodo_dados_mercado)
       setPeriodoDadosMercado(periodo)
       setPeriodoDadosMercadoPreview(periodo)
     }
-    if (resp.coluna_y_padrao) setColunaY(resp.coluna_y_padrao)
+    if (Object.prototype.hasOwnProperty.call(resp, 'coluna_y_padrao')) {
+      setColunaY(colunaYPadrao)
+      setColunaYDraft(colunaYPadrao)
+    }
 
     if (resp.contexto && !resetXSelection) {
-      setColunaY(resp.contexto.coluna_y || resp.coluna_y_padrao || '')
-      setColunasX(resp.contexto.colunas_x || [])
-      setDicotomicas(resp.contexto.dicotomicas || [])
-      setCodigoAlocado(resp.contexto.codigo_alocado || [])
-      setPercentuais(resp.contexto.percentuais || [])
+      const colunaYContexto = String(resp.contexto.coluna_y || colunaYPadrao || '')
+      const colunasXContexto = resp.contexto.colunas_x || []
+      const dicotomicasContexto = resp.contexto.dicotomicas || []
+      const codigoAlocadoContexto = resp.contexto.codigo_alocado || []
+      const percentuaisContexto = resp.contexto.percentuais || []
+      setColunaY(colunaYContexto)
+      setColunaYDraft(colunaYContexto)
+      setColunasX(colunasXContexto)
+      setDicotomicas(dicotomicasContexto)
+      setCodigoAlocado(codigoAlocadoContexto)
+      setPercentuais(percentuaisContexto)
+      setSelectionAppliedSnapshot(buildSelectionSnapshot({
+        coluna_y: colunaYContexto,
+        colunas_x: colunasXContexto,
+        dicotomicas: dicotomicasContexto,
+        codigo_alocado: codigoAlocadoContexto,
+        percentuais: percentuaisContexto,
+      }))
       setOutliersAnteriores(resp.contexto.outliers_anteriores || [])
       setIteracao(resp.contexto.iteracao || 1)
     } else if (resetXSelection) {
+      setColunaY('')
+      setColunaYDraft(colunaYPadrao)
       setColunasX([])
       setDicotomicas([])
       setCodigoAlocado([])
       setPercentuais([])
+      setSelectionAppliedSnapshot(buildSelectionSnapshot({ coluna_y: '' }))
       setTransformacaoY('(x)')
       setTransformacoesX({})
       setTransformacoesAplicadas(null)
       setOrigemTransformacoes(null)
+      setBuscaTransformAppliedSnapshot(buildGrauSnapshot(grauCoef, grauF))
+      setManualTransformAppliedSnapshot(buildTransformacoesSnapshot('(x)', {}))
       setOutliersAnteriores([])
       setIteracao(1)
       setColunaDataMercadoSugerida('')
       setColunaDataMercado('')
+      setColunaDataMercadoAplicada('')
       setPeriodoDadosMercado(null)
       setPeriodoDadosMercadoPreview(null)
       setDataMercadoError('')
       setSelection(null)
       setFit(null)
+      setFiltros(defaultFiltros())
+      setOutliersTexto('')
+      setReincluirTexto('')
+      setOutlierFiltrosAplicadosSnapshot(buildFiltrosSnapshot(defaultFiltros()))
+      setOutlierTextosAplicadosSnapshot(buildOutlierTextSnapshot('', ''))
       setCamposAvaliacao([])
       valoresAvaliacaoRef.current = {}
       setAvaliacaoFormVersion((prev) => prev + 1)
+      setAvaliacaoPendente(false)
       setResultadoAvaliacaoHtml('')
       setOutliersHtml('')
     }
@@ -488,6 +963,7 @@ export default function ElaboracaoTab({ sessionId }) {
     setSection10ManualOpen(false)
     setTransformacoesAplicadas(null)
     setOrigemTransformacoes(null)
+    const transformacaoYAplicada = resp.transformacao_y || transformacaoY
     if (resp.transformacao_y) {
       setTransformacaoY(resp.transformacao_y)
     }
@@ -497,11 +973,15 @@ export default function ElaboracaoTab({ sessionId }) {
       map[field.coluna] = field.valor || '(x)'
     })
     setTransformacoesX(map)
+    setManualTransformAppliedSnapshot(buildTransformacoesSnapshot(transformacaoYAplicada, map))
 
+    const grauCoefAplicado = resp.busca?.grau_coef ?? grauCoef
+    const grauFAplicado = resp.busca?.grau_f ?? grauF
     if (resp.busca) {
-      setGrauCoef(resp.busca.grau_coef ?? 0)
-      setGrauF(resp.busca.grau_f ?? 0)
+      setGrauCoef(grauCoefAplicado)
+      setGrauF(grauFAplicado)
     }
+    setBuscaTransformAppliedSnapshot(buildGrauSnapshot(grauCoefAplicado, grauFAplicado))
 
     if (resp.resumo_outliers) {
       setResumoOutliers(resp.resumo_outliers)
@@ -518,6 +998,8 @@ export default function ElaboracaoTab({ sessionId }) {
   function applyFitResponse(resp, origemMeta = null) {
     setFit(resp)
     setSection11Open(false)
+    const transformacaoYAplicada = resp.transformacao_y || transformacaoY
+    const transformacoesXAplicadas = resp.transformacoes_x || transformacoesX
     if (resp.transformacao_y) {
       setTransformacaoY(resp.transformacao_y)
     }
@@ -533,12 +1015,15 @@ export default function ElaboracaoTab({ sessionId }) {
         transformacoes_x: resp.transformacoes_x || transformacoesX,
       })
     }
+    setManualTransformAppliedSnapshot(buildTransformacoesSnapshot(transformacaoYAplicada, transformacoesXAplicadas))
     if (origemMeta && origemMeta.origem) {
       setOrigemTransformacoes(origemMeta)
     } else if (resp.origem_transformacoes?.origem) {
       setOrigemTransformacoes(resp.origem_transformacoes)
     }
     setResumoOutliers(resp.resumo_outliers || resumoOutliers)
+    setOutlierFiltrosAplicadosSnapshot(buildFiltrosSnapshot(filtros))
+    setOutlierTextosAplicadosSnapshot(buildOutlierTextSnapshot(outliersTexto, reincluirTexto))
     setCamposAvaliacao(resp.avaliacao_campos || [])
     const init = {}
     ;(resp.avaliacao_campos || []).forEach((campo) => {
@@ -546,6 +1031,7 @@ export default function ElaboracaoTab({ sessionId }) {
     })
     valoresAvaliacaoRef.current = init
     setAvaliacaoFormVersion((prev) => prev + 1)
+    setAvaliacaoPendente(false)
     setResultadoAvaliacaoHtml('')
     setBaseChoices([])
     setBaseValue('')
@@ -580,8 +1066,11 @@ export default function ElaboracaoTab({ sessionId }) {
         applyBaseResponse(resp, { resetXSelection })
       } else if (resp.status) {
         setTipoFonteDados('tabular')
+        setColunaY('')
+        setColunaYDraft('')
         setSelection(null)
         setFit(null)
+        setSelectionAppliedSnapshot(buildSelectionSnapshot())
         setColunasX([])
         setDicotomicas([])
         setCodigoAlocado([])
@@ -590,15 +1079,24 @@ export default function ElaboracaoTab({ sessionId }) {
         setTransformacoesX({})
         setTransformacoesAplicadas(null)
         setOrigemTransformacoes(null)
+        setBuscaTransformAppliedSnapshot(buildGrauSnapshot(0, 0))
+        setManualTransformAppliedSnapshot(buildTransformacoesSnapshot('(x)', {}))
         setColunasDataMercado([])
         setColunaDataMercadoSugerida('')
         setColunaDataMercado('')
+        setColunaDataMercadoAplicada('')
         setPeriodoDadosMercado(null)
         setPeriodoDadosMercadoPreview(null)
         setDataMercadoError('')
+        setFiltros(defaultFiltros())
+        setOutliersTexto('')
+        setReincluirTexto('')
+        setOutlierFiltrosAplicadosSnapshot(buildFiltrosSnapshot(defaultFiltros()))
+        setOutlierTextosAplicadosSnapshot(buildOutlierTextSnapshot('', ''))
         setCamposAvaliacao([])
         valoresAvaliacaoRef.current = {}
         setAvaliacaoFormVersion((prev) => prev + 1)
+        setAvaliacaoPendente(false)
         setResultadoAvaliacaoHtml('')
         setStatus(resp.status)
       }
@@ -661,6 +1159,7 @@ export default function ElaboracaoTab({ sessionId }) {
     const coluna = String(value || '')
     setColunaDataMercado(coluna)
     setDataMercadoError('')
+    setStatus((prev) => (String(prev || '').startsWith('Prévia do período') ? '' : prev))
 
     if (!sessionId || !coluna) {
       setPeriodoDadosMercadoPreview(null)
@@ -672,7 +1171,6 @@ export default function ElaboracaoTab({ sessionId }) {
       const resp = await api.previewMarketDateColumn(sessionId, coluna)
       const periodo = normalizePeriodoDadosMercado(resp.periodo_dados_mercado)
       setPeriodoDadosMercadoPreview(periodo)
-      if (resp.status) setStatus(resp.status)
     } catch (err) {
       setPeriodoDadosMercadoPreview(null)
       setDataMercadoError(err.message || 'Falha ao identificar período da coluna selecionada.')
@@ -686,7 +1184,9 @@ export default function ElaboracaoTab({ sessionId }) {
     await withBusy(async () => {
       const resp = await api.applyMarketDateColumn(sessionId, colunaDataMercado)
       const periodo = normalizePeriodoDadosMercado(resp.periodo_dados_mercado)
-      setColunaDataMercado(String(resp.coluna_data_mercado || colunaDataMercado))
+      const colunaAplicada = String(resp.coluna_data_mercado || colunaDataMercado)
+      setColunaDataMercado(colunaAplicada)
+      setColunaDataMercadoAplicada(colunaAplicada)
       setPeriodoDadosMercado(periodo)
       setPeriodoDadosMercadoPreview(periodo)
       setDataMercadoError('')
@@ -701,6 +1201,46 @@ export default function ElaboracaoTab({ sessionId }) {
     })
   }
 
+  function onAplicarVariavelDependente() {
+    const proximaColunaY = String(colunaYDraft || '')
+    const colunaYAtual = String(colunaY || '')
+    if (proximaColunaY === colunaYAtual) return
+
+    const proximasDisponiveis = colunasNumericas.filter((coluna) => coluna !== proximaColunaY)
+    const proximasX = colunasX.filter((coluna) => proximasDisponiveis.includes(coluna))
+    const proximasDicotomicas = dicotomicas.filter((coluna) => proximasX.includes(coluna))
+    const proximoCodigoAlocado = codigoAlocado.filter((coluna) => proximasX.includes(coluna))
+    const proximosPercentuais = percentuais.filter((coluna) => proximasX.includes(coluna))
+
+    setColunaY(proximaColunaY)
+    setColunasX(proximasX)
+    setDicotomicas(proximasDicotomicas)
+    setCodigoAlocado(proximoCodigoAlocado)
+    setPercentuais(proximosPercentuais)
+    setSelectionAppliedSnapshot(buildSelectionSnapshot({ coluna_y: proximaColunaY }))
+    setSelection(null)
+    setFit(null)
+    setTransformacaoY('(x)')
+    setTransformacoesX({})
+    setTransformacoesAplicadas(null)
+    setOrigemTransformacoes(null)
+    setBuscaTransformAppliedSnapshot(buildGrauSnapshot(grauCoef, grauF))
+    setManualTransformAppliedSnapshot(buildTransformacoesSnapshot('(x)', {}))
+    setOutlierFiltrosAplicadosSnapshot(buildFiltrosSnapshot(defaultFiltros()))
+    setOutlierTextosAplicadosSnapshot(buildOutlierTextSnapshot('', ''))
+    setFiltros(defaultFiltros())
+    setCamposAvaliacao([])
+    valoresAvaliacaoRef.current = {}
+    setAvaliacaoFormVersion((prev) => prev + 1)
+    setAvaliacaoPendente(false)
+    setResultadoAvaliacaoHtml('')
+    setOutliersHtml('')
+    setOutliersTexto('')
+    setReincluirTexto('')
+    setBaseChoices([])
+    setBaseValue('')
+  }
+
   async function onMapCoords() {
     if (!manualLat || !manualLon || !sessionId) return
     setLoading(true)
@@ -802,7 +1342,7 @@ export default function ElaboracaoTab({ sessionId }) {
   async function onApplySelection() {
     if (!sessionId || !colunaY || colunasX.length === 0) return
     await withBusy(async () => {
-      const resp = await api.applySelection({
+      const payload = {
         session_id: sessionId,
         coluna_y: colunaY,
         colunas_x: colunasX,
@@ -812,10 +1352,17 @@ export default function ElaboracaoTab({ sessionId }) {
         outliers_anteriores: outliersAnteriores,
         grau_min_coef: grauCoef,
         grau_min_f: grauF,
-      })
+      }
+      const resp = await api.applySelection(payload)
       applySelectionResponse(resp)
+      setSelectionAppliedSnapshot(buildSelectionSnapshot(payload))
       setFit(null)
+      setOutlierFiltrosAplicadosSnapshot(buildFiltrosSnapshot(defaultFiltros()))
+      setOutlierTextosAplicadosSnapshot(buildOutlierTextSnapshot('', ''))
       setCamposAvaliacao([])
+      valoresAvaliacaoRef.current = {}
+      setAvaliacaoFormVersion((prev) => prev + 1)
+      setAvaliacaoPendente(false)
       setResultadoAvaliacaoHtml('')
     })
   }
@@ -824,9 +1371,12 @@ export default function ElaboracaoTab({ sessionId }) {
     if (!sessionId) return
     await withBusy(async () => {
       const busca = await api.searchTransformations(sessionId, grauCoef, grauF)
+      const grauCoefAplicado = busca.grau_coef ?? grauCoef
+      const grauFAplicado = busca.grau_f ?? grauF
       setSelection((prev) => ({ ...prev, busca }))
-      setGrauCoef(busca.grau_coef ?? grauCoef)
-      setGrauF(busca.grau_f ?? grauF)
+      setGrauCoef(grauCoefAplicado)
+      setGrauF(grauFAplicado)
+      setBuscaTransformAppliedSnapshot(buildGrauSnapshot(grauCoefAplicado, grauFAplicado))
     })
   }
 
@@ -888,6 +1438,7 @@ export default function ElaboracaoTab({ sessionId }) {
       const filtrosValidos = filtros.filter((f) => f.variavel && f.operador)
       const resp = await api.applyOutlierFilters(sessionId, filtrosValidos)
       setOutliersTexto(resp.texto || '')
+      setOutlierFiltrosAplicadosSnapshot(buildFiltrosSnapshot(filtros))
     })
   }
 
@@ -920,6 +1471,7 @@ export default function ElaboracaoTab({ sessionId }) {
       setIteracao(resp.iteracao || iteracao)
       setOutliersTexto('')
       setReincluirTexto('')
+      setOutlierTextosAplicadosSnapshot(buildOutlierTextSnapshot('', ''))
       setFit(null)
       setTransformacoesAplicadas(null)
       setOrigemTransformacoes(null)
@@ -945,10 +1497,16 @@ export default function ElaboracaoTab({ sessionId }) {
       setTransformacoesAplicadas(null)
       setOrigemTransformacoes(null)
       setCamposAvaliacao([])
+      setOutliersTexto('')
+      setReincluirTexto('')
+      setFiltros(defaultFiltros())
       valoresAvaliacaoRef.current = {}
       setAvaliacaoFormVersion((prev) => prev + 1)
+      setAvaliacaoPendente(false)
       setResultadoAvaliacaoHtml('')
       setOutliersHtml(resp.outliers_html || '')
+      setOutlierFiltrosAplicadosSnapshot(buildFiltrosSnapshot(defaultFiltros()))
+      setOutlierTextosAplicadosSnapshot(buildOutlierTextSnapshot('', ''))
     })
   }
 
@@ -959,6 +1517,7 @@ export default function ElaboracaoTab({ sessionId }) {
       setResultadoAvaliacaoHtml(resp.resultado_html || '')
       setBaseChoices(resp.base_choices || [])
       setBaseValue(resp.base_value || '')
+      setAvaliacaoPendente(false)
     })
   }
 
@@ -975,6 +1534,7 @@ export default function ElaboracaoTab({ sessionId }) {
       })
       valoresAvaliacaoRef.current = limpo
       setAvaliacaoFormVersion((prev) => prev + 1)
+      setAvaliacaoPendente(false)
     })
   }
 
@@ -1078,6 +1638,132 @@ export default function ElaboracaoTab({ sessionId }) {
     })
   }
 
+  function onDownloadTableCsv(table, fileNameBase) {
+    const blob = tableToCsvBlob(table)
+    if (!blob) {
+      setError('Tabela indisponível para download.')
+      return
+    }
+    downloadBlob(blob, `${sanitizeFileName(fileNameBase, 'tabela')}.csv`)
+  }
+
+  async function onDownloadTablesCsvBatch(items) {
+    const validItems = (items || []).filter((item) => item?.table)
+    if (validItems.length === 0) {
+      setError('Não há tabelas disponíveis para download.')
+      return
+    }
+
+    setDownloadingAssets(true)
+    setError('')
+    try {
+      for (let i = 0; i < validItems.length; i += 1) {
+        const item = validItems[i]
+        const blob = tableToCsvBlob(item.table)
+        if (!blob) continue
+        downloadBlob(blob, `${sanitizeFileName(item.fileNameBase, `tabela_${i + 1}`)}.csv`)
+        if (i < validItems.length - 1) {
+          await sleep(180)
+        }
+      }
+    } catch (err) {
+      setError(err.message || 'Falha ao baixar tabelas.')
+    } finally {
+      setDownloadingAssets(false)
+    }
+  }
+
+  function onDownloadMapaSecao3() {
+    if (!mapaHtml) {
+      setError('Mapa indisponível para download.')
+      return
+    }
+    const blob = new Blob([mapaHtml], { type: 'text/html;charset=utf-8;' })
+    downloadBlob(blob, 'secao3_mapa_dados_mercado.html')
+  }
+
+  async function exportFigureAsPng(figure, fileNameBase, options = {}) {
+    const payload = buildFigureForExport(figure, Boolean(options.forceHideLegend))
+    if (!payload) {
+      throw new Error('Gráfico indisponível para download.')
+    }
+
+    const container = document.createElement('div')
+    container.style.position = 'fixed'
+    container.style.left = '-10000px'
+    container.style.top = '-10000px'
+    container.style.width = `${payload.width}px`
+    container.style.height = `${payload.height}px`
+    container.style.pointerEvents = 'none'
+    container.style.opacity = '0'
+    document.body.appendChild(container)
+
+    try {
+      await Plotly.newPlot(
+        container,
+        payload.data,
+        payload.layout,
+        { displaylogo: false, responsive: false, staticPlot: true },
+      )
+      const dataUrl = await Plotly.toImage(container, {
+        format: 'png',
+        width: payload.width,
+        height: payload.height,
+        scale: 2,
+      })
+      const response = await fetch(dataUrl)
+      const blob = await response.blob()
+      downloadBlob(blob, `${sanitizeFileName(fileNameBase, 'grafico')}.png`)
+    } finally {
+      try {
+        Plotly.purge(container)
+      } catch {
+        // no-op
+      }
+      container.remove()
+    }
+  }
+
+  async function onDownloadFigurePng(figure, fileNameBase, options = {}) {
+    if (!figure) {
+      setError('Gráfico indisponível para download.')
+      return
+    }
+    setDownloadingAssets(true)
+    setError('')
+    try {
+      await exportFigureAsPng(figure, fileNameBase, options)
+    } catch (err) {
+      setError(err.message || 'Falha ao baixar gráfico.')
+    } finally {
+      setDownloadingAssets(false)
+    }
+  }
+
+  async function onDownloadFiguresPngBatch(items) {
+    const validItems = (items || []).filter((item) => item?.figure)
+    if (validItems.length === 0) {
+      setError('Não há gráficos disponíveis para download.')
+      return
+    }
+
+    setDownloadingAssets(true)
+    setError('')
+    try {
+      for (let i = 0; i < validItems.length; i += 1) {
+        const item = validItems[i]
+        await exportFigureAsPng(item.figure, item.fileNameBase, { forceHideLegend: item.forceHideLegend })
+        if (i < validItems.length - 1) {
+          await sleep(220)
+        }
+      }
+    } catch (err) {
+      setError(err.message || 'Falha ao baixar gráficos.')
+    } finally {
+      setDownloadingAssets(false)
+    }
+  }
+
   function toggleSelection(setter, value) {
     setter((prev) => {
       if (prev.includes(value)) return prev.filter((item) => item !== value)
@@ -1473,6 +2159,16 @@ export default function ElaboracaoTab({ sessionId }) {
                         ))}
                       </select>
                     </div>
+                    <div className="download-actions-bar">
+                      <button
+                        type="button"
+                        className="btn-download-subtle"
+                        onClick={onDownloadMapaSecao3}
+                        disabled={loading || downloadingAssets || !mapaHtml}
+                      >
+                        Fazer download
+                      </button>
+                    </div>
                     <MapFrame html={mapaHtml} />
                   </details>
                 )}
@@ -1490,6 +2186,16 @@ export default function ElaboracaoTab({ sessionId }) {
                     <div className="resumo-outliers-box">Índices excluídos: {joinSelection(outliersAnteriores)}</div>
                   ) : null}
                 </div>
+                <div className="download-actions-bar">
+                  <button
+                    type="button"
+                    className="btn-download-subtle"
+                    onClick={() => onDownloadTableCsv(dados, 'secao3_dados_mercado')}
+                    disabled={loading || downloadingAssets || !dados}
+                  >
+                    Fazer download
+                  </button>
+                </div>
                 <DataTable table={dados} maxHeight={540} />
               </div>
             </div>
@@ -1530,6 +2236,7 @@ export default function ElaboracaoTab({ sessionId }) {
                 >
                   Aplicar período
                 </button>
+                {dataMercadoPendente ? <span className="pending-apply-note">{pendingWarningText}</span> : null}
               </div>
               {dataMercadoError ? <div className="error-line inline-error">{dataMercadoError}</div> : null}
             </div>
@@ -1538,16 +2245,29 @@ export default function ElaboracaoTab({ sessionId }) {
           <SectionBlock step="5" title="Selecionar Variável Dependente" subtitle="Defina a variável dependente (Y).">
             <div className="row">
               <label>Variável Dependente (Y)</label>
-              <select value={colunaY} onChange={(e) => setColunaY(e.target.value)}>
+              <select value={colunaYDraft} onChange={(e) => setColunaYDraft(e.target.value)}>
                 <option value="">Selecione</option>
                 {colunasNumericas.map((col) => (
                   <option key={col} value={col}>{col}</option>
                 ))}
               </select>
+              <button
+                type="button"
+                onClick={onAplicarVariavelDependente}
+                disabled={loading || !dependentePendente}
+              >
+                Aplicar variável dependente
+              </button>
+              {dependentePendente ? <span className="pending-apply-note">{pendingWarningText}</span> : null}
             </div>
           </SectionBlock>
 
           <SectionBlock step="6" title="Selecionar Variáveis Independentes" subtitle="Escolha regressoras e grupos de tipologia.">
+            {!colunaY ? (
+              <div className="section1-empty-hint">
+                Aplique a variável dependente na etapa anterior para liberar as opções de variáveis independentes.
+              </div>
+            ) : null}
             <div className="compact-option-group compact-option-group-x">
               <h4>Variáveis Independentes (X)</h4>
               <div className="checkbox-inline-wrap checkbox-inline-wrap-tools">
@@ -1616,7 +2336,8 @@ export default function ElaboracaoTab({ sessionId }) {
             </div>
 
             <div className="row">
-              <button onClick={onApplySelection} disabled={loading || !colunaY || colunasX.length === 0}>Aplicar seleção</button>
+              <button onClick={onApplySelection} disabled={loading || dependentePendente || !colunaY || colunasX.length === 0}>Aplicar seleção</button>
+              {selecaoPendente ? <span className="pending-apply-note">{pendingWarningText}</span> : null}
             </div>
             {selection?.aviso_multicolinearidade?.visible ? (
               <div dangerouslySetInnerHTML={{ __html: selection.aviso_multicolinearidade.html }} />
@@ -1631,6 +2352,16 @@ export default function ElaboracaoTab({ sessionId }) {
       {selection ? (
         <>
           <SectionBlock step="7" title="Estatísticas das Variáveis Selecionadas" subtitle="Resumo estatístico para Y e regressoras.">
+            <div className="download-actions-bar">
+              <button
+                type="button"
+                className="btn-download-subtle"
+                onClick={() => onDownloadTableCsv(selection.estatisticas, 'secao7_estatisticas')}
+                disabled={loading || downloadingAssets || !selection.estatisticas}
+              >
+                Fazer download
+              </button>
+            </div>
             <DataTable table={selection.estatisticas} />
           </SectionBlock>
 
@@ -1646,12 +2377,59 @@ export default function ElaboracaoTab({ sessionId }) {
             >
               <summary>Mostrar/Ocultar gráficos da seção</summary>
               {section8Open ? (
-                <PlotFigure
-                  figure={selection.grafico_dispersao}
-                  title="Dispersão (dados filtrados)"
-                  forceHideLegend
-                  className="plot-stretch"
-                />
+                <>
+                    <div className="download-actions-bar">
+                      {graficosSecao9.length > 1 ? <span className="download-actions-label">Fazer download:</span> : null}
+                    {graficosSecao9.map((item, idx) => {
+                      const fileBase = `secao9_${sanitizeFileName(item.label, `dispersao_${idx + 1}`)}`
+                      return (
+                      <button
+                        key={`s9-dl-${item.id}`}
+                        type="button"
+                        className="btn-download-subtle"
+                        title={item.legenda}
+                        onClick={() => onDownloadFigurePng(item.figure, fileBase, { forceHideLegend: true })}
+                        disabled={loading || downloadingAssets || !item.figure}
+                      >
+                        {graficosSecao9.length > 1 ? item.label : 'Fazer download'}
+                      </button>
+                      )
+                    })}
+                    {graficosSecao9.length > 1 ? (
+                      <button
+                        type="button"
+                        className="btn-download-subtle"
+                        onClick={() => onDownloadFiguresPngBatch(
+                          graficosSecao9.map((item, idx) => ({
+                            figure: item.figure,
+                            fileNameBase: `secao9_${sanitizeFileName(item.label, `dispersao_${idx + 1}`)}`,
+                            forceHideLegend: true,
+                          })),
+                        )}
+                        disabled={loading || downloadingAssets || graficosSecao9.length === 0}
+                      >
+                        Todos
+                      </button>
+                    ) : null}
+                  </div>
+                  {graficosSecao9.length > 0 ? (
+                    <div className="plot-grid-scatter" style={{ '--plot-cols': colunasGraficosSecao9 }}>
+                      {graficosSecao9.map((item) => (
+                        <PlotFigure
+                          key={`s9-plot-${item.id}`}
+                          figure={item.figure}
+                          title={item.title}
+                          subtitle={item.subtitle}
+                          forceHideLegend
+                          className="plot-stretch"
+                          lazy
+                        />
+                      ))}
+                    </div>
+                  ) : (
+                    <div className="empty-box">Grafico indisponivel.</div>
+                  )}
+                </>
               ) : null}
             </details>
           </SectionBlock>
@@ -1671,6 +2449,7 @@ export default function ElaboracaoTab({ sessionId }) {
                 ))}
               </select>
               <button onClick={onSearchTransform} disabled={loading}>Buscar transformações</button>
+              {buscaTransformPendente ? <span className="pending-apply-note">{pendingWarningText}</span> : null}
             </div>
             {(selection.busca?.resultados || []).length > 0 ? (
               <div className="transform-suggestions-grid">
@@ -1752,7 +2531,10 @@ export default function ElaboracaoTab({ sessionId }) {
                   ))}
                 </div>
 
-                <button className="btn-fit-model" onClick={onFitModel} disabled={loading}>Aplicar transformações e ajustar modelo</button>
+                <div className="row row-fit-transformacoes">
+                  <button className="btn-fit-model" onClick={onFitModel} disabled={loading}>Aplicar transformações e ajustar modelo</button>
+                  {manualTransformPendente ? <span className="pending-apply-note">{pendingWarningText}</span> : null}
+                </div>
               </>
             ) : null}
             {transformacoesAplicadas?.coluna_y ? (
@@ -1814,7 +2596,57 @@ export default function ElaboracaoTab({ sessionId }) {
                       <option value="Variáveis Independentes Não Transformadas X Resíduo Padronizado">X não transformado x Resíduo</option>
                     </select>
                   </div>
-                  <PlotFigure figure={fit.grafico_dispersao_modelo} title="Dispersão do modelo" forceHideLegend className="plot-stretch" />
+                    <div className="download-actions-bar">
+                      {graficosSecao12.length > 1 ? <span className="download-actions-label">Fazer download:</span> : null}
+                    {graficosSecao12.map((item, idx) => {
+                      const fileBase = `secao12_${sanitizeFileName(item.label, `dispersao_${idx + 1}`)}`
+                      return (
+                      <button
+                        key={`s12-dl-${item.id}`}
+                        type="button"
+                        className="btn-download-subtle"
+                        title={item.legenda}
+                        onClick={() => onDownloadFigurePng(item.figure, fileBase, { forceHideLegend: true })}
+                        disabled={loading || downloadingAssets || !item.figure}
+                      >
+                        {graficosSecao12.length > 1 ? item.label : 'Fazer download'}
+                      </button>
+                      )
+                    })}
+                    {graficosSecao12.length > 1 ? (
+                      <button
+                        type="button"
+                        className="btn-download-subtle"
+                        onClick={() => onDownloadFiguresPngBatch(
+                          graficosSecao12.map((item, idx) => ({
+                            figure: item.figure,
+                            fileNameBase: `secao12_${sanitizeFileName(item.label, `dispersao_${idx + 1}`)}`,
+                            forceHideLegend: true,
+                          })),
+                        )}
+                        disabled={loading || downloadingAssets || graficosSecao12.length === 0}
+                      >
+                        Todos
+                      </button>
+                    ) : null}
+                  </div>
+                  {graficosSecao12.length > 0 ? (
+                    <div className="plot-grid-scatter" style={{ '--plot-cols': colunasGraficosSecao12 }}>
+                      {graficosSecao12.map((item) => (
+                        <PlotFigure
+                          key={`s12-plot-${item.id}`}
+                          figure={item.figure}
+                          title={item.title}
+                          subtitle={item.subtitle}
+                          forceHideLegend
+                          className="plot-stretch"
+                          lazy
+                        />
+                      ))}
+                    </div>
+                  ) : (
+                    <div className="empty-box">Grafico indisponivel.</div>
+                  )}
                 </>
               ) : null}
             </details>
@@ -1822,6 +2654,36 @@ export default function ElaboracaoTab({ sessionId }) {
 
           <SectionBlock step="13" title="Diagnóstico de Modelo" subtitle="Resumo diagnóstico e tabelas principais do ajuste.">
             <div dangerouslySetInnerHTML={{ __html: fit.diagnosticos_html || '' }} />
+            <div className="download-actions-bar">
+              <span className="download-actions-label">Fazer download:</span>
+              <button
+                type="button"
+                className="btn-download-subtle"
+                onClick={() => onDownloadTableCsv(fit.tabela_coef, 'secao13_coeficientes')}
+                disabled={loading || downloadingAssets || !fit.tabela_coef}
+              >
+                Coeficientes
+              </button>
+              <button
+                type="button"
+                className="btn-download-subtle"
+                onClick={() => onDownloadTableCsv(fit.tabela_obs_calc, 'secao13_obs_calc')}
+                disabled={loading || downloadingAssets || !fit.tabela_obs_calc}
+              >
+                Obs x Calc
+              </button>
+              <button
+                type="button"
+                className="btn-download-subtle"
+                onClick={() => onDownloadTablesCsvBatch([
+                  { table: fit.tabela_coef, fileNameBase: 'secao13_coeficientes' },
+                  { table: fit.tabela_obs_calc, fileNameBase: 'secao13_obs_calc' },
+                ])}
+                disabled={loading || downloadingAssets || (!fit.tabela_coef && !fit.tabela_obs_calc)}
+              >
+                Todos
+              </button>
+            </div>
             <div className="two-col diagnostic-tables">
               <div className="pane">
                 <h4>Tabela de Coeficientes</h4>
@@ -1835,6 +2697,63 @@ export default function ElaboracaoTab({ sessionId }) {
           </SectionBlock>
 
           <SectionBlock step="14" title="Gráficos de Diagnóstico do Modelo" subtitle="Obs x calc, resíduos, histograma, Cook e correlação.">
+            <div className="download-actions-bar">
+              <span className="download-actions-label">Fazer download:</span>
+              <button
+                type="button"
+                className="btn-download-subtle"
+                onClick={() => onDownloadFigurePng(fit.grafico_obs_calc, 'secao14_obs_calc')}
+                disabled={loading || downloadingAssets || !fit.grafico_obs_calc}
+              >
+                Obs x calc
+              </button>
+              <button
+                type="button"
+                className="btn-download-subtle"
+                onClick={() => onDownloadFigurePng(fit.grafico_residuos, 'secao14_residuos')}
+                disabled={loading || downloadingAssets || !fit.grafico_residuos}
+              >
+                Resíduos
+              </button>
+              <button
+                type="button"
+                className="btn-download-subtle"
+                onClick={() => onDownloadFigurePng(fit.grafico_histograma, 'secao14_histograma')}
+                disabled={loading || downloadingAssets || !fit.grafico_histograma}
+              >
+                Histograma
+              </button>
+              <button
+                type="button"
+                className="btn-download-subtle"
+                onClick={() => onDownloadFigurePng(fit.grafico_cook, 'secao14_cook', { forceHideLegend: true })}
+                disabled={loading || downloadingAssets || !fit.grafico_cook}
+              >
+                Cook
+              </button>
+              <button
+                type="button"
+                className="btn-download-subtle"
+                onClick={() => onDownloadFigurePng(fit.grafico_correlacao, 'secao14_correlacao')}
+                disabled={loading || downloadingAssets || !fit.grafico_correlacao}
+              >
+                Correlação
+              </button>
+              <button
+                type="button"
+                className="btn-download-subtle"
+                onClick={() => onDownloadFiguresPngBatch([
+                  { figure: fit.grafico_obs_calc, fileNameBase: 'secao14_obs_calc' },
+                  { figure: fit.grafico_residuos, fileNameBase: 'secao14_residuos' },
+                  { figure: fit.grafico_histograma, fileNameBase: 'secao14_histograma' },
+                  { figure: fit.grafico_cook, fileNameBase: 'secao14_cook', forceHideLegend: true },
+                  { figure: fit.grafico_correlacao, fileNameBase: 'secao14_correlacao' },
+                ])}
+                disabled={loading || downloadingAssets || (!fit.grafico_obs_calc && !fit.grafico_residuos && !fit.grafico_histograma && !fit.grafico_cook && !fit.grafico_correlacao)}
+              >
+                Todos
+              </button>
+            </div>
             <div className="plot-grid-2-fixed">
               <PlotFigure figure={fit.grafico_obs_calc} title="Obs x Calc" />
               <PlotFigure figure={fit.grafico_residuos} title="Resíduos" />
@@ -1847,6 +2766,16 @@ export default function ElaboracaoTab({ sessionId }) {
           </SectionBlock>
 
           <SectionBlock step="15" title="Analisar Outliers" subtitle="Métricas para identificação de observações influentes.">
+            <div className="download-actions-bar">
+              <button
+                type="button"
+                className="btn-download-subtle"
+                onClick={() => onDownloadTableCsv(fit.tabela_metricas, 'secao15_tabela_metricas')}
+                disabled={loading || downloadingAssets || !fit.tabela_metricas}
+              >
+                Fazer download
+              </button>
+            </div>
             <DataTable table={fit.tabela_metricas} maxHeight={320} />
           </SectionBlock>
 
@@ -1908,6 +2837,7 @@ export default function ElaboracaoTab({ sessionId }) {
               <div className="outlier-actions-row">
                 <button onClick={onApplyOutlierFilters} disabled={loading}>Aplicar filtros</button>
                 <button type="button" className="btn-filtro-add" onClick={onAddFiltro} disabled={loading}>Adicionar filtro</button>
+                {outlierFiltrosPendentes ? <span className="pending-apply-note">{pendingWarningText}</span> : null}
               </div>
             </div>
 
@@ -1928,6 +2858,7 @@ export default function ElaboracaoTab({ sessionId }) {
                 <button onClick={onRestartIteration} disabled={loading} className="btn-reiniciar-iteracao">
                   Atualizar Modelo (Excluir/Reincluir Outliers)
                 </button>
+                {outlierTextosPendentes ? <span className="pending-apply-note">{pendingWarningText}</span> : null}
               </div>
             </div>
             <div className="resumo-outliers-box">Iteração: {iteracao} | {resumoOutliers}</div>
@@ -1944,6 +2875,7 @@ export default function ElaboracaoTab({ sessionId }) {
                       defaultValue={String(valoresAvaliacaoRef.current[campo.coluna] ?? '')}
                       onChange={(e) => {
                         valoresAvaliacaoRef.current[campo.coluna] = e.target.value
+                        setAvaliacaoPendente(true)
                       }}
                     >
                       <option value="">Selecione</option>
@@ -1960,6 +2892,7 @@ export default function ElaboracaoTab({ sessionId }) {
                       placeholder={campo.placeholder || ''}
                       onChange={(e) => {
                         valoresAvaliacaoRef.current[campo.coluna] = e.target.value
+                        setAvaliacaoPendente(true)
                       }}
                     />
                   )}
@@ -1970,6 +2903,7 @@ export default function ElaboracaoTab({ sessionId }) {
               <button onClick={onCalculateAvaliacao} disabled={loading}>Calcular</button>
               <button onClick={onClearAvaliacao} disabled={loading}>Limpar</button>
               <button onClick={onExportAvaliacoes} disabled={loading}>Exportar avaliações (Excel)</button>
+              {avaliacaoPendente ? <span className="pending-apply-note">{pendingWarningText}</span> : null}
             </div>
             <div className="row avaliacao-base-row">
               <label>Base comparação</label>

frontend/src/components/PlotFigure.jsx

@@ -1,8 +1,37 @@
-import React from 'react'
+import React, { useEffect, useRef, useState } from 'react'
 import Plot from 'react-plotly.js'
 import Plotly from 'plotly.js-dist-min'
 
-function PlotFigure({ figure, title, forceHideLegend = false, className = '' }) {
+function PlotFigure({ figure, title, subtitle = '', forceHideLegend = false, className = '', lazy = false }) {
+  const containerRef = useRef(null)
+  const [shouldRenderPlot, setShouldRenderPlot] = useState(() => !lazy)
+
+  useEffect(() => {
+    if (!lazy) {
+      setShouldRenderPlot(true)
+      return undefined
+    }
+    if (shouldRenderPlot) return undefined
+    if (typeof window === 'undefined' || !('IntersectionObserver' in window)) {
+      setShouldRenderPlot(true)
+      return undefined
+    }
+    const target = containerRef.current
+    if (!target) return undefined
+    const observer = new IntersectionObserver(
+      (entries) => {
+        const isVisible = entries.some((entry) => entry.isIntersecting || entry.intersectionRatio > 0)
+        if (isVisible) {
+          setShouldRenderPlot(true)
+          observer.disconnect()
+        }
+      },
+      { rootMargin: '240px 0px', threshold: 0.01 },
+    )
+    observer.observe(target)
+    return () => observer.disconnect()
+  }, [lazy, shouldRenderPlot])
+
   if (!figure) {
     return <div className="empty-box">Grafico indisponivel.</div>
   }
@@ -33,16 +62,25 @@ function PlotFigure({ figure, title, forceHideLegend = false, className = '' })
   const cardClassName = `plot-card ${className}`.trim()
 
   return (
-    <div className={cardClassName}>
-      {title ? <h4>{title}</h4> : null}
-      <Plot
-        data={data}
-        layout={layout}
-        config={{ responsive: true, displaylogo: false }}
-        style={{ width: '100%', height: plotHeight, minHeight: '320px' }}
-        useResizeHandler
-        plotly={Plotly}
-      />
+    <div ref={containerRef} className={cardClassName}>
+      {title || subtitle ? (
+        <div className="plot-card-head">
+          {title ? <h4 className="plot-card-title">{title}</h4> : null}
+          {subtitle ? <div className="plot-card-subtitle">{subtitle}</div> : null}
+        </div>
+      ) : null}
+      {shouldRenderPlot ? (
+        <Plot
+          data={data}
+          layout={layout}
+          config={{ responsive: true, displaylogo: false }}
+          style={{ width: '100%', height: plotHeight, minHeight: '320px' }}
+          useResizeHandler
+          plotly={Plotly}
+        />
+      ) : (
+        <div className="plot-lazy-placeholder">Carregando gráfico...</div>
+      )}
     </div>
   )
 }

frontend/src/components/VisualizacaoTab.jsx

@@ -8,7 +8,8 @@ import SectionBlock from './SectionBlock'
 
 const INNER_TABS = [
   { key: 'mapa', label: 'Mapa' },
-  { key: 'dados', label: 'Dados' },
+  { key: 'dados_mercado', label: 'Dados de Mercado' },
+  { key: 'metricas', label: 'Métricas' },
   { key: 'transformacoes', label: 'Transformações' },
   { key: 'resumo', label: 'Resumo' },
   { key: 'coeficientes', label: 'Coeficientes' },
@@ -339,22 +340,18 @@ export default function VisualizacaoTab({ sessionId }) {
               </>
             ) : null}
 
-            {activeInnerTab === 'dados' ? (
-              <div className="two-col">
-                <div className="pane">
-                  <h4>Dados</h4>
-                  <DataTable table={dados} maxHeight={520} />
-                </div>
-                <div className="pane">
-                  <h4>Estatísticas</h4>
-                  <DataTable table={estatisticas} maxHeight={520} />
-                </div>
-              </div>
+            {activeInnerTab === 'dados_mercado' ? (
+              <DataTable table={dados} maxHeight={620} />
+            ) : null}
+
+            {activeInnerTab === 'metricas' ? (
+              <DataTable table={estatisticas} maxHeight={620} />
             ) : null}
 
             {activeInnerTab === 'transformacoes' ? (
               <>
                 <div dangerouslySetInnerHTML={{ __html: escalasHtml }} />
+                <h4 className="visualizacao-table-title">Dados com variáveis transformadas</h4>
                 <DataTable table={dadosTransformados} />
               </>
             ) : null}

frontend/src/styles.css

@@ -214,6 +214,13 @@ textarea {
   padding: 14px;
 }
 
+.visualizacao-table-title {
+  margin: 10px 0 8px;
+  color: #3a4f64;
+  font-family: 'Sora', sans-serif;
+  font-size: 0.88rem;
+}
+
 .tab-content {
   display: flex;
   flex-direction: column;
@@ -1972,6 +1979,12 @@ button.btn-upload-select {
   gap: 12px;
 }
 
+.plot-grid-scatter {
+  display: grid;
+  grid-template-columns: repeat(var(--plot-cols, 3), minmax(0, 1fr));
+  gap: 12px;
+}
+
 .plot-card {
   border: 1px solid #dbe5ef;
   border-radius: 12px;
@@ -1980,15 +1993,44 @@ button.btn-upload-select {
   padding: 8px;
 }
 
-.plot-card h4 {
+.plot-card-head {
   margin: 4px 4px 8px;
-  color: #34495d;
+  min-height: 42px;
+  display: grid;
+  align-content: start;
+  gap: 2px;
+}
+
+.plot-card-title {
+  margin: 0;
+  color: #2f465c;
   font-family: 'Sora', sans-serif;
-  font-size: 0.9rem;
+  font-size: 0.93rem;
+  font-weight: 700;
+  line-height: 1.2;
+}
+
+.plot-card-subtitle {
+  color: #5f7387;
+  font-size: 0.82rem;
+  font-family: 'JetBrains Mono', monospace;
+  line-height: 1.15;
+}
+
+.plot-lazy-placeholder {
+  min-height: 320px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: #6a7f94;
+  font-size: 0.86rem;
+  border: 1px dashed #dbe5ef;
+  border-radius: 10px;
+  background: linear-gradient(180deg, #fbfdff 0%, #f5f9fd 100%);
 }
 
 .plot-card.plot-stretch {
-  min-height: 430px;
+  min-height: 380px;
 }
 
 .plot-full-width {
@@ -2259,6 +2301,15 @@ button.btn-upload-select {
   margin-bottom: 16px;
 }
 
+.row-fit-transformacoes {
+  margin-top: 14px;
+  margin-bottom: 16px;
+}
+
+.row-fit-transformacoes .btn-fit-model {
+  margin: 0;
+}
+
 .transformacao-origem-info {
   margin-top: 6px;
   margin-bottom: 4px;
@@ -2290,6 +2341,48 @@ button.btn-upload-select {
   align-items: center;
 }
 
+.pending-apply-note {
+  display: inline-flex;
+  align-items: center;
+  min-height: 30px;
+  padding: 4px 9px;
+  border: 1px solid #f2cb8f;
+  border-radius: 999px;
+  background: #fff6e8;
+  color: #8a5a15;
+  font-size: 0.76rem;
+  font-weight: 700;
+  line-height: 1.25;
+}
+
+.download-actions-bar {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 7px;
+  margin: 8px 0 10px;
+}
+
+.download-actions-label {
+  display: inline-flex;
+  align-items: center;
+  font-size: 0.76rem;
+  font-weight: 700;
+  color: #5a7086;
+  padding-right: 2px;
+}
+
+button.btn-download-subtle {
+  --btn-bg-start: #f5f8fb;
+  --btn-bg-end: #edf2f7;
+  --btn-border: #c9d7e4;
+  --btn-shadow-soft: rgba(53, 74, 95, 0.08);
+  --btn-shadow-strong: rgba(53, 74, 95, 0.12);
+  color: #3f566d;
+  font-size: 0.76rem;
+  padding: 5px 10px;
+  border-radius: 9px;
+}
+
 .geo-correcoes {
   display: grid;
   grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
@@ -2763,12 +2856,16 @@ button.btn-upload-select {
     grid-template-columns: 1fr;
   }
 
+  .plot-grid-scatter {
+    grid-template-columns: 1fr;
+  }
+
   .plot-card {
     min-height: 340px;
   }
 
   .plot-card.plot-stretch {
-    min-height: 360px;
+    min-height: 330px;
   }
 
   .plot-card.plot-correlation-card {