Update app.py

app.py

@@ -38,8 +38,6 @@ import flight_plotter_v32 as fp
 # ================= CONFIG =================
 KML_FILE = "MH370 - 13 nov (3).kml"
 SEARCH_AREAS_KMZ = "Search areas.kmz"
-
-# NEW: max range ring KML
 MAX_RANGE_KML = "MH370_max_range_6166km_KUL_red.kml"
 
 DEFAULT_LEGS = [
@@ -58,12 +56,10 @@ WAYPOINTS = [
     ("MEKAR", 6.5, 96.48333333),
 ]
 
-# NEW: Reference marker requested
 CAPT_BYRON_BAILEY_NAME = "Captain Byron Bailey"
 CAPT_BYRON_BAILEY_LAT = -(39 + 10 / 60)   # 39°10' S
 CAPT_BYRON_BAILEY_LON = (88 + 18 / 60)    # 88°18' E
 
-# NEW: measured BFO at 00:20Z
 MEASURED_BFO_0020_HZ = 182.0
 
 RING_TIMES = {
@@ -76,20 +72,15 @@ RING_TIMES = {
     "Ping Ring 7": "24:10:00Z",
 }
 
-# satLoc indices
 SATLOC_IDX_MEAS_BFO = 4
 SATLOC_IDX_MEAS_BTO = 5
 
-# ===== Fixed Radar + Turn Completion =====
 RADAR_FIX_LAT = 6.578
 RADAR_FIX_LON = 96.341
 RADAR_FIX_TIME_UTC = datetime(2014, 3, 7, 18, 22, 0, tzinfo=timezone.utc)
-
 TURN_COMPLETE_TIME_UTC = datetime(2014, 3, 7, 18, 40, 0, tzinfo=timezone.utc)
-
 RADAR_INITIAL_TRACK_DEG = 296.0
 
-# ===== Guided validation timestamps of interest =====
 GUIDED_VALIDATION_LABELS = [
     "18:22:00",
     "18:40:00",
@@ -97,42 +88,34 @@ GUIDED_VALIDATION_LABELS = [
     "20:40:00",
     "21:40:00",
     "22:40:00",
-    "24:10:00",  # 00:10Z
-    "24:20:00",  # 00:20Z
+    "24:10:00",
+    "24:20:00",
 ]
-GUIDED_FINAL_LABEL = "24:20:00"  # 00:20Z FINAL RESTING POINT
+GUIDED_FINAL_LABEL = "24:20:00"
 
-# Turn modeling parameters
 TURN_BANK_MIN_DEG = 15.0
 TURN_BANK_MAX_DEG = 30.0
 TURN_BANK_DEFAULT_DEG = 25.0
 TURN_STEP_SEC = 30.0
 
-# ===== Speed bounds per your request =====
 TURN_SPEED_MIN_KT = 470.0
 TURN_SPEED_MAX_KT = 520.0
-
 SOUTH_SPEED_MIN_KT = 430.0
 SOUTH_SPEED_MAX_KT = 510.0
 
-# ===== NEW: Constant southern speed mode =====
-CONST_SOUTH_SPEED_KT = 443.0  # changed from 447 -> 443
+CONST_SOUTH_SPEED_KT = 443.0
 
-# ===== Straight heading search =====
 GUIDED_HEADING_MIN = 175
 GUIDED_HEADING_MAX = 190
 COARSE_HEADING_STEP_DEG = 2.0
 REFINE_HEADING_HALF_WINDOW_DEG = 2.0
 REFINE_HEADING_STEP_DEG = 0.5
 
-# Southern ping-interval schedule (18:40→00:20 = 340 min)
 GUIDED_SOUTH_SEG_MIN = [60.0, 60.0, 60.0, 60.0, 90.0, 10.0]
 GUIDED_SOUTH_SEG_LABELS_END = ["19:40:00", "20:40:00", "21:40:00", "22:40:00", "24:10:00", "24:20:00"]
 
-# HARD BTO labels list (AUTO-FILTERED to those with measured BTO)
 HARD_BTO_LABELS = ["18:40:00", "19:40:00", "20:40:00", "21:40:00", "22:40:00", "24:10:00", "24:20:00"]
 
-# ===== Performance knobs: Top-K polish (Straight mode only) =====
 TOPK_POLISH = 5
 ENABLE_POLISH_STRAIGHT = True
 POLISH_PASSES = 3
@@ -140,21 +123,18 @@ POLISH_WINDOW_KT = 6.0
 POLISH_STEP_KT = 2.0
 POLISH_OBJ_EPS = 1e-3
 
-# ===== Variable heading & speed solver knobs (FAST) =====
 VAR_HEADING_MIN = 170.0
 VAR_HEADING_MAX = 200.0
-VAR_TURN_SPEED_STEP = 10.0          # coarse turn speed scan
-VAR_FIRST_HEADING_STEP = 4.0        # coarse first south heading grid
-VAR_HEADING_DELTA_SET = [-6, -3, 0, 3, 6]  # candidate changes per segment (deg)
-VAR_BEAM_WIDTH = 12                  # keep top-N partial paths each segment
-VAR_SMOOTH_PENALTY_US_PER_DEG = 1.5  # small penalty to avoid wiggles (still BTO-first)
-
-# ===== SE-bias-after-22:40 (new mode) =====
-SE_EAST_DIVERGE_START_SEG_INDEX = 4          # seg 4 starts after 22:40
-SE_VAR_EAST_DELTA_SET = [-8, -4, -2, 0, 2]   # prefer small decreases (eastward) after 22:40
-SE_EAST_BIAS_PENALTY_US_PER_DEG = 0.8        # small; BTO still dominates
-
-# Search area colors (optional)
+VAR_TURN_SPEED_STEP = 10.0
+VAR_FIRST_HEADING_STEP = 4.0
+VAR_HEADING_DELTA_SET = [-6, -3, 0, 3, 6]
+VAR_BEAM_WIDTH = 12
+VAR_SMOOTH_PENALTY_US_PER_DEG = 1.5
+
+SE_EAST_DIVERGE_START_SEG_INDEX = 4
+SE_VAR_EAST_DELTA_SET = [-8, -4, -2, 0, 2]
+SE_EAST_BIAS_PENALTY_US_PER_DEG = 0.8
+
 SEARCH_AREA_COLORS = {
     "Ocean Infinity": "#ff3b3b",
     "Australia": "#1f77b4",
@@ -200,9 +180,7 @@ def color_for_search_area(name: str) -> str:
 def load_ping_rings_from_kml(path: str):
     path = resolve_local_or_mnt(path)
     if not os.path.exists(path):
-        raise FileNotFoundError(
-            f"KML file not found: '{path}'. Put it in the Space root (same folder as app.py)."
-        )
+        raise FileNotFoundError(f"KML file not found: '{path}'.")
 
     tree = ET.parse(path)
     root = tree.getroot()
@@ -250,13 +228,11 @@ else:
     KML_LOAD_ERROR = ""
 
 
-# ================= KML (Maximum Range Ring) =================
+# ================= KML (Generic features / max range ring) =================
 def load_generic_kml_features(path: str):
     path = resolve_local_or_mnt(path)
     if not os.path.exists(path):
-        raise FileNotFoundError(
-            f"KML file not found: '{path}'. Put it in the Space root (same folder as app.py)."
-        )
+        raise FileNotFoundError(f"KML file not found: '{path}'.")
 
     tree = ET.parse(path)
     root = tree.getroot()
@@ -270,7 +246,6 @@ def load_generic_kml_features(path: str):
         name_el = pm.find("kml:name", ns)
         pm_name = name_el.text.strip() if (name_el is not None and name_el.text) else "KML feature"
 
-        # Points
         for pt in pm.findall(".//kml:Point", ns):
             coords_el = pt.find(".//kml:coordinates", ns)
             if coords_el is None or coords_el.text is None:
@@ -279,14 +254,8 @@ def load_generic_kml_features(path: str):
             if len(coords) >= 2:
                 lon = float(coords[0])
                 lat = float(coords[1])
-                features.append({
-                    "type": "point",
-                    "name": pm_name,
-                    "lat": lat,
-                    "lon": lon,
-                })
-
-        # Lines
+                features.append({"type": "point", "name": pm_name, "lat": lat, "lon": lon})
+
         for ls in pm.findall(".//kml:LineString", ns):
             coords_el = ls.find(".//kml:coordinates", ns)
             if coords_el is None or coords_el.text is None:
@@ -302,11 +271,7 @@ def load_generic_kml_features(path: str):
                 lat = float(parts[1])
                 pts.append((lat, lon))
             if pts:
-                features.append({
-                    "type": "line",
-                    "name": pm_name,
-                    "points": pts,
-                })
+                features.append({"type": "line", "name": pm_name, "points": pts})
 
     return features
 
@@ -346,9 +311,7 @@ def _parse_kml_coordinates_text(txt: str):
 def load_search_areas_from_kmz(kmz_path: str):
     kmz_path = resolve_local_or_mnt(kmz_path)
     if not os.path.exists(kmz_path):
-        raise FileNotFoundError(
-            f"KMZ file not found: '{kmz_path}'. Put it next to app.py or ensure it's in /mnt/data."
-        )
+        raise FileNotFoundError(f"KMZ file not found: '{kmz_path}'.")
 
     with zipfile.ZipFile(kmz_path, "r") as zf:
         kml_name = None
@@ -479,13 +442,8 @@ def _turn_rate_deg_per_sec(speed_knots: float, bank_deg: float) -> float:
     return float(omega * 180.0 / math.pi)
 
 
-def build_turn_legs(
-    speed_knots: float,
-    method: str,
-    heading_final_deg: float,
-    bank_pref_deg: float = TURN_BANK_DEFAULT_DEG,
-    step_sec: float = TURN_STEP_SEC
-):
+def build_turn_legs(speed_knots: float, method: str, heading_final_deg: float,
+                    bank_pref_deg: float = TURN_BANK_DEFAULT_DEG, step_sec: float = TURN_STEP_SEC):
     total_sec = (TURN_COMPLETE_TIME_UTC - RADAR_FIX_TIME_UTC).total_seconds()
     if total_sec <= 0:
         return [], {"error": "Invalid turn window."}
@@ -578,19 +536,11 @@ def _dt_from_label(label_hms: str) -> datetime:
     return fp._time_label_to_dt(s, fp.SAT_EPOCH_UTC)
 
 
-def dt_ping6_utc() -> datetime:
-    return fp._time_label_to_dt("22:40:00", fp.SAT_EPOCH_UTC)
-
-
-def dt_ping7_utc() -> datetime:
-    return fp._time_label_to_dt("24:10:00", fp.SAT_EPOCH_UTC)
-
-
 def dt_0020_utc() -> datetime:
     return fp._time_label_to_dt("24:20:00", fp.SAT_EPOCH_UTC)
 
 
-# ================= PATCH satLoc: ensure measured BFO at 00:20 is 182 Hz =================
+# ================= PATCH satLoc =================
 def _patch_measured_bfo_0020():
     target_labels = {"24:20:00", "00:20:00"}
     patched = False
@@ -616,13 +566,12 @@ _ = _patch_measured_bfo_0020()
 
 # ================= ALTITUDE HELPERS =================
 def altitude_ft_at_dt(dt_ping: datetime, start_dt: datetime, alt0_ft: float,
-                      vs_fpm: float, descent_start_dt: datetime | None):
+                      vs_fpm: float, descent_start_dt):
     alt0_ft = float(alt0_ft)
     vs_fpm = float(vs_fpm)
 
     if descent_start_dt is None or vs_fpm == 0.0:
         return max(0.0, alt0_ft)
-
     if dt_ping < descent_start_dt:
         return max(0.0, alt0_ft)
 
@@ -632,13 +581,12 @@ def altitude_ft_at_dt(dt_ping: datetime, start_dt: datetime, alt0_ft: float,
 
 
 def build_altitude_plot(start_dt: datetime, total_time_min: float, alt0_ft: float,
-                        vs_fpm: float, descent_start_dt: datetime | None):
+                        vs_fpm: float, descent_start_dt):
     t = np.linspace(0.0, max(1.0, float(total_time_min)), 120)
     alts = []
     for mins in t:
         dt = start_dt + timedelta(minutes=float(mins))
-        alt = altitude_ft_at_dt(dt, start_dt, float(alt0_ft), float(vs_fpm), descent_start_dt)
-        alts.append(alt)
+        alts.append(altitude_ft_at_dt(dt, start_dt, float(alt0_ft), float(vs_fpm), descent_start_dt))
 
     fig = go.Figure()
     fig.add_trace(go.Scatter(x=t, y=alts, mode="lines", name="Altitude (ft)"))
@@ -653,7 +601,7 @@ def build_altitude_plot(start_dt: datetime, total_time_min: float, alt0_ft: floa
 
 
 # ================= SPEED PROFILE PLOT =================
-def build_speed_profile_plot(start_dt: datetime, legs: list[tuple[float, float, float]]):
+def build_speed_profile_plot(start_dt: datetime, legs):
     xs = [0.0]
     ys = []
     cum_min = 0.0
@@ -672,13 +620,9 @@ def build_speed_profile_plot(start_dt: datetime, legs: list[tuple[float, float,
         xs.append(cum_min)
         ys.append(spd)
 
-    if not ys:
-        fig = go.Figure()
-        fig.update_layout(title="Speed Profile", xaxis_title="Minutes since start", yaxis_title="Speed (kt)", height=320)
-        return fig
-
     fig = go.Figure()
-    fig.add_trace(go.Scatter(x=xs[1:], y=ys, mode="lines", name="Speed (kt)"))
+    if ys:
+        fig.add_trace(go.Scatter(x=xs[1:], y=ys, mode="lines", name="Speed (kt)"))
     fig.update_layout(
         title="Speed Profile",
         xaxis_title="Minutes since start",
@@ -714,10 +658,8 @@ def compute_stats(path_pts, seg_dists_m, total_time_min, legs):
     total_dist_m = float(np.sum(seg_dists_m)) if seg_dists_m else 0.0
     total_dist_km = total_dist_m / 1000.0
     total_dist_nm = total_dist_m / 1852.0
-
     total_time_hr = total_time_min / 60.0
     avg_gs_knots = (total_dist_nm / total_time_hr) if total_time_hr > 0 else 0.0
-
     end_lat, end_lon = path_pts[-1]
     return "\n\n".join([
         f"**Legs:** {len(legs)}",
@@ -793,8 +735,7 @@ def _state_at_dt(start_lat, start_lon, legs, method, start_dt, dt_k):
 def _map_marker_times(start_dt, legs):
     if start_dt == RADAR_FIX_TIME_UTC:
         times = [_dt_from_label(x) for x in GUIDED_VALIDATION_LABELS]
-        times = sorted(list({t: t for t in times}.values()))
-        return times
+        return sorted(list({t: t for t in times}.values()))
 
     times = [start_dt]
     cum = 0.0
@@ -804,7 +745,7 @@ def _map_marker_times(start_dt, legs):
     return times
 
 
-# ================= CLIP TRAJECTORY TO 00:20 (GUIDED) =================
+# ================= CLIP TRAJECTORY =================
 def clip_legs_to_end_dt(legs, start_dt: datetime, end_dt: datetime):
     total_target_sec = (end_dt - start_dt).total_seconds()
     if total_target_sec <= 0:
@@ -849,7 +790,7 @@ def _ping_points_after(start_dt: datetime):
     return pts
 
 
-def _descent_start_dt_from_choice(descent_start_choice: str) -> datetime | None:
+def _descent_start_dt_from_choice(descent_start_choice: str):
     ch = (descent_start_choice or "").strip()
     if ch.startswith("At 00:20Z only"):
         return dt_0020_utc()
@@ -860,13 +801,11 @@ def _descent_start_dt_from_choice(descent_start_choice: str) -> datetime | None:
 
 def bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice):
     pts = _ping_points_after(start_dt)
-
     descent_start_dt = _descent_start_dt_from_choice(descent_start_choice)
 
     leg_secs = [float(m) * 60.0 for _, _, m in legs]
     boundaries = np.cumsum([0.0] + leg_secs)
     total_end = float(boundaries[-1])
-
     leg_start_positions = _precompute_leg_starts(start_lat, start_lon, legs, method)
 
     x_labels, measured, calculated = [], [], []
@@ -889,7 +828,6 @@ def bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_dt, alt_ft,
 
         leg_start_lat, leg_start_lon = leg_start_positions[i]
         hdg, spd, _m = legs[i]
-
         lat, lon = _predict_state_from_leg_start(method, leg_start_lat, leg_start_lon, hdg, spd, t_inside)
 
         alt_now_ft = altitude_ft_at_dt(dt_ping, start_dt, float(alt_ft), float(vs_fpm), descent_start_dt)
@@ -907,23 +845,20 @@ def bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_dt, alt_ft,
         calculated.append(float(pred_bfo))
 
     fig = go.Figure()
-    if not x_labels:
-        fig.update_layout(title="BFO Analysis", xaxis_title="Time", yaxis_title="Hz", height=520)
-        return fig, ""
-
-    fig.add_trace(go.Scatter(
-        x=x_labels, y=measured,
-        mode="markers",
-        name="Measured BFO",
-        marker=dict(size=11, symbol="circle")
-    ))
-    fig.add_trace(go.Scatter(
-        x=x_labels, y=calculated,
-        mode="lines+markers",
-        name="Calculated BFO",
-        line=dict(width=3),
-        marker=dict(size=10, symbol="diamond")
-    ))
+    if x_labels:
+        fig.add_trace(go.Scatter(
+            x=x_labels, y=measured,
+            mode="markers",
+            name="Measured BFO",
+            marker=dict(size=11, symbol="circle")
+        ))
+        fig.add_trace(go.Scatter(
+            x=x_labels, y=calculated,
+            mode="lines+markers",
+            name="Calculated BFO",
+            line=dict(width=3),
+            marker=dict(size=10, symbol="diamond")
+        ))
     fig.update_layout(
         title="BFO Analysis",
         xaxis_title="Time",
@@ -932,7 +867,6 @@ def bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_dt, alt_ft,
         margin=dict(l=60, r=160, t=80, b=60),
         height=520,
     )
-
     return fig, ""
 
 
@@ -945,12 +879,8 @@ def _lookup_measured_at_dt(dt_ping: datetime):
     return None, None
 
 
-def build_validation_table(
-    start_lat, start_lon, method, start_dt, legs,
-    alt_ft, vs_fpm, descent_start_choice
-):
+def build_validation_table(start_lat, start_lon, method, start_dt, legs, alt_ft, vs_fpm, descent_start_choice):
     descent_start_dt = _descent_start_dt_from_choice(descent_start_choice)
-
     is_guided = (start_dt == RADAR_FIX_TIME_UTC)
 
     if is_guided:
@@ -1035,10 +965,7 @@ def _all_bounds(points_list):
 
 def add_permanent_label(m, name, lat, lon):
     tip = f"{html.escape(name)}<br>Lat: {float(lat):.5f}<br>Lon: {float(lon):.5f}"
-    pop = folium.Popup(
-        f"<b>{html.escape(name)}</b><br>Lat: {float(lat):.5f}<br>Lon: {float(lon):.5f}",
-        max_width=260,
-    )
+    pop = folium.Popup(f"<b>{html.escape(name)}</b><br>Lat: {float(lat):.5f}<br>Lon: {float(lon):.5f}", max_width=260)
 
     folium.CircleMarker(
         location=(lat, lon),
@@ -1068,10 +995,7 @@ def add_permanent_label(m, name, lat, lon):
 
 def add_named_marker(m, name: str, lat: float, lon: float):
     tip = f"{html.escape(name)}<br>Lat: {float(lat):.5f}<br>Lon: {float(lon):.5f}"
-    pop = folium.Popup(
-        f"<b>{html.escape(name)}</b><br>Lat: {float(lat):.5f}<br>Lon: {float(lon):.5f}",
-        max_width=260,
-    )
+    pop = folium.Popup(f"<b>{html.escape(name)}</b><br>Lat: {float(lat):.5f}<br>Lon: {float(lon):.5f}", max_width=260)
     folium.CircleMarker(
         location=(float(lat), float(lon)),
         radius=6,
@@ -1087,7 +1011,6 @@ def add_named_marker(m, name: str, lat: float, lon: float):
 
 def add_max_range_features(m, max_range_features):
     bounds_pts = []
-
     for feat in max_range_features:
         ftype = feat.get("type")
         name = feat.get("name", "Maximum range")
@@ -1142,7 +1065,6 @@ def build_leaflet_map(path_pts, legs, method, start_dt, show_max_range_ring=Fals
         control=True,
     ).add_to(m)
 
-    # NEW: mouse cursor lat/lon display
     MousePosition(
         position="topright",
         separator=" | ",
@@ -1151,7 +1073,6 @@ def build_leaflet_map(path_pts, legs, method, start_dt, show_max_range_ring=Fals
         lng_formatter="function(num) {return L.Util.formatNum(num, 5);}",
     ).add_to(m)
 
-    # Search areas
     search_area_pts_for_bounds = []
     for area in SEARCH_AREAS:
         nm = area.get("name", "Search area")
@@ -1174,13 +1095,7 @@ def build_leaflet_map(path_pts, legs, method, start_dt, show_max_range_ring=Fals
             if not line:
                 continue
             search_area_pts_for_bounds.extend(line)
-            folium.PolyLine(
-                locations=line,
-                color=col,
-                weight=3,
-                opacity=0.9,
-                tooltip=nm,
-            ).add_to(m)
+            folium.PolyLine(locations=line, color=col, weight=3, opacity=0.9, tooltip=nm).add_to(m)
 
         for poly in area.get("polygons", []) or []:
             if not poly:
@@ -1197,7 +1112,6 @@ def build_leaflet_map(path_pts, legs, method, start_dt, show_max_range_ring=Fals
                 tooltip=nm,
             ).add_to(m)
 
-    # Ping rings — permanent
     for ring_name in sorted(PING_RINGS.keys()):
         ring_pts = PING_RINGS.get(ring_name)
         if not ring_pts:
@@ -1206,12 +1120,10 @@ def build_leaflet_map(path_pts, legs, method, start_dt, show_max_range_ring=Fals
         tooltip = f"{ring_name} ({ring_time})" if ring_time else ring_name
         folium.PolyLine(ring_pts, weight=2, opacity=0.6, color="yellow", tooltip=tooltip).add_to(m)
 
-    # NEW: toggleable maximum range ring
     max_range_pts_for_bounds = []
     if show_max_range_ring:
         max_range_pts_for_bounds = add_max_range_features(m, MAX_RANGE_FEATURES)
 
-    # Flight path (polyline)
     folium.PolyLine(path_pts, color="white", weight=8, opacity=0.3).add_to(m)
     folium.PolyLine(path_pts, color="red", weight=4, opacity=1.0, tooltip="Flight path").add_to(m)
 
@@ -1294,11 +1206,9 @@ def build_leaflet_map(path_pts, legs, method, start_dt, show_max_range_ring=Fals
                 popup=folium.Popup("<br>".join(popup_lines), max_width=360),
             ).add_to(m)
 
-    # Waypoints
     for name, lat, lon in WAYPOINTS:
-        add_permanent_label(m, name, float(lat), float(lon))
+        add_permanent_label(m, float(name) if False else name, float(lat), float(lon))
 
-    # Requested marker: Captain Byron Bailey
     add_named_marker(m, CAPT_BYRON_BAILEY_NAME, CAPT_BYRON_BAILEY_LAT, CAPT_BYRON_BAILEY_LON)
 
     waypoint_pts = [(float(lat), float(lon)) for _, lat, lon in WAYPOINTS] + [(CAPT_BYRON_BAILEY_LAT, CAPT_BYRON_BAILEY_LON)]
@@ -1376,7 +1286,8 @@ def _simulate_one_leg_end(method: str, lat0: float, lon0: float, hdg: float, spd
     return float(lat1), float(lon1)
 
 
-def _bto_calc(method: str, lat: float, lon: float, dt_ping: datetime, alt_ft: float, vs_fpm: float, start_dt: datetime, descent_start_dt: datetime | None):
+def _bto_calc(method: str, lat: float, lon: float, dt_ping: datetime, alt_ft: float,
+              vs_fpm: float, start_dt: datetime, descent_start_dt):
     alt_now_ft = altitude_ft_at_dt(dt_ping, start_dt, float(alt_ft), float(vs_fpm), descent_start_dt)
     alt_m = alt_now_ft * 0.3048
     return float(fp.calculateBTO_at_time(float(lat), float(lon), alt_m, dt_ping))
@@ -1402,20 +1313,9 @@ def _golden_min_abs(fn, lo: float, hi: float, iters: int = 24):
     return float(x_best), abs(float(fn(x_best)))
 
 
-def _fit_segment_speed(
-    method: str,
-    lat0: float,
-    lon0: float,
-    hdg: float,
-    minutes: float,
-    dt_end: datetime,
-    alt_ft: float,
-    vs_fpm: float,
-    start_dt: datetime,
-    descent_start_dt: datetime | None,
-    vmin: float,
-    vmax: float,
-):
+def _fit_segment_speed(method: str, lat0: float, lon0: float, hdg: float, minutes: float,
+                       dt_end: datetime, alt_ft: float, vs_fpm: float, start_dt: datetime,
+                       descent_start_dt, vmin: float, vmax: float):
     meas = _lookup_measured_bto(dt_end)
     if meas is None:
         v = 0.5 * (vmin + vmax)
@@ -1452,15 +1352,8 @@ def _fit_segment_speed(
     return float(v_best), float(err(v_best)), (lat1, lon1)
 
 
-def _compute_bto_errors_at_enforced(
-    method: str,
-    start_dt: datetime,
-    alt_ft: float,
-    vs_fpm: float,
-    descent_start_dt: datetime | None,
-    full_legs: list[tuple[float, float, float]],
-    enforced_dts: list[datetime],
-):
+def _compute_bto_errors_at_enforced(method: str, start_dt: datetime, alt_ft: float, vs_fpm: float,
+                                    descent_start_dt, full_legs, enforced_dts):
     errs = []
     for dt_k in enforced_dts:
         meas = _lookup_measured_bto(dt_k)
@@ -1474,7 +1367,7 @@ def _compute_bto_errors_at_enforced(
     return errs
 
 
-def _build_south_legs_piecewise_constant_heading(h_south: float, speeds: list[float], minutes: list[float]):
+def _build_south_legs_piecewise_constant_heading(h_south: float, speeds, minutes):
     legs = []
     for v, m in zip(speeds, minutes):
         if float(m) <= 0:
@@ -1483,7 +1376,7 @@ def _build_south_legs_piecewise_constant_heading(h_south: float, speeds: list[fl
     return legs
 
 
-def _build_south_legs_variable(headings: list[float], speeds: list[float], minutes: list[float]):
+def _build_south_legs_variable(headings, speeds, minutes):
     legs = []
     for h, v, m in zip(headings, speeds, minutes):
         if float(m) <= 0:
@@ -1492,28 +1385,17 @@ def _build_south_legs_variable(headings: list[float], speeds: list[float], minut
     return legs
 
 
-# ================= Top-K polish (Straight mode only) =================
-def _polish_south_speeds_topk(
-    method: str,
-    start_dt: datetime,
-    end_dt: datetime,
-    alt_ft: float,
-    vs_fpm: float,
-    descent_start_dt: datetime | None,
-    h_south: float,
-    turn_legs: list[tuple[float, float, float]],
-    enforced_dts: list[datetime],
-    init_speeds: list[float],
-    passes: int = POLISH_PASSES,
-    window_kt: float = POLISH_WINDOW_KT,
-    step_kt: float = POLISH_STEP_KT,
-):
+# ================= Top-K polish =================
+def _polish_south_speeds_topk(method: str, start_dt: datetime, end_dt: datetime, alt_ft: float,
+                              vs_fpm: float, descent_start_dt, h_south: float, turn_legs,
+                              enforced_dts, init_speeds, passes: int = POLISH_PASSES,
+                              window_kt: float = POLISH_WINDOW_KT, step_kt: float = POLISH_STEP_KT):
     speeds = [float(v) for v in init_speeds]
 
     pts_turn, _, _ = simulate_path(RADAR_FIX_LAT, RADAR_FIX_LON, turn_legs, method)
     turn_end_lat, turn_end_lon = float(pts_turn[-1][0]), float(pts_turn[-1][1])
 
-    def build_full(speeds_now: list[float]):
+    def build_full(speeds_now):
         lat_cur, lon_cur = turn_end_lat, turn_end_lon
         seg_errs = []
         for mins, end_lbl, vseg in zip(GUIDED_SOUTH_SEG_MIN, GUIDED_SOUTH_SEG_LABELS_END, speeds_now):
@@ -1589,7 +1471,6 @@ def _polish_south_speeds_topk(
 def solve_guided_straight(method, alt_ft, vs_fpm, descent_start_choice):
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
-
     descent_start_dt = _descent_start_dt_from_choice(descent_start_choice)
 
     pts_all = _ping_points_after(start_dt)
@@ -1607,12 +1488,7 @@ def solve_guided_straight(method, alt_ft, vs_fpm, descent_start_choice):
         h_south = float(h_south)
         v_turn = float(v_turn)
 
-        turn_legs, _turn_info = build_turn_legs(
-            speed_knots=float(v_turn),
-            method=method,
-            heading_final_deg=float(h_south),
-        )
-
+        turn_legs, _turn_info = build_turn_legs(speed_knots=float(v_turn), method=method, heading_final_deg=float(h_south))
         pts_turn, _, _ = simulate_path(RADAR_FIX_LAT, RADAR_FIX_LON, turn_legs, method)
         lat_cur, lon_cur = float(pts_turn[-1][0]), float(pts_turn[-1][1])
 
@@ -1764,11 +1640,10 @@ def solve_guided_straight(method, alt_ft, vs_fpm, descent_start_choice):
     return best_final_legs, "", start_dt
 
 
-# ================= Guided Solver: Variable heading & speed (FAST beam search) =================
+# ================= Guided Solver: Variable heading & speed =================
 def _solve_guided_variable_core(method, alt_ft, vs_fpm, descent_start_choice, se_bias_after_2240: bool):
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
-
     descent_start_dt = _descent_start_dt_from_choice(descent_start_choice)
 
     enforced_labels = _available_hard_bto_labels()
@@ -1782,7 +1657,7 @@ def _solve_guided_variable_core(method, alt_ft, vs_fpm, descent_start_choice, se
     best_global = None
     best_global_legs = None
 
-    def score_from_errors(errs: list[float]):
+    def score_from_errors(errs):
         if not errs:
             return None
         abs_arr = np.abs(np.array(errs, dtype=float))
@@ -1790,11 +1665,7 @@ def _solve_guided_variable_core(method, alt_ft, vs_fpm, descent_start_choice, se
 
     for v_turn in turn_speeds:
         for h1 in first_headings:
-            turn_legs, _turn_info = build_turn_legs(
-                speed_knots=float(v_turn),
-                method=method,
-                heading_final_deg=float(h1),
-            )
+            turn_legs, _turn_info = build_turn_legs(speed_knots=float(v_turn), method=method, heading_final_deg=float(h1))
             pts_turn, _, _ = simulate_path(RADAR_FIX_LAT, RADAR_FIX_LON, turn_legs, method)
             lat0, lon0 = float(pts_turn[-1][0]), float(pts_turn[-1][1])
 
@@ -1915,11 +1786,10 @@ def solve_guided_variable_se(method, alt_ft, vs_fpm, descent_start_choice):
     return _solve_guided_variable_core(method, alt_ft, vs_fpm, descent_start_choice, se_bias_after_2240=True)
 
 
-# ================= Guided Solver: Variable heading, CONSTANT southern speed (443 kt) =================
+# ================= Guided Solver: Variable heading, CONSTANT southern speed =================
 def solve_guided_constant_speed(method, alt_ft, vs_fpm, descent_start_choice):
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
-
     descent_start_dt = _descent_start_dt_from_choice(descent_start_choice)
 
     enforced_labels = _available_hard_bto_labels()
@@ -1933,7 +1803,7 @@ def solve_guided_constant_speed(method, alt_ft, vs_fpm, descent_start_choice):
     best_global = None
     best_global_legs = None
 
-    def score_from_errors(errs: list[float]):
+    def score_from_errors(errs):
         if not errs:
             return None
         abs_arr = np.abs(np.array(errs, dtype=float))
@@ -1943,11 +1813,7 @@ def solve_guided_constant_speed(method, alt_ft, vs_fpm, descent_start_choice):
 
     for v_turn in turn_speeds:
         for h1 in first_headings:
-            turn_legs, _turn_info = build_turn_legs(
-                speed_knots=float(v_turn),
-                method=method,
-                heading_final_deg=float(h1),
-            )
+            turn_legs, _turn_info = build_turn_legs(speed_knots=float(v_turn), method=method, heading_final_deg=float(h1))
             pts_turn, _, _ = simulate_path(RADAR_FIX_LAT, RADAR_FIX_LON, turn_legs, method)
             lat0, lon0 = float(pts_turn[-1][0]), float(pts_turn[-1][1])
 
@@ -1970,7 +1836,6 @@ def solve_guided_constant_speed(method, alt_ft, vs_fpm, descent_start_choice):
 
                 for st in beam:
                     h_prev = float(st["h_prev"])
-
                     cand_h = []
                     for d in VAR_HEADING_DELTA_SET:
                         h_try = _clamp(h_prev + float(d), VAR_HEADING_MIN, VAR_HEADING_MAX)
@@ -2047,19 +1912,13 @@ def _run_common(start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, de
     html_map = build_leaflet_map(path_pts, legs, method, start_dt, show_max_range_ring=show_max_range_ring)
     stats_md = compute_stats(path_pts, seg_dists_m, total_time_min, legs)
 
-    bfo_fig, _bfo_md = bfo_analysis_with_legs(
-        start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice
-    )
+    bfo_fig, _bfo_md = bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice)
 
     descent_start_dt = _descent_start_dt_from_choice(descent_start_choice)
     alt_fig = build_altitude_plot(start_dt, total_time_min, alt_ft, vs_fpm, descent_start_dt)
-
     speed_fig = build_speed_profile_plot(start_dt, legs)
 
-    headers, rows = build_validation_table(
-        start_lat, start_lon, method, start_dt, legs, alt_ft, vs_fpm, descent_start_choice
-    )
-
+    headers, rows = build_validation_table(start_lat, start_lon, method, start_dt, legs, alt_ft, vs_fpm, descent_start_choice)
     return html_map, stats_md, bfo_fig, alt_fig, speed_fig, headers, rows
 
 
@@ -2193,7 +2052,7 @@ with gr.Blocks() as demo:
         value=[],
         interactive=False,
         row_count=(40, "dynamic"),
-        col_count=(11, "fixed"),
+        column_count=(11, "fixed"),
         wrap=True,
         label="Validation"
     )