Update app.py

app.py

@@ -35,23 +35,54 @@ from vix_utils import async_load_vix_term_structure
 from datetime import datetime, timedelta
 import traceback
 
-# Set wide layout
+# ---------- App config ----------
 st.set_page_config(layout="wide", page_title="VIX Regime Detection")
-
-# Apply nest_asyncio for async operations
 nest_asyncio.apply()
+warnings.filterwarnings("ignore", category=FutureWarning, module="vix_utils")
+
+# ---------- Helpers ----------
+@st.cache_data(show_spinner=False)
+def fetch_term_structure_cached():
+    """
+    Fresh event loop for hosted envs; closed after use to avoid leaks.
+    Cached to keep memory + network stable across reruns.
+    """
+    loop = asyncio.new_event_loop()
+    try:
+        asyncio.set_event_loop(loop)
+        return loop.run_until_complete(async_load_vix_term_structure())
+    finally:
+        try:
+            loop.run_until_complete(loop.shutdown_asyncgens())
+        except Exception:
+            pass
+        loop.close()
+
 
-# Title and purpose
+def limit_df_rows_for_display(df: pd.DataFrame, n: int) -> pd.DataFrame:
+    if len(df) <= n:
+        return df
+    return df.tail(n)
+
+
+# ---------- Title ----------
 st.title("VIX Regime Detection")
 st.write(
     "This tool tracks the VIX term structure and identifies regimes: contango, backwardation, or cautious. It reports carry sign, curve slope, and changes over time and shows regime persistence and transition probabilities."
     "For more details, see [this article](https://entreprenerdly.com/detecting-vix-term-structure-regimes/)."
 )
 
-# Sidebar for inputs
+# ---------- Sidebar ----------
 with st.sidebar:
     st.title("Parameters")
 
+    # Stability toggle for Spaces (caps heavy charts & samples)
+    SAFE_MODE = st.checkbox(
+        "Safe mode (limit heavy charts)",
+        value=True,
+        help="Caps figure sizes & sampling to avoid out-of-memory on hosted environments.",
+    )
+
     # Data Range expander
     with st.expander("Data Range", expanded=False):
         start_date = st.date_input(
@@ -178,42 +209,59 @@ with st.sidebar:
     # Run button
     run_analysis = st.button("Run Analysis")
 
-# Main logic
+
+# ---------- Main ----------
 if run_analysis:
     with st.spinner("Loading data..."):
         try:
-            # Fixed end date
+            # Fixed end date (kept, though not used further)
             end_date = datetime.today() + timedelta(days=1)
-            
-            # Async data load
-            async def get_term_structure():
-                df = await async_load_vix_term_structure()
-                return df
-            
-            loop = asyncio.get_event_loop()
-            df = loop.run_until_complete(get_term_structure())
-            
+
+            # Async data load (cached, fresh loop)
+            df = fetch_term_structure_cached()
+
+            # Keep only columns we actually use to cut memory
+            keep_cols = [
+                "Trade Date", "Expiry", "Tenor_Days", "Tenor_Monthly",
+                "Weekly", "Expired", "Settle"
+            ]
+            df = df[keep_cols].copy()
+
+            # Parse Trade Date, sort
+            df["Trade Date"] = pd.to_datetime(df["Trade Date"])
+            df.sort_values(["Trade Date", "Tenor_Days"], inplace=True)
+
+            # Drop exact duplicates early to avoid bloat
+            dup_count = int(df.duplicated(subset=keep_cols).sum())
+            if dup_count:
+                df = df.drop_duplicates(subset=keep_cols)
+                st.warning(f"Removed {dup_count:,} duplicate rows detected in the source feed.")
+
             # Filter by start date
-            df['Trade Date'] = pd.to_datetime(df['Trade Date'])
-            df = df[df['Trade Date'] >= pd.to_datetime(start_date)]
-            
+            df = df[df["Trade Date"] >= pd.to_datetime(start_date)]
+
             if df.empty:
                 st.error("No data available for the selected date range.")
                 st.stop()
-            
-            # Suppress warnings
-            warnings.filterwarnings("ignore", category=FutureWarning, module="vix_utils")
-            
-            # Section 1: Raw Dataframe
+
+            # ---------- Section 1: Raw Dataframe ----------
             st.header("VIX Term Structure Dataset")
             st.write("The raw VIX term structure data loaded for analysis.")
             with st.expander("1. Raw Dataset", expanded=False):
-                st.dataframe(df, use_container_width=True)
-            
-            # Section 2: Slope Time Series Analysis
+                max_show = 2_000 if SAFE_MODE else 10_000
+                st.caption(f"Showing last {min(max_show, len(df)):,} rows (total {len(df):,}). Use download to get all.")
+                st.dataframe(limit_df_rows_for_display(df, max_show), use_container_width=True, height=420)
+                st.download_button(
+                    "Download full CSV",
+                    df.to_csv(index=False).encode(),
+                    file_name="vix_term_structure.csv",
+                    mime="text/csv",
+                )
+
+            # ---------- Section 2: Slope Time Series Analysis ----------
             st.header("Slope Time Series Across Time")
             st.write("Visualizes the VIX term structure slopes over time with regime classifications.")
-            
+
             with st.expander("Methodology", expanded=False):
                 st.write("""
                 This analysis filters the VIX futures data to include only dates from the specified start date onward. For each trade date, the data is grouped, and only groups with at least two tenors are considered. The term structure is sorted by monthly tenor.
@@ -237,99 +285,100 @@ if run_analysis:
                 
                 This visualization allows investors to observe how the term structure evolves over time and how regimes shift. This gives insights into market sentiment and potential volatility dynamics.
                 """)
-            
-            # Code for slope time series
-            df_sub = df.loc[df['Trade Date'] >= pd.to_datetime(start_date)].copy()
-            df_sub.sort_values('Trade Date', inplace=True)
+
+            df_sub = df.copy()
+            df_sub.sort_values("Trade Date", inplace=True)
 
             groups = [
-                (dt, grp.sort_values('Tenor_Monthly'))
-                for dt, grp in df_sub.groupby('Trade Date')
+                (dt, grp.sort_values("Tenor_Monthly"))
+                for dt, grp in df_sub.groupby("Trade Date")
                 if len(grp) > 1
             ]
 
+            # Cap the number of slider dates to avoid thousands of traces
+            MAX_SLIDER_DATES = 240 if SAFE_MODE else 800
+            if len(groups) > MAX_SLIDER_DATES:
+                groups = groups[-MAX_SLIDER_DATES:]
+
             regime_map = {}
             for dt, grp in groups:
-                slope = grp['Settle'].iloc[-1] - grp['Settle'].iloc[0]
+                slope = grp["Settle"].iloc[-1] - grp["Settle"].iloc[0]
                 if slope > slope_thr:
                     regime = "CONTANGO"
                 elif slope < -slope_thr:
                     regime = "BACKWARDATION"
                 else:
                     regime = "CAUTIOUS"
-                regime_map[str(dt.date())] = regime
-
-            fig = go.Figure()
-            dates = []
-            for i, (dt, grp) in enumerate(groups):
-                date_str = str(dt.date())
-                dates.append(date_str)
-                fig.add_trace(
-                    go.Scatter(
-                        x=grp['Expiry'],
-                        y=grp['Settle'],
-                        mode='lines+markers',
-                        name=date_str,
-                        visible=(i == len(groups) - 1),
-                        line=dict(width=2),
-                        marker=dict(size=6)
+                regime_map[str(pd.to_datetime(dt).date())] = regime
+
+            if len(groups) == 0:
+                st.info("Not enough data to render the slider plot.")
+            else:
+                fig = go.Figure()
+                dates = []
+                for i, (dt, grp) in enumerate(groups):
+                    date_str = str(pd.to_datetime(dt).date())
+                    dates.append(date_str)
+                    fig.add_trace(
+                        go.Scatter(
+                            x=grp["Expiry"],
+                            y=grp["Settle"],
+                            mode="lines+markers",
+                            name=date_str,
+                            visible=(i == len(groups) - 1),
+                            line=dict(width=2),
+                            marker=dict(size=6),
+                        )
                     )
-                )
-
-            steps = []
-            for i, d in enumerate(dates):
-                title = f"VIX Term Structure — {d} — {regime_map[d]}"
-                steps.append({
-                    "method": "update",
-                    "args": [
-                        {"visible": [j == i for j in range(len(dates))]},
-                        {"title": title}
-                    ],
-                    "label": d
-                })
-
-            # Raise the slider a bit and give it space
-            slider = {
-                "active": len(dates) - 1,
-                "currentvalue": {"prefix": "Trade Date: ", "font": {"size": 14}},
-                "pad": {"t": 16, "b": 0},     # smaller top pad -> closer to plot
-                "x": 0.0,
-                "y": 0.0015,                    # lift slightly above the bottom
-                "len": 1.0,
-                "steps": steps
-            }
 
-            fig.update_layout(
-                sliders=[slider],
-                title=f"VIX Term Structure — {dates[-1]} — {regime_map[dates[-1]]}",
-                xaxis_title="Futures Expiry",
-                yaxis_title="VIX Futures Price",
-                height=500,
-                margin=dict(l=60, r=20, t=60, b=90),  # extra bottom margin to avoid clipping
-                template="plotly_dark",
-                paper_bgcolor="rgba(0,0,0,1)",
-                plot_bgcolor="rgba(0,0,0,1)",
-                title_font_color="white",
-                font=dict(color="white")
-            )
+                steps = []
+                for i, d in enumerate(dates):
+                    title = f"VIX Term Structure — {d} — {regime_map[d]}"
+                    steps.append({
+                        "method": "update",
+                        "args": [
+                            {"visible": [j == i for j in range(len(dates))]},
+                            {"title": title},
+                        ],
+                        "label": d,
+                    })
 
-            # Subtle gridlines for clarity (optional)
-            fig.update_xaxes(gridcolor="rgba(255,255,255,0.08)")
-            fig.update_yaxes(gridcolor="rgba(255,255,255,0.08)")
+                slider = {
+                    "active": len(dates) - 1,
+                    "currentvalue": {"prefix": "Trade Date: ", "font": {"size": 14}},
+                    "pad": {"t": 16, "b": 0},
+                    "x": 0.0,
+                    "y": 0.0015,
+                    "len": 1.0,
+                    "steps": steps,
+                }
+
+                fig.update_layout(
+                    sliders=[slider],
+                    title=f"VIX Term Structure — {dates[-1]} — {regime_map[dates[-1]]}",
+                    xaxis_title="Futures Expiry",
+                    yaxis_title="VIX Futures Price",
+                    height=500,
+                    margin=dict(l=60, r=20, t=60, b=90),
+                    template="plotly_dark",
+                    paper_bgcolor="rgba(0,0,0,1)",
+                    plot_bgcolor="rgba(0,0,0,1)",
+                    title_font_color="white",
+                    font=dict(color="white"),
+                )
+                fig.update_xaxes(gridcolor="rgba(255,255,255,0.08)")
+                fig.update_yaxes(gridcolor="rgba(255,255,255,0.08)")
+                st.plotly_chart(fig, use_container_width=True)
 
-            st.plotly_chart(fig, use_container_width=True)
-            
             with st.expander("Dynamic Interpretation", expanded=False):
-                # Build daily and interpretations
+                # Build daily and interpretations (unchanged logic)
                 daily_rows = []
                 grp_map = {pd.to_datetime(dt): g.sort_values('Tenor_Monthly') for dt, g in groups}
-                
                 for dt, grp in grp_map.items():
                     g = grp.dropna(subset=['Tenor_Monthly', 'Settle']).copy()
                     settle_by_m = g.groupby('Tenor_Monthly', as_index=True)['Settle'].last()
                     if settle_by_m.size < 2:
                         continue
-                    
                     first_tenor = settle_by_m.index.min()
                     last_tenor  = settle_by_m.index.max()
                     front = float(settle_by_m.loc[first_tenor])
@@ -337,13 +386,11 @@ if run_analysis:
                     slope = back - front
                     curve_width = float(settle_by_m.max() - settle_by_m.min())
                     n_tenors = int(settle_by_m.size)
-                    
                     vx1 = float(settle_by_m.loc[1.0]) if 1.0 in settle_by_m.index else np.nan
                     vx2 = float(settle_by_m.loc[2.0]) if 2.0 in settle_by_m.index else np.nan
                     vx6 = float(settle_by_m.loc[6.0]) if 6.0 in settle_by_m.index else np.nan
                     c12 = (vx2 - vx1) if np.isfinite(vx1) and np.isfinite(vx2) else np.nan
                     c61 = (vx6 - vx1) if np.isfinite(vx1) and np.isfinite(vx6) else np.nan
-                    
                     dstr = str(pd.to_datetime(dt).date())
                     daily_rows.append({
                         'Trade Date': pd.to_datetime(dt),
@@ -356,53 +403,42 @@ if run_analysis:
                         'VX6_VX1': c61,
                         'Regime': regime_map.get(dstr, 'UNKNOWN')
                     })
-                
                 daily = pd.DataFrame(daily_rows).sort_values('Trade Date').reset_index(drop=True)
-                
                 if not daily.empty:
                     for w in (5, 20, 60, 120):
                         mp_mean = min(3, w)
                         mp_std  = min(10, w)
                         daily[f'Slope_MA_{w}']  = daily['Slope'].rolling(window=w, min_periods=mp_mean).mean()
                         daily[f'Slope_STD_{w}'] = daily['Slope'].rolling(window=w, min_periods=mp_std).std()
-                    
                     daily['Slope_Z_120'] = np.where(
                         daily['Slope_STD_120'].fillna(0) > 0,
                         (daily['Slope'] - daily['Slope_MA_120']) / daily['Slope_STD_120'],
                         np.nan
                     )
-                    
                     def _streak(vals):
                         out = np.ones(len(vals), dtype=int)
                         for i in range(1, len(vals)):
                             out[i] = out[i-1] + 1 if vals[i] == vals[i-1] else 1
                         return out
-                    
                     daily['Regime_Streak'] = _streak(daily['Regime'].to_numpy())
-                    
                     def _trend_tag(val, ref):
                         if pd.isna(ref): return "n/a"
                         return "above" if val > ref else ("below" if val < ref else "equal")
-                    
                     def _trend_word(vs_ma):
                         if vs_ma == "above": return "steeper"
                         if vs_ma == "below": return "flatter"
                         return "unchanged"
-                    
                     def _carry_word(x):
                         if pd.isna(x): return "n/a"
                         return "positive" if x >= 0 else "negative"
-                    
                     def _dominant_regime(comp):
                         if not comp: return "n/a"
                         k = max(comp, key=comp.get)
                         return f"{k.lower()} ({comp[k]:.1f}%)"
-                    
                     def _safe_pct_rank(series, value):
                         s = pd.to_numeric(series, errors='coerce').dropna()
                         if s.empty or not np.isfinite(value): return np.nan
                         return float((s < value).mean() * 100.0)
-                    
                     def _qbin(series, value, q=(0.1,0.25,0.5,0.75,0.9)):
                         s = pd.to_numeric(series, errors='coerce').dropna()
                         if s.empty or not np.isfinite(value): return "n/a"
@@ -413,12 +449,10 @@ if run_analysis:
                         if value <= qs[q[3]]: return f"{int(q[2]*100)}–{int(q[3]*100)}th"
                         if value <= qs[q[4]]: return f"{int(q[3]*100)}–{int(q[4]*100)}th"
                         return f">{int(q[4]*100)}th"
-                    
                     start, end = daily['Trade Date'].min().date(), daily['Trade Date'].max().date()
                     days = len(daily)
                     avg_tenors = daily['NumTenors'].mean()
                     last = daily.iloc[-1]
-                    
                     st.write("— Snapshot —")
                     st.write(f"Sample {start} to {end} ({days} days).")
                     st.write(f"Average tenors per day {avg_tenors:.1f}.")
@@ -426,32 +460,26 @@ if run_analysis:
                     st.write(f"Curve width {last['CurveWidth']:.2f} pts across {last['NumTenors']} tenors.")
                     if not pd.isna(last['VX2_VX1']):
                         st.write(f"Front carry VX2−VX1 {last['VX2_VX1']:.2f} pts ({_carry_word(last['VX2_VX1'])}).")
-                    if not pd.isna(last['VX6_VX1']):
-                        st.write(f"Term carry  VX6−VX1 {last['VX6_VX1']:.2f} pts ({_carry_word(last['VX6_VX1'])}).")
-                    
+                    if not pd.isna(last['VX6_VX1']): st.write(f"Term carry  VX6−VX1 {last['VX6_VX1']:.2f} pts ({_carry_word(last['VX6_VX1'])}).")
                     tag5  = _trend_tag(last['Slope'], last.get('Slope_MA_5'))
                     tag20 = _trend_tag(last['Slope'], last.get('Slope_MA_20'))
                     if tag5 != "n/a":  st.write(f"Slope is {_trend_word(tag5)} than 5-day average.")
                     if tag20 != "n/a": st.write(f"Slope is {_trend_word(tag20)} than 20-day average.")
-                    
                     z120 = last.get('Slope_Z_120', np.nan)
                     if not pd.isna(z120):
                         if z120 >= 2:      st.write(f"Slope high vs 120-day history (z={z120:.2f}).")
                         elif z120 <= -2:   st.write(f"Slope low vs 120-day history (z={z120:.2f}).")
                         else:              st.write(f"Slope within 120-day normal (z={z120:.2f}).")
-                    
                     arr = pd.to_numeric(daily['Slope'], errors='coerce').dropna().to_numpy()
                     if arr.size and np.isfinite(last['Slope']):
                         pct = float((arr < last['Slope']).mean() * 100.0)
                         st.write(f"Slope at {pct:.1f} percentile of sample.")
-                    
                     for window in (30, 90):
                         sub = daily.tail(window)
                         if sub.empty: continue
                         comp = (sub['Regime'].value_counts(normalize=True) * 100).to_dict()
                         dom = _dominant_regime(comp)
                         st.write(f"Last {window} days dominant regime {dom}.")
-                    
                     streak = int(last['Regime_Streak'])
                     if len(daily) >= 2:
                         changed = daily['Regime'].to_numpy() != daily['Regime'].shift(1).to_numpy()
@@ -461,26 +489,21 @@ if run_analysis:
                             st.write(f"Current {last['Regime'].lower()} streak {streak} days since {last_change_day}.")
                         else:
                             st.write(f"Current {last['Regime'].lower()} streak {streak} days.")
-                    
                     if len(daily) >= 3:
                         hi = daily.nlargest(1, 'Slope').iloc[0]
                         lo = daily.nsmallest(1, 'Slope').iloc[0]
                         st.write(f"Max slope {hi['Slope']:.2f} on {hi['Trade Date'].date()} ({hi['Regime']}).")
                         st.write(f"Min slope {lo['Slope']:.2f} on {lo['Trade Date'].date()} ({lo['Regime']}).")
-                    
                     anoms = daily[daily['Slope_Z_120'].abs() >= 3]
                     if len(anoms) > 0:
                         last_a = anoms.iloc[-1]
                         st.write(f"Recent anomaly {last_a['Trade Date'].date()} (|z120|={abs(last_a['Slope_Z_120']):.2f}).")
-                    
                     sparse = daily[daily['NumTenors'] < 3]
                     if len(sparse) > 0:
                         st.write(f"{len(sparse)} sparse days (<3 tenors). Treat slopes carefully.")
-                    
                     st.write("— History context —")
                     today = last['Trade Date'].date()
                     reg = last['Regime']
-                    
                     slope_pct   = _safe_pct_rank(daily['Slope'], last['Slope'])
                     width_pct   = _safe_pct_rank(daily['CurveWidth'], last['CurveWidth'])
                     c12_pct     = _safe_pct_rank(daily['VX2_VX1'], last['VX2_VX1']) if pd.notna(last['VX2_VX1']) else np.nan
@@ -489,7 +512,6 @@ if run_analysis:
                     if pd.notna(width_pct): st.write(f"{today}: width percentile vs sample {width_pct:.1f}%.")
                     if pd.notna(c12_pct): st.write(f"{today}: VX2−VX1 percentile vs sample {c12_pct:.1f}%.")
                     if pd.notna(c61_pct): st.write(f"{today}: VX6−VX1 percentile vs sample {c61_pct:.1f}%.")
-                    
                     sub_reg = daily[daily['Regime'] == reg]
                     if not sub_reg.empty:
                         slope_reg_pct = _safe_pct_rank(sub_reg['Slope'], last['Slope'])
@@ -501,7 +523,6 @@ if run_analysis:
                         st.write(f"{today}: slope vs {reg.lower()} median {slope_diff:+.2f} pts (median {slope_med:.2f}).")
                     else:
                         st.write(f"{today}: no history for regime {reg}.")
-                    
                     spells = []
                     start_idx = 0
                     vals = daily['Regime'].to_numpy()
@@ -512,7 +533,6 @@ if run_analysis:
                             spells.append({'Regime': r, 'Length': length, 'EndIndex': i-1})
                             start_idx = i
                     spells = pd.DataFrame(spells)
-                    
                     if not spells.empty:
                         cur_len = int(spells.iloc[-1]['Length'])
                         reg_spells = spells[spells['Regime'] == reg]['Length']
@@ -524,7 +544,6 @@ if run_analysis:
                             st.write(f"{today}: spell is {tag} than mean ({mean_len:.1f} days).")
                         if pd.notna(p75_len):
                             st.write(f"{today}: spell {'≥' if cur_len >= p75_len else '<'} 75th percentile ({p75_len:.0f} days).")
-                        
                         trans = (
                             daily[['Regime']]
                             .assign(Prev=lambda x: x['Regime'].shift(1))
@@ -540,7 +559,6 @@ if run_analysis:
                             if not stay_row.empty:
                                 p_stay = float(stay_row['Prob'].iloc[0])
                                 st.write(f"{today}: one-day stay probability in {reg.lower()} {p_stay:.2f}.")
-                    
                     daily['Month'] = daily['Trade Date'].dt.to_period('M')
                     cur_month = daily['Month'].iloc[-1]
                     mtd = daily[daily['Month'] == cur_month]
@@ -558,13 +576,11 @@ if run_analysis:
                         if pd.notna(typical):
                             comp = "above" if mtd_changes > typical else ("below" if mtd_changes < typical else "in line")
                             st.write(f"{today}: MTD regime churn {comp} median month ({typical:.0f}).")
-                        
                         moy = mtd['Trade Date'].dt.month.iloc[-1]
                         same_moy = daily[daily['Trade Date'].dt.month == moy]['Slope']
                         if not same_moy.dropna().empty:
                             moy_pct = _safe_pct_rank(same_moy, last['Slope'])
                             st.write(f"{today}: slope percentile vs historical {pd.Timestamp(today).strftime('%B')} {moy_pct:.1f}%.")
-                    
                     slope_bin = _qbin(daily['Slope'], last['Slope'])
                     width_bin = _qbin(daily['CurveWidth'], last['CurveWidth'])
                     st.write(f"{today}: slope bin {slope_bin}.")
@@ -575,7 +591,6 @@ if run_analysis:
                         tail_lo = (s_all <= last['Slope']).mean()*100.0
                         tail = min(tail_hi, tail_lo)
                         st.write(f"{today}: tail frequency at this slope level {tail:.1f}%.")
-                    
                     band = max(0.25, s_all.std()*0.1) if not s_all.empty else 0.25
                     recent_sim = daily[(daily['Regime'] == reg) &
                                        (daily['Slope'].between(last['Slope']-band, last['Slope']+band))]
@@ -583,7 +598,6 @@ if run_analysis:
                         prev = recent_sim.iloc[-2]['Trade Date'].date()
                         days_since = (pd.Timestamp(today) - pd.Timestamp(prev)).days
                         st.write(f"{today}: last similar day was {prev} ({days_since} days ago).")
-                    
                     def _stab(row):
                         c1 = abs(row['Slope'] - row.get('Slope_MA_20', np.nan))
                         c2 = abs(row.get('Slope_Z_120', np.nan))
@@ -591,16 +605,15 @@ if run_analysis:
                         if np.isfinite(c1): parts.append(1.0 / (1.0 + c1))
                         if np.isfinite(c2): parts.append(1.0 / (1.0 + c2))
                         return np.mean(parts) if parts else np.nan
-                    
                     daily['Stability'] = daily.apply(_stab, axis=1)
                     stab_pct = _safe_pct_rank(daily['Stability'], daily['Stability'].iloc[-1])
                     if pd.notna(stab_pct):
                         st.write(f"{today}: stability percentile {stab_pct:.1f}% (higher means steadier slope).")
-                
-            # Section 3: 3D Term-Structure Visualization
+
+            # ---------- Section 3: 3D Term-Structure Visualization ----------
             st.header("Term-Structure Surface")
             st.write("A 3D scatter plot showing the VIX term structure over time with trade date, days to expiration, and settle price.")
-            
+
             with st.expander("Methodology", expanded=False):
                 st.write("""
                 This visualization filters the data to include only monthly (non-weekly) and non-expired VIX futures contracts. Dates with fewer than two tenors are excluded to ensure meaningful term structures.
@@ -640,202 +653,189 @@ if run_analysis:
                 
                 The Surface helps identify clusters, trends, and anomalies in the term structure surface.
                 """)
-            
-            # Code for 3D
+
             monthly_df = df[(df["Weekly"] == False) & (df["Expired"] == False)].copy()
             valid_dates = monthly_df['Trade Date'].value_counts()
-            valid_dates = valid_dates[valid_dates > 1].index.tolist()
+            valid_dates = valid_dates[valid_dates > 1].index
             monthly_df_filtered = monthly_df[monthly_df['Trade Date'].isin(valid_dates)].copy()
 
-            # lock the color scale explicitly
-            cmin = float(monthly_df_filtered["Settle"].min())
-            cmax = float(monthly_df_filtered["Settle"].max())
-
-            fig = px.scatter_3d(
-                monthly_df_filtered,
-                x="Trade Date",
-                y="Tenor_Days",
-                z="Settle",
-                color="Settle",
-                color_continuous_scale="Viridis",   # matches the raw notebook’s default
-                range_color=(cmin, cmax),
-                title="VIX Futures Term Structure over Time"
-            )
-
-            # marker styling to match the raw feel
-            fig.update_traces(
-                marker=dict(size=3, opacity=0.9,
-                            colorbar=dict(
-                                title="Settle",
-                                thickness=12,
-                                tickcolor="white",
-                                titlefont=dict(color="white"),
-                                tickfont=dict(color="white")
-                            ))
-            )
-
-            fig.update_layout(
-                scene=dict(
-                    xaxis_title='Trade Date',
-                    yaxis_title='Days to Expiration',
-                    zaxis_title='Settle Price',
-                    xaxis=dict(gridcolor="rgba(255,255,255,0.08)", tickcolor="white"),
-                    yaxis=dict(gridcolor="rgba(255,255,255,0.08)", tickcolor="white"),
-                    zaxis=dict(gridcolor="rgba(255,255,255,0.08)", tickcolor="white"),
-                    bgcolor="rgba(0,0,0,1)"
-                ),
-                template="plotly_dark",
-                paper_bgcolor="rgba(0,0,0,1)",
-                plot_bgcolor="rgba(0,0,0,1)",
-                title_font_color="white",
-                font=dict(color="white"),
-                margin=dict(l=0, r=0, t=60, b=0)
-            )
-
-            st.plotly_chart(fig, use_container_width=True)
-            
-            with st.expander("Dynamic Interpretation", expanded=False):
-                # Dynamic interp for 3D
-                grouped = monthly_df_filtered.groupby("Trade Date")
-                rows = []
-                for dt, g in grouped:
-                    g = g.dropna(subset=["Tenor_Days", "Settle"]).sort_values("Tenor_Days")
-                    if g["Tenor_Days"].nunique() < 2:
-                        continue
-                    
-                    level = float(g["Settle"].mean())
-                    width = float(g["Settle"].max() - g["Settle"].min())
-                    front = float(g.iloc[0]["Settle"])
-                    back  = float(g.iloc[-1]["Settle"])
-                    nten  = int(g["Tenor_Days"].nunique())
-                    
-                    x = g["Tenor_Days"].to_numpy(dtype=float)
-                    y = g["Settle"].to_numpy(dtype=float)
-                    lin = np.polyfit(x, y, 1)
-                    slope = float(lin[0])
-                    curv = np.nan
-                    if nten >= 3:
-                        quad = np.polyfit(x, y, 2)
-                        curv = float(quad[0])
-                    
-                    by_m = (g.dropna(subset=["Tenor_Monthly"])
-                              .drop_duplicates("Tenor_Monthly")
-                              .set_index("Tenor_Monthly")["Settle"])
-                    vx1 = float(by_m.loc[1.0]) if 1.0 in by_m.index else np.nan
-                    vx2 = float(by_m.loc[2.0]) if 2.0 in by_m.index else np.nan
-                    vx6 = float(by_m.loc[6.0]) if 6.0 in by_m.index else np.nan
-                    c12 = (vx2 - vx1) if np.isfinite(vx1) and np.isfinite(vx2) else np.nan
-                    c61 = (vx6 - vx1) if np.isfinite(vx1) and np.isfinite(vx6) else np.nan
-                    
-                    rows.append({
-                        "Trade Date": pd.to_datetime(dt),
-                        "Level": level,
-                        "Width": width,
-                        "Front": front,
-                        "Back": back,
-                        "Slope_pd": slope,
-                        "Curvature": curv,
-                        "NumTenors": nten,
-                        "VX2_VX1": c12,
-                        "VX6_VX1": c61
-                    })
-                
-                surf = pd.DataFrame(rows).sort_values("Trade Date").reset_index(drop=True)
-                
-                if not surf.empty:
-                    for w in (5, 20, 60, 120):
-                        mp_mean = min(3, w)
-                        mp_std  = min(10, w)
-                        surf[f"SlopeMA_{w}"] = surf["Slope_pd"].rolling(w, min_periods=mp_mean).mean()
-                        surf[f"SlopeSTD_{w}"] = surf["Slope_pd"].rolling(w, min_periods=mp_std).std()
-                        surf[f"LevelMA_{w}"] = surf["Level"].rolling(w, min_periods=mp_mean).mean()
-                    
-                    surf["SlopeZ_120"] = np.where(
-                        surf["SlopeSTD_120"].fillna(0) > 0,
-                        (surf["Slope_pd"] - surf["SlopeMA_120"]) / surf["SlopeSTD_120"],
-                        np.nan
-                    )
-                    
-                    def pct_rank(series, value):
-                        s = pd.to_numeric(series, errors="coerce").dropna()
-                        if s.empty or not np.isfinite(value):
-                            return np.nan
-                        return float((s < value).mean() * 100.0)
-                    
-                    def explain_percentile(label, pct):
-                        if pd.isna(pct):
-                            st.write(f"{label}: n/a. Not enough history.")
-                        else:
-                            higher = 100.0 - pct
-                            st.write(f"{label}: {pct:.1f}% of days were lower. {higher:.1f}% were higher.")
-                    
-                    def trend_tag(val, ref):
-                        if pd.isna(ref): return "n/a"
-                        return "above" if val > ref else ("below" if val < ref else "equal")
-                    
-                    def carry_word(x):
-                        if pd.isna(x): return "n/a"
-                        return "positive" if x >= 0 else "negative"
-                    
-                    last = surf.iloc[-1]
-                    start, end = surf["Trade Date"].min().date(), surf["Trade Date"].max().date()
-                    st.write("— Term-structure surface snapshot —")
-                    st.write(f"Sample {start} to {end} ({len(surf)} days).")
-                    st.write(f"Level {last['Level']:.2f}. Width {last['Width']:.2f}.")
-                    st.write(f"Slope {last['Slope_pd']:.4f} pts/day. Curvature {last['Curvature']:.6f}.")
-                    
-                    if not pd.isna(last["VX2_VX1"]):
-                        st.write(f"Front carry VX2−VX1 {last['VX2_VX1']:.2f} ({carry_word(last['VX2_VX1'])}).")
-                    if not pd.isna(last["VX6_VX1"]):
-                        st.write(f"Term carry  VX6−VX1 {last['VX6_VX1']:.2f} ({carry_word(last['VX6_VX1'])}).")
-                    
-                    t5  = trend_tag(last["Slope_pd"], last.get("SlopeMA_5"))
-                    t20 = trend_tag(last["Slope_pd"], last.get("SlopeMA_20"))
-                    if t5  != "n/a": st.write(f"Slope is {t5} the 5-day mean.")
-                    if t20 != "n/a": st.write(f"Slope is {t20} the 20-day mean.")
-                    
-                    z = last.get("SlopeZ_120", np.nan)
-                    if pd.notna(z):
-                        if z >= 2:      st.write(f"Slope is high vs 120-day history (z={z:.2f}).")
-                        elif z <= -2:   st.write(f"Slope is low vs 120-day history (z={z:.2f}).")
-                        else:           st.write(f"Slope is within 120-day range (z={z:.2f}).")
-                    
-                    st.write("— How today compares to history —")
-                    slope_pct = pct_rank(surf["Slope_pd"], last["Slope_pd"])
-                    width_pct = pct_rank(surf["Width"], last["Width"])
-                    level_pct = pct_rank(surf["Level"], last["Level"])
-                    explain_percentile("Slope percentile", slope_pct)
-                    explain_percentile("Width percentile", width_pct)
-                    explain_percentile("Level percentile", level_pct)
-                    
-                    if pd.notna(last["VX2_VX1"]):
-                        c12_pct = pct_rank(surf["VX2_VX1"], last["VX2_VX1"])
-                        explain_percentile("VX2−VX1 percentile", c12_pct)
-                    if pd.notna(last["VX6_VX1"]):
-                        c61_pct = pct_rank(surf["VX6_VX1"], last["VX6_VX1"])
-                        explain_percentile("VX6−VX1 percentile", c61_pct)
-                    
-                    hi = surf.nlargest(1, "Slope_pd").iloc[0]
-                    lo = surf.nsmallest(1, "Slope_pd").iloc[0]
-                    st.write(f"Steepest day {hi['Trade Date'].date()} with {hi['Slope_pd']:.4f} pts/day.")
-                    st.write(f"Flattest day {lo['Trade Date'].date()} with {lo['Slope_pd']:.4f} pts/day.")
-                    
-                    surf["Month"] = surf["Trade Date"].dt.to_period("M")
-                    cur_m = surf["Month"].iloc[-1]
-                    mtd = surf[surf["Month"] == cur_m]
-                    if not mtd.empty and len(mtd) >= 5:
-                        mtd_slope_std = float(mtd["Slope_pd"].std())
-                        mtd_level_std = float(mtd["Level"].std())
-                        st.write(f"MTD slope std {mtd_slope_std:.4f} pts/day. MTD level std {mtd_level_std:.2f}.")
-                    
-                    sparse = surf[surf["NumTenors"] < 3]
-                    if len(sparse) > 0:
-                        st.write(f"{len(sparse)} days have <3 tenors. Interpret slope and curvature carefully.")
-            
-            # Section 4: HMM Regime Classification
+            # Downsample for hosted stability
+            if SAFE_MODE:
+                cutoff = pd.Timestamp.today().normalize() - pd.DateOffset(months=24)
+                monthly_df_filtered = monthly_df_filtered[monthly_df_filtered["Trade Date"] >= cutoff]
+                unique_dates = monthly_df_filtered["Trade Date"].drop_duplicates().sort_values()
+                step = max(1, len(unique_dates) // 150) if len(unique_dates) else 1
+                keep_dates = set(unique_dates.iloc[::step])
+                monthly_df_filtered = monthly_df_filtered[monthly_df_filtered["Trade Date"].isin(keep_dates)]
+
+            MAX_ROWS_3D = 15_000 if SAFE_MODE else 50_000
+            if len(monthly_df_filtered) == 0:
+                st.info("Not enough data for the 3D surface after filtering.")
+            elif len(monthly_df_filtered) > MAX_ROWS_3D:
+                st.warning("3D surface skipped to protect memory (too many points). Disable Safe mode or narrow the date range.")
+            else:
+                cmin = float(monthly_df_filtered["Settle"].min())
+                cmax = float(monthly_df_filtered["Settle"].max())
+                fig = px.scatter_3d(
+                    monthly_df_filtered,
+                    x="Trade Date",
+                    y="Tenor_Days",
+                    z="Settle",
+                    color="Settle",
+                    color_continuous_scale="Viridis",
+                    range_color=(cmin, cmax),
+                    title="VIX Futures Term Structure over Time"
+                )
+                fig.update_traces(
+                    marker=dict(size=2 if SAFE_MODE else 3, opacity=0.9,
+                                colorbar=dict(
+                                    title="Settle",
+                                    thickness=12,
+                                    tickcolor="white",
+                                    titlefont=dict(color="white"),
+                                    tickfont=dict(color="white")
+                                ))
+                )
+                fig.update_layout(
+                    scene=dict(
+                        xaxis_title='Trade Date',
+                        yaxis_title='Days to Expiration',
+                        zaxis_title='Settle Price',
+                        xaxis=dict(gridcolor="rgba(255,255,255,0.08)", tickcolor="white"),
+                        yaxis=dict(gridcolor="rgba(255,255,255,0.08)", tickcolor="white"),
+                        zaxis=dict(gridcolor="rgba(255,255,255,0.08)", tickcolor="white"),
+                        bgcolor="rgba(0,0,0,1)"
+                    ),
+                    template="plotly_dark",
+                    paper_bgcolor="rgba(0,0,0,1)",
+                    plot_bgcolor="rgba(0,0,0,1)",
+                    title_font_color="white",
+                    font=dict(color="white"),
+                    margin=dict(l=0, r=0, t=60, b=0)
+                )
+                st.plotly_chart(fig, use_container_width=True)
+
+                with st.expander("Dynamic Interpretation", expanded=False):
+                    grouped = monthly_df_filtered.groupby("Trade Date")
+                    rows = []
+                    for dt, g in grouped:
+                        g = g.dropna(subset=["Tenor_Days", "Settle"]).sort_values("Tenor_Days")
+                        if g["Tenor_Days"].nunique() < 2:
+                            continue
+                        level = float(g["Settle"].mean())
+                        width = float(g["Settle"].max() - g["Settle"].min())
+                        front = float(g.iloc[0]["Settle"])
+                        back  = float(g.iloc[-1]["Settle"])
+                        nten  = int(g["Tenor_Days"].nunique())
+                        x = g["Tenor_Days"].to_numpy(dtype=float)
+                        y = g["Settle"].to_numpy(dtype=float)
+                        lin = np.polyfit(x, y, 1)
+                        slope = float(lin[0])
+                        curv = np.nan
+                        if nten >= 3:
+                            quad = np.polyfit(x, y, 2)
+                            curv = float(quad[0])
+                        by_m = (g.dropna(subset=["Tenor_Monthly"])
+                                  .drop_duplicates("Tenor_Monthly")
+                                  .set_index("Tenor_Monthly")["Settle"])
+                        vx1 = float(by_m.loc[1.0]) if 1.0 in by_m.index else np.nan
+                        vx2 = float(by_m.loc[2.0]) if 2.0 in by_m.index else np.nan
+                        vx6 = float(by_m.loc[6.0]) if 6.0 in by_m.index else np.nan
+                        c12 = (vx2 - vx1) if np.isfinite(vx1) and np.isfinite(vx2) else np.nan
+                        c61 = (vx6 - vx1) if np.isfinite(vx1) and np.isfinite(vx6) else np.nan
+                        rows.append({
+                            "Trade Date": pd.to_datetime(dt),
+                            "Level": level,
+                            "Width": width,
+                            "Front": front,
+                            "Back": back,
+                            "Slope_pd": slope,
+                            "Curvature": curv,
+                            "NumTenors": nten,
+                            "VX2_VX1": c12,
+                            "VX6_VX1": c61
+                        })
+                    surf = pd.DataFrame(rows).sort_values("Trade Date").reset_index(drop=True)
+                    if not surf.empty:
+                        for w in (5, 20, 60, 120):
+                            mp_mean = min(3, w)
+                            mp_std  = min(10, w)
+                            surf[f"SlopeMA_{w}"] = surf["Slope_pd"].rolling(w, min_periods=mp_mean).mean()
+                            surf[f"SlopeSTD_{w}"] = surf["Slope_pd"].rolling(w, min_periods=mp_std).std()
+                            surf[f"LevelMA_{w}"] = surf["Level"].rolling(w, min_periods=mp_mean).mean()
+                        surf["SlopeZ_120"] = np.where(
+                            surf["SlopeSTD_120"].fillna(0) > 0,
+                            (surf["Slope_pd"] - surf["SlopeMA_120"]) / surf["SlopeSTD_120"],
+                            np.nan
+                        )
+                        def pct_rank(series, value):
+                            s = pd.to_numeric(series, errors="coerce").dropna()
+                            if s.empty or not np.isfinite(value):
+                                return np.nan
+                            return float((s < value).mean() * 100.0)
+                        def explain_percentile(label, pct):
+                            if pd.isna(pct):
+                                st.write(f"{label}: n/a. Not enough history.")
+                            else:
+                                higher = 100.0 - pct
+                                st.write(f"{label}: {pct:.1f}% of days were lower. {higher:.1f}% were higher.")
+                        def trend_tag(val, ref):
+                            if pd.isna(ref): return "n/a"
+                            return "above" if val > ref else ("below" if val < ref else "equal")
+                        def carry_word(x):
+                            if pd.isna(x): return "n/a"
+                            return "positive" if x >= 0 else "negative"
+                        last = surf.iloc[-1]
+                        start, end = surf["Trade Date"].min().date(), surf["Trade Date"].max().date()
+                        st.write("— Term-structure surface snapshot —")
+                        st.write(f"Sample {start} to {end} ({len(surf)} days).")
+                        st.write(f"Level {last['Level']:.2f}. Width {last['Width']:.2f}.")
+                        st.write(f"Slope {last['Slope_pd']:.4f} pts/day. Curvature {last['Curvature']:.6f}.")
+                        if not pd.isna(last["VX2_VX1"]):
+                            st.write(f"Front carry VX2−VX1 {last['VX2_VX1']:.2f} ({carry_word(last['VX2_VX1'])}).")
+                        if not pd.isna(last["VX6_VX1"]):
+                            st.write(f"Term carry  VX6−VX1 {last['VX6_VX1']:.2f} ({carry_word(last['VX6_VX1'])}).")
+                        t5  = trend_tag(last["Slope_pd"], last.get("SlopeMA_5"))
+                        t20 = trend_tag(last["Slope_pd"], last.get("SlopeMA_20"))
+                        if t5  != "n/a": st.write(f"Slope is {t5} the 5-day mean.")
+                        if t20 != "n/a": st.write(f"Slope is {t20} the 20-day mean.")
+                        z = last.get("SlopeZ_120", np.nan)
+                        if pd.notna(z):
+                            if z >= 2:      st.write(f"Slope is high vs 120-day history (z={z:.2f}).")
+                            elif z <= -2:   st.write(f"Slope is low vs 120-day history (z={z:.2f}).")
+                            else:           st.write(f"Slope is within 120-day range (z={z:.2f}).")
+                        st.write("— How today compares to history —")
+                        slope_pct = pct_rank(surf["Slope_pd"], last["Slope_pd"])
+                        width_pct = pct_rank(surf["Width"], last["Width"])
+                        level_pct = pct_rank(surf["Level"], last["Level"])
+                        explain_percentile("Slope percentile", slope_pct)
+                        explain_percentile("Width percentile", width_pct)
+                        explain_percentile("Level percentile", level_pct)
+                        if pd.notna(last["VX2_VX1"]):
+                            c12_pct = pct_rank(surf["VX2_VX1"], last["VX2_VX1"])
+                            explain_percentile("VX2−VX1 percentile", c12_pct)
+                        if pd.notna(last["VX6_VX1"]):
+                            c61_pct = pct_rank(surf["VX6_VX1"], last["VX6_VX1"])
+                            explain_percentile("VX6−VX1 percentile", c61_pct)
+                        hi = surf.nlargest(1, "Slope_pd").iloc[0]
+                        lo = surf.nsmallest(1, "Slope_pd").iloc[0]
+                        st.write(f"Steepest day {hi['Trade Date'].date()} with {hi['Slope_pd']:.4f} pts/day.")
+                        st.write(f"Flattest day {lo['Trade Date'].date()} with {lo['Slope_pd']:.4f} pts/day.")
+                        surf["Month"] = surf["Trade Date"].dt.to_period("M")
+                        cur_m = surf["Month"].iloc[-1]
+                        mtd = surf[surf["Month"] == cur_m]
+                        if not mtd.empty and len(mtd) >= 5:
+                            mtd_slope_std = float(mtd["Slope_pd"].std())
+                            mtd_level_std = float(mtd["Level"].std())
+                            st.write(f"MTD slope std {mtd_slope_std:.4f} pts/day. MTD level std {mtd_level_std:.2f}.")
+                        sparse = surf[surf["NumTenors"] < 3]
+                        if len(sparse) > 0:
+                            st.write(f"{len(sparse)} days have <3 tenors. Interpret slope and curvature carefully.")
+
+            # ---------- Section 4: HMM Regime Classification ----------
             st.header("HMM Regime Classification")
             st.write("Classifies VIX regimes using Hidden Markov Model on slope time series.")
-            
+
             with st.expander("Methodology", expanded=False):
                 st.write("""
                 This analysis focuses on monthly VIX futures contracts. For each trade date with at least two tenors, the daily slope is computed as the linear regression coefficient of settle prices against days to expiration:
@@ -870,8 +870,7 @@ if run_analysis:
                 The plot shows slopes over time, colored by regime, with a black line connecting the slopes and a dashed horizontal at 0 for reference.
                
                 """)
-            
-            # Code for HMM
+
             base = df[~df['Weekly']].copy()
             rows = []
             for d, g in base.groupby('Trade Date'):
@@ -880,31 +879,36 @@ if run_analysis:
                     continue
                 slope = np.polyfit(g['Tenor_Days'], g['Settle'], 1)[0]
                 rows.append({'Trade Date': d, 'Slope': slope})
-
             slope_df = pd.DataFrame(rows).sort_values('Trade Date')
 
+            # Cap HMM sample size in SAFE_MODE
+            MAX_HMM_OBS = 800 if SAFE_MODE else 3000
+            if len(slope_df) > MAX_HMM_OBS:
+                slope_df = slope_df.tail(MAX_HMM_OBS)
+
             X = StandardScaler().fit_transform(slope_df[['Slope']])
+
+            # Trim iterations in safe mode (respect user's input otherwise)
+            hmm_iter = min(int(hmm_n_iter), 300) if SAFE_MODE else int(hmm_n_iter)
             hmm = GaussianHMM(
-                n_components=hmm_n_components,
+                n_components=int(hmm_n_components),
                 covariance_type='full',
-                n_iter=hmm_n_iter,
+                n_iter=hmm_iter,
                 random_state=1
             ).fit(X)
 
             hidden = hmm.predict(X)
-
-            state_mean = pd.Series(hmm.means_.flatten(), index=range(hmm_n_components))
+            state_mean = pd.Series(hmm.means_.flatten(), index=range(hmm.n_components))
             order = state_mean.sort_values().index
-            label_map = {order[i]: ['BACKWARDATION', 'CAUTIOUS', 'CONTANGO'][i] for i in range(min(3, hmm_n_components))}
+            label_map = {order[i]: ['BACKWARDATION', 'CAUTIOUS', 'CONTANGO'][i] for i in range(min(3, hmm.n_components))}
             slope_df['Regime'] = [label_map.get(s, 'UNKNOWN') for s in hidden]
 
-            # consistent ordering + color mapping (dark-friendly)
             cat_order = ['BACKWARDATION', 'CAUTIOUS', 'CONTANGO', 'UNKNOWN']
             color_map = {
-                'BACKWARDATION': '#d62728',  # red
-                'CAUTIOUS':      '#7f7f7f',  # gray
-                'CONTANGO':      '#2ca02c',  # green
-                'UNKNOWN':       '#1f77b4'   # fallback
+                'BACKWARDATION': '#d62728',
+                'CAUTIOUS':      '#7f7f7f',
+                'CONTANGO':      '#2ca02c',
+                'UNKNOWN':       '#1f77b4'
             }
 
             fig = px.scatter(
@@ -917,20 +921,16 @@ if run_analysis:
                 opacity=0.6,
                 title='Daily VIX Curve Slope with Regime States (HMM)'
             )
-
-            # slope line (keep simple like the raw code)
             fig.add_trace(
                 go.Scatter(
                     x=slope_df['Trade Date'],
                     y=slope_df['Slope'],
                     mode='lines',
-                    line=dict(color='white', width=1),   # white for visibility on dark bg
+                    line=dict(color='white', width=1),
                     name='Slope (line)'
                 )
             )
-
             fig.add_hline(y=0, line_dash='dash', line_color='rgba(255,255,255,0.6)')
-
             fig.update_layout(
                 xaxis_title='Trade Date',
                 yaxis_title='Slope (pts / day)',
@@ -946,8 +946,6 @@ if run_analysis:
                 ),
                 margin=dict(l=60, r=20, t=60, b=40)
             )
-
-            # axes text + ticks in white (and subtle grids)
             fig.update_xaxes(
                 title_font=dict(color="white"),
                 tickfont=dict(color="white"),
@@ -966,36 +964,31 @@ if run_analysis:
                 linecolor="rgba(255,255,255,0.15)",
                 ticks="outside"
             )
-
             st.plotly_chart(fig, use_container_width=True)
+
             with st.expander("Dynamic Interpretation", expanded=False):
-                # Dynamic interp for HMM
                 trans = pd.DataFrame(
                     hmm.transmat_,
-                    index=[label_map[i] for i in range(hmm.n_components)],
-                    columns=[label_map[i] for i in range(hmm.n_components)]
+                    index=[label_map.get(i, f"S{i}") for i in range(hmm.n_components)],
+                    columns=[label_map.get(i, f"S{i}") for i in range(hmm.n_components)]
                 )
                 st.write("\nTransition probabilities\n")
                 st.dataframe(trans.round(3))
-                
                 def pct_rank(series, value):
                     s = pd.to_numeric(series, errors="coerce").dropna()
                     if s.empty or not np.isfinite(value):
                         return np.nan
                     return float((s < value).mean() * 100.0)
-                
                 def exp_duration(pii):
                     if np.isclose(pii, 1.0):
                         return np.inf
                     return 1.0 / max(1e-12, (1.0 - pii))
-                
                 def note_regime(name):
                     if name == "CONTANGO":
                         return "term structure slopes up. carry tends to be positive."
                     if name == "BACKWARDATION":
                         return "term structure slopes down. stress is more likely."
                     return "term structure is near flat. signals are mixed."
-                
                 def risk_bias_for_transition(src, dst):
                     if src == "CONTANGO" and dst == "CAUTIOUS":
                         return "carry tailwind may fade."
@@ -1010,40 +1003,33 @@ if run_analysis:
                     if src == "BACKWARDATION" and dst == "CONTANGO":
                         return "stress may unwind fast."
                     return "no clear tilt."
-                
                 def entropy_row(p):
                     p = np.asarray(p, float)
                     p = p[p > 0]
                     return -np.sum(p * np.log2(p)) if p.size else np.nan
-                
                 _, post = hmm.score_samples(X)
                 today = slope_df['Trade Date'].iloc[-1].date()
                 cur_state = hidden[-1]
-                cur_regime = label_map[cur_state]
-                cur_probs = {label_map[i]: float(post[-1, i]) for i in range(hmm.n_components)}
+                cur_regime = label_map.get(cur_state, f"S{cur_state}")
+                cur_probs = {label_map.get(i, f"S{i}"): float(post[-1, i]) for i in range(hmm.n_components)}
                 cur_prob = cur_probs[cur_regime]
-                
                 stay_prob = float(trans.loc[cur_regime, cur_regime])
                 edur = exp_duration(stay_prob)
-                
                 st.write("— Interpretation —")
                 st.write(f"Date {today}. Model labels today as {cur_regime} (prob {cur_prob:.2f}).")
                 st.write(f"This means {note_regime(cur_regime)}")
-                
                 if cur_prob >= 0.8:
                     st.write("Confidence is high. The label is stable.")
                 elif cur_prob >= 0.6:
                     st.write("Confidence is moderate. Treat it as useful, not certain.")
                 else:
                     st.write("Confidence is low. Be cautious using this label.")
-                
                 if stay_prob >= 0.85:
                     st.write("Day-to-day persistence is high. Expect the same regime tomorrow.")
                 elif stay_prob >= 0.65:
                     st.write("Day-to-day persistence is moderate. A hold is slightly more likely.")
                 else:
                     st.write("Day-to-day persistence is low. A switch is common.")
-                
                 if np.isinf(edur):
                     st.write("Spells in this regime can run very long in this model.")
                 elif edur >= 10:
@@ -1052,7 +1038,6 @@ if run_analysis:
                     st.write(f"Typical spell length is medium (~{edur:.0f} days).")
                 else:
                     st.write(f"Typical spell length is short (~{edur:.0f} days).")
-                
                 streak = 1
                 for i in range(len(hidden) - 2, -1, -1):
                     if hidden[i] == cur_state:
@@ -1068,13 +1053,11 @@ if run_analysis:
                         st.write("Streak is mid to late stage.")
                     else:
                         st.write("Streak is early stage.")
-                
                 row_sorted = trans.loc[cur_regime].sort_values(ascending=False)
                 exit_target = row_sorted.drop(index=cur_regime).idxmax()
                 exit_p = float(row_sorted.drop(index=cur_regime).max())
                 back_p = float(trans.loc[exit_target, cur_regime])
                 asym = exit_p - back_p
-                
                 st.write(f"Most likely exit is to {exit_target} at {exit_p:.2f}.")
                 st.write(f"If that happens: {risk_bias_for_transition(cur_regime, exit_target)}")
                 if abs(asym) >= 0.10:
@@ -1082,7 +1065,6 @@ if run_analysis:
                     st.write(f"Flow between {cur_regime} and {exit_target} is {tilt} ({asym:+.2f}).")
                 else:
                     st.write("Two-way flow between these regimes is roughly balanced.")
-                
                 h_bits = entropy_row(trans.loc[cur_regime].values)
                 if h_bits <= 0.6:
                     st.write("Next-state outcomes are concentrated. Path is predictable.")
@@ -1090,14 +1072,12 @@ if run_analysis:
                     st.write("Next-state outcomes cluster in a few paths.")
                 else:
                     st.write("Next-state outcomes are diffuse. Path is uncertain.")
-                
                 T = trans.values
                 name_to_idx = {n:i for i, n in enumerate(trans.index)}
                 i0 = name_to_idx[cur_regime]
                 def kstep(T, i, k):
                     Tk = np.linalg.matrix_power(T, k)
                     return pd.Series(Tk[i], index=trans.columns)
-                
                 d5 = kstep(T, i0, 5)
                 p5_stay = float(d5[cur_regime])
                 if p5_stay >= 0.60:
@@ -1106,7 +1086,6 @@ if run_analysis:
                     st.write("Five-day view: staying is plausible but not dominant.")
                 else:
                     st.write("Five-day view: a different regime is more likely.")
-                
                 eigvals, eigvecs = np.linalg.eig(T.T)
                 idx = np.argmin(np.abs(eigvals - 1))
                 pi = np.real(eigvecs[:, idx]); pi = pi / pi.sum()
@@ -1122,7 +1101,6 @@ if run_analysis:
                     st.write("Long-run: regimes are sticky.")
                 else:
                     st.write("Long-run: regimes churn at a moderate pace.")
-                
                 cur_slope = float(slope_df['Slope'].iloc[-1])
                 pct_full = pct_rank(slope_df['Slope'], cur_slope)
                 st.write(f"Current slope is {cur_slope:.4f} pts/day.")
@@ -1135,8 +1113,7 @@ if run_analysis:
                     else:
                         band = "upper" if pct_full >= 60 else ("lower" if pct_full <= 40 else "middle")
                         st.write(f"Slope sits in the {band} part of its range "
-                              f"({pct_full:.1f}% of days were lower; {higher:.1f}% higher).")
-                
+                                 f"({pct_full:.1f}% of days were lower; {higher:.1f}% higher).")
                 means = hmm.means_.ravel()
                 if hmm.covariance_type == "full":
                     stds = np.sqrt(np.array([c[0,0] for c in hmm.covars_]))
@@ -1154,17 +1131,16 @@ if run_analysis:
                     st.write("States have moderate overlap. Expect some flips.")
                 else:
                     st.write("States overlap a lot. Treat labels with care.")
-                
                 if hasattr(hmm, "monitor_"):
                     conv = hmm.monitor_.converged
                     n_iter = hmm.monitor_.iter
                     if not conv:
                         st.write(f"Training did not fully converge in {n_iter} iterations. Use caution.")
-            
-            # Section 5: Carry Spread Analysis
+
+            # ---------- Section 5: Carry Spread Analysis ----------
             st.header("Carry Spread Analysis")
             st.write("Analyzes carry spreads between short and long term VIX futures expectations.")
-            
+
             with st.expander("Methodology", expanded=False):
                 st.write("""
                 This analysis uses monthly VIX futures data. The settle prices are pivoted into a wide format with rows as trade dates and columns as monthly tenors.
@@ -1179,30 +1155,24 @@ if run_analysis:
                 
                 Positive carry indicates potential roll-down benefits for long positions, while negative carry suggests cost for holding. This helps assess the economic incentive for carrying futures positions across maturities.
                 """)
-            
-            # Code for carry
-            # Carry Spreads — match dark style; force white legend/axes text & ticks
+
             monthly_df_full = df[~df['Weekly']].copy()
             monthly_df_full = monthly_df_full.sort_values('Trade Date')
-
             pivot = (
                 monthly_df_full
                 .pivot(index='Trade Date', columns='Tenor_Monthly', values='Settle')
                 .sort_index()
             )
-
             spreads = pd.DataFrame(index=pivot.index)
             long_legs = [float(l.strip()) for l in carry_long_legs.split(',') if l.strip()]
             for long_leg in long_legs:
                 if {carry_short_leg, long_leg}.issubset(pivot.columns):
-                    label = f'VX{int(long_leg) if long_leg.is_integer() else long_leg}-VX{int(carry_short_leg) if carry_short_leg.is_integer() else carry_short_leg}'
+                    label = f'VX{int(long_leg) if float(long_leg).is_integer() else long_leg}-VX{int(carry_short_leg) if float(carry_short_leg).is_integer() else carry_short_leg}'
                     spreads[label] = pivot[long_leg] - pivot[carry_short_leg]
-
             spreads = spreads.dropna(how='all')
             spreads_long = spreads.reset_index().melt(
                 id_vars='Trade Date', value_name='Spread', var_name='Leg'
             )
-
             fig = px.line(
                 spreads_long,
                 x='Trade Date',
@@ -1210,13 +1180,10 @@ if run_analysis:
                 color='Leg',
                 title='VIX Carry Spreads (Front ↔ 2nd & 6th Month)',
                 markers=True,
-                # bright palette that reads well on dark bg
                 color_discrete_sequence=px.colors.qualitative.Plotly
             )
-
             fig.update_traces(marker=dict(size=5), line=dict(width=2))
             fig.add_hline(y=0, line_dash='dash', line_color='rgba(255,255,255,0.6)')
-
             fig.update_layout(
                 xaxis_title='Trade Date',
                 yaxis_title='Spread (points)',
@@ -1232,8 +1199,6 @@ if run_analysis:
                 ),
                 margin=dict(l=60, r=20, t=60, b=40)
             )
-
-            # axes text + ticks in white (and subtle grids)
             fig.update_xaxes(
                 title_font=dict(color="white"),
                 tickfont=dict(color="white"),
@@ -1252,10 +1217,8 @@ if run_analysis:
                 linecolor="rgba(255,255,255,0.15)",
                 ticks="outside"
             )
-
             st.plotly_chart(fig, use_container_width=True)
 
-            
             with st.expander("Dynamic Interpretation", expanded=False):
                 if spreads.empty:
                     st.write("No spreads could be computed because required tenors are missing in the dataset.")
@@ -1263,47 +1226,41 @@ if run_analysis:
                     latest = spreads.iloc[-1]
                     date = spreads.index[-1].date()
                     st.write(f"Latest trade date in sample: {date}")
-                    
                     for col in spreads.columns:
                         series = spreads[col].dropna()
                         if series.empty:
                             continue
-                        
                         val = latest[col]
                         mean = series.mean()
                         pct = (series.rank(pct=True).iloc[-1] * 100).round(1)
-                        
                         st.write(f"\nSpread: {col}")
                         st.write(f"  Current value: {val:.2f} points")
                         st.write(f"  Historical mean: {mean:.2f} points")
                         st.write(f"  Current percentile vs history: {pct}%")
-                        
                         if val > 0:
                             st.write("  Interpretation: Futures curve is in CONTANGO for this leg "
-                                  f"(longer maturity higher than front).")
+                                     f"(longer maturity higher than front).")
                         elif val < 0:
                             st.write("  Interpretation: Futures curve is in BACKWARDATION for this leg "
-                                  f"(front contract richer than longer maturity).")
+                                     f"(front contract richer than longer maturity).")
                         else:
                             st.write("  Interpretation: Spread is flat, indicating balance between front and further contracts.")
-                        
                         if val > mean:
                             st.write("  Compared to history: Current spread is ABOVE average, "
-                                  "suggesting stronger than typical contango/backwardation.")
+                                     "suggesting stronger than typical contango/backwardation.")
                         elif val < mean:
                             st.write("  Compared to history: Current spread is BELOW average, "
-                                  "suggesting weaker structure than typical.")
+                                     "suggesting weaker structure than typical.")
                         else:
                             st.write("  Compared to history: Current spread is close to historical mean.")
-                    
                     st.write("\nNote: Percentiles show how extreme today’s spread is compared to the full sample. "
-                          "For example, a 90% percentile means the spread is higher than 90% of past values, "
-                          "indicating an unusually strong curve slope.")
-            
-            # Section 6: PCA Decomposition of the Curve
+                             "For example, a 90% percentile means the spread is higher than 90% of past values, "
+                             "indicating an unusually strong curve slope.")
+
+            # ---------- Section 6: PCA Decomposition of the Curve ----------
             st.header("PCA Decomposition of the Curve")
             st.write("Decomposes the VIX curve into principal components like level, slope, and curvature.")
-            
+
             with st.expander("Methodology", expanded=False):
                 st.write("""
                 This analysis uses monthly VIX futures, pivoting settle prices by trade date and user-specified tenors (default first 6 months). Rows with missing values are dropped.
@@ -1336,32 +1293,25 @@ if run_analysis:
                 PCA reduces dimensionality, capturing main modes of variation in the term structure: level (overall volatility), slope (carry/roll), curvature (mid-term premiums).
                 """)
 
-            
-            # Code for PCA
-            # PCA — match dark style; force white legend/axes text & ticks
             pca_df = df[~df['Weekly']].copy()
-
             pivot = (
                 pca_df
                 .pivot(index='Trade Date', columns='Tenor_Monthly', values='Settle')
                 .sort_index()
             )
-
             tenors_list = [float(t.strip()) for t in pca_tenors.split(',') if t.strip()]
             wide = pivot[tenors_list].dropna()
 
-            X = StandardScaler().fit_transform(wide.values)
-            pca = PCA(n_components=pca_n_components).fit(X)
-
-            labels = ['Level (PC1)', 'Slope (PC2)', 'Curvature (PC3)', 'PC4', 'PC5'][:pca_n_components]
+            # Cap PCA rows for hosted stability
+            MAX_PCA_ROWS = 1200 if SAFE_MODE else 4000
+            if len(wide) > MAX_PCA_ROWS:
+                wide = wide.tail(MAX_PCA_ROWS)
 
-            pc_scores = pd.DataFrame(
-                pca.transform(X),
-                index=wide.index,
-                columns=labels
-            )
+            X = StandardScaler().fit_transform(wide.values)
+            pca = PCA(n_components=int(pca_n_components)).fit(X)
+            labels = ['Level (PC1)', 'Slope (PC2)', 'Curvature (PC3)', 'PC4', 'PC5'][:int(pca_n_components)]
+            pc_scores = pd.DataFrame(pca.transform(X), index=wide.index, columns=labels)
 
-            # Scores over time
             fig_scores = px.line(
                 pc_scores,
                 x=pc_scores.index,
@@ -1403,8 +1353,6 @@ if run_analysis:
                 linecolor="rgba(255,255,255,0.15)",
                 ticks="outside"
             )
-
-            # Explained variance
             fig_var = px.bar(
                 x=labels,
                 y=pca.explained_variance_ratio_,
@@ -1443,14 +1391,12 @@ if run_analysis:
             st.plotly_chart(fig_scores, use_container_width=True)
             st.plotly_chart(fig_var, use_container_width=True)
 
-            
             with st.expander("Dynamic Interpretation", expanded=False):
                 def pct_rank(series, value):
                     s = pd.to_numeric(series, errors="coerce").dropna()
                     if s.empty or not np.isfinite(value): 
                         return np.nan
                     return float((s < value).mean() * 100.0)
-                
                 def band_from_pct(p):
                     if pd.isna(p): return "n/a"
                     if p >= 90: return "extreme high (top 10%)"
@@ -1458,48 +1404,39 @@ if run_analysis:
                     if p <= 10: return "extreme low (bottom 10%)"
                     if p <= 25: return "low (bottom quartile)"
                     return "middle range"
-                
                 def delta_tag(x, pos, neg, neutral="unchanged"):
                     if pd.isna(x): return neutral
                     if x > 0: return pos
                     if x < 0: return neg
                     return neutral
-                
                 st.write("\n— PCA components and what they mean —")
                 st.write("PC1: Level. Parallel moves of the whole curve. High means futures are broadly high. Low means broadly low.")
                 st.write("PC2: Slope. Steepness front to back. Positive means contango (back > front). Negative means backwardation (front > back).")
                 st.write("PC3: Curvature. Shape in the middle. Positive means a hump in mid tenors. Negative means a dip in mid tenors.")
-                
                 var_share = pca.explained_variance_ratio_
                 total_var = var_share.sum()
                 st.write("\n— Variance explained —")
                 for i, v in enumerate(var_share):
                     st.write(f"PC{i+1} accounts for {v*100:.1f}% of curve changes.")
                 st.write(f"Together they cover {total_var*100:.1f}% of the variation. The rest is noise or higher order shape.")
-                
                 latest_date = pc_scores.index[-1].date()
                 row = pc_scores.iloc[-1]
                 lvl = float(row[labels[0]]) if len(labels) > 0 else np.nan
                 slp = float(row[labels[1]]) if len(labels) > 1 else np.nan
                 cur = float(row[labels[2]]) if len(labels) > 2 else np.nan
-                
                 lvl_pct = pct_rank(pc_scores[labels[0]], lvl) if len(labels) > 0 else np.nan
                 slp_pct = pct_rank(pc_scores[labels[1]], slp) if len(labels) > 1 else np.nan
                 cur_pct = pct_rank(pc_scores[labels[2]], cur) if len(labels) > 2 else np.nan
-                
                 lvl_band = band_from_pct(lvl_pct)
                 slp_band = band_from_pct(slp_pct)
                 cur_band = band_from_pct(cur_pct)
-                
                 lvl_d5  = pc_scores[labels[0]].diff(5).iloc[-1] if len(labels) > 0 else np.nan
                 slp_d5  = pc_scores[labels[1]].diff(5).iloc[-1] if len(labels) > 1 else np.nan
                 cur_d5  = pc_scores[labels[2]].diff(5).iloc[-1] if len(labels) > 2 else np.nan
                 lvl_d20 = pc_scores[labels[0]].diff(20).iloc[-1] if len(labels) > 0 else np.nan
                 slp_d20 = pc_scores[labels[1]].diff(20).iloc[-1] if len(labels) > 1 else np.nan
                 cur_d20 = pc_scores[labels[2]].diff(20).iloc[-1] if len(labels) > 2 else np.nan
-                
                 st.write(f"\n— Latest observation: {latest_date} —")
-                
                 if len(labels) > 0:
                     st.write("\nLevel (PC1):")
                     st.write(f"Position vs history: {lvl_band}. This gauges the overall price of variance along the strip.")
@@ -1509,12 +1446,10 @@ if run_analysis:
                         st.write("Implication: options and variance products tend to be cheap across expiries.")
                     else:
                         st.write("Implication: overall level is near its long-run zone.")
-                    
                     st.write(f"Recent move: {delta_tag(lvl_d5,'up over 1 week','down over 1 week')}; "
-                          f"{delta_tag(lvl_d20,'up over 1 month','down over 1 month')}.")
+                             f"{delta_tag(lvl_d20,'up over 1 month','down over 1 month')}.")
                     st.write("Use case: compare with slope. High level with negative slope often marks stress. "
-                          "High level with positive slope often marks calm but pricey carry.")
-                
+                             "High level with positive slope often marks calm but pricey carry.")
                 if len(labels) > 1:
                     st.write("\nSlope (PC2):")
                     st.write(f"Position vs history: {slp_band}. This is the carry signal.")
@@ -1524,11 +1459,9 @@ if run_analysis:
                         st.write("Implication: backwardation or near inversion. Hedging demand is high. Carry is hostile for short front exposure.")
                     else:
                         st.write("Implication: slope is near normal. Carry is modest.")
-                    
                     st.write(f"Recent move: {delta_tag(slp_d5,'steepening over 1 week','flattening over 1 week')}; "
-                          f"{delta_tag(slp_d20,'steepening over 1 month','flattening over 1 month')}.")
+                             f"{delta_tag(slp_d20,'steepening over 1 month','flattening over 1 month')}.")
                     st.write("Risk note: fast drops in slope from a high zone often precede drawdowns in carry trades.")
-                
                 if len(labels) > 2:
                     st.write("\nCurvature (PC3):")
                     st.write(f"Position vs history: {cur_band}. This shows where risk concentrates on the term structure.")
@@ -1538,18 +1471,15 @@ if run_analysis:
                         st.write("Implication: mid tenors are discounted vs the ends. Risk focus sits in very short or long expiries.")
                     else:
                         st.write("Implication: shape is ordinary. No special mid-curve premium or discount.")
-                    
                     st.write(f"Recent move: {delta_tag(cur_d5,'higher over 1 week','lower over 1 week')}; "
-                          f"{delta_tag(cur_d20,'higher over 1 month','lower over 1 month')}.")
+                             f"{delta_tag(cur_d20,'higher over 1 month','lower over 1 month')}.")
                     st.write("Use case: aligns hedges to the horizon that the market prices most.")
-                
                 st.write("\n— Joint reading and practical takeaways —")
                 if len(labels) > 1:
                     calm_contango   = (("high" in slp_band or "extreme high" in slp_band) and "middle" in lvl_band)
                     expensive_calm  = (("high" in slp_band or "extreme high" in slp_band) and ("high" in lvl_band or "extreme high" in lvl_band))
                     stress_state    = (("low" in slp_band or "extreme low" in slp_band) and ("high" in lvl_band or "extreme high" in lvl_band))
                     flat_transition = ("middle" in slp_band and "middle" in lvl_band)
-                    
                     if stress_state:
                         st.write("Stress signal: high level with backwardation. Hedging flows dominate. Carry is negative at the front.")
                     elif expensive_calm:
@@ -1560,13 +1490,11 @@ if run_analysis:
                         st.write("Transition zone: level and slope near normal. Wait for a break in slope momentum.")
                     else:
                         st.write("Mixed signals: cross-currents across level and slope. Reduce leverage and watch slope momentum.")
-                    
                     if len(labels) > 2:
                         if "high" in cur_band or "extreme high" in cur_band:
                             st.write("Horizon bias: risk priced in mid tenors. Size hedges in the 2–4 month area.")
                         elif "low" in cur_band or "extreme low" in cur_band:
                             st.write("Horizon bias: risk priced at the tails. Favor very short or long expiries for hedges.")
-                    
                     warn = []
                     if ("high" in slp_band or "extreme high" in slp_band) and slp_d5 < 0:
                         warn.append("slope is rolling over from a high zone")
@@ -1576,7 +1504,6 @@ if run_analysis:
                         warn.append("level keeps rising; shock risk remains")
                     if warn:
                         st.write("Watchlist: " + "; ".join(warn) + ".")
-                
                 st.write("\n— Recap —")
                 if len(labels) > 0:
                     if "high" in lvl_band or "extreme high" in lvl_band:
@@ -1585,7 +1512,6 @@ if run_analysis:
                         st.write("The whole curve is cheap. Protection costs less than usual.")
                     else:
                         st.write("The whole curve is fairly priced vs its own history.")
-                
                 if len(labels) > 1:
                     if "high" in slp_band or "extreme high" in slp_band:
                         st.write("Carry is supportive right now. It helps short front exposure, unless a shock hits.")
@@ -1593,7 +1519,6 @@ if run_analysis:
                         st.write("Carry is hostile right now. It punishes short front exposure.")
                     else:
                         st.write("Carry is modest. No strong tilt from slope.")
-                
                 if len(labels) > 2:
                     if "high" in cur_band or "extreme high" in cur_band:
                         st.write("Risk is concentrated in the middle of the term structure.")
@@ -1601,13 +1526,12 @@ if run_analysis:
                         st.write("Risk is concentrated at the very short or very long end.")
                     else:
                         st.write("Risk is spread evenly across the curve.")
-                
                 st.write("These readings are in-sample. Use them as context, not a forecast.")
-            
-            # Section 7: Constant-Maturity 30-Day Futures Index
+
+            # ---------- Section 7: Constant-Maturity 30-Day Futures Index ----------
             st.header("Constant-Maturity 30-Day Futures Index")
             st.write("Constructs an unlevered index simulating constant 30-day maturity VIX futures exposure.")
-            
+
             with st.expander("Methodology", expanded=False):
                 st.write("""
                 This constructs a synthetic constant-maturity VIX futures price by interpolating between the nearest contracts bracketing the target maturity (default 30 days).
@@ -1634,9 +1558,7 @@ if run_analysis:
                 
                 This index proxies the performance of continuously rolling to maintain constant exposure to 30-day volatility, capturing roll yield and spot moves without leverage.
                 """)
-            
-            # Code for CM
-            # Constant-Maturity 30-Day Index — match dark style; force white axes/ticks
+
             roll_df = df.copy()
             roll_df = roll_df[roll_df['Settle'] > 0]
             roll_df = roll_df.sort_values(['Trade Date', 'Tenor_Days'])
@@ -1645,10 +1567,8 @@ if run_analysis:
             for trade_date, g in roll_df.groupby('Trade Date'):
                 lo = g[g['Tenor_Days'] <= cm_target].tail(1)
                 hi = g[g['Tenor_Days'] >= cm_target].head(1)
-
                 if lo.empty and hi.empty:
                     continue
-
                 if hi.empty or lo.empty:
                     blend = (hi if not hi.empty else lo)['Settle'].iloc[0]
                 else:
@@ -1659,7 +1579,6 @@ if run_analysis:
                     else:
                         w2 = (cm_target - d1) / (d2 - d1)
                         blend = p1 + w2 * (p2 - p1)
-
                 if blend > 0:
                     records.append({'Trade Date': trade_date, 'Blend': blend})
 
@@ -1679,7 +1598,6 @@ if run_analysis:
             )
             fig.update_traces(line=dict(width=2))
             fig.add_hline(y=cm_start, line_dash='dash', line_color='rgba(255,255,255,0.6)')
-
             fig.update_layout(
                 xaxis_title='Trade Date',
                 yaxis_title='Index level',
@@ -1690,8 +1608,6 @@ if run_analysis:
                 showlegend=False,
                 margin=dict(l=60, r=20, t=60, b=40)
             )
-
-            # axes text + ticks in white (and subtle grids)
             fig.update_xaxes(
                 title_font=dict(color="white"),
                 tickfont=dict(color="white"),
@@ -1710,10 +1626,8 @@ if run_analysis:
                 linecolor="rgba(255,255,255,0.15)",
                 ticks="outside"
             )
-
             st.plotly_chart(fig, use_container_width=True)
 
-            
             with st.expander("Dynamic Interpretation", expanded=False):
                 if idx.empty:
                     st.write("No observations available for interpretation.")
@@ -1721,13 +1635,11 @@ if run_analysis:
                     ts = idx.copy().reset_index(drop=True)
                     ts['Trade Date'] = pd.to_datetime(ts['Trade Date'])
                     ts = ts.sort_values('Trade Date')
-                    
                     def pct_rank(series, value):
                         s = pd.to_numeric(series, errors="coerce").dropna()
                         if s.empty or not np.isfinite(value): 
                             return np.nan
                         return float((s < value).mean() * 100.0)
-                    
                     def streak_updown(x):
                         s = np.sign(x.fillna(0).to_numpy())
                         streak = 0
@@ -1736,31 +1648,25 @@ if run_analysis:
                             elif v < 0: streak = streak - 1 if streak <= 0 else -1
                             else: break
                         return streak
-                    
                     for w in (5, 20, 60, 120):
                         mp = min(3, w)
                         ts[f'Ret_MA_{w}']  = ts['Return'].rolling(w, min_periods=mp).mean()
                         ts[f'Ret_STD_{w}'] = ts['Return'].rolling(w, min_periods=mp).std(ddof=0)
-                    
                     ts['Vol20'] = ts['Ret_STD_20'] * np.sqrt(252)
                     ts['Vol60'] = ts['Ret_STD_60'] * np.sqrt(252)
                     ts['Vol120'] = ts['Ret_STD_120'] * np.sqrt(252)
-                    
                     for w in (20, 60, 120, 252):
                         mp = min(5, w)
                         ts[f'Idx_MA_{w}'] = ts['Index'].rolling(w, min_periods=mp).mean()
-                    
                     for w in (60, 120, 252):
                         mu = ts['Blend'].rolling(w, min_periods=min(20, w)).mean()
                         sd = ts['Blend'].rolling(w, min_periods=min(20, w)).std(ddof=0)
                         ts[f'Blend_Z_{w}'] = np.where(sd > 0, (ts['Blend'] - mu) / sd, np.nan)
-                    
                     cummax = ts['Index'].cummax()
                     ts['Drawdown'] = ts['Index'] / cummax - 1.0
                     max_dd = float(ts['Drawdown'].min()) if len(ts) else np.nan
                     dd_now = float(ts['Drawdown'].iloc[-1])
                     peak_date = ts.loc[ts['Index'].idxmax(), 'Trade Date'].date()
-                    
                     r = ts['Return'].dropna()
                     r_mu = r.mean()
                     r_sd = r.std(ddof=0)
@@ -1769,7 +1675,6 @@ if run_analysis:
                         last_tail = not r.empty and (abs(r.iloc[-1] - r_mu) >= 2*r_sd)
                     else:
                         tail_2s, last_tail = np.nan, False
-                    
                     last = ts.iloc[-1]
                     end_date = last['Trade Date'].date()
                     def window_ret(days):
@@ -1779,19 +1684,15 @@ if run_analysis:
                     ret_5d  = window_ret(5)
                     ret_20d = window_ret(20)
                     ret_60d = window_ret(60)
-                    
                     updown_streak = streak_updown(ts['Return'])
-                    
                     idx_pct   = pct_rank(ts['Index'], last['Index'])
                     blend_pct = pct_rank(ts['Blend'], last['Blend'])
-                    
                     def pos(val, ref): 
                         if pd.isna(ref): return "n/a"
                         return "above" if val > ref else ("below" if val < ref else "at")
                     st20  = pos(last['Index'], last.get('Idx_MA_20'))
                     st60  = pos(last['Index'], last.get('Idx_MA_60'))
                     st120 = pos(last['Index'], last.get('Idx_MA_120'))
-                    
                     ma20 = ts['Idx_MA_20']
                     ma20_slope = np.nan
                     if ma20.notna().sum() >= 5:
@@ -1800,7 +1701,6 @@ if run_analysis:
                         if len(y) >= 5:
                             b1 = np.polyfit(x, y, 1)[0]
                             ma20_slope = float(b1)
-                    
                     ts['Month'] = ts['Trade Date'].dt.to_period('M')
                     cur_month = ts['Month'].iloc[-1]
                     mtd = ts[ts['Month'] == cur_month]
@@ -1814,10 +1714,8 @@ if run_analysis:
                           .dropna()
                     )
                     med_m = float(by_month['mret'].median()) if not by_month.empty else np.nan
-                    
                     st.write("\n— 30d Constant-Maturity VIX Futures Index: interpretation —")
                     st.write(f"Date: {end_date}")
-                    
                     if pd.notna(idx_pct):
                         if idx_pct >= 90:
                             st.write("The index level sits in the top decile of its history. Vol risk is priced high.")
@@ -1826,7 +1724,6 @@ if run_analysis:
                         else:
                             zone = "upper" if idx_pct >= 60 else ("lower" if idx_pct <= 40 else "middle")
                             st.write(f"The index level is in the {zone} part of its historical range.")
-                    
                     st.write(f"Trend check: index is {st20} the 20d average, {st60} the 60d, {st120} the 120d.")
                     if np.isfinite(ma20_slope):
                         if ma20_slope > 0:
@@ -1835,11 +1732,9 @@ if run_analysis:
                             st.write("Short-term trend is falling. The 20d average is pointing down.")
                         else:
                             st.write("Short-term trend is flat.")
-                    
                     def fmt_pct(x):
                         return "n/a" if pd.isna(x) else f"{x*100:.1f}%"
                     st.write(f"Recent performance: 1w {fmt_pct(ret_5d)}, 1m {fmt_pct(ret_20d)}, 3m {fmt_pct(ret_60d)}.")
-                    
                     if pd.notna(max_dd):
                         if dd_now < -0.05:
                             st.write(f"Current drawdown: {dd_now*100:.1f}%. The index is below its peak from {peak_date}.")
@@ -1848,16 +1743,13 @@ if run_analysis:
                         else:
                             st.write(f"Modest drawdown: {dd_now*100:.1f}% vs peak on {peak_date}.")
                         st.write(f"Worst drawdown in sample: {max_dd*100:.1f}%.")
-                    
                     v20, v60, v120 = last.get('Vol20'), last.get('Vol60'), last.get('Vol120')
                     if pd.notna(v20):
                         st.write(f"Annualized return volatility: 20d {v20*100:.1f}%, 60d {v60*100:.1f}%, 120d {v120*100:.1f}%.")
-                    
                     if pd.notna(tail_2s):
                         st.write(f"Tail frequency: {tail_2s:.1f}% of days move more than 2σ from the mean.")
                         if last_tail:
                             st.write("Today’s move was a tail event relative to recent history.")
-                    
                     b_pct = blend_pct
                     b_z120 = last.get('Blend_Z_120')
                     b_z252 = last.get('Blend_Z_252') if 'Blend_Z_252' in ts.columns else np.nan
@@ -1875,14 +1767,12 @@ if run_analysis:
                             st.write(f"Relative to the last ~6 months, the 30d blend price is unusually low (z={b_z120:.2f}).")
                         else:
                             st.write(f"Relative to the last ~6 months, the 30d blend price is normal (z={b_z120:.2f}).")
-                    
                     if updown_streak > 0:
                         st.write(f"Up streak: {updown_streak} days of gains.")
                     elif updown_streak < 0:
                         st.write(f"Down streak: {abs(updown_streak)} days of losses.")
                     else:
                         st.write("No up/down streak today.")
-                    
                     if pd.notna(mtd_ret):
                         st.write(f"Month-to-date return: {mtd_ret*100:.1f}%.")
                         if pd.notna(med_m):
@@ -1892,7 +1782,6 @@ if run_analysis:
                                 st.write("This is below the median month in the sample.")
                             else:
                                 st.write("This is in line with a typical month.")
-                    
                     notes = []
                     if pd.notna(v20) and v20 > v60:
                         notes.append("short-term volatility is elevated vs medium term")
@@ -1904,7 +1793,6 @@ if run_analysis:
                         notes.append("30d blend price is an outlier vs 6m history")
                     if notes:
                         st.write("Risk notes: " + "; ".join(notes) + ".")
-                    
                     st.write("\n— Recap —")
                     if pd.notna(idx_pct):
                         loc = "high" if idx_pct >= 60 else ("low" if idx_pct <= 40 else "mid")
@@ -1915,12 +1803,12 @@ if run_analysis:
                     if pd.notna(v20):
                         st.write(f"Return vol (20d): {v20*100:.1f}%.")
                     st.write("Use this as context, not a forecast.")
-            
+
         except Exception as e:
             st.error("An error occurred during analysis. Please check your inputs and try again.")
             st.write(traceback.format_exc())
 
-# Hide default Streamlit style
+# ---------- Hide default Streamlit style ----------
 st.markdown(
     """
     <style>