Update app.py

app.py

@@ -8,17 +8,16 @@
 # Key behavior:
 # - Last radar spot FIXED: 18:22:00Z @ 6.578N, 96.341E
 # - Turn completion FIXED TIME: 18:40:00Z
-# - NEW: Turn completion LOCATION (18:40 lat/lon) is USER-ADJUSTABLE via sliders.
-# - Guided mode computes a realistic turn between 18:22→18:40 that ENDS at the 18:40 lat/lon,
-#   and then simulates/solves the southern path.
+# - 18:40 lat/lon is AUTHORITATIVE (hard-fixed) via sliders.
+# - NEW (important): Program finds the *best* turn (bank + timing + speed factor) automatically.
+#   No user bank angle. No ugly kinked paths.
 # - Guided validation timestamps: 18:22, 18:40, 19:40, 20:40, 21:40, 22:40, 00:10, 00:20
 #
-# FIXES IMPLEMENTED IN THIS VERSION:
-# 1) Remove trajectory (red line) AFTER 00:20
-#    - In guided mode, we CLIP the simulated legs so the polyline ends exactly at 00:20Z.
-# 2) Restore BFO plot (it disappeared previously)
-#    - Re-added full BFO analysis computation + chart + MAE/RMSE markdown.
-# 3) NEW: 18:40 turn completion lat/lon sliders drive the guided preturn geometry (plausible turn).
+# FIXES IMPLEMENTED:
+# 1) Remove trajectory (red line) AFTER 00:20 (guided) by clipping legs to 00:20
+# 2) Restore BFO plot
+# 3) 18:40 is a hard waypoint (no “approx error”); solver produces a smooth turn and then snaps a *tiny*
+#    correction segment (normally meters) if needed.
 
 import os
 import re
@@ -89,7 +88,7 @@ TURN_WINDOW_MIN = (TURN_COMPLETE_TIME_UTC - RADAR_FIX_TIME_UTC).total_seconds()
 # Initial track shown in your radar annotation
 RADAR_INITIAL_TRACK_DEG = 296.0
 
-# ===== NEW: Default 18:40 turn completion location (user can override with sliders) =====
+# ===== Default 18:40 turn completion location (user can override with sliders) =====
 TURN_COMPLETE_DEFAULT_LAT = 6.76
 TURN_COMPLETE_DEFAULT_LON = 95.69
 
@@ -107,16 +106,24 @@ GUIDED_VALIDATION_LABELS = [
 ]
 GUIDED_FINAL_LABEL = "24:20:00"  # 00:20Z FINAL RESTING POINT
 
-# Turn modeling parameters
-TURN_BANK_MIN_DEG = 15.0
-TURN_BANK_MAX_DEG = 30.0
-TURN_BANK_DEFAULT_DEG = 15.0
-TURN_STEP_SEC = 30.0
+# Turn solver search space (automatic)
+TURN_BANK_MIN_DEG = 10.0
+TURN_BANK_MAX_DEG = 35.0
 
-# NEW: How tightly we try to hit the 18:40 point (km)
-TURN_POINT_TOL_KM = 0.50  # "hit" tolerance for reporting; solver still picks best even if > tol
-TURN_PRESEARCH_COARSE_SEC = 10.0  # coarse grid for pre-straight duration
-TURN_PRESEARCH_FINE_SEC = 1.0     # refinement grid around the best coarse solution
+TURN_SIM_DT_SEC = 10.0  # internal turn integration resolution (smaller = smoother, slower)
+TURN_PRE_FRAC_STEP_COARSE = 0.05
+TURN_PRE_FRAC_STEP_FINE = 0.01
+TURN_BANK_STEP_COARSE = 1.0
+TURN_BANK_STEP_FINE = 0.25
+TURN_SPEEDFAC_STEP_COARSE = 0.02
+TURN_SPEEDFAC_STEP_FINE = 0.005
+
+TURN_SPEEDFAC_MIN = 0.70
+TURN_SPEEDFAC_MAX = 1.30
+
+# If the best-fit endpoint is still off by a little, add a tiny correction segment to hit the waypoint exactly.
+TURN_FINAL_SNAP_MAX_KM = 2.0      # if worse than this, we report it (should not happen normally)
+TURN_FINAL_SNAP_SEC = 10.0        # duration of final snap segment (small)
 
 # Guided heading search (south-ish)
 GUIDED_HEADING_MIN = 150.0
@@ -130,7 +137,6 @@ GUIDED_LEG_SCHEDULE_MIN = [12.0, 60.0, 60.0, 60.0, 60.0, 90.0, 10.0]
 DEFAULT_DRIFT_MAX_DEG = 2.0
 DRIFT_STEP_DEG = 0.5
 DEFAULT_WEIGHT_DRIFT = 0.30
-DEFAULT_DRIFT_ITERS = 2
 DRIFT_SCALE_DEG = 1.0
 
 # Search area colors (optional)
@@ -389,7 +395,6 @@ def _turn_rate_deg_per_sec(speed_knots: float, bank_deg: float) -> float:
 
 
 def _haversine_km(lat1, lon1, lat2, lon2) -> float:
-    # quick & stable for our error scoring (km)
     R = 6371.0
     phi1 = math.radians(float(lat1))
     phi2 = math.radians(float(lat2))
@@ -399,6 +404,16 @@ def _haversine_km(lat1, lon1, lat2, lon2) -> float:
     return 2 * R * math.asin(min(1.0, math.sqrt(a)))
 
 
+def _initial_bearing_deg(lat1, lon1, lat2, lon2) -> float:
+    phi1 = math.radians(float(lat1))
+    phi2 = math.radians(float(lat2))
+    dl = math.radians(float(lon2) - float(lon1))
+    y = math.sin(dl) * math.cos(phi2)
+    x = math.cos(phi1) * math.sin(phi2) - math.sin(phi1) * math.cos(phi2) * math.cos(dl)
+    brng = math.degrees(math.atan2(y, x))
+    return (brng + 360.0) % 360.0
+
+
 def _direct(method: str, lat: float, lon: float, heading_deg: float, dist_m: float):
     if method == "VINCENTY":
         (lat2, lon2), _ = fp.vincenty_direct((float(lat), float(lon)), float(heading_deg), float(dist_m))
@@ -407,237 +422,195 @@ def _direct(method: str, lat: float, lon: float, heading_deg: float, dist_m: flo
     return float(lat2), float(lon2)
 
 
-def _simulate_discretized_turn(
+# ================= TURN SOLVER (AUTOMATIC “BEST TURN”) =================
+def _simulate_turn_window(
     method: str,
-    lat0: float,
-    lon0: float,
     speed_knots: float,
     h0: float,
     h1: float,
-    turn_sec: float,
-    sign: float,
-    delta_abs: float,
-    step_sec: float
-):
-    # Returns endpoint after flying the discretized turn with mid-heading sampling
-    lat, lon = float(lat0), float(lon0)
-    if turn_sec <= 1e-9 or delta_abs <= 1e-9:
-        return lat, lon
-
-    step_sec = max(5.0, float(step_sec))
-    n = int(math.ceil(float(turn_sec) / step_sec))
-    if n < 1:
-        n = 1
-
-    remaining = float(turn_sec)
-    for i in range(n):
-        this = min(step_sec, remaining)
-        remaining -= this
-        frac_mid = (i + 0.5) / n
-        hdg_mid = _wrap_heading_deg(float(h0) + float(sign) * float(delta_abs) * float(frac_mid))
-        dist_m = float(speed_knots) * 1852.0 * (float(this) / 3600.0)
-        lat, lon = _direct(method, lat, lon, hdg_mid, dist_m)
-
-    return lat, lon
-
-
-def build_turn_legs_to_point(
-    speed_knots: float,
-    method: str,
-    heading_final_deg: float,
-    target_lat: float,
-    target_lon: float,
-    bank_pref_deg: float = TURN_BANK_DEFAULT_DEG,
-    step_sec: float = TURN_STEP_SEC,
+    bank_deg: float,
+    pre_frac: float,
+    dt_sec: float,
 ):
     """
-    Build a plausible 18:22→18:40 turn profile that:
-    - starts on RADAR_INITIAL_TRACK_DEG
-    - ends at (target_lat, target_lon) exactly at TURN_COMPLETE_TIME_UTC (as close as numerically possible)
-    - ends with heading = heading_final_deg (start of southern leg)
-    - keeps constant speed_knots during the whole window
-    Model:
-      pre-straight on h0 for t_pre
-      constant-bank discretized turn to h1 for t_turn (from bank angle)
-      post-straight on h1 for t_post
-      with t_pre + t_turn + t_post = total
-    We brute-force t_pre (grid) and bank candidate to minimize endpoint error (km).
+    Simulate 18:22→18:40 as:
+      pre-straight at h0 for t_pre
+      constant-bank coordinated turn changing heading at omega for t_turn (to reach h1)
+      post-straight at h1 for remaining time
+    Returns final (lat,lon) plus a list of micro-legs (heading, speed, minutes) for the full window.
     """
     total_sec = (TURN_COMPLETE_TIME_UTC - RADAR_FIX_TIME_UTC).total_seconds()
     if total_sec <= 0:
-        return [], {"error": "Invalid turn window."}
+        return (RADAR_FIX_LAT, RADAR_FIX_LON), []
+
+    bank_deg = float(bank_deg)
+    speed_knots = float(speed_knots)
+    dt_sec = max(5.0, float(dt_sec))
 
-    h0 = float(RADAR_INITIAL_TRACK_DEG)
-    h1 = _wrap_heading_deg(float(heading_final_deg))
     delta = _shortest_signed_delta_deg(h0, h1)
     sign = 1.0 if delta >= 0 else -1.0
     delta_abs = abs(delta)
 
-    # Quick feasibility check: the endpoint straight-line distance must not exceed path length budget
-    L_km = float(speed_knots) * 1.852 * (float(total_sec) / 3600.0)
-    d_km = _haversine_km(RADAR_FIX_LAT, RADAR_FIX_LON, float(target_lat), float(target_lon))
-    if d_km > L_km + 1e-6:
-        return [], {
-            "error": (
-                f"18:40 point is too far for the 18-minute window at {float(speed_knots):.1f} kt.\n"
-                f"Straight-line distance: {d_km:.1f} km; path-length budget: {L_km:.1f} km."
-            ),
-            "d_km": d_km,
-            "L_km": L_km,
-            "h0": h0,
-            "h1": h1,
-            "delta_deg": delta,
-        }
+    # turn time based on coordinated turn rate
+    rate = max(1e-6, _turn_rate_deg_per_sec(speed_knots, bank_deg))
+    t_turn = delta_abs / rate
+    t_turn = min(t_turn, total_sec)
 
-    bank_candidates = [float(bank_pref_deg)] + list(np.linspace(TURN_BANK_MIN_DEG, TURN_BANK_MAX_DEG, 9))
-    bank_candidates = sorted(list({round(b, 6): b for b in bank_candidates}.values()))
-
-    best = None  # dict with error_km, bank, t_pre, t_turn, t_post, end_lat, end_lon
-
-    # coarse grid search
-    coarse = float(TURN_PRESEARCH_COARSE_SEC)
-    pre_candidates = np.arange(0.0, max(0.0, total_sec) + 1e-9, coarse)
-
-    for b in bank_candidates:
-        rate = _turn_rate_deg_per_sec(speed_knots, b)
-        if rate <= 1e-9:
-            continue
-        t_turn = 0.0 if delta_abs <= 1e-9 else (delta_abs / rate)
-        t_turn = max(0.0, min(float(t_turn), float(total_sec)))
-
-        for t_pre in pre_candidates:
-            t_post = float(total_sec) - float(t_pre) - float(t_turn)
-            if t_post < -1e-9:
-                continue
-            t_post = max(0.0, t_post)
-
-            # simulate:
-            lat, lon = float(RADAR_FIX_LAT), float(RADAR_FIX_LON)
-
-            # pre straight
-            if t_pre > 1e-9:
-                dist_m = float(speed_knots) * 1852.0 * (float(t_pre) / 3600.0)
-                lat, lon = _direct(method, lat, lon, h0, dist_m)
-
-            # turn
-            lat, lon = _simulate_discretized_turn(
-                method, lat, lon, speed_knots,
-                h0, h1, t_turn, sign, delta_abs, step_sec
-            )
-
-            # post straight
-            if t_post > 1e-9:
-                dist_m = float(speed_knots) * 1852.0 * (float(t_post) / 3600.0)
-                lat, lon = _direct(method, lat, lon, h1, dist_m)
-
-            err_km = _haversine_km(lat, lon, float(target_lat), float(target_lon))
-
-            if best is None or err_km < best["error_km"]:
-                best = {
-                    "error_km": float(err_km),
-                    "bank_deg": float(b),
-                    "t_pre": float(t_pre),
-                    "t_turn": float(t_turn),
-                    "t_post": float(t_post),
-                    "end_lat": float(lat),
-                    "end_lon": float(lon),
-                }
-
-    if best is None:
-        return [], {"error": "Unable to construct a valid turn profile."}
-
-    # fine refinement around best t_pre, same bank
-    fine = float(TURN_PRESEARCH_FINE_SEC)
-    t_pre0 = best["t_pre"]
-    b0 = best["bank_deg"]
-    rate0 = _turn_rate_deg_per_sec(speed_knots, b0)
-    t_turn0 = 0.0 if delta_abs <= 1e-9 else (delta_abs / rate0)
-    t_turn0 = max(0.0, min(float(t_turn0), float(total_sec)))
-
-    # search +/- 60 seconds around the best coarse t_pre
-    lo = max(0.0, t_pre0 - 60.0)
-    hi = min(float(total_sec), t_pre0 + 60.0)
-    pre_candidates_fine = np.arange(lo, hi + 1e-9, fine)
-
-    best2 = dict(best)
-    best2["t_turn"] = float(t_turn0)
-
-    for t_pre in pre_candidates_fine:
-        t_post = float(total_sec) - float(t_pre) - float(t_turn0)
-        if t_post < -1e-9:
-            continue
-        t_post = max(0.0, t_post)
+    rem = max(0.0, total_sec - t_turn)
+    t_pre = float(pre_frac) * rem
+    t_post = rem - t_pre
 
-        lat, lon = float(RADAR_FIX_LAT), float(RADAR_FIX_LON)
+    lat, lon = float(RADAR_FIX_LAT), float(RADAR_FIX_LON)
+    legs = []
 
-        if t_pre > 1e-9:
-            dist_m = float(speed_knots) * 1852.0 * (float(t_pre) / 3600.0)
-            lat, lon = _direct(method, lat, lon, h0, dist_m)
+    def _do_segment(hdg, seg_sec):
+        nonlocal lat, lon, legs
+        if seg_sec <= 0.1:
+            return
+        # break into dt steps
+        n = int(math.ceil(seg_sec / dt_sec))
+        for i in range(n):
+            this = min(dt_sec, seg_sec - i * dt_sec)
+            if this <= 0:
+                break
+            legs.append((float(hdg), float(speed_knots), float(this) / 60.0))
+            dist_m = speed_knots * 1852.0 * (this / 3600.0)
+            lat, lon = _direct(method, lat, lon, float(hdg), dist_m)
 
-        lat, lon = _simulate_discretized_turn(
-            method, lat, lon, speed_knots,
-            h0, h1, t_turn0, sign, delta_abs, step_sec
-        )
+    # pre straight
+    _do_segment(h0, t_pre)
 
-        if t_post > 1e-9:
-            dist_m = float(speed_knots) * 1852.0 * (float(t_post) / 3600.0)
-            lat, lon = _direct(method, lat, lon, h1, dist_m)
+    # turn: heading changes smoothly while moving
+    if t_turn > 0.1 and delta_abs > 1e-6:
+        n = int(math.ceil(t_turn / dt_sec))
+        for i in range(n):
+            this = min(dt_sec, t_turn - i * dt_sec)
+            if this <= 0:
+                break
+            # heading at mid-step
+            frac = (min(t_turn, (i + 0.5) * dt_sec) / t_turn)
+            hdg = _wrap_heading_deg(h0 + sign * delta_abs * frac)
+            legs.append((float(hdg), float(speed_knots), float(this) / 60.0))
+            dist_m = speed_knots * 1852.0 * (this / 3600.0)
+            lat, lon = _direct(method, lat, lon, float(hdg), dist_m)
 
-        err_km = _haversine_km(lat, lon, float(target_lat), float(target_lon))
+    # post straight
+    _do_segment(h1, t_post)
 
-        if err_km < best2["error_km"]:
-            best2.update({
-                "error_km": float(err_km),
-                "t_pre": float(t_pre),
-                "t_post": float(t_post),
-                "end_lat": float(lat),
-                "end_lon": float(lon),
-            })
+    return (lat, lon), legs
 
-    # Build legs list from best2
-    t_pre = best2["t_pre"]
-    t_turn = best2["t_turn"]
-    t_post = best2["t_post"]
-    bank_deg = best2["bank_deg"]
 
-    legs = []
-    if t_pre > 1.0:
-        legs.append((h0, float(speed_knots), float(t_pre) / 60.0))
-
-    # discretized turn segments
-    if t_turn > 1.0 and delta_abs > 1e-9:
-        step_sec = max(5.0, float(step_sec))
-        n = int(math.ceil(float(t_turn) / step_sec))
-        if n < 1:
-            n = 1
-        remaining = float(t_turn)
-        for i in range(n):
-            this = min(step_sec, remaining)
-            remaining -= this
-            frac_mid = ((i + 0.5) / n)
-            hdg_mid = _wrap_heading_deg(h0 + sign * delta_abs * frac_mid)
-            legs.append((hdg_mid, float(speed_knots), float(this) / 60.0))
+def build_turn_legs_best(
+    method: str,
+    speed_knots_nominal: float,
+    heading_final_deg: float,
+    target_lat: float,
+    target_lon: float,
+):
+    """
+    Finds the best (bank, pre_straight_frac, speed_factor) to land at 18:40 as smoothly as possible.
+    Produces legs for 18:22→18:40 that are already smooth.
+    If residual error remains, adds a tiny “snap” segment to hit the waypoint exactly (usually meters).
+    """
+    h0 = float(RADAR_INITIAL_TRACK_DEG)
+    h1 = _wrap_heading_deg(float(heading_final_deg))
 
-    if t_post > 1.0:
-        legs.append((h1, float(speed_knots), float(t_post) / 60.0))
+    best = None
+
+    # ---- coarse search
+    bank_vals = np.arange(TURN_BANK_MIN_DEG, TURN_BANK_MAX_DEG + 1e-9, TURN_BANK_STEP_COARSE)
+    pre_vals = np.arange(0.0, 1.0 + 1e-9, TURN_PRE_FRAC_STEP_COARSE)
+    spd_vals = np.arange(TURN_SPEEDFAC_MIN, TURN_SPEEDFAC_MAX + 1e-9, TURN_SPEEDFAC_STEP_COARSE)
+
+    for bank in bank_vals:
+        for pre in pre_vals:
+            for sf in spd_vals:
+                spd = float(speed_knots_nominal) * float(sf)
+                (lat_end, lon_end), legs = _simulate_turn_window(
+                    method=method,
+                    speed_knots=spd,
+                    h0=h0,
+                    h1=h1,
+                    bank_deg=bank,
+                    pre_frac=pre,
+                    dt_sec=TURN_SIM_DT_SEC,
+                )
+                err_km = _haversine_km(lat_end, lon_end, float(target_lat), float(target_lon))
+                if best is None or err_km < best["err_km"]:
+                    best = {
+                        "bank": float(bank),
+                        "pre": float(pre),
+                        "sf": float(sf),
+                        "spd": float(spd),
+                        "err_km": float(err_km),
+                        "legs": legs,
+                        "lat_end": float(lat_end),
+                        "lon_end": float(lon_end),
+                    }
+
+    # ---- fine search around best
+    b0 = best["bank"]
+    p0 = best["pre"]
+    sf0 = best["sf"]
+
+    bank_vals = np.arange(max(TURN_BANK_MIN_DEG, b0 - 2.0), min(TURN_BANK_MAX_DEG, b0 + 2.0) + 1e-9, TURN_BANK_STEP_FINE)
+    pre_vals = np.arange(max(0.0, p0 - 0.10), min(1.0, p0 + 0.10) + 1e-9, TURN_PRE_FRAC_STEP_FINE)
+    spd_vals = np.arange(max(TURN_SPEEDFAC_MIN, sf0 - 0.05), min(TURN_SPEEDFAC_MAX, sf0 + 0.05) + 1e-9, TURN_SPEEDFAC_STEP_FINE)
+
+    for bank in bank_vals:
+        for pre in pre_vals:
+            for sf in spd_vals:
+                spd = float(speed_knots_nominal) * float(sf)
+                (lat_end, lon_end), legs = _simulate_turn_window(
+                    method=method,
+                    speed_knots=spd,
+                    h0=h0,
+                    h1=h1,
+                    bank_deg=bank,
+                    pre_frac=pre,
+                    dt_sec=TURN_SIM_DT_SEC,
+                )
+                err_km = _haversine_km(lat_end, lon_end, float(target_lat), float(target_lon))
+                if err_km < best["err_km"]:
+                    best = {
+                        "bank": float(bank),
+                        "pre": float(pre),
+                        "sf": float(sf),
+                        "spd": float(spd),
+                        "err_km": float(err_km),
+                        "legs": legs,
+                        "lat_end": float(lat_end),
+                        "lon_end": float(lon_end),
+                    }
+
+    legs = list(best["legs"])
+    lat_end = best["lat_end"]
+    lon_end = best["lon_end"]
+    err_km = best["err_km"]
+
+    # Tiny snap-to-waypoint if needed, so 18:40 is exact.
+    # We keep it extremely small by relying on the search to get close.
+    snap_added = False
+    if err_km > 1e-6:
+        if err_km > TURN_FINAL_SNAP_MAX_KM:
+            # still force exact, but we will report it (this indicates search bounds are too tight)
+            pass
+        snap_sec = float(TURN_FINAL_SNAP_SEC)
+        hdg = _initial_bearing_deg(lat_end, lon_end, float(target_lat), float(target_lon))
+        dist_m = err_km * 1000.0
+        spd_kn = (dist_m / 1852.0) / (snap_sec / 3600.0)
+        legs.append((float(hdg), float(spd_kn), snap_sec / 60.0))
+        snap_added = True
 
     info = {
-        "h0": h0,
-        "h1": h1,
-        "delta_deg": float(delta),
-        "bank_deg": float(bank_deg),
-        "pre_min": float(t_pre) / 60.0,
-        "turn_min": float(t_turn) / 60.0,
-        "post_min": float(t_post) / 60.0,
-        "total_min": float(total_sec) / 60.0,
-        "target_lat": float(target_lat),
-        "target_lon": float(target_lon),
-        "end_lat": float(best2["end_lat"]),
-        "end_lon": float(best2["end_lon"]),
-        "error_km": float(best2["error_km"]),
-        "L_km": float(L_km),
-        "d_km": float(d_km),
-        "tol_km": float(TURN_POINT_TOL_KM),
+        "bank_deg": float(best["bank"]),
+        "pre_straight_frac": float(best["pre"]),
+        "speed_factor": float(best["sf"]),
+        "turn_speed_knots": float(best["spd"]),
+        "end_error_km_before_snap": float(err_km),
+        "snap_added": bool(snap_added),
+        "h0": float(h0),
+        "h1": float(h1),
     }
     return legs, info
 
@@ -832,10 +805,6 @@ def _map_marker_times(start_dt, legs):
 
 # ================= CLIP TRAJECTORY TO 00:20 (GUIDED) =================
 def clip_legs_to_end_dt(legs, start_dt: datetime, end_dt: datetime):
-    """
-    Returns a new legs list truncated so total duration ends exactly at end_dt.
-    If legs already shorter than end_dt-start_dt, returns legs unchanged.
-    """
     total_target_sec = (end_dt - start_dt).total_seconds()
     if total_target_sec <= 0:
         return []
@@ -851,7 +820,6 @@ def clip_legs_to_end_dt(legs, start_dt: datetime, end_dt: datetime):
             out.append((float(hdg), float(spd), float(minutes)))
             remaining -= sec
         else:
-            # truncate this leg
             trunc_min = max(0.0, remaining / 60.0)
             if trunc_min > 1e-6:
                 out.append((float(hdg), float(spd), float(trunc_min)))
@@ -1088,13 +1056,6 @@ def add_permanent_label(m, name, lat, lon):
 
 
 def build_leaflet_map(path_pts, legs, method, start_dt):
-    """
-    - Ping rings always drawn
-    - Search areas always drawn (color-coded)
-    - Validation markers are the authoritative markers
-    - Guided mode does NOT draw a purple End marker
-    - Trajectory is clipped to 00:20 in guided mode by clipping legs before simulate_path
-    """
     start_lat, start_lon = path_pts[0]
     is_guided = (start_dt == RADAR_FIX_TIME_UTC)
 
@@ -1239,7 +1200,6 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
             f"Distance flown: {dist_km:.2f} km",
         ]
 
-        # Make final point visually distinct
         if is_final:
             folium.CircleMarker(
                 location=(lat, lon),
@@ -1263,7 +1223,6 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
                 popup=folium.Popup("<br>".join(popup_lines), max_width=360),
             ).add_to(m)
 
-    # Permanent labels
     for name, lat, lon in WAYPOINTS:
         add_permanent_label(m, name, float(lat), float(lon))
 
@@ -1353,7 +1312,6 @@ def solve_guided_straight(
     descent_start_choice, weight_bfo, weight_bto,
     turn_complete_lat, turn_complete_lon
 ):
-    # We clip everything to final 00:20Z; end_dt is fixed by label.
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
@@ -1362,7 +1320,6 @@ def solve_guided_straight(
     best_score = None
     best_turn_info = None
 
-    # descent start
     descent_start_dt = None
     if (descent_start_choice or "").startswith("After Ping Ring 6"):
         descent_start_dt = dt_ping6_utc()
@@ -1371,27 +1328,21 @@ def solve_guided_straight(
 
     h = GUIDED_HEADING_MIN
     while h <= GUIDED_HEADING_MAX + 1e-9:
-        southern_legs = make_legs_from_schedule(h, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
-
-        preturn_legs, turn_info = build_turn_legs_to_point(
-            speed_knots=float(speed_knots),
+        # 1) best smooth turn to the authoritative 18:40 waypoint
+        preturn_legs, turn_info = build_turn_legs_best(
             method=method,
+            speed_knots_nominal=float(speed_knots),
             heading_final_deg=float(h),
             target_lat=float(turn_complete_lat),
             target_lon=float(turn_complete_lon),
-            bank_pref_deg=TURN_BANK_DEFAULT_DEG,
-            step_sec=TURN_STEP_SEC
         )
-        if not preturn_legs and isinstance(turn_info, dict) and turn_info.get("error"):
-            h += STRAIGHT_STEP_DEG
-            continue
 
-        full_legs = preturn_legs + southern_legs
+        # 2) southern legs
+        southern_legs = make_legs_from_schedule(float(h), float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
 
-        # clip to 00:20 so scoring window and plotting window are consistent
+        full_legs = preturn_legs + southern_legs
         full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
 
-        # score using BFO/BTO inside start_dt→end_dt duration only
         s = score_legs_bfo_bto(
             RADAR_FIX_LAT, RADAR_FIX_LON, method, start_dt, end_dt, full_legs,
             alt_ft, vs_fpm, descent_start_dt,
@@ -1406,21 +1357,15 @@ def solve_guided_straight(
         h += STRAIGHT_STEP_DEG
 
     if best_full_legs is None:
-        return None, "Guided solve: not enough ping points to score (or 18:40 point unreachable at chosen speed).", None
-
-    turn_line = ""
-    if isinstance(best_turn_info, dict) and "error_km" in best_turn_info:
-        ek = float(best_turn_info["error_km"])
-        if ek <= TURN_POINT_TOL_KM:
-            turn_line = f"- 18:40 target hit: **OK** (error {ek:.2f} km)\n"
-        else:
-            turn_line = f"- 18:40 target hit: **approx** (error {ek:.2f} km)\n"
+        return None, "Guided solve: not enough ping points to score.", None
 
+    ti = best_turn_info or {}
     report = "\n".join([
-        "**Guided mode: Turn-to-18:40 (user lat/lon) + southern solve, clipped to 00:20**",
-        f"- Speed (constrained): **{float(speed_knots):.1f} kt**",
-        f"- Turn completion target (18:40): **lat {float(turn_complete_lat):.5f}, lon {float(turn_complete_lon):.5f}**",
-        turn_line.rstrip(),
+        "**Guided mode: 18:40 waypoint fixed (authoritative) + BEST smooth turn + southern solve, clipped to 00:20**",
+        f"- Speed (south leg constrained): **{float(speed_knots):.1f} kt**",
+        f"- Turn completion (18:40 fixed): **lat {float(turn_complete_lat):.5f}, lon {float(turn_complete_lon):.5f}**",
+        f"- Best turn bank: **{ti.get('bank_deg', float('nan')):.2f}°** | pre-straight frac: **{ti.get('pre_straight_frac', float('nan')):.2f}** | turn speed factor: **{ti.get('speed_factor', float('nan')):.3f}**",
+        f"- 18:40 residual error before snap: **{ti.get('end_error_km_before_snap', 0.0):.3f} km** | snap added: **{ti.get('snap_added', False)}**",
         f"- Best southern heading: **{best_h:.1f}°**",
         f"- BFO points: **{best_score['n_bfo']}** | RMSE_BFO: **{best_score['rmse_bfo']:.2f} Hz**",
         f"- BTO points: **{best_score['n_bto']}** | RMSE_BTO: **{best_score['rmse_bto']:.1f} µs**" if best_score.get("rmse_bto") is not None else
@@ -1436,7 +1381,6 @@ def solve_guided_straight_with_drift(
     drift_max_deg, drift_weight,
     turn_complete_lat, turn_complete_lon
 ):
-    # lightweight drift version: use nominal heading search, but add a small constant drift
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
@@ -1445,14 +1389,12 @@ def solve_guided_straight_with_drift(
     best_score = None
     best_turn_info = None
 
-    # descent start
     descent_start_dt = None
     if (descent_start_choice or "").startswith("After Ping Ring 6"):
         descent_start_dt = dt_ping6_utc()
     elif (descent_start_choice or "").startswith("After Ping Ring 7"):
         descent_start_dt = dt_ping7_utc()
 
-    # try drift candidates within ±drift_max_deg
     drift_candidates = list(np.arange(-float(drift_max_deg), float(drift_max_deg) + 1e-9, DRIFT_STEP_DEG))
     if not drift_candidates:
         drift_candidates = [0.0]
@@ -1462,23 +1404,16 @@ def solve_guided_straight_with_drift(
         for d in drift_candidates:
             h_eff = _wrap_heading_deg(float(h0) + float(d))
 
-            southern_legs = make_legs_from_schedule(h_eff, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
-
-            preturn_legs, turn_info = build_turn_legs_to_point(
-                speed_knots=float(speed_knots),
+            preturn_legs, turn_info = build_turn_legs_best(
                 method=method,
+                speed_knots_nominal=float(speed_knots),
                 heading_final_deg=float(h_eff),
                 target_lat=float(turn_complete_lat),
                 target_lon=float(turn_complete_lon),
-                bank_pref_deg=TURN_BANK_DEFAULT_DEG,
-                step_sec=TURN_STEP_SEC
             )
-            if not preturn_legs and isinstance(turn_info, dict) and turn_info.get("error"):
-                continue
 
+            southern_legs = make_legs_from_schedule(h_eff, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
             full_legs = preturn_legs + southern_legs
-
-            # clip to 00:20
             full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
 
             s = score_legs_bfo_bto(
@@ -1489,7 +1424,6 @@ def solve_guided_straight_with_drift(
             if s is None:
                 continue
 
-            # add drift penalty (RMS here is just |d| for constant drift)
             combined = float(s["combined"]) + float(drift_weight) * (abs(float(d)) / DRIFT_SCALE_DEG)
 
             if best_score is None or combined < best_score["combined_plus"]:
@@ -1503,21 +1437,15 @@ def solve_guided_straight_with_drift(
         h0 += 1.0
 
     if best_full_legs is None:
-        return None, "Guided drift solve: not enough ping points to score (or 18:40 point unreachable at chosen speed).", None
-
-    turn_line = ""
-    if isinstance(best_turn_info, dict) and "error_km" in best_turn_info:
-        ek = float(best_turn_info["error_km"])
-        if ek <= TURN_POINT_TOL_KM:
-            turn_line = f"- 18:40 target hit: **OK** (error {ek:.2f} km)\n"
-        else:
-            turn_line = f"- 18:40 target hit: **approx** (error {ek:.2f} km)\n"
+        return None, "Guided drift solve: not enough ping points to score.", None
 
+    ti = best_turn_info or {}
     report = "\n".join([
-        "**Guided mode: Turn-to-18:40 (user lat/lon) + southern solve (drift), clipped to 00:20**",
-        f"- Speed (constrained): **{float(speed_knots):.1f} kt**",
-        f"- Turn completion target (18:40): **lat {float(turn_complete_lat):.5f}, lon {float(turn_complete_lon):.5f}**",
-        turn_line.rstrip(),
+        "**Guided mode: 18:40 waypoint fixed (authoritative) + BEST smooth turn + southern solve (drift), clipped to 00:20**",
+        f"- Speed (south leg constrained): **{float(speed_knots):.1f} kt**",
+        f"- Turn completion (18:40 fixed): **lat {float(turn_complete_lat):.5f}, lon {float(turn_complete_lon):.5f}**",
+        f"- Best turn bank: **{ti.get('bank_deg', float('nan')):.2f}°** | pre-straight frac: **{ti.get('pre_straight_frac', float('nan')):.2f}** | turn speed factor: **{ti.get('speed_factor', float('nan')):.3f}**",
+        f"- 18:40 residual error before snap: **{ti.get('end_error_km_before_snap', 0.0):.3f} km** | snap added: **{ti.get('snap_added', False)}**",
         f"- Best nominal heading: **{best_h0:.1f}°**",
         f"- Drift used: **{best_score.get('drift_used', 0.0):+.1f}°** | Drift penalty weight: **{float(drift_weight):.2f}**",
         f"- BFO points: **{best_score['n_bfo']}** | RMSE_BFO: **{best_score['rmse_bfo']:.2f} Hz**",
@@ -1604,7 +1532,6 @@ def score_legs_bfo_bto(
 
 # ================= RUNNERS =================
 def _run_common(start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice):
-    # In guided mode, ensure the polyline ends at 00:20 by clipping legs to end_dt first.
     if start_dt == RADAR_FIX_TIME_UTC:
         end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
         legs = clip_legs_to_end_dt(legs, start_dt, end_dt)
@@ -1614,7 +1541,6 @@ 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)
     stats_md = compute_stats(path_pts, seg_dists_m, total_time_min, legs)
 
-    # BFO plot (restored)
     bfo_fig, bfo_md = bfo_analysis_with_legs(
         start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice
     )
@@ -1650,7 +1576,6 @@ def run_guided(
     drift_max_deg, drift_weight,
     turn_complete_lat, turn_complete_lon
 ):
-    # NOTE: start_lat/start_lon inputs are manual-only; guided always uses RADAR_FIX_LAT/LON.
     spd_knots = speed_from_profile(speed_profile, alt_ft, custom_mach, custom_knots)
 
     if (guided_scenario or "").startswith("Straight + drift"):
@@ -1681,7 +1606,6 @@ def run_guided(
         ], value=[])
         return gr.update(), f"### ❌ {report_md}", "", "", fig, "", alt_fig, empty_table
 
-    # Guided always starts at radar fix
     html_map, stats_md, bfo_fig, bfo_md, alt_fig, headers, rows = _run_common(
         RADAR_FIX_LAT, RADAR_FIX_LON, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice
     )
@@ -1713,7 +1637,7 @@ with gr.Blocks() as demo:
         f"- **Turn completion time (fixed):** 18:40:00Z\n"
         f"- **Initial track (fixed):** {RADAR_INITIAL_TRACK_DEG:.1f}°\n"
         f"- **Final resting point:** **00:20:00Z** (trajectory clipped exactly at this time)\n\n"
-        "✅ **New:** Use the sliders below to set the **18:40 turn-completion lat/lon**. Guided mode will build a plausible turn that ends at that point."
+        "✅ **Auto-turn enabled:** Program finds the best bank + timing + speed-factor to reach the fixed 18:40 waypoint smoothly."
     )
 
     gr.Markdown("### 18:40 Turn Completion Location (Guided mode)")
@@ -1750,7 +1674,7 @@ with gr.Blocks() as demo:
         speed_profile = gr.Dropdown(
             ["MRC Mach 0.82", "LRC Mach 0.84", "ECON Mach 0.80", "Custom Mach", "Custom knots"],
             value="MRC Mach 0.82",
-            label="Speed profile (constrains speed during turn + southern leg)",
+            label="Speed profile (constrains southern leg; turn uses best-fit speed factor)",
         )
         custom_mach = gr.Number(value=0.82, label="Custom Mach (if selected)")
         custom_knots = gr.Number(value=470, label="Custom knots (if selected)")