Merge remote-tracking branch 'origin/sync-20261016' into laneful-sync-20261016

simple
mapd: disable map-based Smart Cruise Control and speed limit sources until mapd has a position source
2026-10-26 00:23:42 +08:00 · 2026-10-18 12:43:54 -04:00 · 2026-10-18 01:06:10 -04:00 · 2026-10-18 00:43:07 -04:00 · 2026-10-18 00:43:07 -04:00 · 2026-10-18 00:43:06 -04:00
52 changed files with 957 additions and 1409 deletions
@@ -115,7 +115,7 @@ jobs:
          env ${TG_FLAGS} python3 ${{ github.workspace }}/${{ env.COMPILER }}/compile_onnx.py \
            ${{ github.workspace }}/${{ env.SMALL_ONNX }} \
            ${{ github.workspace }}/${{ env.SMALL_PKL }} \
-            --out-of-band --benchmark-runs 1
+            --device-input "*" --out-of-band --benchmark-runs 1

      - name: Prepare output
        env:
@@ -440,10 +440,9 @@ jobs:
          TG_FLAGS="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"

          taskset -c 7 env ${TG_FLAGS} python3 \
-            ${{ github.workspace }}/tinygrad_repo/examples/openpilot/compile_onnx.py \
+            ${{ github.workspace }}/tinygrad_repo/examples/openpilot/compile3.py \
            ${{ github.workspace }}/${{ env.DM_ONNX }} \
-            ${{ github.workspace }}/${{ env.DM_PKL }} \
-            --out-of-band --benchmark-runs 1
+            ${{ github.workspace }}/${{ env.DM_PKL }}

      - name: Compile DM warp
        run: |
@@ -58,11 +58,6 @@ jobs:

      - name: Create Pull Request
        uses: peter-evans/create-pull-request@9153d834b60caba6d51c9b9510b087acf9f33f83
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-          GIT_CONFIG_COUNT: 1
-          GIT_CONFIG_KEY_0: credential.https://huggingface.co.helper
-          GIT_CONFIG_VALUE_0: '!f() { test "$1" = get && echo username=user && echo "password=$HF_TOKEN"; }; f'
        with:
          author: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
          token: ${{ secrets.GITHUB_TOKEN }}
@@ -74,7 +69,3 @@ jobs:
          labels: bot
          add-paths: |
            openpilot/sunnypilot/modeld_v2/models/*.pkl
-
-      - name: Reset lfs access
-        if: always()
-        run: git config --local --unset-all "lfs.$(git config -f .lfsconfig lfs.url).access" || true
@@ -33,7 +33,7 @@ jobs:

      - name: LFS Fetch
        run: |
-          git lfs fetch || echo "::warning::some objects are missing on commaai/openpilot-lfs; mirroring the rest"
+          git lfs fetch

      - name: Set up Git
        run: |
@@ -68,7 +68,6 @@ jobs:
          git config lfs.activitytimeout 300
          git config lfs.transfer.maxretries 5
          git config lfs.concurrenttransfers 4
-          git config lfs.allowincompletepush true

      - name: Push LFS
        id: sync-and-commit
@@ -82,80 +81,3 @@ jobs:
          done
          echo "All push attempts failed"
          exit 1
-
-      - name: Checkout sunnypilot
-        uses: actions/checkout@v4
-        with:
-          repository: 'sunnypilot/sunnypilot'
-          path: sunnypilot
-          fetch-depth: 0
-          filter: blob:limit=1k
-          lfs: false
-
-      - name: Reference objects on sunnypilot-lfs
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-        run: |
-          set -euo pipefail
-          GIT_LFS_SKIP_SMUDGE=1 git clone --quiet https://huggingface.co/sunnypilot/sunnypilot-lfs hf-lfs
-          mkdir -p hf-lfs/all
-          cat > scan_pointers.py <<'EOF'
-          import re, subprocess, sys, threading
-          repo = sys.argv[1]
-          chk = subprocess.run(["git", "-C", repo, "cat-file", "--batch-all-objects",
-                                "--batch-check=%(objectname) %(objecttype) %(objectsize)"],
-                               capture_output=True, text=True, check=True).stdout
-          small = [f[0] for f in (l.split() for l in chk.splitlines()) if f[1] == "blob" and int(f[2]) < 1024]
-          p = subprocess.Popen(["git", "-C", repo, "cat-file", "--batch=%(objectsize)"],
-                               stdin=subprocess.PIPE, stdout=subprocess.PIPE)
-          def feed():
-            for sha in small:
-              p.stdin.write(sha.encode() + b"\n")
-            p.stdin.close()
-          threading.Thread(target=feed, daemon=True).start()
-          rx = re.compile(rb"^version https://git-lfs\.github\.com/spec/v1\noid sha256:([0-9a-f]{64})\nsize ([0-9]+)\n")
-          seen = {}
-          for _ in small:
-            n = int(p.stdout.readline()); body = p.stdout.read(n); p.stdout.read(1)
-            m = rx.match(body)
-            if m:
-              seen.setdefault(m.group(1).decode(), m.group(2).decode())
-          for oid, size in sorted(seen.items()):
-            print(oid, size)
-          EOF
-          for repo in . sunnypilot; do
-            python3 scan_pointers.py "$repo"
-          done | sort -u | while read -r oid size; do
-            [ -e "hf-lfs/all/$oid" ] && continue
-            printf 'version https://git-lfs.github.com/spec/v1\noid sha256:%s\nsize %s\n' "$oid" "$size" > "hf-lfs/all/$oid"
-            echo "$oid"
-          done > new_oids.txt
-          echo "new pointer files: $(wc -l < new_oids.txt)"
-
-          dropped=0
-          while mapfile -t -n 100 chunk && ((${#chunk[@]})); do
-            body=$(for oid in "${chunk[@]}"; do
-                     size=$(awk '/^size /{print $2}' "hf-lfs/all/$oid")
-                     printf '{"oid":"%s","size":%s}\n' "$oid" "$size"
-                   done | jq -s '{operation:"download",transfers:["basic"],objects:.}')
-            for attempt in 1 2 3 4 5; do
-              resp=$(curl -sS -u "user:${HF_TOKEN}" -w '\n%{http_code}' \
-                       -H 'Accept: application/vnd.git-lfs+json' -H 'Content-Type: application/vnd.git-lfs+json' \
-                       --data "$body" "${LFS_URL}/objects/batch") && [ "$(tail -n1 <<<"$resp")" = 200 ] && break
-              echo "batch check attempt $attempt failed ($(tail -n1 <<<"$resp")), retrying in 60s"; sleep 60
-            done
-            [ "$(tail -n1 <<<"$resp")" = 200 ] || { echo "batch check failed"; exit 1; }
-            for oid in $(sed '$d' <<<"$resp" | jq -r '.objects[] | select(.error) | .oid'); do
-              rm -f "hf-lfs/all/$oid"; dropped=$((dropped+1))
-            done
-          done < new_oids.txt
-          echo "dropped (not on HF): $dropped"
-
-          cd hf-lfs
-          git add -A all
-          if git diff --cached --quiet; then
-            echo "nothing new to reference"
-            exit 0
-          fi
-          git commit -q -m "Reference $(git diff --cached --name-only | wc -l | tr -d ' ') new LFS objects"
-          git push origin HEAD:main
@@ -594,14 +594,8 @@ jobs:
      - name: Publish chestnut branch
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
        run: |
          CHESTNUT_BRANCH="${{ needs.prepare_strategy.outputs.new_branch }}-chestnut"
-          cp .lfsconfig "${{ env.OUTPUT_DIR }}/"
-          echo 'openpilot/selfdrive/modeld/models/big_*_tinygrad.pkl filter=lfs diff=lfs merge=lfs -text' > "${{ env.OUTPUT_DIR }}/.gitattributes"
-          git lfs install
-          git config --global credential.helper store
-          echo "https://user:${HF_TOKEN}@huggingface.co" > ~/.git-credentials

          ${{ env.CI_DIR }}/publish.sh \
            "${{ github.workspace }}" \
@@ -138,9 +138,6 @@ struct ModelManagerSP @0xaedffd8f31e7b55d {
    status @0 :DownloadStatus;
    progress @1 :Float32;
    eta @2 :UInt32;
-    speed @3 :Float32;
-    canceling @4 :Bool;
-    resuming @5 :Bool;
  }

  struct Chunk {
@@ -256,6 +256,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"LagdValueCache", {PERSISTENT, FLOAT, "0.2"}},
    {"LaneTurnDesire", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"LaneTurnValue", {PERSISTENT | BACKUP, FLOAT, "19.0"}},
+    {"LanefulStrength", {PERSISTENT | BACKUP, FLOAT, "0.0"}},
    {"PlanplusControl", {PERSISTENT | BACKUP, FLOAT, "1.0"}},

    // mapd
@@ -48,9 +48,8 @@ def compile_model(onnx_path, pkl_path):
    Action(cmd, "  [ONNX] $TARGET"),
  )

-if not os.getenv('SKIP_TINYGRAD_COMPILE'):
-  compile_model('models/dmonitoring_model.onnx', 'models/dmonitoring_model_tinygrad.pkl')
-  compile_model('models/driving_supercombo.onnx', 'models/driving_tinygrad.pkl')
+compile_model('models/dmonitoring_model.onnx', 'models/dmonitoring_model_tinygrad.pkl')
+compile_model('models/driving_supercombo.onnx', 'models/driving_tinygrad.pkl')

 model_w, model_h = MEDMODEL_INPUT_SIZE
 for cam_w, cam_h in camera_configs:
@@ -63,7 +62,7 @@ for cam_w, cam_h in camera_configs:
  lenv.Command(warp_pkl_path, tinygrad_files + warp_deps + [Value(cmd)], cmd)

 dm_w, dm_h = DM_INPUT_SIZE
-for cam_w, cam_h in [] if os.getenv('SKIP_TINYGRAD_COMPILE') else camera_configs:
+for cam_w, cam_h in camera_configs:
  dm_pkl_path = File(f"models/dm_warp_{cam_w}x{cam_h}_tinygrad.pkl").abspath
  stride, y_height, uv_height, frame_size = get_nv12_info(cam_w, cam_h)
  cmd = (f'{tg_flags} {mac_brew_string} python3 "{compiler}/compile_warp.py" '
@@ -7,7 +7,6 @@ from functools import cached_property
 import os
 os.environ['GMMU'] = '0' # for chestnut fast loading, noop for qcom
 os.environ.setdefault('AM_POWER_LIMIT', '100')
-os.environ.setdefault('AM_PERF_LEVEL', 'high')
 from tinygrad.device import Buffer, Device
 from tinygrad.dtype import DType, dtypes
 from tinygrad.engine.realize import lower_and_compile
@@ -14,7 +14,6 @@ from openpilot.system.ui.lib.application import gui_app
 if gui_app.sunnypilot_ui():
  from openpilot.selfdrive.ui.sunnypilot.mici.layouts.settings import SettingsLayoutSP as SettingsLayout
  from openpilot.selfdrive.ui.sunnypilot.mici.layouts.home import MiciHomeLayoutSP as MiciHomeLayout
-  from openpilot.selfdrive.ui.sunnypilot.mici.layouts.onroad import OnroadViewContainerSP as AugmentedRoadView

 ONROAD_DELAY = 2.5  # seconds

@@ -73,9 +72,6 @@ class MiciMainLayout(Scroller):
    # For scroll_to
    return self._body_onroad_layout if ui_state.is_body else self._car_onroad_layout

-  def _should_auto_scroll_to_onroad(self) -> bool:
-    return True
-
  def _setup_callbacks(self):
    self._alerts_layout.set_enabled(lambda: self.enabled)
    self._alerts_layout.set_pairing_callback(self._settings_layout.show_pairing)
@@ -128,15 +124,13 @@ class MiciMainLayout(Scroller):

    # FIXME: these two pops can interrupt user interacting in the settings
    if self._onroad_time_delay is not None and rl.get_time() - self._onroad_time_delay >= ONROAD_DELAY:
-      if not gui_app.sunnypilot_ui() or self._should_auto_scroll_to_onroad():
-        gui_app.pop_widgets_to(self, lambda: self._scroll_to(self._onroad_layout))
+      gui_app.pop_widgets_to(self, lambda: self._scroll_to(self._onroad_layout))
      self._onroad_time_delay = None

    # When car leaves standstill, pop nav stack and scroll to onroad
    CS = ui_state.sm["carState"]
    if not CS.standstill and self._prev_standstill:
-      if not gui_app.sunnypilot_ui() or self._should_auto_scroll_to_onroad():
-        gui_app.pop_widgets_to(self, lambda: self._scroll_to(self._onroad_layout))
+      gui_app.pop_widgets_to(self, lambda: self._scroll_to(self._onroad_layout))
    self._prev_standstill = CS.standstill

  def _on_interactive_timeout(self):
@@ -206,6 +206,8 @@ class AugmentedRoadView(CameraView):
  def _handle_mouse_release(self, mouse_pos: MousePos):
    # Don't trigger click callback if bookmark was triggered
    if not self._bookmark_icon.interacting():
+      if self._model_renderer.laneful.handle_tap(mouse_pos):
+        return
      super()._handle_mouse_release(mouse_pos)

  def _render(self, _):
@@ -141,6 +141,7 @@ class ModelRenderer(Widget, ModelRendererSP):
    if ui_state.status != UIStatus.DISENGAGED:
      self._draw_lane_lines()
      self._draw_path()
+      self.laneful.draw(self._rect)

    if render_lead_indicator:
      self._update_leads(sm)
@@ -219,6 +220,7 @@ class ModelRenderer(Widget, ModelRendererSP):
    # Update road edges using raw points
    for road_edge in self._road_edges:
      road_edge.projected_points = self._map_line_to_polygon(road_edge.raw_points, line_width_factor, 0.0, max_idx)
+    self.laneful.update(self, max_idx)

    # Update path using raw points
    if lead and lead.present:
@@ -8,6 +8,7 @@ from enum import IntEnum

 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.cruise_sub_layouts.speed_limit_settings import SpeedLimitSettingsLayout
 from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.sunnypilot.mapd import MAPD_AVAILABLE
 from openpilot.system.ui.lib.multilang import tr, tr_noop
 from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp, option_item_sp, simple_button_item_sp
 from openpilot.system.ui.widgets import Widget
@@ -29,6 +30,7 @@ ACC_ENABLED_DESCRIPTION = tr_noop("Enable custom Short & Long press increments f
 ACC_NOLONG_DESCRIPTION = tr_noop("This feature can only be used with sunnypilot longitudinal control enabled.")
 ACC_PCMCRUISE_DISABLED_DESCRIPTION = tr_noop("This feature is not supported on this platform due to vehicle limitations.")
 ONROAD_ONLY_DESCRIPTION = tr_noop("Start the vehicle to check vehicle compatibility.")
+MAP_UNAVAILABLE_DESCRIPTION = tr_noop("Map data is temporarily unavailable.")


 class CruiseLayout(Widget):
@@ -54,7 +56,8 @@ class CruiseLayout(Widget):

    self.scc_m_toggle = toggle_item_sp(
      title=tr("Smart Cruise Control - Map"),
-      description=tr("Use map data to estimate the appropriate speed to drive through turns ahead."),
+      description=(f"<b>{tr(MAP_UNAVAILABLE_DESCRIPTION)}</b>\n\n" if not MAPD_AVAILABLE else "") +
+                  tr("Use map data to estimate the appropriate speed to drive through turns ahead."),
      param="SmartCruiseControlMap")

    self.custom_acc_toggle = toggle_item_sp(
@@ -139,7 +142,7 @@ class CruiseLayout(Widget):
      if has_long or has_icbm:
        self.custom_acc_toggle.action_item.set_enabled(((has_long and not ui_state.CP.pcmCruise) or has_icbm) and ui_state.is_offroad())
        self.scc_v_toggle.action_item.set_enabled(True)
-        self.scc_m_toggle.action_item.set_enabled(True)
+        self.scc_m_toggle.action_item.set_enabled(MAPD_AVAILABLE)
      else:
        ui_state.params.remove("CustomAccIncrementsEnabled")
        ui_state.params.remove("SmartCruiseControlVision")
@@ -8,6 +8,8 @@ from collections.abc import Callable

 import pyray as rl
 from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.sunnypilot.mapd import MAPD_AVAILABLE
+from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.common import Policy
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.sunnypilot.widgets.list_view import multiple_button_item_sp
 from openpilot.system.ui.widgets.network import NavButton
@@ -43,6 +45,8 @@ class SpeedLimitPolicyLayout(Widget):
      param="SpeedLimitPolicy",
      button_width=250,
    )
+    if not MAPD_AVAILABLE:
+      self._speed_limit_policy.action_item.set_enabled_buttons({Policy.car_state_only})

    items = [
      self._speed_limit_policy
@@ -51,6 +55,8 @@ class SpeedLimitPolicyLayout(Widget):

  @staticmethod
  def _get_policy_description():
+    if not MAPD_AVAILABLE:
+      return f"<b>{tr('Map data is temporarily unavailable. Using Speed Limit data only from Car.')}</b>"
    return get_highlighted_description(ui_state.params, "SpeedLimitPolicy", SPEED_LIMIT_POLICY_DESCRIPTIONS)

  def _render(self, rect):
@@ -235,8 +235,6 @@ class ModelsLayout(Widget):
    progress = sum(p.progress for p in progresses) / len(progresses)
    ds = custom.ModelManagerSP.DownloadStatus

-    if any(p.canceling for p in progresses):
-      return {"name": name, "downloading": True, "progress": progress, "status_text": tr("canceling...")}
    if ds.failed in statuses:
      # close.png is authored black and a tint cannot lift it, hence close2
      return {"name": name, "status_text": tr("download failed"), "text_color": rl.RED, "icon": "icons/close2.png"}
@@ -0,0 +1,39 @@
+"""
+Copyright (c) 2021-, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+from openpilot.selfdrive.ui.mici.widgets.button import BigMultiToggle
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.system.ui.widgets.scroller import NavScroller
+
+# above 1.0 the pull overshoots lane center and ping-pongs
+STRENGTHS = {"off": 0.0, "gentle": 0.5, "firm": 1.0}
+
+
+class LanefulStrengthToggle(BigMultiToggle):
+  """Tap to cycle LanefulStrength, like the driving personality toggle."""
+  def __init__(self):
+    super().__init__("laneful strength", list(STRENGTHS), select_callback=self._on_select,
+                     description="Nudges the car toward lane center.\n" +
+                                 "Firm centers faster than gentle.")
+    self.refresh()
+
+  def refresh(self):
+    strength = ui_state.params.get("LanefulStrength", return_default=True)
+    self.set_value(min(STRENGTHS, key=lambda k: abs(STRENGTHS[k] - strength)))
+
+  def _on_select(self, value: str):
+    ui_state.params.put("LanefulStrength", STRENGTHS[value])
+
+
+class LanefulLayoutMici(NavScroller):
+  def __init__(self):
+    super().__init__()
+    self._strength = LanefulStrengthToggle()
+    self._scroller.add_widget(self._strength)
+
+  def show_event(self):
+    super().show_event()
+    self._strength.refresh()
@@ -1,19 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-from openpilot.selfdrive.ui.mici.layouts.main import MiciMainLayout
-from openpilot.selfdrive.ui.sunnypilot.mici.widgets.scroll_panel_sp import GuiScrollPanel2SP
-
-
-class MiciMainLayoutSP(MiciMainLayout):
-  def __init__(self):
-    super().__init__()
-    scroller = self._scroller
-    scroller.scroll_panel = GuiScrollPanel2SP(scroller._horizontal, handle_out_of_bounds=not scroller._snap_items)
-
-  def _should_auto_scroll_to_onroad(self) -> bool:
-    return not self._onroad_layout.is_on_info_panel()
@@ -251,12 +251,11 @@ class ModelsLayoutMici(NavScroller):
      self.current_model_info.info_text.set_text(tr("download failed"))

    elif manager.selectedBundle and manager.selectedBundle.status == custom.ModelManagerSP.DownloadStatus.downloading:
-      self.cancel_download_btn.set_visible(ui_state.params.get("ModelManager_DownloadRef") is not None)
+      self.cancel_download_btn.set_visible(True)
      device.set_override_interactive_timeout(5)
      progress = 0.0
      count = 0
      verifying = False
-      canceling = False
      for model in manager.selectedBundle.models:
        count += 1
        p = model.artifact.downloadProgress
@@ -264,13 +263,11 @@ class ModelsLayoutMici(NavScroller):
                        custom.ModelManagerSP.DownloadStatus.verifying):
          progress += p.progress
          verifying = verifying or p.status == custom.ModelManagerSP.DownloadStatus.verifying
-          canceling = canceling or p.canceling
        elif p.status in (custom.ModelManagerSP.DownloadStatus.downloaded,
                          custom.ModelManagerSP.DownloadStatus.cached):
          progress += 100.0

-      header = tr("canceling...") if canceling else tr("verifying") if verifying else tr("downloading")
-      self.current_model_info.current_model_header.set_text(header)
+      self.current_model_info.current_model_header.set_text(tr("verifying") if verifying else tr("downloading"))
      self.cancel_download_btn.set_text(tr("cancel verification") if verifying else tr("cancel download"))
      self.current_model_info.current_model_header._shimmer = True
      name_text = manager.selectedBundle.internalName.lower()
@@ -1,64 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from collections.abc import Callable
-import pyray as rl
-from openpilot.system.ui.lib.application import gui_app
-from openpilot.selfdrive.ui.sunnypilot.mici.widgets.scroller_sp import ScrollerSP
-from openpilot.selfdrive.ui.sunnypilot.mici.onroad.augmented_road_view import AugmentedRoadViewSP
-from openpilot.selfdrive.ui.sunnypilot.mici.layouts.onroad_info_panel import OnroadInfoPanel
-
-CONFIDENCE_BALL_VISIBLE_RATIO = 0.4
-HORIZONTAL_SETTLE_PX = 5
-HORIZONTAL_RESET_RATIO = 0.5
-
-
-class OnroadViewContainerSP(ScrollerSP):
-  def __init__(self, bookmark_callback=None):
-    super().__init__(horizontal=False, snap_items=True, spacing=0, pad=0, scroll_indicator=False, edge_shadows=False)
-    self.road_view = AugmentedRoadViewSP(bookmark_callback=bookmark_callback)
-    self.onroad_info_panel = OnroadInfoPanel(bookmark_callback=bookmark_callback)
-
-    self._scroller.add_widgets([
-      self.road_view,
-      self.onroad_info_panel,
-    ])
-    self._scroller.set_reset_scroll_at_show(False)
-    self._scroller.set_scrolling_enabled(lambda: abs(self.rect.x) < HORIZONTAL_SETTLE_PX)
-
-    for child in (self.road_view, self.onroad_info_panel):
-      inner_touch_valid = child._touch_valid_callback
-      child.set_touch_valid_callback(
-        lambda inner=inner_touch_valid: self._touch_valid() and (inner() if inner else True)
-      )
-
-  def set_rect(self, rect: rl.Rectangle):
-    super().set_rect(rect)
-    self.road_view.set_rect(rect)
-    self.onroad_info_panel.set_rect(rect)
-    return self
-
-  def is_swiping_left(self) -> bool:
-    return self.road_view.is_swiping_left() or self.onroad_info_panel.is_swiping_left()
-
-  def set_click_callback(self, click_callback: Callable[[], None] | None) -> None:
-    self.road_view.set_click_callback(click_callback)
-    self.onroad_info_panel.set_click_callback(click_callback)
-
-  def is_on_info_panel(self) -> bool:
-    """True when scrolled past halfway toward onroad_info_panel (used by main layout
-    to skip auto-pop-back-to-camera while user is reading the info panel)."""
-    return abs(self._scroller.scroll_panel.get_offset()) > self._rect.height / 2
-
-  def _render(self, rect: rl.Rectangle):
-    if abs(self.rect.x) > gui_app.width * HORIZONTAL_RESET_RATIO:
-      self._scroller.scroll_panel.set_offset(0)
-
-    vertical_offset = self._scroller.scroll_panel.get_offset()
-    show_ball = abs(vertical_offset) < rect.height * CONFIDENCE_BALL_VISIBLE_RATIO
-    self.road_view.set_show_confidence_ball(show_ball)
-
-    super()._render(rect)
@@ -1,403 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import pyray as rl
-from dataclasses import dataclass, field
-from openpilot.common.constants import CV
-from openpilot.common.filter_simple import FirstOrderFilter
-from openpilot.selfdrive.ui.ui_state import ui_state
-from openpilot.system.ui.lib.application import gui_app, FontWeight, MousePos
-from openpilot.system.ui.lib.multilang import tr
-from openpilot.system.ui.lib.text_measure import measure_text_cached
-from openpilot.system.ui.widgets import Widget
-from openpilot.selfdrive.ui.mici.onroad.alert_renderer import AlertRenderer
-from openpilot.selfdrive.ui.mici.onroad.augmented_road_view import BookmarkIcon
-
-METER_TO_KM = 0.001
-METER_TO_MILE = 0.000621371
-
-CONTENT_MARGIN = 16
-SPEED_LIMIT_SIGN_WIDTH = 146
-VIENNA_SIGN_SIZE = 146
-MUTCD_SIGN_HEIGHT = 178
-OFFSET_BADGE_SIZE = 50
-OFFSET_BADGE_PANEL_PADDING = 4
-MUTCD_OFFSET_SIGN_Y_SHIFT = 6
-VIENNA_BADGE_X_RATIO = 0.80
-VIENNA_BADGE_UPCOMING_X_RATIO = 0.70
-VIENNA_BADGE_Y_RATIO = -0.82
-UPCOMING_SIGN_SIZE_RATIO = 0.76
-UPCOMING_SIGN_OVERLAP_RATIO = 0.05
-UNIT_FONT_SIZE = 40
-SPEED_FONT_SIZE = 114
-ROAD_FONT_SIZE = 32
-SCC_TAG_WIDTH = 78
-SCC_TAG_HEIGHT = 30
-SCC_TAG_GAP = 5
-COLUMN_GAP = 12
-
-
-@dataclass(frozen=True)
-class OnroadInfoPanelColors:
-  white: rl.Color = rl.WHITE
-  black: rl.Color = rl.BLACK
-  red: rl.Color = field(default_factory=lambda: rl.Color(255, 0, 0, 255))
-  green: rl.Color = field(default_factory=lambda: rl.Color(0, 255, 0, 255))
-  grey: rl.Color = field(default_factory=lambda: rl.Color(190, 195, 190, 255))
-  light_grey: rl.Color = field(default_factory=lambda: rl.Color(200, 200, 200, 255))
-  dark_grey: rl.Color = field(default_factory=lambda: rl.Color(100, 100, 100, 255))
-  bg_dark: rl.Color = field(default_factory=lambda: rl.Color(0, 0, 0, 255))
-  card_bg: rl.Color = field(default_factory=lambda: rl.Color(50, 50, 50, 200))
-  badge_bg: rl.Color = field(default_factory=lambda: rl.Color(60, 60, 60, 255))
-
-
-COLORS = OnroadInfoPanelColors()
-
-
-class OnroadInfoPanel(Widget):
-  def __init__(self, bookmark_callback=None):
-    super().__init__()
-    self.speed_limit: float = 0.0
-    self.speed_limit_valid: bool = False
-    self.speed_limit_offset: float = 0.0
-    self.next_speed_limit: float = 0.0
-    self.next_speed_limit_distance: float = 0.0
-    self.road_name: str = ""
-    self.current_speed: float = 0.0
-    self.set_speed: float = 0.0
-    self.cruise_enabled: bool = False
-
-    self._sign_slide: float = 0.0
-
-    self._font_bold: rl.Font = gui_app.font(FontWeight.BOLD)
-    self._font_semi_bold: rl.Font = gui_app.font(FontWeight.SEMI_BOLD)
-    self._font_medium: rl.Font = gui_app.font(FontWeight.MEDIUM)
-
-    self._marquee_offset: float = 0.0
-    self._marquee_direction: int = 1
-    self._marquee_pause_timer: float = 0.0
-    self._marquee_speed: float = 40.0
-    self._marquee_pause_duration: float = 1.5
-
-    self._alert_renderer = AlertRenderer()
-    self._alert_alpha_filter = FirstOrderFilter(0, 0.05, 1 / gui_app.target_fps)
-
-    self._bookmark_icon = BookmarkIcon(bookmark_callback)
-
-  def is_swiping_left(self) -> bool:
-    return self._bookmark_icon.is_swiping_left()
-
-  def _handle_mouse_release(self, mouse_pos: MousePos) -> None:
-    # Mirror stock AugmentedRoadView: suppress click while bookmark gesture active
-    if not self._bookmark_icon.interacting():
-      super()._handle_mouse_release(mouse_pos)
-
-  def _update_state(self) -> None:
-    sm = ui_state.sm
-    speed_conv = CV.MS_TO_KPH if ui_state.is_metric else CV.MS_TO_MPH
-
-    if sm.valid["longitudinalPlanSP"]:
-      lp_sp = sm["longitudinalPlanSP"]
-      resolver = lp_sp.speedLimit.resolver
-      self.speed_limit = resolver.speedLimit * speed_conv
-      self.speed_limit_valid = resolver.speedLimitValid
-      self.speed_limit_offset = resolver.speedLimitOffset * speed_conv
-
-    if sm.valid["liveMapDataSP"]:
-      lmd = sm["liveMapDataSP"]
-      self.next_speed_limit = lmd.speedLimitAhead * speed_conv
-      self.next_speed_limit_distance = lmd.speedLimitAheadDistance
-      self.road_name = lmd.roadName
-
-    if sm.updated["carState"]:
-      self.current_speed = sm["carState"].vEgo * speed_conv
-
-    if sm.valid["carState"] and sm.valid["controlsState"]:
-      self.cruise_enabled = sm["carState"].cruiseState.enabled
-      v_cruise_cluster = sm["carState"].vCruiseCluster
-      set_speed_kph = sm["controlsState"].vCruiseDEPRECATED if v_cruise_cluster == 0.0 else v_cruise_cluster
-      self.set_speed = set_speed_kph * (METER_TO_MILE / METER_TO_KM) if not ui_state.is_metric else set_speed_kph
-
-  def _render(self, rect: rl.Rectangle) -> None:
-    self._update_state()
-
-    rl.draw_rectangle(int(rect.x), int(rect.y), int(rect.width), int(rect.height), COLORS.bg_dark)
-
-    left_x = rect.x + CONTENT_MARGIN
-
-    if self.cruise_enabled:
-      unit = tr("MAX")
-      display_speed = self.set_speed
-    else:
-      unit = tr("km/h") if ui_state.is_metric else tr("MPH")
-      display_speed = self.current_speed
-
-    display_speed_text = str(round(display_speed))
-    if self.speed_limit_valid and display_speed > self.speed_limit:
-      speed_color = COLORS.red
-    else:
-      speed_color = COLORS.white
-
-    sign_width = min(SPEED_LIMIT_SIGN_WIDTH, rect.width * 0.30)
-    sign_height = VIENNA_SIGN_SIZE if ui_state.is_metric else MUTCD_SIGN_HEIGHT
-
-    has_upcoming_limit = self.next_speed_limit > 0 and self.next_speed_limit != self.speed_limit
-    target_sign_slide = 1.0 if has_upcoming_limit else 0.0
-    slide_speed = 3.0 * rl.get_frame_time()
-    if self._sign_slide < target_sign_slide:
-      self._sign_slide = min(self._sign_slide + slide_speed, target_sign_slide)
-    elif self._sign_slide > target_sign_slide:
-      self._sign_slide = max(self._sign_slide - slide_speed, target_sign_slide)
-
-    upcoming_width = int(sign_width * UPCOMING_SIGN_SIZE_RATIO)
-    upcoming_height = int(sign_height * UPCOMING_SIGN_SIZE_RATIO)
-    upcoming_reserved_width = int(upcoming_width * 0.85) + 5
-    sign_x_without_upcoming = rect.x + rect.width - sign_width - CONTENT_MARGIN
-    sign_x_with_upcoming = rect.x + rect.width - sign_width - CONTENT_MARGIN - upcoming_reserved_width
-    sign_x = sign_x_without_upcoming + (sign_x_with_upcoming - sign_x_without_upcoming) * self._sign_slide
-    sign_y = rect.y + (rect.height - sign_height) / 2
-    if not ui_state.is_metric and self.speed_limit_offset != 0 and self.speed_limit_valid:
-      sign_y += MUTCD_OFFSET_SIGN_Y_SHIFT
-
-    readout_right = sign_x - COLUMN_GAP
-    readout_width = max(1, readout_right - left_x)
-    road_y = rect.y + rect.height - 44
-
-    unit_font_size = self._fit_font_size(self._font_semi_bold, unit, readout_width, 46, UNIT_FONT_SIZE, 28)
-    speed_font_size = self._fit_font_size(self._font_bold, display_speed_text, readout_width, road_y - (rect.y + 54) - 8,
-                                          SPEED_FONT_SIZE, 76)
-    speed_size = measure_text_cached(self._font_bold, display_speed_text, speed_font_size)
-    speed_y = min(rect.y + 54, road_y - speed_size.y - 8)
-    unit_y = max(rect.y + 14, speed_y - unit_font_size - 6)
-
-    rl.draw_text_ex(self._font_semi_bold, unit, rl.Vector2(left_x, unit_y), unit_font_size, 0, COLORS.grey)
-    rl.draw_text_ex(self._font_bold, display_speed_text, rl.Vector2(left_x, speed_y), speed_font_size, 0, speed_color)
-    self._draw_road_name(left_x, road_y, readout_width)
-
-    if has_upcoming_limit and self._sign_slide > 0.01:
-      upcoming_speed_text = str(round(self.next_speed_limit))
-      distance_text = self._format_distance(self.next_speed_limit_distance)
-      upcoming_x = sign_x + sign_width - int(upcoming_width * UPCOMING_SIGN_OVERLAP_RATIO)
-      upcoming_y = sign_y + (sign_height - upcoming_height) / 2
-
-      upcoming_speed_color = COLORS.black
-      if ui_state.is_metric:
-        self._draw_vienna_sign(upcoming_x, upcoming_y, upcoming_width, upcoming_height, upcoming_speed_text, upcoming_speed_color, is_upcoming=True)
-      else:
-        self._draw_mutcd_sign(upcoming_x, upcoming_y, upcoming_width, upcoming_height, upcoming_speed_text, upcoming_speed_color, is_upcoming=True)
-
-      distance_font_size = self._fit_font_size(self._font_medium, distance_text, upcoming_width, 30, 24, 16)
-      distance_size = measure_text_cached(self._font_medium, distance_text, distance_font_size)
-      rl.draw_text_ex(self._font_medium, distance_text, rl.Vector2(upcoming_x + upcoming_width / 2 - distance_size.x / 2, upcoming_y + upcoming_height),
-                      distance_font_size, 0, COLORS.grey)
-
-    self._draw_speed_limit_sign(sign_x, sign_y, sign_width, sign_height)
-
-    if self.speed_limit_offset != 0 and self.speed_limit_valid:
-      offset_text = str(abs(round(self.speed_limit_offset)))
-      badge_size = OFFSET_BADGE_SIZE
-      badge_rect = self._offset_badge_rect(rect, sign_x, sign_y, sign_width, sign_height, badge_size, has_upcoming_limit)
-
-      if ui_state.is_metric:
-        badge_radius = badge_size / 2
-        badge_center_x = badge_rect.x + badge_radius
-        badge_center_y = badge_rect.y + badge_radius
-        rl.draw_circle(int(badge_center_x), int(badge_center_y), badge_radius + 2, COLORS.dark_grey)
-        rl.draw_circle(int(badge_center_x), int(badge_center_y), badge_radius, COLORS.badge_bg)
-        self._draw_text_centered_fit(self._font_bold, offset_text, 32, rl.Vector2(badge_center_x, badge_center_y), COLORS.white,
-                                     badge_size - 10, badge_size - 8, min_size=24)
-      else:
-        rl.draw_rectangle_rounded(badge_rect, 0.25, 10, COLORS.badge_bg)
-        rl.draw_rectangle_rounded_lines_ex(badge_rect, 0.25, 10, 2, COLORS.dark_grey)
-        self._draw_text_centered_fit(self._font_bold, offset_text, 32, rl.Vector2(badge_rect.x + badge_size / 2, badge_rect.y + badge_size / 2),
-                                     COLORS.white, badge_size - 10, badge_size - 8, min_size=24)
-
-    scc_tag_x = min(left_x + speed_size.x + COLUMN_GAP, readout_right - SCC_TAG_WIDTH)
-    scc_tag_y = speed_y + (speed_size.y - (SCC_TAG_HEIGHT * 2 + SCC_TAG_GAP)) / 2
-    if scc_tag_x >= left_x + speed_size.x + 8:
-      self._draw_scc_icons(scc_tag_x, scc_tag_y, readout_right)
-
-    self._bookmark_icon.render(rect)
-
-    if ui_state.started:
-      alert_obj, no_alert = self._alert_renderer.will_render()
-      self._alert_alpha_filter.update(0 if no_alert else 1)
-      alpha = self._alert_alpha_filter.x
-      if alpha > 0.01:
-        rl.draw_rectangle(int(rect.x), int(rect.y), int(rect.width), int(rect.height), rl.Color(0, 0, 0, int(150 * alpha)))
-      self._alert_renderer.render(rect)
-
-  def _draw_scc_icons(self, x: float, y: float, right_limit: float) -> None:
-    sm = ui_state.sm
-    if not sm.valid["longitudinalPlanSP"]:
-      return
-    scc = sm["longitudinalPlanSP"].smartCruiseControl
-
-    drawn = 0
-
-    for label, active in [("SCC-V", scc.vision.active), ("SCC-M", scc.map.active)]:
-      if not active:
-        continue
-      tag_x = x
-      if tag_x + SCC_TAG_WIDTH > right_limit:
-        return
-      tag_y = y + drawn * (SCC_TAG_HEIGHT + SCC_TAG_GAP)
-      rl.draw_rectangle_rounded(rl.Rectangle(tag_x, tag_y, SCC_TAG_WIDTH, SCC_TAG_HEIGHT), 0.3, 10, COLORS.green)
-      self._draw_text_centered_fit(self._font_bold, label, 18, rl.Vector2(tag_x + SCC_TAG_WIDTH / 2, tag_y + SCC_TAG_HEIGHT / 2), COLORS.black,
-                                   SCC_TAG_WIDTH - 10, SCC_TAG_HEIGHT - 4, min_size=14)
-      drawn += 1
-
-  def _draw_speed_limit_sign(self, x: float, y: float, sign_width: float, sign_height: float) -> None:
-    speed_str = str(round(self.speed_limit)) if self.speed_limit_valid and self.speed_limit > 0 else "--"
-    speed_color = COLORS.black if not self.speed_limit_valid or self.current_speed <= self.speed_limit else COLORS.red
-
-    if ui_state.is_metric:
-      self._draw_vienna_sign(x, y, sign_width, sign_height, speed_str, speed_color, is_upcoming=False)
-    else:
-      self._draw_mutcd_sign(x, y, sign_width, sign_height, speed_str, speed_color, is_upcoming=False)
-
-  def _draw_road_name(self, x: float, y: float, width: float) -> None:
-    if width <= 0:
-      return
-
-    road_display = self.road_name if self.road_name else "--"
-    font_size = self._fit_font_size(self._font_semi_bold, road_display, width, 38, ROAD_FONT_SIZE, 28)
-    road_size = measure_text_cached(self._font_semi_bold, road_display, font_size)
-    text_width = road_size.x
-
-    if text_width <= width:
-      self._marquee_offset = 0.0
-      self._marquee_direction = 1
-      self._marquee_pause_timer = 0.0
-      rl.draw_text_ex(self._font_semi_bold, road_display, rl.Vector2(x, y), font_size, 0, COLORS.white)
-    else:
-      overflow = text_width - width
-      dt = rl.get_frame_time()
-
-      if self._marquee_pause_timer > 0:
-        self._marquee_pause_timer -= dt
-      else:
-        self._marquee_offset += self._marquee_direction * self._marquee_speed * dt
-
-        if self._marquee_offset >= overflow:
-          self._marquee_offset = overflow
-          self._marquee_direction = -1
-          self._marquee_pause_timer = self._marquee_pause_duration
-        elif self._marquee_offset <= 0:
-          self._marquee_offset = 0
-          self._marquee_direction = 1
-          self._marquee_pause_timer = self._marquee_pause_duration
-
-      rl.begin_scissor_mode(int(x), int(y), int(width), int(road_size.y + 4))
-      text_pos = rl.Vector2(x - self._marquee_offset, y)
-      rl.draw_text_ex(self._font_semi_bold, road_display, text_pos, font_size, 0, COLORS.white)
-      rl.end_scissor_mode()
-
-  def _draw_vienna_sign(self, x: float, y: float, width: float, height: float, speed_str: str, speed_color: rl.Color, is_upcoming: bool = False) -> None:
-    center = rl.Vector2(x + width / 2, y + height / 2)
-    outer_radius = min(width, height) / 2
-
-    rl.draw_circle_v(center, outer_radius, COLORS.white)
-    ring_width = outer_radius * 0.18
-    rl.draw_ring(center, outer_radius - ring_width, outer_radius, 0, 360, 36, COLORS.red)
-
-    font_size = outer_radius * (0.7 if len(speed_str) >= 3 else 0.9)
-    self._draw_text_centered_fit(self._font_bold, speed_str, int(font_size), center, speed_color, width * 0.72, height * 0.50, min_size=24)
-
-  def _draw_mutcd_sign(self, x: float, y: float, width: float, height: float, speed_str: str, speed_color: rl.Color, is_upcoming: bool = False) -> None:
-    sign_rect = rl.Rectangle(x, y, width, height)
-    rl.draw_rectangle_rounded(sign_rect, 0.35, 10, COLORS.white)
-
-    inset = max(4, width * 0.05)
-    inner_rect = rl.Rectangle(x + inset, y + inset, width - inset * 2, height - inset * 2)
-    outer_radius = 0.35 * width / 2.0
-    inner_radius = outer_radius - inset
-    inner_roundness = inner_radius / (inner_rect.width / 2.0)
-    rl.draw_rectangle_rounded_lines_ex(inner_rect, inner_roundness, 10, 3, COLORS.black)
-
-    mid_x = x + width / 2
-    label_size = max(18, int(width * 0.26))
-    if is_upcoming:
-      self._draw_text_centered_fit(self._font_bold, tr("AHEAD"), int(width * 0.34), rl.Vector2(mid_x, y + height * 0.28), COLORS.black,
-                                   width * 0.94, height * 0.32, min_size=20)
-    else:
-      self._draw_text_centered_fit(self._font_bold, tr("SPEED"), label_size, rl.Vector2(mid_x, y + height * 0.20), COLORS.black,
-                                   width * 0.84, height * 0.24, min_size=16)
-      self._draw_text_centered_fit(self._font_bold, tr("LIMIT"), label_size, rl.Vector2(mid_x, y + height * 0.40), COLORS.black,
-                                   width * 0.84, height * 0.24, min_size=16)
-
-    speed_font_size = int(width * 0.60) if len(speed_str) >= 3 else int(width * 0.72)
-    self._draw_text_centered_fit(self._font_bold, speed_str, speed_font_size, rl.Vector2(mid_x, y + height * 0.72), speed_color,
-                                 width * 0.90, height * 0.52, min_size=32)
-
-  def _draw_text_centered(self, font, text, size, pos_center, color):
-    sz = measure_text_cached(font, text, size)
-    rl.draw_text_ex(font, text, rl.Vector2(pos_center.x - sz.x / 2, pos_center.y - sz.y / 2), size, 0, color)
-
-  def _draw_text_centered_fit(self, font, text, size, pos_center, color, max_width: float, max_height: float, min_size: int = 10):
-    size = self._fit_font_size(font, text, max_width, max_height, size, min_size)
-    self._draw_text_centered(font, text, size, pos_center, color)
-
-  def _fit_font_size(self, font, text: str, max_width: float, max_height: float, max_size: int | float, min_size: int) -> int:
-    size = int(max_size)
-    while size > min_size:
-      text_size = measure_text_cached(font, text, size)
-      if text_size.x <= max_width and text_size.y <= max_height:
-        return size
-      size -= 2
-    return min_size
-
-  def _offset_badge_rect(self, panel_rect: rl.Rectangle, sign_x: float, sign_y: float, sign_width: float, sign_height: float,
-                         badge_size: float, has_upcoming_limit: bool) -> rl.Rectangle:
-    if ui_state.is_metric:
-      radius = min(sign_width, sign_height) / 2
-      center_x = sign_x + sign_width / 2
-      center_y = sign_y + sign_height / 2
-      badge_x_ratio = VIENNA_BADGE_UPCOMING_X_RATIO if has_upcoming_limit else VIENNA_BADGE_X_RATIO
-      badge_center_x = center_x + radius * badge_x_ratio
-      badge_center_y = center_y + radius * VIENNA_BADGE_Y_RATIO
-      badge_x = badge_center_x - badge_size / 2
-      badge_y = badge_center_y - badge_size / 2
-    else:
-      badge_x = sign_x + sign_width - badge_size * 0.45
-      badge_y = sign_y - badge_size * 0.75
-
-    return rl.Rectangle(
-      self._clamp(
-        badge_x,
-        panel_rect.x + OFFSET_BADGE_PANEL_PADDING,
-        panel_rect.x + panel_rect.width - badge_size - OFFSET_BADGE_PANEL_PADDING,
-      ),
-      self._clamp(
-        badge_y,
-        panel_rect.y + OFFSET_BADGE_PANEL_PADDING,
-        panel_rect.y + panel_rect.height - badge_size - OFFSET_BADGE_PANEL_PADDING,
-      ),
-      badge_size,
-      badge_size,
-    )
-
-  @staticmethod
-  def _clamp(value: float, min_value: float, max_value: float) -> float:
-    return max(min_value, min(max_value, value))
-
-  def _format_distance(self, distance: float) -> str:
-    if ui_state.is_metric:
-      if distance < 50:
-        return tr("Near")
-      if distance >= 1000:
-        return f"{distance * METER_TO_KM:.1f}" + tr("km")
-      if distance < 200:
-        rounded = max(10, int(distance / 10) * 10)
-      else:
-        rounded = int(distance / 100) * 100
-      return str(rounded) + tr("m")
-    else:
-      distance_mi = distance * METER_TO_MILE
-      if distance_mi < 0.1:
-        return tr("Near")
-      return f"{distance_mi:.1f}" + tr("mi")
@@ -11,6 +11,7 @@ from openpilot.selfdrive.ui.mici.widgets.button import BigCircleButton
 from openpilot.selfdrive.ui.mici.widgets.dialog import BigConfirmationDialog, BigDialog
 from openpilot.selfdrive.ui.sunnypilot.mici.layouts.sunnylink import SunnylinkLayoutMici
 from openpilot.selfdrive.ui.sunnypilot.mici.layouts.models import ModelsLayoutMici
+from openpilot.selfdrive.ui.sunnypilot.mici.layouts.laneful import LanefulLayoutMici
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.ui.lib.application import gui_app, FontWeight
 from openpilot.system.ui.lib.multilang import tr
@@ -50,6 +51,10 @@ class SettingsLayoutSP(OP.SettingsLayout):
    models_btn = SettingsBigButton(tr("models"), "", gui_app.texture("../../sunnypilot/selfdrive/assets/offroad/icon_models.png", ICON_SIZE, ICON_SIZE))
    models_btn.set_click_callback(lambda: gui_app.push_widget(models_panel))

+    laneful_panel = LanefulLayoutMici()
+    laneful_btn = SettingsBigButton(tr("laneful"), "", gui_app.texture("icons_mici/settings/device/lkas.png", ICON_SIZE, ICON_SIZE))
+    laneful_btn.set_click_callback(lambda: gui_app.push_widget(laneful_panel))
+
    # onroad: enable button sits at the front (left of toggles)
    self._enable_offroad_btn_onroad = BigCircleButton(self.icon_offroad_enable, red=True)
    self._enable_offroad_btn_onroad.set_click_callback(lambda: self._handle_always_offroad(True))
@@ -67,7 +72,8 @@ class SettingsLayoutSP(OP.SettingsLayout):
    items = self._scroller._items.copy()

    items.insert(1, models_btn)
-    items.insert(5, sunnylink_btn)
+    items.insert(2, laneful_btn)
+    items.insert(6, sunnylink_btn)

    # front slots (only one ever visible at a time): exit-always-offroad, then enable-onroad
    items.insert(0, self._enable_offroad_btn_onroad)
@@ -1,29 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-from openpilot.selfdrive.ui.mici.onroad.augmented_road_view import AugmentedRoadView
-
-
-class _SuppressedConfidenceBall:
-  def render(self, *_):
-    pass
-
-
-class AugmentedRoadViewSP(AugmentedRoadView):
-  def __init__(self, **kwargs):
-    super().__init__(**kwargs)
-    self._show_confidence_ball: bool = True
-    self._real_confidence_ball = self._confidence_ball
-    self._confidence_ball = _SuppressedConfidenceBall()
-
-  def set_show_confidence_ball(self, show: bool) -> None:
-    self._show_confidence_ball = show
-
-  def _render(self, _) -> None:
-    super()._render(_)
-    if self._show_confidence_ball:
-      self._real_confidence_ball.render(self.rect)
@@ -0,0 +1,122 @@
+"""
+Copyright (c) 2021-, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+
+Laneful visuals: cyan lane-center target, thin white "after" path (model path bent by laneful's nudge),
+and a top-center readout of the pull. Mirrors the math in sunnypilot/modeld_v2/laneful.py.
+"""
+import numpy as np
+import pyray as rl
+from openpilot.common.filter_simple import FirstOrderFilter
+from openpilot.common.realtime import DT_MDL
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.shader_polygon import draw_polygon
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+
+CENTER_COLOR = (0, 200, 255)
+AFTER_COLOR = (255, 255, 255)
+# keep in sync with sunnypilot/modeld_v2/laneful.py
+LOOKAHEAD_TIME = 1.5
+MIN_LOOKAHEAD = 10.0
+MAX_ERROR = 0.5
+
+
+class LanefulRenderer:
+  def __init__(self):
+    self._center_points = np.empty((0, 2), dtype=np.float32)
+    self._after_points = np.empty((0, 2), dtype=np.float32)
+    self._trust = 0.0
+    self._strength = 0.0
+    self._frame = 0
+    self._font = gui_app.font(FontWeight.BOLD)
+    # smoothed copies for the readout so the numbers don't flicker
+    self._pull_display = FirstOrderFilter(0.0, 0.5, DT_MDL)
+    self._trust_display = FirstOrderFilter(0.0, 0.5, DT_MDL)
+    self._readout_rect: rl.Rectangle | None = None
+    self._settings_page = None
+
+  def update(self, renderer, max_idx: int) -> None:
+    """Called from the model renderer's update with its lane lines and path already in raw points."""
+    if self._frame % 60 == 0:
+      self._strength = ui_state.params.get("LanefulStrength", return_default=True)
+    self._frame += 1
+
+    left, right = renderer._lane_lines[1].raw_points, renderer._lane_lines[2].raw_points
+    stds = list(ui_state.sm['modelV2'].laneLineStds)
+    if self._strength <= 0.0 or len(left) == 0 or len(right) != len(left) or len(stds) < 3:
+      self._center_points = np.empty((0, 2), dtype=np.float32)
+      self._after_points = np.empty((0, 2), dtype=np.float32)
+      return
+
+    probs = renderer._lane_line_probs
+    l_prob = float(probs[1] * np.interp(stds[1], [0.15, 0.3], [1.0, 0.0]))
+    r_prob = float(probs[2] * np.interp(stds[2], [0.15, 0.3], [1.0, 0.0]))
+    width = np.clip(right[:, 1] - left[:, 1], 2.8, 4.5) if l_prob * r_prob > 0.5 else 3.7
+    center = left.copy()
+    center[:, 1] = (l_prob * (left[:, 1] + width / 2) + r_prob * (right[:, 1] - width / 2)) / (l_prob + r_prob + 1e-4)
+    self._trust = l_prob + r_prob - l_prob * r_prob
+    self._center_points = renderer._map_line_to_polygon(center, 0.1, 0.0, max_idx)
+
+    # "after" path: model path bent toward center the way laneful's pure-pursuit term steers, ending at the lookahead
+    path = renderer._path.raw_points
+    lookahead = max(ui_state.sm['carState'].vEgo * LOOKAHEAD_TIME, MIN_LOOKAHEAD)
+    error = float(np.clip(np.interp(lookahead, center[:, 0], center[:, 1]) - np.interp(lookahead, path[:, 0], path[:, 1]),
+                          -MAX_ERROR, MAX_ERROR))
+    self._pull_display.update(self._trust * error)  # what laneful actually pulls, 0 when lines are untrusted
+    self._trust_display.update(self._trust)
+    after = path.copy()
+    after[:, 1] += self._strength * self._trust * error * (path[:, 0] / lookahead) ** 2
+    self._after_points = renderer._map_line_to_polygon(after, 0.15, renderer._path_offset_z,
+                                                       renderer._get_path_length_idx(path[:, 0], lookahead))
+
+  def draw(self, rect: rl.Rectangle) -> None:
+    if self._center_points.size and self._trust > 0.05:
+      draw_polygon(rect, self._center_points, rl.Color(*CENTER_COLOR, int(np.clip(self._trust, 0.2, 1.0) * 255)))
+    if self._after_points.size:
+      draw_polygon(rect, self._after_points, rl.Color(*AFTER_COLOR, 200))
+    self._readout_rect = None
+    if self._strength > 0.0:
+      self._draw_readout(rect)
+
+  def handle_tap(self, pos) -> bool:
+    """Tapping the readout opens the laneful settings page. Returns True if the tap was consumed."""
+    r = self._readout_rect
+    if r is None or not (r.x - 20 <= pos.x <= r.x + r.width + 20 and r.y - 20 <= pos.y <= r.y + r.height + 20):
+      return False
+    if self._settings_page is None:
+      from openpilot.selfdrive.ui.sunnypilot.mici.layouts.laneful import LanefulLayoutMici
+      self._settings_page = LanefulLayoutMici()
+    gui_app.push_widget(self._settings_page)
+    return True
+
+  def _draw_readout(self, rect: rl.Rectangle) -> None:
+    """Top-center pill: pull toward lane center in cm (capped at 50), arrow = side,
+    bar grows from center toward the pull (full at the cap), brighter with more lane line trust."""
+    pull, trust = self._pull_display.x, self._trust_display.x
+    w, h = 190, 76
+    x, y = rect.x + (rect.width - w) / 2, rect.y + 10
+    cx, cy = x + w / 2, y + 30
+    self._readout_rect = rl.Rectangle(x, y, w, h)
+    rl.draw_rectangle_rounded(self._readout_rect, 0.5, 12, rl.Color(0, 0, 0, 170))
+
+    text = f"{abs(pull) * 100:.0f}"
+    text_w = measure_text_cached(self._font, text, 44, 0).x
+    rl.draw_text_ex(self._font, text, rl.Vector2(cx - text_w / 2, cy - 24), 44, 0, rl.WHITE)
+
+    active = rl.Color(*CENTER_COLOR, int(np.clip(abs(pull) / 0.1, 0.0, 1.0) * 255))
+    idle = rl.Color(255, 255, 255, 40)
+    lx, rx = x + 18, x + w - 18
+    rl.draw_triangle(rl.Vector2(lx, cy), rl.Vector2(lx + 16, cy + 12), rl.Vector2(lx + 16, cy - 12), active if pull < 0 else idle)
+    rl.draw_triangle(rl.Vector2(rx - 16, cy - 12), rl.Vector2(rx - 16, cy + 12), rl.Vector2(rx, cy), active if pull > 0 else idle)
+
+    bar = rl.Rectangle(x + 24, y + h - 16, w - 48, 6)
+    rl.draw_rectangle_rounded(bar, 1.0, 6, rl.Color(255, 255, 255, 40))
+    rl.draw_rectangle(int(cx - 1), int(bar.y - 2), 2, int(bar.height + 4), rl.Color(255, 255, 255, 120))
+    fill = bar.width / 2 * float(np.clip(abs(pull) / MAX_ERROR, 0.0, 1.0))
+    if fill > 1:
+      fill_x = cx if pull > 0 else cx - fill
+      rl.draw_rectangle_rounded(rl.Rectangle(fill_x, bar.y, fill, bar.height), 1.0, 6,
+                                rl.Color(*CENTER_COLOR, int(np.clip(0.3 + 0.7 * trust, 0.0, 1.0) * 255)))
@@ -6,6 +6,7 @@ See the LICENSE.md file in the root directory for more details.
 """
 import pyray as rl
 from openpilot.selfdrive.ui.ui_state import UIStatus
+from openpilot.selfdrive.ui.sunnypilot.mici.onroad.laneful import LanefulRenderer
 from openpilot.selfdrive.ui.sunnypilot.onroad.rainbow_path import RainbowPath

 LANE_LINE_COLORS_SP = {
@@ -17,3 +18,4 @@ LANE_LINE_COLORS_SP = {
 class ModelRendererSP:
  def __init__(self):
    self.rainbow_path = RainbowPath()
+    self.laneful = LanefulRenderer()
@@ -1,83 +0,0 @@
-import pyray as rl
-
-from openpilot.system.ui.lib.application import MouseEvent, MousePos, gui_app
-from openpilot.system.ui.lib.scroll_panel2 import ScrollState
-from openpilot.system.ui.widgets import Widget
-from openpilot.system.ui.widgets import scroller as scroller_mod
-from openpilot.selfdrive.ui.sunnypilot.mici.widgets.scroll_panel_sp import GuiScrollPanel2SP
-
-
-class DummyScrollIndicator:
-  def update(self, *_) -> None:
-    pass
-
-  def render(self) -> None:
-    pass
-
-
-class DummyWidget(Widget):
-  def __init__(self, rect: rl.Rectangle):
-    super().__init__()
-    self.set_rect(rect)
-
-  def _render(self, _) -> None:
-    pass
-
-
-def _mouse_event(x: float, y: float, *, pressed: bool = False, released: bool = False,
-                 down: bool = True, t: float = 0.0) -> MouseEvent:
-  return MouseEvent(MousePos(x, y), 0, pressed, released, down, t)
-
-
-def test_vertical_snap_items_are_supported(monkeypatch):
-  monkeypatch.setattr(scroller_mod, "ScrollIndicator", DummyScrollIndicator)
-
-  scroller = scroller_mod._Scroller([], horizontal=False, snap_items=True, scroll_indicator=False)
-  scroller.set_rect(rl.Rectangle(0, 0, 100, 100))
-  scroller.scroll_panel.set_offset(-60)
-
-  captured_snap_target = None
-
-  def update(_, __, snap_target=None):
-    nonlocal captured_snap_target
-    captured_snap_target = snap_target
-    return scroller.scroll_panel.get_offset()
-
-  monkeypatch.setattr(scroller.scroll_panel, "update", update)
-
-  visible_items: list[Widget] = [
-    DummyWidget(rl.Rectangle(0, -60, 100, 100)),
-    DummyWidget(rl.Rectangle(0, 40, 100, 100)),
-  ]
-  scroller._get_scroll(visible_items, 200)
-
-  assert captured_snap_target == -100
-
-
-def test_scroll_panel_sp_rejects_orthogonal_drags(monkeypatch):
-  panel = GuiScrollPanel2SP(horizontal=True)
-  bounds = rl.Rectangle(0, 0, 100, 100)
-
-  monkeypatch.setattr(gui_app, "_mouse_events", [_mouse_event(10, 10, pressed=True, t=1.0)])
-  panel.update(bounds, 200)
-  assert panel.state == ScrollState.PRESSED
-
-  monkeypatch.setattr(gui_app, "_mouse_events", [_mouse_event(23, 60, t=1.1)])
-  panel.update(bounds, 200)
-
-  assert panel.state == ScrollState.STEADY
-  assert panel.get_offset() == 0
-
-
-def test_scroll_panel_sp_can_disable_out_of_bounds_handling(monkeypatch):
-  panel = GuiScrollPanel2SP(horizontal=False, handle_out_of_bounds=False)
-  bounds = rl.Rectangle(0, 0, 100, 100)
-  monkeypatch.setattr(gui_app, "_mouse_events", [])
-
-  panel.set_offset(20)
-  panel.update(bounds, 200)
-  assert panel.get_offset() == 0
-
-  panel.set_offset(-150)
-  panel.update(bounds, 200)
-  assert panel.get_offset() == -100
@@ -1,33 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import pyray as rl
-from openpilot.system.ui.lib.application import MouseEvent
-from openpilot.system.ui.lib.scroll_panel2 import GuiScrollPanel2, ScrollState
-
-
-class GuiScrollPanel2SP(GuiScrollPanel2):
-  """Scroll panel behavior for nested Mici pagers."""
-
-  def __init__(self, horizontal: bool = True, handle_out_of_bounds: bool = True) -> None:
-    super().__init__(horizontal, handle_out_of_bounds=handle_out_of_bounds)
-
-  def _handle_mouse_event(self, mouse_event: MouseEvent, bounds: rl.Rectangle, bounds_size: float,
-                          content_size: float) -> None:
-    state_before_update = self._state
-    super()._handle_mouse_event(mouse_event, bounds, bounds_size, content_size)
-
-    if self._state == ScrollState.MANUAL_SCROLL and state_before_update == ScrollState.PRESSED and \
-       self._initial_click_event is not None:
-      drag_x = abs(mouse_event.pos.x - self._initial_click_event.pos.x)
-      drag_y = abs(mouse_event.pos.y - self._initial_click_event.pos.y)
-      primary_drag = drag_x if self._horizontal else drag_y
-      cross_drag = drag_y if self._horizontal else drag_x
-      if cross_drag > primary_drag:
-        self._state = ScrollState.STEADY
-        self._velocity = 0.0
-        self._velocity_buffer.clear()
@@ -1,16 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-from openpilot.system.ui.widgets.scroller import Scroller
-from openpilot.selfdrive.ui.sunnypilot.mici.widgets.scroll_panel_sp import GuiScrollPanel2SP
-
-
-class ScrollerSP(Scroller):
-  def __init__(self, **kwargs):
-    super().__init__(**kwargs)
-    inner = self._scroller
-    inner.scroll_panel = GuiScrollPanel2SP(inner._horizontal, handle_out_of_bounds=not inner._snap_items)
@@ -10,9 +10,6 @@ from openpilot.selfdrive.ui.layouts.main import MainLayout
 from openpilot.selfdrive.ui.mici.layouts.main import MiciMainLayout
 from openpilot.selfdrive.ui.ui_state import ui_state

-if gui_app.sunnypilot_ui():
-  from openpilot.selfdrive.ui.sunnypilot.mici.layouts.main import MiciMainLayoutSP as MiciMainLayout
-
 BIG_UI = gui_app.big_ui()


@@ -3,3 +3,7 @@ from openpilot.common.basedir import BASEDIR

 MAPD_BIN_DIR = os.path.join(BASEDIR, 'openpilot', 'third_party/mapd_pfeiferj')
 MAPD_PATH = os.path.join(MAPD_BIN_DIR, 'mapd')
+
+# mapd still runs (OSM downloads) but has no position source since ubloxd owns LastGPSPosition;
+# map-based features stay off until mapd is rebuilt
+MAPD_AVAILABLE = False
@@ -4,7 +4,6 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
-import json
 import math
 import platform

@@ -27,21 +26,6 @@ class OsmMapData(BaseMapData):
      self.last_bearing = math.degrees(location.calibratedOrientationNED.value[2])
      self.last_position = Coordinate(location.positionGeodetic.value[0], location.positionGeodetic.value[1])

-    if self.last_position is None:
-      return
-
-    params = {
-      "latitude": self.last_position.latitude,
-      "longitude": self.last_position.longitude,
-    }
-
-    if self.last_bearing is not None:
-      params['bearing'] = self.last_bearing
-
-    # mapd reads its position from the memory params as JSON, so write it for the mapd binary.
-    # LastGPSPosition is registered as BYTES (ubloxd owns the persistent copy for pigeond),
-    # so the JSON payload has to be encoded here.
-    self.mem_params.put("LastGPSPosition", json.dumps(params).encode(), block=True)

  def get_current_speed_limit(self) -> float:
    return float(self.mem_params.get("MapSpeedLimit") or 0.0)
@@ -121,10 +121,6 @@ def update_osm_db() -> None:
  if not mem_params.get("OSMDownloadBounds"):
    mem_params.put("OSMDownloadBounds", "", block=True)

-  # mapd reads LastGPSPosition from the memory params as JSON, and it is registered as BYTES upstream
-  if not mem_params.get("LastGPSPosition"):
-    mem_params.put("LastGPSPosition", b"{}", block=True)
-

 def main_thread():
  update_installed_version(VERSION, params)
@@ -1,70 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import json
-import math
-import platform
-
-import openpilot.cereal.messaging as messaging
-from openpilot.cereal import log
-from openpilot.common.params import Params
-from openpilot.common.test import OpenpilotTestCase
-from openpilot.sunnypilot.mapd.live_map_data.osm_map_data import OsmMapData
-
-
-class TestOsmMapData(OpenpilotTestCase):
-  """The mapd binary reads its position from the memory params as JSON, so mapd_manager has to feed it."""
-
-  LATITUDE = 32.875134
-  LONGITUDE = -117.209777
-  ALTITUDE = 42.0
-  BEARING = 90.0
-
-  def setup_method(self):
-    self.mem_params = Params("/dev/shm/params") if platform.system() != "Darwin" else Params()
-    self.mem_params.remove("LastGPSPosition")
-    self.map_data = OsmMapData()
-    self.pm = messaging.PubMaster(['liveLocationKalman'])
-
-  def location_message(self, status: log.LiveLocationKalman.Status, position_valid: bool):
-    msg = messaging.new_message('liveLocationKalman', valid=True)
-    location = msg.liveLocationKalman
-    location.status = status
-    location.positionGeodetic = {'value': [self.LATITUDE, self.LONGITUDE, self.ALTITUDE], 'valid': position_valid}
-    location.calibratedOrientationNED = {'value': [0.0, 0.0, math.radians(self.BEARING)], 'valid': True}
-    return msg
-
-  def send_location(self, status: log.LiveLocationKalman.Status, position_valid: bool) -> None:
-    # the first exchange synchronizes the PUB/SUB connection, the second one is actually received
-    self.pm.send('liveLocationKalman', self.location_message(status, position_valid))
-    self.map_data.sm.update(1000)
-    self.pm.send('liveLocationKalman', self.location_message(status, position_valid))
-    self.map_data.sm.update(1000)
-
-  def read_position(self) -> dict:
-    value = self.mem_params.get("LastGPSPosition")
-    self.assertIsNotNone(value, "LastGPSPosition was not written for mapd")
-    return json.loads(value)
-
-  def test_writes_position_for_mapd(self):
-    self.send_location(log.LiveLocationKalman.Status.valid, True)
-    self.map_data.tick()
-
-    position = self.read_position()
-    self.assertAlmostEqual(position['latitude'], self.LATITUDE, delta=1e-6)
-    self.assertAlmostEqual(position['longitude'], self.LONGITUDE, delta=1e-6)
-    self.assertAlmostEqual(position['bearing'], self.BEARING, delta=1e-6)
-
-  def test_invalid_localizer_keeps_last_known_position(self):
-    self.send_location(log.LiveLocationKalman.Status.valid, True)
-    self.map_data.tick()
-
-    self.send_location(log.LiveLocationKalman.Status.uninitialized, False)
-    self.map_data.tick()
-
-    position = self.read_position()
-    self.assertAlmostEqual(position['latitude'], self.LATITUDE, delta=1e-6)
-    self.assertAlmostEqual(position['longitude'], self.LONGITUDE, delta=1e-6)
@@ -0,0 +1,79 @@
+"""
+Copyright (c) 2021-, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+
+Laneful: nudge the model's curvature toward the lane center seen by the lane lines.
+The model stays in charge; this only adds a pure-pursuit correction weighted by lane line confidence,
+and fades to zero (plain laneless) when the lines are weak.
+"""
+import numpy as np
+
+from openpilot.common.filter_simple import FirstOrderFilter
+from openpilot.common.realtime import DT_MDL
+from openpilot.sunnypilot.modeld_v2.constants import ModelConstants, Plan
+
+LANE_WIDTH_DEFAULT = 3.7  # m
+LANE_WIDTH_CLIP = (2.8, 4.5)  # m
+LOOKAHEAD_TIME = 1.5  # s
+MIN_LOOKAHEAD = 10.0  # m
+MAX_ERROR = 0.5  # m, cap on how far laneful can pull
+MIN_SPEED = 9.0  # m/s
+
+
+class Laneful:
+  def __init__(self):
+    self.lane_width = FirstOrderFilter(LANE_WIDTH_DEFAULT, 10.0, DT_MDL)
+
+  def update(self, model_output: dict[str, np.ndarray], v_ego: float, strength: float, desire_active: bool) -> float:
+    """Returns a curvature offset to add to the model's raw desired curvature."""
+    if strength <= 0.0 or desire_active or v_ego < MIN_SPEED or 'lane_lines' not in model_output:
+      return 0.0
+
+    lookahead = max(v_ego * LOOKAHEAD_TIME, MIN_LOOKAHEAD)
+    lines = model_output['lane_lines'][0, :, :, 0]
+    left_y = np.interp(lookahead, ModelConstants.X_IDXS, lines[1])
+    right_y = np.interp(lookahead, ModelConstants.X_IDXS, lines[2])
+
+    # line confidence, discounted when the model is unsure where the line is
+    probs = model_output['lane_lines_prob'][0, 1::2]
+    stds = model_output['lane_lines_stds'][0, :, 0, 0]
+    l_prob = float(probs[1] * np.interp(stds[1], [0.15, 0.3], [1.0, 0.0]))
+    r_prob = float(probs[2] * np.interp(stds[2], [0.15, 0.3], [1.0, 0.0]))
+
+    if l_prob * r_prob > 0.5:
+      self.lane_width.update(float(np.clip(right_y - left_y, *LANE_WIDTH_CLIP)))
+    half_width = self.lane_width.x / 2
+
+    # one weak line -> hug the strong one at half a lane width
+    center_y = (l_prob * (left_y + half_width) + r_prob * (right_y - half_width)) / (l_prob + r_prob + 1e-4)
+    lane_trust = l_prob + r_prob - l_prob * r_prob
+
+    plan = model_output['plan'][0, :, Plan.POSITION]
+    plan_y = np.interp(lookahead, plan[:, 0], plan[:, 1])
+
+    error = np.clip(center_y - plan_y, -MAX_ERROR, MAX_ERROR)
+    return float(strength * lane_trust * 2.0 * error / lookahead ** 2)
+
+
+if __name__ == "__main__":
+  def fake_output(left_y, right_y, prob=0.9, std=0.1, plan_y=0.0):
+    x = np.array(ModelConstants.X_IDXS)
+    lines = np.zeros((1, 4, len(x), 2), dtype=np.float32)
+    lines[0, 1, :, 0], lines[0, 2, :, 0] = left_y, right_y
+    plan = np.zeros((1, len(x), 15), dtype=np.float32)
+    plan[0, :, 0], plan[0, :, 1] = x, plan_y
+    return {'lane_lines': lines, 'plan': plan,
+            'lane_lines_prob': np.full((1, 8), prob, dtype=np.float32),
+            'lane_lines_stds': np.full((1, 4, len(x), 2), std, dtype=np.float32)}
+
+  lf = Laneful()
+  assert abs(lf.update(fake_output(-1.85, 1.85), 25.0, 1.0, False)) < 1e-6, "centered -> no nudge"
+  assert lf.update(fake_output(-1.0, 2.7), 25.0, 1.0, False) > 0, "lane center to the +y side -> nudge toward +y"
+  assert lf.update(fake_output(-2.7, 1.0), 25.0, 1.0, False) < 0, "lane center to the -y side -> nudge toward -y"
+  assert lf.update(fake_output(-1.0, 2.7), 25.0, 1.0, True) == 0.0, "off during lane change/turn"
+  assert lf.update(fake_output(-1.0, 2.7, std=0.5), 25.0, 1.0, False) == 0.0, "blurry lines -> laneless"
+  assert lf.update(fake_output(-1.0, 2.7), 25.0, 0.0, False) == 0.0, "strength 0 -> off"
+  assert lf.update(fake_output(-1.0, 2.7), 25.0, 0.5, False) < lf.update(fake_output(-1.0, 2.7), 25.0, 1.0, False)
+  print("laneful self-check ok")
@@ -39,6 +39,7 @@ from openpilot.selfdrive.modeld.modeld import ChestnutGpuState

 from openpilot.sunnypilot.modeld_v2.fill_model_msg import fill_model_msg, fill_pose_msg, PublishState, get_curvature_from_output
 from openpilot.sunnypilot.modeld_v2.parse_model_outputs import Parser
+from openpilot.sunnypilot.modeld_v2.laneful import Laneful
 from openpilot.sunnypilot.modeld_v2.constants import ModelConstants, Plan
 from openpilot.sunnypilot.modeld_v2.meta_helper import load_meta_constants
 from openpilot.sunnypilot.modeld_v2.camera_offset_helper import CameraOffsetHelper
@@ -228,7 +229,8 @@ class ModelState(ModelStateBase):
    return outputs

  def get_action_from_model(self, model_output: dict[str, np.ndarray], prev_action: log.ModelDataV2.Action,
-                            lat_action_t: float, long_action_t: float, v_ego: float) -> log.ModelDataV2.Action:
+                            lat_action_t: float, long_action_t: float, v_ego: float,
+                            laneful_curvature: float = 0.0) -> log.ModelDataV2.Action:
    if 'action' not in model_output:
      plan = model_output['plan'][0]
      desired_accel = get_accel_from_plan(plan[:, Plan.VELOCITY][:, 0], plan[:, Plan.ACCELERATION][:, 0], self.constants.T_IDXS,
@@ -240,6 +242,7 @@ class ModelState(ModelStateBase):
    else:
      desired_accel = model_output['action'][0, 1]
      desired_curvature = model_output['action'][0, 0] / (max(1.0, v_ego))**2
+    desired_curvature += laneful_curvature

    stop = v_ego < 0.3 and desired_accel < 0.1
    desired_accel = smooth_value(desired_accel, prev_action.desiredAcceleration, self.LONG_SMOOTH_SECONDS)
@@ -366,6 +369,8 @@ def main(demo=False):
  DH = DesireHelper()
  meta_constants = load_meta_constants()
  RELC = RoadEdgeLaneChangeController()
+  laneful = Laneful()
+  laneful_strength = 0.0

  while True:
    # Keep receiving frames until we are at least 1 frame ahead of previous extra frame
@@ -409,6 +414,7 @@ def main(demo=False):
      model.lat_delay = get_lat_delay(params, sm["lateralDelay"].lateralDelay)
      model.PLANPLUS_CONTROL = params.get("PlanplusControl", return_default=True)
      camera_offset_helper.set_offset(params.get("CameraOffset", return_default=True))
+      laneful_strength = params.get("LanefulStrength", return_default=True)
    lat_delay = model.lat_delay + model.LAT_SMOOTH_SECONDS
    if sm.updated["extrinsicsCalibration"] and sm.seen['narrowRoadCameraState'] and sm.seen['deviceState']:
      device_from_calib_euler = np.array(sm["extrinsicsCalibration"].rpyCalib, dtype=np.float32)
@@ -482,7 +488,9 @@ def main(demo=False):

      if not sm['carControl'].latActive:
        prev_action.desiredCurvature = sm['controlsState'].curvature
-      action = model.get_action_from_model(model_output, prev_action, lat_action_t, long_action_t, v_ego)
+      laneful_curvature = laneful.update(model_output, v_ego, laneful_strength,
+                                         desire != log.Desire.none or DH.lane_change_state != log.LaneChangeState.off)
+      action = model.get_action_from_model(model_output, prev_action, lat_action_t, long_action_t, v_ego, laneful_curvature)
      prev_action = action
      fill_model_msg(drivingdata_send, modelv2_send, model_output, action,
                     publish_state, meta_main.frame_id, meta_extra.frame_id, frame_id,
@@ -22,7 +22,7 @@ DEFAULT_MODEL_NAME_PATH = os.path.join(BASEDIR, "openpilot", "sunnypilot", "mode
 MODEL_HASH_PATH = os.path.join(BASEDIR, "openpilot", "sunnypilot", "models", "tests", "model_hash")
 BIG_MODEL_HASH_PATH = os.path.join(BASEDIR, "openpilot", "sunnypilot", "models", "tests", "big_model_hash")
 SUPERCOMBO_ONNX_PATH = os.path.join(BASEDIR, "openpilot", "selfdrive", "modeld", "models", "driving_supercombo.onnx")
-BIG_DRIVING_PKL_PATH = os.path.join(BASEDIR, "openpilot", "selfdrive", "modeld", "models", "big_driving_tinygrad.pkl")
+BIG_SUPERCOMBO_ONNX_PATH = os.path.join(BASEDIR, "openpilot", "selfdrive", "modeld", "models", "big_driving_supercombo.onnx")


 def _read_model_name_fields():
@@ -47,17 +47,18 @@ def update_model_hash():

  print(f"Generated and updated new combined model hash to {MODEL_HASH_PATH}")

-  import subprocess
-  rel = os.path.relpath(BIG_DRIVING_PKL_PATH, os.getcwd())
-  pointer = subprocess.check_output(["git", "show", f"HEAD:{rel}"], text=True)
-  oid = next(l.split(":", 1)[1] for l in pointer.splitlines() if l.startswith("oid sha256:"))
-  big_fingerprint = f"{oid}:{fields.get('DEFAULT_BIG_MODEL', '')}:{fields.get('DEFAULT_BIG_MODEL_REF', '')}"
-  big_combined_hash = hashlib.sha256(big_fingerprint.encode()).hexdigest()
+  if os.path.exists(BIG_SUPERCOMBO_ONNX_PATH):
+    import subprocess
+    rel = os.path.relpath(BIG_SUPERCOMBO_ONNX_PATH, os.getcwd())
+    pointer = subprocess.check_output(["git", "show", f"HEAD:{rel}"], text=True)
+    oid = next(l.split(":", 1)[1] for l in pointer.splitlines() if l.startswith("oid sha256:"))
+    big_fingerprint = f"{oid}:{fields.get('DEFAULT_BIG_MODEL', '')}:{fields.get('DEFAULT_BIG_MODEL_REF', '')}"
+    big_combined_hash = hashlib.sha256(big_fingerprint.encode()).hexdigest()

-  with open(BIG_MODEL_HASH_PATH, "w") as f:
-    f.write(big_combined_hash)
+    with open(BIG_MODEL_HASH_PATH, "w") as f:
+      f.write(big_combined_hash)

-  print(f"Generated and updated new big model hash to {BIG_MODEL_HASH_PATH}")
+    print(f"Generated and updated new big model hash to {BIG_MODEL_HASH_PATH}")


 def get_ref_for_name(url: str, name: str) -> str:
@@ -7,10 +7,7 @@ See the LICENSE.md file in the root directory for more details.

 import asyncio
 import os
-import re
-import threading
 import time
-from concurrent.futures import ThreadPoolExecutor

 import requests
 from openpilot.common.params import Params
@@ -25,99 +22,12 @@ from openpilot.sunnypilot.models.helpers import (ACTIVE_BUNDLE_KEYS, get_active_

 # (connect, read) seconds. read is per-request inactivity, not a total cap
 DOWNLOAD_TIMEOUT = (30, 30)
-# HuggingFace throttles each connection to ~1-2 MB/s but not the connection count; 12 saturates the device link
-MAX_CONCURRENT_PIECES = 12
-PIECE_SIZE = 8 * 1024 * 1024
-PIECE_ATTEMPTS = 3
-PIECE_BACKOFF = 1.0  # seconds, growing linearly: waits 1 s then 2 s between a piece's three attempts
-TRANSIENT_HTTP_STATUS = frozenset({408, 429, 500, 502, 503, 504})
-REPORT_INTERVAL = 0.5  # seconds between progress publications
-# byte ranges count encoded bytes but iter_content yields decoded ones, so ask for an unencoded body
-NO_COMPRESSION = {"Accept-Encoding": "identity"}


 class DownloadCancelled(Exception):
  pass


-def _is_transient(e: BaseException) -> bool:
-  if isinstance(e, requests.HTTPError):
-    return e.response is not None and e.response.status_code in TRANSIENT_HTTP_STATUS
-  return isinstance(e, (requests.ConnectionError, requests.Timeout, requests.exceptions.ChunkedEncodingError))
-
-
-class _Progress:
-  def __init__(self):
-    self._bytes = 0
-    self._lock = threading.Lock()
-
-  def add_bytes(self, n: int) -> None:
-    with self._lock:
-      self._bytes += n
-
-  def snapshot(self) -> int:
-    with self._lock:
-      return self._bytes
-
-
-def _piece_ranges(total: int, piece_size: int) -> list[tuple[int, int]]:
-  return [(start, min(start + piece_size, total)) for start in range(0, total, piece_size)]
-
-
-def _prepare_target(path: str, total: int) -> None:
-  with open(path, "wb") as f:
-    f.truncate(total)
-
-
-def _content_range_total(response: requests.Response) -> int | None:
-  if response.status_code != 206:
-    return None
-  match = re.fullmatch(r"bytes \d+-\d+/(\d+)", response.headers.get("Content-Range", ""))
-  return int(match.group(1)) if match else None
-
-
-def _probe_size(url: str) -> tuple[int, bool]:
-  with requests.get(url, headers={**NO_COMPRESSION, "Range": "bytes=0-0"}, stream=True, timeout=DOWNLOAD_TIMEOUT) as response:
-    response.raise_for_status()
-    total = _content_range_total(response)
-    if total is not None:
-      return total, True
-    return int(response.headers.get("Content-Length", 0)), False
-
-
-def _fetch_piece(url: str, path: str, index: int, start: int, end: int | None, progress: _Progress,
-                 cancel: threading.Event, block_size: int) -> None:
-  headers = {**NO_COMPRESSION, "Range": f"bytes={start}-{end - 1}"} if end is not None else NO_COMPRESSION
-  label = f"{os.path.basename(path)} piece {index}"
-  for attempt in range(PIECE_ATTEMPTS):
-    written = 0
-    try:
-      with requests.get(url, headers=headers, stream=True, timeout=DOWNLOAD_TIMEOUT) as response:
-        response.raise_for_status()
-        if end is not None and response.status_code != 206:
-          raise ValueError(f"server ignored byte range for {label}")
-        with open(path, "r+b") as f:
-          f.seek(start)
-          for block in response.iter_content(chunk_size=block_size):
-            if cancel.is_set():
-              raise DownloadCancelled("Download cancelled")
-            f.write(block)
-            written += len(block)
-            progress.add_bytes(len(block))
-          if end is None:
-            f.truncate()  # unknown length: the body defines the file size
-          if end is not None and written != end - start:
-            raise requests.exceptions.ConnectionError(f"short read: {written} of {end - start} bytes")
-      return
-    except requests.RequestException as e:
-      progress.add_bytes(-written)  # the piece restarts from scratch
-      if not _is_transient(e) or attempt == PIECE_ATTEMPTS - 1:
-        raise
-      cloudlog.warning(f"retrying {label} after {type(e).__name__}: {e}")
-      if cancel.wait(PIECE_BACKOFF * (1 + attempt)):
-        raise DownloadCancelled("Download cancelled") from None
-
-
 class ModelManagerSP:
  """Manages model downloads and status reporting"""

@@ -131,7 +41,7 @@ class ModelManagerSP:
    self.source_models: dict[str, list[custom.ModelManagerSP.ModelBundle]] = {}
    self.selected_bundle: custom.ModelManagerSP.ModelBundle = None
    self.active_bundle: custom.ModelManagerSP.ModelBundle = get_active_bundle(self.params, chestnut=self.chestnut_present)
-    self._block_size = 128 * 1000  # 128 KB network read blocks
+    self._chunk_size = 128 * 1000  # 128 KB chunks
    self._download_start_times: dict[str, float] = {}  # Track start time per model
    self._download_ref: bytes | str | None = None

@@ -146,6 +56,7 @@ class ModelManagerSP:
    self._download_ref = None

  def _sync_artifact_progress(self, source_artifact) -> None:
+    """Mirror download progress to all artifacts sharing the same filename in the selected bundle."""
    if not self.selected_bundle:
      return
    for model in self.selected_bundle.models:
@@ -156,6 +67,7 @@ class ModelManagerSP:
        artifact.downloadProgress.eta = source_artifact.downloadProgress.eta

  def _calculate_eta(self, filename: str, progress: float) -> int:
+    """Calculate ETA based on elapsed time and current progress"""
    if filename not in self._download_start_times or progress <= 0:
      return 60  # Default ETA for new downloads

@@ -163,58 +75,39 @@ class ModelManagerSP:
    if elapsed_time <= 0:
      return 60

+    # If we're at X% after Y seconds, we can estimate total time as (Y / X) * 100
    total_estimated_time = (elapsed_time / progress) * 100
    eta = total_estimated_time - elapsed_time
+
    return max(1, int(eta))  # Return at least 1 second if download is ongoing

-  def _set_progress(self, artifact, status, progress: float, eta: int = 0) -> None:
-    artifact.downloadProgress.status = status
-    artifact.downloadProgress.progress = progress
-    artifact.downloadProgress.eta = eta
-    self._sync_artifact_progress(artifact)
-    self._report_status()
+  async def _download_file(self, url: str, path: str, model) -> None:
+    """Downloads a file with progress tracking"""
+    self._download_start_times[model.fileName] = time.monotonic()

-  def _publish_progress(self, artifact, done_bytes: int, total: int) -> None:
-    # held at 99 until the file passes its hash check
-    progress = min(99.0, done_bytes / total * 100) if total > 0 else 0.0
-    eta = self._calculate_eta(artifact.fileName, progress)
-    self._set_progress(artifact, custom.ModelManagerSP.DownloadStatus.downloading, progress, eta)
+    with requests.get(url, stream=True, timeout=DOWNLOAD_TIMEOUT) as response:  # noqa: ASYNC210
+      response.raise_for_status()
+      total_size = int(response.headers.get("content-length", 0))
+      bytes_downloaded = 0

-  async def _report_until_done(self, tasks: list[asyncio.Future], artifact, progress: _Progress, total: int) -> None:
-    pending = set(tasks)
-    while pending:
-      done, pending = await asyncio.wait(pending, timeout=REPORT_INTERVAL)
-      for task in done:
-        task.result()  # re-raises a worker failure
-      if self._download_interrupted():
-        raise DownloadCancelled("Download cancelled")
-      self._publish_progress(artifact, progress.snapshot(), total)
+      with open(path, 'wb') as f:  # noqa: ASYNC230
+        for chunk in response.iter_content(chunk_size=self._chunk_size):  # type: bytes
+          f.write(chunk)
+          bytes_downloaded += len(chunk)

-  async def _download_file(self, url: str, path: str, artifact) -> None:
-    self._download_start_times[artifact.fileName] = time.monotonic()
-    loop = asyncio.get_running_loop()
+          if self._download_interrupted():
+            raise DownloadCancelled("Download cancelled")

-    total, ranged = await loop.run_in_executor(None, _probe_size, url)
-    pieces: list[tuple[int, int | None]] = list(_piece_ranges(total, PIECE_SIZE)) if ranged else [(0, None)]
-    await loop.run_in_executor(None, _prepare_target, path, total)
-    progress = _Progress()
-    cancel = threading.Event()
+          if total_size > 0:
+            progress = (bytes_downloaded / total_size) * 100
+            model.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.downloading
+            model.downloadProgress.progress = progress
+            model.downloadProgress.eta = self._calculate_eta(model.fileName, progress)
+            self._sync_artifact_progress(model)
+            self._report_status()

-    with ThreadPoolExecutor(max_workers=MAX_CONCURRENT_PIECES) as pool:
-      tasks = [loop.run_in_executor(pool, _fetch_piece, url, path, i, start, end, progress, cancel, self._block_size)
-               for i, (start, end) in enumerate(pieces)]
-      try:
-        await self._report_until_done(tasks, artifact, progress, total)
-      except BaseException as e:
-        cancel.set()
-        if isinstance(e, DownloadCancelled):
-          artifact.downloadProgress.canceling = True
-          self._set_progress(artifact, custom.ModelManagerSP.DownloadStatus.downloading, artifact.downloadProgress.progress)
-        for task in tasks:
-          task.cancel()  # drops queued pieces; running ones see the event at their next block
-        await asyncio.gather(*tasks, return_exceptions=True)
-        raise
-    del self._download_start_times[artifact.fileName]
+    # Clean up start time after download completes
+    del self._download_start_times[model.fileName]

  async def _process_artifact(self, artifact, destination_path: str) -> None:
    if not artifact.downloadUri.uri:
@@ -226,30 +119,33 @@ class ModelManagerSP:
    expected_hash = artifact.downloadUri.sha256
    filename = artifact.fileName
    full_path = os.path.join(destination_path, filename)
-    status = custom.ModelManagerSP.DownloadStatus
-    artifact.downloadProgress.canceling = False

    try:
-      self._set_progress(artifact, status.verifying, 0)
      if await verify_file(full_path, expected_hash):
-        self._set_progress(artifact, status.cached, 100)
+        artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.cached
+        artifact.downloadProgress.progress = 100
+        artifact.downloadProgress.eta = 0
+        self._sync_artifact_progress(artifact)
+        self._report_status()
        return

-      self._set_progress(artifact, status.downloading, 0)
      await self._download_file(url, full_path, artifact)
-      self._set_progress(artifact, status.verifying, 99)
      if not await verify_file(full_path, expected_hash):
        raise ValueError(f"Hash validation failed for {filename}")

-      self._set_progress(artifact, status.downloaded, 100)
+      artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.downloaded
+      artifact.downloadProgress.progress = 100
+      artifact.downloadProgress.eta = 0
+      self._sync_artifact_progress(artifact)
+      self._report_status()

    except DownloadCancelled:
      self._download_start_times.pop(artifact.fileName, None)
-      artifact.downloadProgress.status = status.failed
+      artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.failed
      artifact.downloadProgress.eta = 0
      self._sync_artifact_progress(artifact)
      if self.selected_bundle:
-        self.selected_bundle.status = status.failed
+        self.selected_bundle.status = custom.ModelManagerSP.DownloadStatus.failed
      self._report_status()
      raise

@@ -257,11 +153,11 @@ class ModelManagerSP:
      cloudlog.error(f"Error downloading {filename}: {str(e)}")
      if os.path.isfile(full_path):  # noqa: ASYNC240
        os.remove(full_path)
-      artifact.downloadProgress.status = status.failed
+      artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.failed
      artifact.downloadProgress.eta = 0
      self._sync_artifact_progress(artifact)
      if self.selected_bundle:
-        self.selected_bundle.status = status.failed
+        self.selected_bundle.status = custom.ModelManagerSP.DownloadStatus.failed
      self._report_status()
      self._download_start_times.pop(artifact.fileName, None)
      raise
@@ -376,7 +272,12 @@ class ModelManagerSP:
        rk.keep_time()

  def clear_model_cache(self) -> None:
-    """ Clears the model cache directory of all files except those in the active model bundle."""
+    """
+    Clears the model cache directory of all files except those in the active model bundle.
+    """
+
+    # Get list of files used by both slots' selected bundles (either may become
+    # the truly active bundle depending on hardware availability)
    active_files = []
    for source in ACTIVE_BUNDLE_KEYS:
      if selected_bundle := get_selected_bundle(self.params, source):
@@ -384,6 +285,7 @@ class ModelManagerSP:
          if model.artifact.fileName:
            active_files.append(model.artifact.fileName)

+    # Remove all files except active ones
    model_dir = Paths.model_root()
    try:
      for filename in os.listdir(model_dir):
@@ -1,4 +1,4 @@
 DEFAULT_MODEL = "CD210"
 DEFAULT_MODEL_REF = "5b6436a90cf6902b8aaa71c2b6f3d7164d8ae391"
-DEFAULT_BIG_MODEL = "Mountain Dew Model v3"
-DEFAULT_BIG_MODEL_REF = "1e219d7785cfb7b7343c7f2366347fc86e7ce5f2"
+DEFAULT_BIG_MODEL = "Cinque Terre Model v2"
+DEFAULT_BIG_MODEL_REF = "37bfa1413edcdc2e8844984b83727c33f81d8f46"
@@ -1 +1 @@
-330fdf61b5519642ebccd93aa50f2d7c4ba6c08c5a10c36a2cf155e498700cef
+2c814f08a2c51323b87839fbf8d2c2a9853a2b5536271b3d67f7b7a2de7f9374
@@ -10,7 +10,7 @@ import subprocess

 from openpilot.sunnypilot import get_file_hash
 from openpilot.sunnypilot.models.default_model import MODEL_HASH_PATH, SUPERCOMBO_ONNX_PATH, BIG_MODEL_HASH_PATH, \
-                                                      BIG_DRIVING_PKL_PATH, _read_model_name_fields
+                                                      BIG_SUPERCOMBO_ONNX_PATH, _read_model_name_fields
 import hashlib
 from openpilot.common.test import OpenpilotTestCase

@@ -36,9 +36,12 @@ class TestDefaultModel(OpenpilotTestCase):

    assert combined_hash == current_hash, "Run openpilot/sunnypilot/models/default_model.py to update the default model name and hash"

-  def test_compare_big_pkl_hashes(self):
+  def test_compare_big_onnx_hashes(self):
+    if not os.path.exists(BIG_SUPERCOMBO_ONNX_PATH):
+      self.skipTest("big_driving_supercombo.onnx not present")
+
    fields = _read_model_name_fields()
-    oid = _get_lfs_oid(os.path.relpath(BIG_DRIVING_PKL_PATH, os.getcwd()))
+    oid = _get_lfs_oid(os.path.relpath(BIG_SUPERCOMBO_ONNX_PATH, os.getcwd()))
    big_fingerprint = f"{oid}:{fields.get('DEFAULT_BIG_MODEL', '')}:{fields.get('DEFAULT_BIG_MODEL_REF', '')}"
    combined_hash = hashlib.sha256(big_fingerprint.encode()).hexdigest()

@@ -9,6 +9,7 @@ from openpilot.common.params import Params
 from openpilot.common.realtime import DT_MDL
 from openpilot.selfdrive.car.cruise import V_CRUISE_UNSET
 from openpilot.sunnypilot import PARAMS_UPDATE_PERIOD
+from openpilot.sunnypilot.mapd import MAPD_AVAILABLE
 from openpilot.sunnypilot.navd.helpers import Coordinate
 from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control import MIN_V

@@ -75,7 +76,7 @@ class SmartCruiseControlMap:
  def __init__(self):
    self.params = Params()
    self.mem_params = Params("/dev/shm/params") if platform.system() != "Darwin" else self.params
-    self.enabled = self.params.get_bool("SmartCruiseControlMap")
+    self.enabled = MAPD_AVAILABLE and self.params.get_bool("SmartCruiseControlMap")
    self.long_enabled = False
    self.long_override = False
    self.is_enabled = False
@@ -101,7 +102,7 @@ class SmartCruiseControlMap:

  def update_params(self):
    if self.frame % int(PARAMS_UPDATE_PERIOD / DT_MDL) == 0:
-      self.enabled = self.params.get_bool("SmartCruiseControlMap")
+      self.enabled = MAPD_AVAILABLE and self.params.get_bool("SmartCruiseControlMap")

  def update_calculations(self, sm: messaging.SubMaster) -> None:
    gps = sm[self.gps_location_service]
@@ -8,7 +8,7 @@ import json
 import math
 import platform
 from types import SimpleNamespace
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch

 from openpilot.cereal import custom
 from openpilot.common.params import Params
@@ -23,6 +23,8 @@ MapState = VisionState = custom.LongitudinalPlanSP.SmartCruiseControl.MapState
 class TestSmartCruiseControlMap(OpenpilotTestCase):

  def setup_method(self):
+    self.mapd_patch = patch("openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.map_controller.MAPD_AVAILABLE", True)
+    self.mapd_patch.start()
    self.params = Params()
    self.mem_params = Params("/dev/shm/params") if platform.system() != "Darwin" else self.params
    self.reset_params()
@@ -30,6 +32,9 @@ class TestSmartCruiseControlMap(OpenpilotTestCase):
    self.sm = MagicMock()
    self.sm.__getitem__.return_value = SimpleNamespace(latitude=0.0, longitude=0.0)

+  def teardown_method(self):
+    self.mapd_patch.stop()
+
  def reset_params(self):
    self.params.put_bool("SmartCruiseControlMap", True, block=True)

@@ -50,6 +55,14 @@ class TestSmartCruiseControlMap(OpenpilotTestCase):
    assert self.scc_m.state == VisionState.disabled
    assert not self.scc_m.is_active

+  def test_mapd_unavailable(self):
+    self.mapd_patch.stop()
+    self.scc_m = SmartCruiseControlMap()
+    for _ in range(int(10. / DT_MDL)):
+      self.scc_m.update(self.sm, True, False, 0., 0., 0.)
+    assert self.scc_m.state == VisionState.disabled
+    self.mapd_patch.start()
+
  def test_disabled(self):
    for _ in range(int(10. / DT_MDL)):
      self.scc_m.update(self.sm, False, False, 0., 0., 0.)
@@ -13,6 +13,7 @@ from openpilot.common.gps import get_gps_location_service
 from openpilot.common.params import Params
 from openpilot.common.realtime import DT_MDL
 from openpilot.sunnypilot import PARAMS_UPDATE_PERIOD, get_sanitize_int_param
+from openpilot.sunnypilot.mapd import MAPD_AVAILABLE
 from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit import LIMIT_MAX_MAP_DATA_AGE, LIMIT_ADAPT_ACC
 from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.common import Policy, OffsetType

@@ -48,6 +49,8 @@ class SpeedLimitResolver:
      Policy.max().value,
      self.params
    )
+    if not MAPD_AVAILABLE:
+      self.policy = Policy.car_state_only
    self._policy_to_sources_map = {
      Policy.car_state_only: [SpeedLimitSource.car],
      Policy.map_data_only: [SpeedLimitSource.map],
@@ -91,7 +94,7 @@ class SpeedLimitResolver:

  def update_params(self):
    if self.frame % int(PARAMS_UPDATE_PERIOD / DT_MDL) == 0:
-      self.policy = self.params.get("SpeedLimitPolicy", return_default=True)
+      self.policy = self.params.get("SpeedLimitPolicy", return_default=True) if MAPD_AVAILABLE else Policy.car_state_only
      self.is_metric = self.params.get_bool("IsMetric")
      self.offset_type = self.params.get("SpeedLimitOffsetType", return_default=True)
      self.offset_value = self.params.get("SpeedLimitValueOffset", return_default=True)
@@ -15,6 +15,7 @@ from opendbc.sunnypilot.car.tesla.values import TeslaFlagsSP
 from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
 from openpilot.common.hardware import HARDWARE
+from openpilot.sunnypilot.mapd import MAPD_AVAILABLE


 # Wire-protocol version for the capabilities payload. Bump on breaking changes
@@ -43,6 +44,7 @@ CAPABILITY_FIELDS = (
  "device_type",
  "subaru_has_sng",
  "hyundai_alpha_long_available",
+  "mapd_available",
 )

 CAPABILITY_LABELS: dict[str, str] = {
@@ -65,6 +67,7 @@ CAPABILITY_LABELS: dict[str, str] = {
  "device_type": "Device type",
  "subaru_has_sng": "Subaru Stop-and-Go available",
  "hyundai_alpha_long_available": "Hyundai Alpha Longitudinal available",
+  "mapd_available": "Map data available",
 }

 # Explicit defaults for non-boolean capability fields
@@ -132,6 +135,7 @@ def generate_capabilities(params: Params | None = None) -> dict:
  caps["is_sp_release"] = params.get_bool("IsReleaseSpBranch")
  caps["is_development"] = params.get_bool("IsDevelopmentBranch")
  caps["stock_longitudinal"] = params.get_bool("ToyotaEnforceStockLongitudinal")
+  caps["mapd_available"] = MAPD_AVAILABLE

  bundle = params.get("CarPlatformBundle")
  bundle_brand = _bundle_field(bundle, "brand")
@@ -156,7 +156,7 @@ The tables below describe the **compiled** `settings_ui.json` schema — what th

 **Enablement rules**: Grayed out (disabled) when rules fail. Frontend shows a contextual badge explaining why.

-**Capability fields** (referenced in rules): `has_longitudinal_control`, `has_icbm`, `icbm_available`, `torque_allowed`, `brand`, `pcm_cruise`, `alpha_long_available`, `steer_control_type`, `has_bsm`, `is_release`, `is_sp_release`, `is_development`, `tesla_has_vehicle_bus`, `has_stop_and_go`, `stock_longitudinal`
+**Capability fields** (referenced in rules): `has_longitudinal_control`, `has_icbm`, `icbm_available`, `torque_allowed`, `brand`, `pcm_cruise`, `alpha_long_available`, `steer_control_type`, `has_bsm`, `is_release`, `is_sp_release`, `is_development`, `tesla_has_vehicle_bus`, `has_stop_and_go`, `stock_longitudinal`, `mapd_available`

 ---

@@ -857,19 +857,47 @@
                    },
                    {
                      "value": 1,
-                      "label": "Map Data Only"
+                      "label": "Map Data Only",
+                      "enablement": [
+                        {
+                          "type": "capability",
+                          "field": "mapd_available",
+                          "equals": true
+                        }
+                      ]
                    },
                    {
                      "value": 2,
-                      "label": "Car State Priority"
+                      "label": "Car State Priority",
+                      "enablement": [
+                        {
+                          "type": "capability",
+                          "field": "mapd_available",
+                          "equals": true
+                        }
+                      ]
                    },
                    {
                      "value": 3,
-                      "label": "Map Data Priority"
+                      "label": "Map Data Priority",
+                      "enablement": [
+                        {
+                          "type": "capability",
+                          "field": "mapd_available",
+                          "equals": true
+                        }
+                      ]
                    },
                    {
                      "value": 4,
-                      "label": "Combined"
+                      "label": "Combined",
+                      "enablement": [
+                        {
+                          "type": "capability",
+                          "field": "mapd_available",
+                          "equals": true
+                        }
+                      ]
                    }
                  ]
                },
@@ -1001,6 +1029,11 @@
                }
              ],
              "enablement": [
+                {
+                  "type": "capability",
+                  "field": "mapd_available",
+                  "equals": true
+                },
                {
                  "type": "any",
                  "conditions": [
@@ -167,12 +167,28 @@ sections:
        label: Car State Only
      - value: 1
        label: Map Data Only
+        enablement:
+        - type: capability
+          field: mapd_available
+          equals: true
      - value: 2
        label: Car State Priority
+        enablement:
+        - type: capability
+          field: mapd_available
+          equals: true
      - value: 3
        label: Map Data Priority
+        enablement:
+        - type: capability
+          field: mapd_available
+          equals: true
      - value: 4
        label: Combined
+        enablement:
+        - type: capability
+          field: mapd_available
+          equals: true
    - key: SpeedLimitOffsetType
      widget: multiple_button
      title: Speed Limit Offset Type
@@ -246,6 +262,9 @@ sections:
        field: has_icbm
        equals: true
    enablement:
+    - type: capability
+      field: mapd_available
+      equals: true
    - type: any
      conditions:
      - type: capability
@@ -45,9 +45,8 @@ class ScrollState(Enum):


 class GuiScrollPanel2:
-  def __init__(self, horizontal: bool = True, handle_out_of_bounds: bool = True) -> None:
+  def __init__(self, horizontal: bool = True) -> None:
    self._horizontal = horizontal
-    self._handle_out_of_bounds = handle_out_of_bounds
    self._state = ScrollState.STEADY
    self._offset: rl.Vector2 = rl.Vector2(0, 0)
    self._initial_click_event: MouseEvent | None = None
@@ -86,20 +85,6 @@ class GuiScrollPanel2:
    """Returns (max_offset, min_offset) for the given bounds and content size."""
    return 0.0, min(0.0, bounds_size - content_size)

-  def _clamp_offset(self, bounds_size: float, content_size: float) -> None:
-    if self._handle_out_of_bounds:
-      return
-
-    max_offset, min_offset = self._get_offset_bounds(bounds_size, content_size)
-    offset = self.get_offset()
-    clamped_offset = max(min_offset, min(max_offset, offset))
-    if clamped_offset == offset:
-      return
-
-    self.set_offset(clamped_offset)
-    if (clamped_offset == max_offset and self._velocity > 0) or (clamped_offset == min_offset and self._velocity < 0):
-      self._velocity = 0.0
-
  def _update_state(self, bounds_size: float, content_size: float, snap_target: float | None) -> None:
    """Runs per render frame, independent of mouse events. Updates auto-scrolling state and velocity."""
    max_offset, min_offset = self._get_offset_bounds(bounds_size, content_size)
@@ -153,8 +138,6 @@ class GuiScrollPanel2:
        factor = 1.0 - math.exp(-SNAP_RATE * dt)
        self.set_offset(self.get_offset() + dist * factor)

-    self._clamp_offset(bounds_size, content_size)
-
  def _handle_mouse_event(self, mouse_event: MouseEvent, bounds: rl.Rectangle, bounds_size: float,
                          content_size: float) -> None:
    max_offset, min_offset = self._get_offset_bounds(bounds_size, content_size)
@@ -57,7 +57,7 @@ class DownloadStatusAction(ItemAction):
    self.icon: str | None = None
    self.icon_color: rl.Color | None = None
    self._font = gui_app.font(FontWeight.NORMAL)
-    # raw progress arrives in steps, one per progress report from the manager
+    # raw progress arrives in steps, one per 128KB chunk the manager publishes
    self._progress = FirstOrderFilter(0.0, 0.5, 1 / gui_app.target_fps)
    # integrated per frame; (t * speed) % span jumps whenever the fill width changes
    self._sweep = 0.0
@@ -75,6 +75,7 @@ class _Scroller(Widget):
    self._items: list[Widget] = []
    self._horizontal = horizontal
    self._snap_items = snap_items
+    assert not self._snap_items or self._horizontal, "Snapping is only supported for horizontal scrolling"
    self._spacing = spacing
    self._pad = pad

@@ -191,20 +192,12 @@ class _Scroller(Widget):
    snap_target: float | None = None
    if self._snap_items and visible_items and self._scrolling_to[0] is None:
      # TODO: this doesn't handle two small buttons at the edges well
-      center_pos = (self._rect.x + self._rect.width / 2) if self._horizontal else (self._rect.y + self._rect.height / 2)
-      closest_delta_pos = min(
-        (self._item_center_pos(item) - center_pos for item in visible_items),
-        key=abs,
-      )
+      center_pos = self._rect.x + self._rect.width / 2
+      closest_delta_pos = min((((item.rect.x + item.rect.width / 2) - center_pos) for item in visible_items), key=abs)
      snap_target = self.scroll_panel.get_offset() - closest_delta_pos

    return self.scroll_panel.update(self._rect, content_size, snap_target=snap_target)

-  def _item_center_pos(self, item: Widget) -> float:
-    if self._horizontal:
-      return item.rect.x + item.rect.width / 2
-    return item.rect.y + item.rect.height / 2
-
  @property
  def moving_items(self) -> bool:
    return len(self._move_animations) > 0 or len(self._move_lift) > 0
Author	SHA1	Message	Date
royjr	a952211afd	Merge remote-tracking branch 'origin/sync-20261016' into laneful-sync-20261016	2026-10-18 12:43:54 -04:00
royjr	bf93807e7b	simple	2026-10-18 01:06:10 -04:00
Jason Wen	8704196a73	mapd: disable map-based Smart Cruise Control and speed limit sources until mapd has a position source	2026-10-18 00:43:07 -04:00
James Vecellio-Grant	49b17f6eb5	modeld_v2: create a compiled pkl -> gpu kernel artifact converter (#2053 )	2026-10-18 00:43:07 -04:00
James Vecellio-Grant	a2a109077f	modeld_v2: compile models to plain gpu memory artifact (#2050 )	2026-10-18 00:43:06 -04:00
Jason Wen	15b9a14eb5	Merge commit '35e78a9d9518855ec0dacec919e719624a28131f' into sync-20261016 # Conflicts: # .gitattributes # .gitignore # .gitmodules # opendbc_repo # openpilot/common/params_keys.h # openpilot/common/version.py # openpilot/selfdrive/car/card.py # openpilot/selfdrive/controls/lib/longitudinal_planner.py # openpilot/selfdrive/controls/plannerd.py # openpilot/selfdrive/controls/tests/test_latcontrol.py # openpilot/selfdrive/modeld/modeld.py # openpilot/selfdrive/pandad/pandad.py # openpilot/selfdrive/selfdrived/alerts_offroad.json # openpilot/selfdrive/selfdrived/selfdrived.py # openpilot/selfdrive/test/longitudinal_maneuvers/plant.py # openpilot/selfdrive/ui/layouts/settings/developer.py # openpilot/selfdrive/ui/layouts/settings/toggles.py # openpilot/selfdrive/ui/mici/layouts/home.py # openpilot/selfdrive/ui/mici/layouts/onboarding.py # openpilot/selfdrive/ui/mici/onroad/model_renderer.py # openpilot/selfdrive/ui/onroad/model_renderer.py # openpilot/selfdrive/ui/soundd.py # openpilot/selfdrive/ui/translations/app.pot # openpilot/selfdrive/ui/translations/app_de.po # openpilot/selfdrive/ui/translations/app_en.po # openpilot/selfdrive/ui/translations/app_es.po # openpilot/selfdrive/ui/translations/app_fr.po # openpilot/selfdrive/ui/translations/app_ja.po # openpilot/selfdrive/ui/translations/app_ko.po # openpilot/selfdrive/ui/translations/app_pt-BR.po # openpilot/selfdrive/ui/translations/app_th.po # openpilot/selfdrive/ui/translations/app_tr.po # openpilot/selfdrive/ui/translations/app_uk.po # openpilot/selfdrive/ui/translations/app_zh-CHS.po # openpilot/selfdrive/ui/translations/app_zh-CHT.po # openpilot/selfdrive/ui/ui_state.py # openpilot/system/hardware/chestnut/status.py # openpilot/system/manager/process_config.py # openpilot/system/ui/README.md # panda # tinygrad_repo	2026-10-18 00:43:06 -04:00
royjr	f54f2d462e	settings	2026-10-18 00:15:49 -04:00
royjr	80494ec3cf	init	2026-10-18 00:15:48 -04:00