ramp after stop

fede with speed
ref
2026-11-09 13:53:43 +08:00 · 2026-11-08 14:10:02 -07:00 · 2026-11-07 10:49:54 -07:00 · 2026-11-05 13:31:28 -07:00 · 2026-11-05 13:31:28 -07:00 · 2026-11-05 11:28:47 -07:00
51 changed files with 872 additions and 671 deletions
@@ -34,11 +34,6 @@ on:
        required: false
        type: string
        default: 'qcom'
-      on_device:
-        description: 'Compile on the tici / chestnut runner instead of on a hosted runner with tinygrad''s qcom / amd mock'
-        required: false
-        type: boolean
-        default: false
      hf_repo:
        description: 'Hugging Face dataset repository (e.g. sunnypilot/sunnypilot_models_v1)'
        required: false
@@ -112,11 +107,6 @@ on:
        options:
          - qcom
          - chestnut
-      on_device:
-        description: 'Compile on the tici / chestnut runner instead of on a hosted runner with tinygrad''s qcom / amd mock'
-        required: false
-        type: boolean
-        default: false
      hf_repo:
        description: 'Hugging Face dataset repository'
        required: false
@@ -140,7 +130,6 @@ jobs:
      is_20hz: ${{ inputs.is_20hz }}
      artifact_suffix: ${{ inputs.artifact_suffix }}
      target_hardware: ${{ inputs.target_hardware }}
-      on_device: ${{ inputs.on_device || false }}
    secrets: inherit

  publish_model:
@@ -1,61 +0,0 @@
-name: Chestnut mock build parity
-description: >-
-  Convert one commaai precompiled chestnut model (LS2) on this runner under tinygrad's amd mock, as a hosted chestnut build does, and require the
-  exact bytes the chestnut runner built (the published artifact). Needs setup-amd-mock, numpy and zstandard; tinygrad_repo checked out.
-runs:
-  using: composite
-  steps:
-    - name: Key this check by everything its result depends on
-      id: key
-      shell: bash
-      env:
-        SOURCES: ${{ hashFiles('tinygrad_repo/tinygrad/**/*.py', 'tinygrad_repo/test/mockgpu/**', 'openpilot/sunnypilot/modeld_v2/*.py', '.github/workflows/chestnut-build-parity/action.yml') }}
-      run: echo "key=chestnut-build-parity-$SOURCES-$(sha256sum "$LLVM_PATH" | cut -c1-16)-$(python3 -c 'import platform; print(platform.python_version())')" >> "$GITHUB_OUTPUT"
-
-    - name: Passed before with all of it identical?
-      id: passed
-      uses: actions/cache/restore@v4
-      with:
-        path: ~/.chestnut_build_parity.passed
-        key: ${{ steps.key.outputs.key }}
-
-    - name: Rebuild LS2 on the mock and require the chestnut runner's artifact byte for byte
-      if: steps.passed.outputs.cache-hit != 'true'
-      shell: bash
-      env:
-        REF: b92fc4828664f8767bce5e92f1630ed319cbe509  # commaai/openpilot: precompiled big_driving_tinygrad.pkl, pins tinygrad ec91b74b5b
-        PKL_OID: b4dead3ee091d66ab002a6b8e716c26f4f79e3c931e4be5f48e017ba92f6e960
-        PKL_SIZE: "767228907"
-        TG_SHA: ec91b74b5b6b0fc924b72d3f27689679ca2438b9
-        WANT: 680a8d629785f2b1d1a2b0e40d0dfbcd0f7291c21e20c51259f1d768a22ec217  # driving_light_speed_2_november_04_2026_tinygrad.pkl, recompiled46
-      run: |
-        set -euo pipefail
-        work="$RUNNER_TEMP/chestnut_parity" && rm -rf "$work" && mkdir -p "$work"
-        href=$(curl -fsSL --retry 3 -X POST -H "Accept: application/vnd.git-lfs+json" -H "Content-Type: application/vnd.git-lfs+json" \
-          https://huggingface.co/commaai/openpilot-lfs.git/info/lfs/objects/batch \
-          -d "{\"operation\":\"download\",\"transfer\":[\"basic\"],\"objects\":[{\"oid\":\"$PKL_OID\",\"size\":$PKL_SIZE}]}" | jq -r '.objects[0].actions.download.href')
-        curl -fsSL --retry 3 -o "$work/big_driving_tinygrad.pkl" "$href"
-        echo "$PKL_OID  $work/big_driving_tinygrad.pkl" | sha256sum -c -
-        tg="$work/tinygrad" && git init -q "$tg" && git -C "$tg" fetch -q --depth 1 https://github.com/tinygrad/tinygrad "$TG_SHA" && git -C "$tg" checkout -q FETCH_HEAD
-        CHECK_OOB=0 GMMU=0 PYTHONPATH="$GITHUB_WORKSPACE/tinygrad_repo" python3 tinygrad_repo/test/mockgpu/usb_server.py \
-          env DEV=USB+AMD PYTHONPATH="$tg:$GITHUB_WORKSPACE" python3 openpilot/sunnypilot/modeld_v2/convert_upstream_pkl.py "$work/big_driving_tinygrad.pkl" "$work/LS2.pkl"
-        got=$(sha256sum "$work/LS2.pkl" | cut -d' ' -f1)
-        if [ "$got" != "$WANT" ]; then
-          echo "::error::the mock's LS2 build ($got) is not the chestnut runner's ($WANT): this runner's LLVM or the mock no longer builds what the chestnut does"
-          exit 1
-        fi
-        echo "LS2 rebuilt on the mock: byte-identical to the chestnut runner's build"
-        touch ~/.chestnut_build_parity.passed
-
-    - name: Remember the pass
-      if: steps.passed.outputs.cache-hit != 'true'
-      uses: actions/cache/save@v4
-      with:
-        path: ~/.chestnut_build_parity.passed
-        key: ${{ steps.key.outputs.key }}
-
-    - name: Already passed
-      if: steps.passed.outputs.cache-hit == 'true'
-      shell: bash
-      run: |
-        echo "LS2 rebuild skipped: it already matched the chestnut runner's build with this exact mock, converter, LLVM and python"
@@ -1,60 +0,0 @@
-name: Set up tinygrad's amd mock
-description: LLVM 20 and ROCm comgr, as tinygrad_repo/.github/actions/setup-tinygrad installs them for the mock gpu
-inputs:
-  emu_cache:
-    description: >-
-      Keep tinygrad's cache db (the emulator's compiled kernels and gate results) between runs under this name, e.g. the model's file name.
-      Empty: no cache.
-    default: ''
-runs:
-  using: composite
-  steps:
-    - name: Install LLVM 20 and ROCm comgr
-      shell: bash
-      run: |
-        . /etc/os-release
-        curl -fsSL https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc > /dev/null
-        echo "deb http://apt.llvm.org/$VERSION_CODENAME/ llvm-toolchain-$VERSION_CODENAME-20 main" | sudo tee /etc/apt/sources.list.d/llvm.list
-        sudo mkdir -p /etc/apt/keyrings
-        curl -fsSL https://repo.radeon.com/rocm/rocm.gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/rocm.gpg > /dev/null
-        echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/rocm.gpg] https://repo.radeon.com/rocm/apt/7.1 $VERSION_CODENAME main" | sudo tee /etc/apt/sources.list.d/rocm.list
-        printf 'Package: *\nPin: release o=repo.radeon.com\nPin-Priority: 600\n' | sudo tee /etc/apt/preferences.d/rocm-pin-600
-        sudo apt-get -qq update && sudo apt-get -qq install -y --no-install-recommends libllvm20 clang-20 lld-20 comgr
-        printf '/opt/rocm/lib\n/opt/rocm/lib64\n' | sudo tee /etc/ld.so.conf.d/rocm.conf && sudo ldconfig
-        echo "/usr/lib/llvm-20/bin" >> "$GITHUB_PATH"
-        llvm=$(ls /usr/lib/llvm-20/lib/libLLVM*.so* /usr/lib/*-linux-gnu/libLLVM-20.so* 2>/dev/null | head -1 || true)
-        [ -n "$llvm" ] || { echo "::error::libLLVM 20 not found"; exit 1; }
-        echo "LLVM_PATH=$llvm" >> "$GITHUB_ENV"
-
-    - name: Cache the chestnut's firmware
-      uses: actions/cache@v4
-      with:
-        path: ~/.cache/tinygrad/downloads/fw
-        key: chestnut-fw-${{ hashFiles('tinygrad_repo/tinygrad/runtime/autogen/am/fw.py') }}
-
-    - name: Fetch the chestnut's firmware (gitlab times out now and then; the mock boots from it)
-      shell: bash
-      run: |
-        for i in 1 2 3 4 5; do
-          PYTHONPATH="$GITHUB_WORKSPACE/tinygrad_repo" python3 -c "
-        from tinygrad.helpers import fetch_fw
-        from tinygrad.runtime.autogen.am import fw
-        for n, h in fw.hashes.items():
-          if n.startswith(('psp_14_0_2_', 'smu_14_0_2.', 'sdma_7_0_0.', 'gc_12_0_0_')): fetch_fw('amdgpu', n, h)" && exit 0
-          sleep $((i * 10))
-        done
-        echo "::error::could not fetch the chestnut's firmware from gitlab"; exit 1
-
-    - name: runner cpu
-      if: inputs.emu_cache != ''
-      id: cpu
-      shell: bash
-      run: echo "cpu=$( (grep -m1 '^model name' /proc/cpuinfo; grep -m1 '^flags' /proc/cpuinfo) | sha256sum | cut -c1-16)" >> "$GITHUB_OUTPUT"
-
-    - name: Keep the emulator's compiled kernels between runs
-      if: inputs.emu_cache != ''
-      uses: actions/cache@v4
-      with:
-        path: ~/.cache/tinygrad/cache.db
-        key: emu-${{ steps.cpu.outputs.cpu }}-${{ hashFiles('tinygrad_repo/tinygrad/**/*.py', 'tinygrad_repo/test/mockgpu/**') }}-${{ inputs.emu_cache }}
-        restore-keys: emu-${{ steps.cpu.outputs.cpu }}-${{ hashFiles('tinygrad_repo/tinygrad/**/*.py', 'tinygrad_repo/test/mockgpu/**') }}-
@@ -35,11 +35,6 @@ on:
        required: false
        type: string
        default: 'qcom'
-      on_device:
-        description: 'Compile on the tici / chestnut runner instead of on a hosted runner with tinygrad''s qcom / amd mock'
-        required: false
-        type: boolean
-        default: false
  workflow_dispatch:
    inputs:
      upstream_branch:
@@ -64,11 +59,6 @@ on:
          - qcom
          - chestnut
        default: 'qcom'
-      on_device:
-        description: 'Compile on the tici / chestnut runner instead of on a hosted runner with tinygrad''s qcom / amd mock'
-        required: false
-        type: boolean
-        default: false


 run-name: Build model [${{ inputs.custom_name || inputs.upstream_branch }}] from ref [${{ inputs.upstream_branch }}]
@@ -163,67 +153,18 @@ jobs:
          if-no-files-found: error

  build_model:
-    runs-on: ${{ inputs.on_device && fromJSON(inputs.target_hardware == 'chestnut' && '["self-hosted","chestnut"]' || '["self-hosted","tici"]') || 'ubuntu-24.04' }}
+    runs-on: [self-hosted, "${{ inputs.target_hardware == 'chestnut' && 'chestnut' || 'tici' }}"]
    needs: get_model
    env:
      MODEL_NAME: ${{ inputs.custom_name || inputs.upstream_branch }} (${{ needs.get_model.outputs.model_date }})
      REF: ${{ inputs.upstream_branch }}
-      MOCK_BUILD: ${{ !inputs.on_device }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 1
          submodules: recursive

-      - name: Set up the hosted mock build
-        if: env.MOCK_BUILD == 'true'
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-
-      - name: Install LLVM 20 and ROCm comgr for the amd mock
-        if: env.MOCK_BUILD == 'true' && inputs.target_hardware == 'chestnut'
-        uses: ./.github/workflows/setup-amd-mock
-        with:
-          emu_cache: build
-
-      - name: Install the amd mock build dependencies
-        if: env.MOCK_BUILD == 'true' && inputs.target_hardware == 'chestnut'
-        run: |
-          python3 -m pip install -q numpy zstandard
-
-      - name: Install the qcom mock build dependencies
-        if: env.MOCK_BUILD == 'true' && inputs.target_hardware != 'chestnut'
-        id: qcom_deps
-        run: |
-          sudo apt-get -qq update && sudo apt-get -qq install -y --no-install-recommends qemu-user-static aria2
-          python3 -m pip install -q numpy zstandard tinymesa==25.2.7.2
-          echo "qemu=$(dpkg-query -W -f='${Version}' qemu-user-static)" >> "$GITHUB_OUTPUT"
-
-      - name: Compiler check passed before with all of it identical?
-        if: env.MOCK_BUILD == 'true' && inputs.target_hardware != 'chestnut'
-        id: qcom_compiler
-        uses: actions/cache/restore@v4
-        with:
-          path: ~/.qcom_compiler_parity.passed
-          key: qcom-compiler-parity-${{ steps.qcom_deps.outputs.qemu }}-${{ hashFiles('tinygrad_repo/test/device/qcom/compiler_parity.py', 'tinygrad_repo/test/mockgpu/qcom/a630_compiled.pkl.xz', 'tinygrad_repo/tinygrad/runtime/support/compiler_qcom.py') }}
-
-      - name: Check the off-device qcom compiler builds the a630's bytes
-        if: env.MOCK_BUILD == 'true' && inputs.target_hardware != 'chestnut' && steps.qcom_compiler.outputs.cache-hit != 'true'
-        run: |
-          # every kernel an a630 has compiled must compile to the same bytes here before a model is built here
-          PYTHONPATH="$TINYGRAD_PATH" python3 "$TINYGRAD_PATH/test/device/qcom/compiler_parity.py" check "$TINYGRAD_PATH/test/mockgpu/qcom/a630_compiled.pkl.xz"
-          touch ~/.qcom_compiler_parity.passed
-
-      - name: Remember the compiler check passed
-        if: env.MOCK_BUILD == 'true' && inputs.target_hardware != 'chestnut' && steps.qcom_compiler.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v4
-        with:
-          path: ~/.qcom_compiler_parity.passed
-          key: ${{ steps.qcom_compiler.outputs.cache-primary-key }}
-
      - name: Set environment variables
-        if: env.MOCK_BUILD != 'true'
        id: set-env
        run: |
          # Set up common environment
@@ -236,7 +177,6 @@ jobs:
          printenv >> $GITHUB_ENV

      - name: Setup build environment
-        if: env.MOCK_BUILD != 'true'
        run: |
          mkdir -p "${BUILD_DIR}/"
          sudo find $BUILD_DIR/ -mindepth 1 -delete
@@ -258,28 +198,21 @@ jobs:

      - name: Build Model
        run: |
-          if [ "$MOCK_BUILD" = "true" ]; then
-            TASKSET=""
-            export CHECK_OOB=0 GMMU=0  # as test/mockgpu runs the amd mock
-          else
-            source /etc/profile
-            export UV_PROJECT_ENVIRONMENT=${HOME}/venv
-            export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
-            source ${UV_PROJECT_ENVIRONMENT}/bin/activate
-            TASKSET="taskset -c 7"
-          fi
+          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}')")

-          MOCK=$([ "$MOCK_BUILD" = "true" ] && echo MOCK || true)
-          TG_FLAGS_QCOM="DEV=${MOCK:+MOCK+}QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 OPENPILOT_HACKS=1"
+          TG_FLAGS_QCOM="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 OPENPILOT_HACKS=1"
          if [ "${{ inputs.target_hardware }}" == "chestnut" ]; then
            echo "CHESTNUT build"
            export CHESTNUT=1
-            TG_FLAGS="DEBUG=1 DEV=${MOCK}USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 GMMU=0 TC_OPT=2 TC_MIN_GLOBALS=32"
+            TG_FLAGS="DEBUG=1 DEV=USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 GMMU=0 TC_OPT=2 TC_MIN_GLOBALS=32"
            OUTPUT_PKL="${{ env.MODELS_DIR }}/big_driving_tinygrad.pkl"
          else
            echo "QCOM build"
@@ -294,16 +227,14 @@ jobs:
            echo "Converting commaai's precompiled model with tinygrad $TG_SHA"
            UPSTREAM_TG="${{ runner.temp }}/upstream_tinygrad"
            rm -rf "$UPSTREAM_TG" && git init -q "$UPSTREAM_TG" && git -C "$UPSTREAM_TG" fetch -q --depth 1 "$TG_URL" "$TG_SHA" && git -C "$UPSTREAM_TG" checkout -q FETCH_HEAD
-            ON_MOCK=""
-            if [ "$MOCK_BUILD" = "true" ]; then ON_MOCK="env PYTHONPATH=$TINYGRAD_PATH python3 $TINYGRAD_PATH/test/mockgpu/usb_server.py"; fi
            CONVERTED="${{ runner.temp }}/big_driving_tinygrad_plain.pkl"
-            $ON_MOCK env DEV=USB+AMD PYTHONPATH="$UPSTREAM_TG:${{ github.workspace }}" $TASKSET python3 openpilot/sunnypilot/modeld_v2/convert_upstream_pkl.py \
+            env DEV=USB+AMD PYTHONPATH="$UPSTREAM_TG:${{ github.workspace }}" taskset -c 7 python3 openpilot/sunnypilot/modeld_v2/convert_upstream_pkl.py \
              "${{ env.MODELS_DIR }}/big_driving_tinygrad.pkl" "$CONVERTED"
            mv "$CONVERTED" "$OUTPUT_PKL"
          elif NEW_ARCH_ONNX=$(find "${{ env.MODELS_DIR }}" -maxdepth 1 -name "${{ inputs.target_hardware == 'chestnut' && 'big_' || '' }}*driving*.onnx" -print -quit) &&
               [ -n "$NEW_ARCH_ONNX" ] && grep -qa new_img "$NEW_ARCH_ONNX"; then # the new architecture: one ONNX taking the warped frames as new_img
            echo "Compiling new architecture ONNX: $NEW_ARCH_ONNX"
-            env ${TG_FLAGS} $TASKSET python3 openpilot/sunnypilot/modeld_v2/compile_modeld_v2.py \
+            env ${TG_FLAGS} taskset -c 7 python3 openpilot/sunnypilot/modeld_v2/compile_modeld_v2.py \
              "$NEW_ARCH_ONNX" "$OUTPUT_PKL" --device-input "*" --benchmark-runs 1
          else
            echo "Detected onnx architecture. Routing to native compile_modeld.py."
@@ -353,7 +284,7 @@ jobs:

            if [ -n "$MODEL_TYPE" ]; then
              echo "Detected: $MODEL_TYPE -> $OUTPUT_PKL"
-              env ${TG_FLAGS} $TASKSET python3 "$COMPILE_MODELD" \
+              env ${TG_FLAGS} taskset -c 7 python3 "$COMPILE_MODELD" \
                --model-type $MODEL_TYPE \
                --model-size $MODEL_SIZE \
                --camera-resolutions $CAMERA_RES \
@@ -362,13 +293,6 @@ jobs:
            fi
          fi

-      - name: Replay its check frame on the mock and require the result bit for bit
-        if: env.MOCK_BUILD == 'true'
-        env:
-          DEV: ${{ inputs.target_hardware == 'chestnut' && 'MOCKUSB+AMD' || 'MOCK+QCOM' }}
-          PYTHONPATH: ${{ env.TINYGRAD_PATH }}:${{ github.workspace }}
-        run: python3 -m openpilot.sunnypilot.modeld_v2.mock_parity check "${{ env.MODELS_DIR }}/${{ inputs.target_hardware == 'chestnut' && 'big_' || '' }}driving_tinygrad.pkl"
-
      - name: Prepare Output
        run: |
          sudo rm -rf ${{ env.OUTPUT_DIR }}
@@ -380,7 +304,7 @@ jobs:
            --include='/${{ inputs.target_hardware == 'chestnut' && 'big_' || '' }}driving_tinygrad.pkl' \
            --exclude='*' \
            --delete-excluded \
-            $([ "$MOCK_BUILD" = "true" ] || echo --chown=comma:comma) \
+            --chown=comma:comma \
            ${{ env.MODELS_DIR }}/ ${{ env.OUTPUT_DIR }}/

          python3 "${{ github.workspace }}/release/ci/model_generator.py" \
@@ -409,7 +333,7 @@ jobs:
          path: ${{ env.OUTPUT_DIR }}/artifact_name.txt

      - name: Re-enable powersave
-        if: always() && env.MOCK_BUILD != 'true'
+        if: always()
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --enable
@@ -28,30 +28,24 @@ jobs:
        env:
          DEV: CPU
        run: tools/op.sh test -v openpilot/sunnypilot/modeld_v2/tests/test_plain_artifact.py
-      - uses: ./.github/workflows/setup-amd-mock
+      - name: Install LLVM 20 and ROCm comgr for the amd mock, as tinygrad_repo/.github/actions/setup-tinygrad does
+        run: |
+          . /etc/os-release
+          curl -fsSL https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc > /dev/null
+          echo "deb http://apt.llvm.org/$VERSION_CODENAME/ llvm-toolchain-$VERSION_CODENAME-20 main" | sudo tee /etc/apt/sources.list.d/llvm.list
+          sudo mkdir -p /etc/apt/keyrings
+          curl -fsSL https://repo.radeon.com/rocm/rocm.gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/rocm.gpg > /dev/null
+          echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/rocm.gpg] https://repo.radeon.com/rocm/apt/7.1 $VERSION_CODENAME main" | sudo tee /etc/apt/sources.list.d/rocm.list
+          printf 'Package: *\nPin: release o=repo.radeon.com\nPin-Priority: 600\n' | sudo tee /etc/apt/preferences.d/rocm-pin-600
+          sudo apt-get -qq update && sudo apt-get -qq install -y --no-install-recommends libllvm20 clang-20 lld-20 comgr
+          printf '/opt/rocm/lib\n/opt/rocm/lib64\n' | sudo tee /etc/ld.so.conf.d/rocm.conf && sudo ldconfig
+          echo "/usr/lib/llvm-20/bin" >> "$GITHUB_PATH"
      - name: Convert a pickled USB+AMD jit and replay it under tinygrad's amd mock
        env:
          DEV: MOCKUSB+AMD
          CHECK_OOB: 0
          GMMU: 0
        run: tools/op.sh test -v openpilot/sunnypilot/modeld_v2/tests/test_convert_upstream_pkl.py
-      - name: Resolve commaai's tinygrad pin, which their precompiled chestnut model is built and converted with
-        id: upstream-tg
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          read -r sha url < <(gh api repos/commaai/openpilot/contents/tinygrad_repo --jq '.sha + " " + .submodule_git_url')
-          echo "commaai/openpilot master pins $url@$sha, ours is $(git rev-parse HEAD:tinygrad_repo)"
-          dir="$RUNNER_TEMP/upstream_tinygrad"
-          git init -q "$dir" && git -C "$dir" fetch -q --depth 1 "$url" "$sha" && git -C "$dir" checkout -q FETCH_HEAD
-          echo "path=$dir" >> "$GITHUB_OUTPUT"
-      - name: Convert a pickled USB+AMD jit under commaai's tinygrad, as the chestnut model build does
-        env:
-          DEV: MOCKUSB+AMD
-          CHECK_OOB: 0
-          GMMU: 0
-          PYTHONPATH: ${{ steps.upstream-tg.outputs.path }}:${{ github.workspace }}
-        run: tools/op.sh test -v openpilot/sunnypilot/modeld_v2/tests/test_convert_upstream_pkl.py
      - name: Where tinygrad moved, for the helper or failure point named above
        if: failure() && github.event_name == 'pull_request'
        run: |
@@ -69,8 +63,6 @@ jobs:
    runs-on: ubuntu-latest
    outputs:
      models: ${{ steps.set-matrix.outputs.models }}
-      chestnut: ${{ steps.set-matrix.outputs.chestnut }}
-      qcom: ${{ steps.set-matrix.outputs.qcom }}
    steps:
      - uses: actions/checkout@v4
      - name: Fetch and Parse json
@@ -82,22 +74,16 @@ jobs:
          with open("openpilot/sunnypilot/models/fetcher.py", "r") as f:
            urls = re.findall(r"MODEL_URL(?:_CHESTNUT)?\s*=\s*[\"'"'"']([^\"'"'"']+)[\"'"'"']", f.read())

-          artifacts, chestnut, qcom = [], [], []
+          artifacts = []
          for url in urls:
            data = json.loads(urllib.request.urlopen(url).read())
            for bundle in data.get("bundles", []):
              for model in bundle.get("models", []):
                if "artifact" in model:
                  artifacts.append(model["artifact"])
-                  if "chestnut" in url:
-                    chestnut.append(model["artifact"])
-                  elif "tinygrad" in model["artifact"]["file_name"]:
-                    qcom.append(model["artifact"])

          with open(os.environ["GITHUB_OUTPUT"], "a") as f:
            f.write(f"models={json.dumps(artifacts)}\n")
-            f.write(f"chestnut={json.dumps(chestnut)}\n")
-            f.write(f"qcom={json.dumps(qcom)}\n")
          '

  test-model:
@@ -134,81 +120,3 @@ jobs:
          export PYTHONPATH="$GITHUB_WORKSPACE/tinygrad_repo:$GITHUB_WORKSPACE:$PYTHONPATH"
          python3 -m pip uninstall -y tinygrad || uv pip uninstall -y tinygrad --system || true
          python3 -m pytest openpilot/sunnypilot/modeld_v2/tests/test_models.py
-
-  chestnut-mock-parity:
-    name: Mock parity ${{ matrix.artifact.file_name }}
-    needs: generate-matrix
-    runs-on: ubuntu-24.04
-    strategy:
-      fail-fast: false
-      matrix:
-        artifact: ${{ fromJson(needs.generate-matrix.outputs.chestnut) }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-      - uses: ./.github/workflows/setup-amd-mock
-        with:
-          emu_cache: ${{ matrix.artifact.file_name }}
-      - run: python3 -m pip install -q numpy
-      - name: Download model
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-          MODEL_URL: ${{ matrix.artifact.download_uri.url }}
-          MODEL_SHA: ${{ matrix.artifact.download_uri.sha256 }}
-        shell: bash
-        run: |
-          AUTH=()
-          if [ -n "$HF_TOKEN" ]; then AUTH=(-H "Authorization: Bearer $HF_TOKEN"); fi
-          curl --retry 3 --retry-all-errors -s -S -f -L "${AUTH[@]}" -o "$RUNNER_TEMP/model.pkl" "$MODEL_URL"
-          if [ -n "$MODEL_SHA" ]; then echo "$MODEL_SHA  $RUNNER_TEMP/model.pkl" | sha256sum -c -; fi
-      - name: Replay its check frame on the amd mock and require the chestnut's result bit for bit
-        env:
-          PYTHONPATH: ${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}
-        run: python3 -m openpilot.sunnypilot.modeld_v2.mock_parity check "$RUNNER_TEMP/model.pkl"
-
-  qcom-mock-parity:
-    name: QCOM mock parity ${{ matrix.artifact.file_name }}
-    needs: generate-matrix
-    runs-on: ubuntu-24.04
-    strategy:
-      fail-fast: false
-      matrix:
-        artifact: ${{ fromJson(needs.generate-matrix.outputs.qcom) }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-      - run: python3 -m pip install -q numpy tinymesa==25.2.7.2
-      - name: Download model
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-          MODEL_URL: ${{ matrix.artifact.download_uri.url }}
-          MODEL_SHA: ${{ matrix.artifact.download_uri.sha256 }}
-        shell: bash
-        run: |
-          AUTH=()
-          if [ -n "$HF_TOKEN" ]; then AUTH=(-H "Authorization: Bearer $HF_TOKEN"); fi
-          curl --retry 3 --retry-all-errors -s -S -f -L "${AUTH[@]}" -o "$RUNNER_TEMP/model.pkl" "$MODEL_URL"
-          if [ -n "$MODEL_SHA" ]; then echo "$MODEL_SHA  $RUNNER_TEMP/model.pkl" | sha256sum -c -; fi
-      - name: Replay its check frame on the qcom mock and require the comma device's result bit for bit
-        env:
-          DEV: MOCK+QCOM
-          PYTHONPATH: ${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}
-        run: python3 -m openpilot.sunnypilot.modeld_v2.mock_parity check "$RUNNER_TEMP/model.pkl"
-
-  chestnut-mock-build-parity:
-    name: Chestnut build on the amd mock = chestnut runner build
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-      - uses: ./.github/workflows/setup-amd-mock
-        with:
-          emu_cache: chestnut-build-parity
-      - run: python3 -m pip install -q numpy zstandard
-      - uses: ./.github/workflows/chestnut-build-parity
@@ -4,6 +4,7 @@
 [submodule "opendbc"]
  path = opendbc_repo
  url = https://github.com/sunnypilot/opendbc.git
+  branch = toyotabsmhack
 [submodule "msgq"]
  path = msgq_repo
  url = https://github.com/sunnypilot/msgq.git
@@ -369,6 +369,7 @@ struct CarParamsSP @0x80ae746ee2596b11 {
  pcmCruiseSpeed @3 :Bool;
  intelligentCruiseButtonManagementAvailable @4 :Bool;
  enableGasInterceptor @5 :Bool;
+  smoothStopDecelRate @6 :Float32;

  neuralNetworkLateralControl @2 :NeuralNetworkLateralControl;

@@ -150,6 +150,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {

    // --- sunnypilot params --- //
    {"AccelBoostSP", {PERSISTENT | BACKUP, BOOL, "1"}},
+    {"SmoothStopSP", {PERSISTENT | BACKUP, BOOL, "1"}},
    {"ApiCache_DriveStats", {PERSISTENT, JSON}},
    {"AutoLaneChangeBsmDelay", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"AutoLaneChangeTimer", {PERSISTENT | BACKUP, INT, "0"}},
@@ -200,6 +201,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"ShowAdvancedControls", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"ShowTurnSignals", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"StandstillTimer", {PERSISTENT | BACKUP, BOOL, "0"}},
+    {"TripSummary", {PERSISTENT | BACKUP, BOOL, "1"}},
    {"TrueVEgoUI", {PERSISTENT | BACKUP, BOOL, "0"}},

    // MADS params
@@ -245,6 +247,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"SubaruStopAndGoManualParkingBrake", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"TeslaCoopSteering", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"TeslaMadsScreenButton", {PERSISTENT | BACKUP, INT, "0"}},
+    {"ToyotaEnhancedBsm", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"ToyotaEnforceStockLongitudinal", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"ToyotaStopAndGoHack", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"ToyotaTSS2Smooth", {PERSISTENT | BACKUP, BOOL, "0"}},
@@ -57,6 +57,7 @@ class Controls(ControlsExt):
    self.calibrated_pose: Pose | None = None

    self.LoC = LongControl(self.CP, self.CP_SP)
+    self.LoC = ControlsExt.initialize_longitudinal_control(self, self.LoC)
    self.VM = VehicleModel(self.CP)
    self.LaC: LatControl
    if self.CP.steerControlType == car.CarParams.SteerControlType.angle:
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fbbb4c07c0de022af7b28c60ca34794b9326825375da37af6ae463c2fee4961e
-size 83124285
+oid sha256:65a08adc31d5c456219687d99b7bf5e44d61dae2d49ea67850e76105c7248cce
+size 60918562
@@ -10,6 +10,7 @@ from openpilot.selfdrive.ui.onroad.augmented_road_view import AugmentedRoadView
 from openpilot.selfdrive.ui.ui_state import device, ui_state
 from openpilot.selfdrive.ui.layouts.onboarding import OnboardingWindow
 from openpilot.selfdrive.ui.body.layouts.onroad import BodyLayout
+from openpilot.selfdrive.ui.sunnypilot.layouts.trip_summary import TripSummary

 if gui_app.sunnypilot_ui():
  from openpilot.selfdrive.ui.sunnypilot.layouts.settings.settings import SettingsLayoutSP as SettingsLayout
@@ -31,6 +32,7 @@ class MainLayout(Widget):
    self._sidebar = Sidebar()
    self._current_mode = MainState.HOME
    self._prev_onroad = False
+    self._trip_summary = TripSummary()

    # Initialize layouts
    self._home_layout = HomeLayout()
@@ -10,6 +10,7 @@ from openpilot.selfdrive.ui.body.layouts.onroad import BodyLayout
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.scroller import Scroller
 from openpilot.system.ui.lib.application import gui_app
+from openpilot.selfdrive.ui.sunnypilot.layouts.trip_summary import TripSummary

 if gui_app.sunnypilot_ui():
  from openpilot.selfdrive.ui.sunnypilot.mici.layouts.settings import SettingsLayoutSP as SettingsLayout
@@ -57,6 +58,7 @@ class MiciMainLayout(Scroller):
    self._setup_callbacks()

    gui_app.add_nav_stack_tick(self._handle_transitions)
+    self._trip_summary = TripSummary()
    gui_app.push_widget(self)

    # Start onboarding if terms or training not completed, make sure to push after self
@@ -22,6 +22,7 @@ from openpilot.common.transformations.orientation import rot_from_euler
 from enum import IntEnum

 if gui_app.sunnypilot_ui():
+  from openpilot.selfdrive.ui.sunnypilot.mici.onroad.augmented_road_view import AugmentedRoadViewSP
  from openpilot.selfdrive.ui.sunnypilot.mici.onroad.hud_renderer import HudRendererSP as HudRenderer
  from openpilot.selfdrive.ui.sunnypilot.ui_state import OnroadTimerStatus

@@ -156,9 +157,10 @@ class BookmarkIcon(Widget):
        rl.draw_texture_ex(icon, rl.Vector2(icon_x, icon_y), 0.0, 1.0, rl.Color(255, 255, 255, round(255 * alpha)))


-class AugmentedRoadView(CameraView):
+class AugmentedRoadView(CameraView, AugmentedRoadViewSP):
  def __init__(self, bookmark_callback=None, stream_type: VisionStreamType = VisionStreamType.VISION_STREAM_NARROW_ROAD):
    super().__init__("camerad", stream_type)
+    AugmentedRoadViewSP.__init__(self)
    self._bookmark_callback = bookmark_callback
    self._set_placeholder_color(rl.BLACK)

@@ -275,7 +277,7 @@ class AugmentedRoadView(CameraView):
    if show_navigation:
      self._navigation.render(rl.Rectangle(self._content_rect.x + self._content_rect.width, self.rect.y, PANEL_WIDTH, self.rect.height))
    else:
-      self._confidence_ball.render(self.rect)
+      AugmentedRoadViewSP.render_side_panel(self, self.rect)

    self._bookmark_icon.render(self.rect)

@@ -63,6 +63,13 @@ class CruiseLayout(Widget):
                     "Eases off in curves and when sunnypilot slows or stops. Never goes past your set speed, and lead-car following still comes first."),
      param="AccelBoostSP")

+    self.smooth_stop_toggle = toggle_item_sp(
+      title=tr("Smooth Stop"),
+      description=tr("Brakes gently as sunnypilot comes to a final stop to reduce the lurch at the end. " +
+                     "Applies to all vehicles with sunnypilot longitudinal control."),
+      param="SmoothStopSP",
+      callback=lambda _: ui_state.params.put_bool("OnroadCycleRequested", True))
+
    self.custom_acc_toggle = toggle_item_sp(
      title=tr("Custom ACC Speed Increments"),
      description="",
@@ -93,6 +100,7 @@ class CruiseLayout(Widget):
      self.scc_v_toggle,
      self.scc_m_toggle,
      self.accel_boost_toggle,
+      self.smooth_stop_toggle,
      self.custom_acc_toggle,
      self.custom_acc_short_increment,
      self.custom_acc_long_increment,
@@ -144,6 +152,7 @@ class CruiseLayout(Widget):
          self.icbm_toggle.show_description(True)

      self.accel_boost_toggle.action_item.set_enabled(has_long)
+      self.smooth_stop_toggle.action_item.set_enabled(has_long and not ui_state.engaged)

      if has_long or has_icbm:
        self.custom_acc_toggle.action_item.set_enabled(((has_long and not ui_state.CP.pcmCruise) or has_icbm) and ui_state.is_offroad())
@@ -161,6 +170,7 @@ class CruiseLayout(Widget):
      has_icbm = has_long = False
      self.icbm_toggle.action_item.set_enabled(False)
      self.accel_boost_toggle.action_item.set_enabled(False)
+      self.smooth_stop_toggle.action_item.set_enabled(False)
      self.icbm_toggle.set_description(tr(ONROAD_ONLY_DESCRIPTION))

    show_custom_acc_desc = False
@@ -12,10 +12,16 @@ from openpilot.system.ui.widgets import DialogResult
 from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
 from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp
 from opendbc.car.toyota.values import ToyotaFlags
+from opendbc.sunnypilot.car.toyota.values import ToyotaFlagsSP


 ONROAD_ONLY_DESCRIPTION = tr_noop("Start the vehicle to check vehicle compatibility.")
 SNG_HACK_UNAVAILABLE = tr_noop("sunnypilot Longitudinal Control must be available and enabled for your vehicle to use this feature.")
+BSM_UNAVAILABLE = tr_noop("Enhanced Blind Spot Monitoring requires a TSS2 Toyota/Lexus without SecOC, " +
+                           "or a smartDSU with sunnypilot longitudinal control.")
+BSM_STOCK_LONG_UNAVAILABLE = tr_noop("Enhanced Blind Spot Monitoring is not available while Enforce Factory Longitudinal Control is enabled.")
+BSM_REQUIRED = tr_noop("This vehicle does not report blind spot status over the standard CAN signals. " +
+                        "Enhanced Blind Spot Monitoring is required for blind spot detection.")
 PLATFORM_UNAVAILABLE = tr_noop("This feature is currently not available on this platform.")

 DESCRIPTIONS = {
@@ -26,6 +32,10 @@ DESCRIPTIONS = {
    'sunnypilot will allow some Toyota/Lexus cars to auto resume during stop and go traffic. ' +
    'This feature is only applicable to certain models that are able to use longitudinal control. This is an alpha feature. Use at your own risk.'
  ),
+  'enhanced_bsm': tr_noop(
+    'sunnypilot will poll the blind spot monitor diagnostics directly from the radar. Use this on vehicles whose blind spot monitors ' +
+    'do not report blind spot status over the standard CAN signals. This is an alpha feature. Use at your own risk.'
+  ),
  'tss2_smooth': tr_noop(
    'Enable smoother longitudinal control for TSS2 vehicles. ' +
    'Uses a custom speed-dependent integral gain curve for smoother traffic driving.'
@@ -53,6 +63,14 @@ class ToyotaSettings(BrandSettings):
      enabled=lambda: not ui_state.engaged,
    )

+    self.enhanced_bsm = toggle_item_sp(
+      lambda: tr("Enhanced Blind Spot Monitoring (Alpha)"),
+      description=lambda: tr(DESCRIPTIONS["enhanced_bsm"]),
+      initial_state=ui_state.params.get_bool("ToyotaEnhancedBsm"),
+      callback=self._on_enable_enhanced_bsm,
+      enabled=lambda: not ui_state.engaged,
+    )
+
    self.tss2_smooth = toggle_item_sp(
      lambda: tr("TSS2 Smooth Longitudinal (Alpha)"),
      description=lambda: tr(DESCRIPTIONS["tss2_smooth"]),
@@ -64,6 +82,7 @@ class ToyotaSettings(BrandSettings):
    self.items = [
      self.enforce_stock_longitudinal,
      self.stop_and_go_hack,
+      self.enhanced_bsm,
      self.tss2_smooth,
    ]

@@ -130,6 +149,25 @@ class ToyotaSettings(BrandSettings):
      ui_state.params.put_bool("ToyotaStopAndGoHack", False)
      ui_state.params.put_bool("OnroadCycleRequested", True)

+  def _on_enable_enhanced_bsm(self, state: bool):
+    if state:
+      def confirm_callback(result: int):
+        if result == DialogResult.CONFIRM:
+          ui_state.params.put_bool("ToyotaEnhancedBsm", True)
+          ui_state.params.put_bool("OnroadCycleRequested", True)
+        else:
+          self.enhanced_bsm.action_item.set_state(False)
+
+      content = (f"<h1>{self.enhanced_bsm.title}</h1><br>" +
+                 f"<p>{self.enhanced_bsm.description}</p>")
+
+      dlg = ConfirmDialog(content, tr("Enable"), rich=True, callback=confirm_callback)
+      gui_app.push_widget(dlg)
+
+    else:
+      ui_state.params.put_bool("ToyotaEnhancedBsm", False)
+      ui_state.params.put_bool("OnroadCycleRequested", True)
+
  def update_settings(self):
    if ui_state.CP is not None:
      longitudinal = ui_state.CP.openpilotLongitudinalControl
@@ -150,6 +188,31 @@ class ToyotaSettings(BrandSettings):
        if show_desc:
          self.stop_and_go_hack.show_description(True)

+      # Enhanced BSM needs the radar diagnostic address, which is only in the TX allowlist for
+      # TSS2 cars without SecOC, or for TSS-P cars whose smartDSU lets sunnypilot control
+      # longitudinal. Enforcing factory longitudinal control rules both of those out.
+      sdsu_bsm_supported = (longitudinal and ui_state.CP_SP is not None and
+                            bool(ui_state.CP_SP.flags & ToyotaFlagsSP.SMART_DSU))
+      bsm_supported = (not bool(ui_state.CP.flags & ToyotaFlags.SECOC) and
+                       (bool(ui_state.CP.flags & ToyotaFlags.TSS2) or sdsu_bsm_supported))
+      bsm_available = bsm_supported and not enforce_stock
+      self.enhanced_bsm.action_item.set_enabled(bsm_available and not ui_state.engaged)
+
+      bsm_desc = tr(DESCRIPTIONS["enhanced_bsm"])
+      if not bsm_supported:
+        self.enhanced_bsm.action_item.set_state(False)
+        bsm_desc = "<b>" + tr(BSM_UNAVAILABLE) + "</b>\n\n" + bsm_desc
+      elif enforce_stock:
+        self.enhanced_bsm.action_item.set_state(False)
+        bsm_desc = "<b>" + tr(BSM_STOCK_LONG_UNAVAILABLE) + "</b>\n\n" + bsm_desc
+      elif ui_state.CP_SP is not None and ui_state.CP_SP.flags & ToyotaFlagsSP.SP_NEED_DEBUG_BSM:
+        bsm_desc = "<b>" + tr(BSM_REQUIRED) + "</b>\n\n" + bsm_desc
+
+      if self.enhanced_bsm.description != bsm_desc:
+        self.enhanced_bsm.set_description(bsm_desc)
+        if not bsm_available:
+          self.enhanced_bsm.show_description(True)
+
      tss2 = bool(ui_state.CP.flags & ToyotaFlags.TSS2)
      if longitudinal and not enforce_stock and tss2:
        self.tss2_smooth.action_item.set_enabled(not ui_state.engaged)
@@ -173,6 +236,12 @@ class ToyotaSettings(BrandSettings):
        self.stop_and_go_hack.set_description(new_desc)
        self.stop_and_go_hack.show_description(True)

+      self.enhanced_bsm.action_item.set_enabled(False)
+      bsm_desc = "<b>" + tr(ONROAD_ONLY_DESCRIPTION) + "</b>\n\n" + tr(DESCRIPTIONS["enhanced_bsm"])
+      if self.enhanced_bsm.description != bsm_desc:
+        self.enhanced_bsm.set_description(bsm_desc)
+        self.enhanced_bsm.show_description(True)
+
      self.tss2_smooth.action_item.set_enabled(False)
      new_desc = "<b>" + tr(ONROAD_ONLY_DESCRIPTION) + "</b>\n\n" + tr(DESCRIPTIONS["tss2_smooth"])
      if self.tss2_smooth.description != new_desc:
@@ -72,6 +72,11 @@ class VisualsLayout(Widget):
           "It is the driver's responsibility to observe their environment and make decisions accordingly."),
        None,
      ),
+      "TripSummary": (
+        lambda: tr("Trip Summary"),
+        tr("Show a summary of distance and engagement when you shift into park after a drive."),
+        None,
+      ),
      "TrueVEgoUI": (
        lambda: tr("Speedometer: Always Display True Speed"),
        tr("For applicable vehicles, always display the true vehicle current speed from wheel speed sensors."),
@@ -0,0 +1,199 @@
+"""
+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 time
+import pyray as rl
+
+from opendbc.car.structs import car
+
+from openpilot.common.constants import CV
+from openpilot.selfdrive.ui.onroad.augmented_road_view import BORDER_COLORS
+from openpilot.selfdrive.ui.ui_state import ui_state, UIStatus
+from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+from openpilot.system.ui.widgets import Widget
+
+AUTO_DISMISS = 20.
+FADE_IN, FADE_OUT = 0.35, 0.3
+LAT = (UIStatus.ENGAGED, UIStatus.LAT_ONLY)
+LONG = (UIStatus.ENGAGED, UIStatus.LONG_ONLY)
+GEAR = car.CarState.GearShifter
+FORWARD = (GEAR.drive, GEAR.sport, GEAR.low, GEAR.brake, GEAR.eco, GEAR.manumatic)
+
+
+class TripTracker:
+  def __init__(self):
+    self.reset()
+
+  def reset(self):
+    self.segments: list[list] = []
+    self.seconds = 0.
+    self.takeovers = 0
+    self._t = None
+    self._status = None
+
+  def update(self, driving: bool):
+    now = time.monotonic()
+    if not driving:
+      self._t = None
+      self._status = None
+      return
+    dt = 0. if self._t is None else min(now - self._t, 0.5)
+    self._t = now
+    self.seconds += dt
+    if self._status not in (None, UIStatus.DISENGAGED) and ui_state.status == UIStatus.DISENGAGED:
+      self.takeovers += 1
+    self._status = ui_state.status
+    d = max(ui_state.sm["carState"].vEgo, 0.) * dt
+    if d <= 0.:
+      return
+    if self.segments and self.segments[-1][0] == ui_state.status:
+      self.segments[-1][1] += d
+    else:
+      self.segments.append([ui_state.status, d])
+
+  def total(self, statuses=None) -> float:
+    return sum(m for s, m in self.segments if statuses is None or s in statuses)
+
+
+class TripSummary:
+  def __init__(self):
+    self._trip = TripTracker()
+    self._dialog: TripSummaryDialog | None = None
+    self._gear = None
+    self._drove = False
+    gui_app.add_nav_stack_tick(self._tick)
+
+  def _tick(self):
+    gear = ui_state.sm["carState"].gearShifter if ui_state.started else None
+    self._trip.update(gear not in (None, GEAR.park))
+    self._drove |= gear in FORWARD
+    if gear == self._gear:
+      return
+    self._gear = gear
+
+    if gear not in (None, GEAR.park):
+      self._pop()
+    elif gear == GEAR.park and self._drove and ui_state.trip_summary and not ui_state.is_body and self._trip.total() > 0.:
+      self._dialog = TripSummaryDialog(self._trip, gui_app.get_active_widget(), self._pop)
+      gui_app.push_widget(self._dialog)
+    if gear is None:
+      self._trip.reset()
+    if gear in (None, GEAR.park):
+      self._drove = False
+
+  def _pop(self):
+    if self._dialog is not None and gui_app.get_active_widget() is self._dialog:
+      gui_app.pop_widget()
+    self._dialog = None
+
+
+def _ease(t: float) -> float:
+  t = min(max(t, 0.), 1.)
+  return 1 - (1 - t) ** 3
+
+
+def _fade(c, a: float) -> rl.Color:
+  r, g, b, al = c if isinstance(c, tuple) else (c.r, c.g, c.b, c.a)
+  return rl.Color(r, g, b, int(al * a))
+
+
+class TripSummaryDialog(Widget):
+  def __init__(self, trip: TripTracker, below: Widget | None, on_closed):
+    super().__init__()
+    self._below = below
+    self._on_closed = on_closed
+    self._segments = segments = trip.segments
+    total = sum(m for _, m in segments)
+
+    def pct(statuses):
+      return 100 * sum(m for s, m in segments if s in statuses) / total
+
+    dist = total * (CV.MS_TO_KPH if ui_state.is_metric else CV.MS_TO_MPH) / 3600
+    dist_fmt = "{:.1f}" if dist < 9.95 else "{:.0f}"
+    self._stats = [
+      (dist, dist_fmt, "km" if ui_state.is_metric else "mi", "driven"),
+      (pct(LAT + LONG), "{:.0f}", "%", "engaged"),
+      (pct(LAT), "{:.0f}", "%", "lateral"),
+      (pct(LONG), "{:.0f}", "%", "longitudinal"),
+    ]
+    mins = round(trip.seconds / 60)
+    self._details = [
+      (f"{mins // 60}h {mins % 60}" if mins >= 60 else f"{mins}", "min"),
+      (f"{trip.takeovers}", "takeover" if trip.takeovers == 1 else "takeovers"),
+    ]
+    self._bold = gui_app.font(FontWeight.BOLD)
+    self._semi = gui_app.font(FontWeight.SEMI_BOLD)
+    self._normal = gui_app.font(FontWeight.NORMAL)
+    self._big = gui_app.big_ui()
+    self._shown_t = rl.get_time()
+    self._closing_t: float | None = None
+    self.set_click_callback(self.close)
+
+  def close(self):
+    if self._closing_t is None:
+      self._closing_t = rl.get_time()
+
+  def _render(self, rect: rl.Rectangle):
+    t = rl.get_time() - self._shown_t
+    if self._closing_t is None and t > AUTO_DISMISS:
+      self.close()
+    out = 0. if self._closing_t is None else (rl.get_time() - self._closing_t) / FADE_OUT
+    if out >= 1.:
+      self._on_closed()
+      return
+    bg = 1 - _ease(out)
+    a = _ease(t / FADE_IN) * bg
+
+    if self._big and self._below is not None and bg < 1.:
+      self._below.render(rect)
+    rl.draw_rectangle_rec(rect, _fade(rl.BLACK, bg))
+
+    k = rect.height / 1080 * (1.0 if self._big else 1.22)
+    pad = 120 * k
+    x, w = rect.x + pad, rect.width - 2 * pad
+    y = rect.y + (rect.height - 850 * k) / 2
+
+    rl.draw_text_ex(self._bold, "trip summary", rl.Vector2(x, y), int(150 * k), 0, _fade(rl.WHITE, a))
+    y += 260 * k
+
+    col_w = w / len(self._stats)
+    for i, (target, fmt, unit, label) in enumerate(self._stats):
+      cx = x + col_w * (i + 0.5)
+      v = measure_text_cached(self._bold, fmt.format(target), int(170 * k))
+      u = measure_text_cached(self._semi, unit, int(80 * k))
+      vx = cx - (v.x + 10 * k + u.x) / 2
+      rl.draw_text_ex(self._bold, fmt.format(target), rl.Vector2(vx, y), int(170 * k), 0, _fade(rl.WHITE, a))
+      rl.draw_text_ex(self._semi, unit, rl.Vector2(vx + v.x + 10 * k, y + 75 * k), int(80 * k), 0, _fade(rl.WHITE, a))
+      lb = measure_text_cached(self._normal, label, int(70 * k))
+      rl.draw_text_ex(self._normal, label, rl.Vector2(cx - lb.x / 2, y + 180 * k), int(70 * k), 0, _fade(rl.Color(200, 200, 200, 255), a))
+    y += 330 * k
+
+    bar = rl.Rectangle(x, y, w, 90 * k)
+    total = sum(m for _, m in self._segments)
+    sx = bar.x
+    for status, m in self._segments:
+      sw = bar.width * m / total
+      rl.draw_rectangle_rec(rl.Rectangle(sx, bar.y, min(sw + 1, bar.x + bar.width - sx), bar.height), _fade(BORDER_COLORS[status], a))
+      sx += sw
+    rl.draw_rectangle_rounded_lines_ex(bar, 1.0, 20, 30 * k, _fade(rl.BLACK, a))
+
+    y += (90 + 70) * k
+
+    size = int(90 * k)
+    parts = []
+    for i, (value, unit) in enumerate(self._details):
+      if i:
+        parts.append(("     ", self._normal, None))
+      parts += [(value, self._bold, rl.WHITE), (" " + unit, self._normal, rl.Color(170, 170, 170, 255))]
+    widths = [measure_text_cached(f, t, size).x for t, f, _ in parts]
+    lx = x + (w - sum(widths)) / 2
+    for (text, font, color), tw in zip(parts, widths, strict=True):
+      if color is None:
+        rl.draw_circle(int(lx + tw / 2), int(y + size * 0.6), 12 * k, _fade(rl.Color(110, 110, 110, 255), a))
+      else:
+        rl.draw_text_ex(font, text, rl.Vector2(lx, y), size, 0, _fade(color, a))
+      lx += tw
@@ -0,0 +1,95 @@
+"""
+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
+import pyray as rl
+
+from openpilot.cereal import log
+from openpilot.common.filter_simple import FirstOrderFilter
+from openpilot.selfdrive.ui.mici.onroad import SIDE_PANEL_WIDTH
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.sunnypilot.selfdrive.controls.lib.accel_boost import get_boost_max
+from openpilot.system.ui.lib.application import gui_app
+from openpilot.system.ui.widgets import Widget
+
+BAR_WIDTH = 26
+TRACK_TOP_RATIO = 0.08
+TRACK_BOTTOM_RATIO = 0.92
+CAP_BLEND_START = 0.45
+MAX_BOOST_BLEND = 0.55
+FADE_THRESHOLD = 0.01
+
+COLOR_TRACK = rl.Color(255, 255, 255, 28)
+COLOR_FILL = rl.Color(0, 230, 120, 255)
+
+
+def get_boost_fraction(boost: float, max_boost: float) -> float:
+  if max_boost <= 0.0:
+    return 0.0
+  return min(max(boost / max_boost, 0.0), 1.0)
+
+
+def lighten(color: rl.Color, amount: float) -> rl.Color:
+  amount = min(max(amount, 0.0), 1.0)
+  return rl.Color(int(color.r + (255 - color.r) * amount),
+                  int(color.g + (255 - color.g) * amount),
+                  int(color.b + (255 - color.b) * amount), color.a)
+
+
+def get_boost_color(fraction: float) -> rl.Color:
+  blend = max(0.0, (fraction - CAP_BLEND_START) / (1.0 - CAP_BLEND_START))
+  return lighten(COLOR_FILL, MAX_BOOST_BLEND * blend)
+
+
+class AccelBoostIndicator(Widget):
+  def __init__(self, panel_width: float = SIDE_PANEL_WIDTH, bar_width: float = BAR_WIDTH):
+    super().__init__()
+    self._panel_width = panel_width
+    self._bar_width = bar_width
+    fps = max(gui_app.target_fps, 1)
+    self._boost_filter = FirstOrderFilter(0.0, 0.15, 1 / fps)
+    self._alpha_filter = FirstOrderFilter(0.0, 0.1, 1 / fps)
+    self._max_boost_filter = FirstOrderFilter(get_boost_max(), 0.25, 1 / fps)
+
+  @property
+  def holding_panel(self) -> bool:
+    return self._alpha_filter.x > FADE_THRESHOLD
+
+  def _update_state(self):
+    sm = ui_state.sm
+    visible = (ui_state.accel_boost and ui_state.has_longitudinal_control and sm.alive['selfdriveState'] and
+               sm.alive['longitudinalPlan'] and sm['selfdriveState'].enabled)
+    plan = sm['longitudinalPlan']
+    applied = visible and plan.longitudinalPlanSource == log.LongitudinalPlan.LongitudinalPlanSource.e2e
+    self._boost_filter.update(float(plan.accelBoost) if applied else 0.0)
+    self._alpha_filter.update(1.0 if visible else 0.0)
+
+    if sm.alive['selfdriveState']:
+      self._max_boost_filter.update(get_boost_max(sm['selfdriveState'].personality))
+
+  def _render(self, _):
+    alpha = self._alpha_filter.x
+    if alpha < FADE_THRESHOLD:
+      return
+
+    panel_x = max(self.rect.x, self.rect.x + self.rect.width - self._panel_width)
+    bar_x = panel_x + (self._panel_width - self._bar_width) / 2
+    track_top = self.rect.y + self.rect.height * TRACK_TOP_RATIO
+    track = rl.Rectangle(bar_x, track_top, self._bar_width,
+                         max(1.0, self.rect.height * (TRACK_BOTTOM_RATIO - TRACK_TOP_RATIO)))
+    rl.draw_rectangle_rounded(track, 0.5, 12,
+                              rl.Color(COLOR_TRACK.r, COLOR_TRACK.g, COLOR_TRACK.b, int(COLOR_TRACK.a * alpha)))
+
+    fraction = get_boost_fraction(self._boost_filter.x, self._max_boost_filter.x)
+    fill_h = fraction * track.height
+    if fill_h < 1.0:
+      return
+
+    fill_color = get_boost_color(fraction)
+    tip = track.y + track.height - fill_h
+    rl.begin_scissor_mode(int(track.x), int(tip), int(math.ceil(track.width)) + 1, int(math.ceil(fill_h)))
+    rl.draw_rectangle_rounded(track, 0.5, 12, rl.Color(fill_color.r, fill_color.g, fill_color.b, int(235 * alpha)))
+    rl.end_scissor_mode()
@@ -0,0 +1,19 @@
+"""
+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.sunnypilot.mici.onroad.accel_boost_indicator import AccelBoostIndicator
+
+
+class AugmentedRoadViewSP:
+  def __init__(self):
+    self._accel_boost_indicator = AccelBoostIndicator()
+
+  def render_side_panel(self, rect: rl.Rectangle) -> None:
+    self._accel_boost_indicator.render(rect)
+    if not self._accel_boost_indicator.holding_panel:
+      self._confidence_ball.render(rect)
@@ -0,0 +1,36 @@
+"""
+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.cereal import log
+from openpilot.common.test import OpenpilotTestCase
+from openpilot.selfdrive.ui.sunnypilot.mici.onroad.accel_boost_indicator import (
+  CAP_BLEND_START, COLOR_FILL, get_boost_color, get_boost_fraction,
+)
+from openpilot.sunnypilot.selfdrive.controls.lib.accel_boost import ACCEL_BOOST_MAX, get_boost_max
+
+
+class TestAccelBoostIndicator(OpenpilotTestCase):
+  def test_bar_fills_at_the_active_profile_cap(self):
+    for personality in (log.LongitudinalPersonality.aggressive, log.LongitudinalPersonality.standard,
+                        log.LongitudinalPersonality.relaxed):
+      cap = get_boost_max(personality)
+      assert get_boost_fraction(0.0, cap) == 0.0
+      assert get_boost_fraction(cap * 0.5, cap) == 0.5
+      assert get_boost_fraction(cap, cap) == 1.0
+
+    assert get_boost_fraction(max(ACCEL_BOOST_MAX), min(ACCEL_BOOST_MAX)) == 1.0
+    assert get_boost_fraction(0.0, 0.0) == 0.0
+    assert get_boost_fraction(-1.0, get_boost_max()) == 0.0
+
+  def test_fill_lightens_as_boost_builds(self):
+    base = get_boost_color(0.0)
+    assert (base.r, base.g, base.b) == (COLOR_FILL.r, COLOR_FILL.g, COLOR_FILL.b)
+    assert (get_boost_color(CAP_BLEND_START).r, get_boost_color(CAP_BLEND_START).b) == (COLOR_FILL.r, COLOR_FILL.b)
+
+    full = get_boost_color(1.0)
+    assert full.r > base.r
+    assert full.b > base.b
+    assert full.g > full.r and full.g > full.b
@@ -44,10 +44,12 @@ class UIStateSP:
    self.screensaver = ScreenSaverSP(params=self.params)
    self.screensaver_enabled: bool = False

+    self.accel_boost: bool = False
    self.active_bundle = None
    self.model_runner_tinygrad: bool = False
    self.active_runner_tinygrad: bool = False
    self.blindspot: bool = False
+    self.trip_summary: bool = True
    self.chevron_metrics = None
    self.custom_interactive_timeout: int = 0
    self.developer_ui = None
@@ -171,6 +173,7 @@ class UIStateSP:
    # stock only counts the default big model's compiled pkl. a downloaded big bundle runs on the
    # chestnut just the same, so ChestnutState has to see it as available too.
    self.chestnut_compiled = self.chestnut_compiled or self.model_runner_tinygrad
+    self.accel_boost = self.params.get_bool("AccelBoostSP")
    self.blindspot = self.params.get_bool("BlindSpot")
    self.chevron_metrics = self.params.get("ChevronInfo")
    self.custom_interactive_timeout = self.params.get("InteractivityTimeout", return_default=True)
@@ -185,6 +188,7 @@ class UIStateSP:
    self.standstill_timer = self.params.get_bool("StandstillTimer")
    self.sunnylink_enabled = self.params.get_bool("SunnylinkEnabled")
    self.torque_bar = self.params.get_bool("TorqueBar")
+    self.trip_summary = self.params.get_bool("TripSummary")
    self.enforce_torque_control = self.params.get_bool("EnforceTorqueControl")
    self.custom_torque_params = self.params.get_bool("CustomTorqueParams")
    self.torque_override_enabled = self.params.get_bool("TorqueParamsOverrideEnabled")
@@ -371,7 +371,7 @@ def _compile_warp_resolution_worker(cam_w, cam_h, model_w, model_h, benchmark_ru


 if __name__ == "__main__":
-  if ('USB' in os.getenv('DEV', '') or os.getenv('CHESTNUT')) and not os.getenv('DEV', '').startswith('MOCK'):
+  if 'USB' in os.getenv('DEV', '') or os.getenv('CHESTNUT'):
    from openpilot.system.hardware.chestnut.flash import link_up
    for _ in range(10):
      if link_up():
@@ -17,18 +17,16 @@ def main():
  parser.add_argument("--frame", required=True, help="width,height,stride,y_height,uv_height,buffer_size")
  parser.add_argument("--warp-to", required=True, help="model input WxH")
  parser.add_argument("--output", required=True)
-  parser.add_argument("--light", action="store_true")
  args = parser.parse_args()

  from examples.openpilot.compile_warp import make_frame_prepare, parse_frame, parse_size
  from tinygrad import Device, Tensor, TinyJit
  frame = parse_frame(args.frame)
  warp = make_frame_prepare(frame, *parse_size(args.warp_to))
-  n = 1 if args.light else 2
-  run = TinyJit(lambda input_frame, M_inv: Tensor.stack(*(warp(input_frame[i], M_inv[i]) for i in range(n))), prune=True)
+  run = TinyJit(lambda input_frame, M_inv: Tensor.stack(*(warp(input_frame[i], M_inv[i]) for i in range(2))), prune=True)
  rng = np.random.default_rng(42)
  inputs = {"input_frame": Tensor(rng.integers(0, 256, (2, frame.size), dtype=np.uint8), device=Device.DEFAULT).realize(),
-            "M_inv": Tensor((rng.standard_normal((n, 3, 3)) * 8).astype(np.float32), device=Device.DEFAULT).realize()}
+            "M_inv": Tensor((rng.standard_normal((2, 3, 3)) * 8).astype(np.float32), device=Device.DEFAULT).realize()}
  with record_kernel_linear() as recorded:
    run(**inputs)
    run(**inputs)
@@ -36,7 +34,7 @@ def main():
  assert len(recorded) == 1, f"expected one captured kernel list, got {len(recorded)}"
  part = serialize_jit(run, recorded[0], check)
  PlainJit(*part)
-  specs = {"input_frame": ((2, frame.size), "|u1", Device.DEFAULT), "M_inv": ((n, 3, 3), "<f4", Device.DEFAULT)}
+  specs = {"input_frame": ((2, frame.size), "|u1", Device.DEFAULT), "M_inv": ((2, 3, 3), "<f4", Device.DEFAULT)}
  write_bundle(args.output, {"run": part}, {"input_specs": specs, "metadata": {}})
  print(f"Saved warp to {args.output} ({len(part[0]['calls'])} kernels)")

@@ -10,7 +10,6 @@ import dataclasses
 import inspect
 import itertools
 import mmap
-import os
 import re
 import struct
 import tempfile
@@ -67,75 +66,47 @@ def _patched(buf, topo) -> tuple[bytearray, dict]:
  return blob, rows


-def _packed_args(program) -> dict[int, int]:
-  from tinygrad.device import TinyELF
-  params = getattr(program.arg, "params", None) or ()
-  return {off: p.arg.slot for (off, _), p in zip(TinyELF.iter_sig(tuple((None, p.addrspace, p.dtype, ()) for p in params)), params, strict=True)}
-
-
-def _outer_slot(u, packed: dict[int, int]) -> int | None:
-  from tinygrad.uop.ops import Ops
-  if u.op is Ops.PARAM:
-    return None if packed else u.arg.slot
-  if u.op.name == "REFPARAM":
-    return u.arg.slot
-  if packed and u.op is Ops.LOAD and u.src[0].op is Ops.INDEX and _root(u.src[0].src[0]).op is Ops.PARAM:
-    index = _evaluate(u.src[0].src[1], {}, packed)
-    return None if index is None else packed.get(index * u.dtype.itemsize)
-  return None
-
-
-def _evaluate(u, env, packed: dict[int, int]):
+def _evaluate(u, env):
  from tinygrad.uop.ops import GroupOp, Ops, exec_alu
  if u.op in (Ops.AFTER, Ops.CAST, Ops.BITCAST):
-    return _evaluate(u.src[0], env, packed)
+    return _evaluate(u.src[0], env)
  if u.op is Ops.CONST:
    return u.arg
-  if u.op is Ops.RANGE:
-    return env.get(u)
-  if (slot := _outer_slot(u, packed)) is not None:
-    return env.get(slot)
+  if u.op in (Ops.PARAM, Ops.RANGE):
+    return env.get(u.arg.slot if u.op is Ops.PARAM else u)
  if u.op is Ops.LOAD:
-    table, index = _root(u.src[0].src[0]), _evaluate(u.src[0].src[1], env, packed)
+    table, index = _root(u.src[0].src[0]), _evaluate(u.src[0].src[1], env)
    return struct.unpack_from(u.dtype.fmt, table.arg, index * u.dtype.itemsize)[0] if table.op is Ops.BINARY and index is not None else None
-  if u.op in GroupOp.ALU and None not in (values := [_evaluate(x, env, packed) for x in u.src]):
+  if u.op in GroupOp.ALU and None not in (values := [_evaluate(x, env) for x in u.src]):
    return exec_alu(u.op, u.dtype, values, *([False] if "truncate_output" in inspect.signature(exec_alu).parameters else []))
  return None


 def _input_pokes(submit, kernargs) -> dict[int, tuple[int, int]]:
  from tinygrad.uop.ops import Ops
-  outer, packed = dict(enumerate(submit.src[1:])), _packed_args(submit.src[0])
+  outer = dict(enumerate(submit.src[1:]))
  kernargs_params = {i for i, a in outer.items() if a.op is Ops.GETADDR and _root(a.src[0]) is kernargs}
  inputs = {i: _root(a.src[0]).arg.slot for i, a in outer.items() if a.op is Ops.GETADDR and _root(a.src[0]).op is Ops.PARAM}
  pokes = {}
  for call in (u for u in submit.src[0].src[0].toposort() if u.op is Ops.CALL and len(u.src) > 3):
    _, address, value, *_ = call.src[1:]
-    used = list({slot for x in value.toposort() if (slot := _outer_slot(x, packed)) is not None} & inputs.keys())
-    if len(used) != 1 or not kernargs_params & {_outer_slot(x, packed) for x in address.toposort()}:
+    used = list({x.arg.slot for x in value.toposort() if x.op is Ops.PARAM} & inputs.keys())
+    if len(used) != 1 or not kernargs_params & {x.arg.slot for x in address.toposort() if x.op is Ops.PARAM}:
      continue
    ranges = list(dict.fromkeys(x for x in (*address.toposort(), *value.toposort()) if x.op is Ops.RANGE))
    for trip in itertools.product(*[range(int(r.vmax) + 1) for r in ranges]):
      env = dict.fromkeys(outer, 0) | dict(zip(ranges, trip, strict=True))
-      if (offset := _evaluate(address, env, packed)) % 8 == 0:
-        pokes[offset] = (inputs[used[0]], _evaluate(value, env, packed))
+      if (offset := _evaluate(address, env)) % 8 == 0:
+        pokes[offset] = (inputs[used[0]], _evaluate(value, env))
  return pokes


-def _elf(image: bytes, rodata: int, entry: int) -> bytes:
-  spans = [(".text", 0, rodata), (".rodata", rodata, len(image))] if entry < rodata else \
-          [(".data", 0, rodata), (".rodata", rodata, entry), (".text", entry, len(image))]
-  sections, names = [(0, 0, 0, 0, b"")], b"\0"
-  for name, start, end in (span for span in spans if span[1] < span[2]):
-    sections.append((len(names), 1, 6 if name == ".text" else 2, ALIGNMENT + start, image[start:end]))
-    names += name.encode() + b"\0"
-  sections.append((len(names), 3, 0, 0, names + b".shstrtab\0"))
-  offset, data, headers = 64, b"", []
-  for name, kind, flags, address, content in sections:
-    headers.append(struct.pack("<IIQQQQIIQQ", name, kind, flags, address, offset, len(content), 0, 0, 1, 0))
+def _elf(image: bytes, rodata: int) -> bytes:
+  names, offset, data, headers = b"\0.text\0.rodata\0.shstrtab\0", 64, b"", []
+  for name, kind, address, content in [(0, 0, 0, b""), (1, 1, ALIGNMENT, image[:rodata]), (7, 1, ALIGNMENT + rodata, image[rodata:]), (15, 3, 0, names)]:
+    headers.append(struct.pack("<IIQQQQIIQQ", name, kind, 2 if kind == 1 else 0, address, offset, len(content), 0, 0, 1, 0))
    data, offset = data + content, offset + len(content)
-  header = struct.pack("<HHIQQQIHHHHHH", 1, 0xe0, 1, 0, 0, offset, 0, 64, 0, 0, 64, len(sections), len(sections) - 1)
-  return b"\x7fELF\x02\x01\x01" + bytes(9) + header + data + b"".join(headers)
+  return b"\x7fELF\x02\x01\x01" + bytes(9) + struct.pack("<HHIQQQIHHHHHH", 1, 0xe0, 1, 0, 0, offset, 0, 64, 0, 0, 64, 4, 3) + data + b"".join(headers)


 def convert(jit, kwargs: dict, frame: dict, target) -> tuple[dict, memoryview]:
@@ -184,7 +155,7 @@ def convert(jit, kwargs: dict, frame: dict, target) -> tuple[dict, memoryview]:
    if image_alloc not in programs:
      image = bytes(_patched(image_alloc, topo)[0])
      rodata = next(r for r in range(0, len(image) - 24, 64) if r + struct.unpack_from("<q", image, r + 16)[0] == entry)
-      programs[image_alloc] = blob.add(_elf(image, rodata, entry))
+      programs[image_alloc] = blob.add(_elf(image, rodata))
    start, size = _view(arguments.src[0])
    args = []
    for slot in range(start, start + unwrap(size), 8):
@@ -195,8 +166,7 @@ def convert(jit, kwargs: dict, frame: dict, target) -> tuple[dict, memoryview]:
        base, at, nbytes = _address(argument_words[slot])
        args.append({"buffer": buffers.setdefault(base, len(buffers)), "offset": at, "nbytes": nbytes or base.max_numel() * base.dtype.itemsize, "dtype": u8})
    outs, ins = kernel[6]
-    device_target = dataclasses.asdict(dataclasses.replace(target, interface=target.interface.removeprefix("MOCK")))
-    calls.append({"kind": "program", "name": re.sub(r"\x1b\[[0-9;]*m", "", kernel[1]), "lib": programs[image_alloc], "target": device_target,
+    calls.append({"kind": "program", "name": re.sub(r"\x1b\[[0-9;]*m", "", kernel[1]), "lib": programs[image_alloc], "target": dataclasses.asdict(target),
                  "signature": [[f"data{i}", i, u8, [a.get("nbytes", 1)]] for i, a in enumerate(args)], "global_size": grid, "local_size": local,
                  "globals": list(range(len(args))), "outs": list(outs), "ins": list(ins), "args": args})
    needs_init |= {args[i]["buffer"] for i in ins if "buffer" in args[i] and args[i]["buffer"] not in written}
@@ -237,16 +207,14 @@ def main():
  frame, _ = capture_frame(artifact["run"], kwargs, "output_buffers")
  part = convert(artifact["run"], kwargs, frame, Device[Device.DEFAULT].renderer.target)

-  if not os.getenv("MOCKUSB_SOCKET"):
-    plain = PlainJit(*part)
-    replay = {path[0]: Tensor(array, device=device).realize() for path, array, device in frame["inputs"] if len(path) == 1}
-    replay["output_buffers"] = {path[1]: Tensor(array, device=device).realize() for path, array, device in frame["inputs"] if len(path) == 2}
-    flatten(plain(**replay))
-    for index, (got, expected) in enumerate(zip([t.numpy() for t in replay["output_buffers"].values()], frame["outputs"], strict=True)):
-      assert np.array_equal(got, expected), f"output {index} of the plain artifact differs from the pickle"
+  plain = PlainJit(*part)  # replays the frame, within tolerance
+  replay = {path[0]: Tensor(array, device=device).realize() for path, array, device in frame["inputs"] if len(path) == 1}
+  replay["output_buffers"] = {path[1]: Tensor(array, device=device).realize() for path, array, device in frame["inputs"] if len(path) == 2}
+  flatten(plain(**replay))
+  for index, (got, expected) in enumerate(zip([t.numpy() for t in replay["output_buffers"].values()], frame["outputs"], strict=True)):
+    assert np.array_equal(got, expected), f"output {index} of the plain artifact differs from the pickle"
  write_bundle(args.output, {"run": part}, {key: artifact[key] for key in ("metadata", "input_specs", "output_specs")})
-  checked = "left to mock_parity" if os.getenv("MOCKUSB_SOCKET") else "bit-exact with the pickle"
-  print(f"converted {len(part[0]['calls'])} kernels, {checked}: {args.output}")
+  print(f"converted {len(part[0]['calls'])} kernels, bit-exact with the pickle: {args.output}")


 if __name__ == "__main__":
@@ -20,11 +20,6 @@ def pack_layout(shapes: dict[str, tuple], frame_size: int) -> tuple[dict[str, in
  return offsets | {"frames": offset}, offset + 2 * frame_size


-def host_shapes(input_shapes: dict[str, tuple], states) -> dict[str, tuple]:
-  shapes = {name: shape for name, shape in input_shapes.items() if name not in states and name not in ("new_img", "light_img")}
-  return shapes | ({"light_tfm": (1, 3, 3)} if "light_img" in input_shapes else {})
-
-
 class _Blobs:  # the model's and the warp's blobs as one address space, for a part whose ranges span both files
  def __init__(self, *blobs):
    self.blobs, self.starts = blobs, list(itertools.accumulate([0] + [len(blob) for blob in blobs[:-1]]))
@@ -35,23 +30,18 @@ class _Blobs:  # the model's and the warp's blobs as one address space, for a pa


 def fused_with_warp(cam_w: int, cam_h: int, chestnut: bool):  # load_model's extend: a native model runs upload, warp and model as one submit
-  models = f"{BASEDIR}/openpilot/sunnypilot/modeld_v2/models"
-  return partial(frame_part, f"{models}/{'big_' if chestnut else ''}driving_warp_{cam_w}x{cam_h}_tinygrad.pkl",
-                 light_warp_path=f"{models}/driving_lightwarp_{cam_w}x{cam_h}_tinygrad.pkl")
+  return partial(frame_part, f"{BASEDIR}/openpilot/sunnypilot/modeld_v2/models/{'big_' if chestnut else ''}driving_warp_{cam_w}x{cam_h}_tinygrad.pkl")


-def frame_part(warp_path: str, parts: dict, extras: dict, light_warp_path: str | None = None) -> dict:
+def frame_part(warp_path: str, parts: dict, extras: dict) -> dict:
  if "input_specs" not in extras:  # a legacy model warps in its own parts
    return {}
  (model, model_blob), (warp, warp_blob) = parts["run"], read_parts(warp_path)[0]["run"]
  states = sorted(name for name in extras["input_specs"] if f"next_{name}" in extras["metadata"]["output_shapes"])
-  host = host_shapes({name: shape for name, (shape, _, _) in extras["input_specs"].items()}, states)
-  light = "light_img" in extras["input_specs"]
-  light_warp, light_blob = read_parts(light_warp_path)[0]["run"] if light else ({"buffers": [], "calls": [], "inputs": []}, memoryview(b""))
+  host = {name: shape for name, (shape, _, _) in extras["input_specs"].items() if name not in states and name != "new_img"}
  frame_size = next(s["numel"] for s in warp["inputs"] if s["name"] == "input_frame") // 2
  offsets, packed = pack_layout(host, frame_size)
-  shift, light_shift = len(model_blob), len(model_blob) + len(warp_blob)
-  upload, u8 = len(model["buffers"]) + len(warp["buffers"]) + len(light_warp["buffers"]), repr(_dtype("dtypes.uint8"))
+  shift, upload, u8 = len(model_blob), len(model["buffers"]) + len(warp["buffers"]), repr(_dtype("dtypes.uint8"))

  def view(name: str, nbytes: int, dtype: str) -> dict:
    return {"buffer": upload, "offset": offsets[name], "nbytes": nbytes, "dtype": dtype}
@@ -59,15 +49,12 @@ def frame_part(warp_path: str, parts: dict, extras: dict, light_warp_path: str |
  names = sorted(["host", *states])
  slots = {s["slot"]: names.index(s["name"]) for s in model["inputs"] if s["name"] in states} | \
          {slot: len(names) + i for i, slot in enumerate(outputs)}
-  def warped(part: dict, base: int) -> dict:
-    returned = part["returns"]["tensors"][0]
-    return {k: v for k, v in returned.items() if k != "shape"} | {"buffer": returned["buffer"] + base}
+  returned = warp["returns"]["tensors"][0]
  model_inputs = {s["slot"]: {"input": slots[s["slot"]]} if s["slot"] in slots else
-                  warped(warp, len(model["buffers"])) if s["name"] == "new_img" else
-                  warped(light_warp, len(model["buffers"]) + len(warp["buffers"])) if s["name"] == "light_img" else
+                  {k: v for k, v in returned.items() if k != "shape"} | {"buffer": returned["buffer"] + len(model["buffers"])} if s["name"] == "new_img" else
                  view(s["name"], s["numel"] * _dtype(s["dtype"]).itemsize, s["dtype"]) for s in model["inputs"]}
-  def warp_inputs(part: dict, tfm: str) -> dict:
-    return {s["slot"]: view("frames" if s["name"] == "input_frame" else tfm, s["numel"] * _dtype(s["dtype"]).itemsize, s["dtype"]) for s in part["inputs"]}
+  warp_inputs = {s["slot"]: view("frames" if s["name"] == "input_frame" else "tfm", s["numel"] * _dtype(s["dtype"]).itemsize, s["dtype"])
+                 for s in warp["inputs"]}

  def remap(calls: list, inputs: dict, buffers: int, lib: int) -> list:
    return [call | ({"lib": [call["lib"][0] + lib, call["lib"][1] + lib]} if "lib" in call else {}) |
@@ -75,11 +62,8 @@ def frame_part(warp_path: str, parts: dict, extras: dict, light_warp_path: str |
  header = {"input_names": names, "returns": {"kind": "NoneType", "tensors": []}, "check": None,
            "inputs": [{"slot": names.index("host"), "name": "host", "dtype": u8, "numel": packed, "device": "NPY"}] +
                      [s | {"slot": slots[s["slot"]]} for s in model["inputs"] if s["slot"] in slots],
-            "buffers": model["buffers"] + [b | ({"init": [b["init"][0] + d, b["init"][1] + d]} if "init" in b else {})
-                                           for part, d in ((warp, shift), (light_warp, light_shift)) for b in part["buffers"]] +
+            "buffers": model["buffers"] + [b | ({"init": [b["init"][0] + shift, b["init"][1] + shift]} if "init" in b else {}) for b in warp["buffers"]] +
                       [{"nbytes": packed, "device": model["inputs"][0]["device"], "dtype": u8}],
            "calls": [{"kind": "copy", "args": [{"buffer": upload, "offset": 0, "nbytes": packed, "dtype": u8}, {"input": names.index("host")}]}] +
-                     remap(warp["calls"], warp_inputs(warp, "tfm"), len(model["buffers"]), shift) +
-                     remap(light_warp["calls"], warp_inputs(light_warp, "light_tfm"), len(model["buffers"]) + len(warp["buffers"]), light_shift) +
-                     remap(model["calls"], model_inputs, 0, 0)}
-  return {"run": (header, _Blobs(model_blob, warp_blob, light_blob) if light else _Blobs(model_blob, warp_blob))}
+                     remap(warp["calls"], warp_inputs, len(model["buffers"]), shift) + remap(model["calls"], model_inputs, 0, 0)}
+  return {"run": (header, _Blobs(model_blob, warp_blob))}  # replaces the model's run: one set of buffers, no separate warp
@@ -264,8 +264,8 @@ def _program_uop(call: dict, lib: bytes):
    parameter = UOp.param(call["globals"][compact_slot], _dtype(dtype), math.prod(shape))
    image = (shape[0], shape[1]) if len(shape) == 3 and shape[2] == 4 else None
    parameters.append(parameter.replace(arg=_fields(parameter.arg, name=name, image=image)))
-  info = _fields(ProgramInfo, global_size=tuple(call["global_size"]), local_size=tuple(call["local_size"]), params=tuple(parameters),
-                 globals=tuple(call["globals"]), outs=tuple(call["outs"]), ins=tuple(call["ins"]), target=_fields(Target, **call["target"]))
+  info = _fields(ProgramInfo, global_size=tuple(call["global_size"]), local_size=tuple(call["local_size"]), globals=tuple(call["globals"]),
+                 outs=tuple(call["outs"]), ins=tuple(call["ins"]), target=_fields(Target, **call["target"]))
  return UOp(Ops.PROGRAM, src=(UOp(Ops.SINK, arg=KernelInfo(name=call["name"])), UOp(Ops.LINEAR, src=tuple(parameters)),
                               UOp(Ops.SOURCE, arg=""), UOp(Ops.BINARY, arg=lib)), arg=info)

@@ -1,22 +0,0 @@
-"""
-Copyright (c) 2021-, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import numpy as np
-
-from openpilot.common.transformations.camera import get_view_frame_from_calib_frame, view_frame_from_device_frame
-from openpilot.common.transformations.orientation import rot_from_euler
-
-LIGHT_INPUT_SIZE = (512, 256)
-light_intrinsics = np.array([
-  [1000.0, 0.0, 256.0],
-  [0.0, 1000.0, 200.0],
-  [0.0, 0.0, 1.0]])
-calib_from_light = np.linalg.inv((light_intrinsics @ get_view_frame_from_calib_frame(0, 0, 0, 0))[:, :3])
-
-
-def get_light_warp_matrix(device_from_calib_euler: np.ndarray, intrinsics: np.ndarray) -> np.ndarray:
-  camera_from_calib = intrinsics @ view_frame_from_device_frame @ rot_from_euler(device_from_calib_euler)
-  return (camera_from_calib @ calib_from_light).astype(np.float32)
@@ -1,153 +0,0 @@
-import json
-import os
-import shutil
-import struct
-import sys
-import tempfile
-import time
-
-os.environ.setdefault("DEV", "MOCKUSB+AMD")
-QCOM = "QCOM" in os.environ["DEV"]
-ON_MOCK = os.environ["DEV"].startswith("MOCK")
-ARCH, HARDWARE = ("a630", "comma 3x/4 (a630)") if QCOM else ("gfx1200", "chestnut")
-os.environ.setdefault("CHECK_OOB", "0")
-os.environ.setdefault("GMMU", "0")
-if sys.platform == "darwin" and os.environ["DEV"].startswith("MOCKUSB"):  # the mock's VRAM is a memfd, which macOS lacks: an unlinked file is the same
-  from tinygrad.runtime.autogen import libc
-
-  def _memfd_create(name, flags):
-    fd, path = tempfile.mkstemp()
-    os.unlink(path)
-    return fd
-  libc.memfd_create = _memfd_create
-
-import numpy as np
-
-from openpilot.sunnypilot.modeld_v2.helpers import ALIGNMENT, MAGIC, PlainJit, _device, read_parts
-
-
-class ParityError(RuntimeError):
-  pass
-
-
-def _emulator():
-  try:
-    if QCOM:
-      from test.mockgpu.qcom import emu
-    else:
-      from test.mockgpu.amd import emu
-  except ImportError as e:
-    raise ParityError(f"tinygrad's {'qcom' if QCOM else 'amd'} mock is not importable: put tinygrad_repo on PYTHONPATH") from e
-  if not hasattr(emu, "hw_unverified"):
-    raise ParityError(f"this tinygrad's emulator has no {ARCH} rounding model, its check frames would not match a {HARDWARE}")
-  return emu
-
-
-def unverified(header: dict, blob: memoryview) -> dict[str, int]:
-  emu, out = _emulator(), {}
-  for call in header["calls"]:
-    if call["kind"] != "program":
-      continue
-    if (arch := call["target"].get("arch", "")).split(",")[0] != ARCH:  # IMAGE builds append ",IMAGE_PITCH_ALIGNMENT=64"
-      out[f"arch={arch}"] = out.get(f"arch={arch}", 0) + 1
-      continue
-    for sig, n in emu.hw_unverified(bytes(blob[slice(*call["lib"])])).items():
-      out[sig] = out.get(sig, 0) + n
-  return out
-
-
-def _array(blob: memoryview, stored: dict) -> np.ndarray:
-  return np.frombuffer(blob[slice(*stored["data"])], dtype=np.dtype(stored["dtype"])).reshape(stored["shape"]).copy()
-
-
-def replay(header: dict, blob: memoryview, shared: dict) -> list[np.ndarray]:
-  from tinygrad import Tensor
-  check = header["check"]
-  jit = PlainJit(header, blob, None, verify=False, shared=shared)
-  kwargs: dict = {}
-  for path, stored, device in check["inputs"]:
-    tensor = Tensor(_array(blob, stored), device=_device(device, None)).realize()
-    kwargs[path[0]] = tensor if len(path) == 1 else {**kwargs.get(path[0], {}), path[1]: tensor}
-  result = jit(**kwargs)
-  outputs = kwargs[check["output_container"]].values() if check["output_container"] else result
-  return [t.numpy() for t in (outputs if isinstance(outputs, (list, tuple)) or check["output_container"] else [outputs])]
-
-
-def _parts_with_offsets(path: str) -> tuple[dict, dict]:
-  parts, _ = read_parts(path)
-  with open(path, "rb") as f:
-    head = f.read(len(MAGIC) + 8)
-    start = len(MAGIC) + 8 + struct.unpack_from("<Q", head, len(MAGIC))[0]
-    f.seek(len(MAGIC) + 8)
-    entries = json.loads(f.read(start - len(MAGIC) - 8))["parts"]
-  base = start + -start % ALIGNMENT
-  offsets = {tuple(e["key"]) if isinstance(e["key"], list) else e["key"]: base + e["blob"][0] for e in entries}
-  return parts, offsets
-
-
-def _gate(parts: dict) -> None:
-  missing: dict[str, int] = {}
-  for header, blob in parts.values():
-    if "check" not in header:
-      raise ParityError("artifact has no check frame")
-    for sig, n in unverified(header, blob).items():
-      missing[sig] = missing.get(sig, 0) + n
-  if missing:
-    raise ParityError(f"kernels use instructions the emulator is not verified against a {HARDWARE} for: " +
-                      ", ".join(f"{s} ({n}x)" for s, n in sorted(missing.items(), key=lambda kv: -kv[1])))
-
-
-def check(path: str) -> None:
-  parts, _ = read_parts(path)
-  if ON_MOCK:
-    _gate(parts)
-  shared: dict = {}
-  for key, (header, blob) in parts.items():
-    got = replay(header, blob, shared)
-    for i, (g, stored) in enumerate(zip(got, header["check"]["outputs"], strict=True)):
-      want = _array(blob, stored)
-      if g.shape != want.shape or not np.array_equal(g.view(np.uint8), want.view(np.uint8)):
-        n = int(np.count_nonzero(g != want)) if g.shape == want.shape else -1
-        where = "mock" if ON_MOCK else "device"
-        raise ParityError(f"part {key} output {i}: the {where}'s check frame differs from the stored one in {n} of {want.size} values")
-
-
-def record(path: str, out: str) -> None:
-  parts, offsets = _parts_with_offsets(path)
-  _gate(parts)
-  shared, writes = {}, []
-  for key, (header, blob) in parts.items():
-    for g, stored in zip(replay(header, blob, shared), header["check"]["outputs"], strict=True):
-      want = np.dtype(stored["dtype"])
-      if tuple(g.shape) != tuple(stored["shape"]) or g.dtype != want:
-        raise ParityError(f"part {key}: replayed output {g.dtype}{g.shape} does not fit the stored {want}{tuple(stored['shape'])}")
-      writes.append((offsets[key] + stored["data"][0], np.ascontiguousarray(g).tobytes()))
-  shutil.copyfile(path, out)
-  with open(out, "r+b") as f:
-    for offset, data in writes:
-      f.seek(offset)
-      f.write(data)
-
-
-def main(argv: list[str]) -> int:
-  if len(argv) < 2 or argv[0] not in ("check", "record") or (argv[0] == "record" and len(argv) != 3):
-    print("usage: mock_parity check ARTIFACT... | record ARTIFACT OUT", file=sys.stderr)
-    return 2
-  try:
-    if argv[0] == "record":
-      st = time.perf_counter()
-      record(argv[1], argv[2])
-      print(f"{argv[2]}: check frame recorded on the mock in {time.perf_counter() - st:.0f}s")
-      return 0
-    for path in argv[1:]:
-      st = time.perf_counter()
-      check(path)
-      print(f"{os.path.basename(path)}: bit-identical to its {HARDWARE} check frame on the {'mock' if ON_MOCK else 'device'} ({time.perf_counter() - st:.0f}s)")
-    return 0
-  except ParityError as e:
-    print(f"PARITY FAIL: {e}", file=sys.stderr)
-    return 1
-
-
-if __name__ == "__main__":
-  sys.exit(main(sys.argv[1:]))
@@ -11,7 +11,7 @@ import pickle
 import numpy as np

 from openpilot.common.basedir import BASEDIR
-from openpilot.sunnypilot.modeld_v2.frame_fusion import host_shapes, pack_layout
+from openpilot.sunnypilot.modeld_v2.frame_fusion import pack_layout
 from openpilot.sunnypilot.modeld_v2.helpers import load_model
 from openpilot.sunnypilot.modeld_v2.compile_modeld import (POLICY_INPUTS, derive_frame_skip,
                                                           make_split_input_queues, make_supercombo_input_queues)
@@ -172,7 +172,7 @@ class NativeTinygradAdapter(BaseModelAdapter):

    self.input_queues = {name: Tensor(np.zeros(shape, dtype=dtype), device=self.model_device).realize()
                         for name, (shape, dtype) in self.input_shapes.items() if name in self.state_pairs}
-    shapes = host_shapes({name: shape for name, (shape, _) in self.input_shapes.items()}, self.state_pairs)
+    shapes = {name: shape for name, (shape, _) in self.input_shapes.items() if name not in self.state_pairs and name != 'new_img'}
    offsets, packed = pack_layout(shapes, self.warp_frame_size)
    self.packed_input = np.zeros(packed, dtype=np.uint8)
    self.host = Tensor(self.packed_input, device='NPY')
@@ -44,7 +44,6 @@ from openpilot.sunnypilot.modeld_v2.blendful import Blendful
 from openpilot.sunnypilot.modeld_v2.constants import ModelConstants, Plan
 from openpilot.sunnypilot.modeld_v2.meta_helper import load_meta_constants
 from openpilot.sunnypilot.modeld_v2.camera_offset_helper import CameraOffsetHelper
-from openpilot.sunnypilot.modeld_v2.light_frame import get_light_warp_matrix
 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld_v2.modeld_base import ModelStateBase
 from openpilot.sunnypilot.modeld_v2.helpers import load_model
@@ -172,7 +171,7 @@ class ModelState(ModelStateBase):
      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', 'speed_limit'):
+    for key in ('traffic_convention', 'lateral_control_params', 'action_t'):
      if key in self.numpy_inputs and key in inputs:
        self.numpy_inputs[key][:] = inputs[key]

@@ -180,8 +179,6 @@ class ModelState(ModelStateBase):
      for i, key in enumerate(self._vision_input_names):
        if key in transforms:
          self.numpy_inputs['tfm'][i] = transforms[key].reshape(3, 3)
-      if 'light_tfm' in self.numpy_inputs and 'light' in transforms:
-        self.numpy_inputs['light_tfm'][0] = transforms['light'].reshape(3, 3)
    else:
      self.numpy_inputs['tfm'][:, :] = transforms[self._road_key].reshape(3, 3)
      self.numpy_inputs['big_tfm'][:, :] = transforms[self._wide_key].reshape(3, 3)
@@ -341,7 +338,7 @@ def main(demo=False):
  pub_socks = ["modelV2", "drivingModelData", "cameraOdometry", "modelDataV2SP"] + (["chestnutGpuState"] if CHESTNUT else [])
  pm = PubMaster(pub_socks)
  sm = SubMaster(["deviceState", "carState", "narrowRoadCameraState", "extrinsicsCalibration", "driverMonitoringState",
-                  "carControl", "controlsState", "lateralDelay", "longitudinalPlanSP"])
+                  "carControl", "controlsState", "lateralDelay"])

  publish_state = PublishState()
  chestnut_state = ChestnutGpuState(pm, model.chestnut) if CHESTNUT else None
@@ -354,7 +351,6 @@ def main(demo=False):

  model_transform_main = np.zeros((3, 3), dtype=np.float32)
  model_transform_extra = np.zeros((3, 3), dtype=np.float32)
-  model_transform_light = np.zeros((3, 3), dtype=np.float32)
  live_calib_seen = False
  buf_main, buf_extra = None, None
  meta_main = FrameMeta()
@@ -429,7 +425,6 @@ def main(demo=False):
      model_transform_main = get_warp_matrix(device_from_calib_euler, main_intrinsics, False).astype(np.float32)
      model_transform_extra = get_warp_matrix(device_from_calib_euler, dc.wide_road.intrinsics, True).astype(np.float32)
      model_transform_main, model_transform_extra = camera_offset_helper.update(model_transform_main, model_transform_extra, sm, main_wide_camera)
-      model_transform_light = get_light_warp_matrix(device_from_calib_euler, main_intrinsics)
      live_calib_seen = True

    traffic_convention = np.zeros(2)
@@ -451,7 +446,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}
-    transforms['light'] = model_transform_light

    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)
@@ -469,10 +463,6 @@ def main(demo=False):
    if 'action_t' in model.numpy_inputs:
      inputs['action_t'] = np.array([lat_action_t, long_action_t], dtype=np.float32)

-    if 'speed_limit' in model.numpy_inputs:
-      resolver = sm['longitudinalPlanSP'].speedLimit.resolver
-      inputs['speed_limit'] = np.array([resolver.speedLimitFinal if resolver.speedLimitValid else 0.0], dtype=np.float32)
-
    mt1 = time.perf_counter()
    try:
      send_chestnut = (chestnut_state is not None and
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c08cffa27671d6773e316fdf4dcab80ffce2c4cc6fa28775615bc6726a63d7ba
-size 3473263
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6cddff2e3320057735fd4812d1ef9cc7d6d9fe405e3b6e7c4df85ee654a0e886
-size 7699823
@@ -80,8 +80,7 @@ def serialize_jit(jit, kernel_linear, check: dict | None = None) -> tuple[dict,
    if ast.op is Ops.PROGRAM:
      elf, info = ast.to_elf(), ast.arg
      global_size, local_size = info.launch_dims({})
-      device_target = dataclasses.asdict(dataclasses.replace(elf.target, interface=elf.target.interface.removeprefix("MOCK")))
-      calls.append({"kind": "program", "name": elf.name, "lib": blob.add(bytes(elf.lib)), "target": device_target,
+      calls.append({"kind": "program", "name": elf.name, "lib": blob.add(bytes(elf.lib)), "target": dataclasses.asdict(elf.target),
                    "signature": kernel_signature(ast, elf),
                    "global_size": [int(x) for x in global_size], "local_size": [int(x) for x in local_size],
                    "globals": list(info.globals), "outs": list(info.outs), "ins": list(info.ins), "args": arguments})
@@ -6,7 +6,6 @@ See the LICENSE.md file in the root directory for more details.
 """
 import os
 import re
-import struct
 import sys
 import tempfile
 import unittest
@@ -26,8 +25,8 @@ if sys.platform == "darwin" and os.environ.get("DEV", "").startswith("MOCKUSB"):

 from openpilot.common.test import OpenpilotTestCase
 from openpilot.sunnypilot.modeld_v2 import convert_upstream_pkl
-from openpilot.sunnypilot.modeld_v2.convert_upstream_pkl import _elf, convert
-from openpilot.sunnypilot.modeld_v2.helpers import ALIGNMENT, PlainJit, load_model
+from openpilot.sunnypilot.modeld_v2.convert_upstream_pkl import convert
+from openpilot.sunnypilot.modeld_v2.helpers import PlainJit, load_model
 from openpilot.sunnypilot.modeld_v2.plain_artifact_compiler import capture_frame

 IMG, DESIRE, STATE, OUT = (6, 8, 8), (8,), (4, 16), (1, 32)
@@ -120,18 +119,3 @@ class TestConvertUpstreamPkl(OpenpilotTestCase):
    bundle = load_model(out, cache=False, verify=True)
    assert bundle["metadata"] == {"name": "tiny"} and bundle["input_specs"] == self.input_specs and bundle["output_specs"] == self.output_specs
    self.assert_matches_eager(bundle["run"], 6)
-
-
-class TestKernelElf(OpenpilotTestCase):
-  def test_sections_follow_the_code(self):
-    from tinygrad.runtime.support.elf import elf_loader
-    code = bytes(range(1, 129))
-    for rodata, entry in ((len(code), 0), (0, 256)):
-      image = bytearray(code + bytes(64) if entry < rodata else bytes(256) + code)
-      struct.pack_into("<q", image, rodata + 16, entry - rodata)
-      loaded, sections, _ = elf_loader(_elf(bytes(image), rodata, entry))
-      headers = {section.name: section.header for section in sections}
-      assert bytes(loaded[ALIGNMENT:]) == bytes(image), "the uploaded program differs from the pickle's"
-      assert headers[".rodata"].sh_addr == ALIGNMENT + rodata, "the loader reads the kernel descriptor at .rodata"
-      text = headers[".text"]
-      assert text.sh_addr <= ALIGNMENT + entry < text.sh_addr + text.sh_size, "the amd mock sizes the code from the entry to the end of .text"
@@ -17,4 +17,4 @@ class TestRegistryModels(unittest.TestCase):
      self.skipTest("MODEL_BASE_NAME env var not set, skipping integration test.")
    bundle = load_model(os.path.join(os.environ.get("MODEL_DIR", "/tmp/models"), base_name), {"QCOM": "CPU", "AMD": "CPU"}, verify=False, cache=False)
    jits = [value for value in bundle.values() if isinstance(value, PlainJit)]
-    assert "metadata" in bundle and jits and all(len(jit.captured._linear.src) > 0 for jit in jits)
+    assert "metadata" in bundle and jits and all(len(jit.captured.linear.src) > 0 for jit in jits)
@@ -103,7 +103,9 @@ def setup_interfaces(CI: CarInterfaceBase, params: Params | None = None) -> None


 def initialize_params(params) -> list[dict[str, Any]]:
-  keys: list = []
+  keys: list = [
+    "SmoothStopSP",
+  ]

  # hyundai
  keys.extend([
@@ -126,6 +128,7 @@ def initialize_params(params) -> list[dict[str, Any]]:
  keys.extend([
    "ToyotaEnforceStockLongitudinal",
    "ToyotaStopAndGoHack",
+    "ToyotaEnhancedBsm",
    "ToyotaTSS2Smooth",
  ])

@@ -12,11 +12,13 @@ from openpilot.cereal import log, custom
 from opendbc.car import structs
 from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
+from openpilot.selfdrive.controls.lib.longcontrol import LongControl
 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_torque_v0 import LatControlTorque as LatControlTorqueV0
+from openpilot.sunnypilot.selfdrive.controls.lib.longcontrol_sp import LongControlSP


 class ControlsExt(ModelStateBase):
@@ -34,6 +36,11 @@ class ControlsExt(ModelStateBase):
    self.sm_services_ext = ['radarState', 'selfdriveStateSP']
    self.pm_services_ext = ['carControlSP']

+  def initialize_longitudinal_control(self, lo_c: LongControl) -> LongControl:
+    if self.CP_SP.smoothStopDecelRate > 0.0:
+      return LongControlSP(self.CP, self.CP_SP)
+    return lo_c
+
  def initialize_lateral_control(self, lac, CI, dt):
    enforce_torque_control = self.params.get_bool("EnforceTorqueControl")
    torque_versions = self.params.get("TorqueControlTune")
@@ -0,0 +1,57 @@
+"""
+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 openpilot.common.realtime import DT_CTRL
+from openpilot.selfdrive.controls.lib.longcontrol import LongControl, LongCtrlState
+
+TAPER_JERK = 0.25
+TAPER_MAX_DECEL = 1.0
+STALL_TIME = 1.0
+MAX_JERK = 2.0
+
+
+class LongControlSP(LongControl):
+  def __init__(self, CP, CP_SP):
+    super().__init__(CP, CP_SP)
+    self.was_tapering = False
+    self.stopping_time = 0.0
+
+  def update(self, active, CS, a_target, should_stop, accel_limits):
+    prev_output_accel = self.last_output_accel
+    smooth_stop = self.CP_SP.smoothStopDecelRate > 0.0
+
+    tapering = smooth_stop and not should_stop and -TAPER_MAX_DECEL < a_target < 0.0
+    if tapering:
+      accel_limits = (max(accel_limits[0], -float(np.sqrt(2.0 * TAPER_JERK * max(CS.vEgo, 0.0)))), accel_limits[1])
+
+    output_accel = super().update(active, CS, a_target, should_stop, accel_limits)
+
+    if smooth_stop:
+      if self.long_control_state == LongCtrlState.stopping:
+        output_accel = self.stopping_accel(prev_output_accel, CS, accel_limits)
+      elif self.long_control_state == LongCtrlState.pid and (tapering or self.was_tapering):
+        max_change = MAX_JERK * DT_CTRL
+        output_accel = float(np.clip(output_accel, prev_output_accel - max_change, prev_output_accel + max_change))
+      self.last_output_accel = output_accel
+
+    if self.long_control_state != LongCtrlState.stopping:
+      self.stopping_time = 0.0
+    self.was_tapering = tapering
+    return float(output_accel)
+
+  def stopping_accel(self, accel, CS, accel_limits):
+    self.stopping_time += DT_CTRL
+    if CS.standstill or self.stopping_time > STALL_TIME:
+      if accel > self.CP.stopAccel:
+        accel = min(accel, 0.0) - self.CP_SP.smoothStopDecelRate * DT_CTRL
+    else:
+      target = -float(np.sqrt(2.0 * TAPER_JERK * max(CS.vEgo, 0.0)))
+      max_change = MAX_JERK * DT_CTRL
+      accel = min(accel, 0.0)
+      accel += float(np.clip(target - accel, -max_change, max_change))
+    return float(np.clip(accel, *accel_limits))
@@ -0,0 +1,165 @@
+"""
+Copyright (c) 2021-, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+from types import SimpleNamespace
+
+import pytest
+
+from opendbc.car.structs import car
+from openpilot.common.realtime import DT_CTRL
+from openpilot.cereal import custom
+from openpilot.selfdrive.controls.lib.longcontrol import LongCtrlState
+from openpilot.sunnypilot.selfdrive.controls.lib.longcontrol_sp import LongControlSP, MAX_JERK, STALL_TIME, TAPER_JERK, TAPER_MAX_DECEL
+
+SMOOTH_STOP_DECEL_RATE = 0.3
+
+LIMITS = (-3.0, 2.0)
+
+
+def make_control(stop_accel=-2.0, rate=SMOOTH_STOP_DECEL_RATE):
+  CP = car.CarParams.new_message()
+  CP.stopAccel = stop_accel
+  CP.longitudinalTuning.kiBP = [0.0]
+  CP.longitudinalTuning.kiV = [0.0]
+  CP_SP = custom.CarParamsSP.new_message()
+  CP_SP.smoothStopDecelRate = rate
+  return LongControlSP(CP, CP_SP)
+
+
+def make_cs(v_ego, a_ego=0.0, standstill=False, cruise_standstill=False):
+  return SimpleNamespace(vEgo=v_ego, aEgo=a_ego, brakePressed=False, standstill=standstill,
+                         cruiseState=SimpleNamespace(standstill=cruise_standstill))
+
+
+def start_stopping(loc, a_target=-0.5):
+  for _ in range(100):
+    loc.update(True, make_cs(0.5, a_target), a_target, False, LIMITS)
+  return loc.update(True, make_cs(0.3, a_target), a_target, True, LIMITS)
+
+
+def test_decel_ramps_at_stopping_rate():
+  loc = make_control()
+  out = start_stopping(loc)
+  assert loc.long_control_state == LongCtrlState.stopping
+  for _ in range(100):
+    prev, out = out, loc.update(True, make_cs(0.0, standstill=True), -0.5, True, LIMITS)
+    assert out == pytest.approx(prev - SMOOTH_STOP_DECEL_RATE * DT_CTRL)
+
+
+def test_no_step_at_handover():
+  loc = make_control()
+  for _ in range(100):
+    out = loc.update(True, make_cs(0.5, -0.5), -0.5, False, LIMITS)
+  assert abs(loc.update(True, make_cs(0.3, -0.5), -0.5, True, LIMITS) - out) <= MAX_JERK * DT_CTRL + 1e-6
+
+
+def test_decel_only_grows_after_standstill():
+  loc = make_control()
+  start_stopping(loc)
+  outs = [loc.update(True, make_cs(0.0, standstill=True), -0.5, True, LIMITS) for _ in range(300)]
+  assert all(b <= a for a, b in zip(outs, outs[1:], strict=False))
+
+
+def test_stops_at_stop_accel():
+  loc = make_control(-1.5)
+  start_stopping(loc)
+  for _ in range(int(10.0 / DT_CTRL)):
+    out = loc.update(True, make_cs(0.0, standstill=True), -0.5, True, LIMITS)
+  assert out == pytest.approx(-1.5, abs=0.01)
+
+
+def test_positive_output_starts_from_zero():
+  loc = make_control()
+  loc.update(True, make_cs(0.5), 0.3, False, LIMITS)
+  assert start_stopping(loc, a_target=0.3) <= 0.0
+
+
+def test_repeatable():
+  runs = []
+  for _ in range(2):
+    loc = make_control()
+    runs.append([start_stopping(loc)] + [loc.update(True, make_cs(0.1), -0.5, True, LIMITS) for _ in range(300)])
+  assert runs[0] == runs[1]
+
+
+def test_disabled_uses_stock_stopping_behavior():
+  loc = make_control(rate=0.0)
+  start_stopping(loc)
+  prev = loc.last_output_accel
+  assert loc.update(True, make_cs(0.1), -0.5, True, LIMITS) == pytest.approx(prev - 1.0 * DT_CTRL)
+
+
+@pytest.mark.parametrize("rate", [0.3, 0.8, 2.0])
+def test_rate_comes_from_car_params(rate):
+  loc = make_control(rate=rate)
+  out = start_stopping(loc)
+  assert loc.update(True, make_cs(0.0, standstill=True), -0.5, True, LIMITS) == pytest.approx(out - rate * DT_CTRL)
+
+
+def settle(loc, v, a_target, frames=600):
+  for _ in range(frames):
+    out = loc.update(True, make_cs(v, a_target), a_target, False, LIMITS)
+  return out
+
+
+def test_gentle_braking_fades_with_speed():
+  loc = make_control()
+  outs = [settle(loc, v, -0.6) for v in (1.0, 0.4, 0.15, 0.05)]
+  assert outs[0] < outs[1] < outs[2] < outs[3]
+  assert abs(outs[3]) < 0.2
+
+
+def test_decel_never_exceeds_profile_while_tapering():
+  loc = make_control()
+  for v in (0.8, 0.5, 0.2, 0.1):
+    assert settle(loc, v, -0.6) >= -((2.0 * TAPER_JERK * v) ** 0.5) - 1e-6
+
+
+def test_hard_braking_is_not_tapered():
+  loc = make_control()
+  target = -(TAPER_MAX_DECEL + 0.5)
+  assert settle(loc, 0.1, target) <= target
+
+
+def test_taper_off_without_smooth_stop():
+  loc = make_control(rate=0.0)
+  assert settle(loc, 0.1, -0.6) <= -0.6
+
+
+def test_taper_never_steps_the_output():
+  loc = make_control()
+  prev, v = None, 1.0
+  for target in [-1.2] * 30 + [-0.9] * 300:
+    v = max(v - 0.4 * DT_CTRL, 0.1)
+    out = loc.update(True, make_cs(v, -0.4), target, False, LIMITS)
+    if prev is not None:
+      assert abs(out - prev) <= MAX_JERK * DT_CTRL + 1e-6
+    prev = out
+
+
+def test_stopping_follows_taper_until_standstill():
+  loc = make_control()
+  start_stopping(loc)
+  for _ in range(50):
+    out = loc.update(True, make_cs(0.1, -0.3), -0.5, True, LIMITS)
+  assert out == pytest.approx(-((2.0 * TAPER_JERK * 0.1) ** 0.5), abs=0.01)
+
+
+def test_stopping_ramps_only_after_standstill():
+  loc = make_control()
+  start_stopping(loc)
+  for _ in range(50):
+    out = loc.update(True, make_cs(0.1, -0.3), -0.5, True, LIMITS)
+  after = loc.update(True, make_cs(0.0, standstill=True), -0.5, True, LIMITS)
+  assert after == pytest.approx(out - SMOOTH_STOP_DECEL_RATE * DT_CTRL)
+
+
+def test_creeping_car_is_eventually_braked():
+  loc = make_control()
+  start_stopping(loc)
+  for _ in range(int((STALL_TIME + 5.0) / DT_CTRL)):
+    out = loc.update(True, make_cs(0.1, -0.1), -0.5, True, LIMITS)
+  assert out < -0.5
@@ -13,6 +13,7 @@ from opendbc.car.subaru.values import CAR as SUBARU_CAR, SubaruFlags
 from opendbc.car.toyota.values import CAR as TOYOTA_CAR, ToyotaFlags
 from opendbc.sunnypilot.car.interfaces import has_bsm
 from opendbc.sunnypilot.car.tesla.values import TeslaFlagsSP
+from opendbc.sunnypilot.car.toyota.values import ToyotaFlagsSP
 from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
 from openpilot.common.hardware import HARDWARE
@@ -44,6 +45,7 @@ CAPABILITY_FIELDS = (
  "device_type",
  "subaru_has_sng",
  "hyundai_alpha_long_available",
+  "toyota_enhanced_bsm_available",
  "toyota_tss2",
  "custom_model_active",
 )
@@ -68,6 +70,7 @@ CAPABILITY_LABELS: dict[str, str] = {
  "device_type": "Device type",
  "subaru_has_sng": "Subaru Stop-and-Go available",
  "hyundai_alpha_long_available": "Hyundai Alpha Longitudinal available",
+  "toyota_enhanced_bsm_available": "Toyota Enhanced BSM available",
  "toyota_tss2": "Toyota TSS2 platform",
  "custom_model_active": "Non-Default model selected",
 }
@@ -89,6 +92,7 @@ CAR_CAPABILITY_FIELDS = (
  "subaru_has_sng",
  "hyundai_alpha_long_available",
  "toyota_tss2",
+  "toyota_enhanced_bsm_available",
 )

 # Explicit defaults for non-boolean capability fields
@@ -104,7 +108,7 @@ def _bundle_field(bundle: dict | None, key: str) -> str:
  return bundle.get(key, "") if isinstance(bundle, dict) else ""


-def _resolve_brand_capabilities(caps: dict, bundle_platform: str, CP) -> None:
+def _resolve_brand_capabilities(caps: dict, bundle_platform: str, CP, CP_SP=None) -> None:
  """Set brand-specific capabilities from bundle platform or CarParams fallback.

  Bundle (manual car selection) is a pre-fingerprint approximation.
@@ -138,11 +142,18 @@ def _resolve_brand_capabilities(caps: dict, bundle_platform: str, CP) -> None:
  elif brand == "toyota":
    if bundle_platform:
      try:
-        caps["toyota_tss2"] = bool(TOYOTA_CAR[bundle_platform].config.flags & ToyotaFlags.TSS2)
+        flags = TOYOTA_CAR[bundle_platform].config.flags
+        caps["toyota_tss2"] = bool(flags & ToyotaFlags.TSS2)
+        caps["toyota_enhanced_bsm_available"] = bool(flags & ToyotaFlags.TSS2) and not bool(flags & ToyotaFlags.SECOC)
      except KeyError:
        cloudlog.exception(f"capabilities: unknown toyota platform {bundle_platform!r}")
    elif CP is not None:
      caps["toyota_tss2"] = bool(CP.flags & ToyotaFlags.TSS2)
+      # same gate as _initialize_toyota: TSS2 without SecOC, or TSS-P with a smartDSU and openpilot
+      # longitudinal control (the bundle path can't see 0x2FF, so it stays TSS2-only)
+      sdsu_bsm = CP_SP is not None and bool(CP_SP.flags & ToyotaFlagsSP.SMART_DSU) and bool(CP.openpilotLongitudinalControl)
+      caps["toyota_enhanced_bsm_available"] = (not bool(CP.flags & ToyotaFlags.SECOC) and
+                                               (bool(CP.flags & ToyotaFlags.TSS2) or sdsu_bsm))


 def generate_capabilities(params: Params | None = None) -> dict:
@@ -217,7 +228,7 @@ def generate_capabilities(params: Params | None = None) -> dict:
  if CP is not None:
    caps["has_bsm"] = has_bsm(CP, CP_SP)

-  _resolve_brand_capabilities(caps, bundle_platform, CP)
+  _resolve_brand_capabilities(caps, bundle_platform, CP, CP_SP)

  return caps

@@ -156,7 +156,7 @@ The tables below describe the **compiled** `settings_ui.json` schema — what th

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

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

 ---

@@ -633,6 +633,23 @@
                }
              ]
            },
+            {
+              "key": "SmoothStopSP",
+              "widget": "toggle",
+              "needs_onroad_cycle": true,
+              "title": "Smooth Stop",
+              "description": "Brakes gently as sunnypilot comes to a final stop to reduce the lurch at the end. Applies to all vehicles with sunnypilot longitudinal control.",
+              "enablement": [
+                {
+                  "type": "not_engaged"
+                },
+                {
+                  "type": "capability",
+                  "field": "has_longitudinal_control",
+                  "equals": true
+                }
+              ]
+            },
            {
              "key": "IntelligentCruiseButtonManagement",
              "widget": "toggle",
@@ -1412,6 +1429,12 @@
                }
              ]
            },
+            {
+              "key": "TripSummary",
+              "widget": "toggle",
+              "title": "Trip Summary",
+              "description": "Show a summary of distance and engagement when you shift into park after a drive."
+            },
            {
              "key": "RocketFuel",
              "widget": "toggle",
@@ -2361,6 +2384,28 @@
            }
          ]
        },
+        {
+          "key": "ToyotaEnhancedBsm",
+          "widget": "toggle",
+          "needs_onroad_cycle": true,
+          "title": "Enhanced Blind Spot Monitoring (Alpha)",
+          "description": "sunnypilot will poll the blind spot monitor diagnostics directly from the radar. Use this on vehicles whose blind spot monitors do not report blind spot status over the standard CAN signals. This is an alpha feature. Use at your own risk.",
+          "enablement": [
+            {
+              "type": "not_engaged"
+            },
+            {
+              "type": "capability",
+              "field": "toyota_enhanced_bsm_available",
+              "equals": true
+            },
+            {
+              "type": "capability",
+              "field": "stock_longitudinal",
+              "equals": false
+            }
+          ]
+        },
        {
          "key": "ToyotaTSS2Smooth",
          "widget": "toggle",
@@ -36,6 +36,16 @@ sections:
    description: "Adds a small push on top of sunnypilot's own acceleration, stronger in Aggressive and gentler in Relaxed. Eases off in curves and when sunnypilot slows or stops. Never goes past your set speed, and lead-car following still comes first."
    enablement:
    - $ref: '#/macros/longitudinal'
+  - key: SmoothStopSP
+    widget: toggle
+    needs_onroad_cycle: true
+    title: Smooth Stop
+    description: Brakes gently as sunnypilot comes to a final stop to reduce the lurch at the end. Applies to all vehicles with sunnypilot longitudinal control.
+    enablement:
+    - type: not_engaged
+    - type: capability
+      field: has_longitudinal_control
+      equals: true
  - key: IntelligentCruiseButtonManagement
    widget: toggle
    title: Intelligent Cruise Button Management (ICBM) (Alpha)
@@ -101,6 +101,21 @@ sections:
    - type: param
      key: ToyotaEnforceStockLongitudinal
      equals: false
+  - key: ToyotaEnhancedBsm
+    widget: toggle
+    needs_onroad_cycle: true
+    title: Enhanced Blind Spot Monitoring (Alpha)
+    description: sunnypilot will poll the blind spot monitor diagnostics directly from the radar. Use this on vehicles whose
+      blind spot monitors do not report blind spot status over the standard CAN signals. This is an alpha feature. Use at
+      your own risk.
+    enablement:
+    - $ref: '#/macros/not_engaged'
+    - type: capability
+      field: toyota_enhanced_bsm_available
+      equals: true
+    - type: capability
+      field: stock_longitudinal
+      equals: false
  - key: ToyotaTSS2Smooth
    widget: toggle
    needs_onroad_cycle: true
@@ -39,6 +39,10 @@ sections:
    description: Show a timer on the HUD when the car is at a standstill.
    visibility:
    - $ref: '#/macros/hide_on_mici'
+  - key: TripSummary
+    widget: toggle
+    title: Trip Summary
+    description: Show a summary of distance and engagement when you shift into park after a drive.
  - key: RocketFuel
    widget: toggle
    title: Real-time Acceleration Bar
@@ -70,12 +70,18 @@ class TestOpaquePerBrandFlags(OpenpilotTestCase):
  def test_hyundai_alpha_long_available_field_present(self):
    assert "hyundai_alpha_long_available" in CAPABILITY_FIELDS

+  def test_toyota_enhanced_bsm_available_field_present(self):
+    assert "toyota_enhanced_bsm_available" in CAPABILITY_FIELDS
+
  def test_subaru_has_sng_default_false(self, caps):
    assert caps["subaru_has_sng"] is False

  def test_hyundai_alpha_long_available_default_false(self, caps):
    assert caps["hyundai_alpha_long_available"] is False

+  def test_toyota_enhanced_bsm_available_default_false(self, caps):
+    assert caps["toyota_enhanced_bsm_available"] is False
+
  def test_toyota_tss2_field_present(self):
    assert "toyota_tss2" in CAPABILITY_FIELDS

@@ -207,6 +207,7 @@ class TestNotEngagedReplacement(OpenpilotTestCase):
    "AlphaLongitudinalEnabled",
    "ToyotaEnforceStockLongitudinal",
    "ToyotaStopAndGoHack",
+    "ToyotaEnhancedBsm",
    "ToyotaTSS2Smooth",
  ], names=["key"])
  def test_offroad_only_replaced_with_not_engaged(self, schema, key):
@@ -286,6 +286,7 @@ class TestKnownVehicleSettings(OpenpilotTestCase):
    keys = {i["key"] for i in _brand_items(schema["vehicle_settings"].get("toyota"))}
    assert "ToyotaEnforceStockLongitudinal" in keys
    assert "ToyotaStopAndGoHack" in keys
+    assert "ToyotaEnhancedBsm" in keys
    assert "ToyotaTSS2Smooth" in keys

  def test_tesla_has_coop_steering(self, schema):
@@ -13,41 +13,26 @@ from pathlib import Path
 from datetime import datetime, UTC


-_VERSION_REGEX = re.compile(r'^(?:\d+[a-zA-Z]+|\d+[vVbB]\d+|[vVbB]\d+|\d{4})$')
-_DECIMAL_VERSION_REGEX = re.compile(r'^([vVbB]?)(\d+(?:\.\d+)+)$')
-
-
-def _version(word: str) -> str | None:
-  match = _DECIMAL_VERSION_REGEX.match(word.strip('()[]{}.,;:'))
-  if match:
-    return match.group(1).upper() + match.group(2)
-  stripped = re.sub(r'[^a-zA-Z0-9]', '', word)
-  return stripped.upper() if _VERSION_REGEX.match(stripped) else None
-
-
-def _truncate(short_name: str) -> str:
-  return short_name[:8].rstrip('.')
-
-
 def create_short_name(full_name: str) -> str:
-  # Remove parentheses and extract alphanumeric words, keeping decimals for versioning
+  # Remove parentheses and extract alphanumeric words
  clean_name = re.sub(r'\([^)]*\)', '', full_name)
-  words = [re.sub(r'[^a-zA-Z0-9.]', '', word) for word in clean_name.split()]
-  words = [word for word in words if word]
+  words = [re.sub(r'[^a-zA-Z0-9]', '', word) for word in clean_name.split() if re.sub(r'[^a-zA-Z0-9]', '', word)]

  if len(words) == 1:
-    return _truncate((_version(words[0]) or words[0]).upper())
+    return words[0][:8].upper()

-  # Handle special case: Name + Version (e.g., "Word A1" -> "WordA1", "Model v1.1" -> "ModelV1.1")
-  if len(words) == 2 and re.match(r'^[A-Za-z]?\d+$', words[1]):
-    return _truncate((words[0] + (_version(words[1]) or words[1])).upper())
+  # Handle special case: Name + Version (e.g., "Word A1" -> "WordA1")
+  if len(words) == 2 and re.match(r'^[A-Za-z]\d+$', words[1]):
+    return (words[0] + words[1])[:8].upper()

  result = ""
  for word in words:
    # Version or number patterns
-    version = _version(word)
-    if version:
-      result += version
+    if (re.match(r'^\d+[a-zA-Z]+$', word) or
+        re.match(r'^\d+[vVbB]\d+$', word) or
+        re.match(r'^[vVbB]\d+$', word) or
+        re.match(r'^\d{4}$', word)):
+      result += word.upper()
    # All uppercase abbreviations (2-3 letters)
    elif re.match(r'^[A-Z]{2,3}$', word):
      result += word
@@ -60,7 +45,7 @@ def create_short_name(full_name: str) -> str:
      result += word
    else:
      result += word[0].upper()
-  return _truncate(result)
+  return result[:8]


 def create_pkl_name(full_name: str) -> str:
Author	SHA1	Message	Date
rav4kumar	7feeda0ca4	ramp after stop	2026-11-08 14:10:02 -07:00
rav4kumar	6443f0f266	fede with speed	2026-11-07 10:49:54 -07:00
rav4kumar	4629ac0a8e	ref	2026-11-05 13:31:28 -07:00
rav4kumar	13838673e2	rate based final stop	2026-11-05 13:31:28 -07:00
rav4kumar	696c223033	trip-summary	2026-11-05 11:28:47 -07:00
rav4kumar	1b0e466e2f	boooooost-ui	2026-11-05 11:28:31 -07:00
Kumar	5958b2d25b	Merge branch 'master' into toyota-bsm	2026-11-05 11:26:28 -07:00
Kumar	73c8b30fa9	Merge branch 'master' into toyota-bsm	2026-11-04 12:14:55 -07:00
rav4kumar	8bdb2f54d9	Merge branch 'master' into toyota-bsm	2026-11-03 10:37:16 -07:00
rav4kumar	9c1bdde65b	toyota: enable the enhanced BSM toggle for TSS-P cars with a smartDSU	2026-11-03 10:31:07 -07:00
Kumar	914aaefac1	Merge branch 'master' into toyota-bsm	2026-10-26 11:35:14 -07:00
rav4kumar	d05649c0a4	toyota: bump opendbc and fix BSM wiring	2026-10-26 11:32:51 -07:00
rav4kumar	3521140920	ref	2026-10-25 11:56:26 -07:00
rav4kumar	56628fc770	ref	2026-10-25 11:55:52 -07:00
rav4kumar	60a9cc8657	toyota: add Enhanced Blind Spot Monitoring setting	2026-10-25 11:55:32 -07:00