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

mapd: disable map-based Smart Cruise Control and speed limit sources until mapd has a position source
modeld_v2: create a compiled pkl -> gpu kernel artifact converter (#2053 )
2026-10-22 00:33:45 +08:00 · 2026-10-18 12:43:54 -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 · 2026-10-18 00:43:06 -04:00
33 changed files with 240 additions and 369 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 }}" \
@@ -465,10 +465,6 @@ struct ModelDataV2SP @0xa1680744031fdb2d {
  laneTurnDirection @0 :TurnDirection;
  leftLaneChangeEdgeBlock @1 :Bool;
  rightLaneChangeEdgeBlock @2 :Bool;
-  lanefulCurvature @3 :Float32;
-  lanefulTrust @4 :Float32;
-  modelCurvature @5 :Float32;
-  lanefulGoingAround @6 :Bool;

  enum TurnDirection {
    none @0;
@@ -94,7 +94,7 @@ _services: dict[str, tuple] = {
  "carControlSP": (True, 100., 10),
  "carStateSP": (True, 100., 10),
  "liveMapDataSP": (True, 1., 1),
-  "modelDataV2SP": (True, 20., 10, QueueSize.BIG),
+  "modelDataV2SP": (True, 20., None, QueueSize.BIG),
  "liveLocationKalman": (True, 20.),

  # debug
@@ -256,7 +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"}},
-    {"Laneful", {PERSISTENT | BACKUP, BOOL, "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
@@ -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):
@@ -4,18 +4,36 @@ 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 BigParamControl
+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._toggle = BigParamControl("laneful", "Laneful",
-                                   description="Keeps the car centered in its lane.\n" +
-                                               "Leans on the lane lines when they are clear, drives laneless when they are not.")
-    self._scroller.add_widget(self._toggle)
+    self._strength = LanefulStrengthToggle()
+    self._scroller.add_widget(self._strength)

  def show_event(self):
    super().show_event()
-    self._toggle.refresh()
+    self._strength.refresh()
@@ -5,20 +5,23 @@ 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, from the curvature modeld publishes in modelDataV2SP.lanefulCurvature.
+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.sunnypilot.modeld_v2.laneful import LOOKAHEAD_TIME, MIN_LOOKAHEAD, MAX_ERROR
 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:
@@ -26,22 +29,24 @@ class LanefulRenderer:
    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._alpha = FirstOrderFilter(0.0, 0.3, DT_MDL) # fades that hoe
    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."""
-    laneful_curvature = ui_state.sm['modelDataV2SP'].lanefulCurvature
-    self._alpha.update(float(laneful_curvature != 0.0))
+    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._alpha.x < 0.01 or len(left) == 0 or len(right) != len(left) or len(stds) < 3:
+    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
@@ -55,25 +60,25 @@ class LanefulRenderer:
    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 by laneful's curvature, ending at the lookahead
+    # "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)
-    self._pull_display.update(laneful_curvature * lookahead ** 2 / 2)  # how far laneful moves the car at the 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] += laneful_curvature * path[:, 0] ** 2 / 2
+    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 _color(self, rgb, alpha: float) -> rl.Color:
-    return rl.Color(*rgb, int(alpha * self._alpha.x))
-
  def draw(self, rect: rl.Rectangle) -> None:
    if self._center_points.size and self._trust > 0.05:
-      draw_polygon(rect, self._center_points, self._color(CENTER_COLOR, np.clip(self._trust, 0.2, 1.0) * 255))
-    self._readout_rect = None
+      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, self._color(AFTER_COLOR, 200))
+      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:
@@ -88,30 +93,30 @@ class LanefulRenderer:
    return True

  def _draw_readout(self, rect: rl.Rectangle) -> None:
-    """Top-center pill: pull toward lane center in cm at the lookahead, arrow = side,
+    """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, self._color((0, 0, 0), 170))
+    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, self._color((255, 255, 255), 255))
+    rl.draw_text_ex(self._font, text, rl.Vector2(cx - text_w / 2, cy - 24), 44, 0, rl.WHITE)

-    active = self._color(CENTER_COLOR, np.clip(abs(pull) / 0.1, 0.0, 1.0) * 255)
-    idle = self._color((255, 255, 255), 40)
+    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, self._color((255, 255, 255), 40))
-    rl.draw_rectangle(int(cx - 1), int(bar.y - 2), 2, int(bar.height + 4), self._color((255, 255, 255), 120))
+    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,
-                                self._color(CENTER_COLOR, np.clip(0.3 + 0.7 * trust, 0.0, 1.0) * 255))
+                                rl.Color(*CENTER_COLOR, int(np.clip(0.3 + 0.7 * trust, 0.0, 1.0) * 255)))
@@ -36,7 +36,7 @@ class UIStateSP:
    self.is_sp_release: bool = self.params.get_bool("IsReleaseSpBranch")
    self.sm_services_ext = [
      "modelManagerSP", "selfdriveStateSP", "longitudinalPlanSP", "backupManagerSP",
-      "lateralTorqueParameters", "carStateSP", "liveMapDataSP", "carParamsSP", "lateralDelay", "modelDataV2SP"
+      "lateralTorqueParameters", "carStateSP", "liveMapDataSP", "carParamsSP", "lateralDelay"
    ]

    self.sunnylink_state = SunnylinkState()
@@ -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)
@@ -1,125 +1,79 @@
 """
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+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
+from openpilot.sunnypilot.modeld_v2.constants import ModelConstants, Plan

-LANE_WIDTH_DEFAULT = 3.6  # m (reseeded to model's lane width upon initialization)
+LANE_WIDTH_DEFAULT = 3.7  # m
 LANE_WIDTH_CLIP = (2.8, 4.5)  # m
 LOOKAHEAD_TIME = 1.5  # s
 MIN_LOOKAHEAD = 10.0  # m
-MIN_SPEED = 5.0  # m/s
-LINE_STD = (0.2, 0.6)
-POINT_STD = 0.1
-MAX_ERROR = 1.0
-YIELD = (0.2, 0.45)
-X_IDXS = np.array(ModelConstants.X_IDXS)
+MAX_ERROR = 0.5  # m, cap on how far laneful can pull
+MIN_SPEED = 9.0  # m/s


-class Laneful: # TODO-SP: Rename this to blendful or something similar because it is not pure laneful anymore.
+class Laneful:
  def __init__(self):
-    self.lane_width = FirstOrderFilter(LANE_WIDTH_DEFAULT, 10.0, DT_MDL, initialized=False)
-    self.line_gone = FirstOrderFilter(np.zeros(2), 2.0, DT_MDL)
-    self.line_probs_slow = FirstOrderFilter(np.zeros(2), 3.0, DT_MDL)
-    self.line_probs = FirstOrderFilter(np.zeros(2), 0.5, DT_MDL)
-    self.usual_offset = FirstOrderFilter(0.0, 10.0, DT_MDL, initialized=False)
-    self.going_around = False
-    self.since_turning = 0.0
-    self.trust = 0.0
-    self.model_curvature = 0.0
-    self.smooth = 0.0 # smoothens lanelines below .53 lat accel
-    self.curvature = 0.0
+    self.lane_width = FirstOrderFilter(LANE_WIDTH_DEFAULT, 10.0, DT_MDL)

-  def update(self, model_output: dict[str, np.ndarray], v_ego: float, active: bool, model_curvature: float) -> float:
-    fading = not active or v_ego < MIN_SPEED
-    if fading:
-      self.trust = 0.0
-      self.usual_offset.initialized = False
-      self.lane_width.initialized = False
-      self.going_around = False
-    self.model_curvature = model_curvature
-    target = 0.0 if fading else self._target(model_output, v_ego, model_curvature)
-    target = self.smooth = self.smooth + (target - self.smooth) * DT_MDL / (DT_MDL + np.interp(abs(model_curvature) * v_ego ** 2, [0.18, 0.53], [0.25, 0.0]))
-    releasing = not fading and (abs(target) < abs(self.curvature) or target * self.curvature < 0)
-    step = (2.0 if releasing else 0.5) / max(v_ego, 1.0) ** 2 * DT_MDL  # jerk over 1 second
-    self.curvature = float(np.clip(target, self.curvature - step, self.curvature + step))
-    return self.curvature
-
-  def _target(self, model_output: dict[str, np.ndarray], v_ego: float, model_curvature: float) -> float:
-    if v_ego < MIN_SPEED or 'lane_lines' not in model_output:
+  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]
-    stds = model_output['lane_lines_stds'][0, :, :, 0]
+    left_y = np.interp(lookahead, ModelConstants.X_IDXS, lines[1])
+    right_y = np.interp(lookahead, ModelConstants.X_IDXS, lines[2])

-    probs = self.line_probs.update(model_output['lane_lines_prob'][0, 1::2][1:3])
-    gone = self.line_gone.update((model_output['lane_lines_prob'][0, 1::2][1:3] < 0.3).astype(float))
-    dropping = bool(np.any(probs < 0.6 * self.line_probs_slow.update(model_output['lane_lines_prob'][0, 1::2][1:3])))
-    l_prob = float(probs[0] * np.interp(np.interp(0.5 * lookahead, X_IDXS, stds[1]), LINE_STD, [1.0, 0.0]))
-    r_prob = float(probs[1] * np.interp(np.interp(0.5 * lookahead, X_IDXS, stds[2]), LINE_STD, [1.0, 0.0]))
-    # one line steadily on its own still centers at half say conf. a line that is disappearing gives control back to laneless
-    if gone[1] > 0.8 and l_prob > 0.5:
-      lane_trust = l_prob / 2
-    elif gone[0] > 0.8 and r_prob > 0.5:
-      lane_trust = r_prob / 2
-    elif dropping:
-      lane_trust = min(l_prob, r_prob)
-    else:
-      lane_trust = l_prob + r_prob - l_prob * r_prob
-    if lane_trust <= 0.0:
-      self.trust = 0.0
-      return 0.0
+    # 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]))

-    win = (X_IDXS >= 0.5 * lookahead) & (X_IDXS <= 1.5 * lookahead)
-    x = X_IDXS[win]
-    half_width = self.lane_width.x / 2
    if l_prob * r_prob > 0.5:
-      width = np.interp(lookahead, X_IDXS, lines[2]) - np.interp(lookahead, X_IDXS, lines[1])
-      self.lane_width.update(float(np.clip(width, *LANE_WIDTH_CLIP)))
-      half_width = np.clip(lines[2, win] - lines[1, win], *LANE_WIDTH_CLIP) / 2
-    l_var = stds[1, win] ** 2 / max(l_prob, 1e-4)
-    r_var = stds[2, win] ** 2 / max(r_prob, 1e-4)
-    center = (r_var * (lines[1, win] + half_width) + l_var * (lines[2, win] - half_width)) / (l_var + r_var)
-    weight = 1.0 / (l_var * r_var / (l_var + r_var) + POINT_STD ** 2)
+      self.lane_width.update(float(np.clip(right_y - left_y, *LANE_WIDTH_CLIP)))
+    half_width = self.lane_width.x / 2

-    # Fit curvature to place the plant in center: e ~ dk x^2 / 2
-    plan_x = np.interp(x, model_output['plan'][0, :, 0], model_output['plan'][0, :, 1])
-    plan_share = np.interp(abs(model_curvature) * lookahead ** 2 / 2, [0.5, 2.0], [0.3, 0.5]) # blending up to 50% plan with action during sharp curvature
-    error = np.clip(center - ((1 - plan_share) * model_curvature * x ** 2 / 2 + plan_share * plan_x), -1.0, 1.0)
-    dk = 2.0 * np.sum(weight * error * x ** 2) / np.sum(weight * x ** 4)
+    # 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

-    # A model planning to end up further from its usual spot in the lane than the plant is now is likely going around something
-    hw_now = np.clip(lines[2, 0] - lines[1, 0], *LANE_WIDTH_CLIP) / 2 if l_prob * r_prob > 0.5 else self.lane_width.x / 2
-    center_now = (l_prob * (lines[1, 0] + hw_now) + r_prob * (lines[2, 0] - hw_now)) / (l_prob + r_prob)
-    plan_y = np.interp(lookahead, model_output['plan'][0, :, 0], model_output['plan'][0, :, 1])
-    offset = plan_y - np.interp(lookahead, x, center)
-    if min(gone) > 0.5:  # both lines gone: turns, intersections, relearn ideal model position
-      self.usual_offset.initialized = False
-    usual = self.usual_offset.x if self.usual_offset.initialized else offset
-    swerve = abs(offset - usual) - 0.25 * abs(model_curvature) * lookahead ** 2 / 2
-    away = swerve - abs(-center_now - usual)
-    lane_curvature = 2.0 * np.polyfit(x, center, 2)[0]
-    inside_curve = abs(lane_curvature) * lookahead ** 2 / 2 > 0.1 and (offset - usual) * lane_curvature > 0
-    self.since_turning = 0.0 if abs(model_curvature) * lookahead ** 2 / 2 > 0.5 else self.since_turning + DT_MDL
-    if inside_curve:
-      self.going_around = False
-    elif away > YIELD[0] and self.since_turning > 2.0:
-      self.going_around = True
-    elif swerve < YIELD[0] / 2:
-      self.going_around = False
-    self.usual_offset.update_alpha(20.0 if self.going_around else 10.0)
-    self.usual_offset.update(offset)
-    if inside_curve:
-      lane_trust *= np.interp(abs(offset) - abs(center_now) - 0.25 * abs(model_curvature) * lookahead ** 2 / 2, (0.5, 1.0), [1.0, 0.0])
-    else:
-      lane_trust *= np.interp(swerve, (YIELD[0] / 2, YIELD[0]), [1.0, 0.0]) if self.going_around else np.interp(away, YIELD, [1.0, 0.0])
+    plan = model_output['plan'][0, :, Plan.POSITION]
+    plan_y = np.interp(lookahead, plan[:, 0], plan[:, 1])

-    self.trust = lane_trust if lane_trust < self.trust else self.trust + (lane_trust - self.trust) * DT_MDL / (1.5 + DT_MDL)
-    return float(self.trust * dk)
+    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")
@@ -7,7 +7,6 @@ See the LICENSE.md file in the root directory for more details.
 """

 from collections.abc import Callable
-from functools import partial
 import gc
 import os
 os.environ['GMMU'] = '0'
@@ -231,7 +230,7 @@ class ModelState(ModelStateBase):

  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,
-                            laneful: Callable[[float], float] | None = None) -> log.ModelDataV2.Action:
+                            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,
@@ -243,8 +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
-    if laneful is not None:
-      desired_curvature += laneful(desired_curvature)
+    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)
@@ -372,7 +370,7 @@ def main(demo=False):
  meta_constants = load_meta_constants()
  RELC = RoadEdgeLaneChangeController()
  laneful = Laneful()
-  laneful_enabled = False
+  laneful_strength = 0.0

  while True:
    # Keep receiving frames until we are at least 1 frame ahead of previous extra frame
@@ -416,7 +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_enabled = params.get_bool("Laneful")
+      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)
@@ -490,9 +488,9 @@ def main(demo=False):

      if not sm['carControl'].latActive:
        prev_action.desiredCurvature = sm['controlsState'].curvature
-      laneful_active = laneful_enabled and desire == log.Desire.none and 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,
-                                           partial(laneful.update, model_output, v_ego, laneful_active))
+      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,
@@ -509,10 +507,6 @@ def main(demo=False):
      modelv2_send.modelV2.meta.laneChangeDirection = DH.lane_change_direction
      mdv2sp_send.valid = modelv2_send.valid
      mdv2sp_send.modelDataV2SP.laneTurnDirection = DH.lane_turn_direction
-      mdv2sp_send.modelDataV2SP.lanefulCurvature = laneful.curvature
-      mdv2sp_send.modelDataV2SP.lanefulTrust = float(laneful.trust)
-      mdv2sp_send.modelDataV2SP.modelCurvature = float(laneful.model_curvature)
-      mdv2sp_send.modelDataV2SP.lanefulGoingAround = bool(laneful.going_around)
      drivingdata_send.drivingModelData.meta.laneChangeState = DH.lane_change_state
      drivingdata_send.drivingModelData.meta.laneChangeDirection = DH.lane_change_direction

@@ -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:
@@ -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
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
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