chore: update CHANGELOG for 2026.001.002

* don't use upstream's

* clean

* update schema

* fix

* mismatch test and fix

.github/ISSUE_TEMPLATE/enhancement.md

@@ -0,0 +1,8 @@
+---
+name: Enhancement
+about: For openpilot enhancement suggestions
+title: ''
+labels: 'enhancement'
+assignees: ''
+---
+

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

@@ -172,8 +172,8 @@ jobs:
             output_file="${{ env.MODELS_DIR }}/${base_name}_tinygrad.pkl"
 
             echo "Compiling: $onnx_file -> $output_file"
-            DEV=QCOM FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1 IMAGE=2 python3 "${{ env.TINYGRAD_PATH }}/examples/openpilot/compile3.py" "$onnx_file" "$output_file"
-            DEV=QCOM FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1 python3 "${{ env.MODELS_DIR }}/../get_model_metadata.py" "$onnx_file" || true
+            QCOM=1 python3 "${{ env.TINYGRAD_PATH }}/examples/openpilot/compile3.py" "$onnx_file" "$output_file"
+            DEV=QCOM FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 python3 "${{ env.MODELS_DIR }}/../get_model_metadata.py" "$onnx_file" || true
           done
 
       - name: Validate Model Outputs

CHANGELOG.md

@@ -1,4 +1,14 @@
-sunnypilot Version 2026.001.000 (2026-03-xx)
+sunnypilot Version 2026.001.002 (2026-05-07)
+========================
+* What's Changed (sunnypilot/sunnypilot)
+  * release: ignore upstream IsReleaseBranch by @sunnyhaibin
+
+sunnypilot Version 2026.001.001 (2026-05-06)
+========================
+* What's Changed (sunnypilot/sunnypilot)
+  * ui: update gates for certain toggles by @sunnyhaibin
+
+sunnypilot Version 2026.001.000 (2026-05-06)
 ========================
 * What's Changed (sunnypilot/sunnypilot)
   * Complete rewrite of the user interface from Qt C++ to Raylib Python
@@ -66,6 +76,64 @@ sunnypilot Version 2026.001.000 (2026-03-xx)
   * Pause Lateral Control with Blinker: Post-Blinker Delay by @CHaucke89
   * SCC-V: Use p97 for predicted lateral accel by @yasu-oh
   * Controls: Support for Torque Lateral Control v0 Tune by @sunnyhaibin
+  * [TIZI/TICI] ui: ensure null checks for `CarParams` and `CarParamsSP` by @sunnyhaibin
+  * [TIZI/TICI] ui: use `vCruiseCluster` and `vEgoCluster` for SLA `preActive` by @sunnyhaibin
+  * Fix display of values when using use_float_scaling by @CHaucke89
+  * models: fix default & index "0" by @nayan8teen
+  * [TIZI/TICI] visuals: Improved speed limit by @angaz
+  * ICBM: ensure button timers update on disable to clear stale presses by @jamesmikesell
+  * [TIZI/TICI] ui: simplify Smart Cruise Control text rendering by @sunnyhaibin
+  * controlsd: fix steer_limited_by_safety not updating under MADS by @zephleggett
+  * soundd: trigger timeout warning during MADS lateral-only by @zephleggett
+  * pandad: flasher for Rivian long upgrade module by @lukasloetkolben
+  * modeld_v2: tinygrad transformation warp by @Discountchubbs
+  * tools: block `manage_sunnylinkd` in sim startup script by @sunnyhaibin
+  * [MICI] ui: need superclass `_render` in `HudRendererSP` by @sunnyhaibin
+  * [TIZI/TICI] ui: Speed Limit Assist active status by @sunnyhaibin
+  * ui: reimplement "Screen Off" option to Onroad Brightness by @sunnyhaibin
+  * ui: don't hide steering wheel when blindspot disabled by @royjr
+  * ui: Speed Limit Assist `preActive` improvements  by @sunnyhaibin
+  * ui: consolidate Speed Limit Assist `preActive` status rendering by @sunnyhaibin
+  * [MICI] ui: Speed Limit Assist `preActive` status by @sunnyhaibin
+  * sunnypilot modeld: remove thneed modeld by @Discountchubbs
+  * modeld_v2: decouple planplus scaling from accel by @Discountchubbs
+  * sunnylink: Handle exceptions in `getParamsAllKeysV1` to log crashes by @devtekve
+  * [TIZI/TICI] ui: Developer UI cleanup by @sunnyhaibin
+  * [TIZI/TICI] ui: dynamic alert size by @nayan8teen
+  * i18n(fr): Add French translations by @didlawowo
+  * Toyota: Stop and Go Hack (Alpha) by @sunnyhaibin
+  * ui: `AlertFadeAnimator` for longitudinal-related statuses by @sunnyhaibin
+  * pandad: gate unsupported pandas before flashing by @sunnyhaibin
+  * Rivian: Flash xnor's Longitudinal Upgrade Kit prior supported panda check by @lukasloetkolben
+  * [TIZI/TICI] ui: add back gate steering arc behind toggle by @sunnyhaibin
+  * ui: gate Onroad Brightness Delay on readiness by @sunnyhaibin
+  * ui: add new timer options for Onroad Brightness Delay by @sunnyhaibin
+  * [TIZI/TICI] ui: branch switcher is always available by @sunnyhaibin
+  * pandad: always prioritize internal panda by @sunnyhaibin
+  * sunnylinkd: fetch compressed params schema by @sunnyhaibin
+  * sunnypilot locationd: remove unused car_ekf filter by @sunnyhaibin
+  * modeld_v2: update deprecated temporalPose ref by @sunnyhaibin
+  * NNLC: restore pre-v1 PID gains in torque extension by @mmmorks
+  * MADS safety: enable heartbeat and lateral controls mismatch checks by @sunnyhaibin
+  * [MICI] ui: models panel enhancements by @nayan8teen
+  * [TIZI/TICI] ui: fix unintended selection while scrolling in TreeOptionDialog by @TheSecurityDev
+  * tools: script for video concatenation by @Discountchubbs
+  * tools: profile memory usage by @Discountchubbs
+  * [TIZI/TICI] ui: remove per-frame param sync by @sunnyhaibin
+  * [MICI] ui: always offroad by @nayan8teen
+  * controls: always default Torque Lateral Control to v0 Tune by @sunnyhaibin
+  * Revert "controls: always default Torque Lateral Control to v0 Tune" by @sunnyhaibin
+  * Reapply "controls: always default Torque Lateral Control to v0 Tune" (#1806) by @sunnyhaibin
+  * [MICI] ui: add sunnylink info & connectivity check by @nayan8teen
+  * sunnylink: Remove unused API endpoint by @devtekve
+  * DM: wheel touch enforcement in MADS by @sunnyhaibin
+  * torque: show static override values in Dev UI & gate `useParams` on custom torque tune by @sunnyhaibin
+  * MADS: suppress espActive event when long is not engaged by @sunnyhaibin
+  * sunnylink: SDUI by @sunnyhaibin
+  * [MICI] ui: align upstream changes with sunnypilot settings buttons by @nayan8teen
+  * ui: fix cellular toggles by @AmyJeanes
+  * sunnylink: switch athena domain by @devtekve
+  * Platform List: dynamically migrate CarPlatformBundle by @sunnyhaibin
 * What's Changed (sunnypilot/opendbc)
   * Honda: DBC for Accord 9th Generation by @mvl-boston
   * FCA: update tire stiffness values for `RAM_HD` by @dparring
@@ -84,12 +152,25 @@ sunnypilot Version 2026.001.000 (2026-03-xx)
   * Honda: add missing `GasInterceptor` messages to Taiwan Odyssey DBC by @mvl-boston
   * GM: remove `CHEVROLET_EQUINOX_NON_ACC_3RD_GEN` from `dashcamOnly` by @sunnyhaibin
   * GM: remove `CHEVROLET_BOLT_NON_ACC_2ND_GEN` from `dashcamOnly` by @sunnyhaibin
+  * Hyundai Longitudinal: deprecate ramp update for dynamic tune by @Discountchubbs
+  * Rivian: long upgrade messages on bus 1 by @lukasloetkolben
+  * Toyota: Stop and Go Hack (Alpha) by @sunnyhaibin
+  * Toyota: gate Smart DSU behind Alpha Longitudinal by @sunnyhaibin
+  * Toyota: Gas Interceptor always set `standstill_req` by @sunnyhaibin
+  * MADS safety: dedicated `controls_allowed_lateral` by @sunnyhaibin
+  * Platform List: include community supported platforms by @sunnyhaibin
 * New Contributors (sunnypilot/sunnypilot)
   * @TheSecurityDev made their first contribution in "ui: fix sidebar scroll in UI screenshots"
   * @zikeji made their first contribution in "sunnylink: block remote modification of SSH key parameters"
   * @Candy0707 made their first contribution in "[TIZI/TICI] ui: Fix misaligned turn signals and blindspot indicators with sidebar"
   * @CHaucke89 made their first contribution in "Pause Lateral Control with Blinker: Post-Blinker Delay"
   * @yasu-oh made their first contribution in "SCC-V: Use p97 for predicted lateral accel"
+  * @angaz made their first contribution in "[TIZI/TICI] visuals: Improved speed limit"
+  * @jamesmikesell made their first contribution in "ICBM: ensure button timers update on disable to clear stale presses"
+  * @zephleggett made their first contribution in "controlsd: fix steer_limited_by_safety not updating under MADS"
+  * @lukasloetkolben made their first contribution in "pandad: flasher for Rivian long upgrade module"
+  * @didlawowo made their first contribution in "i18n(fr): Add French translations"
+  * @mmmorks made their first contribution in "NNLC: restore pre-v1 PID gains in torque extension"
 * New Contributors (sunnypilot/opendbc)
   * @AmyJeanes made their first contribution in "Tesla: Fix stock LKAS being blocked when MADS is enabled"
   * @mvl-boston made their first contribution in "Honda: Update Clarity brake to renamed DBC message name"
@@ -99,6 +180,20 @@ sunnypilot Version 2026.001.000 (2026-03-xx)
   * @royjr made their first contribution in "HKG: add KIA_FORTE_2019_NON_SCC fingerprint"
   * @ssysm made their first contribution in "Tesla: remove `TESLA_MODEL_X` from `dashcamOnly`"
 * Full Changelog: https://github.com/sunnypilot/sunnypilot/compare/v2025.002.000...v2026.001.000
+************************
+* Synced with commaai's openpilot (v0.11.1)
+  * master commit c001f3c9b490a80e69539f0af6022f6e07ceb721 (April 16, 2026)
+* New driver monitoring model
+* Improved image processing pipeline for driver camera
+* Rivian R1S and R1T 2025 support thanks to lukasloetkolben!
+* New driving model #36798
+  * Fully trained using a learned simulator
+  * Improved longitudinal performance in Experimental mode
+* Reduce comma four standby power usage by 77% to 52 mW
+* Kia K7 2017 support thanks to royjr!
+* Lexus LS 2018 support thanks to Hacheoy!
+* Improved inter-process communication memory efficiency
+* comma four support
 
 sunnypilot Version 2025.002.000 (2025-11-06)
 ========================

cereal/log.capnp

@@ -273,7 +273,11 @@ struct GPSNMEAData {
   nmea @2 :Text;
 }
 
+# android sensor_event_t
 struct SensorEventData {
+  version @0 :Int32;
+  sensor @1 :Int32;
+  type @2 :Int32;
   timestamp @3 :Int64;
 
   union {
@@ -292,10 +296,7 @@ struct SensorEventData {
 
   struct SensorVec {
     v @0 :List(Float32);
-
-    deprecated :group {
-      status @1 :Int8;
-    }
+    status @1 :Int8;
   }
 
   enum SensorSource {
@@ -313,11 +314,7 @@ struct SensorEventData {
     mmc5603nj @11;
   }
 
-  # formerly based on android sensor_event_t
   deprecated :group {
-    version @0 :Int32;
-    sensor @1 :Int32;
-    type @2 :Int32;
     uncalibrated @10 :Bool;
   }
 }
@@ -460,10 +457,10 @@ struct DeviceState @0xa4d8b5af2aa492eb {
   }
 
   enum ThermalStatus {
-    ok @0;
-    warmDEPRECATED @1;
-    overheated @2;
-    critical @3;
+    green @0;
+    yellow @1;
+    red @2;
+    danger @3;
   }
 
   enum NetworkType {
@@ -2079,7 +2076,7 @@ struct DriverStateV2 {
   }
 }
 
-struct DriverMonitoringStateDEPRECATED @0xb83cda094a1da284 {
+struct DriverMonitoringState @0xb83cda094a1da284 {
   events @18 :List(OnroadEvent);
   faceDetected @1 :Bool;
   isDistracted @2 :Bool;
@@ -2107,75 +2104,6 @@ struct DriverMonitoringStateDEPRECATED @0xb83cda094a1da284 {
   }
 }
 
-struct DriverMonitoringState {
-  lockout @0 :Bool;
-  alertCountLockoutPercent @1 :Int8;
-  alertTimeLockoutPercent @2 :Int8;
-
-  alwaysOn @3 :Bool;
-  alwaysOnLockout @4 :Bool;
-
-  alertLevel @5 :AlertLevel;
-  activePolicy @6 :MonitoringPolicy;
-  isRHD @7 :Bool;
-  rhdCalibration @8 :CalibrationState;
-
-  visionPolicyState @9 :VisionPolicyState;
-  wheeltouchPolicyState @10 :WheeltouchPolicyState;
-
-  enum AlertLevel {
-    # ordinal must match the name to prevent bugs
-    # comparing against the raw ordinal value
-    none @0;
-    one @1;
-    two @2;
-    three @3;
-  }
-
-  enum MonitoringPolicy {
-    wheeltouch @0;
-    vision @1;
-  }
-
-  struct VisionPolicyState {
-    awarenessPercent @0 :Int8;
-    awarenessStep @1 :Float32;
-    isDistracted @2 :Bool;
-    distractedTypes @3 :DistractedTypes;
-
-    faceDetected @4 :Bool;
-    pose @5 :Pose;
-    wheeltouchFallbackPercent @6 :Int8;
-    uncertainOffroadAlertPercent @7 :Int8;
-
-    struct DistractedTypes {
-      pose @0: Bool;
-      eye @1: Bool;
-      phone @2: Bool;
-    }
-
-    struct Pose {
-      pitch @0 :Float32;
-      yaw @1 :Float32;
-      pitchCalib @2 :CalibrationState;
-      yawCalib @3 :CalibrationState;
-      calibrated @4 :Bool;
-      uncertainty @5 :Float32;
-    }
-  }
-
-  struct WheeltouchPolicyState {
-    awarenessPercent @0 :Int8;
-    awarenessStep @1 :Float32;
-    driverInteracting @2 :Bool;
-  }
-
-  struct CalibrationState {
-    calibratedPercent @0 :Int8;
-    offset @1 :Float32;
-  }
-}
-
 struct Boot {
   wallTimeNanos @0 :UInt64;
   pstore @4 :Map(Text, Data);
@@ -2449,6 +2377,7 @@ struct Event {
     boot @60 :Boot;
 
     # ********** openpilot daemon msgs **********
+    gpsNMEA @3 :GPSNMEAData;
     can @5 :List(CanData);
     controlsState @7 :ControlsState;
     selfdriveState @130 :SelfdriveState;
@@ -2473,6 +2402,7 @@ struct Event {
     qcomGnss @31 :QcomGnss;
     gpsLocationExternal @48 :GpsLocationData;
     gpsLocation @21 :GpsLocationData;
+    gnssMeasurements @91 :GnssMeasurements;
     liveParameters @61 :LiveParametersData;
     liveTorqueParameters @94 :LiveTorqueParametersData;
     liveDelay @146 : LiveDelayData;
@@ -2480,7 +2410,7 @@ struct Event {
     thumbnail @66: Thumbnail;
     onroadEvents @134: List(OnroadEvent);
     carParams @69: Car.CarParams;
-    driverMonitoringState @151 :DriverMonitoringState;
+    driverMonitoringState @71: DriverMonitoringState;
     livePose @129 :LivePose;
     modelV2 @75 :ModelDataV2;
     drivingModelData @128 :DrivingModelData;
@@ -2506,6 +2436,7 @@ struct Event {
     # systems stuff
     androidLog @20 :AndroidLogEntry;
     managerState @78 :ManagerState;
+    uploaderState @79 :UploaderState;
     procLog @33 :ProcLog;
     clocks @35 :Clocks;
     deviceState @6 :DeviceState;
@@ -2515,6 +2446,12 @@ struct Event {
     # touch frame
     touch @135 :List(Touch);
 
+    # navigation
+    navInstruction @82 :NavInstruction;
+    navRoute @83 :NavRoute;
+    navThumbnail @84: Thumbnail;
+    mapRenderState @105: MapRenderState;
+
     # UI services
     uiDebug @102 :UIDebug;
 
@@ -2616,13 +2553,5 @@ struct Event {
     gyroscope2DEPRECATED @100 :SensorEventData;
     accelerometer2DEPRECATED @101 :SensorEventData;
     temperatureSensor2DEPRECATED @123 :SensorEventData;
-    driverMonitoringStateDEPRECATED @71 :DriverMonitoringStateDEPRECATED;
-    gpsNMEADEPRECATED @3 :GPSNMEAData;
-    uploaderStateDEPRECATED @79 :UploaderState;
-    navInstructionDEPRECATED @82 :NavInstruction;
-    navRouteDEPRECATED @83 :NavRoute;
-    navThumbnailDEPRECATED @84 :Thumbnail;
-    gnssMeasurementsDEPRECATED @91 :GnssMeasurements;
-    mapRenderStateDEPRECATED @105: MapRenderState;
   }
 }

cereal/services.py

@@ -24,7 +24,10 @@ _services: dict[str, tuple] = {
   # note: the "EncodeIdx" packets will still be in the log
   "gyroscope": (True, 104., 104),
   "accelerometer": (True, 104., 104),
+  "magnetometer": (True, 25.),
+  "lightSensor": (True, 100., 100),
   "temperatureSensor": (True, 2., 200),
+  "gpsNMEA": (True, 9.),
   "deviceState": (True, 2., 1),
   "touch": (True, 20., 1),
   "can": (True, 100., 2053, QueueSize.BIG),  # decimation gives ~3 msgs in a full segment
@@ -53,6 +56,7 @@ _services: dict[str, tuple] = {
   "gpsLocation": (True, 1., 1),
   "ubloxGnss": (True, 10.),
   "qcomGnss": (True, 2.),
+  "gnssMeasurements": (True, 10., 10),
   "clocks": (True, 0.1, 1),
   "ubloxRaw": (True, 20.),
   "livePose": (True, 20., 4),
@@ -71,6 +75,10 @@ _services: dict[str, tuple] = {
   "drivingModelData": (True, 20., 10),
   "modelV2": (True, 20., None, QueueSize.BIG),
   "managerState": (True, 2., 1),
+  "uploaderState": (True, 0., 1),
+  "navInstruction": (True, 1., 10),
+  "navRoute": (True, 0.),
+  "navThumbnail": (True, 0.),
   "qRoadEncodeIdx": (False, 20.),
   "userBookmark": (True, 0., 1),
   "soundPressure": (True, 10., 10),
@@ -106,6 +114,8 @@ _services: dict[str, tuple] = {
   "livestreamRoadEncodeData": (False, 20., None, QueueSize.MEDIUM),
   "livestreamDriverEncodeData": (False, 20., None, QueueSize.MEDIUM),
   "customReservedRawData0": (True, 0.),
+  "customReservedRawData1": (True, 0.),
+  "customReservedRawData2": (True, 0.),
 }
 SERVICE_LIST = {name: Service(*vals) for
                 idx, (name, vals) in enumerate(_services.items())}

common/params_keys.h

@@ -204,6 +204,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     // sunnylink params
     {"EnableSunnylinkUploader", {PERSISTENT | BACKUP, BOOL}},
     {"LastSunnylinkPingTime", {CLEAR_ON_MANAGER_START, INT}},
+    {"ParamsVersion", {PERSISTENT, INT}},
     {"SunnylinkCache_Roles", {PERSISTENT, STRING}},
     {"SunnylinkCache_Users", {PERSISTENT, STRING}},
     {"SunnylinkDongleId", {PERSISTENT, STRING}},

docs/ext/glossary.py

@@ -8,7 +8,7 @@ from markdown.extensions import Extension
 from markdown.preprocessors import Preprocessor
 from markdown.treeprocessors import Treeprocessor
 
-from zensical.extensions.links import LinksTreeprocessor
+from zensical.extensions.links import LinksProcessor
 
 GlossaryTerm = tuple[str, re.Pattern[str], str]
 
@@ -78,7 +78,7 @@ class GlossaryTreeprocessor(Treeprocessor):
   def run(self, root: ET.Element) -> None:
     at = self.md.treeprocessors.get_index_for_name("zrelpath")
     processor = self.md.treeprocessors[at]
-    if not isinstance(processor, LinksTreeprocessor):
+    if not isinstance(processor, LinksProcessor):
       raise TypeError("Links processor not registered")
     if processor.path == GLOSSARY_PAGE:
       return

launch_env.sh

@@ -16,7 +16,7 @@ export VECLIB_MAXIMUM_THREADS=1
 export QCOM_PRIORITY=12
 
 if [ -z "$AGNOS_VERSION" ]; then
-  export AGNOS_VERSION="18.1"
+  export AGNOS_VERSION="17.2"
 fi
 
 export STAGING_ROOT="/data/safe_staging"

selfdrive/car/card.py

@@ -86,7 +86,7 @@ class Car:
 
     self.can_callbacks = can_comm_callbacks(self.can_sock, self.pm.sock['sendcan'])
 
-    is_release = self.params.get_bool("IsReleaseBranch")
+    is_release = False  # self.params.get_bool("IsReleaseBranch")
     is_release_sp = self.params.get_bool("IsReleaseSpBranch")
 
     if CI is None:

selfdrive/car/tests/test_cruise_speed.py

@@ -94,7 +94,7 @@ class TestVCruiseHelper:
         self.enable(V_CRUISE_INITIAL * CV.KPH_TO_MS, False, False)
 
       # Expected diff on enabling. Speed should not change on falling edge of pressed
-      assert (not pressed) == (self.v_cruise_helper.v_cruise_kph == self.v_cruise_helper.v_cruise_kph_last)
+      assert not pressed == self.v_cruise_helper.v_cruise_kph == self.v_cruise_helper.v_cruise_kph_last
 
   def test_resume_in_standstill(self):
     """

selfdrive/controls/controlsd.py

@@ -212,7 +212,7 @@ class Controls(ControlsExt):
     cs.upAccelCmd = float(self.LoC.pid.p)
     cs.uiAccelCmd = float(self.LoC.pid.i)
     cs.ufAccelCmd = float(self.LoC.pid.f)
-    cs.forceDecel = bool((self.sm['driverMonitoringState'].alertLevel == log.DriverMonitoringState.AlertLevel.three) or
+    cs.forceDecel = bool((self.sm['driverMonitoringState'].awarenessStatus < 0.) or
                          (self.sm['selfdriveState'].state == State.softDisabling))
 
     lat_tuning = self.CP.lateralTuning.which()

selfdrive/modeld/SConscript

@@ -1,23 +1,10 @@
 import glob
 import json
 import os
-from itertools import product
 from SCons.Script import Value
 from openpilot.common.file_chunker import chunk_file, get_chunk_paths
-from openpilot.common.transformations.camera import _ar_ox_fisheye, _os_fisheye
-from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE, DM_INPUT_SIZE
-from openpilot.selfdrive.modeld.constants import ModelConstants
-from openpilot.selfdrive.modeld.helpers import CompileConfig
 from tinygrad import Device
 
-CAMERA_CONFIGS = [
-  (_ar_ox_fisheye.width, _ar_ox_fisheye.height),  # tici: 1928x1208
-  (_os_fisheye.width, _os_fisheye.height),        # mici: 1344x760
-]
-MODELD_CONFIGS = [CompileConfig(cam_w, cam_h, prepare_only, 'driving_')
-                  for (cam_w, cam_h), prepare_only in product(CAMERA_CONFIGS, [True, False])]
-DM_WARP_CONFIGS = [CompileConfig(cam_w, cam_h, True, 'dm_') for cam_w, cam_h in CAMERA_CONFIGS]
-
 Import('env', 'arch')
 chunker_file = File("#common/file_chunker.py")
 lenv = env.Clone()
@@ -29,17 +16,18 @@ tinygrad_files = ["#"+x for x in glob.glob(env.Dir("#tinygrad_repo").relpath + "
 def estimate_pickle_max_size(onnx_size):
   return 1.2 * onnx_size  + 10 * 1024 * 1024  # 20% + 10MB is plenty
 
+# THREADS=0 is need to prevent bug: https://github.com/tinygrad/tinygrad/issues/14689
 # get fastest TG config
 available = set(Device.get_available_devices())
-if 'CUDA' in available:
+# FIXME-SP: reset when we bump tg
+if False:  # 'CUDA' in available:
   tg_backend = 'CUDA'
   tg_flags = f'DEV={tg_backend}'
 elif 'QCOM' in available:
   tg_backend = 'QCOM'
-  tg_flags = f'DEV={tg_backend} FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1'
+  tg_flags = f'DEV={tg_backend} FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0'
 else:
-  tg_backend = 'CPU' if arch == 'Darwin' else 'CPU:LLVM'
-  # THREADS=0 is need to prevent bug: https://github.com/tinygrad/tinygrad/issues/14689
+  tg_backend = 'CPU' if arch == 'Darwin' else 'CPU CPU_LLVM=1'  # FIXME-SP: reset when we bump tg
   tg_flags = f'DEV={tg_backend} THREADS=0'
 
 def write_tg_compiled_flags(target, source, env):
@@ -66,35 +54,14 @@ for model_name in ['driving_vision', 'driving_policy', 'dmonitoring_model']:
 image_flag = {
      'larch64': 'IMAGE=2',
 }.get(arch, 'IMAGE=0')
-modeld_dir = Dir("#selfdrive/modeld").abspath
-compile_modeld_script = [File(f"{modeld_dir}/compile_modeld.py")]
-compile_dm_warp_script = [File(f"{modeld_dir}/compile_dm_warp.py")]
-driving_onnx_deps = [File(f"models/{m}.onnx").abspath for m in ['driving_vision', 'driving_policy']]
-driving_metadata_deps = [File(f"models/{m}_metadata.pkl").abspath for m in ['driving_vision', 'driving_policy']]
-
-model_w, model_h = MEDMODEL_INPUT_SIZE
-frame_skip = ModelConstants.MODEL_RUN_FREQ // ModelConstants.MODEL_CONTEXT_FREQ
-for cfg in MODELD_CONFIGS:
-  cmd = (f'{tg_flags} {mac_brew_string} {image_flag} python3 {modeld_dir}/compile_modeld.py '
-         f'--model-size {model_w}x{model_h} '
-         f'--nv12 {",".join(str(x) for x in cfg.nv12)} '
-         f'--vision-onnx {File("models/driving_vision.onnx").abspath} '
-         f'--policy-onnx {File("models/driving_policy.onnx").abspath} '
-         f'--output {cfg.pkl_path} --frame-skip {frame_skip}'
-         + (' --prepare-only' if cfg.prepare_only else ''))
-  node = lenv.Command(cfg.pkl_path, tinygrad_files + compile_modeld_script + driving_onnx_deps + driving_metadata_deps + [chunker_file, compiled_flags_node], cmd)
-  onnx_sizes_sum = sum(os.path.getsize(f) for f in driving_onnx_deps)
-  chunk_targets = get_chunk_paths(cfg.pkl_path, estimate_pickle_max_size(onnx_sizes_sum))
-  def do_chunk(target, source, env, pkl=cfg.pkl_path, chunks=chunk_targets):
-    chunk_file(pkl, chunks)
-  lenv.Command(chunk_targets, node, do_chunk)
-
-dm_w, dm_h = DM_INPUT_SIZE
-for cfg in DM_WARP_CONFIGS:
-  cmd = (f'{tg_flags} {mac_brew_string} {image_flag} python3 {modeld_dir}/compile_dm_warp.py '
-         f'--nv12 {",".join(str(x) for x in cfg.nv12)} --warp-to {dm_w}x{dm_h} '
-         f'--output {cfg.pkl_path}')
-  lenv.Command(cfg.pkl_path, tinygrad_files + compile_dm_warp_script + compile_modeld_script + [compiled_flags_node], cmd)
+script_files = [File(Dir("#selfdrive/modeld").File("compile_warp.py").abspath)]
+compile_warp_cmd = f'{tg_flags} {mac_brew_string} python3 {Dir("#selfdrive/modeld").abspath}/compile_warp.py '
+from openpilot.common.transformations.camera import _ar_ox_fisheye, _os_fisheye
+warp_targets = []
+for cam in [_ar_ox_fisheye, _os_fisheye]:
+  w, h = cam.width, cam.height
+  warp_targets += [File(f"models/warp_{w}x{h}_tinygrad.pkl").abspath, File(f"models/dm_warp_{w}x{h}_tinygrad.pkl").abspath]
+lenv.Command(warp_targets, tinygrad_files + script_files + [compiled_flags_node], compile_warp_cmd)
 
 def tg_compile(flags, model_name):
   pythonpath_string = 'PYTHONPATH="${PYTHONPATH}:' + env.Dir("#tinygrad_repo").abspath + '"'
@@ -115,4 +82,7 @@ def tg_compile(flags, model_name):
     do_chunk,
   )
 
-tg_compile(tg_flags, 'dmonitoring_model')
+# Compile small models
+for model_name in ['driving_vision', 'driving_policy', 'dmonitoring_model']:
+  tg_compile(tg_flags, model_name)
+

selfdrive/modeld/compile_dm_warp.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import pickle
-import time
-
-from tinygrad.tensor import Tensor
-from tinygrad.device import Device
-from tinygrad.engine.jit import TinyJit
-
-from openpilot.selfdrive.modeld.compile_modeld import NV12Frame, warp_perspective_tinygrad, _parse_size, _parse_nv12
-
-
-def make_warp_dm(nv12: NV12Frame, dm_w, dm_h):
-  cam_w, cam_h, stride, _, _, _ = nv12
-  stride_pad = stride - cam_w
-
-  def warp_dm(input_frame, M_inv):
-    M_inv = M_inv.to(Device.DEFAULT).realize()
-    return warp_perspective_tinygrad(input_frame[:cam_h*stride], M_inv,
-                                     (dm_w, dm_h), (cam_h, cam_w), stride_pad).reshape(-1, dm_h * dm_w)
-  return warp_dm
-
-
-def compile_dm_warp(nv12: NV12Frame, dm_w, dm_h, pkl_path):
-  print(f"Compiling DM warp for {nv12.width}x{nv12.height} -> {dm_w}x{dm_h}...")
-
-  warp_dm_jit = TinyJit(make_warp_dm(nv12, dm_w, dm_h), prune=True)
-
-  for i in range(10):
-    frame = Tensor.randint(nv12.size, low=0, high=256, dtype='uint8').realize()
-    M_inv = Tensor(Tensor.randn(3, 3).mul(8).realize().numpy(), device='NPY')
-    Device.default.synchronize()
-    st = time.perf_counter()
-    warp_dm_jit(frame, M_inv).realize()
-    mt = time.perf_counter()
-    Device.default.synchronize()
-    et = time.perf_counter()
-    print(f"  [{i+1}/10] enqueue {(mt-st)*1e3:6.2f} ms -- total {(et-st)*1e3:6.2f} ms")
-
-  with open(pkl_path, "wb") as f:
-    pickle.dump(warp_dm_jit, f)
-  print(f"  Saved to {pkl_path}")
-
-
-if __name__ == "__main__":
-  p = argparse.ArgumentParser()
-  p.add_argument('--nv12', type=_parse_nv12, required=True,
-                 help=f'NV12 frame layout: {",".join(NV12Frame._fields)}')
-  p.add_argument('--warp-to', type=_parse_size, required=True, help='DM input WxH')
-  p.add_argument('--output', required=True)
-  args = p.parse_args()
-
-  dm_w, dm_h = args.warp_to
-  compile_dm_warp(args.nv12, dm_w, dm_h, args.output)

selfdrive/modeld/compile_modeld.py

@@ -1,253 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import pickle
-import time
-from functools import partial
-from collections import namedtuple
-
-import numpy as np
-from tinygrad.tensor import Tensor
-from tinygrad.helpers import Context
-from tinygrad.device import Device
-from tinygrad.engine.jit import TinyJit
-from tinygrad.nn.onnx import OnnxRunner
-
-# https://github.com/tinygrad/tinygrad/issues/15682
-from tinygrad.uop.ops import UOp, Ops
-_orig = UOp.__reduce__
-UOp.__reduce__ = lambda self: (UOp.unique, ()) if self.op is Ops.UNIQUE else _orig(self)
-
-
-NV12Frame = namedtuple("NV12Frame", ['width', 'height', 'stride', 'y_height', 'uv_height', 'size'])
-
-UV_SCALE_MATRIX = np.array([[0.5, 0, 0], [0, 0.5, 0], [0, 0, 1]], dtype=np.float32)
-UV_SCALE_MATRIX_INV = np.linalg.inv(UV_SCALE_MATRIX)
-
-
-def warp_perspective_tinygrad(src_flat, M_inv, dst_shape, src_shape, stride_pad):
-  w_dst, h_dst = dst_shape
-  h_src, w_src = src_shape
-
-  x = Tensor.arange(w_dst).reshape(1, w_dst).expand(h_dst, w_dst).reshape(-1)
-  y = Tensor.arange(h_dst).reshape(h_dst, 1).expand(h_dst, w_dst).reshape(-1)
-
-  # inline 3x3 matmul as elementwise to avoid reduce op (enables fusion with gather)
-  src_x = M_inv[0, 0] * x + M_inv[0, 1] * y + M_inv[0, 2]
-  src_y = M_inv[1, 0] * x + M_inv[1, 1] * y + M_inv[1, 2]
-  src_w = M_inv[2, 0] * x + M_inv[2, 1] * y + M_inv[2, 2]
-
-  src_x = src_x / src_w
-  src_y = src_y / src_w
-
-  x_nn_clipped = Tensor.round(src_x).clip(0, w_src - 1).cast('int')
-  y_nn_clipped = Tensor.round(src_y).clip(0, h_src - 1).cast('int')
-  idx = y_nn_clipped * (w_src + stride_pad) + x_nn_clipped
-
-  return src_flat[idx]
-
-
-def frames_to_tensor(frames):
-  H = (frames.shape[0] * 2) // 3
-  W = frames.shape[1]
-  in_img1 = Tensor.cat(frames[0:H:2, 0::2],
-                       frames[1:H:2, 0::2],
-                       frames[0:H:2, 1::2],
-                       frames[1:H:2, 1::2],
-                       frames[H:H+H//4].reshape((H//2, W//2)),
-                       frames[H+H//4:H+H//2].reshape((H//2, W//2)), dim=0).reshape((6, H//2, W//2))
-  return in_img1
-
-
-def make_frame_prepare(nv12: NV12Frame, model_w, model_h):
-  cam_w, cam_h, stride, y_height, uv_height, _ = nv12
-  uv_offset = stride * y_height
-  stride_pad = stride - cam_w
-
-  def frame_prepare_tinygrad(input_frame, M_inv):
-    # UV_SCALE @ M_inv @ UV_SCALE_INV simplifies to elementwise scaling
-    M_inv_uv = M_inv * Tensor([[1.0, 1.0, 0.5], [1.0, 1.0, 0.5], [2.0, 2.0, 1.0]])
-    # deinterleave NV12 UV plane (UVUV... -> separate U, V)
-    uv = input_frame[uv_offset:uv_offset + uv_height * stride].reshape(uv_height, stride)
-    with Context(SPLIT_REDUCEOP=0):
-      y = warp_perspective_tinygrad(input_frame[:cam_h*stride],
-                                    M_inv, (model_w, model_h),
-                                    (cam_h, cam_w), stride_pad).realize()
-      u = warp_perspective_tinygrad(uv[:cam_h//2, :cam_w:2].flatten(),
-                                    M_inv_uv, (model_w//2, model_h//2),
-                                    (cam_h//2, cam_w//2), 0).realize()
-      v = warp_perspective_tinygrad(uv[:cam_h//2, 1:cam_w:2].flatten(),
-                                    M_inv_uv, (model_w//2, model_h//2),
-                                    (cam_h//2, cam_w//2), 0).realize()
-    yuv = y.cat(u).cat(v).reshape((model_h * 3 // 2, model_w))
-    tensor = frames_to_tensor(yuv)
-    return tensor
-  return frame_prepare_tinygrad
-
-
-def make_input_queues(vision_input_shapes, policy_input_shapes, frame_skip):
-  img = vision_input_shapes['img']  # (1, 12, 128, 256)
-  n_frames = img[1] // 6
-  img_buf_shape = (frame_skip * (n_frames - 1) + 1, 6, img[2], img[3])
-
-  fb = policy_input_shapes['features_buffer']  # (1, 25, 512)
-  dp = policy_input_shapes['desire_pulse']  # (1, 25, 8)
-  tc = policy_input_shapes['traffic_convention']  # (1, 2)
-
-  npy = {
-    'desire': np.zeros(dp[2], dtype=np.float32),
-    'traffic_convention': np.zeros(tc, dtype=np.float32),
-    'tfm': np.zeros((3, 3), dtype=np.float32),
-    'big_tfm': np.zeros((3, 3), dtype=np.float32),
-  }
-  input_queues = {
-    'img_q': Tensor.zeros(img_buf_shape, dtype='uint8').contiguous().realize(),
-    'big_img_q': Tensor.zeros(img_buf_shape, dtype='uint8').contiguous().realize(),
-    'feat_q': Tensor.zeros(frame_skip * (fb[1] - 1) + 1, fb[0], fb[2]).contiguous().realize(),
-    'desire_q': Tensor.zeros(frame_skip * dp[1], dp[0], dp[2]).contiguous().realize(),
-    **{k: Tensor(v, device='NPY').realize() for k, v in npy.items()},
-  }
-  return input_queues, npy
-
-
-def shift_and_sample(buf, new_val, sample_fn):
-  buf.assign(buf[1:].cat(new_val, dim=0).contiguous())
-  return sample_fn(buf)
-
-
-def sample_skip(buf, frame_skip):
-  return buf[::frame_skip].contiguous().flatten(0, 1).unsqueeze(0)
-
-
-def sample_desire(buf, frame_skip):
-  return buf.reshape(-1, frame_skip, *buf.shape[1:]).max(1).flatten(0, 1).unsqueeze(0)
-
-
-def make_run_policy(vision_runner, policy_runner, nv12: NV12Frame, model_w, model_h,
-                    vision_features_slice, frame_skip, prepare_only=False):
-  frame_prepare = make_frame_prepare(nv12, model_w, model_h)
-  sample_skip_fn = partial(sample_skip, frame_skip=frame_skip)
-  sample_desire_fn = partial(sample_desire, frame_skip=frame_skip)
-
-  def run_policy(img_q, big_img_q, feat_q, desire_q, desire, traffic_convention, tfm, big_tfm, frame, big_frame):
-    tfm = tfm.to(Device.DEFAULT)
-    big_tfm = big_tfm.to(Device.DEFAULT)
-    desire = desire.to(Device.DEFAULT)
-    traffic_convention = traffic_convention.to(Device.DEFAULT)
-    Tensor.realize(tfm, big_tfm, desire, traffic_convention)
-
-    img = shift_and_sample(img_q, frame_prepare(frame, tfm).unsqueeze(0), sample_skip_fn)
-    big_img = shift_and_sample(big_img_q, frame_prepare(big_frame, big_tfm).unsqueeze(0), sample_skip_fn)
-
-    if prepare_only:
-      return img, big_img
-
-    vision_out = next(iter(vision_runner({'img': img, 'big_img': big_img}).values())).cast('float32')
-
-    new_feat = vision_out[:, vision_features_slice].reshape(1, -1).unsqueeze(0)
-    feat_buf = shift_and_sample(feat_q, new_feat, sample_skip_fn)
-    desire_buf = shift_and_sample(desire_q, desire.reshape(1, 1, -1), sample_desire_fn)
-
-    inputs = {'features_buffer': feat_buf, 'desire_pulse': desire_buf, 'traffic_convention': traffic_convention}
-    policy_out = next(iter(policy_runner(inputs).values())).cast('float32')
-
-    return vision_out, policy_out
-  return run_policy
-
-
-def compile_modeld(nv12: NV12Frame, model_w, model_h, prepare_only, frame_skip,
-                   vision_onnx, policy_onnx, pkl_path):
-  from get_model_metadata import metadata_path_for
-
-  print(f"Compiling combined policy JIT for {nv12.width}x{nv12.height} (prepare_only={prepare_only})...")
-
-  vision_runner = OnnxRunner(vision_onnx)
-  policy_runner = OnnxRunner(policy_onnx)
-
-  with open(metadata_path_for(vision_onnx), 'rb') as f:
-    vision_metadata = pickle.load(f)
-    vision_features_slice = vision_metadata['output_slices']['hidden_state']
-    vision_input_shapes = vision_metadata['input_shapes']
-  with open(metadata_path_for(policy_onnx), 'rb') as f:
-    policy_input_shapes = pickle.load(f)['input_shapes']
-
-  _run = make_run_policy(vision_runner, policy_runner, nv12, model_w, model_h,
-                         vision_features_slice, frame_skip, prepare_only)
-  run_policy_jit = TinyJit(_run, prune=True)
-
-  N_RUNS = 3
-  SEED = 42
-
-  def random_inputs_run_fn(fn, seed, test_val=None, test_buffers=None, expect_match=True):
-    input_queues, npy = make_input_queues(vision_input_shapes, policy_input_shapes, frame_skip)
-    np.random.seed(seed)
-    Tensor.manual_seed(seed)
-
-    for i in range(N_RUNS):
-      frame = Tensor.randint(nv12.size, low=0, high=256, dtype='uint8').realize()
-      big_frame = Tensor.randint(nv12.size, low=0, high=256, dtype='uint8').realize()
-      for v in npy.values():
-        v[:] = np.random.randn(*v.shape).astype(v.dtype)
-      Device.default.synchronize()
-      st = time.perf_counter()
-      outs = fn(**input_queues, frame=frame, big_frame=big_frame)
-      mt = time.perf_counter()
-      for o in outs:
-        # .realize() not needed once jitted, but needed for unjitted fn
-        o.realize()
-      Device.default.synchronize()
-      et = time.perf_counter()
-      print(f"  [{i+1}/{N_RUNS}] enqueue {(mt-st)*1e3:6.2f} ms -- total {(et-st)*1e3:6.2f} ms")
-
-    val = [np.copy(v.numpy()) for v in outs]
-    buffers = [np.copy(v.numpy().copy()) for v in input_queues.values()]
-
-    if test_val is not None:
-      match = all(np.array_equal(a, b) for a, b in zip(val, test_val, strict=True))
-      assert match == expect_match, f"outputs {'differ from' if expect_match else 'match'} baseline (seed={seed})"
-    if test_buffers is not None:
-      match = all(np.array_equal(a, b) for a, b in zip(buffers, test_buffers, strict=True))
-      assert match == expect_match, f"buffers {'differ from' if expect_match else 'match'} baseline (seed={seed})"
-    return fn, val, buffers
-
-  print('run unjitted')
-  _, test_val, test_buffers = random_inputs_run_fn(_run, seed=SEED)
-  print('capture + replay')
-  run_policy_jit, _, _ = random_inputs_run_fn(run_policy_jit, SEED, test_val, test_buffers)
-
-  print('pickle round trip')
-  with open(pkl_path, "wb") as f:
-    pickle.dump(run_policy_jit, f)
-    print(f"  Saved to {pkl_path}")
-  with open(pkl_path, "rb") as f:
-    run_policy_jit = pickle.load(f)
-  random_inputs_run_fn(run_policy_jit, SEED, test_val, test_buffers, expect_match=True)
-  random_inputs_run_fn(run_policy_jit, SEED+1, test_val, test_buffers, expect_match=False)
-
-
-def _parse_size(s):
-  w, h = s.lower().split('x')
-  return int(w), int(h)
-
-
-def _parse_nv12(s):
-  parts = s.split(',')
-  assert len(parts) == len(NV12Frame._fields), \
-    f"--nv12 expects {','.join(NV12Frame._fields)} (got {s!r})"
-  return NV12Frame(*(int(x) for x in parts))
-
-
-if __name__ == "__main__":
-  p = argparse.ArgumentParser()
-  p.add_argument('--model-size', type=_parse_size, required=True, help='model input WxH')
-  p.add_argument('--nv12', type=_parse_nv12, required=True,
-                 help=f'NV12 frame layout: {",".join(NV12Frame._fields)}')
-  p.add_argument('--vision-onnx', required=True)
-  p.add_argument('--policy-onnx', required=True)
-  p.add_argument('--output', required=True)
-  p.add_argument('--prepare-only', action='store_true')
-  p.add_argument('--frame-skip', type=int, required=True)
-  args = p.parse_args()
-
-  model_w, model_h = args.model_size
-  compile_modeld(args.nv12, model_w, model_h, args.prepare_only, args.frame_skip,
-                 args.vision_onnx, args.policy_onnx, args.output)

selfdrive/modeld/compile_warp.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+import time
+import pickle
+import numpy as np
+from pathlib import Path
+from tinygrad.tensor import Tensor
+from tinygrad.helpers import Context
+from tinygrad.device import Device
+from tinygrad.engine.jit import TinyJit
+
+from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
+from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE, DM_INPUT_SIZE
+from openpilot.common.transformations.camera import _ar_ox_fisheye, _os_fisheye
+
+MODELS_DIR = Path(__file__).parent / 'models'
+
+CAMERA_CONFIGS = [
+  (_ar_ox_fisheye.width, _ar_ox_fisheye.height),  # tici: 1928x1208
+  (_os_fisheye.width, _os_fisheye.height),        # mici: 1344x760
+]
+
+UV_SCALE_MATRIX = np.array([[0.5, 0, 0], [0, 0.5, 0], [0, 0, 1]], dtype=np.float32)
+UV_SCALE_MATRIX_INV = np.linalg.inv(UV_SCALE_MATRIX)
+
+IMG_BUFFER_SHAPE = (30, MEDMODEL_INPUT_SIZE[1] // 2, MEDMODEL_INPUT_SIZE[0] // 2)
+
+
+def warp_pkl_path(w, h):
+  return MODELS_DIR / f'warp_{w}x{h}_tinygrad.pkl'
+
+
+def dm_warp_pkl_path(w, h):
+  return MODELS_DIR / f'dm_warp_{w}x{h}_tinygrad.pkl'
+
+
+def warp_perspective_tinygrad(src_flat, M_inv, dst_shape, src_shape, stride_pad):
+  w_dst, h_dst = dst_shape
+  h_src, w_src = src_shape
+
+  x = Tensor.arange(w_dst).reshape(1, w_dst).expand(h_dst, w_dst).reshape(-1)
+  y = Tensor.arange(h_dst).reshape(h_dst, 1).expand(h_dst, w_dst).reshape(-1)
+
+  # inline 3x3 matmul as elementwise to avoid reduce op (enables fusion with gather)
+  src_x = M_inv[0, 0] * x + M_inv[0, 1] * y + M_inv[0, 2]
+  src_y = M_inv[1, 0] * x + M_inv[1, 1] * y + M_inv[1, 2]
+  src_w = M_inv[2, 0] * x + M_inv[2, 1] * y + M_inv[2, 2]
+
+  src_x = src_x / src_w
+  src_y = src_y / src_w
+
+  x_nn_clipped = Tensor.round(src_x).clip(0, w_src - 1).cast('int')
+  y_nn_clipped = Tensor.round(src_y).clip(0, h_src - 1).cast('int')
+  idx = y_nn_clipped * (w_src + stride_pad) + x_nn_clipped
+
+  return src_flat[idx]
+
+
+def frames_to_tensor(frames, model_w, model_h):
+  H = (frames.shape[0] * 2) // 3
+  W = frames.shape[1]
+  in_img1 = Tensor.cat(frames[0:H:2, 0::2],
+                       frames[1:H:2, 0::2],
+                       frames[0:H:2, 1::2],
+                       frames[1:H:2, 1::2],
+                       frames[H:H+H//4].reshape((H//2, W//2)),
+                       frames[H+H//4:H+H//2].reshape((H//2, W//2)), dim=0).reshape((6, H//2, W//2))
+  return in_img1
+
+
+def make_frame_prepare(cam_w, cam_h, model_w, model_h):
+  stride, y_height, uv_height, _ = get_nv12_info(cam_w, cam_h)
+  uv_offset = stride * y_height
+  stride_pad = stride - cam_w
+
+  def frame_prepare_tinygrad(input_frame, M_inv):
+    # UV_SCALE @ M_inv @ UV_SCALE_INV simplifies to elementwise scaling
+    M_inv_uv = M_inv * Tensor([[1.0, 1.0, 0.5], [1.0, 1.0, 0.5], [2.0, 2.0, 1.0]])
+    # deinterleave NV12 UV plane (UVUV... -> separate U, V)
+    uv = input_frame[uv_offset:uv_offset + uv_height * stride].reshape(uv_height, stride)
+    with Context(SPLIT_REDUCEOP=0):
+      y = warp_perspective_tinygrad(input_frame[:cam_h*stride],
+                                    M_inv, (model_w, model_h),
+                                    (cam_h, cam_w), stride_pad).realize()
+      u = warp_perspective_tinygrad(uv[:cam_h//2, :cam_w:2].flatten(),
+                                    M_inv_uv, (model_w//2, model_h//2),
+                                    (cam_h//2, cam_w//2), 0).realize()
+      v = warp_perspective_tinygrad(uv[:cam_h//2, 1:cam_w:2].flatten(),
+                                    M_inv_uv, (model_w//2, model_h//2),
+                                    (cam_h//2, cam_w//2), 0).realize()
+    yuv = y.cat(u).cat(v).reshape((model_h * 3 // 2, model_w))
+    tensor = frames_to_tensor(yuv, model_w, model_h)
+    return tensor
+  return frame_prepare_tinygrad
+
+
+def make_update_img_input(frame_prepare, model_w, model_h):
+  def update_img_input_tinygrad(tensor, frame, M_inv):
+    M_inv = M_inv.to(Device.DEFAULT)
+    new_img = frame_prepare(frame, M_inv)
+    tensor.assign(tensor[6:].cat(new_img, dim=0).contiguous())
+    return Tensor.cat(tensor[:6], tensor[-6:], dim=0).contiguous().reshape(1, 12, model_h//2, model_w//2)
+  return update_img_input_tinygrad
+
+
+def make_update_both_imgs(frame_prepare, model_w, model_h):
+  update_img = make_update_img_input(frame_prepare, model_w, model_h)
+
+  def update_both_imgs_tinygrad(calib_img_buffer, new_img, M_inv,
+                                calib_big_img_buffer, new_big_img, M_inv_big):
+    calib_img_pair = update_img(calib_img_buffer, new_img, M_inv)
+    calib_big_img_pair = update_img(calib_big_img_buffer, new_big_img, M_inv_big)
+    return calib_img_pair, calib_big_img_pair
+  return update_both_imgs_tinygrad
+
+
+def make_warp_dm(cam_w, cam_h, dm_w, dm_h):
+  stride, y_height, _, _ = get_nv12_info(cam_w, cam_h)
+  stride_pad = stride - cam_w
+
+  def warp_dm(input_frame, M_inv):
+    M_inv = M_inv.to(Device.DEFAULT)
+    result = warp_perspective_tinygrad(input_frame[:cam_h*stride], M_inv, (dm_w, dm_h), (cam_h, cam_w), stride_pad).reshape(-1, dm_h * dm_w)
+    return result
+  return warp_dm
+
+
+def compile_modeld_warp(cam_w, cam_h):
+  model_w, model_h = MEDMODEL_INPUT_SIZE
+  _, _, _, yuv_size = get_nv12_info(cam_w, cam_h)
+
+  print(f"Compiling modeld warp for {cam_w}x{cam_h}...")
+
+  frame_prepare = make_frame_prepare(cam_w, cam_h, model_w, model_h)
+  update_both_imgs = make_update_both_imgs(frame_prepare, model_w, model_h)
+  update_img_jit = TinyJit(update_both_imgs, prune=True)
+
+  full_buffer = Tensor.zeros(IMG_BUFFER_SHAPE, dtype='uint8').contiguous().realize()
+  big_full_buffer = Tensor.zeros(IMG_BUFFER_SHAPE, dtype='uint8').contiguous().realize()
+  new_frame_np = np.random.randint(0, 256, yuv_size, dtype=np.uint8)
+  new_big_frame_np = np.random.randint(0, 256, yuv_size, dtype=np.uint8)
+  for i in range(10):
+    img_inputs = [full_buffer,
+                  Tensor.from_blob(new_frame_np.ctypes.data, (yuv_size,), dtype='uint8').realize(),
+                  Tensor(Tensor.randn(3, 3).mul(8).realize().numpy(), device='NPY')]
+    big_img_inputs = [big_full_buffer,
+                      Tensor.from_blob(new_big_frame_np.ctypes.data, (yuv_size,), dtype='uint8').realize(),
+                      Tensor(Tensor.randn(3, 3).mul(8).realize().numpy(), device='NPY')]
+    inputs = img_inputs + big_img_inputs
+    Device.default.synchronize()
+
+    st = time.perf_counter()
+    _ = update_img_jit(*inputs)
+    mt = time.perf_counter()
+    Device.default.synchronize()
+    et = time.perf_counter()
+    print(f"  [{i+1}/10] enqueue {(mt-st)*1e3:6.2f} ms -- total {(et-st)*1e3:6.2f} ms")
+
+  pkl_path = warp_pkl_path(cam_w, cam_h)
+  with open(pkl_path, "wb") as f:
+    pickle.dump(update_img_jit, f)
+  print(f"  Saved to {pkl_path}")
+
+  jit = pickle.load(open(pkl_path, "rb"))
+  jit(*inputs)
+
+
+def compile_dm_warp(cam_w, cam_h):
+  dm_w, dm_h = DM_INPUT_SIZE
+  _, _, _, yuv_size = get_nv12_info(cam_w, cam_h)
+
+  print(f"Compiling DM warp for {cam_w}x{cam_h}...")
+
+  warp_dm = make_warp_dm(cam_w, cam_h, dm_w, dm_h)
+  warp_dm_jit = TinyJit(warp_dm, prune=True)
+
+  new_frame_np = np.random.randint(0, 256, yuv_size, dtype=np.uint8)
+  for i in range(10):
+    inputs = [Tensor.from_blob(new_frame_np.ctypes.data, (yuv_size,), dtype='uint8').realize(),
+              Tensor(Tensor.randn(3, 3).mul(8).realize().numpy(), device='NPY')]
+    Device.default.synchronize()
+    st = time.perf_counter()
+    warp_dm_jit(*inputs)
+    mt = time.perf_counter()
+    Device.default.synchronize()
+    et = time.perf_counter()
+    print(f"  [{i+1}/10] enqueue {(mt-st)*1e3:6.2f} ms -- total {(et-st)*1e3:6.2f} ms")
+
+  pkl_path = dm_warp_pkl_path(cam_w, cam_h)
+  with open(pkl_path, "wb") as f:
+    pickle.dump(warp_dm_jit, f)
+  print(f"  Saved to {pkl_path}")
+
+
+def run_and_save_pickle():
+  for cam_w, cam_h in CAMERA_CONFIGS:
+    compile_modeld_warp(cam_w, cam_h)
+    compile_dm_warp(cam_w, cam_h)
+
+
+if __name__ == "__main__":
+  run_and_save_pickle()

selfdrive/modeld/dmonitoringmodeld.py

@@ -1,8 +1,12 @@
 #!/usr/bin/env python3
 import os
-from openpilot.selfdrive.modeld.helpers import MODELS_DIR, CompileConfig, set_tinygrad_backend_from_compiled_flags
+from openpilot.selfdrive.modeld.tinygrad_helpers import MODELS_DIR, set_tinygrad_backend_from_compiled_flags
 set_tinygrad_backend_from_compiled_flags()
 
+# FIXME-SP: remove once we bump tg
+from openpilot.system.hardware import TICI
+os.environ['DEV'] = 'QCOM' if TICI else 'CPU'
+
 from tinygrad.tensor import Tensor
 import time
 import pickle
@@ -28,7 +32,7 @@ class ModelState:
   inputs: dict[str, np.ndarray]
   output: np.ndarray
 
-  def __init__(self, cam_w: int, cam_h: int):
+  def __init__(self):
     with open(METADATA_PATH, 'rb') as f:
       model_metadata = pickle.load(f)
       self.input_shapes = model_metadata['input_shapes']
@@ -40,18 +44,22 @@ class ModelState:
 
     self.warp_inputs_np = {'transform': np.zeros((3,3), dtype=np.float32)}
     self.warp_inputs = {k: Tensor(v, device='NPY') for k,v in self.warp_inputs_np.items()}
-    self.frame_buf_params = get_nv12_info(cam_w, cam_h)
+    self.frame_buf_params = None
     self.tensor_inputs = {k: Tensor(v, device='NPY').realize() for k,v in self.numpy_inputs.items()}
     self._blob_cache : dict[int, Tensor] = {}
+    self.image_warp = None
     self.model_run = pickle.loads(read_file_chunked(str(MODEL_PKL_PATH)))
-    with open(CompileConfig(cam_w, cam_h, prefix='dm_', prepare_only=True).pkl_path, "rb") as f:
-      self.image_warp = pickle.load(f)
 
   def run(self, buf: VisionBuf, calib: np.ndarray, transform: np.ndarray) -> tuple[np.ndarray, float]:
     self.numpy_inputs['calib'][0,:] = calib
 
     t1 = time.perf_counter()
 
+    if self.image_warp is None:
+      self.frame_buf_params = get_nv12_info(buf.width, buf.height)
+      warp_path = MODELS_DIR / f'dm_warp_{buf.width}x{buf.height}_tinygrad.pkl'
+      with open(warp_path, "rb") as f:
+        self.image_warp = pickle.load(f)
     ptr = buf.data.ctypes.data
     # There is a ringbuffer of imgs, just cache tensors pointing to all of them
     if ptr not in self._blob_cache:
@@ -105,6 +113,9 @@ def get_driverstate_packet(model_output, frame_id: int, location_ts: int, exec_t
 def main():
   config_realtime_process(7, 5)
 
+  model = ModelState()
+  cloudlog.warning("models loaded, dmonitoringmodeld starting")
+
   cloudlog.warning("connecting to driver stream")
   vipc_client = VisionIpcClient("camerad", VisionStreamType.VISION_STREAM_DRIVER, True)
   while not vipc_client.connect(False):
@@ -112,9 +123,6 @@ def main():
   assert vipc_client.is_connected()
   cloudlog.warning(f"connected with buffer size: {vipc_client.buffer_len}")
 
-  model = ModelState(vipc_client.width, vipc_client.height)
-  cloudlog.warning("models loaded, dmonitoringmodeld starting")
-
   sm = SubMaster(["liveCalibration"])
   pm = PubMaster(["driverStateV2"])
 

selfdrive/modeld/get_model_metadata.py

@@ -7,10 +7,6 @@ from typing import Any
 
 from tinygrad.nn.onnx import OnnxPBParser
 
-def metadata_path_for(onnx_path) -> pathlib.Path:
-  p = pathlib.Path(onnx_path)
-  return p.parent / (p.stem + '_metadata.pkl')
-
 
 class MetadataOnnxPBParser(OnnxPBParser):
   def _parse_ModelProto(self) -> dict:
@@ -52,7 +48,7 @@ if __name__ == "__main__":
     'output_shapes': dict(get_name_and_shape(x) for x in model["graph"]["output"]),
   }
 
-  metadata_path = metadata_path_for(model_path)
+  metadata_path = model_path.parent / (model_path.stem + '_metadata.pkl')
   with open(metadata_path, 'wb') as f:
     pickle.dump(metadata, f)
 

selfdrive/modeld/helpers.py

@@ -1,31 +0,0 @@
-import json
-import os
-from dataclasses import dataclass
-from pathlib import Path
-
-from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
-
-MODELS_DIR = Path(__file__).resolve().parent / 'models'
-COMPILED_FLAGS_PATH = MODELS_DIR / 'tg_compiled_flags.json'
-
-
-def set_tinygrad_backend_from_compiled_flags() -> None:
-  if os.path.isfile(COMPILED_FLAGS_PATH):
-    with open(COMPILED_FLAGS_PATH) as f:
-      os.environ['DEV'] = str(json.load(f)['DEV'])
-
-
-@dataclass
-class CompileConfig:
-  cam_w: int
-  cam_h: int
-  prepare_only: bool
-  prefix: str
-
-  @property
-  def pkl_path(self):
-    return str(MODELS_DIR / f'{self.prefix}{"warp_" if self.prepare_only else ""}{self.cam_w}x{self.cam_h}_tinygrad.pkl')
-
-  @property
-  def nv12(self):
-    return (self.cam_w, self.cam_h, *get_nv12_info(self.cam_w, self.cam_h))

selfdrive/modeld/modeld.py

@@ -1,8 +1,12 @@
 #!/usr/bin/env python3
 import os
-from openpilot.selfdrive.modeld.helpers import MODELS_DIR, CompileConfig, set_tinygrad_backend_from_compiled_flags
+from openpilot.selfdrive.modeld.tinygrad_helpers import MODELS_DIR, set_tinygrad_backend_from_compiled_flags
 set_tinygrad_backend_from_compiled_flags()
 
+# FIXME-SP: remove once we bump tg
+from openpilot.system.hardware import TICI
+os.environ['DEV'] = 'QCOM' if TICI else 'CPU'
+
 USBGPU = "USBGPU" in os.environ
 if USBGPU:
   os.environ['DEV'] = 'AMD'
@@ -26,7 +30,6 @@ from openpilot.common.transformations.model import get_warp_matrix
 from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
 from openpilot.selfdrive.controls.lib.drive_helpers import get_accel_from_plan, smooth_value, get_curvature_from_plan
 from openpilot.selfdrive.modeld.parse_model_outputs import Parser
-from openpilot.selfdrive.modeld.compile_modeld import make_input_queues
 from openpilot.selfdrive.modeld.fill_model_msg import fill_model_msg, fill_pose_msg, PublishState
 from openpilot.common.file_chunker import read_file_chunked
 from openpilot.selfdrive.modeld.constants import ModelConstants, Plan
@@ -38,13 +41,17 @@ from openpilot.sunnypilot.modeld_v2.modeld_base import ModelStateBase
 PROCESS_NAME = "selfdrive.modeld.modeld"
 SEND_RAW_PRED = os.getenv('SEND_RAW_PRED')
 
+VISION_PKL_PATH = MODELS_DIR / 'driving_vision_tinygrad.pkl'
 VISION_METADATA_PATH = MODELS_DIR / 'driving_vision_metadata.pkl'
+POLICY_PKL_PATH = MODELS_DIR / 'driving_policy_tinygrad.pkl'
 POLICY_METADATA_PATH = MODELS_DIR / 'driving_policy_metadata.pkl'
 
 LAT_SMOOTH_SECONDS = 0.0
 LONG_SMOOTH_SECONDS = 0.3
 MIN_LAT_CONTROL_SPEED = 0.3
 
+IMG_QUEUE_SHAPE = (6*(ModelConstants.MODEL_RUN_FREQ//ModelConstants.MODEL_CONTEXT_FREQ + 1), 128, 256)
+assert IMG_QUEUE_SHAPE[0] == 30
 
 
 def get_action_from_model(model_output: dict[str, np.ndarray], prev_action: log.ModelDataV2.Action,
@@ -79,39 +86,108 @@ class FrameMeta:
     if vipc is not None:
       self.frame_id, self.timestamp_sof, self.timestamp_eof = vipc.frame_id, vipc.timestamp_sof, vipc.timestamp_eof
 
+class InputQueues:
+  def __init__ (self, model_fps, env_fps, n_frames_input):
+    assert env_fps % model_fps == 0
+    assert env_fps >= model_fps
+    self.model_fps = model_fps
+    self.env_fps = env_fps
+    self.n_frames_input = n_frames_input
+
+    self.dtypes = {}
+    self.shapes = {}
+    self.q = {}
+
+  def update_dtypes_and_shapes(self, input_dtypes, input_shapes) -> None:
+    self.dtypes.update(input_dtypes)
+    if self.env_fps == self.model_fps:
+      self.shapes.update(input_shapes)
+    else:
+      for k in input_shapes:
+        shape = list(input_shapes[k])
+        if 'img' in k:
+          n_channels = shape[1] // self.n_frames_input
+          shape[1] = (self.env_fps // self.model_fps + (self.n_frames_input - 1)) * n_channels
+        else:
+          shape[1] = (self.env_fps // self.model_fps) * shape[1]
+        self.shapes[k] = tuple(shape)
+
+  def reset(self) -> None:
+    self.q = {k: np.zeros(self.shapes[k], dtype=self.dtypes[k]) for k in self.dtypes.keys()}
+
+  def enqueue(self, inputs:dict[str, np.ndarray]) -> None:
+    for k in inputs.keys():
+      if inputs[k].dtype != self.dtypes[k]:
+        raise ValueError(f'supplied input <{k}({inputs[k].dtype})> has wrong dtype, expected {self.dtypes[k]}')
+      input_shape = list(self.shapes[k])
+      input_shape[1] = -1
+      single_input = inputs[k].reshape(tuple(input_shape))
+      sz = single_input.shape[1]
+      self.q[k][:,:-sz] = self.q[k][:,sz:]
+      self.q[k][:,-sz:] = single_input
+
+  def get(self, *names) -> dict[str, np.ndarray]:
+    if self.env_fps == self.model_fps:
+      return {k: self.q[k] for k in names}
+    else:
+      out = {}
+      for k in names:
+        shape = self.shapes[k]
+        if 'img' in k:
+          n_channels = shape[1] // (self.env_fps // self.model_fps + (self.n_frames_input - 1))
+          out[k] = np.concatenate([self.q[k][:, s:s+n_channels] for s in np.linspace(0, shape[1] - n_channels, self.n_frames_input, dtype=int)], axis=1)
+        elif 'pulse' in k:
+          # any pulse within interval counts
+          out[k] = self.q[k].reshape((shape[0], shape[1] * self.model_fps // self.env_fps, self.env_fps // self.model_fps, -1)).max(axis=2)
+        else:
+          idxs = np.arange(-1, -shape[1], -self.env_fps // self.model_fps)[::-1]
+          out[k] = self.q[k][:, idxs]
+      return out
 
 class ModelState(ModelStateBase):
+  inputs: dict[str, np.ndarray]
+  output: np.ndarray
   prev_desire: np.ndarray  # for tracking the rising edge of the pulse
 
-  def __init__(self, cam_w: int, cam_h: int):
+  def __init__(self):
     ModelStateBase.__init__(self)
     self.LAT_SMOOTH_SECONDS = LAT_SMOOTH_SECONDS
-
     with open(VISION_METADATA_PATH, 'rb') as f:
       vision_metadata = pickle.load(f)
       self.vision_input_shapes =  vision_metadata['input_shapes']
       self.vision_input_names = list(self.vision_input_shapes.keys())
       self.vision_output_slices = vision_metadata['output_slices']
+      vision_output_size = vision_metadata['output_shapes']['outputs'][1]
 
     with open(POLICY_METADATA_PATH, 'rb') as f:
       policy_metadata = pickle.load(f)
       self.policy_input_shapes =  policy_metadata['input_shapes']
       self.policy_output_slices = policy_metadata['output_slices']
+      policy_output_size = policy_metadata['output_shapes']['outputs'][1]
 
     self.prev_desire = np.zeros(ModelConstants.DESIRE_LEN, dtype=np.float32)
 
-    self.frame_skip = ModelConstants.MODEL_RUN_FREQ // ModelConstants.MODEL_CONTEXT_FREQ
-    self.input_queues, self.npy = make_input_queues(self.vision_input_shapes, self.policy_input_shapes, self.frame_skip)
+    # policy inputs
+    self.numpy_inputs = {k: np.zeros(self.policy_input_shapes[k], dtype=np.float32) for k in self.policy_input_shapes}
+    self.full_input_queues = InputQueues(ModelConstants.MODEL_CONTEXT_FREQ, ModelConstants.MODEL_RUN_FREQ, ModelConstants.N_FRAMES)
+    for k in ['desire_pulse', 'features_buffer']:
+      self.full_input_queues.update_dtypes_and_shapes({k: self.numpy_inputs[k].dtype}, {k: self.numpy_inputs[k].shape})
+    self.full_input_queues.reset()
+
+    self.img_queues = {'img': Tensor.zeros(IMG_QUEUE_SHAPE, dtype='uint8').contiguous().realize(),
+                       'big_img': Tensor.zeros(IMG_QUEUE_SHAPE, dtype='uint8').contiguous().realize()}
     self.full_frames : dict[str, Tensor] = {}
     self._blob_cache : dict[int, Tensor] = {}
+    self.transforms_np = {k: np.zeros((3,3), dtype=np.float32) for k in self.img_queues}
+    self.transforms = {k: Tensor(v, device='NPY').realize() for k, v in self.transforms_np.items()}
+    self.vision_output = np.zeros(vision_output_size, dtype=np.float32)
+    self.policy_inputs = {k: Tensor(v, device='NPY').realize() for k,v in self.numpy_inputs.items()}
+    self.policy_output = np.zeros(policy_output_size, dtype=np.float32)
     self.parser = Parser()
-    self.frame_buf_params = {k: get_nv12_info(cam_w, cam_h) for k in ('img', 'big_img')}
-    self.run_policy = pickle.loads(read_file_chunked(CompileConfig(cam_w, cam_h, prefix='driving_', prepare_only=False).pkl_path))
-    self.warp_enqueue = pickle.loads(read_file_chunked(CompileConfig(cam_w, cam_h, prefix='driving_', prepare_only=True).pkl_path))
-    self.warp_enqueue(
-      **self.input_queues,
-      frame=Tensor.zeros(self.frame_buf_params['img'][3], dtype='uint8').contiguous().realize(),
-      big_frame=Tensor.zeros(self.frame_buf_params['big_img'][3], dtype='uint8').contiguous().realize())
+    self.frame_buf_params : dict[str, tuple[int, int, int, int]] = {}
+    self.update_imgs = None
+    self.vision_run = pickle.loads(read_file_chunked(str(VISION_PKL_PATH)))
+    self.policy_run = pickle.loads(read_file_chunked(str(POLICY_PKL_PATH)))
 
   def slice_outputs(self, model_outputs: np.ndarray, output_slices: dict[str, slice]) -> dict[str, np.ndarray]:
     parsed_model_outputs = {k: model_outputs[np.newaxis, v] for k,v in output_slices.items()}
@@ -119,6 +195,18 @@ class ModelState(ModelStateBase):
 
   def run(self, bufs: dict[str, VisionBuf], transforms: dict[str, np.ndarray],
                 inputs: dict[str, np.ndarray], prepare_only: bool) -> dict[str, np.ndarray] | None:
+    # Model decides when action is completed, so desire input is just a pulse triggered on rising edge
+    inputs['desire_pulse'][0] = 0
+    new_desire = np.where(inputs['desire_pulse'] - self.prev_desire > .99, inputs['desire_pulse'], 0)
+    self.prev_desire[:] = inputs['desire_pulse']
+    if self.update_imgs is None:
+      for key in bufs.keys():
+        w, h = bufs[key].width, bufs[key].height
+        self.frame_buf_params[key] = get_nv12_info(w, h)
+      warp_path = MODELS_DIR / f'warp_{w}x{h}_tinygrad.pkl'
+      with open(warp_path, "rb") as f:
+        self.update_imgs = pickle.load(f)
+
     for key in bufs.keys():
       ptr = bufs[key].data.ctypes.data
       yuv_size = self.frame_buf_params[key][3]
@@ -127,31 +215,30 @@ class ModelState(ModelStateBase):
       if cache_key not in self._blob_cache:
         self._blob_cache[cache_key] = Tensor.from_blob(ptr, (yuv_size,), dtype='uint8')
       self.full_frames[key] = self._blob_cache[cache_key]
+    for key in bufs.keys():
+      self.transforms_np[key][:,:] = transforms[key][:,:]
 
-    # Model decides when action is completed, so desire input is just a pulse triggered on rising edge
-    inputs['desire_pulse'][0] = 0
-    self.npy['desire'][:] = np.where(inputs['desire_pulse'] - self.prev_desire > .99, inputs['desire_pulse'], 0)
-    self.prev_desire[:] = inputs['desire_pulse']
-    self.npy['traffic_convention'][:] = inputs['traffic_convention']
-    self.npy['tfm'][:,:] = transforms['img'][:,:]
-    self.npy['big_tfm'][:,:] = transforms['big_img'][:,:]
+    out = self.update_imgs(self.img_queues['img'], self.full_frames['img'], self.transforms['img'],
+                           self.img_queues['big_img'], self.full_frames['big_img'], self.transforms['big_img'])
+    vision_inputs = {'img': out[0], 'big_img': out[1]}
 
     if prepare_only:
-      self.warp_enqueue(**self.input_queues, frame=self.full_frames['img'], big_frame=self.full_frames['big_img'])
       return None
 
-    vision_output, policy_output = self.run_policy(
-      **self.input_queues, frame=self.full_frames['img'], big_frame=self.full_frames['big_img']
-    )
+    self.vision_output = self.vision_run(**vision_inputs).contiguous().realize().uop.base.buffer.numpy().flatten()
+    vision_outputs_dict = self.parser.parse_vision_outputs(self.slice_outputs(self.vision_output, self.vision_output_slices))
 
-    vision_output = vision_output.numpy().flatten()
-    policy_output = policy_output.numpy().flatten()
-    vision_outputs_dict = self.parser.parse_vision_outputs(self.slice_outputs(vision_output, self.vision_output_slices))
-    policy_outputs_dict = self.parser.parse_policy_outputs(self.slice_outputs(policy_output, self.policy_output_slices))
+    self.full_input_queues.enqueue({'features_buffer': vision_outputs_dict['hidden_state'], 'desire_pulse': new_desire})
+    for k in ['desire_pulse', 'features_buffer']:
+      self.numpy_inputs[k][:] = self.full_input_queues.get(k)[k]
+    self.numpy_inputs['traffic_convention'][:] = inputs['traffic_convention']
+
+    self.policy_output = self.policy_run(**self.policy_inputs).contiguous().realize().uop.base.buffer.numpy().flatten()
+    policy_outputs_dict = self.parser.parse_policy_outputs(self.slice_outputs(self.policy_output, self.policy_output_slices))
     combined_outputs_dict = {**vision_outputs_dict, **policy_outputs_dict}
-
     if SEND_RAW_PRED:
-      combined_outputs_dict['raw_pred'] = np.concatenate([vision_output.copy(), policy_output.copy()])
+      combined_outputs_dict['raw_pred'] = np.concatenate([self.vision_output.copy(), self.policy_output.copy()])
+
     return combined_outputs_dict
 
 
@@ -163,6 +250,11 @@ def main(demo=False):
     # also need to move the aux USB interrupts for good timings
     config_realtime_process(7, 54)
 
+  st = time.monotonic()
+  cloudlog.warning("loading model")
+  model = ModelState()
+  cloudlog.warning(f"models loaded in {time.monotonic() - st:.1f}s, modeld starting")
+
   # visionipc clients
   while True:
     available_streams = VisionIpcClient.available_streams("camerad", block=False)
@@ -186,11 +278,6 @@ def main(demo=False):
   if use_extra_client:
     cloudlog.warning(f"connected extra cam with buffer size: {vipc_client_extra.buffer_len} ({vipc_client_extra.width} x {vipc_client_extra.height})")
 
-  st = time.monotonic()
-  cloudlog.warning("loading model")
-  model = ModelState(vipc_client_main.width, vipc_client_main.height)
-  cloudlog.warning(f"models loaded in {time.monotonic() - st:.1f}s, modeld starting")
-
   # messaging
   pm = PubMaster(["modelV2", "drivingModelData", "cameraOdometry", "modelDataV2SP"])
   sm = SubMaster(["deviceState", "carState", "roadCameraState", "liveCalibration", "driverMonitoringState", "carControl", "liveDelay"])

selfdrive/modeld/tinygrad_helpers.py

@@ -0,0 +1,12 @@
+import json
+import os
+from pathlib import Path
+
+MODELS_DIR = Path(__file__).parent / 'models'
+COMPILED_FLAGS_PATH = MODELS_DIR / 'tg_compiled_flags.json'
+
+
+def set_tinygrad_backend_from_compiled_flags() -> None:
+  if os.path.isfile(COMPILED_FLAGS_PATH):
+    with open(COMPILED_FLAGS_PATH) as f:
+      os.environ['DEV'] = str(json.load(f)['DEV'])

selfdrive/monitoring/README.md

@@ -0,0 +1,15 @@
+# driver monitoring (DM)
+
+Uploading driver-facing camera footage is opt-in, but it is encouraged to opt-in to improve the DM model. You can always change your preference using the "Record and Upload Driver Camera" toggle.
+
+## Troubleshooting
+
+Before creating a bug report, go through these troubleshooting steps.
+
+* Ensure the driver-facing camera has a good view of the driver in normal driving positions.
+ * This can be checked in Settings -> Device -> Preview Driver Camera (when car is off).
+* If the camera can't see the driver, the device should be re-mounted.
+
+## Bug report
+
+In order for us to look into DM bug reports, we'll need the driver-facing camera footage. If you don't normally have this enabled, simply enable the toggle for a single drive. Also ensure the "Upload Raw Logs" toggle is enabled before going for a drive.

selfdrive/monitoring/dmonitoringd.py

@@ -2,7 +2,7 @@
 import cereal.messaging as messaging
 from openpilot.common.params import Params
 from openpilot.common.realtime import config_realtime_process
-from openpilot.selfdrive.monitoring.policy import DriverMonitoring
+from openpilot.selfdrive.monitoring.helpers import DriverMonitoring
 
 
 def dmonitoringd_thread():
@@ -25,7 +25,7 @@ def dmonitoringd_thread():
 
     valid = sm.all_checks()
     if demo_mode and sm.valid['driverStateV2']:
-      DM.run_step(sm, demo=True)
+      DM.run_step(sm, demo=demo_mode)
     elif valid:
       DM.run_step(sm, demo=demo_mode)
 
@@ -40,8 +40,8 @@ def dmonitoringd_thread():
 
     # save rhd virtual toggle every 5 mins
     if (sm['driverStateV2'].frameId % 6000 == 0 and not demo_mode and
-     DM.wheelpos_offsetter.filtered_stat.n > DM.settings._WHEELPOS_FILTER_MIN_COUNT and
-     DM.wheel_on_right == (DM.wheelpos_offsetter.filtered_stat.M > DM.settings._WHEELPOS_THRESHOLD)):
+     DM.wheelpos.prob_offseter.filtered_stat.n > DM.settings._WHEELPOS_FILTER_MIN_COUNT and
+     DM.wheel_on_right == (DM.wheelpos.prob_offseter.filtered_stat.M > DM.settings._WHEELPOS_THRESHOLD)):
       params.put_bool_nonblocking("IsRhdDetected", DM.wheel_on_right)
 
 def main():

selfdrive/monitoring/helpers.py

@@ -0,0 +1,463 @@
+from math import atan2, radians
+import numpy as np
+
+from cereal import car, log
+import cereal.messaging as messaging
+from openpilot.selfdrive.selfdrived.events import Events
+from openpilot.selfdrive.selfdrived.alertmanager import set_offroad_alert
+from openpilot.common.realtime import DT_DMON
+from openpilot.common.filter_simple import FirstOrderFilter
+from openpilot.common.params import Params
+from openpilot.common.stat_live import RunningStatFilter
+from openpilot.common.transformations.camera import DEVICE_CAMERAS
+from openpilot.system.hardware import HARDWARE
+
+EventName = log.OnroadEvent.EventName
+
+# ******************************************************************************************
+#  NOTE: To fork maintainers.
+#  Disabling or nerfing safety features will get you and your users banned from our servers.
+#  We recommend that you do not change these numbers from the defaults.
+# ******************************************************************************************
+
+class DRIVER_MONITOR_SETTINGS:
+  def __init__(self, device_type):
+    self._DT_DMON = DT_DMON
+    # ref (page15-16): https://eur-lex.europa.eu/legal-content/EN/TXT/PDF/?uri=CELEX:42018X1947&rid=2
+    self._AWARENESS_TIME = 30. # passive wheeltouch total timeout
+    self._AWARENESS_PRE_TIME_TILL_TERMINAL = 15.
+    self._AWARENESS_PROMPT_TIME_TILL_TERMINAL = 6.
+    self._DISTRACTED_TIME = 11. # active monitoring total timeout
+    self._DISTRACTED_PRE_TIME_TILL_TERMINAL = 8.
+    self._DISTRACTED_PROMPT_TIME_TILL_TERMINAL = 6.
+
+    self._FACE_THRESHOLD = 0.7
+    self._EYE_THRESHOLD = 0.5
+    self._BLINK_THRESHOLD = 0.5
+    self._PHONE_THRESH = 0.5
+
+    self._POSE_PITCH_THRESHOLD = 0.3133
+    self._POSE_PITCH_THRESHOLD_SLACK = 0.3237
+    self._POSE_PITCH_THRESHOLD_STRICT = self._POSE_PITCH_THRESHOLD
+    self._POSE_YAW_THRESHOLD = 0.4020
+    self._POSE_YAW_THRESHOLD_SLACK = 0.5042
+    self._POSE_YAW_THRESHOLD_STRICT = self._POSE_YAW_THRESHOLD
+    self._POSE_YAW_MIN_STEER_DEG = 30
+    self._POSE_YAW_STEER_FACTOR = 0.15
+    self._POSE_YAW_STEER_MAX_OFFSET = 0.3927
+    self._PITCH_NATURAL_OFFSET = 0.011 # initial value before offset is learned
+    self._PITCH_NATURAL_THRESHOLD = 0.449
+    self._YAW_NATURAL_OFFSET = 0.075 # initial value before offset is learned
+    self._PITCH_NATURAL_VAR = 3*0.01
+    self._YAW_NATURAL_VAR = 3*0.05
+    self._PITCH_MAX_OFFSET = 0.124
+    self._PITCH_MIN_OFFSET = -0.0881
+    self._YAW_MAX_OFFSET = 0.289
+    self._YAW_MIN_OFFSET = -0.0246
+
+    self._DCAM_UNCERTAIN_ALERT_THRESHOLD = 0.1
+    self._DCAM_UNCERTAIN_ALERT_COUNT = int(60  / self._DT_DMON)
+    self._DCAM_UNCERTAIN_RESET_COUNT = int(20  / self._DT_DMON)
+    self._POSESTD_THRESHOLD = 0.3
+    self._HI_STD_FALLBACK_TIME = int(10  / self._DT_DMON)  # fall back to wheel touch if model is uncertain for 10s
+    self._DISTRACTED_FILTER_TS = 0.25  # 0.6Hz
+
+    self._POSE_CALIB_MIN_SPEED = 13  # 30 mph
+    self._POSE_OFFSET_MIN_COUNT = int(60 / self._DT_DMON)  # valid data counts before calibration completes, 1min cumulative
+    self._POSE_OFFSET_MAX_COUNT = int(360 / self._DT_DMON)  # stop deweighting new data after 6 min, aka "short term memory"
+
+    self._WHEELPOS_CALIB_MIN_SPEED = 11
+    self._WHEELPOS_THRESHOLD = 0.5
+    self._WHEELPOS_FILTER_MIN_COUNT = int(15 / self._DT_DMON) # allow 15 seconds to converge wheel side
+    self._WHEELPOS_DATA_AVG = 0.03
+    self._WHEELPOS_DATA_VAR = 3*5.5e-5
+    self._WHEELPOS_MAX_COUNT = -1
+
+    self._RECOVERY_FACTOR_MAX = 5.  # relative to minus step change
+    self._RECOVERY_FACTOR_MIN = 1.25  # relative to minus step change
+
+    self._MAX_TERMINAL_ALERTS = 3  # not allowed to engage after 3 terminal alerts
+    self._MAX_TERMINAL_DURATION = int(30 / self._DT_DMON)  # not allowed to engage after 30s of terminal alerts
+
+class DistractedType:
+
+  NOT_DISTRACTED = 0
+  DISTRACTED_POSE = 1 << 0
+  DISTRACTED_BLINK = 1 << 1
+  DISTRACTED_PHONE = 1 << 2
+
+class DriverPose:
+  def __init__(self, settings):
+    pitch_filter_raw_priors = (settings._PITCH_NATURAL_OFFSET, settings._PITCH_NATURAL_VAR, 2)
+    yaw_filter_raw_priors = (settings._YAW_NATURAL_OFFSET, settings._YAW_NATURAL_VAR, 2)
+    self.yaw = 0.
+    self.pitch = 0.
+    self.roll = 0.
+    self.yaw_std = 0.
+    self.pitch_std = 0.
+    self.roll_std = 0.
+    self.pitch_offseter = RunningStatFilter(raw_priors=pitch_filter_raw_priors, max_trackable=settings._POSE_OFFSET_MAX_COUNT)
+    self.yaw_offseter = RunningStatFilter(raw_priors=yaw_filter_raw_priors, max_trackable=settings._POSE_OFFSET_MAX_COUNT)
+    self.calibrated = False
+    self.low_std = True
+    self.cfactor_pitch = 1.
+    self.cfactor_yaw = 1.
+    self.steer_yaw_offset = 0.
+
+class DriverProb:
+  def __init__(self, raw_priors, max_trackable):
+    self.prob = 0.
+    self.prob_offseter = RunningStatFilter(raw_priors=raw_priors, max_trackable=max_trackable)
+    self.prob_calibrated = False
+
+
+# model output refers to center of undistorted+leveled image
+EFL = 598.0 # focal length in K
+cam = DEVICE_CAMERAS[("tici", "ar0231")] # corrected image has same size as raw
+W, H = (cam.dcam.width, cam.dcam.height)  # corrected image has same size as raw
+
+def face_orientation_from_net(angles_desc, pos_desc, rpy_calib):
+  # the output of these angles are in device frame
+  # so from driver's perspective, pitch is up and yaw is right
+
+  pitch_net, yaw_net, roll_net = angles_desc
+
+  face_pixel_position = ((pos_desc[0]+0.5)*W, (pos_desc[1]+0.5)*H)
+  yaw_focal_angle = atan2(face_pixel_position[0] - W//2, EFL)
+  pitch_focal_angle = atan2(face_pixel_position[1] - H//2, EFL)
+
+  pitch = pitch_net + pitch_focal_angle
+  yaw = -yaw_net + yaw_focal_angle
+
+  # no calib for roll
+  pitch -= rpy_calib[1]
+  yaw -= rpy_calib[2]
+  return roll_net, pitch, yaw
+
+
+class DriverMonitoring:
+  def __init__(self, rhd_saved=False, settings=None, always_on=False):
+    # init policy settings
+    self.settings = settings if settings is not None else DRIVER_MONITOR_SETTINGS(device_type=HARDWARE.get_device_type())
+
+    # init driver status
+    wheelpos_filter_raw_priors = (self.settings._WHEELPOS_DATA_AVG, self.settings._WHEELPOS_DATA_VAR, 2)
+    self.wheelpos = DriverProb(raw_priors=wheelpos_filter_raw_priors, max_trackable=self.settings._WHEELPOS_MAX_COUNT)
+    self.pose = DriverPose(settings=self.settings)
+    self.blink_prob = 0.
+    self.phone_prob = 0.
+
+    self.always_on = always_on
+    self.distracted_types = []
+    self.driver_distracted = False
+    self.driver_distraction_filter = FirstOrderFilter(0., self.settings._DISTRACTED_FILTER_TS, self.settings._DT_DMON)
+    self.wheel_on_right = False
+    self.wheel_on_right_last = None
+    self.wheel_on_right_default = rhd_saved
+    self.face_detected = False
+    self.terminal_alert_cnt = 0
+    self.terminal_time = 0
+    self.step_change = 0.
+    self.active_monitoring_mode = True
+    self.is_model_uncertain = False
+    self.hi_stds = 0
+    self.threshold_pre = self.settings._DISTRACTED_PRE_TIME_TILL_TERMINAL / self.settings._DISTRACTED_TIME
+    self.threshold_prompt = self.settings._DISTRACTED_PROMPT_TIME_TILL_TERMINAL / self.settings._DISTRACTED_TIME
+    self.dcam_uncertain_cnt = 0
+    self.dcam_uncertain_alerted = False # once per drive
+    self.dcam_reset_cnt = 0
+
+    self.params = Params()
+    self.too_distracted = self.params.get_bool("DriverTooDistracted")
+
+    self._reset_awareness()
+    self._set_timers(active_monitoring=True)
+    self._reset_events()
+
+  def _reset_awareness(self):
+    self.awareness = 1.
+    self.awareness_active = 1.
+    self.awareness_passive = 1.
+
+  def _reset_events(self):
+    self.current_events = Events()
+
+  def _set_timers(self, active_monitoring):
+    if self.active_monitoring_mode and self.awareness <= self.threshold_prompt:
+      if active_monitoring:
+        self.step_change = self.settings._DT_DMON / self.settings._DISTRACTED_TIME
+      else:
+        self.step_change = 0.
+      return  # no exploit after orange alert
+    elif self.awareness <= 0.:
+      return
+
+    if active_monitoring:
+      # when falling back from passive mode to active mode, reset awareness to avoid false alert
+      if not self.active_monitoring_mode:
+        self.awareness_passive = self.awareness
+        self.awareness = self.awareness_active
+
+      self.threshold_pre = self.settings._DISTRACTED_PRE_TIME_TILL_TERMINAL / self.settings._DISTRACTED_TIME
+      self.threshold_prompt = self.settings._DISTRACTED_PROMPT_TIME_TILL_TERMINAL / self.settings._DISTRACTED_TIME
+      self.step_change = self.settings._DT_DMON / self.settings._DISTRACTED_TIME
+      self.active_monitoring_mode = True
+    else:
+      if self.active_monitoring_mode:
+        self.awareness_active = self.awareness
+        self.awareness = self.awareness_passive
+
+      self.threshold_pre = self.settings._AWARENESS_PRE_TIME_TILL_TERMINAL / self.settings._AWARENESS_TIME
+      self.threshold_prompt = self.settings._AWARENESS_PROMPT_TIME_TILL_TERMINAL / self.settings._AWARENESS_TIME
+      self.step_change = self.settings._DT_DMON / self.settings._AWARENESS_TIME
+      self.active_monitoring_mode = False
+
+  def _set_policy(self, brake_disengage_prob, car_speed):
+    bp = brake_disengage_prob
+    k1 = max(-0.00156*((car_speed-16)**2)+0.6, 0.2)
+    bp_normal = max(min(bp / k1, 0.5),0)
+    self.pose.cfactor_pitch = np.interp(bp_normal, [0, 0.5],
+                                           [self.settings._POSE_PITCH_THRESHOLD_SLACK,
+                                            self.settings._POSE_PITCH_THRESHOLD_STRICT]) / self.settings._POSE_PITCH_THRESHOLD
+    self.pose.cfactor_yaw = np.interp(bp_normal, [0, 0.5],
+                                           [self.settings._POSE_YAW_THRESHOLD_SLACK,
+                                            self.settings._POSE_YAW_THRESHOLD_STRICT]) / self.settings._POSE_YAW_THRESHOLD
+
+  def _get_distracted_types(self):
+    distracted_types = []
+
+    if not self.pose.calibrated:
+      pitch_error = self.pose.pitch - self.settings._PITCH_NATURAL_OFFSET
+      yaw_error = self.pose.yaw - self.settings._YAW_NATURAL_OFFSET
+    else:
+      pitch_error = self.pose.pitch - min(max(self.pose.pitch_offseter.filtered_stat.mean(),
+                                                       self.settings._PITCH_MIN_OFFSET), self.settings._PITCH_MAX_OFFSET)
+      yaw_error = self.pose.yaw - min(max(self.pose.yaw_offseter.filtered_stat.mean(),
+                                                    self.settings._YAW_MIN_OFFSET), self.settings._YAW_MAX_OFFSET)
+    pitch_error = 0 if pitch_error > 0 else abs(pitch_error) # no positive pitch limit
+
+    if yaw_error * self.pose.steer_yaw_offset > 0: # unidirectional
+      yaw_error = max(abs(yaw_error) - min(abs(self.pose.steer_yaw_offset), self.settings._POSE_YAW_STEER_MAX_OFFSET), 0.)
+    else:
+      yaw_error = abs(yaw_error)
+
+    pitch_threshold = self.settings._POSE_PITCH_THRESHOLD * self.pose.cfactor_pitch if self.pose.calibrated else self.settings._PITCH_NATURAL_THRESHOLD
+    yaw_threshold = self.settings._POSE_YAW_THRESHOLD * self.pose.cfactor_yaw
+
+    if pitch_error > pitch_threshold or yaw_error > yaw_threshold:
+      distracted_types.append(DistractedType.DISTRACTED_POSE)
+
+    if self.blink_prob > self.settings._BLINK_THRESHOLD:
+      distracted_types.append(DistractedType.DISTRACTED_BLINK)
+
+    if self.phone_prob > self.settings._PHONE_THRESH:
+      distracted_types.append(DistractedType.DISTRACTED_PHONE)
+
+    return distracted_types
+
+  def _update_states(self, driver_state, cal_rpy, car_speed, op_engaged, standstill, demo_mode=False, steering_angle_deg=0.):
+    rhd_pred = driver_state.wheelOnRightProb
+    # calibrates only when there's movement and either face detected
+    if car_speed > self.settings._WHEELPOS_CALIB_MIN_SPEED and (driver_state.leftDriverData.faceProb > self.settings._FACE_THRESHOLD or
+                                          driver_state.rightDriverData.faceProb > self.settings._FACE_THRESHOLD):
+      self.wheelpos.prob_offseter.push_and_update(rhd_pred)
+
+    self.wheelpos.prob_calibrated = self.wheelpos.prob_offseter.filtered_stat.n > self.settings._WHEELPOS_FILTER_MIN_COUNT
+
+    if self.wheelpos.prob_calibrated or demo_mode:
+      self.wheel_on_right = self.wheelpos.prob_offseter.filtered_stat.M > self.settings._WHEELPOS_THRESHOLD
+    else:
+      self.wheel_on_right = self.wheel_on_right_default # use default/saved if calibration is unfinished
+    # make sure no switching when engaged
+    if op_engaged and self.wheel_on_right_last is not None and self.wheel_on_right_last != self.wheel_on_right and not demo_mode:
+      self.wheel_on_right = self.wheel_on_right_last
+    driver_data = driver_state.rightDriverData if self.wheel_on_right else driver_state.leftDriverData
+    if not all(len(x) > 0 for x in (driver_data.faceOrientation, driver_data.facePosition,
+                                    driver_data.faceOrientationStd, driver_data.facePositionStd)):
+      return
+
+    self.face_detected = driver_data.faceProb > self.settings._FACE_THRESHOLD
+    self.pose.roll, self.pose.pitch, self.pose.yaw = face_orientation_from_net(driver_data.faceOrientation, driver_data.facePosition, cal_rpy)
+    steer_d = max(abs(steering_angle_deg) - self.settings._POSE_YAW_MIN_STEER_DEG, 0.)
+    self.pose.steer_yaw_offset = radians(steer_d) * -np.sign(steering_angle_deg) * self.settings._POSE_YAW_STEER_FACTOR
+    if self.wheel_on_right:
+      self.pose.yaw *= -1
+      self.pose.steer_yaw_offset *= -1
+    self.wheel_on_right_last = self.wheel_on_right
+    self.pose.pitch_std = driver_data.faceOrientationStd[0]
+    self.pose.yaw_std = driver_data.faceOrientationStd[1]
+    model_std_max = max(self.pose.pitch_std, self.pose.yaw_std)
+    self.pose.low_std = model_std_max < self.settings._POSESTD_THRESHOLD
+    self.blink_prob = driver_data.eyesClosedProb * (driver_data.eyesVisibleProb > self.settings._EYE_THRESHOLD)
+    self.phone_prob = driver_data.phoneProb
+
+    self.distracted_types = self._get_distracted_types()
+    self.driver_distracted = (DistractedType.DISTRACTED_PHONE in self.distracted_types
+                              or DistractedType.DISTRACTED_POSE in self.distracted_types
+                              or DistractedType.DISTRACTED_BLINK in self.distracted_types) \
+                              and driver_data.faceProb > self.settings._FACE_THRESHOLD and self.pose.low_std
+    self.driver_distraction_filter.update(self.driver_distracted)
+
+    # update offseter
+    # only update when driver is actively driving the car above a certain speed
+    if self.face_detected and car_speed > self.settings._POSE_CALIB_MIN_SPEED and self.pose.low_std and (not op_engaged or not self.driver_distracted):
+      self.pose.pitch_offseter.push_and_update(self.pose.pitch)
+      self.pose.yaw_offseter.push_and_update(self.pose.yaw)
+
+    self.pose.calibrated = self.pose.pitch_offseter.filtered_stat.n > self.settings._POSE_OFFSET_MIN_COUNT and \
+                           self.pose.yaw_offseter.filtered_stat.n > self.settings._POSE_OFFSET_MIN_COUNT
+
+    if self.face_detected and not self.driver_distracted:
+      if model_std_max > self.settings._DCAM_UNCERTAIN_ALERT_THRESHOLD:
+        if not standstill:
+          self.dcam_uncertain_cnt += 1
+          self.dcam_reset_cnt = 0
+      else:
+        self.dcam_reset_cnt += 1
+        if self.dcam_reset_cnt > self.settings._DCAM_UNCERTAIN_RESET_COUNT:
+          self.dcam_uncertain_cnt = 0
+
+    self.is_model_uncertain = self.hi_stds > self.settings._HI_STD_FALLBACK_TIME
+    self._set_timers(self.face_detected and not self.is_model_uncertain)
+    if self.face_detected and not self.pose.low_std and not self.driver_distracted:
+      self.hi_stds += 1
+    elif self.face_detected and self.pose.low_std:
+      self.hi_stds = 0
+
+  def _update_events(self, driver_engaged, op_engaged, standstill, wrong_gear, car_speed):
+    self._reset_events()
+    # Block engaging until ignition cycle after max number or time of distractions
+    if self.terminal_alert_cnt >= self.settings._MAX_TERMINAL_ALERTS or \
+       self.terminal_time >= self.settings._MAX_TERMINAL_DURATION:
+      if not self.too_distracted:
+        self.params.put_bool_nonblocking("DriverTooDistracted", True)
+      self.too_distracted = True
+
+    # Always-on distraction lockout is temporary
+    if self.too_distracted or (self.always_on and self.awareness <= self.threshold_prompt):
+      self.current_events.add(EventName.tooDistracted)
+
+    always_on_valid = self.always_on and not wrong_gear
+    if (driver_engaged and self.awareness > 0 and not self.active_monitoring_mode) or \
+       (not always_on_valid and not op_engaged) or \
+       (always_on_valid and not op_engaged and self.awareness <= 0):
+      # always reset on disengage with normal mode; disengage resets only on red if always on
+      self._reset_awareness()
+      return
+
+    awareness_prev = self.awareness
+    _reaching_pre = self.awareness - self.step_change <= self.threshold_pre
+    _reaching_terminal = self.awareness - self.step_change <= 0
+    standstill_orange_exemption = standstill and _reaching_pre
+    always_on_red_exemption = always_on_valid and not op_engaged and _reaching_terminal
+
+    if self.awareness > 0 and \
+       ((self.driver_distraction_filter.x < 0.37 and self.face_detected and self.pose.low_std) or standstill_orange_exemption):
+      if driver_engaged:
+        self._reset_awareness()
+        return
+      # only restore awareness when paying attention and alert is not red
+      self.awareness = min(self.awareness + ((self.settings._RECOVERY_FACTOR_MAX-self.settings._RECOVERY_FACTOR_MIN)*
+                                             (1.-self.awareness)+self.settings._RECOVERY_FACTOR_MIN)*self.step_change, 1.)
+      if self.awareness == 1.:
+        self.awareness_passive = min(self.awareness_passive + self.step_change, 1.)
+      # don't display alert banner when awareness is recovering and has cleared orange
+      if self.awareness > self.threshold_prompt:
+        return
+
+    certainly_distracted = self.driver_distraction_filter.x > 0.63 and self.driver_distracted and self.face_detected
+    maybe_distracted = self.hi_stds > self.settings._HI_STD_FALLBACK_TIME or not self.face_detected
+
+    if certainly_distracted or maybe_distracted:
+      # should always be counting if distracted unless at standstill and reaching green
+      # also will not be reaching 0 if DM is active when not engaged
+      if not (standstill_orange_exemption or always_on_red_exemption):
+        self.awareness = max(self.awareness - self.step_change, -0.1)
+
+    alert = None
+    if self.awareness <= 0.:
+      # terminal red alert: disengagement required
+      alert = EventName.driverDistracted3 if self.active_monitoring_mode else EventName.driverUnresponsive3
+      self.terminal_time += 1
+      if awareness_prev > 0.:
+        self.terminal_alert_cnt += 1
+    elif self.awareness <= self.threshold_prompt:
+      # prompt orange alert
+      alert = EventName.driverDistracted2 if self.active_monitoring_mode else EventName.driverUnresponsive2
+    elif self.awareness <= self.threshold_pre:
+      # pre green alert
+      alert = EventName.driverDistracted1 if self.active_monitoring_mode else EventName.driverUnresponsive1
+
+    if alert is not None:
+      self.current_events.add(alert)
+
+    if self.dcam_uncertain_cnt > self.settings._DCAM_UNCERTAIN_ALERT_COUNT and not self.dcam_uncertain_alerted:
+      set_offroad_alert("Offroad_DriverMonitoringUncertain", True)
+      self.dcam_uncertain_alerted = True
+
+
+  def get_state_packet(self, valid=True):
+    # build driverMonitoringState packet
+    dat = messaging.new_message('driverMonitoringState', valid=valid)
+    dat.driverMonitoringState = {
+      "events": self.current_events.to_msg(),
+      "faceDetected": self.face_detected,
+      "isDistracted": self.driver_distracted,
+      "distractedType": sum(self.distracted_types),
+      "awarenessStatus": self.awareness,
+      "posePitchOffset": self.pose.pitch_offseter.filtered_stat.mean(),
+      "posePitchValidCount": self.pose.pitch_offseter.filtered_stat.n,
+      "poseYawOffset": self.pose.yaw_offseter.filtered_stat.mean(),
+      "poseYawValidCount": self.pose.yaw_offseter.filtered_stat.n,
+      "stepChange": self.step_change,
+      "awarenessActive": self.awareness_active,
+      "awarenessPassive": self.awareness_passive,
+      "isLowStd": self.pose.low_std,
+      "hiStdCount": self.hi_stds,
+      "isActiveMode": self.active_monitoring_mode,
+      "isRHD": self.wheel_on_right,
+      "uncertainCount": self.dcam_uncertain_cnt,
+    }
+    return dat
+
+  def run_step(self, sm, demo=False):
+    if demo:
+      highway_speed = 30
+      enabled = True
+      wrong_gear = False
+      standstill = False
+      driver_engaged = False
+      brake_disengage_prob = 1.0
+      rpyCalib = [0., 0., 0.]
+    else:
+      highway_speed = sm['carState'].vEgo
+      enabled = sm['selfdriveState'].enabled or sm['carControl'].latActive
+      wrong_gear = sm['carState'].gearShifter not in (car.CarState.GearShifter.drive, car.CarState.GearShifter.low)
+      standstill = sm['carState'].standstill
+      driver_engaged = sm['carState'].steeringPressed or (sm['selfdriveState'].enabled and sm['carState'].gasPressed)
+      brake_disengage_prob = sm['modelV2'].meta.disengagePredictions.brakeDisengageProbs[0] # brake disengage prob in next 2s
+      rpyCalib = sm['liveCalibration'].rpyCalib
+    self._set_policy(
+      brake_disengage_prob=brake_disengage_prob,
+      car_speed=highway_speed,
+    )
+
+    # Parse data from dmonitoringmodeld
+    self._update_states(
+      driver_state=sm['driverStateV2'],
+      cal_rpy=rpyCalib,
+      car_speed=highway_speed,
+      op_engaged=enabled,
+      standstill=standstill,
+      demo_mode=demo,
+      steering_angle_deg=sm['carState'].steeringAngleDeg,
+    )
+
+    # Update distraction events
+    self._update_events(
+      driver_engaged=driver_engaged,
+      op_engaged=enabled,
+      standstill=standstill,
+      wrong_gear=wrong_gear,
+      car_speed=highway_speed
+    )

selfdrive/monitoring/policy.py

@@ -1,426 +0,0 @@
-from collections import defaultdict
-from math import atan2, radians
-import numpy as np
-
-from cereal import car, log
-import cereal.messaging as messaging
-from openpilot.common.realtime import DT_DMON
-from openpilot.common.filter_simple import FirstOrderFilter
-from openpilot.common.params import Params
-from openpilot.common.stat_live import RunningStatFilter
-from openpilot.common.transformations.camera import DEVICE_CAMERAS
-
-AlertLevel = log.DriverMonitoringState.AlertLevel
-MonitoringPolicy = log.DriverMonitoringState.MonitoringPolicy
-
-def to_percent(v):
-  return int(min(max(v * 100., 0.), 100.))
-
-# ******************************************************************************************
-#  NOTE: To fork maintainers.
-#  Disabling or nerfing safety features will get you and your users banned from our servers.
-#  We recommend that you do not change these numbers from the defaults.
-# ******************************************************************************************
-
-class DRIVER_MONITOR_SETTINGS:
-  def __init__(self):
-    # https://eur-lex.europa.eu/legal-content/EN/TXT/PDF/?uri=CELEX:42018X1947&rid=2
-    self._WHEELTOUCH_POLICY_ALERT_1_TIMEOUT = 15.
-    self._WHEELTOUCH_POLICY_ALERT_2_TIMEOUT = 24.
-    self._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT = 30.
-    # https://cdn.euroncap.com/cars/assets/euro_ncap_protocol_safe_driving_driver_engagement_v11_a30e874152.pdf
-    self._VISION_POLICY_ALERT_1_TIMEOUT = 3.
-    self._VISION_POLICY_ALERT_2_TIMEOUT = 5.
-    self._VISION_POLICY_ALERT_3_TIMEOUT = 11.
-
-    self._TIMEOUT_RECOVERY_FACTOR_MAX = 5.
-    self._TIMEOUT_RECOVERY_FACTOR_MIN = 1.25
-
-    self._MAX_TERMINAL_ALERTS = 3  # not allowed to engage after 3 terminal alerts
-    self._MAX_TERMINAL_DURATION = int(30 / DT_DMON)  # not allowed to engage after 30s of terminal alerts
-
-    self._FACE_THRESHOLD = 0.7
-    self._EYE_THRESHOLD = 0.5
-    self._BLINK_THRESHOLD = 0.5
-    self._PHONE_THRESH = 0.5
-    self._POSE_PITCH_THRESHOLD = 0.3133
-    self._POSE_PITCH_THRESHOLD_SLACK = 0.3237
-    self._POSE_PITCH_THRESHOLD_STRICT = self._POSE_PITCH_THRESHOLD
-    self._POSE_YAW_THRESHOLD = 0.4020
-    self._POSE_YAW_THRESHOLD_SLACK = 0.5042
-    self._POSE_YAW_THRESHOLD_STRICT = self._POSE_YAW_THRESHOLD
-    self._POSE_YAW_MIN_STEER_DEG = 30
-    self._POSE_YAW_STEER_FACTOR = 0.15
-    self._POSE_YAW_STEER_MAX_OFFSET = 0.3927
-    self._PITCH_NATURAL_OFFSET = 0.011 # initial value before offset is learned
-    self._PITCH_NATURAL_THRESHOLD = 0.449
-    self._YAW_NATURAL_OFFSET = 0.075 # initial value before offset is learned
-    self._PITCH_NATURAL_VAR = 3*0.01
-    self._YAW_NATURAL_VAR = 3*0.05
-    self._PITCH_MAX_OFFSET = 0.124
-    self._PITCH_MIN_OFFSET = -0.0881
-    self._YAW_MAX_OFFSET = 0.289
-    self._YAW_MIN_OFFSET = -0.0246
-
-    self._DCAM_UNCERTAIN_ALERT_THRESHOLD = 0.1
-    self._DCAM_UNCERTAIN_ALERT_COUNT = int(60  / DT_DMON)
-    self._DCAM_UNCERTAIN_RESET_COUNT = int(20  / DT_DMON)
-    self._HI_STD_THRESHOLD = 0.3
-    self._HI_STD_FALLBACK_TIME = int(10  / DT_DMON)  # fall back to wheel touch if model is uncertain for 10s
-    self._DISTRACTED_FILTER_TS = 0.25  # 0.6Hz
-
-    self._POSE_CALIB_MIN_SPEED = 13  # 30 mph
-    self._POSE_OFFSET_MIN_COUNT = int(60 / DT_DMON)  # valid data counts before calibration completes, 1min cumulative
-    self._POSE_OFFSET_MAX_COUNT = int(360 / DT_DMON)  # stop deweighting new data after 6 min, aka "short term memory"
-    self._WHEELPOS_CALIB_MIN_SPEED = 11
-    self._WHEELPOS_THRESHOLD = 0.5
-    self._WHEELPOS_FILTER_MIN_COUNT = int(15 / DT_DMON) # allow 15 seconds to converge wheel side
-    self._WHEELPOS_DATA_AVG = 0.03
-    self._WHEELPOS_DATA_VAR = 3*5.5e-5
-    self._WHEELPOS_MAX_COUNT = -1
-
-class DriverPose:
-  def __init__(self, settings):
-    pitch_filter_raw_priors = (settings._PITCH_NATURAL_OFFSET, settings._PITCH_NATURAL_VAR, 2)
-    yaw_filter_raw_priors = (settings._YAW_NATURAL_OFFSET, settings._YAW_NATURAL_VAR, 2)
-    self.yaw = 0.
-    self.pitch = 0.
-    self.pitch_offsetter = RunningStatFilter(raw_priors=pitch_filter_raw_priors, max_trackable=settings._POSE_OFFSET_MAX_COUNT)
-    self.yaw_offsetter = RunningStatFilter(raw_priors=yaw_filter_raw_priors, max_trackable=settings._POSE_OFFSET_MAX_COUNT)
-    self.calibrated = False
-    self.low_std = True
-    self.cfactor_pitch = 1.
-    self.cfactor_yaw = 1.
-    self.steer_yaw_offset = 0.
-
-# model output refers to center of undistorted+leveled image
-ref_undistorted_cam = DEVICE_CAMERAS[("tici", "ar0231")].dcam
-dcam_undistorted_FL = 598.0
-dcam_undistorted_W, dcam_undistorted_H = (ref_undistorted_cam.width, ref_undistorted_cam.height)
-
-def face_orientation_from_model(orient_model, pos_model, rpy_calib):
-  pitch_model = orient_model[0]
-  yaw_model = orient_model[1]
-
-  face_pixel_position = ((pos_model[0]+0.5)*dcam_undistorted_W, (pos_model[1]+0.5)*dcam_undistorted_H)
-  yaw_focal_angle = atan2(face_pixel_position[0] - dcam_undistorted_W//2, dcam_undistorted_FL)
-  pitch_focal_angle = atan2(face_pixel_position[1] - dcam_undistorted_H//2, dcam_undistorted_FL)
-
-  pitch = pitch_model + pitch_focal_angle
-  yaw = -yaw_model + yaw_focal_angle
-
-  pitch -= rpy_calib[1]
-  yaw -= rpy_calib[2]
-  return pitch, yaw
-
-
-class DriverMonitoring:
-  def __init__(self, rhd_saved=False, settings=None, always_on=False):
-    # init policy settings
-    self.settings = settings if settings is not None else DRIVER_MONITOR_SETTINGS()
-
-    # init driver status
-    wheelpos_filter_raw_priors = (self.settings._WHEELPOS_DATA_AVG, self.settings._WHEELPOS_DATA_VAR, 2)
-    self.wheelpos_offsetter = RunningStatFilter(raw_priors=wheelpos_filter_raw_priors, max_trackable=self.settings._WHEELPOS_MAX_COUNT)
-    self.pose = DriverPose(settings=self.settings)
-    self.blink_prob = 0.
-    self.phone_prob = 0.
-
-    self.alert_level = AlertLevel.none
-    self.always_on = always_on
-    self.distracted_types = defaultdict(bool)
-    self.driver_distracted = False
-    self.driver_distraction_filter = FirstOrderFilter(0., self.settings._DISTRACTED_FILTER_TS, DT_DMON)
-    self.wheel_on_right = False
-    self.wheel_on_right_last = None
-    self.wheel_on_right_default = rhd_saved
-    self.face_detected = False
-    self.terminal_alert_cnt = 0
-    self.terminal_time = 0
-    self.step_change = 0.
-    self.active_policy = MonitoringPolicy.vision
-    self.driver_interacting = False
-    self.is_model_uncertain = False
-    self.hi_stds = 0
-    self.model_std_max = 0.
-    self.threshold_alert_1 = 0.
-    self.threshold_alert_2 = 0.
-    self.dcam_uncertain_cnt = 0
-    self.dcam_reset_cnt = 0
-    self.too_distracted = Params().get_bool("DriverTooDistracted")
-
-    self._reset_awareness()
-    self._set_policy(MonitoringPolicy.vision)
-
-  def _reset_awareness(self):
-    self.awareness = 1.
-    self.last_vision_awareness = 1.
-    self.last_wheeltouch_awareness = 1.
-
-  def _set_policy(self, target_policy):
-    if self.active_policy == MonitoringPolicy.vision and self.awareness <= self.threshold_alert_2:
-      if target_policy == MonitoringPolicy.vision:
-        self.step_change = DT_DMON / self.settings._VISION_POLICY_ALERT_3_TIMEOUT
-      else:
-        self.step_change = 0.
-      return  # no exploit after orange alert
-    elif self.awareness <= 0.:
-      return
-
-    if target_policy == MonitoringPolicy.vision:
-      # when falling back from passive mode to active mode, reset awareness to avoid false alert
-      if self.active_policy != MonitoringPolicy.vision:
-        self.last_wheeltouch_awareness = self.awareness
-        self.awareness = self.last_vision_awareness
-
-      self.threshold_alert_1 = 1. - self.settings._VISION_POLICY_ALERT_1_TIMEOUT / self.settings._VISION_POLICY_ALERT_3_TIMEOUT
-      self.threshold_alert_2 = 1. - self.settings._VISION_POLICY_ALERT_2_TIMEOUT / self.settings._VISION_POLICY_ALERT_3_TIMEOUT
-      self.step_change = DT_DMON / self.settings._VISION_POLICY_ALERT_3_TIMEOUT
-      self.active_policy = MonitoringPolicy.vision
-    else:
-      if self.active_policy == MonitoringPolicy.vision:
-        self.last_vision_awareness = self.awareness
-        self.awareness = self.last_wheeltouch_awareness
-
-      self.threshold_alert_1 = 1. - self.settings._WHEELTOUCH_POLICY_ALERT_1_TIMEOUT / self.settings._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT
-      self.threshold_alert_2 = 1. - self.settings._WHEELTOUCH_POLICY_ALERT_2_TIMEOUT / self.settings._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT
-      self.step_change = DT_DMON / self.settings._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT
-      self.active_policy = MonitoringPolicy.wheeltouch
-
-  def _set_pose_strictness(self, brake_disengage_prob, car_speed):
-    bp = brake_disengage_prob
-    k1 = max(-0.00156*((car_speed-16)**2)+0.6, 0.2)
-    bp_normal = max(min(bp / k1, 0.5),0)
-    self.pose.cfactor_pitch = np.interp(bp_normal, [0, 0.5],
-                                           [self.settings._POSE_PITCH_THRESHOLD_SLACK,
-                                            self.settings._POSE_PITCH_THRESHOLD_STRICT]) / self.settings._POSE_PITCH_THRESHOLD
-    self.pose.cfactor_yaw = np.interp(bp_normal, [0, 0.5],
-                                           [self.settings._POSE_YAW_THRESHOLD_SLACK,
-                                            self.settings._POSE_YAW_THRESHOLD_STRICT]) / self.settings._POSE_YAW_THRESHOLD
-
-  def _get_distracted_types(self):
-    self.distracted_types = defaultdict(bool)
-
-    if not self.pose.calibrated:
-      pitch_error = self.pose.pitch - self.settings._PITCH_NATURAL_OFFSET
-      yaw_error = self.pose.yaw - self.settings._YAW_NATURAL_OFFSET
-    else:
-      pitch_error = self.pose.pitch - min(max(self.pose.pitch_offsetter.filtered_stat.mean(),
-                                                       self.settings._PITCH_MIN_OFFSET), self.settings._PITCH_MAX_OFFSET)
-      yaw_error = self.pose.yaw - min(max(self.pose.yaw_offsetter.filtered_stat.mean(),
-                                                    self.settings._YAW_MIN_OFFSET), self.settings._YAW_MAX_OFFSET)
-    pitch_error = 0 if pitch_error > 0 else abs(pitch_error) # no positive pitch limit
-
-    if yaw_error * self.pose.steer_yaw_offset > 0: # unidirectional
-      yaw_error = max(abs(yaw_error) - min(abs(self.pose.steer_yaw_offset), self.settings._POSE_YAW_STEER_MAX_OFFSET), 0.)
-    else:
-      yaw_error = abs(yaw_error)
-
-    pitch_threshold = self.settings._POSE_PITCH_THRESHOLD * self.pose.cfactor_pitch if self.pose.calibrated else self.settings._PITCH_NATURAL_THRESHOLD
-    yaw_threshold = self.settings._POSE_YAW_THRESHOLD * self.pose.cfactor_yaw
-
-    self.distracted_types['pose'] = bool((pitch_error > pitch_threshold) or (yaw_error > yaw_threshold))
-    self.distracted_types['eye'] = bool(self.blink_prob > self.settings._BLINK_THRESHOLD)
-    self.distracted_types['phone'] = bool(self.phone_prob > self.settings._PHONE_THRESH)
-
-  def _update_states(self, driver_state, cal_rpy, car_speed, op_engaged, standstill, demo_mode=False, steering_angle_deg=0.):
-    rhd_pred = driver_state.wheelOnRightProb
-    # calibrates only when there's movement and either face detected
-    if car_speed > self.settings._WHEELPOS_CALIB_MIN_SPEED and (driver_state.leftDriverData.faceProb > self.settings._FACE_THRESHOLD or
-                                          driver_state.rightDriverData.faceProb > self.settings._FACE_THRESHOLD):
-      self.wheelpos_offsetter.push_and_update(rhd_pred)
-
-    wheelpos_calibrated = self.wheelpos_offsetter.filtered_stat.n >= self.settings._WHEELPOS_FILTER_MIN_COUNT
-
-    if wheelpos_calibrated or demo_mode:
-      self.wheel_on_right = self.wheelpos_offsetter.filtered_stat.M > self.settings._WHEELPOS_THRESHOLD
-    else:
-      self.wheel_on_right = self.wheel_on_right_default # use default/saved if calibration is unfinished
-    # make sure no switching when engaged
-    if op_engaged and self.wheel_on_right_last is not None and self.wheel_on_right_last != self.wheel_on_right and not demo_mode:
-      self.wheel_on_right = self.wheel_on_right_last
-    driver_data = driver_state.rightDriverData if self.wheel_on_right else driver_state.leftDriverData
-    if not all(len(x) > 0 for x in (driver_data.faceOrientation, driver_data.facePosition,
-                                    driver_data.faceOrientationStd, driver_data.facePositionStd)):
-      return
-
-    self.face_detected = driver_data.faceProb > self.settings._FACE_THRESHOLD
-    self.pose.pitch, self.pose.yaw = face_orientation_from_model(driver_data.faceOrientation, driver_data.facePosition, cal_rpy)
-    steer_d = max(abs(steering_angle_deg) - self.settings._POSE_YAW_MIN_STEER_DEG, 0.)
-    self.pose.steer_yaw_offset = radians(steer_d) * -np.sign(steering_angle_deg) * self.settings._POSE_YAW_STEER_FACTOR
-    if self.wheel_on_right:
-      self.pose.yaw *= -1
-      self.pose.steer_yaw_offset *= -1
-    self.wheel_on_right_last = self.wheel_on_right
-    self.model_std_max = max(driver_data.faceOrientationStd[0], driver_data.faceOrientationStd[1])
-    self.pose.low_std = self.model_std_max < self.settings._HI_STD_THRESHOLD
-    self.blink_prob = driver_data.eyesClosedProb * (driver_data.eyesVisibleProb > self.settings._EYE_THRESHOLD)
-    self.phone_prob = driver_data.phoneProb
-
-    self._get_distracted_types()
-    self.driver_distracted = any(self.distracted_types.values()) and driver_data.faceProb > self.settings._FACE_THRESHOLD and self.pose.low_std
-    self.driver_distraction_filter.update(self.driver_distracted)
-
-    # only update offsetter when driver is actively driving the car above a certain speed
-    if self.face_detected and car_speed > self.settings._POSE_CALIB_MIN_SPEED and self.pose.low_std and (not op_engaged or not self.driver_distracted):
-      self.pose.pitch_offsetter.push_and_update(self.pose.pitch)
-      self.pose.yaw_offsetter.push_and_update(self.pose.yaw)
-
-    self.pose.calibrated = self.pose.pitch_offsetter.filtered_stat.n >= self.settings._POSE_OFFSET_MIN_COUNT and \
-                           self.pose.yaw_offsetter.filtered_stat.n >= self.settings._POSE_OFFSET_MIN_COUNT
-
-    if self.face_detected and not self.driver_distracted:
-      dcam_uncertain = self.model_std_max > self.settings._DCAM_UNCERTAIN_ALERT_THRESHOLD
-      if dcam_uncertain and not standstill:
-        self.dcam_uncertain_cnt += 1
-        self.dcam_reset_cnt = 0
-      else:
-        self.dcam_reset_cnt += 1
-        if self.dcam_reset_cnt > self.settings._DCAM_UNCERTAIN_RESET_COUNT:
-          self.dcam_uncertain_cnt = 0
-
-    self.is_model_uncertain = self.hi_stds >= self.settings._HI_STD_FALLBACK_TIME
-    self._set_policy(MonitoringPolicy.vision if self.face_detected and not self.is_model_uncertain else MonitoringPolicy.wheeltouch)
-    if self.face_detected and not self.pose.low_std and not self.driver_distracted:
-      self.hi_stds += 1
-    elif self.face_detected and self.pose.low_std:
-      self.hi_stds = 0
-
-  def _update_events(self, driver_engaged, op_engaged, standstill, wrong_gear):
-    self.alert_level = AlertLevel.none
-    self.driver_interacting = driver_engaged
-
-    if self.terminal_alert_cnt >= self.settings._MAX_TERMINAL_ALERTS or \
-       self.terminal_time >= self.settings._MAX_TERMINAL_DURATION:
-      self.too_distracted = True
-
-    always_on_valid = self.always_on and not wrong_gear
-    if (self.driver_interacting and self.awareness > 0 and self.active_policy == MonitoringPolicy.wheeltouch) or \
-       (not always_on_valid and not op_engaged) or \
-       (always_on_valid and not op_engaged and self.awareness <= 0):
-      # always reset on disengage with normal mode; disengage resets only on red if always on
-      self._reset_awareness()
-      return
-
-    awareness_prev = self.awareness
-    _reaching_alert_1 = self.awareness - self.step_change <= self.threshold_alert_1
-    _reaching_alert_3 = self.awareness - self.step_change <= 0
-    standstill_exemption = standstill and _reaching_alert_1
-    always_on_exemption = always_on_valid and not op_engaged and _reaching_alert_3
-
-    if self.awareness > 0 and \
-       ((self.driver_distraction_filter.x < 0.37 and self.face_detected and self.pose.low_std) or standstill_exemption):
-      if self.driver_interacting:
-        self._reset_awareness()
-        return
-      # only restore awareness when paying attention and alert is not red
-      self.awareness = min(self.awareness + ((self.settings._TIMEOUT_RECOVERY_FACTOR_MAX-self.settings._TIMEOUT_RECOVERY_FACTOR_MIN)*
-                                             (1.-self.awareness)+self.settings._TIMEOUT_RECOVERY_FACTOR_MIN)*self.step_change, 1.)
-      if self.awareness == 1.:
-        self.last_wheeltouch_awareness = min(self.last_wheeltouch_awareness + self.step_change, 1.)
-      # don't display alert banner when awareness is recovering and has cleared orange
-      if self.awareness > self.threshold_alert_2:
-        return
-
-    certainly_distracted = self.driver_distraction_filter.x > 0.63 and self.driver_distracted and self.face_detected
-    maybe_distracted = self.is_model_uncertain or not self.face_detected
-
-    if certainly_distracted or maybe_distracted:
-      # should always be counting if distracted unless at standstill and reaching green
-      # also will not be reaching 0 if DM is active when not engaged
-      if not (standstill_exemption or always_on_exemption):
-        self.awareness = max(self.awareness - self.step_change, -0.1)
-
-    if self.awareness <= 0.:
-      # terminal alert: disengagement required
-      self.alert_level = AlertLevel.three
-      self.terminal_time += 1
-      if awareness_prev > 0.:
-        self.terminal_alert_cnt += 1
-    elif self.awareness <= self.threshold_alert_2:
-      self.alert_level = AlertLevel.two
-    elif self.awareness <= self.threshold_alert_1:
-      self.alert_level = AlertLevel.one
-
-  def get_state_packet(self, valid=True):
-    # build driverMonitoringState packet
-    dat = messaging.new_message('driverMonitoringState', valid=valid)
-    dm = dat.driverMonitoringState
-
-    dm.lockout = self.too_distracted
-    dm.alertCountLockoutPercent = to_percent(self.terminal_alert_cnt / self.settings._MAX_TERMINAL_ALERTS)
-    dm.alertTimeLockoutPercent = to_percent(self.terminal_time / self.settings._MAX_TERMINAL_DURATION)
-    dm.alwaysOn = self.always_on
-    dm.alwaysOnLockout = self.always_on and self.awareness <= self.threshold_alert_2
-    dm.alertLevel = self.alert_level
-    dm.activePolicy = self.active_policy
-    dm.isRHD = self.wheel_on_right
-    dm.rhdCalibration.calibratedPercent = to_percent(self.wheelpos_offsetter.filtered_stat.n / self.settings._WHEELPOS_FILTER_MIN_COUNT)
-    dm.rhdCalibration.offset = self.wheelpos_offsetter.filtered_stat.M
-
-    dm.visionPolicyState.awarenessPercent = to_percent(self.last_vision_awareness if self.active_policy != MonitoringPolicy.vision else self.awareness)
-    dm.visionPolicyState.awarenessStep = self.step_change if self.active_policy == MonitoringPolicy.vision else 0.
-    dm.visionPolicyState.isDistracted = self.driver_distracted
-    dm.visionPolicyState.distractedTypes.pose = self.distracted_types['pose']
-    dm.visionPolicyState.distractedTypes.eye = self.distracted_types['eye']
-    dm.visionPolicyState.distractedTypes.phone = self.distracted_types['phone']
-    dm.visionPolicyState.faceDetected = self.face_detected
-    dm.visionPolicyState.pose.pitch = self.pose.pitch
-    dm.visionPolicyState.pose.yaw = self.pose.yaw
-    dm.visionPolicyState.pose.calibrated = self.pose.calibrated
-    dm.visionPolicyState.pose.pitchCalib.calibratedPercent = to_percent(self.pose.pitch_offsetter.filtered_stat.n / self.settings._POSE_OFFSET_MIN_COUNT)
-    dm.visionPolicyState.pose.pitchCalib.offset = self.pose.pitch_offsetter.filtered_stat.M
-    dm.visionPolicyState.pose.yawCalib.calibratedPercent = to_percent(self.pose.yaw_offsetter.filtered_stat.n / self.settings._POSE_OFFSET_MIN_COUNT)
-    dm.visionPolicyState.pose.yawCalib.offset = self.pose.yaw_offsetter.filtered_stat.M
-    dm.visionPolicyState.pose.uncertainty = self.model_std_max
-    dm.visionPolicyState.wheeltouchFallbackPercent = to_percent(self.hi_stds / self.settings._HI_STD_FALLBACK_TIME)
-    dm.visionPolicyState.uncertainOffroadAlertPercent = to_percent(self.dcam_uncertain_cnt / self.settings._DCAM_UNCERTAIN_ALERT_COUNT)
-
-    dm.wheeltouchPolicyState.awarenessPercent = to_percent(self.last_wheeltouch_awareness if self.active_policy == MonitoringPolicy.vision else self.awareness)
-    dm.wheeltouchPolicyState.awarenessStep = 0. if self.active_policy == MonitoringPolicy.vision else self.step_change
-    dm.wheeltouchPolicyState.driverInteracting = self.driver_interacting
-    return dat
-
-  def run_step(self, sm, demo=False):
-    if demo:
-      car_speed = 30
-      enabled = True
-      wrong_gear = False
-      standstill = False
-      driver_engaged = False
-      brake_disengage_prob = 1.0
-      steering_angle_deg = 0.0
-      rpyCalib = [0., 0., 0.]
-    else:
-      car_speed = sm['carState'].vEgo
-      enabled = sm['selfdriveState'].enabled or sm['carControl'].latActive
-      wrong_gear = sm['carState'].gearShifter not in (car.CarState.GearShifter.drive, car.CarState.GearShifter.low)
-      standstill = sm['carState'].standstill
-      driver_engaged = sm['carState'].steeringPressed or sm['carState'].gasPressed
-      brake_disengage_prob = sm['modelV2'].meta.disengagePredictions.brakeDisengageProbs[0] # brake disengage prob in next 2s
-      steering_angle_deg = sm['carState'].steeringAngleDeg
-      rpyCalib = sm['liveCalibration'].rpyCalib
-
-    self._set_pose_strictness(
-      brake_disengage_prob=brake_disengage_prob,
-      car_speed=car_speed,
-    )
-
-    # Parse data from dmonitoringmodeld
-    self._update_states(
-      driver_state=sm['driverStateV2'],
-      cal_rpy=rpyCalib,
-      car_speed=car_speed,
-      op_engaged=enabled,
-      standstill=standstill,
-      demo_mode=demo,
-      steering_angle_deg=steering_angle_deg,
-    )
-
-    # Update distraction events
-    self._update_events(
-      driver_engaged=driver_engaged,
-      op_engaged=enabled,
-      standstill=standstill,
-      wrong_gear=wrong_gear,
-    )

selfdrive/monitoring/test_monitoring.py

@@ -3,16 +3,17 @@ import pytest
 
 from cereal import log, car
 from openpilot.common.realtime import DT_DMON
-from openpilot.selfdrive.monitoring.policy import DriverMonitoring, DRIVER_MONITOR_SETTINGS
+from openpilot.selfdrive.monitoring.helpers import DriverMonitoring, DRIVER_MONITOR_SETTINGS
+from openpilot.system.hardware import HARDWARE
 
 EventName = log.OnroadEvent.EventName
-dm_settings = DRIVER_MONITOR_SETTINGS()
+dm_settings = DRIVER_MONITOR_SETTINGS(device_type=HARDWARE.get_device_type())
 
 TEST_TIMESPAN = 120  # seconds
-DISTRACTED_SECONDS_TO_ORANGE = dm_settings._VISION_POLICY_ALERT_2_TIMEOUT + 1
-DISTRACTED_SECONDS_TO_RED = dm_settings._VISION_POLICY_ALERT_3_TIMEOUT + 1
-INVISIBLE_SECONDS_TO_ORANGE = dm_settings._WHEELTOUCH_POLICY_ALERT_2_TIMEOUT + 1
-INVISIBLE_SECONDS_TO_RED = dm_settings._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT + 1
+DISTRACTED_SECONDS_TO_ORANGE = dm_settings._DISTRACTED_TIME - dm_settings._DISTRACTED_PROMPT_TIME_TILL_TERMINAL + 1
+DISTRACTED_SECONDS_TO_RED = dm_settings._DISTRACTED_TIME + 1
+INVISIBLE_SECONDS_TO_ORANGE = dm_settings._AWARENESS_TIME - dm_settings._AWARENESS_PROMPT_TIME_TILL_TERMINAL + 1
+INVISIBLE_SECONDS_TO_RED = dm_settings._AWARENESS_TIME + 1
 
 def make_msg(face_detected, distracted=False, model_uncertain=False):
   ds = log.DriverStateV2.new_message()
@@ -34,7 +35,7 @@ msg_ATTENTIVE = make_msg(True)
 msg_DISTRACTED = make_msg(True, distracted=True)
 msg_ATTENTIVE_UNCERTAIN = make_msg(True, model_uncertain=True)
 msg_DISTRACTED_UNCERTAIN = make_msg(True, distracted=True, model_uncertain=True)
-msg_DISTRACTED_BUT_SOMEHOW_UNCERTAIN = make_msg(True, distracted=True, model_uncertain=dm_settings._HI_STD_THRESHOLD*1.5)
+msg_DISTRACTED_BUT_SOMEHOW_UNCERTAIN = make_msg(True, distracted=True, model_uncertain=dm_settings._POSESTD_THRESHOLD*1.5)
 
 # driver interaction with car
 car_interaction_DETECTED = True
@@ -50,49 +51,49 @@ always_false = [False] * int(TEST_TIMESPAN / DT_DMON)
 class TestMonitoring:
   def _run_seq(self, msgs, interaction, engaged, standstill):
     DM = DriverMonitoring()
-    alert_lvls = []
+    events = []
     for idx in range(len(msgs)):
       DM._update_states(msgs[idx], [0, 0, 0], 0, engaged[idx], standstill[idx])
       # cal_rpy and car_speed don't matter here
 
       # evaluate events at 10Hz for tests
-      DM._update_events(interaction[idx], engaged[idx], standstill[idx], 0)
-      alert_lvls.append(DM.alert_level)
-    assert len(alert_lvls) == len(msgs), f"got {len(alert_lvls)} for {len(msgs)} driverState input msgs"
-    return alert_lvls, DM
+      DM._update_events(interaction[idx], engaged[idx], standstill[idx], 0, 0)
+      events.append(DM.current_events)
+    assert len(events) == len(msgs), f"got {len(events)} for {len(msgs)} driverState input msgs"
+    return events, DM
 
+  def _assert_no_events(self, events):
+    assert all(not len(e) for e in events)
 
   # engaged, driver is attentive all the time
   def test_fully_aware_driver(self):
-    alert_lvls, d_status = self._run_seq(always_attentive, always_false, always_true, always_false)
-    assert all(a == 0 for a in alert_lvls)
-    assert d_status.active_policy == log.DriverMonitoringState.MonitoringPolicy.vision
+    events, _ = self._run_seq(always_attentive, always_false, always_true, always_false)
+    self._assert_no_events(events)
 
   # engaged, driver is distracted and does nothing
   def test_fully_distracted_driver(self):
-    alert_lvls, d_status = self._run_seq(always_distracted, always_false, always_true, always_false)
-    s = d_status.settings
-    assert alert_lvls[int(s._VISION_POLICY_ALERT_1_TIMEOUT / 2 / DT_DMON)] == 0
-    assert alert_lvls[int((s._VISION_POLICY_ALERT_1_TIMEOUT + \
-                    (s._VISION_POLICY_ALERT_2_TIMEOUT - s._VISION_POLICY_ALERT_1_TIMEOUT) / 2) / DT_DMON)] == 1
-    assert alert_lvls[int((s._VISION_POLICY_ALERT_2_TIMEOUT + \
-                    (s._VISION_POLICY_ALERT_3_TIMEOUT - s._VISION_POLICY_ALERT_2_TIMEOUT) / 2) / DT_DMON)] == 2
-    assert alert_lvls[int((s._VISION_POLICY_ALERT_3_TIMEOUT + \
-                    (TEST_TIMESPAN - 10 - s._VISION_POLICY_ALERT_3_TIMEOUT) / 2) / DT_DMON)] == 3
+    events, d_status = self._run_seq(always_distracted, always_false, always_true, always_false)
+    assert len(events[int((d_status.settings._DISTRACTED_TIME-d_status.settings._DISTRACTED_PRE_TIME_TILL_TERMINAL)/2/DT_DMON)]) == 0
+    assert events[int((d_status.settings._DISTRACTED_TIME-d_status.settings._DISTRACTED_PRE_TIME_TILL_TERMINAL + \
+                    ((d_status.settings._DISTRACTED_PRE_TIME_TILL_TERMINAL-d_status.settings._DISTRACTED_PROMPT_TIME_TILL_TERMINAL)/2))/DT_DMON)].names[0] == \
+                    EventName.driverDistracted1
+    assert events[int((d_status.settings._DISTRACTED_TIME-d_status.settings._DISTRACTED_PROMPT_TIME_TILL_TERMINAL + \
+                    ((d_status.settings._DISTRACTED_PROMPT_TIME_TILL_TERMINAL)/2))/DT_DMON)].names[0] == EventName.driverDistracted2
+    assert events[int((d_status.settings._DISTRACTED_TIME + \
+                    ((TEST_TIMESPAN-10-d_status.settings._DISTRACTED_TIME)/2))/DT_DMON)].names[0] == EventName.driverDistracted3
     assert isinstance(d_status.awareness, float)
 
   # engaged, no face detected the whole time, no action
   def test_fully_invisible_driver(self):
-    alert_lvls, d_status = self._run_seq(always_no_face, always_false, always_true, always_false)
-    s = d_status.settings
-    assert alert_lvls[int(s._WHEELTOUCH_POLICY_ALERT_1_TIMEOUT / 2 / DT_DMON)] == 0
-    assert alert_lvls[int((s._WHEELTOUCH_POLICY_ALERT_1_TIMEOUT + \
-                    (s._WHEELTOUCH_POLICY_ALERT_2_TIMEOUT - s._WHEELTOUCH_POLICY_ALERT_1_TIMEOUT) / 2) / DT_DMON)] == 1
-    assert alert_lvls[int((s._WHEELTOUCH_POLICY_ALERT_2_TIMEOUT + \
-                    (s._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT - s._WHEELTOUCH_POLICY_ALERT_2_TIMEOUT) / 2) / DT_DMON)] == 2
-    assert alert_lvls[int((s._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT + \
-                    (TEST_TIMESPAN - 10 - s._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT) / 2) / DT_DMON)] == 3
-    assert d_status.active_policy == log.DriverMonitoringState.MonitoringPolicy.wheeltouch
+    events, d_status = self._run_seq(always_no_face, always_false, always_true, always_false)
+    assert len(events[int((d_status.settings._AWARENESS_TIME-d_status.settings._AWARENESS_PRE_TIME_TILL_TERMINAL)/2/DT_DMON)]) == 0
+    assert events[int((d_status.settings._AWARENESS_TIME-d_status.settings._AWARENESS_PRE_TIME_TILL_TERMINAL + \
+                      ((d_status.settings._AWARENESS_PRE_TIME_TILL_TERMINAL-d_status.settings._AWARENESS_PROMPT_TIME_TILL_TERMINAL)/2))/DT_DMON)].names[0] == \
+                      EventName.driverUnresponsive1
+    assert events[int((d_status.settings._AWARENESS_TIME-d_status.settings._AWARENESS_PROMPT_TIME_TILL_TERMINAL + \
+                      ((d_status.settings._AWARENESS_PROMPT_TIME_TILL_TERMINAL)/2))/DT_DMON)].names[0] == EventName.driverUnresponsive2
+    assert events[int((d_status.settings._AWARENESS_TIME + \
+                      ((TEST_TIMESPAN-10-d_status.settings._AWARENESS_TIME)/2))/DT_DMON)].names[0] == EventName.driverUnresponsive3
 
   # engaged, down to orange, driver pays attention, back to normal; then down to orange, driver touches wheel
   #  - should have short orange recovery time and no green afterwards; wheel touch only recovers when paying attention
@@ -103,13 +104,13 @@ class TestMonitoring:
                 [msg_ATTENTIVE] * (int(TEST_TIMESPAN/DT_DMON)-int((DISTRACTED_SECONDS_TO_ORANGE*3+2)/DT_DMON))
     interaction_vector = [car_interaction_NOT_DETECTED] * int(DISTRACTED_SECONDS_TO_ORANGE*3/DT_DMON) + \
                          [car_interaction_DETECTED] * (int(TEST_TIMESPAN/DT_DMON)-int(DISTRACTED_SECONDS_TO_ORANGE*3/DT_DMON))
-    alert_lvls, _ = self._run_seq(ds_vector, interaction_vector, always_true, always_false)
-    assert alert_lvls[int(DISTRACTED_SECONDS_TO_ORANGE*0.5/DT_DMON)] == 0
-    assert alert_lvls[int((DISTRACTED_SECONDS_TO_ORANGE-0.1)/DT_DMON)] == 2
-    assert alert_lvls[int(DISTRACTED_SECONDS_TO_ORANGE*1.5/DT_DMON)] == 0
-    assert alert_lvls[int((DISTRACTED_SECONDS_TO_ORANGE*3-0.1)/DT_DMON)] == 2
-    assert alert_lvls[int((DISTRACTED_SECONDS_TO_ORANGE*3+0.1)/DT_DMON)] == 2
-    assert alert_lvls[int((DISTRACTED_SECONDS_TO_ORANGE*3+2.5)/DT_DMON)] == 0
+    events, _ = self._run_seq(ds_vector, interaction_vector, always_true, always_false)
+    assert len(events[int(DISTRACTED_SECONDS_TO_ORANGE*0.5/DT_DMON)]) == 0
+    assert events[int((DISTRACTED_SECONDS_TO_ORANGE-0.1)/DT_DMON)].names[0] == EventName.driverDistracted2
+    assert len(events[int(DISTRACTED_SECONDS_TO_ORANGE*1.5/DT_DMON)]) == 0
+    assert events[int((DISTRACTED_SECONDS_TO_ORANGE*3-0.1)/DT_DMON)].names[0] == EventName.driverDistracted2
+    assert events[int((DISTRACTED_SECONDS_TO_ORANGE*3+0.1)/DT_DMON)].names[0] == EventName.driverDistracted2
+    assert len(events[int((DISTRACTED_SECONDS_TO_ORANGE*3+2.5)/DT_DMON)]) == 0
 
   # engaged, down to orange, driver dodges camera, then comes back still distracted, down to red, \
   #                          driver dodges, and then touches wheel to no avail, disengages and reengages
@@ -127,11 +128,11 @@ class TestMonitoring:
                                                         = [True] * int(1/DT_DMON)
     op_vector[int((DISTRACTED_SECONDS_TO_RED+2*_invisible_time+2.5)/DT_DMON):int((DISTRACTED_SECONDS_TO_RED+2*_invisible_time+3)/DT_DMON)] \
                                                         = [False] * int(0.5/DT_DMON)
-    alert_lvls, _ = self._run_seq(ds_vector, interaction_vector, op_vector, always_false)
-    assert alert_lvls[int((DISTRACTED_SECONDS_TO_ORANGE+0.5*_invisible_time)/DT_DMON)] == 2
-    assert alert_lvls[int((DISTRACTED_SECONDS_TO_RED+1.5*_invisible_time)/DT_DMON)] == 3
-    assert alert_lvls[int((DISTRACTED_SECONDS_TO_RED+2*_invisible_time+1.5)/DT_DMON)] == 3
-    assert alert_lvls[int((DISTRACTED_SECONDS_TO_RED+2*_invisible_time+3.5)/DT_DMON)] == 0
+    events, _ = self._run_seq(ds_vector, interaction_vector, op_vector, always_false)
+    assert events[int((DISTRACTED_SECONDS_TO_ORANGE+0.5*_invisible_time)/DT_DMON)].names[0] == EventName.driverDistracted2
+    assert events[int((DISTRACTED_SECONDS_TO_RED+1.5*_invisible_time)/DT_DMON)].names[0] == EventName.driverDistracted3
+    assert events[int((DISTRACTED_SECONDS_TO_RED+2*_invisible_time+1.5)/DT_DMON)].names[0] == EventName.driverDistracted3
+    assert len(events[int((DISTRACTED_SECONDS_TO_RED+2*_invisible_time+3.5)/DT_DMON)]) == 0
 
   # engaged, invisible driver, down to orange, driver touches wheel; then down to orange again, driver appears
   #  - both actions should clear the alert, but momentary appearance should not
@@ -142,16 +143,16 @@ class TestMonitoring:
     ds_vector[int((2*INVISIBLE_SECONDS_TO_ORANGE+1)/DT_DMON):int((2*INVISIBLE_SECONDS_TO_ORANGE+1+_visible_time)/DT_DMON)] = \
                                                                                              [msg_ATTENTIVE] * int(_visible_time/DT_DMON)
     interaction_vector[int((INVISIBLE_SECONDS_TO_ORANGE)/DT_DMON):int((INVISIBLE_SECONDS_TO_ORANGE+1)/DT_DMON)] = [True] * int(1/DT_DMON)
-    alert_lvls, _ = self._run_seq(ds_vector, interaction_vector, 2*always_true, 2*always_false)
-    assert alert_lvls[int(INVISIBLE_SECONDS_TO_ORANGE*0.5/DT_DMON)] == 0
-    assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE-0.1)/DT_DMON)] == 2
-    assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE+0.1)/DT_DMON)] == 0
+    events, _ = self._run_seq(ds_vector, interaction_vector, 2*always_true, 2*always_false)
+    assert len(events[int(INVISIBLE_SECONDS_TO_ORANGE*0.5/DT_DMON)]) == 0
+    assert events[int((INVISIBLE_SECONDS_TO_ORANGE-0.1)/DT_DMON)].names[0] == EventName.driverUnresponsive2
+    assert len(events[int((INVISIBLE_SECONDS_TO_ORANGE+0.1)/DT_DMON)]) == 0
     if _visible_time == 0.5:
-      assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE*2+1-0.1)/DT_DMON)] == 2
-      assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE*2+1+0.1+_visible_time)/DT_DMON)] == 1
+      assert events[int((INVISIBLE_SECONDS_TO_ORANGE*2+1-0.1)/DT_DMON)].names[0] == EventName.driverUnresponsive2
+      assert events[int((INVISIBLE_SECONDS_TO_ORANGE*2+1+0.1+_visible_time)/DT_DMON)].names[0] == EventName.driverUnresponsive1
     elif _visible_time == 10:
-      assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE*2+1-0.1)/DT_DMON)] == 2
-      assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE*2+1+0.1+_visible_time)/DT_DMON)] == 0
+      assert events[int((INVISIBLE_SECONDS_TO_ORANGE*2+1-0.1)/DT_DMON)].names[0] == EventName.driverUnresponsive2
+      assert len(events[int((INVISIBLE_SECONDS_TO_ORANGE*2+1+0.1+_visible_time)/DT_DMON)]) == 0
 
   # engaged, invisible driver, down to red, driver appears and then touches wheel, then disengages/reengages
   #  - only disengage will clear the alert
@@ -163,19 +164,19 @@ class TestMonitoring:
     ds_vector[int(INVISIBLE_SECONDS_TO_RED/DT_DMON):int((INVISIBLE_SECONDS_TO_RED+_visible_time)/DT_DMON)] = [msg_ATTENTIVE] * int(_visible_time/DT_DMON)
     interaction_vector[int((INVISIBLE_SECONDS_TO_RED+_visible_time)/DT_DMON):int((INVISIBLE_SECONDS_TO_RED+_visible_time+1)/DT_DMON)] = [True] * int(1/DT_DMON)
     op_vector[int((INVISIBLE_SECONDS_TO_RED+_visible_time+1)/DT_DMON):int((INVISIBLE_SECONDS_TO_RED+_visible_time+0.5)/DT_DMON)] = [False] * int(0.5/DT_DMON)
-    alert_lvls, _ = self._run_seq(ds_vector, interaction_vector, op_vector, always_false)
-    assert alert_lvls[int(INVISIBLE_SECONDS_TO_ORANGE*0.5/DT_DMON)] == 0
-    assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE-0.1)/DT_DMON)] == 2
-    assert alert_lvls[int((INVISIBLE_SECONDS_TO_RED-0.1)/DT_DMON)] == 3
-    assert alert_lvls[int((INVISIBLE_SECONDS_TO_RED+0.5*_visible_time)/DT_DMON)] == 3
-    assert alert_lvls[int((INVISIBLE_SECONDS_TO_RED+_visible_time+0.5)/DT_DMON)] == 3
-    assert alert_lvls[int((INVISIBLE_SECONDS_TO_RED+_visible_time+1+0.1)/DT_DMON)] == 0
+    events, _ = self._run_seq(ds_vector, interaction_vector, op_vector, always_false)
+    assert len(events[int(INVISIBLE_SECONDS_TO_ORANGE*0.5/DT_DMON)]) == 0
+    assert events[int((INVISIBLE_SECONDS_TO_ORANGE-0.1)/DT_DMON)].names[0] == EventName.driverUnresponsive2
+    assert events[int((INVISIBLE_SECONDS_TO_RED-0.1)/DT_DMON)].names[0] == EventName.driverUnresponsive3
+    assert events[int((INVISIBLE_SECONDS_TO_RED+0.5*_visible_time)/DT_DMON)].names[0] == EventName.driverUnresponsive3
+    assert events[int((INVISIBLE_SECONDS_TO_RED+_visible_time+0.5)/DT_DMON)].names[0] == EventName.driverUnresponsive3
+    assert len(events[int((INVISIBLE_SECONDS_TO_RED+_visible_time+1+0.1)/DT_DMON)]) == 0
 
   # disengaged, always distracted driver
   #  - dm should stay quiet when not engaged
   def test_pure_dashcam_user(self):
-    alert_lvls, _ = self._run_seq(always_distracted, always_false, always_false, always_false)
-    assert all(a == 0 for a in alert_lvls)
+    events, _ = self._run_seq(always_distracted, always_false, always_false, always_false)
+    assert sum(len(event) for event in events) == 0
 
   # engaged, car stops at traffic light, down to orange, no action, then car starts moving
   #  - should only reach green when stopped, but continues counting down on launch
@@ -183,12 +184,11 @@ class TestMonitoring:
     _redlight_time = 60  # seconds
     standstill_vector = always_true[:]
     standstill_vector[int(_redlight_time/DT_DMON):] = [False] * int((TEST_TIMESPAN-_redlight_time)/DT_DMON)
-    alert_lvls, d_status = self._run_seq(always_distracted, always_false, always_true, standstill_vector)
-    s = d_status.settings
-    assert alert_lvls[int((_redlight_time-0.1)/DT_DMON)] == 0
-    _alert_1_to_2 = s._VISION_POLICY_ALERT_2_TIMEOUT - s._VISION_POLICY_ALERT_1_TIMEOUT
-    assert alert_lvls[int((_redlight_time+0.5)/DT_DMON)] == 1
-    assert alert_lvls[int((_redlight_time+_alert_1_to_2+0.5)/DT_DMON)] == 2
+    events, d_status = self._run_seq(always_distracted, always_false, always_true, standstill_vector)
+    assert len(events[int((_redlight_time-0.1)/DT_DMON)]) == 0
+    _pre_to_prompt = d_status.settings._DISTRACTED_PRE_TIME_TILL_TERMINAL - d_status.settings._DISTRACTED_PROMPT_TIME_TILL_TERMINAL
+    assert events[int((_redlight_time+0.5)/DT_DMON)].names[0] == EventName.driverDistracted1
+    assert events[int((_redlight_time+_pre_to_prompt+0.5)/DT_DMON)].names[0] == EventName.driverDistracted2
 
   # engaged, distracted while moving, then car stops after reaching orange
   #  - should reset timer to pre green at standstill
@@ -196,81 +196,67 @@ class TestMonitoring:
     _stop_time = DISTRACTED_SECONDS_TO_ORANGE + 1  # stop 1 second after reaching orange
     standstill_vector = always_false[:]
     standstill_vector[int(_stop_time/DT_DMON):] = [True] * int((TEST_TIMESPAN-_stop_time)/DT_DMON)
-    alert_lvls, _ = self._run_seq(always_distracted, always_false, always_true, standstill_vector)
+    events, _ = self._run_seq(always_distracted, always_false, always_true, standstill_vector)
     # just before and briefly after stopping: orange alert; goes away quickly after stopped
-    assert alert_lvls[int((_stop_time+0.1)/DT_DMON)] == 2
-    assert alert_lvls[int((_stop_time+0.5)/DT_DMON)] == 0
+    assert events[int((_stop_time+0.1)/DT_DMON)].names[0] == EventName.driverDistracted2
+    assert len(events[int((_stop_time+0.5)/DT_DMON)]) == 0
 
   # engaged, model is somehow uncertain and driver is distracted
   #  - should fall back to wheel touch after uncertain alert
   def test_somehow_indecisive_model(self):
     ds_vector = [msg_DISTRACTED_BUT_SOMEHOW_UNCERTAIN] * int(TEST_TIMESPAN/DT_DMON)
     interaction_vector = always_false[:]
-    alert_lvls, d_status = self._run_seq(ds_vector, interaction_vector, always_true, always_false)
-    s = d_status.settings
-    assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE-1+DT_DMON*s._HI_STD_FALLBACK_TIME-0.1)/DT_DMON)] == 1
-    assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE-1+DT_DMON*s._HI_STD_FALLBACK_TIME+0.1)/DT_DMON)] == 2
-    assert alert_lvls[int((INVISIBLE_SECONDS_TO_RED-1+DT_DMON*s._HI_STD_FALLBACK_TIME+0.1)/DT_DMON)] == 3
+    events, d_status = self._run_seq(ds_vector, interaction_vector, always_true, always_false)
+    assert EventName.driverUnresponsive1 in \
+                              events[int((INVISIBLE_SECONDS_TO_ORANGE-1+DT_DMON*d_status.settings._HI_STD_FALLBACK_TIME-0.1)/DT_DMON)].names
+    assert EventName.driverUnresponsive2 in \
+                              events[int((INVISIBLE_SECONDS_TO_ORANGE-1+DT_DMON*d_status.settings._HI_STD_FALLBACK_TIME+0.1)/DT_DMON)].names
+    assert EventName.driverUnresponsive3 in \
+                              events[int((INVISIBLE_SECONDS_TO_RED-1+DT_DMON*d_status.settings._HI_STD_FALLBACK_TIME+0.1)/DT_DMON)].names
 
 
-@pytest.mark.parametrize("enabled_state, lat_active_state, expected", [
-  (False, False, False), # Both Disabled
-  (True, False, True),   # OP Enabled, Lat Inactive
-  (False, True, True),   # OP Disabled, Lat Active (e.g. MADS)
-  (True, True, True)     # Both Active
-])
-def test_enabled_states(enabled_state, lat_active_state, expected):
-  """
-  Test DriverMonitoring.run_step with all 4 combinations of:
-  - selfdriveState.enabled (True/False)
-  - carControl.latActive (True/False)
-  """
+def _build_sm(selfdrive_enabled, lat_active, steering_pressed, gas_pressed):
   cs = car.CarState.new_message()
   cs.vEgo = 30.0
   cs.gearShifter = car.CarState.GearShifter.drive
-  cs.standstill = False
-  cs.steeringPressed = False
-  cs.gasPressed = False
-
+  cs.steeringPressed = steering_pressed
+  cs.gasPressed = gas_pressed
   ss = log.SelfdriveState.new_message()
-  ss.enabled = enabled_state
-
+  ss.enabled = selfdrive_enabled
   cc = car.CarControl.new_message()
-  cc.latActive = lat_active_state
-
+  cc.latActive = lat_active
   mv2 = log.ModelDataV2.new_message()
   mv2.meta.disengagePredictions.brakeDisengageProbs = [0.0]
-
   lc = log.LiveCalibrationData.new_message()
   lc.rpyCalib = [0.0, 0.0, 0.0]
-
-  ds = make_msg(False)
-
-  sm = {
-    'carState': cs,
-    'selfdriveState': ss,
-    'carControl': cc,
-    'modelV2': mv2,
-    'liveCalibration': lc,
-    'driverStateV2': ds
+  return {
+    'carState': cs, 'selfdriveState': ss, 'carControl': cc,
+    'modelV2': mv2, 'liveCalibration': lc, 'driverStateV2': make_msg(False),
   }
 
-  driver_monitoring = DriverMonitoring()
 
-  # run_test doesn't assign enabled to a variable, so we need to spy on _update_events to see its value
-  captured_args = []
-  original_update_events = driver_monitoring._update_events
+@pytest.mark.parametrize("selfdrive_enabled, lat_active, steering, gas, expected_op_engaged, expected_driver_engaged", [
+  (False, False, False, False, False, False),  # disabled
+  (True,  False, False, False, True,  False),  # OP enabled
+  (False, True,  False, False, True,  False),  # MADS lat-only
+  (True,  True,  False, False, True,  False),  # both active
+  (False, True,  False, True,  True,  False),  # MADS lat-only + gas
+  (True,  True,  False, True,  True,  True),   # full op + gas: override
+  (False, True,  True,  False, True,  True),   # MADS lat-only + wheel touch: override
+])
+def test_run_step_engagement(selfdrive_enabled, lat_active, steering, gas,
+                             expected_op_engaged, expected_driver_engaged):
+  sm = _build_sm(selfdrive_enabled, lat_active, steering, gas)
+  dm = DriverMonitoring()
+  captured = {}
+  orig = dm._update_events
 
-  def spy_update_events(driver_engaged, op_engaged, standstill, wrong_gear):
-    captured_args.append(op_engaged)
-    return original_update_events(driver_engaged, op_engaged, standstill, wrong_gear)
+  def spy(driver_engaged, op_engaged, standstill, wrong_gear, car_speed):
+    captured['driver_engaged'] = driver_engaged
+    captured['op_engaged'] = op_engaged
+    return orig(driver_engaged, op_engaged, standstill, wrong_gear, car_speed)
 
-  driver_monitoring._update_events = spy_update_events
-
-  driver_monitoring.run_step(sm, demo=False)
-
-  # Assertion
-  assert len(captured_args) == 1, "Expected _update_events to be called exactly once"
-  actual_enabled = captured_args[0]
-
-  assert actual_enabled == expected, f"Expected op_engaged={expected}, but got {actual_enabled}"
+  dm._update_events = spy
+  dm.run_step(sm, demo=False)
+  assert captured['op_engaged'] == expected_op_engaged
+  assert captured['driver_engaged'] == expected_driver_engaged

selfdrive/selfdrived/selfdrived.py

@@ -45,8 +45,6 @@ LaneChangeDirection = log.LaneChangeDirection
 EventName = log.OnroadEvent.EventName
 ButtonType = car.CarState.ButtonEvent.Type
 SafetyModel = car.CarParams.SafetyModel
-AlertLevel = log.DriverMonitoringState.AlertLevel
-MonitoringPolicy = log.DriverMonitoringState.MonitoringPolicy
 TurnDirection = custom.ModelDataV2SP.TurnDirection
 
 IGNORED_SAFETY_MODES = (SafetyModel.silent, SafetyModel.noOutput)
@@ -142,8 +140,6 @@ class SelfdriveD(CruiseHelper):
       self.params
     )
     self.recalibrating_seen = False
-    self.dm_lockout_set = False
-    self.dm_uncertain_alerted = False
     self.state_machine = StateMachine()
     self.rk = Ratekeeper(100, print_delay_threshold=None)
 
@@ -220,27 +216,8 @@ class SelfdriveD(CruiseHelper):
     if not self.CP.pcmCruise and CS.vCruise > 250 and resume_pressed:
       self.events.add(EventName.resumeBlocked)
 
-    # Handle DM
     if not self.CP.notCar:
-      # Block engaging until ignition cycle after max number or time of distractions
-      if self.sm['driverMonitoringState'].lockout and not self.dm_lockout_set:
-        self.params.put_bool_nonblocking("DriverTooDistracted", True)
-        self.dm_lockout_set = True
-      # No entry conditions
-      if self.sm['driverMonitoringState'].lockout or self.sm['driverMonitoringState'].alwaysOnLockout:
-        self.events.add(EventName.tooDistracted)
-      # Alerts
-      vision_dm = self.sm['driverMonitoringState'].activePolicy == MonitoringPolicy.vision
-      if self.sm['driverMonitoringState'].alertLevel == AlertLevel.one:
-        self.events.add(EventName.driverDistracted1 if vision_dm else EventName.driverUnresponsive1)
-      elif self.sm['driverMonitoringState'].alertLevel == AlertLevel.two:
-        self.events.add(EventName.driverDistracted2 if vision_dm else EventName.driverUnresponsive2)
-      elif self.sm['driverMonitoringState'].alertLevel == AlertLevel.three:
-        self.events.add(EventName.driverDistracted3 if vision_dm else EventName.driverUnresponsive3)
-      # Warn consistent DM uncertainty
-      if self.sm['driverMonitoringState'].visionPolicyState.uncertainOffroadAlertPercent >= 100 and not self.dm_uncertain_alerted:
-        set_offroad_alert("Offroad_DriverMonitoringUncertain", True)
-        self.dm_uncertain_alerted = True
+      self.events.add_from_msg(self.sm['driverMonitoringState'].events)
       self.events_sp.add_from_msg(self.sm['longitudinalPlanSP'].events)
 
     # Add car events, ignore if CAN isn't valid
@@ -264,7 +241,7 @@ class SelfdriveD(CruiseHelper):
         self.events.add(EventName.pedalPressed)
 
     # Create events for temperature, disk space, and memory
-    if self.sm['deviceState'].thermalStatus >= ThermalStatus.overheated:
+    if self.sm['deviceState'].thermalStatus >= ThermalStatus.red:
       self.events.add(EventName.overheat)
     if self.sm['deviceState'].freeSpacePercent < 7 and not SIMULATION:
       self.events.add(EventName.outOfSpace)

selfdrive/test/process_replay/migration.py

@@ -449,6 +449,9 @@ def migrate_sensorEvents(msgs):
       m.logMonoTime = msg.logMonoTime
 
       m_dat = getattr(m, sensor_service)
+      m_dat.version = evt.version
+      m_dat.sensor = evt.sensor
+      m_dat.type = evt.type
       m_dat.source = evt.source
       m_dat.timestamp = evt.timestamp
       setattr(m_dat, evt.which(), getattr(evt, evt.which()))
@@ -481,41 +484,22 @@ def migrate_onroadEvents(msgs):
   return ops, [], []
 
 
-@migration(inputs=["driverMonitoringStateDEPRECATED"])
+@migration(inputs=["driverMonitoringState"])
 def migrate_driverMonitoringState(msgs):
   ops = []
   for index, msg in msgs:
-    old = msg.driverMonitoringStateDEPRECATED
-    new_msg = messaging.new_message('driverMonitoringState', valid=msg.valid, logMonoTime=msg.logMonoTime)
-    dm = new_msg.driverMonitoringState
-    dm.isRHD = old.isRHD
-    dm.activePolicy = log.DriverMonitoringState.MonitoringPolicy.vision if old.isActiveMode else \
-                          log.DriverMonitoringState.MonitoringPolicy.wheeltouch
+    msg = msg.as_builder()
+    events = []
+    for event in msg.driverMonitoringState.deprecated.events:
+      try:
+        if not str(event.name).endswith('DEPRECATED'):
+          migrated_event = migrate_onroad_event(event)
+          if migrated_event is not None:
+            events.append(migrated_event)
+      except RuntimeError:  # Member was null
+        traceback.print_exc()
 
-    AlertLevel = log.DriverMonitoringState.AlertLevel
-    event_to_alert_level = {
-      'driverDistracted1': AlertLevel.one, 'driverUnresponsive1': AlertLevel.one,
-      'driverDistracted2': AlertLevel.two, 'driverUnresponsive2': AlertLevel.two,
-      'driverDistracted3': AlertLevel.three, 'driverUnresponsive3': AlertLevel.three,
-      'tooDistracted': AlertLevel.three,
-    }
-    for event in old.events:
-      level = event_to_alert_level.get(str(event.name))
-      if level is not None:
-        dm.alertLevel = level
-        break
-
-    dm.visionPolicyState.awarenessPercent = int(max(0, min(100, (old.awarenessStatus if old.isActiveMode else old.awarenessActive) * 100)))
-    dm.visionPolicyState.awarenessStep = old.stepChange if old.isActiveMode else 0.
-    dm.visionPolicyState.isDistracted = old.isDistracted
-    dm.visionPolicyState.faceDetected = old.faceDetected
-    dm.visionPolicyState.pose.pitchCalib.offset = old.posePitchOffset
-    dm.visionPolicyState.pose.pitchCalib.calibratedPercent = int(min(100, old.posePitchValidCount / 600 * 100))
-    dm.visionPolicyState.pose.yawCalib.offset = old.poseYawOffset
-    dm.visionPolicyState.pose.yawCalib.calibratedPercent = int(min(100, old.poseYawValidCount / 600 * 100))
-    dm.visionPolicyState.pose.calibrated = old.posePitchValidCount >= 600 and old.poseYawValidCount >= 600
-    dm.wheeltouchPolicyState.awarenessPercent = int(max(0, min(100, (old.awarenessPassive if old.isActiveMode else old.awarenessStatus) * 100)))
-    dm.wheeltouchPolicyState.awarenessStep = 0. if old.isActiveMode else old.stepChange
-    ops.append((index, new_msg.as_reader()))
+    msg.driverMonitoringState.events = events
+    ops.append((index, msg.as_reader()))
 
   return ops, [], []

selfdrive/test/process_replay/model_replay.py

@@ -35,7 +35,7 @@ GITHUB = GithubUtils(API_TOKEN, DATA_TOKEN)
 EXEC_TIMINGS = [
   # model, instant max, average max
   ("modelV2", 0.05, 0.028),
-  ("driverStateV2", 0.05, 0.018),
+  ("driverStateV2", 0.05, 0.016),
 ]
 
 def get_log_fn(test_route, ref="master"):

selfdrive/ui/body/animations.py

@@ -1,278 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-import time
-
-
-class AnimationMode(Enum):
-  ONCE_FORWARD = 1
-  ONCE_FORWARD_BACKWARD = 2
-  REPEAT_FORWARD = 3
-  REPEAT_FORWARD_BACKWARD = 4
-
-
-@dataclass
-class Animation:
-  frames: list[list[tuple[int, int]]]
-  starting_frames: list[list[tuple[int, int]]] | None = None  # played once before the main loop
-  frame_duration: float = 0.15       # seconds each frame is shown
-  mode: AnimationMode = AnimationMode.REPEAT_FORWARD_BACKWARD
-  repeat_interval: float = 5.0      # seconds between animation restarts (only for REPEAT modes)
-  hold_end: float = 0.0             # seconds to hold the last frame before playing backward (only for *_BACKWARD modes)
-  left_turn_remove: list[tuple[int, int]] | None = None   # dots to remove from frame when turning left
-  right_turn_remove: list[tuple[int, int]] | None = None   # dots to remove from frame when turning right
-
-
-# --- Animation Helper Functions ---
-
-def _mirror(dots: list[tuple[int, int]]) -> list[tuple[int, int]]:
-  """Mirror a component from the left side of the face to the right"""
-  return [(r, 15 - c) for r, c in dots]
-
-
-def _mirror_no_flip(dots: list[tuple[int, int]]) -> list[tuple[int, int]]:
-  """Move a component to the mirrored position on the right half without flipping its shape."""
-  min_c = min(c for _, c in dots)
-  max_c = max(c for _, c in dots)
-  return [(r, 15 - max_c - min_c + c) for r, c in dots]
-
-
-def _shift(dots: list[tuple[int, int]], rc: tuple[int, int]) -> list[tuple[int, int]]:
-  dr, dc = rc
-  return [(r + dr, c + dc) for r, c in dots]
-
-
-def _make_frame(left_eye: list[tuple[int, int]], right_eye: list[tuple[int, int]],
-                left_brow: list[tuple[int, int]], right_brow: list[tuple[int, int]],
-                mouth: list[tuple[int, int]]) -> list[tuple[int, int]]:
-  return left_eye + left_brow + right_eye + right_brow + mouth
-
-
-# --- Animation Helper Components ---
-
-# Eyes (left side)
-EYE_OPEN = [
-        (2, 2), (2, 3),
-(3, 1), (3, 2), (3, 3), (3, 4),
-(4, 1), (4, 2), (4, 3), (4, 4),
-        (5, 2), (5, 3)
-]
-EYE_HALF = [
-(4, 1), (4, 2), (4, 3), (4, 4),
-        (5, 2), (5, 3)
-]
-EYE_CLOSED = [
-(4, 1),                 (4, 4),
-        (5, 2), (5, 3),
-]
-EYE_LEFT_LOOK = [
-        (2, 2), (2, 3),
-(3, 1), (3, 2),
-(4, 1), (4, 2),
-        (5, 2), (5, 3),
-]
-EYE_RIGHT_LOOK = [
-        (2, 2), (2, 3),
-                (3, 3), (3, 4),
-                (4, 3), (4, 4),
-        (5, 2), (5, 3),
-]
-
-# Eyebrows (left side)
-BROW_HIGH = [
-        (0, 1), (0, 2),
-(1, 0),
-]
-BROW_LOWERED = [
-        (1, 1), (1, 2),
-(2, 0)
-]
-BROW_STRAIGHT = [(1, 0), (1, 1), (1, 2)]
-BROW_DOWN = [
-(0, 1), (0, 2),
-                (1, 3)
-]
-
-# Mouths (centered, not mirrored)
-MOUTH_SMILE = [
-(6, 6),                 (6, 9),
-        (7, 7), (7, 8),
-]
-MOUTH_NORMAL = [(7, 7), (7, 8)]
-MOUTH_SAD = [
-        (6, 7), (6, 8),
-(7, 6),                 (7, 9)
-]
-
-# --- Animations ---
-
-NORMAL = Animation(
-  frames=[
-    _make_frame(EYE_OPEN, _mirror(EYE_OPEN), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-    _make_frame(EYE_HALF, _mirror(EYE_HALF), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-    _make_frame(EYE_CLOSED, _mirror(EYE_CLOSED), BROW_LOWERED, _mirror(BROW_LOWERED), MOUTH_SMILE),
-  ],
-  left_turn_remove=[
-    (3, 3), (3, 4),
-    (4, 3), (4, 4),
-  ] + _mirror_no_flip([
-    (3, 1), (3, 2),
-    (4, 1), (4, 2),
-  ]),
-  right_turn_remove=[
-    (3, 1), (3, 2),
-    (4, 1), (4, 2),
-  ] + _mirror_no_flip([
-    (3, 3), (3, 4),
-    (4, 3), (4, 4),
-  ])
-)
-
-ASLEEP = Animation(
-  frames=[
-    _make_frame(EYE_CLOSED, _mirror(EYE_CLOSED), [], [], MOUTH_NORMAL),
-  ],
-)
-
-SLEEPY = Animation(
-  frames=[
-    _make_frame(EYE_CLOSED, _mirror(EYE_CLOSED), _shift(BROW_STRAIGHT, (1, 0)), [], MOUTH_NORMAL),
-    _make_frame(EYE_HALF, _mirror(EYE_CLOSED), BROW_LOWERED, [], MOUTH_NORMAL),
-    _make_frame(EYE_OPEN, _mirror(EYE_CLOSED), BROW_HIGH, [], MOUTH_NORMAL)
-  ],
-  frame_duration=0.25,
-  mode=AnimationMode.ONCE_FORWARD_BACKWARD,
-  repeat_interval=10,
-  hold_end=1.5,
-)
-
-INQUISITIVE = Animation(
-  frames=[
-    _make_frame(EYE_OPEN, _mirror(EYE_OPEN), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-
-    _make_frame(EYE_LEFT_LOOK, _mirror(EYE_RIGHT_LOOK), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-    _make_frame(_shift(EYE_LEFT_LOOK, (0, -1)), _shift(_mirror(EYE_RIGHT_LOOK), (0, -1)), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-    _make_frame(_shift(EYE_LEFT_LOOK, (0, -1)), _shift(_mirror(EYE_RIGHT_LOOK), (0, -1)), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-    _make_frame(_shift(EYE_LEFT_LOOK, (0, -1)), _shift(_mirror(EYE_RIGHT_LOOK), (0, -1)), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-    _make_frame(EYE_LEFT_LOOK, _mirror(EYE_RIGHT_LOOK), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-
-    _make_frame(EYE_RIGHT_LOOK, _mirror(EYE_LEFT_LOOK), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-    _make_frame(_shift(EYE_RIGHT_LOOK, (0, 1)), _shift(_mirror(EYE_LEFT_LOOK), (0, 1)), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-    _make_frame(_shift(EYE_RIGHT_LOOK, (0, 1)), _shift(_mirror(EYE_LEFT_LOOK), (0, 1)), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-    _make_frame(_shift(EYE_RIGHT_LOOK, (0, 1)), _shift(_mirror(EYE_LEFT_LOOK), (0, 1)), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-    _make_frame(EYE_RIGHT_LOOK, _mirror(EYE_LEFT_LOOK), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-
-    _make_frame(EYE_OPEN, _mirror(EYE_OPEN), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-  ],
-  mode=AnimationMode.REPEAT_FORWARD,
-  frame_duration=0.15,
-  repeat_interval=10
-)
-
-WINK = Animation(
-  frames=[
-    _make_frame(EYE_OPEN, _mirror(EYE_OPEN), BROW_HIGH, _mirror(BROW_HIGH), MOUTH_SMILE),
-    _make_frame(EYE_OPEN, _mirror(EYE_CLOSED), BROW_HIGH, _mirror(_shift(BROW_DOWN, (0, 2))), MOUTH_SMILE),
-  ],
-  mode=AnimationMode.ONCE_FORWARD_BACKWARD,
-  frame_duration=0.75,
-)
-
-
-# --- Face Animator Class ---
-
-class FaceAnimator:
-  def __init__(self, animation: Animation):
-    self._animation = animation
-    self._next: Animation | None = None
-    self._start_time = time.monotonic()
-    self._rewinding = False
-    self._rewind_start: float = 0.0
-    self._rewind_from: int = 0
-    self._seen_nonzero = False
-
-  def set_animation(self, animation: Animation):
-    if animation is not self._animation:
-      self._next = animation
-
-  def get_dots(self) -> list[tuple[int, int]]:
-    now = time.monotonic()
-    elapsed = now - self._start_time
-
-    # Handle rewind for forward-only animations
-    if self._rewinding:
-      rewind_elapsed = now - self._rewind_start
-      frames_back = round(rewind_elapsed / self._animation.frame_duration)
-      frame_index = self._rewind_from - frames_back
-      if frame_index <= 0:
-        return self._switch_to_next(now)
-      return self._animation.frames[frame_index]
-
-    # Play starting frames first (once)
-    starting = self._animation.starting_frames or []
-    starting_duration = len(starting) * self._animation.frame_duration
-    if starting and elapsed < starting_duration:
-      frame_index = min(int(elapsed / self._animation.frame_duration), len(starting) - 1)
-      return starting[frame_index]
-
-    # Main loop
-    loop_elapsed = elapsed - starting_duration if starting else elapsed
-    frame_index = _get_frame_index(self._animation, loop_elapsed, gap_first=bool(starting))
-
-    if frame_index != 0:
-      self._seen_nonzero = True
-
-    if self._next is not None:
-      if frame_index == 0 and (len(self._animation.frames) == 1 or self._seen_nonzero):
-        return self._switch_to_next(now)
-      # No natural return to frame 0 — start rewinding
-      if self._animation.mode in (AnimationMode.ONCE_FORWARD, AnimationMode.REPEAT_FORWARD):
-        self._rewinding = True
-        self._rewind_start = now
-        self._rewind_from = frame_index
-
-    return self._animation.frames[frame_index]
-
-  def _switch_to_next(self, now: float) -> list[tuple[int, int]]:
-    self._animation = self._next
-    self._next = None
-    self._rewinding = False
-    self._seen_nonzero = False
-    self._start_time = now
-    return self._animation.frames[0]
-
-
-def _get_frame_index(animation: Animation, elapsed: float, gap_first: bool = False) -> int:
-  """Get the current frame index given elapsed time and animation mode."""
-  num_frames = len(animation.frames)
-  if num_frames == 1:
-    return 0
-
-  fd = animation.frame_duration
-  has_backward = animation.mode in (AnimationMode.ONCE_FORWARD_BACKWARD, AnimationMode.REPEAT_FORWARD_BACKWARD)
-  repeats = animation.mode in (AnimationMode.REPEAT_FORWARD, AnimationMode.REPEAT_FORWARD_BACKWARD)
-
-  forward_duration = num_frames * fd
-  backward_frames = max(num_frames - 2, 0) if has_backward else 0
-  hold = animation.hold_end if has_backward else 0.0
-  cycle_duration = forward_duration + hold + backward_frames * fd
-
-  if not repeats:
-    t = min(elapsed, cycle_duration)
-  else:
-    t = (elapsed + cycle_duration if gap_first else elapsed) % animation.repeat_interval
-
-  # Forward phase
-  if t < forward_duration:
-    return min(int(t / fd), num_frames - 1)
-  t -= forward_duration
-
-  # Hold at last frame
-  if t < hold:
-    return num_frames - 1
-  t -= hold
-
-  # Backward phase
-  if backward_frames and t < backward_frames * fd:
-    return num_frames - 2 - min(int(t / fd), backward_frames - 1)
-
-  return 0 if has_backward else num_frames - 1

selfdrive/ui/body/layouts/onroad.py

@@ -1,93 +0,0 @@
-import time
-import pyray as rl
-
-from openpilot.system.ui.lib.application import gui_app, FontWeight
-from openpilot.system.ui.widgets import Widget
-from openpilot.system.ui.widgets.label import UnifiedLabel
-from openpilot.selfdrive.ui.ui_state import ui_state
-from openpilot.selfdrive.ui.body.animations import FaceAnimator, ASLEEP, INQUISITIVE, NORMAL, SLEEPY
-
-GRID_COLS = 16
-GRID_ROWS = 8
-DOT_RADIUS = 50 if gui_app.big_ui() else 10
-
-IDLE_TIMEOUT = 30.0        # seconds of no joystick input before playing INQUISITIVE
-IDLE_STEER_THRESH = 0.5    # degrees — below this counts as no input
-IDLE_SPEED_THRESH = 0.01   # m/s — below this counts as no input
-
-
-# This class is used both in BIG (tizi) and small (mici) UIs
-class BodyLayout(Widget):
-  def __init__(self):
-    super().__init__()
-    self._animator = FaceAnimator(ASLEEP)
-    self._turning_left = False
-    self._turning_right = False
-    self._last_input_time = time.monotonic()
-    self._was_active = False
-    self._offroad_label = UnifiedLabel("turn on ignition to use", 95 if gui_app.big_ui() else 45, FontWeight.DISPLAY,
-                                       alignment=rl.GuiTextAlignment.TEXT_ALIGN_CENTER,
-                                       alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_MIDDLE)
-
-  def draw_dot_grid(self, rect: rl.Rectangle, dots: list[tuple[int, int]], color: rl.Color):
-    spacing = min(rect.height / GRID_ROWS, rect.width / GRID_COLS)
-
-    grid_w = (GRID_COLS - 1) * spacing
-    grid_h = (GRID_ROWS - 1) * spacing
-
-    offset_x = rect.x + (rect.width - grid_w) / 2
-    offset_y = rect.y + (rect.height - grid_h) / 2
-
-    for row, col in dots:
-      x = int(offset_x + col * spacing)
-      y = int(offset_y + row * spacing)
-      rl.draw_circle(x, y, DOT_RADIUS, color)
-
-  def _update_state(self):
-    super()._update_state()
-
-    sm = ui_state.sm
-
-    if ui_state.is_onroad():
-      if not self._was_active:
-        self._last_input_time = time.monotonic()
-        self._was_active = True
-
-      cs = sm['carState']
-      has_input = abs(cs.steeringAngleDeg) > IDLE_STEER_THRESH or abs(cs.vEgo) > IDLE_SPEED_THRESH
-      if has_input:
-        self._last_input_time = time.monotonic()
-
-      if time.monotonic() - self._last_input_time > IDLE_TIMEOUT:
-        self._animator.set_animation(INQUISITIVE)
-      else:
-        self._animator.set_animation(NORMAL)
-    else:
-      self._was_active = False
-      self._animator.set_animation(ASLEEP)
-
-    steer = sm['testJoystick'].axes[1] if len(sm['testJoystick'].axes) > 1 else 0
-    self._turning_left = steer <= -0.05
-    self._turning_right = steer >= 0.05
-
-  # play animation on screen tap
-  def _handle_mouse_release(self, mouse_pos):
-    super()._handle_mouse_release(mouse_pos)
-    if not self._was_active:
-      self._animator.set_animation(SLEEPY)
-
-  def _render(self, rect: rl.Rectangle):
-    dots = self._animator.get_dots()
-    animation = self._animator._animation
-    if self._turning_left and animation.left_turn_remove:
-      remove_set = set(animation.left_turn_remove)
-      dots = [d for d in dots if d not in remove_set]
-    elif self._turning_right and animation.right_turn_remove:
-      remove_set = set(animation.right_turn_remove)
-      dots = [d for d in dots if d not in remove_set]
-    self.draw_dot_grid(rect, dots, rl.WHITE)
-
-    if ui_state.is_offroad():
-      rl.draw_rectangle(int(self.rect.x), int(self.rect.y), int(self.rect.width), int(self.rect.height), rl.Color(0, 0, 0, 175))
-      upper_half = rl.Rectangle(rect.x, rect.y, rect.width, rect.height / 2)
-      self._offroad_label.render(upper_half)

selfdrive/ui/layouts/main.py

@@ -2,14 +2,13 @@ import pyray as rl
 from enum import IntEnum
 import cereal.messaging as messaging
 from openpilot.system.ui.lib.application import gui_app
-from openpilot.system.ui.widgets import Widget
 from openpilot.selfdrive.ui.layouts.sidebar import Sidebar, SIDEBAR_WIDTH
 from openpilot.selfdrive.ui.layouts.home import HomeLayout
 from openpilot.selfdrive.ui.layouts.settings.settings import SettingsLayout, PanelType
 from openpilot.selfdrive.ui.onroad.augmented_road_view import AugmentedRoadView
 from openpilot.selfdrive.ui.ui_state import device, ui_state
+from openpilot.system.ui.widgets import Widget
 from openpilot.selfdrive.ui.layouts.onboarding import OnboardingWindow
-from openpilot.selfdrive.ui.body.layouts.onroad import BodyLayout
 
 if gui_app.sunnypilot_ui():
   from openpilot.selfdrive.ui.sunnypilot.layouts.settings.settings import SettingsLayoutSP as SettingsLayout
@@ -32,9 +31,7 @@ class MainLayout(Widget):
     self._prev_onroad = False
 
     # Initialize layouts
-    self._home_layout = HomeLayout()
-    self._home_body_layout = BodyLayout()
-    self._layouts = {MainState.HOME: self._home_layout, MainState.SETTINGS: SettingsLayout(), MainState.ONROAD: AugmentedRoadView()}
+    self._layouts = {MainState.HOME: HomeLayout(), MainState.SETTINGS: SettingsLayout(), MainState.ONROAD: AugmentedRoadView()}
 
     self._sidebar_rect = rl.Rectangle(0, 0, 0, 0)
     self._content_rect = rl.Rectangle(0, 0, 0, 0)
@@ -60,18 +57,14 @@ class MainLayout(Widget):
     self._layouts[MainState.HOME]._setup_widget.set_open_settings_callback(lambda: self.open_settings(PanelType.FIREHOSE))
     self._layouts[MainState.HOME].set_settings_callback(lambda: self.open_settings(PanelType.TOGGLES))
     self._layouts[MainState.SETTINGS].set_callbacks(on_close=self._set_mode_for_state)
-
-    for layout in (self._layouts[MainState.ONROAD], self._home_body_layout):
-      layout.set_click_callback(self._on_onroad_clicked)
-
+    self._layouts[MainState.ONROAD].set_click_callback(self._on_onroad_clicked)
     device.add_interactive_timeout_callback(self._set_mode_for_state)
-    ui_state.add_on_body_changed_callbacks(self._on_body_changed)
 
   def _update_layout_rects(self):
     self._sidebar_rect = rl.Rectangle(self._rect.x, self._rect.y, SIDEBAR_WIDTH, self._rect.height)
 
     x_offset = SIDEBAR_WIDTH if self._sidebar.is_visible else 0
-    self._content_rect = rl.Rectangle(self._rect.x + x_offset, self._rect.y, self._rect.width - x_offset, self._rect.height)
+    self._content_rect = rl.Rectangle(self._rect.y + x_offset, self._rect.y, self._rect.width - x_offset, self._rect.height)
 
   def _handle_onroad_transition(self):
     if ui_state.started != self._prev_onroad:
@@ -80,12 +73,6 @@ class MainLayout(Widget):
       self._set_mode_for_state()
 
   def _set_mode_for_state(self):
-    # Don't go onroad if body, home is onroad
-    if ui_state.is_body:
-      self._set_current_layout(MainState.HOME)
-      self._sidebar.set_visible(not ui_state.ignition)
-      return
-
     if ui_state.started:
       # Don't hide sidebar from interactive timeout
       if self._current_mode != MainState.ONROAD:
@@ -117,10 +104,6 @@ class MainLayout(Widget):
   def _on_onroad_clicked(self):
     self._sidebar.set_visible(not self._sidebar.is_visible)
 
-  def _on_body_changed(self):
-    self._layouts[MainState.HOME] = self._home_body_layout if ui_state.is_body else self._home_layout
-    self._set_mode_for_state()
-
   def _render_main_content(self):
     # Render sidebar
     if self._sidebar.is_visible:

selfdrive/ui/layouts/settings/developer.py

@@ -36,7 +36,7 @@ class DeveloperLayout(Widget):
   def __init__(self):
     super().__init__()
     self._params = Params()
-    self._is_release = self._params.get_bool("IsReleaseBranch")
+    self._is_release = False  # self._params.get_bool("IsReleaseBranch")
 
     # Build items and keep references for callbacks/state updates
     self._adb_toggle = toggle_item(
@@ -135,6 +135,12 @@ class DeveloperLayout(Widget):
 
       long_man_enabled = ui_state.has_longitudinal_control and ui_state.is_offroad()
       self._long_maneuver_toggle.action_item.set_enabled(long_man_enabled)
+      if not long_man_enabled:
+        self._long_maneuver_toggle.action_item.set_state(False)
+        self._params.put_bool("LongitudinalManeuverMode", False)
+
+      lat_man_enabled = ui_state.is_offroad()
+      self._lat_maneuver_toggle.action_item.set_enabled(lat_man_enabled)
     else:
       self._long_maneuver_toggle.action_item.set_enabled(False)
       self._lat_maneuver_toggle.action_item.set_enabled(False)

selfdrive/ui/layouts/settings/firehose.py

@@ -1,7 +1,7 @@
 import pyray as rl
 
 from openpilot.system.ui.lib.application import gui_app, FontWeight, FONT_SCALE
-from openpilot.system.ui.lib.multilang import tr, tr_noop
+from openpilot.system.ui.lib.multilang import tr, trn, tr_noop
 from openpilot.system.ui.lib.text_measure import measure_text_cached
 from openpilot.system.ui.lib.scroll_panel import GuiScrollPanel
 from openpilot.system.ui.lib.wrap_text import wrap_text
@@ -65,13 +65,12 @@ class FirehoseLayout(FirehoseLayoutBase):
     y = self._draw_wrapped_text(x, y, w, status_text, gui_app.font(FontWeight.BOLD), 60, status_color)
     y += 20 + 20
 
-    # TODO: add back once reliable
     # Contribution count (if available)
-    #if self._segment_count > 0:
-    #  contrib_text = trn("{} segment of your driving is in the training dataset so far.",
-    #                     "{} segments of your driving is in the training dataset so far.", self._segment_count).format(self._segment_count)
-    #  y = self._draw_wrapped_text(x, y, w, contrib_text, gui_app.font(FontWeight.BOLD), 52, rl.WHITE)
-    #  y += 20 + 20
+    if self._segment_count > 0:
+      contrib_text = trn("{} segment of your driving is in the training dataset so far.",
+                         "{} segments of your driving is in the training dataset so far.", self._segment_count).format(self._segment_count)
+      y = self._draw_wrapped_text(x, y, w, contrib_text, gui_app.font(FontWeight.BOLD), 52, rl.WHITE)
+      y += 20 + 20
 
     # Separator
     rl.draw_rectangle(x, y, w, 2, self.GRAY)

selfdrive/ui/layouts/settings/toggles.py

@@ -42,7 +42,7 @@ class TogglesLayout(Widget):
   def __init__(self):
     super().__init__()
     self._params = Params()
-    self._is_release = self._params.get_bool("IsReleaseBranch")
+    self._is_release = False  # self._params.get_bool("IsReleaseBranch")
 
     # param, title, desc, icon, needs_restart
     self._toggle_defs = {

selfdrive/ui/layouts/sidebar.py

@@ -125,8 +125,10 @@ class Sidebar(Widget, SidebarSP):
   def _update_temperature_status(self, device_state):
     thermal_status = device_state.thermalStatus
 
-    if thermal_status == ThermalStatus.ok:
+    if thermal_status == ThermalStatus.green:
       self._temp_status.update(tr_noop("TEMP"), tr_noop("GOOD"), Colors.GOOD)
+    elif thermal_status == ThermalStatus.yellow:
+      self._temp_status.update(tr_noop("TEMP"), tr_noop("OK"), Colors.WARNING)
     else:
       self._temp_status.update(tr_noop("TEMP"), tr_noop("HIGH"), Colors.DANGER)
 

selfdrive/ui/mici/layouts/home.py

@@ -130,7 +130,6 @@ class MiciHomeLayout(Widget):
 
     self._experimental_icon = IconWidget("icons_mici/experimental_mode.png", (48, 48))
     self._mic_icon = IconWidget("icons_mici/microphone.png", (32, 46))
-    self._body_icon = IconWidget("icons_mici/body.png", (54, 37))
 
     self._alerts_pill = AlertsPill()
 
@@ -138,7 +137,6 @@ class MiciHomeLayout(Widget):
       IconWidget("icons_mici/settings.png", (48, 48), opacity=0.9),
       NetworkIcon(),
       self._experimental_icon,
-      self._body_icon,
       self._mic_icon,
     ], spacing=18)
 
@@ -249,7 +247,6 @@ class MiciHomeLayout(Widget):
     # ***** Center-aligned bottom section icons *****
     self._experimental_icon.set_visible(self._experimental_mode)
     self._mic_icon.set_visible(ui_state.recording_audio)
-    self._body_icon.set_visible(ui_state.is_body)
 
     footer_rect = rl.Rectangle(self.rect.x + HOME_PADDING, self.rect.y + self.rect.height - 48, self.rect.width - HOME_PADDING, 48)
     self._status_bar_layout.render(footer_rect)

selfdrive/ui/mici/layouts/main.py

@@ -6,7 +6,6 @@ from openpilot.selfdrive.ui.mici.layouts.offroad_alerts import MiciOffroadAlerts
 from openpilot.selfdrive.ui.mici.onroad.augmented_road_view import AugmentedRoadView
 from openpilot.selfdrive.ui.ui_state import device, ui_state
 from openpilot.selfdrive.ui.mici.layouts.onboarding import OnboardingWindow
-from openpilot.selfdrive.ui.body.layouts.onroad import BodyLayout
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.scroller import Scroller
 from openpilot.system.ui.lib.application import gui_app
@@ -32,25 +31,22 @@ class MiciMainLayout(Scroller):
     self._home_layout = MiciHomeLayout()
     self._alerts_layout = MiciOffroadAlerts()
     self._settings_layout = SettingsLayout()
-    self._car_onroad_layout = AugmentedRoadView(bookmark_callback=self._on_bookmark_clicked)
-    self._body_onroad_layout = BodyLayout()
+    self._onroad_layout = AugmentedRoadView(bookmark_callback=self._on_bookmark_clicked)
 
     # Initialize widget rects
-    for widget in (self._home_layout, self._alerts_layout, self._settings_layout,
-                   self._car_onroad_layout, self._body_onroad_layout):
+    for widget in (self._home_layout, self._settings_layout, self._alerts_layout, self._onroad_layout):
       # TODO: set parent rect and use it if never passed rect from render (like in Scroller)
       widget.set_rect(rl.Rectangle(0, 0, gui_app.width, gui_app.height))
 
     self._scroller.add_widgets([
       self._alerts_layout,
       self._home_layout,
-      self._car_onroad_layout,
-      self._body_onroad_layout,
+      self._onroad_layout,
     ])
     self._scroller.set_reset_scroll_at_show(False)
 
     # Disable scrolling when onroad is interacting with bookmark
-    self._scroller.set_scrolling_enabled(lambda: not self._car_onroad_layout.is_swiping_left())
+    self._scroller.set_scrolling_enabled(lambda: not self._onroad_layout.is_swiping_left())
 
     # Set callbacks
     self._setup_callbacks()
@@ -63,22 +59,14 @@ class MiciMainLayout(Scroller):
     if not self._onboarding_window.completed:
       gui_app.push_widget(self._onboarding_window)
 
-  @property
-  def _onroad_layout(self) -> Widget:
-    # For scroll_to
-    return self._body_onroad_layout if ui_state.is_body else self._car_onroad_layout
-
   def _setup_callbacks(self):
     self._home_layout.set_callbacks(
       on_settings=lambda: gui_app.push_widget(self._settings_layout),
       on_alerts=lambda: self._scroll_to(self._alerts_layout),
       alert_count_callback=self._alerts_layout.active_alerts,
     )
-    for layout in (self._car_onroad_layout, self._body_onroad_layout):
-      layout.set_click_callback(lambda: self._scroll_to(self._home_layout))
-
+    self._onroad_layout.set_click_callback(lambda: self._scroll_to(self._home_layout))
     device.add_interactive_timeout_callback(self._on_interactive_timeout)
-    ui_state.add_on_body_changed_callbacks(self._on_body_changed)
 
   def _scroll_to(self, layout: Widget):
     layout_x = int(layout.rect.x)
@@ -144,7 +132,3 @@ class MiciMainLayout(Scroller):
     user_bookmark = messaging.new_message('bookmarkButton')
     user_bookmark.valid = True
     self._pm.send('bookmarkButton', user_bookmark)
-
-  def _on_body_changed(self):
-    self._car_onroad_layout.set_visible(not ui_state.is_body)
-    self._body_onroad_layout.set_visible(ui_state.is_body)

selfdrive/ui/mici/layouts/onboarding.py

@@ -140,7 +140,7 @@ class TrainingGuideDMTutorial(NavWidget):
 
     # stay at 100% once reached
     in_bad_face = gui_app.get_active_widget() == self._bad_face_page
-    if ((dm_state.visionPolicyState.faceDetected and looking_center) or self._progress.x > 0.99) and not in_bad_face:
+    if ((dm_state.faceDetected and looking_center) or self._progress.x > 0.99) and not in_bad_face:
       slow = self._progress.x < 0.25
       duration = self.PROGRESS_DURATION * 2 if slow else self.PROGRESS_DURATION
       self._progress.x += 1.0 / (duration * gui_app.target_fps)

selfdrive/ui/mici/layouts/settings/developer.py

@@ -131,6 +131,12 @@ class DeveloperLayoutMici(NavScroller):
 
       long_man_enabled = ui_state.has_longitudinal_control and ui_state.is_offroad()
       self._long_maneuver_toggle.set_enabled(long_man_enabled)
+      if not long_man_enabled:
+        self._long_maneuver_toggle.set_checked(False)
+        ui_state.params.put_bool("LongitudinalManeuverMode", False)
+
+      lat_man_enabled = ui_state.is_offroad()
+      self._lat_maneuver_toggle.set_enabled(lat_man_enabled)
     else:
       self._long_maneuver_toggle.set_enabled(False)
       self._lat_maneuver_toggle.set_enabled(False)

selfdrive/ui/mici/onroad/driver_camera_dialog.py

@@ -1,15 +1,20 @@
 import pyray as rl
-from cereal import car, log, messaging
+from cereal import log, messaging
 from msgq.visionipc import VisionStreamType
 from openpilot.selfdrive.ui.mici.onroad.cameraview import CameraView
 from openpilot.selfdrive.ui.mici.onroad.driver_state import DriverStateRenderer
 from openpilot.selfdrive.ui.ui_state import ui_state, device
+from openpilot.selfdrive.selfdrived.events import EVENTS, ET
 from openpilot.system.ui.lib.application import gui_app, FontWeight
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.nav_widget import NavWidget
 from openpilot.system.ui.widgets.label import gui_label
 
+EventName = log.OnroadEvent.EventName
+
+EVENT_TO_INT = EventName.schema.enumerants
+
 
 class DriverCameraView(CameraView):
   def _calc_frame_matrix(self, rect: rl.Rectangle):
@@ -102,14 +107,11 @@ class BaseDriverCameraDialog(Widget):
     if self._pm is None:
       return
 
-    AudibleAlert = car.CarControl.HUDControl.AudibleAlert
-    ALERT_SOUNDS = {
-      'two': AudibleAlert.promptDistracted,
-      'three': AudibleAlert.warningImmediate,
-    }
     msg = messaging.new_message('selfdriveState')
-    if dm_state is not None:
-      msg.selfdriveState.alertSound = ALERT_SOUNDS.get(str(dm_state.alertLevel), AudibleAlert.none)
+    if dm_state is not None and len(dm_state.events):
+      event_name = EVENT_TO_INT[dm_state.events[0].name]
+      if event_name is not None and event_name in EVENTS and ET.PERMANENT in EVENTS[event_name]:
+        msg.selfdriveState.alertSound = EVENTS[event_name][ET.PERMANENT].audible_alert
     self._pm.send('selfdriveState', msg)
 
   def _render_dm_alerts(self, rect: rl.Rectangle):
@@ -117,31 +119,29 @@ class BaseDriverCameraDialog(Widget):
     dm_state = ui_state.sm["driverMonitoringState"]
     self._publish_alert_sound(dm_state)
 
-    is_vision = dm_state.activePolicy == log.DriverMonitoringState.MonitoringPolicy.vision
-    awareness_pct = dm_state.visionPolicyState.awarenessPercent if is_vision else dm_state.wheeltouchPolicyState.awarenessPercent
     gui_label(rl.Rectangle(rect.x + 2, rect.y + 2, rect.width, rect.height),
-              f"Awareness: {awareness_pct:.0f}%", font_size=44, font_weight=FontWeight.MEDIUM,
+              f"Awareness: {dm_state.awarenessStatus * 100:.0f}%", font_size=44, font_weight=FontWeight.MEDIUM,
               alignment=rl.GuiTextAlignment.TEXT_ALIGN_RIGHT,
               alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_TOP,
               color=rl.Color(0, 0, 0, 180))
-    gui_label(rect, f"Awareness: {awareness_pct:.0f}%", font_size=44, font_weight=FontWeight.MEDIUM,
+    gui_label(rect, f"Awareness: {dm_state.awarenessStatus * 100:.0f}%", font_size=44, font_weight=FontWeight.MEDIUM,
               alignment=rl.GuiTextAlignment.TEXT_ALIGN_RIGHT,
               alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_TOP,
               color=rl.Color(255, 255, 255, int(255 * 0.9)))
 
-    if dm_state.alertLevel == log.DriverMonitoringState.AlertLevel.none:
+    if not dm_state.events:
       return
 
-    # Show alert level
-    alert_level_str = f"{'Pay Attention' if is_vision else 'Touch Wheel'} - level {dm_state.alertLevel}"
+    # Show first event (only one should be active at a time)
+    event_name_str = str(dm_state.events[0].name).split('.')[-1]
     alignment = rl.GuiTextAlignment.TEXT_ALIGN_RIGHT if self.driver_state_renderer.is_rhd else rl.GuiTextAlignment.TEXT_ALIGN_LEFT
 
     shadow_rect = rl.Rectangle(rect.x + 2, rect.y + 2, rect.width, rect.height)
-    gui_label(shadow_rect, alert_level_str, font_size=40, font_weight=FontWeight.BOLD,
+    gui_label(shadow_rect, event_name_str, font_size=40, font_weight=FontWeight.BOLD,
               alignment=alignment,
               alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_BOTTOM,
               color=rl.Color(0, 0, 0, 180))
-    gui_label(rect, alert_level_str, font_size=40, font_weight=FontWeight.BOLD,
+    gui_label(rect, event_name_str, font_size=40, font_weight=FontWeight.BOLD,
               alignment=alignment,
               alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_BOTTOM,
               color=rl.Color(255, 255, 255, int(255 * 0.9)))
@@ -156,7 +156,7 @@ class BaseDriverCameraDialog(Widget):
   def _draw_face_detection(self, rect: rl.Rectangle):
     dm_state = ui_state.sm["driverMonitoringState"]
     driver_data = self.driver_state_renderer.get_driver_data()
-    if not dm_state.visionPolicyState.faceDetected:
+    if not dm_state.faceDetected:
       return
 
     # Get face position and orientation

selfdrive/ui/mici/onroad/driver_state.py

@@ -6,7 +6,7 @@ from openpilot.common.filter_simple import FirstOrderFilter
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.widgets import Widget
 from openpilot.selfdrive.ui.ui_state import ui_state
-
+from openpilot.selfdrive.monitoring.helpers import face_orientation_from_net
 
 AlertSize = log.SelfdriveState.AlertSize
 
@@ -35,8 +35,6 @@ class DriverStateRenderer(Widget):
     self._is_active = False
     self._is_rhd = False
     self._face_detected = False
-    self._face_pitch = 0.
-    self._face_yaw = 0.
     self._should_draw = False
     self._force_active = False
     self._looking_center = False
@@ -155,11 +153,9 @@ class DriverStateRenderer(Widget):
     sm = ui_state.sm
 
     dm_state = sm["driverMonitoringState"]
-    self._is_active = dm_state.activePolicy == log.DriverMonitoringState.MonitoringPolicy.vision
+    self._is_active = dm_state.isActiveMode
     self._is_rhd = dm_state.isRHD
-    self._face_detected = dm_state.visionPolicyState.faceDetected
-    self._face_pitch = dm_state.visionPolicyState.pose.pitch + math.radians(6) # calib or DM pose is not accurate, add a fake upward pitch to bias forward
-    self._face_yaw = -dm_state.visionPolicyState.pose.yaw # undo sign flip in face_orientation_from_model to match UI convention
+    self._face_detected = dm_state.faceDetected
 
     driverstate = sm["driverStateV2"]
     driver_data = driverstate.rightDriverData if self._is_rhd else driverstate.leftDriverData
@@ -167,9 +163,26 @@ class DriverStateRenderer(Widget):
 
   def _update_state(self):
     # Get monitoring state
-    _ = self.get_driver_data()
-    pitch = self._pitch_filter.update(self._face_pitch)
-    yaw = self._yaw_filter.update(self._face_yaw)
+    driver_data = self.get_driver_data()
+    driver_orient = driver_data.faceOrientation
+    driver_position = driver_data.facePosition
+
+    if len(driver_orient) != 3:
+      return
+
+    # Calibrate orientation so looking straight ahead at road (instead of at device) is (0, 0, 0)
+    sm = ui_state.sm
+    if sm.valid['liveCalibration'] and len(sm['liveCalibration'].rpyCalib) == 3:
+      cal_rpy = sm['liveCalibration'].rpyCalib
+    else:
+      cal_rpy = [0.0, 0.0, 0.0]
+
+    _, pitch, yaw = face_orientation_from_net(driver_orient, driver_position, cal_rpy)
+    pitch += math.radians(6)  # calib or DM pose is not accurate, add a fake upward pitch to bias forward
+    yaw = -yaw  # undo sign flip in face_orientation_from_net to match UI convention
+
+    pitch = self._pitch_filter.update(pitch)
+    yaw = self._yaw_filter.update(yaw)
 
     # hysteresis on looking center
     if abs(pitch) < LOOKING_CENTER_THRESHOLD_LOWER and abs(yaw) < LOOKING_CENTER_THRESHOLD_LOWER:

selfdrive/ui/onroad/driver_state.py

@@ -114,7 +114,7 @@ class DriverStateRenderer(Widget):
 
     # Get monitoring state
     dm_state = sm["driverMonitoringState"]
-    self.is_active = dm_state.activePolicy == log.DriverMonitoringState.MonitoringPolicy.vision
+    self.is_active = dm_state.isActiveMode
     self.is_rhd = dm_state.isRHD
 
     # Update fade state (smoother transition between active/inactive)

selfdrive/ui/sunnypilot/layouts/settings/steering.py

@@ -120,20 +120,12 @@ class SteeringLayout(Widget):
   def _update_state(self):
     super()._update_state()
 
-    torque_allowed = True
+    torque_allowed = ui_state.CP is not None and ui_state.CP.steerControlType != car.CarParams.SteerControlType.angle
     if ui_state.CP is not None:
       mads_main_desc = self._mads_limited_desc if self._mads_settings_layout._mads_limited_settings() else self._mads_full_desc
       self._mads_toggle.set_description(f"<b>{mads_main_desc}</b><br><br>{self._mads_base_desc}")
-
-      if ui_state.CP.steerControlType == car.CarParams.SteerControlType.angle:
-        ui_state.params.remove("EnforceTorqueControl")
-        ui_state.params.remove("NeuralNetworkLateralControl")
-        torque_allowed = False
     else:
       self._mads_toggle.set_description(f"<b>{self._mads_check_compat_desc}</b><br><br>{self._mads_base_desc}")
-      ui_state.params.remove("EnforceTorqueControl")
-      ui_state.params.remove("NeuralNetworkLateralControl")
-      torque_allowed = False
 
     self._mads_toggle.action_item.set_enabled(ui_state.is_offroad())
     self._mads_settings_button.action_item.set_enabled(ui_state.is_offroad() and self._mads_toggle.action_item.get_state())

selfdrive/ui/sunnypilot/mici/layouts/settings.py

@@ -5,8 +5,9 @@ This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 from openpilot.selfdrive.ui.mici.layouts.settings import settings as OP
+from openpilot.selfdrive.ui.mici.layouts.settings.settings import SettingsBigButton
 from openpilot.selfdrive.ui.mici.layouts.settings.device import DeviceLayoutMici
-from openpilot.selfdrive.ui.mici.widgets.button import BigButton, BigCircleButton
+from openpilot.selfdrive.ui.mici.widgets.button import BigCircleButton
 from openpilot.selfdrive.ui.mici.widgets.dialog import BigConfirmationDialog, BigDialog
 from openpilot.selfdrive.ui.sunnypilot.mici.layouts.sunnylink import SunnylinkLayoutMici
 from openpilot.selfdrive.ui.sunnypilot.mici.layouts.models import ModelsLayoutMici
@@ -32,11 +33,11 @@ class SettingsLayoutSP(OP.SettingsLayout):
     self.icon_offroad_slider = gui_app.texture("icons_mici/settings/device/lkas.png", BIG_ICON_SIZE, BIG_ICON_SIZE)
 
     sunnylink_panel = SunnylinkLayoutMici(back_callback=gui_app.pop_widget)
-    sunnylink_btn = BigButton("sunnylink", "", gui_app.texture("icons_mici/settings/developer/ssh.png", ICON_SIZE, ICON_SIZE))
+    sunnylink_btn = SettingsBigButton(tr("sunnylink"), "", gui_app.texture("icons_mici/settings/developer/ssh.png", 55, 55))
     sunnylink_btn.set_click_callback(lambda: gui_app.push_widget(sunnylink_panel))
 
     models_panel = ModelsLayoutMici(back_callback=gui_app.pop_widget)
-    models_btn = BigButton("models", "", gui_app.texture("../../sunnypilot/selfdrive/assets/offroad/icon_models.png", ICON_SIZE, ICON_SIZE))
+    models_btn = SettingsBigButton(tr("models"), "", gui_app.texture("../../sunnypilot/selfdrive/assets/offroad/icon_models.png", ICON_SIZE, ICON_SIZE))
     models_btn.set_click_callback(lambda: gui_app.push_widget(models_panel))
 
     # onroad: enable button sits at the front (left of toggles)

selfdrive/ui/sunnypilot/onroad/developer_ui/__init__.py

@@ -141,7 +141,8 @@ class DeveloperUiRenderer(Widget):
 
     # Add torque-specific elements if using torque control
     if sm['controlsState'].lateralControlState.which() == 'torqueState':
-      if sm.valid['liveTorqueParameters']:
+      override_active = ui_state.enforce_torque_control and ui_state.custom_torque_params and ui_state.torque_override_enabled
+      if sm.valid['liveTorqueParameters'] or override_active:
         elements.extend([
           self.friction_elem.update(sm, ui_state.is_metric),
           self.lat_accel_factor_elem.update(sm, ui_state.is_metric),

selfdrive/ui/sunnypilot/onroad/developer_ui/elements.py

@@ -8,8 +8,7 @@ import pyray as rl
 from dataclasses import dataclass
 
 from openpilot.common.constants import CV
-
-
+from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.ui.lib.text_measure import measure_text_cached
 
 
@@ -248,12 +247,12 @@ class FrictionCoefficientElement:
     self.unit = ""
 
   def update(self, sm, is_metric: bool) -> UiElement:
-    ltp = sm['liveTorqueParameters']
-    friction_coef = ltp.frictionCoefficientFiltered
-    live_valid = ltp.liveValid
+    if ui_state.enforce_torque_control and ui_state.custom_torque_params and ui_state.torque_override_enabled:
+      return UiElement(f"{ui_state.torque_override_friction:.3f}", "FRIC.", self.unit, rl.WHITE)
 
-    value = f"{friction_coef:.3f}"
-    color = rl.Color(0, 255, 0, 255) if live_valid else rl.WHITE
+    ltp = sm['liveTorqueParameters']
+    value = f"{ltp.frictionCoefficientFiltered:.3f}"
+    color = rl.Color(0, 255, 0, 255) if ltp.liveValid else rl.WHITE
     return UiElement(value, "FRIC.", self.unit, color)
 
 
@@ -262,12 +261,12 @@ class LatAccelFactorElement:
     self.unit = ""
 
   def update(self, sm, is_metric: bool) -> UiElement:
-    ltp = sm['liveTorqueParameters']
-    lat_accel_factor = ltp.latAccelFactorFiltered
-    live_valid = ltp.liveValid
+    if ui_state.enforce_torque_control and ui_state.custom_torque_params and ui_state.torque_override_enabled:
+      return UiElement(f"{ui_state.torque_override_lat_accel_factor:.3f}", "L.A.F.", self.unit, rl.WHITE)
 
-    value = f"{lat_accel_factor:.3f}"
-    color = rl.Color(0, 255, 0, 255) if live_valid else rl.WHITE
+    ltp = sm['liveTorqueParameters']
+    value = f"{ltp.latAccelFactorFiltered:.3f}"
+    color = rl.Color(0, 255, 0, 255) if ltp.liveValid else rl.WHITE
     return UiElement(value, "L.A.F.", self.unit, color)
 
 

selfdrive/ui/sunnypilot/ui_state.py

@@ -6,7 +6,7 @@ See the LICENSE.md file in the root directory for more details.
 """
 from enum import Enum
 
-from cereal import messaging, log, custom
+from cereal import messaging, log, car, custom
 from openpilot.common.params import Params
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.display import OnroadBrightness
 from openpilot.sunnypilot.sunnylink.sunnylink_state import SunnylinkState
@@ -26,22 +26,20 @@ class OnroadTimerStatus(Enum):
 
 class UIStateSP:
   def __init__(self):
-    self.CP_SP: custom.CarParamsSP | None = None
     self.params = Params()
+    self.CP_SP: custom.CarParamsSP | None = None
+    self.has_icbm: bool = False
+    self.is_sp_release: bool = self.params.get_bool("IsReleaseSpBranch")
     self.sm_services_ext = [
       "modelManagerSP", "selfdriveStateSP", "longitudinalPlanSP", "backupManagerSP",
       "gpsLocation", "liveTorqueParameters", "carStateSP", "liveMapDataSP", "carParamsSP", "liveDelay"
     ]
 
     self.sunnylink_state = SunnylinkState()
-    self.update_params_()
 
     self.onroad_brightness_timer: int = 0
-    self.custom_interactive_timeout: int = self.params.get("InteractivityTimeout", return_default=True)
-    self.reset_onroad_sleep_timer()
-    self.CP_SP: custom.CarParamsSP | None = None
-    self.has_icbm: bool = False
-    self.is_sp_release: bool = self.params.get_bool("IsReleaseSpBranch")
+    self.custom_interactive_timeout: int = 0
+    self._sp_initialized: bool = False
 
   def update(self) -> None:
     if self.sunnylink_enabled:
@@ -123,11 +121,13 @@ class UIStateSP:
 
     return "disengaged"
 
-  def update_params_(self) -> None:
+  def update_params(self) -> None:
     CP_SP_bytes = self.params.get("CarParamsSPPersistent")
     if CP_SP_bytes is not None:
       self.CP_SP = messaging.log_from_bytes(CP_SP_bytes, custom.CarParamsSP)
       self.has_icbm = self.CP_SP.intelligentCruiseButtonManagementAvailable and self.params.get_bool("IntelligentCruiseButtonManagement")
+
+    self._enforce_constraints()
     self.active_bundle = self.params.get("ModelManager_ActiveBundle")
     self.blindspot = self.params.get_bool("BlindSpot")
     self.chevron_metrics = self.params.get("ChevronInfo")
@@ -143,11 +143,63 @@ class UIStateSP:
     self.standstill_timer = self.params.get_bool("StandstillTimer")
     self.sunnylink_enabled = self.params.get_bool("SunnylinkEnabled")
     self.torque_bar = self.params.get_bool("TorqueBar")
+    self.enforce_torque_control = self.params.get_bool("EnforceTorqueControl")
+    self.custom_torque_params = self.params.get_bool("CustomTorqueParams")
+    self.torque_override_enabled = self.params.get_bool("TorqueParamsOverrideEnabled")
+    self.torque_override_lat_accel_factor = float(self.params.get("TorqueParamsOverrideLatAccelFactor", return_default=True))
+    self.torque_override_friction = float(self.params.get("TorqueParamsOverrideFriction", return_default=True))
     self.true_v_ego_ui = self.params.get_bool("TrueVEgoUI")
     self.turn_signals = self.params.get_bool("ShowTurnSignals")
     self.boot_offroad_mode = self.params.get("DeviceBootMode", return_default=True)
     self.always_offroad = self.params.get_bool("OffroadMode")
 
+    if not self._sp_initialized:
+      self._sp_initialized = True
+      self.reset_onroad_sleep_timer()
+
+  def _enforce_constraints(self) -> None:
+    has_long = self.has_longitudinal_control
+    CP = self.CP
+
+    if CP is not None:
+      # Angle steering: no torque-based lateral controls
+      if CP.steerControlType == car.CarParams.SteerControlType.angle:
+        self.params.remove("EnforceTorqueControl")
+        self.params.remove("NeuralNetworkLateralControl")
+
+      # Alpha longitudinal: clear if not available
+      if not CP.alphaLongitudinalAvailable:
+        self.params.remove("AlphaLongitudinalEnabled")
+
+      # BSM not available: clear BSM-dependent settings
+      if not CP.enableBsm:
+        self.params.remove("AutoLaneChangeBsmDelay")
+    else:
+      # No CarParams: clear all car-dependent params as safety default
+      self.params.remove("EnforceTorqueControl")
+      self.params.remove("NeuralNetworkLateralControl")
+      self.params.remove("AlphaLongitudinalEnabled")
+
+    # No longitudinal control: no experimental mode or DEC
+    if not has_long:
+      self.params.remove("ExperimentalMode")
+      self.params.remove("DynamicExperimentalControl")
+
+    # ICBM: clear if not available or if full longitudinal control is active
+    if self.CP_SP is not None:
+      if not self.CP_SP.intelligentCruiseButtonManagementAvailable or has_long:
+        self.params.remove("IntelligentCruiseButtonManagement")
+        self.has_icbm = False
+    else:
+      self.params.remove("IntelligentCruiseButtonManagement")
+      self.has_icbm = False
+
+    # Cruise features requiring longitudinal or ICBM
+    if not (has_long or self.has_icbm):
+      self.params.remove("CustomAccIncrementsEnabled")
+      self.params.remove("SmartCruiseControlVision")
+      self.params.remove("SmartCruiseControlMap")
+
 
 class DeviceSP:
   @staticmethod
@@ -163,7 +215,6 @@ class DeviceSP:
     if _ui_state.onroad_brightness_timer != 0:
       if _ui_state.onroad_brightness == OnroadBrightness.AUTO_DARK:
         return max(30.0, cur_brightness)
-      # For AUTO (Default) and Manual modes (while timer running), use standard brightness
       return cur_brightness
 
     # 0: Auto (Default), 1: Auto (Dark), 2: Screen Off

selfdrive/ui/ui_state.py

@@ -15,7 +15,6 @@ from openpilot.system.hardware import HARDWARE, PC
 from openpilot.selfdrive.ui.sunnypilot.ui_state import UIStateSP, DeviceSP
 
 BACKLIGHT_OFFROAD = 65 if HARDWARE.get_device_type() == "mici" else 50
-PARAM_UPDATE_TIME = 5.0
 
 
 class UIStatus(Enum):
@@ -60,7 +59,6 @@ class UIState(UIStateSP):
         "carOutput",
         "carControl",
         "liveParameters",
-        "testJoystick",
         "rawAudioData",
       ] + self.sm_services_ext
     )
@@ -76,7 +74,7 @@ class UIState(UIStateSP):
 
     # Core state variables
     self.is_metric: bool = self.params.get_bool("IsMetric")
-    self.is_release = self.params.get_bool("IsReleaseBranch")
+    self.is_release = False  # self.params.get_bool("IsReleaseBranch")
     self.always_on_dm: bool = self.params.get_bool("AlwaysOnDM")
     self.started: bool = False
     self.ignition: bool = False
@@ -84,15 +82,15 @@ class UIState(UIStateSP):
     self.panda_type: log.PandaState.PandaType = log.PandaState.PandaType.unknown
     self.personality: log.LongitudinalPersonality = log.LongitudinalPersonality.standard
     self.has_longitudinal_control: bool = False
-    self.is_body: bool | None = None
     self.CP: car.CarParams | None = None
     self.light_sensor: float = -1.0
-    self._param_update_time: float = -PARAM_UPDATE_TIME
+    self._param_update_time: float = 0.0
 
     # Callbacks
     self._offroad_transition_callbacks: list[Callable[[], None]] = []
     self._engaged_transition_callbacks: list[Callable[[], None]] = []
-    self._on_body_changed_callbacks: list[Callable[[], None]] = []
+
+    self.update_params()
 
   def add_offroad_transition_callback(self, callback: Callable[[], None]):
     self._offroad_transition_callbacks.append(callback)
@@ -100,9 +98,6 @@ class UIState(UIStateSP):
   def add_engaged_transition_callback(self, callback: Callable[[], None]):
     self._engaged_transition_callbacks.append(callback)
 
-  def add_on_body_changed_callbacks(self, callback: Callable[[], None]):
-    self._on_body_changed_callbacks.append(callback)
-
   @property
   def engaged(self) -> bool:
     return self.started and (self.sm["selfdriveState"].enabled or self.sm["selfdriveStateSP"].mads.enabled)
@@ -118,7 +113,7 @@ class UIState(UIStateSP):
     self.sm.update(0)
     self._update_state()
     self._update_status()
-    if time.monotonic() - self._param_update_time >= PARAM_UPDATE_TIME:
+    if time.monotonic() - self._param_update_time > 5.0:
       self.update_params()
     device.update()
     UIStateSP.update(self)
@@ -193,13 +188,7 @@ class UIState(UIStateSP):
         self.has_longitudinal_control = self.params.get_bool("AlphaLongitudinalEnabled")
       else:
         self.has_longitudinal_control = self.CP.openpilotLongitudinalControl
-
-      if self.is_body != self.CP.notCar:
-        self.is_body = self.CP.notCar
-        for callback in self._on_body_changed_callbacks:
-          callback()
-
-    UIStateSP.update_params_(self)
+    UIStateSP.update_params(self)
     self._param_update_time = time.monotonic()
 
 

sunnypilot/common/version.h

@@ -1 +1 @@
-#define SUNNYPILOT_VERSION "2026.001.000"
+#define SUNNYPILOT_VERSION "2026.001.002"

sunnypilot/mads/mads.py

@@ -147,6 +147,7 @@ class ModularAssistiveDrivingSystem:
       self.events.remove(EventName.speedTooLow)
       self.events.remove(EventName.cruiseDisabled)
       self.events.remove(EventName.manualRestart)
+      self.events.remove(EventName.espActive)
 
     selfdrive_enable_events = self.events.has(EventName.pcmEnable) or self.events.has(EventName.buttonEnable)
     set_speed_btns_enable = any(be.type in SET_SPEED_BUTTONS for be in CS.buttonEvents)

sunnypilot/modeld_v2/SConscript

@@ -1,6 +1,5 @@
 import os
 import glob
-from tinygrad import Device
 
 Import('env', 'arch')
 lenv = env.Clone()
@@ -22,19 +21,10 @@ if PC:
   if outputs:
     lenv.Command(outputs, inputs, cmd)
 
-available = set(Device.get_available_devices())
-if 'CUDA' in available:
-  tg_backend = 'CUDA'
-  tg_flags = f'DEV={tg_backend}'
-elif 'QCOM' in available:
-  tg_backend = 'QCOM'
-  tg_flags = f'DEV={tg_backend} FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1'
-else:
-  tg_backend = 'CPU' if arch == 'Darwin' else 'CPU:LLVM'
-  # THREADS=0 is need to prevent bug: https://github.com/tinygrad/tinygrad/issues/14689
-  tg_flags = f'DEV={tg_backend} THREADS=0'
-
-mac_brew_string = f'HOME={os.path.expanduser("~")}' if arch == 'Darwin' else ''
+tg_flags = {
+  'larch64': 'DEV=QCOM FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0',
+  'Darwin': f'DEV=CPU THREADS=0 HOME={os.path.expanduser("~")}',
+}.get(arch, 'DEV=CPU CPU_LLVM=1 THREADS=0')
 
 image_flag = {
   'larch64': 'IMAGE=2',
@@ -48,7 +38,7 @@ def tg_compile(flags, model_name):
   return lenv.Command(
     out,
     [fn + ".onnx"] + tinygrad_files,
-    f'{pythonpath_string} {tg_flags} {mac_brew_string} {image_flag} python3 {Dir("#tinygrad_repo").abspath}/examples/openpilot/compile3.py {fn}.onnx {out}'
+    f'{pythonpath_string} {flags} {image_flag} python3 {Dir("#tinygrad_repo").abspath}/examples/openpilot/compile3.py {fn}.onnx {out}'
   )
 
 # Compile models
@@ -56,9 +46,9 @@ for model_name in ['supercombo', 'driving_vision', 'driving_off_policy', 'drivin
   if File(f"models/{model_name}.onnx").exists():
     tg_compile(tg_flags, model_name)
 
-script_files = [File("warp.py"), File(Dir("#selfdrive/modeld").File("compile_modeld.py").abspath)]
+script_files = [File("warp.py"), File(Dir("#selfdrive/modeld").File("compile_warp.py").abspath)]
 pythonpath_string = 'PYTHONPATH="${PYTHONPATH}:' + env.Dir("#tinygrad_repo").abspath + ':' + env.Dir("#").abspath + '"'
-compile_warp_cmd = f'{pythonpath_string} {tg_flags} {mac_brew_string} {image_flag} python3 -m sunnypilot.modeld_v2.warp'
+compile_warp_cmd = f'{pythonpath_string} {tg_flags} python3 -m sunnypilot.modeld_v2.warp'
 
 from openpilot.common.transformations.camera import _ar_ox_fisheye, _os_fisheye
 warp_targets = []

sunnypilot/modeld_v2/tests/test_warp.py

@@ -2,11 +2,8 @@ import os
 os.environ['DEV'] = 'CPU'
 import pytest
 import numpy as np
-from openpilot.sunnypilot.modeld_v2.warp import CAMERA_CONFIGS
-from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
-from openpilot.sunnypilot.modeld_v2.warp import Warp
-from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE
-MODEL_W, MODEL_H = MEDMODEL_INPUT_SIZE
+from openpilot.selfdrive.modeld.compile_warp import get_nv12_info, CAMERA_CONFIGS
+from openpilot.sunnypilot.modeld_v2.warp import Warp, MODEL_W, MODEL_H
 
 VISION_NAME_PAIRS = [  # needed to account for supercombos input_imgs
   ('img', 'big_img'),

sunnypilot/modeld_v2/warp.py

@@ -6,61 +6,29 @@ from tinygrad.tensor import Tensor
 from tinygrad.engine.jit import TinyJit
 from tinygrad.device import Device
 
-# https://github.com/tinygrad/tinygrad/issues/15682
-from tinygrad.uop.ops import UOp, Ops
-_orig = UOp.__reduce__
-UOp.__reduce__ = lambda self: (UOp.unique, ()) if self.op is Ops.UNIQUE else _orig(self)
 from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
-from openpilot.selfdrive.modeld.compile_modeld import (
-  NV12Frame, make_frame_prepare,
+from openpilot.selfdrive.modeld.compile_warp import (
+  CAMERA_CONFIGS, MEDMODEL_INPUT_SIZE, make_frame_prepare, make_update_both_imgs,
+  warp_pkl_path,
 )
-from openpilot.common.transformations.camera import _ar_ox_fisheye, _os_fisheye
-
-CAMERA_CONFIGS = [
-  (_ar_ox_fisheye.width, _ar_ox_fisheye.height),  # tici: 1928x1208
-  (_os_fisheye.width, _os_fisheye.height),        # mici: 1344x760
-]
-from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE
 
 MODELS_DIR = Path(__file__).parent / 'models'
-
+MODEL_W, MODEL_H = MEDMODEL_INPUT_SIZE
 UPSTREAM_BUFFER_LENGTH = 5
 
-def warp_pkl_path(cam_w, cam_h):
-  return MODELS_DIR / f'warp_{cam_w}x{cam_h}_tinygrad.pkl'
-
-def make_update_img_input(frame_prepare, model_w, model_h):
-  def update_img_input_tinygrad(tensor, frame, M_inv):
-    M_inv = M_inv.to(Device.DEFAULT)
-    new_img = frame_prepare(frame, M_inv)
-    tensor.assign(tensor[6:].cat(new_img, dim=0).contiguous())
-    return Tensor.cat(tensor[:6], tensor[-6:], dim=0).contiguous().reshape(1, 12, model_h//2, model_w//2)
-  return update_img_input_tinygrad
-
-def make_update_both_imgs(frame_prepare, model_w, model_h):
-  update_img = make_update_img_input(frame_prepare, model_w, model_h)
-
-  def update_both_imgs_tinygrad(calib_img_buffer, new_img, M_inv,
-                                calib_big_img_buffer, new_big_img, M_inv_big):
-    calib_img_pair = update_img(calib_img_buffer, new_img, M_inv)
-    calib_big_img_pair = update_img(calib_big_img_buffer, new_big_img, M_inv_big)
-    return calib_img_pair, calib_big_img_pair
-  return update_both_imgs_tinygrad
-
 
 def v2_warp_pkl_path(cam_w, cam_h, buffer_length):
   return MODELS_DIR / f'warp_{cam_w}x{cam_h}_b{buffer_length}_tinygrad.pkl'
 
 
-def compile_v2_warp(cam_w, cam_h, buffer_length, model_w=MEDMODEL_INPUT_SIZE[0], model_h=MEDMODEL_INPUT_SIZE[1]):
+def compile_v2_warp(cam_w, cam_h, buffer_length):
   _, _, _, yuv_size = get_nv12_info(cam_w, cam_h)
-  img_buffer_shape = (buffer_length * 6, model_h // 2, model_w // 2)
+  img_buffer_shape = (buffer_length * 6, MODEL_H // 2, MODEL_W // 2)
 
   print(f"Compiling v2 warp for {cam_w}x{cam_h} buffer_length={buffer_length}...")
 
-  nv12 = NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h))
-  frame_prepare = make_frame_prepare(nv12, model_w, model_h)
-  update_both_imgs = make_update_both_imgs(frame_prepare, model_w, model_h)
+  frame_prepare = make_frame_prepare(cam_w, cam_h, MODEL_W, MODEL_H)
+  update_both_imgs = make_update_both_imgs(frame_prepare, MODEL_W, MODEL_H)
   update_img_jit = TinyJit(update_both_imgs, prune=True)
 
   full_buffer = Tensor.zeros(img_buffer_shape, dtype='uint8').contiguous().realize()
@@ -94,11 +62,9 @@ def compile_v2_warp(cam_w, cam_h, buffer_length, model_w=MEDMODEL_INPUT_SIZE[0],
 
 
 class Warp:
-  def __init__(self, buffer_length=2, model_w=MEDMODEL_INPUT_SIZE[0], model_h=MEDMODEL_INPUT_SIZE[1]):
+  def __init__(self, buffer_length=2):
     self.buffer_length = buffer_length
-    self.model_w = model_w
-    self.model_h = model_h
-    self.img_buffer_shape = (buffer_length * 6, model_h // 2, model_w // 2)
+    self.img_buffer_shape = (buffer_length * 6, MODEL_H // 2, MODEL_W // 2)
 
     self.jit_cache = {}
     self.full_buffers = {k: Tensor.zeros(self.img_buffer_shape, dtype='uint8').contiguous().realize() for k in ['img', 'big_img']}
@@ -126,9 +92,8 @@ class Warp:
           with open(upstream_pkl, 'rb') as f:
             self.jit_cache[key] = pickle.load(f)
       if key not in self.jit_cache:
-        nv12 = NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h))
-        frame_prepare = make_frame_prepare(nv12, self.model_w, self.model_h)
-        update_both_imgs = make_update_both_imgs(frame_prepare, self.model_w, self.model_h)
+        frame_prepare = make_frame_prepare(cam_w, cam_h, MODEL_W, MODEL_H)
+        update_both_imgs = make_update_both_imgs(frame_prepare, MODEL_W, MODEL_H)
         self.jit_cache[key] = TinyJit(update_both_imgs, prune=True)
 
     if key not in self._nv12_cache:

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://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_v17.json"
+  MODEL_URL = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_v16.json"
 
   def __init__(self, params: Params):
     self.params = params

sunnypilot/selfdrive/locationd/locationd.cc

@@ -255,7 +255,7 @@ void Localizer::handle_sensor(double current_time, const cereal::SensorEventData
   }
 
   // Gyro Uncalibrated
-  if (log.which() == cereal::SensorEventData::GYRO_UNCALIBRATED) {
+  if (log.getSensor() == SENSOR_GYRO_UNCALIBRATED && log.getType() == SENSOR_TYPE_GYROSCOPE_UNCALIBRATED) {
     auto v = log.getGyroUncalibrated().getV();
     auto meas = Vector3d(-v[2], -v[1], -v[0]);
 
@@ -273,7 +273,7 @@ void Localizer::handle_sensor(double current_time, const cereal::SensorEventData
   }
 
   // Accelerometer
-  if (log.which() == cereal::SensorEventData::ACCELERATION) {
+  if (log.getSensor() == SENSOR_ACCELEROMETER && log.getType() == SENSOR_TYPE_ACCELEROMETER) {
     auto v = log.getAcceleration().getV();
 
     // TODO: reduce false positives and re-enable this check

sunnypilot/selfdrive/locationd/tests/test_locationd.py

@@ -19,7 +19,7 @@ if platform.system() == 'Darwin':
 
 class TestLocationdProc:
   LLD_MSGS = ['gpsLocationExternal', 'cameraOdometry', 'carState', 'liveCalibration',
-              'accelerometer', 'gyroscope']
+              'accelerometer', 'gyroscope', 'magnetometer']
 
   def setup_method(self):
     self.pm = messaging.PubMaster(self.LLD_MSGS)

sunnypilot/selfdrive/locationd/torqued_ext.py

@@ -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 numpy as np
 
 from cereal import car
@@ -18,7 +17,6 @@ RELAXED_MIN_BUCKET_POINTS = np.array([1, 200, 300, 500, 500, 300, 200, 1])
 ALLOWED_CARS = ['toyota', 'hyundai', 'rivian', 'honda']
 
 
-
 class TorqueEstimatorExt:
   def __init__(self, CP: car.CarParams):
     self.CP = CP
@@ -28,6 +26,7 @@ class TorqueEstimatorExt:
     self.enforce_torque_control_toggle = self._params.get_bool("EnforceTorqueControl")  # only during init
     self.use_params = self.CP.brand in ALLOWED_CARS and self.CP.lateralTuning.which() == 'torque'
     self.use_live_torque_params = self._params.get_bool("LiveTorqueParamsToggle")
+    self.custom_torque_params = self._params.get_bool("CustomTorqueParams")
     self.torque_override_enabled = self._params.get_bool("TorqueParamsOverrideEnabled")
     self.min_bucket_points = RELAXED_MIN_BUCKET_POINTS
     self.factor_sanity = 0.0
@@ -51,13 +50,14 @@ class TorqueEstimatorExt:
   def _update_params(self):
     if self.frame % int(PARAMS_UPDATE_PERIOD / DT_MDL) == 0:
       self.use_live_torque_params = self._params.get_bool("LiveTorqueParamsToggle")
+      self.custom_torque_params = self._params.get_bool("CustomTorqueParams")
       self.torque_override_enabled = self._params.get_bool("TorqueParamsOverrideEnabled")
 
   def update_use_params(self):
     self._update_params()
 
     if self.enforce_torque_control_toggle:
-      if self.torque_override_enabled:
+      if self.custom_torque_params and self.torque_override_enabled:
         self.use_params = False
       else:
         self.use_params = self.use_live_torque_params

sunnypilot/sunnylink/athena/sunnylinkd.py

@@ -18,7 +18,7 @@ import time
 
 from jsonrpc import dispatcher
 from functools import partial
-from openpilot.common.params import Params
+from openpilot.common.params import Params, ParamKeyType
 from openpilot.common.realtime import set_core_affinity
 from openpilot.common.swaglog import cloudlog
 from openpilot.system.hardware.hw import Paths
@@ -31,6 +31,8 @@ import cereal.messaging as messaging
 from openpilot.sunnypilot.selfdrive.car.sync_car_list_param import update_car_list_param
 from openpilot.sunnypilot.sunnylink.api import SunnylinkApi
 from openpilot.sunnypilot.sunnylink.utils import sunnylink_need_register, sunnylink_ready, get_param_as_byte, save_param_from_base64_encoded_string
+from openpilot.sunnypilot.sunnylink.capabilities import generate_capabilities, CAPABILITY_LABELS
+from openpilot.sunnypilot.sunnylink.tools.generate_settings_schema import generate_schema
 
 SUNNYLINK_ATHENA_HOST = os.getenv('SUNNYLINK_ATHENA_HOST', 'wss://ws.stg.api.sunnypilot.ai')
 HANDLER_THREADS = int(os.getenv('HANDLER_THREADS', "4"))
@@ -44,12 +46,15 @@ params = Params()
 
 # Parameters that should never be remotely modified
 BLOCKED_PARAMS = {
+  "AdbEnabled",
   "CompletedSunnylinkConsentVersion",
   "CompletedTrainingVersion",
   "GithubUsername",  # Could grant SSH access
   "GithubSshKeys",   # Direct SSH key injection
   "HasAcceptedTerms",
   "HasAcceptedTermsSP",
+  "OnroadCycleRequested",      # Prevent remote cycle trigger
+  "ParamsVersion",         # Device-managed version counter
 }
 
 
@@ -199,34 +204,18 @@ def getParamsAllKeysV1() -> dict[str, str]:
 
 @dispatcher.add_method
 def getParamsMetadata() -> str:
-  """Compressed equivalent of getParamsAllKeysV1 — same struct, gzipped + base64."""
+  """Return settings_ui.json + live capabilities as gzip-compressed, base64-encoded string.
+
+  Reads settings_ui.json, injects live capabilities from CarParams, compresses,
+  and returns. Single RPC for the frontend to get the complete settings UI and
+  runtime capabilities.
+  """
   try:
-    with open(METADATA_PATH) as f:
-      metadata = json.load(f)
-  except Exception:
-    cloudlog.exception("sunnylinkd.getParamsMetadata.exception")
-    metadata = {}
-
-  try:
-    available_keys: list[str] = [k.decode('utf-8') for k in Params().all_keys()]
-
-    params_list: list[dict] = []
-    for key in available_keys:
-      value = get_param_as_byte(key, get_default=True)
-
-      param_entry: dict = {
-        "key": key,
-        "type": int(params.get_type(key).value),
-        "default_value": base64.b64encode(value).decode('utf-8') if value else None,
-      }
-
-      if key in metadata:
-        param_entry["_extra"] = metadata[key]
-
-      params_list.append(param_entry)
-
-    raw = json.dumps(params_list, separators=(',', ':')).encode('utf-8')
-    return base64.b64encode(gzip.compress(raw)).decode('utf-8')
+    schema = generate_schema()
+    schema["capabilities"] = generate_capabilities()
+    schema["capability_labels"] = CAPABILITY_LABELS
+    raw = json.dumps(schema, separators=(",", ":")).encode("utf-8")
+    return base64.b64encode(gzip.compress(raw)).decode("utf-8")
   except Exception:
     cloudlog.exception("sunnylinkd.getParamsMetadata.exception")
     raise
@@ -238,12 +227,25 @@ def getParams(params_keys: list[str], compression: bool = False) -> str | dict[s
   available_keys: list[str] = [k.decode('utf-8') for k in Params().all_keys()]
 
   try:
+    zero_values: dict[int, bytes] = {
+      ParamKeyType.STRING.value: b"",
+      ParamKeyType.BOOL.value: b"0",
+      ParamKeyType.INT.value: b"0",
+      ParamKeyType.FLOAT.value: b"0.0",
+      ParamKeyType.TIME.value: b"",
+      ParamKeyType.JSON.value: b"{}",
+      ParamKeyType.BYTES.value: b"",
+    }
+
     param_keys_validated = [key for key in params_keys if key in available_keys]
     params_dict: dict[str, list[dict[str, str | bool | int]]] = {"params": []}
     for key in param_keys_validated:
       value = get_param_as_byte(key)
       if value is None:
-        continue
+        value = get_param_as_byte(key, get_default=True)
+      if value is None:
+        param_type = params.get_type(key)
+        value = zero_values.get(param_type.value, b"")
 
       params_dict["params"].append({
         "key": key,
@@ -274,6 +276,13 @@ def saveParams(params_to_update: dict[str, str], compression: bool = False) -> N
     except Exception as e:
       cloudlog.error(f"sunnylinkd.saveParams.exception {e}")
 
+  # Increment version counter for frontend change detection
+  try:
+    current = int(params.get("ParamsVersion") or "0")
+    params.put("ParamsVersion", str(current + 1))
+  except Exception:
+    pass
+
 
 def startLocalProxy(global_end_event: threading.Event, remote_ws_uri: str, local_port: int) -> dict[str, int]:
   sunnylink_dongle_id = params.get("SunnylinkDongleId")

sunnypilot/sunnylink/capabilities.py

@@ -0,0 +1,168 @@
+"""
+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
+
+from cereal import car, custom, messaging
+from opendbc.car.hyundai.values import CAR as HYUNDAI_CAR, UNSUPPORTED_LONGITUDINAL_CAR
+from opendbc.car.subaru.values import CAR as SUBARU_CAR, SubaruFlags
+from opendbc.sunnypilot.car.tesla.values import TeslaFlagsSP
+from openpilot.common.params import Params
+from openpilot.common.swaglog import cloudlog
+from openpilot.system.hardware import HARDWARE
+
+
+# Wire-protocol version for the capabilities payload. Bump on breaking changes
+# only; additive fields are backward-compatible and do not require a bump.
+PROTOCOL_VERSION = 1
+
+# All capability fields that rules may reference.
+# Non-boolean fields must have defaults in CAPABILITY_DEFAULTS.
+CAPABILITY_FIELDS = (
+  "protocol_version",
+  "has_longitudinal_control",
+  "has_icbm",
+  "icbm_available",
+  "torque_allowed",
+  "brand",
+  "pcm_cruise",
+  "alpha_long_available",
+  "steer_control_type",
+  "enable_bsm",
+  "is_release",
+  "is_sp_release",
+  "is_development",
+  "tesla_has_vehicle_bus",
+  "has_stop_and_go",
+  "stock_longitudinal",
+  "device_type",
+  "subaru_has_sng",
+  "hyundai_alpha_long_available",
+)
+
+CAPABILITY_LABELS: dict[str, str] = {
+  "protocol_version": "Capabilities protocol version",
+  "has_longitudinal_control": "sunnypilot longitudinal control",
+  "has_icbm": "ICBM enabled",
+  "icbm_available": "ICBM available",
+  "torque_allowed": "torque steering (not available for angle steering vehicles)",
+  "brand": "Vehicle brand",
+  "pcm_cruise": "PCM cruise",
+  "alpha_long_available": "Alpha Longitudinal available",
+  "steer_control_type": "Steer control type",
+  "enable_bsm": "BSM available",
+  "is_release": "Release branch",
+  "is_sp_release": "SP release branch",
+  "is_development": "Development branch",
+  "tesla_has_vehicle_bus": "Tesla vehicle bus",
+  "has_stop_and_go": "Stop and Go",
+  "stock_longitudinal": "stock longitudinal",
+  "device_type": "Device type",
+  "subaru_has_sng": "Subaru Stop-and-Go available",
+  "hyundai_alpha_long_available": "Hyundai Alpha Longitudinal available",
+}
+
+# Explicit defaults for non-boolean capability fields
+CAPABILITY_DEFAULTS: dict[str, bool | str | int] = {
+  "brand": "",
+  "steer_control_type": "",
+  "device_type": "",
+  "protocol_version": PROTOCOL_VERSION,
+}
+
+
+def _bundle_field(bundle: dict | None, key: str) -> str:
+  return bundle.get(key, "") if isinstance(bundle, dict) else ""
+
+
+def generate_capabilities(params: Params | None = None) -> dict:
+  """Generate a SettingsCapabilities dict from CarParams + boolean params.
+
+  When CarPlatformBundle is present, brand and platform come from the bundle
+  (mirrors Raylib). CarParams* deserialization is the fallback before the bundle
+  is written (early after first pairing).
+  """
+  params = params or Params()
+
+  caps: dict = {field: CAPABILITY_DEFAULTS.get(field, False) for field in CAPABILITY_FIELDS}
+
+  # Wire-protocol version is always set explicitly.
+  caps["protocol_version"] = PROTOCOL_VERSION
+
+  # Hardware + boolean params (no CarParams dependency)
+  caps["device_type"] = HARDWARE.get_device_type()
+  caps["is_release"] = False  # params.get_bool("IsReleaseBranch")
+  caps["is_sp_release"] = params.get_bool("IsReleaseSpBranch")
+  caps["is_development"] = params.get_bool("IsDevelopmentBranch")
+  caps["stock_longitudinal"] = params.get_bool("ToyotaEnforceStockLongitudinal")
+
+  bundle = params.get("CarPlatformBundle")
+  bundle_brand = _bundle_field(bundle, "brand")
+  bundle_platform = _bundle_field(bundle, "platform")
+
+  # Bundle-first brand resolution; CP is fallback only.
+  if bundle_brand:
+    caps["brand"] = bundle_brand
+
+  # CarParams-derived capabilities
+  CP_bytes = params.get("CarParamsPersistent")
+  if CP_bytes is not None:
+    try:
+      CP = messaging.log_from_bytes(CP_bytes, car.CarParams)
+      caps["alpha_long_available"] = bool(CP.alphaLongitudinalAvailable)
+      if CP.alphaLongitudinalAvailable:
+        caps["has_longitudinal_control"] = params.get_bool("AlphaLongitudinalEnabled")
+      else:
+        caps["has_longitudinal_control"] = bool(CP.openpilotLongitudinalControl)
+      # CP.steerControlType is the physical control mode (angle / torque).
+      # CP.lateralTuning.which() returns the tuning class (pid / torque / indi)
+      # which is a separate concept and is not interchangeable.
+      caps["steer_control_type"] = str(CP.steerControlType)
+      caps["torque_allowed"] = CP.steerControlType != car.CarParams.SteerControlType.angle
+      if not caps["brand"] and CP.brand:
+        caps["brand"] = str(CP.brand)
+      caps["pcm_cruise"] = bool(CP.pcmCruise)
+      caps["enable_bsm"] = bool(CP.enableBsm)
+      # Generic SnG fallback. Brand-specific opaque flags below override.
+      caps["has_stop_and_go"] = bool(CP.openpilotLongitudinalControl)
+    except Exception:
+      cloudlog.exception("capabilities: failed to deserialize CarParamsPersistent")
+
+  # CarParamsSP-derived capabilities
+  CP_SP_bytes = params.get("CarParamsSPPersistent")
+  if CP_SP_bytes is not None:
+    try:
+      CP_SP = messaging.log_from_bytes(CP_SP_bytes, custom.CarParamsSP)
+      caps["icbm_available"] = bool(CP_SP.intelligentCruiseButtonManagementAvailable)
+      caps["has_icbm"] = bool(CP_SP.intelligentCruiseButtonManagementAvailable) and params.get_bool("IntelligentCruiseButtonManagement")
+      caps["tesla_has_vehicle_bus"] = bool(CP_SP.flags & TeslaFlagsSP.HAS_VEHICLE_BUS)
+    except Exception:
+      cloudlog.exception("capabilities: failed to deserialize CarParamsSPPersistent")
+
+  # Brand-specific opaque flags. Mirror Raylib brand-settings logic so the
+  # device and the dashboard agree on per-platform availability without
+  # leaking the platform identifier over the wire.
+  if caps["brand"] == "subaru" and bundle_platform:
+    try:
+      flags = SUBARU_CAR[bundle_platform].config.flags
+      caps["subaru_has_sng"] = not bool(flags & (SubaruFlags.GLOBAL_GEN2 | SubaruFlags.HYBRID))
+      caps["has_stop_and_go"] = caps["subaru_has_sng"]
+    except KeyError:
+      cloudlog.exception(f"capabilities: unknown subaru platform {bundle_platform!r}")
+
+  if caps["brand"] == "hyundai" and bundle_platform:
+    try:
+      unsupported = set().union(*UNSUPPORTED_LONGITUDINAL_CAR.values())
+      caps["hyundai_alpha_long_available"] = HYUNDAI_CAR[bundle_platform] not in unsupported
+    except KeyError:
+      cloudlog.exception(f"capabilities: unknown hyundai platform {bundle_platform!r}")
+
+  return caps
+
+
+def generate_capabilities_json(params: Params | None = None) -> str:
+  """Generate SettingsCapabilities as a JSON string."""
+  return json.dumps(generate_capabilities(params), separators=(",", ":"))

sunnypilot/sunnylink/docs/README.md

@@ -0,0 +1,588 @@
+# sunnylink Settings UI Guide
+
+> One YAML file per page. Edit, run the compiler, commit. The sunnylink frontend updates automatically.
+
+For detailed architecture, capability fields, parity analysis, and dialog mappings, see [REFERENCE.md](REFERENCE.md).
+
+## What you edit (and what's generated)
+
+| File | What | When to edit |
+|------|------|-------------|
+| `settings_ui_src/pages/<page>.yaml` | One YAML per page (panel). Contains panel metadata + sections + items + sub_panels inline. | Adding/changing/removing a setting. |
+| `settings_ui_src/pages/vehicle.yaml` | Per-brand settings page (`kind: vehicle`). Each brand is a section. | Adding/changing a vehicle-specific setting. |
+| `settings_ui_src/_macros.yaml` | Named rule fragments referenced via `{$ref: "#/macros/<name>"}`. | Adding a reusable rule (e.g. a new platform gate). |
+| **`settings_ui.json`** | **Generated from src tree by `compile_settings_ui.py`. Do not edit by hand.** | Never. Compiler emits it; frontend reads it. |
+
+Pages today: `steering, cruise, display, visuals, toggles, device, software, developer, models, vehicle` (10).
+
+Run `python sunnypilot/sunnylink/tools/compile_settings_ui.py` after edits. Add `--check` in CI to fail on out-of-sync `settings_ui.json`.
+
+Display metadata (titles, descriptions, options, min/max/step/unit) is inline on each item. There is no separate metadata file.
+
+## Page file shape
+
+A page YAML contains the whole panel: metadata at the top, then `sections`. Each section has its own `items` and (optionally) `sub_panels`. Sub-panels are nested inside the section they belong to. Items appear in the order written in the file.
+
+```yaml
+# yaml-language-server: $schema=../_schemas/page.schema.json
+id: steering
+label: Steering
+icon: steering_wheel
+order: 1
+remote_configurable: true
+description: Lateral control, lane changes, and steering behavior
+
+sections:
+  - id: mads
+    title: Modular Assistive Driving System (MADS)
+    items:
+      - key: Mads
+        widget: toggle
+        title: Enable Modular Assistive Driving System (MADS)
+        description: |
+          Enable the beloved MADS feature. Disable toggle to revert back
+          to stock sunnypilot engagement/disengagement.
+        enablement:
+          - {$ref: "#/macros/offroad"}
+
+    sub_panels:
+      - id: mads_settings
+        label: MADS Settings
+        trigger_key: Mads
+        trigger_condition: {type: param, key: Mads, equals: true}
+        items:
+          - key: MadsMainCruiseAllowed
+            widget: toggle
+            title: Toggle with Main Cruise
+            description: |
+              Note: For vehicles without LFA/LKAS button, disabling this will
+              prevent lateral control engagement.
+            enablement:
+              - {$ref: "#/macros/offroad"}
+              - {$ref: "#/macros/mads_full_platforms"}
+```
+
+The vehicle page has the same shape but declares `kind: vehicle`; each section's `id` becomes a brand key under `vehicle_settings` in the compiled JSON.
+
+## Macros (named rule fragments)
+
+`_macros.yaml` declares reusable rule lists. Reference them from any rules array via `{$ref: "#/macros/<name>"}`.
+
+```yaml
+macros:
+  offroad: [{type: offroad_only}]
+  longitudinal: [{type: capability, field: has_longitudinal_control, equals: true}]
+  mads_full_platforms:
+    - type: not
+      condition:
+        type: any
+        conditions:
+          - {type: capability, field: brand, equals: rivian}
+          - type: all
+            conditions:
+              - {type: capability, field: brand, equals: tesla}
+              - type: not
+                condition: {type: capability, field: tesla_has_vehicle_bus, equals: true}
+```
+
+In an item:
+
+```yaml
+enablement:
+  - {$ref: "#/macros/offroad"}
+  - {$ref: "#/macros/mads_full_platforms"}
+```
+
+The compiler splices a list-context `$ref` into its parent list. Macros may reference other macros up to depth 3; cycles are an error.
+
+## Compiler workflow
+
+```
+1. common/params_keys.h               — add/remove the C++ param key
+2. params_metadata.json               — automated via update_params_metadata.py
+3. settings_ui_src/pages/<page>.yaml  — add/edit/remove the item in the right section
+4. python sunnypilot/sunnylink/tools/compile_settings_ui.py
+5. python sunnypilot/sunnylink/tools/validate_settings_ui.py  (or: --check on the compiler)
+6. uv run python -m pytest sunnypilot/sunnylink/tests/   # run regression + compiler tests
+7. commit
+```
+
+CI runs `compile_settings_ui.py --check` to fail on hand-edited `settings_ui.json`.
+
+## Compiled output reference (schema contract)
+
+The tables below describe the **compiled** `settings_ui.json` schema — what the frontend consumes at runtime. JSON snippets show the wire shape; in the src tree you author YAML that compiles to the same shape. Use these as a contract reference for valid fields, their meanings, and rule types.
+
+## Quick reference: widget types
+
+| Widget | Use for | Fields needed |
+|--------|---------|---------------|
+| `toggle` | On/off boolean | `title` |
+| `multiple_button` | 2-4 discrete options | `title` + `options` array |
+| `option` | Numeric range or dropdown | `title` + `min/max/step` or `options` |
+| `info` | Read-only display | `title` |
+
+## Quick reference: item fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `key` | Yes | Param key name (must exist in `params_keys.h`) |
+| `widget` | Yes | `toggle`, `option`, `multiple_button`, `button`, `info` |
+| `title` | Yes | Display name shown to the user |
+| `description` | No | Inline explanatory text below the title. May be empty when only `details` is used. |
+| `details` | No | Extended help text shown in a modal when the user taps an "i" button on the row. Independent of `description`: either, both, or neither may be present. |
+| `options` | For selectors | Array of `{"value": 0, "label": "Off"}` objects (see per-option enablement below) |
+| `min`, `max`, `step` | For sliders | Numeric range constraints |
+| `unit` | No | Unit label. Static: `"seconds"`. Dynamic: `{"metric": "km/h", "imperial": "mph"}` (resolved by IsMetric) |
+| `visibility` | No | Rules for show/hide. Settings are never hidden, always dimmed with UNAVAILABLE badge when rules fail |
+| `enablement` | No | Rules for enabled/disabled (all must pass). Dimmed with badge when rules fail |
+| `blocked` | No | `true` for device-only settings that cannot be modified remotely. Frontend shows as read-only |
+| `title_param_suffix` | No | Dynamic title suffix. Example: `{"param": "IsMetric", "values": {"0": "mph", "1": "km/h"}}` |
+| `sub_items` | No | Nested child items |
+| `needs_onroad_cycle` | No | `true` if changing this param triggers a system restart. Frontend shows a "Restart" badge. See [REFERENCE.md - Remote Onroad Cycle](REFERENCE.md#remote-onroad-cycle) |
+
+## Quick reference: rule types
+
+| Rule | Example | Use for |
+|------|---------|---------|
+| `offroad_only` | `{"type": "offroad_only"}` | Grey out while driving |
+| `not_engaged` | `{"type": "not_engaged"}` | Grey out only while engaged (started + selfdrive/MADS active) |
+| `capability` | `{"type": "capability", "field": "has_longitudinal_control", "equals": true}` | Car-dependent visibility |
+| `param` | `{"type": "param", "key": "Mads", "equals": true}` | Show/enable based on another setting |
+| `param_compare` | `{"type": "param_compare", "key": "SpeedLimitMode", "op": ">", "value": 0}` | Numeric comparison |
+| `not` | `{"type": "not", "condition": {...}}` | Negate a rule |
+| `any` | `{"type": "any", "conditions": [...]}` | OR logic |
+| `all` | `{"type": "all", "conditions": [...]}` | AND logic (for nesting inside `any`/`not`) |
+| `$ref` | `{"$ref": "#/macros/offroad"}` | Reference a named rule fragment in `_macros.yaml` |
+
+**Visibility design**: Settings are always visible. When visibility rules fail, the setting is dimmed with an UNAVAILABLE badge, so users know it exists but is not applicable.
+
+**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`, `enable_bsm`, `is_release`, `is_sp_release`, `is_development`, `tesla_has_vehicle_bus`, `has_stop_and_go`, `stock_longitudinal`
+
+---
+
+## How to
+
+### Pick a writability rule (offroad / not_engaged / param-based)
+
+| Use this | When | Why |
+|---|---|---|
+| `offroad_only` | Param can only be safely changed when the car is parked. Most user-facing toggles. | Strictest. Frontend shows "device is driving" badge and disables the row. |
+| `not_engaged` | Param can be changed while the car is started but only when sunnypilot/MADS is **not** actively driving. | Less strict than offroad. Matches Raylib `engaged = started AND (selfdriveState.enabled OR mads.enabled)`. Use for items the device must apply mid-drive (e.g. test maneuvers, longitudinal stock-vs-OP toggle). |
+| `param`-based | Behavior depends on another setting's value (parent toggle, mode selector, etc.). | Composes with `not`/`any`/`all` for arbitrary logic. |
+| `capability`-based | Behavior depends on the connected car or device (brand, longitudinal, hardware). | Resolved on the device from `CarParams` / hardware. See [`capabilities.py`](../capabilities.py) for the full field list. |
+| (no rule) | Param is always writable, no gating. | Rare. Prefer at least `offroad_only` unless the param is genuinely safe to flip mid-drive. |
+
+Default for new toggles: `enablement: [{$ref: "#/macros/offroad"}]`. Drop down to `not_engaged` only if you've confirmed mid-drive write is safe in the controls/UI code path.
+
+### Use `details` for safety notes / extended help
+
+Inline `description` shows under the title. For longer caveats, safety notes, or "learn more" content, use `details` — the frontend renders an info button that opens a modal. Either field may be present alone or both together.
+
+```yaml
+- key: AutoLaneChangeTimer
+  widget: option
+  title: Auto Lane Change by Blinker
+  description: |-
+    Set a timer to delay the auto lane change operation when the blinker is used.
+    No nudge on the steering wheel is required to auto lane change if a timer is set.
+    Default is Nudge.
+  details: |-
+    Please use caution when using this feature. Only use the blinker when traffic
+    and road conditions permit.
+  options: [...]
+```
+
+For an item that is intentionally minimal inline (no inline body, only the modal):
+
+```yaml
+- key: SomeAdvancedToggle
+  widget: toggle
+  title: Some Advanced Feature
+  details: |-
+    Long-form rationale, caveats, links, etc. — kept entirely behind the info button.
+```
+
+### Add a toggle
+
+1. Register in `common/params_keys.h`:
+   ```cpp
+   {"MyToggle", {PERSISTENT | BACKUP, BOOL}},
+   ```
+
+2. Open `settings_ui_src/pages/<page>.yaml`. Add the item to the right section:
+   ```yaml
+   - key: MyToggle
+     widget: toggle
+     title: My Feature
+     description: What this feature does.
+     enablement:
+       - {$ref: "#/macros/offroad"}
+   ```
+
+   If changing the param requires an onroad cycle to take effect, add `needs_onroad_cycle: true`.
+
+3. Compile + validate + test:
+   ```
+   python sunnypilot/sunnylink/tools/compile_settings_ui.py
+   python sunnypilot/sunnylink/tools/validate_settings_ui.py
+   uv run python -m pytest sunnypilot/sunnylink/tests/
+   ```
+
+### Add a multi-button option
+
+```yaml
+- key: MySelector
+  widget: multiple_button
+  title: Mode
+  options:
+    - {value: 0, label: Off}
+    - {value: 1, label: On}
+    - {value: 2, label: Auto}
+```
+
+### Add a slider or range
+
+```yaml
+- key: MyRange
+  widget: option
+  title: Follow Distance
+  description: Time gap to lead vehicle.
+  min: 0.5
+  max: 3.0
+  step: 0.1
+  unit: seconds
+```
+
+### Add a slider with metric/imperial units
+
+```yaml
+- key: MinSpeed
+  widget: option
+  title: Minimum Speed
+  min: 0
+  max: 100
+  step: 5
+  unit: {metric: km/h, imperial: mph}
+```
+
+Frontend resolves the unit string based on the device's `IsMetric` param. Static units (e.g. `seconds`, `m/s²`) stay plain strings.
+
+### Add a dynamic title suffix
+
+```yaml
+- key: FollowDistance
+  widget: option
+  title: Follow Distance
+  title_param_suffix:
+    param: IsMetric
+    values: {'0': mph, '1': km/h}
+  min: 0.5
+  max: 3.0
+  step: 0.1
+```
+
+Renders as "Follow Distance: mph" / "Follow Distance: km/h".
+
+### Add a device-only read-only setting
+
+```yaml
+- key: OnroadCyclePendingRemote
+  widget: info
+  title: Pending Remote Cycle
+  blocked: true
+```
+
+Frontend treats `blocked: true` items as read-only.
+
+### Add a dropdown option
+
+```yaml
+- key: MyDropdown
+  widget: option
+  title: Recording Quality
+  options:
+    - {value: 0, label: Low (720p)}
+    - {value: 1, label: Medium (1080p)}
+    - {value: 2, label: High (4K)}
+```
+
+### Per-option enablement rules
+
+```yaml
+- key: MadsSteeringMode
+  widget: multiple_button
+  title: Steering Mode on Brake Pedal
+  options:
+    - value: 0
+      label: Remain Active
+      enablement:
+        - {$ref: "#/macros/mads_full_platforms"}
+    - value: 1
+      label: Pause
+      enablement:
+        - {$ref: "#/macros/mads_full_platforms"}
+    - value: 2
+      label: Disengage
+  enablement:
+    - {$ref: "#/macros/offroad"}
+```
+
+When an option's enablement fails, that option is grayed out but still visible.
+
+### Show only when another setting is on
+
+```yaml
+- key: ChildSetting
+  widget: toggle
+  title: Child Feature
+  visibility:
+    - {type: param, key: ParentToggle, equals: true}
+```
+
+(With the "dim instead of hide" design, this setting is dimmed, not hidden, when the rule fails.)
+
+### Show only for specific brands
+
+```yaml
+- key: LongFeature
+  widget: toggle
+  title: Longitudinal Feature
+  visibility:
+    - {$ref: "#/macros/longitudinal"}
+```
+
+### Combine multiple conditions
+
+The `enablement` array is implicit-AND: every entry must pass. Use `any` for OR, `all` for nested AND, `not` for negation. Wrap repeated combinations in a macro so future you doesn't re-derive the logic.
+
+**AND across two params** (writable only when both Mads is on AND ICBM is enabled):
+```yaml
+enablement:
+  - {type: param, key: Mads, equals: true}
+  - {type: param, key: IntelligentCruiseButtonManagement, equals: true}
+```
+
+**OR across two params** (writable when either is on):
+```yaml
+enablement:
+  - type: any
+    conditions:
+      - {type: param, key: ExperimentalMode, equals: true}
+      - {type: param, key: DynamicExperimentalControl, equals: true}
+```
+
+**Mixed: capability AND param** (only on longitudinal cars when ShowAdvancedControls is on):
+```yaml
+enablement:
+  - {$ref: "#/macros/longitudinal"}
+  - {$ref: "#/macros/advanced_only"}
+```
+
+**Three-way: offroad AND torque-allowed AND not-NNLC** (real example: `EnforceTorqueControl`):
+```yaml
+enablement:
+  - {$ref: "#/macros/offroad"}
+  - {type: capability, field: torque_allowed, equals: true}
+  - {type: param, key: NeuralNetworkLateralControl, equals: false}
+```
+
+**Negation across multiple platforms** (everything except Rivian + Tesla-no-bus):
+```yaml
+enablement:
+  - {$ref: "#/macros/offroad"}
+  - {$ref: "#/macros/mads_full_platforms"}   # macro encapsulates the not(any(rivian, all(tesla, not(bus)))) logic
+```
+
+If the same multi-condition block appears in 2+ items, **promote it to a macro** in `_macros.yaml`. Re-run `python sunnypilot/sunnylink/tools/apply_macros.py` to substitute existing inlined matches automatically.
+
+### Mutual exclusion
+
+```yaml
+- key: FeatureAlpha
+  widget: toggle
+  title: Feature Alpha
+  enablement:
+    - {type: param, key: FeatureBeta, equals: false}
+
+- key: FeatureBeta
+  widget: toggle
+  title: Feature Beta
+  enablement:
+    - {type: param, key: FeatureAlpha, equals: false}
+```
+
+### Add a section
+
+In the page YAML, add an entry to the `sections` list:
+```yaml
+sections:
+  - id: my_section
+    title: My Section
+    description: Optional subtitle
+    enablement:
+      - {$ref: "#/macros/longitudinal"}
+    items:
+      - {key: ..., widget: toggle, title: ...}
+```
+
+Sections support `visibility`, `enablement`, and `attestation_required`. When section-level rules fail, all items within are dimmed.
+
+### Add a sub-panel
+
+Sub-panels nest inside the section they belong to:
+```yaml
+sections:
+  - id: parent_section
+    title: Parent
+    items: [...]
+    sub_panels:
+      - id: my_sub
+        label: Advanced Settings
+        trigger_key: ParentParam
+        trigger_condition: {type: param, key: ParentParam, equals: true}
+        items:
+          - {key: ..., widget: toggle, title: ...}
+```
+
+### Add vehicle-brand settings
+
+Edit `pages/vehicle.yaml`. Each section is a brand:
+```yaml
+id: vehicle
+kind: vehicle
+sections:
+  - id: rivian
+    title: Rivian Settings
+    description: ''
+    items:
+      - key: RivianFeature
+        widget: toggle
+        title: Rivian One Pedal
+        enablement:
+          - {$ref: "#/macros/offroad"}
+```
+
+`kind: vehicle` tells the compiler to emit this page as `vehicle_settings.<brand>` in the wire JSON.
+
+### Add a feature with toggles, sub-panel, and macro
+
+Example: "Smart Wipers" with a master toggle, intensity selector, and sub-panel for advanced tuning, gated to torque-steering Hyundais on offroad.
+
+1. **Param keys** — register all 4 in `common/params_keys.h`.
+
+2. **Decide on a macro** — if "torque Hyundai" gating is reused, add to `_macros.yaml`:
+   ```yaml
+   torque_hyundai:
+     - {$ref: "#/macros/offroad"}
+     - {type: capability, field: brand, equals: hyundai}
+     - {type: capability, field: torque_allowed, equals: true}
+   ```
+
+3. **Edit the relevant page** — `pages/visuals.yaml` (or wherever the feature lives). Add a new section + sub_panel:
+   ```yaml
+   sections:
+     - id: smart_wipers
+       title: Smart Wipers
+       description: Camera-driven wiper control (Hyundai/Kia, torque only)
+       items:
+         - key: SmartWipersEnabled
+           widget: toggle
+           title: Enable Smart Wipers
+           enablement:
+             - {$ref: "#/macros/torque_hyundai"}
+         - key: SmartWipersIntensity
+           widget: multiple_button
+           title: Sensitivity
+           options:
+             - {value: 0, label: Low}
+             - {value: 1, label: Medium}
+             - {value: 2, label: High}
+           visibility:
+             - {type: param, key: SmartWipersEnabled, equals: true}
+           enablement:
+             - {$ref: "#/macros/torque_hyundai"}
+       sub_panels:
+         - id: smart_wipers_tuning
+           label: Smart Wipers Tuning
+           trigger_key: SmartWipersEnabled
+           trigger_condition: {type: param, key: SmartWipersEnabled, equals: true}
+           items:
+             - key: SmartWipersHysteresis
+               widget: option
+               title: Hysteresis (frames)
+               min: 1
+               max: 30
+               step: 1
+               enablement:
+                 - {$ref: "#/macros/offroad"}
+                 - {$ref: "#/macros/advanced_only"}
+   ```
+
+4. **Compile / validate / test**:
+   ```
+   python sunnypilot/sunnylink/tools/compile_settings_ui.py
+   python sunnypilot/sunnylink/tools/validate_settings_ui.py
+   uv run python -m pytest sunnypilot/sunnylink/tests/
+   ```
+
+   `apply_macros.py` is automatic for newly-added items only if you wrote the rule list inline; for greenfield items, you'd write `$ref` directly.
+
+### Change a toggle's behavior
+
+1. Find the item in `pages/<page>.yaml`.
+2. Edit `visibility`/`enablement`/`options[].enablement` directly. Use macros where possible.
+3. **Add a regression test** in `sunnypilot/sunnylink/tests/test_settings_changes.py` that asserts the new gate exists. Use existing tests (e.g. `TestMadsBrandGates`, `TestNotEngagedReplacement`) as templates: lookup item by key, assert `_references_capability_field(rules, "...")` or `_flatten_rule_types(rules)` contains/excludes a type. This freezes the new behavior so a future edit won't silently revert it.
+4. Compile + run the full suite. Per-bug test should pass; structural tests should remain green.
+
+### Change a widget type or options
+
+Editing `widget:` from `toggle` to `multiple_button` is a frontend behavior change. Whenever you change widget shape:
+- The param's underlying type (bool / int / string) must match what the new widget writes. `toggle` writes bool; `multiple_button`/`option` write int/string. Update `params_keys.h` if the type changes.
+- Add an `options:` list when switching to `multiple_button` or `option`.
+- Old values stored on devices may not be valid for the new widget. Consider a migration in `sunnypilot/system/updated/` if users have stale values.
+
+### Deprecate or remove a setting
+
+1. Remove the item from `pages/<page>.yaml`.
+2. Remove the param key from `common/params_keys.h` **only after** confirming nothing in `selfdrive/`, `sunnypilot/`, or any controls code reads it.
+3. If the param has been on user devices, drop it via a migration (see `sunnypilot/system/updated/`) so stale values don't linger.
+4. Compile + validate + test. The validator's "no duplicate keys" + structural checks will fail if anything still references the removed key.
+
+### Move a setting to another page
+
+Cut the item block from one page YAML, paste into the target page's section. Compile + validate. The "no duplicate keys" check catches forgotten copies.
+
+### Change display text
+
+Edit `title:` or `description:` in the page YAML and recompile to regenerate `settings_ui.json`.
+
+### Reorder sections, sub-panels, and items
+
+Reorder them within their parent list in the YAML. The compiler preserves authored order — no `order:` field required at the section/sub_panel/item level (panel-level `order:` controls which page comes first in the side nav).
+
+---
+
+### Capability labels and tooltips
+
+The schema response includes `capability_labels`, which map capability field names to descriptions. The frontend uses these to show contextual tooltips when a capability rule prevents a setting from being used.
+
+The device defines these labels in `capabilities.py:CAPABILITY_LABELS`. Examples:
+
+- `has_longitudinal_control` → "sunnypilot longitudinal control"
+- `torque_allowed` → "torque steering (not available for angle steering vehicles)"
+- `brand` → "Vehicle brand"
+
+### Centralized param enforcement
+
+The device-side UI enforces capability constraints in `selfdrive/ui/sunnypilot/ui_state.py:_enforce_constraints()`, which removes incompatible params based on car capabilities. This is the single source of truth for such constraints.
+
+Settings layouts should not duplicate these params.remove() calls. Instead, rely on schema rules and centralized enforcement to prevent duplicate logic and ensure consistency.
+
+Example constraints in `_enforce_constraints()`:
+- Angle steering cars: remove `EnforceTorqueControl` and `NeuralNetworkLateralControl`
+- No CarParams: remove all car-dependent params
+- No longitudinal: remove `ExperimentalMode`
+- No ICBM: remove `IntelligentCruiseButtonManagement`

sunnypilot/sunnylink/params_metadata.json

@@ -1071,6 +1071,10 @@
     "title": "Panda Som Reset Triggered",
     "description": ""
   },
+  "ParamsVersion": {
+    "title": "Params Version",
+    "description": ""
+  },
   "PlanplusControl": {
     "title": "Plan Plus Controls",
     "description": "Adjust planplus model recentering strength. The higher this number the more aggressively the model will recover to lanecenter, too high and it will ping-pong",

sunnypilot/sunnylink/settings_ui.schema.json

@@ -0,0 +1,516 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sunnypilot.com/schemas/settings_ui.schema.json",
+  "title": "sunnypilot Settings UI Schema",
+  "description": "Defines the structure of the sunnypilot settings UI panels, items, rules, and vehicle-specific settings.",
+  "type": "object",
+  "required": ["schema_version", "panels", "vehicle_settings"],
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "JSON Schema reference for editor support."
+    },
+    "schema_version": {
+      "type": "string",
+      "description": "Version of the settings UI schema format.",
+      "examples": ["1.0"]
+    },
+    "panels": {
+      "type": "array",
+      "description": "Top-level settings panels displayed in the UI.",
+      "items": {
+        "$ref": "#/$defs/Panel"
+      }
+    },
+    "vehicle_settings": {
+      "type": "object",
+      "description": "Brand-keyed vehicle-specific settings. Each key is a car brand (e.g. 'hyundai', 'toyota').",
+      "additionalProperties": {
+        "$ref": "#/$defs/VehicleBrandSettings"
+      }
+    }
+  },
+  "$defs": {
+    "Panel": {
+      "type": "object",
+      "description": "A top-level settings panel (tab) in the UI.",
+      "required": ["id", "label", "icon", "order"],
+      "additionalProperties": false,
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "Unique identifier for this panel."
+        },
+        "label": {
+          "type": "string",
+          "description": "Display label shown in the UI."
+        },
+        "icon": {
+          "type": "string",
+          "description": "Icon identifier for this panel."
+        },
+        "order": {
+          "type": "integer",
+          "description": "Sort order for panel display.",
+          "minimum": 0
+        },
+        "description": {
+          "type": "string",
+          "description": "Optional description shown below the panel label."
+        },
+        "remote_configurable": {
+          "type": "boolean",
+          "description": "Whether this panel's settings can be changed remotely via sunnylink.",
+          "default": false
+        },
+        "sections": {
+          "type": "array",
+          "description": "Grouped sections within this panel.",
+          "items": {
+            "$ref": "#/$defs/PanelSection"
+          }
+        },
+        "items": {
+          "type": "array",
+          "description": "Settings items directly in this panel (no section grouping).",
+          "items": {
+            "$ref": "#/$defs/SchemaItem"
+          }
+        },
+        "sub_panels": {
+          "type": "array",
+          "description": "Nested sub-panels triggered by a setting.",
+          "items": {
+            "$ref": "#/$defs/SubPanel"
+          }
+        }
+      }
+    },
+    "PanelSection": {
+      "type": "object",
+      "description": "A grouped section within a panel.",
+      "required": ["id", "title"],
+      "additionalProperties": false,
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "Unique identifier for this section."
+        },
+        "title": {
+          "type": "string",
+          "description": "Display title for this section."
+        },
+        "description": {
+          "type": "string",
+          "description": "Optional description shown below the section title."
+        },
+        "order": {
+          "type": "integer",
+          "description": "Sort order within the parent panel.",
+          "minimum": 0
+        },
+        "visibility": {
+          "type": "array",
+          "description": "Rules that determine whether this section is visible. All rules must pass.",
+          "items": {
+            "$ref": "#/$defs/Rule"
+          }
+        },
+        "enablement": {
+          "type": "array",
+          "description": "Rules that determine whether items in this section are enabled. All rules must pass.",
+          "items": {
+            "$ref": "#/$defs/Rule"
+          }
+        },
+        "attestation_required": {
+          "type": "boolean",
+          "description": "When true, the UI must show an attestation modal before any write to items in this section.",
+          "default": false
+        },
+        "items": {
+          "type": "array",
+          "description": "Settings items within this section.",
+          "items": {
+            "$ref": "#/$defs/SchemaItem"
+          }
+        },
+        "sub_panels": {
+          "type": "array",
+          "description": "Nested sub-panels within this section.",
+          "items": {
+            "$ref": "#/$defs/SubPanel"
+          }
+        }
+      }
+    },
+    "VehicleBrandSettings": {
+      "type": "object",
+      "description": "Brand-specific settings group inside vehicle_settings.",
+      "required": ["items"],
+      "additionalProperties": false,
+      "properties": {
+        "title": {
+          "type": "string",
+          "description": "Display title for this brand's settings group."
+        },
+        "description": {
+          "type": "string",
+          "description": "Optional description shown below the brand title."
+        },
+        "items": {
+          "type": "array",
+          "description": "Settings items for this brand.",
+          "items": {
+            "$ref": "#/$defs/SchemaItem"
+          }
+        }
+      }
+    },
+    "SchemaItem": {
+      "type": "object",
+      "description": "A single settings item (toggle, option selector, button group, etc.).",
+      "required": ["key", "widget"],
+      "additionalProperties": false,
+      "properties": {
+        "key": {
+          "type": "string",
+          "description": "The param key this item reads/writes."
+        },
+        "widget": {
+          "type": "string",
+          "description": "The UI widget type to render.",
+          "enum": ["toggle", "option", "multiple_button", "button", "info"]
+        },
+        "title": {
+          "type": "string",
+          "description": "Override display title (defaults to metadata lookup by key)."
+        },
+        "description": {
+          "type": "string",
+          "description": "Override description text. Rendered inline below the title. May be empty when only `details` is used."
+        },
+        "details": {
+          "type": "string",
+          "description": "Extended help text shown in a popover/modal when the user taps an info ('i') button on the row. Independent of `description`: either, both, or neither may be present."
+        },
+        "options": {
+          "type": "array",
+          "description": "Available options for 'option' or 'multiple_button' widgets.",
+          "items": {
+            "$ref": "#/$defs/SchemaOption"
+          }
+        },
+        "min": {
+          "type": "number",
+          "description": "Minimum value for numeric option widgets."
+        },
+        "max": {
+          "type": "number",
+          "description": "Maximum value for numeric option widgets."
+        },
+        "step": {
+          "type": "number",
+          "description": "Step increment for numeric option widgets."
+        },
+        "unit": {
+          "oneOf": [
+            {
+              "type": "string",
+              "description": "Static unit label (e.g. 'seconds', 'm/s²')."
+            },
+            {
+              "type": "object",
+              "description": "Dynamic unit that changes based on IsMetric param.",
+              "required": ["metric", "imperial"],
+              "additionalProperties": false,
+              "properties": {
+                "metric": {
+                  "type": "string",
+                  "description": "Unit label when IsMetric is true (e.g. 'km/h')."
+                },
+                "imperial": {
+                  "type": "string",
+                  "description": "Unit label when IsMetric is false (e.g. 'mph')."
+                }
+              }
+            }
+          ],
+          "description": "Unit label for numeric values. Use a string for static units or an object with metric/imperial variants for units that depend on the IsMetric param."
+        },
+        "value_map": {
+          "type": "object",
+          "description": "Maps stored values to display labels.",
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
+        "visibility": {
+          "type": "array",
+          "description": "Rules that determine whether this item is visible. All rules must pass.",
+          "items": {
+            "$ref": "#/$defs/Rule"
+          }
+        },
+        "enablement": {
+          "type": "array",
+          "description": "Rules that determine whether this item is enabled/interactive. All rules must pass.",
+          "items": {
+            "$ref": "#/$defs/Rule"
+          }
+        },
+        "sub_items": {
+          "type": "array",
+          "description": "Child items nested under this item (e.g. options revealed by a toggle).",
+          "items": {
+            "$ref": "#/$defs/SchemaItem"
+          }
+        },
+        "action": {
+          "type": "string",
+          "description": "Action identifier for button widgets."
+        },
+        "title_param_suffix": {
+          "type": "object",
+          "description": "Renders an extra suffix in the item title chosen by the value of another param.",
+          "required": ["param", "values"],
+          "additionalProperties": false,
+          "properties": {
+            "param": {
+              "type": "string",
+              "description": "Param key whose value selects the suffix label."
+            },
+            "values": {
+              "type": "object",
+              "description": "Map from stringified param value to suffix label.",
+              "additionalProperties": {
+                "type": "string"
+              }
+            }
+          }
+        },
+        "needs_onroad_cycle": {
+          "type": "boolean",
+          "description": "When true, the device must cycle onroad/offroad for the new value to take effect.",
+          "default": false
+        },
+        "blocked": {
+          "type": "boolean",
+          "description": "When true, this item is treated as DEVICE_ONLY and the dashboard must not write it remotely.",
+          "default": false
+        },
+        "requires_attestation": {
+          "type": "boolean",
+          "description": "When true, writes to this item require an explicit per-write confirmation modal.",
+          "default": false
+        }
+      }
+    },
+    "SubPanel": {
+      "type": "object",
+      "description": "A nested panel that opens when triggered by a parent item.",
+      "required": ["id", "label", "trigger_key"],
+      "additionalProperties": false,
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "Unique identifier for this sub-panel."
+        },
+        "label": {
+          "type": "string",
+          "description": "Display label for the sub-panel header."
+        },
+        "trigger_key": {
+          "type": "string",
+          "description": "The param key that triggers opening this sub-panel."
+        },
+        "trigger_condition": {
+          "$ref": "#/$defs/Rule",
+          "description": "Optional rule that must evaluate to true for the sub-panel trigger to be active."
+        },
+        "items": {
+          "type": "array",
+          "description": "Settings items within this sub-panel.",
+          "items": {
+            "$ref": "#/$defs/SchemaItem"
+          }
+        }
+      }
+    },
+    "SchemaOption": {
+      "type": "object",
+      "description": "A selectable option for option/multiple_button widgets.",
+      "required": ["value", "label"],
+      "additionalProperties": false,
+      "properties": {
+        "value": {
+          "oneOf": [
+            { "type": "number" },
+            { "type": "string" }
+          ],
+          "description": "The stored value when this option is selected."
+        },
+        "label": {
+          "type": "string",
+          "description": "The display label for this option."
+        },
+        "enablement": {
+          "type": "array",
+          "description": "Rules that determine whether this option is selectable. All rules must pass.",
+          "items": {
+            "$ref": "#/$defs/Rule"
+          }
+        }
+      }
+    },
+    "Rule": {
+      "description": "A visibility or enablement rule. Discriminated union on the 'type' field.",
+      "oneOf": [
+        { "$ref": "#/$defs/RuleOffroadOnly" },
+        { "$ref": "#/$defs/RuleNotEngaged" },
+        { "$ref": "#/$defs/RuleCapability" },
+        { "$ref": "#/$defs/RuleParam" },
+        { "$ref": "#/$defs/RuleParamCompare" },
+        { "$ref": "#/$defs/RuleNot" },
+        { "$ref": "#/$defs/RuleAny" },
+        { "$ref": "#/$defs/RuleAll" }
+      ]
+    },
+    "RuleOffroadOnly": {
+      "type": "object",
+      "description": "Rule that passes only when the device is offroad.",
+      "required": ["type"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "const": "offroad_only"
+        }
+      }
+    },
+    "RuleNotEngaged": {
+      "type": "object",
+      "description": "Rule that passes when the vehicle is not engaged (matches Raylib `engaged = started AND (selfdriveState.enabled OR selfdriveStateSP.mads.enabled)`).",
+      "required": ["type"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "const": "not_engaged"
+        }
+      }
+    },
+    "RuleCapability": {
+      "type": "object",
+      "description": "Rule that checks a vehicle capability field against an expected value.",
+      "required": ["type", "field", "equals"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "const": "capability"
+        },
+        "field": {
+          "type": "string",
+          "description": "The capability field name to check."
+        },
+        "equals": {
+          "description": "The expected value to match against."
+        }
+      }
+    },
+    "RuleParam": {
+      "type": "object",
+      "description": "Rule that checks a param value against an expected value.",
+      "required": ["type", "key", "equals"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "const": "param"
+        },
+        "key": {
+          "type": "string",
+          "description": "The param key to read."
+        },
+        "equals": {
+          "description": "The expected value to match against."
+        }
+      }
+    },
+    "RuleParamCompare": {
+      "type": "object",
+      "description": "Rule that compares a numeric param value using a comparison operator.",
+      "required": ["type", "key", "op", "value"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "const": "param_compare"
+        },
+        "key": {
+          "type": "string",
+          "description": "The param key to read."
+        },
+        "op": {
+          "type": "string",
+          "description": "Comparison operator.",
+          "enum": [">", "<", ">=", "<="]
+        },
+        "value": {
+          "type": "number",
+          "description": "The numeric value to compare against."
+        }
+      }
+    },
+    "RuleNot": {
+      "type": "object",
+      "description": "Rule that negates a single child condition.",
+      "required": ["type", "condition"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "const": "not"
+        },
+        "condition": {
+          "$ref": "#/$defs/Rule",
+          "description": "The rule to negate."
+        }
+      }
+    },
+    "RuleAny": {
+      "type": "object",
+      "description": "Rule that passes if ANY of the child conditions pass (logical OR).",
+      "required": ["type", "conditions"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "const": "any"
+        },
+        "conditions": {
+          "type": "array",
+          "description": "Child rules; at least one must pass.",
+          "items": {
+            "$ref": "#/$defs/Rule"
+          },
+          "minItems": 1
+        }
+      }
+    },
+    "RuleAll": {
+      "type": "object",
+      "description": "Rule that passes only if ALL child conditions pass (logical AND).",
+      "required": ["type", "conditions"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "const": "all"
+        },
+        "conditions": {
+          "type": "array",
+          "description": "Child rules; all must pass.",
+          "items": {
+            "$ref": "#/$defs/Rule"
+          },
+          "minItems": 1
+        }
+      }
+    }
+  }
+}

sunnypilot/sunnylink/settings_ui_src/_macros.yaml

@@ -0,0 +1,65 @@
+# Named rule fragments. Reference from items/sections via {$ref: "#/macros/<name>"}.
+# Macros may $ref other macros (max depth 3 — see compile_settings_ui.py). No template logic.
+#
+# Adding a macro: define here once, then reference everywhere. The compiler
+# resolves $refs into the canonical settings_ui.json output the frontend reads.
+
+macros:
+  # Most-used: only writable when the device is offroad.
+  offroad:
+    - {type: offroad_only}
+
+  # Writable while not engaged (started, but selfdrive/MADS not active).
+  not_engaged:
+    - {type: not_engaged}
+
+  # sunnypilot longitudinal control is active.
+  longitudinal:
+    - {type: capability, field: has_longitudinal_control, equals: true}
+
+  # Longitudinal + ICBM both available.
+  longitudinal_and_icbm:
+    - {type: capability, field: has_longitudinal_control, equals: true}
+    - {type: capability, field: has_icbm, equals: true}
+
+  # Item only meaningful when "Show Advanced Controls" is enabled by the user.
+  advanced_only:
+    - {type: param, key: ShowAdvancedControls, equals: true}
+
+  # Hide on MICI hardware (no analog HUD support yet).
+  hide_on_mici:
+    - type: not
+      condition: {type: capability, field: device_type, equals: mici}
+
+  # Mirrors selfdrive/ui/sunnypilot/layouts/.../mads_settings.py:_mads_limited_settings()
+  # Rivian + Tesla-without-vehicle-bus get the limited MADS UI (3-toggle subset).
+  # On those platforms these toggles are disabled — full MADS settings are
+  # only writable on platforms NOT in the limited-set.
+  mads_full_platforms:
+    - type: not
+      condition:
+        type: any
+        conditions:
+          - {type: capability, field: brand, equals: rivian}
+          - type: all
+            conditions:
+              - {type: capability, field: brand, equals: tesla}
+              - type: not
+                condition: {type: capability, field: tesla_has_vehicle_bus, equals: true}
+
+  # Inverse of mads_full_platforms: present only on the limited platforms.
+  # Useful for "show this only on rivian/tesla-no-bus" toggles.
+  mads_limited_platforms:
+    - type: any
+      conditions:
+        - {type: capability, field: brand, equals: rivian}
+        - type: all
+          conditions:
+            - {type: capability, field: brand, equals: tesla}
+            - type: not
+              condition: {type: capability, field: tesla_has_vehicle_bus, equals: true}
+
+  # Hide on sunnypilot release branches (is_release is hardcoded False everywhere; is_sp_release is the active gate).
+  release_branches_hide:
+    - type: not
+      condition: {type: capability, field: is_sp_release, equals: true}

sunnypilot/sunnylink/settings_ui_src/_schemas/macros.schema.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sunnypilot.com/schemas/sdui/macros.schema.json",
+  "title": "Settings UI macros (named rule fragments)",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["macros"],
+  "properties": {
+    "macros": {
+      "type": "object",
+      "description": "Named rule fragments. Each value is either a list of rules (typical) or a single rule object. Reference from items/layout via {$ref: '#/macros/<name>'}.",
+      "patternProperties": {
+        "^[A-Za-z_][A-Za-z0-9_]*$": {
+          "oneOf": [
+            {"type": "array", "items": {"$ref": "rule.schema.json"}},
+            {"$ref": "rule.schema.json"}
+          ]
+        }
+      },
+      "additionalProperties": false
+    }
+  }
+}

sunnypilot/sunnylink/settings_ui_src/_schemas/page.schema.json

@@ -0,0 +1,113 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sunnypilot.com/schemas/sdui/page.schema.json",
+  "title": "Settings UI page (panel) YAML",
+  "description": "Validates pages/<id>.yaml. Each page describes one settings panel (or the vehicle namespace via kind: vehicle).",
+  "type": "object",
+  "required": ["id"],
+  "additionalProperties": false,
+  "properties": {
+    "id": {"type": "string"},
+    "label": {"type": "string"},
+    "icon": {"type": "string"},
+    "order": {"type": "integer"},
+    "remote_configurable": {"type": "boolean"},
+    "description": {"type": "string"},
+    "kind": {
+      "type": "string",
+      "enum": ["panel", "vehicle"],
+      "description": "panel (default) or vehicle (compiles to settings_ui.json#vehicle_settings)."
+    },
+    "sections": {
+      "type": "array",
+      "items": {"$ref": "#/$defs/Section"}
+    },
+    "items": {
+      "type": "array",
+      "items": {"$ref": "#/$defs/Item"}
+    },
+    "sub_panels": {
+      "type": "array",
+      "items": {"$ref": "#/$defs/SubPanel"}
+    }
+  },
+  "$defs": {
+    "Section": {
+      "type": "object",
+      "required": ["id", "title"],
+      "additionalProperties": false,
+      "properties": {
+        "id": {"type": "string"},
+        "title": {"type": "string"},
+        "description": {"type": "string"},
+        "order": {"type": "integer"},
+        "attestation_required": {"type": "boolean"},
+        "visibility": {"type": "array", "items": {"$ref": "rule.schema.json"}},
+        "enablement": {"type": "array", "items": {"$ref": "rule.schema.json"}},
+        "items": {"type": "array", "items": {"$ref": "#/$defs/Item"}},
+        "sub_panels": {"type": "array", "items": {"$ref": "#/$defs/SubPanel"}}
+      }
+    },
+    "SubPanel": {
+      "type": "object",
+      "required": ["id", "label"],
+      "additionalProperties": false,
+      "properties": {
+        "id": {"type": "string"},
+        "label": {"type": "string"},
+        "trigger_key": {"type": ["string", "null"]},
+        "trigger_condition": {"$ref": "rule.schema.json"},
+        "items": {"type": "array", "items": {"$ref": "#/$defs/Item"}}
+      }
+    },
+    "Item": {
+      "type": "object",
+      "required": ["key", "widget"],
+      "additionalProperties": false,
+      "properties": {
+        "key": {"type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]*$"},
+        "widget": {"type": "string", "enum": ["toggle", "option", "multiple_button", "button", "info"]},
+        "title": {"type": "string"},
+        "description": {"type": "string", "description": "Inline body text under the title. May be omitted when only details is used."},
+        "details": {"type": "string", "description": "Extended help shown in a modal when the user taps the info (i) button. Independent of description; either, both, or neither may be present."},
+        "title_param_suffix": {"type": "object"},
+        "min": {"type": "number"},
+        "max": {"type": "number"},
+        "step": {"type": "number"},
+        "unit": {
+          "oneOf": [
+            {"type": "string"},
+            {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["metric", "imperial"],
+              "properties": {
+                "metric": {"type": "string"},
+                "imperial": {"type": "string"}
+              }
+            }
+          ]
+        },
+        "needs_onroad_cycle": {"type": "boolean"},
+        "requires_attestation": {"type": "boolean"},
+        "blocked": {"type": "boolean"},
+        "options": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["value", "label"],
+            "additionalProperties": false,
+            "properties": {
+              "value": {},
+              "label": {"type": "string"},
+              "enablement": {"type": "array", "items": {"$ref": "rule.schema.json"}}
+            }
+          }
+        },
+        "visibility": {"type": "array", "items": {"$ref": "rule.schema.json"}},
+        "enablement": {"type": "array", "items": {"$ref": "rule.schema.json"}},
+        "sub_items": {"type": "array", "items": {"$ref": "#/$defs/Item"}}
+      }
+    }
+  }
+}

sunnypilot/sunnylink/settings_ui_src/_schemas/rule.schema.json

@@ -0,0 +1,101 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sunnypilot.com/schemas/sdui/rule.schema.json",
+  "title": "Rule",
+  "description": "Visibility/enablement rule. Discriminated union on 'type'. Macro reference is also accepted via {$ref: '#/macros/<name>'}.",
+  "oneOf": [
+    {"$ref": "#/$defs/MacroRef"},
+    {"$ref": "#/$defs/RuleOffroadOnly"},
+    {"$ref": "#/$defs/RuleNotEngaged"},
+    {"$ref": "#/$defs/RuleCapability"},
+    {"$ref": "#/$defs/RuleParam"},
+    {"$ref": "#/$defs/RuleParamCompare"},
+    {"$ref": "#/$defs/RuleNot"},
+    {"$ref": "#/$defs/RuleAny"},
+    {"$ref": "#/$defs/RuleAll"}
+  ],
+  "$defs": {
+    "MacroRef": {
+      "type": "object",
+      "required": ["$ref"],
+      "additionalProperties": false,
+      "properties": {
+        "$ref": {
+          "type": "string",
+          "pattern": "^#/macros/[A-Za-z_][A-Za-z0-9_]*$",
+          "description": "Reference to a macro defined in _macros.yaml under #/macros/<name>."
+        }
+      }
+    },
+    "RuleOffroadOnly": {
+      "type": "object",
+      "required": ["type"],
+      "additionalProperties": false,
+      "properties": {"type": {"const": "offroad_only"}}
+    },
+    "RuleNotEngaged": {
+      "type": "object",
+      "required": ["type"],
+      "additionalProperties": false,
+      "properties": {"type": {"const": "not_engaged"}}
+    },
+    "RuleCapability": {
+      "type": "object",
+      "required": ["type", "field", "equals"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {"const": "capability"},
+        "field": {"type": "string"},
+        "equals": {}
+      }
+    },
+    "RuleParam": {
+      "type": "object",
+      "required": ["type", "key", "equals"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {"const": "param"},
+        "key": {"type": "string"},
+        "equals": {}
+      }
+    },
+    "RuleParamCompare": {
+      "type": "object",
+      "required": ["type", "key", "op", "value"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {"const": "param_compare"},
+        "key": {"type": "string"},
+        "op": {"type": "string", "enum": [">", "<", ">=", "<="]},
+        "value": {"type": "number"}
+      }
+    },
+    "RuleNot": {
+      "type": "object",
+      "required": ["type", "condition"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {"const": "not"},
+        "condition": {"$ref": "#"}
+      }
+    },
+    "RuleAny": {
+      "type": "object",
+      "required": ["type", "conditions"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {"const": "any"},
+        "conditions": {"type": "array", "items": {"$ref": "#"}, "minItems": 1}
+      }
+    },
+    "RuleAll": {
+      "type": "object",
+      "required": ["type", "conditions"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {"const": "all"},
+        "conditions": {"type": "array", "items": {"$ref": "#"}, "minItems": 1}
+      }
+    }
+  }
+}

sunnypilot/sunnylink/settings_ui_src/pages/cruise.yaml

@@ -0,0 +1,269 @@
+# Page: cruise
+# Edit this file. Run compile_settings_ui.py to emit settings_ui.json.
+id: cruise
+label: Cruise
+icon: cruise_control
+order: 2
+remote_configurable: true
+description: Longitudinal control, speed limits, and cruise behavior
+sections:
+- id: core_cruise_features
+  title: ''
+  description: ''
+  items:
+  - key: ExperimentalMode
+    widget: toggle
+    title: Experimental Mode
+    enablement:
+    - $ref: '#/macros/longitudinal'
+  - key: DynamicExperimentalControl
+    widget: toggle
+    title: Dynamic Experimental Control
+    description: Let the model decide when to use sunnypilot ACC or sunnypilot End to End Longitudinal.
+    visibility:
+    - $ref: '#/macros/longitudinal'
+    enablement:
+    - $ref: '#/macros/longitudinal'
+  - key: DisengageOnAccelerator
+    widget: toggle
+    title: Disengage Cruise on Accelerator Pedal
+    description: When enabled, pressing the accelerator pedal will disengage longitudinal control.
+  - key: LongitudinalPersonality
+    widget: multiple_button
+    title: Driving Personality
+    description: Standard is recommended. In aggressive mode, sunnypilot will follow lead cars closer and be more aggressive
+      with the gas and brake. In relaxed mode sunnypilot will stay further away from lead cars. On supported cars, you can
+      cycle through these personalities with your steering wheel distance button.
+    options:
+    - value: 0
+      label: Aggressive
+    - value: 1
+      label: Standard
+    - value: 2
+      label: Relaxed
+    enablement:
+    - $ref: '#/macros/longitudinal'
+  - key: IntelligentCruiseButtonManagement
+    widget: toggle
+    title: Intelligent Cruise Button Management (ICBM) (Alpha)
+    visibility:
+    - type: capability
+      field: icbm_available
+      equals: true
+    enablement:
+    - $ref: '#/macros/offroad'
+    - type: not
+      condition:
+        type: capability
+        field: has_longitudinal_control
+        equals: true
+- id: custom_acc_increments
+  title: Custom ACC Speed Intervals
+  description: ''
+  enablement:
+  - $ref: '#/macros/offroad'
+  - type: any
+    conditions:
+    - type: all
+      conditions:
+      - type: capability
+        field: has_longitudinal_control
+        equals: true
+      - type: not
+        condition:
+          type: capability
+          field: pcm_cruise
+          equals: true
+    - type: capability
+      field: has_icbm
+      equals: true
+  items:
+  - key: CustomAccIncrementsEnabled
+    widget: toggle
+    title: Enable Custom ACC Speed Intervals
+    enablement:
+    - $ref: '#/macros/offroad'
+    - type: any
+      conditions:
+      - type: all
+        conditions:
+        - type: capability
+          field: has_longitudinal_control
+          equals: true
+        - type: not
+          condition:
+            type: capability
+            field: pcm_cruise
+            equals: true
+      - type: capability
+        field: has_icbm
+        equals: true
+  sub_panels:
+  - id: custom_acc_intervals
+    label: Custom ACC Speed Intervals Settings
+    trigger_key: CustomAccIncrementsEnabled
+    trigger_condition:
+      type: param
+      key: CustomAccIncrementsEnabled
+      equals: true
+    items:
+    - key: CustomAccShortPressIncrement
+      widget: option
+      title: Short Press Increment
+      min: 1
+      max: 10
+      step: 1
+      enablement:
+      - type: param
+        key: CustomAccIncrementsEnabled
+        equals: true
+    - key: CustomAccLongPressIncrement
+      widget: option
+      title: Long Press Increment
+      min: 1
+      max: 10
+      step: 1
+      enablement:
+      - type: param
+        key: CustomAccIncrementsEnabled
+        equals: true
+- id: speed_limits
+  title: Speed Limits
+  description: Speed limit detection and offset behavior
+  items: []
+  sub_panels:
+  - id: speed_limit_settings
+    label: Speed Limit Settings
+    trigger_key: SpeedLimitMode
+    items:
+    - key: SpeedLimitMode
+      widget: multiple_button
+      title: Speed Limit Assist Mode
+      options:
+      - value: 0
+        label: 'Off'
+      - value: 1
+        label: Information
+      - value: 2
+        label: Warning
+      - value: 3
+        label: Assist
+        enablement:
+        - type: any
+          conditions:
+          - type: capability
+            field: has_longitudinal_control
+            equals: true
+          - type: capability
+            field: has_icbm
+            equals: true
+        - type: not
+          condition:
+            type: capability
+            field: brand
+            equals: rivian
+        - type: not
+          condition:
+            type: all
+            conditions:
+            - type: capability
+              field: brand
+              equals: tesla
+            - type: capability
+              field: is_sp_release
+              equals: true
+    - key: SpeedLimitPolicy
+      widget: multiple_button
+      title: Speed Limit Source
+      options:
+      - value: 0
+        label: Car State Only
+      - value: 1
+        label: Map Data Only
+      - value: 2
+        label: Car State Priority
+      - value: 3
+        label: Map Data Priority
+      - value: 4
+        label: Combined
+    - key: SpeedLimitOffsetType
+      widget: multiple_button
+      title: Speed Limit Offset Type
+      options:
+      - value: 0
+        label: 'Off'
+      - value: 1
+        label: Fixed
+      - value: 2
+        label: Percentage
+    - key: SpeedLimitValueOffset
+      widget: option
+      title: Speed Limit Offset Value
+      min: -30
+      max: 30
+      step: 1
+      unit:
+        metric: km/h
+        imperial: mph
+      visibility:
+      - type: param_compare
+        key: SpeedLimitOffsetType
+        op: '>'
+        value: 0
+- id: smart_cruise
+  title: Smart Cruise Control
+  description: ''
+  enablement:
+  - type: any
+    conditions:
+    - type: capability
+      field: has_longitudinal_control
+      equals: true
+    - type: capability
+      field: has_icbm
+      equals: true
+  items:
+  - key: SmartCruiseControlVision
+    widget: toggle
+    title: Vision
+    description: Use vision path predictions to estimate the appropriate speed to drive through turns ahead.
+    visibility:
+    - type: any
+      conditions:
+      - type: capability
+        field: has_longitudinal_control
+        equals: true
+      - type: capability
+        field: has_icbm
+        equals: true
+    enablement:
+    - type: any
+      conditions:
+      - type: capability
+        field: has_longitudinal_control
+        equals: true
+      - type: capability
+        field: has_icbm
+        equals: true
+  - key: SmartCruiseControlMap
+    widget: toggle
+    title: Map
+    description: Use map data to estimate the appropriate speed to drive through turns ahead.
+    visibility:
+    - type: any
+      conditions:
+      - type: capability
+        field: has_longitudinal_control
+        equals: true
+      - type: capability
+        field: has_icbm
+        equals: true
+    enablement:
+    - type: any
+      conditions:
+      - type: capability
+        field: has_longitudinal_control
+        equals: true
+      - type: capability
+        field: has_icbm
+        equals: true

sunnypilot/sunnylink/settings_ui_src/pages/developer.yaml

@@ -0,0 +1,137 @@
+# Page: developer
+# Edit this file. Run compile_settings_ui.py to emit settings_ui.json.
+id: developer
+label: Developer
+icon: developer
+order: 9
+remote_configurable: true
+description: Debug tools, remote access, and advanced services
+sections:
+- id: connectivity
+  title: Connectivity
+  description: Remote access and debugging interfaces
+  items:
+  - key: AdbEnabled
+    widget: toggle
+    blocked: true
+    title: Enable ADB
+    description: ADB (Android Debug Bridge) allows connecting to your device over USB or over the network. See https://docs.comma.ai/how-to/connect-to-comma
+      for more info.
+    enablement:
+    - $ref: '#/macros/offroad'
+  - key: SshEnabled
+    widget: toggle
+    blocked: true
+    title: Enable SSH
+  - key: JoystickDebugMode
+    widget: toggle
+    title: Joystick Debug Mode
+    enablement:
+    - $ref: '#/macros/offroad'
+  - key: AlphaLongitudinalEnabled
+    widget: toggle
+    needs_onroad_cycle: true
+    title: sunnypilot Longitudinal Control (Alpha)
+    description: 'WARNING: sunnypilot longitudinal control is in alpha for this car and will disable Automatic Emergency Braking
+      (AEB). On this car, sunnypilot defaults to the car''s built-in ACC instead of sunnypilot''s longitudinal control. Enable
+      this to switch to sunnypilot longitudinal control. Enabling Experimental mode is recommended when enabling sunnypilot
+      longitudinal control alpha. Changing this setting will restart sunnypilot if the car is powered on.'
+    visibility:
+    - type: all
+      conditions:
+      - type: capability
+        field: alpha_long_available
+        equals: true
+      - type: not
+        condition:
+          type: capability
+          field: has_icbm
+          equals: true
+    enablement:
+    - $ref: '#/macros/not_engaged'
+  - key: ShowDebugInfo
+    widget: toggle
+    title: UI Debug Mode
+- id: test_maneuvers
+  title: Test Maneuvers
+  description: 'DANGER: enabling these maneuvers replaces normal driving behavior with deterministic test sequences. Each
+    toggle requires explicit confirmation per write. Use only in a closed environment.'
+  visibility:
+  - type: any
+    conditions:
+    - type: capability
+      field: is_development
+      equals: true
+    - type: capability
+      field: is_sp_release
+      equals: true
+  enablement:
+  - type: any
+    conditions:
+    - type: capability
+      field: is_development
+      equals: true
+    - type: param
+      key: ShowAdvancedControls
+      equals: true
+  attestation_required: true
+  items:
+  - key: LateralManeuverMode
+    widget: toggle
+    title: '[TEST] Lateral Maneuver Mode'
+    description: Replaces normal lateral control with a deterministic test sequence. NOT for road use.
+    enablement:
+    - $ref: '#/macros/not_engaged'
+    - type: capability
+      field: torque_allowed
+      equals: true
+  - key: LongitudinalManeuverMode
+    widget: toggle
+    title: '[TEST] Longitudinal Maneuver Mode'
+    description: Replaces normal longitudinal control with a deterministic test sequence. NOT for road use.
+    enablement:
+    - $ref: '#/macros/not_engaged'
+    - $ref: '#/macros/longitudinal'
+- id: advanced_services
+  title: Advanced Settings
+  description: ''
+  items:
+  - key: ShowAdvancedControls
+    widget: toggle
+    title: Show Advanced Controls
+    description: Toggle visibility of advanced sunnypilot controls. This only changes the visibility of the toggles; it does
+      not change the actual enabled/disabled state.
+  - key: EnableGithubRunner
+    widget: toggle
+    title: GitHub Runner Service
+    description: Enables or disables the GitHub runner service.
+    visibility:
+    - $ref: '#/macros/release_branches_hide'
+    enablement:
+    - $ref: '#/macros/advanced_only'
+  - key: EnableCopyparty
+    widget: toggle
+    title: copyparty Service
+    description: copyparty is a very capable file server, you can use it to download your routes, view your logs and even
+      make some edits on some files from your browser. Requires you to connect to your comma locally via its IP address.
+    enablement:
+    - $ref: '#/macros/advanced_only'
+  - key: QuickBootToggle
+    widget: toggle
+    title: Quickboot Mode
+    visibility:
+    - type: not
+      condition:
+        type: any
+        conditions:
+        - type: capability
+          field: is_sp_release
+          equals: true
+        - type: capability
+          field: is_development
+          equals: true
+    enablement:
+    - type: param
+      key: DisableUpdates
+      equals: true
+    - $ref: '#/macros/advanced_only'

sunnypilot/sunnylink/settings_ui_src/pages/device.yaml

@@ -0,0 +1,67 @@
+# Page: device
+# Edit this file. Run compile_settings_ui.py to emit settings_ui.json.
+id: device
+label: Device
+icon: device
+order: 6
+remote_configurable: true
+description: Device behavior, units, and recording settings
+sections:
+- id: general
+  title: General
+  description: Power, boot, and unit preferences
+  items:
+  - key: OffroadMode
+    widget: toggle
+    title: Force Offroad Mode
+  - key: DeviceBootMode
+    widget: option
+    title: Wake Up Behavior
+    description: 'Controls state of the device after boot/sleep. Default: Device will boot/wake-up normally and will be ready
+      to engage. Offroad: Device will be in Always Offroad mode after boot/wake-up.'
+    options:
+    - value: 0
+      label: Standard
+    - value: 1
+      label: Always Offroad
+  - key: QuietMode
+    widget: toggle
+    title: Quiet Mode
+  - key: OnroadUploads
+    widget: toggle
+    title: Onroad Uploads
+  - key: MaxTimeOffroad
+    widget: option
+    title: Max Time Offroad
+    description: Device will automatically shutdown after set time once the engine is turned off. 30h is the default.
+    options:
+    - value: 0
+      label: Always On
+    - value: 1
+      label: 5m
+    - value: 2
+      label: 10m
+    - value: 3
+      label: 15m
+    - value: 4
+      label: 30m
+    - value: 5
+      label: 1h
+    - value: 6
+      label: 2h
+    - value: 7
+      label: 3h
+    - value: 8
+      label: 5h
+    - value: 9
+      label: 10h
+    - value: 10
+      label: 24h
+    - value: 11
+      label: 30h (Default)
+- id: language
+  title: Language
+  items:
+  - key: LanguageSetting
+    widget: info
+    title: Language

sunnypilot/sunnylink/settings_ui_src/pages/display.yaml

@@ -0,0 +1,130 @@
+# Page: display
+# Edit this file. Run compile_settings_ui.py to emit settings_ui.json.
+id: display
+label: Display
+icon: display
+order: 3
+remote_configurable: true
+description: Screen brightness, timeout, and interactivity settings
+sections:
+- id: brightness_timeout
+  title: Brightness & Timeout
+  description: Screen dimming and sleep behavior while driving
+  items:
+  - key: OnroadScreenOffBrightness
+    widget: multiple_button
+    title: Onroad Brightness
+    options:
+    - value: 0
+      label: Auto (Default)
+    - value: 1
+      label: Auto (Dark)
+    - value: 2
+      label: Screen Off
+    - value: 3
+      label: 5 %
+    - value: 4
+      label: 10 %
+    - value: 5
+      label: 15 %
+    - value: 6
+      label: 20 %
+    - value: 7
+      label: 25 %
+    - value: 8
+      label: 30 %
+    - value: 9
+      label: 35 %
+    - value: 10
+      label: 40 %
+    - value: 11
+      label: 45 %
+    - value: 12
+      label: 50 %
+    - value: 13
+      label: 55 %
+    - value: 14
+      label: 60 %
+    - value: 15
+      label: 65 %
+    - value: 16
+      label: 70 %
+    - value: 17
+      label: 75 %
+    - value: 18
+      label: 80 %
+    - value: 19
+      label: 85 %
+    - value: 20
+      label: 90 %
+    - value: 21
+      label: 95 %
+    - value: 22
+      label: 100 %
+  - key: OnroadScreenOffTimer
+    widget: multiple_button
+    title: Onroad Brightness Delay
+    options:
+    - value: 0
+      label: Always On
+    - value: 3
+      label: 3s
+    - value: 5
+      label: 5s
+    - value: 10
+      label: 10s
+    - value: 15
+      label: 15s
+    - value: 30
+      label: 30s
+    - value: 60
+      label: 1m
+    - value: 180
+      label: 3m
+    - value: 300
+      label: 5m
+    - value: 600
+      label: 10m
+    enablement:
+    - type: not
+      condition:
+        type: any
+        conditions:
+        - type: param
+          key: OnroadScreenOffBrightness
+          equals: 0
+        - type: param
+          key: OnroadScreenOffBrightness
+          equals: 1
+  - key: InteractivityTimeout
+    widget: multiple_button
+    title: Interactivity Timeout
+    description: Apply a custom timeout for settings UI. This is the time after which settings UI closes automatically if
+      user is not interacting with the screen.
+    options:
+    - value: 0
+      label: Default
+    - value: 10
+      label: 10 s
+    - value: 20
+      label: 20 s
+    - value: 30
+      label: 30 s
+    - value: 40
+      label: 40 s
+    - value: 50
+      label: 50 s
+    - value: 60
+      label: 1 m
+    - value: 70
+      label: 1 m
+    - value: 80
+      label: 1 m
+    - value: 90
+      label: 1 m
+    - value: 100
+      label: 1 m
+    - value: 110
+      label: 1 m
+    - value: 120
+      label: 2 m

sunnypilot/sunnylink/settings_ui_src/pages/models.yaml

@@ -0,0 +1,89 @@
+# Page: models
+# Edit this file. Run compile_settings_ui.py to emit settings_ui.json.
+id: models
+label: Models
+icon: models
+order: 10
+remote_configurable: false
+description: Driving model behavior and camera calibration
+sections:
+- id: model_behavior
+  title: Model Behavior
+  description: Lane desire and lead-vehicle awareness tuning
+  items:
+  - key: LaneTurnDesire
+    widget: toggle
+    title: Use Lane Turn Desires
+    description: If you are driving at 20 mph (32 km/h) or below and have your blinker on, the car will plan a turn in that
+      direction at the nearest drivable path. This prevents situations (like at red lights) where the car might plan the wrong
+      turn direction.
+  - key: LaneTurnValue
+    widget: option
+    title: Adjust Lane Turn Speed
+    description: Set the maximum speed for lane turn desires.
+    min: 0
+    max: 20
+    step: 1
+    unit:
+      metric: km/h
+      imperial: mph
+    enablement:
+    - type: param
+      key: LaneTurnDesire
+      equals: true
+    - $ref: '#/macros/advanced_only'
+  - key: LagdToggle
+    widget: toggle
+    title: Live Learning Steer Delay
+    description: Allow device to learn and adapt car's steering response time
+  - key: LagdToggleDelay
+    widget: option
+    title: Adjust Software Delay
+    description: Adjust the software delay when Live Learning Steer Delay is toggled off. The default software delay value
+      is 0.2
+    min: 0.05
+    max: 0.5
+    step: 0.01
+    enablement:
+    - type: not
+      condition:
+        type: param
+        key: LagdToggle
+        equals: true
+    - $ref: '#/macros/advanced_only'
+- id: lateral_control
+  title: Lateral Control
+  description: Neural network lateral control for supported models
+  items:
+  - key: NeuralNetworkLateralControl
+    widget: toggle
+    title: Neural Network Lateral Control (NNLC)
+    description: Use a neural network for lateral control instead of the default torque controller.
+    visibility:
+    - type: not
+      condition:
+        type: capability
+        field: steer_control_type
+        equals: angle
+    enablement:
+    - $ref: '#/macros/offroad'
+    - type: capability
+      field: torque_allowed
+      equals: true
+    - type: param
+      key: EnforceTorqueControl
+      equals: false
+- id: camera
+  title: Camera
+  description: Camera position and calibration
+  items:
+  - key: CameraOffset
+    widget: option
+    title: Adjust Camera Offset
+    description: Virtually shift camera's perspective to move model's center to Left(+ values) or Right (- values)
+    min: -0.35
+    max: 0.35
+    step: 0.01
+    unit: meters
+    enablement:
+    - $ref: '#/macros/advanced_only'

sunnypilot/sunnylink/settings_ui_src/pages/software.yaml

@@ -0,0 +1,20 @@
+# Page: software
+# Edit this file. Run compile_settings_ui.py to emit settings_ui.json.
+id: software
+label: Software
+icon: software
+order: 7
+remote_configurable: true
+description: Software update preferences
+sections:
+- id: updates
+  title: Updates
+  description: Control automatic software updates
+  items:
+  - key: DisableUpdates
+    widget: toggle
+    title: Disable Updates
+    description: When enabled, automatic software updates will be off. This requires a reboot to take effect.
+    enablement:
+    - $ref: '#/macros/offroad'
+    - $ref: '#/macros/advanced_only'

sunnypilot/sunnylink/settings_ui_src/pages/steering.yaml

@@ -0,0 +1,257 @@
+# Page: steering
+# Edit this file. Run compile_settings_ui.py to emit settings_ui.json.
+id: steering
+label: Steering
+icon: steering_wheel
+order: 1
+remote_configurable: true
+description: Lateral control, lane changes, and steering behavior
+sections:
+- id: mads
+  title: Modular Assistive Driving System (MADS)
+  description: ''
+  items:
+  - key: Mads
+    widget: toggle
+    title: Enable Modular Assistive Driving System (MADS)
+    description: Enable MADS. Disable toggle to revert back to stock sunnypilot engagement/disengagement.
+    enablement:
+    - $ref: '#/macros/offroad'
+  sub_panels:
+  - id: mads_settings
+    label: MADS Settings
+    trigger_key: Mads
+    trigger_condition:
+      type: param
+      key: Mads
+      equals: true
+    items:
+    - key: MadsMainCruiseAllowed
+      widget: toggle
+      title: Toggle with Main Cruise
+      description: 'Note: For vehicles without LFA/LKAS button, disabling this will prevent lateral control engagement.'
+      enablement:
+      - $ref: '#/macros/offroad'
+      - $ref: '#/macros/mads_full_platforms'
+    - key: MadsUnifiedEngagementMode
+      widget: toggle
+      title: Unified Engagement Mode (UEM)
+      description: 'Engage lateral and longitudinal control with cruise control engagement. Note: Once lateral control is
+        engaged via UEM, it will remain engaged until it is manually disabled via the MADS button or car shut off.'
+      enablement:
+      - $ref: '#/macros/offroad'
+      - $ref: '#/macros/mads_full_platforms'
+    - key: MadsSteeringMode
+      widget: multiple_button
+      title: Steering Mode on Brake Pedal
+      description: Choose how Automatic Lane Centering (ALC) behaves after the brake pedal is manually pressed in sunnypilot.
+      options:
+      - value: 0
+        label: Remain Active
+        enablement:
+        - $ref: '#/macros/mads_full_platforms'
+      - value: 1
+        label: Pause
+        enablement:
+        - $ref: '#/macros/mads_full_platforms'
+      - value: 2
+        label: Disengage
+      enablement:
+      - $ref: '#/macros/offroad'
+- id: blinker
+  title: Blinker Control
+  description: Lateral pause behavior during turn signals
+  items:
+  - key: BlinkerPauseLateralControl
+    widget: toggle
+    title: Pause Lateral Control with Blinker
+    description: Pause lateral control with blinker when traveling below the desired speed selected.
+    sub_items:
+    - key: BlinkerMinLateralControlSpeed
+      widget: option
+      title: Minimum Speed to Pause Lateral Control
+      min: 0
+      max: 255
+      step: 5
+      unit:
+        metric: km/h
+        imperial: mph
+      enablement:
+      - type: param
+        key: BlinkerPauseLateralControl
+        equals: true
+    - key: BlinkerLateralReengageDelay
+      widget: option
+      title: Post-Blinker Delay
+      description: Delay before lateral control resumes after the turn signal ends.
+      min: 0
+      max: 10
+      step: 1
+      unit: second
+      enablement:
+      - type: param
+        key: BlinkerPauseLateralControl
+        equals: true
+- id: torque
+  title: Torque Control
+  description: Steering torque tuning and lateral control method
+  enablement:
+  - type: capability
+    field: torque_allowed
+    equals: true
+  items:
+  - key: EnforceTorqueControl
+    widget: toggle
+    title: Enforce Torque Lateral Control
+    description: Enable this to enforce sunnypilot to steer with Torque lateral control.
+    visibility:
+    - type: not
+      condition:
+        type: capability
+        field: steer_control_type
+        equals: angle
+    enablement:
+    - $ref: '#/macros/offroad'
+    - type: capability
+      field: torque_allowed
+      equals: true
+    - type: param
+      key: NeuralNetworkLateralControl
+      equals: false
+  sub_panels:
+  - id: torque_settings
+    label: Torque Settings
+    trigger_key: EnforceTorqueControl
+    trigger_condition:
+      type: param
+      key: EnforceTorqueControl
+      equals: true
+    items:
+    - key: LiveTorqueParamsToggle
+      widget: toggle
+      title: Self-Tune
+      description: Enables self-tune for Torque lateral control for platforms that do not use Torque lateral control by default.
+      enablement:
+      - $ref: '#/macros/offroad'
+    - key: LiveTorqueParamsRelaxedToggle
+      widget: toggle
+      title: Less Restrict Settings for Self-Tune (Beta)
+      description: Less strict settings when using Self-Tune. This allows torqued to be more forgiving when learning values.
+      enablement:
+      - $ref: '#/macros/offroad'
+      - type: param
+        key: LiveTorqueParamsToggle
+        equals: true
+    - key: CustomTorqueParams
+      widget: toggle
+      title: Enable Custom Tuning
+      description: Enables custom tuning for Torque lateral control. Modifying Lateral Acceleration Factor and Friction below
+        will override the offline values indicated in the YAML files within "opendbc/car/torque_data". The values will also
+        be used live when "Manual Real-Time Tuning" toggle is enabled.
+      enablement:
+      - $ref: '#/macros/offroad'
+    - key: TorqueParamsOverrideEnabled
+      widget: toggle
+      title: Manual Real-Time Tuning
+      description: Enforces the torque lateral controller to use the fixed values instead of the learned values from Self-Tune.
+        Enabling this toggle overrides Self-Tune values.
+      enablement:
+      - $ref: '#/macros/offroad'
+      - type: param
+        key: CustomTorqueParams
+        equals: true
+    - key: TorqueParamsOverrideLatAccelFactor
+      widget: option
+      title: Lateral Acceleration Factor
+      title_param_suffix:
+        param: TorqueParamsOverrideEnabled
+        values:
+          'true': (Real-Time & Offline)
+          'false': (Offline Only)
+      min: 0.1
+      max: 5.0
+      step: 0.1
+      unit: m/s²
+      enablement:
+      - type: param
+        key: CustomTorqueParams
+        equals: true
+      - type: any
+        conditions:
+        - type: param
+          key: TorqueParamsOverrideEnabled
+          equals: true
+        - type: offroad_only
+    - key: TorqueParamsOverrideFriction
+      widget: option
+      title: Friction
+      title_param_suffix:
+        param: TorqueParamsOverrideEnabled
+        values:
+          'true': (Real-Time & Offline)
+          'false': (Offline Only)
+      min: 0.0
+      max: 1.0
+      step: 0.01
+      enablement:
+      - type: param
+        key: CustomTorqueParams
+        equals: true
+      - type: any
+        conditions:
+        - type: param
+          key: TorqueParamsOverrideEnabled
+          equals: true
+        - type: offroad_only
+    - key: TorqueControlTune
+      widget: multiple_button
+      title: Torque Control Tune Version
+      description: Select the version of Torque Control Tune to use.
+      options:
+      - value: ''
+        label: Default
+      - value: 1.0
+        label: v1.0
+      - value: 0.0
+        label: v0.0
+      enablement:
+      - $ref: '#/macros/offroad'
+- id: lane_change
+  title: Lane Change
+  description: Automatic lane change timing and behavior
+  items:
+  - key: AutoLaneChangeTimer
+    widget: option
+    title: Auto Lane Change by Blinker
+    description: |-
+      Set a timer to delay the auto lane change operation when the blinker is used. No nudge on the steering wheel is required to auto lane change if a timer is set. Default is Nudge.
+    details: |-
+      Please use caution when using this feature. Only use the blinker when traffic and road conditions permit.
+    options:
+    - value: -1
+      label: 'Off'
+    - value: 0
+      label: Nudge
+    - value: 1
+      label: Nudgeless
+    - value: 2
+      label: 0.5 second
+    - value: 3
+      label: 1 second
+    - value: 4
+      label: 2 seconds
+    - value: 5
+      label: 3 seconds
+  - key: AutoLaneChangeBsmDelay
+    widget: toggle
+    title: 'Auto Lane Change: Delay with Blind Spot'
+    description: Toggle to enable a delay timer for lane changes when blind spot monitoring (BSM) detects a vehicle in your blind
+      spot.
+    enablement:
+    - type: capability
+      field: enable_bsm
+      equals: true
+    - type: param_compare
+      key: AutoLaneChangeTimer
+      op: '>'
+      value: 0

sunnypilot/sunnylink/settings_ui_src/pages/toggles.yaml

@@ -0,0 +1,49 @@
+# Page: toggles
+# Edit this file. Run compile_settings_ui.py to emit settings_ui.json.
+id: toggles
+label: Toggles
+icon: toggles
+order: 5
+remote_configurable: true
+description: Core openpilot feature toggles
+sections:
+- id: core_toggles
+  title: ''
+  description: ''
+  items:
+  - key: OpenpilotEnabledToggle
+    widget: toggle
+    needs_onroad_cycle: true
+    title: Enable sunnypilot
+    description: Use the sunnypilot system for adaptive cruise control and lane keep driver assistance. Your attention is
+      required at all times to use this feature.
+    enablement:
+    - $ref: '#/macros/offroad'
+  - key: IsLdwEnabled
+    widget: toggle
+    title: Enable Lane Departure Warnings
+    description: Receive alerts to steer back into the lane when your vehicle drifts over a detected lane line without a turn
+      signal activated while driving over 31 mph (50 km/h).
+  - key: AlwaysOnDM
+    widget: toggle
+    title: Always-On Driver Monitoring
+    description: Enable driver monitoring even when sunnypilot is not engaged.
+  - key: IsMetric
+    widget: toggle
+    title: Use Metric System
+    description: Display speed in km/h instead of mph.
+- id: recording
+  title: Recording
+  description: Camera and audio recording during drives
+  items:
+  - key: RecordFront
+    widget: toggle
+    needs_onroad_cycle: true
+    title: Record and Upload Driver Camera
+    description: Upload data from the driver facing camera and help improve the driver monitoring algorithm.
+  - key: RecordAudio
+    widget: toggle
+    needs_onroad_cycle: true
+    title: Record and Upload Microphone Audio
+    description: Record and store microphone audio while driving. The audio will be included in the dashcam video in comma
+      connect.

sunnypilot/sunnylink/settings_ui_src/pages/vehicle.yaml

@@ -0,0 +1,81 @@
+# Page: vehicle (per-brand settings)
+# Compiles to settings_ui.json#vehicle_settings (brand = section id).
+id: vehicle
+label: Vehicle
+icon: vehicle
+order: 99
+kind: vehicle
+sections:
+- id: hyundai
+  title: Hyundai / Kia / Genesis Settings
+  description: ''
+  items:
+  - key: HyundaiLongitudinalTuning
+    widget: multiple_button
+    title: Custom Longitudinal Tuning
+    options:
+    - value: 0
+      label: 'Off'
+    - value: 1
+      label: Dynamic
+    - value: 2
+      label: Predictive
+    visibility:
+    - type: capability
+      field: hyundai_alpha_long_available
+      equals: true
+    enablement:
+    - $ref: '#/macros/offroad'
+    - $ref: '#/macros/longitudinal'
+- id: subaru
+  title: Subaru Settings
+  description: ''
+  items:
+  - key: SubaruStopAndGo
+    widget: toggle
+    title: Stop and Go (Beta)
+    enablement:
+    - $ref: '#/macros/offroad'
+    - type: capability
+      field: has_stop_and_go
+      equals: true
+  - key: SubaruStopAndGoManualParkingBrake
+    widget: toggle
+    title: Stop and Go for Manual Parking Brake (Beta)
+    enablement:
+    - $ref: '#/macros/offroad'
+    - type: capability
+      field: has_stop_and_go
+      equals: true
+- id: tesla
+  title: Tesla Settings
+  description: ''
+  items:
+  - key: TeslaCoopSteering
+    widget: toggle
+    title: Cooperative Steering (Beta)
+    enablement:
+    - $ref: '#/macros/offroad'
+- id: toyota
+  title: Toyota / Lexus Settings
+  description: ''
+  items:
+  - key: ToyotaEnforceStockLongitudinal
+    widget: toggle
+    needs_onroad_cycle: true
+    title: Enforce Factory Longitudinal Control
+    description: sunnypilot will not take over control of gas and brakes. Factory Toyota longitudinal control will be used.
+    enablement:
+    - $ref: '#/macros/not_engaged'
+  - key: ToyotaStopAndGoHack
+    widget: toggle
+    needs_onroad_cycle: true
+    title: Stop and Go Hack (Alpha)
+    description: sunnypilot will allow some Toyota/Lexus cars to auto resume during stop and go traffic. This feature is only
+      applicable to certain models that are able to use longitudinal control. This is an alpha feature. Use at your own risk.
+    enablement:
+    - $ref: '#/macros/not_engaged'
+    - $ref: '#/macros/longitudinal'
+    - type: param
+      key: ToyotaEnforceStockLongitudinal
+      equals: false

sunnypilot/sunnylink/settings_ui_src/pages/visuals.yaml

@@ -0,0 +1,111 @@
+# Page: visuals
+# Edit this file. Run compile_settings_ui.py to emit settings_ui.json.
+id: visuals
+label: Visuals
+icon: visuals
+order: 4
+remote_configurable: true
+description: HUD overlays, alerts, and on-screen display elements
+sections:
+- id: hud_elements
+  title: HUD Elements
+  description: Overlays shown on the driving screen
+  items:
+  - key: BlindSpot
+    widget: toggle
+    title: Show Blind Spot Warnings
+    description: Enabling this will display warnings when a vehicle is detected in your blind spot as long as your car has
+      BSM supported.
+  - key: TorqueBar
+    widget: toggle
+    title: Steering Arc
+    description: Display steering arc on the driving screen when lateral control is enabled.
+  - key: ShowTurnSignals
+    widget: toggle
+    title: Display Turn Signals
+    description: When enabled, visual turn indicators are drawn on the HUD.
+  - key: RoadNameToggle
+    widget: toggle
+    title: Display Road Name
+    description: Displays the name of the road the car is traveling on. The OpenStreetMap database of the location must be
+      downloaded to fetch the road name.
+    visibility:
+    - $ref: '#/macros/hide_on_mici'
+  - key: StandstillTimer
+    widget: toggle
+    title: Standstill Timer
+    description: Show a timer on the HUD when the car is at a standstill.
+    visibility:
+    - $ref: '#/macros/hide_on_mici'
+  - key: RocketFuel
+    widget: toggle
+    title: Real-time Acceleration Bar
+    description: Show an indicator on the left side of the screen to display real-time vehicle acceleration and deceleration.
+      This displays what the car is currently doing, not what the planner is requesting.
+    visibility:
+    - $ref: '#/macros/hide_on_mici'
+  - key: ChevronInfo
+    widget: option
+    title: Display Metrics Below Chevron
+    options:
+    - value: 0
+      label: 'Off'
+    - value: 1
+      label: Distance
+    - value: 2
+      label: Speed
+    - value: 3
+      label: Time
+    - value: 4
+      label: All
+    visibility:
+    - $ref: '#/macros/hide_on_mici'
+    enablement:
+    - $ref: '#/macros/longitudinal'
+- id: developer_ui
+  title: Developer UI Info
+  description: Speedometer and debug display options
+  visibility:
+  - $ref: '#/macros/hide_on_mici'
+  items:
+  - key: DevUIInfo
+    widget: option
+    title: Developer UI
+    description: Display real-time parameters and metrics from various sources.
+    options:
+    - value: 0
+      label: 'Off'
+    - value: 1
+      label: Bottom
+    - value: 2
+      label: Right
+    - value: 3
+      label: Right & Bottom
+  - key: TrueVEgoUI
+    widget: toggle
+    title: 'Speedometer: Always Display True Speed'
+    description: For applicable vehicles, always display the true vehicle current speed from wheel speed sensors.
+  - key: HideVEgoUI
+    widget: toggle
+    title: 'Speedometer: Hide from Onroad Screen'
+    description: When enabled, the speedometer on the onroad screen is not displayed.
+- id: alerts_extras
+  title: Alerts & Extras
+  description: Traffic light alerts and visual flair
+  items:
+  - key: GreenLightAlert
+    widget: toggle
+    title: Green Traffic Light Alert (Beta)
+    description: 'A chime and on-screen alert will play when the traffic light you are waiting for turns green and you have
+      no vehicle in front of you. On-screen visual alert is only available on comma 3X. Note: This chime is only designed
+      as a notification. It is the driver''s responsibility to observe their environment and make decisions accordingly.'
+  - key: LeadDepartAlert
+    widget: toggle
+    title: Lead Departure Alert (Beta)
+    description: 'A chime and on-screen alert will play when you are stopped, and the vehicle in front of you start moving.
+      On-screen visual alert is only available on comma 3X. Note: This chime is only designed as a notification. It is the
+      driver''s responsibility to observe their environment and make decisions accordingly.'
+  - key: RainbowMode
+    widget: toggle
+    title: Tesla Rainbow Mode
+    description: Display a rainbow effect on the path the model wants to take. It does not affect driving in any way.

sunnypilot/sunnylink/tests/test_capabilities.py

@@ -0,0 +1,92 @@
+"""
+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.
+
+Sentinel tests for the capabilities payload contract. PROTOCOL_VERSION is the
+wire-protocol version observable by the dashboard; bumping it is a breaking
+change and must be intentional. KNOWN_PROTOCOL_VERSIONS pins the set we
+explicitly support — when the constant is bumped, this list must be edited in
+the same commit so the bump shows up in code review.
+"""
+from __future__ import annotations
+
+import pytest
+
+from openpilot.sunnypilot.sunnylink.capabilities import (
+  CAPABILITY_DEFAULTS,
+  CAPABILITY_FIELDS,
+  CAPABILITY_LABELS,
+  PROTOCOL_VERSION,
+  generate_capabilities,
+)
+
+
+KNOWN_PROTOCOL_VERSIONS = (1,)
+LATEST_KNOWN = max(KNOWN_PROTOCOL_VERSIONS)
+
+
+@pytest.fixture(scope="module")
+def caps():
+  return generate_capabilities()
+
+
+class TestProtocolVersion:
+  def test_protocol_version_in_capability_fields(self):
+    assert "protocol_version" in CAPABILITY_FIELDS
+
+  def test_protocol_version_has_label(self):
+    assert "protocol_version" in CAPABILITY_LABELS
+
+  def test_protocol_version_default_is_set(self):
+    assert CAPABILITY_DEFAULTS.get("protocol_version") == PROTOCOL_VERSION
+
+  def test_protocol_version_emitted(self, caps):
+    assert "protocol_version" in caps
+    assert isinstance(caps["protocol_version"], int)
+    assert caps["protocol_version"] >= 1
+
+  def test_protocol_version_matches_constant(self, caps):
+    assert caps["protocol_version"] == PROTOCOL_VERSION
+
+  def test_protocol_version_is_known(self):
+    """Sentinel against accidental bumps. Edit KNOWN_PROTOCOL_VERSIONS if intentional."""
+    assert PROTOCOL_VERSION in KNOWN_PROTOCOL_VERSIONS, (
+      f"PROTOCOL_VERSION={PROTOCOL_VERSION} is not in KNOWN_PROTOCOL_VERSIONS={KNOWN_PROTOCOL_VERSIONS}. " +
+      "If this bump is intentional, add it to KNOWN_PROTOCOL_VERSIONS."
+    )
+
+  def test_protocol_version_matches_latest_known(self):
+    assert PROTOCOL_VERSION == LATEST_KNOWN, (
+      "Test invariant: PROTOCOL_VERSION must equal max(KNOWN_PROTOCOL_VERSIONS)."
+    )
+
+
+class TestOpaquePerBrandFlags:
+  def test_subaru_has_sng_field_present(self):
+    assert "subaru_has_sng" in CAPABILITY_FIELDS
+
+  def test_hyundai_alpha_long_available_field_present(self):
+    assert "hyundai_alpha_long_available" in CAPABILITY_FIELDS
+
+  def test_subaru_has_sng_default_false(self, caps):
+    assert caps["subaru_has_sng"] is False
+
+  def test_hyundai_alpha_long_available_default_false(self, caps):
+    assert caps["hyundai_alpha_long_available"] is False
+
+
+class TestCapabilitiesShape:
+  def test_all_fields_present(self, caps):
+    for field in CAPABILITY_FIELDS:
+      assert field in caps, f"capabilities missing {field}"
+
+  def test_all_fields_have_labels(self):
+    for field in CAPABILITY_FIELDS:
+      assert field in CAPABILITY_LABELS, f"CAPABILITY_LABELS missing {field}"
+
+  def test_string_defaults_are_strings(self, caps):
+    assert isinstance(caps["brand"], str)
+    assert isinstance(caps["steer_control_type"], str)
+    assert isinstance(caps["device_type"], str)

sunnypilot/sunnylink/tests/test_compile_settings_ui.py

@@ -0,0 +1,194 @@
+"""
+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.
+
+Tests for the settings_ui_src/ -> settings_ui.json compiler. Covers:
+  - Roundtrip: compiled output matches the checked-in settings_ui.json
+  - $ref macro resolution semantics (list-splice, scalar-substitute, depth, cycles)
+  - Per-page tree integrity (every page has id; vehicle page emits to vehicle_settings)
+
+Does not cover device-side generator (test_settings_schema.py) or per-bug
+regression (test_settings_changes.py); those continue to validate the
+compiled output once the compiler has produced it.
+"""
+from __future__ import annotations
+
+import difflib
+import json
+import os
+
+import pytest
+import yaml
+
+from openpilot.sunnypilot.sunnylink.tools.compile_settings_ui import (
+  CompileError,
+  DEFAULT_OUT,
+  DEFAULT_SRC,
+  _resolve_refs,
+  compile_schema,
+)
+
+
+@pytest.fixture(scope="module")
+def compiled() -> dict:
+  return compile_schema(DEFAULT_SRC)
+
+
+@pytest.fixture(scope="module")
+def committed() -> dict:
+  with open(DEFAULT_OUT) as f:
+    return json.load(f)
+
+
+class TestRoundtrip:
+  def test_compiled_matches_committed(self, compiled, committed):
+    """Compiled output must match the checked-in JSON."""
+    if compiled == committed:
+      return
+    diff = "\n".join(difflib.unified_diff(
+      json.dumps(committed, indent=2).splitlines(),
+      json.dumps(compiled, indent=2).splitlines(),
+      fromfile="settings_ui.json (committed)",
+      tofile="settings_ui.json (freshly compiled)",
+      lineterm="",
+    ))
+    pytest.fail(f"settings_ui.json schema mismatch — run compile_settings_ui.py\n\n{diff}")
+
+  def test_committed_file_is_canonical(self):
+    """Compiled output must byte-match the checked-in file (including trailing newline).
+    Drift means someone edited settings_ui.json by hand instead of editing settings_ui_src/."""
+    schema = compile_schema(DEFAULT_SRC)
+    rendered = json.dumps(schema, indent=2) + "\n"
+    with open(DEFAULT_OUT) as f:
+      current = f.read()
+    if current == rendered:
+      return
+    diff = "\n".join(difflib.unified_diff(
+      current.splitlines(),
+      rendered.splitlines(),
+      fromfile="settings_ui.json (on disk)",
+      tofile="settings_ui.json (freshly compiled)",
+      lineterm="",
+    ))
+    pytest.fail(f"settings_ui.json out of sync — run compile_settings_ui.py\n\n{diff}")
+
+
+class TestRefResolution:
+  def test_list_context_splices(self):
+    macros = {"a": [{"type": "offroad_only"}], "b": [{"type": "not_engaged"}]}
+    out = _resolve_refs([{"$ref": "#/macros/a"}, {"$ref": "#/macros/b"}], macros)
+    assert out == [{"type": "offroad_only"}, {"type": "not_engaged"}]
+
+  def test_scalar_context_substitutes(self):
+    macros = {"x": {"type": "capability", "field": "brand", "equals": "tesla"}}
+    out = _resolve_refs({"condition": {"$ref": "#/macros/x"}}, macros)
+    assert out == {"condition": {"type": "capability", "field": "brand", "equals": "tesla"}}
+
+  def test_chained_ref_resolves(self):
+    macros = {
+      "leaf": [{"type": "offroad_only"}],
+      "middle": [{"$ref": "#/macros/leaf"}],
+    }
+    out = _resolve_refs([{"$ref": "#/macros/middle"}], macros)
+    assert out == [{"type": "offroad_only"}]
+
+  def test_unknown_macro_raises(self):
+    with pytest.raises(CompileError, match="unknown macro"):
+      _resolve_refs([{"$ref": "#/macros/missing"}], {})
+
+  def test_cycle_raises(self):
+    macros = {"a": [{"$ref": "#/macros/b"}], "b": [{"$ref": "#/macros/a"}]}
+    with pytest.raises(CompileError, match="cycle"):
+      _resolve_refs([{"$ref": "#/macros/a"}], macros)
+
+  def test_depth_limit(self):
+    # Depth 4 chain should fail (limit is 3).
+    macros = {
+      "l1": [{"$ref": "#/macros/l2"}],
+      "l2": [{"$ref": "#/macros/l3"}],
+      "l3": [{"$ref": "#/macros/l4"}],
+      "l4": [{"type": "offroad_only"}],
+    }
+    with pytest.raises(CompileError, match="depth"):
+      _resolve_refs([{"$ref": "#/macros/l1"}], macros)
+
+  def test_invalid_ref_scheme(self):
+    with pytest.raises(CompileError, match="unsupported"):
+      _resolve_refs([{"$ref": "https://example.com/x"}], {})
+
+  def test_scalar_macro_in_list_context_raises(self):
+    macros = {"x": {"type": "offroad_only"}}  # macro is a single rule (dict), not a list
+    with pytest.raises(CompileError, match="must resolve to a list"):
+      _resolve_refs([{"$ref": "#/macros/x"}], macros)
+
+
+class TestCompiledShape:
+  def test_panels_present(self, compiled):
+    assert isinstance(compiled["panels"], list)
+    assert len(compiled["panels"]) == 9
+    panel_ids = {p["id"] for p in compiled["panels"]}
+    assert {"steering", "cruise", "display", "visuals", "toggles",
+            "device", "software", "developer", "models"} <= panel_ids
+
+  def test_vehicle_settings_consistent_shape(self, compiled):
+    """Each brand in vehicle_settings must have {title, description, items}."""
+    for brand, data in compiled["vehicle_settings"].items():
+      assert isinstance(data, dict), f"{brand}: expected object, got {type(data).__name__}"
+      assert "title" in data, f"{brand}: missing title"
+      assert "description" in data, f"{brand}: missing description"
+      assert "items" in data, f"{brand}: missing items"
+
+  def test_no_dangling_refs_after_compile(self, compiled):
+    """All $ref objects must be resolved during compilation."""
+    def walk(node):
+      if isinstance(node, dict):
+        if "$ref" in node:
+          pytest.fail(f"unresolved $ref: {node}")
+        for v in node.values():
+          walk(v)
+      elif isinstance(node, list):
+        for x in node:
+          walk(x)
+    walk(compiled)
+
+
+class TestSourceTreeIntegrity:
+  def test_macros_yaml_well_formed(self):
+    with open(os.path.join(DEFAULT_SRC, "_macros.yaml")) as f:
+      doc = yaml.safe_load(f)
+    assert "macros" in doc
+    for name, body in doc["macros"].items():
+      assert name.replace("_", "").isalnum(), f"macro name '{name}' must be alphanumeric_"
+      assert body, f"macro '{name}' empty"
+
+  def test_pages_dir_well_formed(self):
+    pages_dir = os.path.join(DEFAULT_SRC, "pages")
+    assert os.path.isdir(pages_dir), "pages/ directory missing"
+    page_files = sorted(fn for fn in os.listdir(pages_dir) if fn.endswith(".yaml"))
+    # 9 panels + 1 vehicle = 10
+    assert len(page_files) == 10, f"expected 10 pages, found {len(page_files)}: {page_files}"
+
+  def test_every_page_has_id(self):
+    pages_dir = os.path.join(DEFAULT_SRC, "pages")
+    for fn in sorted(os.listdir(pages_dir)):
+      if not fn.endswith(".yaml"):
+        continue
+      path = os.path.join(pages_dir, fn)
+      with open(path) as f:
+        doc = yaml.safe_load(f)
+      assert isinstance(doc, dict), f"{path}: top-level must be a mapping"
+      assert "id" in doc, f"{path}: page missing 'id'"
+      # File basename should match page id (modulo .yaml extension).
+      expected_id = os.path.splitext(fn)[0]
+      assert doc["id"] == expected_id, (
+        f"{path}: page id '{doc['id']}' must match filename '{expected_id}'"
+      )
+
+  def test_vehicle_page_kind(self):
+    """vehicle.yaml must declare kind: vehicle so it routes to vehicle_settings."""
+    path = os.path.join(DEFAULT_SRC, "pages", "vehicle.yaml")
+    with open(path) as f:
+      doc = yaml.safe_load(f)
+    assert doc.get("kind") == "vehicle", "vehicle.yaml must declare kind: vehicle"

sunnypilot/sunnylink/tests/test_settings_changes.py

@@ -0,0 +1,219 @@
+"""
+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.
+
+Per-bug regression tests for the Raylib-vs-schema parity audit. Each test
+isolates one of the gating bugs that the design-overhaul branch fixes so a
+future regression is loud and obvious. These tests are intentionally narrow
+and additive — they do not replace the broader test_settings_schema.py.
+"""
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+import pytest
+
+from openpilot.sunnypilot.sunnylink.tools.generate_settings_schema import (
+  DEFINITION_PATH,
+  TORQUE_VERSIONS_PATH,
+  _build_torque_options,
+  _load_torque_versions,
+  generate_schema,
+)
+
+
+SCHEMA_VALIDATOR_PATH = os.path.join(os.path.dirname(DEFINITION_PATH), "settings_ui.schema.json")
+
+
+def _walk_items(schema: dict[str, Any]):
+  """Yield every item dict from the schema."""
+  def _yield(item: dict[str, Any]):
+    yield item
+    for sub in item.get("sub_items", []):
+      yield from _yield(sub)
+
+  for panel in schema.get("panels", []):
+    for section in panel.get("sections", []):
+      for item in section.get("items", []):
+        yield from _yield(item)
+      for sp in section.get("sub_panels", []):
+        for item in sp.get("items", []):
+          yield from _yield(item)
+    for item in panel.get("items", []):
+      yield from _yield(item)
+    for sp in panel.get("sub_panels", []):
+      for item in sp.get("items", []):
+        yield from _yield(item)
+  for brand in schema.get("vehicle_settings", {}).values():
+    items = brand.get("items", []) if isinstance(brand, dict) else brand
+    for item in items:
+      yield from _yield(item)
+
+
+def _find_item(schema: dict[str, Any], key: str) -> dict[str, Any] | None:
+  for item in _walk_items(schema):
+    if item.get("key") == key:
+      return item
+  return None
+
+
+def _find_section(schema: dict[str, Any], panel_id: str, section_id: str) -> dict[str, Any] | None:
+  for panel in schema.get("panels", []):
+    if panel.get("id") != panel_id:
+      continue
+    for section in panel.get("sections", []):
+      if section.get("id") == section_id:
+        return section
+  return None
+
+
+def _flatten_rule_types(rules: list[dict[str, Any]] | None) -> set[str]:
+  out: set[str] = set()
+
+  def _walk(rule: dict[str, Any]) -> None:
+    out.add(rule.get("type", ""))
+    if rule.get("type") == "not" and "condition" in rule:
+      _walk(rule["condition"])
+    elif rule.get("type") in ("any", "all"):
+      for c in rule.get("conditions", []):
+        _walk(c)
+
+  for rule in rules or []:
+    _walk(rule)
+  return out
+
+
+def _references_capability_field(rules: list[dict[str, Any]] | None, field: str) -> bool:
+  found = False
+
+  def _walk(rule: dict[str, Any]) -> None:
+    nonlocal found
+    if rule.get("type") == "capability" and rule.get("field") == field:
+      found = True
+    elif rule.get("type") == "not" and "condition" in rule:
+      _walk(rule["condition"])
+    elif rule.get("type") in ("any", "all"):
+      for c in rule.get("conditions", []):
+        _walk(c)
+
+  for rule in rules or []:
+    _walk(rule)
+  return found
+
+
+@pytest.fixture(scope="module")
+def schema():
+  return generate_schema()
+
+
+class TestMadsBrandGates:
+  def test_mads_main_cruise_has_brand_gate(self, schema):
+    """MadsMainCruiseAllowed must gate on brand and tesla_has_vehicle_bus."""
+    item = _find_item(schema, "MadsMainCruiseAllowed")
+    assert item is not None
+    assert _references_capability_field(item.get("enablement"), "brand")
+    assert _references_capability_field(item.get("enablement"), "tesla_has_vehicle_bus")
+
+  def test_mads_unified_engagement_has_brand_gate(self, schema):
+    """MadsUnifiedEngagementMode must mirror MadsMainCruiseAllowed brand-gate."""
+    item = _find_item(schema, "MadsUnifiedEngagementMode")
+    assert item is not None
+    assert _references_capability_field(item.get("enablement"), "brand")
+    assert _references_capability_field(item.get("enablement"), "tesla_has_vehicle_bus")
+
+
+class TestTestManeuversSection:
+  def test_lateral_maneuver_mode_in_test_maneuvers(self, schema):
+    section = _find_section(schema, "developer", "test_maneuvers")
+    assert section is not None, "developer.test_maneuvers section missing"
+    keys = {item["key"] for item in section.get("items", [])}
+    assert "LateralManeuverMode" in keys
+    assert "LongitudinalManeuverMode" in keys
+
+  def test_test_maneuvers_section_requires_attestation(self, schema):
+    section = _find_section(schema, "developer", "test_maneuvers")
+    assert section is not None
+    assert section.get("attestation_required") is True
+
+  def test_test_maneuvers_section_visibility_gate(self, schema):
+    section = _find_section(schema, "developer", "test_maneuvers")
+    assert section is not None
+    visibility = section.get("visibility")
+    assert visibility, "test_maneuvers must have visibility gate"
+    vis_refs = json.dumps(visibility)
+    assert "is_development" in vis_refs
+    assert "is_sp_release" in vis_refs
+    enablement = section.get("enablement") or []
+    enable_refs = json.dumps(enablement)
+    assert "ShowAdvancedControls" in enable_refs, \
+      "test_maneuvers must gate ShowAdvancedControls via enablement"
+
+
+class TestValidator:
+  def test_validator_accepts_real_json(self):
+    """settings_ui.json validates against settings_ui.schema.json."""
+    jsonschema = pytest.importorskip("jsonschema")
+    with open(DEFINITION_PATH) as f:
+      data = json.load(f)
+    with open(SCHEMA_VALIDATOR_PATH) as f:
+      validator = json.load(f)
+    jsonschema.validate(instance=data, schema=validator)
+
+
+class TestTorqueOptionGeneration:
+  def test_torque_versions_match_generated_options(self, schema):
+    versions = _load_torque_versions()
+    assert versions, "latcontrol_torque_versions.json must have at least one version"
+    expected = _build_torque_options(versions)
+    item = _find_item(schema, "TorqueControlTune")
+    assert item is not None, "TorqueControlTune item must be present"
+    assert item.get("options") == expected
+
+  def test_torque_versions_path_resolves(self):
+    assert os.path.exists(TORQUE_VERSIONS_PATH), (
+      f"latcontrol_torque_versions.json not found at {TORQUE_VERSIONS_PATH}"
+    )
+
+
+class TestReleaseBranchGates:
+  @pytest.mark.parametrize("key", [
+    "EnableGithubRunner",
+    "QuickBootToggle",
+  ])
+  def test_sp_dev_items_gate_on_is_sp_release(self, schema, key):
+    """sunnypilot dev items must hide on sunnypilot release branches (is_sp_release gate)."""
+    item = _find_item(schema, key)
+    assert item is not None, f"{key} not found in schema"
+    rules = (item.get("visibility") or []) + (item.get("enablement") or [])
+    assert _references_capability_field(rules, "is_sp_release"), f"{key} missing is_sp_release gate"
+
+
+class TestSpuriousOffroadGatesDropped:
+  def test_disengage_on_accelerator_has_no_offroad_only(self, schema):
+    item = _find_item(schema, "DisengageOnAccelerator")
+    assert item is not None
+    assert "offroad_only" not in _flatten_rule_types(item.get("enablement"))
+
+  def test_dynamic_experimental_has_no_offroad_only(self, schema):
+    item = _find_item(schema, "DynamicExperimentalControl")
+    assert item is not None
+    assert "offroad_only" not in _flatten_rule_types(item.get("enablement"))
+
+
+class TestNotEngagedReplacement:
+  @pytest.mark.parametrize("key", [
+    "AlphaLongitudinalEnabled",
+    "ToyotaEnforceStockLongitudinal",
+    "ToyotaStopAndGoHack",
+  ])
+  def test_offroad_only_replaced_with_not_engaged(self, schema, key):
+    """These items should use not_engaged, not offroad_only."""
+    item = _find_item(schema, key)
+    assert item is not None, f"{key} not found"
+    rule_types = _flatten_rule_types(item.get("enablement"))
+    assert "offroad_only" not in rule_types, f"{key} still uses offroad_only"
+    assert "not_engaged" in rule_types, f"{key} missing not_engaged"

sunnypilot/sunnylink/tests/test_settings_schema.py

@@ -0,0 +1,353 @@
+"""
+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 pytest
+
+from openpilot.common.params import Params
+from openpilot.sunnypilot.sunnylink.tools.generate_settings_schema import (
+  SCHEMA_VERSION,
+  generate_schema,
+  generate_schema_json,
+  collect_all_keys,
+  collect_capability_refs,
+)
+from openpilot.sunnypilot.sunnylink.capabilities import CAPABILITY_FIELDS
+
+
+VALID_WIDGET_TYPES = {"toggle", "option", "multiple_button", "button", "info"}
+VALID_RULE_TYPES = {"offroad_only", "not_engaged", "capability", "param", "param_compare", "not", "any", "all"}
+VALID_COMPARE_OPS = {">", "<", ">=", "<="}
+MAX_ALLOWED_MISSING_TITLES = 0  # All items must have titles (metadata is inline in settings_ui.json)
+
+
+def _iter_panel_items(panel: dict):
+  """Yield top-level items from a panel (non-recursive)."""
+  for item in panel.get("items", []):
+    yield item
+  for sp in panel.get("sub_panels", []):
+    for item in sp.get("items", []):
+      yield item
+  for section in panel.get("sections", []):
+    for item in section.get("items", []):
+      yield item
+    for sp in section.get("sub_panels", []):
+      for item in sp.get("items", []):
+        yield item
+
+
+def _iter_all_sub_panels(panel: dict):
+  """Yield all sub_panels from a panel and its sections."""
+  yield from panel.get("sub_panels", [])
+  for section in panel.get("sections", []):
+    yield from section.get("sub_panels", [])
+
+
+def _brand_items(brand_data) -> list[dict]:
+  """Extract items from vehicle_settings[brand] (handles dict or list)."""
+  if isinstance(brand_data, dict):
+    return brand_data.get("items", [])
+  if isinstance(brand_data, list):
+    return brand_data
+  return []
+
+
+@pytest.fixture(scope="module")
+def schema():
+  return generate_schema()
+
+
+@pytest.fixture(scope="module")
+def all_param_keys():
+  """All keys registered in the device param store."""
+  return {k.decode("utf-8") for k in Params().all_keys()}
+
+
+class TestSchemaStructure:
+  def test_schema_is_valid_json(self):
+    """Schema serializes to valid JSON."""
+    raw = generate_schema_json()
+    parsed = json.loads(raw)
+    assert isinstance(parsed, dict)
+
+  def test_has_required_top_level_fields(self, schema):
+    assert "schema_version" in schema
+    assert schema["schema_version"] == SCHEMA_VERSION
+    assert "generated_at" in schema
+    assert "panels" in schema
+    assert "vehicle_settings" in schema
+    assert "capability_fields" in schema
+
+  def test_panels_are_list(self, schema):
+    assert isinstance(schema["panels"], list)
+    assert len(schema["panels"]) > 0
+
+  def test_all_panels_have_required_fields(self, schema):
+    for panel in schema["panels"]:
+      assert "id" in panel, f"Panel missing 'id': {panel}"
+      assert "label" in panel, f"Panel {panel.get('id')} missing 'label'"
+      assert "order" in panel, f"Panel {panel.get('id')} missing 'order'"
+      has_sections = "sections" in panel
+      has_items = "items" in panel
+      assert has_sections or has_items, \
+        f"Panel {panel['id']} must have 'sections' or 'items'"
+      if has_sections:
+        assert isinstance(panel["sections"], list)
+        for sec in panel["sections"]:
+          assert "id" in sec, f"Section in panel {panel['id']} missing 'id'"
+          assert "items" in sec, f"Section {panel['id']}.{sec.get('id')} missing 'items'"
+          assert isinstance(sec["items"], list)
+      if has_items:
+        assert isinstance(panel["items"], list)
+
+  def test_all_items_have_key_and_widget(self, schema):
+    for panel in schema["panels"]:
+      for item in _iter_panel_items(panel):
+        assert "key" in item, f"Item in panel {panel['id']} missing 'key'"
+        assert "widget" in item, f"Item {item.get('key')} missing 'widget'"
+        assert item["widget"] in VALID_WIDGET_TYPES, \
+          f"Item {item['key']} has invalid widget type: {item['widget']}"
+
+  def test_sub_panel_items_have_key_and_widget(self, schema):
+    for panel in schema["panels"]:
+      for sp in _iter_all_sub_panels(panel):
+        assert "id" in sp
+        assert "items" in sp
+        for item in sp["items"]:
+          assert "key" in item
+          assert "widget" in item
+          assert item["widget"] in VALID_WIDGET_TYPES
+
+  def test_vehicle_settings_structure(self, schema):
+    vs = schema["vehicle_settings"]
+    assert isinstance(vs, dict)
+    for brand, data in vs.items():
+      assert isinstance(brand, str)
+      assert isinstance(data, dict), \
+        f"vehicle_settings[{brand}] must be a dict {{title, items, ...}}"
+      assert "items" in data, f"vehicle_settings[{brand}] missing 'items'"
+      assert isinstance(data["items"], list)
+      for item in data["items"]:
+        assert "key" in item, f"Vehicle item for {brand} missing 'key'"
+        assert "widget" in item, f"Vehicle item {item.get('key')} missing 'widget'"
+
+  def test_no_duplicate_keys_across_panels(self, schema):
+    """Param keys should appear in at most one panel."""
+    seen: dict[str, str] = {}  # key -> panel_id
+    for panel in schema["panels"]:
+      for item in _iter_panel_items(panel):
+        key = item["key"]
+        if key in seen:
+          pytest.fail(f"Key '{key}' appears in both panel '{seen[key]}' and '{panel['id']}'")
+        seen[key] = panel["id"]
+        for sub in item.get("sub_items", []):
+          sub_key = sub["key"]
+          if sub_key in seen:
+            pytest.fail(f"Sub-item key '{sub_key}' appears in both '{seen[sub_key]}' and '{panel['id']}'")
+          seen[sub_key] = panel["id"]
+
+
+class TestSchemaCoverage:
+  def test_all_schema_keys_exist_in_params(self, schema, all_param_keys):
+    """Schema keys must exist in Params().all_keys()."""
+    schema_keys = collect_all_keys(schema)
+    missing = schema_keys - all_param_keys
+    assert not missing, f"Schema references keys not in Params: {missing}"
+
+  def test_all_capability_fields_are_declared(self, schema):
+    """Capability fields used in rules must be declared."""
+    declared = set(schema["capability_fields"])
+    referenced = collect_capability_refs(schema)
+    undeclared = referenced - declared
+    assert not undeclared, f"Rules reference undeclared capability fields: {undeclared}"
+
+  def test_capability_fields_match_constant(self, schema):
+    """Schema capability_fields must match CAPABILITY_FIELDS constant."""
+    assert set(schema["capability_fields"]) == set(CAPABILITY_FIELDS)
+
+
+class TestRuleWellFormedness:
+  def _validate_rule(self, rule: dict, context: str = ""):
+    """Recursively validate a single rule dict."""
+    assert "type" in rule, f"Rule missing 'type' in {context}"
+    rtype = rule["type"]
+    assert rtype in VALID_RULE_TYPES, f"Invalid rule type '{rtype}' in {context}"
+
+    if rtype == "capability":
+      assert "field" in rule, f"Capability rule missing 'field' in {context}"
+      assert "equals" in rule, f"Capability rule missing 'equals' in {context}"
+    elif rtype == "param":
+      assert "key" in rule, f"Param rule missing 'key' in {context}"
+      assert "equals" in rule, f"Param rule missing 'equals' in {context}"
+    elif rtype == "param_compare":
+      assert "key" in rule, f"Param compare rule missing 'key' in {context}"
+      assert "op" in rule, f"Param compare rule missing 'op' in {context}"
+      assert rule["op"] in VALID_COMPARE_OPS, f"Invalid op '{rule['op']}' in {context}"
+      assert "value" in rule, f"Param compare rule missing 'value' in {context}"
+    elif rtype == "not":
+      assert "condition" in rule, f"Not rule missing 'condition' in {context}"
+      self._validate_rule(rule["condition"], context=f"{context} > not")
+    elif rtype in ("any", "all"):
+      assert "conditions" in rule, f"{rtype} rule missing 'conditions' in {context}"
+      assert isinstance(rule["conditions"], list)
+      for c in rule["conditions"]:
+        self._validate_rule(c, context=f"{context} > {rtype}")
+
+  def _validate_items(self, items: list[dict], context: str):
+    for item in items:
+      key = item.get("key", "unknown")
+      for rules_field in ("visibility", "enablement"):
+        rules = item.get(rules_field)
+        if rules:
+          assert isinstance(rules, list), f"{key}.{rules_field} must be a list"
+          for rule in rules:
+            self._validate_rule(rule, context=f"{context}.{key}.{rules_field}")
+      for sub in item.get("sub_items", []):
+        self._validate_items([sub], context=f"{context}.{key}")
+
+  def _validate_section_rules(self, section: dict, context: str):
+    for rules_field in ("visibility", "enablement"):
+      rules = section.get(rules_field) or []
+      for rule in rules:
+        self._validate_rule(rule, context=f"{context}.{rules_field}")
+
+  def test_all_panel_rules_well_formed(self, schema):
+    for panel in schema["panels"]:
+      self._validate_items(list(_iter_panel_items(panel)), context=f"panel:{panel['id']}")
+      for sp in _iter_all_sub_panels(panel):
+        self._validate_items(sp["items"], context=f"subpanel:{sp['id']}")
+      for section in panel.get("sections", []):
+        self._validate_section_rules(section, context=f"section:{panel['id']}.{section['id']}")
+
+  def test_all_vehicle_rules_well_formed(self, schema):
+    for brand, data in schema["vehicle_settings"].items():
+      self._validate_items(_brand_items(data), context=f"vehicle:{brand}")
+
+  def test_no_self_referencing_visibility(self, schema):
+    """An item's visibility/enablement rules should not depend on its own key."""
+    def _check_self_ref(item: dict, rules_field: str):
+      key = item.get("key")
+      for rule in item.get(rules_field, []):
+        if rule.get("type") == "param" and rule.get("key") == key:
+          pytest.fail(f"Item {key} has self-referencing {rules_field} rule")
+
+    for panel in schema["panels"]:
+      for item in _iter_panel_items(panel):
+        _check_self_ref(item, "visibility")
+        _check_self_ref(item, "enablement")
+
+    for brand_data in schema.get("vehicle_settings", {}).values():
+      for item in _brand_items(brand_data):
+        _check_self_ref(item, "visibility")
+        _check_self_ref(item, "enablement")
+
+
+class TestKnownPanels:
+  def test_expected_panels_exist(self, schema):
+    panel_ids = {p["id"] for p in schema["panels"]}
+    expected = {"steering", "cruise", "display", "visuals", "device", "software", "developer"}
+    assert expected.issubset(panel_ids), f"Missing panels: {expected - panel_ids}"
+
+  def test_mads_sub_panel_exists(self, schema):
+    steering = next(p for p in schema["panels"] if p["id"] == "steering")
+    sub_ids = {sp["id"] for sp in _iter_all_sub_panels(steering)}
+    assert "mads_settings" in sub_ids
+
+  def test_mutual_exclusion_torque_nnlc(self, schema):
+    """EnforceTorqueControl and NNLC must reference each other in enablement."""
+    torque = nnlc = None
+    for panel in schema["panels"]:
+      for item in _iter_panel_items(panel):
+        if item["key"] == "EnforceTorqueControl":
+          torque = item
+        elif item["key"] == "NeuralNetworkLateralControl":
+          nnlc = item
+    assert torque is not None, "EnforceTorqueControl item missing"
+    assert nnlc is not None, "NeuralNetworkLateralControl item missing"
+    torque_enable_keys = {r.get("key") for r in torque.get("enablement", []) if r.get("type") == "param"}
+    assert "NeuralNetworkLateralControl" in torque_enable_keys
+    nnlc_enable_keys = {r.get("key") for r in nnlc.get("enablement", []) if r.get("type") == "param"}
+    assert "EnforceTorqueControl" in nnlc_enable_keys
+
+
+class TestKnownVehicleSettings:
+  def test_hyundai_has_longitudinal_tuning(self, schema):
+    keys = {i["key"] for i in _brand_items(schema["vehicle_settings"].get("hyundai"))}
+    assert "HyundaiLongitudinalTuning" in keys
+
+  def test_toyota_has_enforce_stock_and_stop_go(self, schema):
+    keys = {i["key"] for i in _brand_items(schema["vehicle_settings"].get("toyota"))}
+    assert "ToyotaEnforceStockLongitudinal" in keys
+    assert "ToyotaStopAndGoHack" in keys
+
+  def test_tesla_has_coop_steering(self, schema):
+    keys = {i["key"] for i in _brand_items(schema["vehicle_settings"].get("tesla"))}
+    assert "TeslaCoopSteering" in keys
+
+  def test_subaru_has_stop_and_go(self, schema):
+    keys = {i["key"] for i in _brand_items(schema["vehicle_settings"].get("subaru"))}
+    assert "SubaruStopAndGo" in keys
+    assert "SubaruStopAndGoManualParkingBrake" in keys
+
+
+class TestItemCompleteness:
+  def _collect_all_items(self, schema):
+    """Collect all items and sub_items from panels and vehicle_settings."""
+    items = []
+    for panel in schema["panels"]:
+      for item in _iter_panel_items(panel):
+        items.append(item)
+        for sub in item.get("sub_items", []):
+          items.append(sub)
+    for brand_data in schema.get("vehicle_settings", {}).values():
+      for item in _brand_items(brand_data):
+        items.append(item)
+        for sub in item.get("sub_items", []):
+          items.append(sub)
+    return items
+
+  def test_all_items_have_titles(self, schema):
+    """All items must have titles."""
+    missing = [i["key"] for i in self._collect_all_items(schema) if "title" not in i]
+    if len(missing) > MAX_ALLOWED_MISSING_TITLES:
+      pytest.fail(f"Items without titles ({len(missing)}): {missing[:10]}")
+
+  def test_no_default_titles(self, schema):
+    """Item titles must differ from keys."""
+    defaults = [i["key"] for i in self._collect_all_items(schema) if i.get("title") == i["key"]]
+    assert not defaults, f"Items with default titles (title == key): {defaults}"
+
+  def test_options_structure(self, schema):
+    """Options must be a list of {value, label} dicts."""
+    for item in self._collect_all_items(schema):
+      opts = item.get("options")
+      if opts is None:
+        continue
+      assert isinstance(opts, list), f"{item['key']}: options must be a list"
+      for opt in opts:
+        assert isinstance(opt, dict), f"{item['key']}: each option must be a dict"
+        assert "value" in opt, f"{item['key']}: option missing 'value': {opt}"
+        assert "label" in opt, f"{item['key']}: option missing 'label': {opt}"
+
+  def test_numeric_constraints(self, schema):
+    """If any of min/max/step is present, all three must be, and min < max."""
+    for item in self._collect_all_items(schema):
+      has_min = "min" in item
+      has_max = "max" in item
+      has_step = "step" in item
+      if has_min or has_max or has_step:
+        assert has_min and has_max and has_step, \
+          f"{item['key']}: must have all of min/max/step or none"
+        assert item["min"] < item["max"], \
+          f"{item['key']}: min ({item['min']}) must be < max ({item['max']})"
+
+  def test_known_param_has_options(self, schema):
+    """LongitudinalPersonality should have 3 options."""
+    cruise = next(p for p in schema["panels"] if p["id"] == "cruise")
+    lp = next((i for i in _iter_panel_items(cruise) if i["key"] == "LongitudinalPersonality"), None)
+    assert lp is not None
+    assert "options" in lp
+    assert len(lp["options"]) == 3

sunnypilot/sunnylink/tools/apply_macros.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""
+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.
+
+Scans all per-page YAML files in settings_ui_src/pages/ and replaces inlined
+rule blocks that exactly match a macro definition in _macros.yaml with $ref
+references.
+
+Match policy:
+  - Whole-list match (exact): replace the entire list with [{$ref}].
+  - Single-rule match: any individual rule whose canonical form equals macro[0]
+    (when macro is exactly one rule) is replaced with {$ref}.
+
+Re-run is idempotent (already-substituted $refs are skipped).
+
+Usage:
+  python apply_macros.py [--src DIR] [--dry-run]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+
+import yaml
+
+DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+DEFAULT_SRC = os.path.join(DIR, "settings_ui_src")
+
+
+class _BlockDumper(yaml.SafeDumper):
+  pass
+
+
+def _represent_dict(dumper, data):
+  return dumper.represent_mapping("tag:yaml.org,2002:map", data.items(), flow_style=False)
+
+
+def _represent_list(dumper, data):
+  flow = all(not isinstance(x, (dict, list)) for x in data) and len(data) <= 8
+  return dumper.represent_sequence("tag:yaml.org,2002:seq", data, flow_style=flow)
+
+
+_BlockDumper.add_representer(dict, _represent_dict)
+_BlockDumper.add_representer(list, _represent_list)
+
+
+def _dump_yaml(data) -> str:
+  return yaml.dump(data, Dumper=_BlockDumper, sort_keys=False, allow_unicode=True, width=120)
+
+
+def _canon(node) -> str:
+  return json.dumps(node, sort_keys=True, separators=(",", ":"))
+
+
+def _is_ref(node) -> bool:
+  return isinstance(node, dict) and len(node) == 1 and "$ref" in node
+
+
+def _make_ref(name: str) -> dict:
+  return {"$ref": f"#/macros/{name}"}
+
+
+def _substitute_rules(rules: list, whole_list: dict, single_rule: dict) -> list:
+  if not isinstance(rules, list) or not rules:
+    return rules
+  full_canon = _canon(rules)
+  if full_canon in whole_list:
+    return [_make_ref(whole_list[full_canon])]
+  out = []
+  for r in rules:
+    if _is_ref(r):
+      out.append(r)
+      continue
+    rc = _canon(r)
+    if rc in single_rule:
+      out.append(_make_ref(single_rule[rc]))
+    else:
+      out.append(r)
+  return out
+
+
+def _walk_item(item: dict, whole_list: dict, single_rule: dict) -> bool:
+  changed = False
+  for ctx in ("visibility", "enablement"):
+    if ctx in item:
+      new = _substitute_rules(item[ctx], whole_list, single_rule)
+      if new != item[ctx]:
+        item[ctx] = new
+        changed = True
+  if "options" in item:
+    for opt in item["options"]:
+      if not isinstance(opt, dict):
+        continue
+      for ctx in ("visibility", "enablement"):
+        if ctx in opt:
+          new = _substitute_rules(opt[ctx], whole_list, single_rule)
+          if new != opt[ctx]:
+            opt[ctx] = new
+            changed = True
+  if "sub_items" in item:
+    for sub in item["sub_items"]:
+      if _walk_item(sub, whole_list, single_rule):
+        changed = True
+  return changed
+
+
+def _walk_page(page: dict, whole_list: dict, single_rule: dict) -> bool:
+  changed = False
+  for sec in page.get("sections", []) or []:
+    for ctx in ("visibility", "enablement"):
+      if ctx in sec:
+        new = _substitute_rules(sec[ctx], whole_list, single_rule)
+        if new != sec[ctx]:
+          sec[ctx] = new
+          changed = True
+    for it in sec.get("items", []) or []:
+      if _walk_item(it, whole_list, single_rule):
+        changed = True
+    for sp in sec.get("sub_panels", []) or []:
+      for it in sp.get("items", []) or []:
+        if _walk_item(it, whole_list, single_rule):
+          changed = True
+  for it in page.get("items", []) or []:
+    if _walk_item(it, whole_list, single_rule):
+      changed = True
+  for sp in page.get("sub_panels", []) or []:
+    for it in sp.get("items", []) or []:
+      if _walk_item(it, whole_list, single_rule):
+        changed = True
+  return changed
+
+
+def _build_macro_indices(macros: dict) -> tuple[dict, dict]:
+  whole_list = {}
+  single_rule = {}
+  for name, body in macros.items():
+    if isinstance(body, list):
+      whole_list[_canon(body)] = name
+      if len(body) == 1 and isinstance(body[0], dict):
+        single_rule[_canon(body[0])] = name
+    elif isinstance(body, dict):
+      single_rule[_canon(body)] = name
+  return whole_list, single_rule
+
+
+def _read_yaml_with_header(path: str) -> tuple[list[str], dict]:
+  with open(path) as f:
+    text = f.read()
+  header_lines = []
+  for line in text.splitlines(keepends=True):
+    if line.startswith("#"):
+      header_lines.append(line)
+    elif line.strip() == "":
+      header_lines.append(line)
+    else:
+      break
+  doc = yaml.safe_load(text) or {}
+  return header_lines, doc
+
+
+def _write_yaml_with_header(path: str, header: list[str], doc: dict) -> None:
+  with open(path, "w") as f:
+    if header:
+      # Keep at most one trailing blank line in header
+      while len(header) > 1 and header[-1].strip() == "" and header[-2].strip() == "":
+        header.pop()
+      for line in header:
+        f.write(line)
+    f.write(_dump_yaml(doc))
+
+
+def apply(src_dir: str, dry_run: bool) -> int:
+  with open(os.path.join(src_dir, "_macros.yaml")) as f:
+    macros_doc = yaml.safe_load(f) or {}
+  macros = (macros_doc.get("macros") or {}) if isinstance(macros_doc, dict) else {}
+  whole_list, single_rule = _build_macro_indices(macros)
+
+  changed_files = 0
+  pages_dir = os.path.join(src_dir, "pages")
+  if os.path.isdir(pages_dir):
+    for fn in sorted(os.listdir(pages_dir)):
+      if not fn.endswith((".yaml", ".yml")) or fn.startswith("_"):
+        continue
+      path = os.path.join(pages_dir, fn)
+      header, doc = _read_yaml_with_header(path)
+      if _walk_page(doc, whole_list, single_rule):
+        changed_files += 1
+        if not dry_run:
+          _write_yaml_with_header(path, header, doc)
+        else:
+          print(f"would-rewrite: {path}")
+
+  print(f"{'Would rewrite' if dry_run else 'Rewrote'} {changed_files} files")
+  return 0
+
+
+def _main() -> int:
+  parser = argparse.ArgumentParser(description="Substitute inlined rule blocks with $ref macros across pages/.")
+  parser.add_argument("--src", default=DEFAULT_SRC)
+  parser.add_argument("--dry-run", action="store_true")
+  args = parser.parse_args()
+  return apply(args.src, args.dry_run)
+
+
+if __name__ == "__main__":
+  sys.exit(_main())

sunnypilot/sunnylink/tools/compile_settings_ui.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""
+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.
+
+Reads settings_ui_src/ (the dev-friendly authoring tree) and emits the
+canonical settings_ui.json that the device generator + frontend consume.
+
+Source layout:
+  _macros.yaml                                # named rule fragments
+  pages/<page_id>.yaml                        # one file per panel/page
+  pages/vehicle.yaml                          # special: emits vehicle_settings
+
+Each page.yaml contains the full panel: metadata + sections + items + sub_panels
+inline. Sub-panels are nested inside the section they belong to. Items appear
+in the order written in the file.
+
+Macro references use JSON-Schema-style $ref pointers:
+  enablement:
+    - {$ref: "#/macros/offroad"}
+    - {$ref: "#/macros/mads_full_platforms"}
+
+Macros may reference other macros (max depth 3). Cycles raise an error.
+
+Usage:
+  python compile_settings_ui.py [--src DIR] [--out PATH] [--check]
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+import os
+import sys
+
+import yaml
+
+DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+DEFAULT_SRC = os.path.join(DIR, "settings_ui_src")
+DEFAULT_OUT = os.path.join(DIR, "settings_ui.json")
+
+SCHEMA_VERSION = "1.0"
+MAX_MACRO_DEPTH = 3
+
+
+class CompileError(Exception):
+  pass
+
+
+def _load_yaml(path: str):
+  with open(path) as f:
+    return yaml.safe_load(f) or {}
+
+
+def _is_ref(node) -> bool:
+  return isinstance(node, dict) and len(node) == 1 and "$ref" in node
+
+
+def _ref_name(node: dict) -> str:
+  ref = node["$ref"]
+  if not isinstance(ref, str) or not ref.startswith("#/macros/"):
+    raise CompileError(f"unsupported $ref: {ref!r} (must start with '#/macros/')")
+  return ref[len("#/macros/"):]
+
+
+def _resolve_refs(node, macros: dict, visiting: tuple[str, ...] = ()):
+  """Resolve $ref nodes against macros. Recursive; depth-limited; cycle-safe.
+
+  - $ref in list-context: macro's list spliced into parent list.
+  - $ref in scalar-context (object value): macro's value substitutes.
+  - Non-list macro values may not be referenced from list contexts.
+  """
+  if _is_ref(node):
+    name = _ref_name(node)
+    if name in visiting:
+      raise CompileError(f"$ref cycle: {' -> '.join(visiting + (name,))}")
+    if len(visiting) >= MAX_MACRO_DEPTH:
+      raise CompileError(f"$ref nesting exceeds depth {MAX_MACRO_DEPTH}: {' -> '.join(visiting + (name,))}")
+    if name not in macros:
+      raise CompileError(f"unknown macro: {name}")
+    return _resolve_refs(copy.deepcopy(macros[name]), macros, visiting + (name,))
+
+  if isinstance(node, dict):
+    return {k: _resolve_refs(v, macros, visiting) for k, v in node.items()}
+
+  if isinstance(node, list):
+    out = []
+    for item in node:
+      if _is_ref(item):
+        resolved = _resolve_refs(item, macros, visiting)
+        if not isinstance(resolved, list):
+          raise CompileError(
+            f"macro '{_ref_name(item)}' must resolve to a list when used in a list context"
+          )
+        out.extend(resolved)
+      else:
+        out.append(_resolve_refs(item, macros, visiting))
+    return out
+
+  return node
+
+
+# Output JSON key order. Mirrors the conventions in the original hand-written
+# settings_ui.json so structural diffs after extraction are minimal.
+_ITEM_KEY_ORDER = [
+  "key",
+  "widget",
+  "needs_onroad_cycle",
+  "requires_attestation",
+  "blocked",
+  "title",
+  "description",
+  "details",
+  "title_param_suffix",
+  "min",
+  "max",
+  "step",
+  "unit",
+  "options",
+  "visibility",
+  "enablement",
+  "sub_items",
+]
+
+
+def _canon_item(item: dict, macros: dict) -> dict:
+  resolved = dict(item)
+  for ctx in ("visibility", "enablement"):
+    if ctx in resolved:
+      resolved[ctx] = _resolve_refs(resolved[ctx], macros)
+  if "options" in resolved:
+    new_opts = []
+    for opt in resolved["options"]:
+      if isinstance(opt, dict):
+        opt = dict(opt)
+        for ctx in ("visibility", "enablement"):
+          if ctx in opt:
+            opt[ctx] = _resolve_refs(opt[ctx], macros)
+      new_opts.append(opt)
+    resolved["options"] = new_opts
+  if "sub_items" in resolved:
+    resolved["sub_items"] = [_canon_item(s, macros) for s in resolved["sub_items"]]
+
+  out: dict = {}
+  for k in _ITEM_KEY_ORDER:
+    if k in resolved:
+      out[k] = resolved[k]
+  for k, v in resolved.items():
+    if k not in out:
+      out[k] = v
+  return out
+
+
+def _canon_section(section: dict, macros: dict) -> dict:
+  out: dict = {"id": section["id"], "title": section["title"]}
+  if "description" in section:
+    out["description"] = section["description"]
+  for k in ("visibility", "enablement"):
+    if k in section:
+      out[k] = _resolve_refs(section[k], macros)
+  if "attestation_required" in section:
+    out["attestation_required"] = section["attestation_required"]
+  out["items"] = [_canon_item(i, macros) for i in section.get("items", [])]
+  if "sub_panels" in section and section["sub_panels"]:
+    out["sub_panels"] = [_canon_sub_panel(sp, macros) for sp in section["sub_panels"]]
+  for k, v in section.items():
+    if k not in out and k != "order":
+      out[k] = v
+  return out
+
+
+def _canon_sub_panel(sp: dict, macros: dict) -> dict:
+  out: dict = {"id": sp["id"], "label": sp["label"], "trigger_key": sp["trigger_key"]}
+  if "trigger_condition" in sp:
+    out["trigger_condition"] = _resolve_refs(sp["trigger_condition"], macros)
+  out["items"] = [_canon_item(i, macros) for i in sp.get("items", [])]
+  for k, v in sp.items():
+    if k not in out:
+      out[k] = v
+  return out
+
+
+def _canon_panel(page: dict, macros: dict) -> dict:
+  out: dict = {
+    "id": page["id"],
+    "label": page["label"],
+    "icon": page["icon"],
+    "order": page["order"],
+  }
+  if "remote_configurable" in page:
+    out["remote_configurable"] = page["remote_configurable"]
+  if "description" in page:
+    out["description"] = page["description"]
+  if "sections" in page and page["sections"]:
+    out["sections"] = [_canon_section(s, macros) for s in page["sections"]]
+  if "items" in page and page["items"]:
+    out["items"] = [_canon_item(i, macros) for i in page["items"]]
+  if "sub_panels" in page and page["sub_panels"]:
+    out["sub_panels"] = [_canon_sub_panel(sp, macros) for sp in page["sub_panels"]]
+  return out
+
+
+def _canon_vehicle(page: dict, macros: dict) -> dict:
+  """Convert page-shape vehicle.yaml to wire-format vehicle_settings dict."""
+  out: dict = {}
+  for sec in page.get("sections", []):
+    brand = sec["id"]
+    brand_out: dict = {"title": sec.get("title", "")}
+    if "description" in sec:
+      brand_out["description"] = sec["description"]
+    brand_out["items"] = [_canon_item(i, macros) for i in sec.get("items", [])]
+    out[brand] = brand_out
+  return out
+
+
+def _load_pages(src: str) -> list[dict]:
+  pages_dir = os.path.join(src, "pages")
+  if not os.path.isdir(pages_dir):
+    return []
+  pages = []
+  for fn in sorted(os.listdir(pages_dir)):
+    if not fn.endswith((".yaml", ".yml")):
+      continue
+    if fn.startswith("_"):
+      continue
+    path = os.path.join(pages_dir, fn)
+    page = _load_yaml(path)
+    if not isinstance(page, dict):
+      raise CompileError(f"{path}: page YAML must be an object")
+    if "id" not in page:
+      raise CompileError(f"{path}: page missing 'id'")
+    page["__source"] = path
+    pages.append(page)
+  return pages
+
+
+def compile_schema(src: str) -> dict:
+  macros_doc = _load_yaml(os.path.join(src, "_macros.yaml"))
+  macros = (macros_doc.get("macros") or {}) if isinstance(macros_doc, dict) else {}
+
+  pages = _load_pages(src)
+
+  panels_out = []
+  vehicle_out: dict = {}
+
+  # Order panels by `order` field (falling back to file position).
+  panel_pages = [p for p in pages if p.get("kind") != "vehicle"]
+  panel_pages.sort(key=lambda p: (p.get("order", 999), p["id"]))
+
+  for page in panel_pages:
+    panels_out.append(_canon_panel(page, macros))
+
+  for page in pages:
+    if page.get("kind") == "vehicle":
+      vehicle_out = _canon_vehicle(page, macros)
+
+  return {
+    "$schema": "./settings_ui.schema.json",
+    "schema_version": SCHEMA_VERSION,
+    "panels": panels_out,
+    "vehicle_settings": vehicle_out,
+  }
+
+
+def _main() -> int:
+  parser = argparse.ArgumentParser(description="Compile settings_ui_src/ -> settings_ui.json")
+  parser.add_argument("--src", default=DEFAULT_SRC)
+  parser.add_argument("--out", default=DEFAULT_OUT)
+  parser.add_argument("--check", action="store_true",
+                      help="Compile and diff against existing settings_ui.json; exit non-zero on diff.")
+  args = parser.parse_args()
+
+  schema = compile_schema(args.src)
+  rendered = json.dumps(schema, indent=2) + "\n"
+
+  if args.check:
+    if not os.path.exists(args.out):
+      print(f"--check: {args.out} does not exist", file=sys.stderr)
+      return 1
+    with open(args.out) as f:
+      current = f.read()
+    if current.strip() == rendered.strip():
+      print(f"--check: {args.out} matches compiled output")
+      return 0
+    print(f"--check: {args.out} differs from compiled output", file=sys.stderr)
+    cur_obj = json.loads(current)
+    if cur_obj == schema:
+      print("(structurally equal; only formatting differs)", file=sys.stderr)
+    return 1
+
+  with open(args.out, "w") as f:
+    f.write(rendered)
+  print(f"Wrote {args.out}")
+  return 0
+
+
+if __name__ == "__main__":
+  sys.exit(_main())

sunnypilot/sunnylink/tools/extract_settings_ui.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""
+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.
+
+One-shot extractor: settings_ui.json -> settings_ui_src/pages/*.yaml.
+
+Reads the existing monolithic settings_ui.json and produces one YAML file per
+page (panel) plus pages/vehicle.yaml for the per-brand settings. Macros remain
+unwritten by extract; populate _macros.yaml separately.
+
+Usage:
+  python extract_settings_ui.py [--src DIR] [--definition PATH]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import sys
+
+import yaml
+
+DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+DEFAULT_DEFINITION = os.path.join(DIR, "settings_ui.json")
+DEFAULT_SRC = os.path.join(DIR, "settings_ui_src")
+
+
+class _BlockDumper(yaml.SafeDumper):
+  pass
+
+
+def _represent_dict(dumper, data):
+  return dumper.represent_mapping("tag:yaml.org,2002:map", data.items(), flow_style=False)
+
+
+def _represent_list(dumper, data):
+  flow = all(not isinstance(x, (dict, list)) for x in data) and len(data) <= 8
+  return dumper.represent_sequence("tag:yaml.org,2002:seq", data, flow_style=flow)
+
+
+_BlockDumper.add_representer(dict, _represent_dict)
+_BlockDumper.add_representer(list, _represent_list)
+
+
+def _dump_yaml(data) -> str:
+  return yaml.dump(data, Dumper=_BlockDumper, sort_keys=False, allow_unicode=True, width=120)
+
+
+# Item field order in per-page YAML (mirrors settings_ui.json conventions).
+_ITEM_ORDER = [
+  "key",
+  "widget",
+  "needs_onroad_cycle",
+  "requires_attestation",
+  "blocked",
+  "title",
+  "description",
+  "details",
+  "title_param_suffix",
+  "min",
+  "max",
+  "step",
+  "unit",
+  "options",
+  "visibility",
+  "enablement",
+  "sub_items",
+]
+
+
+def _ordered_item(item: dict) -> dict:
+  out: dict = {}
+  for k in _ITEM_ORDER:
+    if k in item:
+      v = item[k]
+      if k == "sub_items":
+        v = [_ordered_item(s) for s in v]
+      out[k] = v
+  for k, v in item.items():
+    if k not in out:
+      out[k] = v
+  return out
+
+
+def _ordered_section(section: dict) -> dict:
+  out: dict = {"id": section["id"], "title": section["title"]}
+  for f in ("description", "order", "visibility", "enablement", "attestation_required"):
+    if f in section:
+      out[f] = section[f]
+  if "items" in section:
+    out["items"] = [_ordered_item(i) for i in section["items"]]
+  if "sub_panels" in section and section["sub_panels"]:
+    out["sub_panels"] = [_ordered_sub_panel(sp) for sp in section["sub_panels"]]
+  for k, v in section.items():
+    if k not in out:
+      out[k] = v
+  return out
+
+
+def _ordered_sub_panel(sp: dict) -> dict:
+  out: dict = {"id": sp["id"], "label": sp["label"], "trigger_key": sp["trigger_key"]}
+  if "trigger_condition" in sp:
+    out["trigger_condition"] = sp["trigger_condition"]
+  if "items" in sp:
+    out["items"] = [_ordered_item(i) for i in sp["items"]]
+  for k, v in sp.items():
+    if k not in out:
+      out[k] = v
+  return out
+
+
+def _ordered_page(panel: dict) -> dict:
+  out: dict = {
+    "id": panel["id"],
+    "label": panel["label"],
+    "icon": panel["icon"],
+    "order": panel["order"],
+  }
+  for f in ("remote_configurable", "description"):
+    if f in panel:
+      out[f] = panel[f]
+  if "sections" in panel and panel["sections"]:
+    out["sections"] = [_ordered_section(s) for s in panel["sections"]]
+  if "items" in panel and panel["items"]:
+    out["items"] = [_ordered_item(i) for i in panel["items"]]
+  if "sub_panels" in panel and panel["sub_panels"]:
+    out["sub_panels"] = [_ordered_sub_panel(sp) for sp in panel["sub_panels"]]
+  for k, v in panel.items():
+    if k not in out:
+      out[k] = v
+  return out
+
+
+def _ordered_vehicle_page(vehicle_settings: dict) -> dict:
+  """Convert wire-format vehicle_settings dict into a page-shape YAML.
+
+  Brand becomes a section id. Each brand's items become section items.
+  """
+  sections = []
+  for brand in sorted(vehicle_settings.keys()):
+    bd = vehicle_settings[brand]
+    items = bd.get("items", []) if isinstance(bd, dict) else bd
+    sec: dict = {
+      "id": brand,
+      "title": bd.get("title", "") if isinstance(bd, dict) else "",
+    }
+    if isinstance(bd, dict) and "description" in bd:
+      sec["description"] = bd["description"]
+    sec["items"] = [_ordered_item(i) for i in items]
+    sections.append(sec)
+  return {
+    "id": "vehicle",
+    "label": "Vehicle",
+    "icon": "vehicle",
+    "order": 99,
+    "kind": "vehicle",  # signals to compiler: emit as vehicle_settings, not panels
+    "sections": sections,
+  }
+
+
+def extract(definition_path: str, src_dir: str) -> None:
+  with open(definition_path) as f:
+    data = json.load(f)
+
+  pages_dir = os.path.join(src_dir, "pages")
+  if os.path.isdir(pages_dir):
+    shutil.rmtree(pages_dir)
+  os.makedirs(pages_dir)
+
+  count = 0
+  for panel in data.get("panels", []):
+    page = _ordered_page(panel)
+    path = os.path.join(pages_dir, f"{panel['id']}.yaml")
+    with open(path, "w") as f:
+      f.write(f"# Page: {panel['id']}\n")
+      f.write("# Edit this file. Run compile_settings_ui.py to emit settings_ui.json.\n")
+      f.write(_dump_yaml(page))
+    count += 1
+
+  vehicle_settings = data.get("vehicle_settings", {})
+  if vehicle_settings:
+    vehicle_page = _ordered_vehicle_page(vehicle_settings)
+    path = os.path.join(pages_dir, "vehicle.yaml")
+    with open(path, "w") as f:
+      f.write("# Page: vehicle (per-brand settings)\n")
+      f.write("# Compiles to settings_ui.json#vehicle_settings (brand = section id).\n")
+      f.write(_dump_yaml(vehicle_page))
+    count += 1
+
+  # Ensure _macros.yaml exists
+  macros_path = os.path.join(src_dir, "_macros.yaml")
+  if not os.path.exists(macros_path):
+    with open(macros_path, "w") as f:
+      f.write("# Named rule fragments. Reference from pages via {$ref: \"#/macros/<name>\"}.\n")
+      f.write(_dump_yaml({"macros": {}}))
+
+  print(f"Extracted: {count} pages -> {pages_dir}")
+
+
+def _main() -> int:
+  parser = argparse.ArgumentParser(description="Extract settings_ui.json into per-page YAML files.")
+  parser.add_argument("--definition", default=DEFAULT_DEFINITION, help="path to settings_ui.json")
+  parser.add_argument("--src", default=DEFAULT_SRC, help="path to settings_ui_src/ output dir")
+  args = parser.parse_args()
+  extract(args.definition, args.src)
+  return 0
+
+
+if __name__ == "__main__":
+  sys.exit(_main())

sunnypilot/sunnylink/tools/generate_settings_schema.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+from __future__ import annotations
+
+import base64
+import datetime
+import gzip
+import json
+import os
+from collections.abc import Callable
+
+from openpilot.sunnypilot.sunnylink.capabilities import CAPABILITY_FIELDS, CAPABILITY_LABELS
+
+SCHEMA_VERSION = "1.0"
+_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+DEFINITION_PATH = os.path.join(_DIR, "settings_ui.json")
+TORQUE_VERSIONS_PATH = os.path.normpath(
+  os.path.join(_DIR, "..", "selfdrive", "controls", "lib", "latcontrol_torque_versions.json")
+)
+
+
+def _load_torque_versions() -> dict:
+  """Load latcontrol_torque_versions.json so TorqueControlTune options stay in sync."""
+  try:
+    with open(TORQUE_VERSIONS_PATH) as f:
+      return json.load(f)
+  except (FileNotFoundError, json.JSONDecodeError):
+    return {}
+
+
+def _build_torque_options(versions: dict) -> list[dict]:
+  options: list[dict] = [{"value": "", "label": "Default"}]
+  parsed: list[tuple[float, str]] = []
+  for label, info in versions.items():
+    try:
+      parsed.append((float(info["version"]), label))
+    except (KeyError, TypeError, ValueError):
+      continue
+  for version, label in sorted(parsed, key=lambda kv: kv[0], reverse=True):
+    options.append({"value": version, "label": label})
+  return options
+
+
+def _inject_dynamic_options(schema: dict) -> None:
+  versions = _load_torque_versions()
+  if not versions:
+    return
+  options = _build_torque_options(versions)
+
+  def visitor(item: dict) -> None:
+    if item.get("key") == "TorqueControlTune":
+      item["options"] = options
+
+  _walk_all_items(schema, visitor)
+
+
+def _load_definition() -> dict:
+  """Load settings_ui.json and inject dynamic options sourced from runtime data files."""
+  with open(DEFINITION_PATH) as f:
+    schema = json.load(f)
+  _inject_dynamic_options(schema)
+  return schema
+
+
+# Public API
+def generate_schema() -> dict:
+  """Return the settings_ui.json content augmented with runtime metadata.
+
+  Adds three top-level fields the frontend consumes:
+    - generated_at: ISO timestamp (drives schema-cache freshness checks)
+    - capability_fields: declared CAPABILITY_FIELDS, used for rule validation
+    - capability_labels: human-readable labels for capability_fields
+  """
+  schema = _load_definition()
+  schema["generated_at"] = datetime.datetime.now(datetime.UTC).isoformat()
+  schema["capability_fields"] = list(CAPABILITY_FIELDS)
+  schema["capability_labels"] = dict(CAPABILITY_LABELS)
+  return schema
+
+
+def generate_schema_json() -> str:
+  """Generate SettingsSchema as a compact JSON string."""
+  return json.dumps(generate_schema(), separators=(",", ":"))
+
+
+def generate_schema_compressed() -> str:
+  """Generate SettingsSchema as gzip-compressed, base64-encoded string.
+
+  Compression pipeline:
+    1. JSON serialize (compact, no whitespace)
+    2. UTF-8 encode
+    3. gzip compress
+    4. base64 encode
+  """
+  raw = json.dumps(generate_schema(), separators=(",", ":")).encode("utf-8")
+  return base64.b64encode(gzip.compress(raw)).decode("utf-8")
+
+
+# Schema introspection utilities
+def _walk_rules(rules: list[dict] | None, visitor: Callable[[dict], None]) -> None:
+  """Recursively walk all rules, calling visitor on each leaf rule."""
+  if not rules:
+    return
+  for rule in rules:
+    visitor(rule)
+    if rule.get("type") == "not" and "condition" in rule:
+      _walk_rules([rule["condition"]], visitor)
+    elif rule.get("type") in ("any", "all") and "conditions" in rule:
+      _walk_rules(rule["conditions"], visitor)
+
+
+def _walk_all_items(schema: dict, visitor: Callable[[dict], None]) -> None:
+  """Walk every item in the schema (panels, sections, sub_panels, sub_items, vehicle_settings)."""
+  def _visit_item(item: dict) -> None:
+    visitor(item)
+    for sub in item.get("sub_items", []):
+      _visit_item(sub)
+
+  for panel in schema.get("panels", []):
+    # Walk section items (V2)
+    for section in panel.get("sections", []):
+      for item in section.get("items", []):
+        _visit_item(item)
+      for sp in section.get("sub_panels", []):
+        for item in sp.get("items", []):
+          _visit_item(item)
+
+    # Walk flat items (V1)
+    for item in panel.get("items", []):
+      _visit_item(item)
+    for sp in panel.get("sub_panels", []):
+      for item in sp.get("items", []):
+        _visit_item(item)
+
+  for brand_data in schema.get("vehicle_settings", {}).values():
+    items = brand_data.get("items", []) if isinstance(brand_data, dict) else brand_data
+    for item in items:
+      _visit_item(item)
+
+
+def collect_all_keys(schema: dict) -> set[str]:
+  """Collect all param keys referenced in the schema (items + rules)."""
+  keys: set[str] = set()
+
+  def _visit_rule(rule: dict) -> None:
+    if rule.get("type") in ("param", "param_compare") and "key" in rule:
+      keys.add(rule["key"])
+
+  def _visit_item(item: dict) -> None:
+    if "key" in item:
+      keys.add(item["key"])
+    _walk_rules(item.get("visibility"), _visit_rule)
+    _walk_rules(item.get("enablement"), _visit_rule)
+
+  _walk_all_items(schema, _visit_item)
+  return keys
+
+
+def collect_capability_refs(schema: dict) -> set[str]:
+  """Collect all capability field names referenced in rules."""
+  refs: set[str] = set()
+
+  def _visit_rule(rule: dict) -> None:
+    if rule.get("type") == "capability" and "field" in rule:
+      refs.add(rule["field"])
+
+  def _visit_item(item: dict) -> None:
+    _walk_rules(item.get("visibility"), _visit_rule)
+    _walk_rules(item.get("enablement"), _visit_rule)
+
+  _walk_all_items(schema, _visit_item)
+  return refs
+
+
+if __name__ == "__main__":
+  # CLI: print schema for inspection
+  schema = generate_schema()
+  print(json.dumps(schema, indent=2))
+  print(f"\nTotal panels: {len(schema.get('panels', []))}")
+  print(f"Total vehicle brands: {len(schema.get('vehicle_settings', {}))}")
+  keys = collect_all_keys(schema)
+  print(f"Total unique param keys: {len(keys)}")
+
+  # Show compression stats
+  raw_json = json.dumps(schema, separators=(",", ":")).encode("utf-8")
+  compressed = gzip.compress(raw_json)
+  print(f"\nRaw JSON size: {len(raw_json):,} bytes")
+  print(f"Compressed size: {len(compressed):,} bytes")
+  print(f"Compression ratio: {len(compressed)/len(raw_json):.1%}")

sunnypilot/sunnylink/tools/validate_settings_ui.py

@@ -0,0 +1,526 @@
+#!/usr/bin/env python3
+"""
+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.
+
+Validates settings_ui.json against structural, semantic, and referential integrity constraints.
+
+Usage:
+  python validate_settings_ui.py
+  python validate_settings_ui.py /path/to/settings_ui.json
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+from openpilot.sunnypilot.sunnylink.capabilities import CAPABILITY_FIELDS
+
+VALID_WIDGETS = {"toggle", "option", "multiple_button", "button", "info"}
+VALID_COMPARE_OPS = {">", "<", ">=", "<="}
+
+DEFAULT_PATH = os.path.join(
+  os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+  "settings_ui.json",
+)
+
+
+class ValidationResult:
+  """Tracks pass/fail for each named check."""
+
+  def __init__(self) -> None:
+    self.passed: list[str] = []
+    self.failed: list[tuple[str, str]] = []
+    self.warnings: list[str] = []
+
+  def ok(self, name: str) -> None:
+    self.passed.append(name)
+    print(f"OK: {name}")
+
+  def error(self, name: str, details: str) -> None:
+    self.failed.append((name, details))
+    print(f"ERROR: {name}: {details}")
+
+  def warn(self, msg: str) -> None:
+    self.warnings.append(msg)
+    print(f"WARNING: {msg}")
+
+  @property
+  def success(self) -> bool:
+    return len(self.failed) == 0
+
+  def summary(self) -> None:
+    total_passed = len(self.passed)
+    total_failed = len(self.failed)
+    print(f"\n{'='*60}")
+    print(f"Summary: {total_passed} checks passed, {total_failed} checks failed")
+    if self.warnings:
+      print(f"         {len(self.warnings)} warnings")
+    if self.success:
+      print("Result: PASS")
+    else:
+      print("Result: FAIL")
+
+
+def validate_rule(rule: dict, path: str, result: ValidationResult,
+                  capability_fields: tuple[str, ...]) -> bool:
+  """Validate a single rule dict. Returns True if valid."""
+  if not isinstance(rule, dict):
+    result.error("rule well-formedness", f"{path}: rule is not a dict: {rule!r}")
+    return False
+
+  rule_type = rule.get("type")
+  if rule_type is None:
+    result.error("rule well-formedness", f"{path}: rule missing 'type' field")
+    return False
+
+  if rule_type in ("offroad_only", "not_engaged"):
+    # Only type required
+    return True
+
+  if rule_type == "capability":
+    valid = True
+    if "field" not in rule or not isinstance(rule["field"], str):
+      result.error("rule well-formedness", f"{path}: capability rule missing/invalid 'field'")
+      valid = False
+    if "equals" not in rule:
+      result.error("rule well-formedness", f"{path}: capability rule missing 'equals'")
+      valid = False
+    return valid
+
+  if rule_type == "param":
+    valid = True
+    if "key" not in rule or not isinstance(rule["key"], str):
+      result.error("rule well-formedness", f"{path}: param rule missing/invalid 'key'")
+      valid = False
+    if "equals" not in rule:
+      result.error("rule well-formedness", f"{path}: param rule missing 'equals'")
+      valid = False
+    return valid
+
+  if rule_type == "param_compare":
+    valid = True
+    if "key" not in rule or not isinstance(rule["key"], str):
+      result.error("rule well-formedness", f"{path}: param_compare rule missing/invalid 'key'")
+      valid = False
+    if "op" not in rule or rule["op"] not in VALID_COMPARE_OPS:
+      result.error("rule well-formedness",
+                    f"{path}: param_compare rule missing/invalid 'op' (must be one of {VALID_COMPARE_OPS})")
+      valid = False
+    if "value" not in rule or not isinstance(rule["value"], (int, float)):
+      result.error("rule well-formedness", f"{path}: param_compare rule missing/invalid 'value' (must be number)")
+      valid = False
+    return valid
+
+  if rule_type == "not":
+    if "condition" not in rule or not isinstance(rule["condition"], dict):
+      result.error("rule well-formedness", f"{path}: 'not' rule missing/invalid 'condition'")
+      return False
+    return validate_rule(rule["condition"], f"{path}.not", result, capability_fields)
+
+  if rule_type in ("any", "all"):
+    if "conditions" not in rule or not isinstance(rule["conditions"], list):
+      result.error("rule well-formedness", f"{path}: '{rule_type}' rule missing/invalid 'conditions' array")
+      return False
+    valid = True
+    for i, cond in enumerate(rule["conditions"]):
+      if not validate_rule(cond, f"{path}.{rule_type}[{i}]", result, capability_fields):
+        valid = False
+    return valid
+
+  result.error("rule well-formedness", f"{path}: unknown rule type '{rule_type}'")
+  return False
+
+
+def collect_rules_from_item(item: dict) -> list[tuple[str, list[dict]]]:
+  """Return list of (context, rules_list) for an item's visibility + enablement."""
+  result = []
+  key = item.get("key", "?")
+  if "visibility" in item:
+    result.append((f"item '{key}' visibility", item["visibility"]))
+  if "enablement" in item:
+    result.append((f"item '{key}' enablement", item["enablement"]))
+  return result
+
+
+def walk_rules_flat(rules: list[dict]) -> list[dict]:
+  """Flatten all rules recursively into a single list."""
+  flat: list[dict] = []
+  for rule in rules:
+    flat.append(rule)
+    if rule.get("type") == "not" and "condition" in rule:
+      flat.extend(walk_rules_flat([rule["condition"]]))
+    elif rule.get("type") in ("any", "all") and "conditions" in rule:
+      flat.extend(walk_rules_flat(rule["conditions"]))
+  return flat
+
+
+def collect_all_items(data: dict) -> list[tuple[str, dict]]:
+  """Collect all items with their location path from the schema.
+
+  Returns (path, item_dict) tuples. Traverses sections, sub_panels, sub_items,
+  and vehicle_settings.
+  """
+  items: list[tuple[str, dict]] = []
+
+  for panel in data.get("panels", []):
+    pid = panel.get("id", "?")
+
+    # Flat items on panel
+    for item in panel.get("items", []):
+      _collect_item(f"panel '{pid}'", item, items)
+
+    # Sections
+    for section in panel.get("sections", []):
+      sid = section.get("id", "?")
+      for item in section.get("items", []):
+        _collect_item(f"panel '{pid}' > section '{sid}'", item, items)
+      for sp in section.get("sub_panels", []):
+        spid = sp.get("id", "?")
+        for item in sp.get("items", []):
+          _collect_item(f"panel '{pid}' > section '{sid}' > sub_panel '{spid}'", item, items)
+
+    # Top-level sub_panels on panel (no section)
+    for sp in panel.get("sub_panels", []):
+      spid = sp.get("id", "?")
+      for item in sp.get("items", []):
+        _collect_item(f"panel '{pid}' > sub_panel '{spid}'", item, items)
+
+  # Vehicle settings (supports both flat list and { title, items } structure)
+  for brand, brand_data in data.get("vehicle_settings", {}).items():
+    brand_items = brand_data.get("items", []) if isinstance(brand_data, dict) else brand_data
+    for item in brand_items:
+      _collect_item(f"vehicle_settings '{brand}'", item, items)
+
+  return items
+
+
+def _collect_item(path: str, item: dict, items: list[tuple[str, dict]]) -> None:
+  """Recursively collect an item and its sub_items."""
+  items.append((path, item))
+  for sub in item.get("sub_items", []):
+    _collect_item(f"{path} > sub_item", sub, items)
+
+
+def collect_panel_keys(panel: dict) -> set[str]:
+  """Collect all item keys within a single panel (sections, sub_panels, sub_items)."""
+  keys: set[str] = set()
+
+  def _add(item: dict) -> None:
+    if "key" in item:
+      keys.add(item["key"])
+    for sub in item.get("sub_items", []):
+      _add(sub)
+
+  for item in panel.get("items", []):
+    _add(item)
+  for section in panel.get("sections", []):
+    for item in section.get("items", []):
+      _add(item)
+    for sp in section.get("sub_panels", []):
+      for item in sp.get("items", []):
+        _add(item)
+  for sp in panel.get("sub_panels", []):
+    for item in sp.get("items", []):
+      _add(item)
+
+  return keys
+
+
+def check_json_parseable(path: str, result: ValidationResult) -> dict | None:
+  """Check 1: JSON parseable."""
+  try:
+    with open(path) as f:
+      data = json.load(f)
+    result.ok("JSON parseable")
+    return data
+  except json.JSONDecodeError as e:
+    result.error("JSON parseable", str(e))
+    return None
+  except FileNotFoundError:
+    result.error("JSON parseable", f"file not found: {path}")
+    return None
+
+
+def check_structural(data: dict, result: ValidationResult) -> None:
+  """Check 2: Required fields on panels, sections, items, sub_panels."""
+  errors: list[str] = []
+
+  for i, panel in enumerate(data.get("panels", [])):
+    for field in ("id", "label", "icon", "order"):
+      if field not in panel:
+        errors.append(f"panels[{i}]: missing required field '{field}'")
+
+    for j, section in enumerate(panel.get("sections", [])):
+      for field in ("id", "title"):
+        if field not in section:
+          errors.append(f"panels[{i}].sections[{j}]: missing required field '{field}'")
+
+      for k, sp in enumerate(section.get("sub_panels", [])):
+        for field in ("id", "label", "trigger_key"):
+          if field not in sp:
+            errors.append(f"panels[{i}].sections[{j}].sub_panels[{k}]: missing required field '{field}'")
+
+    for k, sp in enumerate(panel.get("sub_panels", [])):
+      for field in ("id", "label", "trigger_key"):
+        if field not in sp:
+          errors.append(f"panels[{i}].sub_panels[{k}]: missing required field '{field}'")
+
+  # Validate items
+  all_items = collect_all_items(data)
+  for path, item in all_items:
+    if "key" not in item:
+      errors.append(f"{path}: item missing required field 'key'")
+    if "widget" not in item:
+      errors.append(f"{path}: item missing required field 'widget'")
+    elif item["widget"] not in VALID_WIDGETS:
+      errors.append(
+        f"{path}: item '{item.get('key', '?')}' has invalid widget '{item['widget']}'"
+        + f" (must be one of {VALID_WIDGETS})"
+      )
+
+  if errors:
+    result.error("structural", "; ".join(errors))
+  else:
+    result.ok("structural")
+
+
+def check_item_completeness(data: dict, result: ValidationResult) -> None:
+  """Check 3: All items have required metadata (title, options for dropdowns)."""
+  all_items = collect_all_items(data)
+  issues: list[str] = []
+
+  for _path, item in all_items:
+    key = item.get("key", "unknown")
+    if "title" not in item:
+      issues.append(f"{key}: missing 'title'")
+    elif item["title"] == key:
+      issues.append(f"{key}: title must not equal key (use a human-readable title)")
+    widget = item.get("widget")
+    if widget in ("multiple_button", "option") and "options" in item:
+      opts = item["options"]
+      if not isinstance(opts, list):
+        issues.append(f"{key}: options must be a list")
+      else:
+        for opt in opts:
+          if not isinstance(opt, dict) or "value" not in opt or "label" not in opt:
+            issues.append(f"{key}: each option must have 'value' and 'label'")
+            break
+
+  if issues:
+    for issue in issues:
+      result.error("item completeness", issue)
+  else:
+    result.ok("item completeness")
+
+
+def check_no_duplicate_keys(data: dict, result: ValidationResult) -> None:
+  """Check 4: No param key appears in more than one panel."""
+  panel_keys: dict[str, list[str]] = {}  # key -> list of panel ids
+
+  for panel in data.get("panels", []):
+    pid = panel.get("id", "?")
+    keys = collect_panel_keys(panel)
+    for key in keys:
+      panel_keys.setdefault(key, []).append(pid)
+
+  # Also check vehicle_settings keys don't collide with panel keys
+  for brand, brand_data in data.get("vehicle_settings", {}).items():
+    brand_items = brand_data.get("items", []) if isinstance(brand_data, dict) else brand_data
+    for item in brand_items:
+      key = item.get("key")
+      if key:
+        panel_keys.setdefault(key, []).append(f"vehicle_settings.{brand}")
+
+  duplicates = {k: v for k, v in panel_keys.items() if len(v) > 1}
+  if duplicates:
+    details = "; ".join(f"'{k}' in [{', '.join(v)}]" for k, v in duplicates.items())
+    result.error("no duplicate keys", details)
+  else:
+    result.ok("no duplicate keys")
+
+
+def check_rule_wellformedness(data: dict, result: ValidationResult) -> None:
+  """Check 5: All rules have valid structure."""
+  all_items = collect_all_items(data)
+
+  # Save current error count to detect new errors
+  error_count_before = len(result.failed)
+
+  for path, item in all_items:
+    for ctx, rules in collect_rules_from_item(item):
+      for i, rule in enumerate(rules):
+        validate_rule(rule, f"{path} > {ctx}[{i}]", result, CAPABILITY_FIELDS)
+
+  # Also validate trigger_condition rules on sub_panels
+  for panel in data.get("panels", []):
+    pid = panel.get("id", "?")
+    for section in panel.get("sections", []):
+      for sp in section.get("sub_panels", []):
+        if "trigger_condition" in sp:
+          validate_rule(sp["trigger_condition"], f"panel '{pid}' > sub_panel '{sp.get('id', '?')}' trigger_condition",
+                        result, CAPABILITY_FIELDS)
+
+  if len(result.failed) == error_count_before:
+    result.ok("rule well-formedness")
+
+
+def check_capability_refs(data: dict, result: ValidationResult) -> None:
+  """Check 6: All capability rule field values are in CAPABILITY_FIELDS."""
+  all_items = collect_all_items(data)
+  invalid_refs: list[str] = []
+  cap_set = set(CAPABILITY_FIELDS)
+
+  for _path, item in all_items:
+    for _ctx, rules in collect_rules_from_item(item):
+      for rule in walk_rules_flat(rules):
+        if rule.get("type") == "capability":
+          field = rule.get("field")
+          if field and field not in cap_set:
+            invalid_refs.append(f"'{field}' in item '{item.get('key', '?')}'")
+
+  # Also check trigger_conditions
+  for panel in data.get("panels", []):
+    for section in panel.get("sections", []):
+      for sp in section.get("sub_panels", []):
+        if "trigger_condition" in sp:
+          for rule in walk_rules_flat([sp["trigger_condition"]]):
+            if rule.get("type") == "capability":
+              field = rule.get("field")
+              if field and field not in cap_set:
+                invalid_refs.append(f"'{field}' in sub_panel '{sp.get('id', '?')}' trigger_condition")
+
+  if invalid_refs:
+    result.error("capability refs", f"unknown capability fields: {', '.join(invalid_refs)}")
+  else:
+    result.ok("capability refs")
+
+
+def check_no_self_reference(data: dict, result: ValidationResult) -> None:
+  """Check 7: Item's rules must not reference the item's own key."""
+  all_items = collect_all_items(data)
+  self_refs: list[str] = []
+
+  for path, item in all_items:
+    key = item.get("key")
+    if not key:
+      continue
+    for _ctx, rules in collect_rules_from_item(item):
+      for rule in walk_rules_flat(rules):
+        if rule.get("type") in ("param", "param_compare") and rule.get("key") == key:
+          self_refs.append(f"'{key}' at {path}")
+
+  if self_refs:
+    result.error("no self-reference", f"items reference their own key: {', '.join(self_refs)}")
+  else:
+    result.ok("no self-reference")
+
+
+def check_sub_panel_triggers(data: dict, result: ValidationResult) -> None:
+  """Check 8: Sub-panel trigger_key must reference a key in the same panel."""
+  errors: list[str] = []
+
+  for panel in data.get("panels", []):
+    pid = panel.get("id", "?")
+    panel_keys = collect_panel_keys(panel)
+
+    # Check sub_panels at section level
+    for section in panel.get("sections", []):
+      for sp in section.get("sub_panels", []):
+        trigger = sp.get("trigger_key")
+        if trigger and trigger not in panel_keys:
+          errors.append(
+            f"sub_panel '{sp.get('id', '?')}' trigger_key '{trigger}'"
+            + f" not found in panel '{pid}'"
+          )
+
+    # Check top-level sub_panels
+    for sp in panel.get("sub_panels", []):
+      trigger = sp.get("trigger_key")
+      if trigger and trigger not in panel_keys:
+        errors.append(
+          f"sub_panel '{sp.get('id', '?')}' trigger_key '{trigger}'"
+          + f" not found in panel '{pid}'"
+        )
+
+  if errors:
+    result.error("sub-panel triggers", "; ".join(errors))
+  else:
+    result.ok("sub-panel triggers")
+
+
+def check_ordering(data: dict, result: ValidationResult) -> None:
+  """Check 9: Panel order values must be unique."""
+  orders: dict[int, list[str]] = {}
+  for panel in data.get("panels", []):
+    order = panel.get("order")
+    if order is not None:
+      orders.setdefault(order, []).append(panel.get("id", "?"))
+
+  duplicates = {o: ids for o, ids in orders.items() if len(ids) > 1}
+  if duplicates:
+    details = "; ".join(f"order {o}: [{', '.join(ids)}]" for o, ids in duplicates.items())
+    result.error("ordering", f"duplicate order values: {details}")
+  else:
+    result.ok("ordering")
+
+
+def check_vehicle_brands(data: dict, result: ValidationResult) -> None:
+  """Check 10: Vehicle settings keys lowercase + each brand has consistent {title, description, items} shape."""
+  vehicle = data.get("vehicle_settings", {})
+  errors: list[str] = []
+
+  for brand, brand_data in vehicle.items():
+    if not isinstance(brand, str) or brand != brand.lower():
+      errors.append(f"non-lowercase brand key: '{brand}'")
+    if not isinstance(brand_data, dict):
+      errors.append(f"brand '{brand}': expected object with {{title, description, items}}, got bare list")
+      continue
+    if "items" not in brand_data:
+      errors.append(f"brand '{brand}': missing 'items'")
+    if "title" not in brand_data:
+      errors.append(f"brand '{brand}': missing 'title' (use empty string for none)")
+
+  if errors:
+    result.error("vehicle brands", "; ".join(errors))
+  else:
+    result.ok("vehicle brands")
+
+
+def validate(path: str) -> bool:
+  """Run all validation checks on the given settings_ui.json file.
+
+  Returns True if all checks pass.
+  """
+  result = ValidationResult()
+
+  # Check 1: JSON parseable
+  data = check_json_parseable(path, result)
+  if data is None:
+    result.summary()
+    return False
+
+  # Checks 2-10
+  check_structural(data, result)
+  check_item_completeness(data, result)
+  check_no_duplicate_keys(data, result)
+  check_rule_wellformedness(data, result)
+  check_capability_refs(data, result)
+  check_no_self_reference(data, result)
+  check_sub_panel_triggers(data, result)
+  check_ordering(data, result)
+  check_vehicle_brands(data, result)
+
+  result.summary()
+  return result.success
+
+
+if __name__ == "__main__":
+  target = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_PATH
+  success = validate(target)
+  sys.exit(0 if success else 1)

sunnypilot/system/params_migration.py

@@ -4,7 +4,10 @@ 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
+
 from openpilot.common.swaglog import cloudlog
+from openpilot.sunnypilot.selfdrive.car.sync_car_list_param import CAR_LIST_JSON_OUT
 
 ONROAD_BRIGHTNESS_MIGRATION_VERSION: str = "1.0"
 ONROAD_BRIGHTNESS_TIMER_MIGRATION_VERSION: str = "1.0"
@@ -14,6 +17,36 @@ ONROAD_BRIGHTNESS_TIMER_VALUES = {0: 3, 1: 5, 2: 7, 3: 10, 4: 15, 5: 30, **{i: (
 VALID_TIMER_VALUES = set(ONROAD_BRIGHTNESS_TIMER_VALUES.values())
 
 
+def _migrate_car_platform_bundle(_params):
+  bundle = _params.get("CarPlatformBundle")
+  if bundle is None:
+    return
+
+  old_platform = bundle.get("platform")
+  if not old_platform:
+    return
+
+  from opendbc.car.fingerprints import MIGRATION  # lazy: avoids heavy import at module level
+  if old_platform not in MIGRATION:
+    return
+
+  new_platform = str(MIGRATION[old_platform])
+
+  with open(CAR_LIST_JSON_OUT) as f:
+    car_list = json.load(f)
+
+  candidates = [(k, v) for k, v in car_list.items() if v.get("platform") == new_platform]
+  if candidates:
+    old_model = bundle.get("model")
+    key, data = next(((k, v) for k, v in candidates if v.get("model") == old_model), candidates[0])
+    bundle = {**data, "name": key}
+  else:
+    bundle["platform"] = new_platform
+
+  _params.put("CarPlatformBundle", bundle)
+  cloudlog.info(f"params_migration: CarPlatformBundle migrated {old_platform!r} -> {new_platform!r}")
+
+
 def run_migration(_params):
   # migrate OnroadScreenOffBrightness
   if _params.get("OnroadScreenOffBrightnessMigrated") != ONROAD_BRIGHTNESS_MIGRATION_VERSION:
@@ -45,3 +78,5 @@ def run_migration(_params):
       cloudlog.info(log_str + f" Setting OnroadScreenOffTimerMigrated to {ONROAD_BRIGHTNESS_TIMER_MIGRATION_VERSION}")
     except Exception as e:
       cloudlog.exception(f"Error migrating OnroadScreenOffTimer: {e}")
+
+  _migrate_car_platform_bundle(_params)

sunnypilot/system/sensord/sensors/bmx055_accel.cc

@@ -71,10 +71,9 @@ bool BMX055_Accel::get_event(MessageBuilder &msg, uint64_t ts) {
 
   auto event = msg.initEvent().initAccelerometer2();
   event.setSource(cereal::SensorEventData::SensorSource::BMX055);
-  auto deprecated = event.initDeprecated();
-  deprecated.setVersion(1);
-  deprecated.setSensor(SENSOR_ACCELEROMETER);
-  deprecated.setType(SENSOR_TYPE_ACCELEROMETER);
+  event.setVersion(1);
+  event.setSensor(SENSOR_ACCELEROMETER);
+  event.setType(SENSOR_TYPE_ACCELEROMETER);
   event.setTimestamp(start_time);
 
   float xyz[] = {x, y, z};

sunnypilot/system/sensord/sensors/bmx055_gyro.cc

@@ -78,10 +78,9 @@ bool BMX055_Gyro::get_event(MessageBuilder &msg, uint64_t ts) {
 
   auto event = msg.initEvent().initGyroscope2();
   event.setSource(cereal::SensorEventData::SensorSource::BMX055);
-  auto deprecated = event.initDeprecated();
-  deprecated.setVersion(1);
-  deprecated.setSensor(SENSOR_GYRO_UNCALIBRATED);
-  deprecated.setType(SENSOR_TYPE_GYROSCOPE_UNCALIBRATED);
+  event.setVersion(1);
+  event.setSensor(SENSOR_GYRO_UNCALIBRATED);
+  event.setType(SENSOR_TYPE_GYROSCOPE_UNCALIBRATED);
   event.setTimestamp(start_time);
 
   float xyz[] = {x, y, z};

sunnypilot/system/sensord/sensors/bmx055_magn.cc

@@ -229,10 +229,9 @@ bool BMX055_Magn::get_event(MessageBuilder &msg, uint64_t ts) {
 
     auto event = msg.initEvent().initMagnetometer();
     event.setSource(cereal::SensorEventData::SensorSource::BMX055);
-    auto deprecated = event.initDeprecated();
-    deprecated.setVersion(2);
-    deprecated.setSensor(SENSOR_MAGNETOMETER_UNCALIBRATED);
-    deprecated.setType(SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED);
+    event.setVersion(2);
+    event.setSensor(SENSOR_MAGNETOMETER_UNCALIBRATED);
+    event.setType(SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED);
     event.setTimestamp(start_time);
 
     // Move magnetometer into same reference frame as accel/gryo

sunnypilot/system/sensord/sensors/bmx055_temp.cc

@@ -22,9 +22,8 @@ bool BMX055_Temp::get_event(MessageBuilder &msg, uint64_t ts) {
 
   auto event = msg.initEvent().initTemperatureSensor();
   event.setSource(cereal::SensorEventData::SensorSource::BMX055);
-  auto deprecated = event.initDeprecated();
-  deprecated.setVersion(1);
-  deprecated.setType(SENSOR_TYPE_AMBIENT_TEMPERATURE);
+  event.setVersion(1);
+  event.setType(SENSOR_TYPE_AMBIENT_TEMPERATURE);
   event.setTimestamp(start_time);
   event.setTemperature(temp);
 

sunnypilot/system/sensord/sensors/lsm6ds3_accel.cc

@@ -236,10 +236,9 @@ bool LSM6DS3_Accel::get_event(MessageBuilder &msg, uint64_t ts) {
 
   auto event = msg.initEvent().initAccelerometer();
   event.setSource(source);
-  auto deprecated = event.initDeprecated();
-  deprecated.setVersion(1);
-  deprecated.setSensor(SENSOR_ACCELEROMETER);
-  deprecated.setType(SENSOR_TYPE_ACCELEROMETER);
+  event.setVersion(1);
+  event.setSensor(SENSOR_ACCELEROMETER);
+  event.setType(SENSOR_TYPE_ACCELEROMETER);
   event.setTimestamp(ts);
 
   float xyz[] = {y, -x, z};

sunnypilot/system/sensord/sensors/lsm6ds3_gyro.cc

@@ -219,10 +219,9 @@ bool LSM6DS3_Gyro::get_event(MessageBuilder &msg, uint64_t ts) {
 
   auto event = msg.initEvent().initGyroscope();
   event.setSource(source);
-  auto deprecated = event.initDeprecated();
-  deprecated.setVersion(2);
-  deprecated.setSensor(SENSOR_GYRO_UNCALIBRATED);
-  deprecated.setType(SENSOR_TYPE_GYROSCOPE_UNCALIBRATED);
+  event.setVersion(2);
+  event.setSensor(SENSOR_GYRO_UNCALIBRATED);
+  event.setType(SENSOR_TYPE_GYROSCOPE_UNCALIBRATED);
   event.setTimestamp(ts);
 
   float xyz[] = {y, -x, z};

sunnypilot/system/sensord/sensors/lsm6ds3_temp.cc

@@ -28,9 +28,8 @@ bool LSM6DS3_Temp::get_event(MessageBuilder &msg, uint64_t ts) {
 
   auto event = msg.initEvent().initTemperatureSensor();
   event.setSource(source);
-  auto deprecated = event.initDeprecated();
-  deprecated.setVersion(1);
-  deprecated.setType(SENSOR_TYPE_AMBIENT_TEMPERATURE);
+  event.setVersion(1);
+  event.setType(SENSOR_TYPE_AMBIENT_TEMPERATURE);
   event.setTimestamp(start_time);
   event.setTemperature(temp);
 

sunnypilot/system/sensord/sensors/mmc5603nj_magn.cc

@@ -91,10 +91,9 @@ bool MMC5603NJ_Magn::get_event(MessageBuilder &msg, uint64_t ts) {
 
   auto event = msg.initEvent().initMagnetometer();
   event.setSource(cereal::SensorEventData::SensorSource::MMC5603NJ);
-  auto deprecated = event.initDeprecated();
-  deprecated.setVersion(1);
-  deprecated.setSensor(SENSOR_MAGNETOMETER_UNCALIBRATED);
-  deprecated.setType(SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED);
+  event.setVersion(1);
+  event.setSensor(SENSOR_MAGNETOMETER_UNCALIBRATED);
+  event.setType(SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED);
   event.setTimestamp(start_time);
 
   float vals[] = {xyz[0], xyz[1], xyz[2], reset_xyz[0], reset_xyz[1], reset_xyz[2]};