Improve load-time caching and baseline snapshots

app.py

@@ -92,7 +92,7 @@ from utils.dates import current_wbc_date_str
 from data.scores import fetch_scores_for_date
 from data.odds import fetch_featured_odds
 from data.schedule import fetch_schedule_for_date
-from data.shared_baseline import build_shared_baseline_bundle
+from data.shared_baseline import load_or_build_shared_baseline_bundle
 from data.statcast import fetch_statcast_range, fetch_statcast_range_pitcher, normalize_statcast
 from data.weather import fetch_weather_for_venue
 from database.db import (
@@ -100,8 +100,19 @@ from database.db import (
     insert_bet,
     next_bet_id,
     read_table,
+    read_cached_odds,
+    read_cached_probable_starters,
+    read_cached_probable_starters_meta,
+    read_cached_schedule_for_date,
+    read_cached_upcoming_props_bundle,
+    read_cached_weather_for_venue,
     update_bet_result,
     upsert_dataframe,
+    replace_cached_odds,
+    replace_cached_probable_starters,
+    replace_cached_schedule,
+    replace_cached_upcoming_props_bundle,
+    replace_cached_weather,
     ensure_recommendation_logs_table,
     insert_recommendation_logs,
     ensure_recommendation_outcomes_table,
@@ -600,7 +611,21 @@ def load_statcast_previous_season_full_pitcher() -> pd.DataFrame:
 def load_probable_starters() -> dict:
     """Probable starting pitchers for next 7 days from MLB Stats API."""
     from data.mlb_starters import fetch_probable_starters_for_props
-    return fetch_probable_starters_for_props()
+    try:
+        cached_meta = read_cached_probable_starters_meta(conn)
+        if not cached_meta.empty and _is_fetched_at_fresh(cached_meta.iloc[0]["fetched_at"], 60 * 60):
+            cached = read_cached_probable_starters(conn)
+            if cached:
+                return cached
+    except Exception:
+        pass
+
+    fresh = fetch_probable_starters_for_props()
+    try:
+        replace_cached_probable_starters(conn, fresh)
+    except Exception as exc:
+        logger.warning("[load_probable_starters] cache persist failure: %s", exc)
+    return fresh
 
 
 @st.cache_data(ttl=STATCAST_TTL_SECONDS)
@@ -653,14 +678,63 @@ def _extract_probable_starter_names(probable_starters: dict | None) -> tuple[str
     return _coerce_name_tuple(names)
 
 
+def _extract_live_dashboard_participants(live_games: pd.DataFrame) -> tuple[tuple[str, ...], tuple[str, ...]]:
+    if live_games is None or live_games.empty:
+        return tuple(), tuple()
+
+    batter_names: list[str] = []
+    pitcher_names: list[str] = []
+    for col in ["on_deck_name", "in_hole_name", "three_away_name", "batter_name"]:
+        if col in live_games.columns:
+            batter_names.extend(
+                [
+                    str(value).strip()
+                    for value in live_games[col].dropna().astype(str).tolist()
+                    if str(value).strip()
+                ]
+            )
+    for col in ["pitcher_name"]:
+        if col in live_games.columns:
+            pitcher_names.extend(
+                [
+                    str(value).strip()
+                    for value in live_games[col].dropna().astype(str).tolist()
+                    if str(value).strip()
+                ]
+            )
+    return _coerce_name_tuple(batter_names), _coerce_name_tuple(pitcher_names)
+
+
+def _is_fetched_at_fresh(value: object, max_age_seconds: int) -> bool:
+    try:
+        ts = pd.to_datetime(value, errors="coerce", utc=True)
+        if pd.isna(ts):
+            return False
+        age_seconds = max(0.0, float((pd.Timestamp.now(tz="UTC") - ts).total_seconds()))
+        return age_seconds <= float(max_age_seconds)
+    except Exception:
+        return False
+
+
+def _latest_fetched_at_from_df(df: pd.DataFrame) -> object:
+    if df is None or df.empty or "fetched_at" not in df.columns:
+        return None
+    try:
+        return pd.to_datetime(df["fetched_at"], errors="coerce", utc=True).max()
+    except Exception:
+        return None
+
+
 @st.cache_data(ttl=STATCAST_TTL_SECONDS, show_spinner=False)
 def load_shared_baseline_bundle_cached(
     batter_names: tuple[str, ...] = (),
     pitcher_names: tuple[str, ...] = (),
 ) -> dict:
-    return build_shared_baseline_bundle(
+    return load_or_build_shared_baseline_bundle(
         batter_names=batter_names,
         pitcher_names=pitcher_names,
+        max_age_seconds=max(STATCAST_TTL_SECONDS, 60 * 60),
+        persist_runtime_refresh=True,
     )
 
 
@@ -695,7 +769,30 @@ def load_upcoming_hr_props() -> pd.DataFrame:
 @st.cache_data(ttl=300, show_spinner=False)
 def load_upcoming_hr_props_bundle() -> dict:
     try:
-        return fetch_all_upcoming_hr_props_bundle(sportsbooks=DEFAULT_PROP_BOOKS)
+        cached_bundle = read_cached_upcoming_props_bundle(conn, cache_key="default")
+        cache_meta = cached_bundle.get("cache_meta", pd.DataFrame())
+        if not cache_meta.empty and _is_fetched_at_fresh(cache_meta.iloc[0]["fetched_at"], 300):
+            merged = cached_bundle.get("merged_props_feed", pd.DataFrame())
+            coverage = cached_bundle.get("coverage_summary", pd.DataFrame())
+            return {
+                "odds_api_raw": pd.DataFrame(),
+                "scraper_raw": pd.DataFrame(),
+                "merged_props_feed": merged if isinstance(merged, pd.DataFrame) else pd.DataFrame(),
+                "coverage_summary": coverage if isinstance(coverage, pd.DataFrame) else pd.DataFrame(),
+                "cache_meta": cache_meta,
+                "cache_source": "db_snapshot",
+            }
+    except Exception:
+        pass
+
+    try:
+        bundle = fetch_all_upcoming_hr_props_bundle(sportsbooks=DEFAULT_PROP_BOOKS)
+        try:
+            replace_cached_upcoming_props_bundle(conn, bundle, cache_key="default")
+        except Exception as exc:
+            logger.warning("[load_upcoming_hr_props_bundle] cache persist failure: %s", exc)
+        bundle["cache_source"] = "live_fetch"
+        return bundle
     except Exception as exc:
         logger.warning("[load_upcoming_hr_props_bundle] failure: %s", exc)
         return {
@@ -703,16 +800,43 @@ def load_upcoming_hr_props_bundle() -> dict:
             "scraper_raw": pd.DataFrame(),
             "merged_props_feed": pd.DataFrame(),
             "coverage_summary": pd.DataFrame(),
+            "cache_meta": pd.DataFrame(),
+            "cache_source": "unavailable",
         }
 
 
 @st.cache_data(ttl=REFRESH_TTL_SECONDS)
 def load_odds() -> pd.DataFrame:
-    return fetch_featured_odds()
+    try:
+        cached = read_cached_odds(conn)
+        if not cached.empty and _is_fetched_at_fresh(cached.iloc[0]["fetched_at"], REFRESH_TTL_SECONDS):
+            return cached
+    except Exception:
+        pass
+
+    fresh = fetch_featured_odds()
+    try:
+        replace_cached_odds(conn, fresh)
+    except Exception as exc:
+        logger.warning("[load_odds] cache persist failure: %s", exc)
+    return fresh
 
 @st.cache_data(ttl=SCHEDULE_TTL_SECONDS)
 def load_dashboard_schedule_for_date(date_str: str) -> pd.DataFrame:
-    return fetch_schedule_for_date(date_str)
+    try:
+        cached = read_cached_schedule_for_date(conn, date_str)
+        latest_cached_at = _latest_fetched_at_from_df(cached)
+        if not cached.empty and _is_fetched_at_fresh(latest_cached_at, SCHEDULE_TTL_SECONDS):
+            return cached
+    except Exception:
+        pass
+
+    fresh = fetch_schedule_for_date(date_str)
+    try:
+        replace_cached_schedule(conn, fresh)
+    except Exception as exc:
+        logger.warning("[load_dashboard_schedule_for_date] cache persist failure: %s", exc)
+    return fresh
 
 
 @st.cache_data(ttl=SCORES_TTL_SECONDS)
@@ -742,7 +866,21 @@ def get_stable_scores_for_dashboard_date(date_str: str) -> pd.DataFrame:
     return fresh_scores
 
 def load_weather(venue_name: str) -> pd.DataFrame:
-    return fetch_weather_for_venue(venue_name)
+    try:
+        cached = read_cached_weather_for_venue(conn, venue_name)
+        latest_cached_at = _latest_fetched_at_from_df(cached)
+        if not cached.empty and _is_fetched_at_fresh(latest_cached_at, REFRESH_TTL_SECONDS):
+            return cached.head(1).reset_index(drop=True)
+    except Exception:
+        pass
+
+    fresh = fetch_weather_for_venue(venue_name)
+    try:
+        if fresh is not None and not fresh.empty:
+            replace_cached_weather(conn, fresh)
+    except Exception as exc:
+        logger.warning("[load_weather] cache persist failure: %s", exc)
+    return fresh
 
 
 def render_header() -> None:
@@ -2952,13 +3090,6 @@ def render_dashboard() -> None:
             pass
 
     schedule_df = load_dashboard_schedule_for_date(schedule_date_str)
-    baseline_bundle = load_shared_baseline_bundle_cached()
-    statcast_df = baseline_bundle.get("blended_batter_df", pd.DataFrame())
-    pitcher_statcast_df = baseline_bundle.get("blended_pitcher_df", pd.DataFrame())
-    if statcast_df.empty:
-        statcast_df = load_statcast_recent()
-    if pitcher_statcast_df.empty:
-        pitcher_statcast_df = statcast_df
 
     live_games, final_games, scheduled_games = split_games_for_scoreboard(
         schedule_df=schedule_df,
@@ -3006,6 +3137,18 @@ def render_dashboard() -> None:
             live_games = recovered_live_games
             final_games = recovered_final_games
 
+    dashboard_batter_names, dashboard_pitcher_names = _extract_live_dashboard_participants(live_games)
+    baseline_bundle = load_shared_baseline_bundle_cached(
+        batter_names=dashboard_batter_names,
+        pitcher_names=dashboard_pitcher_names,
+    ) if not live_games.empty else {}
+    statcast_df = baseline_bundle.get("blended_batter_df", pd.DataFrame()) if isinstance(baseline_bundle, dict) else pd.DataFrame()
+    pitcher_statcast_df = baseline_bundle.get("blended_pitcher_df", pd.DataFrame()) if isinstance(baseline_bundle, dict) else pd.DataFrame()
+    if statcast_df.empty and not live_games.empty:
+        statcast_df = load_statcast_recent()
+    if pitcher_statcast_df.empty and not live_games.empty:
+        pitcher_statcast_df = statcast_df
+
     filter_option = st.radio(
         "Game Status",
         ["All", "Live", "Final", "Scheduled"],

data/shared_baseline.py

@@ -1,13 +1,19 @@
 from __future__ import annotations
 
 from collections import defaultdict
+import json
 from typing import Any
 
 import pandas as pd
 from sqlalchemy import text
 
-from database.db import get_connection
+from database.db import get_connection, replace_table_contents
 from features.pitch_features import add_pitch_features
+from models.rolling_form_model import (
+    build_batter_rolling_form_row,
+    build_pitcher_rolling_form_row,
+)
+from utils.helpers import utc_now_iso
 from visualization.cards.player_identity import load_identity_map, normalize_for_matching
 
 PRIOR_SEASONS = (2021, 2022, 2023, 2024, 2025)
@@ -17,6 +23,8 @@ _HITTER_BLEND_K = 260.0
 _PITCHER_BLEND_K = 320.0
 _MAX_ROWS_PER_PLAYER = 420
 _MIN_CURRENT_ROWS_WHEN_AVAILABLE = 20
+_SNAPSHOT_VERSION = "shared_baseline_v1"
+_DEFAULT_SNAPSHOT_MAX_AGE_SECONDS = 60 * 30
 _PRIOR_SEASON_RECENCY_WEIGHTS = {
     2025: 1.00,
     2024: 0.85,
@@ -189,6 +197,62 @@ def _prepare_frame(df: pd.DataFrame) -> pd.DataFrame:
     return add_pitch_features(out)
 
 
+def _json_default(value: Any) -> Any:
+    if isinstance(value, (pd.Timestamp, pd.Timedelta)):
+        return str(value)
+    return str(value)
+
+
+def _serialize_payload_frame(df: pd.DataFrame) -> str:
+    if df is None or df.empty:
+        return "[]"
+    out = df.copy()
+    if "game_date" in out.columns:
+        out["game_date"] = out["game_date"].astype(str)
+    return json.dumps(out.where(out.notna(), other=None).to_dict("records"), default=_json_default)
+
+
+def _deserialize_payload_frame(payload_json: str) -> pd.DataFrame:
+    try:
+        payload = json.loads(str(payload_json or "[]"))
+    except Exception:
+        payload = []
+    if not payload:
+        return pd.DataFrame()
+    return _prepare_frame(pd.DataFrame(payload))
+
+
+def _normalize_names_tuple(values: tuple[str, ...] | None) -> tuple[str, ...]:
+    if not values:
+        return tuple()
+    out = []
+    seen = set()
+    for value in values:
+        cleaned = str(value or "").strip()
+        if not cleaned:
+            continue
+        lowered = cleaned.lower()
+        if lowered in seen:
+            continue
+        seen.add(lowered)
+        out.append(cleaned)
+    return tuple(sorted(out))
+
+
+def _is_snapshot_stale(built_at: Any, max_age_seconds: int) -> bool:
+    if not built_at:
+        return True
+    try:
+        built_ts = pd.to_datetime(built_at, errors="coerce", utc=True)
+        if pd.isna(built_ts):
+            return True
+        now_ts = pd.Timestamp.now(tz="UTC")
+        age_seconds = max(0.0, float((now_ts - built_ts).total_seconds()))
+        return age_seconds > float(max_age_seconds)
+    except Exception:
+        return True
+
+
 def _load_current_events(conn, current_season: int) -> pd.DataFrame:
     query = text(
         """
@@ -600,6 +664,485 @@ def _blend_entity_frames(
     return blended_df, metadata_df
 
 
+def _build_snapshot_rows(
+    frame: pd.DataFrame,
+    built_at: str,
+    snapshot_version: str,
+    source_status: str,
+) -> pd.DataFrame:
+    rows: list[dict[str, Any]] = []
+    if frame is None or frame.empty or "player_name" not in frame.columns:
+        return pd.DataFrame(
+            columns=[
+                "player_name",
+                "source_row_count",
+                "payload_json",
+                "snapshot_built_at",
+                "snapshot_version",
+                "source_status",
+            ]
+        )
+
+    for player_name, player_df in frame.groupby("player_name", dropna=False):
+        player_name_str = str(player_name or "").strip()
+        if not player_name_str:
+            continue
+        rows.append(
+            {
+                "player_name": player_name_str,
+                "source_row_count": int(len(player_df)),
+                "payload_json": _serialize_payload_frame(player_df.reset_index(drop=True)),
+                "snapshot_built_at": built_at,
+                "snapshot_version": snapshot_version,
+                "source_status": source_status,
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def _build_meta_snapshot_rows(
+    meta_df: pd.DataFrame,
+    built_at: str,
+    snapshot_version: str,
+    source_status: str,
+) -> pd.DataFrame:
+    if meta_df is None:
+        meta_df = pd.DataFrame()
+    out = meta_df.copy()
+    for col in [
+        "player_name",
+        "baseline_role",
+        "baseline_mode",
+        "prior_sample_size",
+        "season_2026_sample_size",
+        "prior_weight",
+        "season_2026_weight",
+        "baseline_driver",
+        "rolling_overlay_active",
+    ]:
+        if col not in out.columns:
+            out[col] = None
+    out["snapshot_built_at"] = built_at
+    out["snapshot_version"] = snapshot_version
+    out["source_status"] = source_status
+    return out[
+        [
+            "player_name",
+            "baseline_role",
+            "baseline_mode",
+            "prior_sample_size",
+            "season_2026_sample_size",
+            "prior_weight",
+            "season_2026_weight",
+            "baseline_driver",
+            "rolling_overlay_active",
+            "snapshot_built_at",
+            "snapshot_version",
+            "source_status",
+        ]
+    ].copy()
+
+
+def _build_rolling_snapshot_rows(
+    frame: pd.DataFrame,
+    role_label: str,
+    built_at: str,
+    snapshot_version: str,
+    source_status: str,
+) -> pd.DataFrame:
+    rows: list[dict[str, Any]] = []
+    if frame is None or frame.empty or "player_name" not in frame.columns:
+        return pd.DataFrame(
+            columns=[
+                "player_name",
+                "source_row_count",
+                "payload_json",
+                "snapshot_built_at",
+                "snapshot_version",
+                "source_status",
+            ]
+        )
+
+    for player_name, player_df in frame.groupby("player_name", dropna=False):
+        player_name_str = str(player_name or "").strip()
+        if not player_name_str:
+            continue
+        reference_date = None
+        if "game_date" in player_df.columns:
+            try:
+                reference_date = pd.to_datetime(
+                    player_df["game_date"], errors="coerce"
+                ).max()
+            except Exception:
+                reference_date = None
+
+        if role_label == "batter":
+            payload = build_batter_rolling_form_row(
+                statcast_df=frame,
+                player_name=player_name_str,
+                reference_date=reference_date,
+            )
+        else:
+            payload = build_pitcher_rolling_form_row(
+                statcast_df=frame,
+                pitcher_name=player_name_str,
+                reference_date=reference_date,
+            )
+
+        rows.append(
+            {
+                "player_name": player_name_str,
+                "source_row_count": int(len(player_df)),
+                "payload_json": json.dumps(payload, default=_json_default),
+                "snapshot_built_at": built_at,
+                "snapshot_version": snapshot_version,
+                "source_status": source_status,
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def _read_snapshot_table(
+    conn,
+    table_name: str,
+    player_names: tuple[str, ...] = (),
+) -> pd.DataFrame:
+    if player_names:
+        clauses = []
+        params: dict[str, Any] = {}
+        for idx, player_name in enumerate(player_names):
+            key = f"name_{idx}"
+            clauses.append(f":{key}")
+            params[key] = str(player_name)
+        query = text(
+            f"SELECT * FROM {table_name} WHERE player_name IN ({', '.join(clauses)}) ORDER BY player_name"
+        )
+        return pd.read_sql(query, conn, params=params)
+    return pd.read_sql(text(f"SELECT * FROM {table_name} ORDER BY player_name"), conn)
+
+
+def _hydrate_snapshot_frame(snapshot_df: pd.DataFrame) -> pd.DataFrame:
+    if snapshot_df is None or snapshot_df.empty:
+        return pd.DataFrame()
+    frames: list[pd.DataFrame] = []
+    for _, row in snapshot_df.iterrows():
+        frame = _deserialize_payload_frame(row.get("payload_json"))
+        if frame.empty:
+            continue
+        frames.append(frame)
+    if not frames:
+        return pd.DataFrame()
+    return pd.concat(frames, ignore_index=True, sort=False)
+
+
+def _hydrate_rolling_snapshot_frame(snapshot_df: pd.DataFrame) -> pd.DataFrame:
+    if snapshot_df is None or snapshot_df.empty:
+        return pd.DataFrame()
+    rows: list[dict[str, Any]] = []
+    for _, row in snapshot_df.iterrows():
+        try:
+            payload = json.loads(str(row.get("payload_json") or "{}"))
+        except Exception:
+            payload = {}
+        payload["player_name"] = str(row.get("player_name") or "").strip()
+        payload["snapshot_built_at"] = row.get("snapshot_built_at")
+        payload["snapshot_version"] = row.get("snapshot_version")
+        payload["source_status"] = row.get("source_status")
+        rows.append(payload)
+    return pd.DataFrame(rows)
+
+
+def persist_shared_baseline_snapshots(
+    bundle: dict[str, pd.DataFrame],
+    source_status: str = "runtime_refreshed",
+) -> dict[str, pd.DataFrame]:
+    built_at = utc_now_iso()
+
+    hitter_snapshot = _build_snapshot_rows(
+        bundle.get("blended_batter_df", pd.DataFrame()),
+        built_at=built_at,
+        snapshot_version=_SNAPSHOT_VERSION,
+        source_status=source_status,
+    )
+    pitcher_snapshot = _build_snapshot_rows(
+        bundle.get("blended_pitcher_df", pd.DataFrame()),
+        built_at=built_at,
+        snapshot_version=_SNAPSHOT_VERSION,
+        source_status=source_status,
+    )
+    hitter_meta = _build_meta_snapshot_rows(
+        bundle.get("batter_baseline_meta", pd.DataFrame()),
+        built_at=built_at,
+        snapshot_version=_SNAPSHOT_VERSION,
+        source_status=source_status,
+    )
+    pitcher_meta = _build_meta_snapshot_rows(
+        bundle.get("pitcher_baseline_meta", pd.DataFrame()),
+        built_at=built_at,
+        snapshot_version=_SNAPSHOT_VERSION,
+        source_status=source_status,
+    )
+    hitter_rolling = _build_rolling_snapshot_rows(
+        bundle.get("season_2026_ytd_hitter_df", pd.DataFrame()),
+        role_label="batter",
+        built_at=built_at,
+        snapshot_version=_SNAPSHOT_VERSION,
+        source_status=source_status,
+    )
+    pitcher_rolling = _build_rolling_snapshot_rows(
+        bundle.get("season_2026_ytd_pitcher_df", pd.DataFrame()),
+        role_label="pitcher",
+        built_at=built_at,
+        snapshot_version=_SNAPSHOT_VERSION,
+        source_status=source_status,
+    )
+
+    conn = get_connection()
+    try:
+        replace_table_contents(conn, "shared_hitter_baseline_snapshot", hitter_snapshot)
+        replace_table_contents(conn, "shared_pitcher_baseline_snapshot", pitcher_snapshot)
+        replace_table_contents(conn, "shared_hitter_baseline_meta", hitter_meta)
+        replace_table_contents(conn, "shared_pitcher_baseline_meta", pitcher_meta)
+        replace_table_contents(conn, "shared_hitter_rolling_snapshot", hitter_rolling)
+        replace_table_contents(conn, "shared_pitcher_rolling_snapshot", pitcher_rolling)
+    finally:
+        try:
+            conn.close()
+        except Exception:
+            pass
+
+    snapshot_status = pd.DataFrame(
+        [
+            {
+                "table_name": "shared_hitter_baseline_snapshot",
+                "row_count": int(len(hitter_snapshot)),
+                "snapshot_built_at": built_at,
+                "snapshot_version": _SNAPSHOT_VERSION,
+                "source_status": source_status,
+                "stale": False,
+            },
+            {
+                "table_name": "shared_pitcher_baseline_snapshot",
+                "row_count": int(len(pitcher_snapshot)),
+                "snapshot_built_at": built_at,
+                "snapshot_version": _SNAPSHOT_VERSION,
+                "source_status": source_status,
+                "stale": False,
+            },
+            {
+                "table_name": "shared_hitter_baseline_meta",
+                "row_count": int(len(hitter_meta)),
+                "snapshot_built_at": built_at,
+                "snapshot_version": _SNAPSHOT_VERSION,
+                "source_status": source_status,
+                "stale": False,
+            },
+            {
+                "table_name": "shared_pitcher_baseline_meta",
+                "row_count": int(len(pitcher_meta)),
+                "snapshot_built_at": built_at,
+                "snapshot_version": _SNAPSHOT_VERSION,
+                "source_status": source_status,
+                "stale": False,
+            },
+            {
+                "table_name": "shared_hitter_rolling_snapshot",
+                "row_count": int(len(hitter_rolling)),
+                "snapshot_built_at": built_at,
+                "snapshot_version": _SNAPSHOT_VERSION,
+                "source_status": source_status,
+                "stale": False,
+            },
+            {
+                "table_name": "shared_pitcher_rolling_snapshot",
+                "row_count": int(len(pitcher_rolling)),
+                "snapshot_built_at": built_at,
+                "snapshot_version": _SNAPSHOT_VERSION,
+                "source_status": source_status,
+                "stale": False,
+            },
+        ]
+    )
+    bundle["snapshot_status"] = snapshot_status
+    bundle["snapshot_source_status"] = source_status
+    bundle["runtime_fallback_used"] = False
+    return bundle
+
+
+def load_shared_baseline_bundle_from_snapshots(
+    batter_names: tuple[str, ...] = (),
+    pitcher_names: tuple[str, ...] = (),
+    max_age_seconds: int = _DEFAULT_SNAPSHOT_MAX_AGE_SECONDS,
+) -> dict[str, pd.DataFrame]:
+    batter_names = _normalize_names_tuple(batter_names)
+    pitcher_names = _normalize_names_tuple(pitcher_names)
+
+    conn = get_connection()
+    try:
+        hitter_snapshot = _read_snapshot_table(
+            conn,
+            "shared_hitter_baseline_snapshot",
+            player_names=batter_names,
+        )
+        pitcher_snapshot = _read_snapshot_table(
+            conn,
+            "shared_pitcher_baseline_snapshot",
+            player_names=pitcher_names,
+        )
+        hitter_meta = _read_snapshot_table(
+            conn,
+            "shared_hitter_baseline_meta",
+            player_names=batter_names,
+        )
+        pitcher_meta = _read_snapshot_table(
+            conn,
+            "shared_pitcher_baseline_meta",
+            player_names=pitcher_names,
+        )
+        hitter_rolling = _read_snapshot_table(
+            conn,
+            "shared_hitter_rolling_snapshot",
+            player_names=batter_names,
+        )
+        pitcher_rolling = _read_snapshot_table(
+            conn,
+            "shared_pitcher_rolling_snapshot",
+            player_names=pitcher_names,
+        )
+    except Exception:
+        return {
+            "multi_year_prior_hitter_df": pd.DataFrame(),
+            "season_2026_ytd_hitter_df": pd.DataFrame(),
+            "multi_year_prior_pitcher_df": pd.DataFrame(),
+            "season_2026_ytd_pitcher_df": pd.DataFrame(),
+            "blended_batter_df": pd.DataFrame(),
+            "blended_pitcher_df": pd.DataFrame(),
+            "batter_baseline_meta": pd.DataFrame(),
+            "pitcher_baseline_meta": pd.DataFrame(),
+            "hitter_rolling_snapshot": pd.DataFrame(),
+            "pitcher_rolling_snapshot": pd.DataFrame(),
+            "snapshot_status": pd.DataFrame(),
+            "snapshot_source_status": "snapshot_unavailable",
+            "runtime_fallback_used": False,
+        }
+    finally:
+        try:
+            conn.close()
+        except Exception:
+            pass
+
+    snapshot_status_rows: list[dict[str, Any]] = []
+    for table_name, frame in [
+        ("shared_hitter_baseline_snapshot", hitter_snapshot),
+        ("shared_pitcher_baseline_snapshot", pitcher_snapshot),
+        ("shared_hitter_baseline_meta", hitter_meta),
+        ("shared_pitcher_baseline_meta", pitcher_meta),
+        ("shared_hitter_rolling_snapshot", hitter_rolling),
+        ("shared_pitcher_rolling_snapshot", pitcher_rolling),
+    ]:
+        built_at = None
+        version = None
+        source_status = None
+        if isinstance(frame, pd.DataFrame) and not frame.empty:
+            built_at = frame.get("snapshot_built_at", pd.Series(dtype="object")).iloc[0]
+            version = frame.get("snapshot_version", pd.Series(dtype="object")).iloc[0]
+            source_status = frame.get("source_status", pd.Series(dtype="object")).iloc[0]
+        snapshot_status_rows.append(
+            {
+                "table_name": table_name,
+                "row_count": 0 if frame is None else int(len(frame)),
+                "snapshot_built_at": built_at,
+                "snapshot_version": version,
+                "source_status": source_status,
+                "stale": _is_snapshot_stale(built_at, max_age_seconds),
+            }
+        )
+
+    return {
+        "multi_year_prior_hitter_df": pd.DataFrame(),
+        "season_2026_ytd_hitter_df": pd.DataFrame(),
+        "multi_year_prior_pitcher_df": pd.DataFrame(),
+        "season_2026_ytd_pitcher_df": pd.DataFrame(),
+        "blended_batter_df": _hydrate_snapshot_frame(hitter_snapshot),
+        "blended_pitcher_df": _hydrate_snapshot_frame(pitcher_snapshot),
+        "batter_baseline_meta": hitter_meta,
+        "pitcher_baseline_meta": pitcher_meta,
+        "hitter_rolling_snapshot": _hydrate_rolling_snapshot_frame(hitter_rolling),
+        "pitcher_rolling_snapshot": _hydrate_rolling_snapshot_frame(pitcher_rolling),
+        "snapshot_status": pd.DataFrame(snapshot_status_rows),
+        "snapshot_source_status": "snapshot",
+        "runtime_fallback_used": False,
+    }
+
+
+def load_or_build_shared_baseline_bundle(
+    batter_names: tuple[str, ...] = (),
+    pitcher_names: tuple[str, ...] = (),
+    max_age_seconds: int = _DEFAULT_SNAPSHOT_MAX_AGE_SECONDS,
+    persist_runtime_refresh: bool = True,
+) -> dict[str, pd.DataFrame]:
+    batter_names = _normalize_names_tuple(batter_names)
+    pitcher_names = _normalize_names_tuple(pitcher_names)
+
+    snapshot_bundle = load_shared_baseline_bundle_from_snapshots(
+        batter_names=batter_names,
+        pitcher_names=pitcher_names,
+        max_age_seconds=max_age_seconds,
+    )
+    snapshot_status = snapshot_bundle.get("snapshot_status", pd.DataFrame())
+
+    requested_hitter_covered = True
+    if batter_names:
+        available_hitters = {
+            str(name).strip().lower()
+            for name in snapshot_bundle.get("batter_baseline_meta", pd.DataFrame())
+            .get("player_name", pd.Series(dtype="object"))
+            .dropna()
+            .astype(str)
+            .tolist()
+        }
+        requested_hitter_covered = all(name.lower() in available_hitters for name in batter_names)
+
+    requested_pitcher_covered = True
+    if pitcher_names:
+        available_pitchers = {
+            str(name).strip().lower()
+            for name in snapshot_bundle.get("pitcher_baseline_meta", pd.DataFrame())
+            .get("player_name", pd.Series(dtype="object"))
+            .dropna()
+            .astype(str)
+            .tolist()
+        }
+        requested_pitcher_covered = all(name.lower() in available_pitchers for name in pitcher_names)
+
+    snapshot_has_data = not snapshot_bundle.get("blended_batter_df", pd.DataFrame()).empty or not snapshot_bundle.get("blended_pitcher_df", pd.DataFrame()).empty
+    snapshot_stale = bool(
+        isinstance(snapshot_status, pd.DataFrame)
+        and not snapshot_status.empty
+        and snapshot_status["stale"].fillna(False).any()
+    )
+
+    if snapshot_has_data and requested_hitter_covered and requested_pitcher_covered and not snapshot_stale:
+        return snapshot_bundle
+
+    runtime_bundle = build_shared_baseline_bundle(
+        batter_names=batter_names,
+        pitcher_names=pitcher_names,
+    )
+    runtime_bundle["snapshot_source_status"] = "runtime_fallback"
+    runtime_bundle["runtime_fallback_used"] = True
+
+    if persist_runtime_refresh and not batter_names and not pitcher_names:
+        runtime_bundle = persist_shared_baseline_snapshots(
+            runtime_bundle,
+            source_status="runtime_refreshed",
+        )
+
+    if "snapshot_status" not in runtime_bundle:
+        runtime_bundle["snapshot_status"] = snapshot_status
+    return runtime_bundle
+
+
 def build_shared_baseline_bundle(
     batter_names: tuple[str, ...] | None = None,
     pitcher_names: tuple[str, ...] | None = None,

data/statcast.py

@@ -90,6 +90,8 @@ def normalize_statcast(df: pd.DataFrame) -> pd.DataFrame:
 
     rename_map = {
         "player_name": "player_name",
+        "batter": "batter",
+        "pitcher": "pitcher",
         "pitch_type": "pitch_type",
         "pitch_name": "pitch_name",
         "release_speed": "release_speed",
@@ -114,6 +116,10 @@ def normalize_statcast(df: pd.DataFrame) -> pd.DataFrame:
         "p_throws": "pitcher_hand",
         "home_team": "home_team",
         "away_team": "away_team",
+        "inning_topbot": "inning_topbot",
+        "team": "team",
+        "batter_team": "batter_team",
+        "team_name": "team_name",
         "game_date": "game_date",
         "game_pk": "game_pk",
         "inning": "inning",
@@ -130,6 +136,11 @@ def normalize_statcast(df: pd.DataFrame) -> pd.DataFrame:
     out = df[keep_cols].copy()
     out = out.rename(columns={col: rename_map[col] for col in keep_cols})
 
+    if "pitcher_hand" in out.columns and "p_throws" not in out.columns:
+        out["p_throws"] = out["pitcher_hand"]
+    if "batter_stand" in out.columns and "stand" not in out.columns:
+        out["stand"] = out["batter_stand"]
+
     numeric_cols = [
         "release_speed",
         "release_spin_rate",
@@ -160,4 +171,4 @@ def normalize_statcast(df: pd.DataFrame) -> pd.DataFrame:
     if "game_date" in out.columns:
         out["game_date"] = pd.to_datetime(out["game_date"], errors="coerce")
 
-    return out
+    return out

database/db.py

@@ -22,6 +22,7 @@ so they can be added later without structural changes.
 
 from __future__ import annotations
 
+import json
 from typing import Any, Iterable, Mapping
 
 import pandas as pd
@@ -287,6 +288,7 @@ def initialize_schema(conn) -> None:
     """
     ensure_statcast_core_tables(conn)
     ensure_live_pitch_tables(conn)
+    ensure_shared_baseline_snapshot_tables(conn)
 
     conn.execute(text(
         """
@@ -311,17 +313,42 @@ def initialize_schema(conn) -> None:
         CREATE TABLE IF NOT EXISTS cached_schedule (
             fetched_at  TEXT,
             game_id     TEXT,
+            game_pk     TEXT,
             game_date   TEXT,
             status      TEXT,
             away_team   TEXT,
             home_team   TEXT,
             away_score  INTEGER,
             home_score  INTEGER,
-            venue       TEXT
+            away_hits   INTEGER,
+            home_hits   INTEGER,
+            away_errors INTEGER,
+            home_errors INTEGER,
+            venue       TEXT,
+            game_datetime_utc TEXT,
+            tv          TEXT,
+            start_time_et TEXT,
+            sport_id    INTEGER
         )
         """
     ))
 
+    for _stmt in [
+        "ALTER TABLE cached_schedule ADD COLUMN IF NOT EXISTS game_pk TEXT",
+        "ALTER TABLE cached_schedule ADD COLUMN IF NOT EXISTS away_hits INTEGER",
+        "ALTER TABLE cached_schedule ADD COLUMN IF NOT EXISTS home_hits INTEGER",
+        "ALTER TABLE cached_schedule ADD COLUMN IF NOT EXISTS away_errors INTEGER",
+        "ALTER TABLE cached_schedule ADD COLUMN IF NOT EXISTS home_errors INTEGER",
+        "ALTER TABLE cached_schedule ADD COLUMN IF NOT EXISTS game_datetime_utc TEXT",
+        "ALTER TABLE cached_schedule ADD COLUMN IF NOT EXISTS tv TEXT",
+        "ALTER TABLE cached_schedule ADD COLUMN IF NOT EXISTS start_time_et TEXT",
+        "ALTER TABLE cached_schedule ADD COLUMN IF NOT EXISTS sport_id INTEGER",
+    ]:
+        try:
+            conn.execute(text(_stmt))
+        except Exception:
+            pass
+
     conn.execute(text(
         """
         CREATE TABLE IF NOT EXISTS cached_odds (
@@ -354,6 +381,58 @@ def initialize_schema(conn) -> None:
         """
     ))
 
+    conn.execute(text(
+        """
+        CREATE TABLE IF NOT EXISTS cached_probable_starters (
+            fetched_at       TEXT,
+            away_team_norm   TEXT,
+            home_team_norm   TEXT,
+            away_team_raw    TEXT,
+            home_team_raw    TEXT,
+            away_pitcher     TEXT,
+            home_pitcher     TEXT
+        )
+        """
+    ))
+
+    conn.execute(text(
+        """
+        CREATE TABLE IF NOT EXISTS cached_projected_lineups (
+            fetched_at         TEXT,
+            team_name_norm     TEXT,
+            team_name          TEXT,
+            source             TEXT,
+            lineup_vs_rhp_json TEXT,
+            lineup_vs_lhp_json TEXT,
+            rotation_json      TEXT
+        )
+        """
+    ))
+
+    conn.execute(text(
+        """
+        CREATE TABLE IF NOT EXISTS cached_upcoming_props_feed (
+            fetched_at    TEXT,
+            cache_key     TEXT,
+            row_count     INTEGER,
+            payload_json  TEXT
+        )
+        """
+    ))
+
+    conn.execute(text(
+        """
+        CREATE TABLE IF NOT EXISTS cached_upcoming_props_bundle_meta (
+            fetched_at            TEXT,
+            cache_key             TEXT,
+            merged_row_count      INTEGER,
+            odds_api_row_count    INTEGER,
+            scraper_row_count     INTEGER,
+            coverage_summary_json TEXT
+        )
+        """
+    ))
+
     conn.execute(text(
         "CREATE INDEX IF NOT EXISTS idx_statcast_player_date "
         "ON statcast_event_core (player_name, source_season, game_date)"
@@ -386,6 +465,34 @@ def initialize_schema(conn) -> None:
         "CREATE INDEX IF NOT EXISTS idx_lbgl_player_date "
         "ON live_batter_game_log_2026 (player_name, game_date)"
     ))
+    conn.execute(text(
+        "CREATE INDEX IF NOT EXISTS idx_cached_schedule_game_date "
+        "ON cached_schedule (game_date)"
+    ))
+    conn.execute(text(
+        "CREATE INDEX IF NOT EXISTS idx_cached_odds_fetched_at "
+        "ON cached_odds (fetched_at)"
+    ))
+    conn.execute(text(
+        "CREATE INDEX IF NOT EXISTS idx_cached_weather_venue "
+        "ON cached_weather (venue_key, fetched_at)"
+    ))
+    conn.execute(text(
+        "CREATE INDEX IF NOT EXISTS idx_cached_probable_starters_matchup "
+        "ON cached_probable_starters (away_team_norm, home_team_norm)"
+    ))
+    conn.execute(text(
+        "CREATE INDEX IF NOT EXISTS idx_cached_projected_lineups_team "
+        "ON cached_projected_lineups (team_name_norm)"
+    ))
+    conn.execute(text(
+        "CREATE INDEX IF NOT EXISTS idx_cached_upcoming_props_feed_key "
+        "ON cached_upcoming_props_feed (cache_key, fetched_at)"
+    ))
+    conn.execute(text(
+        "CREATE INDEX IF NOT EXISTS idx_cached_upcoming_props_bundle_meta_key "
+        "ON cached_upcoming_props_bundle_meta (cache_key, fetched_at)"
+    ))
 
 
 # ---------------------------------------------------------------------------
@@ -405,10 +512,415 @@ def upsert_dataframe(
     _bulk_insert(conn, table_name, df)
 
 
+def replace_table_contents(
+    conn,
+    table_name: str,
+    df: pd.DataFrame | None,
+) -> None:
+    """
+    Replace the full contents of a table, even when the replacement frame is empty.
+    """
+    conn.execute(text(f"DELETE FROM {table_name}"))
+    if df is None or df.empty:
+        return
+    _bulk_insert(conn, table_name, df)
+
+
 def read_table(conn, table_name: str) -> pd.DataFrame:
     return pd.read_sql(text(f"SELECT * FROM {table_name}"), conn)
 
 
+def _safe_json_dump(value: Any) -> str:
+    return json.dumps(value, default=str)
+
+
+def _safe_json_load(value: Any, default: Any) -> Any:
+    try:
+        if value is None or str(value).strip() == "":
+            return default
+        return json.loads(str(value))
+    except Exception:
+        return default
+
+
+def _latest_fetched_at(df: pd.DataFrame) -> str:
+    if df is None or df.empty or "fetched_at" not in df.columns:
+        return utc_now_iso()
+    try:
+        ts = pd.to_datetime(df["fetched_at"], errors="coerce").max()
+        if pd.isna(ts):
+            return utc_now_iso()
+        return str(ts)
+    except Exception:
+        return utc_now_iso()
+
+
+def replace_cached_schedule(conn, df: pd.DataFrame) -> None:
+    if df is None:
+        df = pd.DataFrame()
+    cols = [
+        "fetched_at",
+        "game_id",
+        "game_pk",
+        "game_date",
+        "status",
+        "away_team",
+        "home_team",
+        "away_score",
+        "home_score",
+        "away_hits",
+        "home_hits",
+        "away_errors",
+        "home_errors",
+        "venue",
+        "game_datetime_utc",
+        "tv",
+        "start_time_et",
+        "sport_id",
+    ]
+    out = df.copy()
+    for col in cols:
+        if col not in out.columns:
+            out[col] = None
+    date_values = {
+        str(value).strip()
+        for value in out["game_date"].dropna().astype(str).tolist()
+        if str(value).strip()
+    }
+    if date_values:
+        clauses = []
+        params: dict[str, Any] = {}
+        for idx, value in enumerate(sorted(date_values)):
+            key = f"date_{idx}"
+            clauses.append(f":{key}")
+            params[key] = value
+        conn.execute(
+            text(f"DELETE FROM cached_schedule WHERE game_date IN ({', '.join(clauses)})"),
+            params,
+        )
+    _bulk_insert(conn, "cached_schedule", out[cols])
+
+
+def read_cached_schedule_for_date(conn, date_str: str) -> pd.DataFrame:
+    return pd.read_sql(
+        text("SELECT * FROM cached_schedule WHERE game_date = :date ORDER BY game_id"),
+        conn,
+        params={"date": str(date_str)},
+    )
+
+
+def replace_cached_odds(conn, df: pd.DataFrame) -> None:
+    if df is None:
+        df = pd.DataFrame()
+    cols = [
+        "fetched_at",
+        "event_id",
+        "commence_time",
+        "home_team",
+        "away_team",
+        "sportsbook",
+        "market_key",
+        "outcome_name",
+        "price",
+        "point",
+    ]
+    out = df.copy()
+    for col in cols:
+        if col not in out.columns:
+            out[col] = None
+    replace_table_contents(conn, "cached_odds", out[cols])
+
+
+def read_cached_odds(conn) -> pd.DataFrame:
+    return pd.read_sql(text("SELECT * FROM cached_odds ORDER BY fetched_at DESC"), conn)
+
+
+def replace_cached_weather(conn, df: pd.DataFrame) -> None:
+    if df is None:
+        df = pd.DataFrame()
+    cols = [
+        "fetched_at",
+        "venue_key",
+        "location_name",
+        "temperature_f",
+        "humidity",
+        "wind_speed_mph",
+        "wind_deg",
+        "description",
+    ]
+    out = df.copy()
+    for col in cols:
+        if col not in out.columns:
+            out[col] = None
+    venue_values = {
+        str(value).strip()
+        for value in out["venue_key"].dropna().astype(str).tolist()
+        if str(value).strip()
+    }
+    if venue_values:
+        clauses = []
+        params: dict[str, Any] = {}
+        for idx, value in enumerate(sorted(venue_values)):
+            key = f"venue_{idx}"
+            clauses.append(f":{key}")
+            params[key] = value
+        conn.execute(
+            text(f"DELETE FROM cached_weather WHERE venue_key IN ({', '.join(clauses)})"),
+            params,
+        )
+    _bulk_insert(conn, "cached_weather", out[cols])
+
+
+def read_cached_weather_for_venue(conn, venue_key: str) -> pd.DataFrame:
+    return pd.read_sql(
+        text(
+            """
+            SELECT * FROM cached_weather
+            WHERE venue_key = :venue
+            ORDER BY fetched_at DESC
+            """
+        ),
+        conn,
+        params={"venue": str(venue_key)},
+    )
+
+
+def replace_cached_probable_starters(
+    conn,
+    starters_map: Mapping[tuple[str, str], Mapping[str, Any]] | None,
+) -> None:
+    rows: list[dict[str, Any]] = []
+    fetched_at = utc_now_iso()
+    for key, payload in (starters_map or {}).items():
+        if not isinstance(key, tuple) or len(key) != 2:
+            continue
+        away_norm, home_norm = key
+        payload = dict(payload or {})
+        rows.append(
+            {
+                "fetched_at": fetched_at,
+                "away_team_norm": str(away_norm or "").strip(),
+                "home_team_norm": str(home_norm or "").strip(),
+                "away_team_raw": str(payload.get("away_team_raw") or "").strip(),
+                "home_team_raw": str(payload.get("home_team_raw") or "").strip(),
+                "away_pitcher": str(payload.get("away_pitcher") or "").strip() or None,
+                "home_pitcher": str(payload.get("home_pitcher") or "").strip() or None,
+            }
+        )
+    replace_table_contents(conn, "cached_probable_starters", pd.DataFrame(rows))
+
+
+def read_cached_probable_starters(conn) -> dict[tuple[str, str], dict[str, str | None]]:
+    df = pd.read_sql(text("SELECT * FROM cached_probable_starters"), conn)
+    if df.empty:
+        return {}
+    out: dict[tuple[str, str], dict[str, str | None]] = {}
+    for _, row in df.iterrows():
+        key = (
+            str(row.get("away_team_norm") or "").strip(),
+            str(row.get("home_team_norm") or "").strip(),
+        )
+        if not key[0] or not key[1]:
+            continue
+        out[key] = {
+            "away_team_raw": str(row.get("away_team_raw") or "").strip(),
+            "home_team_raw": str(row.get("home_team_raw") or "").strip(),
+            "away_pitcher": str(row.get("away_pitcher") or "").strip() or None,
+            "home_pitcher": str(row.get("home_pitcher") or "").strip() or None,
+        }
+    return out
+
+
+def read_cached_probable_starters_meta(conn) -> pd.DataFrame:
+    return pd.read_sql(
+        text(
+            """
+            SELECT fetched_at, COUNT(*) AS matchup_count
+            FROM cached_probable_starters
+            GROUP BY fetched_at
+            ORDER BY fetched_at DESC
+            """
+        ),
+        conn,
+    )
+
+
+def replace_cached_projected_lineups(
+    conn,
+    projected_lineups: Mapping[str, Mapping[str, Any]] | None,
+) -> None:
+    rows: list[dict[str, Any]] = []
+    fetched_at = utc_now_iso()
+    for team_norm, payload in (projected_lineups or {}).items():
+        payload = dict(payload or {})
+        rows.append(
+            {
+                "fetched_at": fetched_at,
+                "team_name_norm": str(team_norm or "").strip(),
+                "team_name": str(payload.get("team_name") or "").strip(),
+                "source": str(payload.get("source") or "").strip(),
+                "lineup_vs_rhp_json": _safe_json_dump(payload.get("lineup_vs_rhp") or []),
+                "lineup_vs_lhp_json": _safe_json_dump(payload.get("lineup_vs_lhp") or []),
+                "rotation_json": _safe_json_dump(payload.get("rotation") or []),
+            }
+        )
+    df = pd.DataFrame(rows)
+    if not df.empty:
+        team_values = {
+            str(value).strip()
+            for value in df["team_name_norm"].dropna().astype(str).tolist()
+            if str(value).strip()
+        }
+        if team_values:
+            clauses = []
+            params: dict[str, Any] = {}
+            for idx, value in enumerate(sorted(team_values)):
+                key = f"team_{idx}"
+                clauses.append(f":{key}")
+                params[key] = value
+            conn.execute(
+                text(f"DELETE FROM cached_projected_lineups WHERE team_name_norm IN ({', '.join(clauses)})"),
+                params,
+            )
+    if df.empty:
+        return
+    _bulk_insert(conn, "cached_projected_lineups", df)
+
+
+def read_cached_projected_lineups(
+    conn,
+    team_names_norm: Iterable[str] | None = None,
+) -> dict[str, dict[str, Any]]:
+    team_names = [str(v or "").strip() for v in (team_names_norm or []) if str(v or "").strip()]
+    if team_names:
+        clauses = []
+        params: dict[str, Any] = {}
+        for idx, team_name in enumerate(team_names):
+            key = f"team_{idx}"
+            clauses.append(f":{key}")
+            params[key] = team_name
+        df = pd.read_sql(
+            text(
+                f"SELECT * FROM cached_projected_lineups WHERE team_name_norm IN ({', '.join(clauses)})"
+            ),
+            conn,
+            params=params,
+        )
+    else:
+        df = pd.read_sql(text("SELECT * FROM cached_projected_lineups"), conn)
+    if df.empty:
+        return {}
+    out: dict[str, dict[str, Any]] = {}
+    for _, row in df.iterrows():
+        team_norm = str(row.get("team_name_norm") or "").strip()
+        if not team_norm:
+            continue
+        out[team_norm] = {
+            "team_name": str(row.get("team_name") or "").strip(),
+            "source": str(row.get("source") or "").strip(),
+            "lineup_vs_rhp": _safe_json_load(row.get("lineup_vs_rhp_json"), []),
+            "lineup_vs_lhp": _safe_json_load(row.get("lineup_vs_lhp_json"), []),
+            "rotation": _safe_json_load(row.get("rotation_json"), []),
+        }
+    return out
+
+
+def read_cached_projected_lineups_meta(conn) -> pd.DataFrame:
+    return pd.read_sql(
+        text(
+            """
+            SELECT fetched_at, COUNT(*) AS team_count
+            FROM cached_projected_lineups
+            GROUP BY fetched_at
+            ORDER BY fetched_at DESC
+            """
+        ),
+        conn,
+    )
+
+
+def replace_cached_upcoming_props_bundle(
+    conn,
+    bundle: Mapping[str, pd.DataFrame] | None,
+    cache_key: str = "default",
+) -> None:
+    bundle = dict(bundle or {})
+    merged = bundle.get("merged_props_feed", pd.DataFrame())
+    coverage = bundle.get("coverage_summary", pd.DataFrame())
+    odds_api_raw = bundle.get("odds_api_raw", pd.DataFrame())
+    scraper_raw = bundle.get("scraper_raw", pd.DataFrame())
+
+    fetched_at = _latest_fetched_at(merged if isinstance(merged, pd.DataFrame) else pd.DataFrame())
+    feed_df = pd.DataFrame(
+        [
+            {
+                "fetched_at": fetched_at,
+                "cache_key": cache_key,
+                "row_count": int(len(merged)) if isinstance(merged, pd.DataFrame) else 0,
+                "payload_json": _safe_json_dump(
+                    [] if merged is None or not isinstance(merged, pd.DataFrame)
+                    else merged.where(merged.notna(), other=None).to_dict("records")
+                ),
+            }
+        ]
+    )
+    meta_df = pd.DataFrame(
+        [
+            {
+                "fetched_at": fetched_at,
+                "cache_key": cache_key,
+                "merged_row_count": int(len(merged)) if isinstance(merged, pd.DataFrame) else 0,
+                "odds_api_row_count": int(len(odds_api_raw)) if isinstance(odds_api_raw, pd.DataFrame) else 0,
+                "scraper_row_count": int(len(scraper_raw)) if isinstance(scraper_raw, pd.DataFrame) else 0,
+                "coverage_summary_json": _safe_json_dump(
+                    [] if coverage is None or not isinstance(coverage, pd.DataFrame)
+                    else coverage.where(coverage.notna(), other=None).to_dict("records")
+                ),
+            }
+        ]
+    )
+    replace_table_contents(conn, "cached_upcoming_props_feed", feed_df)
+    replace_table_contents(conn, "cached_upcoming_props_bundle_meta", meta_df)
+
+
+def read_cached_upcoming_props_bundle(
+    conn,
+    cache_key: str = "default",
+) -> dict[str, pd.DataFrame]:
+    feed_df = pd.read_sql(
+        text(
+            """
+            SELECT * FROM cached_upcoming_props_feed
+            WHERE cache_key = :cache_key
+            ORDER BY fetched_at DESC
+            LIMIT 1
+            """
+        ),
+        conn,
+        params={"cache_key": cache_key},
+    )
+    meta_df = pd.read_sql(
+        text(
+            """
+            SELECT * FROM cached_upcoming_props_bundle_meta
+            WHERE cache_key = :cache_key
+            ORDER BY fetched_at DESC
+            LIMIT 1
+            """
+        ),
+        conn,
+        params={"cache_key": cache_key},
+    )
+
+    merged = pd.DataFrame(_safe_json_load(feed_df.iloc[0]["payload_json"], [])) if not feed_df.empty else pd.DataFrame()
+    coverage = pd.DataFrame(_safe_json_load(meta_df.iloc[0]["coverage_summary_json"], [])) if not meta_df.empty else pd.DataFrame()
+    return {
+        "merged_props_feed": merged,
+        "coverage_summary": coverage,
+        "cache_meta": meta_df,
+    }
+
+
 # ---------------------------------------------------------------------------
 # Bets
 # ---------------------------------------------------------------------------
@@ -876,6 +1388,113 @@ def read_upcoming_hr_props(conn) -> pd.DataFrame:
     )
 
 
+# ---------------------------------------------------------------------------
+# Shared baseline snapshots
+# ---------------------------------------------------------------------------
+
+def ensure_shared_baseline_snapshot_tables(conn) -> None:
+    conn.execute(text(
+        """
+        CREATE TABLE IF NOT EXISTS shared_hitter_baseline_snapshot (
+            player_name        TEXT,
+            source_row_count   INTEGER,
+            payload_json       TEXT,
+            snapshot_built_at  TEXT,
+            snapshot_version   TEXT,
+            source_status      TEXT
+        )
+        """
+    ))
+    conn.execute(text(
+        """
+        CREATE TABLE IF NOT EXISTS shared_pitcher_baseline_snapshot (
+            player_name        TEXT,
+            source_row_count   INTEGER,
+            payload_json       TEXT,
+            snapshot_built_at  TEXT,
+            snapshot_version   TEXT,
+            source_status      TEXT
+        )
+        """
+    ))
+    conn.execute(text(
+        """
+        CREATE TABLE IF NOT EXISTS shared_hitter_baseline_meta (
+            player_name               TEXT,
+            baseline_role             TEXT,
+            baseline_mode             TEXT,
+            prior_sample_size         INTEGER,
+            season_2026_sample_size   INTEGER,
+            prior_weight              DOUBLE PRECISION,
+            season_2026_weight        DOUBLE PRECISION,
+            baseline_driver           TEXT,
+            rolling_overlay_active    BOOLEAN,
+            snapshot_built_at         TEXT,
+            snapshot_version          TEXT,
+            source_status             TEXT
+        )
+        """
+    ))
+    conn.execute(text(
+        """
+        CREATE TABLE IF NOT EXISTS shared_pitcher_baseline_meta (
+            player_name               TEXT,
+            baseline_role             TEXT,
+            baseline_mode             TEXT,
+            prior_sample_size         INTEGER,
+            season_2026_sample_size   INTEGER,
+            prior_weight              DOUBLE PRECISION,
+            season_2026_weight        DOUBLE PRECISION,
+            baseline_driver           TEXT,
+            rolling_overlay_active    BOOLEAN,
+            snapshot_built_at         TEXT,
+            snapshot_version          TEXT,
+            source_status             TEXT
+        )
+        """
+    ))
+    conn.execute(text(
+        """
+        CREATE TABLE IF NOT EXISTS shared_hitter_rolling_snapshot (
+            player_name        TEXT,
+            source_row_count   INTEGER,
+            payload_json       TEXT,
+            snapshot_built_at  TEXT,
+            snapshot_version   TEXT,
+            source_status      TEXT
+        )
+        """
+    ))
+    conn.execute(text(
+        """
+        CREATE TABLE IF NOT EXISTS shared_pitcher_rolling_snapshot (
+            player_name        TEXT,
+            source_row_count   INTEGER,
+            payload_json       TEXT,
+            snapshot_built_at  TEXT,
+            snapshot_version   TEXT,
+            source_status      TEXT
+        )
+        """
+    ))
+
+    for _table in [
+        "shared_hitter_baseline_snapshot",
+        "shared_pitcher_baseline_snapshot",
+        "shared_hitter_baseline_meta",
+        "shared_pitcher_baseline_meta",
+        "shared_hitter_rolling_snapshot",
+        "shared_pitcher_rolling_snapshot",
+    ]:
+        try:
+            conn.execute(text(
+                f"CREATE UNIQUE INDEX IF NOT EXISTS uq_{_table}_player_name "
+                f"ON {_table} (player_name)"
+            ))
+        except Exception:
+            pass
+
+
 # ---------------------------------------------------------------------------
 # Batter prop audit view
 # ---------------------------------------------------------------------------

models/hr_probability_engine.py

@@ -85,10 +85,19 @@ def _empty_result(player_name: str, mode: str) -> dict[str, Any]:
         "matchup_platoon_multiplier": 1.0,
         "matchup_platoon_reason": "unknown",
         "pitcher_reliability": 0.0,
+        "pitcher_resolution_status": "pitcher_missing",
         "trend_reliability": 0.0,
         "zone_reliability": 0.0,
+        "zone_status": "unavailable",
+        "zone_store_sample_size": 0,
         "family_zone_reliability": 0.0,
+        "family_zone_status": "unavailable",
+        "family_zone_batter_sample_size": 0,
+        "family_zone_pitcher_sample_size": 0,
         "arsenal_reliability": 0.0,
+        "arsenal_status": "unavailable",
+        "arsenal_batter_sample_size": 0,
+        "arsenal_pitcher_sample_size": 0,
         "pulled_contact_reliability": 0.0,
         "environment_reliability": 0.0,
         "trajectory_reliability": 0.0,
@@ -96,6 +105,7 @@ def _empty_result(player_name: str, mode: str) -> dict[str, Any]:
         "opportunity_reliability": 0.0,
         "model_voice_reason_candidates": [],
         "model_voice_tags": [],
+        "reason_candidate_count": 0,
     }
 
 
@@ -387,6 +397,11 @@ def build_hr_probability_result(
     )
     pitcher_reliability = _sample_reliability(pitcher_row.get("sample_size"), 180.0)
     result["pitcher_reliability"] = pitcher_reliability
+    result["pitcher_resolution_status"] = (
+        "resolved" if result["pitcher_name"] and _safe_float(pitcher_row.get("sample_size"), 0.0) > 0 else
+        "resolved_no_pitcher_statcast" if result["pitcher_name"] else
+        "pitcher_missing"
+    )
     result["pitcher_hr_adjustment"] = _apply_reliability(
         _safe_float(pitcher_adj.get("hr_adj")),
         pitcher_reliability,
@@ -437,6 +452,8 @@ def build_hr_probability_result(
             _sample_reliability(pitcher_row.get("sample_size"), 180.0),
         )
         zone_eff = 0.0
+        batter_zone_row: dict[str, Any] = {}
+        pitcher_zone_row: dict[str, Any] = {}
         try:
             from models.batter_zone_model import build_batter_zone_feature_row
             from models.pitcher_zone_model import build_pitcher_zone_feature_row
@@ -449,10 +466,13 @@ def build_hr_probability_result(
                 pitcher_zone_row=pitcher_zone_row,
             )
             zone_eff = _safe_float(zone_matchup_adj.get("hr_zone_boost")) * 0.10
+            result["zone_store_sample_size"] = int(_safe_float(batter_zone_row.get("zone_sample_size"), 0.0) or 0.0)
         except Exception:
             skipped_layers.append("zone_matchup_unavailable")
 
         family_zone_eff = 0.0
+        batter_family_zone_row: dict[str, Any] = {}
+        pitcher_family_zone_row: dict[str, Any] = {}
         try:
             from models.family_zone_profile_store import (
                 build_batter_family_zone_feature_row,
@@ -469,6 +489,8 @@ def build_hr_probability_result(
             family_zone_eff = _safe_float(
                 family_zone_matchup_adj.get("family_zone_hr_boost")
             ) * 0.07
+            result["family_zone_batter_sample_size"] = int(_safe_float(batter_family_zone_row.get("family_zone_sample_size"), 0.0) or 0.0)
+            result["family_zone_pitcher_sample_size"] = int(_safe_float(pitcher_family_zone_row.get("family_zone_sample_size"), 0.0) or 0.0)
         except Exception:
             skipped_layers.append("family_zone_db_unavailable")
 
@@ -487,6 +509,18 @@ def build_hr_probability_result(
             family_zone_eff * matchup_multiplier,
             matchup_reliability,
         )
+        result["zone_status"] = (
+            "applied" if abs(result["zone_hr_adjustment"]) > 1e-6 else
+            "missing_batter_zone_profile" if int(_safe_float(batter_zone_row.get("zone_sample_size"), 0.0) or 0.0) <= 0 else
+            "missing_pitcher_zone_profile" if int(_safe_float(pitcher_zone_row.get("zone_sample_size"), 0.0) or 0.0) <= 0 else
+            "available_zero_effect"
+        )
+        result["family_zone_status"] = (
+            "applied" if abs(result["family_zone_hr_adjustment"]) > 1e-6 else
+            "missing_batter_family_zone_profile" if int(_safe_float(batter_family_zone_row.get("family_zone_sample_size"), 0.0) or 0.0) <= 0 else
+            "missing_pitcher_family_zone_profile" if int(_safe_float(pitcher_family_zone_row.get("family_zone_sample_size"), 0.0) or 0.0) <= 0 else
+            "available_zero_effect"
+        )
 
         hr_prob = _clamp(hr_prob + result["zone_hr_adjustment"], 0.005, 0.25)
         hr_prob = _clamp(hr_prob + result["family_zone_hr_adjustment"], 0.005, 0.25)
@@ -510,6 +544,8 @@ def build_hr_probability_result(
             )
 
         arsenal_eff = 0.0
+        batter_arsenal_row: dict[str, Any] = {}
+        pitcher_arsenal_row: dict[str, Any] = {}
         try:
             from models.arsenal_matchup_model import compute_arsenal_matchup_adjustment
             from models.batter_arsenal_model import build_batter_arsenal_feature_row
@@ -524,11 +560,19 @@ def build_hr_probability_result(
             arsenal_eff = (
                 _safe_float(arsenal_matchup_adj.get("arsenal_hr_boost")) * 0.05
             ) * matchup_multiplier
+            result["arsenal_batter_sample_size"] = int(_safe_float(batter_arsenal_row.get("arsenal_sample_size"), 0.0) or 0.0)
+            result["arsenal_pitcher_sample_size"] = int(_safe_float(pitcher_arsenal_row.get("arsenal_sample_size"), 0.0) or 0.0)
         except Exception:
             skipped_layers.append("arsenal_matchup_unavailable")
 
         result["arsenal_reliability"] = matchup_reliability
         result["arsenal_hr_adjustment"] = _apply_reliability(arsenal_eff, matchup_reliability)
+        result["arsenal_status"] = (
+            "applied" if abs(result["arsenal_hr_adjustment"]) > 1e-6 else
+            "missing_batter_arsenal_profile" if int(_safe_float(batter_arsenal_row.get("arsenal_sample_size"), 0.0) or 0.0) <= 0 else
+            "missing_pitcher_arsenal_profile" if int(_safe_float(pitcher_arsenal_row.get("arsenal_sample_size"), 0.0) or 0.0) <= 0 else
+            "available_zero_effect"
+        )
         hr_prob = _clamp(hr_prob + result["arsenal_hr_adjustment"], 0.005, 0.25)
         if abs(result["arsenal_hr_adjustment"]) > 1e-6:
             applied_layers.append("arsenal")
@@ -554,6 +598,9 @@ def build_hr_probability_result(
             )
     else:
         skipped_layers.extend(["pitcher_missing", "zone_matchup_unavailable", "arsenal_matchup_unavailable"])
+        result["zone_status"] = "missing_pitcher_identity"
+        result["family_zone_status"] = "missing_pitcher_identity"
+        result["arsenal_status"] = "missing_pitcher_identity"
 
     result["pulled_contact_reliability"] = _sample_reliability(batter_pa, 155.0)
     result["pulled_contact_hr_adjustment"] = _apply_reliability(
@@ -764,6 +811,7 @@ def build_hr_probability_result(
     )
     result["model_voice_reason_candidates"] = ranked_reasons
     result["model_voice_tags"] = [str(item.get("template_key") or "") for item in ranked_reasons if str(item.get("template_key") or "").strip()]
+    result["reason_candidate_count"] = len(ranked_reasons)
     result["pregame_context_applied"] = any(
         abs(_safe_float(result.get(key))) > 1e-6
         for key in [

visualization/debug_page.py

@@ -37,6 +37,11 @@ from analytics.recommendation_engine import build_upcoming_hitter_recommendation
 from database.db import (
     read_batter_prop_audit_view,
     read_batter_prop_outcomes,
+    read_cached_probable_starters_meta,
+    read_cached_projected_lineups_meta,
+    read_cached_upcoming_props_bundle,
+    read_cached_schedule_for_date,
+    read_cached_odds,
     read_game_outcomes,
     read_recommendation_audit_view,
     read_table,
@@ -845,6 +850,20 @@ def render_debug(
                 baseline_summary_frames: list[pd.DataFrame] = []
                 batter_meta = (baseline_bundle or {}).get("batter_baseline_meta", pd.DataFrame())
                 pitcher_meta = (baseline_bundle or {}).get("pitcher_baseline_meta", pd.DataFrame())
+                snapshot_status = (baseline_bundle or {}).get("snapshot_status", pd.DataFrame())
+                hitter_rolling_snapshot = (baseline_bundle or {}).get("hitter_rolling_snapshot", pd.DataFrame())
+                pitcher_rolling_snapshot = (baseline_bundle or {}).get("pitcher_rolling_snapshot", pd.DataFrame())
+
+                source_status = str((baseline_bundle or {}).get("snapshot_source_status") or "unknown")
+                runtime_fallback_used = bool((baseline_bundle or {}).get("runtime_fallback_used"))
+
+                c1, c2 = st.columns(2)
+                c1.metric("Baseline Source", source_status.replace("_", " ").title())
+                c2.metric("Runtime Fallback Used", "Yes" if runtime_fallback_used else "No")
+
+                if isinstance(snapshot_status, pd.DataFrame) and not snapshot_status.empty:
+                    st.write("Snapshot Freshness")
+                    st.dataframe(snapshot_status, use_container_width=True, hide_index=True)
 
                 if isinstance(batter_meta, pd.DataFrame) and not batter_meta.empty:
                     batter_display = batter_meta.copy()
@@ -897,6 +916,131 @@ def render_debug(
                 else:
                     st.info("Shared baseline metadata is not loaded.")
 
+                rolling_summary_frames: list[pd.DataFrame] = []
+                if isinstance(hitter_rolling_snapshot, pd.DataFrame) and not hitter_rolling_snapshot.empty:
+                    hitter_roll = hitter_rolling_snapshot.copy()
+                    hitter_roll["baseline_role"] = "batter"
+                    rolling_summary_frames.append(
+                        hitter_roll[
+                            [
+                                c for c in [
+                                    "baseline_role",
+                                    "player_name",
+                                    "batter_games_in_window_5g",
+                                    "batter_games_in_window_10g",
+                                    "batter_recent_form_available",
+                                    "snapshot_built_at",
+                                    "source_status",
+                                ] if c in hitter_roll.columns
+                            ]
+                        ]
+                    )
+
+                if isinstance(pitcher_rolling_snapshot, pd.DataFrame) and not pitcher_rolling_snapshot.empty:
+                    pitcher_roll = pitcher_rolling_snapshot.copy()
+                    pitcher_roll["baseline_role"] = "pitcher"
+                    rolling_summary_frames.append(
+                        pitcher_roll[
+                            [
+                                c for c in [
+                                    "baseline_role",
+                                    "player_name",
+                                    "pitcher_games_in_window_5g",
+                                    "pitcher_games_in_window_10g",
+                                    "pitcher_recent_form_available",
+                                    "pitcher_rolling_confidence",
+                                    "snapshot_built_at",
+                                    "source_status",
+                                ] if c in pitcher_roll.columns
+                            ]
+                        ]
+                    )
+
+                if rolling_summary_frames:
+                    st.write("Rolling Snapshot Diagnostics")
+                    st.dataframe(
+                        pd.concat(rolling_summary_frames, ignore_index=True),
+                        use_container_width=True,
+                        hide_index=True,
+                    )
+
+            with st.expander("Cached Source Freshness", expanded=False):
+                freshness_rows: list[dict[str, Any]] = []
+
+                try:
+                    schedule_cached = read_cached_schedule_for_date(conn, current_wbc_date_str())
+                    freshness_rows.append(
+                        {
+                            "source": "cached_schedule",
+                            "row_count": int(len(schedule_cached)),
+                            "latest_fetched_at": (
+                                pd.to_datetime(schedule_cached["fetched_at"], errors="coerce").max()
+                                if not schedule_cached.empty and "fetched_at" in schedule_cached.columns
+                                else None
+                            ),
+                        }
+                    )
+                except Exception:
+                    pass
+
+                try:
+                    odds_cached = read_cached_odds(conn)
+                    freshness_rows.append(
+                        {
+                            "source": "cached_odds",
+                            "row_count": int(len(odds_cached)),
+                            "latest_fetched_at": (
+                                pd.to_datetime(odds_cached["fetched_at"], errors="coerce").max()
+                                if not odds_cached.empty and "fetched_at" in odds_cached.columns
+                                else None
+                            ),
+                        }
+                    )
+                except Exception:
+                    pass
+
+                try:
+                    starters_meta = read_cached_probable_starters_meta(conn)
+                    freshness_rows.append(
+                        {
+                            "source": "cached_probable_starters",
+                            "row_count": int(starters_meta.iloc[0]["matchup_count"]) if not starters_meta.empty else 0,
+                            "latest_fetched_at": starters_meta.iloc[0]["fetched_at"] if not starters_meta.empty else None,
+                        }
+                    )
+                except Exception:
+                    pass
+
+                try:
+                    lineups_meta = read_cached_projected_lineups_meta(conn)
+                    freshness_rows.append(
+                        {
+                            "source": "cached_projected_lineups",
+                            "row_count": int(lineups_meta.iloc[0]["team_count"]) if not lineups_meta.empty else 0,
+                            "latest_fetched_at": lineups_meta.iloc[0]["fetched_at"] if not lineups_meta.empty else None,
+                        }
+                    )
+                except Exception:
+                    pass
+
+                try:
+                    props_cache = read_cached_upcoming_props_bundle(conn, cache_key="default")
+                    props_meta = props_cache.get("cache_meta", pd.DataFrame())
+                    freshness_rows.append(
+                        {
+                            "source": "cached_upcoming_props_bundle",
+                            "row_count": int(props_meta.iloc[0]["merged_row_count"]) if not props_meta.empty else 0,
+                            "latest_fetched_at": props_meta.iloc[0]["fetched_at"] if not props_meta.empty else None,
+                        }
+                    )
+                except Exception:
+                    pass
+
+                if freshness_rows:
+                    st.dataframe(pd.DataFrame(freshness_rows), use_container_width=True, hide_index=True)
+                else:
+                    st.info("No cached source freshness rows available.")
+
     st.subheader("Upcoming Props Feed Diagnostics")
 
     props_debug = upcoming_props_debug or {}
@@ -904,6 +1048,19 @@ def render_debug(
     odds_api_raw_df = props_debug.get("odds_api_raw", pd.DataFrame())
     scraper_raw_df = props_debug.get("scraper_raw", pd.DataFrame())
     merged_props_df = props_debug.get("merged_props_feed", pd.DataFrame())
+    props_cache_meta = props_debug.get("cache_meta", pd.DataFrame())
+    props_cache_source = str(props_debug.get("cache_source") or "unknown")
+
+    c1, c2 = st.columns(2)
+    c1.metric("Props Cache Source", props_cache_source.replace("_", " ").title())
+    c2.metric(
+        "Props Cached Rows",
+        int(props_cache_meta.iloc[0]["merged_row_count"]) if isinstance(props_cache_meta, pd.DataFrame) and not props_cache_meta.empty and "merged_row_count" in props_cache_meta.columns else int(len(merged_props_df)),
+    )
+
+    if isinstance(props_cache_meta, pd.DataFrame) and not props_cache_meta.empty:
+        st.write("Props Bundle Cache Meta")
+        st.dataframe(props_cache_meta, use_container_width=True, hide_index=True)
 
     if not coverage_summary_df.empty:
         st.write("Coverage Summary")

visualization/props_page.py

@@ -20,7 +20,14 @@ from analytics.props_mapper import map_props_to_models
 from analytics.props_view_model import build_hr_props_view_model, select_best_lines_per_prop
 from config.settings import DEFAULT_PROP_BOOKS
 from data.live_prop_odds import fetch_all_upcoming_hr_props
-from database.db import ensure_upcoming_hr_props_table, insert_upcoming_hr_props
+from database.db import (
+    ensure_upcoming_hr_props_table,
+    get_connection,
+    insert_upcoming_hr_props,
+    read_cached_projected_lineups,
+    read_cached_projected_lineups_meta,
+    replace_cached_projected_lineups,
+)
 from utils.helpers import utc_now_iso
 
 
@@ -425,7 +432,38 @@ def _load_projected_lineups_for_props(teams: tuple[str, ...]) -> dict[str, dict[
 
     if not teams:
         return {}
-    return fetch_projected_lineups_for_teams(list(teams))
+    team_names = tuple(sorted({str(team or "").strip().lower() for team in teams if str(team or "").strip()}))
+
+    conn = get_connection()
+    try:
+        cached_meta = read_cached_projected_lineups_meta(conn)
+        if not cached_meta.empty:
+            try:
+                latest = pd.to_datetime(cached_meta.iloc[0]["fetched_at"], errors="coerce", utc=True)
+                if pd.notna(latest):
+                    age_seconds = float((pd.Timestamp.now(tz="UTC") - latest).total_seconds())
+                    if age_seconds <= float(60 * 60 * 6):
+                        cached = read_cached_projected_lineups(conn, team_names_norm=team_names)
+                        if cached:
+                            return cached
+            except Exception:
+                pass
+    finally:
+        try:
+            conn.close()
+        except Exception:
+            pass
+
+    fresh = fetch_projected_lineups_for_teams(list(teams))
+    try:
+        conn = get_connection()
+        try:
+            replace_cached_projected_lineups(conn, fresh)
+        finally:
+            conn.close()
+    except Exception:
+        pass
+    return fresh
 
 
 def _render_empty_props_state() -> None: