Upload app.py

app.py

@@ -1,77 +1,2084 @@
-"""Interactive Lynote Notes demo (kept ready for PRO hosting).
+### SWEDEN TAC FOR 100 TRAIN-KM AND PR ###
+### WORKS PERFECT ###
 
-Paste text, get a cited note, then ask questions grounded in the same text.
-The demo uses the library's offline extractive provider, so it needs no model
-and no API key — only Gradio and the lynote-notes package.
+
+import gradio as gr
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+
+# ==========================================
+# 1. CLASS DEFINITIONS & INFRASTRUCTURE
+# ==========================================
+
+class Train:
+    def __init__(self, id, direction, priority, stops, start_time_offset, speed_kmh, dwell_min):
+        self.id = str(id)
+        self.direction = direction
+        self.priority = int(priority)
+        self.speed_kmh = float(speed_kmh)
+        self.dwell_min = float(dwell_min)
+        self.stops = stops
+        self.start_time_offset = float(start_time_offset)
+        self.schedule = []
+
+    def copy(self):
+        new_t = Train(self.id, self.direction, self.priority, self.stops,
+                      self.start_time_offset, self.speed_kmh, self.dwell_min)
+        new_t.schedule = []
+        for s in self.schedule:
+            node_copy = s.copy()
+            if 'min_arr_constraint' not in node_copy: node_copy['min_arr_constraint'] = None
+            new_t.schedule.append(node_copy)
+        return new_t
+
+class Infrastructure:
+    def __init__(self, station_df, spacing_km=5.0):
+        # Access by index to be robust against header names
+        self.stations = station_df.iloc[:, 0].astype(str).tolist()
+        self.distances = pd.to_numeric(station_df.iloc[:, 1], errors='coerce').fillna(0.0).tolist()
+        self.station_map = {name: i for i, name in enumerate(self.stations)}
+        self.dist_map = {name: d for name, d in zip(self.stations, self.distances)}
+        self.spacing_km = float(spacing_km)
+
+    def get_travel_time(self, s1, s2, speed_kmh):
+        d1 = self.dist_map.get(s1, 0.0)
+        d2 = self.dist_map.get(s2, 0.0)
+        dist_km = abs(d1 - d2)
+        if speed_kmh <= 0: return timedelta(minutes=1)
+        hours = dist_km / speed_kmh
+        return timedelta(hours=hours)
+
+    def get_dynamic_headway(self, speed_kmh):
+        if speed_kmh <= 0: return timedelta(minutes=5)
+        minutes = (self.spacing_km / speed_kmh) * 60.0
+        return timedelta(minutes=max(1.0, minutes))
+
+# ==========================================
+# 2. PHYSICS ENGINE
+# ==========================================
+
+def update_train_times(train, infra, base_time):
+    if not train.schedule:
+        current_time = base_time + timedelta(minutes=train.start_time_offset)
+        train.schedule = []
+        for s in train.stops:
+            train.schedule.append({
+                'station': s,
+                'arr': current_time,
+                'dep': current_time,
+                'min_arr_constraint': None,
+                'manual_delay': timedelta(0)
+            })
+
+    for i in range(len(train.schedule)):
+        current_node = train.schedule[i]
+        manual_delay = current_node.get('manual_delay', timedelta(0))
+
+        # A. ARRIVAL
+        if i == 0:
+            base_origin_time = base_time + timedelta(minutes=train.start_time_offset)
+            current_node['arr'] = base_origin_time + manual_delay
+        else:
+            prev_node = train.schedule[i-1]
+            phys_run_time = infra.get_travel_time(prev_node['station'], current_node['station'], train.speed_kmh)
+            min_phys_arr = prev_node['dep'] + phys_run_time
+            safety_limit = current_node.get('min_arr_constraint')
+
+            delayed_phys_arr = min_phys_arr + manual_delay
+
+            if safety_limit:
+                current_node['arr'] = max(delayed_phys_arr, safety_limit)
+            else:
+                current_node['arr'] = delayed_phys_arr
+
+        # B. DEPARTURE
+        dwell = timedelta(minutes=train.dwell_min) if i < len(train.schedule) - 1 else timedelta(0)
+        min_dep = current_node['arr'] + dwell
+        current_node['dep'] = max(current_node['dep'], min_dep)
+
+# ==========================================
+# 3. CONFLICT DETECTOR
+# ==========================================
+
+def detect_conflicts(trains, infra):
+    conflicts = []
+    for i in range(len(trains)):
+        for j in range(i + 1, len(trains)):
+            t1 = trains[i]
+            t2 = trains[j]
+            for k in range(len(t1.schedule) - 1):
+                u, v = t1.schedule[k]['station'], t1.schedule[k+1]['station']
+                t2_stations = [s['station'] for s in t2.schedule]
+                if u in t2_stations and v in t2_stations:
+                    idx_u_t2 = t2_stations.index(u)
+                    idx_v_t2 = t2_stations.index(v)
+                    if abs(idx_u_t2 - idx_v_t2) == 1:
+                        t1_ent, t1_ext = t1.schedule[k]['dep'], t1.schedule[k+1]['arr']
+                        if idx_u_t2 < idx_v_t2:
+                            t2_ent, t2_ext = t2.schedule[idx_u_t2]['dep'], t2.schedule[idx_v_t2]['arr']
+                            direction = "Same"
+                        else:
+                            t2_ent, t2_ext = t2.schedule[idx_v_t2]['dep'], t2.schedule[idx_u_t2]['arr']
+                            direction = "Opposite"
+
+                        is_conflict = False
+                        conflict_reason = ""
+
+                        if direction == "Opposite":
+                            if max(t1_ent, t2_ent) < min(t1_ext, t2_ext):
+                                is_conflict = True; conflict_reason = "Head-on"
+                        else:
+                            if t1_ent <= t2_ent:
+                                l_ent, f_ent = t1_ent, t2_ent
+                                leader_ext, follower_ext = t1_ext, t2_ext
+                                hw = infra.get_dynamic_headway(t2.speed_kmh)
+                            elif t1_ent > t2_ent:
+                                l_ent, f_ent = t2_ent, t1_ent
+                                leader_ext, follower_ext = t2_ext, t1_ext
+                                hw = infra.get_dynamic_headway(t1.speed_kmh)
+
+                            tol = timedelta(seconds=1)
+                            if f_ent < l_ent + hw - tol:
+                                is_conflict = True; conflict_reason = f"Entry HW ({hw.seconds//60}m)"
+                            elif follower_ext < leader_ext + hw - tol:
+                                is_conflict = True; conflict_reason = f"Exit HW ({hw.seconds//60}m)"
+
+                        if is_conflict:
+                            conflicts.append({'time': max(t1_ent, t2_ent), 'trains': (t1, t2), 'segment': (u, v), 'dir': direction, 'desc': f"{conflict_reason} on {u}->{v}"})
+    conflicts.sort(key=lambda x: x['time'])
+    return conflicts
+
+# ==========================================
+# 4. RESOLVER (With Max Buffer Logic)
+# ==========================================
+
+def resolve_all_conflicts(trains, infra, base_time, selected_train_id=None, max_buffer_min=30.0):
+    iteration = 0
+    max_iter = 200
+    logs = []
+    max_buffer_td = timedelta(minutes=float(max_buffer_min))
+
+    while iteration < max_iter:
+        conflicts = detect_conflicts(trains, infra)
+        if not conflicts:
+            logs.append("No conflicts found.")
+            break
+
+        c = conflicts[0]
+        t1, t2 = c['trains']
+        u, v = c['segment']
+        direction = c['dir']
+
+        # If the user selected a train in the View & Optimization panel,
+        # treat it as the optimization target for this conflict. This makes the
+        # Select Train list-box functional: the selected service is protected
+        # before normal priority/tie-break logic is applied.
+        selected_id = str(selected_train_id) if selected_train_id not in (None, "", "None") else None
+        if selected_id and str(t1.id) == selected_id and str(t2.id) != selected_id:
+            winner, loser = t1, t2
+            logs.append(f"Iter {iteration}: Optimization target {winner.id} given dispatch priority.")
+        elif selected_id and str(t2.id) == selected_id and str(t1.id) != selected_id:
+            winner, loser = t2, t1
+            logs.append(f"Iter {iteration}: Optimization target {winner.id} given dispatch priority.")
+        elif t1.priority > t2.priority:
+            winner, loser = t1, t2
+        elif t2.priority > t1.priority:
+            winner, loser = t2, t1
+        else:
+            winner, loser = (t1, t2) if t1.id < t2.id else (t2, t1)
+
+        def get_idx(train, station): return [s['station'] for s in train.schedule].index(station)
+
+        if direction == "Same":
+            u_w, v_w = get_idx(winner, u), get_idx(winner, v)
+            u_l, v_l = get_idx(loser, u), get_idx(loser, v)
+            if u_w > v_w: u_w, v_w = v_w, u_w
+            if u_l > v_l: u_l, v_l = v_l, u_l
+
+            if winner.schedule[u_w]['dep'] <= loser.schedule[u_l]['dep']:
+                leader, follower = winner, loser
+                l_u, l_v = u_w, v_w
+                f_u, f_v = u_l, v_l
+                follower_is_winner = False
+            else:
+                leader, follower = loser, winner
+                l_u, l_v = u_l, v_l
+                f_u, f_v = u_w, v_w
+                follower_is_winner = True
+
+            hw = infra.get_dynamic_headway(follower.speed_kmh)
+
+            applied_buffer = False
+            if follower_is_winner and selected_train_id and str(follower.id) == str(selected_train_id):
+                 gap_needed = (follower.schedule[f_u]['dep'] + hw) - leader.schedule[l_u]['dep']
+                 current_buffer = leader.schedule[l_u].get('manual_delay', timedelta(0))
+                 total_new_buffer = current_buffer + gap_needed
+
+                 if gap_needed > timedelta(0):
+                     if total_new_buffer <= max_buffer_td:
+                         logs.append(f"Iter {iteration}: Selected Train Optimization -> Applying {gap_needed.total_seconds()//60:.1f}m Buffer to {leader.id} at {u}. Total: {total_new_buffer.total_seconds()//60:.1f}m")
+                         leader.schedule[l_u]['manual_delay'] = total_new_buffer
+                         update_train_times(leader, infra, base_time)
+                         applied_buffer = True
+                     else:
+                         logs.append(f"Iter {iteration}: Selected Train Optimization Rejected. Total buffer needed ({total_new_buffer.total_seconds()//60:.1f}m) exceeds Limit ({max_buffer_min}m).")
+
+            if not applied_buffer:
+                req_dep = leader.schedule[l_u]['dep'] + hw
+                if follower.schedule[f_u]['dep'] < req_dep:
+                    logs.append(f"Iter {iteration}: Holding {follower.id} at {u}. Req HW: {hw}")
+                    follower.schedule[f_u]['dep'] = req_dep
+
+                req_arr = leader.schedule[l_v]['arr'] + hw
+                current_const = follower.schedule[f_v].get('min_arr_constraint')
+                if current_const is None or req_arr > current_const:
+                    logs.append(f"Iter {iteration}: Slowing {follower.id} on {u}->{v}. Req HW: {hw}")
+                    follower.schedule[f_v]['min_arr_constraint'] = req_arr
+
+                update_train_times(follower, infra, base_time)
+
+                if follower_is_winner:
+                     if l_v < len(leader.schedule):
+                         follower_next_dep = follower.schedule[f_v]['dep']
+                         req_leader_dep = follower_next_dep + hw
+                         if leader.schedule[l_v]['dep'] < req_leader_dep:
+                             logs.append(f"Iter {iteration}: Overtake at {v}. Holding {leader.id}.")
+                             leader.schedule[l_v]['dep'] = req_leader_dep
+                             update_train_times(leader, infra, base_time)
+
+        else:
+            u_w, v_w = get_idx(winner, u), get_idx(winner, v)
+            t_clear = max(winner.schedule[u_w]['arr'], winner.schedule[v_w]['arr'])
+            u_l, v_l = get_idx(loser, u), get_idx(loser, v)
+            l_ent = min(u_l, v_l)
+            if loser.schedule[l_ent]['dep'] < t_clear:
+                logs.append(f"Iter {iteration}: Opp Dir. Holding {loser.id} at {u}.")
+                loser.schedule[l_ent]['dep'] = t_clear
+                update_train_times(loser, infra, base_time)
+        iteration += 1
+    return logs
+
+# ==========================================
+# 5. DATA EXPORT & VISUALS
+# ==========================================
+
+def generate_timetable_matrix(trains, infra):
+    data = []
+    columns = ["Train ID", "Direction"]
+    for s in infra.stations:
+        columns.append(f"{s} Arr")
+        columns.append(f"{s} Dep")
+
+    for t in trains:
+        row = {"Train ID": t.id, "Direction": t.direction}
+        for s_data in t.schedule:
+            s_name = s_data['station']
+            row[f"{s_name} Arr"] = s_data['arr'].strftime("%H:%M:%S")
+            row[f"{s_name} Dep"] = s_data['dep'].strftime("%H:%M:%S")
+
+        for s in infra.stations:
+            if f"{s} Arr" not in row: row[f"{s} Arr"] = "-"
+            if f"{s} Dep" not in row: row[f"{s} Dep"] = "-"
+
+        data.append(row)
+
+    df = pd.DataFrame(data)
+    final_cols = ["Train ID", "Direction"]
+    for s in infra.stations:
+        final_cols.append(f"{s} Arr")
+        final_cols.append(f"{s} Dep")
+
+    return df[final_cols]
+
+def calculate_delay_stats(nom_trains, adj_trains, primary_delay_df):
+    stats = []
+    primary_map = {}
+    if primary_delay_df is not None and not primary_delay_df.empty:
+        for _, row in primary_delay_df.iterrows():
+             if not pd.isna(row.iloc[0]):
+                 tid = str(row.iloc[0])
+                 try: val = float(row.iloc[2])
+                 except: val = 0.0
+                 primary_map[tid] = primary_map.get(tid, 0) + val
+
+    for t_nom, t_adj in zip(nom_trains, adj_trains):
+        nom_end = t_nom.schedule[-1]['arr']
+        adj_end = t_adj.schedule[-1]['arr']
+        total_delay = (adj_end - nom_end).total_seconds() / 60.0
+        p_delay = primary_map.get(t_nom.id, 0.0)
+        s_delay = max(0.0, total_delay - p_delay)
+
+        if p_delay > 0 and s_delay > 0.1: d_type = "Both"
+        elif p_delay > 0: d_type = "Primary Only"
+        elif s_delay > 0.1: d_type = "Secondary"
+        else: d_type = "On Time"
+
+        stats.append({
+            "Train ID": t_nom.id,
+            "Total Delay": round(total_delay, 1),
+            "Primary": round(p_delay, 1),
+            "Secondary": round(s_delay, 1),
+            "Type": d_type
+        })
+    return pd.DataFrame(stats)
+
+def generate_buffer_report(trains, primary_delay_df):
+    report_data = []
+    requested_delays = {}
+    if primary_delay_df is not None and not primary_delay_df.empty:
+        for _, row in primary_delay_df.iterrows():
+            if not pd.isna(row.iloc[0]):
+                tid = str(row.iloc[0])
+                st = str(row.iloc[1])
+                try: val = float(row.iloc[2])
+                except: val = 0.0
+                requested_delays[(tid, st)] = val
+
+    for t in trains:
+        for node in t.schedule:
+            st = node['station']
+            total_manual = node.get('manual_delay', timedelta(0)).total_seconds() / 60.0
+            requested = requested_delays.get((t.id, st), 0.0)
+            buffer_val = total_manual - requested
+
+            if buffer_val > 0.1:
+                report_data.append({
+                    "Train ID": t.id,
+                    "Station": st,
+                    "Requested Delay (min)": round(requested, 1),
+                    "Total Added Delay (min)": round(total_manual, 1),
+                    "System Buffer (min)": round(buffer_val, 1)
+                })
+
+    if not report_data:
+        return pd.DataFrame(columns=["Train ID", "Station", "Requested Delay (min)", "Total Added Delay (min)", "System Buffer (min)"])
+
+    return pd.DataFrame(report_data)
+
+def create_filtered_marey(t_nom, t_del, t_adj, infra, view_mode, selected_train_id):
+    fig = go.Figure()
+    colors = ['#7C5CFF', '#4C8DFF', '#A978FF', '#45BFA7', '#6EC6FF', '#FF8AA1']
+    def get_dist(s): return infra.dist_map.get(s, 0)
+
+    def add_lines(trains, color, style, name_suffix, opacity, visible, width=2):
+        for i, t in enumerate(trains):
+            is_selected = (str(t.id) == str(selected_train_id))
+            x, y, txt = [], [], []
+            if is_selected and style == 'solid':
+                c = '#F2B84B'; w = 5; op = 1.0
+            else:
+                c = colors[i % len(colors)] if color == 'auto' else color
+                w = width; op = opacity
+
+            for s in t.schedule:
+                d = get_dist(s['station'])
+                x.extend([s['arr'], s['dep']])
+                y.extend([d, d])
+                txt.extend([f"Arrival at {s['station']}", f"Departure from {s['station']}"])
+
+            fig.add_trace(go.Scatter(
+                x=x,
+                y=y,
+                mode='lines+markers' if style == 'solid' else 'lines',
+                name=f"T{t.id} {name_suffix}" + (" · selected" if is_selected else ""),
+                line=dict(color=c, width=w, dash='solid' if style == 'solid' else style, shape='spline'),
+                marker=dict(size=7, color=c, line=dict(width=1, color='rgba(255,255,255,0.92)')) if style == 'solid' else None,
+                hovertext=txt,
+                hovertemplate="%{hovertext}<br>%{x|%H:%M:%S}<br>%{y} km<extra></extra>",
+                opacity=op,
+                visible=visible
+            ))
+
+    if view_mode in ["All Scenarios", "Nominal Only"]: add_lines(t_nom, '#9AA2B1', 'dash', "(Nominal)", 0.58, True)
+    if view_mode in ["All Scenarios", "Conflicted Only"]: add_lines(t_del, '#EE7486', 'dot', "(Conflicted)", 0.82, True if view_mode != "All Scenarios" else 'legendonly')
+    if view_mode in ["All Scenarios", "Resolved Only"]: add_lines(t_adj, 'auto', 'solid', "(Resolved)", 1.0, True, width=3)
+
+    fig.update_layout(
+        title=dict(
+            text=f"Marey diagram · {view_mode}",
+            x=0.01,
+            y=0.98,
+            xanchor='left',
+            yanchor='top',
+            font=dict(size=17, color='#262936')
+        ),
+        xaxis_title="Time",
+        yaxis_title="Station / distance",
+        yaxis=dict(
+            tickmode='array', tickvals=infra.distances, ticktext=infra.stations,
+            gridcolor='rgba(147,153,170,0.18)', zeroline=False,
+            tickfont=dict(color='#687083'), title_font=dict(color='#9299AA')
+        ),
+        xaxis=dict(
+            tickformat="%H:%M", gridcolor='rgba(147,153,170,0.14)', zeroline=False,
+            tickfont=dict(color='#687083'), title_font=dict(color='#9299AA')
+        ),
+        plot_bgcolor='#FFFFFF',
+        paper_bgcolor='rgba(0,0,0,0)',
+        font=dict(color='#5F6677', family='Inter, Segoe UI, sans-serif'),
+        legend=dict(
+            orientation='h',
+            yanchor='top', y=-0.18,
+            xanchor='left', x=0,
+            bgcolor='rgba(0,0,0,0)',
+            borderwidth=0,
+            font=dict(color='#5F6677')
+        ),
+        hoverlabel=dict(bgcolor='#FFFFFF', font_color='#262936', bordercolor='#DED8F3'),
+        margin=dict(l=58, r=24, t=68, b=105),
+        height=620,
+        transition=dict(duration=220, easing='cubic-in-out')
+    )
+    return fig
+
+def simulate_capacity_vs_reliability(infra, fleet_profiles, delay_data, max_trains_input, tac_fee, pr_rate, d_mode, r_prob, r_min, r_max, im_resp_share):
+    import random
+    from datetime import datetime, timedelta
+    import pandas as pd
+    import plotly.graph_objects as go
+
+    results = []
+
+    try: max_t = int(max_trains_input)
+    except: max_t = 20
+    if max_t < 2: max_t = 2
+
+    densities = list(range(2, max_t + 1))
+    base_time = datetime(2024, 1, 1, 8, 0, 0)
+
+    try: im_share = float(im_resp_share)
+    except: im_share = 50.0
+
+    best_profit = -float('inf')
+    best_trains = []
+    best_delay_df = pd.DataFrame() # <-- Initialize the dataframe to hold the best delays
+
+    for tph in densities:
+        scheduled_headway = 60.0 / tph
+        trains = []
+        current_run_delays = [] # <-- Track delays just for this specific TPH run
+
+        for i in range(tph):
+            profile = fleet_profiles[i % len(fleet_profiles)]
+            new_train = profile.copy()
+
+            generated_id = str(i + 1)
+            new_train.original_id = generated_id
+            new_train.id = f"T{generated_id}_{profile.id}"
+            new_train.start_time_offset = i * scheduled_headway
+            new_train.had_primary_delay = False # Track this cleanly!
+
+            update_train_times(new_train, infra, base_time)
+
+            # --- INJECT DELAYS BASED ON USER MODE ---
+            if d_mode == "Predefined (from Delays Tab)" and delay_data is not None and not delay_data.empty:
+                for _, d_row in delay_data.iterrows():
+                    d_keys = d_row.keys()
+                    delay_t_id = ""
+                    if "Train ID" in d_keys: delay_t_id = str(d_row["Train ID"]).strip()
+                    elif "Trian ID" in d_keys: delay_t_id = str(d_row["Trian ID"]).strip()
+
+                    st_name = str(d_row.get("Station", "")).strip()
+                    d_val = 0.0
+                    if "Delay" in d_keys: d_val = float(d_row["Delay"])
+                    elif "Delay (min)" in d_keys: d_val = float(d_row["Delay (min)"])
+
+                    if delay_t_id == generated_id and d_val > 0:
+                        new_train.had_primary_delay = True
+                        # Responsibility is decided by the same rule for every
+                        # primary delay, regardless of whether the delay is
+                        # predefined (from the Delays tab) or randomly generated -
+                        # it's set once, before the run, via the "IM Responsibility
+                        # Share" slider, so results across capacity levels stay
+                        # comparable and consistent between delay modes.
+                        party = "IM" if random.uniform(0, 100) <= im_share else "RU"
+                        amount = round(d_val * pr_rate, 2)
+                        current_run_delays.append({
+                            "Train ID": new_train.id, "Station": st_name, "Delay (min)": d_val,
+                            "Responsible Party": party, "Amount (€)": amount,
+                            "Effect on IM": f"Penalty to IM: -€{amount:,.2f}" if party == "IM" else f"Income for IM: +€{amount:,.2f}"
+                        })
+                        shift_active = False
+                        for stop_event in new_train.schedule:
+                            if st_name and st_name.lower() == str(stop_event['station']).lower():
+                                shift_active = True
+                            if shift_active:
+                                stop_event['arr'] += timedelta(minutes=d_val)
+                                stop_event['dep'] += timedelta(minutes=d_val)
+
+            elif d_mode == "Randomized":
+                # Roll the dice to see if this train gets delayed
+                if random.uniform(0, 100) <= float(r_prob):
+                    new_train.had_primary_delay = True
+                    # Pick a random station (excluding the final destination)
+                    rand_idx = random.randint(0, len(new_train.schedule) - 2)
+                    rand_station = new_train.schedule[rand_idx]['station']
+                    d_val = round(random.uniform(float(r_min), float(r_max)), 1)
+
+                    # Same responsibility rule as the predefined branch above -
+                    # the IM Responsibility Share slider, not a fresh 50/50 pick.
+                    party = "IM" if random.uniform(0, 100) <= im_share else "RU"
+                    amount = round(d_val * pr_rate, 2)
+
+                    # Log the generated delay
+                    current_run_delays.append({
+                        "Train ID": new_train.id, "Station": rand_station, "Delay (min)": d_val,
+                        "Responsible Party": party, "Amount (€)": amount,
+                        "Effect on IM": f"Penalty to IM: -€{amount:,.2f}" if party == "IM" else f"Income for IM: +€{amount:,.2f}"
+                    })
+
+                    shift_active = False
+                    for stop_event in new_train.schedule:
+                        if stop_event['station'] == rand_station:
+                            shift_active = True
+                        if shift_active:
+                            stop_event['arr'] += timedelta(minutes=d_val)
+                            stop_event['dep'] += timedelta(minutes=d_val)
+
+            trains.append(new_train)
+
+        resolve_all_conflicts(trains, infra, base_time)
+
+        # --- CALCULATE SECONDARY DELAY ---
+        total_secondary_delay = 0
+        for i, train in enumerate(trains):
+            if getattr(train, 'had_primary_delay', False):
+                continue
+
+            dummy = fleet_profiles[i % len(fleet_profiles)].copy()
+            dummy.start_time_offset = train.start_time_offset
+            update_train_times(dummy, infra, base_time)
+
+            last_station_idx = len(dummy.stops) - 1
+            expected_arr = dummy.schedule[last_station_idx]['arr']
+            actual_arr = train.schedule[last_station_idx]['arr']
+
+            delay_min = (actual_arr - expected_arr).total_seconds() / 60.0
+            if delay_min > 0: total_secondary_delay += delay_min
+
+        # --- PRIMARY DELAY RESPONSIBILITY COST (assigned before the run) ---
+        # Secondary delays are always paid by IM (PR Penalty above, unchanged).
+        # Primary delays are charged to whichever party (IM/RU) was assigned:
+        # IM-caused = penalty for IM; RU-caused = income for IM (RU pays IM).
+        primary_im_penalty = sum(d["Amount (€)"] for d in current_run_delays if d["Responsible Party"] == "IM")
+        primary_ru_income = sum(d["Amount (€)"] for d in current_run_delays if d["Responsible Party"] == "RU")
+
+        revenue = tph * tac_fee
+        penalty_cost = total_secondary_delay * pr_rate
+        profit = revenue - penalty_cost - primary_im_penalty + primary_ru_income
+
+        # --- CHECK IF THIS IS THE BEST SCENARIO ---
+        if profit > best_profit:
+            best_profit = profit
+            best_trains = [t.copy() for t in trains]
+            # Save the delays that were applied to this specific winning scenario!
+            if current_run_delays:
+                best_delay_df = pd.DataFrame(current_run_delays)
+            else:
+                best_delay_df = pd.DataFrame(columns=["Train ID", "Station", "Delay (min)", "Responsible Party", "Amount (€)", "Effect on IM"])
+
+        results.append({
+            'Capacity (Trains/Hour)': tph,
+            'Total Secondary Delay (min)': total_secondary_delay,
+            'Revenue (€)': revenue,
+            'PR Penalty (€)': penalty_cost,
+            'IM Primary Penalty (€)': primary_im_penalty,
+            'IM Primary Income (€)': primary_ru_income,
+            'Total Profit (€)': profit
+        })
+
+    df = pd.DataFrame(results)
+
+    timetable_data = []
+    if best_trains:
+        for t in best_trains:
+            for stop in t.schedule:
+                timetable_data.append({
+                    "Train ID": t.id,
+                    "Station": stop['station'],
+                    "Arrival": stop['arr'].strftime("%H:%M:%S"),
+                    "Departure": stop['dep'].strftime("%H:%M:%S")
+                })
+    best_timetable_df = pd.DataFrame(timetable_data)
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=df['Capacity (Trains/Hour)'], y=df['Revenue (€)'], mode='lines+markers', name='TAC Revenue', line=dict(color='#4C8DFF', width=3, shape='spline'), marker=dict(size=7)))
+    fig.add_trace(go.Scatter(x=df['Capacity (Trains/Hour)'], y=df['PR Penalty (€)'], mode='lines+markers', name='PR Penalty Cost', line=dict(dash='dash', color='#EE7486', width=2.5, shape='spline'), marker=dict(size=7)))
+    fig.add_trace(go.Scatter(x=df['Capacity (Trains/Hour)'], y=df['IM Primary Income (€)'] - df['IM Primary Penalty (€)'], mode='lines+markers', name='Primary Delay Net (IM)', line=dict(dash='dot', color='#45BFA7', width=2.5, shape='spline'), marker=dict(size=7)))
+    fig.add_trace(go.Scatter(x=df['Capacity (Trains/Hour)'], y=df['Total Profit (€)'], mode='lines+markers', name='Total Profit', line=dict(width=4, color='#7C5CFF', shape='spline'), marker=dict(size=8)))
+
+    best_tph = df.loc[df['Total Profit (€)'].idxmax()]['Capacity (Trains/Hour)']
+    fig.add_vline(x=best_tph, line_dash="dot", line_color="#F2B84B", annotation_text="Sweet Spot", annotation_position="top left")
+
+    fig.update_layout(
+        title=dict(text="Capacity vs. reliability", x=0.01, xanchor='left', font=dict(size=18, color='#262936')),
+        xaxis_title="Scheduled trains per hour",
+        yaxis_title="Euros (€)",
+        plot_bgcolor='#FFFFFF',
+        paper_bgcolor='rgba(0,0,0,0)',
+        font=dict(color='#5F6677', family='Inter, Segoe UI, sans-serif'),
+        xaxis=dict(gridcolor='rgba(147,153,170,0.14)', zeroline=False, tickfont=dict(color='#687083'), title_font=dict(color='#9299AA')),
+        yaxis=dict(gridcolor='rgba(147,153,170,0.14)', zeroline=False, tickfont=dict(color='#687083'), title_font=dict(color='#9299AA')),
+        legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1, bgcolor='rgba(0,0,0,0)', borderwidth=0, font=dict(color='#5F6677')),
+        hoverlabel=dict(bgcolor='#FFFFFF', font_color='#262936', bordercolor='#DED8F3'),
+        margin=dict(l=62, r=24, t=82, b=56),
+        transition=dict(duration=220, easing='cubic-in-out')
+    )
+
+    # --- GENERATE THE TRADITIONAL MAREY DIAGRAM (BOTTOM-LEFT TO TOP-RIGHT) ---
+    best_marey_fig = go.Figure()
+    dist_map = {st: dist for st, dist in zip(infra.stations, infra.distances)}
+
+    if best_trains:
+        for t in best_trains:
+            times = []
+            locs = []
+            for stop in t.schedule:
+                times.append(stop['arr'])
+                locs.append(dist_map[stop['station']])
+                times.append(stop['dep'])
+                locs.append(dist_map[stop['station']])
+
+            color = '#EE7486' if getattr(t, 'had_primary_delay', False) else '#7C5CFF'
+
+            best_marey_fig.add_trace(go.Scatter(
+                x=times,
+                y=locs,
+                mode='lines+markers',
+                name=t.id,
+                line=dict(color=color, width=3, shape='spline'),
+                marker=dict(size=5, color=color, line=dict(width=1, color='rgba(255,255,255,0.92)'))
+            ))
+
+        station_names = list(dist_map.keys())
+        station_distances = list(dist_map.values())
+
+        best_marey_fig.update_layout(
+            title=dict(
+                text=f"Optimal space-time diagram · {best_tph} trains/hour",
+                x=0.01, y=0.98, xanchor='left', yanchor='top',
+                font=dict(size=17, color='#262936')
+            ),
+            xaxis_title="Time",
+            yaxis_title="Station / distance",
+            xaxis=dict(
+                tickformat="%H:%M", tickangle=-25,
+                gridcolor='rgba(147,153,170,0.14)', zeroline=False,
+                tickfont=dict(color='#687083'), title_font=dict(color='#9299AA')
+            ),
+            yaxis=dict(
+                tickmode='array', tickvals=station_distances,
+                ticktext=[f"{st} ({d}km)" for st, d in zip(station_names, station_distances)],
+                gridcolor='rgba(147,153,170,0.18)', zeroline=False,
+                tickfont=dict(color='#687083'), title_font=dict(color='#9299AA')
+            ),
+            plot_bgcolor='#FFFFFF',
+            paper_bgcolor='rgba(0,0,0,0)',
+            font=dict(color='#5F6677', family='Inter, Segoe UI, sans-serif'),
+            hoverlabel=dict(bgcolor='#FFFFFF', font_color='#262936', bordercolor='#DED8F3'),
+            showlegend=False,
+            margin=dict(l=72, r=24, t=68, b=64),
+            transition=dict(duration=220, easing='cubic-in-out')
+        )
+
+    # Returning 5 elements, matching what run_economic_analysis expects!
+    return df, fig, best_timetable_df, best_marey_fig, best_delay_df
+
+# ==========================================
+# 6. SIMULATION & GRADIO
+# ==========================================
+
+def run_simulation(station_data, train_data, delay_data, spacing_input, plot_view, selected_train_input, max_buffer_input, d_mode, r_prob, r_min, r_max):
+    import random
+    from datetime import datetime, timedelta
+    import pandas as pd # Just in case it's not globally available here
+
+    # ----------------------------------------------------
+    # DATA CLEANING & HEADER RECOVERY (Robust to CSV errors)
+    # ----------------------------------------------------
+
+    # 1. Clean Train Data
+    if train_data is not None:
+        train_data = _normalize_uploaded_dataframe(train_data)
+
+    # 2. Clean Delay Data
+    if delay_data is not None:
+         delay_data = _normalize_uploaded_dataframe(delay_data)
+
+    # 3. Clean Station Data
+    if station_data is not None:
+         station_data = _normalize_uploaded_dataframe(station_data)
+
+    # ----------------------------------------------------
+
+    try: sp_km = float(spacing_input)
+    except: sp_km = 5.0
+
+    try: max_buff = float(max_buffer_input)
+    except: max_buff = 15.0
+
+    infra = Infrastructure(station_data, spacing_km=sp_km)
+    base_time = datetime.strptime("08:00", "%H:%M")
+
+    # 1. Nominal
+    trains_nom = []
+    stations_list = infra.stations
+
+    if train_data is None or train_data.empty:
+        return pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame(["No train data"]), go.Figure()
+
+    for _, row in train_data.iterrows():
+        if pd.isna(row.iloc[0]): continue
+
+        try:
+            t_id = str(row['Train ID'])
+            direction = row['Direction']
+            stops = stations_list[:] if str(direction).strip().lower() == "outbound" else stations_list[::-1]
+
+            t = Train(t_id, direction, row['Priority'], stops, row['Start Time Offset (min)'], row['Speed (km/h)'], row['Dwell (min)'])
+            update_train_times(t, infra, base_time)
+            trains_nom.append(t)
+        except KeyError as e:
+            return pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame([f"CSV Error: Column missing - {e}"]), go.Figure()
+
+    # 2. Delayed
+    trains_del = [t.copy() for t in trains_nom]
+
+    # --- THE BAIT AND SWITCH: GENERATE RANDOM DATAFRAME IF SELECTED ---
+    if d_mode == "Randomized (Monte Carlo)":
+        random_delays = []
+        for t in trains_del:
+            if random.uniform(0, 100) <= float(r_prob):
+                if len(t.stops) > 1: # Pick a random station (not the final destination)
+                    rand_idx = random.randint(0, len(t.stops) - 2)
+                    rand_station = t.stops[rand_idx]
+                    d_val = round(random.uniform(float(r_min), float(r_max)), 1)
+                    random_delays.append({"Train ID": t.id, "Station": rand_station, "Delay": d_val})
+
+        # Override the delay_data variable so your existing code thinks it came from the CSV!
+        if random_delays:
+            delay_data = pd.DataFrame(random_delays)
+        else:
+            delay_data = pd.DataFrame(columns=["Train ID", "Station", "Delay"])
+    # ---------------------------------------------------------------
+
+    delay_lookup = {}
+    if delay_data is not None and not delay_data.empty:
+        for _, row in delay_data.iterrows():
+            if pd.isna(row.iloc[0]): continue
+            tid = str(row.iloc[0])
+            st = str(row.iloc[1])
+            try: val = float(row.iloc[2])
+            except: val = 0.0
+            delay_lookup[(tid, st)] = val
+
+    directions = set(t.direction for t in trains_del)
+    for d in directions:
+        d_trains = [t for t in trains_del if t.direction == d]
+        d_trains.sort(key=lambda x: x.start_time_offset)
+
+        last_departure_time = None
+        for t in d_trains:
+            if not t.schedule: update_train_times(t, infra, base_time)
+
+            origin_s = t.schedule[0]['station']
+            prim_delay_min = delay_lookup.get((t.id, origin_s), 0.0)
+
+            nominal_start = base_time + timedelta(minutes=t.start_time_offset)
+            earliest_start = nominal_start + timedelta(minutes=prim_delay_min)
+
+            if last_departure_time:
+                h_min = infra.get_dynamic_headway(t.speed_kmh)
+                min_safe_start = last_departure_time + h_min
+                actual_start = max(earliest_start, min_safe_start)
+            else:
+                actual_start = earliest_start
+
+            t.schedule[0]['manual_delay'] = actual_start - nominal_start
+
+            for node in t.schedule[1:]:
+                st_name = node['station']
+                d_val = delay_lookup.get((t.id, st_name), 0.0)
+                if d_val > 0:
+                    node['manual_delay'] = timedelta(minutes=d_val)
+
+            update_train_times(t, infra, base_time)
+            last_departure_time = t.schedule[0]['dep']
+
+    # 3. Adjusted (Resolution with Max Buffer)
+    trains_adj = [t.copy() for t in trains_del]
+
+    selected_train_id = None
+    if selected_train_input and selected_train_input != "None":
+        selected_train_id = str(selected_train_input)
+
+    logs = resolve_all_conflicts(trains_adj, infra, base_time, selected_train_id=selected_train_id, max_buffer_min=max_buff)
+
+    # 4. Outputs
+    df_nom_matrix = generate_timetable_matrix(trains_nom, infra)
+    df_adj_matrix = generate_timetable_matrix(trains_adj, infra)
+    df_stats = calculate_delay_stats(trains_nom, trains_adj, delay_data)
+    df_buffer = generate_buffer_report(trains_adj, delay_data)
+    fig = create_filtered_marey(trains_nom, trains_del, trains_adj, infra, plot_view, selected_train_id)
+
+    return df_nom_matrix, df_adj_matrix, df_stats, df_buffer, pd.DataFrame(logs, columns=["Logs"]), fig
+
+def get_train_choices(df):
+    if df is None or df.empty:
+        return gr.update(choices=["None"], value="None", interactive=True)
+
+    choices = ["None"]
+    try:
+        # Check potential ID columns
+        col = None
+        if 'Train ID' in df.columns:
+            col = 'Train ID'
+        elif len(df.columns) > 0:
+            col = df.columns[0]  # Fallback to first column
+
+        if col:
+            valid_ids = df[col].dropna().astype(str).str.strip().tolist()
+            # Keep the list stable and remove duplicates while preserving order.
+            seen = set(choices)
+            for train_id in valid_ids:
+                if train_id and train_id not in seen:
+                    choices.append(train_id)
+                    seen.add(train_id)
+    except Exception:
+        pass
+
+    return gr.update(choices=choices, value="None", interactive=True)
+
+# Helper function to load the trains CSV and refresh the selected-train dropdown at the same time.
+def load_train_csv(file):
+    df = load_csv(file)
+    return df, get_train_choices(df)
+
+# --- PRIMARY DELAY RESPONSIBILITY ---
+# Responsibility for a primary delay (IM vs RU) is decided by a single shared
+# rule - the "IM Responsibility Share" percentage set before running the
+# sweet-spot search - applied identically whether the delay is predefined
+# (from the Delays tab) or randomly generated during the run. This keeps the
+# assumption consistent across delay modes and across every capacity level
+# tested (see simulate_capacity_vs_reliability). If IM is responsible it's a
+# penalty for IM; if RU is responsible it's income for IM (RU pays IM).
+# Secondary delays are untouched - always a cost paid by IM (PR Penalty).
+
+# Add delay_data to the function inputs
+def run_economic_analysis(station_data, fleet_data, delay_data, spacing_input, max_trains, tac_val, pr_val, d_mode, r_prob, r_min, r_max, im_resp_share):
+    import pandas as pd
+    import plotly.graph_objects as go
+
+    try: sp_km = float(spacing_input)
+    except: sp_km = 5.0
+    if station_data is not None:
+        station_data = _normalize_uploaded_dataframe(station_data)
+    if delay_data is not None:
+        delay_data = _normalize_uploaded_dataframe(delay_data)
+    if fleet_data is not None:
+        fleet_data = _normalize_uploaded_dataframe(fleet_data)
+    infra = Infrastructure(station_data, spacing_km=sp_km)
+
+    if fleet_data is None or fleet_data.empty:
+        # We now return 5 empty/error elements
+        return pd.DataFrame([{"Error": "No fleet data defined"}]), go.Figure(), pd.DataFrame(), go.Figure(), pd.DataFrame()
+
+    fleet_data = fleet_data.dropna(how='all')
+    fleet_data.columns = fleet_data.columns.astype(str).str.strip()
+
+    fleet_profiles = []
+    for _, row in fleet_data.iterrows():
+        t_id = str(row.get("Type Name", "Standard")).strip()
+        speed = float(row.get("Speed (km/h)", 100))
+        dwell = float(row.get("Dwell (min)", 2))
+        priority = int(row.get("Priority", 1))
+
+        stops = infra.stations[:]
+        fleet_profiles.append(Train(t_id, "Outbound", priority, stops, 0, speed, dwell))
+
+    # Now unpack 5 variables from the simulation engine!
+    df, fig, best_timetable_df, best_marey_fig, best_delay_df = simulate_capacity_vs_reliability(
+        infra, fleet_profiles, delay_data, max_trains, tac_val, pr_val, d_mode, r_prob, r_min, r_max, im_resp_share
+    )
+
+    return df, fig, best_timetable_df, best_marey_fig, best_delay_df
+
+# CSV loading and normalization helpers
+# ----------------------------------------------------
+# Uploaded files often use slightly different header names, for example
+# "Trian ID", "Speed", or "Start time". The simulator expects canonical
+# internal names, so normalize them immediately when the CSV is loaded.
+def _compact_header(name):
+    import re
+    return re.sub(r"[^a-z0-9]+", "", str(name).strip().lower())
+
+def _normalize_uploaded_dataframe(df):
+    if df is None:
+        return None
+
+    df = df.copy()
+    df = df.dropna(how='all')
+    df.columns = df.columns.astype(str).str.strip()
+
+    compact_cols = [_compact_header(c) for c in df.columns]
+    compact_set = set(compact_cols)
+
+    train_markers = {
+        "trainid", "trianid", "direction", "priority", "speed", "speedkmh",
+        "starttime", "startoffset", "starttimeoffset", "starttimeoffsetmin",
+        "dwell", "dwellmin", "dwellminutes"
+    }
+    station_markers = {"distance", "distancekm", "km", "stationdistance"}
+    delay_markers = {"delay", "delaymin", "delayminutes", "delaymins"}
+
+    if compact_set & train_markers:
+        csv_kind = "trains"
+    elif compact_set & station_markers:
+        csv_kind = "stations"
+    elif compact_set & delay_markers:
+        csv_kind = "delays"
+    else:
+        csv_kind = "unknown"
+
+    base_aliases = {
+        "trainid": "Train ID",
+        "trianid": "Train ID",      # common typo in uploaded files
+        "trainno": "Train ID",
+        "trainnumber": "Train ID",
+        "id": "Train ID" if csv_kind == "trains" else "ID",
+        "direction": "Direction",
+        "dir": "Direction",
+        "priority": "Priority",
+        "speed": "Speed (km/h)",
+        "speedkmh": "Speed (km/h)",
+        "speedkmph": "Speed (km/h)",
+        "start": "Start Time Offset (min)",
+        "starttime": "Start Time Offset (min)",
+        "startoffset": "Start Time Offset (min)",
+        "starttimeoffset": "Start Time Offset (min)",
+        "starttimeoffsetmin": "Start Time Offset (min)",
+        "starttimemin": "Start Time Offset (min)",
+        "startminutes": "Start Time Offset (min)",
+        "dwell": "Dwell (min)",
+        "dwelltime": "Dwell (min)",
+        "dwellmin": "Dwell (min)",
+        "dwellminutes": "Dwell (min)",
+        "delay": "Delay (min)",
+        "delaymin": "Delay (min)",
+        "delaymins": "Delay (min)",
+        "delayminutes": "Delay (min)",
+        "distance": "Distance (km)",
+        "distancekm": "Distance (km)",
+        "km": "Distance (km)",
+        "typename": "Type Name",
+        "type": "Type Name",
+    }
+
+    station_aliases = {
+        "station": "Station Name" if csv_kind == "stations" else "Station",
+        "stationname": "Station Name" if csv_kind == "stations" else "Station",
+        "stationnames": "Station Name" if csv_kind == "stations" else "Station",
+        "stop": "Station",
+        "stops": "Station",
+    }
+
+    rename_map = {}
+    used = set()
+    for original in df.columns:
+        key = _compact_header(original)
+        new_name = station_aliases.get(key, base_aliases.get(key, original.strip()))
+        # Avoid duplicate column names after normalization.
+        if new_name in used:
+            suffix = 2
+            candidate = f"{new_name} {suffix}"
+            while candidate in used:
+                suffix += 1
+                candidate = f"{new_name} {suffix}"
+            new_name = candidate
+        rename_map[original] = new_name
+        used.add(new_name)
+
+    df = df.rename(columns=rename_map)
+
+    # Positional fallbacks for common no/weak-header files.
+    if csv_kind == "trains" and "Train ID" not in df.columns and len(df.columns) >= 6:
+        df.columns = [
+            "Train ID", "Direction", "Priority", "Speed (km/h)",
+            "Start Time Offset (min)", "Dwell (min)"
+        ] + list(df.columns[6:])
+    elif csv_kind == "stations" and "Station Name" not in df.columns and len(df.columns) >= 2:
+        df.columns = ["Station Name", "Distance (km)"] + list(df.columns[2:])
+    elif csv_kind == "delays" and "Train ID" not in df.columns and len(df.columns) >= 3:
+        df.columns = ["Train ID", "Station", "Delay (min)"] + list(df.columns[3:])
+
+    # Reorder known tables so the displayed matrix is consistent.
+    desired_order = []
+    if csv_kind == "trains":
+        desired_order = ["Train ID", "Direction", "Priority", "Speed (km/h)", "Start Time Offset (min)", "Dwell (min)"]
+    elif csv_kind == "stations":
+        desired_order = ["Station Name", "Distance (km)"]
+    elif csv_kind == "delays":
+        desired_order = ["Train ID", "Station", "Delay (min)"]
+
+    if desired_order:
+        ordered = [c for c in desired_order if c in df.columns]
+        extras = [c for c in df.columns if c not in ordered]
+        df = df[ordered + extras]
+
+    return df.reset_index(drop=True)
+
+# Helper function to load CSV
+def load_csv(file):
+    if file is None:
+        return None
+
+    file_path = getattr(file, "name", file)
+    suffix = str(file_path).lower().rsplit(".", 1)[-1] if "." in str(file_path) else ""
+
+    try:
+        if suffix in {"xlsx", "xls"}:
+            # .xlsx uses openpyxl in normal pandas installations; .xls uses xlrd when available.
+            df = pd.read_excel(file_path)
+        else:
+            # sep=None lets pandas detect comma/semicolon/tab-delimited CSVs.
+            df = pd.read_csv(file_path, sep=None, engine="python")
+        return _normalize_uploaded_dataframe(df)
+    except Exception:
+        try:
+            if suffix in {"xlsx", "xls"}:
+                df = pd.read_excel(file_path)
+            else:
+                df = pd.read_csv(file_path)
+            return _normalize_uploaded_dataframe(df)
+        except Exception:
+            return None
+
+d_stations = pd.DataFrame({'Station Name': ['A', 'B', 'C', 'D', 'E'], 'Distance (km)': [0, 15, 35, 45, 60]})
+d_trains = pd.DataFrame({
+    'Train ID': [101, 102],
+    'Direction': ['Outbound', 'Outbound'],
+    'Priority': [3, 2],
+    'Speed (km/h)': [60, 120],
+    'Start Time Offset (min)': [0, 5],
+    'Dwell (min)': [2, 2]
+})
+d_delays = pd.DataFrame({'Train ID': [101], 'Station': ['B'], 'Delay (min)': [10]})
+
+
+CUSTOM_CSS = """
+:root {
+    --ly-bg: #f7f8fc;
+    --ly-surface: #ffffff;
+    --ly-surface-soft: #fbfaff;
+    --ly-surface-tint: #f5f1ff;
+    --ly-border: #e9eaf2;
+    --ly-border-strong: #dcdfea;
+    --ly-text: #202431;
+    --ly-text-2: #5f6677;
+    --ly-muted: #9299aa;
+    --ly-primary: #7c5cff;
+    --ly-primary-2: #4c8dff;
+    --ly-primary-soft: #f1edff;
+    --ly-cyan-soft: #edf7ff;
+    --ly-success: #46b99a;
+    --ly-danger: #ee7486;
+    --ly-warning: #f2b84b;
+    --ly-radius: 16px;
+    --ly-radius-sm: 11px;
+    --ly-shadow: 0 10px 30px rgba(70, 61, 110, 0.065);
+    --matrix-cycle: 1200ms;
+    --matrix-base: #d8d5e6;
+    --matrix-active: #7c5cff;
+    --matrix-ease: ease-in-out;
+}
+
+html, body {
+    min-height: 100%;
+    background: var(--ly-bg) !important;
+}
+
+body, .gradio-container {
+    font-family: Inter, ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif !important;
+}
+
+.gradio-container {
+    max-width: 1480px !important;
+    margin: 0 auto !important;
+    padding: 0 24px 34px !important;
+    color: var(--ly-text) !important;
+    background:
+        radial-gradient(circle at 10% -8%, rgba(124, 92, 255, .07), transparent 24rem),
+        radial-gradient(circle at 88% -6%, rgba(76, 141, 255, .07), transparent 26rem),
+        var(--ly-bg) !important;
+    overflow: visible !important;
+}
+
+.gradio-container h1,
+.gradio-container h2,
+.gradio-container h3,
+.gradio-container h4,
+.gradio-container label,
+.gradio-container .label-wrap {
+    color: var(--ly-text) !important;
+}
+.gradio-container p,
+.gradio-container .prose,
+.gradio-container .markdown,
+.gradio-container .gr-markdown {
+    color: var(--ly-text-2) !important;
+}
+
+/* Lynote-inspired top navigation and soft introduction band. */
+.app-topbar {
+    position: sticky;
+    top: 0;
+    z-index: 80;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 18px;
+    margin: 0 -24px;
+    padding: 13px 24px;
+    background: rgba(255,255,255,.92);
+    border-bottom: 1px solid rgba(229,231,240,.92);
+    backdrop-filter: blur(14px);
+    -webkit-backdrop-filter: blur(14px);
+}
+.app-brand {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    min-width: 0;
+}
+.app-mark {
+    display: grid;
+    place-items: center;
+    width: 34px;
+    height: 34px;
+    flex: 0 0 34px;
+    border-radius: 10px;
+    color: #fff !important;
+    background: linear-gradient(145deg, var(--ly-primary), var(--ly-primary-2));
+    font-size: 16px;
+    font-weight: 800;
+    box-shadow: 0 7px 16px rgba(124,92,255,.18);
+}
+.app-title {
+    color: var(--ly-text) !important;
+    font-size: 16px;
+    line-height: 1.2;
+    font-weight: 760;
+    letter-spacing: -0.02em;
+}
+.app-badge {
+    flex: 0 0 auto;
+    padding: 6px 10px;
+    border-radius: 999px;
+    color: #6750d8 !important;
+    background: var(--ly-primary-soft);
+    border: 1px solid #e5ddff;
+    font-size: 11.5px;
+    font-weight: 700;
+}
+.workspace-hero {
+    position: relative;
+    overflow: hidden;
+    margin: 24px 0 22px;
+    padding: 28px 30px;
+    border: 1px solid #ebe8f7;
+    border-radius: 20px;
+    background:
+        radial-gradient(circle at 12% 20%, rgba(180,151,255,.20), transparent 19rem),
+        radial-gradient(circle at 85% 25%, rgba(125,197,255,.20), transparent 21rem),
+        linear-gradient(120deg, #fbf8ff 0%, #f5f7ff 48%, #f2faff 100%);
+}
+.workspace-hero::after {
+    content: "";
+    position: absolute;
+    width: 260px;
+    height: 260px;
+    right: -100px;
+    bottom: -170px;
+    border-radius: 50%;
+    background: rgba(124,92,255,.06);
+    pointer-events: none;
+}
+.workspace-kicker {
+    position: relative;
+    z-index: 1;
+    display: inline-flex;
+    margin-bottom: 8px;
+    padding: 5px 9px;
+    border: 1px solid #e3dcff;
+    border-radius: 999px;
+    color: #6f55d9 !important;
+    background: rgba(255,255,255,.62);
+    font-size: 11px;
+    font-weight: 750;
+}
+.workspace-title {
+    position: relative;
+    z-index: 1;
+    margin: 0;
+    max-width: 860px;
+    color: #232431 !important;
+    font-size: clamp(28px, 3.2vw, 42px);
+    line-height: 1.08;
+    letter-spacing: -0.035em;
+    font-weight: 780;
+}
+.workspace-subtitle {
+    position: relative;
+    z-index: 1;
+    max-width: 850px;
+    margin-top: 10px;
+    color: #687083 !important;
+    font-size: 14px;
+    line-height: 1.6;
+}
+
+/* Page headings */
+.gradio-container h2 {
+    margin: 2px 0 6px !important;
+    font-size: 21px !important;
+    line-height: 1.3 !important;
+    font-weight: 740 !important;
+    letter-spacing: -0.025em !important;
+}
+.gradio-container h2 + p {
+    margin-top: 0 !important;
+    margin-bottom: 18px !important;
+    color: var(--ly-muted) !important;
+    font-size: 13.5px !important;
+}
+.panel-card h3,
+.chart-card h3,
+.results-card h3 {
+    margin: 0 0 13px !important;
+    color: var(--ly-text) !important;
+    font-size: 15px !important;
+    line-height: 1.35 !important;
+    font-weight: 720 !important;
+    letter-spacing: -0.012em !important;
+}
+
+/* White Lynote-style workspace cards. */
+.panel-card,
+.chart-card,
+.results-card {
+    position: relative !important;
+    overflow: visible !important;
+    margin-bottom: 14px !important;
+    padding: 18px !important;
+    border: 1px solid var(--ly-border) !important;
+    border-radius: var(--ly-radius) !important;
+    background: var(--ly-surface) !important;
+    box-shadow: var(--ly-shadow) !important;
+    transition: border-color 160ms ease, box-shadow 160ms ease, transform 160ms ease !important;
+}
+.panel-card:hover,
+.results-card:hover {
+    border-color: #dedbea !important;
+    box-shadow: 0 12px 34px rgba(70,61,110,.085) !important;
+}
+.chart-card {
+    min-height: 650px;
+}
+
+/* Remove nested Gradio visual noise while keeping white workspace surfaces. */
+.gradio-container .block,
+.gradio-container .form,
+.gradio-container .panel,
+.gradio-container .gr-box,
+.gradio-container .contain,
+.gradio-container .wrap {
+    border-radius: var(--ly-radius-sm) !important;
+    box-shadow: none !important;
+    overflow: visible !important;
+}
+.panel-card .block,
+.panel-card .form,
+.panel-card .gr-box,
+.panel-card .contain,
+.panel-card .wrap,
+.chart-card .block,
+.chart-card .form,
+.chart-card .gr-box,
+.chart-card .contain,
+.chart-card .wrap,
+.results-card .block,
+.results-card .form,
+.results-card .gr-box,
+.results-card .contain,
+.results-card .wrap {
+    background: transparent !important;
+    border-color: transparent !important;
+}
+
+/* Form controls */
+.gradio-container input,
+.gradio-container textarea,
+.gradio-container select {
+    min-height: 40px !important;
+    color: var(--ly-text) !important;
+    background: #fcfcfe !important;
+    border: 1px solid var(--ly-border-strong) !important;
+    border-radius: 10px !important;
+    box-shadow: none !important;
+    transition: border-color 150ms ease, box-shadow 150ms ease, background-color 150ms ease !important;
+}
+.gradio-container input:hover,
+.gradio-container textarea:hover,
+.gradio-container select:hover {
+    border-color: #cfc7f4 !important;
+}
+.gradio-container input:focus,
+.gradio-container textarea:focus,
+.gradio-container select:focus,
+.gradio-container input:focus-visible,
+.gradio-container textarea:focus-visible,
+.gradio-container select:focus-visible {
+    border-color: var(--ly-primary) !important;
+    box-shadow: 0 0 0 3px rgba(124,92,255,.10) !important;
+    outline: none !important;
+    background: #fff !important;
+}
+.gradio-container input[type="radio"],
+.gradio-container input[type="checkbox"],
+.gradio-container input[type="range"] {
+    accent-color: var(--ly-primary) !important;
+}
+.gradio-container label,
+.gradio-container .label-wrap {
+    font-weight: 630 !important;
+}
+
+/* Dropdown stability */
+.selector-strip,
+#view_listbox,
+#train_listbox,
+.hort-view-select,
+.hort-train-select {
+    overflow: visible !important;
+    filter: none !important;
+    transform: none !important;
+    backdrop-filter: none !important;
+    -webkit-backdrop-filter: none !important;
+}
+.selector-strip { z-index: 20 !important; }
+#view_listbox, #train_listbox { position: relative !important; z-index: 30 !important; }
+.hort-listbox label,
+.hort-listbox .label-wrap {
+    color: var(--ly-text-2) !important;
+    font-weight: 650 !important;
+}
+
+/* Radio groups as calm option cards. */
+.gradio-container fieldset {
+    padding: 6px !important;
+    background: #fafafe !important;
+    border: 1px solid var(--ly-border) !important;
+    border-radius: 12px !important;
+}
+.hort-radio label {
+    display: flex !important;
+    align-items: center !important;
+    gap: 8px !important;
+    margin: 3px 0 !important;
+    padding: 9px 10px !important;
+    border: 1px solid transparent !important;
+    border-radius: 9px !important;
+    color: var(--ly-text-2) !important;
+    background: transparent !important;
+    transition: background-color 140ms ease, color 140ms ease, border-color 140ms ease !important;
+}
+.hort-radio label:hover {
+    color: var(--ly-text) !important;
+    background: #f6f4ff !important;
+}
+.hort-radio label:has(input[type="radio"]:checked),
+.hort-radio label[aria-checked="true"],
+.hort-radio .selected {
+    color: #654bd0 !important;
+    background: var(--ly-primary-soft) !important;
+    border-color: #ded5ff !important;
+    box-shadow: none !important;
+    font-weight: 700 !important;
+}
+
+/* Compact horizontal uploader with Lynote's pale violet treatment. */
+.input-file-example {
+    width: 100% !important;
+    margin: 0 0 13px !important;
+    padding: 9px 10px !important;
+    display: flex !important;
+    flex-flow: row nowrap !important;
+    align-items: center !important;
+    gap: 10px !important;
+    background: #fbfaff !important;
+    border: 1px dashed #dcd3ff !important;
+    border-radius: 12px !important;
+    box-shadow: none !important;
+}
+.input-file-example > * { margin: 0 !important; }
+.input-file-example .input-file-label-wrap {
+    flex: 0 0 auto !important;
+    width: auto !important;
+    min-width: max-content !important;
+}
+.input-file-example .input-file-control {
+    flex: 0 1 210px !important;
+    width: 210px !important;
+    min-width: 170px !important;
+    max-width: 230px !important;
+}
+.input-file-example .input-file-help-wrap {
+    flex: 1 1 180px !important;
+    min-width: 140px !important;
+}
+.input-file-example .input-file-label {
+    margin: 0 !important;
+    color: #4d5363 !important;
+    font-size: 12px !important;
+    line-height: 1.2 !important;
+    font-weight: 700 !important;
+    white-space: nowrap !important;
+}
+.input-file-control,
+.input-file-control > div,
+.input-file-control .wrap,
+.input-file-control .block,
+.input-file-control .container {
+    margin: 0 !important;
+    padding: 0 !important;
+    width: 100% !important;
+    min-width: 0 !important;
+    background: transparent !important;
+    border: 0 !important;
+    box-shadow: none !important;
+}
+.input-file-control button[aria-label*="upload" i],
+.input-file-control button[aria-label*="drop" i],
+.input-file-control .file,
+.input-file-control .file-preview,
+.input-file-control [class*="file-preview"] {
+    width: 100% !important;
+    height: 36px !important;
+    min-height: 36px !important;
+    max-height: 36px !important;
+    padding: 0 11px !important;
+    display: flex !important;
+    align-items: center !important;
+    justify-content: flex-start !important;
+    overflow: hidden !important;
+    color: #5d6473 !important;
+    background: #ffffff !important;
+    border: 1px solid #cfc3ff !important;
+    border-radius: 9px !important;
+    box-shadow: 0 2px 6px rgba(124,92,255,.045) !important;
+    cursor: pointer !important;
+    transition: border-color 140ms ease, box-shadow 140ms ease, background-color 140ms ease !important;
+}
+.input-file-control button[aria-label*="upload" i]:hover,
+.input-file-control button[aria-label*="drop" i]:hover {
+    border-color: var(--ly-primary) !important;
+    background: #fdfcff !important;
+    box-shadow: 0 0 0 3px rgba(124,92,255,.07) !important;
+}
+.input-file-control button[aria-label*="upload" i] > *,
+.input-file-control button[aria-label*="drop" i] > *,
+.input-file-control .file svg,
+.input-file-control .file-preview svg {
+    display: none !important;
+}
+.input-file-control button[aria-label*="upload" i]::before,
+.input-file-control button[aria-label*="drop" i]::before {
+    content: "Browse file";
+    color: #6c52d9 !important;
+    font-size: 12px !important;
+    font-weight: 700 !important;
+    white-space: nowrap;
+}
+.input-file-control .file-name,
+.input-file-control [class*="file-name"] {
+    min-width: 0 !important;
+    overflow: hidden !important;
+    text-overflow: ellipsis !important;
+    white-space: nowrap !important;
+    color: var(--ly-text-2) !important;
+    font-size: 12px !important;
+}
+.input-file-example .input-file-help {
+    margin: 0 !important;
+    color: var(--ly-muted) !important;
+    font-size: 10.5px !important;
+    line-height: 1.3 !important;
+    font-weight: 400 !important;
+}
+
+/* Actions */
+.gradio-container button {
+    border-radius: 10px !important;
+    font-weight: 700 !important;
+    transition: background-color 140ms ease, border-color 140ms ease, box-shadow 140ms ease !important;
+}
+.gradio-container button.primary {
+    min-height: 42px !important;
+    color: #ffffff !important;
+    background: linear-gradient(135deg, var(--ly-primary), #6f68f6) !important;
+    border: 1px solid var(--ly-primary) !important;
+    box-shadow: 0 7px 16px rgba(124,92,255,.17) !important;
+}
+.gradio-container button.primary:hover {
+    background: linear-gradient(135deg, #6f50f0, #5e7bf2) !important;
+    border-color: #6f50f0 !important;
+    box-shadow: 0 9px 20px rgba(124,92,255,.20) !important;
+}
+.gradio-container button.secondary {
+    color: var(--ly-text-2) !important;
+    background: #fff !important;
+    border-color: var(--ly-border) !important;
+}
+
+/* Main tabs resemble Lynote's flat source tabs. */
+.hort-main-tabs > .tab-nav,
+.gradio-container .hort-main-tabs .tab-nav {
+    display: flex !important;
+    width: 100% !important;
+    max-width: 100% !important;
+    gap: 24px !important;
+    margin-bottom: 20px !important;
+    padding: 0 2px !important;
+    overflow: auto hidden !important;
+    background: transparent !important;
+    border: 0 !important;
+    border-bottom: 1px solid var(--ly-border) !important;
+    border-radius: 0 !important;
+}
+.gradio-container .tab-nav button {
+    position: relative !important;
+    min-height: 42px !important;
+    padding: 8px 2px 11px !important;
+    color: var(--ly-muted) !important;
+    background: transparent !important;
+    border: 0 !important;
+    border-radius: 0 !important;
+    box-shadow: none !important;
+    font-size: 13px !important;
+    font-weight: 650 !important;
+    white-space: nowrap !important;
+}
+.gradio-container .tab-nav button:hover {
+    color: #5e4bc3 !important;
+    background: transparent !important;
+}
+.gradio-container .tab-nav button.selected,
+.gradio-container .tab-nav button[aria-selected="true"] {
+    color: #5f48cb !important;
+    background: transparent !important;
+    font-weight: 750 !important;
+}
+.gradio-container .tab-nav button.selected::after,
+.gradio-container .tab-nav button[aria-selected="true"]::after {
+    content: "";
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: -1px;
+    height: 2px;
+    border-radius: 999px 999px 0 0;
+    background: var(--ly-primary);
+}
+
+/* Result tabs inside cards stay compact. */
+.results-card .tab-nav {
+    gap: 14px !important;
+    margin: 0 0 12px !important;
+    border-bottom: 1px solid var(--ly-border) !important;
+}
+.results-card .tab-nav button {
+    min-height: 36px !important;
+    padding: 6px 1px 9px !important;
+    font-size: 12px !important;
+}
+
+/* Dataframes */
+.gradio-container .table-wrap,
+.gradio-container [class*="dataframe"] {
+    border-radius: 11px !important;
+}
+.gradio-container table {
+    color: var(--ly-text-2) !important;
+    background: #ffffff !important;
+    border-color: var(--ly-border) !important;
+}
+.gradio-container table th {
+    color: #5b6272 !important;
+    background: #f8f8fb !important;
+    border-color: var(--ly-border) !important;
+    font-weight: 700 !important;
+}
+.gradio-container table td {
+    background: #ffffff !important;
+    border-color: #eef0f4 !important;
+}
+.gradio-container table tbody tr:hover td {
+    background: #faf9ff !important;
+}
+.gradio-container [role="grid"],
+.gradio-container [role="gridcell"],
+.gradio-container [role="columnheader"] {
+    border-color: var(--ly-border) !important;
+}
+
+/* Plot shells */
+.plot-container,
+.js-plotly-plot,
+.plotly,
+.gr-plot {
+    overflow: hidden !important;
+    border-radius: 12px !important;
+}
+.chart-card .gr-plot,
+.chart-card .plot-container,
+.chart-card .js-plotly-plot,
+.chart-card .plotly,
+.results-card .gr-plot,
+.results-card .plot-container,
+.results-card .js-plotly-plot,
+.results-card .plotly {
+    background: #ffffff !important;
+}
+
+/* Matrix loader retained, recoloured for Lynote. */
+.t-matrix {
+    display: grid;
+    grid-template-columns: repeat(4, 2px);
+    grid-auto-rows: 2px;
+    gap: 2px;
+    width: max-content;
+    height: max-content;
+}
+.t-matrix i {
+    display: block;
+    width: 2px;
+    height: 2px;
+    margin: 0;
+    padding: 0;
+    border: 0;
+    border-radius: 0;
+    background: var(--matrix-base);
+    animation: t-matrix-pulse var(--matrix-cycle) var(--matrix-ease) infinite;
+    animation-delay: calc(var(--d, 0) * 1ms);
+}
+.t-matrix i.is-gap { visibility: hidden; animation: none; }
+@keyframes t-matrix-pulse {
+    0%, 45%, 100% { background-color: var(--matrix-base); }
+    15% { background-color: var(--matrix-active); }
+}
+.gradio-container [data-testid="status-tracker"].matrix-loading {
+    display: flex !important;
+    align-items: center !important;
+    justify-content: center !important;
+    background: transparent !important;
+    border: 0 !important;
+    box-shadow: none !important;
+    animation: none !important;
+    opacity: 1 !important;
+}
+.gradio-container [data-testid="status-tracker"].matrix-loading > :not(.t-matrix) { display: none !important; }
+.gradio-container [data-testid="status-tracker"].matrix-loading > .t-matrix { display: grid !important; }
+.gradio-container .matrix-spinner-host {
+    display: inline-grid !important;
+    place-items: center !important;
+    width: 14px !important;
+    height: 14px !important;
+    min-width: 14px !important;
+    min-height: 14px !important;
+    padding: 0 !important;
+    border: 0 !important;
+    background: transparent !important;
+    box-shadow: none !important;
+    animation: none !important;
+}
+.gradio-container .matrix-spinner-host > :not(.t-matrix) { display: none !important; }
+.gradio-container .matrix-spinner-host > .t-matrix { display: grid !important; }
+
+.footer-note {
+    margin: 20px 0 4px !important;
+    text-align: center;
+    color: #a1a7b5 !important;
+    font-size: 11px;
+}
+footer { display: none !important; }
+
+/* Dropdown overlays and scrollbars */
+.panel-card *, .results-card *, .chart-card * { scroll-margin-top: 0; }
+.gradio-container * {
+    scrollbar-width: thin;
+    scrollbar-color: #d8dbe5 transparent;
+}
+.gradio-container *::-webkit-scrollbar { width: 8px; height: 8px; }
+.gradio-container *::-webkit-scrollbar-thumb { background: #d8dbe5; border-radius: 999px; }
+.gradio-container *::-webkit-scrollbar-track { background: transparent; }
+
+@media (max-width: 1120px) {
+    .input-file-example { flex-wrap: wrap !important; }
+    .input-file-example .input-file-help-wrap {
+        flex: 1 0 100% !important;
+        padding-left: 0 !important;
+    }
+}
+@media (max-width: 760px) {
+    .gradio-container { padding: 0 12px 24px !important; }
+    .app-topbar { margin: 0 -12px; padding: 12px; }
+    .app-badge { display: none; }
+    .workspace-hero { margin-top: 16px; padding: 22px 18px; border-radius: 16px; }
+    .workspace-title { font-size: 28px; }
+    .panel-card, .chart-card, .results-card { padding: 14px !important; border-radius: 13px !important; }
+    .chart-card { min-height: 520px; }
+    .hort-main-tabs > .tab-nav,
+    .gradio-container .hort-main-tabs .tab-nav {
+        gap: 17px !important;
+    }
+}
+@media (prefers-reduced-motion: reduce) {
+    .t-matrix i { animation: none !important; }
+    * { scroll-behavior: auto !important; transition-duration: 0.01ms !important; }
+}
 """
 
-import tempfile
+# Gradio DOM adapter for the requested 4x4 matrix loading animation.
+MATRIX_LOADER_JS = r"""
+() => {
+    const MATRIX_CLASS = "t-matrix";
+
+    function buildMatrix(host) {
+        if (!host || host.querySelector(":scope > ." + MATRIX_CLASS)) return;
+        const matrix = document.createElement("div");
+        matrix.className = MATRIX_CLASS;
+        matrix.dataset.variant = "scan";
+        matrix.setAttribute("aria-hidden", "true");
+        for (let index = 0; index < 16; index++) {
+            const dot = document.createElement("i");
+            dot.style.setProperty("--d", String((index % 4) * 120));
+            matrix.appendChild(dot);
+        }
+        host.appendChild(matrix);
+    }
+
+    function syncStatusTrackers(root = document) {
+        const trackers = root.querySelectorAll ? root.querySelectorAll('[data-testid="status-tracker"]') : [];
+        trackers.forEach((tracker) => {
+            const active = Boolean(tracker.querySelector(".loading") || tracker.classList.contains("generating"));
+            if (active) {
+                tracker.classList.add("matrix-loading");
+                buildMatrix(tracker);
+            } else {
+                tracker.classList.remove("matrix-loading");
+                const matrix = tracker.querySelector(":scope > ." + MATRIX_CLASS);
+                if (matrix) matrix.remove();
+            }
+        });
+    }
+
+    function syncStandaloneSpinners(root = document) {
+        if (!root.querySelectorAll) return;
+        root.querySelectorAll('.loading-spinner, .spinner:not(.spinner-button)').forEach((spinner) => {
+            if (spinner.closest("." + MATRIX_CLASS)) return;
+            spinner.classList.add("matrix-spinner-host");
+            buildMatrix(spinner);
+        });
+    }
+
+    function syncAll() {
+        syncStatusTrackers(document);
+        syncStandaloneSpinners(document);
+    }
+
+    syncAll();
+    if (window.__railDelayMatrixLoaderObserver) {
+        try { window.__railDelayMatrixLoaderObserver.disconnect(); } catch (_) {}
+    }
+    const observer = new MutationObserver(syncAll);
+    observer.observe(document.body, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: ["class", "data-testid"]
+    });
+    window.__railDelayMatrixLoaderObserver = observer;
+    return [];
+}
+"""
 
-import gradio as gr
 
-from lynote_notes import Workspace
-
-MAX_CHARS = 5_000
-UTM = (
-    "https://lynote.ai/ai-notes?utm_source=huggingface"
-    "&utm_medium=space&utm_campaign=hf_launch&utm_content=oss_notes"
-)
-
-
-def _workspace(text: str) -> Workspace:
-    ws = Workspace(tempfile.mkdtemp())
-    ws.add_text(text, "Pasted text")
-    return ws
-
-
-def make_note(text: str, title: str):
-    text = (text or "").strip()
-    if len(text) < 80:
-        return "Add at least 80 characters of source text."
-    if len(text) > MAX_CHARS:
-        return f"Input is limited to {MAX_CHARS:,} characters in this demo."
-    ws = _workspace(text)
-    note = ws.make_note(title or "Your note")
-    return ws.export_note(note, "md")
-
-
-def ask_question(text: str, question: str):
-    text = (text or "").strip()
-    question = (question or "").strip()
-    if not text or not question:
-        return "Paste some source text and ask a question."
-    ws = _workspace(text)
-    answer = ws.ask(question)
-    lines = [answer.text, ""]
-    for index, citation in enumerate(answer.citations, start=1):
-        lines.append(f"[{index}] {citation.source_title} · {citation.locator} — {citation.snippet}")
-    lines.append("")
-    lines.append(f"Try the full product: {UTM}")
-    return "\n".join(lines)
-
-
-with gr.Blocks(title="AI Notes — Source-Grounded AI Note Taker") as demo:
-    gr.Markdown(
-        "# 📝 AI Notes\n"
-        "Source-grounded notes with citations — every bullet links back to the exact "
-        "source chunk. Open source: [github.com/lynote-ai/lynote-notes]"
-        "(https://github.com/lynote-ai/lynote-notes)"
+try:
+    HORT_THEME = gr.themes.Soft(
+        primary_hue="violet",
+        secondary_hue="blue",
+        neutral_hue="slate",
+        radius_size="md",
+        spacing_size="md",
     )
-    source = gr.Textbox(
-        label="Source text (80–5,000 characters)",
-        placeholder="Paste a lecture transcript, article, or meeting notes…",
-        lines=10,
+except Exception:
+    HORT_THEME = None
+
+def make_exact_file_input():
+    """Render label, file picker, and helper text on one horizontal line."""
+    with gr.Row(elem_classes=["input-file-example"]):
+        gr.HTML(
+            '<label class="input-file-label">Upload a file</label>',
+            elem_classes=["input-file-label-wrap"]
+        )
+        file_component = gr.File(
+            label="Upload a file",
+            show_label=False,
+            file_types=[".csv", ".xlsx", ".xls"],
+            height=36,
+            elem_classes=["input-file-control"]
+        )
+        gr.HTML(
+            '<p class="input-file-help">You are only allowed to upload .CSV, .XLSX or .XLS files.</p>',
+            elem_classes=["input-file-help-wrap"]
+        )
+    return file_component
+
+
+with gr.Blocks(title="Rail Delay Lab", theme=HORT_THEME, css=CUSTOM_CSS) as demo:
+    gr.HTML("""
+    <header class="app-topbar">
+        <div class="app-brand">
+            <div class="app-mark">R</div>
+            <div class="app-title">Rail Delay Lab</div>
+        </div>
+        <div class="app-badge">Interactive railway simulator</div>
+    </header>
+    <section class="workspace-hero">
+        <div class="workspace-kicker">Railway capacity workspace</div>
+        <div class="workspace-title">Plan, simulate and understand railway delay propagation.</div>
+        <div class="workspace-subtitle">Configure infrastructure, train requests and delay scenarios, then inspect conflict resolution, space-time behaviour and the capacity–reliability trade-off in one clean workspace.</div>
+    </section>
+    """)
+
+    with gr.Tabs(elem_classes=["hort-main-tabs"]):
+        with gr.TabItem("Delay Propagation and Conflict Resolution"):
+            gr.Markdown("## Delay Propagation and Conflict Resolution")
+            gr.Markdown("Upload or edit the input tables, configure the scenario, then run the simulation.")
+
+            with gr.Row():
+                with gr.Column(scale=5):
+                    with gr.Group(elem_classes=["panel-card"]):
+                        gr.Markdown("### Infrastructure")
+                        file_infra = make_exact_file_input()
+                        t_stations = gr.Dataframe(value=d_stations, label="Stations Data", interactive=True, max_height=560, wrap=True, show_row_numbers=True, buttons=[])
+                        file_infra.upload(fn=load_csv, inputs=file_infra, outputs=t_stations)
+                        txt_spacing = gr.Number(value=5.0, label="Min Safety Spacing (km)", step=0.1)
+
+                    with gr.Group(elem_classes=["panel-card"]):
+                        gr.Markdown("### Delay injection")
+                        file_delays = make_exact_file_input()
+                        t_delays = gr.Dataframe(value=d_delays, label="Delay Data", interactive=True, max_height=520, wrap=True, show_row_numbers=True, buttons=[])
+                        file_delays.upload(fn=load_csv, inputs=file_delays, outputs=t_delays)
+
+                        main_delay_mode = gr.Radio(
+                            choices=["Use Uploaded/Inserted Delay", "Randomized (Monte Carlo)"],
+                            value="Use Uploaded/Inserted Delay",
+                            label="Simulation Delay Mode",
+                            elem_classes=["hort-radio"]
+                        )
+                        with gr.Row():
+                            main_rand_prob = gr.Slider(0, 100, value=25, step=5, label="Delay Probability (%)")
+                            main_min_delay = gr.Number(value=5, label="Min Delay (min)")
+                            main_max_delay = gr.Number(value=15, label="Max Delay (min)")
+
+                    with gr.Group(elem_classes=["panel-card"]):
+                        gr.Markdown("### View & optimization")
+                        with gr.Row(elem_classes=["selector-strip"]):
+                            dd_view = gr.Dropdown(
+                                choices=["All Scenarios", "Nominal Only", "Conflicted Only", "Resolved Only"],
+                                value="All Scenarios",
+                                label="Select View",
+                                interactive=True,
+                                filterable=False,
+                                allow_custom_value=False,
+                                elem_id="view_listbox",
+                                elem_classes=["hort-listbox", "hort-view-select"]
+                            )
+                            dd_selected_train = gr.Dropdown(
+                                choices=["None", "101", "102"],
+                                value="None",
+                                label="Select Train",
+                                interactive=True,
+                                filterable=False,
+                                allow_custom_value=False,
+                                elem_id="train_listbox",
+                                elem_classes=["hort-listbox", "hort-train-select"]
+                            )
+                        txt_max_buffer = gr.Number(value=15.0, label="Max Buffer Cap (min)", step=1.0)
+
+                with gr.Column(scale=7):
+                    with gr.Group(elem_classes=["panel-card"]):
+                        gr.Markdown("### Train requests")
+                        file_trains = make_exact_file_input()
+                        t_trains = gr.Dataframe(value=d_trains, label="Train Requests Data", interactive=True, max_height=680, wrap=True, show_row_numbers=True, buttons=[])
+                        file_trains.upload(fn=load_train_csv, inputs=file_trains, outputs=[t_trains, dd_selected_train])
+                        btn = gr.Button("Simulate", variant="primary", size="lg")
+
+                    with gr.Group(elem_classes=["chart-card"]):
+                        gr.Markdown("### Operational space-time diagram")
+                        plot = gr.Plot(label="Marey Diagram")
+
+            with gr.Group(elem_classes=["results-card"]):
+                gr.Markdown("### Results")
+                with gr.Tabs():
+                    with gr.TabItem("Resolved Timetable"):
+                        out_adj = gr.Dataframe(max_height=620, wrap=True, show_row_numbers=True, buttons=[])
+                    with gr.TabItem("Nominal Timetable"):
+                        out_nom = gr.Dataframe(max_height=620, wrap=True, show_row_numbers=True, buttons=[])
+                    with gr.TabItem("Delay Breakdown"):
+                        out_stats = gr.Dataframe(max_height=460, wrap=True, show_row_numbers=True, buttons=[])
+                    with gr.TabItem("Buffer Report"):
+                        out_buffer = gr.Dataframe(max_height=460, wrap=True, show_row_numbers=True, buttons=[])
+                    with gr.TabItem("Conflict Logs"):
+                        out_logs = gr.Dataframe(max_height=460, wrap=True, show_row_numbers=True, buttons=[])
+
+        with gr.TabItem("Economic Capacity Analysis"):
+            gr.Markdown("## Economic Capacity Analysis")
+            gr.Markdown("Evaluate capacity, secondary delay, TAC revenue, penalties, and the operating sweet spot.")
+
+            with gr.Row():
+                with gr.Column(scale=5):
+                    with gr.Group(elem_classes=["panel-card"]):
+                        gr.Markdown("### Infrastructure & delays")
+                        econ_file_infra = make_exact_file_input()
+                        econ_t_stations = gr.Dataframe(value=d_stations, label="Stations Data", interactive=True, max_height=560, wrap=True, show_row_numbers=True, buttons=[])
+                        econ_file_infra.upload(fn=load_csv, inputs=econ_file_infra, outputs=econ_t_stations)
+                        econ_txt_spacing = gr.Number(value=5.0, label="Min Safety Spacing (km)", step=0.1)
+
+                        econ_file_delays = make_exact_file_input()
+                        econ_t_delays = gr.Dataframe(value=d_delays, label="Delay Data", interactive=True, max_height=520, wrap=True, show_row_numbers=True, buttons=[])
+                        econ_file_delays.upload(fn=load_csv, inputs=econ_file_delays, outputs=econ_t_delays)
+
+                    with gr.Group(elem_classes=["panel-card"]):
+                        gr.Markdown("### Delay strategy")
+                        delay_mode = gr.Radio(
+                            choices=["Predefined (from Delays Tab)", "Randomized"],
+                            value="Predefined (from Delays Tab)",
+                            label="Delay Mode",
+                            elem_classes=["hort-radio"]
+                        )
+                        with gr.Row():
+                            rand_prob = gr.Slider(0, 100, value=25, step=5, label="Probability of Delay per Train (%)")
+                            min_delay = gr.Number(value=5, label="Min Random Delay (min)")
+                            max_delay = gr.Number(value=15, label="Max Random Delay (min)")
+
+                    with gr.Group(elem_classes=["panel-card"]):
+                        gr.Markdown("### Delay responsibility")
+                        gr.Markdown("_Sets, **before** the sweet-spot search runs, what share of every primary delay is attributed to the Infrastructure Manager (IM) vs the Railway Undertaking (RU) - applied the same way whether the delay is Predefined or Randomized above. IM-caused delays are a penalty for IM; RU-caused delays are income for IM. Secondary delays always stay a cost for IM (PR Penalty)._")
+                        im_resp_share = gr.Slider(0, 100, value=50, step=5, label="IM Responsibility Share for Primary Delays (%)")
+
+                with gr.Column(scale=7):
+                    with gr.Group(elem_classes=["panel-card"]):
+                        gr.Markdown("### Fleet mix")
+                        t_fleet = gr.Dataframe(
+                            headers=["Type Name", "Speed (km/h)", "Dwell (min)", "Priority"],
+                            value=[["High-Speed", 130, 2, 1], ["Regional", 100, 4, 2], ["Freight", 80, 5, 3]],
+                            interactive=True,
+                            label="Fleet Composition",
+                            max_height=420,
+                            wrap=True,
+                            show_row_numbers=True,
+                            buttons=[]
+                        )
+
+                    with gr.Group(elem_classes=["panel-card"]):
+                        gr.Markdown("### Economic parameters")
+                        with gr.Row():
+                            max_trains_in = gr.Number(value=25, label="Max Trains to Evaluate")
+                            num_tac = gr.Number(value=115.84, label="TAC Fee (€ per train)")
+                            num_pr = gr.Number(value=7.09, label="PR Penalty (€ per min)")
+                        btn_econ = gr.Button("Calculate Sweet Spot", variant="primary", size="lg")
+
+            with gr.Group(elem_classes=["results-card"]):
+                gr.Markdown("### Capacity analysis")
+                with gr.Row():
+                    out_econ_plot = gr.Plot(label="Profit Curve")
+                    out_best_marey = gr.Plot(label="Optimal Timetable (Space-Time Diagram)")
+                with gr.Row():
+                    out_econ_df = gr.Dataframe(label="Raw Economic Data", max_height=620, wrap=True, show_row_numbers=True, buttons=[])
+                    out_best_timetable = gr.Dataframe(label="Optimal Timetable (Data)", max_height=620, wrap=True, show_row_numbers=True, buttons=[])
+                gr.Markdown("### Primary delays in the best scenario")
+                out_econ_delays = gr.Dataframe(label="Primary Delays & Responsibility (Best Scenario)", max_height=460, wrap=True, show_row_numbers=True, buttons=[])
+
+    gr.HTML("<div class='footer-note'>HoRT RailCap Lab · Educational railway capacity and reliability simulator</div>")
+
+    demo.load(fn=None, js=MATRIX_LOADER_JS, queue=False, show_progress="hidden")
+
+    t_trains.change(fn=get_train_choices, inputs=[t_trains], outputs=[dd_selected_train])
+
+    btn.click(
+        fn=run_simulation,
+        inputs=[
+            t_stations, t_trains, t_delays, txt_spacing, dd_view, dd_selected_train, txt_max_buffer,
+            main_delay_mode, main_rand_prob, main_min_delay, main_max_delay
+        ],
+        outputs=[out_nom, out_adj, out_stats, out_buffer, out_logs, plot]
+    )
+
+    dd_view.change(
+        fn=run_simulation,
+        inputs=[
+            t_stations, t_trains, t_delays, txt_spacing, dd_view, dd_selected_train, txt_max_buffer,
+            main_delay_mode, main_rand_prob, main_min_delay, main_max_delay
+        ],
+        outputs=[out_nom, out_adj, out_stats, out_buffer, out_logs, plot]
+    )
+
+    dd_selected_train.change(
+        fn=run_simulation,
+        inputs=[
+            t_stations, t_trains, t_delays, txt_spacing, dd_view, dd_selected_train, txt_max_buffer,
+            main_delay_mode, main_rand_prob, main_min_delay, main_max_delay
+        ],
+        outputs=[out_nom, out_adj, out_stats, out_buffer, out_logs, plot]
+    )
+
+    txt_max_buffer.change(
+        fn=run_simulation,
+        inputs=[
+            t_stations, t_trains, t_delays, txt_spacing, dd_view, dd_selected_train, txt_max_buffer,
+            main_delay_mode, main_rand_prob, main_min_delay, main_max_delay
+        ],
+        outputs=[out_nom, out_adj, out_stats, out_buffer, out_logs, plot]
+    )
+
+    main_delay_mode.change(
+        fn=run_simulation,
+        inputs=[
+            t_stations, t_trains, t_delays, txt_spacing, dd_view, dd_selected_train, txt_max_buffer,
+            main_delay_mode, main_rand_prob, main_min_delay, main_max_delay
+        ],
+        outputs=[out_nom, out_adj, out_stats, out_buffer, out_logs, plot]
+    )
+
+    btn_econ.click(
+        fn=run_economic_analysis,
+        inputs=[
+            econ_t_stations, t_fleet, econ_t_delays, econ_txt_spacing, max_trains_in,
+            num_tac, num_pr, delay_mode, rand_prob, min_delay, max_delay, im_resp_share
+        ],
+        outputs=[out_econ_df, out_econ_plot, out_best_timetable, out_best_marey, out_econ_delays]
     )
-    with gr.Tab("Generate note"):
-        title = gr.Textbox(label="Note title", value="Your note")
-        note_button = gr.Button("Generate cited note", variant="primary")
-        note_output = gr.Markdown()
-        note_button.click(make_note, inputs=[source, title], outputs=note_output)
-    with gr.Tab("Ask a question"):
-        question = gr.Textbox(label="Question", placeholder="What did we decide about pricing?")
-        ask_button = gr.Button("Ask", variant="primary")
-        answer_output = gr.Markdown()
-        ask_button.click(ask_question, inputs=[source, question], outputs=answer_output)
 
+# Launch the app. Gradio 6 moved css/theme from Blocks() to launch(), while
+# Gradio 4/5 accepts them in Blocks(). This keeps the visual theme working on
+# both current and older Hugging Face Spaces runtimes.
 if __name__ == "__main__":
-    demo.launch()
+    import inspect
+    launch_kwargs = {"debug": False}
+    if "css" in inspect.signature(demo.launch).parameters:
+        launch_kwargs.update({"css": CUSTOM_CSS, "theme": HORT_THEME})
+    demo.launch(**launch_kwargs)