limit steering angle to prevent MDPS faults

- Reduced max allowable angle to 180° in `values.py` and 1800 in `hyundai_canfd.h`. - Prevents potential faults and ensures safer steering operation.
welp, this was the blocking piece
2026-08-07 23:55:43 +08:00 · 2026-08-07 11:50:45 +02:00 · 2026-08-07 11:31:07 +02:00 · 2026-08-06 19:03:46 +02:00 · 2026-08-06 18:50:27 +02:00 · 2026-08-06 17:03:18 +02:00
118 changed files with 4549 additions and 9006 deletions
@@ -2,5 +2,6 @@ Wen
 REGIST
 PullRequest
 cancelled
+indeces
 FOF
 NoO
@@ -12,11 +12,11 @@ on:
        required: false
        type: string
      recompiled_dir:
-        description: 'Existing recompiled directory number (e.g. 1 for recompiled1)'
+        description: 'Existing recompiled directory number (e.g. 3 for recompiled3)'
        required: true
        type: string
      json_version:
-        description: 'driving_models version number to update (e.g. 18 for driving_models_v18.json)'
+        description: 'driving_models version number to update (e.g. 5 for driving_models_v5.json)'
        required: true
        type: string
      artifact_suffix:
@@ -63,11 +63,12 @@ on:
        default: 'None'
        options:
          - None
-          - Master Models
-          - Release Models
-          - 2025 World Models
-          - 2026 World Models
+          - Simple Plan Models
+          - Space Lab Models
+          - TR Models
+          - DTR Models
          - Custom Merge Models
+          - FOF series models
          - Other
      custom_model_folder:
        description: 'Custom model folder name (if "Other" selected)'
@@ -0,0 +1,39 @@
+name: prebuilt
+on:
+  schedule:
+    - cron: '0 * * * *'
+  workflow_dispatch:
+
+env:
+  DOCKER_LOGIN: docker login ghcr.io -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }}
+  BUILD: release/ci/docker_build_sp.sh
+
+jobs:
+  build_prebuilt:
+    name: build prebuilt
+    runs-on: ubuntu-latest
+    if: github.repository == 'sunnypilot/sunnypilot'
+    env:
+      PUSH_IMAGE: true
+    permissions:
+      checks: read
+      contents: read
+      packages: write
+    steps:
+    - name: Wait for green check mark
+      if: ${{ github.event_name != 'workflow_dispatch' }}
+      uses: lewagon/wait-on-check-action@ccfb013c15c8afb7bf2b7c028fb74dc5a068cccc
+      with:
+        ref: master
+        wait-interval: 30
+        running-workflow-name: 'build prebuilt'
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        check-regexp: ^((?!.*(build master-ci|create badges).*).)*$
+    - uses: actions/checkout@v6
+      with:
+        submodules: true
+    - run: git lfs pull
+    - name: Build and Push docker image
+      run: |
+        $DOCKER_LOGIN
+        eval "$BUILD"
@@ -30,11 +30,6 @@ on:
        required: false
        type: string
        default: ''
-      target_hardware:
-        description: 'Hardware target to compile for (qcom or usbgpu)'
-        required: false
-        type: string
-        default: 'qcom'
  workflow_dispatch:
    inputs:
      upstream_branch:
@@ -51,14 +46,6 @@ on:
        required: false
        type: boolean
        default: true
-      target_hardware:
-        description: 'Hardware target to compile for'
-        required: true
-        type: choice
-        options:
-          - qcom
-          - usbgpu
-        default: 'qcom'


 run-name: Build model [${{ inputs.custom_name || inputs.upstream_branch }}] from ref [${{ inputs.upstream_branch }}]
@@ -174,30 +161,19 @@ jobs:
          name: models-${{ env.REF }}${{ inputs.artifact_suffix }}
          path: ${{ env.MODELS_DIR }}
      - run: |
-          rm -f ${{ env.MODELS_DIR }}/{dmonitoring_model,big_driving_policy,big_driving_vision,big_driving_supercombo}.onnx
+          rm -f ${{ env.MODELS_DIR }}/{dmonitoring_model,big_driving_policy,big_driving_vision}.onnx

      - name: Build Model
        run: |
          source /etc/profile
          export UV_PROJECT_ENVIRONMENT=${HOME}/venv
          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
-          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          export PYTHONPATH="${PYTHONPATH}:${{ env.TINYGRAD_PATH }}:${{ github.workspace }}"

          COMPILE_MODELD="${{ github.workspace }}/openpilot/sunnypilot/modeld_v2/compile_modeld.py"
          MODEL_SIZE=$(python3 -c "from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE as s; print(f'{s[0]}x{s[1]}')")
          CAMERA_RES=$(python3 -c "from openpilot.common.transformations.camera import _ar_ox_fisheye as a, _os_fisheye as o; print(f'{a.width}x{a.height} {o.width}x{o.height}')")
-
-          if [ "${{ inputs.target_hardware }}" == "usbgpu" ]; then
-            echo "USBGPU build"
-            export USBGPU=1
-            TG_FLAGS="DEV=AMD USBGPU=1 IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
-            OUTPUT_PKL="${{ env.MODELS_DIR }}/big_driving_tinygrad.pkl"
-          else
-            echo "QCOM build"
-            TG_FLAGS="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
-            OUTPUT_PKL="${{ env.MODELS_DIR }}/driving_tinygrad.pkl"
-          fi
+          TG_FLAGS="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"

          # Generate metadata for all ONNX files
          find "${{ env.MODELS_DIR }}" -maxdepth 1 -name '*.onnx' | while IFS= read -r onnx_file; do
@@ -210,13 +186,7 @@ jobs:
          POLICY_ONNX="${{ env.MODELS_DIR }}/driving_policy.onnx"
          OFF_POLICY_ONNX="${{ env.MODELS_DIR }}/driving_off_policy.onnx"
          ON_POLICY_ONNX="${{ env.MODELS_DIR }}/driving_on_policy.onnx"
-          SUPERCOMBO_ONNX=""
-          for f in "${{ env.MODELS_DIR }}/supercombo.onnx" "${{ env.MODELS_DIR }}/driving_supercombo.onnx"; do
-            if [ -f "$f" ]; then
-              SUPERCOMBO_ONNX="$f"
-              break
-            fi
-          done
+          SUPERCOMBO_ONNX="${{ env.MODELS_DIR }}/supercombo.onnx"

          MODEL_TYPE="" ONNX_ARGS="" OUTPUT_NAME=""
          if [ -f "$VISION_ONNX" ]; then
@@ -237,15 +207,24 @@ jobs:
          fi

          if [ -n "$MODEL_TYPE" ]; then
-            echo "Detected: $MODEL_TYPE -> $OUTPUT_PKL"
+            echo "Detected: $MODEL_TYPE -> driving_tinygrad.pkl"
            env ${TG_FLAGS} python3 "$COMPILE_MODELD" \
              --model-type $MODEL_TYPE \
              --model-size $MODEL_SIZE \
              --camera-resolutions $CAMERA_RES \
              $ONNX_ARGS \
-              --output "$OUTPUT_PKL"
+              --output "${{ env.MODELS_DIR }}/driving_tinygrad.pkl"
          fi

+      - name: Validate Model Outputs
+        run: |
+          source /etc/profile
+          export UV_PROJECT_ENVIRONMENT=${HOME}/venv
+          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
+          python3 "${{ github.workspace }}/release/ci/model_generator.py" \
+            --validate-only \
+            --model-dir "${{ env.MODELS_DIR }}"
+
      - name: Prepare Output
        run: |
          sudo rm -rf ${{ env.OUTPUT_DIR }}
@@ -4,7 +4,6 @@
 [submodule "opendbc"]
  path = opendbc_repo
  url = https://github.com/sunnypilot/opendbc.git
-  branch = tn
 [submodule "msgq"]
  path = msgq_repo
  url = https://github.com/sunnypilot/msgq.git
@@ -21,5 +21,12 @@
        </clean>
      </configuration>
    </target>
+    <target id="f2590b2b-9b93-49f9-8510-da3f3724a2ae" name="replay" defaultType="TOOL">
+      <configuration id="d475264f-6f4c-4092-9b4e-6773309f38b7" name="replay" toolchainName="Default">
+        <build type="TOOL">
+          <tool actionId="Tool_External Tools_uv build tools replay" />
+        </build>
+      </configuration>
+    </target>
  </component>
 </project>
@@ -20,4 +20,11 @@
      <option name="WORKING_DIRECTORY" value="$ProjectFileDir$" />
    </exec>
  </tool>
+  <tool name="uv build tools replay" showInMainMenu="false" showInEditor="false" showInProject="false" showInSearchPopup="false" disabled="false" useConsole="true" showConsoleOnStdOut="false" showConsoleOnStdErr="false" synchronizeAfterRun="true">
+    <exec>
+      <option name="COMMAND" value="bash" />
+      <option name="PARAMETERS" value="-c &quot;source .venv/bin/activate &amp;&amp; scons -u -j$(nproc) tools/replay/&quot;" />
+      <option name="WORKING_DIRECTORY" value="$ProjectFileDir$" />
+    </exec>
+  </tool>
 </toolSet>
@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Build Debug" type="CLionExternalRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" WORKING_DIR="file://$ProjectFileDir$/selfdrive/ui" PASS_PARENT_ENVS_2="true" PROJECT_NAME="sunnypilot" TARGET_NAME="uv Scons Build Debug" CONFIG_NAME="uv Scons Build Debug" RUN_PATH="ui">
+  <configuration default="false" name="Build Debug" type="CLionExternalRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" WORKING_DIR="file://$ProjectFileDir$/selfdrive/ui" PASS_PARENT_ENVS_2="true" PROJECT_NAME="openpilot-special" TARGET_NAME="uv Scons Build Debug" CONFIG_NAME="uv Scons Build Debug" RUN_PATH="ui">
    <envs>
      <env name="QT_DBL_CLICK_DIST" value="150" />
    </envs>
@@ -0,0 +1,27 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Debug Route Controls" type="PythonConfigurationType" factoryName="Python">
+    <module name="openpilot-special" />
+    <option name="ENV_FILES" value="" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="PARENT_ENVS" value="true" />
+    <envs>
+      <env name="PYTHONUNBUFFERED" value="1" />
+      <env name="FINGERPRINT" value="KIA_EV9" />
+      <env name="SKIP_FW_QUERY" value="1" />
+    </envs>
+    <option name="SDK_HOME" value="" />
+    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/selfdrive/car" />
+    <option name="IS_MODULE_SDK" value="true" />
+    <option name="ADD_CONTENT_ROOTS" value="true" />
+    <option name="ADD_SOURCE_ROOTS" value="true" />
+    <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
+    <option name="SCRIPT_NAME" value="$PROJECT_DIR$/selfdrive/car/card.py" />
+    <option name="PARAMETERS" value="" />
+    <option name="SHOW_COMMAND_LINE" value="false" />
+    <option name="EMULATE_TERMINAL" value="true" />
+    <option name="MODULE_MODE" value="false" />
+    <option name="REDIRECT_INPUT" value="false" />
+    <option name="INPUT_FILE" value="" />
+    <method v="2" />
+  </configuration>
+</component>
@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Replay for controls + ui" type="Multirun" separateTabs="false" reuseTabsWithFailures="false" startOneByOne="true" markFailedProcess="true" hideSuccessProcess="false" delayTime="0.0">
+    <runConfiguration name="replay for controls" type="Native Application" />
+    <runConfiguration name="Build Debug" type="Custom Build Application" />
+    <method v="2" />
+  </configuration>
+</component>
@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="replay for controls" type="CLionNativeAppRunConfigurationType" focusToolWindowBeforeRun="true" PROGRAM_PARAMS="&quot;$Prompt$&quot; --block &quot;sendcan,carState,carParams,carOutput,liveTracks,carParamsSP,carStateSP,bookmarkButton&quot;" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="true" WORKING_DIR="file://$ProjectFileDir$/tools/replay" PASS_PARENT_ENVS_2="true" PROJECT_NAME="openpilot-special" TARGET_NAME="replay" CONFIG_NAME="replay" version="1" RUN_PATH="replay">
+    <method v="2">
+      <option name="CLION.COMPOUND.BUILD" enabled="true" />
+    </method>
+  </configuration>
+</component>
@@ -69,8 +69,6 @@ struct LeadData {
 struct SelfdriveStateSP @0x81c2f05a394cf4af {
  mads @0 :ModularAssistiveDrivingSystem;
  intelligentCruiseButtonManagement @1 :IntelligentCruiseButtonManagement;
-  buttonsPressed @2 :UInt16;
-  buttonsReleaseToggle @3 :UInt16;

  enum AudibleAlert {
    none @0;
@@ -139,16 +137,10 @@ struct ModelManagerSP @0xaedffd8f31e7b55d {
    eta @2 :UInt32;
  }

-  struct Chunk {
-    fileName @0 :Text;
-    sha256 @1 :Text;
-  }
-
  struct Artifact {
    fileName @0 :Text;
    downloadUri @1 :DownloadUri;
    downloadProgress @2 :DownloadProgress;
-    chunks @3 :List(Chunk);
  }

  struct Model {
@@ -163,7 +155,6 @@ struct ModelManagerSP @0xaedffd8f31e7b55d {
      policy @3;
      offPolicy @4;
      onPolicy @5;
-      chunked @6;
    }
  }

@@ -203,7 +194,6 @@ struct LongitudinalPlanSP @0xf35cc4560bbf6ec2 {
  aTarget @5 :Float32;
  events @6 :List(OnroadEventSP.Event);
  e2eAlerts @7 :E2eAlerts;
-  accelController @8 :AccelController;

  struct DynamicExperimentalControl {
    state @0 :DynamicExperimentalControlState;
@@ -306,35 +296,6 @@ struct LongitudinalPlanSP @0xf35cc4560bbf6ec2 {
    greenLightAlert @0 :Bool;
    leadDepartAlert @1 :Bool;
  }
-
-  struct AccelController {
-    enabled @0 :Bool;
-    active @1 :Bool;
-    shadowOnlyDEPRECATED @2 :Bool;
-    profile @3 :Profile;
-    state @4 :State;
-
-    enum Profile {
-      eco @0;
-      normal @1;
-      sport @2;
-    }
-
-    enum State {
-      inactive @0;
-      free @1;
-      restrict @2;
-      hold @3;
-      release @4;
-      stopHold @5;
-    }
-  }
-
-  enum AccelerationPersonality {
-    eco @0;
-    normal @1;
-    sport @2;
-  }
 }

 struct OnroadEventSP @0xda96579883444c35 {
@@ -381,7 +342,6 @@ struct OnroadEventSP @0xda96579883444c35 {
    speedLimitChanged @21;
    speedLimitPending @22;
    e2eChime @23;
-    laneChangeRoadEdge @24;
  }
 }

@@ -488,8 +448,6 @@ struct LiveMapDataSP @0xf416ec09499d9d19 {

 struct ModelDataV2SP @0xa1680744031fdb2d {
  laneTurnDirection @0 :TurnDirection;
-  leftLaneChangeEdgeBlock @1 :Bool;
-  rightLaneChangeEdgeBlock @2 :Bool;

  enum TurnDirection {
    none @0;
@@ -179,20 +179,12 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"QuickBootToggle", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"QuietMode", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"RainbowMode", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"RoadEdgeLaneChangeEnabled", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"RocketFuel", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"ShowAdvancedControls", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"ShowTurnSignals", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"StandstillTimer", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"TrueVEgoUI", {PERSISTENT | BACKUP, BOOL, "0"}},

-    // toyota specific params
-    {"ToyotaAutoHold", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"ToyotaEnhancedBsm", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"ToyotaTSS2Long", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"ToyotaDriveMode", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"ToyotaPriusTss2Pid", {PERSISTENT | BACKUP, BOOL, "0"}},
-
    // MADS params
    {"Mads", {PERSISTENT | BACKUP, BOOL, "1"}},
    {"MadsMainCruiseAllowed", {PERSISTENT | BACKUP, BOOL, "1"}},
@@ -230,17 +222,12 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"SubaruStopAndGo", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"SubaruStopAndGoManualParkingBrake", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"TeslaCoopSteering", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"TeslaMadsScreenButton", {PERSISTENT | BACKUP, INT, "0"}},
    {"ToyotaEnforceStockLongitudinal", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"ToyotaStopAndGoHack", {PERSISTENT | BACKUP, BOOL, "0"}},

    {"DynamicExperimentalControl", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"BlindSpot", {PERSISTENT | BACKUP, BOOL, "0"}},

-    // Accel Controller profiles (Eco / Normal / Sport)
-    {"AccelPersonalityEnabled", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"AccelPersonality", {PERSISTENT | BACKUP, INT, "1"}},
-
    // sunnypilot model params
    {"CameraOffset", {PERSISTENT | BACKUP, FLOAT, "0.0"}},
    {"LagdToggle", {PERSISTENT | BACKUP, BOOL, "1"}},
@@ -112,16 +112,12 @@ class TestParams:
  def test_params_default_value(self):
    self.params.remove("LanguageSetting")
    self.params.remove("LongitudinalPersonality")
-    self.params.remove("AccelPersonalityEnabled")
-    self.params.remove("AccelPersonality")
    self.params.remove("LiveParametersV2")

    assert self.params.get("LanguageSetting") is None
    assert self.params.get("LanguageSetting", return_default=False) is None
    assert isinstance(self.params.get("LanguageSetting", return_default=True), str)
    assert isinstance(self.params.get("LongitudinalPersonality", return_default=True), int)
-    assert self.params.get("AccelPersonalityEnabled", return_default=True) is False
-    assert self.params.get("AccelPersonality", return_default=True) == 1
    assert self.params.get("LiveParametersV2") is None
    assert self.params.get("LiveParametersV2", return_default=True) is None

@@ -28,6 +28,8 @@ SP_BRANCH_MIGRATIONS = {
  ("tizi", "release3-staging"): "release-tizi-staging",
  ("mici", "release3"): "release-mici",
  ("mici", "release3-staging"): "release-mici-staging",
+  ("tici", "hkg-angle-steering-2025"): "hkg-angle-steering-2025-tici",
+  ("tici", "hkg-angle-steering-2025-prebuilt"): "hkg-angle-steering-2025-tici-prebuilt"
 }

 BUILD_METADATA_FILENAME = "build.json"
@@ -11,7 +11,7 @@ from opendbc.car.structs import car
 from openpilot.common.params import Params
 from openpilot.common.realtime import config_realtime_process, Priority, Ratekeeper
 from openpilot.common.swaglog import cloudlog, ForwardingHandler
-from opendbc.safety import ALTERNATIVE_EXPERIENCE
+
 from opendbc.car import DT_CTRL, structs
 from opendbc.car.can_definitions import CanData, CanRecvCallable, CanSendCallable
 from opendbc.car.carlog import carlog
@@ -122,13 +122,7 @@ class Car:
      self.CI, self.CP, self.CP_SP = CI, CI.CP, CI.CP_SP
      self.RI = RI

-    # set alternative experiences from parameters
-    sp_toyota_auto_brake_hold = self.params.get_bool("ToyotaAutoHold")
    self.CP.alternativeExperience = 0
-    if sp_toyota_auto_brake_hold:
-      self.CP.alternativeExperience |= ALTERNATIVE_EXPERIENCE.ALLOW_AEB
-
-
    # mads
    set_alternative_experience(self.CP, self.CP_SP, self.params)
    set_car_specific_params(self.CP, self.CP_SP, self.params)
@@ -33,7 +33,7 @@ class DesireHelper:
  def get_lane_change_direction(CS):
    return LaneChangeDirection.left if CS.leftBlinker else LaneChangeDirection.right

-  def update(self, carstate, lateral_active, lane_change_prob, left_edge_detected=False, right_edge_detected=False):
+  def update(self, carstate, lateral_active, lane_change_prob):
    self.alc.update_params()
    self.lane_turn_controller.update_params()
    v_ego = carstate.vEgo
@@ -64,8 +64,8 @@ class DesireHelper:
                         ((carstate.steeringTorque > 0 and self.lane_change_direction == LaneChangeDirection.left) or
                          (carstate.steeringTorque < 0 and self.lane_change_direction == LaneChangeDirection.right))

-        blindspot_detected = (((carstate.leftBlindspot or left_edge_detected) and self.lane_change_direction == LaneChangeDirection.left) or
-                              ((carstate.rightBlindspot or right_edge_detected) and self.lane_change_direction == LaneChangeDirection.right))
+        blindspot_detected = ((carstate.leftBlindspot and self.lane_change_direction == LaneChangeDirection.left) or
+                              (carstate.rightBlindspot and self.lane_change_direction == LaneChangeDirection.right))

        self.alc.update_lane_change(blindspot_detected, carstate.brakePressed)

@@ -4,7 +4,6 @@ from openpilot.common.realtime import DT_CTRL
 from openpilot.selfdrive.controls.lib.drive_helpers import CONTROL_N
 from openpilot.common.pid import PIDController
 from openpilot.selfdrive.modeld.constants import ModelConstants
-from openpilot.sunnypilot.selfdrive.controls.lib.longcontrol import LongControlSP

 CONTROL_N_T_IDX = ModelConstants.T_IDXS[:CONTROL_N]

@@ -40,7 +39,7 @@ def long_control_state_trans(CP_SP, active, long_control_state,

  return long_control_state

-class LongControl(LongControlSP):
+class LongControl:
  def __init__(self, CP, CP_SP):
    self.CP = CP
    self.CP_SP = CP_SP
@@ -67,7 +66,7 @@ class LongControl(LongControlSP):

    elif self.long_control_state == LongCtrlState.stopping:
      output_accel = self.last_output_accel
-      if output_accel > self.CP.stopAccel and not LongControlSP.should_hold_stopping(self, CS, a_target):
+      if output_accel > self.CP.stopAccel:
        output_accel = min(output_accel, 0.0)
        # TODO: can we just go straight to stopAccel?
        output_accel -= 1.0 * DT_CTRL  # m/s^2/s while trying to stop
@@ -9,7 +9,6 @@ from openpilot.common.swaglog import cloudlog
 # WARNING: imports outside of constants will not trigger a rebuild
 from openpilot.selfdrive.modeld.constants import index_function
 from openpilot.selfdrive.controls.radard import _LEAD_ACCEL_TAU
-from openpilot.sunnypilot.selfdrive.controls.lib.longitudinal_mpc_lib.long_mpc import LongitudinalMpcSP

 if __name__ == '__main__':  # generating code
  from acados.acados_template import AcadosModel, AcadosOcp, AcadosOcpSolver
@@ -214,9 +213,8 @@ def gen_long_ocp():
  return ocp


-class LongitudinalMpc(LongitudinalMpcSP):
+class LongitudinalMpc:
  def __init__(self, dt=DT_MDL):
-    LongitudinalMpcSP.__init__(self)
    self.dt = dt
    self.solver = AcadosOcpSolverCython(MODEL_NAME, ACADOS_SOLVER_TYPE, N)
    self.reset()
@@ -268,8 +266,7 @@ class LongitudinalMpc(LongitudinalMpcSP):
  def set_weights(self, prev_accel_constraint=True, personality=log.LongitudinalPersonality.standard):
    jerk_factor = get_jerk_factor(personality)
    a_change_cost = A_CHANGE_COST if prev_accel_constraint else 0
-    cost_weights = [X_EGO_OBSTACLE_COST, X_EGO_COST, V_EGO_COST, A_EGO_COST, jerk_factor * a_change_cost,
-                    LongitudinalMpcSP.scale_jerk_cost(self, jerk_factor * J_EGO_COST)]
+    cost_weights = [X_EGO_OBSTACLE_COST, X_EGO_COST, V_EGO_COST, A_EGO_COST, jerk_factor * a_change_cost, jerk_factor * J_EGO_COST]
    constraint_cost_weights = [LIMIT_COST, LIMIT_COST, LIMIT_COST, DANGER_ZONE_COST]
    self.set_cost_weights(cost_weights, constraint_cost_weights)

@@ -329,7 +326,7 @@ class LongitudinalMpc(LongitudinalMpcSP):
    # when the leads are no factor.
    v_lower = v_ego + (T_IDXS * CRUISE_MIN_ACCEL * 1.05)
    # TODO does this make sense when max_a is negative?
-    v_upper = v_ego + (T_IDXS * self.cruise_accel_max(CRUISE_MAX_ACCEL) * 1.05)
+    v_upper = v_ego + (T_IDXS * CRUISE_MAX_ACCEL * 1.05)
    v_cruise_clipped = np.clip(v_cruise * np.ones(N+1), v_lower, v_upper)
    cruise_obstacle = np.cumsum(T_DIFFS * v_cruise_clipped) + get_safe_obstacle_distance(v_cruise_clipped, t_follow)

@@ -343,7 +340,6 @@ class LongitudinalMpc(LongitudinalMpcSP):

    self.params[:,0] = ACCEL_MIN
    self.params[:,1] = ACCEL_MAX
-    LongitudinalMpcSP.apply_accel_limits(self)
    self.params[:,2] = np.min(x_obstacles, axis=1)
    self.params[:,3] = np.copy(self.a_prev)
    self.params[:,4] = t_follow
@@ -363,7 +359,6 @@ class LongitudinalMpc(LongitudinalMpcSP):
    self.solver.constraints_set(0, "ubx", self.x0)

    self.solution_status = self.solver.solve()
-    LongitudinalMpcSP.save_solution_status(self)
    self.solve_time = float(self.solver.get_stats('time_tot')[0])

    for i in range(N+1):
@@ -51,7 +51,7 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
  def __init__(self, CP, CP_SP, init_v=0.0, init_a=0.0, dt=DT_MDL):
    self.CP = CP
    self.mpc = LongitudinalMpc(dt=dt)
-    LongitudinalPlannerSP.__init__(self, self.CP, CP_SP, self.mpc, dt=dt)
+    LongitudinalPlannerSP.__init__(self, self.CP, CP_SP, self.mpc)
    self.fcw = False
    self.dt = dt
    self.allow_throttle = True
@@ -110,13 +110,13 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
      clipped_accel_coast = max(accel_coast, accel_clip[0])
      clipped_accel_coast_interp = np.interp(v_ego, [MIN_ALLOW_THROTTLE_SPEED, MIN_ALLOW_THROTTLE_SPEED*2], [accel_clip[1], clipped_accel_coast])
      accel_clip[1] = min(accel_clip[1], clipped_accel_coast_interp)
+
    # Get new v_cruise and a_desired from Smart Cruise Control and Speed Limit Assist
    v_cruise, self.a_desired = LongitudinalPlannerSP.update_targets(self, sm, self.v_desired_filter.x, self.a_desired, v_cruise)
+
    if force_slow_decel:
      v_cruise = 0.0

-    is_e2e, v_cruise = LongitudinalPlannerSP.update_accel_controller(self, sm, v_cruise, prev_accel_constraint, accel_clip[1], reset_state)
-
    self.mpc.set_weights(prev_accel_constraint, personality=sm['selfdriveState'].personality)
    self.mpc.set_cur_state(self.v_desired_filter.x, self.a_desired)
    self.mpc.update(sm['radarState'], v_cruise, personality=sm['selfdriveState'].personality)
@@ -135,13 +135,13 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
    self.a_desired = float(np.interp(self.dt, CONTROL_N_T_IDX, self.a_desired_trajectory))
    self.v_desired_filter.x = self.v_desired_filter.x + self.dt * (self.a_desired + a_prev) / 2.0

-    action_t = self.CP.longitudinalActuatorDelay + DT_MDL
+    action_t =  self.CP.longitudinalActuatorDelay + DT_MDL
    output_a_target_mpc, output_should_stop_mpc = get_accel_from_plan(self.v_desired_trajectory, self.a_desired_trajectory, CONTROL_N_T_IDX,
                                                                        action_t=action_t)
    output_a_target_e2e = sm['modelV2'].action.desiredAcceleration
    output_should_stop_e2e = sm['modelV2'].action.shouldStop

-    if is_e2e:
+    if self.is_e2e(sm):
      output_a_target = min(output_a_target_e2e, output_a_target_mpc)
      self.output_should_stop = output_should_stop_e2e or output_should_stop_mpc
      if output_a_target < output_a_target_mpc:
@@ -149,7 +149,6 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
    else:
      output_a_target = output_a_target_mpc
      self.output_should_stop = output_should_stop_mpc
-    self.output_should_stop = LongitudinalPlannerSP.update_should_stop(self, self.output_should_stop)

    for idx in range(2):
      accel_clip[idx] = np.clip(accel_clip[idx], self.prev_accel_clip[idx] - 0.05, self.prev_accel_clip[idx] + 0.05)
@@ -159,7 +158,7 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
  def publish(self, sm, pm):
    plan_send = messaging.new_message('longitudinalPlan')

-    plan_send.valid = sm.all_checks()
+    plan_send.valid = sm.all_checks(service_list=['carState', 'controlsState', 'selfdriveState', 'radarState'])

    longitudinalPlan = plan_send.longitudinalPlan
    longitudinalPlan.modelMonoTime = sm.logMonoTime['modelV2']
@@ -29,19 +29,19 @@ def main():
  longitudinal_planner = LongitudinalPlanner(CP, CP_SP)
  pm = messaging.PubMaster(['longitudinalPlan', 'driverAssistance', 'longitudinalPlanSP'])
  sm = messaging.SubMaster(['carControl', 'carState', 'controlsState', 'liveParameters', 'radarState', 'modelV2', 'selfdriveState',
-                            'liveMapDataSP', 'carStateSP', 'selfdriveStateSP', gps_location_service],
-                           poll='modelV2', ignore_alive=ignore_services, ignore_avg_freq=ignore_services, ignore_valid=ignore_services)
+                            'liveMapDataSP', 'carStateSP', gps_location_service],
+                           poll='carState', ignore_alive=ignore_services, ignore_avg_freq=ignore_services, ignore_valid=ignore_services)

  while True:
    sm.update()
-    longitudinal_planner.sla.update_buttons(sm['selfdriveStateSP'].buttonsReleaseToggle)
+    longitudinal_planner.sla.update_car_state(sm['carState'])
    if sm.updated['modelV2']:
      longitudinal_planner.update(sm)
      longitudinal_planner.publish(sm, pm)

      ldw.update(sm.frame, sm['modelV2'], sm['carState'], sm['carControl'])
      msg = messaging.new_message('driverAssistance')
-      msg.valid = sm.all_checks()
+      msg.valid = sm.all_checks(['carState', 'carControl', 'modelV2', 'liveParameters'])
      msg.driverAssistance.leftLaneDeparture = ldw.left
      msg.driverAssistance.rightLaneDeparture = ldw.right
      pm.send('driverAssistance', msg)
@@ -30,7 +30,6 @@ from openpilot.sunnypilot import get_sanitize_int_param
 from openpilot.sunnypilot.selfdrive.car.car_specific import CarSpecificEventsSP
 from openpilot.sunnypilot.selfdrive.car.cruise_helpers import CruiseHelper
 from openpilot.sunnypilot.selfdrive.car.intelligent_cruise_button_management.controller import IntelligentCruiseButtonManagement
-from openpilot.sunnypilot.selfdrive.selfdrived.button_state_tracker import ButtonStateTracker
 from openpilot.sunnypilot.selfdrive.selfdrived.events import EventsSP

 REPLAY = "REPLAY" in os.environ
@@ -178,7 +177,6 @@ class SelfdriveD(CruiseHelper):
    self.car_events_sp = CarSpecificEventsSP(self.CP, self.CP_SP)

    CruiseHelper.__init__(self, self.CP)
-    self.button_state_tracker = ButtonStateTracker()

  def update_events(self, CS):
    """Compute onroadEvents from carState"""
@@ -327,16 +325,9 @@ class SelfdriveD(CruiseHelper):
    # Handle lane change
    if self.sm['modelV2'].meta.laneChangeState == LaneChangeState.preLaneChange:
      direction = self.sm['modelV2'].meta.laneChangeDirection
-      mdv2sp = self.sm['modelDataV2SP']
-
      if (CS.leftBlindspot and direction == LaneChangeDirection.left) or \
-            (CS.rightBlindspot and direction == LaneChangeDirection.right):
+         (CS.rightBlindspot and direction == LaneChangeDirection.right):
        self.events.add(EventName.laneChangeBlocked)
-
-      elif (mdv2sp.leftLaneChangeEdgeBlock and direction == LaneChangeDirection.left) or \
-           (mdv2sp.rightLaneChangeEdgeBlock and direction == LaneChangeDirection.right):
-        self.events_sp.add(custom.OnroadEventSP.EventName.laneChangeRoadEdge)
-
      else:
        if direction == LaneChangeDirection.left:
          self.events.add(EventName.preLaneChangeLeft)
@@ -606,8 +597,6 @@ class SelfdriveD(CruiseHelper):
    icbm.sendButton = self.icbm.cruise_button
    icbm.vTarget = self.icbm.v_target

-    self.button_state_tracker.publish(ss_sp)
-
    self.pm.send('selfdriveStateSP', ss_sp_msg)

    # onroadEventsSP - logged every second or on change
@@ -627,7 +616,6 @@ class SelfdriveD(CruiseHelper):
      self.mads.update(CS)
    self.update_alerts(CS)

-    self.button_state_tracker.update(CS)
    self.publish_selfdriveState(CS)

    self.CS_prev = CS
@@ -11,14 +11,6 @@ from openpilot.selfdrive.controls.lib.longitudinal_planner import LongitudinalPl
 from openpilot.selfdrive.controls.radard import _LEAD_ACCEL_TAU


-class PlannerSM(dict):
-  def __init__(self, radar_frame: int, services: dict):
-    super().__init__(services)
-    self.logMonoTime = {"radarState": radar_frame}
-    self.valid = {"radarState": True}
-    self.alive = {"radarState": True}
-
-
 class Plant:
  messaging_initialized = False

@@ -140,7 +132,7 @@ class Plant:
    car_control.carControl.orientationNED = [0., float(pitch), 0.]

    # ******** get controlsState messages for plotting ***
-    sm = PlannerSM(self.rk.frame, {'radarState': radar.radarState,
+    sm = {'radarState': radar.radarState,
          'carState': car_state.carState,
          'carControl': car_control.carControl,
          'controlsState': control.controlsState,
@@ -149,7 +141,7 @@ class Plant:
          'modelV2': model.modelV2,
          'carStateSP': car_state_sp.carStateSP,
          'liveMapDataSP': live_map_data_sp.liveMapDataSP,
-          'gpsLocation': gps_data.gpsLocation})
+          'gpsLocation': gps_data.gpsLocation}
    self.planner.update(sm)
    self.acceleration = self.planner.output_a_target
    if self.planner.output_should_stop:
@@ -27,12 +27,6 @@ DESCRIPTIONS = {
    "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."
  ),
-  "AccelPersonalityEnabled": tr_noop(
-    "Begin slowing early and smoothly behind lead vehicles. Stock longitudinal control retains braking and stopping authority."
-  ),
-  "AccelPersonality": tr_noop(
-    "Eco slows earliest and recovers gently, Normal balances comfort and response, and Sport reacts and recovers more quickly."
-  ),
  "IsLdwEnabled": tr_noop(
    "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)."
@@ -112,24 +106,6 @@ class TogglesLayout(Widget):
      icon="speed_limit.png"
    )

-    self._accel_personality_enabled = toggle_item(
-      lambda: tr("Enable Accel Controller"),
-      lambda: tr(DESCRIPTIONS["AccelPersonalityEnabled"]),
-      self._params.get_bool("AccelPersonalityEnabled"),
-      callback=self._set_accel_personality_enabled,
-      icon="speed_limit.png",
-    )
-
-    self._accel_personality_setting = multiple_button_item(
-      lambda: tr("Acceleration Profile"),
-      lambda: tr(DESCRIPTIONS["AccelPersonality"]),
-      buttons=[lambda: tr("Eco"), lambda: tr("Normal"), lambda: tr("Sport")],
-      button_width=300,
-      callback=self._set_accel_personality,
-      selected_index=self._params.get("AccelPersonality", return_default=True),
-      icon="speed_limit.png"
-    )
-
    self._toggles = {}
    self._locked_toggles = set()
    for param, (title, desc, icon, needs_restart) in self._toggle_defs.items():
@@ -159,11 +135,9 @@ class TogglesLayout(Widget):

      self._toggles[param] = toggle

-      # insert longitudinal personality and Accel Controller settings after NDOG toggle
+      # insert longitudinal personality after NDOG toggle
      if param == "DisengageOnAccelerator":
        self._toggles["LongitudinalPersonality"] = self._long_personality_setting
-        self._toggles["AccelPersonalityEnabled"] = self._accel_personality_enabled
-        self._toggles["AccelPersonality"] = self._accel_personality_setting

    self._update_experimental_mode_icon()
    self._scroller = Scroller(list(self._toggles.values()), line_separator=True, spacing=0)
@@ -184,7 +158,6 @@ class TogglesLayout(Widget):

  def _update_toggles(self):
    ui_state.update_params()
-    accel_personality_enabled = self._params.get_bool("AccelPersonalityEnabled")

    e2e_description = tr(
      "sunnypilot defaults to driving in chill mode. Experimental mode enables alpha-level features that aren't ready for chill mode. " +
@@ -203,15 +176,11 @@ class TogglesLayout(Widget):
        self._toggles["ExperimentalMode"].action_item.set_enabled(True)
        self._toggles["ExperimentalMode"].set_description(e2e_description)
        self._long_personality_setting.action_item.set_enabled(True)
-        self._accel_personality_enabled.action_item.set_enabled(True)
-        self._accel_personality_setting.action_item.set_enabled(accel_personality_enabled)
      else:
        # no long for now
        self._toggles["ExperimentalMode"].action_item.set_enabled(False)
        self._toggles["ExperimentalMode"].action_item.set_state(False)
        self._long_personality_setting.action_item.set_enabled(False)
-        self._accel_personality_enabled.action_item.set_enabled(False)
-        self._accel_personality_setting.action_item.set_enabled(False)
        self._params.remove("ExperimentalMode")

        unavailable = tr("Experimental mode is currently unavailable on this car since the car's stock ACC is used for longitudinal control.")
@@ -234,10 +203,6 @@ class TogglesLayout(Widget):
    # refresh toggles from params to mirror external changes
    for param in self._toggle_defs:
      self._toggles[param].action_item.set_state(self._params.get_bool(param))
-    self._accel_personality_enabled.action_item.set_state(accel_personality_enabled)
-    self._accel_personality_setting.action_item.set_selected_button(
-      self._params.get("AccelPersonality", return_default=True)
-    )

    # these toggles need restart, block while engaged
    for toggle_def in self._toggle_defs:
@@ -282,10 +247,3 @@ class TogglesLayout(Widget):

  def _set_longitudinal_personality(self, button_index: int):
    self._params.put("LongitudinalPersonality", button_index, block=True)
-
-  def _set_accel_personality(self, button_index: int):
-    self._params.put("AccelPersonality", button_index, block=True)
-
-  def _set_accel_personality_enabled(self, state: bool):
-    self._params.put_bool("AccelPersonalityEnabled", state, block=True)
-    self._accel_personality_setting.action_item.set_enabled(state and ui_state.has_longitudinal_control)
@@ -13,7 +13,6 @@ from openpilot.system.ui.lib.application import gui_app

 if gui_app.sunnypilot_ui():
  from openpilot.selfdrive.ui.sunnypilot.mici.layouts.settings import SettingsLayoutSP as SettingsLayout
-  from openpilot.selfdrive.ui.sunnypilot.mici.layouts.onroad import OnroadViewContainerSP as AugmentedRoadView

 ONROAD_DELAY = 2.5  # seconds

@@ -119,15 +118,13 @@ class MiciMainLayout(Scroller):

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

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

  def _on_interactive_timeout(self):
@@ -14,8 +14,6 @@ class TogglesLayoutMici(NavScroller):
    super().__init__()

    self._personality_toggle = BigMultiParamToggle("driving personality", "LongitudinalPersonality", ["aggressive", "standard", "relaxed"])
-    self._accel_personality_enabled = BigParamControl("enable accel controller", "AccelPersonalityEnabled")
-    self._accel_personality_toggle = BigMultiParamToggle("acceleration profile", "AccelPersonality", ["eco", "normal", "sport"])
    self._experimental_btn = BigParamControl("experimental mode", "ExperimentalMode")
    is_metric_toggle = BigParamControl("use metric units", "IsMetric")
    ldw_toggle = BigParamControl("lane departure warnings", "IsLdwEnabled")
@@ -26,8 +24,6 @@ class TogglesLayoutMici(NavScroller):

    self._scroller.add_widgets([
      self._personality_toggle,
-      self._accel_personality_enabled,
-      self._accel_personality_toggle,
      self._experimental_btn,
      is_metric_toggle,
      ldw_toggle,
@@ -40,7 +36,6 @@ class TogglesLayoutMici(NavScroller):
    # Toggle lists
    self._refresh_toggles = (
      ("ExperimentalMode", self._experimental_btn),
-      ("AccelPersonalityEnabled", self._accel_personality_enabled),
      ("IsMetric", is_metric_toggle),
      ("IsLdwEnabled", ldw_toggle),
      ("AlwaysOnDM", always_on_dm_toggle),
@@ -50,9 +45,6 @@ class TogglesLayoutMici(NavScroller):
    )

    enable_openpilot.set_enabled(lambda: not ui_state.engaged)
-    self._accel_personality_toggle.set_enabled(
-      lambda: ui_state.has_longitudinal_control and ui_state.params.get_bool("AccelPersonalityEnabled")
-    )
    record_front.set_enabled(False if ui_state.params.get_bool("RecordFrontLock") else (lambda: not ui_state.engaged))
    record_mic.set_enabled(lambda: not ui_state.engaged)

@@ -83,18 +75,13 @@ class TogglesLayoutMici(NavScroller):
      if ui_state.has_longitudinal_control:
        self._experimental_btn.set_visible(True)
        self._personality_toggle.set_visible(True)
-        self._accel_personality_enabled.set_visible(True)
-        self._accel_personality_toggle.set_visible(True)
      else:
        # no long for now
        self._experimental_btn.set_visible(False)
        self._experimental_btn.set_checked(False)
        self._personality_toggle.set_visible(False)
-        self._accel_personality_enabled.set_visible(False)
-        self._accel_personality_toggle.set_visible(False)
        ui_state.params.remove("ExperimentalMode")

    # Refresh toggles from params to mirror external changes
    for key, item in self._refresh_toggles:
      item.set_checked(ui_state.params.get_bool(key))
-    self._accel_personality_toggle.refresh()
@@ -383,18 +383,13 @@ class BigMultiParamToggle(BigMultiToggle):
    self._load_value()

  def _load_value(self):
-    value = self._params.get(self._param, return_default=True)
-    index = value if isinstance(value, int) else 0
-    self.set_value(self._options[max(0, min(index, len(self._options) - 1))])
+    self.set_value(self._options[self._params.get(self._param) or 0])

  def _handle_mouse_release(self, mouse_pos: MousePos):
    super()._handle_mouse_release(mouse_pos)
    new_idx = self._options.index(self.value)
    self._params.put(self._param, new_idx)

-  def refresh(self):
-    self._load_value()
-

 class BigParamControl(BigToggle):
  def __init__(self, text: str, param: str, toggle_callback: Callable | None = None):
@@ -43,7 +43,7 @@ class ModelsLayout(Widget):
    self._initialize_items()

    self.clear_cache_item.action_item.set_value(f"{self.calculate_cache_size():.2f} MB")
-    for ctrl, key in [(self.lane_turn_value_control, "LaneTurnValue"), (self.delay_control, "LagdToggleDelay"), (self.camera_offset, "CameraOffset")]:
+    for ctrl, key in [(self.lane_turn_value_control, "LaneTurnValue"), (self.delay_control, "LagdToggleDelay")]:
      ctrl.action_item.set_value(int(float(ui_state.params.get(key, return_default=True)) * 100))

    self._scroller = Scroller(self.items, line_separator=True, spacing=0)
@@ -93,14 +93,9 @@ class ModelsLayout(Widget):

    self.lagd_toggle = toggle_item_sp(tr("Live Learning Steer Delay"), "", param="LagdToggle")

-    self.camera_offset = option_item_sp(tr("Adjust Camera Offset"), "CameraOffset", -35, 35,
-                                        tr("Virtually shift camera's perspective to move model's center to Left(+ values) or Right (- values)"),
-                                        1, None, True, "", style.BUTTON_ACTION_WIDTH, None, True,
-                                        lambda v: f"{v / 100:.2f} m")
-
    self.items = [self.current_model_item, self.cancel_download_item, self.supercombo_label, self.vision_label,
-                  self.policy_label, self.off_policy_label, self.on_policy_label, self.refresh_item, self.clear_cache_item,
-                  self.lane_turn_desire_toggle, self.lane_turn_value_control, self.lagd_toggle, self.delay_control, self.camera_offset]
+                  self.policy_label, self.off_policy_label, self.on_policy_label, self.refresh_item, self.clear_cache_item, self.lane_turn_desire_toggle,
+                  self.lane_turn_value_control, self.lagd_toggle, self.delay_control]

  def _update_lagd_description(self, lagd_toggle: bool):
    desc = tr("Enable this for the car to learn and adapt its steering response time. Disable to use a fixed steering response time. " +
@@ -237,7 +232,6 @@ class ModelsLayout(Widget):
    advanced_controls: bool = ui_state.params.get_bool("ShowAdvancedControls")
    turn_desire: bool = ui_state.params.get_bool("LaneTurnDesire")
    live_delay: bool = ui_state.params.get_bool("LagdToggle")
-    camera_offset: bool = ui_state.params.get("ModelManager_ActiveBundle") is not None

    self.lane_turn_desire_toggle.action_item.set_state(turn_desire)
    self.lane_turn_value_control.set_visible(turn_desire and advanced_controls)
@@ -246,7 +240,6 @@ class ModelsLayout(Widget):
    new_step = int(round(100 / CV.MPH_TO_KPH)) if ui_state.is_metric else 100
    if self.lane_turn_value_control.action_item is not None and self.lane_turn_value_control.action_item.value_change_step != new_step:
      self.lane_turn_value_control.action_item.value_change_step = new_step
-    self.camera_offset.set_visible(camera_offset)

    self._update_lagd_description(live_delay)
    self.model_manager = ui_state.sm["modelManagerSP"]
@@ -51,17 +51,11 @@ class LaneChangeSettingsLayout(Widget):
      description=lambda: tr("Toggle to enable a delay timer for seamless lane changes when blind spot monitoring " +
                             "(BSM) detects a obstructing vehicle, ensuring safe maneuvering."),
    )
-    self._road_edge_block = toggle_item_sp(
-      param="RoadEdgeLaneChangeEnabled",
-      title=lambda: tr("Block Lane Change: Road Edge Detection"),
-      description=lambda: tr("Blocks the lane change if the model sees a road edge on your signaled side."),
-    )

    items = [
      self._lane_change_timer,
      LineSeparatorSP(40),
      self._bsm_delay,
-      self._road_edge_block,
    ]

    return items
@@ -7,7 +7,7 @@ See the LICENSE.md file in the root directory for more details.
 from collections.abc import Callable
 import pyray as rl

-from opendbc.sunnypilot.car.tesla.values import MadsScreenButtonType, TeslaFlagsSP
+from opendbc.sunnypilot.car.tesla.values import TeslaFlagsSP
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.sunnypilot.mads.helpers import MadsSteeringModeOnBrake
 from openpilot.system.ui.lib.multilang import tr, tr_noop
@@ -96,10 +96,7 @@ class MadsSettingsLayout(Widget):
    if brand == "rivian":
      return True
    elif brand == "tesla":
-      if ui_state.CP_SP is None or not ui_state.CP_SP.flags & TeslaFlagsSP.HAS_VEHICLE_BUS:
-        return True
-      screen_button = int(ui_state.params.get("TeslaMadsScreenButton", return_default=True))
-      return screen_button == MadsScreenButtonType.OFF
+      return not (ui_state.CP_SP is not None and ui_state.CP_SP.flags & TeslaFlagsSP.HAS_VEHICLE_BUS)
    return False

  def _update_steering_mode_description(self, button_index: int):
@@ -4,11 +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.
 """
-from opendbc.sunnypilot.car.tesla.values import TeslaFlagsSP
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.vehicle.brands.base import BrandSettings
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.ui.lib.multilang import tr
-from openpilot.system.ui.sunnypilot.widgets.list_view import multiple_button_item_sp, toggle_item_sp
+from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp

 COOP_STEERING_MIN_KMH = 23
 OEM_STEERING_MIN_KMH = 48
@@ -19,14 +18,7 @@ class TeslaSettings(BrandSettings):
  def __init__(self):
    super().__init__()
    self.coop_steering_toggle = toggle_item_sp(tr("Cooperative Steering (Beta)"), "", param="TeslaCoopSteering")
-    self.mads_screen_button = multiple_button_item_sp(
-      title=lambda: tr("MADS Screen Activation"),
-      description="",
-      buttons=[lambda: tr("Off"), lambda: tr("3-Finger"), lambda: tr("4-Finger"), lambda: tr("5-Finger")],
-      param="TeslaMadsScreenButton",
-      inline=False,
-    )
-    self.items = [self.coop_steering_toggle, self.mads_screen_button]
+    self.items = [self.coop_steering_toggle]

  def update_settings(self):
    is_metric = ui_state.is_metric
@@ -49,18 +41,3 @@ class TeslaSettings(BrandSettings):

    self.coop_steering_toggle.set_description(coop_steering_desc)
    self.coop_steering_toggle.action_item.set_enabled(ui_state.is_offroad())
-
-    has_vehicle_bus = ui_state.CP_SP is not None and bool(ui_state.CP_SP.flags & TeslaFlagsSP.HAS_VEHICLE_BUS)
-    self.mads_screen_button.set_visible(has_vehicle_bus)
-
-    mads_screen_button_desc = (
-      f"{tr('Use a multi-finger press on the infotainment screen to toggle MADS.')} " +
-      f"{tr('This allows the use of full MADS functionality when enabled.')}<br><br>" +
-      f"{tr('Selecting a higher finger count may reduce accidental activations.')}<br><br>" +
-      f"<b>{tr('Note: Setting this to Off will reset your MADS settings to default.')}</b>"
-    )
-    if not ui_state.is_offroad():
-      mads_screen_button_disabled_msg = tr("Enable \"Always Offroad\" in Device panel, or turn vehicle off to change.")
-      mads_screen_button_desc = f"<b>{mads_screen_button_disabled_msg}</b><br><br>{mads_screen_button_desc}"
-    self.mads_screen_button.set_description(mads_screen_button_desc)
-    self.mads_screen_button.action_item.set_enabled(ui_state.is_offroad())
@@ -1,13 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-from openpilot.selfdrive.ui.mici.layouts.main import MiciMainLayout
-
-
-class MiciMainLayoutSP(MiciMainLayout):
-  def _should_auto_scroll_to_onroad(self) -> bool:
-    return not self._onroad_layout.is_on_info_panel()
@@ -1,63 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import pyray as rl
-from openpilot.system.ui.lib.application import gui_app
-from openpilot.selfdrive.ui.sunnypilot.mici.widgets.scroller_sp import ScrollerSP
-from openpilot.selfdrive.ui.sunnypilot.mici.onroad.augmented_road_view import AugmentedRoadViewSP
-from openpilot.selfdrive.ui.sunnypilot.mici.layouts.onroad_info_panel import OnroadInfoPanel
-
-CONFIDENCE_BALL_VISIBLE_RATIO = 0.4
-HORIZONTAL_SETTLE_PX = 5
-HORIZONTAL_RESET_RATIO = 0.5
-
-
-class OnroadViewContainerSP(ScrollerSP):
-  def __init__(self, bookmark_callback=None):
-    super().__init__(horizontal=False, snap_items=True, spacing=0, pad=0, scroll_indicator=False, edge_shadows=False)
-    self.road_view = AugmentedRoadViewSP(bookmark_callback=bookmark_callback)
-    self.onroad_info_panel = OnroadInfoPanel(bookmark_callback=bookmark_callback)
-
-    self._scroller.add_widgets([
-      self.road_view,
-      self.onroad_info_panel,
-    ])
-    self._scroller.set_reset_scroll_at_show(False)
-    self._scroller.set_scrolling_enabled(lambda: abs(self.rect.x) < HORIZONTAL_SETTLE_PX)
-
-    for child in (self.road_view, self.onroad_info_panel):
-      inner_touch_valid = child._touch_valid_callback
-      child.set_touch_valid_callback(
-        lambda inner=inner_touch_valid: self._touch_valid() and (inner() if inner else True)
-      )
-
-  def set_rect(self, rect: rl.Rectangle):
-    super().set_rect(rect)
-    self.road_view.set_rect(rect)
-    self.onroad_info_panel.set_rect(rect)
-    return self
-
-  def is_swiping_left(self) -> bool:
-    return self.road_view.is_swiping_left() or self.onroad_info_panel.is_swiping_left()
-
-  def set_click_callback(self, callback) -> None:
-    self.road_view.set_click_callback(callback)
-    self.onroad_info_panel.set_click_callback(callback)
-
-  def is_on_info_panel(self) -> bool:
-    """True when scrolled past halfway toward onroad_info_panel (used by main layout
-    to skip auto-pop-back-to-camera while user is reading the info panel)."""
-    return abs(self._scroller.scroll_panel.get_offset()) > self._rect.height / 2
-
-  def _render(self, rect: rl.Rectangle):
-    if abs(self.rect.x) > gui_app.width * HORIZONTAL_RESET_RATIO:
-      self._scroller.scroll_panel.set_offset(0)
-
-    vertical_offset = self._scroller.scroll_panel.get_offset()
-    show_ball = abs(vertical_offset) < rect.height * CONFIDENCE_BALL_VISIBLE_RATIO
-    self.road_view.set_show_confidence_ball(show_ball)
-
-    super()._render(rect)
@@ -1,324 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import pyray as rl
-from dataclasses import dataclass
-from openpilot.common.constants import CV
-from openpilot.common.filter_simple import FirstOrderFilter
-from openpilot.selfdrive.ui.ui_state import ui_state
-from openpilot.system.ui.lib.application import gui_app, FontWeight
-from openpilot.system.ui.lib.multilang import tr
-from openpilot.system.ui.lib.text_measure import measure_text_cached
-from openpilot.system.ui.lib.application import MousePos
-from openpilot.system.ui.widgets import Widget
-from openpilot.selfdrive.ui.mici.onroad.alert_renderer import AlertRenderer
-from openpilot.selfdrive.ui.mici.onroad.augmented_road_view import BookmarkIcon
-
-METER_TO_KM = 0.001
-METER_TO_MILE = 0.000621371
-
-
-@dataclass(frozen=True)
-class OnroadInfoPanelColors:
-  white: rl.Color = rl.WHITE
-  black: rl.Color = rl.BLACK
-  red: rl.Color = rl.Color(255, 0, 0, 255)
-  green: rl.Color = rl.Color(0, 255, 0, 255)
-  grey: rl.Color = rl.Color(190, 195, 190, 255)
-  light_grey: rl.Color = rl.Color(200, 200, 200, 255)
-  dark_grey: rl.Color = rl.Color(100, 100, 100, 255)
-  bg_dark: rl.Color = rl.Color(0, 0, 0, 255)
-  card_bg: rl.Color = rl.Color(50, 50, 50, 200)
-  badge_bg: rl.Color = rl.Color(60, 60, 60, 255)
-
-
-COLORS = OnroadInfoPanelColors()
-
-
-class OnroadInfoPanel(Widget):
-  def __init__(self, bookmark_callback=None):
-    super().__init__()
-    self.speed_limit: float = 0.0
-    self.speed_limit_valid: bool = False
-    self.speed_limit_offset: float = 0.0
-    self.next_speed_limit: float = 0.0
-    self.next_speed_limit_distance: float = 0.0
-    self.road_name: str = ""
-    self.current_speed: float = 0.0
-    self.set_speed: float = 0.0
-    self.cruise_enabled: bool = False
-
-    self._sign_slide: float = 0.0
-
-    self._font_bold: rl.Font = gui_app.font(FontWeight.BOLD)
-    self._font_semi_bold: rl.Font = gui_app.font(FontWeight.SEMI_BOLD)
-    self._font_medium: rl.Font = gui_app.font(FontWeight.MEDIUM)
-
-    self._marquee_offset: float = 0.0
-    self._marquee_direction: int = 1
-    self._marquee_pause_timer: float = 0.0
-    self._marquee_speed: float = 40.0
-    self._marquee_pause_duration: float = 1.5
-
-    self._alert_renderer = AlertRenderer()
-    self._alert_alpha_filter = FirstOrderFilter(0, 0.05, 1 / gui_app.target_fps)
-
-    self._bookmark_icon = BookmarkIcon(bookmark_callback)
-
-  def is_swiping_left(self) -> bool:
-    return self._bookmark_icon.is_swiping_left()
-
-  def _handle_mouse_release(self, mouse_pos: MousePos) -> None:
-    # Mirror stock AugmentedRoadView: suppress click while bookmark gesture active
-    if not self._bookmark_icon.interacting():
-      super()._handle_mouse_release(mouse_pos)
-
-  def _update_state(self) -> None:
-    sm = ui_state.sm
-    speed_conv = CV.MS_TO_KPH if ui_state.is_metric else CV.MS_TO_MPH
-
-    if sm.valid["longitudinalPlanSP"]:
-      lp_sp = sm["longitudinalPlanSP"]
-      resolver = lp_sp.speedLimit.resolver
-      self.speed_limit = resolver.speedLimit * speed_conv
-      self.speed_limit_valid = resolver.speedLimitValid
-      self.speed_limit_offset = resolver.speedLimitOffset * speed_conv
-
-    if sm.valid["liveMapDataSP"]:
-      lmd = sm["liveMapDataSP"]
-      self.next_speed_limit = lmd.speedLimitAhead * speed_conv
-      self.next_speed_limit_distance = lmd.speedLimitAheadDistance
-      self.road_name = lmd.roadName
-
-    if sm.updated["carState"]:
-      self.current_speed = sm["carState"].vEgo * speed_conv
-
-    if sm.valid["carState"] and sm.valid["controlsState"]:
-      self.cruise_enabled = sm["carState"].cruiseState.enabled
-      v_cruise_cluster = sm["carState"].vCruiseCluster
-      set_speed_kph = sm["controlsState"].vCruiseDEPRECATED if v_cruise_cluster == 0.0 else v_cruise_cluster
-      self.set_speed = set_speed_kph * (METER_TO_MILE / METER_TO_KM) if not ui_state.is_metric else set_speed_kph
-
-  def _render(self, rect: rl.Rectangle) -> None:
-    self._update_state()
-
-    rl.draw_rectangle(int(rect.x), int(rect.y), int(rect.width), int(rect.height), COLORS.bg_dark)
-    margin = 20
-    mid_y = rect.y + rect.height / 2
-
-    left_x = rect.x + margin
-
-    if self.cruise_enabled:
-      unit = tr("MAX")
-      display_speed = self.set_speed
-    else:
-      unit = tr("km/h") if ui_state.is_metric else tr("MPH")
-      display_speed = self.current_speed
-
-    speed_val = str(round(display_speed))
-    if self.speed_limit_valid and display_speed > self.speed_limit:
-      speed_color = COLORS.red
-    else:
-      speed_color = COLORS.white
-
-    rl.draw_text_ex(self._font_semi_bold, unit, rl.Vector2(left_x, mid_y - 95), 38, 0, COLORS.grey)
-    rl.draw_text_ex(self._font_bold, speed_val, rl.Vector2(left_x, mid_y - 60), 110, 0, speed_color)
-
-    sign_width = 135
-    sign_height = 135 if ui_state.is_metric else 175
-
-    has_next = self.next_speed_limit > 0 and self.next_speed_limit != self.speed_limit
-    target_slide = 1.0 if has_next else 0.0
-    slide_speed = 3.0 * rl.get_frame_time()
-    if self._sign_slide < target_slide:
-      self._sign_slide = min(self._sign_slide + slide_speed, target_slide)
-    elif self._sign_slide > target_slide:
-      self._sign_slide = max(self._sign_slide - slide_speed, target_slide)
-
-    next_w = int(sign_width * 0.7)
-    next_h = int(sign_height * 0.7)
-    next_peek = int(next_w * 0.85) + 5
-    centered_x = rect.x + rect.width - sign_width - margin
-    shifted_x = rect.x + rect.width - sign_width - margin - next_peek
-    sign_x = centered_x + (shifted_x - centered_x) * self._sign_slide
-    sign_y = rect.y + (rect.height - sign_height) / 2
-
-    road_y = mid_y + 55
-    road_width = sign_x - left_x - margin
-    self._draw_road_name(left_x, road_y, road_width)
-
-    if has_next and self._sign_slide > 0.01:
-      next_val = str(round(self.next_speed_limit))
-      dist_str = self._format_distance(self.next_speed_limit_distance)
-      next_x = sign_x + sign_width - int(next_w * 0.15)
-      next_y = sign_y + (sign_height - next_h) / 2
-
-      next_speed_color = COLORS.black
-      if ui_state.is_metric:
-        self._draw_vienna_sign(next_x, next_y, next_w, next_h, next_val, next_speed_color, is_upcoming=True)
-      else:
-        self._draw_mutcd_sign(next_x, next_y, next_w, next_h, next_val, next_speed_color, is_upcoming=True)
-
-      dist_size = measure_text_cached(self._font_medium, dist_str, 24)
-      rl.draw_text_ex(self._font_medium, dist_str, rl.Vector2(next_x + next_w / 2 - dist_size.x / 2, next_y + next_h + 4), 24, 0, COLORS.grey)
-
-    self._draw_speed_limit_sign(sign_x, sign_y, sign_width, sign_height)
-
-    if self.speed_limit_offset != 0 and self.speed_limit_valid:
-      offset_val = str(abs(round(self.speed_limit_offset)))
-      badge_sz = 42
-      badge_x = sign_x + sign_width - badge_sz * 0.85
-      badge_y = sign_y - badge_sz * 0.25
-
-      if ui_state.is_metric:
-        badge_r = badge_sz / 2
-        badge_cx = badge_x + badge_r
-        badge_cy = badge_y + badge_r
-        rl.draw_circle(int(badge_cx), int(badge_cy), badge_r + 2, COLORS.dark_grey)
-        rl.draw_circle(int(badge_cx), int(badge_cy), badge_r, COLORS.badge_bg)
-        self._draw_text_centered(self._font_bold, offset_val, 24, rl.Vector2(badge_cx, badge_cy), COLORS.white)
-      else:
-        mutcd_badge_x = sign_x + sign_width - badge_sz * 0.65
-        mutcd_badge_y = sign_y - badge_sz * 0.50
-        badge_rect = rl.Rectangle(mutcd_badge_x, mutcd_badge_y, badge_sz, badge_sz)
-        rl.draw_rectangle_rounded(badge_rect, 0.25, 10, COLORS.badge_bg)
-        rl.draw_rectangle_rounded_lines_ex(badge_rect, 0.25, 10, 2, COLORS.dark_grey)
-        self._draw_text_centered(self._font_bold, offset_val, 24, rl.Vector2(mutcd_badge_x + badge_sz / 2, mutcd_badge_y + badge_sz / 2), COLORS.white)
-
-    # SCC
-    speed_size = measure_text_cached(self._font_bold, speed_val, 110)
-    scc_x = left_x + speed_size.x + 30
-    scc_y = mid_y - 50
-    self._draw_scc_icons(scc_x, scc_y)
-
-    self._bookmark_icon.render(rect)
-
-    if ui_state.started:
-      alert_obj, no_alert = self._alert_renderer.will_render()
-      self._alert_alpha_filter.update(0 if no_alert else 1)
-      alpha = self._alert_alpha_filter.x
-      if alpha > 0.01:
-        rl.draw_rectangle(int(rect.x), int(rect.y), int(rect.width), int(rect.height), rl.Color(0, 0, 0, int(150 * alpha)))
-      self._alert_renderer.render(rect)
-
-  def _draw_scc_icons(self, x: float, y: float) -> None:
-    sm = ui_state.sm
-    if not sm.valid["longitudinalPlanSP"]:
-      return
-    scc = sm["longitudinalPlanSP"].smartCruiseControl
-
-    box_w, box_h = 100, 36
-    gap = 6
-    drawn = 0
-
-    for label, active in [("SCC-V", scc.vision.active), ("SCC-M", scc.map.active)]:
-      if not active:
-        continue
-      bx = x
-      by = y + drawn * (box_h + gap)
-      rl.draw_rectangle_rounded(rl.Rectangle(bx, by, box_w, box_h), 0.3, 10, COLORS.green)
-      self._draw_text_centered(self._font_bold, label, 20, rl.Vector2(bx + box_w / 2, by + box_h / 2), COLORS.black)
-      drawn += 1
-
-  def _draw_speed_limit_sign(self, x: float, y: float, sign_width: float, sign_height: float) -> None:
-    speed_str = str(round(self.speed_limit)) if self.speed_limit_valid and self.speed_limit > 0 else "--"
-    speed_color = COLORS.black if not self.speed_limit_valid or self.current_speed <= self.speed_limit else COLORS.red
-
-    if ui_state.is_metric:
-      self._draw_vienna_sign(x, y, sign_width, sign_height, speed_str, speed_color, is_upcoming=False)
-    else:
-      self._draw_mutcd_sign(x, y, sign_width, sign_height, speed_str, speed_color, is_upcoming=False)
-
-  def _draw_road_name(self, x: float, y: float, width: float) -> None:
-    road_display = self.road_name if self.road_name else "--"
-    font_size = 30
-    road_size = measure_text_cached(self._font_semi_bold, road_display, font_size)
-    text_width = road_size.x
-
-    if text_width <= width:
-      self._marquee_offset = 0.0
-      self._marquee_direction = 1
-      self._marquee_pause_timer = 0.0
-      rl.draw_text_ex(self._font_semi_bold, road_display, rl.Vector2(x, y), font_size, 0, COLORS.white)
-    else:
-      overflow = text_width - width
-      dt = rl.get_frame_time()
-
-      if self._marquee_pause_timer > 0:
-        self._marquee_pause_timer -= dt
-      else:
-        self._marquee_offset += self._marquee_direction * self._marquee_speed * dt
-
-        if self._marquee_offset >= overflow:
-          self._marquee_offset = overflow
-          self._marquee_direction = -1
-          self._marquee_pause_timer = self._marquee_pause_duration
-        elif self._marquee_offset <= 0:
-          self._marquee_offset = 0
-          self._marquee_direction = 1
-          self._marquee_pause_timer = self._marquee_pause_duration
-
-      rl.begin_scissor_mode(int(x), int(y), int(width), int(road_size.y + 4))
-      text_pos = rl.Vector2(x - self._marquee_offset, y)
-      rl.draw_text_ex(self._font_semi_bold, road_display, text_pos, font_size, 0, COLORS.white)
-      rl.end_scissor_mode()
-
-  def _draw_vienna_sign(self, x: float, y: float, width: float, height: float, speed_str: str, speed_color: rl.Color, is_upcoming: bool = False) -> None:
-    center = rl.Vector2(x + width / 2, y + height / 2)
-    outer_radius = min(width, height) / 2
-
-    rl.draw_circle_v(center, outer_radius, COLORS.white)
-    ring_width = outer_radius * 0.18
-    rl.draw_ring(center, outer_radius - ring_width, outer_radius, 0, 360, 36, COLORS.red)
-
-    font_size = outer_radius * (0.7 if len(speed_str) >= 3 else 0.9)
-    text_size = measure_text_cached(self._font_bold, speed_str, int(font_size))
-    text_pos = rl.Vector2(center.x - text_size.x / 2, center.y - text_size.y / 2)
-    rl.draw_text_ex(self._font_bold, speed_str, text_pos, font_size, 0, speed_color)
-
-  def _draw_mutcd_sign(self, x: float, y: float, width: float, height: float, speed_str: str, speed_color: rl.Color, is_upcoming: bool = False) -> None:
-    sign_rect = rl.Rectangle(x, y, width, height)
-    rl.draw_rectangle_rounded(sign_rect, 0.35, 10, COLORS.white)
-
-    inset = max(4, width * 0.05)
-    inner_rect = rl.Rectangle(x + inset, y + inset, width - inset * 2, height - inset * 2)
-    outer_radius = 0.35 * width / 2.0
-    inner_radius = outer_radius - inset
-    inner_roundness = inner_radius / (inner_rect.width / 2.0)
-    rl.draw_rectangle_rounded_lines_ex(inner_rect, inner_roundness, 10, 3, COLORS.black)
-
-    mid_x = x + width / 2
-    label_size = max(18, int(width * 0.26))
-    if is_upcoming:
-      self._draw_text_centered(self._font_bold, tr("AHEAD"), label_size, rl.Vector2(mid_x, y + height * 0.27), COLORS.black)
-    else:
-      self._draw_text_centered(self._font_bold, tr("SPEED"), label_size, rl.Vector2(mid_x, y + height * 0.20), COLORS.black)
-      self._draw_text_centered(self._font_bold, tr("LIMIT"), label_size, rl.Vector2(mid_x, y + height * 0.40), COLORS.black)
-
-    speed_font_size = int(width * 0.52) if len(speed_str) >= 3 else int(width * 0.62)
-    self._draw_text_centered(self._font_bold, speed_str, speed_font_size, rl.Vector2(mid_x, y + height * 0.72), speed_color)
-
-  def _draw_text_centered(self, font, text, size, pos_center, color):
-    sz = measure_text_cached(font, text, size)
-    rl.draw_text_ex(font, text, rl.Vector2(pos_center.x - sz.x / 2, pos_center.y - sz.y / 2), size, 0, color)
-
-  def _format_distance(self, distance: float) -> str:
-    if ui_state.is_metric:
-      if distance < 50:
-        return tr("Near")
-      if distance >= 1000:
-        return f"{distance * METER_TO_KM:.1f}" + tr("km")
-      if distance < 200:
-        rounded = max(10, int(distance / 10) * 10)
-      else:
-        rounded = int(distance / 100) * 100
-      return str(rounded) + tr("m")
-    else:
-      distance_mi = distance * METER_TO_MILE
-      if distance_mi < 0.1:
-        return tr("Near")
-      return f"{distance_mi:.1f}" + tr("mi")
@@ -1,30 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import pyray as rl
-from openpilot.selfdrive.ui.mici.onroad.augmented_road_view import AugmentedRoadView
-
-
-class _SuppressedConfidenceBall:
-  def render(self, *_):
-    pass
-
-
-class AugmentedRoadViewSP(AugmentedRoadView):
-  def __init__(self, **kwargs):
-    super().__init__(**kwargs)
-    self._show_confidence_ball: bool = True
-    self._real_confidence_ball = self._confidence_ball
-    self._confidence_ball = _SuppressedConfidenceBall()
-
-  def set_show_confidence_ball(self, show: bool) -> None:
-    self._show_confidence_ball = show
-
-  def _render(self, rect: rl.Rectangle) -> None:
-    super()._render(rect)
-    if self._show_confidence_ball:
-      self._real_confidence_ball.render(self.rect)
@@ -1,34 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import pyray as rl
-from openpilot.system.ui.lib.application import MouseEvent
-from openpilot.system.ui.lib.scroll_panel2 import GuiScrollPanel2, ScrollState
-
-
-class GuiScrollPanel2SP(GuiScrollPanel2):
-  """Reject orthogonal-dominant drags so nested scrollers (outer horizontal +
-  inner vertical) don't both engage on a slightly diagonal swipe.
-
-  Implemented as a post-super state rollback rather than reimplementing the
-  PRESSED state machine — keeps stock behaviour authoritative."""
-
-  def _handle_mouse_event(self, mouse_event: MouseEvent, bounds: rl.Rectangle, bounds_size: float,
-                          content_size: float) -> None:
-    pre_state = self._state
-    super()._handle_mouse_event(mouse_event, bounds, bounds_size, content_size)
-
-    if self._state == ScrollState.MANUAL_SCROLL and pre_state == ScrollState.PRESSED and \
-       self._initial_click_event is not None:
-      diff_x = abs(mouse_event.pos.x - self._initial_click_event.pos.x)
-      diff_y = abs(mouse_event.pos.y - self._initial_click_event.pos.y)
-      along = diff_x if self._horizontal else diff_y
-      anti = diff_y if self._horizontal else diff_x
-      if anti > along:
-        self._state = ScrollState.STEADY
-        self._velocity = 0.0
-        self._velocity_buffer.clear()
@@ -1,16 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-from openpilot.system.ui.widgets.scroller import Scroller
-from openpilot.selfdrive.ui.sunnypilot.mici.widgets.scroll_panel_sp import GuiScrollPanel2SP
-
-
-class ScrollerSP(Scroller):
-  def __init__(self, **kwargs):
-    super().__init__(**kwargs)
-    inner = self._scroller
-    inner.scroll_panel = GuiScrollPanel2SP(inner._horizontal, handle_out_of_bounds=not inner._snap_items)
@@ -10,9 +10,6 @@ from openpilot.selfdrive.ui.layouts.main import MainLayout
 from openpilot.selfdrive.ui.mici.layouts.main import MiciMainLayout
 from openpilot.selfdrive.ui.ui_state import ui_state

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


@@ -9,7 +9,7 @@ from openpilot.common.params import Params
 from opendbc.car import structs
 from opendbc.safety import ALTERNATIVE_EXPERIENCE
 from opendbc.sunnypilot.car.hyundai.values import HyundaiFlagsSP, HyundaiSafetyFlagsSP
-from opendbc.sunnypilot.car.tesla.values import MadsScreenButtonType, TeslaFlagsSP
+from opendbc.sunnypilot.car.tesla.values import TeslaFlagsSP


 MADS_NO_ACC_MAIN_BUTTON = ("rivian", "tesla")
@@ -21,20 +21,17 @@ class MadsSteeringModeOnBrake:
  DISENGAGE = 2


-def get_mads_limited_brands(CP: structs.CarParams, CP_SP: structs.CarParamsSP, params: Params) -> bool:
+def get_mads_limited_brands(CP: structs.CarParams, CP_SP: structs.CarParamsSP) -> bool:
  if CP.brand == 'rivian':
    return True
  if CP.brand == 'tesla':
-    if not CP_SP.flags & TeslaFlagsSP.HAS_VEHICLE_BUS:
-      return True
-    screen_button = int(params.get("TeslaMadsScreenButton", return_default=True))
-    return screen_button == MadsScreenButtonType.OFF
+    return not CP_SP.flags & TeslaFlagsSP.HAS_VEHICLE_BUS

  return False


 def read_steering_mode_param(CP: structs.CarParams, CP_SP: structs.CarParamsSP, params: Params):
-  if get_mads_limited_brands(CP, CP_SP, params):
+  if get_mads_limited_brands(CP, CP_SP):
    return MadsSteeringModeOnBrake.DISENGAGE

  return params.get("MadsSteeringMode", return_default=True)
@@ -66,7 +63,7 @@ def set_car_specific_params(CP: structs.CarParams, CP_SP: structs.CarParamsSP, p
  # MADS is currently partially supported for these platforms due to lack of consistent states to engage controls
  # Only MadsSteeringModeOnBrake.DISENGAGE is supported for these platforms
  # TODO-SP: To enable MADS full support for Rivian and most Tesla, identify consistent signals for MADS toggling
-  mads_partial_support = get_mads_limited_brands(CP, CP_SP, params)
+  mads_partial_support = get_mads_limited_brands(CP, CP_SP)
  if mads_partial_support:
    params.put("MadsSteeringMode", 2, block=True)
    params.put_bool("MadsUnifiedEngagementMode", True, block=True)
@@ -13,7 +13,7 @@ from openpilot.selfdrive.selfdrived.events import Events
 from openpilot.sunnypilot.selfdrive.selfdrived.events import EventsSP
 from openpilot.sunnypilot.mads.helpers import MadsSteeringModeOnBrake, read_steering_mode_param
 from openpilot.sunnypilot.mads.mads import ModularAssistiveDrivingSystem
-from opendbc.sunnypilot.car.tesla.values import MadsScreenButtonType, TeslaFlagsSP
+from opendbc.sunnypilot.car.tesla.values import TeslaFlagsSP

 State = custom.ModularAssistiveDrivingSystem.ModularAssistiveDrivingSystemState
 EventName = log.OnroadEvent.EventName
@@ -38,12 +38,6 @@ def make_panda_state(mocker, controls_allowed_lateral=True):
  return ps


-def make_params_mock(mocker, values):
-  params = mocker.MagicMock()
-  params.get = mocker.MagicMock(side_effect=lambda k, **kwargs: values[k])
-  return params
-
-
 def make_mads(mocker, steering_mode):
  sd = mocker.MagicMock()
  sd.CP = structs.CarParams()
@@ -229,27 +223,15 @@ class TestBrandSteeringModeRestrictions:
    params = mocker.MagicMock()
    assert read_steering_mode_param(CP, CP_SP, params) == MadsSteeringModeOnBrake.DISENGAGE

-  @pytest.mark.parametrize("screen_button", [MadsScreenButtonType.THREE_FINGER,
-                                             MadsScreenButtonType.FOUR_FINGER,
-                                             MadsScreenButtonType.FIVE_FINGER])
-  def test_tesla_with_vehicle_bus_uses_param(self, mocker, screen_button):
+  def test_tesla_with_vehicle_bus_uses_param(self, mocker):
    CP = structs.CarParams()
    CP.brand = "tesla"
    CP_SP = structs.CarParamsSP()
    CP_SP.flags = TeslaFlagsSP.HAS_VEHICLE_BUS
-    params = make_params_mock(mocker, {"TeslaMadsScreenButton": screen_button,
-                                       "MadsSteeringMode": MadsSteeringModeOnBrake.REMAIN_ACTIVE})
+    params = mocker.MagicMock()
+    params.get = mocker.MagicMock(return_value=MadsSteeringModeOnBrake.REMAIN_ACTIVE)
    assert read_steering_mode_param(CP, CP_SP, params) == MadsSteeringModeOnBrake.REMAIN_ACTIVE

-  def test_tesla_with_vehicle_bus_screen_button_off_forced_to_disengage(self, mocker):
-    CP = structs.CarParams()
-    CP.brand = "tesla"
-    CP_SP = structs.CarParamsSP()
-    CP_SP.flags = TeslaFlagsSP.HAS_VEHICLE_BUS
-    params = make_params_mock(mocker, {"TeslaMadsScreenButton": MadsScreenButtonType.OFF,
-                                       "MadsSteeringMode": MadsSteeringModeOnBrake.REMAIN_ACTIVE})
-    assert read_steering_mode_param(CP, CP_SP, params) == MadsSteeringModeOnBrake.DISENGAGE
-
  @pytest.mark.parametrize("brand", ["hyundai", "toyota", "honda", "gm"])
  def test_other_brands_use_param(self, mocker, brand):
    CP = structs.CarParams()
@@ -82,3 +82,18 @@ if os.path.isfile(supercombo_onnx):
  compile_combined('supercombo',
                   f'--supercombo-onnx {supercombo_onnx}',
                   'driving_combined_supercombo_tinygrad.pkl')
+
+if PC:
+  inputs = tinygrad_files + [File(Dir("#openpilot/sunnypilot/modeld_v2").File("install_models_pc.py").abspath)]
+  outputs = []
+  model_dir = Dir("models").abspath
+  cmd = f'python3 {Dir("#openpilot/sunnypilot/modeld_v2").abspath}/install_models_pc.py {model_dir}'
+
+  for model_name in ['supercombo', 'driving_vision', 'driving_off_policy', 'driving_on_policy', 'driving_policy']:
+    if File(f"models/{model_name}.onnx").exists():
+        inputs.append(File(f"models/{model_name}.onnx"))
+        inputs.append(File(f"models/{model_name}_tinygrad.pkl"))
+        outputs.append(File(f"models/{model_name}_metadata.pkl"))
+  if outputs:
+    lenv.Command(outputs, inputs, cmd)
+
@@ -10,355 +10,471 @@ import argparse
 import os
 import pickle
 import time
-from collections import defaultdict
 from functools import partial
+from collections import defaultdict
+
 import numpy as np
-os.environ['GMMU'] = '0'
-
-def _patch_tinygrad_fetch_fw():
-  import hashlib
-  import pathlib
-  import zstandard
-  from tinygrad import helpers
-  _orig_fetch_fw = helpers.fetch_fw
-  def fetch_fw(path, name, sha256):
-    p = pathlib.Path(f"/lib/firmware/{path}/{name}.zst")
-    if p.is_file():
-      blob = zstandard.ZstdDecompressor().stream_reader(p.read_bytes()).read()
-      if hashlib.sha256(blob).hexdigest() == sha256:
-        return blob
-    return _orig_fetch_fw(path, name, sha256)
-  helpers.fetch_fw = fetch_fw
-_patch_tinygrad_fetch_fw()
-
-from openpilot.selfdrive.modeld.compile_modeld import NV12Frame, make_frame_prepare, sample_desire, sample_skip, shift_and_sample
-from tinygrad import dtypes
+from tinygrad.tensor import Tensor
 from tinygrad.device import Device
 from tinygrad.engine.jit import TinyJit
-from tinygrad.tensor import Tensor
+
+from openpilot.selfdrive.modeld.compile_modeld import (
+  NV12Frame, make_frame_prepare,
+  shift_and_sample, sample_skip, sample_desire,
+)

 MODEL_TYPES = ('vision_policy', 'supercombo', 'vision_multi_policy')


-def _detect_desire_key(shapes: dict) -> str | None:
-  return next((key for key in shapes if key.startswith('desire')), None)
+def _detect_desire_key(policy_input_shapes):
+  for k in policy_input_shapes:
+    if k.startswith('desire'):
+      return k
+  return None


-def _detect_vision_keys(shapes: dict) -> tuple[str | None, str | None]:
-  img_keys = sorted(key for key in shapes if 'img' in key)
-  return (
-    next((key for key in img_keys if 'big' not in key), None),
-    next((key for key in img_keys if 'big' in key), None)
-  )
+def _detect_vision_keys(vision_input_shapes):
+  img_keys = sorted([k for k in vision_input_shapes if 'img' in k])
+  road_key = next((k for k in img_keys if 'big' not in k), None)
+  wide_key = next((k for k in img_keys if 'big' in k), None)
+  if road_key is None or wide_key is None:
+    raise ValueError(f"Cannot determine road/wide image keys from {list(vision_input_shapes.keys())}")
+  return road_key, wide_key


-def derive_frame_skip(vision_input_shapes: dict, policy_input_shapes: dict) -> int:
-  features_buffer = policy_input_shapes.get('features_buffer')
-  return 1 if not features_buffer or features_buffer[1] >= 99 else 4
+def make_split_input_queues(vision_input_shapes, policy_input_shapes, frame_skip, device):
+  road_key, _ = _detect_vision_keys(vision_input_shapes)
+  img = vision_input_shapes[road_key]
+  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']
+  desire_key = _detect_desire_key(policy_input_shapes)
+  dp = policy_input_shapes[desire_key]
+  tc = policy_input_shapes.get('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),
+  }
+
+  handled = {'features_buffer', desire_key, 'traffic_convention'}
+  for key, shape in policy_input_shapes.items():
+    if key in handled:
+      continue
+    npy[key] = np.zeros(shape, dtype=np.float32)
+
+  input_queues = {
+    'img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
+    'big_img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
+    'feat_q': Tensor(np.zeros((frame_skip * (fb[1] - 1) + 1, fb[0], fb[2]), dtype=np.float32), device=device).contiguous().realize(),
+    'desire_q': Tensor(np.zeros((frame_skip * dp[1], dp[0], dp[2]), dtype=np.float32), device=device).contiguous().realize(),
+    **{k: Tensor(v, device='NPY').realize() for k, v in npy.items()},
+  }
+  return input_queues, npy


-def get_policy_npy_shapes(input_shapes: dict, is_supercombo: bool = False) -> tuple[dict, list[int]]:
-  desire_key = _detect_desire_key(input_shapes)
-  shapes = {}
-  if desire_key:
-    shapes['desire'] = (input_shapes[desire_key][2],)
-
-  if is_supercombo and 'features_buffer' in input_shapes:
-    fb = input_shapes['features_buffer']
-    shapes['prev_feat'] = (fb[0], fb[2])
-
-  for key, shape in input_shapes.items():
-    if key not in (desire_key, 'features_buffer') and 'img' not in key:
-      shapes[key] = tuple(shape)
-
-  sizes = [int(np.prod(size)) for size in shapes.values()]
-  return shapes, sizes
-
-
-def generate_queues_and_npy(input_shapes: dict, frame_skip: int, device: str = Device.DEFAULT,
-                            is_supercombo: bool = False, use_packed: bool = True) -> tuple[dict, dict]:
-  road_key, _ = _detect_vision_keys(input_shapes)
-  if not road_key:
-    raise ValueError("Vision road key missing from input shapes.")
-
-  img_shape = input_shapes[road_key]
-  n_frames = img_shape[1] // 6
-  img_buf_shape = (frame_skip * (n_frames - 1) + 1, 6, img_shape[2], img_shape[3])
-
-  desire_key = _detect_desire_key(input_shapes)
-  if not desire_key:
-    raise ValueError("Desire key missing from input shapes.")
-
-  desire_shape = input_shapes[desire_key]
-  features_buffer = input_shapes.get('features_buffer')
-
-  if use_packed:  # remove packed detection block after all models are recompiled
-    npy_arrays = {
-      'tfm': np.zeros((3, 3), dtype=np.float32),
-      'big_tfm': np.zeros((3, 3), dtype=np.float32)
-    }
-
-    shapes, sizes = get_policy_npy_shapes(input_shapes, is_supercombo=is_supercombo)
-    packed_npy_inputs = np.zeros(sum(sizes), dtype=np.float32)
-
-    split_indices = np.cumsum(sizes[:-1]) if len(sizes) > 1 else []
-    split_views = np.split(packed_npy_inputs, split_indices) if len(sizes) > 0 else []
-    for (k, s), v in zip(shapes.items(), split_views, strict=True):
-      npy_arrays[k] = v.reshape(s)
-
-    queues = {
-      'img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
-      'big_img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
-      'desire_q': Tensor(np.zeros((frame_skip * desire_shape[1], desire_shape[0], desire_shape[2]),
-                    dtype=np.float32), device=device).contiguous().realize(),
-      'packed_npy_inputs': Tensor(packed_npy_inputs, device='NPY').realize(),
-    }
-
-    if features_buffer:
-      queues['feat_q'] = Tensor(np.zeros((frame_skip * (features_buffer[1] - 1) + 1, features_buffer[0], features_buffer[2]),
-                         dtype=np.float32), device=device).contiguous().realize()
-
-    queues.update({key: Tensor(value, device='NPY').realize() for key, value in npy_arrays.items() if key in ('tfm', 'big_tfm')})
-  else:
-    # TODO-SP: Remove legacy queuing fallback else block after all models are recompiled
-    npy_arrays = {
-      'desire': np.zeros(desire_shape[2], dtype=np.float32),
-      'tfm': np.zeros((3, 3), dtype=np.float32),
-      'big_tfm': np.zeros((3, 3), dtype=np.float32)
-    }
-
-    for key, shape in input_shapes.items():
-      if key not in npy_arrays and 'img' not in key and key not in ('features_buffer', desire_key):
-        npy_arrays[key] = np.zeros(shape, dtype=np.float32)
-
-    queues = {
-      'img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
-      'big_img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
-      'desire_q': Tensor(np.zeros((frame_skip * desire_shape[1], desire_shape[0], desire_shape[2]),
-                    dtype=np.float32), device=device).contiguous().realize()
-    }
-
-    if features_buffer:
-      queues['feat_q'] = Tensor(np.zeros((frame_skip * (features_buffer[1] - 1) + 1, features_buffer[0], features_buffer[2]),
-                         dtype=np.float32), device=device).contiguous().realize()
-
-    queues.update({key: Tensor(value, device='NPY').realize() for key, value in npy_arrays.items()})
-
-  return queues, npy_arrays
-
-
-def make_split_input_queues(vision_input_shapes: dict, policy_input_shapes: dict,
-                            frame_skip: int, device: str = Device.DEFAULT, use_packed: bool = True) -> tuple[dict, dict]:
-  return generate_queues_and_npy({**vision_input_shapes, **policy_input_shapes}, frame_skip, device, is_supercombo=False, use_packed=use_packed)
-
-
-def make_supercombo_input_queues(input_shapes: dict, frame_skip: int,
-                                 device: str = Device.DEFAULT, use_packed: bool = True) -> tuple[dict, dict]:
-  return generate_queues_and_npy(input_shapes, frame_skip, device, is_supercombo=True, use_packed=use_packed)
-
-
-def create_jit_runner(vision_runner, policy_runners: list, nv12: NV12Frame, model_size: tuple[int, int],
-            features_slice: slice, frame_skip: int, input_shapes: dict, prepare_only: bool):
-  frame_prepare = make_frame_prepare(nv12, *model_size)
+def make_run_split_policy(vision_runner, policy_runner, nv12: NV12Frame, model_w, model_h,
+                          vision_features_slice, frame_skip, desire_key, extra_policy_keys,
+                          vision_road_key, vision_wide_key, 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)

-  desire_key = _detect_desire_key(input_shapes)
-  road_key, wide_key = _detect_vision_keys(input_shapes)
+  def run_policy(img_q, big_img_q, feat_q, desire_q, desire, traffic_convention, tfm, big_tfm, frame, big_frame, **extra):
+    npy_tensors = [tfm.to(Device.DEFAULT), big_tfm.to(Device.DEFAULT),
+                   desire.to(Device.DEFAULT), traffic_convention.to(Device.DEFAULT)]
+    extra_device = {k: extra[k].to(Device.DEFAULT) for k in extra_policy_keys}
+    Tensor.realize(*npy_tensors, *extra_device.values())
+    tfm, big_tfm, desire, traffic_convention = npy_tensors

-  if not desire_key or not road_key or not wide_key:
-    raise ValueError("Missing required vision or desire keys in input shapes.")
-
-  is_supercombo = vision_runner is None
-  npy_shapes, npy_sizes = get_policy_npy_shapes(input_shapes, is_supercombo=is_supercombo)
-
-  def runner(img_q, big_img_q, feat_q, packed_npy_inputs, frame, big_frame, tfm, big_tfm, **kwargs):
-    desire_q = kwargs['desire_q']
-
-    packed_npy_inputs_dev = packed_npy_inputs.to(Device.DEFAULT)
-    tfm_dev = tfm.to(Device.DEFAULT)
-    big_tfm_dev = big_tfm.to(Device.DEFAULT)
-
-    Tensor.realize(packed_npy_inputs_dev, tfm_dev, big_tfm_dev)
-
-    img = shift_and_sample(img_q, frame_prepare(frame, tfm_dev).unsqueeze(0), sample_skip_fn).realize()
-    big_img = shift_and_sample(big_img_q, frame_prepare(big_frame, big_tfm_dev).unsqueeze(0), sample_skip_fn).realize()
+    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

-    unpacked_tensors = [tensor.reshape(shape) for tensor, shape in zip(packed_npy_inputs_dev.split(npy_sizes), npy_shapes.values(), strict=True)]
-    unpacked_dict = dict(zip(npy_shapes.keys(), unpacked_tensors, strict=True))
+    vision_out = next(iter(vision_runner({vision_road_key: img, vision_wide_key: big_img}).values())).cast('float32')

-    desire_dev = unpacked_dict['desire']
-    desire_buf = shift_and_sample(desire_q, desire_dev.reshape(1, 1, -1), sample_desire_fn).realize()
+    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 = {desire_key: desire_buf}
-    for key, tensor_val in unpacked_dict.items():
-      if key not in ('desire', 'prev_feat'):
-        inputs[key] = tensor_val
+    inputs = {'features_buffer': feat_buf, desire_key: desire_buf, 'traffic_convention': traffic_convention, **extra_device}
+    policy_out = next(iter(policy_runner(inputs).values())).cast('float32')

-    if 'prev_feat' in unpacked_dict:
-      prev_feat_dev = unpacked_dict['prev_feat']
-      inputs['features_buffer'] = shift_and_sample(feat_q, prev_feat_dev.reshape(1, 1, -1), sample_skip_fn).realize()
-
-    if vision_runner:
-      vision_out_cast = next(iter(vision_runner({road_key: img, wide_key: big_img}).values())).cast('float32').realize()
-      if 'features_buffer' not in inputs:
-        new_feat = vision_out_cast[:, features_slice].reshape(1, -1).unsqueeze(0)
-        inputs['features_buffer'] = shift_and_sample(feat_q, new_feat, sample_skip_fn).realize()
-      policy_outs = [next(iter(pol_runner(inputs).values())).cast('float32').realize() for pol_runner in policy_runners]
-      return (vision_out_cast, *policy_outs) if len(policy_outs) > 1 else (vision_out_cast, policy_outs[0])
-
-    inputs.update({road_key: img, wide_key: big_img})
-    if 'features_buffer' not in inputs:
-      inputs['features_buffer'] = sample_skip_fn(feat_q)
-
-    policy_out = next(iter(policy_runners[0](inputs).values())).cast('float32').realize()
-    if 'features_buffer' not in inputs and features_slice is not None:
-      new_feat = policy_out[:, features_slice].reshape(1, -1).unsqueeze(0)
-      shift_and_sample(feat_q, new_feat, sample_skip_fn).realize()
-    return policy_out
-
-  return runner
+    return vision_out, policy_out
+  return run_policy


-def compile_and_warmup(nv12: NV12Frame, model_size: tuple[int, int], prepare_only: bool, frame_skip: int, vision_runner, policy_runners: list, metadata: dict):
-  print(f"Compiling combined JIT for {nv12.width}x{nv12.height} (prepare_only={prepare_only})...")
+def compile_split_policy(nv12: NV12Frame, model_w, model_h, prepare_only, frame_skip,
+                         vision_runner, policy_runner, vision_metadata, policy_metadata):
+  print(f"Compiling combined policy JIT for {nv12.width}x{nv12.height} (prepare_only={prepare_only})...")

-  all_shapes = {key: value for meta in metadata.values() for key, value in meta['input_shapes'].items()}
+  vision_features_slice = vision_metadata['output_slices']['hidden_state']
+  vision_input_shapes = vision_metadata['input_shapes']
+  policy_input_shapes = policy_metadata['input_shapes']
+  desire_key = _detect_desire_key(policy_input_shapes)
+  extra_policy_keys = [k for k in policy_input_shapes if k not in ('features_buffer', desire_key, 'traffic_convention')]
+  vision_road_key, vision_wide_key = _detect_vision_keys(vision_input_shapes)

-  feat_meta = metadata.get('vision') or metadata.get('model') or metadata.get('policy')
-  if not feat_meta:
-    raise ValueError("Could not find vision, model, or policy metadata.")
+  _run = make_run_split_policy(vision_runner, policy_runner, nv12, model_w, model_h,
+                               vision_features_slice, frame_skip, desire_key, extra_policy_keys,
+                               vision_road_key, vision_wide_key, prepare_only)
+  run_policy_jit = TinyJit(_run, prune=True)

-  features_slice = feat_meta['output_slices']['hidden_state']
-  WARP_DEV = 'CPU' if "USBGPU" in os.environ else Device.DEFAULT
+  SEED = 42

-  is_supercombo = vision_runner is None
-  run_func = create_jit_runner(vision_runner, policy_runners, nv12, model_size, features_slice, frame_skip, all_shapes, prepare_only)
-  run_jit = TinyJit(run_func, prune=True)
-  queues, npy_arrays = generate_queues_and_npy(all_shapes, frame_skip, Device.DEFAULT, is_supercombo=is_supercombo)
+  def random_inputs_run_fn(fn, seed, test_val=None, test_buffers=None, expect_match=True):
+    input_queues, npy = make_split_input_queues(vision_input_shapes, policy_input_shapes, frame_skip, Device.DEFAULT)
+    rng = np.random.default_rng(seed)
+    Tensor.manual_seed(seed)

+    testing = test_val is not None or test_buffers is not None
+    n_runs = 1 if testing else 3
+
+    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[:] = rng.standard_normal(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()
+      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")
+
+      if i == 0:
+        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('capture + replay')
+  run_policy_jit, test_val, test_buffers = random_inputs_run_fn(run_policy_jit, SEED)
+
+  print('pickle round trip')
+  run_policy_jit = pickle.loads(pickle.dumps(run_policy_jit))
+  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)
+  return run_policy_jit
+
+
+def derive_frame_skip(vision_input_shapes, policy_input_shapes):
+  fb = policy_input_shapes.get('features_buffer')
+  if fb is None:
+    return 1
+  fb_history = fb[1]
+  if fb_history >= 99:
+    return 1
+  return 4
+
+
+def make_supercombo_input_queues(input_shapes, frame_skip, device):
+  img_shape = input_shapes.get('img', input_shapes.get('input_imgs'))
+  if img_shape is None:
+    raise ValueError("No img input found in model shapes")
+
+  n_frames = img_shape[1] // 6
+  img_buf_shape = (frame_skip * (n_frames - 1) + 1, 6, img_shape[2], img_shape[3])
+
+  numpy_keys = {}
+  queue_keys = {}
+
+  for key, shape in input_shapes.items():
+    if 'img' in key:
+      continue
+    if len(shape) == 3 and shape[1] > 1:
+      if key.startswith('desire'):
+        numpy_keys[key] = np.zeros(shape[2], dtype=np.float32)
+        queue_keys[f'{key}_q'] = Tensor(
+          np.zeros((frame_skip * shape[1], shape[0], shape[2]), dtype=np.float32),
+          device=device).contiguous().realize()
+      elif key == 'features_buffer':
+        queue_keys['feat_q'] = Tensor(
+          np.zeros((frame_skip * (shape[1] - 1) + 1, shape[0], shape[2]), dtype=np.float32),
+          device=device).contiguous().realize()
+      else:
+        numpy_keys[key] = np.zeros(shape, dtype=np.float32)
+    elif len(shape) == 2:
+      numpy_keys[key] = np.zeros(shape, dtype=np.float32)
+
+  if 'traffic_convention' not in numpy_keys:
+    tc_shape = input_shapes.get('traffic_convention', (1, 2))
+    numpy_keys['traffic_convention'] = np.zeros(tc_shape, dtype=np.float32)
+
+  numpy_keys['tfm'] = np.zeros((3, 3), dtype=np.float32)
+  numpy_keys['big_tfm'] = np.zeros((3, 3), dtype=np.float32)
+
+  input_queues = {
+    'img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
+    'big_img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
+    **queue_keys,
+    **{k: Tensor(v, device='NPY').realize() for k, v in numpy_keys.items()},
+  }
+  return input_queues, numpy_keys
+
+
+def make_run_supercombo(model_runner, nv12: NV12Frame, model_w, model_h,
+                        features_slice, frame_skip, input_shapes, 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)
+
+  desire_key = _detect_desire_key(input_shapes)
+  if desire_key is None:
+    raise ValueError(f"No desire* key found in input_shapes: {list(input_shapes.keys())}")
+  road_img_key, wide_img_key = _detect_vision_keys(input_shapes)
+  extra_policy_keys = [k for k in input_shapes
+                       if k not in (desire_key, 'features_buffer', 'traffic_convention')
+                       and 'img' not in k]
+
+  def run_supercombo(img_q, big_img_q, feat_q, desire_q,
+                     frame, big_frame, **kwargs):
+    desire = kwargs.get(desire_key)
+    traffic_convention = kwargs.get('traffic_convention')
+    tfm = kwargs['tfm']
+    big_tfm = kwargs['big_tfm']
+
+    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
+
+    desire_buf = shift_and_sample(desire_q, desire.reshape(1, 1, -1), sample_desire_fn)
+    feat_buf = sample_skip_fn(feat_q)
+
+    inputs = {road_img_key: img, wide_img_key: big_img,
+              desire_key: desire_buf, 'features_buffer': feat_buf,
+              'traffic_convention': traffic_convention}
+    for k in extra_policy_keys:
+      if k in kwargs:
+        inputs[k] = kwargs[k].to(Device.DEFAULT)
+
+    model_out = next(iter(model_runner(inputs).values())).cast('float32')
+
+    new_feat = model_out[:, features_slice].reshape(1, -1).unsqueeze(0)
+    shift_and_sample(feat_q, new_feat, sample_skip_fn)
+
+    return model_out
+
+  return run_supercombo
+
+
+def make_run_vision_multi_policy(vision_runner, policy_runners, nv12: NV12Frame, model_w, model_h,
+                                 vision_features_slice, frame_skip, desire_key, extra_policy_keys,
+                                 vision_road_key, vision_wide_key, 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_multi_policy(img_q, big_img_q, feat_q, desire_q, desire,
+                       traffic_convention, tfm, big_tfm, frame, big_frame, **extra):
+    npy_tensors = [tfm.to(Device.DEFAULT), big_tfm.to(Device.DEFAULT),
+                   desire.to(Device.DEFAULT), traffic_convention.to(Device.DEFAULT)]
+    extra_device = {k: extra[k].to(Device.DEFAULT) for k in extra_policy_keys}
+    Tensor.realize(*npy_tensors, *extra_device.values())
+    tfm, big_tfm, desire, traffic_convention = npy_tensors
+
+    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({vision_road_key: img, vision_wide_key: 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_key: desire_buf, 'traffic_convention': traffic_convention, **extra_device}
+
+    policy_outputs = []
+    for runner in policy_runners:
+      policy_out = next(iter(runner(inputs).values())).cast('float32')
+      policy_outputs.append(policy_out)
+
+    return (vision_out, *policy_outputs)
+
+  return run_multi_policy
+
+
+def _warmup_and_serialize(run_jit, input_queues, npy, nv12):
  for i in range(3):
    rng = np.random.default_rng(42 + i)
-    frame = Tensor.randint(nv12.size, low=0, high=256, dtype=dtypes.uint8, device=WARP_DEV).realize()
-    big_frame = Tensor.randint(nv12.size, low=0, high=256, dtype=dtypes.uint8, device=WARP_DEV).realize()
-    for arr in npy_arrays.values():
-      arr[:] = rng.standard_normal(arr.shape).astype(arr.dtype)
-
+    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[:] = rng.standard_normal(v.shape).astype(v.dtype)
    Device.default.synchronize()
-    start_time = time.perf_counter()
-    run_jit(**queues, frame=frame, big_frame=big_frame)
-    mid_time = time.perf_counter()
+    st = time.perf_counter()
+    run_jit(**input_queues, frame=frame, big_frame=big_frame)
+    mt = time.perf_counter()
    Device.default.synchronize()
-    print(f"  [{i + 1}/3] enqueue {(mid_time - start_time) * 1e3:6.2f} ms -- total {(time.perf_counter() - start_time) * 1e3:6.2f} ms")
-
-  # TODO-SP: switch to dump_oob/load_oob on next full recompile of all models
-  return pickle.loads(pickle.dumps(run_jit)) if not prepare_only else run_jit
+    et = time.perf_counter()
+    print(f"  [{i + 1}/3] enqueue {(mt - st) * 1e3:6.2f} ms -- total {(et - st) * 1e3:6.2f} ms")
+  return pickle.loads(pickle.dumps(run_jit))


-def _parse_size(size_str: str) -> tuple[int, int]:
-  width, height = size_str.lower().split('x')
-  return int(width), int(height)
+def compile_supercombo(nv12: NV12Frame, model_w, model_h, prepare_only, frame_skip,
+                       model_runner, metadata):
+  print(f"Compiling combined supercombo JIT for {nv12.width}x{nv12.height} (prepare_only={prepare_only})...")
+
+  features_slice = metadata['output_slices']['hidden_state']
+  input_shapes = metadata['input_shapes']
+
+  _run = make_run_supercombo(model_runner, nv12, model_w, model_h,
+                             features_slice, frame_skip, input_shapes, prepare_only)
+  run_jit = TinyJit(_run, prune=True)
+
+  input_queues, npy = make_supercombo_input_queues(input_shapes, frame_skip, Device.DEFAULT)
+
+  run_jit = _warmup_and_serialize(run_jit, input_queues, npy, nv12)
+  return run_jit


-def read_file_chunked_to_shm(path):
-  if not path:
-    return None
-  import atexit
-  import shutil
-  from openpilot.common.file_chunker import open_file_chunked
-  from openpilot.common.hardware.hw import Paths
-  shm_path = os.path.join(Paths.shm_path(), os.path.basename(path))
-  atexit.register(lambda: os.path.exists(shm_path) and os.remove(shm_path))
-  with open(shm_path, 'wb') as dst, open_file_chunked(path) as src:
-    shutil.copyfileobj(src, dst)
-  return shm_path
+def compile_multi_policy(nv12: NV12Frame, model_w, model_h, prepare_only, frame_skip,
+                         vision_runner, policy_runners, vision_metadata, policy_metadata):
+  print(f"Compiling combined multi-policy JIT for {nv12.width}x{nv12.height} (prepare_only={prepare_only})...")
+
+  vision_features_slice = vision_metadata['output_slices']['hidden_state']
+  vision_input_shapes = vision_metadata['input_shapes']
+  policy_input_shapes = policy_metadata['input_shapes']
+  desire_key = _detect_desire_key(policy_input_shapes)
+  extra_policy_keys = [k for k in policy_input_shapes if k not in ('features_buffer', desire_key, 'traffic_convention')]
+  vision_road_key, vision_wide_key = _detect_vision_keys(vision_input_shapes)
+
+  _run = make_run_vision_multi_policy(vision_runner, policy_runners, nv12, model_w, model_h,
+                                      vision_features_slice, frame_skip, desire_key, extra_policy_keys,
+                                      vision_road_key, vision_wide_key, prepare_only)
+  run_jit = TinyJit(_run, prune=True)
+
+  input_queues, npy = make_split_input_queues(vision_input_shapes, policy_input_shapes, frame_skip, Device.DEFAULT)
+
+  run_jit = _warmup_and_serialize(run_jit, input_queues, npy, nv12)
+  return run_jit


-def _compile_for_resolutions(camera_resolutions: list, model_size: tuple[int, int], frame_skip: int,
-               vision_runner, policy_runners: list, metadata: dict) -> dict:
-  from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
-  return {
-    (cam_w, cam_h): {
-      name: compile_and_warmup(NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h)), model_size, prepare_only,
-                   frame_skip, vision_runner, policy_runners, metadata)
-      for name, prepare_only in [('warp_enqueue', True), ('run_policy', False)]
-    }
-    for cam_w, cam_h in camera_resolutions
-  }
-
-
-def _load_policy_runners(args: argparse.Namespace) -> tuple[list, list]:
-  runners, keys = [], []
-  for name, onnx_arg in [('policy', args.policy_onnx), ('off_policy', args.off_policy_onnx), ('on_policy', args.on_policy_onnx)]:
-    if onnx_arg:
-      runners.append(OnnxRunner(onnx_arg))
-      keys.append(name)
-  return runners, keys
+def _parse_size(s):
+  w, h = s.lower().split('x')
+  return int(w), int(h)


 if __name__ == "__main__":
-  from openpilot.selfdrive.modeld.get_model_metadata import make_metadata_dict
  from tinygrad.nn.onnx import OnnxRunner
+  from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
+  from openpilot.selfdrive.modeld.get_model_metadata import make_metadata_dict

-  parser = argparse.ArgumentParser(description="Compile combined JIT pkl for sunnypilot modeld_v2")
-  parser.add_argument('--model-type', choices=MODEL_TYPES, required=True)
-  parser.add_argument('--model-size', type=_parse_size, required=True, help='model input WxH')
-  parser.add_argument('--camera-resolutions', type=_parse_size, nargs='+', required=True)
-  parser.add_argument('--frame-skip', type=int, default=None, help='frame skip value (auto-derived if not provided)')
-  parser.add_argument('--output', required=True)
+  p = argparse.ArgumentParser(description="Compile combined JIT pkl for sunnypilot modeld_v2")
+  p.add_argument('--model-type', choices=MODEL_TYPES, required=True)
+  p.add_argument('--model-size', type=_parse_size, required=True, help='model input WxH')
+  p.add_argument('--camera-resolutions', type=_parse_size, nargs='+', required=True)
+  p.add_argument('--frame-skip', type=int, default=None, help='frame skip value (auto-derived if not provided)')
+  p.add_argument('--output', required=True)

-  parser.add_argument('--vision-onnx', help='vision ONNX (for split models)')
-  parser.add_argument('--policy-onnx', help='policy ONNX (for vision_policy)')
-  parser.add_argument('--off-policy-onnx', help='off-policy ONNX (for vision_multi_policy)')
-  parser.add_argument('--on-policy-onnx', help='on-policy ONNX (for vision_multi_policy)')
-  parser.add_argument('--supercombo-onnx', help='supercombo ONNX (for supercombo)')
+  p.add_argument('--vision-onnx', help='vision ONNX (for split models)')
+  p.add_argument('--policy-onnx', help='policy ONNX (for vision_policy)')
+  p.add_argument('--off-policy-onnx', help='off-policy ONNX (for vision_multi_policy)')
+  p.add_argument('--on-policy-onnx', help='on-policy ONNX (for vision_multi_policy)')
+  p.add_argument('--supercombo-onnx', help='supercombo ONNX (for supercombo)')

-  args = parser.parse_args()
-  output_data = defaultdict(dict)
-
-  args.vision_onnx = read_file_chunked_to_shm(args.vision_onnx)
-  args.policy_onnx = read_file_chunked_to_shm(args.policy_onnx)
-  args.off_policy_onnx = read_file_chunked_to_shm(args.off_policy_onnx)
-  args.on_policy_onnx = read_file_chunked_to_shm(args.on_policy_onnx)
-  args.supercombo_onnx = read_file_chunked_to_shm(args.supercombo_onnx)
-
-  vision_runner = OnnxRunner(args.vision_onnx) if args.vision_onnx else None
+  args = p.parse_args()
+  out = defaultdict(dict)

  if args.model_type == 'vision_policy':
-    assert vision_runner and args.policy_onnx
-    policy_runners = [OnnxRunner(args.policy_onnx)]
-    output_data['metadata'] = {'vision': make_metadata_dict(args.vision_onnx), 'policy': make_metadata_dict(args.policy_onnx)}
+    assert args.vision_onnx and args.policy_onnx
+    vision_runner = OnnxRunner(args.vision_onnx)
+    policy_runner = OnnxRunner(args.policy_onnx)
+    out['metadata']['vision'] = make_metadata_dict(args.vision_onnx)
+    out['metadata']['policy'] = make_metadata_dict(args.policy_onnx)
+
+    frame_skip = args.frame_skip if args.frame_skip is not None else derive_frame_skip(out['metadata']['vision']['input_shapes'],
+                                                                                       out['metadata']['policy']['input_shapes'])
+
+    for cam_w, cam_h in args.camera_resolutions:
+      nv12 = NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h))
+      model_w, model_h = args.model_size
+      out[(cam_w, cam_h)] = {
+        name: compile_split_policy(nv12, model_w, model_h, prepare_only, frame_skip,
+                                   vision_runner, policy_runner,
+                                   out['metadata']['vision'], out['metadata']['policy'])
+        for name, prepare_only in [('warp_enqueue', True), ('run_policy', False)]
+      }
+
  elif args.model_type == 'supercombo':
    assert args.supercombo_onnx
-    policy_runners = [OnnxRunner(args.supercombo_onnx)]
-    output_data['metadata'] = {'model': make_metadata_dict(args.supercombo_onnx)}
+    model_runner = OnnxRunner(args.supercombo_onnx)
+    out['metadata']['model'] = make_metadata_dict(args.supercombo_onnx)
+
+    frame_skip = args.frame_skip if args.frame_skip is not None else derive_frame_skip({}, out['metadata']['model']['input_shapes'])
+
+    for cam_w, cam_h in args.camera_resolutions:
+      nv12 = NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h))
+      model_w, model_h = args.model_size
+      out[(cam_w, cam_h)] = {
+        name: compile_supercombo(nv12, model_w, model_h, prepare_only, frame_skip,
+                                 model_runner, out['metadata']['model'])
+        for name, prepare_only in [('warp_enqueue', True), ('run_policy', False)]
+      }
+
  elif args.model_type == 'vision_multi_policy':
-    assert vision_runner
-    policy_runners, policy_names = _load_policy_runners(args)
-    output_data['metadata'] = {'vision': make_metadata_dict(args.vision_onnx)}
-    for name in policy_names:
-      runner_arg = getattr(args, f"{name}_onnx")
-      output_data['metadata'][name] = make_metadata_dict(runner_arg)
+    assert args.vision_onnx
+    vision_runner = OnnxRunner(args.vision_onnx)
+    out['metadata']['vision'] = make_metadata_dict(args.vision_onnx)

-  policy_keys = [key for key in output_data['metadata'].keys() if key != 'vision']
-  first_policy_meta = output_data['metadata'][policy_keys[0]] if policy_keys else {}
-  vision_meta = output_data['metadata'].get('vision', {})
+    policy_runners = []
+    policy_onnxes = []
+    if args.policy_onnx:
+      policy_onnxes.append(('policy', args.policy_onnx))
+    if args.off_policy_onnx:
+      policy_onnxes.append(('off_policy', args.off_policy_onnx))
+    if args.on_policy_onnx:
+      policy_onnxes.append(('on_policy', args.on_policy_onnx))

-  derived_frame_skip = args.frame_skip or derive_frame_skip(vision_meta.get('input_shapes', {}), first_policy_meta.get('input_shapes', {}))
-  output_data.update(_compile_for_resolutions(args.camera_resolutions, args.model_size, derived_frame_skip,
-                        vision_runner, policy_runners, output_data['metadata']))
+    for name, onnx_path in policy_onnxes:
+      runner = OnnxRunner(onnx_path)
+      policy_runners.append(runner)
+      out['metadata'][name] = make_metadata_dict(onnx_path)

-  with open(args.output, "wb") as file:
-    # TODO-SP: switch to dump_oob from openpilot/selfdrive/helpers on next full recompile of all models
-    pickle.dump(output_data, file)
+    first_policy_key = policy_onnxes[0][0]
+    frame_skip = args.frame_skip if args.frame_skip is not None else derive_frame_skip(out['metadata']['vision']['input_shapes'],
+                                                                                       out['metadata'][first_policy_key]['input_shapes'])

+    for cam_w, cam_h in args.camera_resolutions:
+      nv12 = NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h))
+      model_w, model_h = args.model_size
+      out[(cam_w, cam_h)] = {
+        name: compile_multi_policy(nv12, model_w, model_h, prepare_only, frame_skip,
+                                   vision_runner, policy_runners,
+                                   out['metadata']['vision'], out['metadata'][first_policy_key])
+        for name, prepare_only in [('warp_enqueue', True), ('run_policy', False)]
+      }
+
+  with open(args.output, "wb") as f:
+    pickle.dump(out, f)
  pkl_size = os.path.getsize(args.output)
  print(f"Saved combined JIT to {args.output} ({pkl_size / 1e6:.2f} MB)")

  from openpilot.common.file_chunker import chunk_file, get_chunk_targets
  chunk_targets = get_chunk_targets(args.output, pkl_size)
  chunk_file(args.output, chunk_targets)
-  print(f"Chunked into {len(chunk_targets) - 1} file(s)")
+  num_chunks = len(chunk_targets) - 1
+  print(f"Chunked into {num_chunks} file(s)")
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+import sys
+import shutil
+import pickle
+import codecs
+from pathlib import Path
+
+from openpilot.common.hardware.hw import Paths
+from openpilot.sunnypilot.modeld_v2.get_model_metadata import MetadataOnnxPBParser, get_name_and_shape, get_metadata_value_by_name
+
+
+def generate_metadata_pkl(model_path, output_path):
+  try:
+    model = MetadataOnnxPBParser(model_path).parse()
+    output_slices = get_metadata_value_by_name(model, 'output_slices')
+    if not output_slices:
+      return False
+    metadata = {
+      'model_checkpoint': get_metadata_value_by_name(model, 'model_checkpoint'),
+      'output_slices': pickle.loads(codecs.decode(output_slices.encode(), "base64")),
+      'input_shapes': dict(get_name_and_shape(x) for x in model["graph"]["input"]),
+      'output_shapes': dict(get_name_and_shape(x) for x in model["graph"]["output"]),
+    }
+    with open(output_path, 'wb') as f:
+      pickle.dump(metadata, f)
+    return True
+  except Exception:
+    return False
+
+
+def install_models(model_dir):
+  model_dir = Path(model_dir)
+  models = ["driving_off_policy", "driving_on_policy", "driving_vision"]
+  found_models = []
+
+  for model in models:
+    if (model_dir / f"{model}.onnx").exists():
+      found_models.append(model)
+
+  if not found_models:
+    return
+
+  try:
+    custom_name = input(f"Found models ({', '.join(found_models)}). Enter model short name (e.g. wmiv4): ").strip()
+  except EOFError:
+    return
+
+  if not custom_name:
+    print("No name provided, skipping installation.")
+    return
+
+  dest_dir = Path(Paths.model_root())
+  dest_dir.mkdir(parents=True, exist_ok=True)
+
+  for model in found_models:
+    onnx_path = model_dir / f"{model}.onnx"
+    tinygrad_pkl = model_dir / f"{model}_tinygrad.pkl"
+    metadata_pkl = model_dir / f"{model}_metadata.pkl"
+
+    if not metadata_pkl.exists():
+      generate_metadata_pkl(onnx_path, metadata_pkl)
+
+    dest_tinygrad = dest_dir / f"{model}_{custom_name}_tinygrad.pkl"
+    dest_metadata = dest_dir / f"{model}_{custom_name}_metadata.pkl"
+
+    if tinygrad_pkl.exists():
+      shutil.move(str(tinygrad_pkl), str(dest_tinygrad))
+    if metadata_pkl.exists():
+      shutil.move(str(metadata_pkl), str(dest_metadata))
+
+if __name__ == "__main__":
+  if len(sys.argv) < 2:
+    print("Usage: install_models_pc.py <model_dir>")
+    sys.exit(1)
+  install_models(sys.argv[1])
@@ -7,7 +7,6 @@ See the LICENSE.md file in the root directory for more details.
 """

 import os
-os.environ['GMMU'] = '0'
 from openpilot.common.hardware import TICI
 os.environ['DEV'] = 'QCOM' if TICI else 'CPU'
 USBGPU = "USBGPU" in os.environ
@@ -24,11 +23,6 @@ from setproctitle import setproctitle
 from openpilot.cereal.messaging import PubMaster, SubMaster
 from msgq.visionipc import VisionIpcClient, VisionStreamType, VisionBuf
 from opendbc.car.car_helpers import get_demo_car_params
-
-from tinygrad.tensor import Tensor
-from tinygrad.device import Device
-
-from openpilot.common.file_chunker import open_file_chunked
 from openpilot.common.swaglog import cloudlog
 from openpilot.common.params import Params
 from openpilot.common.filter_simple import FirstOrderFilter
@@ -36,7 +30,6 @@ from openpilot.common.realtime import config_realtime_process, DT_MDL
 from openpilot.common.transformations.camera import DEVICE_CAMERAS
 from openpilot.common.transformations.model import get_warp_matrix
 from openpilot.system import sentry
-from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
 from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
 from openpilot.selfdrive.controls.lib.drive_helpers import get_accel_from_plan, smooth_value

@@ -44,12 +37,10 @@ from openpilot.sunnypilot.modeld_v2.fill_model_msg import fill_model_msg, fill_p
 from openpilot.sunnypilot.modeld_v2.constants import Plan
 from openpilot.sunnypilot.modeld_v2.meta_helper import load_meta_constants
 from openpilot.sunnypilot.modeld_v2.camera_offset_helper import CameraOffsetHelper
-from openpilot.sunnypilot.modeld_v2.compile_modeld import derive_frame_skip, make_split_input_queues

 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld_v2.modeld_base import ModelStateBase
 from openpilot.sunnypilot.models.helpers import get_active_bundle
-from openpilot.sunnypilot.selfdrive.controls.lib.relc import RoadEdgeLaneChangeController

 PROCESS_NAME = "openpilot.selfdrive.modeld.modeld_tinygrad"

@@ -108,37 +99,29 @@ class ModelState(ModelStateBase):
    self._init_combined(pkl_path, cam_w, cam_h, model_bundle)

  def _init_combined(self, pkl_path, cam_w, cam_h, bundle):
+    from tinygrad.tensor import Tensor
+    from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
+    from openpilot.sunnypilot.modeld_v2.compile_modeld import derive_frame_skip, make_split_input_queues
+    from tinygrad.device import Device
+
+    from openpilot.common.file_chunker import open_file_chunked
+
    cloudlog.warning(f"loading combined pkl: {pkl_path}")
-    # TODO-SP: switch to load_oob from openpilot/selfdrive/helpers on next full recompile of all models
    jits = pickle.load(open_file_chunked(pkl_path))

    self.DEV = Device.DEFAULT
-    self.WARP_DEV = 'CPU' if USBGPU else self.DEV
-    self.QUEUE_DEV = self.DEV

    metadata = jits['metadata']
-
-    self._run_policy = jits[(cam_w, cam_h)]['run_policy']
-    self._warp_enqueue = jits[(cam_w, cam_h)]['warp_enqueue']
-
-    # TODO-SP: Remove legacy use_packed detection block after all models are recompiled
-    captured = getattr(self._run_policy, 'captured', None)
-    if captured is not None:
-      use_packed = 'packed_npy_inputs' in getattr(captured, 'expected_names', [])
-    else:
-      use_packed = True
-
    if 'model' in metadata:
      model_metadata = metadata['model']
      self.vision_output_slices = model_metadata['output_slices']
      self.policy_output_slices = {}
      self._policy_slices_list = []
      self._combined_model_type = 'supercombo'
-      self._vision_input_names = [key for key in model_metadata['input_shapes'] if 'img' in key]
+      self._vision_input_names = [k for k in model_metadata['input_shapes'] if 'img' in k]
      from openpilot.sunnypilot.modeld_v2.compile_modeld import make_supercombo_input_queues
      frame_skip = derive_frame_skip({}, model_metadata['input_shapes'])
-      self.input_queues, self.numpy_inputs = make_supercombo_input_queues(model_metadata['input_shapes'],
-                                                                          frame_skip, device=self.QUEUE_DEV, use_packed=use_packed)
+      self.input_queues, self.numpy_inputs = make_supercombo_input_queues(model_metadata['input_shapes'], frame_skip, device=self.DEV)
    else:
      vision_metadata = metadata['vision']
      policy_keys = [k for k in metadata if k != 'vision']
@@ -156,12 +139,11 @@ class ModelState(ModelStateBase):
      policy_input_shapes = first_policy_metadata['input_shapes']
      self._vision_input_names = [k for k in vision_input_shapes if 'img' in k]
      frame_skip = derive_frame_skip(vision_input_shapes, policy_input_shapes)
-      self.input_queues, self.numpy_inputs = make_split_input_queues(vision_input_shapes, policy_input_shapes,
-                                                                     frame_skip, device=self.QUEUE_DEV, use_packed=use_packed)
+      self.input_queues, self.numpy_inputs = make_split_input_queues(vision_input_shapes, policy_input_shapes, frame_skip, device=self.DEV)

-    self._desire_key = next(key for key in self.numpy_inputs if key.startswith('desire'))
-    self._road_key = next(key for key in self._vision_input_names if 'big' not in key)
-    self._wide_key = next(key for key in self._vision_input_names if 'big' in key)
+    from openpilot.sunnypilot.modeld_v2.parse_model_outputs_split import Parser as SplitParser
+    from openpilot.sunnypilot.modeld_v2.parse_model_outputs import Parser as CombinedParser
+    self.parser = SplitParser() if self._combined_model_type != 'supercombo' else CombinedParser()

    is_20hz = bundle.is20hz if bundle else self._combined_model_type in ('split', 'multi_policy')
    if is_20hz:
@@ -171,24 +153,20 @@ class ModelState(ModelStateBase):
      from openpilot.sunnypilot.modeld_v2.constants import ModelConstants
      self.constants = ModelConstants()

-    if self._combined_model_type != 'supercombo':
-      from openpilot.sunnypilot.modeld_v2.parse_model_outputs_split import Parser as SplitParser
-      self.parser = SplitParser()
-    else:
-      from openpilot.sunnypilot.modeld_v2.parse_model_outputs import Parser as CombinedParser
-      self.parser = CombinedParser()
-
    self.prev_desire = np.zeros(self.constants.DESIRE_LEN, dtype=np.float32)
    self.full_frames: dict = {}
    self._blob_cache: dict = {}
    nv12_info = get_nv12_info(cam_w, cam_h)
    self.frame_buf_params = dict.fromkeys(self._vision_input_names, nv12_info)

-    yuv_size = self.frame_buf_params[self._road_key][3]
+    self._run_policy = jits[(cam_w, cam_h)]['run_policy']
+    self._warp_enqueue = jits[(cam_w, cam_h)]['warp_enqueue']
+    road_name = next(k for k in self._vision_input_names if 'big' not in k)
+    yuv_size = self.frame_buf_params[road_name][3]
    self._warp_enqueue(
      **self.input_queues,
-      frame=Tensor(np.zeros(yuv_size, dtype=np.uint8), device=self.WARP_DEV).contiguous().realize(),
-      big_frame=Tensor(np.zeros(yuv_size, dtype=np.uint8), device=self.WARP_DEV).contiguous().realize())
+      frame=Tensor(np.zeros(yuv_size, dtype=np.uint8), device=self.DEV).contiguous().realize(),
+      big_frame=Tensor(np.zeros(yuv_size, dtype=np.uint8), device=self.DEV).contiguous().realize())


  @property
@@ -201,28 +179,30 @@ class ModelState(ModelStateBase):

  @property
  def desire_key(self) -> str:
-    return self._desire_key
+    return next(k for k in self.numpy_inputs if k.startswith('desire'))

  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:
+    from tinygrad.tensor import Tensor
+
    for key in bufs.keys():
      ptr = np.frombuffer(bufs[key].data, dtype=np.uint8).ctypes.data
      yuv_size = self.frame_buf_params[key][3]
      cache_key = (key, ptr)
      if cache_key not in self._blob_cache:
-        self._blob_cache[cache_key] = Tensor.from_blob(ptr, (yuv_size,), dtype='uint8', device=self.WARP_DEV)
+        self._blob_cache[cache_key] = Tensor.from_blob(ptr, (yuv_size,), dtype='uint8', device=self.DEV)
      self.full_frames[key] = self._blob_cache[cache_key]

    desire_key = self.desire_key
    inputs[desire_key][0] = 0
    self.numpy_inputs[desire_key][:] = np.where(inputs[desire_key] - self.prev_desire > .99, inputs[desire_key], 0)
    self.prev_desire[:] = inputs[desire_key]
-    for key in ('traffic_convention', 'lateral_control_params', 'action_t'):
+    for key in ('traffic_convention', 'lateral_control_params'):
      if key in self.numpy_inputs and key in inputs:
        self.numpy_inputs[key][:] = inputs[key]

-    road_key = self._road_key
-    wide_key = self._wide_key
+    road_key = next(n for n in bufs if 'big' not in n)
+    wide_key = next(n for n in bufs if 'big' in n)
    self.numpy_inputs['tfm'][:, :] = transforms[road_key].reshape(3, 3)
    self.numpy_inputs['big_tfm'][:, :] = transforms[wide_key].reshape(3, 3)

@@ -236,26 +216,17 @@ class ModelState(ModelStateBase):
      model_output = raw_outputs.numpy().flatten()
      sliced = {k: model_output[np.newaxis, v] for k, v in self.vision_output_slices.items()}
      outputs = self.parser.parse_outputs(sliced)
-      if 'prev_feat' in self.numpy_inputs:
-        self.numpy_inputs['prev_feat'][:] = model_output[self.vision_output_slices['hidden_state']]
    else:
      vision_output = raw_outputs[0].numpy().flatten()
      vision_sliced = {k: vision_output[np.newaxis, v] for k, v in self.vision_output_slices.items()}
      outputs = self.parser.parse_vision_outputs(vision_sliced)

-      if 'prev_feat' in self.numpy_inputs and 'hidden_state' in self.vision_output_slices:
-        self.numpy_inputs['prev_feat'][:] = vision_output[self.vision_output_slices['hidden_state']]
-
      for i, policy_slices in enumerate(self._policy_slices_list):
        policy_output = raw_outputs[i + 1].numpy().flatten()
        policy_sliced = {k: policy_output[np.newaxis, v] for k, v in policy_slices.items()}
        parsed = self.parser.parse_policy_outputs(policy_sliced)
-        if ('off' in self._policy_keys[i]
-          and self._has_on_policy
-          and any('plan' in self._policy_slices_list[j] for j, k in enumerate(self._policy_keys) if 'on' in k.lower())):
-
+        if 'off' in self._policy_keys[i] and self._has_on_policy:
          parsed.pop('plan', None)
-
        outputs.update(parsed)

      if 'planplus' in outputs and 'plan' in outputs:
@@ -266,30 +237,17 @@ class ModelState(ModelStateBase):
      buf[0, :-1] = buf[0, 1:]
      buf[0, -1, :] = outputs['desired_curvature'][0, :] if not self.mlsim else 0

-    # TODO-SP: This is a hack to prevent GPU corruption by calculating in CPU space, it can be removed on next recompile
-    if 'prev_feat' not in self.numpy_inputs and 'feat_q' in self.input_queues:
-      feat_val = self.input_queues['feat_q'].numpy()
-      self.input_queues['feat_q'].assign(feat_val).realize()
-
    return outputs

  def get_action_from_model(self, model_output: dict[str, np.ndarray], prev_action: log.ModelDataV2.Action,
                            lat_action_t: float, long_action_t: float, v_ego: float) -> log.ModelDataV2.Action:
-    if 'action' not in model_output:
-      plan = model_output['plan'][0]
-      desired_accel, should_stop = get_accel_from_plan(plan[:, Plan.VELOCITY][:, 0], plan[:, Plan.ACCELERATION][:, 0], self.constants.T_IDXS,
-                                                       action_t=long_action_t)
-
-      curvature_plan = (plan + (self.PLANPLUS_CONTROL - 1.0) * model_output['planplus'][0]
-                        if 'planplus' in model_output and self.PLANPLUS_CONTROL != 1.0 else plan)
-      desired_curvature = get_curvature_from_output(model_output, curvature_plan, v_ego, lat_action_t, self.mlsim)
-    else:
-      desired_accel = model_output['action'][0, 1]
-      desired_curvature = model_output['action'][0, 0] / (max(1.0, v_ego))**2
-      should_stop = (v_ego < 0.3 and desired_accel < 0.1)
-
+    plan = model_output['plan'][0]
+    desired_accel, should_stop = get_accel_from_plan(plan[:, Plan.VELOCITY][:, 0], plan[:, Plan.ACCELERATION][:, 0], self.constants.T_IDXS,
+                                                     action_t=long_action_t)
    desired_accel = smooth_value(desired_accel, prev_action.desiredAcceleration, self.LONG_SMOOTH_SECONDS)

+    curvature_plan = plan + (self.PLANPLUS_CONTROL - 1.0) * model_output['planplus'][0] if 'planplus' in model_output and self.PLANPLUS_CONTROL != 1.0 else plan
+    desired_curvature = get_curvature_from_output(model_output, curvature_plan, v_ego, lat_action_t, self.mlsim)
    if self.generation is not None and self.generation >= 10: # smooth curvature for post FOF models
      if v_ego > self.MIN_LAT_CONTROL_SPEED:
        desired_curvature = smooth_value(desired_curvature, prev_action.desiredCurvature, self.LAT_SMOOTH_SECONDS)
@@ -367,7 +325,6 @@ def main(demo=False):
  prev_action = log.ModelDataV2.Action()

  DH = DesireHelper()
-  RELC = RoadEdgeLaneChangeController(DH)
  meta_constants = load_meta_constants()

  while True:
@@ -443,12 +400,6 @@ def main(demo=False):

    bufs = {name: buf_extra if 'big' in name else buf_main for name in model.vision_input_names}
    transforms = {name: model_transform_extra if 'big' in name else model_transform_main for name in model.vision_input_names}
-
-    frame_delay = DT_MDL # compensate for time passed since the frame was captured: current_time - timestamp_eof is 50ms on average
-    action_delay = DT_MDL / 2 # middle of the interval between model output (current state) and next frame (expected state)
-    lat_action_t = lat_delay + frame_delay + action_delay
-    long_action_t = long_delay + frame_delay + action_delay
-
    inputs:dict[str, np.ndarray] = {
      model.desire_key: vec_desire,
      'traffic_convention': traffic_convention,
@@ -457,9 +408,6 @@ def main(demo=False):
    if 'lateral_control_params' in model.numpy_inputs:
      inputs['lateral_control_params'] = np.array([v_ego, lat_delay], dtype=np.float32)

-    if 'action_t' in model.numpy_inputs:
-      inputs['action_t'] = np.array([lat_action_t, long_action_t], dtype=np.float32)
-
    mt1 = time.perf_counter()
    model_output = model.run(bufs, transforms, inputs, prepare_only)
    mt2 = time.perf_counter()
@@ -471,7 +419,7 @@ def main(demo=False):
      posenet_send = messaging.new_message('cameraOdometry')
      mdv2sp_send = messaging.new_message('modelDataV2SP')

-      action = model.get_action_from_model(model_output, prev_action, lat_action_t, long_action_t, v_ego)
+      action = model.get_action_from_model(model_output, prev_action, lat_delay + DT_MDL, long_delay + DT_MDL, v_ego)
      prev_action = action
      fill_model_msg(drivingdata_send, modelv2_send, model_output, action,
                     publish_state, meta_main.frame_id, meta_extra.frame_id, frame_id,
@@ -481,10 +429,7 @@ def main(demo=False):
      l_lane_change_prob = desire_state[log.Desire.laneChangeLeft]
      r_lane_change_prob = desire_state[log.Desire.laneChangeRight]
      lane_change_prob = l_lane_change_prob + r_lane_change_prob
-      RELC.update(modelv2_send.modelV2.roadEdgeStds, modelv2_send.modelV2.laneLineProbs, v_ego)
-      mdv2sp_send.modelDataV2SP.leftLaneChangeEdgeBlock = RELC.left_edge_detected
-      mdv2sp_send.modelDataV2SP.rightLaneChangeEdgeBlock = RELC.right_edge_detected
-      DH.update(sm['carState'], sm['carControl'].latActive, lane_change_prob, RELC.left_edge_detected, RELC.right_edge_detected)
+      DH.update(sm['carState'], sm['carControl'].latActive, lane_change_prob)
      modelv2_send.modelV2.meta.laneChangeState = DH.lane_change_state
      modelv2_send.modelV2.meta.laneChangeDirection = DH.lane_change_direction
      mdv2sp_send.modelDataV2SP.laneTurnDirection = DH.lane_turn_direction
@@ -1,16 +1,13 @@
 import numpy as np
 from openpilot.sunnypilot.modeld_v2.constants import ModelConstants

-
 def safe_exp(x, out=None):
  # -11 is around 10**14, more causes float16 overflow
  return np.exp(np.clip(x, -np.inf, 11), out=out)

-
 def sigmoid(x):
  return 1. / (1. + safe_exp(-x))

-
 def softmax(x, axis=-1):
  x -= np.max(x, axis=axis, keepdims=True)
  if x.dtype == np.float32 or x.dtype == np.float64:
@@ -20,19 +17,6 @@ def softmax(x, axis=-1):
  x /= np.sum(x, axis=axis, keepdims=True)
  return x

-
-def _infer_mhp(slice_size: int, prod_out_shape: int, max_in_n: int = 16, max_out_n: int = 6) -> tuple[int, int]:
-  for out_n in range(max_out_n + 1):
-    per = 2 * prod_out_shape + out_n
-    if per <= 0:
-      continue
-    if slice_size % per == 0:
-      in_n = slice_size // per
-      if 1 <= in_n <= max_in_n:
-        return in_n, out_n
-  return 1, 0  # single hypothesis, no weights — matches a non-MDN output
-
-
 class Parser:
  def __init__(self, ignore_missing=False):
    self.ignore_missing = ignore_missing
@@ -56,22 +40,17 @@ class Parser:
    raw = outs[name]
    outs[name] = sigmoid(raw)

-  def parse_mdn(self, name, outs, out_shape, in_N=0, out_N=0):
+  def parse_mdn(self, name, outs, in_N=0, out_N=1, out_shape=None):
    if self.check_missing(outs, name):
      return
    raw = outs[name]
-
-    if in_N == 0 and out_N == 0:
-      prod = int(np.prod(out_shape))
-      in_N, out_N = _infer_mhp(raw.shape[1], prod)
-
-    raw = raw.reshape((raw.shape[0], in_N, -1))
+    raw = raw.reshape((raw.shape[0], max(in_N, 1), -1))

    n_values = (raw.shape[2] - out_N)//2
    pred_mu = raw[:,:,:n_values]
    pred_std = safe_exp(raw[:,:,n_values: 2*n_values])

-    if in_N > 1 and out_N > 0:
+    if in_N > 1:
      weights = np.zeros((raw.shape[0], in_N, out_N), dtype=raw.dtype)
      for i in range(out_N):
        weights[:,:,i - out_N] = softmax(raw[:,:,i - out_N], axis=-1)
@@ -82,6 +61,7 @@ class Parser:
          weights[fidx] = weights[fidx][idxs]
          pred_mu[fidx] = pred_mu[fidx][idxs]
          pred_std[fidx] = pred_std[fidx][idxs]
+      assert out_shape is not None
      full_shape = tuple([raw.shape[0], in_N] + list(out_shape))
      outs[name + '_weights'] = weights
      outs[name + '_hypotheses'] = pred_mu.reshape(full_shape)
@@ -94,43 +74,37 @@ class Parser:
          idxs = np.argsort(weights[fidx,:,hidx])[::-1]
          pred_mu_final[fidx, hidx] = pred_mu[fidx, idxs[0]]
          pred_std_final[fidx, hidx] = pred_std[fidx, idxs[0]]
-    elif in_N > 1 and out_N == 0:
-      # MHP without weights: keep every hypothesis intact, surface them as
-      # ``*_hypotheses`` and propagate the full multi-hypothesis tensor.
-      full_shape = tuple([raw.shape[0], in_N] + list(out_shape))
-      outs[name + '_hypotheses'] = pred_mu.reshape(full_shape)
-      outs[name + '_stds_hypotheses'] = pred_std.reshape(full_shape)
-      pred_mu_final = pred_mu
-      pred_std_final = pred_std
    else:
      pred_mu_final = pred_mu
      pred_std_final = pred_std

-    if out_N > 1 or (in_N > 1 and out_N == 0):
-      n_selections = out_N if out_N > 1 else in_N
-      final_shape = tuple([raw.shape[0], n_selections] + list(out_shape))
+    if out_N > 1:
+      assert out_shape is not None
+      final_shape = tuple([raw.shape[0], out_N] + list(out_shape))
    else:
+      assert out_shape is not None
      final_shape = tuple([raw.shape[0],] + list(out_shape))
    outs[name] = pred_mu_final.reshape(final_shape)
    outs[name + '_stds'] = pred_std_final.reshape(final_shape)

  def parse_outputs(self, outs: dict[str, np.ndarray]) -> dict[str, np.ndarray]:
-    # supercombo (4955 / 102) and newer variants (e.g. 990 / 144).
-    self.parse_mdn('plan',   outs, out_shape=(ModelConstants.IDX_N, ModelConstants.PLAN_WIDTH))
-    self.parse_mdn('lane_lines', outs, out_shape=(ModelConstants.NUM_LANE_LINES, ModelConstants.IDX_N, ModelConstants.LANE_LINES_WIDTH))
-    self.parse_mdn('road_edges', outs, out_shape=(ModelConstants.NUM_ROAD_EDGES, ModelConstants.IDX_N, ModelConstants.LANE_LINES_WIDTH))
-    self.parse_mdn('pose',         outs, out_shape=(ModelConstants.POSE_WIDTH,))
-    self.parse_mdn('road_transform', outs, out_shape=(ModelConstants.POSE_WIDTH,))
+    self.parse_mdn('plan', outs, in_N=ModelConstants.PLAN_MHP_N, out_N=ModelConstants.PLAN_MHP_SELECTION,
+                   out_shape=(ModelConstants.IDX_N,ModelConstants.PLAN_WIDTH))
+    self.parse_mdn('lane_lines', outs, in_N=0, out_N=0, out_shape=(ModelConstants.NUM_LANE_LINES,ModelConstants.IDX_N,ModelConstants.LANE_LINES_WIDTH))
+    self.parse_mdn('road_edges', outs, in_N=0, out_N=0, out_shape=(ModelConstants.NUM_ROAD_EDGES,ModelConstants.IDX_N,ModelConstants.LANE_LINES_WIDTH))
+    self.parse_mdn('pose', outs, in_N=0, out_N=0, out_shape=(ModelConstants.POSE_WIDTH,))
+    self.parse_mdn('road_transform', outs, in_N=0, out_N=0, out_shape=(ModelConstants.POSE_WIDTH,))
    if 'sim_pose' in outs:
-      self.parse_mdn('sim_pose', outs, out_shape=(ModelConstants.POSE_WIDTH,))
-    self.parse_mdn('wide_from_device_euler', outs, out_shape=(ModelConstants.WIDE_FROM_DEVICE_WIDTH,))
-    self.parse_mdn('lead', outs, out_shape=(ModelConstants.LEAD_TRAJ_LEN, ModelConstants.LEAD_WIDTH))
+      self.parse_mdn('sim_pose', outs, in_N=0, out_N=0, out_shape=(ModelConstants.POSE_WIDTH,))
+    self.parse_mdn('wide_from_device_euler', outs, in_N=0, out_N=0, out_shape=(ModelConstants.WIDE_FROM_DEVICE_WIDTH,))
+    self.parse_mdn('lead', outs, in_N=ModelConstants.LEAD_MHP_N, out_N=ModelConstants.LEAD_MHP_SELECTION,
+                   out_shape=(ModelConstants.LEAD_TRAJ_LEN,ModelConstants.LEAD_WIDTH))
    if 'lat_planner_solution' in outs:
-      self.parse_mdn('lat_planner_solution', outs, out_shape=(ModelConstants.IDX_N, ModelConstants.LAT_PLANNER_SOLUTION_WIDTH))
+      self.parse_mdn('lat_planner_solution', outs, in_N=0, out_N=0, out_shape=(ModelConstants.IDX_N,ModelConstants.LAT_PLANNER_SOLUTION_WIDTH))
    if 'desired_curvature' in outs:
-      self.parse_mdn('desired_curvature', outs, out_shape=(ModelConstants.DESIRED_CURV_WIDTH,))
+      self.parse_mdn('desired_curvature', outs, in_N=0, out_N=0, out_shape=(ModelConstants.DESIRED_CURV_WIDTH,))
    for k in ['lead_prob', 'lane_lines_prob', 'meta']:
      self.parse_binary_crossentropy(k, outs)
    self.parse_categorical_crossentropy('desire_state', outs, out_shape=(ModelConstants.DESIRE_PRED_WIDTH,))
-    self.parse_categorical_crossentropy('desire_pred',  outs, out_shape=(ModelConstants.DESIRE_PRED_LEN, ModelConstants.DESIRE_PRED_WIDTH))
+    self.parse_categorical_crossentropy('desire_pred', outs, out_shape=(ModelConstants.DESIRE_PRED_LEN,ModelConstants.DESIRE_PRED_WIDTH))
    return outs
@@ -123,7 +123,7 @@ class Parser:
      self.parse_categorical_crossentropy('desire_state', outs, out_shape=(SplitModelConstants.DESIRE_PRED_WIDTH,))
    if 'lane_lines' in outs:
      self.parse_mdn('lane_lines', outs, in_N=0, out_N=0,
-                     out_shape=(SplitModelConstants.NUM_LANE_LINES,SplitModelConstants.IDX_N,SplitModelConstants.LANE_LINES_WIDTH))
+                    out_shape=(SplitModelConstants.NUM_LANE_LINES,SplitModelConstants.IDX_N,SplitModelConstants.LANE_LINES_WIDTH))
    if 'lane_lines_prob' in outs:
      self.parse_binary_crossentropy('lane_lines_prob', outs)
    if 'lead_prob' in outs:
@@ -134,11 +134,9 @@ class Parser:
      self.parse_binary_crossentropy('meta', outs)
    if 'road_edges' in outs:
      self.parse_mdn('road_edges', outs, in_N=0, out_N=0,
-                     out_shape=(SplitModelConstants.NUM_ROAD_EDGES,SplitModelConstants.IDX_N,SplitModelConstants.LANE_LINES_WIDTH))
+                    out_shape=(SplitModelConstants.NUM_ROAD_EDGES,SplitModelConstants.IDX_N,SplitModelConstants.LANE_LINES_WIDTH))
    if 'sim_pose' in outs:
      self.parse_mdn('sim_pose', outs, in_N=0, out_N=0, out_shape=(SplitModelConstants.POSE_WIDTH,))
-    if 'action' in outs:
-      self.parse_mdn('action', outs, in_N=0, out_N=0, out_shape=(SplitModelConstants.ACTION_WIDTH,))

  def parse_vision_outputs(self, outs: dict[str, np.ndarray]) -> dict[str, np.ndarray]:
    self.parse_mdn('pose', outs, in_N=0, out_N=0, out_shape=(SplitModelConstants.POSE_WIDTH,))
@@ -67,12 +67,22 @@ class TestStockEquivalence:
    state = model_state_factory(ARCHETYPES['vision_policy_split'])

    frame_skip = derive_frame_skip(SPLIT_VISION_INPUT_SHAPES, SPLIT_POLICY_INPUT_SHAPES)
+    # action_t is a deep-model prerequisite the SP loader doesn't provide yet; see skip_keys below
    stock_shapes = {**SPLIT_VISION_INPUT_SHAPES, **SPLIT_POLICY_INPUT_SHAPES, 'action_t': (1, 2)}
    stock_queues, stock_npy = make_input_queues(stock_shapes, frame_skip, device='NPY')

-    assert set(state.input_queues.keys()) == set(stock_queues.keys())
-    assert {'desire', 'traffic_convention'} <= set(state.numpy_inputs.keys())
-    assert set(state.numpy_inputs.keys()) == set(stock_npy.keys()) - {'action_t', 'prev_feat'}
+    # TODO-SP: remove action_t skip once SP adds prerequisite for deep models (action_t input queue)
+    # prev_feat is a stock QCOM corruption workaround handled inside the SP loader's JIT path
+    skip_keys = {'action_t', 'prev_feat'}
+    # stock packs the per-key policy inputs into packed_npy_inputs; the npy views carry the individual keys
+    stock_queue_keys = set(stock_queues.keys())
+    if 'packed_npy_inputs' in stock_queue_keys:
+      stock_queue_keys.remove('packed_npy_inputs')
+      stock_queue_keys |= set(stock_npy.keys())
+    assert set(state.input_queues.keys()) == stock_queue_keys - skip_keys, \
+      f"Queue keys differ: v2={set(state.input_queues.keys())}, stock={stock_queue_keys}"
+    assert set(state.numpy_inputs.keys()) == set(stock_npy.keys()) - skip_keys, \
+      f"Npy keys differ: v2={set(state.numpy_inputs.keys())}, stock={set(stock_npy.keys())}"

  def test_split_queue_keys_work_with_desire_key(self, model_state_factory):
    from openpilot.sunnypilot.modeld_v2.compile_modeld import derive_frame_skip, make_split_input_queues
@@ -0,0 +1,103 @@
+import os
+os.environ['DEV'] = 'CPU'
+import pytest
+import numpy as np
+from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
+from openpilot.sunnypilot.modeld_v2.warp import 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'),
+  ('input_imgs', 'big_input_imgs'),
+]
+
+
+class MockVisionBuf:
+  def __init__(self, w, h):
+    self.width = w
+    self.height = h
+    _, _, _, yuv_size = get_nv12_info(w, h)
+    self.data = np.zeros(yuv_size, dtype=np.uint8)
+
+
+@pytest.mark.parametrize("buffer_length", [2, 5])
+def test_warp_initialization(buffer_length):
+  warp = Warp(buffer_length)
+  assert warp.buffer_length == buffer_length
+  assert warp.img_buffer_shape == (buffer_length * 6, MODEL_H // 2, MODEL_W // 2)
+
+
+@pytest.mark.parametrize("buffer_length", [2, 5])
+@pytest.mark.parametrize("cam_w, cam_h", CAMERA_CONFIGS)
+@pytest.mark.parametrize("road, wide", VISION_NAME_PAIRS)
+def test_warp_process(buffer_length, cam_w, cam_h, road, wide):
+  warp = Warp(buffer_length)
+  mock_buf = MockVisionBuf(cam_w, cam_h)
+  transform = np.eye(3, dtype=np.float32).flatten()
+  bufs = {road: mock_buf, wide: mock_buf}
+  transforms = {road: transform, wide: transform}
+
+  out = warp.process(bufs, transforms)
+  assert isinstance(out, dict)
+  assert road in out and wide in out
+  assert out[road].shape == (1, 12, MODEL_H // 2, MODEL_W // 2)
+  assert out[wide].shape == (1, 12, MODEL_H // 2, MODEL_W // 2)
+
+  key = (cam_w, cam_h)
+  assert key in warp.jit_cache
+
+  out2 = warp.process(bufs, transforms)
+  assert out2[road].shape == out[road].shape
+
+
+@pytest.mark.parametrize("road, wide", VISION_NAME_PAIRS)
+def test_warp_buffer_shift(road, wide):
+  warp = Warp(2)
+  cam_w, cam_h = CAMERA_CONFIGS[1]
+  transform = np.eye(3, dtype=np.float32).flatten()
+
+  buf1 = MockVisionBuf(cam_w, cam_h)
+  buf1.data[0] = 255
+  bufs1 = {road: buf1, wide: buf1}
+  transforms = {road: transform, wide: transform}
+  out1 = warp.process(bufs1, transforms)
+  road1 = out1[road].numpy().copy()
+
+  buf2 = MockVisionBuf(cam_w, cam_h)
+  buf2.data[0] = 128
+  bufs2 = {road: buf2, wide: buf2}
+  out2 = warp.process(bufs2, transforms)
+  assert not np.array_equal(road1, out2[road].numpy())
+
+
+@pytest.mark.parametrize("buffer_length", [2, 5])
+@pytest.mark.parametrize("road, wide", VISION_NAME_PAIRS)
+def test_warp_buffer_accumulation(buffer_length, road, wide):
+  warp = Warp(buffer_length)
+  cam_w, cam_h = CAMERA_CONFIGS[0]
+  transform = np.eye(3, dtype=np.float32).flatten()
+  transforms = {road: transform, wide: transform}
+  outputs = []
+
+  for i in range(buffer_length + 1):
+    buf = MockVisionBuf(cam_w, cam_h)
+    buf.data[:] = i * 10
+    out = warp.process({road: buf, wide: buf}, transforms)
+    outputs.append(out[road].numpy().copy())
+
+  assert warp.full_buffers['img'].shape == (buffer_length * 6, MODEL_H // 2, MODEL_W // 2)
+  for i in range(1, len(outputs)):
+    assert not np.array_equal(outputs[i - 1], outputs[i])
+
+
+def test_warp_different_cameras_same_instance():
+  warp = Warp(2)
+  transform = np.eye(3, dtype=np.float32).flatten()
+
+  buf1 = MockVisionBuf(*CAMERA_CONFIGS[0])
+  warp.process({'img': buf1, 'big_img': buf1}, {'img': transform, 'big_img': transform})
+  assert len(warp.jit_cache) == 1
+
+  buf2 = MockVisionBuf(*CAMERA_CONFIGS[1])
+  warp.process({'img': buf2, 'big_img': buf2}, {'img': transform, 'big_img': transform})
+  assert len(warp.jit_cache) == 2
@@ -0,0 +1,171 @@
+import pickle
+import time
+import numpy as np
+from pathlib import Path
+from tinygrad.tensor import Tensor
+from tinygrad.engine.jit import TinyJit
+from tinygrad.device import Device
+
+from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
+from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE
+from openpilot.common.transformations.camera import _ar_ox_fisheye, _os_fisheye
+from openpilot.selfdrive.modeld.compile_modeld import NV12Frame, make_frame_prepare as _make_frame_prepare
+
+CAMERA_CONFIGS = [
+  (_ar_ox_fisheye.width, _ar_ox_fisheye.height),
+  (_os_fisheye.width, _os_fisheye.height),
+]
+
+
+def make_frame_prepare(cam_w, cam_h, model_w, model_h):
+  nv12 = NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h))
+  return _make_frame_prepare(nv12, model_w, model_h)
+
+
+def warp_pkl_path(w, h):
+  from openpilot.selfdrive.modeld.helpers import MODELS_DIR
+  return MODELS_DIR / f'warp_{w}x{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
+
+MODELS_DIR = Path(__file__).parent / 'models'
+MODEL_W, MODEL_H = MEDMODEL_INPUT_SIZE
+UPSTREAM_BUFFER_LENGTH = 5
+
+
+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):
+  _, _, _, yuv_size = get_nv12_info(cam_w, cam_h)
+  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}...")
+
+  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.default_rng(0).integers(0, 256, yuv_size, dtype=np.uint8)
+  new_big_frame_np = np.random.default_rng(1).integers(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 = v2_warp_pkl_path(cam_w, cam_h, buffer_length)
+  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"))
+  verify_frame = np.random.default_rng(0).integers(0, 256, yuv_size, dtype=np.uint8)
+  verify_big_frame = np.random.default_rng(1).integers(0, 256, yuv_size, dtype=np.uint8)
+  fresh_inputs = [
+    Tensor.zeros(img_buffer_shape, dtype='uint8').contiguous().realize(),
+    Tensor.from_blob(verify_frame.ctypes.data, (yuv_size,), dtype='uint8').realize(),
+    Tensor(Tensor.randn(3, 3).mul(8).realize().numpy(), device='NPY'),
+    Tensor.zeros(img_buffer_shape, dtype='uint8').contiguous().realize(),
+    Tensor.from_blob(verify_big_frame.ctypes.data, (yuv_size,), dtype='uint8').realize(),
+    Tensor(Tensor.randn(3, 3).mul(8).realize().numpy(), device='NPY'),
+  ]
+  jit(*fresh_inputs)
+
+
+class Warp:
+  def __init__(self, buffer_length=2):
+    self.buffer_length = buffer_length
+    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']}
+    self._blob_cache: dict[int, Tensor] = {}
+    self._nv12_cache: dict[tuple[int, int], int] = {}
+    self.transforms_np = {k: np.zeros((3, 3), dtype=np.float32) for k in ['img', 'big_img']}
+    self.transforms = {k: Tensor(v, device='NPY').realize() for k, v in self.transforms_np.items()}
+
+  def process(self, bufs, transforms):
+    if not bufs:
+      return {}
+    road = next(n for n in bufs if 'big' not in n)
+    wide = next(n for n in bufs if 'big' in n)
+    cam_w, cam_h = bufs[road].width, bufs[road].height
+    key = (cam_w, cam_h)
+
+    if key not in self.jit_cache:
+      v2_pkl = v2_warp_pkl_path(cam_w, cam_h, self.buffer_length)
+      if v2_pkl.exists():
+        with open(v2_pkl, 'rb') as f:
+          self.jit_cache[key] = pickle.load(f)
+      elif self.buffer_length == UPSTREAM_BUFFER_LENGTH:
+        upstream_pkl = warp_pkl_path(cam_w, cam_h)
+        if upstream_pkl.exists():
+          with open(upstream_pkl, 'rb') as f:
+            self.jit_cache[key] = pickle.load(f)
+      if key not in self.jit_cache:
+        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:
+      self._nv12_cache[key] = get_nv12_info(cam_w, cam_h)[3]
+    yuv_size = self._nv12_cache[key]
+
+    road_ptr = bufs[road].data.ctypes.data
+    wide_ptr = bufs[wide].data.ctypes.data
+    if road_ptr not in self._blob_cache:
+      self._blob_cache[road_ptr] = Tensor.from_blob(road_ptr, (yuv_size,), dtype='uint8')
+    if wide_ptr not in self._blob_cache:
+      self._blob_cache[wide_ptr] = Tensor.from_blob(wide_ptr, (yuv_size,), dtype='uint8')
+    road_blob = self._blob_cache[road_ptr]
+    wide_blob = self._blob_cache[wide_ptr] if wide_ptr != road_ptr else Tensor.from_blob(wide_ptr, (yuv_size,), dtype='uint8')
+    np.copyto(self.transforms_np['img'], transforms[road].reshape(3, 3))
+    np.copyto(self.transforms_np['big_img'], transforms[wide].reshape(3, 3))
+
+    Device.default.synchronize()
+    res = self.jit_cache[key](
+      self.full_buffers['img'], road_blob, self.transforms['img'],
+      self.full_buffers['big_img'], wide_blob, self.transforms['big_img'],
+    )
+    out_road = res[0].realize()
+    out_wide = res[1].realize()
+
+    return {road: out_road, wide: out_wide}
+
+
+if __name__ == "__main__":
+  for cam_w, cam_h in CAMERA_CONFIGS:
+    for bl in [2, 5]:
+      compile_v2_warp(cam_w, cam_h, bl)
@@ -6,12 +6,11 @@ See the LICENSE.md file in the root directory for more details.
 """

 import time
-import os
+
 import requests
 from requests.exceptions import (SSLError, RequestException, HTTPError)
 from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
-from openpilot.common.hardware.hw import Paths
 from openpilot.sunnypilot.models.helpers import is_bundle_version_compatible

 from openpilot.cereal import custom
@@ -27,35 +26,11 @@ class ModelParser:
    download_uri.sha256 = download_uri_data.get("sha256")
    return download_uri

-  @staticmethod
-  def _parse_chunk(chunk_data) -> custom.ModelManagerSP.Chunk:
-    chunk = custom.ModelManagerSP.Chunk()
-    chunk.fileName = chunk_data.get("file_name")
-    chunk.sha256 = chunk_data.get("sha256")
-    return chunk
-
  @staticmethod
  def _parse_artifact(artifact_data) -> custom.ModelManagerSP.Artifact:
    artifact = custom.ModelManagerSP.Artifact()
    artifact.fileName = artifact_data.get("file_name")
    artifact.downloadUri = ModelParser._parse_download_uri(artifact_data.get("download_uri", {}))
-
-    if "chunks" in artifact_data:
-      artifact.chunks = [ModelParser._parse_chunk(chunk_data) for chunk_data in artifact_data["chunks"]]
-
-      try:
-        model_dir = Paths.model_root()
-        os.makedirs(model_dir, exist_ok=True)
-        manifest_path = os.path.join(model_dir, f"{artifact.fileName}.chunkmanifest")
-        num_chunks = str(len(artifact.chunks))
-
-        if not os.path.exists(manifest_path) or open(manifest_path).read().strip() != num_chunks:
-          with open(manifest_path, "w") as f:
-            f.write(num_chunks)
-          cloudlog.info(f"Wrote chunk manifest for {artifact.fileName}: {num_chunks} chunks")
-      except Exception as e:
-        cloudlog.warning(f"Failed to write chunk manifest for {artifact.fileName}: {e}")
-
    return artifact

  @staticmethod
@@ -64,6 +39,8 @@ class ModelParser:

    model.type = model_data.get("type")
    model.artifact = ModelParser._parse_artifact(model_data.get("artifact", {}))
+    if metadata := model_data.get("metadata"):
+      model.metadata = ModelParser._parse_artifact(metadata)
    return model

  @staticmethod
@@ -139,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_v18.json"
+  MODEL_URL = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_v17.json"

  def __init__(self, params: Params):
    self.params = params
@@ -207,5 +184,4 @@ if __name__ == "__main__":
      # Print artifact details
      print(f"Artifact: {model.artifact.fileName}, Download URI: {model.artifact.downloadUri.uri}")
      # Print metadata details
-      if model.artifact.chunks:
-        print(f"Contains {len(model.artifact.chunks)} chunks.")
+      print(f"Metadata: {model.metadata.fileName}, Download URI: {model.metadata.downloadUri.uri}")
@@ -18,7 +18,7 @@ from openpilot.sunnypilot.models.constants import Meta, MetaSimPose, MetaTombRai
 from openpilot.common.hardware.hw import Paths

 # SET ME TO THE EXACT JSON VERSION WE SET IN SUNNYPILOT_MODELS REPO
-REQUIRED_JSON_VERSION = 16
+REQUIRED_JSON_VERSION = 15

 CUSTOM_MODEL_PATH = Paths.model_root()
 METADATA_PATH = Path(__file__).parent / '../models/supercombo_metadata.pkl'
@@ -56,20 +56,12 @@ def is_bundle_version_compatible(bundle: dict) -> bool:

 def _bundle_artifacts(bundle: custom.ModelManagerSP.ModelBundle) -> list[tuple[str, str]]:
  artifacts = []
-  from openpilot.common.file_chunker import get_chunk_name
  for model in getattr(bundle, 'models', []) or []:
-    for artifact in (getattr(model, 'artifact', None),):
-      if artifact and getattr(artifact, 'fileName', None):
-        if len(artifact.chunks) > 0:
-          for i, chunk in enumerate(artifact.chunks):
-            chunk_name = get_chunk_name(artifact.fileName, i, len(artifact.chunks))
-            if getattr(chunk, 'sha256', None):
-              artifacts.append((chunk_name, chunk.sha256))
-        else:
-          if getattr(artifact, 'downloadUri', None):
-            sha256 = getattr(artifact.downloadUri, 'sha256', None)
-            if sha256:
-              artifacts.append((artifact.fileName, sha256))
+    for artifact in (getattr(model, 'artifact', None), getattr(model, 'metadata', None)):
+      if artifact and getattr(artifact, 'fileName', None) and getattr(artifact, 'downloadUri', None):
+        sha256 = getattr(artifact.downloadUri, 'sha256', None)
+        if sha256:
+          artifacts.append((artifact.fileName, sha256))
  return artifacts


@@ -164,7 +156,8 @@ def _get_model():


 def load_metadata():
-  metadata_path = METADATA_PATH
+  model = _get_model()
+  metadata_path = f"{CUSTOM_MODEL_PATH}/{model.metadata.fileName}" if model else METADATA_PATH

  with open(metadata_path, 'rb') as f:
    return pickle.load(f)
@@ -38,11 +38,11 @@ class ModelManagerSP:
    if not self.selected_bundle:
      return
    for model in self.selected_bundle.models:
-      artifact = model.artifact
-      if artifact is not source_artifact and artifact.fileName == source_artifact.fileName:
-        artifact.downloadProgress.status = source_artifact.downloadProgress.status
-        artifact.downloadProgress.progress = source_artifact.downloadProgress.progress
-        artifact.downloadProgress.eta = source_artifact.downloadProgress.eta
+      for artifact in (model.artifact, model.metadata):
+        if artifact is not source_artifact and artifact.fileName == source_artifact.fileName:
+          artifact.downloadProgress.status = source_artifact.downloadProgress.status
+          artifact.downloadProgress.progress = source_artifact.downloadProgress.progress
+          artifact.downloadProgress.eta = source_artifact.downloadProgress.eta

  def _calculate_eta(self, filename: str, progress: float) -> int:
    """Calculate ETA based on elapsed time and current progress"""
@@ -89,16 +89,20 @@ class ModelManagerSP:
        del self._download_start_times[model.fileName]

  async def _download_chunked(self, base_url: str, base_path: str, artifact) -> None:
-    from openpilot.common.file_chunker import get_chunk_name, get_manifest_path
-
-    num_chunks = len(artifact.chunks)
-    if num_chunks == 0:
-      raise ValueError("No chunks defined in artifact")
-
+    from openpilot.common.file_chunker import get_manifest_path, get_chunk_name
+    manifest_url = get_manifest_path(base_url)
    manifest_path = get_manifest_path(base_path)
+
+    async with aiohttp.ClientSession() as session:
+      async with session.get(manifest_url) as resp:
+        if resp.status == 404:
+          raise FileNotFoundError
+        resp.raise_for_status()
+        num_chunks = int((await resp.read()).strip())
+
    self._download_start_times[artifact.fileName] = time.monotonic()

-    for i, _ in enumerate(artifact.chunks):
+    for i in range(num_chunks):
      chunk_url = get_chunk_name(base_url, i, num_chunks)
      chunk_path = get_chunk_name(base_path, i, num_chunks)
      chunk_downloaded = 0
@@ -113,7 +117,7 @@ class ModelManagerSP:
              if self.params.get("ModelManager_DownloadIndex") is None:
                raise Exception("Download cancelled")
              intra = chunk_downloaded / max(chunk_size, 1)
-              progress = min(99.0, ((i + intra) / num_chunks) * 100)
+              progress = min(99, (i + intra) / num_chunks * 100)
              artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.downloading
              artifact.downloadProgress.progress = progress
              artifact.downloadProgress.eta = self._calculate_eta(artifact.fileName, progress)
@@ -136,22 +140,7 @@ class ModelManagerSP:
    full_path = os.path.join(destination_path, filename)

    try:
-      is_cached = False
-      if len(artifact.chunks) > 0:
-        from openpilot.common.file_chunker import get_chunk_name
-        chunks_valid = True
-        for i, chunk in enumerate(artifact.chunks):
-          chunk_path = get_chunk_name(full_path, i, len(artifact.chunks))
-          if not await verify_file(chunk_path, chunk.sha256):
-            chunks_valid = False
-            break
-        if chunks_valid and len(artifact.chunks) > 0:
-          is_cached = True
-      else:
-        if await verify_file(full_path, expected_hash):
-          is_cached = True
-
-      if is_cached:
+      if await verify_file(full_path, expected_hash):
        artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.cached
        artifact.downloadProgress.progress = 100
        artifact.downloadProgress.eta = 0
@@ -159,17 +148,13 @@ class ModelManagerSP:
        self._report_status()
        return

-      if len(artifact.chunks) > 0:
+      try:
        await self._download_chunked(url, full_path, artifact)
-        from openpilot.common.file_chunker import get_chunk_name
-        for i, chunk in enumerate(artifact.chunks):
-          chunk_path = get_chunk_name(full_path, i, len(artifact.chunks))
-          if not await verify_file(chunk_path, chunk.sha256):
-            raise ValueError(f"Hash validation failed for chunk {i+1} of {filename}")
-      else:
+      except (FileNotFoundError, aiohttp.ClientResponseError):
        await self._download_file(url, full_path, artifact)
-        if not await verify_file(full_path, expected_hash):
-          raise ValueError(f"Hash validation failed for {filename}")
+
+      if not await verify_file(full_path, expected_hash):
+        raise ValueError(f"Hash validation failed for {filename}")

      artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.downloaded
      artifact.downloadProgress.progress = 100
@@ -185,15 +170,18 @@ class ModelManagerSP:
      artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.failed
      artifact.downloadProgress.eta = 0
      self._sync_artifact_progress(artifact)
-      if self.selected_bundle:
-        self.selected_bundle.status = custom.ModelManagerSP.DownloadStatus.failed
+      self.selected_bundle.status = custom.ModelManagerSP.DownloadStatus.failed
      self._report_status()
      self._download_start_times.pop(artifact.fileName, None)
      raise

  async def _process_model(self, model, destination_path: str) -> None:
    """Processes a single model download including verification"""
-    await self._process_artifact(model.artifact, destination_path)
+    model_artifact = model.artifact
+    metadata_artifact = model.metadata
+
+    await self._process_artifact(metadata_artifact, destination_path)
+    await self._process_artifact(model_artifact, destination_path)

  def _report_status(self) -> None:
    """Reports current status through messaging system"""
@@ -217,16 +205,16 @@ class ModelManagerSP:
    try:
      seen_artifacts: set[str] = set()
      for model in self.selected_bundle.models:
-        artifact = model.artifact
-        if not artifact.fileName:
-          continue
-        if artifact.fileName in seen_artifacts:
-          artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.cached
-          artifact.downloadProgress.progress = 100
-          artifact.downloadProgress.eta = 0
-        else:
-          seen_artifacts.add(artifact.fileName)
-          await self._process_artifact(artifact, destination_path)
+        for artifact in (model.metadata, model.artifact):
+          if not artifact.fileName:
+            continue
+          if artifact.fileName in seen_artifacts:
+            artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.cached
+            artifact.downloadProgress.progress = 100
+            artifact.downloadProgress.eta = 0
+          else:
+            seen_artifacts.add(artifact.fileName)
+            await self._process_artifact(artifact, destination_path)

      self.active_bundle = self.selected_bundle
      self.active_bundle.status = custom.ModelManagerSP.DownloadStatus.downloaded
@@ -287,6 +275,8 @@ class ModelManagerSP:
      for model in self.active_bundle.models:
        if hasattr(model, 'artifact') and model.artifact.fileName:
          active_files.append(model.artifact.fileName)
+        if hasattr(model, 'metadata') and model.metadata.fileName:
+          active_files.append(model.metadata.fileName)

    # Remove all files except active ones (including their chunk files)
    model_dir = Paths.model_root()
@@ -0,0 +1,28 @@
+from openpilot.sunnypilot.models.helpers import get_active_bundle
+from openpilot.sunnypilot.models.runners.model_runner import ModelRunner
+from openpilot.sunnypilot.models.runners.tinygrad.tinygrad_runner import TinygradRunner, TinygradSplitRunner
+from openpilot.sunnypilot.models.runners.constants import ModelType
+
+
+def get_model_runner() -> ModelRunner:
+  """
+  Factory function to create and return the appropriate ModelRunner instance.
+
+  Selects TinygradRunner, choosing TinygradSplitRunner if separate vision/policy
+  models are detected in the active bundle.
+
+  :return: An instance of a ModelRunner subclass (ONNXRunner, TinygradRunner, or TinygradSplitRunner).
+  """
+  bundle = get_active_bundle()
+  if bundle and bundle.models:
+    model_types = {m.type.raw for m in bundle.models}
+    # Check if the bundle uses separate vision and policy models (legacy or new split format)
+    split_types = {ModelType.vision, ModelType.policy, ModelType.offPolicy, ModelType.onPolicy}
+    if model_types & split_types:
+      return TinygradSplitRunner()
+    # Otherwise, assume a single model (likely supercombo)
+    if bundle.models:
+      return TinygradRunner(bundle.models[0].type.raw)
+
+  # Default fallback to TinygradRunner with the supercombo type if bundle info is missing/incomplete
+  return TinygradRunner(ModelType.supercombo)
@@ -0,0 +1,174 @@
+from abc import abstractmethod, ABC
+
+import numpy as np
+from openpilot.sunnypilot.models.helpers import get_active_bundle
+from openpilot.sunnypilot.models.runners.constants import NumpyDict, ShapeDict, Model, SliceDict, SEND_RAW_PRED
+from openpilot.common.hardware.hw import Paths
+import pickle
+
+CUSTOM_MODEL_PATH = Paths.model_root()
+
+
+class ModelData:
+  """
+  Stores metadata and configuration for a specific machine learning model.
+
+  This class loads model metadata (like input shapes and output slices)
+  from a pickle file associated with a model instance.
+
+  :param model: The machine learning model object containing metadata.
+  """
+  def __init__(self, model: Model):
+    self.model = model
+    self.metadata = model.metadata
+    self.input_shapes: ShapeDict = {}
+    self.output_slices: SliceDict = {}
+    if self.metadata:
+      self._load_metadata()
+
+  def _load_metadata(self) -> None:
+    """Loads input shapes and output slices from the model's metadata pickle file."""
+    metadata_path = f"{CUSTOM_MODEL_PATH}/{self.metadata.fileName}"
+    with open(metadata_path, 'rb') as f:
+      model_metadata = pickle.load(f)
+    self.input_shapes = model_metadata.get('input_shapes', {})
+    self.output_slices = model_metadata.get('output_slices', {})
+
+
+class ModularRunner(ABC):
+  """
+  Represents a modular runner for handling and slicing model outputs.
+
+  This abstract base class is designed to provide an interface for modular
+  parsing and processing of model outputs. Classes inheriting from it must
+  implement the specified abstract methods, defining how model outputs
+  should be handled and stored. The primary goal is to enable structured
+  parsing of outputs through a dictionary-based method mapping.
+
+  :ivar parser_method_dict: Mapping dictionary containing parser methods
+      for handling specific types of outputs.
+  :type parser_method_dict: dict
+  """
+
+  @property
+  @abstractmethod
+  def parser_method_dict(self) -> dict:
+    pass
+
+  @parser_method_dict.setter
+  @abstractmethod
+  def parser_method_dict(self, value: dict) -> None:
+    pass
+
+  @abstractmethod
+  def _slice_outputs(self, model_outputs: np.ndarray) -> NumpyDict:
+    pass
+
+
+class ModelRunner(ModularRunner):
+  """
+  Abstract base class for managing and executing machine learning models.
+
+  Provides a common interface for loading models, preparing inputs, running
+  inference, and slicing/parsing outputs based on model metadata. Derived
+  classes implement the specifics of input preparation and model execution
+  for different frameworks (e.g., Tinygrad, ONNX).
+  """
+
+  def __init__(self):
+    """Initializes the model runner, loading the active model bundle."""
+    self.is_20hz: bool | None = None
+    self.is_20hz_3d: bool | None = None
+    self.models: dict[int, ModelData] = {}
+    self._model_data: ModelData | None = None  # Active model data for current operation
+    self._parser_method_dict: dict = {}
+    self.inputs: dict = {}
+    self._parser = None
+    self._load_models()
+    self._constants = None
+
+  @property
+  def constants(self):
+    return self._constants
+
+  @property
+  def parser_method_dict(self) -> dict:
+    """Returns the dictionary mapping model types to their respective parsing methods."""
+    return self._parser_method_dict
+
+  @parser_method_dict.setter
+  def parser_method_dict(self, value: dict) -> None:
+    """Sets the dictionary mapping model types to their respective parsing methods."""
+    self._parser_method_dict = value
+
+  def _load_models(self) -> None:
+    """Loads the active model bundle configuration and sets up ModelData."""
+    bundle = get_active_bundle()
+    if not bundle:
+      raise ValueError("No active model bundle found, why are we being executed?")
+
+    self.models = {model.type.raw: ModelData(model) for model in bundle.models}
+    self.is_20hz = bundle.is20hz
+    self.is_20hz_3d = False
+
+  @property
+  def input_shapes(self) -> ShapeDict:
+    """Returns the input shapes for the currently active model."""
+    if self._model_data:
+      return self._model_data.input_shapes
+    raise ValueError("Model data is not available. Ensure the model is loaded correctly.")
+
+  @property
+  def output_slices(self) -> SliceDict:
+    """Returns the output slices for the currently active model."""
+    if self._model_data:
+      return self._model_data.output_slices
+    raise ValueError("Model data is not available. Ensure the model is loaded correctly.")
+
+  @property
+  def vision_input_names(self) -> list[str]:
+    """Returns the list of vision input names from the input shapes."""
+    if self._model_data:
+      return list(self._model_data.input_shapes.keys())
+    raise ValueError("Model data is not available. Ensure the model is loaded correctly.")
+
+  @abstractmethod
+  def prepare_inputs(self, numpy_inputs: NumpyDict) -> dict:
+    """
+    Abstract method to prepare inputs for model inference.
+
+    :param numpy_inputs: Dictionary of numpy arrays for non-image inputs.
+    :return: Dictionary of prepared inputs ready for the model.
+    """
+    raise NotImplementedError
+
+  @abstractmethod
+  def _run_model(self) -> NumpyDict:
+    """
+    Abstract method to execute model inference with prepared inputs.
+
+    :return: Dictionary containing the model's raw output arrays.
+    """
+    raise NotImplementedError
+
+  def _slice_outputs(self, model_outputs: np.ndarray) -> NumpyDict:
+    """
+    Slices the raw model output array based on the output_slices metadata.
+
+    :param model_outputs: The raw numpy array output from the model.
+    :return: A dictionary where keys are output names and values are sliced numpy arrays.
+    """
+    if not self._model_data:
+      raise ValueError("Model data is not available. Ensure the model is loaded correctly.")
+    sliced_outputs = {k: model_outputs[np.newaxis, v] for k, v in self._model_data.output_slices.items()}
+    if SEND_RAW_PRED:
+      sliced_outputs['raw_pred'] = model_outputs.copy()  # Optionally include the full raw output
+    return sliced_outputs
+
+  def run_model(self) -> NumpyDict:
+    """
+    Executes the model inference pipeline: runs the model and parses outputs.
+
+    :return: Dictionary containing the final parsed model outputs.
+    """
+    return self._run_model()  # Parsing is handled within specific runner implementations
@@ -0,0 +1,91 @@
+import os
+from abc import ABC
+
+import numpy as np
+from openpilot.sunnypilot.modeld_v2.parse_model_outputs import Parser as CombinedParser
+from openpilot.sunnypilot.modeld_v2.parse_model_outputs_split import Parser as SplitParser
+from openpilot.sunnypilot.models.runners.constants import ModelType, NumpyDict
+from openpilot.sunnypilot.models.runners.model_runner import ModularRunner
+from openpilot.common.hardware.hw import Paths
+
+
+SEND_RAW_PRED = os.getenv('SEND_RAW_PRED')
+CUSTOM_MODEL_PATH = Paths.model_root()
+
+
+class OffPolicyTinygrad(ModularRunner, ABC):
+  """
+  A TinygradRunner specialized for off-policy models.
+
+  Uses a SplitParser to handle outputs specific to the off-policy part of a split model setup.
+  """
+  def __init__(self):
+    self._off_policy_parser = SplitParser()
+    self.parser_method_dict[ModelType.offPolicy] = self._parse_off_policy_outputs
+
+  def _parse_off_policy_outputs(self, model_outputs: np.ndarray) -> NumpyDict:
+    """Parses off-policy model outputs using SplitParser."""
+    result: NumpyDict = self._off_policy_parser.parse_policy_outputs(self._slice_outputs(model_outputs))
+    return result
+
+
+class OnPolicyTinygrad(ModularRunner, ABC):
+  """
+  A TinygradRunner specialized for on-policy models.
+
+  Uses a SplitParser to handle outputs specific to the on-policy part of a split model setup.
+  """
+  def __init__(self):
+    self._on_policy_parser = SplitParser()
+    self.parser_method_dict[ModelType.onPolicy] = self._parse_on_policy_outputs
+
+  def _parse_on_policy_outputs(self, model_outputs: np.ndarray) -> NumpyDict:
+    """Parses on-policy model outputs using SplitParser."""
+    result: NumpyDict = self._on_policy_parser.parse_policy_outputs(self._slice_outputs(model_outputs))
+    return result
+
+
+class PolicyTinygrad(ModularRunner, ABC):
+  """
+  A TinygradRunner specialized for policy-only models.
+
+  Uses a SplitParser to handle outputs specific to the policy part of a split model setup.
+  """
+  def __init__(self):
+    self._policy_parser = SplitParser()
+    self.parser_method_dict[ModelType.policy] = self._parse_policy_outputs
+
+  def _parse_policy_outputs(self, model_outputs: np.ndarray) -> NumpyDict:
+    """Parses policy model outputs using SplitParser."""
+    result: NumpyDict = self._policy_parser.parse_policy_outputs(self._slice_outputs(model_outputs))
+    return result
+
+class VisionTinygrad(ModularRunner, ABC):
+  """
+  A TinygradRunner specialized for vision-only models.
+
+  Uses a SplitParser to handle outputs specific to the vision part of a split model setup.
+  """
+  def __init__(self):
+    self._vision_parser = SplitParser()
+    self.parser_method_dict[ModelType.vision] = self._parse_vision_outputs
+
+  def _parse_vision_outputs(self, model_outputs: np.ndarray) -> NumpyDict:
+    """Parses vision model outputs using SplitParser."""
+    result: NumpyDict = self._vision_parser.parse_vision_outputs(self._slice_outputs(model_outputs))
+    return result
+
+class SupercomboTinygrad(ModularRunner, ABC):
+  """
+  A TinygradRunner specialized for vision-only models.
+
+  Uses a SplitParser to handle outputs specific to the vision part of a split model setup.
+  """
+  def __init__(self):
+    self._supercombo_parser = CombinedParser()
+    self.parser_method_dict[ModelType.supercombo] = self._parse_supercombo_outputs
+
+  def _parse_supercombo_outputs(self, model_outputs: np.ndarray) -> NumpyDict:
+    """Parses vision model outputs using SplitParser."""
+    result: NumpyDict = self._supercombo_parser.parse_outputs(self._slice_outputs(model_outputs))
+    return result
@@ -0,0 +1,179 @@
+import pickle
+
+import numpy as np
+from openpilot.sunnypilot.models.runners.constants import NumpyDict, ModelType, ShapeDict, CUSTOM_MODEL_PATH, SliceDict
+from openpilot.sunnypilot.models.runners.model_runner import ModelRunner
+from openpilot.sunnypilot.models.runners.tinygrad.model_types import PolicyTinygrad, VisionTinygrad, SupercomboTinygrad, OffPolicyTinygrad, OnPolicyTinygrad
+from openpilot.sunnypilot.models.split_model_constants import SplitModelConstants
+from openpilot.sunnypilot.modeld_v2.constants import ModelConstants
+
+from tinygrad.tensor import Tensor
+
+
+class TinygradRunner(ModelRunner, SupercomboTinygrad, PolicyTinygrad, VisionTinygrad, OffPolicyTinygrad, OnPolicyTinygrad):
+  """
+  A ModelRunner implementation for executing Tinygrad models.
+
+  Handles loading Tinygrad model artifacts (.pkl), preparing inputs as Tinygrad
+  Tensors (potentially using QCOM extensions on TICI), running inference,
+  and parsing the outputs.
+
+  :param model_type: The type of model (e.g., supercombo) to load and run.
+  """
+  def __init__(self, model_type: int = ModelType.supercombo):
+    ModelRunner.__init__(self)
+    SupercomboTinygrad.__init__(self)
+    PolicyTinygrad.__init__(self)
+    VisionTinygrad.__init__(self)
+    OffPolicyTinygrad.__init__(self)
+    OnPolicyTinygrad.__init__(self)
+    self._constants = ModelConstants
+    self._model_data = self.models.get(model_type)
+    if not self._model_data or not self._model_data.model:
+      raise ValueError(f"Model data for type {model_type} not available.")
+
+    artifact_filename = self._model_data.model.artifact.fileName
+    assert artifact_filename.endswith('_tinygrad.pkl'), \
+      f"Invalid model file {artifact_filename} for TinygradRunner"
+
+    model_pkl_path = f"{CUSTOM_MODEL_PATH}/{artifact_filename}"
+    with open(model_pkl_path, "rb") as f:
+      try:
+        # Load the compiled Tinygrad model runner function
+        self.model_run = pickle.load(f)
+      except FileNotFoundError as e:
+        # Provide a helpful error message if the model was built for a different platform
+        assert "/dev/kgsl-3d0" not in str(e), "Model was built on C3 or C3X, but is being loaded on PC"
+        raise
+
+    # Map input names to their required dtype and device from the loaded model
+    self.input_to_dtype = {}
+    self.input_to_device = {}
+    for idx, name in enumerate(self.model_run.captured.expected_names):
+      info = self.model_run.captured.expected_input_info[idx]
+      self.input_to_dtype[name] = info[2]  # dtype
+      self.input_to_device[name] = info[3]  # device
+    self._policy_cached = False
+
+  @property
+  def vision_input_names(self) -> list[str]:
+    """Returns the list of vision input names from the input shapes."""
+    return [name for name in self.input_shapes.keys() if 'img' in name]
+
+
+  def prepare_policy_inputs(self, numpy_inputs: NumpyDict):
+    if not self._policy_cached:
+      for key, value in numpy_inputs.items():
+        self.inputs[key] = Tensor(value, device='NPY').realize()
+      self._policy_cached = True
+
+  def prepare_inputs(self, numpy_inputs: NumpyDict) -> dict:
+    """Prepares all vision and policy inputs for the model."""
+    self.prepare_policy_inputs(numpy_inputs)
+    for key in self.vision_input_names:
+      if key in self.inputs:
+        self.inputs[key] = self.inputs[key].cast(self.input_to_dtype[key])
+    return self.inputs
+
+  def _run_model(self) -> NumpyDict:
+    """Runs the Tinygrad model inference and parses the outputs."""
+    outputs = self.model_run(**self.inputs).contiguous().realize().uop.base.buffer.numpy().flatten()
+    return self._parse_outputs(outputs)
+
+  def _parse_outputs(self, model_outputs: np.ndarray) -> NumpyDict:
+    """Parses the raw model outputs using the standard Parser."""
+    if self._model_data is None:
+      raise ValueError("Model data is not available. Ensure the model is loaded correctly.")
+
+    result: NumpyDict = self.parser_method_dict[self._model_data.model.type.raw](model_outputs)
+    return result
+
+
+class TinygradSplitRunner(ModelRunner):
+  """
+  A ModelRunner that coordinates separate TinygradVisionRunner and TinygradPolicyRunner instances.
+
+  Manages the execution of split vision and policy models, combining their inputs and outputs.
+  """
+  def __init__(self):
+    super().__init__()
+    self.is_20hz_3d = True
+    self.vision_runner = TinygradRunner(ModelType.vision)
+    self.policy_runner = TinygradRunner(ModelType.policy) if self.models.get(ModelType.policy) else None
+    self.off_policy_runner = TinygradRunner(ModelType.offPolicy) if self.models.get(ModelType.offPolicy) else None
+    self.on_policy_runner = TinygradRunner(ModelType.onPolicy) if self.models.get(ModelType.onPolicy) else None
+    self._constants = SplitModelConstants
+
+  def _run_model(self) -> NumpyDict:
+    """Runs both vision and policy models and merges their parsed outputs."""
+    vision_output = self.vision_runner.run_model()
+    outputs = {**vision_output}
+
+    if self.policy_runner:
+      policy_output = self.policy_runner.run_model()
+      outputs.update(policy_output)
+
+    if self.off_policy_runner:
+      off_policy_output = self.off_policy_runner.run_model()
+      if self.on_policy_runner:
+        off_policy_output.pop('plan', None)
+      outputs.update(off_policy_output)
+
+    if self.on_policy_runner:
+      on_policy_output = self.on_policy_runner.run_model()
+      outputs.update(on_policy_output)
+
+    if 'planplus' in outputs and 'plan' in outputs:
+      outputs['plan'] = outputs['plan'] + outputs['planplus']
+
+    return outputs
+
+  @property
+  def vision_input_names(self) -> list[str]:
+    """Returns the list of vision input names from the vision runner."""
+    return list(self.vision_runner.vision_input_names)
+
+  @property
+  def input_shapes(self) -> ShapeDict:
+    """Returns the combined input shapes from both vision and policy models."""
+    shapes = {**self.vision_runner.input_shapes}
+    if self.policy_runner:
+      shapes.update(self.policy_runner.input_shapes)
+    if self.off_policy_runner:
+      shapes.update(self.off_policy_runner.input_shapes)
+    if self.on_policy_runner:
+      shapes.update(self.on_policy_runner.input_shapes)
+    return shapes
+
+  @property
+  def output_slices(self) -> SliceDict:
+    """Returns the combined output slices from both vision and policy models."""
+    slices = {**self.vision_runner.output_slices}
+    if self.policy_runner:
+      slices.update(self.policy_runner.output_slices)
+    if self.off_policy_runner:
+      slices.update(self.off_policy_runner.output_slices)
+    if self.on_policy_runner:
+      slices.update(self.on_policy_runner.output_slices)
+    return slices
+
+  def prepare_inputs(self, numpy_inputs: NumpyDict) -> dict:
+    """Prepares inputs for both vision and policy models."""
+    if self.policy_runner:
+      self.policy_runner.prepare_policy_inputs(numpy_inputs)
+
+    for key in self.vision_input_names:
+      if key in self.inputs:
+        self.vision_runner.inputs[key] = self.inputs[key].cast(self.vision_runner.input_to_dtype[key])
+
+    inputs = {**self.vision_runner.inputs}
+    if self.policy_runner:
+      inputs.update(self.policy_runner.inputs)
+
+    if self.off_policy_runner:
+      self.off_policy_runner.prepare_policy_inputs(numpy_inputs)
+      inputs.update(self.off_policy_runner.inputs)
+    if self.on_policy_runner:
+      self.on_policy_runner.prepare_policy_inputs(numpy_inputs)
+      inputs.update(self.on_policy_runner.inputs)
+    return inputs
@@ -43,7 +43,6 @@ class SplitModelConstants:
  LANE_LINES_WIDTH = 2
  ROAD_EDGES_WIDTH = 2
  PLAN_WIDTH = 15
-  ACTION_WIDTH = 2
  DESIRE_PRED_WIDTH = 8
  LAT_PLANNER_SOLUTION_WIDTH = 4
  DESIRED_CURV_WIDTH = 1
@@ -8,7 +8,6 @@ from typing import Any

 from opendbc.car import structs
 from opendbc.car.interfaces import CarInterfaceBase
-from opendbc.car.toyota.values import CAR as TOYOTA_CAR
 from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
 from openpilot.sunnypilot.selfdrive.controls.lib.nnlc.helpers import get_nn_model_path
@@ -70,32 +69,6 @@ def _initialize_torque_lateral_control(CI: CarInterfaceBase, CP: structs.CarPara
    CI.configure_torque_tune(CP.carFingerprint, CP.lateralTuning)


-_PRIUS_TSS2_PID_KP_BP = [1.0, 1.5, 2.0, 3.0, 5.0, 7.5, 10.0, 15.0, 30.0]
-_PRIUS_TSS2_PID_KI_BP = [1.0, 1.5, 2.0, 3.0, 5.0, 7.5, 10.0, 15.0, 30.0]
-_PRIUS_TSS2_PID_KP_V = [0.1304, 0.1409, 0.1357, 0.1409, 0.15, 0.1614, 0.1826, 0.2348, 0.4696]
-_PRIUS_TSS2_PID_KI_V = [0.00016, 0.00035, 0.00063, 0.00141, 0.00391, 0.0088, 0.01565, 0.03522, 0.14087]
-_PRIUS_TSS2_PID_KF = 4e-05
-
-
-def _enforce_prius_tss2_pid_lateral_control(CP: structs.CarParams, params: Params = None) -> bool:
-  if params is None:
-    params = Params()
-
-  if CP.carFingerprint != TOYOTA_CAR.TOYOTA_PRIUS_TSS2:
-    return False
-
-  return params.get_bool("ToyotaPriusTss2Pid")
-
-
-def _initialize_prius_tss2_pid_lateral_control(CP: structs.CarParams) -> None:
-  CP.lateralTuning.init('pid')
-  CP.lateralTuning.pid.kpBP = _PRIUS_TSS2_PID_KP_BP
-  CP.lateralTuning.pid.kpV = _PRIUS_TSS2_PID_KP_V
-  CP.lateralTuning.pid.kiBP = _PRIUS_TSS2_PID_KI_BP
-  CP.lateralTuning.pid.kiV = _PRIUS_TSS2_PID_KI_V
-  CP.lateralTuning.pid.kf = _PRIUS_TSS2_PID_KF
-
-
 def _cleanup_unsupported_params(CP: structs.CarParams, CP_SP: structs.CarParamsSP, params: Params = None) -> None:
  if params is None:
    params = Params()
@@ -122,15 +95,8 @@ def _cleanup_unsupported_params(CP: structs.CarParams, CP_SP: structs.CarParamsS
 def setup_interfaces(CI: CarInterfaceBase, params: Params = None) -> None:
  enforce_torque = _enforce_torque_lateral_control(CI.CP, params)
  nnlc_enabled = _initialize_neural_network_lateral_control(CI.CP, CI.CP_SP, params)
-  prius_tss2_pid_enabled = _enforce_prius_tss2_pid_lateral_control(CI.CP, params)
-  if prius_tss2_pid_enabled:
-    # Prius TSS2 PID toggle takes priority over NNLC/EnforceTorqueControl for this car.
-    enforce_torque = False
-    nnlc_enabled = False
  _initialize_intelligent_cruise_button_management(CI.CP, CI.CP_SP, params)
  _initialize_torque_lateral_control(CI, CI.CP, enforce_torque, nnlc_enabled)
-  if prius_tss2_pid_enabled:
-    _initialize_prius_tss2_pid_lateral_control(CI.CP)
  _cleanup_unsupported_params(CI.CP, CI.CP_SP)

  try:
@@ -157,16 +123,12 @@ def initialize_params(params) -> list[dict[str, Any]]:
  # tesla
  keys.extend([
    "TeslaCoopSteering",
-    "TeslaMadsScreenButton",
  ])

  # toyota
  keys.extend([
    "ToyotaEnforceStockLongitudinal",
    "ToyotaStopAndGoHack",
-    "ToyotaEnhancedBsm",
-    "ToyotaAutoHold",
-    "ToyotaPriusTss2Pid",
  ])

  return [{k: params.get(k, return_default=True)} for k in keys]
@@ -1,122 +0,0 @@
-import numpy as np
-import pytest
-from opendbc.car import structs
-from openpilot.sunnypilot.selfdrive.car import interfaces as si
-
-
-class FakeParams:
-  def __init__(self, values=None):
-    self.values = values or {}
-
-  def get_bool(self, key):
-    return bool(self.values.get(key, False))
-
-  def get(self, key, return_default=False):
-    return self.values.get(key)
-
-  def remove(self, key):
-    self.values.pop(key, None)
-
-
-class FakeCI:
-  def __init__(self, CP, CP_SP):
-    self.CP = CP
-    self.CP_SP = CP_SP
-    self.configure_torque_tune_calls = 0
-
-  def configure_torque_tune(self, fingerprint, tune):
-    self.configure_torque_tune_calls += 1
-    tune.init('torque')
-
-
-def make_prius_tss2_cp():
-  CP = structs.CarParams(carFingerprint='TOYOTA_PRIUS_TSS2', steerControlType=structs.CarParams.SteerControlType.torque)
-  CP.lateralTuning.init('torque')
-  return CP
-
-
-class TestPriusTss2PidGate:
-  def test_disabled_for_other_toyota_platforms(self):
-    CP = structs.CarParams(carFingerprint='TOYOTA_RAV4_TSS2')
-    assert si._enforce_prius_tss2_pid_lateral_control(CP, FakeParams({'ToyotaPriusTss2Pid': True})) is False
-
-  def test_disabled_when_param_off(self):
-    CP = make_prius_tss2_cp()
-    assert si._enforce_prius_tss2_pid_lateral_control(CP, FakeParams({'ToyotaPriusTss2Pid': False})) is False
-
-  def test_enabled_for_prius_tss2_with_param_on(self):
-    CP = make_prius_tss2_cp()
-    assert si._enforce_prius_tss2_pid_lateral_control(CP, FakeParams({'ToyotaPriusTss2Pid': True})) is True
-
-
-class TestPriusTss2PidApply:
-  def test_flips_union_and_sets_gains(self):
-    CP = make_prius_tss2_cp()
-    assert CP.lateralTuning.which() == 'torque'
-
-    si._initialize_prius_tss2_pid_lateral_control(CP)
-
-    assert CP.lateralTuning.which() == 'pid'
-    assert list(CP.lateralTuning.pid.kpV) == pytest.approx(si._PRIUS_TSS2_PID_KP_V)
-    assert list(CP.lateralTuning.pid.kiV) == pytest.approx(si._PRIUS_TSS2_PID_KI_V)
-    assert CP.lateralTuning.pid.kf == pytest.approx(si._PRIUS_TSS2_PID_KF)
-    # PIDController interp needs non-empty breakpoints matching V lists.
-    assert len(CP.lateralTuning.pid.kpBP) == len(CP.lateralTuning.pid.kpV)
-    assert len(CP.lateralTuning.pid.kiBP) == len(CP.lateralTuning.pid.kiV)
-
-  def test_kp_rises_toward_highway_not_boosted_at_low_speed(self):
-    """Real on-road data (route 550a71ee4c7a7fbe/00000549--01e8f2ab51) showed boosting kp below
-    5 m/s increased saturation and hunting rather than helping - the shape must rise toward highway
-    speed, matching every other real multi-breakpoint PID car's tune (GM Volt, Cadillac Escalade
-    ESV, Honda Civic 2022) and the LatControlTorqueV0-derived KP_INTERP shape, not the reverse."""
-    CP = make_prius_tss2_cp()
-    si._initialize_prius_tss2_pid_lateral_control(CP)
-
-    kp_parking_lot = np.interp(2.0, CP.lateralTuning.pid.kpBP, CP.lateralTuning.pid.kpV)
-    kp_cruise = np.interp(5.0, CP.lateralTuning.pid.kpBP, CP.lateralTuning.pid.kpV)
-    kp_highway = np.interp(30.0, CP.lateralTuning.pid.kpBP, CP.lateralTuning.pid.kpV)
-    assert kp_parking_lot < kp_cruise < kp_highway
-
-
-class TestSetupInterfacesPrecedence:
-  def test_pid_toggle_wins_over_nnlc_and_enforce_torque(self):
-    """The Prius TSS2 PID toggle must be the last thing to touch lateralTuning: if the user also
-    has NNLC and/or EnforceTorqueControl on, the union must still end up 'pid' and
-    configure_torque_tune must never run, or the car would silently keep driving on torque."""
-    CP = make_prius_tss2_cp()
-    CP_SP = structs.CarParamsSP()
-    CI = FakeCI(CP, CP_SP)
-    params = FakeParams({
-      'EnforceTorqueControl': True,
-      'NeuralNetworkLateralControl': True,
-      'ToyotaPriusTss2Pid': True,
-    })
-
-    si.setup_interfaces(CI, params)
-
-    assert CP.lateralTuning.which() == 'pid'
-    assert CI.configure_torque_tune_calls == 0
-
-  def test_other_toyota_platform_unaffected_by_toggle(self):
-    """The same param being on must not leak into a different car's tuning."""
-    CP = structs.CarParams(carFingerprint='TOYOTA_RAV4_TSS2', steerControlType=structs.CarParams.SteerControlType.torque)
-    CP.lateralTuning.init('torque')
-    CP_SP = structs.CarParamsSP()
-    CI = FakeCI(CP, CP_SP)
-    params = FakeParams({'ToyotaPriusTss2Pid': True})
-
-    si.setup_interfaces(CI, params)
-
-    assert CP.lateralTuning.which() == 'torque'
-    assert CI.configure_torque_tune_calls == 0
-
-  def test_toggle_off_leaves_torque_control_path_intact(self):
-    CP = make_prius_tss2_cp()
-    CP_SP = structs.CarParamsSP()
-    CI = FakeCI(CP, CP_SP)
-    params = FakeParams({'EnforceTorqueControl': True, 'ToyotaPriusTss2Pid': False})
-
-    si.setup_interfaces(CI, params)
-
-    assert CP.lateralTuning.which() == 'torque'
-    assert CI.configure_torque_tune_calls == 1
@@ -10,14 +10,12 @@ import openpilot.cereal.messaging as messaging
 from openpilot.cereal import log, custom

 from opendbc.car import structs
-from opendbc.car.toyota.values import CAR as TOYOTA_CAR
 from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
 from openpilot.sunnypilot import PARAMS_UPDATE_PERIOD
 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld_v2.modeld_base import ModelStateBase
 from openpilot.sunnypilot.selfdrive.controls.lib.blinker_pause_lateral import BlinkerPauseLateral
-from openpilot.sunnypilot.selfdrive.controls.lib.latcontrol_pid_ext import LatControlPidSmooth
 from openpilot.sunnypilot.selfdrive.controls.lib.latcontrol_torque_v0 import LatControlTorque as LatControlTorqueV0


@@ -37,15 +35,12 @@ class ControlsExt(ModelStateBase):
    self.pm_services_ext = ['carControlSP']

  def initialize_lateral_control(self, lac, CI, dt):
-    if self.CP.lateralTuning.which() != 'torque':
-      if self.CP.carFingerprint == TOYOTA_CAR.TOYOTA_PRIUS_TSS2 and self.CP.lateralTuning.which() == 'pid':
-        return LatControlPidSmooth(self.CP, self.CP_SP, CI, dt)
-      return lac
-
    enforce_torque_control = self.params.get_bool("EnforceTorqueControl")
    torque_versions = self.params.get("TorqueControlTune")
    if not enforce_torque_control:
-      return LatControlTorqueV0(self.CP, self.CP_SP, CI, dt)  # FIXME-SP: revert when upstream fixes tuning issues with v1
+      if self.CP.lateralTuning.which() == 'torque':
+        return LatControlTorqueV0(self.CP, self.CP_SP, CI, dt)  # FIXME-SP: revert when upstream fixes tuning issues with v1
+      return lac

    if torque_versions == 0.0:  # v0
      return LatControlTorqueV0(self.CP, self.CP_SP, CI, dt)
@@ -1,418 +0,0 @@
-import math
-
-import numpy as np
-
-from opendbc.car.interfaces import ACCEL_MAX
-from openpilot.common.params import Params
-from openpilot.common.realtime import DT_MDL
-from openpilot.selfdrive.controls.lib.longitudinal_mpc_lib.long_mpc import LongitudinalPlanSource
-from openpilot.sunnypilot import get_sanitize_int_param
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_controller.constants import (
-  CAP_FILTER_FRAMES, COMFORT_DECEL, DEPARTURE_MOTION_NOISE_FLOOR, LAUNCH_END_SPEED, LAUNCH_TARGET_HEADROOM, LAUNCH_TARGET_SLEW,
-  LEAD_BRAKING_ACCEL_THRESHOLD, LEAD_DROPOUT_COAST_TIME, LEAD_LOSS_HOLD_TIME, LEAD_MATCH_ACCEL_SLEW, LEAD_MATCH_GAP_GAIN, LEAD_MATCH_SPEED_HEADROOM,
-  LEAD_SWITCH_MAX_HOLD_TIME,
-  MATCHED_SPEED_DECEL_RATE, MPC_DECEL_JERK_COST_MULTIPLIER, MPC_DECEL_JERK_MAX_REQUIRED_DECEL, MPC_DECEL_JERK_MAX_REQUIRED_DECEL_RATE,
-  MPC_DECEL_JERK_MAX_TARGET_REDUCTION, MPC_DECEL_TREND_FRAMES, SPEED_RELIEF_DEADBAND, SPEED_RESTRICT_DEADBAND, TARGET_SPEED_ARM_MARGIN,
-  TARGET_RELEASE_SLEW, TARGET_SPEED_RESERVE, PLANNER_BRAKING_ACCEL_THRESHOLD, RADAR_STALE_TIMEOUT, STOP_HOLD_CREEP_DISTANCE, STOP_HOLD_EGO_SPEED,
-  STOP_HOLD_EXIT_FRAMES, STOP_HOLD_EXIT_SPEED, STOP_HOLD_MAX_LEAD_DISTANCE, VEGO_NOISE_TOLERANCE, PARAM_READ_INTERVAL, AccelProfile,
-  profile_accel_max, sanitize_profile,
-)
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_controller.helpers import build_accel_ceiling, is_valid_context
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_controller.lead import LeadPlan, calculate_lead_plan, has_radar_lead, is_lead_source
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_controller.state import AccelControllerState, TargetState
-
-
-class AccelController:
-  def __init__(self, CP, dt: float = DT_MDL):
-    if not math.isfinite(dt) or dt <= 0.0:
-      raise ValueError("dt must be finite and positive")
-
-    self.dt = dt
-    self.delay = float(CP.longitudinalActuatorDelay) + DT_MDL
-    self.lead_loss_hold_frames = max(CAP_FILTER_FRAMES, math.ceil(LEAD_LOSS_HOLD_TIME / dt))
-    self.lead_dropout_coast_frames = max(self.lead_loss_hold_frames, math.ceil(LEAD_DROPOUT_COAST_TIME / dt))
-    self.lead_switch_max_hold_frames = max(self.lead_loss_hold_frames, math.ceil(LEAD_SWITCH_MAX_HOLD_TIME / dt))
-    self.radar_stale_frames = max(1, math.ceil(RADAR_STALE_TIMEOUT / dt))
-    self.params = Params()
-    self.available = bool(CP.openpilotLongitudinalControl)
-    self.enabled = False
-    self.profile = AccelProfile.normal
-    self._param_read_frames = max(1, int(round(PARAM_READ_INTERVAL / dt)))
-    self._param_frame = 0
-    self._jerk_smoothing_blocked = False
-    self._required_decel_samples: list[float] = []
-    self._required_decel_lead = -1
-    self._required_decel_lead_track_id = -1
-    self._lead_trend_warmup = False
-    self._cruise_accel_limited = False
-    self.target_state = TargetState()
-    self._held_lead_plan: LeadPlan | None = None
-    self.is_active = self.launching = self.departure_launching = False
-    self.output_v_target = 0.0
-    self.mpc_accel_max: tuple[float, ...] | None = None
-    self.cruise_accel_max: float | None = None
-    self.state = AccelControllerState.inactive
-    self.selected_lead = -1
-    self.selected_lead_track_id = -1
-    self.required_decel = 0.0
-
-  @property
-  def is_enabled(self) -> bool:
-    return self.available and self.enabled
-
-  def update_params(self) -> None:
-    if self._param_frame % self._param_read_frames == 0:
-      self.enabled = self.params.get_bool("AccelPersonalityEnabled")
-      self.profile = get_sanitize_int_param("AccelPersonality", AccelProfile.eco, AccelProfile.sport, self.params)
-    self._param_frame += 1
-
-  def _update_target(self, lead_plan: LeadPlan, base_speed: float, v_ego: float, profile: int, profile_max_accel: float,
-                     previous_should_stop: bool, previous_mpc_source, planner_speed: float, planner_accel: float) -> float:
-    state = self.target_state
-    lead_filter_ready = state.update_samples(lead_plan, self.dt)
-    state.active_frames += 1
-    has_lead = lead_plan.selected_lead >= 0
-    filtered_cap = state.filtered_cap
-    slot_changed = has_lead and state.selected_lead >= 0 and lead_plan.selected_lead != state.selected_lead
-    track_changed = (has_lead and state.selected_lead >= 0 and lead_plan.selected_lead == state.selected_lead
-      and lead_plan.selected_lead_track_id != state.selected_lead_track_id
-      and (state.selected_lead_track_id >= 0 or lead_plan.selected_lead_track_id >= 0))
-    false_relief = has_lead and math.isfinite(filtered_cap) and lead_plan.cap >= filtered_cap + SPEED_RELIEF_DEADBAND
-    guarded_restriction = state.state in (AccelControllerState.restrict, AccelControllerState.hold, AccelControllerState.release)
-    switched_to_relief = ((slot_changed or track_changed) and false_relief
-                          and (guarded_restriction or planner_accel <= PLANNER_BRAKING_ACCEL_THRESHOLD))
-    confirmed_relief = (not has_lead or (state.target_speed is not None and lead_plan.closing_speed <= 0.0
-                        and lead_plan.cap >= state.target_speed + SPEED_RELIEF_DEADBAND))
-    state.update_lead_switch_guard(switched_to_relief, confirmed_relief, slot_changed or track_changed or false_relief,
-                                   self.lead_loss_hold_frames, self.lead_switch_max_hold_frames)
-    if has_lead:
-      state.selected_lead = lead_plan.selected_lead
-      state.selected_lead_track_id = lead_plan.selected_lead_track_id
-    elif state.lead_loss_frames >= self.lead_loss_hold_frames:
-      state.reset_lead_switch_guard()
-      state.selected_lead = state.selected_lead_track_id = -1
-    departure_separation = (lead_plan.departure_lead_separations[lead_plan.departure_lead_index]
-                            if lead_plan.departure_lead_index >= 0 else math.inf)
-    stopped_lead_hold = (has_lead and lead_plan.has_nearly_stopped_lead
-      and (lead_plan.departure_cap < 0.50 or (state.lead_braking and departure_separation <= STOP_HOLD_MAX_LEAD_DISTANCE)))
-    invalid_lead = lead_plan.lead_status and not has_lead
-    prior_lead_context = is_lead_source(previous_mpc_source) or math.isfinite(filtered_cap) or state.lead_braking
-    previous_stop = previous_should_stop and prior_lead_context and (not has_lead or lead_plan.departure_lead_speed < STOP_HOLD_EXIT_SPEED)
-    stop_evidence = stopped_lead_hold or lead_plan.cap < 0.50 or filtered_cap < 0.50 or (previous_stop and not state.launching) or invalid_lead
-    departure_motion_confirmed = (state.launching and state.departure_launch and has_lead
-      and (state.departure.progress(lead_plan, DEPARTURE_MOTION_NOISE_FLOOR) or state.departure.recent_motion()))
-    if state.active_frames >= self.lead_loss_hold_frames and math.isfinite(filtered_cap) and has_lead and planner_accel <= PLANNER_BRAKING_ACCEL_THRESHOLD:
-      state.lead_braking = True
-    elif not has_lead and state.lead_loss_frames >= self.lead_loss_hold_frames:
-      state.lead_braking = False
-
-    if state.target_speed is None:
-      e2e_handoff = previous_mpc_source == LongitudinalPlanSource.e2e
-      seed_from_ego = has_lead and planner_accel > PLANNER_BRAKING_ACCEL_THRESHOLD and not e2e_handoff
-      state.target_speed = min(base_speed, v_ego) if seed_from_ego else base_speed
-      if seed_from_ego and v_ego >= LAUNCH_END_SPEED and lead_plan.closing_speed > 0.0:
-        state.arm_release_slew()
-      state.e2e_braking_handoff = e2e_handoff and planner_accel < 0.0
-      state.state = AccelControllerState.free
-      if v_ego < STOP_HOLD_EGO_SPEED and not stop_evidence:
-        state.target_speed = min(base_speed, v_ego + LAUNCH_TARGET_HEADROOM)
-        state.state = AccelControllerState.release
-        state.launching = True
-        state.departure_launch = False
-    elif state.e2e_braking_handoff and planner_accel >= 0.0:
-      state.e2e_braking_handoff = False
-
-    state.target_speed = min(state.target_speed, base_speed)
-    if v_ego < STOP_HOLD_EGO_SPEED and stop_evidence and not departure_motion_confirmed and state.state != AccelControllerState.stopHold:
-      state.enter_stop_hold(lead_plan)
-      return state.target_speed
-
-    if state.state == AccelControllerState.stopHold:
-      state.departure.backfill_references()
-      fast_departure = (has_lead and min(lead_plan.selected_lead_speed, lead_plan.departure_lead_speed) > STOP_HOLD_EXIT_SPEED
-        and lead_plan.departure_cap > STOP_HOLD_EXIT_SPEED)
-      raw_departure = fast_departure or not lead_plan.lead_status and state.lead_loss_frames >= self.lead_loss_hold_frames
-      departed = state.departure.progress(lead_plan, STOP_HOLD_CREEP_DISTANCE) or raw_departure
-      if fast_departure and state.departure_frames == 0:
-        state.departure.keep_latest_motion_sample()
-      state.departure_frames = state.departure_frames + 1 if departed else 0
-      state.target_speed = 0.0
-      fast_departure_confirmed = fast_departure and state.departure.recent_motion()
-      if state.departure_frames < STOP_HOLD_EXIT_FRAMES or fast_departure and not fast_departure_confirmed:
-        return state.target_speed
-      state.target_speed = base_speed
-      state.state = AccelControllerState.release
-      state.departure_frames = 0
-      state.launching = True
-      state.departure_launch = has_lead
-      return state.target_speed
-
-    if state.launching:
-      renewed_stop = (has_lead and not departure_motion_confirmed
-        and (lead_plan.cap < STOP_HOLD_EXIT_SPEED
-             or (lead_plan.has_nearly_stopped_lead and lead_plan.departure_cap < STOP_HOLD_EXIT_SPEED)))
-      guarded_departure_loss = state.departure_launch and not lead_plan.lead_status and state.lead_loss_frames < self.lead_loss_hold_frames
-      if invalid_lead:
-        state.launching = state.departure_launch = False
-        if v_ego < STOP_HOLD_EGO_SPEED:
-          state.enter_stop_hold(lead_plan)
-          return state.target_speed
-        state.state = AccelControllerState.hold
-        return state.target_speed
-      if guarded_departure_loss:
-        state.state = AccelControllerState.hold
-        return state.target_speed
-      if state.departure_launch and not has_lead:
-        state.departure_launch = False
-      if renewed_stop:
-        state.launching = state.departure_launch = False
-        if v_ego < STOP_HOLD_EGO_SPEED:
-          state.enter_stop_hold(lead_plan)
-          return state.target_speed
-      if state.launching:
-        if state.departure_launch:
-          state.target_speed = base_speed
-        else:
-          launch_target = min(base_speed, v_ego + LAUNCH_TARGET_HEADROOM)
-          state.target_speed = min(base_speed, max(state.target_speed, launch_target) + LAUNCH_TARGET_SLEW * self.dt)
-        if v_ego >= LAUNCH_END_SPEED:
-          state.launching = state.departure_launch = False
-
-    comfort_decel = COMFORT_DECEL[profile]
-    if (has_lead and not state.launching and state.state == AccelControllerState.restrict
-      and lead_plan.closing_speed <= 0.0 and v_ego >= state.filtered_lead_speed - VEGO_NOISE_TOLERANCE):
-      state.matched_lead = True
-    elif not has_lead and state.lead_loss_frames >= self.lead_loss_hold_frames:
-      state.matched_lead = False
-
-    lost_lead_source = is_lead_source(previous_mpc_source) and not has_lead and planner_speed < state.target_speed
-    if not has_lead and (state.matched_lead or lost_lead_source):
-      if lost_lead_source:
-        state.lead_dropout = True
-        state.target_speed = planner_speed
-        state.arm_release_slew()
-      state.state = AccelControllerState.hold
-      return state.target_speed
-
-    if state.matched_lead:
-      if math.isfinite(state.filtered_lead_speed):
-        recovery_speed = min(base_speed, state.filtered_lead_speed + min(LEAD_MATCH_SPEED_HEADROOM, LEAD_MATCH_GAP_GAIN * lead_plan.usable_gap))
-        desired_accel_limit = min(profile_max_accel, max(recovery_speed - v_ego, 0.0))
-      else:
-        desired_accel_limit = 0.0
-      if state.filtered_lead_accel < LEAD_BRAKING_ACCEL_THRESHOLD:
-        desired_accel_limit = profile_max_accel
-      if state.matched_accel_limit is None:
-        state.matched_accel_limit = profile_max_accel
-      if state.lead_switch_guard_frames > 0:
-        desired_accel_limit = min(desired_accel_limit, state.matched_accel_limit)
-      state.matched_accel_limit = min(profile_max_accel, float(np.clip(
-        desired_accel_limit, state.matched_accel_limit - LEAD_MATCH_ACCEL_SLEW * self.dt,
-        state.matched_accel_limit + LEAD_MATCH_ACCEL_SLEW * self.dt,
-      )))
-      matched_ceiling = min(base_speed, filtered_cap)
-      if matched_ceiling <= state.target_speed - SPEED_RESTRICT_DEADBAND:
-        state.target_speed = max(matched_ceiling, state.target_speed - MATCHED_SPEED_DECEL_RATE * self.dt)
-        state.arm_release_slew()
-        state.state = AccelControllerState.restrict
-      elif (state.lead_switch_guard_frames == 0 and matched_ceiling >= state.target_speed + SPEED_RELIEF_DEADBAND
-            and (state.lead_switch_elapsed_frames < self.lead_switch_max_hold_frames or planner_accel > PLANNER_BRAKING_ACCEL_THRESHOLD)):
-        state.target_speed = min(matched_ceiling, state.target_speed + profile_max_accel * self.dt)
-        state.state = AccelControllerState.free if state.target_speed >= base_speed - SPEED_RESTRICT_DEADBAND else AccelControllerState.release
-      else:
-        state.state = AccelControllerState.free if state.target_speed >= base_speed - SPEED_RESTRICT_DEADBAND else AccelControllerState.hold
-      if state.state == AccelControllerState.free:
-        state.reset_release_slew(state.target_speed)
-      else:
-        state.update_release_slew(matched_ceiling, math.isfinite(matched_ceiling) and state.target_speed == matched_ceiling)
-      return state.target_speed
-    state.matched_accel_limit = None
-
-    ceiling = min(base_speed, filtered_cap)
-    synced_to_planner = lead_filter_ready and not state.launching and planner_speed < state.target_speed
-    if synced_to_planner:
-      state.target_speed = max(planner_speed, state.target_speed - comfort_decel * self.dt)
-
-    if ceiling <= state.target_speed - SPEED_RESTRICT_DEADBAND or (state.state == AccelControllerState.restrict and ceiling < state.target_speed):
-      if not synced_to_planner:
-        state.target_speed = max(ceiling, state.target_speed - comfort_decel * self.dt)
-      state.arm_release_slew()
-      state.state = AccelControllerState.restrict
-      return state.target_speed
-
-    filter_warmup = has_lead and not math.isfinite(filtered_cap)
-    guarded_lead_loss = not has_lead and state.lead_loss_frames < (self.lead_dropout_coast_frames if state.lead_dropout else self.lead_loss_hold_frames)
-    if (filter_warmup or guarded_lead_loss) and state.target_speed < base_speed - SPEED_RESTRICT_DEADBAND:
-      state.state = AccelControllerState.hold
-      return state.target_speed
-
-    confirmed_clear_road = not math.isfinite(filtered_cap) and not guarded_lead_loss
-    relief = (not has_lead or lead_plan.closing_speed <= 0.0) and planner_accel > PLANNER_BRAKING_ACCEL_THRESHOLD
-    continuing_release = state.release_slew_armed and ceiling > state.target_speed
-    if relief and (continuing_release or ceiling >= state.target_speed + SPEED_RELIEF_DEADBAND
-                   or (confirmed_clear_road and ceiling > state.target_speed)):
-      if state.lead_switch_guard_frames == 0:
-        timed_out = state.lead_switch_elapsed_frames >= self.lead_switch_max_hold_frames
-        if not state.release_slew_armed and (timed_out or (state.release_settle_speed is not None
-                                                          and ceiling - state.target_speed > TARGET_RELEASE_SLEW * self.dt)):
-          state.arm_release_slew(force=True)
-        release_rate = comfort_decel if timed_out else TARGET_RELEASE_SLEW
-        state.target_speed = min(ceiling, state.target_speed + release_rate * self.dt) if state.release_slew_armed else ceiling
-      if state.release_slew_armed and state.target_speed < ceiling:
-        state.state = AccelControllerState.release
-      else:
-        state.state = AccelControllerState.free if state.target_speed >= base_speed - SPEED_RESTRICT_DEADBAND else AccelControllerState.hold
-    else:
-      state.state = AccelControllerState.free if state.target_speed >= base_speed - SPEED_RESTRICT_DEADBAND else AccelControllerState.hold
-    if state.target_speed >= base_speed:
-      state.lead_dropout = False
-      state.reset_release_slew(state.target_speed)
-    else:
-      state.update_release_slew(ceiling, math.isfinite(ceiling) and state.target_speed == ceiling)
-    return state.target_speed
-
-  def _update_freshness(self, radar_fresh: bool) -> None:
-    self.target_state.stale_frames = 0 if radar_fresh else self.target_state.stale_frames + 1
-    if self.target_state.stale_frames >= self.radar_stale_frames:
-      self.target_state = TargetState()
-
-  def reset(self) -> None:
-    self.target_state = TargetState()
-    self._held_lead_plan = None
-    self._jerk_smoothing_blocked = False
-    self._required_decel_samples.clear()
-    self._required_decel_lead = self._required_decel_lead_track_id = -1
-    self._lead_trend_warmup = False
-    self._cruise_accel_limited = False
-    self.is_active = self.launching = self.departure_launching = False
-    self.output_v_target = 0.0
-    self.mpc_accel_max = None
-    self.cruise_accel_max = None
-    self.state = AccelControllerState.inactive
-    self.selected_lead = -1
-    self.selected_lead_track_id = -1
-    self.required_decel = 0.0
-
-  def update(self, radar_state, *, base_speed: float, v_ego: float, a_ego: float, follow_personality, acc_selected: bool,
-             engaged: bool, cruise_initialized: bool, stock_accel_max: float, previous_should_stop: bool, radar_fresh: bool = True,
-             previous_mpc_source=None, planner_speed: float | None = None, planner_accel: float = 0.0) -> None:
-    self.profile = sanitize_profile(self.profile)
-    sanitized_v_ego = max(v_ego, 0.0) if math.isfinite(v_ego) and v_ego >= -VEGO_NOISE_TOLERANCE else v_ego
-    profile_max_accel = profile_accel_max(self.profile, sanitized_v_ego)
-    stock_accel_max = float(stock_accel_max)
-    positive_accel_max = (max(0.0, min(profile_max_accel, stock_accel_max, ACCEL_MAX))
-                          if math.isfinite(profile_max_accel) and math.isfinite(stock_accel_max) else math.nan)
-    planner_speed = sanitized_v_ego if planner_speed is None else planner_speed
-    valid_context = is_valid_context(base_speed, sanitized_v_ego, a_ego, planner_speed, planner_accel, stock_accel_max, self.delay,
-                                     engaged, cruise_initialized)
-    enabled_context = valid_context and self.is_enabled and bool(acc_selected)
-    if enabled_context and radar_fresh:
-      lead_plan = calculate_lead_plan(radar_state, sanitized_v_ego, a_ego, self.delay, self.profile, follow_personality)
-      self._held_lead_plan = lead_plan
-    elif enabled_context and self._held_lead_plan is not None:
-      lead_plan = self._held_lead_plan
-    else:
-      lead_plan = LeadPlan(lead_status=has_radar_lead(radar_state))
-      self._held_lead_plan = None
-
-    if enabled_context:
-      self._update_freshness(radar_fresh)
-    active = enabled_context and (radar_fresh or self.target_state.target_speed is not None)
-    if active and radar_fresh:
-      target_speed = self._update_target(
-        lead_plan, base_speed, sanitized_v_ego, self.profile, profile_max_accel, previous_should_stop,
-        previous_mpc_source, planner_speed, planner_accel,
-      )
-    elif active:
-      target_speed = self.target_state.target_speed
-    else:
-      self.target_state = TargetState()
-      target_speed = base_speed
-
-    if not radar_fresh and not active:
-      self._held_lead_plan = None
-      lead_plan = LeadPlan(lead_status=has_radar_lead(radar_state))
-
-    state = self.target_state
-    stop_hold_active = active and state.state == AccelControllerState.stopHold
-    matched_limit_active = active and state.matched_lead and state.matched_accel_limit is not None and not state.e2e_braking_handoff
-    lead_accel_request = active and lead_plan.selected_lead >= 0 and lead_plan.closing_speed <= 0.0 and planner_accel >= 0.0
-    profile_limit_active = active and not stop_hold_active and (state.launching or not lead_plan.lead_status or lead_accel_request)
-    if matched_limit_active:
-      effective_accel_max = min(positive_accel_max, state.matched_accel_limit)
-    elif profile_limit_active:
-      effective_accel_max = positive_accel_max
-    else:
-      effective_accel_max = math.inf
-    mpc_accel_max = build_accel_ceiling(effective_accel_max, planner_accel) if matched_limit_active or profile_limit_active else None
-    guarded_lead_loss = not lead_plan.lead_status and state.selected_lead >= 0 and state.lead_loss_frames < self.lead_loss_hold_frames
-    lead_context = lead_plan.lead_status or math.isfinite(state.filtered_cap) or guarded_lead_loss
-    reserve_eligible = active and lead_context and not stop_hold_active and not state.launching and not state.e2e_braking_handoff
-    reserve_can_arm = reserve_eligible and state.lead_switch_guard_frames == 0
-    if not lead_context:
-      state.speed_reserve_armed = False
-    elif (reserve_can_arm and not state.speed_reserve_armed and math.isfinite(state.filtered_cap)
-          and state.filtered_cap <= target_speed + TARGET_SPEED_ARM_MARGIN):
-      state.speed_reserve_armed = True
-
-    output_target = 0.0 if stop_hold_active else target_speed
-    if reserve_eligible and state.speed_reserve_armed:
-      output_target = max(0.0, output_target - TARGET_SPEED_RESERVE)
-
-    self.is_active = active
-    self.launching = active and state.launching
-    self.departure_launching = self.launching and state.departure_launch
-    self.output_v_target = output_target
-    self.mpc_accel_max = mpc_accel_max
-    start_cruise_accel_limit = (active and state.state == AccelControllerState.free and lead_plan.lead_status
-                                and lead_plan.closing_speed > 0.0 and planner_accel >= 0.0
-                                and previous_mpc_source == LongitudinalPlanSource.cruise)
-    keep_cruise_accel_limit = (self._cruise_accel_limited and active and lead_context and state.state == AccelControllerState.free
-                               and not state.e2e_braking_handoff)
-    self._cruise_accel_limited = start_cruise_accel_limit or keep_cruise_accel_limit
-    self.cruise_accel_max = positive_accel_max if self._cruise_accel_limited else None
-    self.state = state.state
-    self.selected_lead = lead_plan.selected_lead
-    self.selected_lead_track_id = lead_plan.selected_lead_track_id
-    self.required_decel = lead_plan.required_decel
-
-  def get_jerk_cost_multiplier(self, actuating: bool, prev_accel_constraint: bool, target_reduction: float, previous_mpc_failed: bool) -> float:
-    lead_restriction = (actuating and prev_accel_constraint and self.state == AccelControllerState.restrict and self.selected_lead >= 0
-      and not self.launching and target_reduction > 1e-6)
-    same_lead = self.selected_lead == self._required_decel_lead and self.selected_lead_track_id == self._required_decel_lead_track_id
-    lead_changed = lead_restriction and self._required_decel_lead >= 0 and not same_lead
-    if lead_changed:
-      self._lead_trend_warmup = True
-    elif not lead_restriction:
-      self._lead_trend_warmup = False
-    if not lead_restriction or not same_lead or not math.isfinite(self.required_decel):
-      self._required_decel_samples.clear()
-    if lead_restriction and math.isfinite(self.required_decel):
-      self._required_decel_samples.append(self.required_decel)
-      if len(self._required_decel_samples) > MPC_DECEL_TREND_FRAMES:
-        self._required_decel_samples.pop(0)
-    self._required_decel_lead = self.selected_lead if lead_restriction else -1
-    self._required_decel_lead_track_id = self.selected_lead_track_id if lead_restriction else -1
-
-    history = self._required_decel_samples
-    history_ready = len(history) == MPC_DECEL_TREND_FRAMES
-    tightening_lead = (history_ready
-      and (history[-1] - history[0]) / (self.dt * (len(history) - 1)) > MPC_DECEL_JERK_MAX_REQUIRED_DECEL_RATE
-      and sum(after > before for before, after in zip(history[:-1], history[1:], strict=True)) >= 2)
-    modest_decel = (lead_restriction and target_reduction < MPC_DECEL_JERK_MAX_TARGET_REDUCTION
-      and 0.0 < self.required_decel < MPC_DECEL_JERK_MAX_REQUIRED_DECEL)
-    smoothing_eligible = modest_decel and (not self._lead_trend_warmup or history_ready) and not tightening_lead
-    if history_ready:
-      self._lead_trend_warmup = False
-    if previous_mpc_failed or (lead_restriction and not self._jerk_smoothing_blocked and (not modest_decel or tightening_lead)):
-      self._jerk_smoothing_blocked = True
-    elif not lead_restriction:
-      self._jerk_smoothing_blocked = False
-    return MPC_DECEL_JERK_COST_MULTIPLIER if smoothing_eligible and not self._jerk_smoothing_blocked else 1.0
-
-  def update_should_stop(self, should_stop: bool) -> bool:
-    if not self.is_active:
-      return should_stop
-    if self.departure_launching:
-      return False
-    return should_stop or self.state == AccelControllerState.stopHold
@@ -1,76 +0,0 @@
-import math
-
-import numpy as np
-
-from openpilot.cereal import custom
-
-
-AccelProfile = custom.LongitudinalPlanSP.AccelController.Profile
-ACCEL_PROFILES = tuple(AccelProfile.schema.enumerants.values())
-
-COMFORT_DECEL = {
-  AccelProfile.eco: 0.25,
-  AccelProfile.normal: 0.30,
-  AccelProfile.sport: 0.35,
-}
-
-ACCEL_PROFILE_MAX_BP = [0.0, 3.0, 10.0, 25.0, 40.0]
-ACCEL_PROFILE_MAX_V = {
-  AccelProfile.eco: [1.65, 1.30, 0.72, 0.32, 0.16],
-  AccelProfile.normal: [1.80, 1.50, 0.97, 0.48, 0.30],
-  AccelProfile.sport: [2.00, 1.90, 1.15, 0.68, 0.42],
-}
-
-CAP_FILTER_FRAMES = 5
-LEAD_LOSS_HOLD_TIME = 0.50
-LEAD_DROPOUT_COAST_TIME = 1.50
-LEAD_SWITCH_MAX_HOLD_TIME = 6.0
-SPEED_RESTRICT_DEADBAND = 0.15
-SPEED_RELIEF_DEADBAND = 0.35
-TARGET_RELEASE_SLEW = 8.75
-TARGET_SPEED_ARM_MARGIN = 1.0
-TARGET_SPEED_RESERVE = 0.10
-LAUNCH_TARGET_HEADROOM = 3.0
-LAUNCH_TARGET_SLEW = 8.75
-LAUNCH_END_SPEED = 3.0
-ACCEL_LIMIT_HORIZON_JERK = 1.0
-LEAD_MATCH_GAP_GAIN = 0.04
-LEAD_MATCH_SPEED_HEADROOM = 1.25
-LEAD_MATCH_ACCEL_SLEW = 0.25
-MATCHED_SPEED_DECEL_RATE = 0.50
-PLANNER_BRAKING_ACCEL_THRESHOLD = -0.11
-LEAD_BRAKING_ACCEL_THRESHOLD = -0.11
-MPC_DECEL_JERK_COST_MULTIPLIER = 1.05
-MPC_DECEL_JERK_MAX_REQUIRED_DECEL = 0.80
-MPC_DECEL_JERK_MAX_REQUIRED_DECEL_RATE = 0.35
-MPC_DECEL_JERK_MAX_TARGET_REDUCTION = 9.0
-MPC_DECEL_TREND_FRAMES = 4
-
-STOP_HOLD_EGO_SPEED = 0.30
-STOPPED_LEAD_SPEED = 0.30
-STOP_HOLD_EXIT_SPEED = 0.80
-STOP_HOLD_EXIT_FRAMES = 4
-STOP_HOLD_CREEP_SPEED = 0.15
-STOP_HOLD_CREEP_DISTANCE = 0.30
-DEPARTURE_MOTION_NOISE_FLOOR = 0.03
-DEPARTURE_MOTION_STEP_MIN = 0.005
-STOP_HOLD_MAX_LEAD_DISTANCE = 30.0
-STOP_GAP_RESERVE = 0.75
-STOP_GAP_RESERVE_LEAD_SPEED = 2.0
-STOP_GAP_RESERVE_DECEL_BP = (0.30, 0.80)
-
-RADAR_STALE_TIMEOUT = 0.50
-MAX_LEAD_ACCEL_TAU = 10.0
-MIN_LEAD_SPEED = -1.0
-VEGO_NOISE_TOLERANCE = 0.10
-PARAM_READ_INTERVAL = 0.25
-
-
-def sanitize_profile(profile: int) -> int:
-  return profile if profile in ACCEL_PROFILES else AccelProfile.normal
-
-
-def profile_accel_max(profile: int, v_ego: float) -> float:
-  if not math.isfinite(v_ego):
-    return math.nan
-  return float(np.interp(max(v_ego, 0.0), ACCEL_PROFILE_MAX_BP, ACCEL_PROFILE_MAX_V[sanitize_profile(profile)]))
@@ -1,22 +0,0 @@
-import math
-
-import numpy as np
-
-from opendbc.car.interfaces import ACCEL_MIN, ACCEL_MAX
-from openpilot.selfdrive.controls.lib.longitudinal_mpc_lib.long_mpc import T_IDXS
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_controller.constants import ACCEL_LIMIT_HORIZON_JERK, VEGO_NOISE_TOLERANCE
-
-
-def is_valid_context(base_speed: float, v_ego: float, a_ego: float, planner_speed: float, planner_accel: float, stock_accel_max: float,
-                     delay: float, engaged: bool, cruise_initialized: bool) -> bool:
-  values = (base_speed, v_ego, a_ego, planner_speed, planner_accel, stock_accel_max, delay)
-  return (engaged and cruise_initialized and base_speed >= 0.0 and v_ego >= -VEGO_NOISE_TOLERANCE
-          and planner_speed >= 0.0 and stock_accel_max >= 0.0 and delay >= 0.0 and all(math.isfinite(value) for value in values))
-
-
-def build_accel_ceiling(limit: float, planner_accel: float) -> tuple[float, ...] | None:
-  if limit >= ACCEL_MAX - 1e-9:
-    return None
-  a0 = float(np.clip(planner_accel, ACCEL_MIN, ACCEL_MAX))
-  ceiling = np.clip(np.maximum(limit, a0 - ACCEL_LIMIT_HORIZON_JERK * T_IDXS), 0.0, ACCEL_MAX)
-  return tuple(float(value) for value in ceiling)
@@ -1,147 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import math
-from typing import NamedTuple
-
-import numpy as np
-
-from openpilot.cereal import log
-from openpilot.selfdrive.controls.lib.longitudinal_mpc_lib.long_mpc import (
-  LongitudinalMpc, LongitudinalPlanSource, STOP_DISTANCE, T_IDXS, get_T_FOLLOW, get_stopped_equivalence_factor,
-)
-from openpilot.selfdrive.controls.radard import _LEAD_ACCEL_TAU
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_controller.constants import (
-  COMFORT_DECEL, MAX_LEAD_ACCEL_TAU, MIN_LEAD_SPEED, STOP_GAP_RESERVE, STOP_GAP_RESERVE_DECEL_BP,
-  STOP_GAP_RESERVE_LEAD_SPEED, STOPPED_LEAD_SPEED, sanitize_profile,
-)
-
-
-class LeadPlan(NamedTuple):
-  cap: float = math.inf
-  selected_lead: int = -1
-  selected_lead_track_id: int = -1
-  selected_lead_speed: float = math.inf
-  selected_lead_accel: float = 0.0
-  departure_lead_index: int = -1
-  departure_lead_speed: float = math.inf
-  departure_cap: float = math.inf
-  departure_lead_speeds: tuple[float, float] = (math.inf, math.inf)
-  departure_lead_distances: tuple[float, float] = (-math.inf, -math.inf)
-  departure_lead_track_ids: tuple[int, int] = (-1, -1)
-  departure_lead_separations: tuple[float, float] = (-math.inf, -math.inf)
-  usable_gap: float = math.inf
-  closing_speed: float = 0.0
-  required_decel: float = 0.0
-  has_nearly_stopped_lead: bool = False
-  lead_status: bool = False
-
-
-def is_lead_source(source) -> bool:
-  return source in (LongitudinalPlanSource.lead0, LongitudinalPlanSource.lead1)
-
-
-def has_radar_lead(radar_state) -> bool:
-  return bool(radar_state.leadOne.present or radar_state.leadTwo.present)
-
-
-def _project_ego(v_ego: float, a_ego: float, delay: float) -> tuple[float, float]:
-  if a_ego < 0.0:
-    stop_time = -v_ego / a_ego if v_ego > 0.0 else 0.0
-    if stop_time <= delay:
-      distance = -v_ego**2 / (2.0 * a_ego) if v_ego > 0.0 else 0.0
-      return distance, 0.0
-  return max(v_ego * delay + 0.5 * a_ego * delay**2, 0.0), max(v_ego + a_ego * delay, 0.0)
-
-
-def _lead_values(lead) -> tuple[float, float, float, float] | None:
-  if not lead.present:
-    return None
-  d_rel, v_lead = float(lead.dRel), float(lead.vLeadK)
-  if not math.isfinite(d_rel) or d_rel < 0.0 or not math.isfinite(v_lead) or v_lead < MIN_LEAD_SPEED:
-    return None
-
-  a_lead = float(lead.aLeadK)
-  if not math.isfinite(a_lead):
-    a_lead = 0.0
-  a_lead_tau = float(lead.aLeadTau)
-  if not math.isfinite(a_lead_tau) or not 0.0 < a_lead_tau <= MAX_LEAD_ACCEL_TAU:
-    a_lead_tau = _LEAD_ACCEL_TAU
-  return d_rel, max(v_lead, 0.0), float(np.clip(a_lead, -10.0, 5.0)), a_lead_tau
-
-
-def calculate_lead_plan(radar_state, v_ego: float, a_ego: float, delay: float, profile: int,
-                        follow_personality=log.LongitudinalPersonality.standard) -> LeadPlan:
-  if not all(math.isfinite(value) for value in (v_ego, a_ego, delay)) or v_ego < 0.0 or delay < 0.0:
-    return LeadPlan()
-
-  leads = (radar_state.leadOne, radar_state.leadTwo)
-  lead_status = any(lead.present for lead in leads)
-  t_follow = get_T_FOLLOW(follow_personality)
-  if not math.isfinite(t_follow) or t_follow < 0.0:
-    return LeadPlan(lead_status=lead_status)
-
-  profile = sanitize_profile(profile)
-  x_ego, v_ego_delay = _project_ego(v_ego, a_ego, delay)
-  comfort_decel = COMFORT_DECEL[profile]
-  candidates: list[LeadPlan] = []
-  departure_candidates: list[tuple[float, int]] = []
-  departure_speeds = [math.inf, math.inf]
-  departure_distances = [-math.inf, -math.inf]
-  departure_track_ids = [-1, -1]
-  departure_separations = [-math.inf, -math.inf]
-  departure_caps = [math.inf, math.inf]
-
-  for lead_index, lead in enumerate(leads):
-    values = _lead_values(lead)
-    if values is None:
-      continue
-
-    d_rel, v_lead, a_lead, a_lead_tau = values
-    lead_xv = LongitudinalMpc.extrapolate_lead(d_rel, v_lead, a_lead, a_lead_tau)
-    x_lead = float(np.interp(delay, T_IDXS, lead_xv[:, 0]))
-    v_lead_delay = float(np.interp(delay, T_IDXS, lead_xv[:, 1]))
-    safety_gap = max(x_lead - x_ego - STOP_DISTANCE - t_follow * v_lead_delay, 0.0)
-    closing_speed = max(v_ego_delay - v_lead_delay, 0.0)
-    required_decel = 0.0 if closing_speed == 0.0 else math.inf if safety_gap == 0.0 else closing_speed**2 / (2.0 * safety_gap)
-    reserve = float(np.interp(v_lead_delay, (0.0, STOP_GAP_RESERVE_LEAD_SPEED), (STOP_GAP_RESERVE, 0.0)))
-    reserve_scale = float(np.interp(required_decel, STOP_GAP_RESERVE_DECEL_BP, (1.0, 0.0)))
-    usable_gap = max(safety_gap - reserve * reserve_scale, 0.0)
-    cap = v_lead_delay + math.sqrt(2.0 * comfort_decel * usable_gap)
-    departure_cap = v_lead_delay + math.sqrt(2.0 * comfort_decel * safety_gap)
-    separation = x_lead - x_ego
-    departure_distance = x_lead + float(get_stopped_equivalence_factor(v_lead_delay))
-
-    finite_values = (x_lead, v_lead_delay, safety_gap, usable_gap, closing_speed, cap, departure_cap, departure_distance)
-    if (not all(math.isfinite(value) and value >= 0.0 for value in finite_values) or math.isnan(required_decel)
-        or required_decel < 0.0 or not math.isfinite(separation)):
-      continue
-
-    track_id = max(int(lead.radarTrackId), -1) if math.isfinite(lead.radarTrackId) else -1
-    candidates.append(LeadPlan(
-      cap=cap, selected_lead=lead_index, selected_lead_track_id=track_id, selected_lead_speed=v_lead_delay, selected_lead_accel=a_lead,
-      usable_gap=usable_gap, closing_speed=closing_speed, required_decel=required_decel, lead_status=lead_status,
-    ))
-    departure_candidates.append((departure_distance, lead_index))
-    departure_speeds[lead_index] = v_lead_delay
-    departure_distances[lead_index] = d_rel
-    departure_track_ids[lead_index] = track_id
-    departure_separations[lead_index] = separation
-    departure_caps[lead_index] = departure_cap
-
-  if not candidates:
-    return LeadPlan(lead_status=lead_status)
-
-  selected = min(candidates, key=lambda candidate: candidate.cap)
-  departure_lead_index = min(departure_candidates, key=lambda candidate: candidate[0])[1]
-  departure_lead_speed = departure_speeds[departure_lead_index]
-  return selected._replace(
-    departure_lead_index=departure_lead_index, departure_lead_speed=departure_lead_speed,
-    departure_cap=departure_caps[departure_lead_index], departure_lead_speeds=tuple(departure_speeds),
-    departure_lead_distances=tuple(departure_distances), departure_lead_track_ids=tuple(departure_track_ids),
-    departure_lead_separations=tuple(departure_separations), has_nearly_stopped_lead=departure_lead_speed < STOPPED_LEAD_SPEED,
-  )
@@ -1,190 +0,0 @@
-import math
-from statistics import median
-
-import numpy as np
-
-from openpilot.cereal import custom
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_controller.constants import (
-  CAP_FILTER_FRAMES, DEPARTURE_MOTION_NOISE_FLOOR, DEPARTURE_MOTION_STEP_MIN, SPEED_RELIEF_DEADBAND, STOP_HOLD_CREEP_DISTANCE,
-  STOP_HOLD_CREEP_SPEED, STOP_HOLD_EXIT_FRAMES,
-)
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_controller.lead import LeadPlan
-
-
-AccelControllerState = custom.LongitudinalPlanSP.AccelController.State
-
-
-class DepartureTracker:
-  def __init__(self) -> None:
-    self.samples: list[list[float]] = [[], []]
-    self.motion_samples: list[float] = []
-    self.references: list[float | None] = [None, None]
-    self.track_ids = [-1, -1]
-
-  def separation(self, lead_index: int) -> float:
-    samples = self.samples[lead_index]
-    return float(median(samples)) if samples else -math.inf
-
-  def update(self, lead_plan: LeadPlan, dt: float) -> None:
-    for lead_index, distance in enumerate(lead_plan.departure_lead_distances):
-      if not math.isfinite(distance):
-        continue
-      samples = self.samples[lead_index]
-      track_id = lead_plan.departure_lead_track_ids[lead_index]
-      identity_changed = bool(samples) and track_id != self.track_ids[lead_index] and (track_id >= 0 or self.track_ids[lead_index] >= 0)
-      max_distance_step = max(STOP_HOLD_CREEP_DISTANCE / 2.0, 3.0 * lead_plan.departure_lead_speeds[lead_index] * dt)
-      geometry_jump = bool(samples) and abs(distance - samples[-1]) > max_distance_step
-      if identity_changed or geometry_jump:
-        samples.clear()
-        self.references[lead_index] = distance
-      samples.append(distance)
-      if len(samples) > CAP_FILTER_FRAMES:
-        samples.pop(0)
-      self.track_ids[lead_index] = track_id
-    lead_index = lead_plan.departure_lead_index
-    if lead_index >= 0:
-      distance = lead_plan.departure_lead_distances[lead_index]
-      samples = self.motion_samples
-      max_distance_step = max(STOP_HOLD_CREEP_DISTANCE / 2.0, 3.0 * lead_plan.departure_lead_speed * dt)
-      if samples and abs(distance - samples[-1]) > max_distance_step:
-        samples.clear()
-      samples.append(distance)
-      if len(samples) > CAP_FILTER_FRAMES:
-        samples.pop(0)
-
-  def seed(self, lead_plan: LeadPlan) -> None:
-    self.samples = [[], []]
-    self.motion_samples = []
-    self.references = [None, None]
-    self.track_ids = list(lead_plan.departure_lead_track_ids)
-    for lead_index, distance in enumerate(lead_plan.departure_lead_distances):
-      if math.isfinite(distance):
-        self.samples[lead_index].append(distance)
-        self.references[lead_index] = distance
-    if lead_plan.departure_lead_index >= 0:
-      self.motion_samples.append(lead_plan.departure_lead_distances[lead_plan.departure_lead_index])
-
-  def progress(self, lead_plan: LeadPlan, minimum_distance: float) -> bool:
-    lead_index = lead_plan.departure_lead_index
-    if lead_index < 0 or lead_plan.departure_lead_speed <= STOP_HOLD_CREEP_SPEED:
-      return False
-    reference = self.references[lead_index]
-    distance = self.separation(lead_index)
-    return reference is not None and distance - reference >= minimum_distance
-
-  def recent_motion(self) -> bool:
-    samples = self.motion_samples[-STOP_HOLD_EXIT_FRAMES:]
-    if len(samples) < STOP_HOLD_EXIT_FRAMES:
-      return False
-    deltas = np.diff(samples)
-    return bool(samples[-1] - samples[0] >= DEPARTURE_MOTION_NOISE_FLOOR and np.count_nonzero(deltas > DEPARTURE_MOTION_STEP_MIN) >= 2)
-
-  def backfill_references(self) -> None:
-    for lead_index in range(len(self.references)):
-      separation = self.separation(lead_index)
-      if math.isfinite(separation) and self.references[lead_index] is None:
-        self.references[lead_index] = separation
-
-  def keep_latest_motion_sample(self) -> None:
-    if self.motion_samples:
-      self.motion_samples = self.motion_samples[-1:]
-
-
-class TargetState:
-  def __init__(self) -> None:
-    self.cap_samples = [math.inf] * CAP_FILTER_FRAMES
-    self.lead_speed_samples = [math.inf] * CAP_FILTER_FRAMES
-    self.lead_accel_samples = [0.0] * CAP_FILTER_FRAMES
-    self.departure = DepartureTracker()
-    self.target_speed: float | None = None
-    self.state = AccelControllerState.inactive
-    self.departure_frames = self.active_frames = self.lead_loss_frames = self.release_settle_frames = 0
-    self.lead_switch_guard_frames = self.lead_switch_elapsed_frames = self.lead_switch_stable_frames = self.stale_frames = 0
-    self.selected_lead = self.selected_lead_track_id = -1
-    self.launching = self.departure_launch = self.matched_lead = self.lead_dropout = self.release_slew_armed = False
-    self.lead_braking = self.e2e_braking_handoff = self.speed_reserve_armed = False
-    self.matched_accel_limit: float | None = None
-    self.release_settle_speed: float | None = None
-
-  def reset_lead_switch_guard(self) -> None:
-    self.lead_switch_guard_frames = self.lead_switch_elapsed_frames = self.lead_switch_stable_frames = 0
-
-  def arm_release_slew(self, force: bool = False) -> None:
-    if self.release_slew_armed:
-      self.release_settle_frames = 0
-      return
-    if not force and self.release_settle_speed is not None and self.target_speed is not None:
-      if self.release_settle_speed - self.target_speed < SPEED_RELIEF_DEADBAND:
-        return
-    self.release_slew_armed = True
-    self.release_settle_frames = 0
-    self.release_settle_speed = None
-
-  def reset_release_slew(self, settled_speed: float | None = None) -> None:
-    self.release_slew_armed = False
-    self.release_settle_frames = 0
-    self.release_settle_speed = settled_speed
-
-  def update_release_slew(self, ceiling: float, settled: bool) -> None:
-    if not self.release_slew_armed:
-      return
-    if not settled:
-      self.release_settle_frames = 0
-    elif self.release_settle_speed is None or ceiling > self.release_settle_speed:
-      self.release_settle_frames = 1
-      self.release_settle_speed = ceiling
-    else:
-      self.release_settle_frames += 1
-    if self.release_settle_frames >= CAP_FILTER_FRAMES:
-      self.release_slew_armed = False
-      self.release_settle_frames = 0
-
-  def update_lead_switch_guard(self, arm: bool, confirmed: bool, unstable: bool, hold_frames: int, max_frames: int) -> None:
-    if self.lead_switch_elapsed_frames > 0:
-      self.lead_switch_stable_frames = 0 if unstable else self.lead_switch_stable_frames + 1
-      if self.lead_switch_guard_frames == 0 and self.lead_switch_stable_frames >= hold_frames:
-        self.reset_lead_switch_guard()
-    if arm and self.lead_switch_elapsed_frames == 0:
-      self.lead_switch_guard_frames, self.lead_switch_elapsed_frames = hold_frames, 1
-    elif self.lead_switch_guard_frames > 0:
-      self.lead_switch_elapsed_frames += 1
-      if self.lead_switch_elapsed_frames >= max_frames:
-        self.lead_switch_guard_frames = 0
-      else:
-        self.lead_switch_guard_frames = self.lead_switch_guard_frames - 1 if confirmed else hold_frames
-
-  @property
-  def filtered_cap(self) -> float:
-    return sorted(self.cap_samples)[CAP_FILTER_FRAMES // 2]
-
-  @property
-  def filtered_lead_speed(self) -> float:
-    return sorted(self.lead_speed_samples)[CAP_FILTER_FRAMES // 2]
-
-  @property
-  def filtered_lead_accel(self) -> float:
-    return sorted(self.lead_accel_samples)[CAP_FILTER_FRAMES // 2]
-
-  def update_samples(self, lead_plan: LeadPlan, dt: float) -> bool:
-    had_filtered_lead = math.isfinite(self.filtered_cap)
-    has_lead = lead_plan.selected_lead >= 0
-    self.cap_samples.append(lead_plan.cap if has_lead else math.inf)
-    self.lead_speed_samples.append(lead_plan.selected_lead_speed if has_lead else math.inf)
-    self.lead_accel_samples.append(lead_plan.selected_lead_accel if has_lead else 0.0)
-    self.cap_samples.pop(0)
-    self.lead_speed_samples.pop(0)
-    self.lead_accel_samples.pop(0)
-    self.lead_loss_frames = 0 if has_lead else self.lead_loss_frames + 1
-    self.departure.update(lead_plan, dt)
-    return not had_filtered_lead and math.isfinite(self.filtered_cap)
-
-  def enter_stop_hold(self, lead_plan: LeadPlan) -> None:
-    self.departure.seed(lead_plan)
-    self.target_speed = 0.0
-    self.state = AccelControllerState.stopHold
-    self.departure_frames = 0
-    self.launching = self.departure_launch = False
-    self.reset_release_slew()
-    self.matched_lead = self.speed_reserve_armed = False
-    self.matched_accel_limit = None
-    self.reset_lead_switch_guard()
@@ -1,532 +0,0 @@
-import inspect
-import math
-from types import SimpleNamespace
-
-import numpy as np
-import pytest
-
-from openpilot.cereal import custom, log, messaging
-from opendbc.car.interfaces import ACCEL_MAX, ACCEL_MIN
-from openpilot.common.realtime import DT_MDL
-from openpilot.selfdrive.controls.lib.longitudinal_mpc_lib.long_mpc import N, LongitudinalMpc
-from openpilot.selfdrive.controls.lib.longitudinal_mpc_lib.long_mpc import LongitudinalPlanSource as MpcLongitudinalPlanSource
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_controller.accel_controller import AccelController, AccelControllerState
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_controller.constants import (
-  MPC_DECEL_JERK_COST_MULTIPLIER, MPC_DECEL_JERK_MAX_REQUIRED_DECEL, MPC_DECEL_JERK_MAX_TARGET_REDUCTION, AccelProfile,
-)
-from openpilot.sunnypilot.selfdrive.controls.lib.longitudinal_mpc_lib.long_mpc import LongitudinalMpcSP
-from openpilot.sunnypilot.selfdrive.controls.lib.longitudinal_planner import LongitudinalPlannerSP, LongitudinalPlanSource
-
-
-def radar_state():
-  return messaging.new_message("radarState").radarState
-
-
-class PlannerSM(dict):
-  def __init__(self, radar_log_mono_time: int):
-    super().__init__(
-      radarState=radar_state(),
-      carState=SimpleNamespace(vEgo=10.0, aEgo=0.0, vCruise=20.0),
-      selfdriveState=SimpleNamespace(personality=0),
-      controlsState=SimpleNamespace(forceDecel=False),
-    )
-    self.valid = {"radarState": True}
-    self.alive = {"radarState": True}
-    self.logMonoTime = {"radarState": radar_log_mono_time}
-
-
-class ControllerStub:
-  def __init__(self, *, target_speed=15.0, active=True, mpc_accel_max=None, cruise_accel_max=None,
-               state=AccelControllerState.free, selected_lead=-1,
-               selected_lead_track_id=-1, launching=False, departure_launching=False, required_decel=0.0):
-    self.available = self.enabled = True
-    self.profile = AccelProfile.normal
-    self.output_v_target = target_speed
-    self.is_active = active
-    self.mpc_accel_max = mpc_accel_max
-    self.cruise_accel_max = cruise_accel_max
-    self.state = state
-    self.selected_lead = selected_lead
-    self.selected_lead_track_id = selected_lead_track_id
-    self.launching = launching
-    self.departure_launching = departure_launching
-    self.required_decel = required_decel
-    self.dt = DT_MDL
-    self._jerk_smoothing_blocked = False
-    self._required_decel_samples = []
-    self._required_decel_lead = -1
-    self._required_decel_lead_track_id = -1
-    self._lead_trend_warmup = False
-    self.update_kwargs = None
-    self.reset_calls = 0
-
-  def update(self, _radar_state, **kwargs):
-    self.update_kwargs = kwargs
-
-  @property
-  def is_enabled(self):
-    return self.available and self.enabled
-
-  def update_params(self):
-    pass
-
-  def reset(self):
-    self.reset_calls += 1
-
-  def get_jerk_cost_multiplier(self, *args):
-    return AccelController.get_jerk_cost_multiplier(self, *args)
-
-  def update_should_stop(self, should_stop):
-    return AccelController.update_should_stop(self, should_stop)
-
-
-def planner_for_mpc_test(*, target_speed=15.0, active=True, is_e2e=False, mpc_accel_max=None,
-                         cruise_accel_max=None,
-                         state=AccelControllerState.free, selected_lead=-1, launching=False,
-                         departure_launching=False, required_decel=0.0,
-                         mpc_source=MpcLongitudinalPlanSource.lead0):
-  planner = LongitudinalPlannerSP.__new__(LongitudinalPlannerSP)
-  is_e2e_calls = []
-  planner.is_e2e = lambda _sm: is_e2e_calls.append(True) or is_e2e
-  planner.output_v_target = 20.0
-  planner.output_should_stop = False
-  planner.allow_throttle = True
-  planner.a_desired = 0.0
-  planner.v_desired_filter = SimpleNamespace(x=10.0)
-  planner._radar_fresh_this_cycle = True
-  planner.mpc = SimpleNamespace(source=mpc_source, last_solution_status=0)
-  planner.accel_controller = ControllerStub(
-    target_speed=target_speed, active=active, state=state, selected_lead=selected_lead, launching=launching,
-    departure_launching=departure_launching, required_decel=required_decel, mpc_accel_max=mpc_accel_max,
-    cruise_accel_max=cruise_accel_max,
-  )
-  return planner, is_e2e_calls
-
-
-def prepare_controller_mpc(planner, *, mpc_v_cruise=20.0, force_decel=False):
-  configs = []
-  sm = {
-    "radarState": radar_state(),
-    "controlsState": SimpleNamespace(forceDecel=force_decel),
-    "carState": SimpleNamespace(vCruise=20.0, vEgo=10.0, aEgo=0.0),
-    "selfdriveState": SimpleNamespace(personality=0),
-  }
-  planner.mpc.set_accel_controller_params = lambda *args: configs.append(args)
-  is_e2e, target = planner.update_accel_controller(sm, mpc_v_cruise, True, ACCEL_MAX, False)
-  assert len(configs) == 1
-  return is_e2e, target, configs[0]
-
-
-def test_accel_controller_schema_contract():
-  expected = {"eco": 0, "normal": 1, "sport": 2}
-  state = {"inactive": 0, "free": 1, "restrict": 2, "hold": 3, "release": 4, "stopHold": 5}
-  accel_controller = custom.LongitudinalPlanSP.schema.fields["accelController"]
-  fields = custom.LongitudinalPlanSP.AccelController.schema.fields
-
-  assert accel_controller.proto.ordinal.explicit == 8
-  assert {name: field.proto.ordinal.explicit for name, field in fields.items()} == {
-    "enabled": 0, "active": 1, "shadowOnlyDEPRECATED": 2, "profile": 3, "state": 4,
-  }
-  assert fields["shadowOnlyDEPRECATED"].proto.slot.type.which() == "bool"
-  assert custom.LongitudinalPlanSP.AccelerationPersonality.schema.enumerants == expected
-  assert custom.LongitudinalPlanSP.AccelController.Profile.schema.enumerants == expected
-  assert custom.LongitudinalPlanSP.AccelController.State.schema.enumerants == state
-
-
-def test_accel_controller_schema_round_trip_and_toyota_compatibility():
-  message = custom.LongitudinalPlanSP.new_message()
-  message.accelController.enabled = True
-  message.accelController.active = True
-  message.accelController.profile = custom.LongitudinalPlanSP.AccelController.Profile.sport
-  message.accelController.state = custom.LongitudinalPlanSP.AccelController.State.release
-
-  with custom.LongitudinalPlanSP.from_bytes(message.to_bytes()) as reader:
-    assert reader.accelController.enabled and reader.accelController.active
-    assert reader.accelController.profile == custom.LongitudinalPlanSP.AccelController.Profile.sport
-    assert reader.accelController.state == custom.LongitudinalPlanSP.AccelController.State.release
-
-  from opendbc.car.toyota.carstate import AccelPersonality, CarState
-
-  assert AccelPersonality.schema.enumerants == {"eco": 0, "normal": 1, "sport": 2}
-  assert CarState.__module__ == "opendbc.car.toyota.carstate"
-
-
-def test_mpc_inherits_accel_controller_extension_without_changing_stock_signature_or_bounds():
-  assert LongitudinalMpc.__bases__ == (LongitudinalMpcSP,)
-  assert tuple(inspect.signature(LongitudinalMpc.update).parameters) == ("self", "radarstate", "v_cruise", "personality")
-  mpc = LongitudinalMpc()
-  radar = radar_state()
-  mpc.run = lambda: None
-
-  mpc.set_cur_state(10.0, 0.8)
-  mpc.update(radar, 30.0)
-  np.testing.assert_array_equal(mpc.params[:, 0], ACCEL_MIN)
-  np.testing.assert_array_equal(mpc.params[:, 1], ACCEL_MAX)
-  assert mpc.cruise_accel_max(1.6) == 1.6
-
-  mpc.set_accel_controller_params(None, 1.0, 0.4)
-  assert mpc.cruise_accel_max(1.6) == 0.4
-
-  requested_ceiling = tuple(np.full(N + 1, 0.4))
-  mpc.set_accel_controller_params(requested_ceiling, 1.0)
-  mpc.update(radar, 30.0)
-  np.testing.assert_array_equal(mpc.params[:, 0], ACCEL_MIN)
-  assert mpc.params[0, 1] == pytest.approx(0.8)
-  np.testing.assert_array_equal(mpc.params[1:, 1], requested_ceiling[1:])
-
-  for malformed_ceiling in ("bad", [0.4] * N, np.full(N + 1, math.nan), [10**10000] * (N + 1)):
-    mpc.set_accel_controller_params(malformed_ceiling, 1.0)
-    mpc.update(radar, 30.0)
-    np.testing.assert_array_equal(mpc.params[:, 0], ACCEL_MIN)
-    np.testing.assert_array_equal(mpc.params[:, 1], ACCEL_MAX)
-
-  mpc.set_accel_controller_params(None, 1.0)
-  mpc.update(radar, 30.0)
-  np.testing.assert_array_equal(mpc.params[:, 1], ACCEL_MAX)
-
-
-def test_mpc_jerk_cost_multiplier_is_backward_compatible_and_does_not_change_other_costs():
-  mpc = LongitudinalMpc.__new__(LongitudinalMpc)
-  LongitudinalMpcSP.__init__(mpc)
-  captured = []
-  mpc.set_cost_weights = lambda costs, constraints: captured.append((np.asarray(costs), np.asarray(constraints)))
-
-  mpc.set_weights(True, personality=log.LongitudinalPersonality.standard)
-  default_costs, default_constraints = captured[-1]
-  mpc.set_accel_controller_params(None, 1.0)
-  mpc.set_weights(True, personality=log.LongitudinalPersonality.standard)
-  explicit_costs, explicit_constraints = captured[-1]
-  mpc.set_accel_controller_params(None, 1.2)
-  mpc.set_weights(True, personality=log.LongitudinalPersonality.standard)
-  smoothed_costs, smoothed_constraints = captured[-1]
-
-  np.testing.assert_array_equal(explicit_costs, default_costs)
-  np.testing.assert_array_equal(explicit_constraints, default_constraints)
-  np.testing.assert_array_equal(smoothed_costs[:-1], default_costs[:-1])
-  assert smoothed_costs[-1] == pytest.approx(default_costs[-1] * 1.2)
-  np.testing.assert_array_equal(smoothed_constraints, default_constraints)
-
-  mpc.set_weights(False, personality=log.LongitudinalPersonality.standard)
-  assert captured[-1][0][-2] == 0.0
-  assert captured[-1][0][-1] == pytest.approx(default_costs[-1] * 1.2)
-
-
-def test_accel_controller_hook_only_configures_mpc():
-  radar = radar_state()
-  planner, _ = planner_for_mpc_test(active=False)
-  calls = []
-  planner.mpc = SimpleNamespace(
-    source=MpcLongitudinalPlanSource.cruise,
-    last_solution_status=0,
-    set_accel_controller_params=lambda accel_max, multiplier, cruise_accel_max: calls.append(
-      ("configure", accel_max, multiplier, cruise_accel_max)),
-    set_weights=lambda constraint, personality: calls.append(("weights", constraint, personality)),
-    set_cur_state=lambda speed, accel: calls.append(("state", speed, accel)),
-    update=lambda radar_arg, target, *, personality: calls.append(("update", radar_arg, target, personality)),
-  )
-  sm = {
-    "radarState": radar,
-    "controlsState": SimpleNamespace(forceDecel=False),
-    "carState": SimpleNamespace(vCruise=20.0, vEgo=10.0, aEgo=0.0),
-    "selfdriveState": SimpleNamespace(personality=2),
-  }
-  is_e2e, target = planner.update_accel_controller(sm, 17.5, True, ACCEL_MAX, False)
-
-  assert not is_e2e and target == 17.5
-  assert calls == [("configure", None, 1.0, None)]
-
-
-def test_active_acc_uses_target_and_ceiling_in_exactly_one_solve():
-  ceiling = tuple(np.linspace(0.8, 0.4, N + 1))
-  planner, mode_calls = planner_for_mpc_test(mpc_accel_max=ceiling)
-  is_e2e, target, config = prepare_controller_mpc(planner)
-
-  assert not is_e2e
-  assert len(mode_calls) == 1
-  assert target == 15.0
-  assert config == (ceiling, 1.0, None)
-
-
-def test_cruise_accel_ceiling_is_forwarded_to_mpc():
-  planner, _ = planner_for_mpc_test(cruise_accel_max=0.3)
-  _, _, config = prepare_controller_mpc(planner)
-  assert config == (None, 1.0, 0.3)
-
-
-def test_valid_lead_stop_hold_preplans_from_raw_target_without_an_accel_ceiling():
-  planner, _ = planner_for_mpc_test(
-    target_speed=0.0, mpc_accel_max=None, state=AccelControllerState.stopHold, selected_lead=0,
-  )
-  _, target, config = prepare_controller_mpc(planner)
-
-  assert target == 20.0
-  assert config == (None, 1.0, None)
-
-
-def test_missing_lead_stop_hold_keeps_zero_mpc_target_without_an_accel_ceiling():
-  planner, _ = planner_for_mpc_test(
-    target_speed=0.0, mpc_accel_max=None, state=AccelControllerState.stopHold, selected_lead=-1,
-  )
-  _, target, config = prepare_controller_mpc(planner)
-
-  assert target == 0.0
-  assert config == (None, 1.0, None)
-
-
-@pytest.mark.parametrize(
-  ("active", "departure_launching", "expected"),
-  [
-    (True, True, False),
-    (True, False, True),
-    (False, True, True),
-  ],
-)
-def test_only_confirmed_live_acc_departure_clears_should_stop(active, departure_launching, expected):
-  planner = LongitudinalPlannerSP.__new__(LongitudinalPlannerSP)
-  planner.accel_controller = ControllerStub(active=active, departure_launching=departure_launching, state=AccelControllerState.stopHold)
-  assert planner.update_should_stop(True) is expected
-  assert planner.update_should_stop(False) is (active and not departure_launching)
-
-
-@pytest.mark.parametrize(("active", "is_e2e"), [(False, False), (True, True)])
-def test_disabled_or_e2e_is_an_exact_mpc_bypass(active, is_e2e):
-  ceiling = tuple(np.linspace(0.8, 0.4, N + 1))
-  planner, mode_calls = planner_for_mpc_test(active=active, is_e2e=is_e2e, mpc_accel_max=ceiling)
-  returned_e2e, target, config = prepare_controller_mpc(planner)
-
-  assert returned_e2e is is_e2e
-  assert len(mode_calls) == 1
-  assert target == 20.0
-  assert config == (None, 1.0, None)
-
-
-def test_force_decel_target_remains_authoritative_and_disables_ceiling():
-  ceiling = tuple(np.linspace(0.8, 0.4, N + 1))
-  planner, mode_calls = planner_for_mpc_test(mpc_accel_max=ceiling)
-  _, target, config = prepare_controller_mpc(planner, mpc_v_cruise=0.0, force_decel=True)
-
-  assert len(mode_calls) == 1
-  assert target == 0.0
-  assert config == (None, 1.0, None)
-
-
-def test_previous_mpc_failure_gets_one_stock_recovery_cycle_without_resetting_controller_state():
-  ceiling = tuple(np.linspace(0.8, 0.4, N + 1))
-  planner, mode_calls = planner_for_mpc_test(mpc_accel_max=ceiling)
-  controller = planner.accel_controller
-  planner.mpc.last_solution_status = 4
-
-  _, failed_target, failed_config = prepare_controller_mpc(planner)
-  assert controller.reset_calls == 0
-  assert controller.update_kwargs["acc_selected"]
-  assert len(mode_calls) == 1
-  assert failed_target == 20.0
-  assert failed_config == (None, 1.0, None)
-
-  planner.mpc.last_solution_status = 0
-  _, recovered_target, recovered_config = prepare_controller_mpc(planner)
-  assert controller.reset_calls == 0
-  assert len(mode_calls) == 2
-  assert recovered_target == 15.0
-  assert recovered_config == (ceiling, 1.0, None)
-
-
-@pytest.mark.parametrize(
-  "mpc_source",
-  (MpcLongitudinalPlanSource.cruise, MpcLongitudinalPlanSource.lead0, MpcLongitudinalPlanSource.lead1),
-)
-def test_routine_governor_restriction_forwards_the_jerk_cost_multiplier(mpc_source):
-  planner, _ = planner_for_mpc_test(
-    state=AccelControllerState.restrict, selected_lead=0, required_decel=0.30,
-    mpc_source=mpc_source,
-  )
-  _, target, config = prepare_controller_mpc(planner)
-
-  assert target == 15.0
-  assert config == (None, MPC_DECEL_JERK_COST_MULTIPLIER, None)
-
-
-def test_ineligible_required_decel_blocks_smoothing_only_until_the_restriction_episode_ends():
-  planner, _ = planner_for_mpc_test(
-    state=AccelControllerState.restrict, selected_lead=0, required_decel=0.30,
-  )
-  _, _, initial_config = prepare_controller_mpc(planner)
-  controller = planner.accel_controller
-  assert initial_config[1] == MPC_DECEL_JERK_COST_MULTIPLIER
-
-  controller.required_decel = MPC_DECEL_JERK_MAX_REQUIRED_DECEL
-  _, _, ineligible_config = prepare_controller_mpc(planner)
-  assert ineligible_config[1] == 1.0
-
-  controller.required_decel = 0.30
-  _, _, flicker_config = prepare_controller_mpc(planner)
-  assert flicker_config[1] == 1.0
-
-  controller.state = AccelControllerState.free
-  controller.output_v_target = 20.0
-  prepare_controller_mpc(planner)
-  controller.state = AccelControllerState.restrict
-  controller.output_v_target = 15.0
-  _, _, rearmed_config = prepare_controller_mpc(planner)
-  assert rearmed_config[1] == MPC_DECEL_JERK_COST_MULTIPLIER
-
-
-def test_consistently_tightening_lead_releases_smoothing_until_the_restriction_ends():
-  planner, _ = planner_for_mpc_test(
-    state=AccelControllerState.restrict, selected_lead=0, required_decel=0.18,
-  )
-  _, _, config = prepare_controller_mpc(planner)
-  controller = planner.accel_controller
-  multipliers = [config[1]]
-  for required_decel in (0.20, 0.23, 0.25):
-    controller.required_decel = required_decel
-    _, _, config = prepare_controller_mpc(planner)
-    multipliers.append(config[1])
-
-  assert multipliers == [MPC_DECEL_JERK_COST_MULTIPLIER] * 3 + [1.0]
-
-  controller.required_decel = 0.20
-  _, _, config = prepare_controller_mpc(planner)
-  assert config[1] == 1.0
-
-  controller.state = AccelControllerState.free
-  controller.output_v_target = 20.0
-  prepare_controller_mpc(planner)
-  controller.state = AccelControllerState.restrict
-  controller.output_v_target = 15.0
-  controller.required_decel = 0.18
-  _, _, config = prepare_controller_mpc(planner)
-  assert config[1] == MPC_DECEL_JERK_COST_MULTIPLIER
-
-
-def test_one_frame_required_decel_noise_does_not_disable_routine_smoothing():
-  planner, _ = planner_for_mpc_test(
-    state=AccelControllerState.restrict, selected_lead=0, required_decel=0.18,
-  )
-  _, _, config = prepare_controller_mpc(planner)
-  controller = planner.accel_controller
-  multipliers = [config[1]]
-  for required_decel in (0.24, 0.19, 0.22):
-    controller.required_decel = required_decel
-    _, _, config = prepare_controller_mpc(planner)
-    multipliers.append(config[1])
-
-  assert multipliers == [MPC_DECEL_JERK_COST_MULTIPLIER] * 4
-
-
-@pytest.mark.parametrize(
-  ("state", "selected_lead", "launching", "required_decel", "target_speed", "mpc_source"),
-  [
-    (AccelControllerState.free, 0, False, 0.30, 15.0, MpcLongitudinalPlanSource.cruise),
-    (AccelControllerState.hold, 0, False, 0.30, 15.0, MpcLongitudinalPlanSource.cruise),
-    (AccelControllerState.stopHold, 0, False, 0.30, 15.0, MpcLongitudinalPlanSource.cruise),
-    (AccelControllerState.restrict, -1, False, 0.30, 15.0, MpcLongitudinalPlanSource.cruise),
-    (AccelControllerState.restrict, 0, True, 0.30, 15.0, MpcLongitudinalPlanSource.cruise),
-    (AccelControllerState.restrict, 0, False, MPC_DECEL_JERK_MAX_REQUIRED_DECEL, 15.0, MpcLongitudinalPlanSource.cruise),
-    (AccelControllerState.restrict, 0, False, math.inf, 15.0, MpcLongitudinalPlanSource.cruise),
-    (AccelControllerState.restrict, 0, False, math.nan, 15.0, MpcLongitudinalPlanSource.cruise),
-    (AccelControllerState.restrict, 0, False, 0.0, 15.0, MpcLongitudinalPlanSource.cruise),
-    (AccelControllerState.restrict, 0, False, -0.01, 15.0, MpcLongitudinalPlanSource.cruise),
-    (AccelControllerState.restrict, 0, False, 0.30, 20.0 - MPC_DECEL_JERK_MAX_TARGET_REDUCTION, MpcLongitudinalPlanSource.cruise),
-    (AccelControllerState.restrict, 0, False, 0.30, 20.0, MpcLongitudinalPlanSource.cruise),
-    (AccelControllerState.restrict, 0, False, 0.30, 25.0, MpcLongitudinalPlanSource.cruise),
-  ],
-)
-def test_non_routine_or_stock_lead_states_keep_stock_jerk_cost(
-  state, selected_lead, launching, required_decel, target_speed, mpc_source,
-):
-  planner, _ = planner_for_mpc_test(
-    state=state, selected_lead=selected_lead, launching=launching,
-    required_decel=required_decel, target_speed=target_speed, mpc_source=mpc_source,
-  )
-  _, _, config = prepare_controller_mpc(planner)
-
-  assert config[1] == 1.0
-
-
-def test_controller_receives_previous_mpc_state_and_cached_radar_freshness():
-  planner, _ = planner_for_mpc_test(mpc_source=log.LongitudinalPlan.LongitudinalPlanSource.lead0)
-  planner._radar_fresh_this_cycle = True
-  planner.a_desired = -0.4
-  planner.v_desired_filter = SimpleNamespace(x=9.5)
-  prepare_controller_mpc(planner)
-  received = planner.accel_controller.update_kwargs
-
-  assert received["previous_mpc_source"] == log.LongitudinalPlan.LongitudinalPlanSource.lead0
-  assert received["planner_speed"] == 9.5
-  assert received["planner_accel"] == -0.4
-  assert received["radar_fresh"] is True
-
-
-def test_controller_is_disabled_when_openpilot_longitudinal_control_is_unavailable():
-  controller = AccelController(SimpleNamespace(longitudinalActuatorDelay=0.1, openpilotLongitudinalControl=False))
-  controller.enabled = True
-  assert not controller.is_enabled
-
-
-def test_radar_freshness_is_computed_once_and_shared_with_dec_and_controller():
-  planner = LongitudinalPlannerSP.__new__(LongitudinalPlannerSP)
-  planner._radar_log_mono_time = None
-  planner._radar_fresh_this_cycle = True
-  planner.events_sp = SimpleNamespace(clear=lambda: None)
-  dec_freshness = []
-  planner.dec = SimpleNamespace(update=lambda _sm, *, radar_fresh, planner_accel: dec_freshness.append(radar_fresh))
-  planner.e2e_alerts_helper = SimpleNamespace(update=lambda *_args: None)
-  planner.output_a_target = 0.0
-  planner.output_v_target = 20.0
-  planner.output_should_stop = False
-  planner.allow_throttle = True
-  planner.a_desired = 0.0
-  planner.v_desired_filter = SimpleNamespace(x=10.0)
-  planner.mpc = SimpleNamespace(
-    source=log.LongitudinalPlan.LongitudinalPlanSource.cruise, last_solution_status=0,
-    set_accel_controller_params=lambda *_args: None,
-  )
-  planner.is_e2e = lambda _sm: False
-  planner.accel_controller = ControllerStub(target_speed=20.0, active=False)
-
-  sm = PlannerSM(100)
-  for expected in (True, False):
-    planner.update(sm)
-    planner.update_accel_controller(sm, 20.0, True, ACCEL_MAX, False)
-    assert dec_freshness[-1] is expected and planner.accel_controller.update_kwargs["radar_fresh"] is expected
-
-  sm.logMonoTime["radarState"] = 101
-  planner.update(sm)
-  planner.update_accel_controller(sm, 20.0, True, ACCEL_MAX, False)
-  assert dec_freshness[-1] is True and planner.accel_controller.update_kwargs["radar_fresh"] is True
-
-
-def test_accel_controller_status_publishes_minimal_fields():
-  planner = LongitudinalPlannerSP.__new__(LongitudinalPlannerSP)
-  planner.source = LongitudinalPlanSource.cruise
-  planner.output_v_target = 20.0
-  planner.output_a_target = 0.0
-  planner.events_sp = SimpleNamespace(to_msg=list)
-  planner.dec = SimpleNamespace(mode=lambda: "acc", enabled=lambda: False, active=lambda: False)
-  planner.accel_controller = ControllerStub(active=False, state=AccelControllerState.restrict)
-  planner.scc = SimpleNamespace(
-    vision=SimpleNamespace(state=0, output_v_target=20.0, output_a_target=0.0, current_lat_acc=0.0, max_pred_lat_acc=0.0, is_enabled=False, is_active=False),
-    map=SimpleNamespace(state=0, output_v_target=20.0, output_a_target=0.0, is_enabled=False, is_active=False),
-  )
-  planner.resolver = SimpleNamespace(
-    speed_limit=0.0, speed_limit_last=0.0, speed_limit_final=0.0, speed_limit_final_last=0.0,
-    speed_limit_valid=False, speed_limit_last_valid=False, speed_limit_offset=0.0, distance=0.0,
-    source=custom.LongitudinalPlanSP.SpeedLimit.Source.none,
-  )
-  planner.sla = SimpleNamespace(
-    state=custom.LongitudinalPlanSP.SpeedLimit.AssistState.disabled, is_enabled=False, is_active=False,
-    output_v_target=20.0, output_a_target=0.0,
-  )
-  planner.e2e_alerts_helper = SimpleNamespace(green_light_alert=False, lead_depart_alert=False)
-  sent = {}
-  planner.publish_longitudinal_plan_sp(
-    SimpleNamespace(all_checks=lambda service_list: True),
-    SimpleNamespace(send=lambda service, message: sent.update({service: message})),
-  )
-
-  telemetry = sent["longitudinalPlanSP"].longitudinalPlanSP.accelController
-  assert telemetry.enabled and not telemetry.active
-  assert telemetry.profile == int(AccelProfile.normal)
-  assert telemetry.state == int(AccelControllerState.restrict)
-  assert set(custom.LongitudinalPlanSP.AccelController.schema.fields) == {"enabled", "active", "shadowOnlyDEPRECATED", "profile", "state"}
@@ -1,48 +1,17 @@
-from openpilot.common.realtime import DT_MDL
-
-
 class WMACConstants:
-  TRAJECTORY_SIZE = 33
-  PARAM_READ_FRAMES = max(1, int(round(1.0 / DT_MDL)))
+  # Lead detection parameters
+  LEAD_WINDOW_SIZE = 6  # Stable detection window
+  LEAD_PROB = 0.45  # Balanced threshold for lead detection

-  EMERGENCY_HOLD_FRAMES = max(1, int(round(0.75 / DT_MDL)))
-  MIN_MODE_DURATION = {'acc': max(1, int(round(0.6 / DT_MDL))), 'blended': max(1, int(round(0.5 / DT_MDL)))}
-  ENTER_BLENDED_FRAMES = max(1, int(round(0.4 / DT_MDL)))
-  EXIT_BLENDED_FRAMES = max(1, int(round(0.35 / DT_MDL)))
-  STANDSTILL_FRAMES = max(1, int(round(0.2 / DT_MDL)))
+  # Slow down detection parameters
+  SLOW_DOWN_WINDOW_SIZE = 5  # Responsive but stable
+  SLOW_DOWN_PROB = 0.3  # Balanced threshold for slow down scenarios

-  LEAD_PROB = 0.45
-  LEAD_EXIT_PROB = 0.25
-  LEAD_RISE_RATE = 1.0
-  LEAD_FALL_RATE = 0.35
-  RADAR_LEAD_CONTINUITY_FRAMES = max(1, int(round(1.0 / DT_MDL)))
-  RADAR_LEAD_DROPOUT_FRAMES = max(1, int(round(0.2 / DT_MDL)))
-  RADAR_STALE_FRAMES = max(1, int(round(0.5 / DT_MDL)))
-
-  SLOW_DOWN_PROB = 0.5
-  SLOW_DOWN_EXIT_PROB = 0.4
-  SLOW_DOWN_RISE_RATE = 0.65
-  SLOW_DOWN_FALL_RATE = 0.15
+  # Optimized slow down distance curve - smooth and progressive
  SLOW_DOWN_BP = [0., 10., 20., 30., 40., 50., 55., 60.]
  SLOW_DOWN_DIST = [32., 46., 64., 86., 108., 130., 145., 165.]
-  URGENT_SLOW_DOWN_PROB = 0.85

-  MODEL_DECEL_START = -0.5
-  MODEL_DECEL_RANGE = 2.0
-  MODEL_DECEL_TREND_FRAMES = 4
-  MODEL_DECEL_TREND_ACCEL = -0.075
-  MODEL_DECEL_TREND_RATE = 0.35
-  MODEL_DECEL_TREND_MAX_MPC_ACCEL = 0.075
-  MODEL_DECEL_TREND_MAX_COMMAND_STEP = 0.15
-  MODEL_DECEL_TREND_RELEASE_ACCEL = -0.02
-  ENDPOINT_URGENCY_GAIN = 1.3
-  CRITICAL_ENDPOINT_FACTOR = 0.3
-  CRITICAL_URGENCY_GAIN = 1.5
-  SPEED_URGENCY_MIN = 25.0
-  SPEED_URGENCY_RANGE = 80.0
-
-  SLOWNESS_PROB = 0.55
-  SLOWNESS_EXIT_PROB = 0.45
-  SLOWNESS_RISE_RATE = 0.35
-  SLOWNESS_FALL_RATE = 0.5
-  SLOWNESS_CRUISE_OFFSET = 1.025
+  # Slowness detection parameters
+  SLOWNESS_WINDOW_SIZE = 10  # Stable slowness detection
+  SLOWNESS_PROB = 0.55  # Clear threshold for slowness
+  SLOWNESS_CRUISE_OFFSET = 1.025  # Conservative cruise speed offset
@@ -6,119 +6,129 @@ See the LICENSE.md file in the root directory for more details.
 """
 # Version = 2025-6-30

-from collections import deque
-import math
-from typing import Literal
-
 from openpilot.cereal import messaging
-from numpy import interp
 from opendbc.car import structs
+from numpy import interp
 from openpilot.common.params import Params
 from openpilot.common.realtime import DT_MDL
 from openpilot.sunnypilot.selfdrive.controls.lib.dec.constants import WMACConstants
+from typing import Literal

+# d-e2e, from modeldata.h
+TRAJECTORY_SIZE = 33
+SET_MODE_TIMEOUT = 15
+
+# Define the valid mode types
 ModeType = Literal['acc', 'blended']


-def clip01(value: float) -> float:
-  return max(0.0, min(1.0, float(value)))
+class SmoothKalmanFilter:
+  """Enhanced Kalman filter with smoothing for stable decision making."""

+  def __init__(self, initial_value=0, measurement_noise=0.1, process_noise=0.01,
+               alpha=1.0, smoothing_factor=0.85):
+    self.x = initial_value
+    self.P = 1.0
+    self.R = measurement_noise
+    self.Q = process_noise
+    self.alpha = alpha
+    self.smoothing_factor = smoothing_factor
+    self.initialized = False
+    self.history = []
+    self.max_history = 10
+    self.confidence = 0.0

-class SmoothedSignal:
-  def __init__(self, rise_rate: float, fall_rate: float, initial_value: float = 0.0):
-    self.rise_rate = clip01(rise_rate)
-    self.fall_rate = clip01(fall_rate)
-    self.value = clip01(initial_value)
+  def add_data(self, measurement):
+    if len(self.history) >= self.max_history:
+      self.history.pop(0)
+    self.history.append(measurement)

-  def update(self, measurement: float) -> float:
-    measurement = clip01(measurement)
-    rate = self.rise_rate if measurement > self.value else self.fall_rate
-    self.value += (measurement - self.value) * rate
-    return self.value
+    if not self.initialized:
+      self.x = measurement
+      self.initialized = True
+      self.confidence = 0.1
+      return

-  def reset(self, value: float = 0.0) -> None:
-    self.value = clip01(value)
+    self.P = self.alpha * self.P + self.Q

+    K = self.P / (self.P + self.R)
+    effective_K = K * (1.0 - self.smoothing_factor) + self.smoothing_factor * 0.1

-class HysteresisSignal:
-  def __init__(self, enter_threshold: float, exit_threshold: float, rise_rate: float, fall_rate: float):
-    self.enter_threshold = clip01(enter_threshold)
-    self.exit_threshold = clip01(exit_threshold)
-    self.filter = SmoothedSignal(rise_rate, fall_rate)
-    self.active = False
+    innovation = measurement - self.x
+    self.x = self.x + effective_K * innovation
+    self.P = (1 - effective_K) * self.P

-  def update(self, measurement: float) -> bool:
-    value = self.filter.update(measurement)
-    threshold = self.exit_threshold if self.active else self.enter_threshold
-    self.active = value > threshold
-    return self.active
+    if abs(innovation) < 0.1:
+      self.confidence = min(1.0, self.confidence + 0.05)
+    else:
+      self.confidence = max(0.1, self.confidence - 0.02)

-  def reset(self) -> None:
-    self.filter.reset()
-    self.active = False
+  def get_value(self):
+    return self.x if self.initialized else None

-  @property
-  def value(self) -> float:
-    return self.filter.value
+  def get_confidence(self):
+    return self.confidence
+
+  def reset_data(self):
+    self.initialized = False
+    self.history = []
+    self.confidence = 0.0


 class ModeTransitionManager:
+  """Manages smooth transitions between driving modes with hysteresis."""
+
  def __init__(self):
    self.current_mode: ModeType = 'acc'
+    self.mode_confidence = {'acc': 1.0, 'blended': 0.0}
+    self.transition_timeout = 0
+    self.min_mode_duration = 10
    self.mode_duration = 0
-    self._pending_mode: ModeType = 'acc'
-    self._pending_count = 0
-    self._blended_hold_frames = 0
+    self.emergency_override = False

-  def request_mode(self, mode: ModeType, immediate: bool = False, hold_frames: int = 0, cancel_hold: bool = False) -> None:
-    if immediate:
-      self._blended_hold_frames = max(self._blended_hold_frames, hold_frames) if mode == 'blended' else 0
-      self._pending_mode = mode
-      self._pending_count = 0
-      self._switch_mode(mode)
+  def request_mode(self, mode: ModeType, confidence: float = 1.0, emergency: bool = False):
+    # Emergency override for critical situations (stops, collisions)
+    if emergency:
+      self.emergency_override = True
+      self.current_mode = mode
+      self.transition_timeout = SET_MODE_TIMEOUT
+      self.mode_duration = 0
      return

-    if cancel_hold and mode == 'acc':
-      self._blended_hold_frames = 0
+    self.mode_confidence[mode] = min(1.0, self.mode_confidence[mode] + 0.1 * confidence)
+    for m in self.mode_confidence:
+      if m != mode:
+        self.mode_confidence[m] = max(0.0, self.mode_confidence[m] - 0.05)

-    if self._blended_hold_frames > 0:
-      mode = 'blended'
-
-    if mode == self.current_mode:
-      self._pending_mode = mode
-      self._pending_count = 0
+    # Require minimum duration in current mode (unless emergency)
+    if self.mode_duration < self.min_mode_duration and not self.emergency_override:
      return

-    if mode != self._pending_mode:
-      self._pending_mode = mode
-      self._pending_count = 1
-    else:
-      self._pending_count += 1
+    # Hysteresis: higher threshold for mode changes
+    confidence_threshold = 0.6 if mode != self.current_mode else 0.3  # Lower threshold for faster response

-    if self.mode_duration < WMACConstants.MIN_MODE_DURATION[self.current_mode]:
-      return
+    if self.mode_confidence[mode] > confidence_threshold:
+      if mode != self.current_mode and self.transition_timeout == 0:
+        self.transition_timeout = SET_MODE_TIMEOUT
+        self.current_mode = mode
+        self.mode_duration = 0

-    required_count = WMACConstants.ENTER_BLENDED_FRAMES if mode == 'blended' else WMACConstants.EXIT_BLENDED_FRAMES
-    if self._pending_count >= required_count:
-      self._switch_mode(mode)
-
-  def update(self) -> None:
-    if self._blended_hold_frames > 0:
-      self._blended_hold_frames -= 1
+  def update(self):
+    if self.transition_timeout > 0:
+      self.transition_timeout -= 1
    self.mode_duration += 1

+    # Reset emergency override after some time
+    if self.emergency_override and self.mode_duration > 20:
+      self.emergency_override = False
+
+    # Gradual confidence decay
+    for mode in self.mode_confidence:
+      self.mode_confidence[mode] *= 0.98
+
  def get_mode(self) -> ModeType:
    return self.current_mode

-  def _switch_mode(self, mode: ModeType) -> None:
-    if mode == self.current_mode:
-      return
-
-    self.current_mode = mode
-    self.mode_duration = 0
-    self._pending_mode = mode
-    self._pending_count = 0
-

 class DynamicExperimentalController:
  def __init__(self, CP: structs.CarParams, mpc, params=None):
@@ -132,32 +142,35 @@ class DynamicExperimentalController:

    self._mode_manager = ModeTransitionManager()

-    self._lead_tracker = HysteresisSignal(
-      enter_threshold=WMACConstants.LEAD_PROB,
-      exit_threshold=WMACConstants.LEAD_EXIT_PROB,
-      rise_rate=WMACConstants.LEAD_RISE_RATE,
-      fall_rate=WMACConstants.LEAD_FALL_RATE,
-    )
-    self._slow_down_tracker = HysteresisSignal(
-      enter_threshold=WMACConstants.SLOW_DOWN_PROB,
-      exit_threshold=WMACConstants.SLOW_DOWN_EXIT_PROB,
-      rise_rate=WMACConstants.SLOW_DOWN_RISE_RATE,
-      fall_rate=WMACConstants.SLOW_DOWN_FALL_RATE,
-    )
-    self._slowness_tracker = HysteresisSignal(
-      enter_threshold=WMACConstants.SLOWNESS_PROB,
-      exit_threshold=WMACConstants.SLOWNESS_EXIT_PROB,
-      rise_rate=WMACConstants.SLOWNESS_RISE_RATE,
-      fall_rate=WMACConstants.SLOWNESS_FALL_RATE,
+    # Smooth filters for stable decision making with faster response for critical scenarios
+    self._lead_filter = SmoothKalmanFilter(
+      measurement_noise=0.15,
+      process_noise=0.05,
+      alpha=1.02,
+      smoothing_factor=0.8
    )

+    self._slow_down_filter = SmoothKalmanFilter(
+      measurement_noise=0.1,
+      process_noise=0.1,
+      alpha=1.05,
+      smoothing_factor=0.7
+    )
+
+    self._slowness_filter = SmoothKalmanFilter(
+      measurement_noise=0.1,
+      process_noise=0.06,
+      alpha=1.015,
+      smoothing_factor=0.92
+    )
+
+    self._mpc_fcw_filter = SmoothKalmanFilter(
+      measurement_noise=0.2,
+      process_noise=0.1,
+      alpha=1.1,
+      smoothing_factor=0.5
+    )
    self._has_lead_filtered = False
-    self._has_any_lead = False
-    self._has_current_radar_acc_lead = False
-    self._has_radar_acc_lead = False
-    self._radar_acc_lead_frames = 0
-    self._radar_fresh = True
-    self._radar_stale_frames = 0
    self._has_slow_down = False
    self._has_slowness = False
    self._has_mpc_fcw = False
@@ -166,18 +179,13 @@ class DynamicExperimentalController:
    self._has_standstill = False
    self._mpc_fcw_crash_cnt = 0
    self._standstill_count = 0
-
+    # debug
    self._endpoint_x = float('inf')
    self._expected_distance = 0.0
    self._trajectory_valid = False
-    self._raw_urgency = 0.0
-    self._model_accel_samples = deque(maxlen=WMACConstants.MODEL_DECEL_TREND_FRAMES)
-    self._model_decel_trending = False
-    self._model_decel_latched = False
-    self._planner_accel = math.nan

  def _read_params(self) -> None:
-    if self._frame % WMACConstants.PARAM_READ_FRAMES == 0:
+    if self._frame % int(1. / DT_MDL) == 0:
      self._enabled = self._params.get_bool("DynamicExperimentalControl")

  def mode(self) -> str:
@@ -190,202 +198,191 @@ class DynamicExperimentalController:
    return self._active

  def set_mpc_fcw_crash_cnt(self) -> None:
+    """Set MPC FCW crash count"""
    self._mpc_fcw_crash_cnt = self._mpc.crash_cnt

-  def _update_calculations(self, sm: messaging.SubMaster, radar_fresh: bool) -> None:
+  def _update_calculations(self, sm: messaging.SubMaster) -> None:
    car_state = sm['carState']
-    radar_state = sm['radarState']
-    lead_one = radar_state.leadOne
-    lead_two = radar_state.leadTwo
+    lead_one = sm['radarState'].leadOne
    md = sm['modelV2']

    self._v_ego_kph = car_state.vEgo * 3.6
    self._v_cruise_kph = car_state.vCruise
    self._has_standstill = car_state.standstill

+    # standstill detection
    if self._has_standstill:
-      self._standstill_count = min(WMACConstants.STANDSTILL_FRAMES * 3, self._standstill_count + 1)
+      self._standstill_count = min(20, self._standstill_count + 1)
    else:
      self._standstill_count = max(0, self._standstill_count - 1)

-    self._radar_fresh = bool(radar_fresh)
-    if self._radar_fresh:
-      self._radar_stale_frames = 0
-      self._has_lead_filtered = self._lead_tracker.update(float(lead_one.present))
-      self._has_any_lead = bool(lead_one.present or lead_two.present)
-      self._has_current_radar_acc_lead = bool(max(self._radar_acc_lead_score(lead_one), self._radar_acc_lead_score(lead_two)))
-      self._update_radar_acc_lead()
-    else:
-      self._radar_stale_frames += 1
-      self._has_current_radar_acc_lead = False
-      if self._radar_stale_frames < WMACConstants.RADAR_STALE_FRAMES:
-        self._update_radar_acc_lead()
-      else:
-        self._lead_tracker.reset()
-        self._has_lead_filtered = False
-        self._has_any_lead = False
-        self._has_radar_acc_lead = False
-        self._radar_acc_lead_frames = 0
-    self._has_mpc_fcw = self._mpc_fcw_crash_cnt > 0
+    # Lead detection
+    self._lead_filter.add_data(float(lead_one.present))
+    lead_value = self._lead_filter.get_value() or 0.0
+    self._has_lead_filtered = lead_value > WMACConstants.LEAD_PROB
+
+    # MPC FCW detection
+    fcw_filtered_value = self._mpc_fcw_filter.get_value() or 0.0
+    self._mpc_fcw_filter.add_data(float(self._mpc_fcw_crash_cnt > 0))
+    self._has_mpc_fcw = fcw_filtered_value > 0.5
+
+    # Slow down detection
    self._calculate_slow_down(md)

-    if self._standstill_count > WMACConstants.STANDSTILL_FRAMES or self._has_slow_down:
-      self._slowness_tracker.reset()
-      self._has_slowness = False
-    else:
+    # Slowness detection
+    if not (self._standstill_count > 5) and not self._has_slow_down:
      current_slowness = float(self._v_ego_kph <= (self._v_cruise_kph * WMACConstants.SLOWNESS_CRUISE_OFFSET))
-      self._has_slowness = self._slowness_tracker.update(current_slowness)
+      self._slowness_filter.add_data(current_slowness)
+      slowness_value = self._slowness_filter.get_value() or 0.0

-  def _calculate_slow_down(self, md) -> None:
+      # Hysteresis for slowness
+      threshold = WMACConstants.SLOWNESS_PROB * (0.8 if self._has_slowness else 1.1)
+      self._has_slowness = slowness_value > threshold
+
+  def _calculate_slow_down(self, md):
+    """Calculate urgency based on trajectory endpoint vs expected distance."""
+
+    # Reset to safe defaults
+    urgency = 0.0
    self._endpoint_x = float('inf')
-    self._expected_distance = 0.0
    self._trajectory_valid = False

-    self._update_model_decel_trend(md)
-    urgency = self._model_action_urgency(md)
-    position_valid = len(md.position.x) == WMACConstants.TRAJECTORY_SIZE
+    #Require exact trajectory size
+    position_valid = len(md.position.x) == TRAJECTORY_SIZE
+    orientation_valid = len(md.orientation.x) == TRAJECTORY_SIZE

-    if position_valid:
-      self._trajectory_valid = True
-      self._endpoint_x = md.position.x[WMACConstants.TRAJECTORY_SIZE - 1]
-      self._expected_distance = interp(self._v_ego_kph, WMACConstants.SLOW_DOWN_BP, WMACConstants.SLOW_DOWN_DIST)
-      urgency = max(urgency, self._endpoint_urgency(self._endpoint_x, self._expected_distance))
+    if not (position_valid and orientation_valid):
+      # Invalid trajectory - this itself might indicate a stop scenario
+      # Apply moderate urgency for incomplete trajectories at speed
+      if self._v_ego_kph > 20.0:
+        urgency = 0.3

-    self._raw_urgency = clip01(urgency)
-    self._has_slow_down = self._slow_down_tracker.update(self._raw_urgency)
-    self._urgency = self._slow_down_tracker.value
-
-  def _update_model_decel_trend(self, md) -> None:
-    try:
-      desired_accel = float(md.action.desiredAcceleration)
-    except (AttributeError, OverflowError, TypeError, ValueError):
-      desired_accel = math.nan
-    if not math.isfinite(desired_accel):
-      self._reset_model_decel_trend()
-    else:
-      self._model_accel_samples.append(desired_accel)
-    history = tuple(self._model_accel_samples)
-    self._model_decel_trending = (len(history) == self._model_accel_samples.maxlen
-                                  and history[-1] <= WMACConstants.MODEL_DECEL_TREND_ACCEL
-                                  and (history[0] - history[-1]) / (DT_MDL * (len(history) - 1)) > WMACConstants.MODEL_DECEL_TREND_RATE
-                                  and all(after <= before for before, after in zip(history[:-1], history[1:], strict=True))
-                                  and sum(after < before for before, after in zip(history[:-1], history[1:], strict=True)) >= 2)
-    if len(history) == self._model_accel_samples.maxlen and all(
-      accel >= WMACConstants.MODEL_DECEL_TREND_RELEASE_ACCEL for accel in history
-    ):
-      self._model_decel_latched = False
-
-  def _reset_model_decel_trend(self) -> None:
-    self._model_accel_samples.clear()
-    self._model_decel_trending = False
-    self._model_decel_latched = False
-
-  def _radar_acc_lead_score(self, lead_one) -> float:
-    radar_track_id = int(getattr(lead_one, 'radarTrackId', -1))
-    return float(lead_one.present and (bool(getattr(lead_one, 'radar', False)) or radar_track_id >= 0))
-
-  def _update_radar_acc_lead(self) -> None:
-    if self._has_current_radar_acc_lead:
-      self._radar_acc_lead_frames = WMACConstants.RADAR_LEAD_CONTINUITY_FRAMES
-      self._has_radar_acc_lead = True
+      self._slow_down_filter.add_data(urgency)
+      urgency_filtered = self._slow_down_filter.get_value() or 0.0
+      self._has_slow_down = urgency_filtered > WMACConstants.SLOW_DOWN_PROB
+      self._urgency = urgency_filtered
      return

-    if not self._has_any_lead:
-      self._radar_acc_lead_frames = min(self._radar_acc_lead_frames, WMACConstants.RADAR_LEAD_DROPOUT_FRAMES)
+    # We have a valid full trajectory
+    self._trajectory_valid = True

-    self._has_radar_acc_lead = self._radar_acc_lead_frames > 0
-    self._radar_acc_lead_frames = max(0, self._radar_acc_lead_frames - 1)
+    # Use the exact endpoint (33rd point, index 32)
+    endpoint_x = md.position.x[TRAJECTORY_SIZE - 1]
+    self._endpoint_x = endpoint_x

-  def _model_action_urgency(self, md) -> float:
-    action = getattr(md, 'action', None)
-    if action is None:
-      return 0.0
+    # Get expected distance based on current speed using tuned constants
+    expected_distance = interp(self._v_ego_kph,
+                               WMACConstants.SLOW_DOWN_BP,
+                               WMACConstants.SLOW_DOWN_DIST)
+    self._expected_distance = expected_distance

-    urgency = 1.0 if getattr(action, 'shouldStop', False) else 0.0
-    desired_accel = getattr(action, 'desiredAcceleration', 0.0)
-    if desired_accel < WMACConstants.MODEL_DECEL_START:
-      urgency = max(urgency, min(1.0, (WMACConstants.MODEL_DECEL_START - desired_accel) / WMACConstants.MODEL_DECEL_RANGE))
-    return urgency
+    # Calculate urgency based on trajectory shortage
+    if endpoint_x < expected_distance:
+      shortage = expected_distance - endpoint_x
+      shortage_ratio = shortage / expected_distance

-  def _endpoint_urgency(self, endpoint_x: float, expected_distance: float) -> float:
-    if endpoint_x >= expected_distance:
-      return 0.0
+      # Base urgency on shortage ratio
+      urgency = min(1.0, shortage_ratio * 2.0)

-    shortage_ratio = (expected_distance - endpoint_x) / expected_distance
-    urgency = min(1.0, shortage_ratio * WMACConstants.ENDPOINT_URGENCY_GAIN)
+      # Increase urgency for very short trajectories (imminent stops)
+      critical_distance = expected_distance * 0.3
+      if endpoint_x < critical_distance:
+        urgency = min(1.0, urgency * 2.0)

-    if endpoint_x < expected_distance * WMACConstants.CRITICAL_ENDPOINT_FACTOR:
-      urgency = min(1.0, urgency * WMACConstants.CRITICAL_URGENCY_GAIN)
+      # Speed-based urgency adjustment
+      if self._v_ego_kph > 25.0:
+        speed_factor = 1.0 + (self._v_ego_kph - 25.0) / 80.0
+        urgency = min(1.0, urgency * speed_factor)

-    if self._v_ego_kph > WMACConstants.SPEED_URGENCY_MIN:
-      speed_factor = 1.0 + (self._v_ego_kph - WMACConstants.SPEED_URGENCY_MIN) / WMACConstants.SPEED_URGENCY_RANGE
-      urgency = min(1.0, urgency * speed_factor)
+    # Apply filtering but with less smoothing for stops
+    self._slow_down_filter.add_data(urgency)
+    urgency_filtered = self._slow_down_filter.get_value() or 0.0

-    return urgency
+    # Update state with lower threshold for better stop detection
+    self._has_slow_down = urgency_filtered > (WMACConstants.SLOW_DOWN_PROB * 0.8)
+    self._urgency = urgency_filtered

-  def _model_decel_handoff_ready(self) -> bool:
-    try:
-      mpc_accel = float(self._mpc.a_solution[1])
-      return (math.isfinite(mpc_accel) and mpc_accel <= WMACConstants.MODEL_DECEL_TREND_MAX_MPC_ACCEL
-              and math.isfinite(self._planner_accel) and self._planner_accel <= WMACConstants.MODEL_DECEL_TREND_MAX_MPC_ACCEL
-              and self._planner_accel - self._model_accel_samples[-1] <= WMACConstants.MODEL_DECEL_TREND_MAX_COMMAND_STEP)
-    except (AttributeError, IndexError, OverflowError, TypeError, ValueError):
-      return False
-
-  def _desired_mode(self) -> tuple[ModeType, bool]:
-    standstill = self._standstill_count > WMACConstants.STANDSTILL_FRAMES
-    urgent_slow_down = self._has_slow_down and self._raw_urgency > WMACConstants.URGENT_SLOW_DOWN_PROB
-
-    if not self._CP.radarUnavailable and self._has_current_radar_acc_lead:
-      self._reset_model_decel_trend()
-      return 'acc', True
-
-    radar_stale = not self._radar_fresh if self._has_mpc_fcw else self._radar_stale_frames > 1
-    if (radar_stale or not self._has_any_lead) and (self._has_mpc_fcw or urgent_slow_down):
-      self._radar_acc_lead_frames = 0
-      self._has_radar_acc_lead = False
-      return 'blended', True
-
-    if not self._CP.radarUnavailable and self._has_radar_acc_lead:
-      self._reset_model_decel_trend()
-      return 'acc', True
-
-    entering_model_slowdown = self._model_decel_trending and self._model_decel_handoff_ready() and not self._model_decel_latched
-    self._model_decel_latched |= entering_model_slowdown
-    if self._model_decel_latched:
-      return 'blended', entering_model_slowdown
+  def _radarless_mode(self) -> None:
+    """Radarless mode decision logic with emergency handling."""

+    # EMERGENCY: MPC FCW - immediate blended mode
    if self._has_mpc_fcw:
-      return 'blended', True
+      self._mode_manager.request_mode('blended', confidence=1.0, emergency=True)
+      return
+
+    # Standstill: use blended
+    if self._standstill_count > 3:
+      self._mode_manager.request_mode('blended', confidence=0.9)
+      return
+
+    # Slow down scenarios: emergency for high urgency, normal for lower urgency
+    if self._has_slow_down:
+      if self._urgency > 0.7:
+        # Emergency: immediate blended mode for high urgency stops
+        self._mode_manager.request_mode('blended', confidence=1.0, emergency=True)
+      else:
+        # Normal: blended with urgency-based confidence
+        confidence = min(1.0, self._urgency * 1.5)
+        self._mode_manager.request_mode('blended', confidence=confidence)
+      return
+
+    # Driving slow: use ACC (but not if actively slowing down)
+    if self._has_slowness and not self._has_slow_down:
+      self._mode_manager.request_mode('acc', confidence=0.8)
+      return
+
+    # Default: ACC
+    self._mode_manager.request_mode('acc', confidence=0.7)
+
+  def _radar_mode(self) -> None:
+    """Radar mode with emergency handling."""
+
+    # EMERGENCY: MPC FCW - immediate blended mode
+    if self._has_mpc_fcw:
+      self._mode_manager.request_mode('blended', confidence=1.0, emergency=True)
+      return
+
+    # If lead detected and not in standstill: always use ACC
+    if self._has_lead_filtered and not (self._standstill_count > 3):
+      self._mode_manager.request_mode('acc', confidence=1.0)
+      return
+
+    # Slow down scenarios: emergency for high urgency, normal for lower urgency
+    if self._has_slow_down:
+      if self._urgency > 0.7:
+        # Emergency: immediate blended mode for high urgency stops
+        self._mode_manager.request_mode('blended', confidence=1.0, emergency=True)
+      else:
+        # Normal: blended with urgency-based confidence
+        confidence = min(1.0, self._urgency * 1.3)
+        self._mode_manager.request_mode('blended', confidence=confidence)
+      return
+
+    # Standstill: use blended
+    if self._standstill_count > 3:
+      self._mode_manager.request_mode('blended', confidence=0.9)
+      return
+
+    # Driving slow: use ACC (but not if actively slowing down)
+    if self._has_slowness and not self._has_slow_down:
+      self._mode_manager.request_mode('acc', confidence=0.8)
+      return
+
+    # Default: ACC
+    self._mode_manager.request_mode('acc', confidence=0.7)
+
+  def update(self, sm: messaging.SubMaster) -> None:
+    self._read_params()
+
+    self.set_mpc_fcw_crash_cnt()
+
+    self._update_calculations(sm)

    if self._CP.radarUnavailable:
-      if standstill or self._has_slow_down:
-        return 'blended', urgent_slow_down
-      return 'acc', False
+      self._radarless_mode()
+    else:
+      self._radar_mode()

-    if standstill or self._has_slow_down:
-      return 'blended', urgent_slow_down
-
-    return 'acc', False
-
-  def update(self, sm: messaging.SubMaster, *, radar_fresh: bool = True, planner_accel: float | None = None) -> None:
-    self._read_params()
-    self.set_mpc_fcw_crash_cnt()
-    try:
-      self._planner_accel = float(planner_accel)
-    except (OverflowError, TypeError, ValueError):
-      self._planner_accel = math.nan
-    self._update_calculations(sm, radar_fresh)
-    self._active = sm['selfdriveState'].experimentalMode and self._enabled
-    if not self._active:
-      model_decel_latched = self._model_decel_latched
-      self._reset_model_decel_trend()
-      if model_decel_latched:
-        self._mode_manager.request_mode('acc', immediate=True)
-
-    mode, immediate = self._desired_mode()
-    self._mode_manager.request_mode(mode, immediate=immediate, hold_frames=WMACConstants.EMERGENCY_HOLD_FRAMES,
-                                    cancel_hold=not self._CP.radarUnavailable and self._has_radar_acc_lead)
    self._mode_manager.update()
-
+    self._active = sm['selfdriveState'].experimentalMode and self._enabled
    self._frame += 1
@@ -0,0 +1,94 @@
+import pytest
+
+from openpilot.sunnypilot.selfdrive.controls.lib.dec.dec import DynamicExperimentalController
+
+class MockLeadOne:
+  def __init__(self, status=0.0):
+    self.status = status
+
+class MockRadarState:
+  def __init__(self, status=0.0):
+    self.leadOne = MockLeadOne(status=status)
+
+class MockCarState:
+  def __init__(self, vEgo=0.0, vCruise=0.0, standstill=False):
+    self.vEgo = vEgo
+    self.vCruise = vCruise
+    self.standstill = standstill
+
+class MockModelData:
+  def __init__(self, valid=True):
+    size = 33 if valid else 10  # incomplete if invalid
+    self.position = type("Pos", (), {"x": [0.0] * size})()
+    self.orientation = type("Ori", (), {"x": [0.0] * size})()
+
+class MockSelfDriveState:
+  def __init__(self, experimentalMode=False):
+    self.experimentalMode = experimentalMode
+
+class MockParams:
+  def get_bool(self, name):
+    return True
+
+@pytest.fixture
+def default_sm():
+  sm = {
+    'carState': MockCarState(vEgo=10.0, vCruise=20.0),
+    'radarState': MockRadarState(status=1.0),
+    'modelV2': MockModelData(valid=True),
+    'selfdriveState': MockSelfDriveState(experimentalMode=True),
+  }
+  return sm
+
+@pytest.fixture
+def mock_cp():
+  class CP:
+    radarUnavailable = False
+  return CP()
+
+@pytest.fixture
+def mock_mpc():
+  class MPC:
+    crash_cnt = 0
+  return MPC()
+
+# Fake Kalman Filter that always returns a given value
+class FakeKalman:
+  def __init__(self, value=1.0):
+    self.value = value
+  def add_data(self, v): pass
+  def get_value(self): return self.value
+  def get_confidence(self): return 1.0
+  def reset_data(self): pass
+
+def test_initial_mode_is_acc(mock_cp, mock_mpc):
+  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
+  assert controller.mode() == "acc"
+
+def test_standstill_triggers_blended(mock_cp, mock_mpc, default_sm):
+  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
+  default_sm['carState'].standstill = True
+  for _ in range(10):
+    controller.update(default_sm)
+  assert controller.mode() == "blended"
+
+def test_emergency_blended_on_fcw(mock_cp, mock_mpc, default_sm):
+  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
+  mock_mpc.crash_cnt = 1  # simulate FCW
+  for _ in range(2):
+    controller.update(default_sm)
+  assert controller.mode() == "blended"
+
+def test_radarless_slowdown_triggers_blended(mock_cp, mock_mpc, default_sm):
+  mock_cp.radarUnavailable = True
+  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
+
+  # Force conditions to simulate slowdown
+  controller._slow_down_filter = FakeKalman(value=1.0)  # ty: ignore[invalid-assignment]
+  controller._v_ego_kph = 35.0
+  default_sm['modelV2'] = MockModelData(valid=False)  # Incomplete trajectory
+
+  for _ in range(3):
+    controller.update(default_sm)
+
+  assert controller.mode() == "blended"
@@ -1,633 +0,0 @@
-import pytest
-
-from openpilot.sunnypilot.selfdrive.controls.lib.dec.constants import WMACConstants
-from openpilot.sunnypilot.selfdrive.controls.lib.dec.dec import DynamicExperimentalController, HysteresisSignal
-
-
-class MockLeadOne:
-  def __init__(self, status=0.0, dRel=30.0, vRel=0.0, radar=False, radarTrackId=-1):
-    self.present = status
-    self.dRel = dRel
-    self.vRel = vRel
-    self.radar = radar
-    self.radarTrackId = radarTrackId
-
-
-class MockRadarState:
-  def __init__(self, status=0.0, dRel=30.0, vRel=0.0, radar=False, radarTrackId=-1, leadTwo=None):
-    self.leadOne = MockLeadOne(status=status, dRel=dRel, vRel=vRel, radar=radar, radarTrackId=radarTrackId)
-    self.leadTwo = leadTwo if leadTwo is not None else MockLeadOne()
-
-
-class MockCarState:
-  def __init__(self, vEgo=0.0, vCruise=0.0, standstill=False):
-    self.vEgo = vEgo
-    self.vCruise = vCruise
-    self.standstill = standstill
-
-
-class MockAction:
-  def __init__(self, desiredAcceleration=0.0, shouldStop=False):
-    self.desiredAcceleration = desiredAcceleration
-    self.shouldStop = shouldStop
-
-
-class MockModelData:
-  def __init__(self, valid=True, endpoint_x=200.0, orientation_valid=None, desired_acceleration=0.0, should_stop=False):
-    position_size = 33 if valid else 10
-    orientation_size = position_size if orientation_valid is None else (33 if orientation_valid else 10)
-    position_x = [0.0] * position_size
-    if position_x:
-      position_x[-1] = endpoint_x
-    self.position = type("Pos", (), {"x": position_x})()
-    self.orientation = type("Ori", (), {"x": [0.0] * orientation_size})()
-    self.acceleration = type("Accel", (), {"x": [0.0] * position_size})()
-    self.action = MockAction(desired_acceleration, should_stop)
-
-
-class MockSelfDriveState:
-  def __init__(self, experimentalMode=False):
-    self.experimentalMode = experimentalMode
-
-
-class MockParams:
-  def get_bool(self, name):
-    return True
-
-
-@pytest.fixture
-def default_sm():
-  sm = {
-    'carState': MockCarState(vEgo=10.0, vCruise=20.0),
-    'radarState': MockRadarState(status=1.0, radar=True, radarTrackId=7),
-    'modelV2': MockModelData(valid=True),
-    'selfdriveState': MockSelfDriveState(experimentalMode=True),
-  }
-  return sm
-
-
-@pytest.fixture
-def mock_cp():
-  class CP:
-    radarUnavailable = False
-  return CP()
-
-
-@pytest.fixture
-def mock_mpc():
-  class MPC:
-    crash_cnt = 0
-    a_solution = [0.0, 0.0]
-  return MPC()
-
-
-def test_initial_mode_is_acc(mock_cp, mock_mpc):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  assert controller.mode() == "acc"
-
-
-def test_standstill_triggers_blended(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  default_sm['carState'].standstill = True
-  for _ in range(20):
-    controller.update(default_sm)
-  assert controller.mode() == "blended"
-
-
-def test_emergency_blended_on_fcw(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  mock_mpc.crash_cnt = 1
-  controller.update(default_sm)
-  assert controller.mode() == "blended"
-
-
-def test_radarless_slowdown_triggers_blended(mock_cp, mock_mpc, default_sm):
-  mock_cp.radarUnavailable = True
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-
-  controller.update(default_sm)
-
-  assert controller.mode() == "blended"
-
-
-def test_valid_position_with_missing_orientation_can_trigger_slowdown(mock_cp, mock_mpc, default_sm):
-  mock_cp.radarUnavailable = True
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0, orientation_valid=False)
-
-  controller.update(default_sm)
-
-  assert controller._trajectory_valid
-  assert controller.mode() == "blended"
-
-
-def test_incomplete_position_does_not_trigger_slowdown(mock_cp, mock_mpc, default_sm):
-  mock_cp.radarUnavailable = True
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  default_sm['modelV2'] = MockModelData(valid=False, endpoint_x=0.0)
-
-  for _ in range(3):
-    controller.update(default_sm)
-
-  assert not controller._trajectory_valid
-  assert not controller._has_slow_down
-  assert controller.mode() == "acc"
-
-
-def test_slowdown_hysteresis_prevents_threshold_chatter():
-  signal = HysteresisSignal(enter_threshold=0.5, exit_threshold=0.4, rise_rate=1.0, fall_rate=1.0)
-
-  assert signal.update(0.55)
-  assert signal.update(0.45)
-  assert not signal.update(0.35)
-
-
-def test_model_should_stop_triggers_blended_without_valid_trajectory(mock_cp, mock_mpc, default_sm):
-  mock_cp.radarUnavailable = True
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  default_sm['modelV2'] = MockModelData(valid=False, should_stop=True)
-
-  controller.update(default_sm)
-
-  assert not controller._trajectory_valid
-  assert controller.mode() == "blended"
-
-
-def test_confirmed_model_decel_trend_enters_blended_before_a_large_command(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-
-  for desired_acceleration in (-0.02, -0.05, -0.08):
-    default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=desired_acceleration)
-    controller.update(default_sm, planner_accel=0.0)
-    assert controller.mode() == "acc"
-
-  default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=-0.12)
-  controller.update(default_sm, planner_accel=0.0)
-
-  assert controller._model_decel_trending
-  assert not controller._has_slow_down
-  assert controller.mode() == "blended"
-
-
-def test_confirmed_model_decel_handoff_stays_latched_through_a_plateau(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-
-  for desired_acceleration in (-0.02, -0.05, -0.08, -0.12):
-    default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=desired_acceleration)
-    controller.update(default_sm, planner_accel=0.0)
-
-  for _ in range(WMACConstants.EMERGENCY_HOLD_FRAMES + WMACConstants.EXIT_BLENDED_FRAMES + 1):
-    default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=-0.12)
-    controller.update(default_sm, planner_accel=0.0)
-
-  assert not controller._model_decel_trending
-  assert controller._model_decel_latched
-  assert controller.mode() == "blended"
-
-  for _ in range(WMACConstants.MODEL_DECEL_TREND_FRAMES + WMACConstants.EXIT_BLENDED_FRAMES):
-    default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=0.0)
-    controller.update(default_sm, planner_accel=0.0)
-
-  assert not controller._model_decel_latched
-  assert controller.mode() == "acc"
-
-
-def test_model_decel_trend_never_overrides_a_radar_lead(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-
-  for desired_acceleration in (-0.02, -0.05, -0.08, -0.12):
-    default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=desired_acceleration)
-    controller.update(default_sm)
-
-  assert not controller._model_accel_samples
-  assert not controller._model_decel_latched
-  assert controller._has_radar_acc_lead
-  assert controller.mode() == "acc"
-
-
-def test_radar_acquisition_clears_a_latched_model_decel_handoff(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  for desired_acceleration in (-0.02, -0.05, -0.08, -0.12):
-    default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=desired_acceleration)
-    controller.update(default_sm, planner_accel=0.0)
-  assert controller._model_decel_latched
-
-  default_sm['radarState'] = MockRadarState(status=1.0, radar=True, radarTrackId=7)
-  controller.update(default_sm, planner_accel=0.0)
-
-  assert not controller._model_accel_samples
-  assert not controller._model_decel_latched
-  assert controller.mode() == "acc"
-
-
-def test_model_decel_trend_does_not_accumulate_while_dec_is_inactive(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  default_sm['selfdriveState'].experimentalMode = False
-  for desired_acceleration in (-0.02, -0.05, -0.08, -0.12):
-    default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=desired_acceleration)
-    controller.update(default_sm, planner_accel=0.0)
-
-  assert not controller._model_accel_samples
-  assert not controller._model_decel_latched
-
-  default_sm['selfdriveState'].experimentalMode = True
-  controller.update(default_sm, planner_accel=0.0)
-  assert not controller._model_decel_trending
-  assert controller.mode() == "acc"
-
-
-def test_disabling_dec_clears_a_latched_model_decel_mode(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  for desired_acceleration in (-0.02, -0.05, -0.08, -0.12):
-    default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=desired_acceleration)
-    controller.update(default_sm, planner_accel=0.0)
-  assert controller._model_decel_latched
-  assert controller.mode() == "blended"
-
-  default_sm['selfdriveState'].experimentalMode = False
-  default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=0.0)
-  controller.update(default_sm, planner_accel=0.0)
-
-  assert not controller._model_decel_latched
-  assert controller.mode() == "acc"
-
-
-def test_model_decel_trend_waits_while_mpc_is_accelerating(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  mock_mpc.a_solution[1] = 0.5
-
-  for desired_acceleration in (-0.02, -0.05, -0.08, -0.12):
-    default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=desired_acceleration)
-    controller.update(default_sm, planner_accel=0.0)
-
-  assert controller._model_decel_trending
-  assert controller.mode() == "acc"
-
-
-def test_steep_model_decel_trend_defers_to_the_existing_urgent_path(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-
-  for desired_acceleration in (0.0, -0.2, -0.4, -0.6):
-    default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=desired_acceleration)
-    controller.update(default_sm, planner_accel=0.05)
-
-  assert controller._model_decel_trending
-  assert controller.mode() == "acc"
-
-
-def test_model_decel_trend_waits_while_the_planner_is_accelerating(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-
-  for desired_acceleration in (-0.02, -0.05, -0.08, -0.12):
-    default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=desired_acceleration)
-    controller.update(default_sm, planner_accel=0.2)
-
-  assert controller._model_decel_trending
-  assert controller.mode() == "acc"
-
-
-def test_alternating_model_accel_noise_does_not_trigger_an_early_handoff(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-
-  for desired_acceleration in (0.0, -0.2, 0.0, -0.2):
-    default_sm['modelV2'] = MockModelData(valid=False, desired_acceleration=desired_acceleration)
-    controller.update(default_sm)
-
-  assert not controller._model_decel_trending
-  assert controller.mode() == "acc"
-
-
-def test_radar_lead_keeps_acc_over_model_slowdown(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=1.0, radar=True, radarTrackId=7)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-
-  for _ in range(3):
-    controller.update(default_sm)
-
-  assert controller._has_slow_down
-  assert controller._has_radar_acc_lead
-  assert controller.mode() == "acc"
-
-
-def test_far_radar_lead_always_uses_acc(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=1.0, dRel=120.0, vRel=0.0, radar=True)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-
-  controller.update(default_sm)
-
-  assert controller._has_lead_filtered
-  assert controller._has_radar_acc_lead
-  assert controller.mode() == "acc"
-
-
-def test_radar_acquisition_immediately_returns_blended_to_acc(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-  controller.update(default_sm)
-  assert controller.mode() == "blended"
-
-  default_sm['radarState'] = MockRadarState(status=1.0, dRel=120.0, radar=True, radarTrackId=7)
-  controller.update(default_sm)
-
-  assert controller._has_radar_acc_lead
-  assert controller.mode() == "acc"
-
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  default_sm['modelV2'] = MockModelData(valid=True)
-  for _ in range(20):
-    controller.update(default_sm)
-  assert controller.mode() == "acc"
-
-
-def test_close_vision_only_lead_can_use_blended(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=1.0, dRel=30.0, vRel=-5.0)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-  controller.update(default_sm)
-
-  assert not controller._has_radar_acc_lead
-  assert controller.mode() == "blended"
-
-
-def test_second_radar_lead_forces_acc(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  lead_two = MockLeadOne(status=1.0, dRel=120.0, radar=True, radarTrackId=8)
-  default_sm['radarState'] = MockRadarState(status=1.0, dRel=30.0, vRel=-5.0, leadTwo=lead_two)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-  controller.update(default_sm)
-
-  assert controller._has_radar_acc_lead
-  assert controller.mode() == "acc"
-
-
-def test_second_vision_only_lead_does_not_force_acc(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  lead_two = MockLeadOne(status=1.0, dRel=20.0, vRel=-10.0)
-  default_sm['radarState'] = MockRadarState(status=0.0, leadTwo=lead_two)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-  controller.update(default_sm)
-
-  assert not controller._has_radar_acc_lead
-  assert controller.mode() == "blended"
-
-
-def test_inactive_lead_with_radar_marker_does_not_force_acc(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=0.0, radar=True, radarTrackId=7)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-  controller.update(default_sm)
-
-  assert not controller._has_radar_acc_lead
-  assert controller.mode() == "blended"
-
-
-def test_radarless_car_ignores_marked_radar_track(mock_cp, mock_mpc, default_sm):
-  mock_cp.radarUnavailable = True
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=1.0, radar=True, radarTrackId=7)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-  controller.update(default_sm)
-
-  assert controller._has_radar_acc_lead
-  assert controller.mode() == "blended"
-
-
-def test_closing_far_radar_lead_returns_to_acc(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=1.0, dRel=120.0, vRel=-25.0, radarTrackId=7)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-
-  for _ in range(20):
-    controller.update(default_sm)
-
-  assert controller._has_radar_acc_lead
-  assert controller.mode() == "acc"
-
-
-def test_radar_lead_keeps_acc_over_fcw_and_standstill(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=1.0, radar=True, radarTrackId=7)
-  default_sm['carState'].standstill = True
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0, should_stop=True)
-  mock_mpc.crash_cnt = 1
-
-  for _ in range(10):
-    controller.update(default_sm)
-
-  assert controller._has_lead_filtered
-  assert controller._has_mpc_fcw
-  assert controller.mode() == "acc"
-
-
-def test_lead_flicker_hold_prevents_one_frame_mode_flip(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=1.0, radar=True, radarTrackId=7)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=50.0)
-  for _ in range(2):
-    controller.update(default_sm)
-  assert controller._has_slow_down
-
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  controller.update(default_sm)
-
-  assert controller._has_lead_filtered
-  assert controller.mode() == "acc"
-
-
-def test_radar_lead_continuity_with_vision_fallback_expires_into_confirmed_transition(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=1.0, radar=True, radarTrackId=7)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=50.0)
-  for _ in range(2):
-    controller.update(default_sm)
-  assert controller._has_slow_down
-
-  default_sm['radarState'] = MockRadarState(status=1.0)
-  for _ in range(WMACConstants.RADAR_LEAD_CONTINUITY_FRAMES):
-    controller.update(default_sm)
-    assert controller._has_radar_acc_lead
-    assert controller.mode() == "acc"
-
-  controller.update(default_sm)
-  assert not controller._has_radar_acc_lead
-  assert controller.mode() == "acc"
-
-  for _ in range(WMACConstants.ENTER_BLENDED_FRAMES - 1):
-    controller.update(default_sm)
-  assert controller.mode() == "blended"
-
-
-def test_radar_lead_short_dropout_guard_expires_without_any_lead(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=1.0, radar=True, radarTrackId=7)
-  controller.update(default_sm)
-
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  for _ in range(WMACConstants.RADAR_LEAD_DROPOUT_FRAMES):
-    controller.update(default_sm)
-    assert controller._has_radar_acc_lead
-
-  controller.update(default_sm)
-  assert not controller._has_radar_acc_lead
-
-
-def test_one_stale_radar_frame_does_not_drop_acc_authority(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  controller.update(default_sm)
-
-  controller.update(default_sm, radar_fresh=False)
-
-  assert not controller._has_current_radar_acc_lead
-  assert controller._has_radar_acc_lead
-  assert controller._radar_acc_lead_frames == WMACConstants.RADAR_LEAD_CONTINUITY_FRAMES - 1
-  assert controller._radar_stale_frames == 1
-  assert controller.mode() == "acc"
-
-
-def test_one_stale_radar_frame_does_not_override_retained_lead_for_model_urgency(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  controller.update(default_sm)
-  default_sm['modelV2'] = MockModelData(valid=False, should_stop=True)
-
-  controller.update(default_sm, radar_fresh=False)
-  assert controller.mode() == "acc"
-
-  controller.update(default_sm, radar_fresh=False)
-  assert controller.mode() == "blended"
-
-
-def test_one_stale_radar_frame_does_not_delay_fcw(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  controller.update(default_sm)
-  mock_mpc.crash_cnt = 1
-
-  controller.update(default_sm, radar_fresh=False)
-
-  assert controller.mode() == "blended"
-
-
-def test_frozen_radar_marker_cannot_rearm_acc_authority(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  controller.update(default_sm)
-
-  for _ in range(WMACConstants.RADAR_STALE_FRAMES - 1):
-    controller.update(default_sm, radar_fresh=False)
-    assert controller._has_radar_acc_lead
-
-  controller.update(default_sm, radar_fresh=False)
-
-  assert not controller._has_current_radar_acc_lead
-  assert not controller._has_radar_acc_lead
-  assert not controller._has_any_lead
-  assert not controller._has_lead_filtered
-
-
-def test_fresh_radar_reacquisition_after_stale_timeout_is_immediate(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  controller.update(default_sm)
-  for _ in range(WMACConstants.RADAR_STALE_FRAMES):
-    controller.update(default_sm, radar_fresh=False)
-
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-  controller.update(default_sm, radar_fresh=False)
-  assert controller.mode() == "blended"
-
-  lead_two = MockLeadOne(status=1.0, radar=True, radarTrackId=8)
-  default_sm['radarState'] = MockRadarState(status=0.0, leadTwo=lead_two)
-  controller.update(default_sm, radar_fresh=True)
-
-  assert controller._radar_stale_frames == 0
-  assert controller._has_current_radar_acc_lead
-  assert controller.mode() == "acc"
-
-
-@pytest.mark.parametrize("urgent_source", ["fcw", "should_stop"])
-def test_no_lead_urgent_slowdown_bypasses_radar_dropout_guard(mock_cp, mock_mpc, default_sm, urgent_source):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=1.0, radar=True, radarTrackId=7)
-  controller.update(default_sm)
-
-  default_sm['radarState'] = MockRadarState(status=0.0)
-  if urgent_source == "fcw":
-    mock_mpc.crash_cnt = 1
-  else:
-    default_sm['modelV2'] = MockModelData(valid=False, should_stop=True)
-  controller.update(default_sm)
-
-  assert not controller._has_radar_acc_lead
-  assert controller.mode() == "blended"
-
-  mock_mpc.crash_cnt = 0
-  default_sm['modelV2'] = MockModelData(valid=True)
-  controller.update(default_sm)
-  assert controller.mode() == "blended"
-
-
-def test_lead_two_radar_authority_continues_with_vision_lead_one(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  lead_two = MockLeadOne(status=1.0, radar=True, radarTrackId=8)
-  default_sm['radarState'] = MockRadarState(status=0.0, leadTwo=lead_two)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-  controller.update(default_sm)
-  assert controller._has_current_radar_acc_lead
-  assert controller.mode() == "acc"
-
-  default_sm['radarState'] = MockRadarState(status=1.0)
-  for _ in range(WMACConstants.RADAR_LEAD_CONTINUITY_FRAMES):
-    controller.update(default_sm)
-    assert controller._has_radar_acc_lead
-    assert controller.mode() == "acc"
-
-
-def test_alternating_radar_slots_keep_acc_authority(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-
-  for frame in range(WMACConstants.RADAR_LEAD_CONTINUITY_FRAMES * 2):
-    if frame % 2 == 0:
-      default_sm['radarState'] = MockRadarState(status=1.0, radar=True, radarTrackId=7, leadTwo=MockLeadOne(status=1.0))
-    else:
-      default_sm['radarState'] = MockRadarState(status=1.0, leadTwo=MockLeadOne(status=1.0, radar=True, radarTrackId=8))
-    controller.update(default_sm)
-
-    assert controller._has_current_radar_acc_lead
-    assert controller.mode() == "acc"
-
-
-def test_radar_reacquisition_immediately_restores_acc_after_continuity_expiry(mock_cp, mock_mpc, default_sm):
-  controller = DynamicExperimentalController(mock_cp, mock_mpc, params=MockParams())
-  default_sm['radarState'] = MockRadarState(status=1.0, radar=True, radarTrackId=7)
-  default_sm['modelV2'] = MockModelData(valid=True, endpoint_x=0.0)
-  controller.update(default_sm)
-
-  default_sm['radarState'] = MockRadarState(status=1.0)
-  for _ in range(WMACConstants.RADAR_LEAD_CONTINUITY_FRAMES + 1):
-    controller.update(default_sm)
-  assert not controller._has_radar_acc_lead
-  assert controller.mode() == "blended"
-
-  lead_two = MockLeadOne(status=1.0, radar=True, radarTrackId=8)
-  default_sm['radarState'] = MockRadarState(status=1.0, leadTwo=lead_two)
-  controller.update(default_sm)
-
-  assert controller._has_current_radar_acc_lead
-  assert controller.mode() == "acc"
@@ -1,32 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import math
-
-from openpilot.common.pid import PIDController
-from openpilot.selfdrive.controls.lib.latcontrol_pid import LatControlPID
-
-DECAY_TAU = 2.0  # seconds; starting guess, not validated against a real car
-
-
-class DecayingIntegratorPIDController(PIDController):
-  def __init__(self, *args, decay_tau=DECAY_TAU, **kwargs):
-    super().__init__(*args, **kwargs)
-    self.decay_tau = decay_tau
-
-  def update(self, error, error_rate=0.0, speed=0.0, feedforward=0., freeze_integrator=False):
-    if freeze_integrator:
-      self.i *= math.exp(-self.i_dt / self.decay_tau)
-    return super().update(error, error_rate=error_rate, speed=speed, feedforward=feedforward, freeze_integrator=freeze_integrator)
-
-
-class LatControlPidSmooth(LatControlPID):
-  def __init__(self, CP, CP_SP, CI, dt, decay_tau=DECAY_TAU):
-    super().__init__(CP, CP_SP, CI, dt)
-    self.pid = DecayingIntegratorPIDController(
-      (CP.lateralTuning.pid.kpBP, CP.lateralTuning.pid.kpV),
-      (CP.lateralTuning.pid.kiBP, CP.lateralTuning.pid.kiV),
-      pos_limit=self.steer_max, neg_limit=-self.steer_max, decay_tau=decay_tau)
@@ -1,16 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-STOPPING_DISTANCE = 0.75
-STOPPED_SPEED = 0.02
-STOPPING_TIME = 2.5
-
-
-class LongControlSP:
-  def should_hold_stopping(self, CS, a_target: float) -> bool:
-    return (self.last_output_accel <= 0.0 and a_target >= self.last_output_accel and CS.vEgo > STOPPED_SPEED and CS.aEgo < 0.0
-            and CS.vEgo <= -CS.aEgo * STOPPING_TIME and CS.vEgo ** 2 <= -2.0 * CS.aEgo * STOPPING_DISTANCE)
@@ -1,46 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import numpy as np
-
-from opendbc.car.interfaces import ACCEL_MIN, ACCEL_MAX
-
-
-class LongitudinalMpcSP:
-  def __init__(self) -> None:
-    self._accel_max_trajectory: tuple[float, ...] | None = None
-    self._cruise_accel_max: float | None = None
-    self._jerk_cost_multiplier = 1.0
-    self.last_solution_status = 0
-
-  def set_accel_controller_params(self, accel_max: tuple[float, ...] | None, jerk_cost_multiplier: float,
-                                  cruise_accel_max: float | None = None) -> None:
-    self._accel_max_trajectory = accel_max
-    self._cruise_accel_max = cruise_accel_max
-    self._jerk_cost_multiplier = jerk_cost_multiplier
-
-  def cruise_accel_max(self, stock_accel_max: float) -> float:
-    if self._cruise_accel_max is None or not np.isfinite(self._cruise_accel_max):
-      return stock_accel_max
-    return min(max(self._cruise_accel_max, 0.0), stock_accel_max)
-
-  def scale_jerk_cost(self, jerk_cost: float) -> float:
-    return jerk_cost * self._jerk_cost_multiplier
-
-  def apply_accel_limits(self) -> None:
-    if self._accel_max_trajectory is None:
-      return
-
-    accel_max = np.asarray(self._accel_max_trajectory)
-    if accel_max.shape != self.params[:, 1].shape or accel_max.dtype.kind not in "iuf" or not np.all(np.isfinite(accel_max)):
-      return
-
-    self.params[:, 1] = np.clip(accel_max, 0.0, ACCEL_MAX)
-    self.params[0, 1] = max(self.params[0, 1], float(np.clip(self.x0[2], ACCEL_MIN, ACCEL_MAX)))
-
-  def save_solution_status(self) -> None:
-    self.last_solution_status = self.solution_status
@@ -8,9 +8,7 @@ See the LICENSE.md file in the root directory for more details.
 from openpilot.cereal import messaging, custom
 from opendbc.car import structs
 from openpilot.common.constants import CV
-from openpilot.common.realtime import DT_MDL
-from openpilot.selfdrive.car.cruise import V_CRUISE_MAX, V_CRUISE_UNSET
-from openpilot.sunnypilot.selfdrive.controls.lib.accel_controller.accel_controller import AccelController, AccelControllerState
+from openpilot.selfdrive.car.cruise import V_CRUISE_MAX
 from openpilot.sunnypilot.selfdrive.controls.lib.dec.dec import DynamicExperimentalController
 from openpilot.sunnypilot.selfdrive.controls.lib.e2e_alerts_helper import E2EAlertsHelper
 from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.smart_cruise_control import SmartCruiseControl
@@ -24,10 +22,9 @@ LongitudinalPlanSource = custom.LongitudinalPlanSP.LongitudinalPlanSource


 class LongitudinalPlannerSP:
-  def __init__(self, CP: structs.CarParams, CP_SP: structs.CarParamsSP, mpc, dt: float = DT_MDL):
-    self.mpc = mpc
-    self.accel_controller = AccelController(CP, dt=dt)
+  def __init__(self, CP: structs.CarParams, CP_SP: structs.CarParamsSP, mpc):
    self.events_sp = EventsSP()
+    self.resolver = SpeedLimitResolver()
    self.dec = DynamicExperimentalController(CP, mpc)
    self.scc = SmartCruiseControl()
    self.resolver = SpeedLimitResolver()
@@ -35,8 +32,6 @@ class LongitudinalPlannerSP:
    self.generation = int(model_bundle.generation) if (model_bundle := get_active_bundle()) else None
    self.source = LongitudinalPlanSource.cruise
    self.e2e_alerts_helper = E2EAlertsHelper()
-    self._radar_log_mono_time = None
-    self._radar_fresh_this_cycle = True

    self.output_v_target = 0.
    self.output_a_target = 0.
@@ -48,35 +43,6 @@ class LongitudinalPlannerSP:

    return experimental_mode and self.dec.mode() == "blended"

-  def update_accel_controller(self, sm: messaging.SubMaster, v_cruise: float, prev_accel_constraint: bool,
-                              stock_accel_max: float, reset_state: bool) -> tuple[bool, float]:
-    is_e2e = self.is_e2e(sm)
-    force_decel = sm['controlsState'].forceDecel
-    previous_mpc_failed = self.mpc.last_solution_status != 0
-
-    self.accel_controller.update(
-      sm['radarState'], base_speed=self.output_v_target, v_ego=sm['carState'].vEgo, a_ego=sm['carState'].aEgo,
-      follow_personality=sm['selfdriveState'].personality, acc_selected=not is_e2e,
-      engaged=not reset_state and not force_decel, cruise_initialized=sm['carState'].vCruise != V_CRUISE_UNSET,
-      stock_accel_max=stock_accel_max if self.allow_throttle else 0.0, previous_should_stop=self.output_should_stop,
-      radar_fresh=self._radar_fresh_this_cycle, previous_mpc_source=self.mpc.source, planner_speed=self.v_desired_filter.x,
-      planner_accel=self.a_desired,
-    )
-    controller = self.accel_controller
-    actuating = controller.is_active and not is_e2e and not force_decel and not previous_mpc_failed
-    valid_lead_stop_hold = actuating and controller.state == AccelControllerState.stopHold and controller.selected_lead >= 0
-    controller_v_cruise = v_cruise if valid_lead_stop_hold else min(v_cruise, controller.output_v_target) if actuating else v_cruise
-    accel_max = controller.mpc_accel_max if actuating else None
-    cruise_accel_max = controller.cruise_accel_max if actuating else None
-    jerk_cost_multiplier = controller.get_jerk_cost_multiplier(
-      actuating, prev_accel_constraint, v_cruise - controller_v_cruise, previous_mpc_failed,
-    )
-    self.mpc.set_accel_controller_params(accel_max, jerk_cost_multiplier, cruise_accel_max)
-    return is_e2e, controller_v_cruise
-
-  def update_should_stop(self, should_stop: bool) -> bool:
-    return self.accel_controller.update_should_stop(should_stop)
-
  def update_targets(self, sm: messaging.SubMaster, v_ego: float, a_ego: float, v_cruise: float) -> tuple[float, float]:
    CS = sm['carState']
    v_cruise_cluster_kph = min(CS.vCruiseCluster, V_CRUISE_MAX)
@@ -107,19 +73,9 @@ class LongitudinalPlannerSP:
    self.output_v_target, self.output_a_target = targets[self.source]
    return self.output_v_target, self.output_a_target

-  def _update_radar_freshness(self, sm: messaging.SubMaster) -> bool:
-    radar_log_mono_time = sm.logMonoTime['radarState']
-    radar_healthy = sm.valid['radarState'] and sm.alive['radarState']
-    radar_advanced = self._radar_log_mono_time is None or radar_log_mono_time > self._radar_log_mono_time
-    if radar_advanced:
-      self._radar_log_mono_time = radar_log_mono_time
-    return radar_healthy and radar_advanced
-
  def update(self, sm: messaging.SubMaster) -> None:
-    self._radar_fresh_this_cycle = self._update_radar_freshness(sm)
-    self.accel_controller.update_params()
    self.events_sp.clear()
-    self.dec.update(sm, radar_fresh=self._radar_fresh_this_cycle, planner_accel=self.output_a_target)
+    self.dec.update(sm)
    self.e2e_alerts_helper.update(sm, self.events_sp)

  def publish_longitudinal_plan_sp(self, sm: messaging.SubMaster, pm: messaging.PubMaster) -> None:
@@ -139,12 +95,6 @@ class LongitudinalPlannerSP:
    dec.enabled = self.dec.enabled()
    dec.active = self.dec.active()

-    accelController = longitudinalPlanSP.accelController
-    accelController.enabled = self.accel_controller.is_enabled
-    accelController.active = self.accel_controller.is_active
-    accelController.profile = self.accel_controller.profile
-    accelController.state = self.accel_controller.state
-
    # Smart Cruise Control
    smartCruiseControl = longitudinalPlanSP.smartCruiseControl
    # Vision Control
@@ -1,84 +0,0 @@
-"""
-Copyright (c) 2021-, rav4kumar, 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 openpilot.common.constants import CV
-from openpilot.common.realtime import DT_MDL
-from openpilot.common.params import Params
-
-NEARSIDE_PROB = 0.2
-EDGE_PROB = 0.35
-EDGE_REACTION_TIME = 1.0
-EDGE_CLEAR_TIME = 0.3
-MIN_SPEED = 20 * CV.MPH_TO_MS
-
-
-class RoadEdgeLaneChangeController:
-  def __init__(self, desire_helper):
-    self.DH = desire_helper
-    self.params = Params()
-    self.enabled = self.params.get_bool("RoadEdgeLaneChangeEnabled")
-    self.param_read_counter = 0
-    self.left_edge_detected = False
-    self.right_edge_detected = False
-    self.left_edge_timer = 0.0
-    self.right_edge_timer = 0.0
-    self.left_clear_timer = 0.0
-    self.right_clear_timer = 0.0
-
-  def read_params(self) -> None:
-    self.enabled = self.params.get_bool("RoadEdgeLaneChangeEnabled")
-
-  def update_params(self) -> None:
-    if self.param_read_counter % 50 == 0:
-      self.read_params()
-    self.param_read_counter += 1
-
-  def reset(self) -> None:
-    self.left_edge_detected = False
-    self.right_edge_detected = False
-    self.left_edge_timer = 0.0
-    self.right_edge_timer = 0.0
-    self.left_clear_timer = 0.0
-    self.right_clear_timer = 0.0
-
-  def update(self, road_edge_stds, lane_line_probs, v_ego: float) -> None:
-    self.update_params()
-
-    if not self.enabled or v_ego < MIN_SPEED:
-      self.reset()
-      return
-
-    left_edge_prob = np.clip(1.0 - road_edge_stds[0], 0.0, 1.0)
-    right_edge_prob = np.clip(1.0 - road_edge_stds[1], 0.0, 1.0)
-    left_lane_prob = lane_line_probs[0]
-    right_lane_prob = lane_line_probs[3]
-
-    left_cond = left_edge_prob > EDGE_PROB and left_lane_prob < NEARSIDE_PROB and right_lane_prob >= left_lane_prob
-    right_cond = right_edge_prob > EDGE_PROB and right_lane_prob < NEARSIDE_PROB and left_lane_prob >= right_lane_prob
-
-    if left_cond:
-      self.left_edge_timer = min(self.left_edge_timer + DT_MDL, EDGE_REACTION_TIME + EDGE_CLEAR_TIME)
-      self.left_clear_timer = 0.0
-      if self.left_edge_timer > EDGE_REACTION_TIME:
-        self.left_edge_detected = True
-    else:
-      self.left_clear_timer += DT_MDL
-      if self.left_clear_timer > EDGE_CLEAR_TIME:
-        self.left_edge_timer = 0.0
-        self.left_edge_detected = False
-
-    if right_cond:
-      self.right_edge_timer = min(self.right_edge_timer + DT_MDL, EDGE_REACTION_TIME + EDGE_CLEAR_TIME)
-      self.right_clear_timer = 0.0
-      if self.right_edge_timer > EDGE_REACTION_TIME:
-        self.right_edge_detected = True
-    else:
-      self.right_clear_timer += DT_MDL
-      if self.right_clear_timer > EDGE_CLEAR_TIME:
-        self.right_edge_timer = 0.0
-        self.right_edge_detected = False
@@ -151,8 +151,8 @@ class SmartCruiseControlMap:
        a = 0.5 * TARGET_JERK
        b = self.a_ego
        c = self.v_ego - tv
-        t_a = -1 * ((b**2 - 4 * a * c) ** 0.5 + b) / (2 * a)
-        t_b = ((b**2 - 4 * a * c) ** 0.5 - b) / (2 * a)
+        t_a = -1 * ((b**2 - 4 * a * c) ** 0.5 + b) / 2 * a
+        t_b = ((b**2 - 4 * a * c) ** 0.5 - b) / 2 * a
        if not isinstance(t_a, complex) and t_a > 0:
          t = t_a
        else:
@@ -4,17 +4,13 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
-import json
-import math
 import platform

-import pytest
-
 from openpilot.cereal import custom
 from openpilot.common.params import Params
 from openpilot.common.realtime import DT_MDL
 from openpilot.selfdrive.car.cruise import V_CRUISE_UNSET
-from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.map_controller import R, SmartCruiseControlMap
+from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.map_controller import SmartCruiseControlMap

 MapState = VisionState = custom.LongitudinalPlanSP.SmartCruiseControl.MapState

@@ -59,17 +55,4 @@ class TestSmartCruiseControlMap:
      self.scc_m.update(True, False, 0., 0., 0.)
    assert self.scc_m.state == VisionState.enabled

-  def test_moderate_curve(self):
-    # Regression: `... / 2 * a` parsed as `(.../2)*a` instead of `.../(2*a)`,
-    # making max_d ~11x too small so the moderate-curve branch never tripped.
-    # v_ego=25, a_ego=0, tv=24: fixed max_d≈45m vs buggy ≈4m at a 40m waypoint.
-    waypoint_lon_deg = (40.0 / R) * (180.0 / math.pi)
-    self.mem_params.put("LastGPSPosition", json.dumps({"latitude": 0.0, "longitude": 0.0}), block=True)
-    self.mem_params.put("MapTargetVelocities",
-                        json.dumps([{"latitude": 0.0, "longitude": waypoint_lon_deg, "velocity": 24.0}]), block=True)
-
-    self.scc_m.update(True, False, 25.0, 0.0, 30.0)
-
-    assert self.scc_m.v_target == pytest.approx(24.0)
-
  # TODO-SP: mock data from modelV2 to test other states
@@ -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.
 """
-from types import SimpleNamespace
 from typing import Any

 import numpy as np
@@ -16,12 +15,8 @@ from openpilot.common.params import Params
 from openpilot.common.realtime import DT_MDL
 from openpilot.selfdrive.car.cruise import V_CRUISE_UNSET
 from openpilot.selfdrive.modeld.constants import ModelConstants
-from openpilot.sunnypilot.selfdrive.controls.lib.longitudinal_planner import LongitudinalPlannerSP, LongitudinalPlanSource
 from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control import MIN_V
-from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.vision_controller import (
-  _A_LAT_REG_MAX, _BELOW_EGO_TARGET_RELEASE_RATE, _ENTERING_PRED_LAT_ACC_TH, _MIN_ACTIVATION_SPEED,
-  _RELIEF_CONFIRMATION_FRAMES, _TARGET_RELEASE_RATE, SmartCruiseControlVision,
-)
+from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.vision_controller import SmartCruiseControlVision, _ENTERING_PRED_LAT_ACC_TH

 VisionState = custom.LongitudinalPlanSP.SmartCruiseControl.VisionState

@@ -125,21 +120,6 @@ class TestSmartCruiseControlVision:
  def reset_params(self):
    self.params.put_bool("SmartCruiseControlVision", True, block=True)

-  def set_lat_accels(self, current: float, predicted: float, v_ego: float = 20., model_speed: float = 20.) -> None:
-    self.sm['controlsState'].curvature = current / v_ego**2
-    self.sm['modelV2'].velocity.x = [model_speed] * len(ModelConstants.T_IDXS)
-    self.sm['modelV2'].orientationRate.z = [predicted / model_speed] * len(ModelConstants.T_IDXS)
-
-  def update_lat_accels(self, current: float, predicted: float, cruise: float = 30., a_ego: float = 0.,
-                        v_ego: float = 20., model_speed: float = 20.) -> None:
-    self.set_lat_accels(current, predicted, v_ego, model_speed)
-    self.scc_v.update(self.sm, True, False, v_ego, a_ego, cruise)
-
-  def enter_curve(self, predicted: float = 2.2) -> None:
-    self.update_lat_accels(0.5, predicted)
-    self.update_lat_accels(0.5, predicted)
-    assert self.scc_v.state == VisionState.entering
-
  def test_initial_state(self):
    assert self.scc_v.state == VisionState.disabled
    assert not self.scc_v.is_active
@@ -165,253 +145,6 @@ class TestSmartCruiseControlVision:
      self.scc_v.update(self.sm, True, False, 0., 0., 0.)
    assert self.scc_v.state == VisionState.enabled

-  def test_unconfirmed_leaving_and_reentry_only_shape_speed(self):
-    self.enter_curve()
-    targets = [self.scc_v.output_v_target]
-
-    self.update_lat_accels(2., 2.2, a_ego=-0.8)
-    assert self.scc_v.state == VisionState.turning
-    assert self.scc_v.output_a_target == -0.8
-    targets.append(self.scc_v.output_v_target)
-
-    self.update_lat_accels(1.2, 1.2, a_ego=0.3)
-    assert self.scc_v.state == VisionState.leaving
-    assert self.scc_v.output_a_target == 0.3
-    targets.append(self.scc_v.output_v_target)
-
-    self.update_lat_accels(1., 3., a_ego=-1.2)
-    assert self.scc_v.state == VisionState.entering
-    assert self.scc_v.output_a_target == -1.2
-    targets.append(self.scc_v.output_v_target)
-
-    entering, turning, leaving, reentering = targets
-    assert turning == pytest.approx(entering)
-    assert 0. < leaving - turning <= _BELOW_EGO_TARGET_RELEASE_RATE * DT_MDL + 1e-9
-    assert reentering < leaving
-
-  def test_new_curve_interrupts_confirmed_release_immediately(self):
-    self.enter_curve()
-    for _ in range(_RELIEF_CONFIRMATION_FRAMES + 1):
-      self.update_lat_accels(0.8, 0.8)
-    releasing_v_target = self.scc_v.output_v_target
-    assert self.scc_v.state == VisionState.leaving
-
-    self.update_lat_accels(0.8, 3., a_ego=-0.7)
-    assert self.scc_v.state == VisionState.entering
-    assert self.scc_v.output_v_target < releasing_v_target
-    assert self.scc_v.output_a_target == -0.7
-
-  @pytest.mark.parametrize("planner_accel", (-2., -0.5, 0., 0.8))
-  def test_planner_acceleration_passes_through_exactly(self, planner_accel):
-    self.enter_curve()
-    self.update_lat_accels(0.5, 2.2, a_ego=planner_accel)
-    assert self.scc_v.output_a_target == planner_accel
-
-  def test_planner_acceleration_passes_through_all_states(self):
-    cases = (
-      (False, False, 0.5, 2.2, -0.2, VisionState.disabled),
-      (True, False, 0.5, 0.8, 0.1, VisionState.enabled),
-      (True, False, 0.5, 2.2, -0.4, VisionState.entering),
-      (True, False, 2., 2.2, -0.8, VisionState.turning),
-      (True, False, 1.2, 1.2, 0.3, VisionState.leaving),
-      (True, True, 1.2, 1.2, 0.6, VisionState.overriding),
-    )
-    for long_enabled, override, current, predicted, planner_accel, state in cases:
-      self.set_lat_accels(current, predicted)
-      self.scc_v.update(self.sm, long_enabled, override, 20., planner_accel, 30.)
-      assert self.scc_v.state == state
-      assert self.scc_v.output_a_target == planner_accel
-
-  def test_jitter_requires_confirmed_relief_then_releases_smoothly(self):
-    self.enter_curve()
-    previous_v_target = self.scc_v.output_v_target
-
-    for frame in range(_RELIEF_CONFIRMATION_FRAMES * 2):
-      self.update_lat_accels(1., 1.05 if frame % 2 == 0 else 1.15)
-      assert self.scc_v.state == VisionState.entering
-      assert self.scc_v.output_v_target >= previous_v_target
-      assert self.scc_v.output_v_target - previous_v_target <= _BELOW_EGO_TARGET_RELEASE_RATE * DT_MDL + 1e-9
-      previous_v_target = self.scc_v.output_v_target
-
-    for _ in range(_RELIEF_CONFIRMATION_FRAMES):
-      self.update_lat_accels(1.15, 0.8)
-      assert self.scc_v.state == VisionState.entering
-      assert 0. <= self.scc_v.output_v_target - previous_v_target <= _BELOW_EGO_TARGET_RELEASE_RATE * DT_MDL + 1e-9
-      previous_v_target = self.scc_v.output_v_target
-
-    release_cruise = 30.
-    for _ in range(_RELIEF_CONFIRMATION_FRAMES - 1):
-      self.update_lat_accels(0.8, 0.8, release_cruise)
-      assert self.scc_v.state == VisionState.entering
-      assert 0. <= self.scc_v.output_v_target - previous_v_target <= _BELOW_EGO_TARGET_RELEASE_RATE * DT_MDL + 1e-9
-      previous_v_target = self.scc_v.output_v_target
-
-    active_v_targets = [previous_v_target]
-    for _ in range(int((release_cruise - previous_v_target) / (_TARGET_RELEASE_RATE * DT_MDL)) + 10):
-      self.update_lat_accels(0.8, 0.8, release_cruise)
-      if not self.scc_v.is_active:
-        break
-      assert self.scc_v.state == VisionState.leaving
-      assert self.scc_v.output_v_target != V_CRUISE_UNSET
-      active_v_targets.append(self.scc_v.output_v_target)
-
-    assert self.scc_v.state == VisionState.enabled
-    assert self.scc_v.output_v_target == V_CRUISE_UNSET
-    assert active_v_targets[-1] == pytest.approx(release_cruise)
-    assert np.all((np.diff(active_v_targets) >= 0.) &
-                  (np.diff(active_v_targets) <= _BELOW_EGO_TARGET_RELEASE_RATE * DT_MDL + 1e-9))
-
-  def test_target_release_slows_after_reaching_ego_speed(self):
-    self.enter_curve()
-
-    for _ in range(100):
-      previous_v_target = self.scc_v.output_v_target
-      self.update_lat_accels(0.8, 0.8)
-      if previous_v_target >= self.scc_v.v_ego:
-        rise = self.scc_v.output_v_target - previous_v_target
-        assert 0. < rise <= _TARGET_RELEASE_RATE * DT_MDL + 1e-9
-        break
-    else:
-      pytest.fail("curve target did not release to ego speed")
-
-  def test_curve_target_is_independent_of_ego_speed(self):
-    model_speed = 24.
-    predicted_yaw_rate = 0.12
-    predicted_lat_accel = model_speed * predicted_yaw_rate
-    expected_v_target = (_A_LAT_REG_MAX / (predicted_yaw_rate / model_speed)) ** 0.5
-    targets = []
-
-    for v_ego in (18., 28.):
-      controller = SmartCruiseControlVision()
-      self.set_lat_accels(0.5, predicted_lat_accel, v_ego, model_speed)
-      controller.update(self.sm, True, False, v_ego, 0., 30.)
-      controller.update(self.sm, True, False, v_ego, 0., 30.)
-      assert controller.state == VisionState.entering
-      targets.append(controller.v_target)
-
-    assert targets[0] == pytest.approx(expected_v_target)
-    assert targets[1] == pytest.approx(expected_v_target)
-
-  def test_curve_target_respects_minimum_speed_floor(self):
-    model_speed = 10.
-    predicted_yaw_rate = 2.
-    self.set_lat_accels(0.5, model_speed * predicted_yaw_rate, model_speed=model_speed)
-    self.scc_v.update(self.sm, True, False, 20., 0., 30.)
-    self.scc_v.update(self.sm, True, False, 20., 0., 30.)
-
-    assert self.scc_v.state == VisionState.entering
-    assert self.scc_v.v_target < MIN_V
-    assert self.scc_v.output_v_target == pytest.approx(MIN_V)
-
-  @pytest.mark.parametrize(
-    ("velocities", "yaw_rates"),
-    [([], []), ([np.nan] * len(ModelConstants.T_IDXS), [np.nan] * len(ModelConstants.T_IDXS)), ([20.] * 5, [0.1] * 3)],
-    ids=("empty", "nonfinite", "mismatched"),
-  )
-  def test_model_vector_edges_remain_finite(self, velocities, yaw_rates):
-    self.sm['modelV2'].velocity.x = velocities
-    self.sm['modelV2'].orientationRate.z = yaw_rates
-    self.scc_v.update(self.sm, True, False, 20., 0., 30.)
-    self.scc_v.update(self.sm, True, False, 20., 0., 30.)
-
-    assert all(np.isfinite(value) for value in (
-      self.scc_v.current_lat_acc, self.scc_v.max_pred_lat_acc, self.scc_v.v_target,
-      self.scc_v.output_v_target, self.scc_v.output_a_target,
-    ))
-
-  @pytest.mark.parametrize("launch_speed", (5.75, 9.9, _MIN_ACTIVATION_SPEED))
-  def test_vision_control_does_not_steal_launch(self, launch_speed):
-    self.set_lat_accels(0.5, 3., launch_speed)
-    self.scc_v.update(self.sm, True, False, launch_speed, 0., 30.)
-    self.scc_v.update(self.sm, True, False, launch_speed, 0., 30.)
-
-    assert launch_speed <= _MIN_ACTIVATION_SPEED
-    assert self.scc_v.state == VisionState.enabled
-    assert not self.scc_v.is_active
-    assert self.scc_v.output_v_target == V_CRUISE_UNSET
-
-  def test_vision_control_can_activate_above_launch_range(self):
-    speed = _MIN_ACTIVATION_SPEED + 0.01
-    self.set_lat_accels(0.5, 3., speed)
-    self.scc_v.update(self.sm, True, False, speed, 0., 30.)
-    self.scc_v.update(self.sm, True, False, speed, 0., 30.)
-
-    assert self.scc_v.state == VisionState.entering
-    assert self.scc_v.is_active
-
-  def test_sequential_curve_tightens_immediately_and_releases_bounded(self):
-    self.enter_curve(3.)
-    for _ in range(20):
-      self.update_lat_accels(0.5, 3.)
-    restrictive_v_target = self.scc_v.output_v_target
-
-    self.update_lat_accels(0.5, 1.4, a_ego=0.4)
-    first_relief_v_target = self.scc_v.output_v_target
-    assert self.scc_v.state == VisionState.entering
-    assert 0. < first_relief_v_target - restrictive_v_target <= _BELOW_EGO_TARGET_RELEASE_RATE * DT_MDL + 1e-9
-    assert self.scc_v.output_a_target == 0.4
-
-    self.update_lat_accels(0.5, 1.4)
-    assert 0. <= self.scc_v.output_v_target - first_relief_v_target <= _BELOW_EGO_TARGET_RELEASE_RATE * DT_MDL + 1e-9
-
-    self.update_lat_accels(0.5, 3., a_ego=-0.6)
-    assert self.scc_v.state == VisionState.entering
-    assert self.scc_v.output_v_target == pytest.approx(restrictive_v_target)
-    assert self.scc_v.output_a_target == -0.6
-
-    for _ in range(4):
-      self.update_lat_accels(0.5, 1.4)
-      assert 0. < self.scc_v.output_v_target - restrictive_v_target <= _BELOW_EGO_TARGET_RELEASE_RATE * DT_MDL + 1e-9
-      self.update_lat_accels(0.5, 3.)
-      assert self.scc_v.output_v_target == pytest.approx(restrictive_v_target)
-
-  def test_acceleration_is_continuous_through_planner_arbitration(self):
-    car_control = messaging.new_message('carControl')
-    car_control.carControl.enabled = True
-    car_control.carControl.cruiseControl.override = False
-    self.sm['carControl'] = car_control.carControl
-    self.sm['carState'].vCruiseCluster = 108.
-
-    planner = LongitudinalPlannerSP.__new__(LongitudinalPlannerSP)
-    planner.scc = SimpleNamespace(
-      vision=self.scc_v,
-      map=SimpleNamespace(output_v_target=V_CRUISE_UNSET, output_a_target=0.),
-      update=lambda sm, enabled, override, v_ego, a_ego, v_cruise: self.scc_v.update(
-        sm, enabled, override, v_ego, a_ego, v_cruise),
-    )
-    planner.resolver = SimpleNamespace(
-      speed_limit_valid=False, speed_limit_last_valid=False, speed_limit=0., speed_limit_final_last=0., distance=0.,
-      update=lambda _v_ego, _sm: None,
-    )
-    planner.sla = SimpleNamespace(
-      output_v_target=V_CRUISE_UNSET, output_a_target=0., update=lambda *_args: None,
-    )
-    planner.events_sp = SimpleNamespace()
-
-    self.set_lat_accels(0.5, 2.2)
-    planner.update_targets(self.sm, 20., -0.8, 30.)
-    planner.update_targets(self.sm, 20., -0.8, 30.)
-    assert planner.source == LongitudinalPlanSource.sccVision
-    assert planner.output_a_target == -0.8
-
-    for planner_accel in (-2., 0.5, -0.2):
-      planner.update_targets(self.sm, 20., planner_accel, 30.)
-      assert planner.source == LongitudinalPlanSource.sccVision
-      assert planner.output_a_target == planner_accel
-
-    self.set_lat_accels(0.8, 0.8)
-    for _ in range(int(30. / (_TARGET_RELEASE_RATE * DT_MDL)) + 10):
-      planner.update_targets(self.sm, 20., 0.4, 30.)
-      assert planner.output_a_target == 0.4
-      if planner.source == LongitudinalPlanSource.cruise:
-        break
-    else:
-      pytest.fail("SCC Vision did not release to cruise")
-
-    planner.update_targets(self.sm, 20., 0.4, 30.)
-    assert self.scc_v.state == VisionState.enabled
-    assert planner.source == LongitudinalPlanSource.cruise
-
  @pytest.mark.parametrize(
    "case, should_enter",
    [
@@ -1,82 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import gc
-
-import numpy as np
-
-from openpilot.sunnypilot.selfdrive.controls.lib.longitudinal_planner import LongitudinalPlanSource
-from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.vision_controller import _A_LAT_REG_MAX
-from openpilot.sunnypilot.selfdrive.test.longitudinal_maneuvers.plant import PlantSP as Plant
-
-
-def _run_constant_curve(*, scc_enabled: bool, cruise: float, duration: float = 70.) -> dict[str, np.ndarray]:
-  gc.collect()
-  curvature = 0.005
-  plant = Plant(lead_relevancy=False, speed=30., actuator_delay=0.15, actuator_lag=0.20)
-  planner = plant.planner
-  planner.accel_controller.enabled = False
-  planner.accel_controller.update_params = lambda: None
-  planner.dec._enabled = False
-  planner.dec._read_params = lambda: None
-  planner.scc.map.enabled = False
-  planner.scc.map.update_params = lambda: None
-  planner.scc.vision.enabled = scc_enabled
-  planner.scc.vision._update_params = lambda: None
-
-  if scc_enabled:
-    original_update_calculations = planner.scc.vision._update_calculations
-
-    def inject_constant_curvature(sm):
-      velocities = np.asarray(sm['modelV2'].velocity.x, dtype=float)
-      sm['modelV2'].orientationRate.z = (curvature * velocities).tolist()
-      sm['controlsState'].curvature = curvature
-      original_update_calculations(sm)
-
-    planner.scc.vision._update_calculations = inject_constant_curvature
-
-  original_update = planner.update
-
-  def enable_longitudinal(sm):
-    sm['carControl'].enabled = True
-    sm['carControl'].longActive = True
-    original_update(sm)
-
-  planner.update = enable_longitudinal
-  rows = []
-  while plant.current_time < duration:
-    output = plant.step(v_cruise=cruise)
-    rows.append((
-      plant.current_time, output['speed'], planner.mpc.last_solution_status, output['should_stop'],
-      planner.scc.vision.is_active, planner.source == LongitudinalPlanSource.sccVision,
-      planner.scc.vision.output_v_target,
-    ))
-
-  data = np.asarray(rows, dtype=float)
-  gc.collect()
-  return {
-    'time': data[:, 0], 'speed': data[:, 1], 'solver_status': data[:, 2], 'should_stop': data[:, 3],
-    'active': data[:, 4], 'scc_source': data[:, 5], 'target': data[:, 6],
-  }
-
-
-def test_constant_curve_recovers_like_stock_speed_cap():
-  target = (_A_LAT_REG_MAX / 0.005) ** 0.5
-  scc = _run_constant_curve(scc_enabled=True, cruise=30.)
-  stock = _run_constant_curve(scc_enabled=False, cruise=target)
-  scc_final = scc['speed'][scc['time'] >= 60.]
-  stock_final = stock['speed'][stock['time'] >= 60.]
-
-  assert not scc['solver_status'].any()
-  assert not stock['solver_status'].any()
-  assert not scc['should_stop'].any()
-  assert np.all(scc['active'][scc['time'] >= 60.])
-  assert np.all(scc['scc_source'][scc['time'] >= 60.])
-  assert np.allclose(scc['target'][scc['time'] >= 60.], target)
-  assert scc_final.min() >= target - 1.
-  assert abs(scc_final.mean() - stock_final.mean()) < 0.5
-  assert abs(scc_final.min() - stock_final.min()) < 1.
-  assert abs(scc_final.max() - stock_final.max()) < 1.
@@ -29,11 +29,19 @@ _FINISH_LAT_ACC_TH = 1.1  # Lat Acc threshold to trigger the end of the turn cyc

 _A_LAT_REG_MAX = 2.  # Maximum lateral acceleration

-_RELIEF_CONFIRMATION_FRAMES = max(1, int(round(0.5 / DT_MDL)))
-_TARGET_RELEASE_RATE = 1.  # m/s^2
-_BELOW_EGO_TARGET_RELEASE_RATE = 3.  # m/s^2
-_MIN_PRED_SPEED = 1.  # m/s
-_MIN_ACTIVATION_SPEED = 10.  # m/s
+_NO_OVERSHOOT_TIME_HORIZON = 4.  # s. Time to use for velocity desired based on a_target when not overshooting.
+
+# Lookup table for the minimum smooth deceleration during the ENTERING state
+# depending on the actual maximum absolute lateral acceleration predicted on the turn ahead.
+_ENTERING_SMOOTH_DECEL_V = [-0.2, -1.]  # min decel value allowed on ENTERING state
+_ENTERING_SMOOTH_DECEL_BP = [1.3, 3.]  # absolute value of lat acc ahead
+
+# Lookup table for the acceleration for the TURNING state
+# depending on the current lateral acceleration of the vehicle.
+_TURNING_ACC_V = [0.5, 0., -0.4]  # acc value
+_TURNING_ACC_BP = [1.5, 2.3, 3.]  # absolute value of current lat acc
+
+_LEAVING_ACC = 0.5  # Conformable acceleration to regain speed while leaving a turn.


 class SmartCruiseControlVision:
@@ -57,26 +65,13 @@ class SmartCruiseControlVision:
    self.state = VisionState.disabled
    self.current_lat_acc = 0.
    self.max_pred_lat_acc = 0.
-    self.relief_frames = 0
-
-  def _v_demand(self) -> float:
-    return max(MIN_V, min(self.v_target, self.v_cruise_setpoint))
-
-  def _released_v_target(self) -> float:
-    demand = self._v_demand()
-    if demand < self.output_v_target:
-      return demand
-    release_rate = _BELOW_EGO_TARGET_RELEASE_RATE if self.output_v_target < min(self.v_ego, demand) else _TARGET_RELEASE_RATE
-    return min(demand, self.output_v_target + release_rate * DT_MDL)

  def get_a_target_from_control(self) -> float:
-    return self.a_ego
+    return self.a_target

  def get_v_target_from_control(self) -> float:
    if self.is_active:
-      if self.output_v_target == V_CRUISE_UNSET:
-        return self._v_demand()
-      return self._released_v_target()
+      return max(self.v_target, MIN_V) + self.a_target * _NO_OVERSHOOT_TIME_HORIZON

    return V_CRUISE_UNSET

@@ -87,27 +82,25 @@ class SmartCruiseControlVision:
  def _update_calculations(self, sm: messaging.SubMaster) -> None:
    if not self.long_enabled:
      return
+    else:
+      rate_plan = np.array(np.abs(sm['modelV2'].orientationRate.z))
+      vel_plan = np.array(sm['modelV2'].velocity.x)

-    rate_plan = np.asarray(np.abs(sm['modelV2'].orientationRate.z), dtype=float)
-    vel_plan = np.asarray(sm['modelV2'].velocity.x, dtype=float)
-    size = min(len(rate_plan), len(vel_plan))
-    rate_plan, vel_plan = rate_plan[:size], vel_plan[:size]
-    valid = np.isfinite(rate_plan) & np.isfinite(vel_plan) & (vel_plan >= _MIN_PRED_SPEED)
+      self.current_lat_acc = self.v_ego ** 2 * abs(sm['controlsState'].curvature)

-    self.current_lat_acc = self.v_ego ** 2 * abs(sm['controlsState'].curvature)
-    self.max_pred_lat_acc = 0.
-    self.v_target = V_CRUISE_UNSET
-    if np.any(valid):
-      self.max_pred_lat_acc = float(np.percentile(rate_plan[valid] * vel_plan[valid], 97))
-      max_pred_curvature = float(np.percentile(rate_plan[valid] / vel_plan[valid], 97))
-      if max_pred_curvature > 0.:
-        self.v_target = min(float((_A_LAT_REG_MAX / max_pred_curvature) ** 0.5), V_CRUISE_UNSET)
+      # get the maximum lat accel from the model
+      predicted_lat_accels = rate_plan * vel_plan
+      self.max_pred_lat_acc = np.percentile(predicted_lat_accels, 97)
+
+      # get the maximum curve based on the current velocity
+      v_ego = max(self.v_ego, 0.1)  # ensure a value greater than 0 for calculations
+      max_curve = self.max_pred_lat_acc / (v_ego**2)
+
+      # Get the target velocity for the maximum curve
+      self.v_target = (_A_LAT_REG_MAX / max_curve) ** 0.5

  def _update_state_machine(self) -> tuple[bool, bool]:
    # ENABLED, ENTERING, TURNING, LEAVING, OVERRIDING
-    relief = self.current_lat_acc < _FINISH_LAT_ACC_TH and self.max_pred_lat_acc < _ABORT_ENTERING_PRED_LAT_ACC_TH
-    self.relief_frames = self.relief_frames + 1 if self.state in ACTIVE_STATES and relief else 0
-
    if self.state != VisionState.disabled:
      # longitudinal and feature disable always have priority in a non-disabled state
      if not self.long_enabled or not self.enabled:
@@ -119,7 +112,7 @@ class SmartCruiseControlVision:
        # ENABLED
        if self.state == VisionState.enabled:
          # Do not enter a turn control cycle if the speed is low.
-          if self.v_ego <= _MIN_ACTIVATION_SPEED:
+          if self.v_ego <= MIN_V:
            pass
          # If significant lateral acceleration is predicted ahead, then move to Entering turn state.
          elif self.max_pred_lat_acc >= _ENTERING_PRED_LAT_ACC_TH:
@@ -135,26 +128,23 @@ class SmartCruiseControlVision:
          # Transition to Turning if current lateral acceleration is over the threshold.
          if self.current_lat_acc >= _TURNING_LAT_ACC_TH:
            self.state = VisionState.turning
-          # Begin releasing only after both current and predicted lateral acceleration stay clear.
-          elif self.relief_frames >= _RELIEF_CONFIRMATION_FRAMES:
-            self.state = VisionState.leaving
+          # Abort if the predicted lateral acceleration drops
+          elif self.max_pred_lat_acc < _ABORT_ENTERING_PRED_LAT_ACC_TH:
+            self.state = VisionState.enabled

        # TURNING
        elif self.state == VisionState.turning:
-          # Transition out of Turning if current lateral acceleration drops below a threshold.
+          # Transition to Leaving if current lateral acceleration drops below a threshold.
          if self.current_lat_acc <= _LEAVING_LAT_ACC_TH:
-            self.state = VisionState.entering if self.max_pred_lat_acc >= _ENTERING_PRED_LAT_ACC_TH else VisionState.leaving
+            self.state = VisionState.leaving

        # LEAVING
        elif self.state == VisionState.leaving:
          # Transition back to Turning if current lateral acceleration goes back over the threshold.
          if self.current_lat_acc >= _TURNING_LAT_ACC_TH:
            self.state = VisionState.turning
-          # Start a new turn cycle immediately if another curve is predicted.
-          elif self.max_pred_lat_acc >= _ENTERING_PRED_LAT_ACC_TH:
-            self.state = VisionState.entering
-          # Finish after confirmed relief and a gradual release to the cruise setpoint.
-          elif self.relief_frames >= _RELIEF_CONFIRMATION_FRAMES and self.output_v_target >= self.v_cruise_setpoint:
+          # Finish if current lateral acceleration goes below a threshold.
+          elif self.current_lat_acc < _FINISH_LAT_ACC_TH:
            self.state = VisionState.enabled

    # DISABLED
@@ -167,11 +157,32 @@ class SmartCruiseControlVision:

    enabled = self.state in ENABLED_STATES
    active = self.state in ACTIVE_STATES
-    if not active:
-      self.relief_frames = 0

    return enabled, active

+  def _update_solution(self) -> float:
+    # DISABLED, ENABLED, OVERRIDING
+    if self.state not in ACTIVE_STATES:
+      # when not overshooting, calculate v_turn as the speed at the prediction horizon when following
+      # the smooth deceleration.
+      a_target = self.a_ego
+    # ENTERING
+    elif self.state == VisionState.entering:
+      # when not overshooting, target a smooth deceleration in preparation for a sharp turn to come.
+      a_target = np.interp(self.max_pred_lat_acc, _ENTERING_SMOOTH_DECEL_BP, _ENTERING_SMOOTH_DECEL_V)
+    # TURNING
+    elif self.state == VisionState.turning:
+      # When turning, we provide a target acceleration that is comfortable for the lateral acceleration felt.
+      a_target = np.interp(self.current_lat_acc, _TURNING_ACC_BP, _TURNING_ACC_V)
+    # LEAVING
+    elif self.state == VisionState.leaving:
+      # When leaving, we provide a comfortable acceleration to regain speed.
+      a_target = _LEAVING_ACC
+    else:
+      raise NotImplementedError(f"SCC-V state not supported: {self.state}")
+
+    return a_target
+
  def update(self, sm: messaging.SubMaster, long_enabled: bool, long_override: bool, v_ego: float, a_ego: float,
             v_cruise_setpoint: float) -> None:
    self.long_enabled = long_enabled
@@ -184,7 +195,7 @@ class SmartCruiseControlVision:
    self._update_calculations(sm)

    self.is_enabled, self.is_active = self._update_state_machine()
-    self.a_target = self.a_ego
+    self.a_target = self._update_solution()

    self.output_v_target = self.get_v_target_from_control()
    self.output_a_target = self.get_a_target_from_control()
@@ -91,7 +91,7 @@ class SpeedLimitAssist:

    self._plus_hold = 0.
    self._minus_hold = 0.
-    self._release_toggle_prev = 0
+    self._last_carstate_ts = 0.

    # TODO-SP: SLA's own output_a_target for planner
    # Solution functions mapped to respective states
@@ -146,16 +146,16 @@ class SpeedLimitAssist:
      set_speed_limit_assist_availability(self.CP, self.CP_SP, self.params)
      self.enabled = self.params.get("SpeedLimitMode", return_default=True) == Mode.assist

-  def update_buttons(self, release_toggle: int) -> None:
-    released = self._release_toggle_prev ^ release_toggle
-    self._release_toggle_prev = release_toggle
-    if not released:
-      return
+  def update_car_state(self, CS: car.CarState) -> None:
    now = time.monotonic()
-    if any((released >> b) & 1 for b in CRUISE_BUTTONS_PLUS):
-      self._plus_hold = max(self._plus_hold, now + CRUISE_BUTTON_CONFIRM_HOLD)
-    if any((released >> b) & 1 for b in CRUISE_BUTTONS_MINUS):
-      self._minus_hold = max(self._minus_hold, now + CRUISE_BUTTON_CONFIRM_HOLD)
+    self._last_carstate_ts = now
+
+    for b in CS.buttonEvents:
+      if not b.pressed:
+        if b.type in CRUISE_BUTTONS_PLUS:
+          self._plus_hold = max(self._plus_hold, now + CRUISE_BUTTON_CONFIRM_HOLD)
+        elif b.type in CRUISE_BUTTONS_MINUS:
+          self._minus_hold = max(self._minus_hold, now + CRUISE_BUTTON_CONFIRM_HOLD)

  def _get_button_release(self, req_plus: bool, req_minus: bool) -> bool:
    now = time.monotonic()
@@ -5,14 +5,11 @@ 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 time
-
 import pytest

 from openpilot.cereal import custom
 from opendbc.car.car_helpers import interfaces
 from opendbc.car.rivian.values import CAR as RIVIAN
-from opendbc.car.structs import car
 from opendbc.car.tesla.values import CAR as TESLA
 from opendbc.car.toyota.values import CAR as TOYOTA
 from openpilot.common.constants import CV
@@ -24,13 +21,9 @@ from openpilot.sunnypilot.selfdrive.car import interfaces as sunnypilot_interfac
 from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit import PCM_LONG_REQUIRED_MAX_SET_SPEED
 from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.common import Mode
 from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.speed_limit_assist import SpeedLimitAssist, \
-  PRE_ACTIVE_GUARD_PERIOD, ACTIVE_STATES, CRUISE_BUTTON_CONFIRM_HOLD
-from openpilot.sunnypilot.selfdrive.selfdrived.button_state_tracker import ButtonStateTracker
+  PRE_ACTIVE_GUARD_PERIOD, ACTIVE_STATES
 from openpilot.sunnypilot.selfdrive.selfdrived.events import EventsSP

-ButtonEvent = car.CarState.ButtonEvent
-ButtonType = car.CarState.ButtonEvent.Type
-
 SpeedLimitAssistState = custom.LongitudinalPlanSP.SpeedLimit.AssistState

 ALL_STATES = tuple(SpeedLimitAssistState.schema.enumerants.values())
@@ -283,86 +276,3 @@ class TestSpeedLimitAssist:
        assert self.sla.state in [SpeedLimitAssistState.preActive, SpeedLimitAssistState.active]
      elif initial_state in ACTIVE_STATES:
        assert self.sla.state in ACTIVE_STATES
-
-
-class TestButtonStateTrackerSLAIntegration:
-
-  def setup_method(self, method):
-    self.tracker = ButtonStateTracker()
-    self.params = Params()
-    self.params.put("IsReleaseSpBranch", True, block=True)
-    self.params.put("SpeedLimitMode", int(Mode.assist), block=True)
-    self.params.put_bool("IsMetric", False, block=True)
-    self.params.put("SpeedLimitOffsetType", 0, block=True)
-    self.params.put("SpeedLimitValueOffset", 0, block=True)
-
-    CarInterface = interfaces[DEFAULT_CAR]
-    CP = CarInterface.get_non_essential_params(DEFAULT_CAR)
-    CP.openpilotLongitudinalControl = True
-    CP_SP = CarInterface.get_non_essential_params_sp(CP, DEFAULT_CAR)
-    self.sla = SpeedLimitAssist(CP, CP_SP)
-
-  def _make_cs(self, events=None) -> car.CarState:
-    CS = car.CarState()
-    CS.buttonEvents = events or []
-    return CS
-
-  def _run_ctrl_frames(self, frames: list[car.CarState]) -> None:
-    for cs in frames:
-      self.tracker.update(cs)
-
-  def test_button_confirm_via_tracker(self) -> None:
-    self._run_ctrl_frames([
-      self._make_cs([ButtonEvent(type=ButtonType.accelCruise, pressed=True)]),
-      self._make_cs(),
-      self._make_cs([ButtonEvent(type=ButtonType.accelCruise, pressed=False)]),
-      self._make_cs(),
-      self._make_cs(),
-    ])
-    self.sla.update_buttons(self.tracker.release_toggle)
-    assert self.sla._get_button_release(req_plus=True, req_minus=False)
-
-  def test_rapid_press_release_between_polls(self) -> None:
-    self.sla.update_buttons(self.tracker.release_toggle)
-
-    self._run_ctrl_frames([
-      self._make_cs([ButtonEvent(type=ButtonType.decelCruise, pressed=True)]),
-      self._make_cs([ButtonEvent(type=ButtonType.decelCruise, pressed=False)]),
-      self._make_cs(),
-      self._make_cs(),
-      self._make_cs(),
-    ])
-    self.sla.update_buttons(self.tracker.release_toggle)
-    assert self.sla._get_button_release(req_plus=False, req_minus=True)
-
-  def test_multiple_releases_between_polls(self) -> None:
-    self.sla.update_buttons(self.tracker.release_toggle)
-
-    self._run_ctrl_frames([
-      self._make_cs([
-        ButtonEvent(type=ButtonType.accelCruise, pressed=True),
-        ButtonEvent(type=ButtonType.decelCruise, pressed=True),
-      ]),
-      self._make_cs([
-        ButtonEvent(type=ButtonType.accelCruise, pressed=False),
-        ButtonEvent(type=ButtonType.decelCruise, pressed=False),
-      ]),
-    ])
-    self.sla.update_buttons(self.tracker.release_toggle)
-    assert self.sla._get_button_release(req_plus=True, req_minus=False)
-    assert self.sla._get_button_release(req_plus=False, req_minus=True)
-
-  def test_no_false_positive_same_toggle(self) -> None:
-    self.sla.update_buttons(self.tracker.release_toggle)
-    self.sla.update_buttons(self.tracker.release_toggle)
-    assert not self.sla._get_button_release(req_plus=True, req_minus=False)
-    assert not self.sla._get_button_release(req_plus=False, req_minus=True)
-
-  def test_button_confirm_expires(self) -> None:
-    self._run_ctrl_frames([
-      self._make_cs([ButtonEvent(type=ButtonType.accelCruise, pressed=True)]),
-      self._make_cs([ButtonEvent(type=ButtonType.accelCruise, pressed=False)]),
-    ])
-    self.sla.update_buttons(self.tracker.release_toggle)
-    time.sleep(CRUISE_BUTTON_CONFIRM_HOLD + 0.1)
-    assert not self.sla._get_button_release(req_plus=True, req_minus=False)
@@ -1,11 +1,10 @@
 import pytest
 from openpilot.cereal import log, custom
 from openpilot.common.params import Params
+
 from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
 from openpilot.sunnypilot.selfdrive.controls.lib.lane_turn_desire import LaneTurnController, LANE_CHANGE_SPEED_MIN
 from openpilot.sunnypilot.selfdrive.controls.lib.auto_lane_change import AutoLaneChangeMode
-from openpilot.sunnypilot.selfdrive.controls.lib.relc import RoadEdgeLaneChangeController
-

 TurnDirection = custom.ModelDataV2SP.TurnDirection

@@ -108,10 +107,7 @@ def set_lane_turn_params():
 ])
 def test_desire_helper_integration(carstate, lateral_active, lane_change_prob, expected_desire, set_lane_turn_params):
  dh = DesireHelper()
-  relc = RoadEdgeLaneChangeController(dh)
-  relc.enabled = True
  dh.alc.lane_change_set_timer = AutoLaneChangeMode.NUDGE
  for _ in range(10):
-    dh.update(carstate, lateral_active, lane_change_prob,
-              left_edge_detected=relc.left_edge_detected, right_edge_detected=relc.right_edge_detected)
+    dh.update(carstate, lateral_active, lane_change_prob)
  assert dh.desire == expected_desire  # The first four tests were unit tests to test the controller, where this tests the integration in desire helpers
@@ -1,73 +0,0 @@
-import math
-
-import pytest
-
-from openpilot.sunnypilot.selfdrive.controls.lib.latcontrol_pid_ext import DecayingIntegratorPIDController
-
-RATE = 100
-DT = 1.0 / RATE
-
-
-def build_pid(decay_tau=2.0):
-  return DecayingIntegratorPIDController(0.05, 0.05, pos_limit=1.0, neg_limit=-1.0, rate=RATE, decay_tau=decay_tau)
-
-
-class TestDecayingIntegratorPIDController:
-  def test_accumulates_normally_when_not_frozen(self):
-    """Unfrozen behavior must be identical to stock PIDController - only freeze behavior changes."""
-    pid = build_pid()
-    for _ in range(50):
-      pid.update(error=1.0, speed=1.0, feedforward=0.0, freeze_integrator=False)
-    assert pid.i > 0
-
-  def test_decays_toward_zero_while_frozen(self):
-    pid = build_pid(decay_tau=2.0)
-    for _ in range(200):  # 2s build-up, well below saturation so anti-windup doesn't clip i
-      pid.update(error=1.0, speed=1.0, feedforward=0.0, freeze_integrator=False)
-    i_before = pid.i
-    assert i_before > 0
-
-    i_trace = []
-    for _ in range(600):  # 6s frozen = 3 time constants
-      pid.update(error=1.0, speed=1.0, feedforward=0.0, freeze_integrator=True)
-      i_trace.append(pid.i)
-
-    # monotonic decay toward zero, never grows, never flips sign
-    assert all(0 <= i_trace[k + 1] <= i_trace[k] for k in range(len(i_trace) - 1))
-    assert i_trace[-1] < 0.05 * i_before, "should be mostly decayed after 3 time constants"
-
-  def test_matches_exponential_decay_time_constant(self):
-    """Sanity-checks the decay is a real exp(-t/tau), not just 'decreasing'."""
-    pid = build_pid(decay_tau=2.0)
-    pid.i = 1.0
-
-    for _ in range(200):  # exactly one time constant (2s @ 100Hz)
-      pid.update(error=0.0, speed=1.0, feedforward=0.0, freeze_integrator=True)
-
-    assert pid.i == pytest.approx(math.exp(-1.0), rel=1e-3)
-
-  def test_no_discontinuity_at_freeze_transition(self):
-    """The whole point: control output must not jump the instant freeze conditions engage."""
-    pid = build_pid(decay_tau=2.0)
-    for _ in range(200):
-      pid.update(error=1.0, speed=1.0, feedforward=0.0, freeze_integrator=False)
-    control_before = pid.control
-
-    control_after = pid.update(error=1.0, speed=1.0, feedforward=0.0, freeze_integrator=True)
-
-    assert abs(control_after - control_before) < 0.01, "output jumped at the freeze transition"
-
-  def test_stale_integral_does_not_kick_back_in_on_unfreeze(self):
-    """The bug this exists to fix: after a long freeze, unfreezing must not suddenly reapply a
-    large stale integral untouched for however long the freeze lasted."""
-    pid = build_pid(decay_tau=2.0)
-    for _ in range(200):
-      pid.update(error=1.0, speed=1.0, feedforward=0.0, freeze_integrator=False)
-    i_peak = pid.i
-
-    for _ in range(1000):  # 10s frozen, ~5 time constants
-      pid.update(error=0.0, speed=1.0, feedforward=0.0, freeze_integrator=True)
-
-    # unfreeze: the resumed integral must be near zero, not the stale peak
-    pid.update(error=0.0, speed=1.0, feedforward=0.0, freeze_integrator=False)
-    assert abs(pid.i) < 0.01 * i_peak
@@ -1,215 +0,0 @@
-import pytest
-
-from opendbc.car import DT_CTRL, gen_empty_fingerprint, structs
-from opendbc.car.car_helpers import interfaces
-from opendbc.car.gm.values import CAR as GM
-from opendbc.car.honda.values import CAR as HONDA
-from opendbc.car.hyundai.values import CAR as HYUNDAI
-from opendbc.car.rivian.values import CAR as RIVIAN
-from opendbc.car.toyota.values import CAR as TOYOTA
-from opendbc.car.volkswagen.values import CAR as VOLKSWAGEN
-from openpilot.selfdrive.controls.lib.drive_helpers import should_stop
-from openpilot.selfdrive.controls.lib.longcontrol import LongControl, LongCtrlState
-from openpilot.sunnypilot.selfdrive.controls.lib.longcontrol import STOPPED_SPEED
-from openpilot.sunnypilot.selfdrive.test.longitudinal_maneuvers.plant import PRIUS_TSS2_ROUTE_MODEL, PlantSP
-
-
-STOP_ACCEL_VEHICLES = (TOYOTA.TOYOTA_RAV4_TSS2, HONDA.HONDA_CIVIC_2022, VOLKSWAGEN.VOLKSWAGEN_ARTEON_MK1, RIVIAN.RIVIAN_R1)
-ROUTE_STOP_ONSETS = (
-  (0.290, -0.497, -0.270, -0.302), (0.464, -0.223, -0.264, -0.292), (0.467, -0.582, -0.316, -0.359),
-  (0.530, -0.311, -0.309, -0.333), (0.581, -0.467, -0.312, -0.352), (0.398, -0.557, -0.311, -0.348),
-  (0.517, -0.290, -0.301, -0.327), (0.312, -0.420, -0.271, -0.304), (0.474, -0.509, -0.303, -0.347),
-  (0.241, -0.554, -0.573, -0.617), (0.292, -0.154, -0.302, -0.326),
-)
-
-
-def get_car_params(candidate):
-  fingerprint = gen_empty_fingerprint()
-  interface = interfaces[candidate]
-  CP = interface.get_params(candidate, fingerprint, [], True, False, False)
-  return CP, interface.get_params_sp(CP, candidate, fingerprint, [], True, False, False)
-
-
-def make_car_state(v_ego=0.2, a_ego=0.0, standstill=False) -> structs.CarState:
-  state = structs.CarState(vEgo=float(v_ego), aEgo=float(a_ego), standstill=standstill)
-  state.cruiseState.standstill = standstill
-  return state
-
-
-def make_control(candidate, initial_accel=-0.33):
-  CP, CP_SP = get_car_params(candidate)
-  control = LongControl(CP, CP_SP)
-  control.long_control_state = LongCtrlState.pid
-  control.last_output_accel = initial_accel
-  return CP, control
-
-
-def stock_stopping_output(output_accel, stop_accel):
-  return min(output_accel, 0.0) - DT_CTRL if output_accel > stop_accel else output_accel
-
-
-def test_stop_threshold_remains_unchanged():
-  assert should_stop(0.24, 0.0)
-  assert not should_stop(0.26, 0.0)
-  assert not should_stop(0.24, 0.1)
-
-
-@pytest.mark.parametrize(("v_ego", "a_ego", "a_target", "initial_accel"), ROUTE_STOP_ONSETS)
-def test_logged_stop_onsets_hold_the_existing_brake(v_ego, a_ego, a_target, initial_accel):
-  _, control = make_control(TOYOTA.TOYOTA_RAV4_TSS2, initial_accel)
-  output = control.update(True, make_car_state(v_ego, a_ego), a_target, True, (-3.5, 2.0))
-  assert control.long_control_state == LongCtrlState.stopping
-  assert output == pytest.approx(initial_accel)
-
-
-@pytest.mark.parametrize("candidate", STOP_ACCEL_VEHICLES)
-def test_urgent_braking_matches_the_stock_ramp(candidate):
-  CP, control = make_control(candidate)
-  CS = make_car_state(0.8, -0.1)
-  output = control.last_output_accel
-
-  for _ in range(round(1.0 / DT_CTRL)):
-    output = control.update(True, CS, -3.0, True, (-3.5, 2.0))
-
-  expected = -0.33
-  for _ in range(round(1.0 / DT_CTRL)):
-    expected = stock_stopping_output(expected, CP.stopAccel)
-  assert output == pytest.approx(expected)
-
-
-@pytest.mark.parametrize("candidate", STOP_ACCEL_VEHICLES)
-def test_stronger_planner_brake_matches_the_stock_ramp(candidate):
-  CP, control = make_control(candidate)
-  outputs = [control.update(True, make_car_state(0.3, -0.3), -1.0, True, (-3.5, 2.0)) for _ in range(10)]
-  expected = []
-  output = -0.33
-  for _ in range(10):
-    output = stock_stopping_output(output, CP.stopAccel)
-    expected.append(output)
-  assert outputs == pytest.approx(expected)
-
-
-@pytest.mark.parametrize("candidate", STOP_ACCEL_VEHICLES)
-def test_insufficient_deceleration_uses_the_stock_ramp_immediately(candidate):
-  CP, control = make_control(candidate)
-  output = control.update(True, make_car_state(0.6, -0.1), -0.1, True, (-3.5, 2.0))
-  assert output == pytest.approx(stock_stopping_output(-0.33, CP.stopAccel))
-
-
-def test_deceleration_noise_cannot_release_the_brake():
-  _, control = make_control(TOYOTA.TOYOTA_RAV4_TSS2)
-  outputs = [control.update(True, make_car_state(0.3, -0.3 if frame % 2 else 0.0), -0.1, True, (-3.5, 2.0)) for frame in range(40)]
-  assert all(current <= previous for previous, current in zip(outputs[:-1], outputs[1:], strict=True))
-
-
-def test_planner_noise_cannot_release_the_brake():
-  _, control = make_control(TOYOTA.TOYOTA_RAV4_TSS2)
-  outputs = [control.update(True, make_car_state(0.3, -0.3), -1.0 if frame % 2 else -0.1, True, (-3.5, 2.0)) for frame in range(40)]
-  assert all(current <= previous for previous, current in zip(outputs[:-1], outputs[1:], strict=True))
-
-
-@pytest.mark.parametrize(("v_ego", "a_ego", "a_target"), ((float("nan"), -0.3, -0.1), (0.3, float("nan"), -0.1), (0.3, -0.3, float("nan"))))
-def test_invalid_state_uses_the_stock_ramp(v_ego, a_ego, a_target):
-  CP, control = make_control(TOYOTA.TOYOTA_RAV4_TSS2)
-  output = control.update(True, make_car_state(v_ego, a_ego), a_target, True, (-3.5, 2.0))
-  assert output == pytest.approx(stock_stopping_output(-0.33, CP.stopAccel))
-
-
-@pytest.mark.parametrize(("speed", "initial_accel", "grade_accel", "actuator_lag"), (
-  (0.24, 0.0, 0.0, 0.15), (0.464, -0.223, 0.0, 0.25), (0.53, -0.31, 0.0, 0.35),
-  (0.24, 0.0, 0.49, 0.15), (0.53, -0.31, 0.49, 0.25), (0.6, -0.3, 0.49, 0.35), (0.6, -0.3, 0.49, 0.5),
-))
-def test_smooth_stop_distance_is_bounded(speed, initial_accel, grade_accel, actuator_lag):
-  _, control = make_control(TOYOTA.TOYOTA_RAV4_TSS2, initial_accel)
-  applied_accel = initial_accel
-  distance = 0.0
-
-  for _ in range(round(4.0 / DT_CTRL)):
-    command = control.update(True, make_car_state(speed, applied_accel), -0.1, True, (-3.5, 2.0))
-    applied_accel += DT_CTRL / actuator_lag * (command + grade_accel - applied_accel)
-    speed = max(0.0, speed + applied_accel * DT_CTRL)
-    distance += speed * DT_CTRL
-    if speed == 0.0:
-      break
-
-  assert speed == 0.0
-  assert distance < 1.0
-
-
-@pytest.mark.parametrize("candidate", STOP_ACCEL_VEHICLES)
-def test_standstill_uses_the_stock_ramp(candidate):
-  CP, control = make_control(candidate)
-  control.long_control_state = LongCtrlState.off
-  CS = make_car_state(0.0, 0.0, standstill=True)
-  outputs = [control.update(True, CS, 0.0, False, (-3.5, 2.0)) for _ in range(round(2.0 / DT_CTRL))]
-  expected = -0.33
-  for _ in range(round(2.0 / DT_CTRL)):
-    expected = stock_stopping_output(expected, CP.stopAccel)
-  assert outputs[0] == pytest.approx(stock_stopping_output(-0.33, CP.stopAccel))
-  assert outputs[-1] == pytest.approx(expected)
-
-
-@pytest.mark.parametrize(("v_ego", "a_ego", "standstill"), ((0.6, -0.1, False), (0.0, 0.0, True)))
-def test_stopping_never_releases_a_stronger_command(v_ego, a_ego, standstill):
-  _, control = make_control(TOYOTA.TOYOTA_RAV4_TSS2, -3.0)
-  output = control.update(True, make_car_state(v_ego, a_ego, standstill), 0.0, True, (-3.5, 2.0))
-  assert output == pytest.approx(-3.0)
-
-
-def test_reported_standstill_while_moving_can_hold_the_brake():
-  _, control = make_control(GM.CHEVROLET_BOLT_EUV)
-  control.long_control_state = LongCtrlState.off
-  output = control.update(True, make_car_state(0.3, -0.3, standstill=True), -0.1, False, (-3.5, 2.0))
-  assert output == pytest.approx(-0.33)
-
-
-def test_stopping_removes_positive_acceleration_immediately():
-  _, control = make_control(HYUNDAI.HYUNDAI_SONATA, 0.2)
-  output = control.update(True, make_car_state(0.2, -0.2), -0.1, True, (-3.5, 2.0))
-  assert output == pytest.approx(-DT_CTRL)
-
-
-def test_rollback_uses_the_stock_ramp():
-  CP, control = make_control(TOYOTA.TOYOTA_RAV4_TSS2)
-  output = control.update(True, make_car_state(-0.1, 0.1), -0.1, True, (-3.5, 2.0))
-  assert output == pytest.approx(stock_stopping_output(-0.33, CP.stopAccel))
-
-
-def test_departure_uses_the_stock_pid_path():
-  _, control = make_control(TOYOTA.TOYOTA_RAV4_TSS2)
-  control.long_control_state = LongCtrlState.stopping
-  output = control.update(True, make_car_state(0.0), 0.6, False, (-3.5, 2.0))
-  assert control.long_control_state == LongCtrlState.pid
-  assert output > 0.0
-
-
-def test_planner_mpc_and_longcontrol_complete_a_smooth_stop():
-  plant = PlantSP(
-    lead_relevancy=True, speed=0.6, distance_lead=3.6, run_long_control=True,
-    actuator_model=PRIUS_TSS2_ROUTE_MODEL,
-  )
-  plant.planner.accel_controller.enabled = True
-  plant.planner.accel_controller.profile = 1
-  plant.planner.accel_controller.update_params = lambda: None
-  plant.planner.dec._enabled = False
-  plant.planner.dec._read_params = lambda: None
-  commands = []
-  speeds = []
-  states = []
-  solver_statuses = []
-
-  while plant.current_time < 5.0:
-    result = plant.step(v_lead=0.0, v_cruise=8.0)
-    commands.append(result["actuator_command"])
-    speeds.append(result["speed"])
-    states.append(result["long_control_state"])
-    solver_statuses.append(plant.planner.mpc.last_solution_status)
-
-  stopping = states.index(LongCtrlState.stopping)
-  moving_stop_commands = [command for command, state, speed in zip(commands, states, speeds, strict=True)
-                          if state == LongCtrlState.stopping and speed > STOPPED_SPEED]
-  assert all(current <= previous + 1e-9 for previous, current in zip(commands[stopping:-1], commands[stopping + 1:], strict=True))
-  assert len(moving_stop_commands) > 1 and max(moving_stop_commands) - min(moving_stop_commands) < 1e-9
-  assert plant.speed == 0.0 and plant.distance < 1.0
-  assert plant.distance_lead - plant.distance > 3.0
-  assert all(status == 0 for status in solver_statuses)
@@ -1,159 +0,0 @@
-"""
-Closed-loop smoke test for the Prius TSS2 PID lateral-control toggle's starting gains
-(openpilot/sunnypilot/selfdrive/car/interfaces.py::_PRIUS_TSS2_PID_*).
-
-IMPORTANT LIMITATION: there is no real Prius TSS2 EPS actuator model anywhere in this repo (unlike
-the longitudinal plant model used by test_accel_controller_closed_loop.py, which was fit to logged
-routes). The actuator here is a generic, uncalibrated 2nd-order lag (see `SurrogateEpsActuator`) —
-it stands in for "some steering rack with plausible bandwidth," not this specific car's real EPS.
-
-This test can only prove the starting gains are stable and roughly critically damped against that
-generic surrogate. It CANNOT prove they are correctly tuned for a real Prius TSS2 — that requires
-on-road A/B via tools/lateral_maneuvers (see its README) before trusting this tune on its own.
-
-SCOPE: cruise-speed (20-30mph) only. The surrogate's steady-state gain is K = 1/(kf*v_ego**2) (see
-`SurrogateEpsActuator`), which blows up as v_ego -> 0 and produces meaningless multi-hundred-degree
-oscillation at parking-lot speed — an artifact of the surrogate, not of the kp/ki tune. This mirrors
-a real constraint: angle*v_ego**2 feedforward (and this kf calibration) is explicitly a higher-speed
-approximation (see the "25+mph" comment in latcontrol_torque_v0.py) — there's no valid basis here to
-simulate the low-speed "sharp turn" boost in _PRIUS_TSS2_PID_KP_BP/_V at all. That boost is only
-covered by the static shape check in test_prius_tss2_pid.py
-(test_kp_is_boosted_below_integrator_freeze_speed) — it has NOT been closed-loop or on-road
-verified. Validate it in a parking lot before trusting it anywhere faster.
-"""
-import math
-
-import numpy as np
-import pytest
-
-from opendbc.car import DT_CTRL
-from opendbc.car.car_helpers import interfaces as car_interfaces
-from opendbc.car.vehicle_model import VehicleModel
-from openpilot.selfdrive.controls.lib.latcontrol_pid import LatControlPID
-from openpilot.sunnypilot.selfdrive.car.interfaces import _initialize_prius_tss2_pid_lateral_control
-
-MPH_TO_MS = 0.44704
-DURATION_S = 6.0
-STEADY_WINDOW_S = 1.0
-TARGET_LAT_ACCEL = 1.5  # m/s^2, roughly a lateral_maneuvers "step" size
-
-
-class FakeCarState:
-  def __init__(self, v_ego):
-    self.vEgo = v_ego
-    self.steeringAngleDeg = 0.0
-    self.steeringRateDeg = 0.0
-    self.steeringPressed = False
-
-
-class FakeLiveParams:
-  roll = 0.0
-  angleOffsetDeg = 0.0
-
-
-class SurrogateEpsActuator:
-  """Generic critically-damped 2nd-order torque->angle lag. NOT fit to any real car.
-
-  The steady-state gain (deg per unit torque) is derived from the tune's own `kf`, i.e.
-  K = 1 / (kf * v_ego**2) — the same steady-state relationship LatControlPID's feedforward term
-  assumes (ff = kf * angle_deg * v_ego**2 ~= torque needed to hold that angle). A fixed, unrelated
-  gain guess saturated the actuator well below the test's target angle at 20-30mph — this ties the
-  surrogate to the one steady-state assumption already baked into the tune, so the test only
-  exercises kp/ki dynamic response and stability, not an arbitrary extra unknown.
-  """
-
-  def __init__(self, deg_per_unit_torque, natural_freq_hz=3.0, zeta=1.0):
-    self.wn = 2 * math.pi * natural_freq_hz
-    self.zeta = zeta
-    self.k = deg_per_unit_torque
-    self.angle = 0.0
-    self.rate = 0.0
-
-  def step(self, torque, dt):
-    accel = self.wn ** 2 * (self.k * torque - self.angle) - 2 * self.zeta * self.wn * self.rate
-    self.rate += accel * dt
-    self.angle += self.rate * dt
-    return self.angle, self.rate
-
-
-def run_closed_loop(CP, v_ego, target_lat_accel, duration_s=DURATION_S):
-  VM = VehicleModel(CP)
-  lac = LatControlPID(CP, structs_car_params_sp(), FakeCI(), DT_CTRL)
-  deg_per_unit_torque = 1.0 / (CP.lateralTuning.pid.kf * v_ego ** 2)
-  actuator = SurrogateEpsActuator(deg_per_unit_torque)
-  CS = FakeCarState(v_ego)
-  params = FakeLiveParams()
-
-  desired_curvature = -target_lat_accel / v_ego ** 2
-  desired_angle_deg = math.degrees(VM.get_steer_from_curvature(-desired_curvature, v_ego, 0.0))
-
-  n_steps = int(duration_s / DT_CTRL)
-  angle_trace = np.zeros(n_steps)
-  torque_trace = np.zeros(n_steps)
-
-  for i in range(n_steps):
-    output_torque, _, _ = lac.update(True, CS, VM, params, False, desired_curvature, None, False, 0.0)
-    output_torque = float(output_torque)
-    angle, rate = actuator.step(output_torque, DT_CTRL)
-    CS.steeringAngleDeg = float(angle)
-    CS.steeringRateDeg = float(rate)
-    angle_trace[i] = angle
-    torque_trace[i] = output_torque
-
-  return angle_trace, torque_trace, desired_angle_deg
-
-
-def structs_car_params_sp():
-  from opendbc.car import structs
-  return structs.CarParamsSP()
-
-
-class FakeCI:
-  @staticmethod
-  def get_steer_feedforward_function():
-    return lambda desired_angle, v_ego: desired_angle * (v_ego ** 2)
-
-
-def make_prius_tss2_cp():
-  CarInterface = car_interfaces['TOYOTA_PRIUS_TSS2']
-  CP = CarInterface.get_params('TOYOTA_PRIUS_TSS2', {0: {}, 1: {}, 2: {}}, [], alpha_long=False, is_release=False, docs=False)
-  _initialize_prius_tss2_pid_lateral_control(CP)
-  assert CP.lateralTuning.which() == 'pid'
-  return CP
-
-
-@pytest.mark.parametrize('v_mph', [20.0, 30.0])
-def test_starting_gains_settle_without_diverging(v_mph):
-  CP = make_prius_tss2_cp()
-  v_ego = v_mph * MPH_TO_MS
-
-  angle_trace, torque_trace, desired_angle_deg = run_closed_loop(CP, v_ego, TARGET_LAT_ACCEL)
-
-  assert np.all(np.isfinite(angle_trace)), "diverged/NaN — unsafe to ever test on-road"
-  assert np.all(np.abs(torque_trace) <= 1.0 + 1e-6), "output_torque exceeded steer_max=1.0 saturation bound"
-
-  steady_n = int(STEADY_WINDOW_S / DT_CTRL)
-  steady_angle = angle_trace[-steady_n:]
-  settle_error_deg = abs(np.mean(steady_angle) - desired_angle_deg)
-  oscillation_deg = np.ptp(steady_angle)
-
-  assert settle_error_deg < 1.0, f"steady-state tracking error too large: {settle_error_deg:.3f} deg (target {desired_angle_deg:.2f} deg)"
-  assert oscillation_deg < 0.5, f"sustained oscillation in tail window: {oscillation_deg:.3f} deg peak-to-peak (limit-cycle candidate)"
-
-
-def test_gains_are_not_a_no_op_sanity_check():
-  """Confirms this harness actually has teeth: gains far more aggressive than the shipped starting
-  point produce a limit cycle against the same surrogate actuator, so the tolerances above aren't
-  trivially satisfied by any input."""
-  CP = make_prius_tss2_cp()
-  CP.lateralTuning.pid.kpBP = [0.0]
-  CP.lateralTuning.pid.kpV = [1.5]   # 10x the cruise-speed kp
-  CP.lateralTuning.pid.kiBP = [0.0]
-  CP.lateralTuning.pid.kiV = [0.5]   # 10x the shipped ki
-  v_ego = 20.0 * MPH_TO_MS
-
-  angle_trace, _, desired_angle_deg = run_closed_loop(CP, v_ego, TARGET_LAT_ACCEL)
-
-  steady_n = int(STEADY_WINDOW_S / DT_CTRL)
-  oscillation_deg = np.ptp(angle_trace[-steady_n:])
-  assert oscillation_deg > 0.5, "expected an aggressive 10x-gain tune to visibly ring against this actuator; harness may not be sensitive"
@@ -1,99 +0,0 @@
-"""
-Copyright (c) 2021-, rav4kumar, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import pytest
-
-from openpilot.common.realtime import DT_MDL
-from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
-from openpilot.sunnypilot.selfdrive.controls.lib.relc import (
-  RoadEdgeLaneChangeController, EDGE_REACTION_TIME, EDGE_CLEAR_TIME, MIN_SPEED,
-)
-
-V_HIGH = MIN_SPEED + 2.0
-V_LOW = MIN_SPEED - 1.0
-
-
-@pytest.fixture
-def relc(mocker):
-  mock_params = mocker.patch("openpilot.sunnypilot.selfdrive.controls.lib.relc.Params")
-  mock_params.return_value.get_bool.return_value = True
-  controller = RoadEdgeLaneChangeController(DesireHelper())
-  controller.enabled = True
-  return controller
-
-
-def drive(controller, road_edge_stds, lane_line_probs, seconds, v_ego=V_HIGH):
-  for _ in range(int(seconds / DT_MDL) + 1):
-    controller.update(road_edge_stds, lane_line_probs, v_ego)
-
-
-@pytest.mark.parametrize("road_edge_stds,lane_line_probs,attr", [
-  ([0.0, 0.9], [0.0, 0.8, 0.8, 0.8], "left_edge_detected"),
-  ([0.9, 0.0], [0.8, 0.8, 0.8, 0.0], "right_edge_detected"),
-])
-def test_edge_detection(relc, road_edge_stds, lane_line_probs, attr):
-  drive(relc, road_edge_stds, lane_line_probs, EDGE_REACTION_TIME + 0.1)
-  assert getattr(relc, attr)
-
-
-def test_edge_detection_requires_time(relc):
-  drive(relc, [0.0, 0.9], [0.0, 0.8, 0.8, 0.8], EDGE_REACTION_TIME - 0.05)
-  assert not relc.left_edge_detected
-
-
-def test_both_edges_detected(relc):
-  drive(relc, [0.0, 0.0], [0.0, 0.8, 0.8, 0.0], EDGE_REACTION_TIME + 0.1)
-  assert relc.left_edge_detected
-  assert relc.right_edge_detected
-
-
-def test_noise_doesnt_clear(relc):
-  edge = ([0.0, 0.9], [0.0, 0.8, 0.8, 0.8])
-  clear = ([0.9, 0.9], [0.8, 0.8, 0.8, 0.8])
-
-  drive(relc, *edge, EDGE_REACTION_TIME + 0.1)
-  assert relc.left_edge_detected
-
-  relc.update(*clear, V_HIGH)
-  relc.update(*edge, V_HIGH)
-  assert relc.left_edge_detected
-
-
-def test_clears_after_window(relc):
-  edge = ([0.0, 0.9], [0.0, 0.8, 0.8, 0.8])
-  clear = ([0.9, 0.9], [0.8, 0.8, 0.8, 0.8])
-
-  drive(relc, *edge, EDGE_REACTION_TIME + 0.1)
-  assert relc.left_edge_detected
-
-  drive(relc, *clear, EDGE_CLEAR_TIME + 0.05)
-  assert not relc.left_edge_detected
-  assert relc.left_edge_timer == 0.0
-
-
-def test_low_speed_skips(relc):
-  drive(relc, [0.0, 0.9], [0.0, 0.8, 0.8, 0.8], EDGE_REACTION_TIME + 0.1, v_ego=V_LOW)
-  assert not relc.left_edge_detected
-  assert relc.left_edge_timer == 0.0
-
-
-def test_speed_drop_resets(relc):
-  drive(relc, [0.0, 0.9], [0.0, 0.8, 0.8, 0.8], EDGE_REACTION_TIME + 0.1)
-  assert relc.left_edge_detected
-
-  relc.update([0.0, 0.9], [0.0, 0.8, 0.8, 0.8], V_LOW)
-  assert not relc.left_edge_detected
-
-
-def test_param_off_resets(relc):
-  drive(relc, [0.0, 0.9], [0.0, 0.8, 0.8, 0.8], EDGE_REACTION_TIME + 0.1)
-  assert relc.left_edge_detected
-
-  relc.params.get_bool.return_value = False
-  relc.read_params()
-  relc.update([0.0, 0.9], [0.0, 0.8, 0.8, 0.8], V_HIGH)
-  assert not relc.left_edge_detected
-  assert not relc.right_edge_detected
@@ -1,109 +0,0 @@
-from opendbc.car import structs
-
-from openpilot.sunnypilot.selfdrive.controls import controlsd_ext
-from openpilot.sunnypilot.selfdrive.controls.lib.latcontrol_pid_ext import LatControlPidSmooth
-
-
-class FakeParams:
-  def __init__(self, values=None):
-    self.values = values or {}
-
-  def get_bool(self, key):
-    return bool(self.values.get(key, False))
-
-  def get(self, key, return_default=False):
-    return self.values.get(key)
-
-
-class FakeCI:
-  def get_steer_feedforward_function(self):
-    return lambda desired_angle, v_ego: desired_angle * (v_ego ** 2)
-
-
-def make_ext(CP, params_values=None):
-  # Bypass __init__: it blocks on CarParamsSP over messaging, which isn't available in a unit test.
-  ext = controlsd_ext.ControlsExt.__new__(controlsd_ext.ControlsExt)
-  ext.CP = CP
-  ext.CP_SP = structs.CarParamsSP()
-  ext.params = FakeParams(params_values)
-  return ext
-
-
-def make_prius_tss2_pid_cp():
-  CP = structs.CarParams(carFingerprint='TOYOTA_PRIUS_TSS2')
-  CP.lateralTuning.init('pid')
-  CP.lateralTuning.pid.kpBP, CP.lateralTuning.pid.kpV = [0.0, 5.0], [0.30, 0.15]
-  CP.lateralTuning.pid.kiBP, CP.lateralTuning.pid.kiV = [0.0], [0.05]
-  CP.lateralTuning.pid.kf = 4e-05
-  return CP
-
-
-class TestInitializeLateralControlPidSmoothDispatch:
-  """The Prius TSS2 PID toggle's decaying-integrator variant must be scoped to exactly the one
-  (fingerprint, union) combination it applies to - never touch any other PID car's controller."""
-
-  def test_prius_tss2_pid_gets_smooth_variant(self):
-    ext = make_ext(make_prius_tss2_pid_cp())
-    lac = object()
-
-    result = ext.initialize_lateral_control(lac, FakeCI(), 0.01)
-
-    assert isinstance(result, LatControlPidSmooth)
-
-  def test_other_native_pid_car_is_untouched(self):
-    """A hypothetical other brand's native PID car must NOT get swapped to our variant just
-    because the union happens to be 'pid' - only our exact fingerprint qualifies."""
-    CP = structs.CarParams(carFingerprint='SOME_OTHER_PID_CAR')
-    CP.lateralTuning.init('pid')
-    ext = make_ext(CP)
-    lac = object()
-
-    result = ext.initialize_lateral_control(lac, FakeCI(), 0.01)
-
-    assert result is lac
-
-
-class TestInitializeLateralControlPidGuard:
-  """Regression test for the crash this toggle would otherwise cause: torque-only LatControl
-  variants read CP.lateralTuning.torque directly, which raises on a capnp union that's actually
-  'pid' (e.g. the Prius TSS2 PID toggle). initialize_lateral_control must never attempt that."""
-
-  def test_pid_union_returns_lac_unchanged_even_with_enforce_torque_on(self):
-    CP = structs.CarParams()
-    CP.lateralTuning.init('pid')
-    ext = make_ext(CP, {'EnforceTorqueControl': True, 'TorqueControlTune': 0.0})
-
-    lac = object()
-    result = ext.initialize_lateral_control(lac, CI=None, dt=0.01)
-
-    assert result is lac
-
-  def test_pid_union_returns_lac_unchanged_with_enforce_torque_off(self):
-    CP = structs.CarParams()
-    CP.lateralTuning.init('pid')
-    ext = make_ext(CP, {'EnforceTorqueControl': False})
-
-    lac = object()
-    result = ext.initialize_lateral_control(lac, CI=None, dt=0.01)
-
-    assert result is lac
-
-  def test_torque_union_still_dispatches_to_torque_v0(self, monkeypatch):
-    calls = []
-
-    class StubTorqueV0:
-      def __init__(self, CP, CP_SP, CI, dt):
-        calls.append((CP, CP_SP, CI, dt))
-
-    monkeypatch.setattr(controlsd_ext, 'LatControlTorqueV0', StubTorqueV0)
-
-    CP = structs.CarParams()
-    CP.lateralTuning.init('torque')
-    ext = make_ext(CP, {'EnforceTorqueControl': False})
-    ext.CP_SP = None
-
-    lac = object()
-    result = ext.initialize_lateral_control(lac, CI=None, dt=0.01)
-
-    assert isinstance(result, StubTorqueV0)
-    assert len(calls) == 1
@@ -1,26 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from opendbc.car import structs
-
-
-class ButtonStateTracker:
-  def __init__(self) -> None:
-    self.pressed: int = 0
-    self.release_toggle: int = 0
-
-  def update(self, CS: structs.CarState) -> None:
-    for b in CS.buttonEvents:
-      bit = 1 << b.type.raw
-      if b.pressed:
-        self.pressed |= bit
-      else:
-        self.pressed &= ~bit
-        self.release_toggle ^= bit
-
-  def publish(self, ss_sp) -> None:
-    ss_sp.buttonsPressed = self.pressed
-    ss_sp.buttonsReleaseToggle = self.release_toggle
@@ -244,12 +244,4 @@ EVENTS_SP: dict[int, dict[str, Alert | AlertCallbackType]] = {
      AlertStatus.normal, AlertSize.none,
      Priority.MID, VisualAlert.none, AudibleAlert.prompt, 3.),
  },
-
-  EventNameSP.laneChangeRoadEdge: {
-    ET.WARNING: Alert(
-      "Lane Change Unavailable: Road Edge",
-      "",
-      AlertStatus.userPrompt, AlertSize.small,
-      Priority.LOW, VisualAlert.none, AudibleAlert.prompt, 0.1),
-  },
 }
@@ -1,67 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from opendbc.car.structs import car
-from openpilot.sunnypilot.selfdrive.selfdrived.button_state_tracker import ButtonStateTracker
-
-ButtonEvent = car.CarState.ButtonEvent
-ButtonType = car.CarState.ButtonEvent.Type
-
-
-class TestButtonStateTracker:
-  def setup_method(self) -> None:
-    self.tracker = ButtonStateTracker()
-
-  def make_cs(self, events: list) -> car.CarState:
-    CS = car.CarState()
-    CS.buttonEvents = events
-    return CS
-
-  def test_initial_state(self) -> None:
-    assert self.tracker.pressed == 0
-    assert self.tracker.release_toggle == 0
-
-  def test_press_sets_bit(self) -> None:
-    self.tracker.update(self.make_cs([ButtonEvent(type=ButtonType.accelCruise, pressed=True)]))
-    assert self.tracker.pressed == (1 << ButtonType.accelCruise)
-    assert self.tracker.release_toggle == 0
-
-  def test_release_clears_and_toggles(self) -> None:
-    self.tracker.update(self.make_cs([ButtonEvent(type=ButtonType.accelCruise, pressed=True)]))
-    self.tracker.update(self.make_cs([ButtonEvent(type=ButtonType.accelCruise, pressed=False)]))
-    assert self.tracker.pressed == 0
-    assert self.tracker.release_toggle == (1 << ButtonType.accelCruise)
-
-  def test_multiple_buttons(self) -> None:
-    self.tracker.update(self.make_cs([
-      ButtonEvent(type=ButtonType.accelCruise, pressed=True),
-      ButtonEvent(type=ButtonType.decelCruise, pressed=True),
-    ]))
-    assert self.tracker.pressed == (1 << ButtonType.accelCruise) | (1 << ButtonType.decelCruise)
-
-    self.tracker.update(self.make_cs([ButtonEvent(type=ButtonType.accelCruise, pressed=False)]))
-    assert self.tracker.pressed == (1 << ButtonType.decelCruise)
-    assert self.tracker.release_toggle == (1 << ButtonType.accelCruise)
-
-  def test_release_toggle_flips(self) -> None:
-    for _ in range(2):
-      self.tracker.update(self.make_cs([ButtonEvent(type=ButtonType.gapAdjustCruise, pressed=True)]))
-      self.tracker.update(self.make_cs([ButtonEvent(type=ButtonType.gapAdjustCruise, pressed=False)]))
-    assert self.tracker.release_toggle == 0
-
-  def test_publish(self) -> None:
-    self.tracker.update(self.make_cs([ButtonEvent(type=ButtonType.accelCruise, pressed=True)]))
-    self.tracker.update(self.make_cs([ButtonEvent(type=ButtonType.decelCruise, pressed=True)]))
-    self.tracker.update(self.make_cs([ButtonEvent(type=ButtonType.accelCruise, pressed=False)]))
-
-    class MockSP:
-      buttonsPressed = 0
-      buttonsReleaseToggle = 0
-
-    sp = MockSP()
-    self.tracker.publish(sp)
-    assert sp.buttonsPressed == self.tracker.pressed
-    assert sp.buttonsReleaseToggle == self.tracker.release_toggle
--- a/Show More
+++ b/Show More