gap

#	common/params_keys.h
#	sunnypilot/navd/constants.py

.github/workflows/post-to-discourse/action.yml

@@ -0,0 +1,105 @@
+name: 'Post to Discourse'
+description: 'Posts a message to a Discourse topic (existing or new)'
+
+inputs:
+  discourse-url:
+    description: 'Discourse instance URL (e.g., https://discourse.example.com)'
+    required: true
+  api-key:
+    description: 'Discourse API key'
+    required: true
+  api-username:
+    description: 'Discourse API username'
+    required: true
+  topic-id:
+    description: 'Discourse topic ID to post to (use this OR category-id + title)'
+    required: false
+  category-id:
+    description: 'Category ID for new topic (required if topic-id not provided)'
+    required: false
+  title:
+    description: 'Title for new topic (required if topic-id not provided)'
+    required: false
+  message:
+    description: 'Message content (markdown supported)'
+    required: true
+
+outputs:
+  post-number:
+    description: 'The post number in the topic'
+    value: ${{ steps.post.outputs.post_number }}
+  post-url:
+    description: 'Direct URL to the post'
+    value: ${{ steps.post.outputs.post_url }}
+  topic-id:
+    description: 'The topic ID (useful when creating a new topic)'
+    value: ${{ steps.post.outputs.topic_id }}
+
+runs:
+  using: "composite"
+  steps:
+    - name: Post to Discourse
+      id: post
+      shell: bash
+      run: |
+        # Validate inputs
+        if [ -z "${{ inputs.topic-id }}" ] && ([ -z "${{ inputs.category-id }}" ] || [ -z "${{ inputs.title }}" ]); then
+          echo "❌ Error: Must provide either topic-id OR both category-id and title"
+          exit 1
+        fi
+        
+        if [ -n "${{ inputs.topic-id }}" ] && ([ -n "${{ inputs.category-id }}" ] || [ -n "${{ inputs.title }}" ]); then
+          echo "⚠️  Warning: Both topic-id and category-id/title provided. Will post to existing topic."
+        fi
+        
+        # Determine if creating new topic or posting to existing
+        if [ -n "${{ inputs.topic-id }}" ]; then
+          echo "📝 Posting to existing topic ID: ${{ inputs.topic-id }}"
+        
+          # Create JSON payload for posting to existing topic
+          PAYLOAD=$(jq -n \
+            --arg content '${{ inputs.message }}' \
+            --arg topic_id "${{ inputs.topic-id }}" \
+            '{topic_id: $topic_id, raw: $content}')
+        else
+          echo "✨ Creating new topic: ${{ inputs.title }}"
+        
+          # Create JSON payload for new topic
+          PAYLOAD=$(jq -n \
+            --arg content '${{ inputs.message }}' \
+            --arg title "${{ inputs.title }}" \
+            --arg category "${{ inputs.category-id }}" \
+            '{title: $title, category: ($category | tonumber), raw: $content}')
+        fi
+        
+        # Post to Discourse
+        RESPONSE=$(curl -s -w "\n%{http_code}" \
+          -X POST "${{ inputs.discourse-url }}/posts.json" \
+          -H "Content-Type: application/json" \
+          -H "Api-Key: ${{ inputs.api-key }}" \
+          -H "Api-Username: ${{ inputs.api-username }}" \
+          -d "$PAYLOAD")
+        
+        HTTP_CODE=$(echo "$RESPONSE" | tail -n1)
+        BODY=$(echo "$RESPONSE" | sed '$d')
+        
+        if [ "$HTTP_CODE" -ge 200 ] && [ "$HTTP_CODE" -lt 300 ]; then
+          echo "✅ Successfully posted to Discourse!"
+        
+          POST_NUMBER=$(echo "$BODY" | jq -r '.post_number // "unknown"')
+          TOPIC_ID=$(echo "$BODY" | jq -r '.topic_id // "${{ inputs.topic-id }}"')
+          POST_URL="${{ inputs.discourse-url }}/t/${TOPIC_ID}/${POST_NUMBER}"
+        
+          echo "post_number=${POST_NUMBER}" >> $GITHUB_OUTPUT
+          echo "post_url=${POST_URL}" >> $GITHUB_OUTPUT
+          echo "topic_id=${TOPIC_ID}" >> $GITHUB_OUTPUT
+        
+          echo "Topic ID: ${TOPIC_ID}"
+          echo "Post number: ${POST_NUMBER}"
+          echo "URL: ${POST_URL}"
+        else
+          echo "❌ Failed to post to Discourse"
+          echo "HTTP Code: ${HTTP_CODE}"
+          echo "Response: ${BODY}"
+          exit 1
+        fi

.github/workflows/selfdrive_tests.yaml

@@ -21,11 +21,12 @@ env:
   PYTHONWARNINGS: error
   BASE_IMAGE: sunnypilot-base
   AZURE_TOKEN: ${{ secrets.AZURE_COMMADATACI_OPENPILOTCI_TOKEN }}
+  MAPBOX_TOKEN_CI: ${{ secrets.MAPBOX_TOKEN_CI }}
 
   DOCKER_LOGIN: docker login ghcr.io -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }}
   BUILD: release/ci/docker_build_sp.sh base
 
-  RUN: docker run --shm-size 2G -v $PWD:/tmp/openpilot -w /tmp/openpilot -e CI=1 -e PYTHONWARNINGS=error -e FILEREADER_CACHE=1 -e PYTHONPATH=/tmp/openpilot -e NUM_JOBS -e JOB_ID -e GITHUB_ACTION -e GITHUB_REF -e GITHUB_HEAD_REF -e GITHUB_SHA -e GITHUB_REPOSITORY -e GITHUB_RUN_ID -v $GITHUB_WORKSPACE/.ci_cache/scons_cache:/tmp/scons_cache -v $GITHUB_WORKSPACE/.ci_cache/comma_download_cache:/tmp/comma_download_cache -v $GITHUB_WORKSPACE/.ci_cache/openpilot_cache:/tmp/openpilot_cache $BASE_IMAGE /bin/bash -c
+  RUN: docker run --shm-size 2G -v $PWD:/tmp/openpilot -w /tmp/openpilot -e CI=1 -e PYTHONWARNINGS=error -e FILEREADER_CACHE=1 -e PYTHONPATH=/tmp/openpilot -e NUM_JOBS -e JOB_ID -e GITHUB_ACTION -e GITHUB_REF -e GITHUB_HEAD_REF -e GITHUB_SHA -e GITHUB_REPOSITORY -e GITHUB_RUN_ID -e MAPBOX_TOKEN_CI=$MAPBOX_TOKEN_CI -v $GITHUB_WORKSPACE/.ci_cache/scons_cache:/tmp/scons_cache -v $GITHUB_WORKSPACE/.ci_cache/comma_download_cache:/tmp/comma_download_cache -v $GITHUB_WORKSPACE/.ci_cache/openpilot_cache:/tmp/openpilot_cache $BASE_IMAGE /bin/bash -c
 
   PYTEST: pytest --continue-on-collection-errors --durations=0 -n logical
 

.github/workflows/sunnypilot-build-prebuilt.yaml

@@ -302,36 +302,51 @@ jobs:
             git push -f origin ${TAG}
 
   notify:
-    needs: [ build, publish ]
+    needs: 
+    - prepare_strategy
+    - build
+    - publish
     runs-on: ubuntu-24.04
-    if: ${{ (always() && !cancelled() && !failure()) && needs.publish.result == 'success' && !failure() && (!contains(github.event_name, 'pull_request') || (github.event.action == 'labeled' && github.event.label.name == 'prebuilt')) }}
+    if: ${{ (always() && !cancelled() && !failure())
+      && needs.publish.result == 'success'
+      && (!contains(github.event_name, 'pull_request') || (github.event.action == 'labeled' && github.event.label.name == 'prebuilt'))
+      && (fromJSON(vars.DEV_FEEDBACK_NOTIFICATION_BRANCHES_V2)[github.head_ref || github.ref_name] != null) }}
     steps:
       - uses: actions/checkout@v4
-      - name: Setup Alpine Linux environment
-        uses: jirutka/setup-alpine@v1.2.0
-        with:
-          packages: 'jq gettext curl'
 
-      - name: Send Discord Notification
-        env:
-          DISCORD_WEBHOOK: ${{ contains(fromJSON(vars.DEV_FEEDBACK_NOTIFICATION_BRANCHES), env.SOURCE_BRANCH) && secrets.DISCORD_DEV_FEEDBACK_CHANNEL_WEBHOOK || secrets.DISCORD_DEV_PRIVATE_CHANNEL_WEBHOOK }}
+      - name: Prepare notification message
+        id: message
         run: |
-          TEMPLATE='${{ vars.DISCORD_GENERAL_UPDATE_NOTICE }}'
-          export EXTRA_VERSION_IDENTIFIER="${{ needs.build.outputs.extra_version_identifier }}"
-          export VERSION="${{ needs.build.outputs.version }}"
-          export branch_name=${{ env.SOURCE_BRANCH }}
-          export new_branch=${{ needs.build.outputs.new_branch }}
-          export extra_version_identifier=${{ needs.build.outputs.extra_version_identifier || github.run_number}}
-          echo ${TEMPLATE} | envsubst | jq -c '.' | tee payload.json
-          curl -X POST -H "Content-Type: application/json" -d @payload.json $DISCORD_WEBHOOK
+          TEMPLATE='${{ vars.DISCOURSE_GENERAL_UPDATE_NOTICE }}'
+          export VERSION="${{ needs.prepare_strategy.outputs.version }}"
+          export branch_name="${{ env.SOURCE_BRANCH }}"
+          export new_branch="${{ needs.prepare_strategy.outputs.new_branch }}"
+          export commit_sha="${{ github.sha }}"
+          export commit_short_sha="${{ github.sha }}"
+          export commit_short_sha="${commit_short_sha:0:7}"
+          export extra_version_identifier="${{ needs.prepare_strategy.outputs.extra_version_identifier || github.run_number }}"
+          export PUBLIC_REPO_URL="${{ env.PUBLIC_REPO_URL }}"
 
-          echo ""
-          echo "----   ℹ️ To update the list of branches that notify to dev-feedback  -----"
-          echo ""
-          echo "1. Go to: ${{ github.server_url }}/${{ github.repository }}/settings/variables/actions/DEV_FEEDBACK_NOTIFICATION_BRANCHES"
-          echo "2. Current value: ${{ vars.DEV_FEEDBACK_NOTIFICATION_BRANCHES }}"
-          echo "3. Update as needed (JSON array with no spaces)"
-        shell: alpine.sh {0}
+          MESSAGE=$(cat << 'EOF' | envsubst
+          ${{ vars.DISCOURSE_GENERAL_UPDATE_NOTICE }}
+          EOF
+          )
+          
+          {
+            echo 'content<<EOFMARKER'
+            echo "$MESSAGE"
+            echo 'EOFMARKER'
+          } >> $GITHUB_OUTPUT
+        shell: bash
+
+      - name: Post to Discourse
+        uses: ./.github/workflows/post-to-discourse
+        with:
+          discourse-url: ${{ vars.DISCOURSE_URL }}
+          api-key: ${{ secrets.DISCOURSE_API_KEY }}
+          api-username: "system"
+          topic-id: ${{ fromJSON(vars.DEV_FEEDBACK_NOTIFICATION_BRANCHES_V2)[github.head_ref || github.ref_name].topic_id }}
+          message: ${{ steps.message.outputs.content }}
 
   manage-pr-labels:
     name: Remove prebuilt label

.github/workflows/sunnypilot-master-dev-prep.yaml

@@ -3,7 +3,6 @@ name: Build dev
 env:
   DEFAULT_SOURCE_BRANCH: "master"
   DEFAULT_TARGET_BRANCH: "master-dev"
-  PR_LABEL: "dev"
   LFS_URL: 'https://gitlab.com/sunnypilot/public/sunnypilot-new-lfs.git/info/lfs'
   LFS_PUSH_URL: 'ssh://git@gitlab.com/sunnypilot/public/sunnypilot-new-lfs.git'
 
@@ -43,7 +42,7 @@ jobs:
     if: (
       (github.event_name == 'workflow_dispatch')
       || (github.event_name == 'push' && github.ref == format('refs/heads/{0}', github.event.repository.default_branch))
-      || (contains(github.event_name, 'pull_request') && ((github.event.action == 'labeled' && (github.event.label.name == 'dev' || github.event.label.name == 'trust-fork-pr') && contains(github.event.pull_request.labels.*.name, 'dev'))))
+      || (contains(github.event_name, 'pull_request') && ((github.event.action == 'labeled' && (github.event.label.name == vars.PREBUILT_PR_LABEL || github.event.label.name == 'trust-fork-pr') && contains(github.event.pull_request.labels.*.name, vars.PREBUILT_PR_LABEL))))
       )
     steps:
       - uses: actions/checkout@v4
@@ -55,7 +54,7 @@ jobs:
         uses: ./.github/workflows/wait-for-action # Path to where you place the action
         if: (
           (github.event_name == 'push' && github.ref == format('refs/heads/{0}', github.event.repository.default_branch))
-          || (contains(github.event_name, 'pull_request') && ((github.event.action == 'labeled' && (github.event.label.name == 'dev' || github.event.label.name == 'trust-fork-pr') && contains(github.event.pull_request.labels.*.name, 'dev'))))
+          || (contains(github.event_name, 'pull_request') && ((github.event.action == 'labeled' && (github.event.label.name == vars.PREBUILT_PR_LABEL || github.event.label.name == 'trust-fork-pr') && contains(github.event.pull_request.labels.*.name, vars.PREBUILT_PR_LABEL))))
           )
         with:
           workflow: selfdrive_tests.yaml # The workflow file to monitor
@@ -119,7 +118,7 @@ jobs:
           # Use GitHub API to get PRs with specific label, ordered by creation date
           PR_LIST=$(gh api graphql -f query='
             query($search_query:String!) {
-              search(query: $search_query, type:ISSUE, first:100) {
+              search(query: $search_query, type:ISSUE, first:40) {
                 nodes {
                   ... on PullRequest {
                     number
@@ -149,7 +148,7 @@ jobs:
                   }
                 }
               }
-            }' -F search_query="repo:${{ github.repository }} is:pr is:open label:${PR_LABEL},${PR_LABEL}-c3 draft:false sort:created-asc")
+            }' -F search_query="repo:${{ github.repository }} is:pr is:open label:${{ vars.PREBUILT_PR_LABEL }},${{ vars.PREBUILT_PR_LABEL }}-c3 draft:false sort:created-asc")
 
           PR_LIST=${PR_LIST//\'/}
           echo "PR_LIST=${PR_LIST}" >> $GITHUB_OUTPUT

.github/workflows/test-discourse.yaml.yml

@@ -0,0 +1,78 @@
+name: Debug Discourse Posting
+
+on:
+  push:
+
+jobs:
+  test-discourse-post:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Post test message to Discourse
+        uses: ./.github/workflows/post-to-discourse
+        with:
+          discourse-url: ${{ vars.DISCOURSE_URL }}
+          api-key: ${{ secrets.DISCOURSE_API_KEY }}
+          api-username: ${{ secrets.DISCOURSE_API_USERNAME }}
+          topic-id: ${{ vars.DISCOURSE_UPDATES_TOPIC_ID }}
+          message: |
+            ## 🧪 Test Post from GitHub Actions
+            
+            **This is a test post to verify Discourse integration**
+            
+            - **Workflow**: ${{ github.workflow }}
+            - **Run Number**: #${{ github.run_number }}
+            - **Branch**: `${{ github.ref_name }}`
+            - **Commit**: ${{ github.sha }}
+            - **Actor**: @${{ github.actor }}
+            - **Timestamp**: ${{ github.event.head_commit.timestamp }}
+            
+            ---
+            
+            ### Fake Build Info (for testing)
+            - **Version**: 0.9.8-test
+            - **Build**: #42
+            - **Branch**: release-test
+            
+            [View workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
+            
+            *This is an automated test message. Drive safe! 🚗💨*
+      
+      
+      - name: Create topic on Discourse
+        uses: ./.github/workflows/post-to-discourse
+        with:
+          discourse-url: ${{ vars.DISCOURSE_URL }}
+          api-key: ${{ secrets.DISCOURSE_API_KEY }}
+          api-username: ${{ secrets.DISCOURSE_API_USERNAME }}
+          #topic-id: ${{ vars.DISCOURSE_UPDATES_TOPIC_ID }}
+          category-id: 4
+          title: "This is a test of a new topic instead of a reply"
+          message: |
+            ## 🧪 Test Post from GitHub Actions
+            
+            **This is a test post to verify Discourse integration**
+            
+            - **Workflow**: ${{ github.workflow }}
+            - **Run Number**: #${{ github.run_number }}
+            - **Branch**: `${{ github.ref_name }}`
+            - **Commit**: ${{ github.sha }}
+            - **Actor**: @${{ github.actor }}
+            - **Timestamp**: ${{ github.event.head_commit.timestamp }}
+            
+            ---
+            
+            ### Fake Build Info (for testing)
+            - **Version**: 0.9.8-test
+            - **Build**: #42
+            - **Branch**: release-test
+            
+            [View workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
+            
+            *This is an automated test message. Drive safe! 🚗💨*
+      - name: Display results
+        if: always()
+        run: |
+          echo "::notice::Discourse post test completed"
+          echo "Check your Discourse topic to verify the post appeared correctly"

CHANGELOG.md

@@ -1,3 +1,6 @@
+sunnypilot Version 2025.002.000 (2025-xx-xx)
+========================
+
 sunnypilot Version 2025.001.000 (2025-10-25)
 ========================
 * 🛠️ Major rewrite

cereal/custom.capnp

@@ -340,6 +340,7 @@ struct OnroadEventSP @0xda96579883444c35 {
     speedLimitChanged @21;
     speedLimitPending @22;
     e2eChime @23;
+    navigationBanner @24;
   }
 }
 
@@ -454,7 +455,20 @@ struct ModelDataV2SP @0xa1680744031fdb2d {
   }
 }
 
-struct CustomReserved10 @0xcb9fd56c7057593a {
+struct Navigationd @0xcb9fd56c7057593a {
+  upcomingTurn @0 :Text;
+  currentSpeedLimit @1 :UInt64;
+  bannerInstructions @2 :Text;
+  distanceFromRoute @3 :Float64;
+  allManeuvers @4 :List(Maneuver);
+  valid @5 :Bool;
+
+  struct Maneuver {
+    distance @0 :Float64;
+    type @1 :Text;
+    modifier @2 :Text;
+    instruction @3 :Text;
+  }
 }
 
 struct CustomReserved11 @0xc2243c65e0340384 {

cereal/log.capnp

@@ -2632,7 +2632,7 @@ struct Event {
     carStateSP @114 :Custom.CarStateSP;
     liveMapDataSP @115 :Custom.LiveMapDataSP;
     modelDataV2SP @116 :Custom.ModelDataV2SP;
-    customReserved10 @136 :Custom.CustomReserved10;
+    navigationd @136 :Custom.Navigationd;
     customReserved11 @137 :Custom.CustomReserved11;
     customReserved12 @138 :Custom.CustomReserved12;
     customReserved13 @139 :Custom.CustomReserved13;

cereal/services.py

@@ -89,6 +89,7 @@ _services: dict[str, tuple] = {
   "carStateSP": (True, 100., 10),
   "liveMapDataSP": (True, 1., 1),
   "modelDataV2SP": (True, 20.),
+  "navigationd": (True, 3.),
   "liveLocationKalman": (True, 20.),
 
   # debug

common/params_keys.h

@@ -187,6 +187,15 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"ModelManager_LastSyncTime", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, INT, "0"}},
     {"ModelManager_ModelsCache", {PERSISTENT | BACKUP, JSON}},
 
+    // Navigation params
+    {"AllowNavigation", {PERSISTENT | BACKUP, BOOL, "0"}},
+    {"MapboxToken", {PERSISTENT | BACKUP, STRING}},
+    {"MapboxSettings", {CLEAR_ON_MANAGER_START, JSON}},
+    {"MapboxRoute", {PERSISTENT, STRING}},
+    {"MapboxRecompute", {PERSISTENT | BACKUP, BOOL, "0"}},
+    {"NavDesiresAllowed", {PERSISTENT | BACKUP, BOOL, "0"}},
+    {"NavEvents", {PERSISTENT | BACKUP, BOOL, "0"}},
+
     // Neural Network Lateral Control
     {"NeuralNetworkLateralControl", {PERSISTENT | BACKUP, BOOL, "0"}},
 

selfdrive/controls/controlsd.py

@@ -132,7 +132,7 @@ class Controls(ControlsExt, ModelStateBase):
       self.LoC.reset()
 
     # accel PID loop
-    pid_accel_limits = self.CI.get_pid_accel_limits(self.CP, CS.vEgo, CS.vCruise * CV.KPH_TO_MS)
+    pid_accel_limits = self.CI.get_pid_accel_limits(self.CP, self.CP_SP, CS.vEgo, CS.vCruise * CV.KPH_TO_MS)
     actuators.accel = float(self.LoC.update(CC.longActive, CS, long_plan.aTarget, long_plan.shouldStop, pid_accel_limits))
 
     # Steering PID loop and lateral MPC

selfdrive/controls/lib/desire_helper.py

@@ -3,6 +3,7 @@ from openpilot.common.constants import CV
 from openpilot.common.realtime import DT_MDL
 from openpilot.sunnypilot.selfdrive.controls.lib.auto_lane_change import AutoLaneChangeController, AutoLaneChangeMode
 from openpilot.sunnypilot.selfdrive.controls.lib.lane_turn_desire import LaneTurnController
+from openpilot.sunnypilot.navd.navigation_desires.navigation_desires import NavigationDesires
 
 LaneChangeState = log.LaneChangeState
 LaneChangeDirection = log.LaneChangeDirection
@@ -51,6 +52,7 @@ class DesireHelper:
     self.alc = AutoLaneChangeController(self)
     self.lane_turn_controller = LaneTurnController(self)
     self.lane_turn_direction = TurnDirection.none
+    self.navigation_desires = NavigationDesires()
 
   @staticmethod
   def get_lane_change_direction(CS):
@@ -143,3 +145,7 @@ class DesireHelper:
         self.desire = log.Desire.none
 
     self.alc.update_state()
+
+    nav_desire = self.navigation_desires.update(carstate, lateral_active)
+    if nav_desire != log.Desire.none and (self.desire == log.Desire.none or self.desire in (log.Desire.turnLeft, log.Desire.turnRight)):
+      self.desire = nav_desire

selfdrive/controls/plannerd.py

@@ -27,7 +27,7 @@ def main():
   longitudinal_planner = LongitudinalPlanner(CP, CP_SP)
   pm = messaging.PubMaster(['longitudinalPlan', 'driverAssistance', 'longitudinalPlanSP'])
   sm = messaging.SubMaster(['carControl', 'carState', 'controlsState', 'liveParameters', 'radarState', 'modelV2', 'selfdriveState',
-                            'liveMapDataSP', 'carStateSP', gps_location_service],
+                            'liveMapDataSP', 'navigationd', 'carStateSP', gps_location_service],
                            poll='carState')
 
   while True:

selfdrive/selfdrived/selfdrived.py

@@ -88,7 +88,7 @@ class SelfdriveD(CruiseHelper):
     # TODO: de-couple selfdrived with card/conflate on carState without introducing controls mismatches
     self.car_state_sock = messaging.sub_sock('carState', timeout=20)
 
-    ignore = self.sensor_packets + self.gps_packets + ['alertDebug'] + ['modelDataV2SP']
+    ignore = self.sensor_packets + self.gps_packets + ['alertDebug'] + ['modelDataV2SP'] + ['navigationd']
     if SIMULATION:
       ignore += ['driverCameraState', 'managerState']
     if REPLAY:
@@ -98,7 +98,7 @@ class SelfdriveD(CruiseHelper):
                                    'carOutput', 'driverMonitoringState', 'longitudinalPlan', 'livePose', 'liveDelay',
                                    'managerState', 'liveParameters', 'radarState', 'liveTorqueParameters',
                                    'controlsState', 'carControl', 'driverAssistance', 'alertDebug', 'userBookmark', 'audioFeedback',
-                                   'modelDataV2SP', 'longitudinalPlanSP'] + \
+                                   'modelDataV2SP', 'longitudinalPlanSP', 'navigationd'] + \
                                    self.camera_packets + self.sensor_packets + self.gps_packets,
                                   ignore_alive=ignore, ignore_avg_freq=ignore,
                                   ignore_valid=ignore, frequency=int(1/DT_CTRL))

selfdrive/test/longitudinal_maneuvers/plant.py

@@ -71,6 +71,7 @@ class Plant:
     model = messaging.new_message('modelV2')
     car_state_sp = messaging.new_message('carStateSP')
     live_map_data_sp = messaging.new_message('liveMapDataSP')
+    navigationd = messaging.new_message('navigationd')
     gps_data = messaging.new_message('gpsLocation')
     a_lead = (v_lead - self.v_lead_prev)/self.ts
     self.v_lead_prev = v_lead
@@ -141,6 +142,7 @@ class Plant:
           'modelV2': model.modelV2,
           'carStateSP': car_state_sp.carStateSP,
           'liveMapDataSP': live_map_data_sp.liveMapDataSP,
+          'navigationd': navigationd.navigationd,
           'gpsLocation': gps_data.gpsLocation}
     self.planner.update(sm)
     self.acceleration = self.planner.output_a_target

selfdrive/ui/sunnypilot/qt/offroad/settings/models_panel.cc

@@ -310,9 +310,8 @@ void ModelsPanel::handleCurrentModelLblBtnClicked() {
   QList<TreeNode> sortedModels;
   QSet<QString> modelFolders;
   QRegularExpression re("\\(([^)]*)\\)[^(]*$");
-  const auto bundles = model_manager.getAvailableBundles();
 
-  for (const auto &bundle : bundles) {
+  for (const auto &bundle : model_manager.getAvailableBundles()) {
     auto overrides = bundle.getOverrides();
     QString folder;
     for (const auto &override : overrides) {
@@ -392,7 +391,7 @@ void ModelsPanel::handleCurrentModelLblBtnClicked() {
     showResetParamsDialog();
   } else {
     // Find selected bundle and initiate download
-    for (const auto &bundle: bundles) {
+    for (const auto &bundle: model_manager.getAvailableBundles()) {
       if (QString::fromStdString(bundle.getRef()) == selectedBundleRef) {
         params.put("ModelManager_DownloadIndex", std::to_string(bundle.getIndex()));
         if (bundle.getGeneration() != model_manager.getActiveBundle().getGeneration()) {

selfdrive/ui/sunnypilot/qt/offroad/settings/sunnylink_panel.cc

@@ -90,7 +90,7 @@ SunnylinkPanel::SunnylinkPanel(QWidget *parent) : QFrame(parent) {
   QString sunnylinkUploaderDesc = tr("Enable sunnylink uploader to allow sunnypilot to upload your driving data to sunnypilot servers. (only for highest tiers, and does NOT bring ANY benefit to you. We are just testing data volume.)");
   sunnylinkUploaderEnabledBtn = new ParamControlSP(
     "EnableSunnylinkUploader",
-    tr("[Don't use] Enable sunnylink uploader"),
+    tr("Enable sunnylink uploader (just for testing infrastructure)"),
     sunnylinkUploaderDesc,
     "", nullptr, true);
   list->addItem(sunnylinkUploaderEnabledBtn);
@@ -290,7 +290,10 @@ void SunnylinkPanel::updatePanel() {
   pairSponsorBtn->setEnabled(!is_onroad && is_sunnylink_enabled);
   pairSponsorBtn->setValue(is_paired ? tr("Paired") : tr("Not Paired"));
 
-  sunnylinkUploaderEnabledBtn->setEnabled(max_current_sponsor_rule.roleTier == SponsorTier::Guardian && is_sunnylink_enabled);
+  bool can_do_uploads = max_current_sponsor_rule.roleTier >= SponsorTier::Novice && is_sunnylink_enabled;
+  sunnylinkUploaderEnabledBtn->setVisible(can_do_uploads);
+  sunnylinkUploaderEnabledBtn->setEnabled(can_do_uploads);
+  
 
   if (!is_sunnylink_enabled) {
     sunnylinkEnabledBtn->setValue("");

sunnypilot/common/version.h

@@ -1 +1 @@
-#define SUNNYPILOT_VERSION "2025.001.000"
+#define SUNNYPILOT_VERSION "2025.002.000"

sunnypilot/models/fetcher.py

@@ -116,7 +116,7 @@ class ModelCache:
 
 class ModelFetcher:
   """Handles fetching and caching of model data from remote source"""
-  MODEL_URL = "https://docs.sunnypilot.ai/driving_models_v7.json"
+  MODEL_URL = "https://docs.sunnypilot.ai/driving_models_v8.json"
 
   def __init__(self, params: Params):
     self.params = params

sunnypilot/navd/README.md

@@ -0,0 +1,6 @@
+# Navigation
+
+Navigation daemon with Mapbox integration for semi-offline navigation. This module handles route planning, geocoding, and turn-by-turn instructions to support autonomous driving features.
+
+- `navigation_helpers/`: Mapbox API integration and navigation instructions processing.
+- `navigationd`: Navigation service which uses mapbox integration to generate a route and keep it up to date. This service runs at three hz, using keep time to ensure the while loop only updates three times a second rather than every time sm updates, which in this case would be twenty hz (LLK).

sunnypilot/navd/constants.py

@@ -0,0 +1,16 @@
+"""
+Copyright (c) 2021-, James Vecellio, 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.
+"""
+
+
+class NAV_CV:
+  """ These distances are expected in meters format and convert to desired format """
+  SHORT_DISTANCE_METERS = 200.0
+  QUARTER_MILE = 402.336
+  POINT_ONE_MILE = 160.9344
+  METERS_TO_KILO = 1000  # divide n by this
+  METERS_TO_MILE = 1609.344  # divide n by this
+  METERS_TO_FEET = 3.280839895  # multiply n by this

sunnypilot/navd/event_builder.py

@@ -0,0 +1,83 @@
+"""
+Copyright (c) 2021-, James Vecellio, 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 cereal import custom, messaging
+from openpilot.common.params import Params
+from openpilot.common.realtime import DT_MDL
+
+from sunnypilot.navd.constants import NAV_CV
+
+
+class EventBuilder:
+  def __init__(self):
+    self._counter: int = -1
+    self._enabled: bool = False
+    self._params = Params()
+
+  @staticmethod
+  def _build_banner_message(metric: bool, nav_msg):
+    m = nav_msg.allManeuvers[1] if len(nav_msg.allManeuvers) > 1 else nav_msg.allManeuvers[0]
+    banner = m.instruction
+
+    if metric:
+      dist = f'{m.distance / NAV_CV.METERS_TO_KILO:.1f} km,'
+      if m.distance < NAV_CV.SHORT_DISTANCE_METERS:
+        dist = f'{int(m.distance)}m,'
+    else:
+      dist = f'{m.distance / NAV_CV.METERS_TO_MILE:.1f} mi,'
+      if m.distance < NAV_CV.QUARTER_MILE:
+        dist = f'{round((m.distance * NAV_CV.METERS_TO_FEET) / 50) * 50}ft,'
+
+    if m.type == 'arrive' or m.type == 'depart' or 'Your destination' in banner:
+      base_msg = banner
+    elif banner.startswith(('Continue', 'Drive', 'Head')):
+      base_msg = f'For {dist} {banner}'
+    elif 'Turn' in banner or 'Take' in banner or 'Make' in banner:
+      base_msg = f'In {dist} {banner}'
+    else:
+      base_msg = f'For {dist} Continue on {banner}'
+
+    return base_msg
+
+  @staticmethod
+  def _get_turning_message(upcoming_turn):
+    turn_messages = {
+      'left': 'Turning Left, Make sure to nudge the wheel',
+      'right': 'Turning Right, Make sure to nudge the wheel',
+      'slightLeft': 'Keeping Left',
+      'slightRight': 'Keeping Right',
+      'sharpLeft': 'Sharp Left Turn',
+      'sharpRight': 'Sharp Right Turn',
+      'straight': 'Continuing Straight',
+      'uturn': 'U-Turn Ahead',
+    }
+    return turn_messages.get(upcoming_turn, f"Upcoming {upcoming_turn.replace('_', ' ').title()}")
+
+  @staticmethod
+  def build_navigation_events(sm: messaging.SubMaster, metric=True) -> list:
+    nav_msg = sm['navigationd']
+    if not nav_msg.valid:
+      return []
+
+    banner_message = EventBuilder._build_banner_message(metric, nav_msg)
+
+    if nav_msg.upcomingTurn != 'none':
+      banner_message = EventBuilder._get_turning_message(nav_msg.upcomingTurn)
+
+    return [{
+      'name': custom.OnroadEventSP.EventName.navigationBanner,
+      'message': banner_message,
+    }]
+
+  def update(self, sm: messaging.SubMaster) -> list:
+    self._counter += 1
+    if self._counter % int(3.0 / DT_MDL) == 0:
+      self._enabled = self._params.get("NavEvents", return_default=True)
+
+    if self._enabled:
+      return self.build_navigation_events(sm)
+    else:
+      return []

sunnypilot/navd/helpers.py

@@ -126,6 +126,8 @@ def string_to_direction(direction: str) -> str:
     if d in direction:
       if 'slight' in direction and d in MODIFIABLE_DIRECTIONS:
         return 'slight' + d.capitalize()
+      elif 'sharp' in direction and d in MODIFIABLE_DIRECTIONS:
+        return 'sharp' + d.capitalize()
       return d
   return 'none'
 

sunnypilot/navd/navigation_desires/navigation_desires.py

@@ -0,0 +1,44 @@
+"""
+Copyright (c) 2021-, James Vecellio, 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 cereal.messaging as messaging
+from cereal import car, log
+from openpilot.common.constants import CV
+from openpilot.common.params import Params
+
+
+class NavigationDesires:
+  def __init__(self):
+    self.sm = messaging.SubMaster(['navigationd'])
+    self.desire = log.Desire.none
+    self._turn_speed_limit = 20 * CV.MPH_TO_MS
+    self._params = Params()
+    self.param_counter = -1
+    self.nav_allowed: bool = False
+
+  def update_params(self):
+    self.param_counter += 1
+    if self.param_counter % 60 == 0:  # every 3 seconds at 20hz
+      self.nav_allowed = self._params.get("NavDesiresAllowed", return_default=True)
+
+  def update(self, CS: car.CarState, lateral_active: bool) -> log.Desire:
+    self.update_params()
+    self.sm.update(0)
+    nav_msg = self.sm['navigationd']
+    self.desire = log.Desire.none
+    if self.nav_allowed and nav_msg.valid and lateral_active:
+      upcoming = nav_msg.upcomingTurn
+      if upcoming == 'slightLeft' and (not CS.leftBlindspot or CS.vEgo < self._turn_speed_limit):
+        self.desire = log.Desire.keepLeft
+      elif upcoming == 'slightRight' and (not CS.rightBlindspot or CS.vEgo < self._turn_speed_limit):
+        self.desire = log.Desire.keepRight
+      elif (upcoming == 'left' and CS.steeringPressed and CS.steeringTorque > 0 and not CS.rightBlinker
+            and not CS.leftBlindspot and CS.vEgo < self._turn_speed_limit):
+        self.desire = log.Desire.turnLeft
+      elif (upcoming == 'right' and CS.steeringPressed and CS.steeringTorque < 0 and not CS.leftBlinker
+            and not CS.rightBlindspot and CS.vEgo < self._turn_speed_limit):
+        self.desire = log.Desire.turnRight
+    return self.desire

sunnypilot/navd/navigation_desires/tests/test_navigation_desires.py

@@ -0,0 +1,96 @@
+"""
+Copyright (c) 2021-, James Vecellio, 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 pytest
+import types
+
+from cereal import log
+from openpilot.common.params import Params
+
+from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
+from openpilot.sunnypilot.navd.navigation_desires.navigation_desires import NavigationDesires
+
+
+def make_car(vEgo=0, leftBlinker=False, rightBlinker=False, leftBlindspot=False, rightBlindspot=False, steeringPressed=False, steeringTorque=0):
+  return types.SimpleNamespace(
+    vEgo=vEgo, leftBlinker=leftBlinker, rightBlinker=rightBlinker,
+    leftBlindspot=leftBlindspot, rightBlindspot=rightBlindspot,
+    steeringPressed=steeringPressed, steeringTorque=steeringTorque
+  )
+
+NAVIGATION_PARAMS: list[tuple] = [
+  ('slightLeft', make_car(), log.Desire.keepLeft),
+  ('slightRight', make_car(), log.Desire.keepRight),
+  ('slightLeft', make_car(vEgo=9, leftBlindspot=True), log.Desire.none),
+  ('slightRight', make_car(vEgo=9, rightBlindspot=True), log.Desire.none),
+  ('left', make_car(vEgo=5, leftBlinker=True, rightBlinker=False, leftBlindspot=False, steeringPressed=True, steeringTorque=1), log.Desire.turnLeft),
+  ('left', make_car(vEgo=5, leftBlinker=False, rightBlinker=True), log.Desire.none),
+  ('right', make_car(vEgo=6, rightBlinker=True, leftBlindspot=False, steeringPressed=True, steeringTorque=-1), log.Desire.turnRight),
+  ('right', make_car(vEgo=6, rightBlinker=True, rightBlindspot=True), log.Desire.none),
+  ('left', make_car(vEgo=9, leftBlinker=True), log.Desire.none),
+]
+
+INTEGRATION_PARAMS: list[tuple] = [(carstate, upcoming, log.Desire.none, expected) for upcoming, carstate, expected in NAVIGATION_PARAMS] + [
+  (make_car(vEgo=9, leftBlinker=True, steeringPressed=True, steeringTorque=1), 'slightLeft', log.Desire.turnLeft, log.Desire.keepLeft),
+  (make_car(vEgo=9, rightBlinker=True, steeringPressed=True, steeringTorque=-1), 'slightRight', log.Desire.turnRight, log.Desire.keepRight),
+  (make_car(vEgo=9, leftBlinker=True), 'slightLeft', log.Desire.laneChangeLeft, log.Desire.laneChangeLeft),
+  (make_car(vEgo=9, rightBlinker=True), 'slightRight', log.Desire.laneChangeRight, log.Desire.laneChangeRight),
+  (make_car(vEgo=9), 'none', log.Desire.none, log.Desire.none),
+]
+
+def make_nav_msg(valid=False, upcoming='none'):
+  return types.SimpleNamespace(valid=valid, upcomingTurn=upcoming)
+
+def params_setter(allowed: bool):
+  params = Params()
+  params.put("NavDesiresAllowed", allowed)
+
+@pytest.fixture
+def mock_submaster(mocker):
+  mock_sm = mocker.patch('cereal.messaging.SubMaster')
+  mock_sm_instance = mocker.Mock()
+  mock_sm.return_value = mock_sm_instance
+  mock_sm_instance.__getitem__ = mocker.Mock(return_value=make_nav_msg(valid=False))
+  params_setter(True)
+  return mock_sm_instance
+
+@pytest.mark.parametrize("upcoming, carstate, expected", NAVIGATION_PARAMS)
+def test_navigation_desires_update(mock_submaster, mocker, upcoming, carstate, expected):
+  nav_desires = NavigationDesires()
+  nav_desires.sm.__getitem__ = mocker.Mock(return_value=make_nav_msg(valid=True, upcoming=upcoming))
+  nav_desires.update(carstate, True)
+  assert nav_desires.desire == expected
+
+@pytest.mark.parametrize("msg_valid,lateral_active", [(False, True), (True, False)])
+def test_invalid_or_inactive(mock_submaster, mocker, msg_valid, lateral_active):
+  nav_desires = NavigationDesires()
+  nav_desires.sm.__getitem__ = mocker.Mock(return_value=make_nav_msg(valid=msg_valid, upcoming='slightLeft'))
+  nav_desires.update(make_car(), lateral_active)
+  assert nav_desires.desire == log.Desire.none
+
+def test_update(mock_submaster, mocker):
+  mock_submaster.__getitem__ = mocker.Mock(return_value=make_nav_msg(valid=True, upcoming='left'))
+  nav_desires = NavigationDesires()
+
+  assert nav_desires.update(make_car(leftBlinker=True, steeringPressed=True, steeringTorque=1), True) == log.Desire.turnLeft
+
+  params_setter(False)
+  nav_desires.param_counter = 59
+  nav_desires.update(make_car(leftBlinker=True), True)
+  assert nav_desires.desire == log.Desire.none
+
+@pytest.mark.parametrize("carstate, upcoming, current_desire, expected", INTEGRATION_PARAMS)
+def test_desire_helper(mock_submaster, mocker, carstate, upcoming, current_desire, expected):
+  mock_submaster.__getitem__ = mocker.Mock(return_value=make_nav_msg(valid=True, upcoming=upcoming))
+  dh = DesireHelper()
+  dh.desire = current_desire
+
+  if current_desire in (log.Desire.laneChangeLeft, log.Desire.laneChangeRight):
+    dh.lane_change_state = log.LaneChangeState.laneChangeStarting
+    dh.lane_change_direction = log.LaneChangeDirection.left if current_desire == log.Desire.laneChangeLeft else log.LaneChangeDirection.right
+
+  dh.update(carstate, True, 1.0)
+  assert dh.desire == expected

sunnypilot/navd/navigation_helpers/mapbox_integration.py

@@ -0,0 +1,113 @@
+"""
+Copyright (c) 2021-, James Vecellio, 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 requests
+from urllib.parse import quote
+
+from openpilot.common.params import Params
+
+
+class MapboxIntegration:
+  def __init__(self):
+    self.params = Params()
+
+  def get_public_token(self) -> str:
+    token: str = self.params.get('MapboxToken', return_default=True)
+    return token
+
+  def set_destination(self, postvars, current_lon, current_lat, bearing=None) -> tuple[dict, bool]:
+    if 'latitude' in postvars and 'longitude' in postvars:
+      self.nav_confirmed(postvars, current_lon, current_lat, bearing)
+      return postvars, True
+
+    addr = postvars['place_name']
+    if not addr:
+      return postvars, False
+
+    token = self.get_public_token()
+    url = f'https://api.mapbox.com/geocoding/v5/mapbox.places/{quote(addr)}.json?access_token={token}&limit=1&proximity={current_lon},{current_lat}'
+    try:
+      response = requests.get(url, timeout=5)
+      if response.status_code == 200:
+        features = response.json()['features']
+        if features:
+          longitude, latitude = features[0]['geometry']['coordinates']
+          postvars.update({'latitude': latitude, 'longitude': longitude, 'name': addr})
+          self.nav_confirmed(postvars, current_lon, current_lat, bearing)
+          return postvars, True
+    except requests.RequestException:
+      pass  # Broad exception to handle network errors like no internet without crashing navd process.
+    return postvars, False
+
+  def nav_confirmed(self, postvars, start_lon, start_lat, bearing=None) -> None:
+    if not postvars:
+      return
+
+    latitude = float(postvars['latitude'])
+    longitude = float(postvars['longitude'])
+
+    data: dict = {'navData': {'current': {'latitude': latitude, 'longitude': longitude}, 'route': {}}}
+
+    token = self.get_public_token()
+    route_data = self.generate_route(start_lon, start_lat, longitude, latitude, token, bearing)
+    if route_data:
+      data['navData']['route'] = route_data
+    self.params.put('MapboxSettings', data)
+
+  @staticmethod
+  def generate_route(start_lon, start_lat, end_lon, end_lat, token, bearing=None) -> dict | None:
+    if not token:
+      return None
+
+    params = {
+      'access_token': token,
+      'geometries': 'geojson',
+      'steps': 'true',
+      'overview': 'full',
+      'annotations': 'maxspeed',
+      'alternatives': 'false',
+      'banner_instructions': 'true',
+    }
+    if bearing is not None:
+      params['bearings'] = f'{int((bearing + 360) % 360):.0f},90;'
+
+    try:
+      response = requests.get(f'https://api.mapbox.com/directions/v5/mapbox/driving/{start_lon},{start_lat};{end_lon},{end_lat}', params=params, timeout=5)
+      data = response.json() if response.status_code == 200 else {}
+    except requests.RequestException:
+      return None
+
+    routes = data['routes'] if data else None
+    legs = routes[0]['legs'] if routes else None
+
+    if data.get('code') != 'Ok' or not routes or not legs:
+      return None
+
+    route = routes[0]
+    leg = legs[0]
+
+    steps = [
+      {
+        'maneuver': step['maneuver']['type'],
+        'instruction': step['maneuver']['instruction'],
+        'distance': step['distance'],
+        'duration': step['duration'],
+        'location': {'longitude': step['maneuver']['location'][0], 'latitude': step['maneuver']['location'][1]},
+        'modifier': step['maneuver'].get('modifier', 'none'),
+        'bannerInstructions': step['bannerInstructions'],
+      }
+      for step in leg['steps']
+    ]
+
+    maxspeed = [{'speed': item['speed'], 'unit': item['unit']} for item in leg['annotation']['maxspeed'] if 'speed' in item]
+
+    return {
+      'steps': steps,
+      'totalDistance': route['distance'],
+      'totalDuration': route['duration'],
+      'geometry': [{'longitude': coord[0], 'latitude': coord[1]} for coord in route['geometry']['coordinates']],
+      'maxspeed': maxspeed,
+    }

sunnypilot/navd/navigation_helpers/nav_instructions.py

@@ -0,0 +1,138 @@
+"""
+Copyright (c) 2021-, James Vecellio, 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.common.constants import CV
+from openpilot.common.params import Params
+
+from openpilot.sunnypilot.navd.helpers import Coordinate, string_to_direction
+
+
+class NavigationInstructions:
+  def __init__(self):
+    self.coord = Coordinate(0, 0)
+    self.params = Params()
+    self._cached_route = None
+    self._route_loaded = False
+    self._no_route = False
+
+  def get_route_progress(self, current_lat, current_lon) -> dict | None:
+    route = self.get_current_route()
+    if not route or not route['geometry'] or not route['steps']:
+      return None
+
+    self.coord.latitude = current_lat
+    self.coord.longitude = current_lon
+
+    # Find the closest point on the route relative to self
+    closest_idx, min_distance = min(((idx, self.coord.distance_to(coord)) for idx, coord in enumerate(route['geometry'])), key=lambda x: x[1])
+    closest_cumulative = route['cumulative_distances'][closest_idx]
+
+    # Find the current step index, which is the HIGHEST idx where the step location cumulative less/equal closest cumulative
+    current_step_idx = max((idx for idx, step in enumerate(route['steps']) if step['cumulative_distance'] <= closest_cumulative), default=-1)
+    current_step = route['steps'][current_step_idx if current_step_idx >= 0 else 0]
+
+    # The next turn is the next step relative to our cumulative index
+    next_turn_idx = current_step_idx + 1
+    next_turn = route['steps'][next_turn_idx] if 0 <= next_turn_idx < len(route['steps']) else None
+
+    current_maxspeed = current_step['maxspeed']
+
+    distance_to_end_of_step = max(0, current_step['distance'] - (closest_cumulative - current_step['cumulative_distance']))
+
+    all_maneuvers: list = []
+    max_maneuvers = 3
+    for idx in range(current_step_idx, min(current_step_idx + max_maneuvers, len(route['steps']))):
+      step = route['steps'][idx]
+      if idx == current_step_idx:
+        distance = distance_to_end_of_step
+      else:
+        distance = step['cumulative_distance'] - closest_cumulative
+      all_maneuvers.append({'distance': distance, 'type': step['maneuver'], 'modifier': step['modifier'], 'instruction': step['instruction']})
+
+    return {
+      'distance_from_route': min_distance,
+      'current_step': current_step,
+      'next_turn': next_turn,
+      'current_maxspeed': current_maxspeed,
+      'all_maneuvers': all_maneuvers,
+      'current_step_idx': current_step_idx,
+      'distance_to_end_of_step': distance_to_end_of_step,
+    }
+
+  def get_current_route(self):
+    if self._route_loaded and self._cached_route is not None:
+      return self._cached_route
+    if self._no_route:
+      return None
+
+    param_value = self.params.get('MapboxSettings')
+    route = param_value['navData']['route'] if param_value else None
+    if not route:
+      self._no_route = True
+      return None
+
+    geometry = [Coordinate(coord['latitude'], coord['longitude']) for coord in route['geometry']]
+    cumulative_distances = [0.0]
+    cumulative_distances.extend(cumulative_distances[-1] + geometry[step - 1].distance_to(geometry[step]) for step in range(1, len(geometry)))
+    maxspeed = [(speed['speed'], speed['unit']) for speed in route['maxspeed']]
+    steps = []
+    for step in route['steps']:
+      location = Coordinate(step['location']['latitude'], step['location']['longitude'])
+      closest_idx = min(range(len(geometry)), key=lambda i: location.distance_to(geometry[i]))
+      steps.append({
+        'bannerInstructions': step['bannerInstructions'],
+        'distance': step['distance'],
+        'duration': step['duration'],
+        'maneuver': step['maneuver'],
+        'location': location,
+        'cumulative_distance': cumulative_distances[closest_idx],
+        'maxspeed': maxspeed[min(closest_idx, len(maxspeed) - 1)] if len(maxspeed) > 0 else (0, 'kmh'),
+        'modifier': string_to_direction(step['modifier']),
+        'instruction': step['instruction'],
+      })
+    self._cached_route = {
+      'steps': steps,
+      'total_distance': route['totalDistance'],
+      'total_duration': route['totalDuration'],
+      'geometry': geometry,
+      'cumulative_distances': cumulative_distances,
+      'maxspeed': maxspeed,
+    }
+    self._route_loaded = True
+    return self._cached_route
+
+  def clear_route_cache(self):
+    self._cached_route = None
+    self._route_loaded = False
+    self._no_route = False
+
+  def get_upcoming_turn_from_progress(self, progress, current_lat, current_lon) -> str:
+    if progress and progress['next_turn']:
+      self.coord.latitude = current_lat
+      self.coord.longitude = current_lon
+      distance = self.coord.distance_to(progress['next_turn']['location'])
+      if distance <= 100:
+        modifier = progress['next_turn']['modifier']
+        return str(modifier)
+    return 'none'
+
+  @staticmethod
+  def get_current_speed_limit_from_progress(progress, is_metric: bool) -> int:
+    if progress and progress['current_maxspeed']:
+      speed, _ = progress['current_maxspeed']
+      if is_metric:
+        return int(speed)
+      else:
+        return int(round(speed * CV.KPH_TO_MPH))
+    return 0
+
+  @staticmethod
+  def arrived_at_destination(progress) -> bool:
+    if progress['all_maneuvers'][0]['type'] == 'arrive':
+      return True
+    elif progress['all_maneuvers'][0]['instruction'].startswith('Your destination'):
+      return True
+    return False

sunnypilot/navd/navigation_helpers/tests/test_mapbox.py

@@ -0,0 +1,94 @@
+"""
+Copyright (c) 2021-, James Vecellio, 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 os
+
+from openpilot.common.constants import CV
+
+from openpilot.sunnypilot.navd.navigation_helpers.mapbox_integration import MapboxIntegration
+from openpilot.sunnypilot.navd.navigation_helpers.nav_instructions import NavigationInstructions
+
+
+class TestMapbox:
+  @classmethod
+  def setup_class(cls):
+    cls.mapbox = MapboxIntegration()
+    cls.nav = NavigationInstructions()
+
+    token = os.environ.get('MAPBOX_TOKEN_CI')
+    if token:
+      cls.mapbox.params.put('MapboxToken', token)
+
+    # route setup
+    cls.current_lon, cls.current_lat = -119.17557, 34.23305
+    cls.mapbox.params.put('MapboxRoute', '740 E Ventura Blvd. Camarillo, CA')
+    cls.postvars = {"place_name": cls.mapbox.params.get('MapboxRoute')}
+    cls.postvars, cls.valid_addr = cls.mapbox.set_destination(cls.postvars, cls.current_lon, cls.current_lat)
+    cls.route = cls.nav.get_current_route()
+    cls.progress = cls.nav.get_route_progress(cls.current_lat, cls.current_lon)
+
+  def test_set_destination(self):
+    assert self.valid_addr
+    settings = self.mapbox.params.get('MapboxSettings')
+    assert settings is not None
+    dest_lat = settings['navData']['current']['latitude']
+    dest_lon = settings['navData']['current']['longitude']
+    assert dest_lat == self.postvars["latitude"] and dest_lon == self.postvars["longitude"]
+
+  def test_get_route(self):
+    assert self.route is not None
+    assert 'steps' in self.route
+    assert 'geometry' in self.route
+    assert 'maxspeed' in self.route
+    assert 'total_distance' in self.route
+    assert 'total_duration' in self.route
+    assert len(self.route['steps']) > 0
+    assert len(self.route['geometry']) > 0
+    assert len(self.route['maxspeed']) > 0
+
+    if self.route and 'steps' in self.route:
+      for step in self.route['steps']:
+        assert 'modifier' in step
+
+  def test_upcoming_turn_detection(self):
+    upcoming = self.nav.get_upcoming_turn_from_progress(self.progress, self.current_lat, self.current_lon)
+    assert isinstance(upcoming, str)
+    assert upcoming == 'none'
+
+    if self.route['steps']:
+      turn_lat = self.route['steps'][1]['location'].latitude
+      turn_lon = self.route['steps'][1]['location'].longitude
+      close_lat = turn_lat - 0.0008  # 80 ish meters before the turn
+      if self.progress and self.progress.get('next_turn'):
+        expected_turn = self.progress['next_turn']['modifier']
+        upcoming_close = self.nav.get_upcoming_turn_from_progress(self.progress, close_lat, turn_lon)
+        if expected_turn:
+          assert upcoming_close == expected_turn == 'right', "Should be a right turn upcoming"
+
+  def test_route_progress_tracking(self):
+    assert self.progress is not None
+    assert 'distance_from_route' in self.progress
+    assert 'next_turn' in self.progress
+    assert 'current_maxspeed' in self.progress
+    assert 'all_maneuvers' in self.progress
+    assert 'distance_to_end_of_step' in self.progress
+    assert self.progress['distance_from_route'] >= 0
+    assert isinstance(self.progress['all_maneuvers'], list)
+
+  def test_speed_limit_handling(self):
+    speed_limit_metric = self.nav.get_current_speed_limit_from_progress(self.progress, True)
+    speed_limit_imperial = self.nav.get_current_speed_limit_from_progress(self.progress, False)
+    assert isinstance(speed_limit_metric, int)
+    assert isinstance(speed_limit_imperial, int)
+    expected_metric = int(self.progress['current_maxspeed'][0])
+    expected_imperial = int(round(self.progress['current_maxspeed'][0] * CV.KPH_TO_MPH))
+    assert speed_limit_metric == expected_metric
+    assert speed_limit_imperial == expected_imperial
+
+  def test_arrival_detection(self):
+    is_arrived = self.nav.arrived_at_destination(self.progress)
+    assert isinstance(is_arrived, bool)
+    assert not is_arrived

sunnypilot/navd/navigationd.py

@@ -0,0 +1,160 @@
+"""
+Copyright (c) 2021-, James Vecellio, 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 math
+
+import cereal.messaging as messaging
+from cereal import custom
+from openpilot.common.params import Params
+from openpilot.common.realtime import Ratekeeper
+from openpilot.common.swaglog import cloudlog
+
+from openpilot.sunnypilot.navd.constants import NAV_CV
+from openpilot.sunnypilot.navd.helpers import Coordinate, parse_banner_instructions
+from openpilot.sunnypilot.navd.navigation_helpers.mapbox_integration import MapboxIntegration
+from openpilot.sunnypilot.navd.navigation_helpers.nav_instructions import NavigationInstructions
+
+
+class Navigationd:
+  def __init__(self):
+    self.params = Params()
+    self.mapbox = MapboxIntegration()
+    self.nav_instructions = NavigationInstructions()
+
+    self.sm = messaging.SubMaster(['liveLocationKalman'])
+    self.pm = messaging.PubMaster(['navigationd'])
+    self.rk = Ratekeeper(3) # 3 Hz
+
+    self.route = None
+    self.destination: str | None = None
+    self.new_destination: str = ''
+
+    self.allow_navigation: bool = False
+    self.recompute_allowed: bool = False
+    self.allow_recompute: bool = False
+    self.reroute_counter: int = 0
+    self.cancel_route_counter: int = 0
+
+    self.frame: int = -1
+    self.last_position: Coordinate | None = None
+    self.last_bearing: float | None = None
+    self.is_metric: bool = False
+    self.valid: bool = False
+
+  def _update_params(self):
+    if self.last_position is not None:
+      self.frame += 1
+      if self.frame % 9 == 0:
+        self.allow_navigation = self.params.get('AllowNavigation', return_default=True)
+        self.is_metric = self.params.get('IsMetric', return_default=True)
+        self.new_destination = self.params.get('MapboxRoute')
+        self.recompute_allowed = self.params.get('MapboxRecompute', return_default=True)
+
+      self.allow_recompute: bool = (self.new_destination != self.destination and self.new_destination != '') or (
+        self.recompute_allowed and self.reroute_counter > 9 and self.route
+      )
+
+      if self.allow_recompute:
+        postvars = {'place_name': self.new_destination}
+        postvars, valid_addr = self.mapbox.set_destination(postvars, self.last_position.longitude, self.last_position.latitude, self.last_bearing)
+        cloudlog.debug(f'Set new destination to: {self.new_destination}, valid: {valid_addr}')
+        if valid_addr:
+          self.destination = self.new_destination
+          self.nav_instructions.clear_route_cache()
+          self.route = self.nav_instructions.get_current_route()
+          self.cancel_route_counter = 0
+          self.reroute_counter = 0
+
+      if self.cancel_route_counter == 30:
+        self.cancel_route_counter = 0
+        self.destination = None
+        self.nav_instructions.clear_route_cache()
+        self.route = None
+
+      self.valid = self.route is not None
+
+  def _update_navigation(self) -> tuple[str, dict | None, dict]:
+    banner_instructions: str = ''
+    nav_data: dict = {}
+    if self.allow_navigation and self.last_position is not None:
+      if progress := self.nav_instructions.get_route_progress(self.last_position.latitude, self.last_position.longitude):
+        nav_data['upcoming_turn'] = self.nav_instructions.get_upcoming_turn_from_progress(progress, self.last_position.latitude, self.last_position.longitude)
+        nav_data['current_speed_limit'] = self.nav_instructions.get_current_speed_limit_from_progress(progress, self.is_metric)
+        arrived = self.nav_instructions.arrived_at_destination(progress)
+
+        if progress['current_step']:
+          parsed = parse_banner_instructions(progress['current_step']['bannerInstructions'], progress['distance_to_end_of_step'])
+          if parsed:
+            banner_instructions = parsed['maneuverPrimaryText']
+
+        nav_data['distance_from_route'] = progress['distance_from_route']
+        large_distance = progress['distance_from_route'] > 100
+
+        if large_distance:
+          self.cancel_route_counter = self.cancel_route_counter + 1 if progress['distance_from_route'] > NAV_CV.QUARTER_MILE else 0
+          if self.recompute_allowed:
+            self.reroute_counter += 1
+        elif arrived:
+          self.cancel_route_counter += 1
+        else:
+          self.cancel_route_counter = 0
+          self.reroute_counter = 0
+
+        # Don't recompute in last segment to prevent reroute loops
+        if self.route:
+          if progress['current_step_idx'] == len(self.route['steps']) - 1:
+            self.allow_recompute = False
+    else:
+      banner_instructions = ''
+      progress = None
+      nav_data = {}
+      self.valid = False
+
+    return banner_instructions, progress, nav_data
+
+  def _build_navigation_message(self, banner_instructions: str, progress: dict | None, nav_data: dict, valid: bool):
+    msg = messaging.new_message('navigationd')
+    msg.valid = valid
+    msg.navigationd.upcomingTurn = nav_data.get('upcoming_turn', 'none')
+    msg.navigationd.currentSpeedLimit = nav_data.get('current_speed_limit', 0)
+    msg.navigationd.bannerInstructions = banner_instructions
+    msg.navigationd.distanceFromRoute = nav_data.get('distance_from_route', 0.0)
+    msg.navigationd.valid = self.valid
+
+    all_maneuvers = (
+      [custom.Navigationd.Maneuver.new_message(distance=m['distance'], type=m['type'], modifier=m['modifier'],
+                                               instruction=m['instruction']) for m in progress['all_maneuvers']]
+      if progress
+      else []
+    )
+    msg.navigationd.allManeuvers = all_maneuvers
+
+    return msg
+
+  def run(self):
+    cloudlog.warning('navigationd init')
+
+    while True:
+      self.sm.update()
+      location = self.sm['liveLocationKalman']
+      localizer_valid = location.positionGeodetic.valid if location else False
+
+      if localizer_valid:
+        self.last_bearing = math.degrees(location.calibratedOrientationNED.value[2])
+        self.last_position = Coordinate(location.positionGeodetic.value[0], location.positionGeodetic.value[1])
+
+      self._update_params()
+      banner_instructions, progress, nav_data = self._update_navigation()
+
+      msg = self._build_navigation_message(banner_instructions, progress, nav_data, valid=localizer_valid)
+
+      self.pm.send('navigationd', msg)
+      self.rk.keep_time()
+
+
+def main():
+  nav = Navigationd()
+  nav.run()

sunnypilot/navd/tests/test_event_builder.py

@@ -0,0 +1,92 @@
+"""
+Copyright (c) 2021-, James Vecellio, 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 cereal import custom
+from openpilot.common.params import Params
+
+from openpilot.sunnypilot.navd.event_builder import EventBuilder
+
+
+class MockSM(dict):
+  def __init__(self, nav_msg):
+    super().__init__()
+    self['navigationd'] = nav_msg
+
+
+class TestEventBuilder:
+  def setup_method(self):
+    self.params = Params()
+    self.event_builder = EventBuilder()
+
+  def create_nav_msg(self, upcoming_turn='none', valid=True):
+    nav_msg = custom.Navigationd.new_message()
+    nav_msg.valid = valid
+    nav_msg.upcomingTurn = upcoming_turn
+    nav_msg.allManeuvers = [
+      custom.Navigationd.Maneuver.new_message(distance=192.84873284, type='turn', modifier='left', instruction='West Esplanade Drive'),
+      custom.Navigationd.Maneuver.new_message(distance=192.84809314, type='turn', modifier='right', instruction='West Esplanade Drive'),
+    ]
+    return nav_msg
+
+  def test_validity(self):
+    nav_msg = self.create_nav_msg(valid=False)
+    events = EventBuilder.build_navigation_events(MockSM(nav_msg))
+    assert events == []
+
+  def test_enabled(self):
+    self.params.put("NavEvents", True)
+    nav_msg = self.create_nav_msg()
+    events = self.event_builder.update(MockSM(nav_msg))
+    expected = [{
+      'name': custom.OnroadEventSP.EventName.navigationBanner,
+      'message': 'For 192m, Continue on West Esplanade Drive'
+    }]
+    assert events == expected
+
+    self.params.put("NavEvents", False)
+    self.event_builder._counter = 59
+    events = self.event_builder.update(MockSM(nav_msg))
+    assert events == []
+
+
+  def test_build_navigation_events(self):
+    nav_msg = self.create_nav_msg()
+    events = EventBuilder.build_navigation_events(MockSM(nav_msg), False)
+    expected = [{
+      'name': custom.OnroadEventSP.EventName.navigationBanner,
+      'message': 'For 650ft, Continue on West Esplanade Drive',
+    }]
+    assert events == expected
+
+  def test_distance_condition_imperial(self):
+    nav_msg = self.create_nav_msg()
+    nav_msg.allManeuvers[1] = custom.Navigationd.Maneuver.new_message(distance=160.0, type='continue', modifier='straight', instruction='1234 Apple Way')
+    events = EventBuilder.build_navigation_events(MockSM(nav_msg), False)
+    expected = [{
+      'name': custom.OnroadEventSP.EventName.navigationBanner,
+      'message': 'For 500ft, Continue on 1234 Apple Way',
+    }]
+    assert events == expected
+
+  def test_upcoming_turn_override(self):
+    nav_msg = self.create_nav_msg(upcoming_turn='left')
+    events = EventBuilder.build_navigation_events(MockSM(nav_msg))
+    expected = [{
+      'name': custom.OnroadEventSP.EventName.navigationBanner,
+      'message': 'Turning Left, Make sure to nudge the wheel',
+    }]
+    assert events == expected
+
+  def test_straight(self):
+    nav_msg = self.create_nav_msg()
+    nav_msg.allManeuvers[1] = custom.Navigationd.Maneuver.new_message(distance=80.0, type='continue', modifier='straight', instruction='1234 Apple Way')
+
+    events = EventBuilder.build_navigation_events(MockSM(nav_msg))
+    expected = [{
+      'name': custom.OnroadEventSP.EventName.navigationBanner,
+      'message': 'For 80m, Continue on 1234 Apple Way'
+    }]
+    assert events == expected

sunnypilot/navd/tests/test_navigationd.py

@@ -0,0 +1,76 @@
+"""
+Copyright (c) 2021-, James Vecellio, 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 platform
+import pytest
+
+import cereal.messaging as messaging
+
+from openpilot.sunnypilot.navd.navigationd import Navigationd
+from openpilot.sunnypilot.navd.helpers import Coordinate
+
+
+class TestNavigationd:
+  is_darwin = platform.system() == "Darwin"
+
+  @pytest.fixture(autouse=True)
+  def setup_method(self, mocker):
+    if self.is_darwin:
+      mocker.patch('cereal.messaging.SubMaster')
+      mocker.patch('cereal.messaging.PubMaster')
+
+  def test_update_params(self):
+    nav = Navigationd()
+    nav.last_position = None
+    nav._update_params()
+    assert nav.frame == -1
+    nav.last_position = Coordinate(latitude=37.0, longitude=128.0)
+    nav._update_params()
+    assert nav.frame == 0  # frame only updates when last position is set
+
+  def test_update_navigation_no_position(self):
+    nav = Navigationd()
+    nav.last_position = None
+    banner, progress, nav_data = nav._update_navigation()
+    assert banner == ''
+    assert progress is None
+    assert nav_data == {}
+
+  def test_update_navigation(self):
+    nav = Navigationd()
+    nav.last_position = Coordinate(latitude=37.0, longitude=128.0)
+    nav.route = {'580 Winchester dr, oxnard, CA': True}
+    banner, progress, nav_data = nav._update_navigation()
+    assert isinstance(banner, str)
+    assert not progress  # no route was actually set
+    assert isinstance(nav_data, dict)
+
+  def test_build_navigation_message(self):
+    if self.is_darwin:
+      nav = Navigationd()
+      msg = nav._build_navigation_message('', None, {}, True)
+      assert msg.navigationd.bannerInstructions == ''
+      assert msg.navigationd.valid is False
+    else:
+      sm = messaging.SubMaster(['navigationd'])
+      nav = Navigationd()
+      msg = nav._build_navigation_message('', None, {}, True)
+
+      nav.pm.send('navigationd', msg)
+      sm.update()
+      received_msg = sm['navigationd']
+
+      assert received_msg.bannerInstructions == msg.navigationd.bannerInstructions
+      assert received_msg.valid == msg.navigationd.valid
+
+  def test_cancel_route(self):
+    nav = Navigationd()
+    nav.last_position = Coordinate(latitude=37.0, longitude=128.0)
+    nav.route = {'580 Winchester dr, oxnard, CA': True}
+    nav.cancel_route_counter = 30
+    nav._update_params()
+    assert nav.route is None
+    assert nav.destination is None

sunnypilot/selfdrive/controls/lib/longitudinal_planner.py

@@ -16,6 +16,7 @@ from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.speed_limit_assist
 from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.speed_limit_resolver import SpeedLimitResolver
 from openpilot.sunnypilot.selfdrive.selfdrived.events import EventsSP
 from openpilot.sunnypilot.models.helpers import get_active_bundle
+from openpilot.sunnypilot.navd.event_builder import EventBuilder
 
 DecState = custom.LongitudinalPlanSP.DynamicExperimentalControl.DynamicExperimentalControlState
 LongitudinalPlanSource = custom.LongitudinalPlanSP.LongitudinalPlanSource
@@ -32,6 +33,7 @@ class LongitudinalPlannerSP:
     self.generation = int(model_bundle.generation) if (model_bundle := get_active_bundle()) else None
     self.source = LongitudinalPlanSource.cruise
     self.e2e_alerts_helper = E2EAlertsHelper()
+    self.event_builder = EventBuilder()
 
     self.output_v_target = 0.
     self.output_a_target = 0.
@@ -77,10 +79,16 @@ class LongitudinalPlannerSP:
     self.output_v_target, self.output_a_target = targets[self.source]
     return self.output_v_target, self.output_a_target
 
+  def update_navigation_events(self, sm: messaging.SubMaster) -> None:
+    nav_events = self.event_builder.update(sm)
+    for event in nav_events:
+      self.events_sp.add(event['name'])
+
   def update(self, sm: messaging.SubMaster) -> None:
     self.events_sp.clear()
     self.dec.update(sm)
     self.e2e_alerts_helper.update(sm, self.events_sp)
+    self.update_navigation_events(sm)
 
   def publish_longitudinal_plan_sp(self, sm: messaging.SubMaster, pm: messaging.PubMaster) -> None:
     plan_sp_send = messaging.new_message('longitudinalPlanSP')

sunnypilot/selfdrive/controls/lib/tests/test_auto_lane_change.py

@@ -7,11 +7,17 @@ See the LICENSE.md file in the root directory for more details.
 
 from parameterized import parameterized
 
+import cereal.messaging
 from openpilot.common.realtime import DT_MDL
 from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper, LaneChangeState, LaneChangeDirection
 from openpilot.sunnypilot.selfdrive.controls.lib.auto_lane_change import AutoLaneChangeController, AutoLaneChangeMode, \
   AUTO_LANE_CHANGE_TIMER, ONE_SECOND_DELAY
 
+class MockSubMaster:
+  def __init__(self, services):
+    pass
+
+
 AUTO_LANE_CHANGE_TIMER_COMBOS = [
   (AutoLaneChangeMode.NUDGELESS, AUTO_LANE_CHANGE_TIMER[AutoLaneChangeMode.NUDGELESS]),
   (AutoLaneChangeMode.HALF_SECOND, AUTO_LANE_CHANGE_TIMER[AutoLaneChangeMode.HALF_SECOND]),
@@ -23,6 +29,7 @@ AUTO_LANE_CHANGE_TIMER_COMBOS = [
 
 class TestAutoLaneChangeController:
   def setup_method(self):
+    cereal.messaging.SubMaster = MockSubMaster
     self.DH = DesireHelper()
     self.alc = AutoLaneChangeController(self.DH)
 

sunnypilot/selfdrive/controls/lib/tests/test_lane_turn_desire.py

@@ -1,14 +1,29 @@
 import pytest
+
+import cereal.messaging
 from cereal import log, custom
 from openpilot.common.params import Params
 
 from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
 from openpilot.sunnypilot.selfdrive.controls.lib.lane_turn_desire import LaneTurnController, LANE_CHANGE_SPEED_MIN
-from openpilot.sunnypilot.selfdrive.controls.lib.auto_lane_change import AutoLaneChangeMode
 
 TurnDirection = custom.ModelDataV2SP.TurnDirection
 
 
+class MockSubMaster:
+  def __init__(self, services): pass
+
+  def update(self, timeout): pass
+
+  def __getitem__(self, key):
+    return type('nav_msg', (), {'valid': False})()
+
+
+@pytest.fixture(autouse=True)
+def mock_submaster():
+  cereal.messaging.SubMaster = MockSubMaster
+
+
 @pytest.mark.parametrize("left_blinker,right_blinker,v_ego,blindspot_left,blindspot_right,expected", [
   (True, False, 5, False, False, TurnDirection.turnLeft),
   (False, True, 6, False, False, TurnDirection.turnRight),
@@ -107,7 +122,6 @@ def set_lane_turn_params():
 ])
 def test_desire_helper_integration(carstate, lateral_active, lane_change_prob, expected_desire, set_lane_turn_params):
   dh = DesireHelper()
-  dh.alc.lane_change_set_timer = AutoLaneChangeMode.NUDGE
   for _ in range(10):
     dh.update(carstate, lateral_active, lane_change_prob)
-  assert dh.desire == expected_desire  # The first four tests were unit tests to test the controller, where this tests the integration in desire helpers
+  assert dh.desire == expected_desire

sunnypilot/selfdrive/locationd/tests/test_locationd.py

@@ -1,4 +1,5 @@
 import pytest
+import platform
 import json
 import random
 import time
@@ -12,6 +13,10 @@ from openpilot.common.transformations.coordinates import ecef2geodetic
 from openpilot.system.manager.process_config import managed_processes
 
 
+if platform.system() == 'Darwin':
+  pytest.skip("Skipping locationd test on macOS due to unsupported msgq.", allow_module_level=True)
+
+
 class TestLocationdProc:
   LLD_MSGS = ['gpsLocationExternal', 'cameraOdometry', 'carState', 'liveCalibration',
               'accelerometer', 'gyroscope', 'magnetometer']

sunnypilot/selfdrive/selfdrived/events.py

@@ -4,6 +4,7 @@ from openpilot.common.constants import CV
 from openpilot.sunnypilot.selfdrive.selfdrived.events_base import EventsBase, Priority, ET, Alert, \
   NoEntryAlert, ImmediateDisableAlert, EngagementAlert, NormalPermanentAlert, AlertCallbackType, wrong_car_mode_alert
 from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit import PCM_LONG_REQUIRED_MAX_SET_SPEED, CONFIRM_SPEED_THRESHOLD
+from openpilot.sunnypilot.navd.event_builder import EventBuilder
 
 
 AlertSize = log.SelfdriveState.AlertSize
@@ -55,6 +56,14 @@ def speed_limit_pre_active_alert(CP: car.CarParams, CS: car.CarState, sm: messag
     Priority.LOW, VisualAlert.none, AudibleAlertSP.promptSingleLow, .1)
 
 
+def navigation_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  events = EventBuilder.build_navigation_events(sm, metric)
+  if not events:
+    return Alert("", "", AlertStatus.normal, AlertSize.none, Priority.LOWEST, VisualAlert.none, AudibleAlert.none, 0.)
+
+  return Alert(events[0]['message'], "", AlertStatus.normal, AlertSize.small, Priority.LOW, VisualAlert.none, AudibleAlert.none, 2.)
+
+
 class EventsSP(EventsBase):
   def __init__(self):
     super().__init__()
@@ -226,4 +235,8 @@ EVENTS_SP: dict[int, dict[str, Alert | AlertCallbackType]] = {
       AlertStatus.normal, AlertSize.none,
       Priority.MID, VisualAlert.none, AudibleAlert.prompt, 3.),
   },
+
+  EventNameSP.navigationBanner: {
+    ET.WARNING: navigation_alert,
+  },
 }

system/manager/process_config.py

@@ -180,6 +180,9 @@ procs += [
   NativeProcess("mapd", Paths.mapd_root(), ["bash", "-c", f"{MAPD_PATH} > /dev/null 2>&1"], mapd_ready),
   PythonProcess("mapd_manager", "sunnypilot.mapd.mapd_manager", always_run),
 
+  # navigationd
+  PythonProcess("navigationd", "sunnypilot.navd.navigationd", only_onroad),
+
   # locationd
   NativeProcess("locationd_llk", "sunnypilot/selfdrive/locationd", ["./locationd"], only_onroad),
 ]