Update opendbc_repo

Merge branch 'master' into hens
Update opendbc_repo
2026-09-01 06:23:44 +08:00 · 2026-08-18 01:01:24 -04:00 · 2026-08-17 17:13:35 -04:00 · 2026-08-17 17:09:57 -04:00 · 2026-08-17 09:41:13 -04:00 · 2026-08-16 15:30:31 -04:00
80 changed files with 1119 additions and 3456 deletions
@@ -8,13 +8,13 @@ on:
        required: true
        type: string
      target_hardware:
-        description: 'Hardware target to compile for (qcom or chestnut)'
+        description: 'Hardware target to compile for (qcom or usbgpu)'
        required: true
        type: choice
        default: 'qcom'
        options:
          - qcom
-          - chestnut
+          - usbgpu
      hf_repo:
        description: 'Hugging Face dataset repository'
        required: false
@@ -59,7 +59,7 @@ jobs:
        id: get-json
        run: |
          cd docs/docs
-          PREFIX="driving_models_${{ inputs.target_hardware == 'chestnut' && 'chestnut_' || '' }}v"
+          PREFIX="driving_models_${{ inputs.target_hardware == 'usbgpu' && 'usbgpu_' || '' }}v"
          latest=$(ls ${PREFIX}*.json | sed -E "s/${PREFIX}([0-9]+)\.json/\1/" | sort -n | tail -1)
          next=$((latest+1))
          json_file="${PREFIX}${next}.json"
@@ -1,501 +0,0 @@
 name: Build default models
 on:
  workflow_dispatch:
    inputs:
      target:
        description: 'Model target to build'
        required: true
        type: choice
        options:
          - small
          - big
          - dm
  workflow_call:
    inputs:
      target:
        description: 'Model target to build (small, big, or dm)'
        required: true
        type: string
 concurrency:
  group: build-default-models-${{ inputs.target }}
  cancel-in-progress: false
 env:
  HF_REPO: sunnypilot/sunnypilot_models_v1
 jobs:
  resolve:
    runs-on: ubuntu-24.04
    outputs:
      model_name: ${{ steps.resolve.outputs.model_name }}
      onnx_ref: ${{ steps.resolve.outputs.onnx_ref }}
      onnx_path: ${{ steps.resolve.outputs.onnx_path }}
      hf_defaults_path: ${{ steps.resolve.outputs.hf_defaults_path }}
      tinygrad_ref: ${{ steps.resolve.outputs.tinygrad_ref }}
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - id: resolve
        run: |
          export PYTHONPATH=${{ github.workspace }}
          if [ "${{ inputs.target }}" = "big" ]; then
            NAME=$(python3 -c "from openpilot.sunnypilot.models.model_name import DEFAULT_BIG_MODEL; print(DEFAULT_BIG_MODEL)")
            ONNX_PATH="openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx"
            HF_DEFAULTS_PATH="models/defaults/big"
          elif [ "${{ inputs.target }}" = "dm" ]; then
            ONNX_PATH="openpilot/selfdrive/modeld/models/dmonitoring_model.onnx"
            HF_DEFAULTS_PATH="models/defaults/dm"
            NAME="dmonitoring_model ($(git log -1 --format=%cd --date=format:'%B %d, %Y' -- "$ONNX_PATH"))"
          else
            NAME=$(python3 -c "from openpilot.sunnypilot.models.model_name import DEFAULT_MODEL; print(DEFAULT_MODEL)")
            ONNX_PATH="openpilot/selfdrive/modeld/models/driving_supercombo.onnx"
            HF_DEFAULTS_PATH="models/defaults/small"
          fi
          ONNX_REF=$(git log -1 --format='%H' -- "$ONNX_PATH")
          TINYGRAD_REF=$(python3 openpilot/sunnypilot/models/tinygrad_ref.py)
          if [ -z "$TINYGRAD_REF" ]; then
            echo "::error::Failed to resolve tinygrad ref"
            exit 1
          fi
          echo "model_name=${NAME}" >> $GITHUB_OUTPUT
          echo "onnx_ref=${ONNX_REF}" >> $GITHUB_OUTPUT
          echo "onnx_path=${ONNX_PATH}" >> $GITHUB_OUTPUT
          echo "hf_defaults_path=${HF_DEFAULTS_PATH}" >> $GITHUB_OUTPUT
          echo "tinygrad_ref=${TINYGRAD_REF}" >> $GITHUB_OUTPUT
  build_small_model:
    needs: resolve
    if: ${{ inputs.target == 'small' }}
    runs-on: [self-hosted, tici]
    env:
      SMALL_ONNX: openpilot/selfdrive/modeld/models/driving_supercombo.onnx
      SMALL_PKL: openpilot/selfdrive/modeld/models/driving_tinygrad.pkl
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - name: Pull ONNX via LFS
        run: git lfs pull -I "${{ env.SMALL_ONNX }}"
      - name: Set environment variables
        run: |
          source /etc/profile
          export UV_PROJECT_ENVIRONMENT=${HOME}/venv
          export UV_PYTHON_PREFERENCE=managed
          export UV_PYTHON_INSTALL_DIR=${HOME}/uv/python
          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
          uv sync --frozen
          printenv >> $GITHUB_ENV
      - name: Disable powersave
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --disable
      - name: Compile small model with stock compiler
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          export PYTHONPATH="${PYTHONPATH}:${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}"
          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}')")
          FRAME_SKIP=$(python3 -c "from openpilot.selfdrive.modeld.constants import ModelConstants as MC; print(MC.MODEL_RUN_FREQ // MC.MODEL_CONTEXT_FREQ)")
          TG_FLAGS="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
          env ${TG_FLAGS} python3 \
            ${{ github.workspace }}/openpilot/selfdrive/modeld/compile_modeld.py \
            --onnx ${{ github.workspace }}/${{ env.SMALL_ONNX }} \
            --model-size $MODEL_SIZE \
            --camera-resolutions $CAMERA_RES \
            --frame-skip $FRAME_SKIP \
            --output ${{ github.workspace }}/${{ env.SMALL_PKL }}
      - name: Chunk small pkl
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          export PYTHONPATH=${{ github.workspace }}
          python3 -c "
          from openpilot.common.file_chunker import chunk_file, get_chunk_targets
          import os
          pkl = '${{ github.workspace }}/${{ env.SMALL_PKL }}'
          size = os.path.getsize(pkl)
          targets = get_chunk_targets(pkl, size)
          chunk_file(pkl, targets)
          print(f'Chunked into {len(targets)} files')
          "
      - name: Prepare output
        env:
          MODEL_NAME: ${{ needs.resolve.outputs.model_name }}
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          export PYTHONPATH=${{ github.workspace }}
          MODELS_DIR="${{ github.workspace }}/openpilot/selfdrive/modeld/models"
          OUTPUT_DIR="${{ github.workspace }}/small_output"
          PKL_BASE="driving_tinygrad.pkl"
          mkdir -p "$OUTPUT_DIR"
          cp "$MODELS_DIR/${PKL_BASE}".chunk* "$OUTPUT_DIR/"
          cp "$MODELS_DIR/${PKL_BASE}.chunkmanifest" "$OUTPUT_DIR/"
          python3 "${{ github.workspace }}/release/ci/model_generator.py" \
            --model-dir "$MODELS_DIR" \
            --output-dir "$OUTPUT_DIR" \
            --custom-name "$MODEL_NAME" \
            --upstream-branch "${{ needs.resolve.outputs.onnx_ref }}"
          echo "model-${MODEL_NAME}-${{ github.run_number }}" > "$OUTPUT_DIR/artifact_name.txt"
      - name: Upload small model artifact
        uses: actions/upload-artifact@v4
        with:
          name: model-${{ needs.resolve.outputs.model_name }}-${{ github.run_number }}
          path: ${{ github.workspace }}/small_output/
      - name: Upload artifact name file
        uses: actions/upload-artifact@v4
        with:
          name: artifact-name-${{ needs.resolve.outputs.model_name }}
          path: ${{ github.workspace }}/small_output/artifact_name.txt
      - name: Re-enable powersave
        if: always()
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --enable
  build_big_model:
    needs: resolve
    if: ${{ inputs.target == 'big' }}
    runs-on: [self-hosted, chestnut]
    env:
      BIG_ONNX: openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx
      BIG_PKL: openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - name: Pull big ONNX via LFS
        run: git lfs pull -I "${{ env.BIG_ONNX }}"
      - name: Set environment variables
        run: |
          source /etc/profile
          export UV_PROJECT_ENVIRONMENT=${HOME}/venv
          export UV_PYTHON_PREFERENCE=managed
          export UV_PYTHON_INSTALL_DIR=${HOME}/uv/python
          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
          uv sync --frozen
          printenv >> $GITHUB_ENV
      - name: Disable powersave
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --disable
      - name: Wait for chestnut PCIe link
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          export PYTHONPATH="${PYTHONPATH}:${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}"
          python3 -c "
          import time
          from openpilot.system.hardware.chestnut.flash import link_up
          for i in range(10):
              if link_up():
                  print(f'PCIe link up after {i+1} attempt(s)')
                  break
              time.sleep(1)
          else:
              raise RuntimeError('Chestnut PCIe link not ready after 10 attempts')
          "
      - name: Compile big model with stock compiler
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          export PYTHONPATH="${PYTHONPATH}:${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}"
          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}')")
          FRAME_SKIP=$(python3 -c "from openpilot.selfdrive.modeld.constants import ModelConstants as MC; print(MC.MODEL_RUN_FREQ // MC.MODEL_CONTEXT_FREQ)")
          TG_FLAGS="DEBUG=2 DEV=USB+AMD:LLVM WARP_DEV=QCOM FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2"
          env ${TG_FLAGS} python3 \
            ${{ github.workspace }}/openpilot/selfdrive/modeld/compile_modeld.py \
            --onnx ${{ github.workspace }}/${{ env.BIG_ONNX }} \
            --model-size $MODEL_SIZE \
            --camera-resolutions $CAMERA_RES \
            --frame-skip $FRAME_SKIP \
            --output ${{ github.workspace }}/${{ env.BIG_PKL }}
      - name: Chunk big pkl
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          export PYTHONPATH=${{ github.workspace }}
          python3 -c "
          from openpilot.common.file_chunker import chunk_file, get_chunk_targets
          import os
          pkl = '${{ github.workspace }}/${{ env.BIG_PKL }}'
          size = os.path.getsize(pkl)
          targets = get_chunk_targets(pkl, size)
          chunk_file(pkl, targets)
          print(f'Chunked into {len(targets)} files')
          "
      - name: Prepare output
        env:
          MODEL_NAME: ${{ needs.resolve.outputs.model_name }}
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          export PYTHONPATH=${{ github.workspace }}
          MODELS_DIR="${{ github.workspace }}/openpilot/selfdrive/modeld/models"
          OUTPUT_DIR="${{ github.workspace }}/big_output"
          PKL_BASE="big_driving_tinygrad.pkl"
          mkdir -p "$OUTPUT_DIR"
          cp "$MODELS_DIR/${PKL_BASE}".chunk* "$OUTPUT_DIR/"
          cp "$MODELS_DIR/${PKL_BASE}.chunkmanifest" "$OUTPUT_DIR/"
          python3 "${{ github.workspace }}/release/ci/model_generator.py" \
            --model-dir "$MODELS_DIR" \
            --output-dir "$OUTPUT_DIR" \
            --custom-name "$MODEL_NAME" \
            --upstream-branch "${{ needs.resolve.outputs.onnx_ref }}"
          echo "model-${MODEL_NAME}-${{ github.run_number }}" > "$OUTPUT_DIR/artifact_name.txt"
      - name: Upload big model artifact
        uses: actions/upload-artifact@v4
        with:
          name: model-${{ needs.resolve.outputs.model_name }}-${{ github.run_number }}
          path: ${{ github.workspace }}/big_output/
      - name: Upload artifact name file
        uses: actions/upload-artifact@v4
        with:
          name: artifact-name-${{ needs.resolve.outputs.model_name }}
          path: ${{ github.workspace }}/big_output/artifact_name.txt
      - name: Re-enable powersave
        if: always()
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --enable
  upload_defaults:
    needs: [ resolve, build_small_model, build_big_model, build_dm_model ]
    if: |
      ${{
        !cancelled() &&
        (inputs.target == 'big' && needs.build_big_model.result == 'success' ||
         inputs.target == 'small' && needs.build_small_model.result == 'success' ||
         inputs.target == 'dm' && needs.build_dm_model.result == 'success')
      }}
    runs-on: ubuntu-24.04
    permissions:
      id-token: write
      contents: write
    steps:
      - uses: actions/checkout@v4
      - name: Pull ONNX via LFS
        run: git lfs pull -I "${{ needs.resolve.outputs.onnx_path }}"
      - name: Install huggingface_hub
        run: pip install --upgrade "huggingface_hub>=0.22.0"
      - name: Download artifact name
        if: ${{ inputs.target == 'small' || inputs.target == 'big' }}
        uses: actions/download-artifact@v4
        with:
          name: artifact-name-${{ needs.resolve.outputs.model_name }}
          path: artifact_name
      - name: Read artifact name
        if: ${{ inputs.target == 'small' || inputs.target == 'big' }}
        id: artifact
        run: |
          ARTIFACT_NAME=$(cat artifact_name/artifact_name.txt)
          echo "artifact_name=$ARTIFACT_NAME" >> $GITHUB_OUTPUT
      - name: Download model artifact
        if: ${{ inputs.target == 'small' || inputs.target == 'big' }}
        uses: actions/download-artifact@v4
        with:
          name: ${{ steps.artifact.outputs.artifact_name }}
          path: output
      - name: Upload model to HF
        if: ${{ inputs.target == 'small' || inputs.target == 'big' }}
        env:
          HF_OIDC_RESOURCE: datasets/${{ env.HF_REPO }}
          ARTIFACT_NAME: ${{ steps.artifact.outputs.artifact_name }}
        run: |
          rm -f output/artifact_name.txt
          export PYTHONPATH=$(pwd)
          python3 release/ci/upload_default_model.py \
            --hf-repo "${{ env.HF_REPO }}" \
            --hf-defaults-path "${{ needs.resolve.outputs.hf_defaults_path }}" \
            --artifact-name "$ARTIFACT_NAME" \
            --model-dir output \
            --onnx-path "${{ needs.resolve.outputs.onnx_path }}" \
            --onnx-ref "${{ needs.resolve.outputs.onnx_ref }}" \
            --model-name "${{ needs.resolve.outputs.model_name }}" \
            --tinygrad-ref "${{ needs.resolve.outputs.tinygrad_ref }}" \
            --run-number "${{ github.run_number }}"
      - name: Download DM artifact
        if: ${{ inputs.target == 'dm' }}
        uses: actions/download-artifact@v4
        with:
          name: dm-model-${{ github.run_number }}
          path: dm_output
      - name: Generate DM metadata and upload to HF
        if: ${{ inputs.target == 'dm' }}
        env:
          HF_OIDC_RESOURCE: datasets/${{ env.HF_REPO }}
        run: |
          export PYTHONPATH=$(pwd)
          python3 -c "
          import json, hashlib
          from pathlib import Path
          from datetime import datetime, UTC
          dm_dir = Path('dm_output')
          manifest = list(dm_dir.glob('*.chunkmanifest'))
          assert manifest, 'No chunkmanifest found'
          pkl_name = manifest[0].name.removesuffix('.chunkmanifest')
          num_chunks = int(manifest[0].read_text().strip())
          chunks = []
          for i in range(num_chunks):
              chunk = dm_dir / f'{pkl_name}.chunk{i+1:02d}of{num_chunks:02d}'
              chunks.append({
                  'file_name': chunk.name,
                  'sha256': hashlib.sha256(chunk.read_bytes()).hexdigest()
              })
          digest = hashlib.sha256()
          for c in chunks:
              with open(dm_dir / c['file_name'], 'rb') as f:
                  while block := f.read(1024*1024):
                      digest.update(block)
          metadata = {
              'bundles': [{
                  'short_name': 'DMMODEL',
                  'display_name': '${{ needs.resolve.outputs.model_name }}',
                  'ref': '${{ needs.resolve.outputs.onnx_ref }}',
                  'runner': 'tinygrad',
                  'build_time': datetime.now(UTC).strftime('%Y-%m-%dT%H:%M:%SZ'),
                  'models': [{
                      'type': 'chunked',
                      'artifact': {
                          'file_name': pkl_name,
                          'download_uri': {'url': '', 'sha256': digest.hexdigest()},
                          'chunks': chunks
                      }
                  }]
              }]
          }
          with open(dm_dir / 'metadata.json', 'w') as f:
              json.dump(metadata, f, indent=2)
          print('Generated DM metadata.json')
          "
          python3 release/ci/upload_default_model.py \
            --hf-repo "${{ env.HF_REPO }}" \
            --hf-defaults-path "${{ needs.resolve.outputs.hf_defaults_path }}" \
            --artifact-name "dm-model-${{ github.run_number }}" \
            --model-dir dm_output \
            --onnx-path "${{ needs.resolve.outputs.onnx_path }}" \
            --onnx-ref "${{ needs.resolve.outputs.onnx_ref }}" \
            --model-name "${{ needs.resolve.outputs.model_name }}" \
            --tinygrad-ref "${{ needs.resolve.outputs.tinygrad_ref }}" \
            --run-number "${{ github.run_number }}"
  build_dm_model:
    needs: resolve
    if: ${{ inputs.target == 'dm' }}
    runs-on: [self-hosted, tici]
    env:
      DM_ONNX: openpilot/selfdrive/modeld/models/dmonitoring_model.onnx
      DM_PKL: openpilot/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - name: Pull DM ONNX via LFS
        run: git lfs pull -I "${{ env.DM_ONNX }}"
      - name: Set environment variables
        run: |
          source /etc/profile
          export UV_PROJECT_ENVIRONMENT=${HOME}/venv
          export UV_PYTHON_PREFERENCE=managed
          export UV_PYTHON_INSTALL_DIR=${HOME}/uv/python
          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
          uv sync --frozen
          printenv >> $GITHUB_ENV
      - name: Disable powersave
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --disable
      - name: Compile DM model
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          export PYTHONPATH="${PYTHONPATH}:${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}"
          TG_FLAGS="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
          taskset -c 7 env ${TG_FLAGS} python3 \
            ${{ github.workspace }}/tinygrad_repo/examples/openpilot/compile3.py \
            ${{ github.workspace }}/${{ env.DM_ONNX }} \
            ${{ github.workspace }}/${{ env.DM_PKL }}
      - name: Chunk DM pkl
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          export PYTHONPATH=${{ github.workspace }}
          python3 -c "
          from openpilot.common.file_chunker import chunk_file, get_chunk_targets
          import os
          pkl = '${{ github.workspace }}/${{ env.DM_PKL }}'
          size = os.path.getsize(pkl)
          targets = get_chunk_targets(pkl, size)
          chunk_file(pkl, targets)
          print(f'Chunked {pkl} into {len(targets)} chunks')
          "
      - name: Prepare DM output
        run: |
          mkdir -p dm_output
          cp ${{ github.workspace }}/${{ env.DM_PKL }}.chunk* dm_output/
          cp ${{ github.workspace }}/${{ env.DM_PKL }}.chunkmanifest dm_output/
      - name: Upload DM artifact
        uses: actions/upload-artifact@v4
        with:
          name: dm-model-${{ github.run_number }}
          path: dm_output/
      - name: Re-enable powersave
        if: always()
        run: |
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --enable
@@ -30,7 +30,7 @@ on:
        type: boolean
        default: true
      target_hardware:
-        description: 'Hardware target to compile for (qcom or chestnut)'
+        description: 'Hardware target to compile for (qcom or usbgpu)'
        required: false
        type: string
        default: 'qcom'
@@ -101,7 +101,7 @@ on:
        default: 'qcom'
        options:
          - qcom
-          - chestnut
+          - usbgpu
      hf_repo:
        description: 'Hugging Face dataset repository'
        required: false
@@ -109,7 +109,7 @@ on:
        default: 'sunnypilot/sunnypilot_models_v1'
 env:
  RECOMPILED_DIR: recompiled${{ inputs.recompiled_dir }}
-  JSON_FILE: docs/docs/driving_models_${{ inputs.target_hardware == 'chestnut' && 'chestnut_v' || 'v' }}${{ inputs.json_version }}.json
+  JSON_FILE: docs/docs/driving_models_${{ inputs.target_hardware == 'usbgpu' && 'usbgpu_v' || 'v' }}${{ inputs.json_version }}.json
 jobs:
  build_model:
@@ -1,66 +0,0 @@
 name: Download HF model chunks
 description: Resolve and download model chunks from HuggingFace in parallel
 inputs:
  hf_repo:
    description: HuggingFace dataset repo
    required: true
  models:
    description: 'JSON array of {hf_path, onnx_hash, canonical} objects'
    required: true
  dest_dir:
    description: Destination directory for downloaded chunks
    required: true
 runs:
  using: composite
  steps:
    - name: Download model chunks
      shell: bash
      env:
        HF_REPO: ${{ inputs.hf_repo }}
        MODELS_JSON: ${{ inputs.models }}
        DEST_DIR: ${{ inputs.dest_dir }}
      run: |
        set -eo pipefail
        DOWNLOAD_LIST=$(mktemp)
        resolve_chunks() {
          local HF_PATH="$1" ONNX_HASH="$2" CANONICAL="$3" DEST_DIR="$4"
          local JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_PATH}/default_models.json"
          local DEFAULTS BUNDLE ARTIFACT BASE_URL NUM_CHUNKS
          DEFAULTS=$(curl -fsSL "$JSON_URL")
          BUNDLE=$(echo "$DEFAULTS" | jq --arg hash "$ONNX_HASH" '.bundles[] | select(.onnx_sha256 == $hash)')
          ARTIFACT=$(echo "$BUNDLE" | jq -r '.models[0].artifact')
          BASE_URL=$(echo "$ARTIFACT" | jq -r '.download_uri.url' | sed 's|/[^/]*$||')
          NUM_CHUNKS=$(echo "$ARTIFACT" | jq -r '.chunks | length')
          mkdir -p "$DEST_DIR"
          while IFS= read -r CHUNK_NAME; do
            CHUNK_IDX=$(echo "$CHUNK_NAME" | grep -oP 'chunk\K[0-9]+of[0-9]+' || true)
            if [ -z "$CHUNK_IDX" ]; then
              echo "::error::Failed to parse chunk index from: $CHUNK_NAME"
              return 1
            fi
            ENCODED_URL=$(python3 -c "import urllib.parse; print(urllib.parse.quote('${BASE_URL}/${CHUNK_NAME}', safe=':/'))")
            printf '%s\t%s\n' "$ENCODED_URL" "${DEST_DIR}/${CANONICAL}.chunk${CHUNK_IDX}" >> "$DOWNLOAD_LIST"
          done < <(echo "$ARTIFACT" | jq -r '.chunks[].file_name')
          echo "$NUM_CHUNKS" > "${DEST_DIR}/${CANONICAL}.chunkmanifest"
        }
        echo "$MODELS_JSON" | jq -c '.[]' | while IFS= read -r model; do
          HF_PATH=$(echo "$model" | jq -r '.hf_path')
          ONNX_HASH=$(echo "$model" | jq -r '.onnx_hash')
          CANONICAL=$(echo "$model" | jq -r '.canonical')
          resolve_chunks "$HF_PATH" "$ONNX_HASH" "$CANONICAL" "$DEST_DIR"
        done
        TOTAL=$(wc -l < "$DOWNLOAD_LIST")
        echo "Downloading $TOTAL chunks with 8 parallel connections..."
        xargs -P8 -d'\n' -I{} bash -c '
          URL="${1%%	*}"
          DEST="${1#*	}"
          echo "Downloading $(basename "$DEST")"
          curl -fsSL --retry 3 --retry-delay 5 -o "$DEST" "$URL"
        ' _ {} < "$DOWNLOAD_LIST"
        rm -f "$DOWNLOAD_LIST"
@@ -31,7 +31,7 @@ on:
        type: string
        default: ''
      target_hardware:
-        description: 'Hardware target to compile for (qcom or chestnut)'
+        description: 'Hardware target to compile for (qcom or usbgpu)'
        required: false
        type: string
        default: 'qcom'
@@ -57,7 +57,7 @@ on:
        type: choice
        options:
          - qcom
-          - chestnut
+          - usbgpu
        default: 'qcom'
@@ -102,26 +102,21 @@ jobs:
          cat $GITHUB_OUTPUT
      - run: |
          cd ${{ github.workspace }}/openpilot/openpilot
-          if [ "${{ inputs.target_hardware }}" != "chestnut" ]; then
+          if [ "${{ inputs.target_hardware }}" != "usbgpu" ]; then
-            git lfs pull -X "**/selfdrive/modeld/models/big_*.onnx,**/selfdrive/modeld/models/dmonitoring_*.onnx"
+            git lfs pull -X "selfdrive/modeld/models/big_*.onnx" -X "selfdrive/modeld/models/dmonitoring_*.onnx"
            rm -f selfdrive/modeld/models/big_*.onnx selfdrive/modeld/models/dmonitoring_*.onnx
          else
-            git lfs pull -I "**/selfdrive/modeld/models/big_*.onnx" -X ""
+            git lfs pull -I "selfdrive/modeld/models/big_*.onnx"
            find selfdrive/modeld/models -name "*.onnx" ! -name "big_*.onnx" -delete
          fi
          if grep -lIF "version https://git-lfs.github.com/spec/v1" selfdrive/modeld/models/*.onnx; then
            echo "::error::the ONNX files above are still LFS pointers, not real models"
            exit 1
          fi
      - name: 'Upload Artifact'
        uses: actions/upload-artifact@v4
        with:
          name: models-${{ env.REF }}${{ inputs.artifact_suffix  }}
          path: ${{ github.workspace }}/openpilot/openpilot/selfdrive/modeld/models/*.onnx
          if-no-files-found: error
  build_model:
-    runs-on: [self-hosted, chestnut]
+    runs-on: [self-hosted, tici]
    needs: get_model
    env:
      MODEL_NAME: ${{ inputs.custom_name || inputs.upstream_branch }} (${{ needs.get_model.outputs.model_date }})
@@ -132,6 +127,7 @@ jobs:
          fetch-depth: 1
          submodules: recursive
      - run: git lfs pull
      - name: Set environment variables
        id: set-env
@@ -164,7 +160,7 @@ jobs:
          fi
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --disable
-          rm -rf ${{ env.MODELS_DIR }}/*.onnx*
+          rm -rf ${{ env.MODELS_DIR }}/*.onnx
      - name: Download model artifacts
        uses: actions/download-artifact@v4
@@ -184,48 +180,34 @@ jobs:
          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}')")
-          TG_FLAGS_QCOM="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
+          if [ "${{ inputs.target_hardware }}" == "usbgpu" ]; then
-          if [ "${{ inputs.target_hardware }}" == "chestnut" ]; then
+            echo "USBGPU build"
-            echo "CHESTNUT build"
+            export USBGPU=1
-            export CHESTNUT=1
+            TG_FLAGS="DEBUG=2 DEV=USB+AMD:LLVM WARP_DEV=QCOM FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2"
            TG_FLAGS="DEBUG=1 DEV=USB+AMD:LLVM WARP_DEV=QCOM FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2"
            OUTPUT_PKL="${{ env.MODELS_DIR }}/big_driving_tinygrad.pkl"
          else
            echo "QCOM build"
-            TG_FLAGS="$TG_FLAGS_QCOM"
+            TG_FLAGS="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
            OUTPUT_PKL="${{ env.MODELS_DIR }}/driving_tinygrad.pkl"
          fi
          # Generate metadata for all ONNX files
          find "${{ env.MODELS_DIR }}" -maxdepth 1 -name '*.onnx' | while IFS= read -r onnx_file; do
            echo "Generating metadata: $onnx_file"
-            env ${TG_FLAGS_QCOM} python3 "${{ env.MODELS_DIR }}/../get_model_metadata.py" "$onnx_file" || true
+            env ${TG_FLAGS} python3 "${{ env.MODELS_DIR }}/../get_model_metadata.py" "$onnx_file" || true
          done
          # Detect model type and build compile args
-          VISION_ONNX=""
+          VISION_ONNX="${{ env.MODELS_DIR }}/driving_vision.onnx"
-          for f in "${{ env.MODELS_DIR }}/driving_vision.onnx" "${{ env.MODELS_DIR }}/big_driving_vision.onnx"; do
+          POLICY_ONNX="${{ env.MODELS_DIR }}/driving_policy.onnx"
-            [ -f "$f" ] && VISION_ONNX="$f" && break
+          OFF_POLICY_ONNX="${{ env.MODELS_DIR }}/driving_off_policy.onnx"
-          done
+          ON_POLICY_ONNX="${{ env.MODELS_DIR }}/driving_on_policy.onnx"
          POLICY_ONNX=""
          for f in "${{ env.MODELS_DIR }}/driving_policy.onnx" "${{ env.MODELS_DIR }}/big_driving_policy.onnx"; do
            [ -f "$f" ] && POLICY_ONNX="$f" && break
          done
          OFF_POLICY_ONNX=""
          for f in "${{ env.MODELS_DIR }}/driving_off_policy.onnx" "${{ env.MODELS_DIR }}/big_driving_off_policy.onnx"; do
            [ -f "$f" ] && OFF_POLICY_ONNX="$f" && break
          done
          ON_POLICY_ONNX=""
          for f in "${{ env.MODELS_DIR }}/driving_on_policy.onnx" "${{ env.MODELS_DIR }}/big_driving_on_policy.onnx"; do
            [ -f "$f" ] && ON_POLICY_ONNX="$f" && break
          done
          SUPERCOMBO_ONNX=""
-          for f in "${{ env.MODELS_DIR }}/supercombo.onnx" "${{ env.MODELS_DIR }}/driving_supercombo.onnx" "${{ env.MODELS_DIR }}/big_supercombo.onnx" "${{ env.MODELS_DIR }}/big_driving_supercombo.onnx"; do
+          for f in "${{ env.MODELS_DIR }}/supercombo.onnx" "${{ env.MODELS_DIR }}/driving_supercombo.onnx"; do
-            [ -f "$f" ] && SUPERCOMBO_ONNX="$f" && break
+            if [ -f "$f" ]; then
              SUPERCOMBO_ONNX="$f"
              break
            fi
          done
          MODEL_TYPE="" ONNX_ARGS="" OUTPUT_NAME=""
@@ -4,8 +4,12 @@ env:
  BUILD_DIR: "/data/openpilot"
  OUTPUT_DIR: ${{ github.workspace }}/output
  CI_DIR: ${{ github.workspace }}/release/ci
  SCONS_CACHE_DIR: ${{ github.workspace }}/release/ci/scons_cache
  PUBLIC_REPO_URL: "https://github.com/sunnypilot/sunnypilot"
  # Branch configurations
  STAGING_SOURCE_BRANCH: 'master'
  # Runtime configuration
  SOURCE_BRANCH: "${{ github.head_ref || github.ref_name }}"
@@ -36,11 +40,8 @@ jobs:
      publish_concurrency_group: ${{ steps.strategy.outputs.publish_concurrency_group }}
      is_stable_branch: ${{ steps.strategy.outputs.is_stable_branch }}
      build: ${{ steps.strategy.outputs.build }}
      include_big_model: ${{ steps.strategy.outputs.include_big_model }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 1
      - name: Extract deploy strategy
        id: strategy
        run: |
@@ -81,9 +82,6 @@ jobs:
            stable_version=$(cat openpilot/sunnypilot/common/version.h | grep SUNNYPILOT_VERSION | sed -e 's/[^0-9|.]//g');
            echo "version=$([ "$is_stable_branch" = "true" ] && echo "$stable_version" || echo "$BUILD")" >> $GITHUB_OUTPUT
            echo "extra_version_identifier=${environment}" >> $GITHUB_OUTPUT
            include_big_model="$(echo "$CONFIG" | jq -r '.include_big_model // false')";
            echo "include_big_model=$include_big_model" >> $GITHUB_OUTPUT
          fi
          echo "build=$BUILD" >> $GITHUB_OUTPUT
          cat $GITHUB_OUTPUT
@@ -98,8 +96,6 @@ jobs:
      }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 1
      - name: Wait for Tests
        uses: ./.github/workflows/wait-for-action # Path to where you place the action
        with:
@@ -113,6 +109,11 @@ jobs:
      group: build-${{ github.head_ref || github.ref_name }}
      cancel-in-progress: false
    runs-on: [self-hosted, tici]
    outputs:
      new_branch: ${{ needs.prepare_strategy.outputs.new_branch }}
      version: ${{ needs.prepare_strategy.outputs.version }}
      extra_version_identifier: ${{ needs.prepare_strategy.outputs.extra_version_identifier }}
      commit_sha: ${{ github.sha }}
    if: ${{
      (always() && !cancelled() && !failure()) &&
      needs.prepare_strategy.result == 'success' &&
@@ -123,14 +124,31 @@ jobs:
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 1
          submodules: recursive
          ref: ${{ env.SOURCE_BRANCH }}
          repository: ${{ github.event.pull_request.head.repo.fork && github.event.pull_request.head.repo.full_name || github.repository }}
      - run: git lfs pull
      - name: Cache SCons
        uses: actions/cache@v4
        with:
          path: ${{env.SCONS_CACHE_DIR}}
          key: scons-${{ runner.os }}-${{ runner.arch }}-${{ env.SOURCE_BRANCH }}-${{ github.sha }}
          # Note: GitHub Actions enforces cache isolation between different build sources (PR builds, workflow dispatches, etc.)
          #   for security. Only caches from the default branch are shared across all builds. This is by design and cannot be overridden.
          restore-keys: |
            scons-${{ runner.os }}-${{ runner.arch }}-${{ env.SOURCE_BRANCH }}
            scons-${{ runner.os }}-${{ runner.arch }}-${{ env.STAGING_SOURCE_BRANCH }}
            scons-${{ runner.os }}-${{ runner.arch }}
      - name: Set environment variables
        id: set-env
        run: |
          echo "new_branch=${{ needs.prepare_strategy.outputs.new_branch }}" >> $GITHUB_OUTPUT
          echo "version=${{ needs.prepare_strategy.outputs.version }}" >> $GITHUB_OUTPUT
          echo "extra_version_identifier=${{ needs.prepare_strategy.outputs.extra_version_identifier }}" >> $GITHUB_OUTPUT
          echo "commit_sha=${{ github.sha }}" >> $GITHUB_OUTPUT
          # Set up common environment
          source /etc/profile;
          export UV_PROJECT_ENVIRONMENT=${HOME}/venv
@@ -139,6 +157,9 @@ jobs:
          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
          uv sync
          printenv >> $GITHUB_ENV
          if [[ "${{ runner.debug }}" == "1" ]]; then
            cat $GITHUB_OUTPUT
          fi
      - name: Setup build environment
        run: |
@@ -147,7 +168,7 @@ jobs:
          echo "Starting build stage..."
          echo "BUILD_DIR: ${BUILD_DIR}"
          echo "CI_DIR: ${CI_DIR}"
-          echo "VERSION: ${{ needs.prepare_strategy.outputs.version }}"
+          echo "VERSION: ${{ steps.set-env.outputs.version }}"
          echo "UV_PROJECT_ENVIRONMENT: ${UV_PROJECT_ENVIRONMENT}"
          echo "VIRTUAL_ENV: ${VIRTUAL_ENV}"
          echo "-------"
@@ -159,44 +180,61 @@ jobs:
      - name: Build Main Project
        run: |
-          export PYTHONPATH="$BUILD_DIR:$BUILD_DIR/msgq_repo:$BUILD_DIR/opendbc_repo:$BUILD_DIR/rednose_repo:$BUILD_DIR/teleoprtc_repo:$BUILD_DIR/tinygrad_repo"
+          export PYTHONPATH="$BUILD_DIR"
-          ./tools/release/release_files.py | xargs -0 cp -pR --parents -t "$BUILD_DIR" --
+          ./tools/release/release_files.py | sort | uniq | rsync -rRl${RUNNER_DEBUG:+v} --files-from=- . $BUILD_DIR/
          # outside the checkout, which is wiped each run. /data/scons_cache is the device's, not ours.
          SCONS_CACHE="$RUNNER_WORKSPACE/scons_cache"
          mkdir -p "$SCONS_CACHE"
          cd $BUILD_DIR
-          echo "Building locationd..."
+          ln -sfn msgq_repo/msgq msgq
-          # -j1: parallel rednose generators OOM the device
+          ln -sfn opendbc_repo/opendbc opendbc
-          scons -j1 cache_dir="$SCONS_CACHE" --minimal \
+          ln -sfn rednose_repo/rednose rednose
-            openpilot/selfdrive/locationd openpilot/sunnypilot/selfdrive/locationd
+          ln -sfn teleoprtc_repo/teleoprtc teleoprtc
          ln -sfn tinygrad_repo/tinygrad tinygrad
          sed -i '/from .board.jungle import PandaJungle, PandaJungleDFU/s/^/#/' panda/__init__.py
          echo "Building sunnypilot's modeld_v2..."
          scons -j$(nproc) cache_dir=${{env.SCONS_CACHE_DIR}} --minimal openpilot/sunnypilot/modeld_v2
          echo "Building sunnypilot's locationd..."
          scons -j2 cache_dir=${{env.SCONS_CACHE_DIR}} --minimal openpilot/sunnypilot/selfdrive/locationd
          echo "Building openpilot's locationd..."
          scons -j1 cache_dir=${{env.SCONS_CACHE_DIR}} --minimal openpilot/selfdrive/locationd
          echo "Building rest of sunnypilot"
-          SKIP_TINYGRAD_COMPILE=1 /usr/bin/time -v scons -j$(nproc) cache_dir="$SCONS_CACHE" --minimal
+          scons -j$(nproc) cache_dir=${{env.SCONS_CACHE_DIR}} --minimal
          touch ${BUILD_DIR}/prebuilt
          if [[ "${{ runner.debug }}" == "1" ]]; then
            ls -la ${BUILD_DIR}
          fi
-      - name: Strip release tree
+      - name: Prepare Output
        run: |
-          cd $BUILD_DIR
+          sudo rm -rf ${OUTPUT_DIR}
-          find . -name '*.a' -delete
+          mkdir -p ${OUTPUT_DIR}
-          find . -name '*.o' -delete
+          rsync -am${RUNNER_DEBUG:+v} \
-          find . -name '*.os' -delete
+            --exclude='.sconsign.dblite' \
-          find . -name '*.pyc' -delete
+            --exclude='*.a' \
-          find . -name 'moc_*' -delete
+            --exclude='*.o' \
-          find . -name '__pycache__' -type d -exec rm -rf {} +
+            --exclude='*.os' \
-          find . -name 'SConstruct' -delete
+            --exclude='*.pyc' \
-          find . -name 'SConscript' -delete
+            --exclude='moc_*' \
-          rm -rf .sconsign.dblite Jenkinsfile tools/release/ release/
+            --exclude='__pycache__' \
-          rm -f openpilot/selfdrive/modeld/models/*.onnx*
+            --exclude='Jenkinsfile' \
-          rm -f openpilot/sunnypilot/modeld*/models/*.onnx*
+            --exclude='**/release/' \
-          find openpilot/third_party/ -name '*x86*' -exec rm -r {} +
+            --exclude='**/.github/' \
-          find openpilot/third_party/ -name '*Darwin*' -exec rm -r {} +
+            --exclude='**/openpilot/selfdrive/ui/replay/' \
-          cd -
+            --exclude='**/__pycache__/' \
            --exclude='${{env.SCONS_CACHE_DIR}}' \
            --exclude='**/.git/' \
            --exclude='**/SConstruct' \
            --exclude='**/SConscript' \
            --exclude='**/.venv/' \
            --exclude='openpilot/selfdrive/modeld/models/*.onnx*' \
            --exclude='openpilot/sunnypilot/modeld*/models/*.onnx*' \
            --exclude='openpilot/third_party/*x86*' \
            --exclude='openpilot/third_party/*Darwin*' \
            --delete-excluded \
            --chown=comma:comma \
            ${BUILD_DIR}/ ${OUTPUT_DIR}/
      - name: 'Tar.gz files'
        run: |
-          tar czf prebuilt.tar.gz -C ${{ env.BUILD_DIR }} .
+          tar czf prebuilt.tar.gz -C ${{ env.OUTPUT_DIR }} .
          ls -la prebuilt.tar.gz
      - name: 'Upload Artifact'
@@ -204,7 +242,6 @@ jobs:
        with:
          name: prebuilt
          path: prebuilt.tar.gz
          compression-level: 0
      - name: Re-enable powersave
        if: always()
@@ -212,212 +249,22 @@ jobs:
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --enable
  prepare_chestnut:
    needs: [ prepare_strategy ]
    runs-on: ubuntu-24.04
    if: ${{ needs.prepare_strategy.outputs.include_big_model == 'true' }}
    outputs:
      onnx_sha256: ${{ steps.resolve.outputs.onnx_sha256 }}
    env:
      GH_REPO: ${{ github.repository }}
      HF_REPO: sunnypilot/sunnypilot_models_v1
      HF_DEFAULTS_PATH: models/defaults/big
    steps:
      - name: Resolve ONNX hash and tinygrad ref via API
        id: resolve
        run: |
          REF="${{ github.head_ref || github.ref_name }}"
          ONNX_HASH=$(gh api "repos/${GH_REPO}/contents/openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx?ref=${REF}" --jq '.content' | base64 -d | grep '^oid sha256:' | cut -d: -f2)
          echo "ONNX hash: $ONNX_HASH"
          echo "onnx_sha256=$ONNX_HASH" >> $GITHUB_OUTPUT
          TINYGRAD_REF=$(gh api "repos/${GH_REPO}/contents/tinygrad_repo?ref=${REF}" --jq '.sha')
          echo "tinygrad ref: $TINYGRAD_REF"
          JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_DEFAULTS_PATH}/default_models.json"
          check_defaults() {
            DEFAULTS=$(curl -fsSL "$JSON_URL" 2>/dev/null) || return 1
            TINYGRAD_MATCH=$(echo "$DEFAULTS" | jq -r --arg ref "$TINYGRAD_REF" '.tinygrad_ref == $ref' 2>/dev/null)
            [ "$TINYGRAD_MATCH" = "true" ] || return 1
            BUNDLE=$(echo "$DEFAULTS" | jq --arg hash "$ONNX_HASH" '.bundles[] | select(.onnx_sha256 == $hash)' 2>/dev/null)
            [ -n "$BUNDLE" ] && [ "$BUNDLE" != "null" ]
          }
          if check_defaults; then
            echo "HF defaults match repo ONNX hash and tinygrad ref"
            exit 0
          fi
          echo "No matching model on HF — dispatching build"
          gh workflow run build-default-models.yaml --ref "$REF" -f target=big
          echo "Polling HF for big model availability..."
          for i in $(seq 1 90); do
            sleep 30
            if check_defaults; then
              echo "Big model available on HF after $((i * 30))s"
              exit 0
            fi
            echo "Poll $i/90: not yet available"
          done
          echo "::error::Big model not available on HF after 45 minutes"
          exit 1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      - name: Cancel run on failure
        if: failure()
        run: gh run cancel ${{ github.run_id }}
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
  prepare_small_model:
    needs: [ prepare_strategy ]
    runs-on: ubuntu-24.04
    outputs:
      driving_onnx_sha256: ${{ steps.resolve.outputs.driving_onnx_sha256 }}
    env:
      GH_REPO: ${{ github.repository }}
      HF_REPO: sunnypilot/sunnypilot_models_v1
      HF_DEFAULTS_PATH: models/defaults/small
    steps:
      - name: Resolve ONNX hash and tinygrad ref via API
        id: resolve
        run: |
          REF="${{ github.head_ref || github.ref_name }}"
          DRIVING_HASH=$(gh api "repos/${GH_REPO}/contents/openpilot/selfdrive/modeld/models/driving_supercombo.onnx?ref=${REF}" --jq '.content' | base64 -d | grep '^oid sha256:' | cut -d: -f2)
          echo "Driving ONNX hash: $DRIVING_HASH"
          echo "driving_onnx_sha256=$DRIVING_HASH" >> $GITHUB_OUTPUT
          TINYGRAD_REF=$(gh api "repos/${GH_REPO}/contents/tinygrad_repo?ref=${REF}" --jq '.sha')
          echo "tinygrad ref: $TINYGRAD_REF"
          JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_DEFAULTS_PATH}/default_models.json"
          check_defaults() {
            DEFAULTS=$(curl -fsSL "$JSON_URL" 2>/dev/null) || return 1
            TINYGRAD_MATCH=$(echo "$DEFAULTS" | jq -r --arg ref "$TINYGRAD_REF" '.tinygrad_ref == $ref' 2>/dev/null)
            [ "$TINYGRAD_MATCH" = "true" ] || return 1
            DRIVING=$(echo "$DEFAULTS" | jq --arg hash "$DRIVING_HASH" '.bundles[] | select(.onnx_sha256 == $hash)' 2>/dev/null)
            [ -n "$DRIVING" ] && [ "$DRIVING" != "null" ] || return 1
          }
          if check_defaults; then
            echo "HF defaults match repo ONNX hash and tinygrad ref"
            exit 0
          fi
          echo "No matching model on HF — dispatching build"
          gh workflow run build-default-models.yaml --ref "$REF" -f target=small
          echo "Polling HF for model availability..."
          for i in $(seq 1 60); do
            sleep 30
            if check_defaults; then
              echo "Model available on HF after $((i * 30))s"
              exit 0
            fi
            echo "Poll $i/60: not yet available"
          done
          echo "::error::Small driving model not available on HF after 30 minutes"
          exit 1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      - name: Cancel run on failure
        if: failure()
        run: gh run cancel ${{ github.run_id }}
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
  prepare_dm_model:
    needs: [ prepare_strategy ]
    runs-on: ubuntu-24.04
    outputs:
      dm_onnx_sha256: ${{ steps.resolve.outputs.dm_onnx_sha256 }}
    env:
      GH_REPO: ${{ github.repository }}
      HF_REPO: sunnypilot/sunnypilot_models_v1
      HF_DEFAULTS_PATH: models/defaults/dm
    steps:
      - name: Resolve ONNX hash and tinygrad ref via API
        id: resolve
        run: |
          REF="${{ github.head_ref || github.ref_name }}"
          DM_HASH=$(gh api "repos/${GH_REPO}/contents/openpilot/selfdrive/modeld/models/dmonitoring_model.onnx?ref=${REF}" --jq '.content' | base64 -d | grep '^oid sha256:' | cut -d: -f2)
          echo "DM ONNX hash: $DM_HASH"
          echo "dm_onnx_sha256=$DM_HASH" >> $GITHUB_OUTPUT
          TINYGRAD_REF=$(gh api "repos/${GH_REPO}/contents/tinygrad_repo?ref=${REF}" --jq '.sha')
          echo "tinygrad ref: $TINYGRAD_REF"
          JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_DEFAULTS_PATH}/default_models.json"
          check_defaults() {
            DEFAULTS=$(curl -fsSL "$JSON_URL" 2>/dev/null) || return 1
            TINYGRAD_MATCH=$(echo "$DEFAULTS" | jq -r --arg ref "$TINYGRAD_REF" '.tinygrad_ref == $ref' 2>/dev/null)
            [ "$TINYGRAD_MATCH" = "true" ] || return 1
            DM=$(echo "$DEFAULTS" | jq --arg hash "$DM_HASH" '.bundles[] | select(.onnx_sha256 == $hash)' 2>/dev/null)
            [ -n "$DM" ] && [ "$DM" != "null" ] || return 1
          }
          if check_defaults; then
            echo "HF defaults match DM ONNX hash and tinygrad ref"
            exit 0
          fi
          echo "No matching DM model on HF — dispatching build"
          gh workflow run build-default-models.yaml --ref "$REF" -f target=dm
          echo "Polling HF for DM model availability..."
          for i in $(seq 1 60); do
            sleep 30
            if check_defaults; then
              echo "DM model available on HF after $((i * 30))s"
              exit 0
            fi
            echo "Poll $i/60: not yet available"
          done
          echo "::error::DM model not available on HF after 30 minutes"
          exit 1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      - name: Cancel run on failure
        if: failure()
        run: gh run cancel ${{ github.run_id }}
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
  publish:
    concurrency:
      # We do a bit of a hack here to avoid canceling the publishing job if a new commit comes in while we're publishing by adding the sha to the group name.
      # This means that if multiple commits come in while we're publishing, they will be queued up and publish one after the other.
      # Otherwise, if a job is waiting to be published due to environment wait time, it would be canceled by a new commit and restart the wait time.
      group: ${{ needs.prepare_strategy.outputs.publish_concurrency_group }}
      cancel-in-progress: ${{ needs.prepare_strategy.outputs.cancel_publish_in_progress == 'true' }}
-    if: ${{
+    if: ${{ (always() && !cancelled() && !failure()) && needs.build.result == 'success' && needs.prepare_strategy.result == 'success' && (!contains(github.event_name, 'pull_request') || (github.event.action == 'labeled' && github.event.label.name == 'prebuilt')) }}
-      always() && !cancelled() &&
+    needs: [ build, prepare_strategy ]
      needs.build.result == 'success' &&
      needs.prepare_strategy.result == 'success' &&
      needs.prepare_small_model.result == 'success' &&
      needs.prepare_dm_model.result == 'success' &&
      (!contains(github.event_name, 'pull_request') || (github.event.action == 'labeled' && github.event.label.name == 'prebuilt')) &&
      (needs.prepare_strategy.outputs.include_big_model != 'true' || needs.prepare_chestnut.result == 'success')
      }}
    needs: [ build, prepare_strategy, prepare_chestnut, prepare_small_model, prepare_dm_model ]
    runs-on: ubuntu-24.04
    environment: ${{ needs.prepare_strategy.outputs.environment }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 1
-      - name: Download prebuilt artifact
+      - name: Download build artifacts
        uses: actions/download-artifact@v4
        with:
          name: prebuilt
@@ -427,17 +274,6 @@ jobs:
          mkdir -p ${{ env.OUTPUT_DIR }}
          tar xzf prebuilt.tar.gz -C ${{ env.OUTPUT_DIR }}
      - name: Download model chunks from HF
        uses: ./.github/workflows/download-hf-model-chunks
        with:
          hf_repo: sunnypilot/sunnypilot_models_v1
          dest_dir: ${{ env.OUTPUT_DIR }}/openpilot/selfdrive/modeld/models
          models: |
            [
              {"hf_path": "models/defaults/small", "onnx_hash": "${{ needs.prepare_small_model.outputs.driving_onnx_sha256 }}", "canonical": "driving_tinygrad.pkl"},
              {"hf_path": "models/defaults/dm", "onnx_hash": "${{ needs.prepare_dm_model.outputs.dm_onnx_sha256 }}", "canonical": "dmonitoring_model_tinygrad.pkl"}
            ]
      - name: Configure Git
        run: |
          git config --global user.email "github-actions[bot]@users.noreply.github.com"
@@ -447,95 +283,36 @@ jobs:
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
-          echo '${{ toJSON(needs.prepare_strategy.outputs) }}'
+          echo '${{ toJSON(needs.build.outputs) }}'
          ls -la ${{ env.OUTPUT_DIR }}
          ${{ env.CI_DIR }}/publish.sh \
            "${{ github.workspace }}" \
            "${{ env.OUTPUT_DIR }}" \
-            "${{ needs.prepare_strategy.outputs.new_branch }}" \
+            "${{ needs.build.outputs.new_branch }}" \
-            "${{ needs.prepare_strategy.outputs.version }}" \
+            "${{ needs.build.outputs.version }}" \
            "https://x-access-token:${{github.token}}@github.com/sunnypilot/sunnypilot.git" \
-            "${{ needs.prepare_strategy.outputs.extra_version_identifier }}"
+            "${{ needs.build.outputs.extra_version_identifier }}"
          echo ""
          echo "----   ℹ️ To update the list of branches that auto deploy prebuilts  -----"
          echo ""
          echo "1. Go to: ${{ github.server_url }}/${{ github.repository }}/settings/variables/actions/AUTO_DEPLOY_PREBUILT_BRANCHES"
          echo "2. Current value: ${{ vars.AUTO_DEPLOY_PREBUILT_BRANCHES }}"
          echo "3. Update as needed (JSON array with no spaces)"
      - name: Tag ${{ needs.prepare_strategy.outputs.environment }}
        if: ${{ needs.prepare_strategy.outputs.is_stable_branch == 'true' && (github.event_name != 'push' || !startsWith(github.ref, 'refs/tags/')) }}
        run: |
            TAG="${{ needs.prepare_strategy.outputs.environment }}/${{ needs.prepare_strategy.outputs.version }}/${{ needs.prepare_strategy.outputs.build }}"
-            git tag -f -a ${TAG} -m "${{ needs.prepare_strategy.outputs.environment }} @ ${{ needs.prepare_strategy.outputs.version }} of build ${{ needs.prepare_strategy.outputs.build }}."
+            git tag -f -a ${TAG} -m "${{ needs.prepare_strategy.outputs.environment }} @ ${{ needs.prepare_strategy.outputs.version }} of build ${{ needs.build.outputs.build }}."
            git push -f origin ${TAG}
  publish_chestnut:
    concurrency:
      group: ${{ needs.prepare_strategy.outputs.publish_concurrency_group }}-chestnut
      cancel-in-progress: ${{ needs.prepare_strategy.outputs.cancel_publish_in_progress == 'true' }}
    if: ${{
      always() && !cancelled() &&
      needs.build.result == 'success' &&
      needs.prepare_strategy.result == 'success' &&
      needs.prepare_small_model.result == 'success' &&
      needs.prepare_dm_model.result == 'success' &&
      needs.prepare_chestnut.result == 'success' &&
      (!contains(github.event_name, 'pull_request') || (github.event.action == 'labeled' && github.event.label.name == 'prebuilt'))
      }}
    needs: [ build, prepare_strategy, prepare_chestnut, prepare_small_model, prepare_dm_model ]
    runs-on: ubuntu-24.04
    environment: ${{ needs.prepare_strategy.outputs.environment }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 1
      - name: Download prebuilt artifact
        uses: actions/download-artifact@v4
        with:
          name: prebuilt
      - name: Untar prebuilt
        run: |
          mkdir -p ${{ env.OUTPUT_DIR }}
          tar xzf prebuilt.tar.gz -C ${{ env.OUTPUT_DIR }}
      - name: Download model chunks from HF
        uses: ./.github/workflows/download-hf-model-chunks
        with:
          hf_repo: sunnypilot/sunnypilot_models_v1
          dest_dir: ${{ env.OUTPUT_DIR }}/openpilot/selfdrive/modeld/models
          models: |
            [
              {"hf_path": "models/defaults/small", "onnx_hash": "${{ needs.prepare_small_model.outputs.driving_onnx_sha256 }}", "canonical": "driving_tinygrad.pkl"},
              {"hf_path": "models/defaults/dm", "onnx_hash": "${{ needs.prepare_dm_model.outputs.dm_onnx_sha256 }}", "canonical": "dmonitoring_model_tinygrad.pkl"},
              {"hf_path": "models/defaults/big", "onnx_hash": "${{ needs.prepare_chestnut.outputs.onnx_sha256 }}", "canonical": "big_driving_tinygrad.pkl"}
            ]
      - name: Configure Git
        run: |
          git config --global user.email "github-actions[bot]@users.noreply.github.com"
          git config --global user.name "github-actions[bot]"
      - name: Publish chestnut branch
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          CHESTNUT_BRANCH="${{ needs.prepare_strategy.outputs.new_branch }}-chestnut"
          ${{ env.CI_DIR }}/publish.sh \
            "${{ github.workspace }}" \
            "${{ env.OUTPUT_DIR }}" \
            "$CHESTNUT_BRANCH" \
            "${{ needs.prepare_strategy.outputs.version }}" \
            "https://x-access-token:${{github.token}}@github.com/sunnypilot/sunnypilot.git" \
            "${{ needs.prepare_strategy.outputs.extra_version_identifier }}"
  notify:
    needs:
    - prepare_strategy
    - build
    - publish
    - publish_chestnut
    - prepare_chestnut
    - prepare_small_model
    - prepare_dm_model
    runs-on: ubuntu-24.04
    if: ${{ (always() && !cancelled() && !failure())
      && needs.publish.result == 'success'
@@ -543,12 +320,11 @@ jobs:
      && (fromJSON(vars.DEV_FEEDBACK_NOTIFICATION_BRANCHES_V2)[github.head_ref || github.ref_name] != null) }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 1
      - name: Prepare notification message
        id: message
        run: |
          TEMPLATE='${{ vars.DISCOURSE_GENERAL_UPDATE_NOTICE }}'
          export VERSION="${{ needs.prepare_strategy.outputs.version }}"
          export branch_name="${{ env.SOURCE_BRANCH }}"
          export new_branch="${{ needs.prepare_strategy.outputs.new_branch }}"
@@ -557,7 +333,6 @@ jobs:
          export commit_short_sha="${commit_short_sha:0:7}"
          export extra_version_identifier="${{ needs.prepare_strategy.outputs.extra_version_identifier || github.run_number }}"
          export PUBLIC_REPO_URL="${{ env.PUBLIC_REPO_URL }}"
          export chestnut_branch="${{ needs.prepare_chestnut.result == 'success' && format('{0}-chestnut', needs.prepare_strategy.outputs.new_branch) || '' }}"
          MESSAGE=$(cat << 'EOF' | envsubst
          ${{ vars.DISCOURSE_GENERAL_UPDATE_NOTICE }}
@@ -598,7 +373,7 @@ jobs:
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: prNumber,
-              name: process.env.LABEL
+              name: process.env.LABELf
            });
            console.log(`Removed '${process.env.LABEL}' label from PR #${prNumber}`);
@@ -25,8 +25,7 @@ env:
 jobs:
  preview:
-    if: false # tmp disable due to GH API rate limiting flakiness
+    if: github.repository == 'sunnypilot/sunnypilot'
    #if: github.repository == 'sunnypilot/sunnypilot'
    name: preview
    runs-on: ubuntu-latest
    timeout-minutes: 20
@@ -24,9 +24,7 @@ function agnos_init {
    if $AGNOS_PY --verify $MANIFEST; then
      sudo reboot
    fi
-    while true; do
+    $DIR/openpilot/common/hardware/comma/updater $AGNOS_PY $MANIFEST
      $DIR/openpilot/common/hardware/comma/updater $AGNOS_PY $MANIFEST
    done
  fi
 }
@@ -131,7 +131,6 @@ struct ModelManagerSP @0xaedffd8f31e7b55d {
    downloaded @2;
    cached @3;
    failed @4;
    verifying @5;
  }
  struct DownloadProgress {
@@ -59,7 +59,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"IsDriverViewEnabled", {CLEAR_ON_MANAGER_START, BOOL}},
    {"IsEngaged", {PERSISTENT, BOOL}},
    {"IsLdwEnabled", {PERSISTENT | BACKUP, BOOL}},
-    {"IsLiveStreaming", {CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_ON, BOOL}},
+    {"IsLiveStreaming", {CLEAR_ON_MANAGER_START, BOOL}},
    {"IsMetric", {PERSISTENT | BACKUP, BOOL}},
    {"IsOffroad", {CLEAR_ON_MANAGER_START, BOOL}},
    {"IsRhdDetected", {PERSISTENT, BOOL}},
@@ -130,8 +130,8 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"UpdaterLastFetchTime", {PERSISTENT, TIME}},
    {"UptimeOffroad", {PERSISTENT, FLOAT, "0.0"}},
    {"UptimeOnroad", {PERSISTENT, FLOAT, "0.0"}},
-    {"ChestnutActive", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION | CLEAR_ON_IGNITION_ON, BOOL}},
+    {"UsbGpuActive", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION | CLEAR_ON_IGNITION_ON, BOOL}},
-    {"ChestnutLoading", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION | CLEAR_ON_IGNITION_ON, BOOL}},
+    {"UsbGpuLoading", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION | CLEAR_ON_IGNITION_ON, BOOL}},
    {"Version", {PERSISTENT, STRING}},
    // --- sunnypilot params --- //
@@ -195,16 +195,14 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    // Model Manager params
    {"ModelManager_ActiveBundle", {PERSISTENT, JSON}},
-    {"ModelManager_ActiveBundleUSBGPU", {PERSISTENT, JSON}}, //TODO-SP: kept for migration, remove on next sync?
+    {"ModelManager_ActiveJson", {CLEAR_ON_MANAGER_START, STRING}},
    {"ModelManager_ActiveBundleChestnut", {PERSISTENT, JSON}},
    {"ModelManager_ActiveJson", {CLEAR_ON_MANAGER_START, JSON}},
    {"ModelManager_ClearCache", {CLEAR_ON_MANAGER_START, BOOL}},
-    {"ModelManager_DownloadRef", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, STRING}},
+    {"ModelManager_DownloadIndex", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, INT}},
    {"ModelManager_Favs", {PERSISTENT | BACKUP, STRING}},
    {"ModelManager_LastSyncTime", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, INT, "0"}},
-    {"ModelManager_LastSyncTime_Chestnut", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, INT, "0"}},
+    {"ModelManager_LastSyncTime_USBGPU", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, INT, "0"}},
    {"ModelManager_ModelsCache", {PERSISTENT | BACKUP, JSON}},
-    {"ModelManager_ModelsCache_Chestnut", {PERSISTENT | BACKUP, JSON}},
+    {"ModelManager_ModelsCache_USBGPU", {PERSISTENT | BACKUP, JSON}},
    // Neural Network Lateral Control
    {"NeuralNetworkLateralControl", {PERSISTENT | BACKUP, BOOL, "0"}},
@@ -247,7 +245,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    // mapd
    {"MapAdvisorySpeedLimit", {CLEAR_ON_ONROAD_TRANSITION, FLOAT}},
    {"Mapd_ClearCache", {CLEAR_ON_MANAGER_START, BOOL}},
    {"MapdVersion", {PERSISTENT, STRING}},
    {"MapSpeedLimit", {CLEAR_ON_ONROAD_TRANSITION, FLOAT, "0.0"}},
    {"NextMapSpeedLimit", {CLEAR_ON_ONROAD_TRANSITION, JSON}},
@@ -16,15 +16,6 @@ MASTER_SP_BRANCHES = ['master']
 RELEASE_BRANCHES = ['release-tizi-staging', 'release-mici-staging', 'release-tizi', 'release-mici', 'nightly']
 TESTED_BRANCHES = RELEASE_BRANCHES + ['devel-staging', 'nightly-dev'] + RELEASE_SP_BRANCHES + TESTED_SP_BRANCHES
 CHESTNUT_BRANCHES = {
  "staging": "staging-chestnut",
  "dev": "dev-chestnut",
  "release-mici": "release-chestnut",
  "release-tizi": "release-chestnut",
  "release-mici-staging": "release-chestnut-staging",
  "release-tizi-staging": "release-chestnut-staging",
 }
 SP_BRANCH_MIGRATIONS = {
  ("tici", "staging-c3-new"): "staging-tici",
  ("tici", "dev-c3-new"): "staging-tici",
@@ -1,3 +0,0 @@
 version https://git-lfs.github.com/spec/v1
 oid sha256:845c40ff0d37612e8f2f482a36845744b5ae91ce2fcfc8117990d7d278b59820
 size 13079
@@ -0,0 +1,3 @@
 version https://git-lfs.github.com/spec/v1
 oid sha256:8a8c5fece2a1c7587feb41cbe04c6aee08e768ecd9b5d00da6af9832a4ccc842
 size 2034
@@ -0,0 +1,3 @@
 version https://git-lfs.github.com/spec/v1
 oid sha256:7409c53d7c72681c24982fd83b56ce70f80797c9c0f936d9296a5c18557ac472
 size 7279
@@ -0,0 +1,3 @@
 version https://git-lfs.github.com/spec/v1
 oid sha256:58bd6155433f623b1f75d134bd8ca4745d9aa71f6767eb807cdbcf7deb3089a1
 size 10876
@@ -49,8 +49,9 @@ def get_cruise_accel(e2e, v_cruise, v_ego, a_cruise_prev, angle_steers, CP, dt,
      max_accel = min(max_accel, coast_limit)
  target_accel = np.clip(v_cruise - v_ego, A_CRUISE_MIN, max_accel)
-  j_cruise = np.interp(v_ego, A_CRUISE_MAX_BP, J_CRUISE_VALS)
+  if not e2e:
-  target_accel = float(np.clip(target_accel, a_cruise_prev - j_cruise * dt, a_cruise_prev + j_cruise * dt))
+    j_cruise = np.interp(v_ego, A_CRUISE_MAX_BP, J_CRUISE_VALS)
    target_accel = float(np.clip(target_accel, a_cruise_prev - j_cruise * dt, a_cruise_prev + j_cruise * dt))
  return target_accel
@@ -64,9 +65,10 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
    self.dt = dt
    self.allow_throttle = True
    self.a_desired = init_a
    self.v_desired_filter = FirstOrderFilter(init_v, 2.0, self.dt)
-    self.a_cruise = init_a
+    self.a_cruise = 0.0
-    self.output_a_target = init_a
+    self.output_a_target = 0.0
    self.output_should_stop = False
    self.v_desired_trajectory = np.zeros(CONTROL_N)
@@ -103,8 +105,7 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
    if reset_state:
      self.v_desired_filter.x = v_ego
-      self.output_a_target = np.clip(sm['carState'].aEgo, ACCEL_MIN, ACCEL_MAX)
+      self.a_desired = np.clip(sm['carState'].aEgo, ACCEL_MIN, ACCEL_MAX)
      self.a_cruise = self.output_a_target
    # Prevent divergence, smooth in current v_ego
    self.v_desired_filter.x = max(0.0, self.v_desired_filter.update(v_ego))
@@ -112,11 +113,11 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
    # No change cost when user is controlling the speed, or when standstill
    prev_accel_constraint = not (reset_state or sm['carState'].standstill)
-    # Get new v_cruise and a_target from Smart Cruise Control and Speed Limit Assist
+    # Get new v_cruise and a_desired from Smart Cruise Control and Speed Limit Assist
-    v_cruise, self.output_a_target = LongitudinalPlannerSP.update_targets(self, sm, self.v_desired_filter.x, self.output_a_target, v_cruise)
+    v_cruise, self.a_desired = LongitudinalPlannerSP.update_targets(self, sm, self.v_desired_filter.x, self.a_desired, v_cruise)
    self.mpc.set_weights(prev_accel_constraint, personality=sm['selfdriveState'].personality)
-    self.mpc.set_cur_state(self.v_desired_filter.x, self.output_a_target)
+    self.mpc.set_cur_state(self.v_desired_filter.x, self.a_desired)
    self.mpc.update(sm['radarState'], personality=sm['selfdriveState'].personality)
    self.v_desired_trajectory = np.interp(CONTROL_N_T_IDX, T_IDXS_MPC, self.mpc.v_solution)
@@ -129,7 +130,7 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
      cloudlog.info("FCW triggered")
    # Save starting point for next iteration
-    a_prev = self.output_a_target
+    a_prev = self.a_desired
    action_t =  self.CP.longitudinalActuatorDelay + DT_MDL
    output_a_target_mpc = get_accel_from_plan(self.v_desired_trajectory, self.a_desired_trajectory, CONTROL_N_T_IDX,
@@ -154,6 +155,7 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
    self.output_should_stop = any(should_stop for _, _, should_stop in candidates)
    self.output_a_target = np.clip(output_a_target, ACCEL_MIN, ACCEL_MAX)
    self.a_desired = float(self.output_a_target)
    self.v_desired_filter.x = self.v_desired_filter.x + self.dt * (self.output_a_target + a_prev) / 2.0
  def publish(self, sm, pm):
@@ -7,7 +7,7 @@ from openpilot.common.file_chunker import chunk_file, get_chunk_targets, get_exi
 from openpilot.common.transformations.camera import _ar_ox_fisheye, _os_fisheye
 from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE, DM_INPUT_SIZE
 from openpilot.selfdrive.modeld.constants import ModelConstants
-from openpilot.selfdrive.modeld.helpers import TG_INPUT_DEVICES_PATH, chestnut_present, modeld_pkl_path
+from openpilot.selfdrive.modeld.helpers import TG_INPUT_DEVICES_PATH, usbgpu_present, modeld_pkl_path
 CAMERA_CONFIGS = [
@@ -36,18 +36,18 @@ else:
 tg_devices = { # which device to put jit inputs to at runtime
  'openpilot.selfdrive.modeld.modeld': {
    'default': {'WARP_DEV': tg_backend, 'QUEUE_DEV': tg_backend},
-    'chestnut': {'WARP_DEV': tg_backend, 'QUEUE_DEV': 'AMD'}
+    'usbgpu': {'WARP_DEV': tg_backend, 'QUEUE_DEV': 'AMD'}
  },
  'openpilot.selfdrive.modeld.dmonitoringmodeld': {
    'default': {'DEV': tg_backend}
  },
 }
-CHESTNUT = chestnut_present()
+USBGPU = usbgpu_present()
-if CHESTNUT:
+if USBGPU:
-  chestnut_tg_flags = f'DEBUG=2 DEV=USB+AMD:LLVM WARP_DEV={tg_backend} FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2'
+  usbgpu_tg_flags = f'DEBUG=2 DEV=USB+AMD:LLVM WARP_DEV={tg_backend} FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2'
  # the USB+AMD GPU takes an exclusive flock; serialize all targets that touch it
-  chestnut_lock = File("models/.chestnut.lock").abspath
+  usbgpu_lock = File("models/.usb_gpu.lock").abspath
 def write_tg_devices(target, source, env):
  with open(str(target[0]), "w") as f:
@@ -73,45 +73,44 @@ compile_modeld_script = [
 model_w, model_h = MEDMODEL_INPUT_SIZE
 frame_skip = ModelConstants.MODEL_RUN_FREQ // ModelConstants.MODEL_CONTEXT_FREQ
-if not os.getenv('SKIP_TINYGRAD_COMPILE'):
+for usbgpu in [False, True] if USBGPU else [False]:
-  for chestnut in [False, True] if CHESTNUT else [False]:
+  target_pkl_path = File(modeld_pkl_path(usbgpu)).abspath
-    target_pkl_path = File(modeld_pkl_path(chestnut)).abspath
+  # BIG_INTO_SMALL=1 builds the default target from the big model, e.g. to test it without a USB GPU
-    # BIG_INTO_SMALL=1 builds the default target from the big model, e.g. to test it without a chestnut
+  file_prefix, cmd_flags = ('big_', usbgpu_tg_flags) if usbgpu else ('big_' if os.getenv('BIG_INTO_SMALL') else '', tg_flags)
-    file_prefix, cmd_flags = ('big_', chestnut_tg_flags) if chestnut else ('big_' if os.getenv('BIG_INTO_SMALL') else '', tg_flags)
+  driving_onnx_deps = get_existing_chunks(File(f"models/{file_prefix}driving_supercombo.onnx").abspath)
-    driving_onnx_deps = get_existing_chunks(File(f"models/{file_prefix}driving_supercombo.onnx").abspath)
+  camera_res_args = ' '.join(f'{cw}x{ch}' for cw, ch in CAMERA_CONFIGS)
-    camera_res_args = ' '.join(f'{cw}x{ch}' for cw, ch in CAMERA_CONFIGS)
+  # CPU 7 is isolated with isolcpus on AGNOS, so explicitly pin the compiler to it.
-    # CPU 7 is isolated with isolcpus on AGNOS, so explicitly pin the compiler to it.
+  taskset = 'taskset -c 7 ' if arch == 'comma_arm64' else ''
-    taskset = 'taskset -c 7 ' if arch == 'comma_arm64' else ''
+  cmd = (f'{cmd_flags} {mac_brew_string} {taskset}python3 {modeld_dir}/compile_modeld.py '
-    cmd = (f'{cmd_flags} {mac_brew_string} {taskset}python3 {modeld_dir}/compile_modeld.py '
+        f'--model-size {model_w}x{model_h} '
-          f'--model-size {model_w}x{model_h} '
+        f'--camera-resolutions {camera_res_args} '
-          f'--camera-resolutions {camera_res_args} '
+        f'--onnx {File(f"models/{file_prefix}driving_supercombo.onnx").abspath} '
-          f'--onnx {File(f"models/{file_prefix}driving_supercombo.onnx").abspath} '
+        f'--output {target_pkl_path} --frame-skip {frame_skip}')
-          f'--output {target_pkl_path} --frame-skip {frame_skip}')
+  onnx_sizes_sum = sum(os.path.getsize(f) for f in driving_onnx_deps)
-    onnx_sizes_sum = sum(os.path.getsize(f) for f in driving_onnx_deps)
+  chunk_targets = get_chunk_targets(target_pkl_path, estimate_pickle_max_size(onnx_sizes_sum))
-    chunk_targets = get_chunk_targets(target_pkl_path, estimate_pickle_max_size(onnx_sizes_sum))
+  def do_compile(target, source, env, command=cmd, pkl=target_pkl_path, chunks=chunk_targets):
-    def do_compile(target, source, env, command=cmd, pkl=target_pkl_path, chunks=chunk_targets):
+    from openpilot.system.hardware.chestnut.flash import link_up
-      from openpilot.system.hardware.chestnut.flash import link_up
+    # chestnut can enumerate before its PCIe link is up due to varying 12V power behavior across cars
-      # chestnut can enumerate before its PCIe link is up due to varying 12V power behavior across cars
+    for _ in range(10):
-      for _ in range(10):
+      if link_up():
-        if link_up():
+        break
-          break
+      time.sleep(1)
-        time.sleep(1)
+    else:
-      else:
+      print("Chestnut not ready, skipping big model build")
-        print("Chestnut not ready, skipping big model build")
+      return
-        return
+    if ret := env.Execute(command):
-      if ret := env.Execute(command):
+      return ret
-        return ret
+    chunk_file(pkl, chunks)
-      chunk_file(pkl, chunks)
+  def do_chunk(target, source, env, pkl=target_pkl_path, chunks=chunk_targets):
-    def do_chunk(target, source, env, pkl=target_pkl_path, chunks=chunk_targets):
+    chunk_file(pkl, chunks)
-      chunk_file(pkl, chunks)
+  actions = Action(do_compile, "  [USBGPU] $TARGET") if usbgpu else [cmd, Action(do_chunk, "  [CHUNK] $TARGET")]
-    actions = Action(do_compile, "  [CHESTNUT] $TARGET") if chestnut else [cmd, Action(do_chunk, "  [CHUNK] $TARGET")]
+  node = lenv.Command(
-    node = lenv.Command(
+    chunk_targets,
-      chunk_targets,
+    tinygrad_files + compile_modeld_script + driving_onnx_deps + [Value(chunk_targets), chunker_file],
-      tinygrad_files + compile_modeld_script + driving_onnx_deps + [Value(chunk_targets), chunker_file],
+    actions,
-      actions,
+  )
-    )
+  if usbgpu:
-    if chestnut:
+    lenv.SideEffect(usbgpu_lock, node)
      lenv.SideEffect(chestnut_lock, node)
 # get model metadata
 fn = File(f"models/dmonitoring_model").abspath
@@ -143,5 +142,4 @@ def tg_compile(flags, model_name):
     Action(do_chunk, "  [CHUNK] $TARGET")],
  )
-if not os.getenv('SKIP_TINYGRAD_COMPILE'):
+tg_compile(tg_flags, 'dmonitoring_model')
  tg_compile(tg_flags, 'dmonitoring_model')
@@ -29,7 +29,7 @@ class ModelState:
  output: np.ndarray
  def __init__(self, cam_w: int, cam_h: int):
-    self.DEV = get_tg_input_devices(PROCESS_NAME, chestnut=False)['DEV']
+    self.DEV = get_tg_input_devices(PROCESS_NAME, usbgpu=False)['DEV']
    with open(METADATA_PATH, 'rb') as f:
      model_metadata = pickle.load(f)
      self.input_shapes = model_metadata['input_shapes']
@@ -13,12 +13,12 @@ MODELS_DIR = Path(__file__).resolve().parent / 'models'
 TG_INPUT_DEVICES_PATH = MODELS_DIR / 'tg_input_devices.json'
-def get_tg_input_devices(process_name: str, chestnut: bool):
+def get_tg_input_devices(process_name: str, usbgpu: bool):
  with open(TG_INPUT_DEVICES_PATH) as f:
-    return json.load(f)[process_name]['default' if not chestnut else 'chestnut']
+    return json.load(f)[process_name]['default' if not usbgpu else 'usbgpu']
-def modeld_pkl_path(chestnut: bool):
+def modeld_pkl_path(usbgpu: bool):
-  prefix = 'big_' if chestnut else ''
+  prefix = 'big_' if usbgpu else ''
  return MODELS_DIR / f'{prefix}driving_tinygrad.pkl'
 def dump_oob(obj, f):
@@ -45,7 +45,7 @@ def load_oob(f):
      yield pb
  return pickle.load(io.BytesIO(opcodes), buffers=buffers())
-def chestnut_present() -> bool:
+def usbgpu_present() -> bool:
  for d in USB_DEVICES_PATH.glob("*"):
    try:
      usb_id = (int((d / "idVendor").read_text(), 16), int((d / "idProduct").read_text(), 16))
@@ -56,5 +56,5 @@ def chestnut_present() -> bool:
      pass
  return False
-def chestnut_compiled() -> bool:
+def usbgpu_compiled() -> bool:
-  return Path(get_manifest_path(modeld_pkl_path(chestnut=True))).is_file()
+  return Path(get_manifest_path(modeld_pkl_path(usbgpu=True))).is_file()
@@ -1,9 +1,7 @@
 #!/usr/bin/env python3
 from collections.abc import Callable
 import ctypes
 from functools import cached_property
 import os
-os.environ['GMMU'] = '0' # for chestnut fast loading, noop for qcom
+os.environ['GMMU'] = '0' # for usbgpu fast loading, noop for qcom
 from tinygrad.tensor import Tensor
 from tinygrad.device import Device
 import struct
@@ -32,7 +30,7 @@ from openpilot.selfdrive.modeld.compile_modeld import make_input_queues, WARP_IN
 from openpilot.selfdrive.modeld.fill_model_msg import fill_model_msg, fill_driving_model_data, fill_pose_msg, PublishState
 from openpilot.common.file_chunker import open_file_chunked
 from openpilot.selfdrive.modeld.constants import ModelConstants, Plan
-from openpilot.selfdrive.modeld.helpers import chestnut_present, chestnut_compiled, modeld_pkl_path, get_tg_input_devices, load_oob
+from openpilot.selfdrive.modeld.helpers import usbgpu_present, usbgpu_compiled, modeld_pkl_path, get_tg_input_devices, load_oob
 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld_v2.modeld_base import ModelStateBase
@@ -96,10 +94,8 @@ class ChestnutState:
    if self.big and "AMD" in Device._opened_devices and self.sends % 100 == 1:
      try:
        smu = Device["AMD"].iface.dev_impl.smu
        metrics_t = smu.smu_mod.SmuMetricsExternal_t
        smu._send_msg(smu.smu_mod.PPSMC_MSG_TransferTableSmu2Dram, smu.smu_mod.TABLE_SMU_METRICS, timeout=100)
-        metrics_buf = bytearray(smu.adev.vram.view(smu.driver_table_paddr, ctypes.sizeof(metrics_t))[:])
+        metrics = smu.read_table(smu.smu_mod.SmuMetricsExternal_t, smu.smu_mod.TABLE_SMU_METRICS).SmuMetrics
        metrics = metrics_t.from_buffer(metrics_buf).SmuMetrics
        self.metrics = {'tempC': metrics.AvgTemperature[smu.smu_mod.TEMP_HOTSPOT],
                        'memoryTempC': metrics.AvgTemperature[smu.smu_mod.TEMP_MEM],
                        'powerDrawW': metrics.AverageSocketPower,
@@ -145,18 +141,18 @@ class FrameMeta:
 class ModelState(ModelStateBase):
  prev_desire: np.ndarray  # for tracking the rising edge of the pulse
-  def __init__(self, cam_w: int, cam_h: int, chestnut: bool):
+  def __init__(self, cam_w: int, cam_h: int, usbgpu: bool):
    ModelStateBase.__init__(self)
-    input_devices = get_tg_input_devices(PROCESS_NAME, chestnut)
+    input_devices = get_tg_input_devices(PROCESS_NAME, usbgpu)
    self.WARP_DEV, self.QUEUE_DEV = input_devices['WARP_DEV'], input_devices['QUEUE_DEV']
-    jits = load_oob(open_file_chunked(modeld_pkl_path(chestnut)))
+    jits = load_oob(open_file_chunked(modeld_pkl_path(usbgpu)))
    metadata = jits['metadata']
    self.input_shapes = metadata['input_shapes']
    self.vision_input_names = [k for k in self.input_shapes if 'img' in k]
    self.output_slices = metadata['output_slices']
    self.prev_desire = np.zeros(ModelConstants.DESIRE_LEN, dtype=np.float32)
-    self.chestnut = chestnut
+    self.usbgpu = usbgpu
    self.frame_skip = ModelConstants.MODEL_RUN_FREQ // ModelConstants.MODEL_CONTEXT_FREQ
    self.input_queues, self.npy = make_input_queues(self.input_shapes, self.frame_skip, device=self.QUEUE_DEV)
@@ -172,7 +168,7 @@ class ModelState(ModelStateBase):
    return parsed_model_outputs
  def run(self, bufs: dict[str, VisionBuf], transforms: dict[str, np.ndarray],
-          inputs: dict[str, np.ndarray], after_enqueue: Callable[[], None] | None = None) -> dict[str, np.ndarray]:
+          inputs: dict[str, np.ndarray]) -> dict[str, np.ndarray] | None:
    for key in bufs.keys():
      ptr = np.frombuffer(bufs[key].data, dtype=np.uint8).ctypes.data
      yuv_size = self.frame_buf_params[key][3]
@@ -196,11 +192,11 @@ class ModelState(ModelStateBase):
    outs, = self.run_policy(
      **{k: self.input_queues[k] for k in POLICY_INPUTS if k in self.input_queues}, warped=warped
    )
    if after_enqueue is not None:
      after_enqueue()
    model_output = outs.numpy()[0]
-    if self.chestnut and not np.all(np.isfinite(model_output)):
+    if self.usbgpu and not np.all(np.isfinite(model_output)):
-      raise RuntimeError("model output not finite")
+      # TODO remove with prev_feat
      cloudlog.error("model output not finite, dropping frame")
      return None
    outputs_dict = self.parser.parse_outputs(self.slice_outputs(model_output, self.output_slices))
    self.npy['prev_feat'][:] = model_output[self.output_slices['hidden_state']]
@@ -222,12 +218,12 @@ class ModelState(ModelStateBase):
 def main(demo=False):
  cloudlog.warning("modeld init")
-  CHESTNUT = chestnut_present() and chestnut_compiled()
+  USBGPU = usbgpu_present() and usbgpu_compiled()
-  if CHESTNUT:
+  if USBGPU:
    os.environ['HCQDEV_WAIT_TIMEOUT_MS'] = '3000'
  params = Params()
-  params.put_bool("ChestnutLoading", CHESTNUT)
+  params.put_bool("UsbGpuLoading", USBGPU)
-  params.remove("ChestnutActive")
+  params.remove("UsbGpuActive")
  config_realtime_process(7, 54)
@@ -257,7 +253,7 @@ def main(demo=False):
  st = time.monotonic()
  cloudlog.warning("loading model")
  model = None
-  if CHESTNUT:
+  if USBGPU:
    big_model = None
    def load_big():
      nonlocal big_model
@@ -271,23 +267,23 @@ def main(demo=False):
    loader.start()
    loader.join(BIG_MODEL_TIMEOUT)
    model = big_model
-    params.put_bool("ChestnutActive", model is not None)
+    params.put_bool("UsbGpuActive", model is not None)
-  small_model = ModelState(vipc_client_main.width, vipc_client_main.height, False) if model is None or CHESTNUT else None
+  small_model = ModelState(vipc_client_main.width, vipc_client_main.height, False) if model is None or USBGPU else None
  if model is None:
    model = small_model
-  params.put_bool("ChestnutLoading", False)
+  params.put_bool("UsbGpuLoading", False)
  assert model is not None
  cloudlog.warning(f"models loaded in {time.monotonic() - st:.1f}s, modeld starting")
  # messaging
-  pub_socks = ["modelV2", "drivingModelData", "cameraOdometry", "modelDataV2SP"] + (["chestnutState"] if CHESTNUT else [])
+  pub_socks = ["modelV2", "drivingModelData", "cameraOdometry", "modelDataV2SP"] + (["chestnutState"] if USBGPU else [])
  pm = PubMaster(pub_socks)
  sm = SubMaster(["deviceState", "carState", "narrowRoadCameraState", "extrinsicsCalibration", "driverMonitoringState", "carControl", "lateralDelay"])
  publish_state = PublishState()
  params = Params()
-  chestnut_state = ChestnutState(pm, model.chestnut) if CHESTNUT else None
+  chestnut_state = ChestnutState(pm, model.usbgpu) if USBGPU else None
  # setup filter to track dropped frames
  frame_dropped_filter = FirstOrderFilter(0., 10., 1. / ModelConstants.MODEL_RUN_FREQ)
@@ -397,15 +393,13 @@ def main(demo=False):
    mt1 = time.perf_counter()
    try:
-      send_chestnut = (chestnut_state is not None and
+      model_output = model.run(bufs, transforms, inputs)
                       run_count % round(ModelConstants.MODEL_RUN_FREQ / SERVICE_LIST['chestnutState'].frequency) == 0)
      model_output = model.run(bufs, transforms, inputs, chestnut_state.send if send_chestnut else None)
    except Exception:
-      if not params.get_bool("ChestnutActive"):
+      if not params.get_bool("UsbGpuActive"):
        raise
      # fallback to small model
      cloudlog.exception("big model failed, fall back to small")
-      params.put_bool("ChestnutActive", False)
+      params.put_bool("UsbGpuActive", False)
      assert small_model is not None
      model = small_model
      if chestnut_state is not None:
@@ -425,7 +419,7 @@ def main(demo=False):
      fill_model_msg(modelv2_send, model_output, action,
                     publish_state, meta_main.frame_id, meta_extra.frame_id, frame_id,
                     frame_drop_ratio, meta_main.timestamp_eof, model_execution_time, extrinsics_calibration_seen)
-      modelv2_send.modelV2.big = model.chestnut
+      modelv2_send.modelV2.big = model.usbgpu
      desire_state = modelv2_send.modelV2.meta.desireState
      l_lane_change_prob = desire_state[log.Desire.laneChangeLeft]
@@ -447,6 +441,10 @@ def main(demo=False):
      pm.send('modelDataV2SP', mdv2sp_send)
    last_vipc_frame_id = meta_main.frame_id
    if chestnut_state is not None and run_count % round(ModelConstants.MODEL_RUN_FREQ / SERVICE_LIST['chestnutState'].frequency) == 0:
      chestnut_state.send()
 if __name__ == "__main__":
  try:
    import argparse
@@ -18,7 +18,7 @@
    "_comment": "Set extra field to the failed reason."
  },
  "Offroad_ChestnutBranch": {
-    "text": "Chestnut detected! Switch to the %1 branch to use chestnut-class models.",
+    "text": "Chestnut detected! Switch to the release-chestnut branch to use chestnut-class models.",
    "severity": 0
  },
  "Offroad_UnregisteredHardware": {
@@ -195,17 +195,17 @@ class SelfdriveD(CruiseHelper):
      self.events.add(EventName.joystickDebug)
      self.startup_event = None
-    loading = self.params.get_bool("ChestnutLoading")
+    loading = self.params.get_bool("UsbGpuLoading")
    if self.big_model_loading and not loading:
      self.big_model_ready_t = time.monotonic()
    self.big_model_loading = loading
    if self.big_model_loading:
      self.events.add(EventName.bigModelLoading)
-    big_active = self.params.get("ChestnutActive")
+    big_active = self.params.get("UsbGpuActive")
-    chestnut_present = self.sm['deviceState'].chestnutPresent
+    usbgpu_present = self.sm['deviceState'].chestnutPresent
    model_unavailable = big_active is True and self.sm.seen['modelV2'] and not self.sm.alive['modelV2']
-    big_failed = big_active is False or model_unavailable or (self.big_model_active and not chestnut_present)
+    big_failed = big_active is False or model_unavailable or (self.big_model_active and not usbgpu_present)
    if big_failed and not self.big_model_failed:
      self.events.add(EventName.bigModelFailed)
    self.big_model_failed = big_failed
@@ -168,16 +168,9 @@ class Sidebar(Widget, SidebarSP):
    # Home/Flag button
    flag_pressed = mouse_down and rl.check_collision_point_rec(mouse_pos, HOME_BTN)
    button_img = self._flag_img if ui_state.started else self._home_img
    button_pos = rl.Vector2(HOME_BTN.x, HOME_BTN.y)
    icon_opacity = 1.0
    if gui_app.sunnypilot_ui():
      button_img, button_pos, icon_opacity = SidebarSP._get_home_icon(self, button_img)
    tint = Colors.BUTTON_PRESSED if (ui_state.started and flag_pressed) else Colors.BUTTON_NORMAL
-    if icon_opacity < 1.0:
+    rl.draw_texture_ex(button_img, rl.Vector2(HOME_BTN.x, HOME_BTN.y), 0.0, 1.0, tint)
      tint = rl.Color(tint[0], tint[1], tint[2], int(255 * icon_opacity))
    rl.draw_texture_ex(button_img, button_pos, 0.0, 1.0, tint)
    # Microphone button
    if self._recording_audio:
@@ -9,7 +9,7 @@ from openpilot.system.ui.widgets.layouts import HBoxLayout
 from openpilot.system.ui.widgets.icon_widget import IconWidget
 from openpilot.system.ui.widgets.label import UnifiedLabel, gui_label
 from openpilot.system.ui.lib.application import gui_app, FontWeight, MousePos
-from openpilot.selfdrive.ui.ui_state import ui_state, ChestnutState
+from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.common.version import RELEASE_BRANCHES
 HEAD_BUTTON_FONT_SIZE = 40
@@ -139,8 +139,8 @@ class MiciHomeLayout(Widget):
    self._version_text = self._get_version_text()
    self._experimental_icon = IconWidget("icons_mici/experimental_mode.png", (48, 48))
-    self._chestnut_icon = IconWidget("icons_mici/chestnut_green.png", (68, 40))
+    self._egpu_icon = IconWidget("icons_mici/egpu_green.png", (50, 37))
-    self._chestnut_failed_icon = IconWidget("icons_mici/chestnut_orange.png", (68, 40))
+    self._egpu_icon_gray = IconWidget("icons_mici/egpu_gray.png", (50, 37))
    self._mic_icon = IconWidget("icons_mici/microphone.png", (32, 46))
    self._body_icon = IconWidget("icons_mici/body.png", (54, 37))
@@ -150,8 +150,8 @@ class MiciHomeLayout(Widget):
      IconWidget("icons_mici/settings.png", (48, 48), opacity=0.9),
      NetworkIcon(),
      self._experimental_icon,
-      self._chestnut_icon,
+      self._egpu_icon,
-      self._chestnut_failed_icon,
+      self._egpu_icon_gray,
      self._body_icon,
      self._mic_icon,
    ], spacing=18)
@@ -248,11 +248,8 @@ class MiciHomeLayout(Widget):
    # ***** Center-aligned bottom section icons *****
    self._experimental_icon.set_visible(ui_state.experimental_mode)
-    if gui_app.sunnypilot_ui():
+    self._egpu_icon.set_visible(ui_state.sm["deviceState"].chestnutPresent and ui_state.usbgpu_compiled)
-      self._set_chestnut_visibility()
+    self._egpu_icon_gray.set_visible(ui_state.sm["deviceState"].chestnutPresent and not ui_state.usbgpu_compiled)
    else:
      self._chestnut_icon.set_visible(ui_state.chestnut_state in (ChestnutState.READY, ChestnutState.LOADING, ChestnutState.ACTIVE))
      self._chestnut_failed_icon.set_visible(ui_state.chestnut_state in (ChestnutState.UNCOMPILED, ChestnutState.FAILED))
    self._mic_icon.set_visible(ui_state.recording_audio)
    self._body_icon.set_visible(bool(ui_state.is_body))
@@ -3,7 +3,7 @@ import pyray as rl
 from dataclasses import dataclass
 from openpilot.common.constants import CV
 from openpilot.selfdrive.ui.mici.onroad.torque_bar import TorqueBar
-from openpilot.selfdrive.ui.ui_state import ui_state, UIStatus, ChestnutState
+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.multilang import tr
 from openpilot.system.ui.lib.text_measure import measure_text_cached
@@ -107,7 +107,8 @@ class HudRenderer(Widget):
    self.speed: float = 0.0
    self.v_ego_cluster_seen: bool = False
    self._engaged: bool = False
-    self._chestnut_fade_time: float = 0
+    self._small_model_engaged: bool = False
    self._egpu_fade_time: float = 0
    self._can_draw_top_icons = True
    self._show_wheel_critical = False
@@ -123,15 +124,17 @@ class HudRenderer(Widget):
    self._txt_wheel: rl.Texture = gui_app.texture('icons_mici/wheel.png', 50, 50)
    self._txt_wheel_critical: rl.Texture = gui_app.texture('icons_mici/wheel_critical.png', 50, 50)
    self._txt_exclamation_point: rl.Texture = gui_app.texture('icons_mici/exclamation_point.png', 9, 44)
-    self._txt_chestnut: rl.Texture = gui_app.texture('icons_mici/chestnut.png', 60, 44)
+    self._txt_egpu: rl.Texture = gui_app.texture('icons_mici/egpu.png', 60, 44)
-    self._txt_chestnut_green: rl.Texture = gui_app.texture('icons_mici/chestnut_green.png', 60, 44)
+    self._txt_egpu_green: rl.Texture = gui_app.texture('icons_mici/egpu_green.png', 60, 44)
-    self._txt_chestnut_orange: rl.Texture = gui_app.texture('icons_mici/chestnut_orange.png', 75, 44)
+    self._txt_egpu_orange: rl.Texture = gui_app.texture('icons_mici/egpu_orange.png', 60, 44)
-    self._chestnut_icon: rl.Texture | None = None
+    self._txt_egpu_crossed: rl.Texture = gui_app.texture('icons_mici/egpu_crossed.png', 60, 52)
    self._egpu_icon: rl.Texture | None = None
    self._wheel_alpha_filter = FirstOrderFilter(0, 0.05, 1 / gui_app.target_fps)
    self._wheel_y_filter = FirstOrderFilter(0, 0.1, 1 / gui_app.target_fps)
    self._set_speed_alpha_filter = FirstOrderFilter(0.0, 0.1, 1 / gui_app.target_fps)
-    self._chestnut_alpha_filter = FirstOrderFilter(0.0, 0.1, 1 / gui_app.target_fps)
+    self._egpu_alpha_filter = FirstOrderFilter(0.0, 0.1, 1 / gui_app.target_fps)
  def set_wheel_critical_icon(self, critical: bool):
    """Set the wheel icon to critical or normal state."""
@@ -162,10 +165,13 @@ class HudRenderer(Widget):
      controls_state.deprecated.vCruise if v_cruise_cluster == 0.0 else v_cruise_cluster
    )
    engaged = sm['selfdriveState'].enabled
    if (engaged and not self._engaged and not ui_state.usbgpu_loading and ui_state.usbgpu_active is not True and
        ui_state.sm.recv_frame['modelV2'] > ui_state.started_frame):
      self._small_model_engaged = True
    if engaged != self._engaged:
      self._egpu_fade_time = rl.get_time() if engaged else 0
    if (set_speed != self.set_speed and engaged) or (engaged and not self._engaged):
      self._set_speed_changed_time = rl.get_time()
    if engaged != self._engaged:
      self._chestnut_fade_time = rl.get_time() if engaged else 0
    self._engaged = engaged
    self.set_speed = set_speed
    self.is_cruise_set = 0 < self.set_speed < SET_SPEED_NA
@@ -185,7 +191,8 @@ class HudRenderer(Widget):
    if self.is_cruise_set:
      self._draw_set_speed(rect)
-    self._draw_model_source(rect)
+    if ui_state.usbgpu and ui_state.usbgpu_compiled:
      self._draw_model_source(rect)
    self._draw_steering_wheel(rect)
@@ -193,24 +200,30 @@ class HudRenderer(Widget):
    if ui_state.sm.recv_frame['selfdriveState'] < ui_state.started_frame:
      return
-    loading = ui_state.chestnut_state == ChestnutState.LOADING
+    big_failed = (ui_state.usbgpu_active is False or not ui_state.sm['deviceState'].chestnutPresent or
                  (ui_state.usbgpu_active is True and ui_state.sm.recv_frame['modelV2'] > ui_state.started_frame and
                   not ui_state.sm.alive['modelV2']) or
                  (ui_state.usbgpu_active is None and ui_state.sm.recv_frame['modelV2'] > ui_state.started_frame))
    self._small_model_engaged &= big_failed
    loading = ui_state.usbgpu_loading or (ui_state.usbgpu_active is None and not big_failed)
    if loading:
-      icon = self._txt_chestnut
+      pulse = 0.5 - 0.5 * math.cos(rl.get_time() * 6.0)
-      opacity = 0.35 + 0.65 * (0.5 - 0.5 * math.cos(rl.get_time() * 6.0))
+      icon = self._txt_egpu
-    elif ui_state.chestnut_state in (ChestnutState.UNCOMPILED, ChestnutState.FAILED):
+      opacity = 0.35 + 0.65 * pulse
-      icon = self._txt_chestnut_orange
+    elif self._small_model_engaged:
-      opacity = 1.0
+      icon = self._txt_egpu_crossed
-    elif ui_state.chestnut_state == ChestnutState.ACTIVE:
+      opacity = 0.65
-      icon = self._txt_chestnut_green
+    elif big_failed:
      icon = self._txt_egpu_orange
      opacity = 1.0
    else:
-      return
+      icon = self._txt_egpu_green
      opacity = 1.0
-    if icon is not self._chestnut_icon:
+    if icon is not self._egpu_icon:
-      self._chestnut_fade_time = rl.get_time()
+      self._egpu_fade_time = rl.get_time()
-      self._chestnut_icon = icon
+      self._egpu_icon = icon
-    visible = loading or rl.get_time() - self._chestnut_fade_time < SET_SPEED_PERSISTENCE
+    alpha = self._egpu_alpha_filter.update(loading or 0 < rl.get_time() - self._egpu_fade_time < SET_SPEED_PERSISTENCE)
    alpha = self._chestnut_alpha_filter.update(visible)
    if alpha < 1e-2:
      return
@@ -149,15 +149,11 @@ class BigButton(Widget):
  def set_touch_valid_callback(self, touch_callback: Callable[[], bool]) -> None:
    super().set_touch_valid_callback(lambda: touch_callback() and self._grow_animation_until is None)
-  def _title_width_hint(self) -> int:
+  def _width_hint(self) -> int:
-    # A value moves the title to the top, where it shares space with the icon
+    # A value moves the title to the top, where it shares space with the icon.
    icon_size = self._txt_icon.width if self._txt_icon and self.value else 0
    return int(self._rect.width - self.LABEL_HORIZONTAL_PADDING * 2 - icon_size)
  def _subtitle_width_hint(self) -> int:
    # Bottom aligned, so it sits below the icon
    return int(self._rect.width - self.LABEL_HORIZONTAL_PADDING * 2)
  def _get_label_font_size(self):
    if len(self.text) <= 18:
      return 48
@@ -232,14 +228,14 @@ class BigButton(Widget):
    label_color = LABEL_COLOR if self.enabled else rl.Color(255, 255, 255, int(255 * 0.35))
    self._label.set_color(label_color)
-    label_rect = rl.Rectangle(label_x, btn_y + self.LABEL_VERTICAL_PADDING, self._title_width_hint(),
+    label_rect = rl.Rectangle(label_x, btn_y + self.LABEL_VERTICAL_PADDING, self._width_hint(),
                              self._rect.height - self.LABEL_VERTICAL_PADDING * 2)
    self._label.render(label_rect)
    if self.value:
-      label_y = label_rect.y + self._label.get_content_height(int(label_rect.width))
+      label_y = btn_y + self.LABEL_VERTICAL_PADDING + self._label.get_content_height(self._width_hint())
      sub_label_height = btn_y + self._rect.height - self.LABEL_VERTICAL_PADDING - label_y
-      sub_label_rect = rl.Rectangle(label_x, label_y, self._subtitle_width_hint(), sub_label_height)
+      sub_label_rect = rl.Rectangle(label_x, label_y, self._width_hint(), sub_label_height)
      self._sub_label.render(sub_label_rect)
    # ICON -------------------------------------------------------------------
@@ -316,6 +312,9 @@ class BigMultiToggle(BigToggle):
    self.set_value(self._options[0])
  def _width_hint(self) -> int:
    return int(self._rect.width - self.LABEL_HORIZONTAL_PADDING * 2 - self._txt_enabled_toggle.width)
  def _handle_mouse_release(self, mouse_pos: MousePos):
    super()._handle_mouse_release(mouse_pos)
    cur_idx = self._options.index(self.value)
@@ -364,6 +363,9 @@ class GreyBigButton(BigButton):
  def LABEL_VERTICAL_PADDING(self):
    return BigButton.LABEL_VERTICAL_PADDING if self._label.text else 18
  def _width_hint(self) -> int:
    return int(self._rect.width - self.LABEL_HORIZONTAL_PADDING * 2)
  def _get_label_font_size(self):
    return 36
@@ -192,7 +192,7 @@ class ModelRenderer(Widget, ChevronMetrics, ModelRendererSP):
    max_idx = self._get_path_length_idx(path_x_array, max_distance)
    self._path.projected_points = self._map_line_to_polygon(
-      self._path.raw_points, self._get_path_half_width(), self._path_offset_z, max_idx, max_distance, allow_invert=False
+      self._path.raw_points, 0.9, self._path_offset_z, max_idx, max_distance, allow_invert=False
    )
    self._update_experimental_gradient()
@@ -292,7 +292,7 @@ class ModelRenderer(Widget, ChevronMetrics, ModelRendererSP):
    allow_throttle = sm['longitudinalPlan'].allowThrottle or not self._longitudinal_control
    self._blend_filter.update(int(allow_throttle))
-    if ui_state.rainbow_path and self._lateral_active:
+    if ui_state.rainbow_path:
      self.rainbow_path.draw_rainbow_path(self._rect, self._path)
      return
@@ -20,7 +20,6 @@ from openpilot.system.ui.widgets.list_view import button_item
 from openpilot.system.ui.sunnypilot.widgets.html_render import HtmlModalSP
 from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.external_storage import external_storage_item
 PREBUILT_PATH = os.path.join(Paths.comma_home(), "prebuilt") if PC else "/data/openpilot/prebuilt"
@@ -53,11 +52,7 @@ class DeveloperLayoutSP(DeveloperLayout):
    self.error_log_btn = button_item(tr("Error Log"), tr("VIEW"), tr("View the error log for sunnypilot crashes."), callback=self._on_error_log_clicked)
-    self.external_storage = external_storage_item(tr("External Storage"), description=tr("Extend your comma device's storage by inserting a USB drive " +
+    self.items: list = [self.show_advanced_controls, self.enable_github_runner_toggle, self.enable_copyparty_toggle, self.prebuilt_toggle, self.error_log_btn,]
                                                                                         "into the aux port."))
    self.items: list = [self.show_advanced_controls, self.enable_github_runner_toggle, self.enable_copyparty_toggle, self.prebuilt_toggle,
                        self.external_storage, self.error_log_btn,]
  @staticmethod
  def _on_prebuilt_toggled(state):
@@ -1,261 +0,0 @@
 """
 Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 import pyray as rl
 import threading
 import subprocess
 import copy
 from enum import Enum
 from collections.abc import Callable
 from openpilot.common.params import Params
 from openpilot.common.hardware import PC
 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.lib.multilang import tr, tr_noop
 from openpilot.system.ui.widgets import DialogResult
 from openpilot.system.ui.widgets.button import Button, ButtonStyle
 from openpilot.system.ui.widgets.confirm_dialog import alert_dialog, ConfirmDialog
 from openpilot.system.ui.widgets.list_view import (
  ItemAction,
  ListItem,
  BUTTON_HEIGHT,
  BUTTON_BORDER_RADIUS,
  BUTTON_FONT_SIZE,
  BUTTON_WIDTH,
 )
 VALUE_FONT_SIZE = 48
 class ExternalStorageState(Enum):
  DISABLED = tr_noop("DISABLED")
  LOADING = tr_noop("LOADING")
  CHECK = tr_noop("CHECK")
  MOUNT = tr_noop("MOUNT")
  UNMOUNT = tr_noop("UNMOUNT")
  FORMAT = tr_noop("FORMAT")
 class ExternalStorageAction(ItemAction):
  MAX_WIDTH = 500
  def __init__(self):
    super().__init__(self.MAX_WIDTH, True)
    self._params = Params()
    self._error_message = ""
    self._text_font = gui_app.font(FontWeight.NORMAL)
    self._button = Button(
      "",
      click_callback=self._handle_button_click,
      button_style=ButtonStyle.LIST_ACTION,
      border_radius=BUTTON_BORDER_RADIUS,
      font_size=BUTTON_FONT_SIZE,
    )
    self._value_text = ""
    self._formatting = False
    self._refresh_pending = False
    self._state = ExternalStorageState.CHECK
    self._refresh_state()
    self.refresh()
  def set_touch_valid_callback(self, callback):
    def wrapped():
      if self._state == ExternalStorageState.DISABLED:
        return False
      return callback()
    super().set_touch_valid_callback(wrapped)
    self._button.set_touch_valid_callback(wrapped)
  def _run(self, cmd: str) -> bool:
    return subprocess.call(["sh", "-c", cmd]) == 0
  def _run_output(self, cmd: str) -> str:
    try:
      out = subprocess.check_output(["sh", "-c", cmd], universal_newlines=True)
      return out.strip()
    except Exception:
      return ""
  def _render(self, rect: rl.Rectangle) -> bool:
    if self._error_message:
      msg = copy.copy(self._error_message)
      gui_app.set_modal_overlay(alert_dialog(msg))
      self._error_message = ""
    if self._value_text:
      text_size = measure_text_cached(self._text_font, self._value_text, VALUE_FONT_SIZE)
      rl.draw_text_ex(
        self._text_font,
        self._value_text,
        (rect.x + rect.width - BUTTON_WIDTH - text_size.x - 30,
         rect.y + (rect.height - text_size.y) / 2),
        VALUE_FONT_SIZE,
        1.0,
        rl.Color(170, 170, 170, 255),
      )
    button_rect = rl.Rectangle(
      rect.x + rect.width - BUTTON_WIDTH,
      rect.y + (rect.height - BUTTON_HEIGHT) / 2,
      BUTTON_WIDTH,
      BUTTON_HEIGHT
    )
    self._button.set_rect(button_rect)
    self._button.set_text(tr(self._state.value))
    self._button.set_enabled(self._state not in (ExternalStorageState.LOADING,
                                                 ExternalStorageState.DISABLED))
    self._button.render(button_rect)
    return False
  def _refresh_state(self):
    if PC:
      self._state = ExternalStorageState.DISABLED
      self._button.set_enabled(False)
      self._value_text = ""
  def debounced_refresh(self):
    if self._refresh_pending:
      return
    self._refresh_pending = True
    def _timer():
      import time
      time.sleep(0.25)
      self._refresh_pending = False
      self.refresh()
    threading.Thread(target=_timer, daemon=True).start()
  def refresh(self):
    def _work():
      is_mounted = self._run("findmnt -n /mnt/external_realdata")
      has_drive = self._run("lsblk -f /dev/sdg")
      has_fs = self._run("lsblk -f /dev/sdg1 | grep -q ext4")
      has_label = self._run("blkid /dev/sdg1 | grep -q 'LABEL=\"openpilot\"'")
      info = ""
      if is_mounted and has_label:
        info = self._run_output(
          "df -h /mnt/external_realdata | awk 'NR==2 {print $3 \"/\" $2}'"
        )
      def apply():
        if self._formatting:
          self._value_text = tr("formatting")
          self._state = ExternalStorageState.FORMAT
          return
        if not has_drive:
          self._value_text = tr("insert drive")
          self._state = ExternalStorageState.CHECK
        elif not has_fs or not has_label:
          self._value_text = tr("needs format")
          self._state = ExternalStorageState.FORMAT
        elif is_mounted:
          self._value_text = info
          self._state = ExternalStorageState.UNMOUNT
        else:
          self._value_text = tr("drive detected")
          self._state = ExternalStorageState.MOUNT
      apply()
    threading.Thread(target=_work, daemon=True).start()
  def _handle_button_click(self):
    st = self._state
    if st == ExternalStorageState.DISABLED:
      return
    if st in (ExternalStorageState.CHECK, ExternalStorageState.MOUNT):
      self.mount_storage()
    elif st == ExternalStorageState.UNMOUNT:
      self.unmount_storage()
    elif st == ExternalStorageState.FORMAT:
      dialog = ConfirmDialog(
          tr("Are you sure you want to format this drive? This will erase all data."),
          confirm_text=tr("Format"),
          cancel_text=tr("Cancel"),
        )
      gui_app.set_modal_overlay(dialog, callback=self._confirm_format)
  def _confirm_format(self, result: DialogResult):
    if result == DialogResult.CONFIRM:
      self.format_storage()
  def mount_storage(self):
    self._value_text = tr("mounting")
    self._state = ExternalStorageState.LOADING
    def _work():
      cmd = """
        sudo mount -o remount,rw / &&
        sudo mkdir -p /mnt/external_realdata &&
        (grep -q '/dev/sdg1 /mnt/external_realdata' /etc/fstab ||
         echo '/dev/sdg1 /mnt/external_realdata ext4 defaults,nofail 0 2' >> /etc/fstab) &&
        sudo systemctl daemon-reexec &&
        sudo mount /mnt/external_realdata &&
        sudo chown -R comma:comma /mnt/external_realdata &&
        sudo chmod -R 775 /mnt/external_realdata &&
        sudo mount -o remount,ro /
      """
      subprocess.call(["sh", "-c", cmd])
      self.debounced_refresh()
    threading.Thread(target=_work, daemon=True).start()
  def unmount_storage(self):
    self._value_text = tr("unmounting")
    self._state = ExternalStorageState.LOADING
    def _work():
      subprocess.call(["sh", "-c", "sudo umount /mnt/external_realdata"])
      self.debounced_refresh()
    threading.Thread(target=_work, daemon=True).start()
  def format_storage(self):
    self._formatting = True
    self._value_text = tr("formatting")
    self._state = ExternalStorageState.LOADING
    def _work():
      cmd = """
        sudo wipefs -a /dev/sdg &&
        sudo parted -s /dev/sdg mklabel gpt mkpart primary ext4 0% 100% &&
        sudo mkfs.ext4 -F -L openpilot /dev/sdg1
      """
      exitcode = subprocess.call(["sh", "-c", cmd])
      def apply():
        self._formatting = False
        if exitcode == 0:
          self.mount_storage()
        else:
          self._value_text = tr("needs format")
          self._state = ExternalStorageState.FORMAT
      apply()
    threading.Thread(target=_work, daemon=True).start()
 def external_storage_item(title: str | Callable[[], str], description: str | Callable[[], str]) -> ListItem:
  return ListItem(
    title=title,
    description=description,
    action_item=ExternalStorageAction()
  )
@@ -10,10 +10,9 @@ import time
 import pyray as rl
 from openpilot.cereal import custom
-from openpilot.sunnypilot.models.helpers import ACTIVE_BUNDLE_KEYS, get_selected_bundle, resolve_bundle_by_ref
+from openpilot.sunnypilot.models.default_model import DEFAULT_MODEL
 from openpilot.common.constants import CV
 from openpilot.selfdrive.ui.ui_state import device, ui_state
 from openpilot.selfdrive.ui.sunnypilot.model_info import big_model_state, bundles_for_source, carrying_model, default_model_name, queued_name
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.widgets import DialogResult, Widget
@@ -23,9 +22,9 @@ from openpilot.system.ui.widgets.toggle import ON_COLOR
 from openpilot.sunnypilot.models.runners.constants import CUSTOM_MODEL_PATH
 from openpilot.system.ui.sunnypilot.lib.styles import style
-from openpilot.system.ui.sunnypilot.lib.utils import NoElideButtonAction, ScrollingButtonAction
+from openpilot.system.ui.sunnypilot.lib.utils import NoElideButtonAction
 from openpilot.system.ui.sunnypilot.widgets.list_view import ListItemSP, toggle_item_sp, option_item_sp
-from openpilot.system.ui.sunnypilot.widgets.download_status import download_status_item
+from openpilot.system.ui.sunnypilot.widgets.progress_bar import progress_item
 from openpilot.system.ui.sunnypilot.widgets.tree_dialog import TreeOptionDialog, TreeNode, TreeFolder
 if gui_app.sunnypilot_ui():
@@ -36,11 +35,9 @@ class ModelsLayout(Widget):
  def __init__(self):
    super().__init__()
    self.model_manager = None
    self.download_status = None
    self.prev_download_status = None
    self.model_dialog = None
    self._selection_source = None
    self._downloading = False
    self._verifying = False
    self._last_note = None
    self.last_cache_calc_time = 0
    self._initialize_items()
@@ -52,24 +49,21 @@ class ModelsLayout(Widget):
    self._scroller = Scroller(self.items, line_separator=True, spacing=0)
  def _initialize_items(self):
-    self.small_model_item = ListItemSP(
+    self.current_model_item = ListItemSP(
-      title=tr("Small Model"),
+      title=tr("Current Model"),
      description="",
-      action_item=ScrollingButtonAction(tr("SELECT")),
+      action_item=NoElideButtonAction(tr("SELECT")),
-      callback=lambda: self._open_source_dialog("qcom")
+      callback=self._handle_current_model_clicked
    )
-    self.big_model_item = ListItemSP(
+    self.supercombo_label = progress_item(tr("Driving Model"))
-      title=tr("Big Model"),
+    self.vision_label = progress_item(tr("Vision Model"))
-      action_item=ScrollingButtonAction(tr("SELECT")),
+    self.policy_label = progress_item(tr("Policy Model"))
-      callback=lambda: self._open_source_dialog("chestnut")
+    self.off_policy_label = progress_item(tr("Off-Policy Model"))
-    )
+    self.on_policy_label = progress_item(tr("On-Policy Model"))
    self.download_item = download_status_item(lambda: tr("Download") if self._downloading else tr("Model Status"))
    self.refresh_item = button_item(tr("Refresh Model List"), tr("REFRESH"), "",
                                    lambda: (ui_state.params.put("ModelManager_LastSyncTime", 0),
                                             ui_state.params.put("ModelManager_LastSyncTime_Chestnut", 0),
                                             gui_app.push_widget(alert_dialog(tr("Fetching Latest Models")))))
    self.clear_cache_item = ListItemSP(
@@ -79,9 +73,7 @@ class ModelsLayout(Widget):
      callback=self._clear_cache
    )
-    self.cancel_download_item = button_item(lambda: tr("Cancel Verification") if self._verifying else tr("Cancel Download"),
+    self.cancel_download_item = button_item(tr("Cancel Download"), tr("Cancel"), "", lambda: ui_state.params.remove("ModelManager_DownloadIndex"))
                                            tr("Cancel"), "",
                                            lambda: ui_state.params.remove("ModelManager_DownloadRef"))
    self.lane_turn_value_control = option_item_sp(tr("Adjust Lane Turn Speed"), "LaneTurnValue", 500, 2000,
                                                  tr("Set the maximum speed for lane turn desires. Default is 19 mph."),
@@ -106,7 +98,8 @@ class ModelsLayout(Widget):
                                        1, None, True, "", style.BUTTON_ACTION_WIDTH, None, True,
                                        lambda v: f"{v / 100:.2f} m")
-    self.items = [self.small_model_item, self.big_model_item, self.cancel_download_item, self.download_item, self.refresh_item, self.clear_cache_item,
+    self.items = [self.current_model_item, self.cancel_download_item, self.supercombo_label, self.vision_label,
                  self.policy_label, self.off_policy_label, self.on_policy_label, self.refresh_item, self.clear_cache_item,
                  self.lane_turn_desire_toggle, self.lane_turn_value_control, self.lagd_toggle, self.delay_control, self.camera_offset]
  def _update_lagd_description(self, lagd_toggle: bool):
@@ -120,16 +113,16 @@ class ModelsLayout(Widget):
      desc += f"<br>{tr('Actuator Delay:')} {cp:.2f} s + {tr('Software Delay:')} {sw:.2f} s = {tr('Total Delay:')} {cp + sw:.2f} s"
    self.lagd_toggle.set_description(desc)
  def _is_downloading(self):
    return (self.model_manager and self.model_manager.selectedBundle and
            self.model_manager.selectedBundle.status == custom.ModelManagerSP.DownloadStatus.downloading)
  @staticmethod
  def calculate_cache_size():
    cache_size = 0.0
    if os.path.exists(CUSTOM_MODEL_PATH):
-      for file in os.listdir(CUSTOM_MODEL_PATH):
+      cache_size = sum(os.path.getsize(os.path.join(CUSTOM_MODEL_PATH, file)) for file in os.listdir(CUSTOM_MODEL_PATH)) / (1024**2)
-        try:
+    return cache_size
          cache_size += os.path.getsize(os.path.join(CUSTOM_MODEL_PATH, file))
        except OSError:
          continue
    return cache_size / (1024**2)
  def _clear_cache(self):
    def _callback(response):
@@ -142,178 +135,109 @@ class ModelsLayout(Widget):
    gui_app.push_widget(dialog)
  def _handle_bundle_download_progress(self):
    labels = {custom.ModelManagerSP.Model.Type.supercombo: self.supercombo_label,
              custom.ModelManagerSP.Model.Type.vision: self.vision_label,
              custom.ModelManagerSP.Model.Type.policy: self.policy_label,
              custom.ModelManagerSP.Model.Type.offPolicy: self.off_policy_label,
              custom.ModelManagerSP.Model.Type.onPolicy: self.on_policy_label}
    for label in labels.values():
      label.set_visible(False)
    self.cancel_download_item.set_visible(False)
-    self._downloading = False
+
-    self._verifying = False
+    if not self.model_manager or (not self.model_manager.selectedBundle and not self.model_manager.activeBundle):
-    self.download_item.set_visible(True)
+      return
    bundle = self.model_manager.selectedBundle if self._is_downloading() or (
      self.model_manager.selectedBundle and self.model_manager.selectedBundle.status == custom.ModelManagerSP.DownloadStatus.failed
    ) else self.model_manager.activeBundle
    if not bundle:
      return
    self.download_status = bundle.status
    status_changed = self.prev_download_status != self.download_status
    self.prev_download_status = self.download_status
    self.cancel_download_item.set_visible(bool(self.model_manager.selectedBundle) and ui_state.params.get("ModelManager_DownloadIndex") is not None)
    if (current_time := time.monotonic()) - self.last_cache_calc_time > 0.5:
      self.last_cache_calc_time = current_time
      self.clear_cache_item.action_item.set_value(f"{self.calculate_cache_size():.2f} MB")
-    bundle = self.model_manager.selectedBundle if self.model_manager else None
+    if self.download_status == custom.ModelManagerSP.DownloadStatus.downloading:
    progresses = [model.artifact.downloadProgress for model in bundle.models if model.artifact.fileName] if bundle else []
    if not progresses or bundle.status not in (custom.ModelManagerSP.DownloadStatus.downloading,
                                               custom.ModelManagerSP.DownloadStatus.failed):
      self.download_item.action_item.update(name="", segments=self._slot_segments())
      return
    self.cancel_download_item.set_visible(ui_state.params.get("ModelManager_DownloadRef") is not None)
    if bundle.status == custom.ModelManagerSP.DownloadStatus.downloading:
      device._reset_interactive_timeout()
-    state = self._download_row_state(progresses, bundle.internalName)
+    for model in bundle.models:
-    if queued := queued_name(bundle.ref):
+      if label := labels.get(getattr(model.type, 'raw', model.type)):
-      state["name"] += f"  |  {queued} {tr('queued')}"
+        label.set_visible(True)
-    self.download_item.action_item.update(**state)
+        p = model.artifact.downloadProgress
-    self._downloading = self.download_item.action_item.downloading
+        text, show, color = f"pending - {bundle.displayName}", False, rl.GRAY
-    ds = custom.ModelManagerSP.DownloadStatus
+        if p.status == custom.ModelManagerSP.DownloadStatus.downloading:
-    self._verifying = any(getattr(p.status, 'raw', p.status) == ds.verifying for p in progresses)
+          text, show = f"{int(p.progress)}% - {bundle.displayName}", True
-
+        elif p.status in (custom.ModelManagerSP.DownloadStatus.downloaded, custom.ModelManagerSP.DownloadStatus.cached):
-  def _slot_segments(self):
+          status_text = tr("from cache" if p.status == custom.ModelManagerSP.DownloadStatus.cached else "downloaded")
-    """small and big slots side by side; green marks the slot whose pick is actually
+          text, color = f"{bundle.displayName} - {status_text if status_changed else tr('ready')}", ON_COLOR
-    driving (runner-matched, so a failed Default big greens neither slot), an empty
+        elif p.status == custom.ModelManagerSP.DownloadStatus.failed:
-    slot shows its default."""
+          text, color = f"download failed - {bundle.displayName}", rl.RED
-    big_state = big_model_state()
+        label.action_item.update(p.progress, text, show, color)
    carry_source, carry_internal, _ = carrying_model()
    segments = []
    for source, label in (("qcom", tr("small")), ("chestnut", tr("big"))):
      if segments:
        segments.append(("|", rl.GRAY, None, None))
      bundle = get_selected_bundle(ui_state.params, source)
      name = bundle.internalName if bundle else default_model_name(source)
      color = ON_COLOR if (source == carry_source and name == carry_internal) else rl.LIGHTGRAY
      name = "● " + name
      if source == "chestnut":
        if big_state == 'failed':
          color = rl.RED
        elif big_state == 'loading':
          color = rl.GOLD
      segments.append((label, rl.GRAY, None, None))
      segments.append((name, color, None, None))
    return segments
  @staticmethod
-  def _set_item_note(item, text):
+  def _show_reset_params_dialog():
-    # a description renders only while shown; hide before clearing or the
+    def _callback(response):
-    # empty description keeps its visible state
+      if response == DialogResult.CONFIRM:
-    if text:
+        ui_state.params.remove("CalibrationParams")
-      item.set_description(text)
+        ui_state.params.remove("LiveTorqueParameters")
-      item.show_description(True)
+    msg = tr("Model download has started in the background. We suggest resetting calibration. Would you like to do that now?")
-    else:
+    dialog = ConfirmDialog(msg, tr("Reset Calibration"), callback=_callback)
-      item.show_description(False)
+    gui_app.push_widget(dialog)
      item.set_description("")
  def _status_note(self) -> str:
    """The failover story for the Model Status row. One-way big -> small, and the
    fallback is runner-matched: a Default big can only fall back to the Default
    small (stock modeld), a custom big has no automatic fallback yet."""
    if not ui_state.chestnut_present:
      return ""
    big_bundle = get_selected_bundle(ui_state.params, "chestnut")
    big_name = big_bundle.internalName if big_bundle else default_model_name("chestnut")
    big_is_default = big_bundle is None
    fallback_name = default_model_name("qcom")
    state = big_model_state()
    if state == 'failed':
      if big_is_default:
        return tr("Big model unavailable, {} is driving until the next drive.").format(fallback_name)
      return tr("Big model unavailable until the next drive.")
    if state == 'loading':
      if big_is_default:
        return tr("{} drives until the big model is ready.").format(fallback_name)
      return tr("Getting the big model ready.")
    if big_is_default:
      return tr("{} will drive. If it fails during a drive, {} takes over until the next drive.").format(big_name, fallback_name)
    return tr("{} will drive when the chestnut is ready.").format(big_name)
  @staticmethod
  def _download_row_state(progresses, name: str) -> dict:
    """Maps a bundle's artifact progress to DownloadStatusAction.update kwargs."""
    # .raw: _DynamicEnum equals its int but does not hash like it
    statuses = {getattr(p.status, 'raw', p.status) for p in progresses}
    progress = sum(p.progress for p in progresses) / len(progresses)
    ds = custom.ModelManagerSP.DownloadStatus
    if ds.failed in statuses:
      # close.png is authored black and a tint cannot lift it, hence close2
      return {"name": name, "status_text": tr("download failed"), "text_color": rl.RED, "icon": "icons/close2.png"}
    if ds.verifying in statuses:
      return {"name": name, "downloading": True, "progress": progress, "status_text": tr("verifying")}
    if ds.downloading in statuses:
      return {"name": name, "downloading": True, "progress": progress}
    if statuses <= {ds.downloaded, ds.cached}:
      return {"name": name, "text_color": ON_COLOR, "icon": "icons/checkmark.png"}
    # circled_slash is authored grey; tinting it again only darkens it
    return {"name": name, "text_color": rl.GRAY, "icon": "icons/circled_slash.png", "icon_color": rl.WHITE}
  def _on_model_selected(self, result):
    if result != DialogResult.CONFIRM:
      self.model_dialog = None
      return
    selected_ref = self.model_dialog.selection_ref
    self.model_dialog = None
    if selected_ref == "Default":
-      if self._selection_source in ACTIVE_BUNDLE_KEYS:
+      ui_state.params.remove("ModelManager_ActiveBundle")
-        ui_state.params.remove(ACTIVE_BUNDLE_KEYS[self._selection_source])
+      self._show_reset_params_dialog()
-      return
+    elif selected_bundle := next((bundle for bundle in self.model_manager.availableBundles if bundle.ref == selected_ref), None):
-    if selected_bundle := self._resolve_selected_bundle(selected_ref):
+      ui_state.params.put("ModelManager_DownloadIndex", selected_bundle.index)
-      ui_state.params.put("ModelManager_DownloadRef", selected_bundle.ref)
+      if self.model_manager.activeBundle and selected_bundle.generation != self.model_manager.activeBundle.generation:
-
+        self._show_reset_params_dialog()
-  def _resolve_selected_bundle(self, ref):
+    self.model_dialog = None
    source_bundles = {source: bundles_for_source(source) for source in ("qcom", "chestnut")}
    resolved = resolve_bundle_by_ref(ref, source_bundles)
    return resolved[0] if resolved else None
  @staticmethod
  def _bundle_to_node(bundle):
    return TreeNode(bundle.ref, {'display_name': bundle.displayName, 'short_name': bundle.internalName})
-  def _get_folders(self, favorites, bundles):
+  def _get_folders(self, favorites):
    bundles = self.model_manager.availableBundles
    folders = {}
    for bundle in bundles:
      folders.setdefault(next((ov_ride.value for ov_ride in bundle.overrides if ov_ride.key == "folder"), ""), []).append(bundle)
-    folders_list = []
+    folders_list = [TreeFolder("", [TreeNode("Default", {'display_name': f"{DEFAULT_MODEL} (Default)", 'short_name': "Default"})])]
    for folder, folder_bundles in sorted(folders.items(), key=lambda x: max((bundle.index for bundle in x[1]), default=-1), reverse=True):
      folder_bundles.sort(key=lambda bundle: bundle.index, reverse=True)
      name = folder + (f" - (Updated: {m.group(1)})" if folder_bundles and (m := re.search(r'\(([^)]*)\)[^(]*$', folder_bundles[0].displayName)) else "")
      folders_list.append(TreeFolder(name, [self._bundle_to_node(bundle) for bundle in folder_bundles]))
    if favorites and (fav_bundles := [bundle for bundle in bundles if bundle.ref in favorites]):
-      folders_list.insert(0, TreeFolder("Favorites", [self._bundle_to_node(bundle) for bundle in fav_bundles]))
+      folders_list.insert(1, TreeFolder("Favorites", [self._bundle_to_node(bundle) for bundle in fav_bundles]))
    return folders_list
-  def _open_source_dialog(self, source):
+  def _handle_current_model_clicked(self):
    self._selection_source = source
    favs = ui_state.params.get("ModelManager_Favs")
    favorites = set(favs.split(';')) if favs else set()
-    folders_list = self._source_folders(favorites, source)
+    folders_list = self._get_folders(favorites)
-    if not folders_list:
+
-      gui_app.push_widget(alert_dialog(tr("No models are available for this hardware yet. Connect to the internet and refresh the model list.")))
+    active_ref = self.model_manager.activeBundle.ref if self.model_manager.activeBundle else "Default"
-      return
+    self.model_dialog = TreeOptionDialog(tr("Select a Model"), folders_list, active_ref, "ModelManager_Favs",
-    self.model_dialog = TreeOptionDialog(tr("Select a Model"), folders_list, self._slot_active_ref(source), "ModelManager_Favs",
+                                         get_folders_fn=self._get_folders, on_exit=self._on_model_selected)
                                         get_folders_fn=lambda favs: self._source_folders(favs, source), on_exit=self._on_model_selected)
    gui_app.push_widget(self.model_dialog)
  def _source_folders(self, favorites, source):
    bundles = bundles_for_source(source)
    if not bundles:
      return []
    folders_list = [TreeFolder("", [TreeNode("Default", {'display_name': default_model_name(source)})])]
    folders_list.extend(self._get_folders(favorites, bundles))
    return folders_list
  @staticmethod
  def _slot_active_ref(source: str) -> str:
    bundle = get_selected_bundle(ui_state.params, source)
    return bundle.ref if bundle else "Default"
  def _update_state(self):
    advanced_controls: bool = ui_state.params.get_bool("ShowAdvancedControls")
    turn_desire: bool = ui_state.params.get_bool("LaneTurnDesire")
    live_delay: bool = ui_state.params.get_bool("LagdToggle")
-    camera_offset: bool = ui_state.active_bundle is not None
+    camera_offset: bool = ui_state.params.get("ModelManager_ActiveBundle") is not None
    self.lane_turn_desire_toggle.action_item.set_state(turn_desire)
    self.lane_turn_value_control.set_visible(turn_desire and advanced_controls)
@@ -327,27 +251,18 @@ class ModelsLayout(Widget):
    self._update_lagd_description(live_delay)
    self.model_manager = ui_state.sm["modelManagerSP"]
    self._handle_bundle_download_progress()
    active_name = self.model_manager.activeBundle.internalName if self.model_manager and self.model_manager.activeBundle.ref else f"{DEFAULT_MODEL} (Default)"
    self.current_model_item.action_item.set_value(active_name)
-    carry_source, _, carry_display = carrying_model()
+    if not ui_state.is_offroad():
-    for item, item_source in ((self.small_model_item, "qcom"), (self.big_model_item, "chestnut")):
+      self.current_model_item.action_item.set_enabled(False)
-      bundle = get_selected_bundle(ui_state.params, item_source)
+      self.current_model_item.set_description(tr("Only available when vehicle is off, or always offroad mode is on"))
-      name = bundle.displayName if bundle else default_model_name(item_source)
+    else:
-      color = ON_COLOR if (item_source == carry_source and name == carry_display) else style.ITEM_TEXT_VALUE_COLOR
+      self.current_model_item.action_item.set_enabled(True)
-      item.action_item.set_value(name, color)
+      self.current_model_item.set_description("")
    note = self._status_note()
    if note != self._last_note:
      self._last_note = note
      self._set_item_note(self.download_item, note)
    offroad = ui_state.is_offroad()
    self.small_model_item.action_item.set_enabled(offroad)
    self.big_model_item.action_item.set_enabled(offroad)
    self.small_model_item.set_description("" if offroad else tr("Only available when vehicle is off, or always offroad mode is on"))
  def _render(self, rect):
    self._scroller.render(rect)
  def show_event(self):
    self._scroller.show_event()
    self._last_note = None  # re-expand the failover note every time the page opens
@@ -8,6 +8,7 @@ import datetime
 import os
 import platform
 import requests
 import shutil
 import threading
 from pathlib import Path
 from time import monotonic
@@ -74,12 +75,22 @@ class OSMLayout(Widget):
  def _update_map_size(self):
    threading.Thread(target=self.calculate_size, daemon=True).start()
-  def _on_confirm_delete_maps(self):
+  def _do_delete_maps(self):
-    ui_state.params.put_bool("Mapd_ClearCache", True)
+    if MAP_PATH.exists():
      shutil.rmtree(MAP_PATH)
    for param in ("OsmDownloadedDate", "OsmLocal", "OsmLocationName", "OsmLocationTitle", "OsmStateName", "OsmStateTitle"):
      ui_state.params.remove(param)
    self._delete_maps_btn.action_item.set_enabled(True)
    self._delete_maps_btn.action_item.set_text(tr("DELETE"))
    self._update_map_size()
  def _on_confirm_delete_maps(self):
    self._delete_maps_btn.action_item.set_enabled(False)
    self._delete_maps_btn.action_item.set_text("DELETING...")
    threading.Thread(target=self._do_delete_maps).start()
  def _delete_maps(self):
    self._show_confirm(tr("This will delete ALL downloaded maps\n\nAre you sure you want to delete all maps?"),
                       tr("Yes, delete all maps"), self._on_confirm_delete_maps)
@@ -4,14 +4,11 @@ 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
 import time
 from dataclasses import dataclass
-from openpilot.selfdrive.ui.ui_state import ui_state, ChestnutState
+from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.sunnypilot.sunnylink.api import UNREGISTERED_SUNNYLINK_DONGLE_ID
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.lib.multilang import tr_noop
@@ -21,9 +18,6 @@ METRIC_MARGIN = 30
 METRIC_START_Y = 300
 HOME_BTN = rl.Rectangle(60, 860, 180, 180)
 CHESTNUT_ICON_WIDTH = 180
 CHESTNUT_ICON_HEIGHT = 133
 # Color scheme
 class Colors:
@@ -59,9 +53,6 @@ class MetricData:
 class SidebarSP:
  def __init__(self):
    self._sunnylink_status = MetricData(tr_noop("SUNNYLINK"), tr_noop("OFFLINE"), Colors.WARNING)
    self._chestnut_green_img = gui_app.texture("icons_mici/chestnut_green.png", CHESTNUT_ICON_WIDTH, CHESTNUT_ICON_HEIGHT)
    self._chestnut_default_img = gui_app.texture("icons_mici/chestnut.png", CHESTNUT_ICON_WIDTH, CHESTNUT_ICON_HEIGHT)
    self._chestnut_orange_img = gui_app.texture("icons_mici/chestnut_orange.png", CHESTNUT_ICON_WIDTH, CHESTNUT_ICON_HEIGHT)
  def _update_sunnylink_status(self):
    if not ui_state.params.get_bool("SunnylinkEnabled"):
@@ -87,24 +78,6 @@ class SidebarSP:
    self._sunnylink_status.update(tr_noop("SUNNYLINK"), status, color)
  def _get_home_icon(self, default_img: rl.Texture) -> tuple[rl.Texture, rl.Vector2, float]:
    default_pos = rl.Vector2(HOME_BTN.x, HOME_BTN.y)
    state = ui_state.chestnut_state
    if state == ChestnutState.DISCONNECTED:
      return default_img, default_pos, 1.0
    if state == ChestnutState.LOADING:
      icon = self._chestnut_default_img
      opacity = 0.35 + 0.65 * (0.5 - 0.5 * math.cos(rl.get_time() * 6.0))
    elif state in (ChestnutState.UNCOMPILED, ChestnutState.FAILED):
      icon, opacity = self._chestnut_orange_img, 1.0
    else:
      icon, opacity = self._chestnut_green_img, 1.0
    x = HOME_BTN.x + (HOME_BTN.width - icon.width) / 2
    y = HOME_BTN.y + (HOME_BTN.height - icon.height) / 2
    return icon, rl.Vector2(x, y), opacity
  def _draw_metrics_w_sunnylink(self, rect: rl.Rectangle, _temp, _panda, _connect):
    metrics = [_temp, _panda, _connect, self._sunnylink_status]
    start_y = int(rect.y) + METRIC_START_Y
@@ -4,14 +4,8 @@ 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.selfdrive.ui.mici.layouts.home import MiciHomeLayout
 from openpilot.selfdrive.ui.ui_state import ui_state, ChestnutState
 from openpilot.system.ui.lib.application import FontWeight
 from openpilot.system.ui.widgets.icon_widget import IconWidget
 from openpilot.system.ui.widgets.label import UnifiedLabel
@@ -19,16 +13,3 @@ class MiciHomeLayoutSP(MiciHomeLayout):
  def __init__(self):
    super().__init__()
    self._openpilot_label = UnifiedLabel("sunnypilot", font_size=88, font_weight=FontWeight.AUDIOWIDE, max_width=480, wrap_text=False)
    self._chestnut_loading_icon = IconWidget("icons_mici/chestnut.png", (68, 40))
    self._chestnut_loading_icon.set_visible(False)
    failed_idx = self._status_bar_layout.widgets.index(self._chestnut_failed_icon)
    self._status_bar_layout.widgets.insert(failed_idx + 1, self._chestnut_loading_icon)
  def _set_chestnut_visibility(self):
    # stock has no loading tier: it shows green from the moment a big model is available. keep the
    # pulse so the status bar and the onroad HUD agree on what loading looks like.
    loading = ui_state.chestnut_state == ChestnutState.LOADING
    self._chestnut_loading_icon._opacity = 0.35 + 0.65 * (0.5 - 0.5 * math.cos(rl.get_time() * 6.0))
    self._chestnut_loading_icon.set_visible(loading)
    self._chestnut_icon.set_visible(not loading and ui_state.chestnut_state in (ChestnutState.READY, ChestnutState.ACTIVE))
    self._chestnut_failed_icon.set_visible(ui_state.chestnut_state in (ChestnutState.UNCOMPILED, ChestnutState.FAILED))
@@ -7,37 +7,16 @@ See the LICENSE.md file in the root directory for more details.
 import pyray as rl
 from openpilot.cereal import custom
-from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog
+from openpilot.sunnypilot.models.default_model import DEFAULT_MODEL
 from openpilot.sunnypilot.models.helpers import ACTIVE_BUNDLE_KEYS, get_selected_bundle
 from openpilot.selfdrive.ui.mici.widgets.button import BigButton
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.models import ModelsLayout
 from openpilot.selfdrive.ui.ui_state import ui_state, device
 from openpilot.selfdrive.ui.sunnypilot.model_info import (active_source, big_model_state, bundles_for_source, carrying_model,
                                                           default_model_name, model_info, queued_name)
 from openpilot.system.ui.lib.application import FontWeight, gui_app
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.label import UnifiedLabel
 from openpilot.system.ui.widgets.scroller import NavScroller
 def _model_info() -> tuple[str, str, str]:
  """(active model, info header, info text) for the panel. Runner-matched: the
  active line names what actually drives, and a notable big-model state takes
  the info pair."""
  source, active_name, other_name = model_info()
  state = big_model_state()
  _, _, carry_display = carrying_model()
  if carry_display is None:
    big = get_selected_bundle(ui_state.params, "chestnut")
    carry_display = big.displayName if big else default_model_name("chestnut")
  active_text = (carry_display or active_name).lower()
  if state == 'failed':
    return active_text, tr("big model"), tr("unavailable")
  if state == 'loading':
    return active_text, tr("big model"), tr("getting ready")
  header = tr("small model") if source == "chestnut" else tr("big model")
  return active_text, header, other_name.lower()
 class CurrentModelInfo(Widget):
  def __init__(self):
    super().__init__()
@@ -47,12 +26,12 @@ class CurrentModelInfo(Widget):
    header_color = rl.Color(255, 255, 255, int(255 * 0.9))
    subheader_color = rl.Color(255, 255, 255, int(255 * 0.9 * 0.65))
    max_width = int(self._rect.width - 20)
    active_text, info_header, info_text = _model_info()
    self.current_model_header = UnifiedLabel(tr("active model"), 48, max_width=max_width, text_color=header_color, font_weight=FontWeight.DISPLAY)
-    self.current_model_text = UnifiedLabel(active_text, 32, max_width=max_width, text_color=subheader_color, font_weight=FontWeight.ROMAN, scroll=True)
+    default_text = f"{DEFAULT_MODEL} (Default)".lower()
    self.current_model_text = UnifiedLabel(default_text, 32, max_width=max_width, text_color=subheader_color, font_weight=FontWeight.ROMAN, scroll=True)
-    self.info_header = UnifiedLabel(info_header, 48, max_width=max_width, text_color=header_color, font_weight=FontWeight.DISPLAY)
+    self.info_header = UnifiedLabel("cache size", 48, max_width=max_width, text_color=header_color, font_weight=FontWeight.DISPLAY)
-    self.info_text = UnifiedLabel(info_text, 32, max_width=max_width, text_color=subheader_color, font_weight=FontWeight.ROMAN, scroll=True)
+    self.info_text = UnifiedLabel("0 mb", 32, max_width=max_width, text_color=subheader_color, font_weight=FontWeight.ROMAN)
  def _render(self, _):
    self.current_model_header.set_position(self._rect.x + 20, self._rect.y - 10)
@@ -76,13 +55,12 @@ class ModelsLayoutMici(NavScroller):
    self._download_progress = "."
    self._download_frame = 0
    self._was_downloading = False
    self._selection_source: str | None = None
    self.select_model_btn = BigButton(tr("select model"))
    self.select_model_btn.set_click_callback(self._show_folders)
    self.cancel_download_btn = BigButton(tr("cancel download"))
-    self.cancel_download_btn.set_click_callback(lambda: ui_state.params.remove("ModelManager_DownloadRef"))
+    self.cancel_download_btn.set_click_callback(lambda: ui_state.params.remove("ModelManager_DownloadIndex"))
    self.main_items = [self.current_model_info, self.select_model_btn, self.cancel_download_btn]
    self._scroller.add_widgets(self.main_items)
@@ -91,7 +69,8 @@ class ModelsLayoutMici(NavScroller):
  def model_manager(self):
    return ui_state.sm["modelManagerSP"]
-  def _get_grouped_bundles(self, bundles, favorites = None):
+  def _get_grouped_bundles(self, favorites = None):
    bundles = self.model_manager.availableBundles
    folders = {}
    for bundle in bundles:
      folder = next((override.value for override in bundle.overrides if override.key == "folder"), "")
@@ -111,70 +90,47 @@ class ModelsLayoutMici(NavScroller):
  def _show_folders(self):
    self.focused_widget = self.select_model_btn
    hardware_btns = []
    active = active_source()
    for source, label in (("qcom", tr("small models")), ("chestnut", tr("big models"))):
      bundle = get_selected_bundle(ui_state.params, source)
      value = (bundle.internalName if bundle else default_model_name(source)).lower()
      if source == active:
        value += f" ({tr('active')})"
      btn = BigButton(label.lower(), value=value)
      btn.set_click_callback(lambda s=source: self._select_hardware(s))
      hardware_btns.append(btn)
    self._push_selection_view(hardware_btns)
  def _select_hardware(self, source):
    self._selection_source = source
    favs = ui_state.params.get("ModelManager_Favs")
    favorites = set(favs.split(';')) if favs else set()
-    bundles = bundles_for_source(source)
+    folders = self._get_grouped_bundles(favorites)
    if not bundles:
      gui_app.push_widget(BigDialog(title=tr("No models available"),
                                    description=tr("No models are available for this hardware yet. Connect to the internet and refresh the model list.")))
      return
    folders = self._get_grouped_bundles(bundles, favorites)
    folder_buttons = []
-    default_btn = BigButton(default_model_name(source).lower())
+    default_btn = BigButton(f"{DEFAULT_MODEL} (Default)".lower())
-    default_btn.set_click_callback(lambda s=source: self._select_default(s))
+    default_btn.set_click_callback(self._select_default)
    folder_buttons.append(default_btn)
    for folder in sorted(folders.keys(), key=lambda f: max((bundle.index for bundle in folders[f]), default=-1), reverse=True):
-      btn = BigButton(folder.lower())
+      if folder.lower() in ["release models", "master models", "favorites"]:
-      btn.set_click_callback(lambda f=folder: self._select_folder(f))
+        btn = BigButton(folder.lower())
-      if folder.lower() == "favorites":
+        btn.set_click_callback(lambda f=folder: self._select_folder(f))
-        folder_buttons.insert(0, btn)
+        if folder.lower() == "favorites":
-      else:
+          folder_buttons.insert(0, btn)
-        folder_buttons.append(btn)
+        else:
          folder_buttons.append(btn)
    self._push_selection_view(folder_buttons)
  def _pop_to_main(self):
    gui_app.pop_widgets_to(self)
    self._scroller.scroll_panel.set_offset(0.0)
  def _select_model(self, bundle):
-    ui_state.params.put("ModelManager_DownloadRef", bundle.ref)
+    ui_state.params.put("ModelManager_DownloadIndex", bundle.index)
    self._pop_to_main()
-  def _select_default(self, source):
+  def _select_default(self):
-    ui_state.params.remove(ACTIVE_BUNDLE_KEYS[source])
+    ui_state.params.remove("ModelManager_ActiveBundle")
    self._pop_to_main()
  def _select_folder(self, folder_name):
    source = self._selection_source
    if source is None:  # folders are only reachable after picking a hardware
      return
    favs = ui_state.params.get("ModelManager_Favs")
    favorites = set(favs.split(';')) if favs else set()
-    folders = self._get_grouped_bundles(bundles_for_source(source), favorites)
+    folders = self._get_grouped_bundles(favorites)
    bundles = sorted(folders.get(folder_name, []), key=lambda b: b.index, reverse=True)
    btns = []
    for bundle in bundles:
-      btn = BigButton(bundle.displayName.lower())
+      txt = bundle.displayName.lower()
      btn = BigButton(txt)
      btn.set_click_callback(lambda b=bundle: self._select_model(b))
      btns.append(btn)
    self._push_selection_view(btns)
@@ -206,10 +162,10 @@ class ModelsLayoutMici(NavScroller):
    self._was_downloading = is_downloading
    self.current_model_info.current_model_header.set_text(tr("active model"))
-    active_text, info_header, info_text = _model_info()
+    model_text = manager.activeBundle.displayName.lower() if manager.activeBundle.ref else f"{DEFAULT_MODEL} (Default)".lower()
-    self.current_model_info.current_model_text.set_text(active_text)
+    self.current_model_info.current_model_text.set_text(model_text)
-    self.current_model_info.info_header.set_text(info_header)
+    self.current_model_info.info_header.set_text(tr("cache size"))
-    self.current_model_info.info_text.set_text(info_text)
+    self.current_model_info.info_text.set_text(f"{ModelsLayout.calculate_cache_size():.2f} MB")
    if manager.selectedBundle and manager.selectedBundle.status == custom.ModelManagerSP.DownloadStatus.failed:
      self.current_model_info.info_header.set_text(tr("error") + self._download_progress)
@@ -220,29 +176,19 @@ class ModelsLayoutMici(NavScroller):
      device.set_override_interactive_timeout(5)
      progress = 0.0
      count = 0
      verifying = False
      for model in manager.selectedBundle.models:
        count += 1
        p = model.artifact.downloadProgress
-        if p.status in (custom.ModelManagerSP.DownloadStatus.downloading,
+        if p.status == custom.ModelManagerSP.DownloadStatus.downloading:
                        custom.ModelManagerSP.DownloadStatus.verifying):
          progress += p.progress
          verifying = verifying or p.status == custom.ModelManagerSP.DownloadStatus.verifying
        elif p.status in (custom.ModelManagerSP.DownloadStatus.downloaded,
                          custom.ModelManagerSP.DownloadStatus.cached):
          progress += 100.0
-      self.current_model_info.current_model_header.set_text(tr("verifying") if verifying else tr("downloading"))
+      self.current_model_info.current_model_header.set_text(tr("downloading"))
      self.cancel_download_btn.set_text(tr("cancel verification") if verifying else tr("cancel download"))
      self.current_model_info.current_model_header._shimmer = True
-      name_text = manager.selectedBundle.internalName.lower()
+      self.current_model_info.current_model_text.set_text(f"{manager.selectedBundle.internalName.lower()}")
      if queued := queued_name(manager.selectedBundle.ref):
        name_text += f"  |  {queued.lower()} {tr('queued')}"
      self.current_model_info.current_model_text.set_text(name_text)
      self.current_model_info.info_header.set_text(tr("progress") + self._download_progress)
      self.current_model_info.info_header._shimmer = True
      self.current_model_info.info_text.set_text(f"{progress/count:.2f}%")
    elif manager.selectedBundle and manager.selectedBundle.status == custom.ModelManagerSP.DownloadStatus.downloaded:
      self.current_model_info.info_header.set_text(tr("downloaded"))
      self.current_model_info.info_text.set_text(tr("downloaded"))
@@ -12,23 +12,13 @@ from openpilot.selfdrive.ui.mici.widgets.dialog import BigConfirmationDialog, Bi
 from openpilot.selfdrive.ui.sunnypilot.mici.layouts.sunnylink import SunnylinkLayoutMici
 from openpilot.selfdrive.ui.sunnypilot.mici.layouts.models import ModelsLayoutMici
 from openpilot.selfdrive.ui.ui_state import ui_state
-from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.lib.multilang import tr
 ICON_SIZE = 70
 BIG_ICON_SIZE = 110
 class SunnylinkBigButton(SettingsBigButton):
  def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self._label.set_font_weight(FontWeight.AUDIOWIDE)
  def _get_label_font_size(self):
    # Audiowide runs wider than Inter: "sunnylink" wraps to two lines at 64
    return 56
 class SettingsLayoutSP(OP.SettingsLayout):
  def __init__(self):
    OP.SettingsLayout.__init__(self)
@@ -43,7 +33,7 @@ class SettingsLayoutSP(OP.SettingsLayout):
    self.icon_offroad_slider = gui_app.texture("icons_mici/settings/device/lkas.png", BIG_ICON_SIZE, BIG_ICON_SIZE)
    sunnylink_panel = SunnylinkLayoutMici()
-    sunnylink_btn = SunnylinkBigButton(tr("sunnylink"), "", gui_app.texture("../../sunnypilot/selfdrive/assets/icons_mici/sunnylink.png", 76, 44))
+    sunnylink_btn = SettingsBigButton(tr("sunnylink"), "", gui_app.texture("icons_mici/settings/developer/ssh.png", 55, 55))
    sunnylink_btn.set_click_callback(lambda: gui_app.push_widget(sunnylink_panel))
    models_panel = ModelsLayoutMici()
@@ -66,8 +56,8 @@ class SettingsLayoutSP(OP.SettingsLayout):
    items = self._scroller._items.copy()
-    items.insert(1, models_btn)
+    items.insert(1, sunnylink_btn)
-    items.insert(5, sunnylink_btn)
+    items.insert(2, models_btn)
    # front slots (only one ever visible at a time): exit-always-offroad, then enable-onroad
    items.insert(0, self._enable_offroad_btn_onroad)
@@ -1,85 +0,0 @@
 """
 Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 from openpilot.selfdrive.ui.ui_state import ui_state, ChestnutState
 from openpilot.sunnypilot.models.fetcher import get_cached_bundles
 from openpilot.sunnypilot.models.helpers import get_active_source, get_selected_bundle, resolve_bundle_by_ref
 from openpilot.sunnypilot.models.model_name import DEFAULT_BIG_MODEL, DEFAULT_MODEL
 def active_source() -> str:
  return get_active_source(chestnut=ui_state.chestnut_present,
                           chestnut_active=ui_state.chestnut_active, chestnut_loading=ui_state.chestnut_loading,
                           offroad=ui_state.is_offroad())
 def bundles_for_source(source: str):
  if source == active_source():
    return ui_state.sm["modelManagerSP"].availableBundles
  return get_cached_bundles(ui_state.params, source)
 def default_model(source: str) -> str:
  return DEFAULT_BIG_MODEL if source == 'chestnut' else DEFAULT_MODEL
 def default_model_name(source: str) -> str:
  return f"{default_model(source)} (Default)"
 def big_model_state() -> str | None:
  """'failed' | 'loading' | None, from the same state the icons render."""
  return {ChestnutState.UNCOMPILED: 'failed',
          ChestnutState.FAILED: 'failed',
          ChestnutState.LOADING: 'loading'}.get(ui_state.chestnut_state)
 def carrying_model() -> tuple[str | None, str | None, str | None]:
  """(source, internal name, display name) of what actually drives. Runner-matched:
  when a Default big cannot carry, stock modeld runs the Default small, never the
  small slot's pick; a custom big has no automatic fallback yet -> (None, None, None)."""
  source = active_source()
  if source == "chestnut":
    bundle = get_selected_bundle(ui_state.params, "chestnut")
    if bundle:
      return "chestnut", bundle.internalName, bundle.displayName
    name = default_model_name("chestnut")
    return "chestnut", name, name
  if ui_state.chestnut_present:
    if get_selected_bundle(ui_state.params, "chestnut") is None:
      name = default_model_name("qcom")
      return "qcom", name, name
    return None, None, None
  bundle = get_selected_bundle(ui_state.params, "qcom")
  if bundle:
    return "qcom", bundle.internalName, bundle.displayName
  name = default_model_name("qcom")
  return "qcom", name, name
 def queued_name(current_ref) -> str | None:
  ref = ui_state.params.get("ModelManager_DownloadRef")
  if ref and ref != current_ref:
    source_bundles = {source: bundles_for_source(source) for source in ("qcom", "chestnut")}
    if resolved := resolve_bundle_by_ref(ref, source_bundles):
      return resolved[0].internalName
  return None
 def model_info() -> tuple[str, str, str]:
  """returns (active source, active model name, other model name)
  Names come from the params slots, never modelManagerSP.activeBundle — the
  manager republishes a tick after a chestnut change, so the stale bundle
  would flash the wrong model."""
  source = active_source()
  other = "qcom" if source == "chestnut" else "chestnut"
  active_bundle = get_selected_bundle(ui_state.params, source)
  other_bundle = get_selected_bundle(ui_state.params, other)
  active_name = active_bundle.displayName if active_bundle else default_model_name(source)
  other_name = other_bundle.displayName if other_bundle else default_model_name(other)
  return source, active_name, other_name
@@ -4,29 +4,11 @@ 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.common.filter_simple import FirstOrderFilter
 from openpilot.selfdrive.ui.ui_state import ui_state, UIStatus
 from openpilot.selfdrive.ui.sunnypilot.onroad.chevron_metrics import ChevronMetrics
 from openpilot.selfdrive.ui.sunnypilot.onroad.rainbow_path import RainbowPath
 from openpilot.selfdrive.ui.sunnypilot.ui_state import MADSState
 from openpilot.system.ui.lib.application import gui_app
 class ModelRendererSP:
  def __init__(self):
    self.rainbow_path = RainbowPath()
    self.chevron_metrics = ChevronMetrics()
    self._width_filter = FirstOrderFilter(0.9, 0.1, 1 / gui_app.target_fps)
  @property
  def _lateral_active(self) -> bool:
    sm = ui_state.sm
    if sm.valid["selfdriveStateSP"]:
      mads = sm["selfdriveStateSP"].mads
      if mads.available:
        return mads.enabled and mads.state != MADSState.paused
    return ui_state.status in (UIStatus.ENGAGED, UIStatus.LAT_ONLY)
  def _get_path_half_width(self) -> float:
    target = 0.9 if self._lateral_active else 0.40
    return self._width_filter.update(target)
@@ -10,7 +10,6 @@ from openpilot.cereal import messaging, log, custom
 from opendbc.car.structs import car
 from openpilot.common.params import Params
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.display import OnroadBrightness
 from openpilot.sunnypilot.models.helpers import ACTIVE_BUNDLE_KEYS, get_active_source
 from openpilot.sunnypilot.sunnylink.sunnylink_state import SunnylinkState
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.sunnypilot.widgets.screen_saver import ScreenSaverSP
@@ -44,7 +43,6 @@ class UIStateSP:
    self.screensaver_enabled: bool = False
    self.active_bundle = None
    self.model_runner_tinygrad: bool = False
    self.blindspot: bool = False
    self.chevron_metrics = None
    self.custom_interactive_timeout: int = 0
@@ -152,13 +150,7 @@ class UIStateSP:
      self.has_icbm = self.CP_SP.intelligentCruiseButtonManagementAvailable and self.params.get_bool("IntelligentCruiseButtonManagement")
    self._enforce_constraints()
-    source = get_active_source(chestnut=self.chestnut_present, chestnut_active=self.chestnut_active,
+    self.active_bundle = self.params.get("ModelManager_ActiveBundle")
                               chestnut_loading=self.chestnut_loading, offroad=self.is_offroad())
    self.active_bundle = self.params.get(ACTIVE_BUNDLE_KEYS[source])
    self.model_runner_tinygrad = self.active_bundle is not None and self.active_bundle.get("runner") == "tinygrad"
    # 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.blindspot = self.params.get_bool("BlindSpot")
    self.chevron_metrics = self.params.get("ChevronInfo")
    self.custom_interactive_timeout = self.params.get("InteractivityTimeout", return_default=True)
@@ -12,7 +12,7 @@ from openpilot.common.swaglog import cloudlog
 from openpilot.selfdrive.ui.lib.prime_state import PrimeState
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.common.hardware import HARDWARE, PC
-from openpilot.selfdrive.modeld.helpers import chestnut_compiled
+from openpilot.selfdrive.modeld.helpers import usbgpu_compiled
 from openpilot.selfdrive.ui.sunnypilot.ui_state import UIStateSP, DeviceSP
@@ -28,15 +28,6 @@ class UIStatus(Enum):
  LONG_ONLY = "long_only"
 class ChestnutState(Enum):
  DISCONNECTED = "disconnected"
  UNCOMPILED = "uncompiled"
  READY = "ready"
  LOADING = "loading"
  ACTIVE = "active"
  FAILED = "failed"
 class UIState(UIStateSP):
  _instance: 'UIState | None' = None
@@ -91,11 +82,10 @@ class UIState(UIStateSP):
    self.always_on_dm: bool = self.params.get_bool("AlwaysOnDM")
    self.experimental_mode: bool = self.params.get_bool("ExperimentalMode")
    self.experimental_mode_confirmed: bool = self.params.get_bool("ExperimentalModeConfirmed")
-    self.chestnut_present: bool = False
+    self.usbgpu: bool = False
-    self.chestnut_compiled: bool = chestnut_compiled()
+    self.usbgpu_compiled: bool = usbgpu_compiled()
-    self.chestnut_active: bool | None = None
+    self.usbgpu_active: bool | None = self.params.get("UsbGpuActive")
-    self.chestnut_loading: bool = False
+    self.usbgpu_loading: bool = self.params.get_bool("UsbGpuLoading")
    self.chestnut_state = ChestnutState.DISCONNECTED
    self.started: bool = False
    self.ignition: bool = False
    self.recording_audio: bool = False
@@ -141,7 +131,6 @@ class UIState(UIStateSP):
    self.sm.update(0)
    self._update_state()
    self._update_status()
    self._update_chestnut_state()
    device.update()
    UIStateSP.update(self)
@@ -205,35 +194,12 @@ class UIState(UIStateSP):
        self.status = UIStatus.DISENGAGED
        self.started_frame = self.sm.frame
        self.started_time = time.monotonic()
        self.chestnut_present = self.sm["deviceState"].chestnutPresent
      for callback in self._offroad_transition_callbacks:
        callback()
      self._started_prev = self.started
  def _update_chestnut_state(self) -> None:
    detected = self.sm["deviceState"].chestnutPresent
    if not self.started:
      self.chestnut_present = detected
      self.chestnut_state = (ChestnutState.READY if detected and self.chestnut_compiled else
                             ChestnutState.UNCOMPILED if detected else ChestnutState.DISCONNECTED)
      return
    model_seen = self.sm.recv_frame["modelV2"] > self.started_frame
    if not self.chestnut_present:
      self.chestnut_state = ChestnutState.DISCONNECTED
    elif not self.chestnut_compiled:
      self.chestnut_state = ChestnutState.UNCOMPILED
    elif self.chestnut_state == ChestnutState.FAILED or not detected or (model_seen and (not self.sm.alive["modelV2"] or not self.sm["modelV2"].big)):
      self.chestnut_state = ChestnutState.FAILED
    elif self.chestnut_loading or not model_seen:
      self.chestnut_state = ChestnutState.LOADING
    elif self.chestnut_active is False:
      self.chestnut_state = ChestnutState.FAILED
    else:
      self.chestnut_state = ChestnutState.ACTIVE
  def update_params(self) -> None:
    # For slower operations
    # Update longitudinal control state
@@ -250,10 +216,12 @@ class UIState(UIStateSP):
    self.always_on_dm = self.params.get_bool("AlwaysOnDM")
    self.experimental_mode = self.params.get_bool("ExperimentalMode")
    self.experimental_mode_confirmed = self.params.get_bool("ExperimentalModeConfirmed")
-    if not self.chestnut_compiled:
+    # keep usbgpu UI active until offroad transition when gpu disappears
-      self.chestnut_compiled = chestnut_compiled()
+    self.usbgpu = self.sm["deviceState"].chestnutPresent or (self.usbgpu and self.started)
-    self.chestnut_active = self.params.get("ChestnutActive")
+    if not self.usbgpu_compiled:
-    self.chestnut_loading = self.params.get_bool("ChestnutLoading")
+      self.usbgpu_compiled = usbgpu_compiled()
    self.usbgpu_active = self.params.get("UsbGpuActive")
    self.usbgpu_loading = self.params.get_bool("UsbGpuLoading")
    UIStateSP.update_params(self)
@@ -8,10 +8,7 @@ from openpilot.common.params import Params
 def get_lat_delay(params: Params, stock_lat_delay: float) -> float:
 # live learning on: use what lagd publishes.
 # off: use the fixed steerActuatorDelay + software delay sum that LagdToggle caches.
  if params.get_bool("LagdToggle"):
-    return stock_lat_delay
+    return float(params.get("LagdValueCache", return_default=True))
-  return float(params.get("LagdValueCache", return_default=True))
+  return stock_lat_delay
@@ -55,19 +55,6 @@ def cleanup_old_osm_data(files_to_remove: list[str]) -> None:
      shutil.rmtree(file, ignore_errors=False)
 def clear_downloaded_maps() -> None:
  """Deletes downloaded OSM map data and resets params."""
  path = f"{Paths.mapd_root()}/offline"
  if os.path.exists(path):
    shutil.rmtree(path, ignore_errors=True)
  for param in ("OsmDownloadedDate", "OsmLocal", "OsmLocationName", "OsmLocationTitle",
                "OsmStateName", "OsmStateTitle"):
    params.remove(param)
  cloudlog.info("mapd: downloaded maps cleared")
 def request_refresh_osm_location_data(nations: list[str], states: list[str] | None = None) -> None:
  params.put("OsmDownloadedDate", str(datetime.now().timestamp()), block=True)
  params.put_bool("OsmDbUpdatesCheck", False, block=True)
@@ -144,10 +131,6 @@ def main_thread():
    show_alert = bool(get_files_for_cleanup() and params.get_bool("OsmLocal"))
    set_offroad_alert("Offroad_OSMUpdateRequired", show_alert, "This alert will be cleared when new maps are downloaded.")
    if params.get("Mapd_ClearCache"):
      clear_downloaded_maps()
      params.remove("Mapd_ClearCache")
    update_osm_db()
    live_map_sp.tick()
    rk.keep_time()
@@ -7,7 +7,6 @@ See the LICENSE.md file in the root directory for more details.
 """
 import argparse
 import math
 import os
 import tempfile
 import time
@@ -67,15 +66,14 @@ def get_policy_npy_shapes(input_shapes: dict, is_supercombo: bool = False) -> tu
  if desire_key:
    shapes['desire'] = (input_shapes[desire_key][2],)
  if is_supercombo and 'features_buffer' in input_shapes:
    fb = input_shapes['features_buffer']
    shapes['prev_feat'] = (fb[0], fb[2])
  for key, shape in input_shapes.items():
    if key not in (desire_key, 'features_buffer') and 'img' not in key:
      shapes[key] = tuple(shape)
  if is_supercombo and 'features_buffer' in input_shapes:
    fb = input_shapes['features_buffer']
    feat_dim = math.prod(fb[2:])
    shapes['prev_feat'] = (fb[0], feat_dim)
  sizes = [int(np.prod(size)) for size in shapes.values()]
  return shapes, sizes
@@ -119,9 +117,7 @@ def generate_queues_and_npy(input_shapes: dict, frame_skip: int, device: str = D
  }
  if features_buffer:
-    feat_dim = math.prod(features_buffer[2:])
+    queues['feat_q'] = Tensor(np.zeros((frame_skip * (features_buffer[1] - 1) + 1, features_buffer[0], features_buffer[2]),
    feat_q_len = frame_skip * features_buffer[1] if is_supercombo else frame_skip * (features_buffer[1] - 1) + 1
    queues['feat_q'] = Tensor(np.zeros((feat_q_len, features_buffer[0], feat_dim),
                       dtype=np.float32), device=device).contiguous().realize()
  queues.update({key: Tensor(value, device='NPY').realize() for key, value in npy_arrays.items() if key in ('tfm', 'big_tfm')})
@@ -186,14 +182,14 @@ def make_run_policy(vision_runner, policy_runners: list, features_slice: slice,
    warped_dev = warped.to(Device.DEFAULT)
    Tensor.realize(packed_npy_inputs_dev, warped_dev)
-    img = shift_and_sample(img_q, warped_dev[0:1], sample_skip_fn)
+    img = shift_and_sample(img_q, warped_dev[0:1], sample_skip_fn).realize()
-    big_img = shift_and_sample(big_img_q, warped_dev[1:2], sample_skip_fn)
+    big_img = shift_and_sample(big_img_q, warped_dev[1:2], sample_skip_fn).realize()
    unpacked_tensors = [tensor.reshape(shape) for tensor, shape in zip(packed_npy_inputs_dev.split(npy_sizes), npy_shapes.values(), strict=True)]
    unpacked_dict = dict(zip(npy_shapes.keys(), unpacked_tensors, strict=True))
    desire_dev = unpacked_dict['desire']
-    desire_buf = shift_and_sample(desire_q, desire_dev.reshape(1, 1, -1), sample_desire_fn)
+    desire_buf = shift_and_sample(desire_q, desire_dev.reshape(1, 1, -1), sample_desire_fn).realize()
    inputs = {desire_key: desire_buf}
    for key, tensor_val in unpacked_dict.items():
@@ -202,7 +198,7 @@ def make_run_policy(vision_runner, policy_runners: list, features_slice: slice,
    if 'prev_feat' in unpacked_dict:
      prev_feat_dev = unpacked_dict['prev_feat']
-      inputs['features_buffer'] = shift_and_sample(feat_q, prev_feat_dev.reshape(1, 1, -1), sample_skip_fn).reshape(input_shapes['features_buffer'])
+      inputs['features_buffer'] = shift_and_sample(feat_q, prev_feat_dev.reshape(1, 1, -1), sample_skip_fn).realize()
    if vision_runner:
      vision_out_cast = next(iter(vision_runner({road_key: img, wide_key: big_img}).values())).cast('float32').realize()
@@ -214,7 +210,7 @@ def make_run_policy(vision_runner, policy_runners: list, features_slice: slice,
    inputs.update({road_key: img, wide_key: big_img})
    if 'features_buffer' not in inputs:
-      inputs['features_buffer'] = sample_skip_fn(feat_q).reshape(input_shapes['features_buffer'])
+      inputs['features_buffer'] = sample_skip_fn(feat_q)
    policy_out = next(iter(policy_runners[0](inputs).values())).cast('float32').realize()
    if 'features_buffer' not in inputs and features_slice is not None:
@@ -275,17 +271,18 @@ def _parse_size(size_str: str) -> tuple[int, int]:
  return int(width), int(height)
-def read_file_chunked_to_disk(path):
+def read_file_chunked_to_shm(path):
  if not path:
    return None
  import atexit
  import shutil
  from openpilot.common.file_chunker import open_file_chunked
-  tmp_path = f'{path}.unchunked'
+  from openpilot.common.hardware.hw import Paths
-  with open(tmp_path, 'wb') as f, open_file_chunked(path) as src:
+  shm_path = os.path.join(Paths.shm_path(), os.path.basename(path))
-    shutil.copyfileobj(src, f)
+  atexit.register(lambda: os.path.exists(shm_path) and os.remove(shm_path))
-  atexit.register(lambda: os.path.exists(tmp_path) and os.remove(tmp_path))
+  with open(shm_path, 'wb') as dst, open_file_chunked(path) as src:
-  return tmp_path
+    shutil.copyfileobj(src, dst)
  return shm_path
 def _load_policy_runners(args: argparse.Namespace) -> tuple[list, list]:
@@ -298,7 +295,7 @@ def _load_policy_runners(args: argparse.Namespace) -> tuple[list, list]:
 if __name__ == "__main__":
-  if 'USB' in os.getenv('DEV', '') or os.getenv('CHESTNUT'):
+  if 'USB' in os.getenv('DEV', '') or os.getenv('USBGPU'):
    from openpilot.system.hardware.chestnut.flash import link_up
    for _ in range(10):
      if link_up():
@@ -329,11 +326,11 @@ if __name__ == "__main__":
  model_w, model_h = args.model_size
  output_data = {}
-  args.vision_onnx = read_file_chunked_to_disk(args.vision_onnx)
+  args.vision_onnx = read_file_chunked_to_shm(args.vision_onnx)
-  args.policy_onnx = read_file_chunked_to_disk(args.policy_onnx)
+  args.policy_onnx = read_file_chunked_to_shm(args.policy_onnx)
-  args.off_policy_onnx = read_file_chunked_to_disk(args.off_policy_onnx)
+  args.off_policy_onnx = read_file_chunked_to_shm(args.off_policy_onnx)
-  args.on_policy_onnx = read_file_chunked_to_disk(args.on_policy_onnx)
+  args.on_policy_onnx = read_file_chunked_to_shm(args.on_policy_onnx)
-  args.supercombo_onnx = read_file_chunked_to_disk(args.supercombo_onnx)
+  args.supercombo_onnx = read_file_chunked_to_shm(args.supercombo_onnx)
  vision_runner = OnnxRunner(args.vision_onnx) if args.vision_onnx else None
@@ -9,7 +9,7 @@ See the LICENSE.md file in the root directory for more details.
 import os
 os.environ['GMMU'] = '0'
 from openpilot.common.hardware import COMMA_HARDWARE
-from openpilot.selfdrive.modeld.helpers import chestnut_present, load_oob
+from openpilot.selfdrive.modeld.helpers import usbgpu_present, load_oob
 import time
 import numpy as np
 import openpilot.cereal.messaging as messaging
@@ -84,14 +84,14 @@ class ModelState(ModelStateBase):
  inputs: dict[str, np.ndarray]
  prev_desire: np.ndarray
-  def __init__(self, cam_w: int, cam_h: int, chestnut: bool = False):
+  def __init__(self, cam_w: int, cam_h: int, usbgpu: bool = False):
    ModelStateBase.__init__(self)
    env_pkl = os.environ.get('COMBINED_MODEL_PKL')
    if env_pkl and os.path.exists(env_pkl):
      model_bundle = None
    else:
-      model_bundle = get_active_bundle(chestnut=chestnut)
+      model_bundle = get_active_bundle()
    self.generation = model_bundle.generation if model_bundle is not None else None
    overrides = {override.key: override.value for override in model_bundle.overrides} if model_bundle else {}
@@ -99,7 +99,7 @@ class ModelState(ModelStateBase):
    self.LONG_SMOOTH_SECONDS = float(overrides.get('long', ".0"))
    self.MIN_LAT_CONTROL_SPEED = 0.3
    self.PLANPLUS_CONTROL: float = 1.0
-    self.chestnut = chestnut
+    self.usbgpu = usbgpu
    pkl_path = _find_driving_pkl(model_bundle)
    assert pkl_path is not None, "No driving pkl found — all models must be compiled with compile_modeld.py"
@@ -110,7 +110,7 @@ class ModelState(ModelStateBase):
    jits = load_oob(open_file_chunked(pkl_path))
    self.WARP_DEV = 'QCOM' if COMMA_HARDWARE else 'CPU'
-    self.DEV = 'AMD' if self.chestnut else self.WARP_DEV
+    self.DEV = 'AMD' if self.usbgpu else self.WARP_DEV
    self.QUEUE_DEV = self.DEV
    metadata = jits['metadata']
@@ -185,7 +185,7 @@ class ModelState(ModelStateBase):
    else:
      self.warp(**{k: self.input_queues[k] for k in WARP_INPUTS}, frame=frame_tensor, big_frame=big_frame_tensor)
-    if self.chestnut:
+    if self.usbgpu:
      self.warmup()
  def warmup(self) -> None:
@@ -287,7 +287,7 @@ class ModelState(ModelStateBase):
      buf[0, :-1] = buf[0, 1:]
      buf[0, -1, :] = outputs['desired_curvature'][0, :] if not self.mlsim else 0
-    if self.chestnut and not np.all(np.isfinite(outputs.get('plan', np.array([0.])))):
+    if self.usbgpu and not np.all(np.isfinite(outputs.get('plan', np.array([0.])))):
      cloudlog.error("model output not finite, dropping frame")
      return None
@@ -327,13 +327,13 @@ def main(demo=False):
  setproctitle(PROCESS_NAME)
  config_realtime_process(7, 54)
-  CHESTNUT = chestnut_present()
+  USBGPU = usbgpu_present()
-  if CHESTNUT:
+  if USBGPU:
    os.environ['HCQDEV_WAIT_TIMEOUT_MS'] = '3000'
  params = Params()
-  params.put_bool("ChestnutLoading", CHESTNUT)
+  params.put_bool("UsbGpuLoading", USBGPU)
-  params.remove("ChestnutActive")
+  params.remove("UsbGpuActive")
  # visionipc clients
  while True:
@@ -362,31 +362,31 @@ def main(demo=False):
  st = time.monotonic()
  model = None
-  if CHESTNUT:
+  if USBGPU:
    import threading
    def load():
      nonlocal model
-      model = ModelState(cam_w=vipc_client_main.width, cam_h=vipc_client_main.height, chestnut=True)
+      model = ModelState(cam_w=vipc_client_main.width, cam_h=vipc_client_main.height, usbgpu=True)
    t = threading.Thread(target=load, daemon=True)
    t.start()
    t.join(60)
    if model is None:
-      params.put_bool("ChestnutActive", False)
+      params.put_bool("UsbGpuActive", False)
-      raise RuntimeError("chestnut model load failed or timed out (60s)")
+      raise RuntimeError("eGPU model load failed or timed out (60s)")
-    params.put_bool("ChestnutActive", True)
+    params.put_bool("UsbGpuActive", True)
  else:
-    model = ModelState(cam_w=vipc_client_main.width, cam_h=vipc_client_main.height, chestnut=False)
+    model = ModelState(cam_w=vipc_client_main.width, cam_h=vipc_client_main.height, usbgpu=False)
-  params.put_bool("ChestnutLoading", False)
+  params.put_bool("UsbGpuLoading", False)
  cloudlog.warning(f"models loaded in {time.monotonic() - st:.1f}s, modeld starting")
  # messaging
-  pub_socks = ["modelV2", "drivingModelData", "cameraOdometry", "modelDataV2SP"] + (["chestnutState"] if CHESTNUT else [])
+  pub_socks = ["modelV2", "drivingModelData", "cameraOdometry", "modelDataV2SP"] + (["chestnutState"] if USBGPU else [])
  pm = PubMaster(pub_socks)
  sm = SubMaster(["deviceState", "carState", "narrowRoadCameraState", "extrinsicsCalibration", "driverMonitoringState", "carControl", "lateralDelay"])
  publish_state = PublishState()
-  chestnut_state = ChestnutState(pm, CHESTNUT) if CHESTNUT else None
+  chestnut_state = ChestnutState(pm, USBGPU) if USBGPU else None
  # setup filter to track dropped frames
  frame_dropped_filter = FirstOrderFilter(0., 10., 1. / model.constants.MODEL_FREQ)
@@ -524,7 +524,7 @@ def main(demo=False):
      fill_model_msg(drivingdata_send, modelv2_send, model_output, action,
                     publish_state, meta_main.frame_id, meta_extra.frame_id, frame_id,
                     frame_drop_ratio, meta_main.timestamp_eof, model_execution_time, live_calib_seen, meta_constants)
-      modelv2_send.modelV2.big = model.chestnut
+      modelv2_send.modelV2.big = model.usbgpu
      desire_state = modelv2_send.modelV2.meta.desireState
      l_lane_change_prob = desire_state[log.Desire.laneChangeLeft]
@@ -190,8 +190,8 @@ def tmp_path():
 def patch_modeld(monkeypatch):
  def _patch(bundle):
-    monkeypatch.setattr(helpers, 'get_active_bundle', lambda params=None, *, chestnut=None: bundle)
+    monkeypatch.setattr(helpers, 'get_active_bundle', lambda params=None: bundle)
-    monkeypatch.setattr(modeld_module, 'get_active_bundle', lambda params=None, *, chestnut=None: bundle)
+    monkeypatch.setattr(modeld_module, 'get_active_bundle', lambda params=None: bundle)
  return _patch
@@ -59,8 +59,8 @@ class TestFindDrivingPkl(OpenpilotTestCase):
 class TestModelStateCombinedInit(OpenpilotTestCase):
  def test_asserts_when_no_pkl(self, monkeypatch):
    bundle = DummyBundle(models=[], is_20hz=True)
-    monkeypatch.setattr(helpers, 'get_active_bundle', lambda params=None, *, chestnut=None: bundle)
+    monkeypatch.setattr(helpers, 'get_active_bundle', lambda params=None: bundle)
-    monkeypatch.setattr(modeld_module, 'get_active_bundle', lambda params=None, *, chestnut=None: bundle)
+    monkeypatch.setattr(modeld_module, 'get_active_bundle', lambda params=None: bundle)
    with self.assertRaisesRegex(AssertionError, "No driving pkl found"):
      ModelState(cam_w=CAM_W, cam_h=CAM_H)
@@ -5,15 +5,10 @@ This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 import os
 import tempfile
 from pathlib import Path
 import numpy as np
 from openpilot.common.parameterized import parameterized
-from openpilot.common.file_chunker import chunk_file, get_chunk_targets
+from openpilot.sunnypilot.modeld_v2.compile_modeld import derive_frame_skip, _detect_desire_key
 from openpilot.sunnypilot.modeld_v2.compile_modeld import derive_frame_skip, _detect_desire_key, read_file_chunked_to_disk
 from openpilot.common.test import OpenpilotTestCase
@@ -165,115 +160,3 @@ class TestOutputSlicePreservation(OpenpilotTestCase):
    policy_slices = {'plan': slice(0, 495), 'meta': slice(495, 550)}
    assert set(vision_slices.keys()) & set(policy_slices.keys()) == set(), \
      "vision and policy slices should not overlap in keys"
 class TestReadFileChunkedToDisk(OpenpilotTestCase):
  def test_none_passthrough(self):
    assert read_file_chunked_to_disk(None) is None
  def test_unchunked_source_staged_on_disk(self):
    with tempfile.TemporaryDirectory() as d:
      src = Path(d) / "driving_supercombo.onnx"
      payload = os.urandom(1024)
      src.write_bytes(payload)
      out = Path(read_file_chunked_to_disk(str(src)))
      assert out.parent == Path(d)
      assert out.name == "driving_supercombo.onnx.unchunked"
      assert out.read_bytes() == payload
  def test_chunked_source_reassembled_on_disk(self):
    with tempfile.TemporaryDirectory() as d:
      src = Path(d) / "driving_supercombo.onnx"
      payload = os.urandom(4096)
      src.write_bytes(payload)
      chunk_file(str(src), get_chunk_targets(str(src), len(payload)))
      assert not src.exists()
      out = Path(read_file_chunked_to_disk(str(src)))
      assert out.parent == Path(d)
      assert out.read_bytes() == payload
 class Test4DFeaturesBuffer(OpenpilotTestCase):
  def test_get_policy_npy_shapes_4d(self):
    from openpilot.sunnypilot.modeld_v2.compile_modeld import get_policy_npy_shapes
    input_shapes = {
      'desire_pulse': (1, 25, 8),
      'features_buffer': (1, 24, 32, 512),  # compare 4d to 3d for regression
      'traffic_convention': (1, 2),
      'action_t': (1, 2)
    }
    shapes, sizes = get_policy_npy_shapes(input_shapes, is_supercombo=True)
    assert shapes['prev_feat'] == (1, 16384)
    assert sizes == [8, 2, 2, 16384]
  def test_get_policy_npy_shapes_3d(self):
    from openpilot.sunnypilot.modeld_v2.compile_modeld import get_policy_npy_shapes
    input_shapes = {
      'desire_pulse': (1, 25, 8),
      'features_buffer': (1, 24, 512),
      'traffic_convention': (1, 2),
      'action_t': (1, 2)
    }
    shapes, sizes = get_policy_npy_shapes(input_shapes, is_supercombo=True)
    assert shapes['prev_feat'] == (1, 512)
    assert sizes == [8, 2, 2, 512]
 class TestStockCompileModeldEquivalence(OpenpilotTestCase):
  def test_get_policy_npy_shapes_matches_stock(self):
    from openpilot.selfdrive.modeld.compile_modeld import get_policy_npy_shapes as stock_get_policy_npy_shapes
    from openpilot.sunnypilot.modeld_v2.compile_modeld import get_policy_npy_shapes as sunny_get_policy_npy_shapes
    stock_input_shapes = {
      'desire_pulse': (1, 25, 8),
      'features_buffer': (1, 24, 512), # see below comment
      'traffic_convention': (1, 2),
      'action_t': (1, 2),
    }
    stock_shapes, stock_sizes = stock_get_policy_npy_shapes(stock_input_shapes)
    sunny_shapes, sunny_sizes = sunny_get_policy_npy_shapes(stock_input_shapes, is_supercombo=True)
    assert sunny_shapes == stock_shapes
    assert sunny_sizes == stock_sizes
    assert sunny_shapes['prev_feat'] == (1, 512)
  def test_make_input_queues_full_stock_equivalence(self):
    from openpilot.selfdrive.modeld.compile_modeld import make_input_queues as stock_make_input_queues
    from openpilot.sunnypilot.modeld_v2.compile_modeld import make_supercombo_input_queues as sunny_make_supercombo_input_queues
    input_shapes = {
      'img': (1, 12, 128, 256),
      'desire_pulse': (1, 25, 8),
      'features_buffer': (1, 24, 512),  # when https://github.com/commaai/openpilot/pull/38681 merges, update to 1,24,32,512
      'traffic_convention': (1, 2),
      'action_t': (1, 2),
    }
    frame_skip = 4
    stock_queues, stock_npy = stock_make_input_queues(input_shapes, frame_skip, device='NPY')
    sunny_queues, sunny_npy = sunny_make_supercombo_input_queues(input_shapes, frame_skip, device='NPY')
    assert set(sunny_queues.keys()) == set(stock_queues.keys())
    for key in stock_queues:
      assert sunny_queues[key].shape == stock_queues[key].shape, \
        f"Queue shape mismatch for {key}: sunny {sunny_queues[key].shape} != stock {stock_queues[key].shape}"
    assert set(sunny_npy.keys()) == set(stock_npy.keys())
    for key in stock_npy:
      assert sunny_npy[key].shape == stock_npy[key].shape, \
        f"Numpy array shape mismatch for {key}: sunny {sunny_npy[key].shape} != stock {stock_npy[key].shape}"
  def test_make_warp_queues_stock_equivalence(self):
    from openpilot.selfdrive.modeld.compile_modeld import make_warp_input_queues as stock_make_warp_queues
    from openpilot.sunnypilot.modeld_v2.compile_modeld import make_warp_queues as sunny_make_warp_queues
    stock_vision_shapes = {'img': (1, 12, 128, 256)}  # for now?
    stock_queues, stock_npy = stock_make_warp_queues(stock_vision_shapes, frame_skip=4, device='NPY')
    sunny_queues, sunny_npy = sunny_make_warp_queues(device='NPY')
    assert set(sunny_npy.keys()) == set(stock_npy.keys()) == {'tfm', 'big_tfm'}
    for key in sunny_npy:
      assert sunny_npy[key].shape == stock_npy[key].shape == (3, 3)
@@ -3,17 +3,8 @@ import os
 import hashlib
 from openpilot.common.basedir import BASEDIR
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.sunnypilot import get_file_hash
-from openpilot.sunnypilot.models.model_name import DEFAULT_MODEL, DEFAULT_BIG_MODEL
+from openpilot.sunnypilot.models.model_name import DEFAULT_MODEL
 def get_default_model() -> str:
  show_big_model = (ui_state.chestnut_present
                    and (ui_state.chestnut_active or ui_state.chestnut_loading or ui_state.is_offroad()))
  return DEFAULT_BIG_MODEL if show_big_model else DEFAULT_MODEL
 DEFAULT_MODEL_NAME_PATH = os.path.join(BASEDIR, "openpilot", "sunnypilot", "models", "model_name.py")
 MODEL_HASH_PATH = os.path.join(BASEDIR, "openpilot", "sunnypilot", "models", "tests", "model_hash")
@@ -22,6 +13,7 @@ SUPERCOMBO_ONNX_PATH = os.path.join(BASEDIR, "openpilot", "selfdrive", "modeld",
 def update_model_hash():
  supercombo_hash = get_file_hash(SUPERCOMBO_ONNX_PATH)
  combined_hash = hashlib.sha256(supercombo_hash.encode()).hexdigest()
  with open(MODEL_HASH_PATH, "w") as f:
@@ -30,28 +22,40 @@ def update_model_hash():
  print(f"Generated and updated new combined model hash to {MODEL_HASH_PATH}")
-def update_default_model_names(default_model_name: str, default_big_model_name: str):
+def get_current_default_model_name():
-  print("[CHANGE DEFAULT MODEL NAMES]")
+  print("[GET DEFAULT MODEL NAME]")
-  with open(DEFAULT_MODEL_NAME_PATH, "w") as f:
+  name = DEFAULT_MODEL
-    f.write(f'DEFAULT_MODEL = "{default_model_name}"\n')
+  print(f'Current default model name: "{name}"')
    f.write(f'DEFAULT_BIG_MODEL = "{default_big_model_name}"\n')
-  print(f'New default small model name: "{default_model_name}"')
+  return name
-  print(f'New default big model name: "{default_big_model_name}"')
+
 def update_default_model_name(name: str):
  print("[CHANGE DEFAULT MODEL NAME]")
  with open(DEFAULT_MODEL_NAME_PATH, "w") as f:
    f.write(f'DEFAULT_MODEL = "{name}"\n')
  print(f'New default model name: "{name}"')
  print("[DONE]")
 if __name__ == "__main__":
-  parser = argparse.ArgumentParser(description="Update default model names and hash")
+  parser = argparse.ArgumentParser(description="Update default model name and hash")
-  parser.add_argument("--new_small_model_name", type=str, help="New default small model name")
+  parser.add_argument("--new_name", type=str, help="New default model name")
  parser.add_argument("--new_big_model_name", type=str, help="New default big model name")
  args = parser.parse_args()
-  if args.new_small_model_name is None and args.new_big_model_name is None:
+  if not args.new_name:
-    new_name = input(f'Enter new default small model name (current: "{DEFAULT_MODEL}", leave empty to keep): ').strip()
+    print("Warning: No new default model name provided. Use --new_name to specify")
-    new_big_model_name = input(f'Enter new default big model name (current: "{DEFAULT_BIG_MODEL}", leave empty to keep): ').strip()
+    print("Default model name and hash will not be updated! (aborted)")
-  else:
+    exit(0)
    new_name, new_big_model_name = args.new_small_model_name, args.new_big_model_name
-  update_default_model_names(new_name or DEFAULT_MODEL, new_big_model_name or DEFAULT_BIG_MODEL)
+  current_name = get_current_default_model_name()
  new_name = args.new_name
  if current_name == new_name:
    print(f'Proposed default model name: "{new_name}"')
    confirm = input("Proposed default model name is the same as the current default model name. Confirm? (y/n): ").upper().strip()
    if confirm != "Y":
      print("Default model name and hash will not be updated! (aborted)")
      exit(0)
  update_default_model_name(new_name)
  update_model_hash()
@@ -13,6 +13,8 @@ from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
 from openpilot.common.hardware.hw import Paths
 from openpilot.sunnypilot.models.helpers import is_bundle_version_compatible
 from openpilot.selfdrive.modeld.helpers import usbgpu_present
 from openpilot.cereal import custom
@@ -138,53 +140,45 @@ class ModelCache:
 class ModelFetcher:
  """Handles fetching and caching of model data from remote source"""
-  MODEL_URL = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_v21.json"
+  MODEL_URL = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_v19.json"
-  MODEL_URL_CHESTNUT = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_chestnut_v22.json"
+  MODEL_URL_USBGPU = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_usbgpu_v19.json"
  MODEL_SOURCES = {
    "qcom": (MODEL_URL, ""),
    "chestnut": (MODEL_URL_CHESTNUT, "_Chestnut"),
  }
  def __init__(self, params: Params):
    self.params = params
    self.model_parser = ModelParser()
-    self.model_caches = {
+    self._is_usbgpu: bool | None = None
-      source: ModelCache(params, suffix=suffix)
+    self.model_cache = ModelCache(params)
-      for source, (_, suffix) in self.MODEL_SOURCES.items()
+    self.model_url = self.MODEL_URL
-    }
+    self._update_model_source()
    self._refetched: set[str] = set()
    self.params.put("ModelManager_ActiveJson", {
      "qcom": self.MODEL_URL,
      "chestnut": self.MODEL_URL_CHESTNUT,
    }, block=True)
-  @staticmethod
+  def _update_model_source(self) -> None:
-  def active_source(chestnut_present: bool) -> str:
+    """Updates what json to use based on usbgpu availability"""
-    return "chestnut" if chestnut_present else "qcom"
+    is_usbgpu = usbgpu_present()
    if is_usbgpu != self._is_usbgpu:
      self._is_usbgpu = is_usbgpu
      self.model_cache = ModelCache(self.params, suffix="_USBGPU" if is_usbgpu else "")
      self.model_url = self.MODEL_URL_USBGPU if is_usbgpu else self.MODEL_URL
      self.params.put("ModelManager_ActiveJson", self.model_url, block=True)
-  def _fetch_and_cache_models(self, source: str) -> list[custom.ModelManagerSP.ModelBundle] | None:
+  def _fetch_and_cache_models(self) -> list[custom.ModelManagerSP.ModelBundle] | None:
    """Fetches fresh model data from remote and updates cache.
    Returns None on transport errors. Raises on 404 and other fatal HTTP errors.
    """
    model_url, _ = self.MODEL_SOURCES[source]
    try:
-      response = requests.get(model_url, timeout=10)
+      response = requests.get(self.model_url, timeout=10)
      # Explicitly handle 404 differently
      if response.status_code == 404:
-        cloudlog.error(f"Models URL returned 404 Not Found: {model_url}")
+        cloudlog.error(f"Models URL returned 404 Not Found: {self.model_url}")
-        raise HTTPError(f"404 Not Found: {model_url}", response=response)
+        raise HTTPError(f"404 Not Found: {self.model_url}", response=response)
      # Raise for any other 4xx/5xx
      response.raise_for_status()
      json_data = response.json()
-      parsed = self.model_parser.parse_models(json_data)
+      self.model_cache.set(json_data)
-      if parsed:
+      cloudlog.debug("Successfully updated models cache")
-        self.model_caches[source].set(json_data)
+      return self.model_parser.parse_models(json_data)
        cloudlog.debug(f"Successfully updated models cache for {source}")
      return parsed
    except ConnectionError as e:
      cloudlog.warning(f"DNS/connection error while fetching models: {e}")
@@ -197,40 +191,16 @@ class ModelFetcher:
    return None
-  @staticmethod
+  def get_available_bundles(self) -> list[custom.ModelManagerSP.ModelBundle]:
-  def _cache_matches_source(source: str, cached_data: dict) -> bool:
+    """Gets the list of available models, with smart cache handling"""
-    bundles = cached_data.get("bundles", [])
+    self._update_model_source()
-    if source == "chestnut":
+    cached_data, is_expired = self.model_cache.get()
      return any(bundle.get("is_big") is True for bundle in bundles)
    return not any(bundle.get("is_big") is True for bundle in bundles)
  def get_bundles_for_source(self, source: str) -> list[custom.ModelManagerSP.ModelBundle]:
    if source not in self.MODEL_SOURCES:
      cloudlog.warning(f"Unknown model source: {source}")
      return []
    cached_data, is_expired = self.model_caches[source].get()
    if cached_data and not is_expired:
-      # a source is refetched over a mismatch at most once per process: if the fresh
+      cloudlog.debug("Using valid cached models data")
-      # manifest still mismatches, the URL is authoritative and the cache is trusted
+      return self.model_parser.parse_models(cached_data)
      if self._cache_matches_source(source, cached_data) or source in self._refetched:
        try:
          parsed = self.model_parser.parse_models(cached_data)
        except Exception:
          cloudlog.warning(f"Failed to parse cached models for {source}; refetching", exc_info=True)
        else:
          if parsed:
            cloudlog.debug(f"Using valid cached models data for source {source}")
            return parsed
          # a source-matching cache that yields no valid bundles is stale (e.g. an old
          # manifest version) - do not trust it, refetch so the source is repopulated
          cloudlog.warning(f"Cached models for {source} have no valid bundles; refetching")
      else:
        self._refetched.add(source)
        cloudlog.warning(f"Cached models for {source} not valid; refetching once")
-    fetched_bundles = self._fetch_and_cache_models(source)
+    fetched_bundles = self._fetch_and_cache_models()
    if fetched_bundles is not None:
      return fetched_bundles
@@ -238,33 +208,12 @@ class ModelFetcher:
      cloudlog.warning("Failed to fetch fresh data and no cache available")
    cloudlog.warning("Failed to fetch fresh data. Using expired cache as fallback")
-    try:
+    return self.model_parser.parse_models(cached_data)
      return self.model_parser.parse_models(cached_data)
    except Exception:
      return []
 def get_cached_bundles(params: Params, source: str) -> list[custom.ModelManagerSP.ModelBundle]:
  if source not in ModelFetcher.MODEL_SOURCES:
    cloudlog.warning(f"Unknown model source: {source}")
    return []
  _, suffix = ModelFetcher.MODEL_SOURCES[source]
  cached_data = params.get(f"ModelManager_ModelsCache{suffix}")
  if not cached_data:
    return []
  try:
    return ModelParser.parse_models(cached_data)
  except Exception as e:
    cloudlog.warning(f"Failed to parse cached models for source {source}: {e}")
    return []
 if __name__ == "__main__":
  from openpilot.selfdrive.modeld.helpers import chestnut_present
  params = Params()
  model_fetcher = ModelFetcher(params)
-  bundles = model_fetcher.get_bundles_for_source(ModelFetcher.active_source(chestnut_present()))
+  bundles = model_fetcher.get_available_bundles()
  for bundle in bundles:
    for model in bundle.models:
      model_overrides = {override.key: override.value for override in bundle.overrides}
@@ -16,20 +16,14 @@ from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
 from openpilot.sunnypilot.models.constants import Meta, MetaSimPose, MetaTombRaider
 from openpilot.common.hardware.hw import Paths
 from openpilot.selfdrive.modeld.helpers import chestnut_present
 # SET ME TO THE EXACT JSON VERSION WE SET IN SUNNYPILOT_MODELS REPO
-REQUIRED_JSON_VERSION = 18
+REQUIRED_JSON_VERSION = 17
 CUSTOM_MODEL_PATH = Paths.model_root()
 METADATA_PATH = Path(__file__).parent / '../models/supercombo_metadata.pkl'
 ModelManager = custom.ModelManagerSP
-
+_LAST_VALIDATED_RAW = None
 ACTIVE_BUNDLE_KEYS = {
  "qcom": "ModelManager_ActiveBundle",
  "chestnut": "ModelManager_ActiveBundleChestnut",
 }
 _LAST_VALIDATED_RAW: dict[str, dict | None] = {}
 def _compute_hash(file_path: str) -> str | None:
@@ -92,11 +86,11 @@ def _bundle_needs_reset(active_bundle: custom.ModelManagerSP.ModelBundle, availa
  if available_bundles is not None:
    matching_bundle = None
    for bundle in available_bundles:
-      if active_bundle.ref and bundle.ref:
+      if getattr(active_bundle, 'ref', None) and getattr(bundle, 'ref', None):
        if active_bundle.ref == bundle.ref:
          matching_bundle = bundle
          break
-      elif active_bundle.internalName == bundle.internalName:
+      elif getattr(active_bundle, 'internalName', None) == getattr(bundle, 'internalName', None):
        matching_bundle = bundle
        break
@@ -104,79 +98,47 @@ def _bundle_needs_reset(active_bundle: custom.ModelManagerSP.ModelBundle, availa
      return True
    if active_bundle.minimumSelectorVersion != matching_bundle.minimumSelectorVersion:
      return True
-    if active_bundle.runner != matching_bundle.runner:
+
-      return True
+    active_runner = getattr(active_bundle, 'runner', None)
    matching_runner = getattr(matching_bundle, 'runner', None)
    if active_runner is not None and matching_runner is not None:
      if getattr(active_runner, 'raw', active_runner) != getattr(matching_runner, 'raw', matching_runner):
        return True
    if set(_bundle_artifacts(active_bundle)) != set(_bundle_artifacts(matching_bundle)):
      return True
  return not _bundle_is_valid_locally(active_bundle)
-def _parse_active_bundle(raw_bundle) -> "custom.ModelManagerSP.ModelBundle | None":
+def validate_active_bundle(params: Params, available_bundles: list[custom.ModelManagerSP.ModelBundle] | None = None) -> None:
  try:
    if isinstance(raw_bundle, dict) and raw_bundle and is_bundle_version_compatible(raw_bundle):
      return custom.ModelManagerSP.ModelBundle(**raw_bundle)
  except Exception:
    pass
  return None
 def get_selected_bundle(params: Params | None = None, source: str = "qcom") -> "custom.ModelManagerSP.ModelBundle | None":
  params = params or Params()
  return _parse_active_bundle(params.get(ACTIVE_BUNDLE_KEYS[source]))
 def get_active_source(chestnut: bool | None = None, chestnut_active: bool | None = None,
                      chestnut_loading: bool | None = None, offroad: bool | None = None) -> str:
  if chestnut is None:
    chestnut = chestnut_present()
  state_valid = chestnut_active is not None or chestnut_loading is not None or offroad is not None
  big_active = chestnut and (not state_valid or chestnut_active or chestnut_loading or offroad)
  return "chestnut" if big_active else "qcom"
 def get_active_bundle(params: Params | None = None, *, chestnut: bool | None = None) -> "custom.ModelManagerSP.ModelBundle | None":
  # no cross-slot fallback: an empty active slot means the hardware default, which
  # only stock modeld can run - modeld_v2 requires a real bundle
  params = params or Params()
  return get_selected_bundle(params, get_active_source(chestnut=chestnut))
 def resolve_bundle_by_ref(
  ref: str, source_bundles: dict[str, list[custom.ModelManagerSP.ModelBundle]],
 ) -> "tuple[custom.ModelManagerSP.ModelBundle, str] | None":
  for source, bundles in source_bundles.items():
    for bundle in bundles:
      if bundle.ref == ref:
        return bundle, source
  return None
 def _validate_active_bundle(params: Params, source: str, available_bundles: list[custom.ModelManagerSP.ModelBundle] | None = None) -> None:
  global _LAST_VALIDATED_RAW
-  key = ACTIVE_BUNDLE_KEYS[source]
+  raw_bundle = params.get("ModelManager_ActiveBundle")
  raw_bundle = params.get(key)
  if not raw_bundle:
    return
-  if _LAST_VALIDATED_RAW.get(key) == raw_bundle:
+  if raw_bundle == _LAST_VALIDATED_RAW:
    return
-  active_bundle = _parse_active_bundle(raw_bundle)
+  active_bundle = get_active_bundle(params, raw_bundle_dict=raw_bundle)
  if active_bundle is None or _bundle_needs_reset(active_bundle, available_bundles):
-    cloudlog.warning(f"Active model bundle invalid for {source}; resetting to default")
+    cloudlog.warning("Active model bundle invalid; resetting to default")
-    params.remove(key)
+    params.remove("ModelManager_ActiveBundle")
-    _LAST_VALIDATED_RAW[key] = None
+    params.put("ModelRunnerTypeCache", int(custom.ModelManagerSP.Runner.stock), block=True)
    _LAST_VALIDATED_RAW = None
  else:
-    _LAST_VALIDATED_RAW[key] = raw_bundle
+    _LAST_VALIDATED_RAW = raw_bundle
-def validate_active_bundles(params: Params, source_bundles: dict[str, list[custom.ModelManagerSP.ModelBundle]]) -> None:
+def get_active_bundle(params: Params | None = None, raw_bundle_dict: dict | bytes | None = None) -> "custom.ModelManagerSP.ModelBundle | None":
-  # an empty list means the fetch failed, not that the catalog dropped the bundle
+  params = params or Params()
-  for source, bundles in source_bundles.items():
+  try:
-    _validate_active_bundle(params, source, bundles or None)
+    active_bundle_dict = raw_bundle_dict if raw_bundle_dict is not None else (params.get("ModelManager_ActiveBundle") or {})
-  get_active_model_runner(params, force_check=True)
+    if isinstance(active_bundle_dict, dict) and active_bundle_dict and is_bundle_version_compatible(active_bundle_dict):
      return custom.ModelManagerSP.ModelBundle(**active_bundle_dict)
  except Exception:
    pass
  return None
 def get_active_model_runner(params: Params | None = None, force_check: bool = False) -> int:
@@ -17,17 +17,12 @@ from openpilot.common.hardware.hw import Paths
 from openpilot.cereal import messaging, custom
 from openpilot.sunnypilot.models.fetcher import ModelFetcher
-from openpilot.sunnypilot.models.helpers import (ACTIVE_BUNDLE_KEYS, get_active_bundle, get_selected_bundle,
+from openpilot.sunnypilot.models.helpers import get_active_bundle, validate_active_bundle, verify_file
                                                  resolve_bundle_by_ref, validate_active_bundles, verify_file)
 # (connect, read) seconds. read is per-request inactivity, not a total cap
 DOWNLOAD_TIMEOUT = (30, 30)
 class DownloadCancelled(Exception):
  pass
 class ModelManagerSP:
  """Manages model downloads and status reporting"""
@@ -35,25 +30,11 @@ class ModelManagerSP:
    self.params = Params()
    self.model_fetcher = ModelFetcher(self.params)
    self.pm = messaging.PubMaster(["modelManagerSP"])
    self.sm = messaging.SubMaster(["deviceState"])
    self.chestnut_present = False
    self.available_models: list[custom.ModelManagerSP.ModelBundle] = []
    self.source_models: dict[str, list[custom.ModelManagerSP.ModelBundle]] = {}
    self.selected_bundle: custom.ModelManagerSP.ModelBundle = None
-    self.active_bundle: custom.ModelManagerSP.ModelBundle = get_active_bundle(self.params, chestnut=self.chestnut_present)
+    self.active_bundle: custom.ModelManagerSP.ModelBundle = get_active_bundle(self.params)
    self._chunk_size = 128 * 1000  # 128 KB chunks
    self._download_start_times: dict[str, float] = {}  # Track start time per model
    self._download_ref: bytes | str | None = None
  def _download_interrupted(self) -> bool:
    # only removal cancels: a different ref is a queued selection that
    # _release_download_ref leaves in place for the next tick
    return self.params.get("ModelManager_DownloadRef") is None
  def _release_download_ref(self) -> None:
    if self.params.get("ModelManager_DownloadRef") == self._download_ref:
      self.params.remove("ModelManager_DownloadRef")
    self._download_ref = None
  def _sync_artifact_progress(self, source_artifact) -> None:
    """Mirror download progress to all artifacts sharing the same filename in the selected bundle."""
@@ -95,8 +76,8 @@ class ModelManagerSP:
          f.write(chunk)
          bytes_downloaded += len(chunk)
-          if self._download_interrupted():
+          if self.params.get("ModelManager_DownloadIndex") is None:
-            raise DownloadCancelled("Download cancelled")
+            raise Exception("Download cancelled")
          if total_size > 0:
            progress = (bytes_downloaded / total_size) * 100
@@ -109,7 +90,7 @@ class ModelManagerSP:
    # Clean up start time after download completes
    del self._download_start_times[model.fileName]
-  async def _download_chunked(self, base_url: str, base_path: str, artifact, skip: frozenset[int] | set[int] = frozenset()) -> None:
+  async def _download_chunked(self, base_url: str, base_path: str, artifact) -> None:
    from openpilot.common.file_chunker import get_chunk_name, get_manifest_path
    num_chunks = len(artifact.chunks)
@@ -121,11 +102,8 @@ class ModelManagerSP:
    # Shared connection saves a TCP+TLS handshake per chunk.
    # Keep sequential: the link saturates on one stream and Session is not thread-safe.
    completed = len(skip)
    with requests.Session() as session:
      for i, _ in enumerate(artifact.chunks):
        if i in skip:
          continue
        chunk_url = get_chunk_name(base_url, i, num_chunks)
        chunk_path = get_chunk_name(base_path, i, num_chunks)
        chunk_downloaded = 0
@@ -136,16 +114,15 @@ class ModelManagerSP:
            for data in response.iter_content(chunk_size=self._chunk_size):
              f.write(data)
              chunk_downloaded += len(data)
-              if self._download_interrupted():
+              if self.params.get("ModelManager_DownloadIndex") is None:
-                raise DownloadCancelled("Download cancelled")
+                raise Exception("Download cancelled")
              intra = chunk_downloaded / max(chunk_size, 1)
-              progress = min(99.0, ((completed + intra) / num_chunks) * 100)
+              progress = min(99.0, ((i + intra) / num_chunks) * 100)
              artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.downloading
              artifact.downloadProgress.progress = progress
              artifact.downloadProgress.eta = self._calculate_eta(artifact.fileName, progress)
              self._sync_artifact_progress(artifact)
              self._report_status()
        completed += 1
    with open(manifest_path, 'w') as f:  # noqa: ASYNC230
      f.write(str(num_chunks))
@@ -156,8 +133,6 @@ class ModelManagerSP:
  async def _process_artifact(self, artifact, destination_path: str) -> None:
    if not artifact.downloadUri.uri:
      return None
    if self._download_interrupted():
      raise DownloadCancelled("Download cancelled")
    url = artifact.downloadUri.uri
    expected_hash = artifact.downloadUri.sha256
@@ -165,23 +140,17 @@ class ModelManagerSP:
    full_path = os.path.join(destination_path, filename)
    try:
      # progress counts only valid chunks so a resumed download continues the
      # bar from where verification left it, instead of falling back to zero
      is_cached = False
      valid_chunks: set[int] = set()
      if len(artifact.chunks) > 0:
        from openpilot.common.file_chunker import get_chunk_name
-        num_chunks = len(artifact.chunks)
+        chunks_valid = True
        for i, chunk in enumerate(artifact.chunks):
-          if self._download_interrupted():
+          chunk_path = get_chunk_name(full_path, i, len(artifact.chunks))
-            raise DownloadCancelled("Download cancelled")
+          if not await verify_file(chunk_path, chunk.sha256):
-          if await verify_file(get_chunk_name(full_path, i, num_chunks), chunk.sha256):
+            chunks_valid = False
-            valid_chunks.add(i)
+            break
-          artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.verifying
+        if chunks_valid and len(artifact.chunks) > 0:
-          artifact.downloadProgress.progress = (len(valid_chunks) / num_chunks) * 100
+          is_cached = True
          self._sync_artifact_progress(artifact)
          self._report_status()
        is_cached = len(valid_chunks) == num_chunks
      else:
        if await verify_file(full_path, expected_hash):
          is_cached = True
@@ -195,7 +164,7 @@ class ModelManagerSP:
        return
      if len(artifact.chunks) > 0:
-        await self._download_chunked(url, full_path, artifact, skip=valid_chunks)
+        await self._download_chunked(url, full_path, artifact)
        from openpilot.common.file_chunker import get_chunk_name
        for i, chunk in enumerate(artifact.chunks):
          chunk_path = get_chunk_name(full_path, i, len(artifact.chunks))
@@ -212,17 +181,6 @@ class ModelManagerSP:
      self._sync_artifact_progress(artifact)
      self._report_status()
    except DownloadCancelled:
      # a cancel keeps whatever is on disk: complete chunks resume the next attempt
      self._download_start_times.pop(artifact.fileName, None)
      artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.failed
      artifact.downloadProgress.eta = 0
      self._sync_artifact_progress(artifact)
      if self.selected_bundle:
        self.selected_bundle.status = custom.ModelManagerSP.DownloadStatus.failed
      self._report_status()
      raise
    except Exception as e:
      cloudlog.error(f"Error downloading {filename}: {str(e)}")
      for f in [full_path] + [p for p in (os.path.join(destination_path, f) for f in os.listdir(destination_path)) if filename in p]:
@@ -254,12 +212,10 @@ class ModelManagerSP:
    model_manager_state.availableBundles = self.available_models
    self.pm.send('modelManagerSP', msg)
-  async def _download_bundle(self, model_bundle: custom.ModelManagerSP.ModelBundle, destination_path: str, source: str) -> None:
+  async def _download_bundle(self, model_bundle: custom.ModelManagerSP.ModelBundle, destination_path: str) -> None:
    """Downloads all models in a bundle"""
    self.selected_bundle = model_bundle
    self.selected_bundle.status = custom.ModelManagerSP.DownloadStatus.downloading
    for model in self.selected_bundle.models:
      model.artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.downloading
    self._report_status()
    os.makedirs(destination_path, exist_ok=True)
    try:
@@ -276,11 +232,10 @@ class ModelManagerSP:
          seen_artifacts.add(artifact.fileName)
          await self._process_artifact(artifact, destination_path)
-      if self._download_interrupted():
+      self.active_bundle = self.selected_bundle
-        raise DownloadCancelled("Download cancelled")
+      self.active_bundle.status = custom.ModelManagerSP.DownloadStatus.downloaded
-      self.selected_bundle.status = custom.ModelManagerSP.DownloadStatus.downloaded
+      self.params.put("ModelManager_ActiveBundle", self.active_bundle.to_dict(), block=True)
-      self.params.put(ACTIVE_BUNDLE_KEYS[source], model_bundle.to_dict(), block=True)
+      self.selected_bundle = None
      self.active_bundle = get_active_bundle(self.params, chestnut=self.chestnut_present)
    except Exception:
      if self.selected_bundle is not None:
@@ -290,30 +245,9 @@ class ModelManagerSP:
    finally:
      self._report_status()
-  def download(self, model_bundle: custom.ModelManagerSP.ModelBundle, destination_path: str, source: str) -> None:
+  def download(self, model_bundle: custom.ModelManagerSP.ModelBundle, destination_path: str) -> None:
    """Main entry point for downloading a model bundle"""
-    asyncio.run(self._download_bundle(model_bundle, destination_path, source))
+    asyncio.run(self._download_bundle(model_bundle, destination_path))
  def _process_download_requests(self) -> None:
    # loops so a ref queued during a download starts in the same tick, without
    # the bar dropping to idle for a tick between the two transfers
    last_ref = None
    while (ref_to_download := self.params.get("ModelManager_DownloadRef")) is not None:
      if ref_to_download == last_ref:  # a repeating ref falls back to the next tick instead of spinning
        return
      last_ref = ref_to_download
      resolved = resolve_bundle_by_ref(ref_to_download, self.source_models)
      if not resolved:
        return
      model_to_download, source = resolved
      self._download_ref = ref_to_download
      try:
        self.download(model_to_download, Paths.model_root(), source)
      except Exception as e:
        cloudlog.exception(e)
      finally:
        self._release_download_ref()
        self.selected_bundle = None
  def main_thread(self) -> None:
    """Main thread for model management"""
@@ -321,14 +255,19 @@ class ModelManagerSP:
    while True:
      try:
-        self.sm.update(0)
+        self.available_models = self.model_fetcher.get_available_bundles()
-        self.chestnut_present = self.sm['deviceState'].chestnutPresent
+        validate_active_bundle(self.params, self.available_models)
-        self.source_models = {source: self.model_fetcher.get_bundles_for_source(source) for source in ModelFetcher.MODEL_SOURCES}
+        self.active_bundle = get_active_bundle(self.params)
        self.available_models = self.source_models[ModelFetcher.active_source(self.chestnut_present)]
        validate_active_bundles(self.params, self.source_models)
        self.active_bundle = get_active_bundle(self.params, chestnut=self.chestnut_present)
-        self._process_download_requests()
+        if (index_to_download := self.params.get("ModelManager_DownloadIndex")) is not None:
          if model_to_download := next((model for model in self.available_models if model.index == index_to_download), None):
            try:
              self.download(model_to_download, Paths.model_root())
            except Exception as e:
              cloudlog.exception(e)
            finally:
              self.params.remove("ModelManager_DownloadIndex")
              self.selected_bundle = None
        if self.params.get("ModelManager_ClearCache"):
          self.clear_model_cache()
@@ -346,14 +285,12 @@ class ModelManagerSP:
    Clears the model cache directory of all files except those in the active model bundle.
    """
-    # Get list of files used by both slots' selected bundles (either may become
+    # Get list of files used by active model bundle
    # the truly active bundle depending on hardware availability)
    active_files = []
-    for source in ACTIVE_BUNDLE_KEYS:
+    if self.active_bundle is not None: # When the default model is active
-      if selected_bundle := get_selected_bundle(self.params, source):
+      for model in self.active_bundle.models:
-        for model in selected_bundle.models:
+        if hasattr(model, 'artifact') and model.artifact.fileName:
-          if model.artifact.fileName:
+          active_files.append(model.artifact.fileName)
            active_files.append(model.artifact.fileName)
    # Remove all files except active ones (including their chunk files)
    model_dir = Paths.model_root()
@@ -1,2 +1 @@
 DEFAULT_MODEL = "CD210"
 DEFAULT_BIG_MODEL = "Lebowski"
@@ -20,4 +20,4 @@ class TestDefaultModel(OpenpilotTestCase):
    with open(MODEL_HASH_PATH) as f:
      current_hash = f.read().strip()
-    assert combined_hash == current_hash, "Run openpilot/sunnypilot/models/default_model.py to update the default model name and hash"
+    assert combined_hash == current_hash, "Run sunnypilot/models/default_model.py to update the default model name and hash"
@@ -11,7 +11,6 @@ import http.server
 import os
 import tempfile
 import threading
 import time
 import unittest
 from typing import Any
 from unittest import mock
@@ -24,10 +23,6 @@ from openpilot.common.test import OpenpilotTestCase
 from openpilot.common.file_chunker import get_chunk_name, get_manifest_path
 from openpilot.selfdrive.test.helpers import http_server_context
 from openpilot.sunnypilot.models import manager as manager_module
 from openpilot.sunnypilot.models.fetcher import ModelFetcher, get_cached_bundles
 from openpilot.sunnypilot.models import helpers
 from openpilot.sunnypilot.models.helpers import (get_active_bundle, get_active_source, get_selected_bundle,
                                                  resolve_bundle_by_ref, validate_active_bundles)
 from openpilot.sunnypilot.models.manager import ModelManagerSP
 CHUNK_BODIES = [b'A' * 5000, b'B' * 5000, b'C' * 3000]
@@ -103,13 +98,11 @@ class ManagerDownloadTestBase(OpenpilotTestCase):
    self.manager = ModelManagerSP.__new__(ModelManagerSP)
    self.manager.params = mock.MagicMock()
    self.manager.params.get.return_value = b'0'  # not cancelled
    self.manager._download_ref = b'0'
    self.manager.pm = mock.MagicMock()
    self.manager.pm.send.side_effect = self._record_progress
    self.manager.selected_bundle = None
    self.manager.active_bundle = None
    self.manager.available_models = []
    self.manager.chestnut_present = False
    self.manager._chunk_size = 1024
    self.manager._download_start_times = {}
@@ -256,166 +249,6 @@ class TestManagerDownload(ManagerDownloadTestBase):
        assert self.manager._download_start_times == {}
    self.run_with_server(body)
  def test_download_ref_present_keeps_download_alive(self):
    """A pending download request (DownloadRef set) must not be cancelled mid-transfer."""
    def body():
      artifact = self.make_artifact(chunked=True)
      base_path = os.path.join(self.dest, artifact.fileName)
      self.manager.params.get.side_effect = lambda key: b"ref" if key == "ModelManager_DownloadRef" else None
      self.manager._download_ref = b"ref"
      asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
      assert os.path.isfile(get_manifest_path(base_path))
    self.run_with_server(body)
  def test_cancellation_via_download_ref(self):
    """Removing DownloadRef mid-transfer cancels the download."""
    def body():
      artifact = self.make_artifact(chunked=True)
      base_path = os.path.join(self.dest, artifact.fileName)
      checks = {"n": 0}
      def get(key):
        if key == "ModelManager_DownloadRef":
          checks["n"] += 1
          return b"ref" if checks["n"] <= 2 else None
        return b"0"
      self.manager.params.get.side_effect = get
      self.manager._download_ref = b"ref"
      with self.assertRaises(Exception) as ctx:
        asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
      assert 'cancelled' in str(ctx.exception).lower()
      assert not os.path.isfile(get_manifest_path(base_path))
    self.run_with_server(body)
  def test_replaced_download_ref_queues_instead_of_cancelling(self):
    """Selecting another model mid-transfer lets the running download finish."""
    def body():
      artifact = self.make_artifact(chunked=True)
      base_path = os.path.join(self.dest, artifact.fileName)
      self.manager.params.get.side_effect = lambda key: b"other-ref" if key == "ModelManager_DownloadRef" else None
      self.manager._download_ref = b"ref"
      asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
      assert os.path.isfile(get_manifest_path(base_path))
    self.run_with_server(body)
  def test_replaced_download_ref_is_kept(self):
    """A selection made during a download must survive that download's cleanup."""
    self.manager.params.get.return_value = b"new-ref"
    self.manager._download_ref = b"old-ref"
    self.manager._release_download_ref()
    self.manager.params.remove.assert_not_called()
  def test_own_download_ref_is_released(self):
    self.manager.params.get.return_value = b"ref"
    self.manager._download_ref = b"ref"
    self.manager._release_download_ref()
    self.manager.params.remove.assert_called_once_with("ModelManager_DownloadRef")
  def test_cached_bundle_cancel_skips_slot_write(self):
    """A cancel must stop an already-on-disk bundle before it is applied to the slot."""
    def body():
      artifact = self.make_artifact(chunked=True)
      base_path = os.path.join(self.dest, artifact.fileName)
      for i, data in enumerate(CHUNK_BODIES):
        with open(get_chunk_name(base_path, i, len(CHUNK_BODIES)), 'wb') as f:
          f.write(data)
      self._bundle.ref = "test-ref"
      params, store = self._make_params_with_store()
      store["ModelManager_DownloadRef"] = None  # removed -> cancelled
      self.manager.params = params
      self.manager._download_ref = b"ref"
      with self.assertRaises(Exception) as ctx:
        asyncio.run(self.manager._download_bundle(self._bundle, self.dest, "qcom"))
      assert 'cancelled' in str(ctx.exception).lower()
      assert "ModelManager_ActiveBundle" not in store
      assert all(os.path.isfile(p) for p in self.chunk_paths(base_path)), "cancel must not delete cached chunks"
    self.run_with_server(body)
  def test_resume_skips_valid_chunks(self):
    """A chunk already on disk is kept and not re-downloaded; progress starts above its share."""
    def body():
      artifact = self.make_artifact(chunked=True)
      base_path = os.path.join(self.dest, artifact.fileName)
      with open(get_chunk_name(base_path, 0, len(CHUNK_BODIES)), 'wb') as f:
        f.write(CHUNK_BODIES[0])
      asyncio.run(self.manager._process_artifact(artifact, self.dest))
      chunk0_suffix = get_chunk_name('', 0, len(CHUNK_BODIES))
      assert not any(p.endswith(chunk0_suffix) for p in DownloadHandler.request_paths), "valid chunk was re-downloaded"
      for i, expected in enumerate(CHUNK_BODIES):
        with open(get_chunk_name(base_path, i, len(CHUNK_BODIES)), 'rb') as f:
          assert f.read() == expected
      assert os.path.isfile(get_manifest_path(base_path))
      assert min(self.reported) >= (1 / len(CHUNK_BODIES)) * 100 - 1, "progress must not restart below the resumed share"
    self.run_with_server(body)
  def test_verify_reports_valid_fraction_then_cached(self):
    """A fully cached bundle publishes climbing verify progress and ends cached."""
    def body():
      artifact = self.make_artifact(chunked=True)
      base_path = os.path.join(self.dest, artifact.fileName)
      for i, data in enumerate(CHUNK_BODIES):
        with open(get_chunk_name(base_path, i, len(CHUNK_BODIES)), 'wb') as f:
          f.write(data)
      asyncio.run(self.manager._process_artifact(artifact, self.dest))
      assert DownloadHandler.request_paths == [], "cached bundle must not hit the network"
      assert [round(p) for p in self.reported[:3]] == [33, 67, 100]
      assert artifact.downloadProgress.status == custom.ModelManagerSP.DownloadStatus.cached
    self.run_with_server(body)
  def _make_params_with_store(self):
    params = mock.MagicMock()
    store = {}
    def get(key, *args, **kwargs):
      return store.get(key, b"0")  # b"0" -> download not cancelled
    def put(key, value, *args, **kwargs):
      store[key] = value
    params.get.side_effect = get
    params.put.side_effect = put
    return params, store
  def test_download_writes_qcom_slot(self):
    """A download resolved to the qcom source writes the qcom active bundle slot only."""
    def body():
      artifact = self.make_artifact(chunked=True)
      self._bundle.ref = "test-ref"
      self._bundle.minimumSelectorVersion = 18
      params, store = self._make_params_with_store()
      self.manager.params = params
      asyncio.run(self.manager._download_bundle(self._bundle, self.dest, "qcom"))
      assert "ModelManager_ActiveBundle" in store, "qcom download must write the qcom slot"
      assert "ModelManager_ActiveBundleChestnut" not in store, "qcom download must not touch the chestnut slot"
      assert self.manager.selected_bundle.status == custom.ModelManagerSP.DownloadStatus.downloaded
      assert self.manager.active_bundle is not None and self.manager.active_bundle.ref == "test-ref"
      assert self.manager.active_bundle.status == custom.ModelManagerSP.DownloadStatus.downloaded
      chunk_names = [get_chunk_name(artifact.fileName, i, len(artifact.chunks)) for i in range(len(artifact.chunks))]
      missing = [c for c in chunk_names if not os.path.isfile(os.path.join(self.dest, c))]
      assert missing == [], f"chunks missing from the cache: {missing}"
    self.run_with_server(body)
  def test_download_writes_chestnut_slot(self):
    """A download resolved to the chestnut source writes the chestnut active bundle slot only."""
    def body():
      self.make_artifact(chunked=True)
      self._bundle.ref = "big-ref"
      self._bundle.minimumSelectorVersion = 18
      params, store = self._make_params_with_store()
      self.manager.params = params
      asyncio.run(self.manager._download_bundle(self._bundle, self.dest, "chestnut"))
      assert "ModelManager_ActiveBundleChestnut" in store, "chestnut download must write the chestnut slot"
      assert "ModelManager_ActiveBundle" not in store, "chestnut download must not touch the qcom slot"
      assert self.manager.selected_bundle.status == custom.ModelManagerSP.DownloadStatus.downloaded
    self.run_with_server(body)
 class TestManagerImports(OpenpilotTestCase):
  """Catches undeclared dependencies. aiohttp lived only in the AGNOS venv; 19.6 dropped
@@ -434,352 +267,6 @@ class TestManagerImports(OpenpilotTestCase):
    assert connect > 0 and read > 0, "requests defaults to no timeout; downloads would hang forever"
 class TestResolveBundleByRef(OpenpilotTestCase):
  """A ref resolves to (bundle, source) across both hardware manifests. Refs are
  unique per manifest and never overlap across sources, so a ref maps to exactly
  one slot. Shared by the manager's download flow and the settings UI."""
  @staticmethod
  def _bundle(ref: str):
    bundle = custom.ModelManagerSP.ModelBundle.new_message()
    bundle.ref = ref
    return bundle
  def test_qcom_ref_resolves_to_qcom_slot(self):
    small = self._bundle("small")
    assert resolve_bundle_by_ref("small", {"qcom": [small], "chestnut": []}) == (small, "qcom")
  def test_chestnut_ref_resolves_to_chestnut_slot(self):
    big = self._bundle("big")
    assert resolve_bundle_by_ref("big", {"qcom": [], "chestnut": [big]}) == (big, "chestnut")
  def test_unknown_ref_returns_none(self):
    source_bundles = {"qcom": [self._bundle("small")], "chestnut": []}
    assert resolve_bundle_by_ref("nope", source_bundles) is None
 def manifest_bundle(short_name: str, ref: str, index: int = 0, is_big: bool = False) -> dict:
  """Minimal manifest bundle dict, version-compatible (no chunks to avoid disk side effects).
  Big (chestnut) bundles carry `is_big: true` in the manifest JSON."""
  return {
    "index": index,
    "short_name": short_name,
    "display_name": short_name.upper(),
    "generation": 1,
    "environment": "release",
    "runner": "tinygrad",
    "is_big": is_big,
    "minimum_selector_version": "18",
    "ref": ref,
    "models": [{
      "type": "supercombo",
      "artifact": {
        "file_name": f"{short_name}.pkl",
        "download_uri": {"url": f"https://example.com/{short_name}.pkl", "sha256": "s"},
      },
    }],
  }
 def fresh_sync_time() -> int:
  return int(time.monotonic() * 1e9)
 class TestModelFetcherSources(OpenpilotTestCase):
  """Both manifests are always maintained: get_bundles_for_source exposes either
  source by name, and active_source picks which one matches the attached hardware."""
  def _make_params(self, qcom_manifest, chestnut_manifest):
    params = mock.MagicMock()
    def get(key):
      if key == "ModelManager_ModelsCache":
        return qcom_manifest
      if key == "ModelManager_ModelsCache_Chestnut":
        return chestnut_manifest
      if key in ("ModelManager_LastSyncTime", "ModelManager_LastSyncTime_Chestnut"):
        return fresh_sync_time()
      return None
    params.get.side_effect = get
    return params
  def test_active_source_follows_chestnut_presence(self):
    assert ModelFetcher.active_source(False) == "qcom"
    assert ModelFetcher.active_source(True) == "chestnut"
  def test_get_bundles_for_source_returns_each_source(self):
    params = self._make_params({"bundles": [manifest_bundle("small", "aaa")]},
                               {"bundles": [manifest_bundle("big", "bbb", is_big=True)]})
    fetcher = ModelFetcher(params)
    assert [bundle.ref for bundle in fetcher.get_bundles_for_source("qcom")] == ["aaa"]
    assert [bundle.ref for bundle in fetcher.get_bundles_for_source("chestnut")] == ["bbb"]
  def test_get_bundles_for_source_unknown(self):
    assert ModelFetcher(mock.MagicMock()).get_bundles_for_source("bogus") == []
  def test_get_cached_bundles_parses_source(self):
    params = self._make_params({"bundles": [manifest_bundle("small", "aaa")]},
                               {"bundles": [manifest_bundle("big", "bbb", is_big=True)]})
    qcom_bundles = get_cached_bundles(params, "qcom")
    chestnut_bundles = get_cached_bundles(params, "chestnut")
    assert [b.ref for b in qcom_bundles] == ["aaa"]
    assert [b.ref for b in chestnut_bundles] == ["bbb"]
    assert qcom_bundles[0].displayName == "SMALL"
  def test_get_cached_bundles_empty_when_missing(self):
    params = mock.MagicMock()
    params.get.return_value = None
    assert get_cached_bundles(params, "qcom") == []
    assert get_cached_bundles(params, "chestnut") == []
  def test_get_cached_bundles_unknown_source(self):
    assert get_cached_bundles(mock.MagicMock(), "bogus") == []
  def test_active_json_has_both_urls(self):
    params = mock.MagicMock()
    ModelFetcher(params)
    active_json_calls = [call for call in params.put.call_args_list if call.args[0] == "ModelManager_ActiveJson"]
    assert active_json_calls, "expected ModelManager_ActiveJson to be written"
    assert active_json_calls[-1].args[1] == {
      "qcom": ModelFetcher.MODEL_URL,
      "chestnut": ModelFetcher.MODEL_URL_CHESTNUT,
    }
 class TestSourceCacheIntegrity(OpenpilotTestCase):
  """Each source's cached manifest must contain only that source's models; the
  `is_big` flag in the JSON marks the big (chestnut) models. A mismatched cache is
  legacy data from before the per-source split (the active manifest was cached
  under the unsuffixed key regardless of hardware) and is refetched. This
  replaces the old one-time bundle migration."""
  def _make_params(self, qcom_manifest, chestnut_manifest):
    params = mock.MagicMock()
    def get(key):
      if key == "ModelManager_ModelsCache":
        return qcom_manifest
      if key == "ModelManager_ModelsCache_Chestnut":
        return chestnut_manifest
      if key in ("ModelManager_LastSyncTime", "ModelManager_LastSyncTime_Chestnut"):
        return fresh_sync_time()
      return None
    params.get.side_effect = get
    return params
  def _fetched(self, *bundles):
    return ModelFetcher(mock.MagicMock()).model_parser.parse_models({"bundles": list(bundles)})
  def test_qcom_cache_with_big_models_is_refetched(self):
    """Legacy: the unsuffixed cache holds the big manifest. is_big confirms it is
    the wrong set for qcom, so a fresh fetch replaces it."""
    params = self._make_params({"bundles": [manifest_bundle("big", "bbb", is_big=True)]},
                               {"bundles": [manifest_bundle("big2", "ccc", is_big=True)]})
    fetcher = ModelFetcher(params)
    fetched = self._fetched(manifest_bundle("small", "aaa"))
    with mock.patch.object(fetcher, "_fetch_and_cache_models", return_value=fetched):
      bundles = fetcher.get_bundles_for_source("qcom")
    assert [bundle.ref for bundle in bundles] == ["aaa"]
  def test_chestnut_cache_without_big_models_is_refetched(self):
    params = self._make_params({"bundles": [manifest_bundle("small", "aaa")]},
                               {"bundles": [manifest_bundle("big2", "ccc")]})
    fetcher = ModelFetcher(params)
    fetched = self._fetched(manifest_bundle("big", "bbb", is_big=True))
    with mock.patch.object(fetcher, "_fetch_and_cache_models", return_value=fetched):
      bundles = fetcher.get_bundles_for_source("chestnut")
    assert [bundle.ref for bundle in bundles] == ["bbb"]
  def test_matching_caches_are_used_without_fetch(self):
    params = self._make_params({"bundles": [manifest_bundle("small", "aaa")]},
                               {"bundles": [manifest_bundle("big", "bbb", is_big=True)]})
    fetcher = ModelFetcher(params)
    with mock.patch.object(fetcher, "_fetch_and_cache_models", side_effect=AssertionError("cache should be used")):
      assert [bundle.ref for bundle in fetcher.get_bundles_for_source("qcom")] == ["aaa"]
      assert [bundle.ref for bundle in fetcher.get_bundles_for_source("chestnut")] == ["bbb"]
  def test_stale_version_cache_is_refetched(self):
    """A source-matching cache whose bundles are all filtered by the selector version
    check parses to zero valid bundles; it is stale (e.g. an old manifest) and must be
    refetched instead of silently returning an empty list forever."""
    stale = manifest_bundle("small", "aaa")
    stale["minimum_selector_version"] = "16"
    params = self._make_params({"bundles": [stale]},
                               {"bundles": [manifest_bundle("big", "bbb", is_big=True)]})
    fetcher = ModelFetcher(params)
    fetched = self._fetched(manifest_bundle("small2", "ddd"))
    with mock.patch.object(fetcher, "_fetch_and_cache_models", return_value=fetched) as fetch:
      bundles = fetcher.get_bundles_for_source("qcom")
    fetch.assert_called_once_with("qcom")
    assert [bundle.ref for bundle in bundles] == ["ddd"]
  def test_mismatched_refetch_happens_once(self):
    """If the fresh manifest still fails the source check, the URL is authoritative:
    trust it instead of refetching at 1 Hz forever."""
    params = self._make_params({"bundles": [manifest_bundle("big", "bbb", is_big=True)]},
                               {"bundles": [manifest_bundle("big2", "ccc", is_big=True)]})
    fetcher = ModelFetcher(params)
    fetched = self._fetched(manifest_bundle("big", "bbb", is_big=True))
    with mock.patch.object(fetcher, "_fetch_and_cache_models", return_value=fetched) as fetch:
      first = fetcher.get_bundles_for_source("qcom")
      second = fetcher.get_bundles_for_source("qcom")
    fetch.assert_called_once_with("qcom")
    assert [bundle.ref for bundle in first] == ["bbb"]
    assert [bundle.ref for bundle in second] == ["bbb"]
  def test_corrupt_cache_is_refetched(self):
    """A cache that fails to parse (e.g. truncated/foreign JSON) must trigger a
    refetch instead of raising every loop and never recovering."""
    corrupt = {"bundles": [{"short_name": "broken"}]}  # missing required fields
    params = self._make_params(corrupt, {"bundles": [manifest_bundle("big", "bbb", is_big=True)]})
    fetcher = ModelFetcher(params)
    fetched = self._fetched(manifest_bundle("small", "aaa"))
    with mock.patch.object(fetcher, "_fetch_and_cache_models", return_value=fetched) as fetch:
      bundles = fetcher.get_bundles_for_source("qcom")
    fetch.assert_called_once_with("qcom")
    assert [bundle.ref for bundle in bundles] == ["aaa"]
 class TestActiveBundleValidation(OpenpilotTestCase):
  """Validation is per-slot: a failed fetch (empty bundle list) must not reset a slot,
  and resetting one slot must not stomp the runner cache derived from the other."""
  def setUp(self):
    super().setUp()
    helpers._LAST_VALIDATED_RAW.clear()
  @staticmethod
  def _raw_bundle(ref: str, runner: int | None = None) -> dict:
    bundle = custom.ModelManagerSP.ModelBundle.new_message()
    bundle.ref = ref
    bundle.minimumSelectorVersion = 18
    if runner is not None:
      bundle.runner = runner
    return bundle.to_dict()
  def _params(self, qcom=None, chestnut=None):
    params = mock.MagicMock()
    def get(key, *args, **kwargs):
      return {"ModelManager_ActiveBundle": qcom, "ModelManager_ActiveBundleChestnut": chestnut}.get(key)
    params.get.side_effect = get
    return params
  def test_empty_catalog_does_not_reset_slot(self):
    params = self._params(qcom=self._raw_bundle("small"))
    with mock.patch("openpilot.sunnypilot.models.helpers.chestnut_present", return_value=False):
      validate_active_bundles(params, {"qcom": [], "chestnut": []})
    params.remove.assert_not_called()
  def test_reset_recomputes_runner_from_surviving_slot(self):
    tinygrad = int(custom.ModelManagerSP.Runner.tinygrad)
    big_raw = self._raw_bundle("big", runner=tinygrad)
    params = self._params(qcom=self._raw_bundle("gone"), chestnut=big_raw)
    catalog = {"qcom": [custom.ModelManagerSP.ModelBundle(**self._raw_bundle("other"))],
               "chestnut": [custom.ModelManagerSP.ModelBundle(**big_raw)]}
    with mock.patch("openpilot.sunnypilot.models.helpers.chestnut_present", return_value=True):
      validate_active_bundles(params, catalog)
    params.remove.assert_called_once_with("ModelManager_ActiveBundle")
    runner_puts = [call for call in params.put.call_args_list if call.args[0] == "ModelRunnerTypeCache"]
    assert [call.args[1] for call in runner_puts] == [tinygrad]
 class TestActiveBundleSelection(OpenpilotTestCase):
  """The effective active bundle is the active source's slot: chestnut when a GPU is
  present, qcom otherwise. An empty active slot means the hardware default (stock
  runner), never the other slot's pick - modeld_v2 requires a real bundle."""
  @staticmethod
  def _raw_bundle(ref: str) -> dict:
    bundle = custom.ModelManagerSP.ModelBundle.new_message()
    bundle.ref = ref
    bundle.minimumSelectorVersion = 18
    return bundle.to_dict()
  def _params(self, qcom=None, chestnut=None):
    params = mock.MagicMock()
    def get(key, *args, **kwargs):
      if key == "ModelManager_ActiveBundle":
        return qcom
      if key == "ModelManager_ActiveBundleChestnut":
        return chestnut
      return None
    params.get.side_effect = get
    return params
  def test_selected_bundle_is_per_slot(self):
    params = self._params(qcom=self._raw_bundle("small"), chestnut=self._raw_bundle("big"))
    assert get_selected_bundle(params, "qcom").ref == "small"
    assert get_selected_bundle(params, "chestnut").ref == "big"
  def test_no_gpu_uses_qcom_slot(self):
    params = self._params(qcom=self._raw_bundle("small"), chestnut=self._raw_bundle("big"))
    with mock.patch("openpilot.sunnypilot.models.helpers.chestnut_present", return_value=False):
      assert get_active_bundle(params).ref == "small"
  def test_gpu_uses_chestnut_slot(self):
    params = self._params(qcom=self._raw_bundle("small"), chestnut=self._raw_bundle("big"))
    with mock.patch("openpilot.sunnypilot.models.helpers.chestnut_present", return_value=True):
      assert get_active_bundle(params).ref == "big"
  def test_gpu_without_big_selection_is_hardware_default(self):
    params = self._params(qcom=self._raw_bundle("small"), chestnut=None)
    with mock.patch("openpilot.sunnypilot.models.helpers.chestnut_present", return_value=True):
      assert get_active_bundle(params) is None
 class TestEffectiveSource(OpenpilotTestCase):
  """One gate decides the active source. With no flags it is runtime truth (GPU
  attached); display callers (mici) pass the ui_state flags, which additionally
  require the big model to be loading, active, or the device offroad. The active
  bundle is simply the selected bundle of that source."""
  @staticmethod
  def _raw_bundle(ref: str) -> dict:
    bundle = custom.ModelManagerSP.ModelBundle.new_message()
    bundle.ref = ref
    bundle.minimumSelectorVersion = 18
    return bundle.to_dict()
  def test_runtime_no_gpu(self):
    with mock.patch("openpilot.sunnypilot.models.helpers.chestnut_present", return_value=False):
      assert get_active_source() == "qcom"
  def test_runtime_gpu_present(self):
    with mock.patch("openpilot.sunnypilot.models.helpers.chestnut_present", return_value=True):
      assert get_active_source() == "chestnut"
  def test_display_offroad_gpu_present_shows_big(self):
    assert get_active_source(chestnut=True, chestnut_active=False, chestnut_loading=False, offroad=True) == "chestnut"
  def test_display_onroad_gpu_loading_shows_big(self):
    assert get_active_source(chestnut=True, chestnut_active=False, chestnut_loading=True, offroad=False) == "chestnut"
  def test_display_onroad_gpu_active_shows_big(self):
    assert get_active_source(chestnut=True, chestnut_active=True, chestnut_loading=False, offroad=False) == "chestnut"
  def test_display_onroad_gpu_idle_shows_small(self):
    assert get_active_source(chestnut=True, chestnut_active=False, chestnut_loading=False, offroad=False) == "qcom"
  def test_display_active_none_is_idle(self):
    assert get_active_source(chestnut=True, chestnut_active=None, chestnut_loading=False, offroad=False) == "qcom"
  def test_active_bundle_follows_source(self):
    params = mock.MagicMock()
    params.get.side_effect = lambda key: {"ModelManager_ActiveBundle": self._raw_bundle("small"),
                                          "ModelManager_ActiveBundleChestnut": self._raw_bundle("big")}.get(key)
    with mock.patch("openpilot.sunnypilot.models.helpers.chestnut_present", return_value=False):
      assert get_active_bundle(params).ref == "small"
    assert get_selected_bundle(params, get_active_source(chestnut=True, chestnut_active=False,
                                                         chestnut_loading=False, offroad=True)).ref == "big"
@unittest.skipUnless(os.environ.get('RUN_INTEGRATION_TESTS'), 'requires external network')
 class TestLiveModelManifest(OpenpilotTestCase):
  """Every artifact and chunk URL in the published manifest must resolve."""
@@ -1,11 +1,13 @@
 import requests
 from openpilot.common.params import Params
 from openpilot.sunnypilot.models.tinygrad_ref import get_tinygrad_ref
 from openpilot.sunnypilot.models.fetcher import ModelFetcher
 from openpilot.common.test import OpenpilotTestCase
 def fetch_tinygrad_ref():
-  response = requests.get(ModelFetcher.MODEL_URL, timeout=10)
+  fetcher = ModelFetcher(Params())
  response = requests.get(fetcher.model_url, timeout=10)
  response.raise_for_status()
  json_data = response.json()
  return json_data.get("tinygrad_ref")
@@ -1,3 +0,0 @@
 version https://git-lfs.github.com/spec/v1
 oid sha256:447099e93e303b29e7b3eac237bb0f27f8c5e12786991139aee2432532a75f58
 size 12310
@@ -83,14 +83,9 @@ class TestLocationdProc(OpenpilotTestCase):
      self.pm.send(msg.which(), msg)
      if msg.which() == "cameraOdometry":
        self.pm.wait_for_readers_to_update(msg.which(), timeout=1, dt=0.005)
-    for _ in range(50):
+    time.sleep(1)  # wait for async params write
      val = self.params.get('LastGPSPositionLLK')
      if val is not None:
        break
      time.sleep(0.1)
-    self.assertIsNotNone(val, "LastGPSPositionLLK not written within 5s")
+    lastGPS = json.loads(self.params.get('LastGPSPositionLLK'))
    lastGPS = json.loads(val)
    self.assertAlmostEqual(lastGPS['latitude'], self.lat, delta=0.001)
    self.assertAlmostEqual(lastGPS['longitude'], self.lon, delta=0.001)
    self.assertAlmostEqual(lastGPS['altitude'], self.alt, delta=0.001)
@@ -28,7 +28,7 @@ from websocket import (ABNF, WebSocket, WebSocketException, WebSocketTimeoutExce
                       create_connection, WebSocketConnectionClosedException)
 import openpilot.cereal.messaging as messaging
-from openpilot.sunnypilot.models.model_name import DEFAULT_MODEL, DEFAULT_BIG_MODEL
+from openpilot.sunnypilot.models.default_model import DEFAULT_MODEL
 from openpilot.sunnypilot.selfdrive.car.sync_sunnylink_params import update_car_list_param
 from openpilot.sunnypilot.sunnylink.api import SunnylinkApi
 from openpilot.sunnypilot.sunnylink.utils import sunnylink_need_register, sunnylink_ready, get_param_as_byte, save_param_from_base64_encoded_string
@@ -182,8 +182,6 @@ def getParamsMetadata() -> str:
    schema["capabilities"] = generate_capabilities()
    schema["capability_labels"] = CAPABILITY_LABELS
    schema["default_model"] = DEFAULT_MODEL
    schema["default_big_model"] = DEFAULT_BIG_MODEL
    schema["chestnut_active"] = params.get_bool("ChestnutActive")
    raw = json.dumps(schema, separators=(",", ":")).encode("utf-8")
    return base64.b64encode(gzip.compress(raw)).decode("utf-8")
  except Exception:
@@ -65,7 +65,6 @@ def sp_stats(end_event):
    'MadsSteeringMode',
    'MadsUnifiedEngagementMode',
    'ModelManager_ActiveBundle',
    'ModelManager_ActiveBundleChestnut',
    'ModelManager_Favs',
    'EnableSunnylinkUploader',
    'SunnylinkEnabled',
@@ -84,25 +84,6 @@ def _migrate_tesla_mads_screen_button(_params):
    cloudlog.exception(f"Error migrating TeslaMadsScreenButton: {e}")
 def _migrate_model_bundle_slots(_params):
  # Pre-split, a chestnut user's big-model selection lived in the single
  # ActiveBundle. Seed both slots; validation drops whichever does not match
  # its own manifest.
  try:
    if _params.get("ModelManager_ActiveBundleChestnut") is not None:
      return
    if (chestnut_bundle := _params.get("ModelManager_ActiveBundleUSBGPU")) is not None:
      _params.put("ModelManager_ActiveBundleChestnut", chestnut_bundle, block=True)
      cloudlog.info("params_migration: seeded ModelManager_ActiveBundleChestnut from ModelManager_ActiveBundleUSBGPU")
      return
    if (bundle := _params.get("ModelManager_ActiveBundle")) is None:
      return
    _params.put("ModelManager_ActiveBundleChestnut", bundle, block=True)
    cloudlog.info("params_migration: seeded ModelManager_ActiveBundleChestnut from ModelManager_ActiveBundle")
  except Exception as e:
    cloudlog.exception(f"Error migrating model bundle slots: {e}")
 def run_migration(_params):
  # migrate OnroadScreenOffBrightness
  if _params.get("OnroadScreenOffBrightnessMigrated") != ONROAD_BRIGHTNESS_MIGRATION_VERSION:
@@ -139,6 +120,3 @@ def run_migration(_params):
  # seed TeslaMadsScreenButton for existing Tesla installs
  _migrate_tesla_mads_screen_button(_params)
  # seed the chestnut model slot from the pre-split single slot
  _migrate_model_bundle_slots(_params)
@@ -1,36 +0,0 @@
 """
 Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 from openpilot.common.params import Params
 from openpilot.common.test import OpenpilotTestCase
 from openpilot.sunnypilot.system.params_migration import _migrate_model_bundle_slots
 class TestModelBundleSlotMigration(OpenpilotTestCase):
  """Pre-split, a chestnut user's big-model selection lived in the single ActiveBundle.
  The migration seeds both slots; per-source validation later drops whichever does not
  match its own manifest."""
  def test_seeds_chestnut_slot_from_active_bundle(self):
    params = Params()
    bundle = {"ref": "big", "minimumSelectorVersion": 18}
    params.put("ModelManager_ActiveBundle", bundle, block=True)
    _migrate_model_bundle_slots(params)
    assert params.get("ModelManager_ActiveBundleChestnut") == bundle
    assert params.get("ModelManager_ActiveBundle") == bundle
  def test_noop_when_chestnut_slot_already_set(self):
    params = Params()
    params.put("ModelManager_ActiveBundle", {"ref": "small"}, block=True)
    params.put("ModelManager_ActiveBundleChestnut", {"ref": "big"}, block=True)
    _migrate_model_bundle_slots(params)
    assert params.get("ModelManager_ActiveBundleChestnut") == {"ref": "big"}
  def test_noop_when_no_selection(self):
    params = Params()
    _migrate_model_bundle_slots(params)
    assert params.get("ModelManager_ActiveBundleChestnut") is None
@@ -828,22 +828,20 @@ def startStream(sdp: str, enabled: bool) -> dict:
  bridge_services_in = []
  # stale car params case taken care of by webrtcd being shut off on ignition
-  cp_bytes = params.get("CarParamsPersistent")
+  cp_bytes = Params().get("CarParamsPersistent")
  if cp_bytes is not None:
    with car.CarParams.from_bytes(cp_bytes) as CP:
      if CP.notCar:
        bridge_services_in.append("testJoystick")
  else:
    raise Exception("failed to get CarParamsPersistent")
  if params.get_bool("IsOffroad"):
    # manager owns camerad/stream_encoderd/webrtcd; flip the param and let it bring them up.
    # webrtcd clears IsLiveStreaming when the session ends
    params.put_bool("IsLiveStreaming", True)
    # wait for webrtcd end points to wake up
-    try:
+    wait_for_webrtcd()
      wait_for_webrtcd()
    except TimeoutError:
      cloudlog.event("athena.startStream.webrtcd_offroad_start_timeout", error=True)
      raise
  return post_stream_request(StreamRequestBody(sdp, ["wideRoad"], enabled, bridge_services_in, ["carState", "deviceState"]))
@@ -16,7 +16,6 @@ from openpilot.common.utils import strip_deprecated_keys
 from openpilot.common.filter_simple import FirstOrderFilter
 from openpilot.common.params import Params
 from openpilot.common.realtime import DT_HW
 from openpilot.selfdrive.modeld.helpers import MODELS_DIR, chestnut_compiled
 from openpilot.selfdrive.selfdrived.alertmanager import set_offroad_alert
 from openpilot.common.hardware import HARDWARE, COMMA_HARDWARE
 from openpilot.common.basedir import BASEDIR
@@ -27,7 +26,7 @@ from openpilot.common.swaglog import cloudlog
 from openpilot.sunnypilot.system.statsd import statlog
 from openpilot.system.hardware.power_monitoring import PowerMonitoring
 from openpilot.system.hardware.fan_controller import FanController
-from openpilot.common.version import terms_version, training_version, get_build_metadata, terms_version_sp, CHESTNUT_BRANCHES
+from openpilot.common.version import terms_version, training_version, get_build_metadata, terms_version_sp
 ThermalStatus = log.DeviceState.ThermalStatus
@@ -239,7 +238,8 @@ def hardware_thread(end_event, hw_queue) -> None:
  fan_controller = FanController(int(1./DT_HW))
  chestnut = Chestnut()
-  big_model_available = (MODELS_DIR / 'big_driving_supercombo.onnx').is_file() or chestnut_compiled()
+  big_model_available = os.path.isfile(os.path.join(BASEDIR, "openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx")) or \
                        os.path.isfile(os.path.join(BASEDIR, "openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl.chunkmanifest"))
  while not end_event.is_set():
    sm.update(PANDA_STATES_TIMEOUT)
@@ -301,11 +301,7 @@ def hardware_thread(end_event, hw_queue) -> None:
    set_usb_state(msg.deviceState, last_hw_state.usb_state)
    chestnut.update(started_ts is None, last_hw_state.usb_state)
-    current_channel = get_build_metadata().channel
+    set_offroad_alert_if_changed("Offroad_ChestnutBranch", msg.deviceState.chestnutPresent and not big_model_available)
    chestnut_target = CHESTNUT_BRANCHES.get(current_channel)
    chestnut_needs_switch = msg.deviceState.chestnutPresent and not big_model_available and chestnut_target is not None
    set_offroad_alert_if_changed("Offroad_ChestnutBranch", chestnut_needs_switch,
                                 extra_text=chestnut_target if chestnut_needs_switch else None)
    # this subset is only used for offroad
    temp_sources = [
@@ -0,0 +1,40 @@
 #!/usr/bin/env bash
 # Define the service name
 SERVICE_NAME="actions.runner.sunnypilot.$(uname -n)"
 # Function to control the service
 control_service() {
    local action=$1  # Store the function argument in a local variable
    sudo systemctl $action ${SERVICE_NAME}
 }
 service_exists_and_is_loaded() {
    sudo systemctl status ${SERVICE_NAME} &>/dev/null
    if [[ $? -ne 4 ]]; then
        return 0  # Service is known to systemd (i.e., loaded)
    else
        return 1  # Service is unknown to systemd (i.e., not loaded)
    fi
 }
 # Check for required argument
 if [[ -z $1 ]] || { [[ $1 != "start" ]] && [[ $1 != "stop" ]]; }; then
    echo "Usage: $0 {start|stop}"
    exit 1
 fi
 # Store the script argument in a descriptive variable
 ACTION=$1
 # Trap EXIT signal (Ctrl+C) and stop the service
 trap 'control_service stop ; exit' SIGINT SIGKILL EXIT
 # Enter the main loop
 while true; do
    # Check if the service is actually present on the system
    if service_exists_and_is_loaded; then
        control_service $ACTION  # Call the function with the specified action
    fi
    sleep 1  # Pause before the next iteration
 done
@@ -68,6 +68,10 @@ def only_offroad(started: bool, params: Params, CP: car.CarParams) -> bool:
 def livestream(started: bool, params: Params, CP: car.CarParams) -> bool:
  return params.get_bool("IsLiveStreaming")
 def use_github_runner(started, params, CP: car.CarParams) -> bool:
  return not PC and params.get_bool("EnableGithubRunner") and (
    not params.get_bool("NetworkMetered") and not params.get_bool("GithubRunnerSufficientVoltage"))
 def use_copyparty(started, params, CP: car.CarParams) -> bool:
  return bool(params.get_bool("EnableCopyparty"))
@@ -106,12 +110,15 @@ def or_(*fns):
 def and_(*fns):
  return lambda *args: operator.and_(*(fn(*args) for fn in fns))
 def not_(*fns):
  return lambda *args: operator.not_(*(fn(*args) for fn in fns))
 procs = [
  DaemonProcess("manage_athenad", "openpilot.system.athena.manage_athenad", "AthenadPid"),
  NativeProcess("loggerd", "openpilot/system/loggerd", ["./loggerd"], logging),
  NativeProcess("encoderd", "openpilot/system/loggerd", ["./encoderd"], only_onroad),
-  NativeProcess("stream_encoderd", "openpilot/system/loggerd", ["./encoderd", "--stream"], or_(livestream, notcar)),
+  NativeProcess("stream_encoderd", "openpilot/system/loggerd", ["./encoderd", "--stream"], or_(and_(livestream, not_(iscar)), notcar)),
  PythonProcess("logmessaged", "openpilot.system.logmessaged", always_run),
  NativeProcess("camerad", "openpilot/system/camerad", ["./camerad"], or_(driverview, livestream), enabled=not WEBCAM),
@@ -156,7 +163,7 @@ procs = [
  # debug procs
  NativeProcess("bridge", "openpilot/cereal/messaging", ["./bridge"], notcar),
-  PythonProcess("webrtcd", "openpilot.system.webrtc.webrtcd", or_(livestream, notcar)),
+  PythonProcess("webrtcd", "openpilot.system.webrtc.webrtcd", or_(and_(livestream, not_(iscar)), notcar)),
  PythonProcess("joystick", "openpilot.tools.joystick.joystick_control", and_(joystick, iscar)),
  # sunnylink <3
@@ -182,6 +189,10 @@ procs += [
  NativeProcess("locationd_llk", "openpilot/sunnypilot/selfdrive/locationd", ["./locationd"], only_onroad),
 ]
 if os.path.exists("./github_runner.sh"):
  procs += [NativeProcess("github_runner_start", "openpilot/system/manager",
                          ["./github_runner.sh", "start"], and_(only_offroad, use_github_runner), sigkill=False)]
 if os.path.exists("../../sunnypilot/sunnylink/uploader.py"):
  procs += [PythonProcess("sunnylink_uploader", "openpilot.sunnypilot.sunnylink.uploader", use_sunnylink_uploader_shim)]
@@ -4,29 +4,7 @@ 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 collections.abc import Callable
 import pyray as rl
 from openpilot.system.ui.lib.application import gui_app, FontWeight
 from openpilot.system.ui.sunnypilot.lib.styles import style
 from openpilot.system.ui.sunnypilot.widgets.list_view import ButtonActionSP
 from openpilot.system.ui.widgets.label import ScrollState, UnifiedLabel
 from openpilot.system.ui.widgets.list_view import BUTTON_WIDTH, BUTTON_HEIGHT, TEXT_PADDING, _resolve_value
 SCROLL_SPEED = 1.2  # stock is 0.8, boosted 50% to compensate for larger font (50 vs 32)
 SCROLL_REFERENCE_FPS = 60.
 class UnifiedLabelSP(UnifiedLabel):
  # stock scroll formula (0.8 / 60 * fps) is inverted — pre-correct so speed is constant px/sec
  def _render(self, _):
    if self._needs_scroll and self._scroll_state == ScrollState.SCROLLING:
      fps = gui_app.target_fps
      wrong_step = 0.8 / SCROLL_REFERENCE_FPS * fps
      correct_step = SCROLL_SPEED * SCROLL_REFERENCE_FPS / fps
      self._scroll_offset -= (correct_step - wrong_step)
    super()._render(_)
 class NoElideButtonAction(ButtonActionSP):
@@ -34,36 +12,6 @@ class NoElideButtonAction(ButtonActionSP):
    return super().get_width_hint() + 1
 class ScrollingButtonAction(ButtonActionSP):
  def __init__(self, text: str | Callable[[], str], width: int = style.BUTTON_ACTION_WIDTH,
               enabled: bool | Callable[[], bool] = True):
    super().__init__(text=text, width=width, enabled=enabled)
    self._value_label = UnifiedLabelSP("", font_size=style.ITEM_TEXT_FONT_SIZE, font_weight=FontWeight.NORMAL,
                                       text_color=self._value_color, scroll=True,
                                       alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_MIDDLE)
  def set_value(self, value: str | Callable[[], str], color: rl.Color = style.ITEM_TEXT_VALUE_COLOR):
    if self.value != _resolve_value(value, ""):
      self._value_label.reset_scroll()
    super().set_value(value, color)
    self._value_label.set_text(value)
    self._value_label.set_text_color(color)
  def _render(self, rect: rl.Rectangle) -> bool:
    """Duplicate of ButtonActionSP._render, with the value drawn by a scrolling label"""
    self._button.set_text(self.text)
    self._button.set_enabled(_resolve_value(self.enabled))
    button_rect = rl.Rectangle(rect.x + rect.width - BUTTON_WIDTH, rect.y + (rect.height - BUTTON_HEIGHT) / 2, BUTTON_WIDTH, BUTTON_HEIGHT)
    self._button.render(button_rect)
    if self.value:
      self._value_label.render(rl.Rectangle(rect.x, rect.y, rect.width - BUTTON_WIDTH - TEXT_PADDING, rect.height))
    pressed = self._pressed
    self._pressed = False
    return pressed
 class AlertFadeAnimator:
  def __init__(self, target_fps: int, duration_on: float = 0.75, rc: float = 0.05):
    from openpilot.common.filter_simple import FirstOrderFilter
@@ -1,211 +0,0 @@
 """
 Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 import math
 import numpy as np
 import pyray as rl
 from openpilot.common.filter_simple import FirstOrderFilter
 from openpilot.system.ui.lib.application import gui_app, FontWeight
 from openpilot.system.ui.lib.shader_polygon import draw_polygon, Gradient
 from openpilot.system.ui.lib.text_measure import measure_text_cached
 from openpilot.system.ui.sunnypilot.lib.styles import style
 from openpilot.system.ui.sunnypilot.widgets.list_view import ListItemSP
 from openpilot.system.ui.widgets.label import UnifiedLabel
 from openpilot.system.ui.sunnypilot.lib.utils import UnifiedLabelSP
 from openpilot.system.ui.widgets.list_view import ItemAction
 FONT_SIZE = style.ITEM_TEXT_FONT_SIZE
 ICON_SIZE = 56
 ICON_PADDING = 12
 BAR_WIDTH = 1100
 BAR_HEIGHT = 20
 SEGMENT_GAP = 24
 SEGMENT_NAME_MAX_WIDTH = 380
 BAR_GAP = 16
 BAR_RADIUS = BAR_HEIGHT / 2
 CAPSULE_POINTS = 24
 RAIL_COLOR = rl.Color(60, 60, 60, 255)
 FILL_COLOR = rl.Color(30, 121, 232, 255)
 # rl.WHITE is a tuple; the shimmer path reads .a off the color
 TEXT_COLOR = rl.Color(255, 255, 255, 255)
 SWEEP_SPEED = 550.0  # px/s
 SWEEP_BAND = 240.0   # highlight half-width, px
 SWEEP_DIM = 0.65
 class DownloadStatusAction(ItemAction):
  """Model download row: a name + percent over a progress rail while downloading, a name + icon otherwise."""
  def __init__(self):
    super().__init__(width=BAR_WIDTH)
    self.name = ""
    self.status_text = ""
    self.segments: list[tuple[str, rl.Color, str | None, rl.Color | None]] | None = None
    self._segment_labels: list[UnifiedLabelSP] = []
    self.downloading = False
    self.text_color = rl.GRAY
    self.icon: str | None = None
    self.icon_color: rl.Color | None = None
    self._font = gui_app.font(FontWeight.NORMAL)
    # raw progress arrives in steps, one per 128KB chunk the manager publishes
    self._progress = FirstOrderFilter(0.0, 0.5, 1 / gui_app.target_fps)
    # integrated per frame; (t * speed) % span jumps whenever the fill width changes
    self._sweep = 0.0
    self._name_label = UnifiedLabel("", font_size=FONT_SIZE, font_weight=FontWeight.NORMAL, text_color=TEXT_COLOR,
                                    alignment=rl.GuiTextAlignment.TEXT_ALIGN_LEFT,
                                    alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_MIDDLE)
    self._percent_label = UnifiedLabel("", font_size=FONT_SIZE, font_weight=FontWeight.NORMAL, text_color=TEXT_COLOR,
                                       alignment=rl.GuiTextAlignment.TEXT_ALIGN_RIGHT,
                                       alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_MIDDLE)
  def update(self, name, downloading=False, progress=0.0, status_text="", text_color=rl.GRAY, icon=None, icon_color=None, segments=None):
    self.segments = segments
    if downloading and not self.downloading:
      self._name_label.reset_shimmer()
      self._progress.x = progress
      self._sweep = 0.0
    self.name = name
    self.downloading = downloading
    self.status_text = status_text
    self.text_color = text_color
    self.icon = icon
    self.icon_color = icon_color
    self._name_label._shimmer = downloading
    if downloading:
      self._progress.update(progress)
      self._sweep += SWEEP_SPEED / gui_app.target_fps
  @property
  def _idle_text(self) -> str:
    return f"{self.name} - {self.status_text}" if self.status_text else self.name
  def get_width_hint(self) -> float:
    if self.downloading:
      return BAR_WIDTH
    if self.segments:
      return sum(total for _, _, total in self._measured_segments())
    width = measure_text_cached(self._font, self._idle_text, FONT_SIZE).x
    if self.icon:
      width += ICON_SIZE + ICON_PADDING
    return width
  def _measured_segments(self):
    """[(segment, text width, total width incl. icon and gap)]"""
    out = []
    for i, seg in enumerate(self.segments or []):
      text_width = min(measure_text_cached(self._font, seg[0], FONT_SIZE).x, SEGMENT_NAME_MAX_WIDTH)
      total = text_width + (ICON_PADDING + ICON_SIZE if seg[2] else 0) + (SEGMENT_GAP if i else 0)
      out.append((seg, text_width, total))
    return out
  def _render(self, rect: rl.Rectangle):
    if self.downloading:
      self._render_downloading(rect)
    else:
      self._render_idle(rect)
  def _sweep_gradient(self, width: float) -> Gradient:
    # clearance at both ends keeps the wrap offscreen
    center = (self._sweep % (width + 2 * SWEEP_BAND)) - SWEEP_BAND
    def band(x: float) -> float:
      return max(0.0, 1.0 - abs(x - center) / SWEEP_BAND)
    # sampling the corners is exact for a piecewise linear band
    xs = sorted({0.0, width} | {min(max(center + o, 0.0), width) for o in (-SWEEP_BAND, 0.0, SWEEP_BAND)}, reverse=True)
    # the gradient axis runs right-to-left in screen space
    stops = [1.0 - x / width for x in xs]
    # alpha here is the lift over the SWEEP_DIM base, not the final opacity
    colors = [rl.Color(FILL_COLOR.r, FILL_COLOR.g, FILL_COLOR.b, int(255 * band(x))) for x in xs]
    return Gradient(start=(0.0, 0.0), end=(1.0, 0.0), colors=colors, stops=stops)
  @staticmethod
  def _capsule(rect: rl.Rectangle) -> np.ndarray:
    """Rounded-end ribbon so the gradient covers the caps."""
    r = rect.height / 2
    cy = rect.y + r
    top, bottom = [], []
    for i in range(CAPSULE_POINTS):
      x = rect.x + rect.width * i / (CAPSULE_POINTS - 1)
      d = min(x - rect.x, rect.x + rect.width - x, r)
      h = math.sqrt(max(r * r - (r - d) ** 2, 0.0))
      top.append((x, cy - h))
      bottom.append((x, cy + h))
    return np.array(top + bottom[::-1], dtype=np.float32)
  def _draw_fill(self, rail: rl.Rectangle, fill_width: float):
    if fill_width <= 0:
      return
    fill = rl.Rectangle(rail.x, rail.y, fill_width, rail.height)
    rl.draw_rectangle_rounded(fill, 1.0, 10, rl.Color(FILL_COLOR.r, FILL_COLOR.g, FILL_COLOR.b, int(255 * SWEEP_DIM)))
    draw_polygon(fill, self._capsule(fill), gradient=self._sweep_gradient(fill_width))
  def _render_downloading(self, rect: rl.Rectangle):
    percent = f"{int(self._progress.x)}%"
    if self.status_text:
      percent = f"{self.status_text} {percent}"
    text_height = measure_text_cached(self._font, percent, FONT_SIZE).y
    top = rect.y + (rect.height - (text_height + BAR_GAP + BAR_HEIGHT)) / 2
    text_rect = rl.Rectangle(rect.x, top, rect.width, text_height)
    self._name_label.set_text(self.name)
    self._name_label.render(text_rect)
    self._percent_label.set_text(percent)
    self._percent_label.render(text_rect)
    rail = rl.Rectangle(rect.x, top + text_height + BAR_GAP, rect.width, BAR_HEIGHT)
    rl.draw_rectangle_rounded(rail, 1.0, 10, RAIL_COLOR)
    self._draw_fill(rail, max(0.0, min(rect.width, rect.width * (self._progress.x / 100.0))))
  def _render_idle(self, rect: rl.Rectangle):
    if self.segments:
      self._render_segments(rect)
      return
    text = self._idle_text
    text_size = measure_text_cached(self._font, text, FONT_SIZE)
    right = rect.x + rect.width
    if self.icon:
      texture = gui_app.texture(self.icon, ICON_SIZE, ICON_SIZE, keep_aspect_ratio=True)
      rl.draw_texture_v(texture, rl.Vector2(right - texture.width, rect.y + (rect.height - texture.height) / 2),
                        self.icon_color or self.text_color)
      right -= texture.width + ICON_PADDING
    rl.draw_text_ex(self._font, text, rl.Vector2(right - text_size.x, rect.y + (rect.height - text_size.y) / 2),
                    FONT_SIZE, 0, self.text_color)
  def _render_segments(self, rect: rl.Rectangle):
    measured = self._measured_segments()
    while len(self._segment_labels) < len(measured):
      self._segment_labels.append(UnifiedLabelSP("", font_size=FONT_SIZE, max_width=SEGMENT_NAME_MAX_WIDTH,
                                                 scroll=True, wrap_text=False))
    x = rect.x + rect.width - sum(total for _, _, total in measured)
    for i, ((text, color, icon, icon_color), text_width, _) in enumerate(measured):
      if i:
        x += SEGMENT_GAP
      label = self._segment_labels[i]
      if label.text != text:
        label.set_text(text)
      label.set_text_color(color)
      text_height = measure_text_cached(self._font, text, FONT_SIZE).y
      label.set_position(x, rect.y + (rect.height - text_height) / 2)
      label.render()
      x += text_width
      if icon:
        texture = gui_app.texture(icon, ICON_SIZE, ICON_SIZE, keep_aspect_ratio=True)
        rl.draw_texture_v(texture, rl.Vector2(x + ICON_PADDING, rect.y + (rect.height - texture.height) / 2),
                          icon_color or color)
        x += ICON_PADDING + ICON_SIZE
 def download_status_item(title):
  return ListItemSP(title=title, action_item=DownloadStatusAction(), title_color=style.ITEM_TEXT_COLOR)
@@ -23,9 +23,9 @@ def post_stream_request(body: StreamRequestBody) -> dict:
    ret["time"] = (t_end - t_start) * 1000
    return ret
  except requests.ConnectTimeout as e:
-    raise Exception("device took too long to respond.") from e
+    raise Exception("webrtc took too long to respond.") from e
  except requests.ConnectionError as e:
-    raise Exception("turn car ignition off to use livestreaming.") from e
+    raise Exception("webrtc server on device is not running.") from e
 def wait_for_webrtcd(max_retries: float = 10) -> None:
@@ -37,4 +37,4 @@ def wait_for_webrtcd(max_retries: float = 10) -> None:
    except requests.ConnectionError:
      attempts += 1
      time.sleep(0.5)
-  raise TimeoutError("livestreaming service did not initialize in time.")
+  raise TimeoutError("webrtcd did not initialize in time.")
@@ -7,7 +7,7 @@ from openpilot.common.test import OpenpilotTestCase
 from openpilot.cereal import messaging, log
 from teleoprtc.tracks import VIDEO_CLOCK_RATE
-from openpilot.system.webrtc.webrtcd import CerealOutgoingMessageProxy, CerealIncomingMessageProxy, ServerState, handle_get_stream
+from openpilot.system.webrtc.webrtcd import CerealOutgoingMessageProxy, CerealIncomingMessageProxy
 from openpilot.system.webrtc.device.video import LiveStreamVideoStreamTrack
@@ -80,8 +80,3 @@ class TestStreamSession(OpenpilotTestCase):
        start_pts = packet.pts
      assert abs(i + packet.pts - (start_pts + (((time.monotonic_ns() - start_ns) * VIDEO_CLOCK_RATE) // 1_000_000_000))) < 450 #5ms
      assert bytes(packet) == b""
  def test_stream_rejects_non_json_content_type(self):
    response = self.loop.run_until_complete(handle_get_stream(ServerState(), b"{}", "text/plain"))
    assert response == (415, b'{"error": "unsupported media type"}', "application/json; charset=utf-8")
@@ -21,16 +21,10 @@ from typing import Any
 from openpilot.system.webrtc.helpers import StreamRequestBody
 from openpilot.system.webrtc.schema import generate_field
 from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
 from openpilot.cereal import messaging, log
 SESSION_TIMEOUT_SECONDS = 300
 # ice candidate parser for logging
 def _ice_candidates(sdp: str) -> list[str]:
  return [line.removeprefix("a=") for line in sdp.splitlines() if line.startswith("a=candidate:")]
 # socket trick: route lookup for 8.8.8.8 (nothing is sent or actually connected to)
 # return the source interfaces IP which is the default interface of the device
 def _default_route_ip() -> str | None:
@@ -259,7 +253,7 @@ class StreamSession:
    self._cleanup_lock = asyncio.Lock()
    self._cleanup_done = False
    self.logger = logging.getLogger("webrtcd")
-    cloudlog.warning(
+    self.logger.info(
      "New stream session (%s), video cameras %s, video enabled %s, incoming services %s, outgoing services %s",
      self.identifier, [t.id for t in self.video_tracks], body.enabled, body.bridge_services_in, body.bridge_services_out,
    )
@@ -335,12 +329,9 @@ class StreamSession:
  async def run(self):
    try:
      self.params.put("LivestreamRequestKeyframe", True)
      # avoid datachannel race by adding messange_handler immediately
      self.stream.set_message_handler(self.message_handler)
      await asyncio.wait_for(self.stream.wait_for_connection(), timeout=15)
      if self.stream.has_messaging_channel():
        self.stream.set_message_handler(self.message_handler)
        if self.incoming_bridge is not None:
          await self.shared_pub_master.add_services_if_needed(self.incoming_bridge_services)
        if self.outgoing_bridge is not None:
@@ -350,18 +341,14 @@ class StreamSession:
      if self.bitrate_controller is not None:
        self.bitrate_controller.start()
-      with cloudlog.ctx(session_id=self.identifier):
+      self.logger.info("Stream session (%s) connected", self.identifier)
        cloudlog.warning("webrtcd.session.connected")
      if self.is_body:
        await self.run_body_session()
      else:
        await self.run_normal_session()
-      with cloudlog.ctx(session_id=self.identifier):
+      self.logger.info("Stream session (%s) ended", self.identifier)
        cloudlog.warning("webrtcd.session.ended")
    except Exception:
      self.logger.exception("Stream session failure")
      with cloudlog.ctx(session_id=self.identifier):
        cloudlog.exception("webrtcd.session.exception")
    finally:
      await self.post_run_cleanup()
@@ -408,10 +395,7 @@ def _text_response(text: str, status: int = 200) -> tuple[int, bytes, str]:
  return (status, text.encode(), "text/plain; charset=utf-8")
-async def handle_get_stream(state: ServerState, raw_body: bytes, content_type: str) -> tuple[int, bytes, str]:
+async def handle_get_stream(state: ServerState, raw_body: bytes) -> tuple[int, bytes, str]:
  if content_type != "application/json":
    return _json_response({"error": "unsupported media type"}, status=415)
  stream_dict = state.streams
  body = StreamRequestBody(**json.loads(raw_body))
@@ -435,25 +419,15 @@ async def handle_get_stream(state: ServerState, raw_body: bytes, content_type: s
    stream_dict[session.identifier] = session
    try:
      answer = await asyncio.wait_for(session.get_answer(), timeout=30)
      cloudlog.event(
        "webrtcd.session.ice_candidates",
        session_id=session.identifier,
        offer_candidates=_ice_candidates(body.sdp),
        answer_candidates=_ice_candidates(answer.sdp),
      )
    except TimeoutError:
      await session.stop()
      stream_dict.pop(session.identifier, None)
      logging.getLogger("webrtcd").exception("Timed out creating stream answer")
      with cloudlog.ctx(session_id=session.identifier):
        cloudlog.warning("webrtcd.session.answer_timeout")
      raise
    except Exception:
      await session.stop()
      stream_dict.pop(session.identifier, None)
      logging.getLogger("webrtcd").exception("Failed to create stream answer")
      with cloudlog.ctx(session_id=session.identifier):
        cloudlog.exception("webrtcd.session.answer_exception")
      raise
    session.start()
@@ -534,7 +508,7 @@ class WebrtcdHandler(BaseHTTPRequestHandler):
        services = parse_qs(parsed.query).get("services", [""])[0]
        result = self._run(handle_get_schema(self.server.state, services))
      elif parsed.path == "/stream":
-        result = self._run(handle_get_stream(self.server.state, self._read_body(), self.headers.get_content_type()))
+        result = self._run(handle_get_stream(self.server.state, self._read_body()))
      else:  # /notify
        try:
          payload = json.loads(self._read_body())
@@ -637,7 +611,7 @@ def webrtcd_thread(host: str, port: int):
 def main():
  parser = argparse.ArgumentParser(description="WebRTC daemon")
-  parser.add_argument("--host", type=str, default="127.0.0.1", help="Host to listen on")
+  parser.add_argument("--host", type=str, default="0.0.0.0", help="Host to listen on")
  parser.add_argument("--port", type=int, default=5001, help="Port to listen on")
  args = parser.parse_args()
@@ -21,7 +21,7 @@ dependencies = [
  "tqdm",         # cars (fw_versions.py) on start + many one-off uses
  # core
-  "scons==4.10.1",  # 4.11 removed the qt3 tool still used to build Cabana
+  "scons",
  "pycapnp==2.1.0",  # 2.2 introduces a memory leak due to cyclic references
  "numpy >=2.0",
@@ -0,0 +1,260 @@
 #!/usr/bin/env bash
 set -e
 # Default values
 DEFAULT_REPO_URL="https://github.com/sunnypilot"
 START_AT_BOOT=false
 RESTORE_MODE=false
 RUNNER_VERSION="2.325.0"
 # Parse command line arguments
 while [[ $# -gt 0 ]]; do
    case $1 in
        --start-at-boot)
            START_AT_BOOT=true
            shift
            ;;
        --token)
            GITHUB_TOKEN="$2"
            shift 2
            ;;
        --repo)
            REPO_URL="$2"
            shift 2
            ;;
        --restore)
            RESTORE_MODE=true
            shift
            ;;
        *)
            if [ -z "$GITHUB_TOKEN" ]; then
                GITHUB_TOKEN="$1"
            elif [ -z "$REPO_URL" ]; then
                REPO_URL="$1"
            fi
            shift
            ;;
    esac
 done
 # Determine BASE_DIR based on mount point
 if mountpoint -q /data/media; then
    BASE_DIR="/data/media/0/github"
 else
    BASE_DIR="/data/github"
 fi
 # Constants
 RUNNER_USER="github-runner"
 USER_GROUPS="comma,gpu,gpio,sudo"
 RUNNER_DIR="${BASE_DIR}/runner"
 BUILDS_DIR="${BASE_DIR}/builds"
 LOGS_DIR="${BASE_DIR}/logs"
 CACHE_DIR="${BASE_DIR}/cache"
 OPENPILOT_DIR="${BASE_DIR}/openpilot"
 # Basic utility functions (no dependencies)
 remount_rw() {
    sudo mount -o remount,rw /
 }
 remount_ro() {
    sync || true  # Try to sync but continue even if it fails
    sudo mount -o remount,ro /  # Always try to remount as read-only
 }
 # Always ensure we try to remount as read-only on exit
 trap remount_ro EXIT
 setup_runner_user() {
    sudo useradd --comment 'GitHub Runner' --create-home --home-dir ${BASE_DIR} ${RUNNER_USER} --shell /bin/bash -G ${USER_GROUPS} || sudo usermod -aG ${USER_GROUPS} ${RUNNER_USER}
 }
 create_sudoers_entry() {
    sudo grep -qxF "${RUNNER_USER} ALL=(ALL) NOPASSWD: ALL" /etc/sudoers || echo "${RUNNER_USER} ALL=(ALL) NOPASSWD: ALL" | sudo tee -a /etc/sudoers
 }
 set_directory_permissions() {
    sudo chown -R ${RUNNER_USER}:comma "$BASE_DIR"
    sudo chmod -R g+rwx "$BASE_DIR"
    sudo find "$BASE_DIR" -type d -exec chmod g+s {} +
 }
 setup_directories() {
    echo "Creating necessary directories..."
    sudo mkdir -p "$RUNNER_DIR" "$BUILDS_DIR" "$LOGS_DIR" "$CACHE_DIR" "$OPENPILOT_DIR"
    mkdir -p "/data/openpilot"
    sudo chown -R comma:comma "/data/openpilot"
    sync
 }
 wipe_bash_logout() {
  export BASE_DIR
  sudo -u ${RUNNER_USER} bash -c "touch ${BASE_DIR}/.bash_logout"
  sudo -u ${RUNNER_USER} bash -c "truncate -s 0 '${BASE_DIR}/.bash_logout'"
 }
 # System configuration functions (depends on basic utility functions)
 setup_system_configs() {
    echo "Setting up system configurations..."
    remount_rw
    setup_runner_user
    create_sudoers_entry
    remount_ro
    set_directory_permissions
    wipe_bash_logout
 }
 # Runner setup functions
 install_runner() {
    echo "Downloading and setting up runner..."
    cd "$RUNNER_DIR"
    curl -o actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz -L https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz
    sudo -u ${RUNNER_USER} tar -xzf ./actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz
    sudo rm ./actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz
    sudo chmod +x ./config.sh
 }
 configure_runner() {
    remount_rw
    echo "Configuring runner..."
    cd "$RUNNER_DIR"
    sudo -u ${RUNNER_USER} ./config.sh --url "$REPO_URL" --token "$GITHUB_TOKEN" --name $(hostname) --runnergroup "tici-tizi" --labels "tici" --work "$BUILDS_DIR" --unattended
    remount_ro
 }
 create_service_template() {
    echo "Creating service template..."
    cat <<EOL > "$RUNNER_DIR/bin/actions.runner.service.template"
 [Unit]
 Description={{Description}}
 After=network-online.target nss-lookup.target time-sync.target
 Wants=network-online.target nss-lookup.target time-sync.target
 StartLimitInterval=5
 StartLimitBurst=10
 [Service]
 Type=simple
 User=root
 ExecStart=/usr/bin/unshare -m -- /bin/bash -c 'mount --bind ${OPENPILOT_DIR} /data/openpilot && setpriv --reuid={{User}} --regid={{User}} --init-groups env HOME=${BASE_DIR} USER={{User}} LOGNAME={{User}} MAIL=/var/mail/{{User}} {{RunnerRoot}}/runsvc.sh'
 WorkingDirectory={{RunnerRoot}}
 KillMode=process
 KillSignal=SIGTERM
 TimeoutStopSec=5min
 Restart=always
 RestartSec=120
 [Install]
 WantedBy=multi-user.target
 EOL
 }
 install_service() {
    local service_name
    if [ -f "${RUNNER_DIR}/.service" ]; then
        service_name=$(cat "${RUNNER_DIR}/.service")
    else
        service_name="actions.runner.sunnypilot.$(uname -n)"
    fi
    create_service_template
    remount_rw
    local service_path="/etc/systemd/system/${service_name}"
    echo "Installing systemd service..."
    if [ -f "${service_path}" ]; then
        echo "Service ${service_path} found in systemd, we will delete it"
        sudo rm -f "${service_path}"
    fi
    cd "$RUNNER_DIR"
    sudo ./svc.sh install $RUNNER_USER
    if [ "$START_AT_BOOT" = false ]; then
        sudo systemctl disable "${service_name}"
    fi
    remount_ro
 }
 check_restore_prerequisites() {
    local can_restore=false
    local service_name=""
    # Check if base runner directory exists
    if [ ! -d "${RUNNER_DIR}" ]; then
        echo "ERROR: Runner directory ${RUNNER_DIR} does not exist"
        echo "This directory is required for restore operations"
        exit 1
    fi
    # First check if we have the required files for restoration
    if [ -f "${RUNNER_DIR}/.credentials" ] && [ -f "${RUNNER_DIR}/.service" ]; then
        can_restore=true
        service_name=$(cat "${RUNNER_DIR}/.service")
        echo "Found required runner configuration files"
    else
        echo "Missing required runner configuration files"
        echo "Required: .credentials and .service files in ${RUNNER_DIR}"
        exit 1
    fi
    if ! id "${RUNNER_USER}" &>/dev/null; then
        echo "User ${RUNNER_USER} does not exist"
    fi
    # Only proceed if we can restore AND need to restore
    if [ "$can_restore" = true ]; then
        echo "Restoration is possible"
        return 0
    else
        echo "No restoration possible"
        exit 0
    fi
 }
 perform_restore() {
    echo "Starting runner restoration..."
    setup_directories
    setup_system_configs
    install_service
    echo "Runner restoration completed successfully"
 }
 perform_install() {
    echo "Starting fresh installation..."
    setup_directories
    setup_system_configs
    install_runner
    set_directory_permissions
    configure_runner
    install_service
    echo "Installation completed successfully"
 }
 main() {
    if [ "$RESTORE_MODE" = true ]; then
        echo "Running in restore mode - will only restore system configurations..."
        check_restore_prerequisites
        perform_restore
    else
        # Check required arguments for normal installation
        if [ -z "$GITHUB_TOKEN" ]; then
            echo "Usage: $0 [--start-at-boot] [--token <github_token>] [--repo <repository_url>] [--restore]"
            echo "Required argument (except for --restore): github_token"
            echo "Optional arguments:"
            echo "  --start-at-boot    Enable auto-start at boot (default: false)"
            echo "  --repo            Repository URL (default: ${DEFAULT_REPO_URL})"
            echo "  --restore         Restore existing runner configuration"
            exit 1
        fi
        # Set repository URL if not provided
        REPO_URL="${REPO_URL:-$DEFAULT_REPO_URL}"
        perform_install
    fi
    echo "Starting runner service..."
    cd "$RUNNER_DIR"
    sudo ./svc.sh start
 }
 main
@@ -53,28 +53,24 @@ def create_pkl_name(full_name: str) -> str:
  return pkl
-def _hash_pkl(pkl_path: Path) -> str:
+def _read_pkl_bytes(pkl_path: Path) -> bytes:
  manifest = Path(f"{pkl_path}.chunkmanifest")
  if manifest.exists():
    num_chunks = int(manifest.read_text().strip())
-    paths = [Path(f"{pkl_path}.chunk{i + 1:02d}of{num_chunks:02d}") for i in range(num_chunks)]
+    parts = []
-  else:
+    for i in range(num_chunks):
-    paths = [pkl_path]
+      chunk = Path(f"{pkl_path}.chunk{i + 1:02d}of{num_chunks:02d}")
-
+      parts.append(chunk.read_bytes())
-  digest = hashlib.sha256()
+    return b''.join(parts)
-  for path in paths:
+  return pkl_path.read_bytes()
    with path.open('rb') as f:
      while block := f.read(1024 * 1024):
        digest.update(block)
  return digest.hexdigest()
 def _find_driving_pkl(output_path: Path) -> Path | None:
-  for pattern in ('*driving_tinygrad.pkl', '*driving_*_tinygrad.pkl'):
+  for pattern in ('driving_tinygrad.pkl', 'driving_*_tinygrad.pkl'):
    matches = sorted(output_path.glob(pattern))
    if matches:
      return matches[0]
-  for pattern in ('*driving_tinygrad.pkl.chunkmanifest', '*driving_*_tinygrad.pkl.chunkmanifest'):
+  for pattern in ('driving_tinygrad.pkl.chunkmanifest', 'driving_*_tinygrad.pkl.chunkmanifest'):
    matches = sorted(output_path.glob(pattern))
    if matches:
      return Path(str(matches[0]).removesuffix('.chunkmanifest'))
@@ -90,20 +86,8 @@ def _rename_pkl_with_chunks(old_pkl: Path, new_pkl: Path) -> Path:
  return old_pkl.rename(new_pkl)
 def _hash_onnx_files(model_dir: Path) -> str | None:
  onnx_files = sorted(model_dir.glob("*.onnx"))
  if not onnx_files:
    return None
  digest = hashlib.sha256()
  for f in onnx_files:
    with f.open('rb') as fh:
      while block := fh.read(1024 * 1024):
        digest.update(block)
  return digest.hexdigest()
 def generate_chunked_model(driving_pkl: Path) -> dict:
-  tinygrad_hash = _hash_pkl(driving_pkl)
+  tinygrad_hash = hashlib.sha256(_read_pkl_bytes(driving_pkl)).hexdigest()
  chunks_config = []
  manifest_file = Path(f"{driving_pkl}.chunkmanifest")
@@ -135,8 +119,7 @@ def generate_chunked_model(driving_pkl: Path) -> dict:
  }
-def create_metadata_json(models: list, output_dir: Path, custom_name=None, short_name=None, is_20hz=False, upstream_branch="unknown",
+def create_metadata_json(models: list, output_dir: Path, custom_name=None, short_name=None, is_20hz=False, upstream_branch="unknown") -> None:
                         onnx_sha256=None, is_big=False) -> None:
  bundle_json = {
    "short_name": short_name,
    "display_name": custom_name or upstream_branch,
@@ -149,13 +132,9 @@ def create_metadata_json(models: list, output_dir: Path, custom_name=None, short
    "generation": "-1",
    "build_time": datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ"),
    "overrides": {},
    "is_big": is_big,
    "models": models,
  }
  if onnx_sha256:
    bundle_json["onnx_sha256"] = onnx_sha256
  # Write metadata to output_dir
  metadata_json = {
    "bundles": [bundle_json]
@@ -187,8 +166,6 @@ if __name__ == "__main__":
    print(f"No driving_tinygrad.pkl found in {_output_dir}", file=sys.stderr)
    sys.exit(1)
  is_big = _driving_pkl.name.startswith('big_')
  if _pkl:
    new_pkl = _output_dir / f"driving_{_pkl}_tinygrad.pkl"
    if not new_pkl.exists():
@@ -197,6 +174,4 @@ if __name__ == "__main__":
      _driving_pkl = new_pkl
  _model_metadata = generate_chunked_model(_driving_pkl)
-  _onnx_sha256 = _hash_onnx_files(Path(args.model_dir))
+  create_metadata_json([_model_metadata], _output_dir, args.custom_name, _short_name, args.is_20hz, args.upstream_branch)
  create_metadata_json([_model_metadata], _output_dir, args.custom_name, _short_name, args.is_20hz, args.upstream_branch,
                       onnx_sha256=_onnx_sha256, is_big=is_big)
@@ -47,17 +47,11 @@ git rm -rf $OUTPUT_DIR/.git || true # Doing cleanup, but it might fail if the .g
 git remote remove origin || true # ensure cleanup
 git remote add origin $GIT_ORIGIN
 #git push origin -d $DEV_BRANCH || true # Ensuring we delete the remote branch if it exists as we are wiping it out
-git fetch --depth 1 origin $DEV_BRANCH || (git checkout -b $DEV_BRANCH && git commit --allow-empty -m "sunnypilot v$VERSION release" && git push -u origin $DEV_BRANCH)
+git fetch origin $DEV_BRANCH || (git checkout -b $DEV_BRANCH && git commit --allow-empty -m "sunnypilot v$VERSION release" && git push -u origin $DEV_BRANCH)
 echo "[-] committing version $VERSION T=$SECONDS"
 git add -f .
 # gitlinks break the release tree on device
 if git ls-files -s | awk '$1 == "160000" { found = 1; print } END { exit !found }'; then
    echo "Error: submodules found in release tree."
    exit 1
 fi
 # include source commit hash and build date in commit
 GIT_HASH=$(git --git-dir=$SOURCE_DIR/.git rev-parse HEAD)
 DATETIME=$(date '+%Y-%m-%dT%H:%M:%S')
@@ -0,0 +1,66 @@
 #!/usr/bin/env bash
 # Determine BASE_DIR based on mount point
 if mountpoint -q /data/media; then
    GITHUB_BASE_DIR="/data/media/0/github"
 else
    GITHUB_BASE_DIR="/data/github"
 fi
 # Define directories and user
 BIN_DIR="$GITHUB_BASE_DIR/bin"
 BUILDS_DIR="$GITHUB_BASE_DIR/builds"
 OPENPILOT_DIR="$GITHUB_BASE_DIR/openpilot"
 LOGS_DIR="$GITHUB_BASE_DIR/logs"
 CACHE_DIR="$GITHUB_BASE_DIR/cache"
 RUNNER_USERNAME="github-runner"
 # Define the systemd service name
 SERVICE_NAME="github-runner"
 USER_GROUPS="comma,gpu,gpio,sudo"
 # Function to stop and disable the systemd service
 stop_and_uninstall_service() {
    cd $GITHUB_BASE_DIR/runner
    sudo ./svc.sh stop
    sudo ./svc.sh uninstall
 }
 # Function to remove the systemd service file
 remove_runner() {
    cd $GITHUB_BASE_DIR/runner
    sudo rm .runner
    sudo su -c './config.sh remove' github-runner
 }
 # Function to delete the Github Runner directories
 delete_directories() {
    sudo rm -rf "$BIN_DIR/github-runner"
    sudo rm -rf "$GITHUB_BASE_DIR" "$BIN_DIR" "$BUILDS_DIR" "$LOGS_DIR" "$CACHE_DIR" "$OPENPILOT_DIR"
 }
 # Function to remove the Github Runner user
 delete_user() {
    for group in ${USER_GROUPS//,/ }
    do
       sudo gpasswd -d ${RUNNER_USERNAME} ${group}
    done
    sudo userdel -r ${RUNNER_USERNAME}
 }
 # Function to remove sudoers entry
 remove_sudoers_entry() {
    sudo sed -i.bak "/${RUNNER_USERNAME} ALL=(ALL) NOPASSWD: ALL/d" /etc/sudoers
 }
 # Make filesystem writable
 sudo mount -o remount rw /
 # Ensure filesystem is remounted as read-only on script exit
 trap "sudo mount -o remount ro /" EXIT
 # Call functions
 stop_and_uninstall_service
 remove_runner
 delete_directories
 delete_user
 remove_sudoers_entry
 # End of uninstall script
@@ -1,104 +0,0 @@
 #!/usr/bin/env python3
 """
 Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 import argparse
 import hashlib
 import json
 import tempfile
 from huggingface_hub import HfApi, hf_hub_download
 def hash_file(path: str) -> str:
  digest = hashlib.sha256()
  with open(path, 'rb') as f:
    while block := f.read(1024 * 1024):
      digest.update(block)
  return digest.hexdigest()
 def main():
  parser = argparse.ArgumentParser()
  parser.add_argument("--hf-repo", required=True)
  parser.add_argument("--hf-defaults-path", required=True)
  parser.add_argument("--artifact-name", required=True)
  parser.add_argument("--model-dir", required=True)
  parser.add_argument("--onnx-path", required=True)
  parser.add_argument("--onnx-ref", required=True)
  parser.add_argument("--model-name", required=True)
  parser.add_argument("--tinygrad-ref", required=True)
  parser.add_argument("--run-number", required=True)
  args = parser.parse_args()
  api = HfApi()
  onnx_sha256 = hash_file(args.onnx_path)
  short_ref = args.onnx_ref[:8]
  folder_name = f"model-{args.model_name}-{short_ref}-{args.run_number}"
  print(f"ONNX hash: {onnx_sha256}")
  print(f"ONNX ref: {args.onnx_ref} (short: {short_ref})")
  print(f"Folder: {folder_name}")
  metadata_path = f"{args.model_dir}/metadata.json"
  with open(metadata_path) as f:
    metadata = json.load(f)
  bundle = metadata['bundles'][0]
  bundle['display_name'] = args.model_name
  bundle['onnx_sha256'] = onnx_sha256
  bundle['onnx_ref'] = args.onnx_ref
  artifact = bundle['models'][0]['artifact']
  hf_base = f"https://huggingface.co/datasets/{args.hf_repo}/resolve/main/{args.hf_defaults_path}/{folder_name}"
  artifact['download_uri']['url'] = f"{hf_base}/{artifact['file_name']}"
  for chunk in artifact.get('chunks', []):
    chunk['url'] = f"{hf_base}/{chunk['file_name']}"
  print(f"Uploading model to {args.hf_defaults_path}/{folder_name}/")
  api.upload_folder(
    folder_path=args.model_dir,
    path_in_repo=f"{args.hf_defaults_path}/{folder_name}",
    repo_id=args.hf_repo,
    repo_type="dataset",
  )
  json_filename = f"{args.hf_defaults_path}/default_models.json"
  try:
    local_path = hf_hub_download(repo_id=args.hf_repo, repo_type='dataset', filename=json_filename)
    with open(local_path) as f:
      defaults_json = json.load(f)
  except Exception:
    defaults_json = {"tinygrad_ref": args.tinygrad_ref, "bundles": []}
  defaults_json['tinygrad_ref'] = args.tinygrad_ref
  existing_idx = next((i for i, b in enumerate(defaults_json['bundles'])
                       if b.get('onnx_sha256') == onnx_sha256), None)
  if existing_idx is not None:
    defaults_json['bundles'][existing_idx] = bundle
  else:
    defaults_json['bundles'].append(bundle)
  print(json.dumps(defaults_json, indent=2))
  with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
    json.dump(defaults_json, f, indent=2)
    tmp_path = f.name
  api.upload_file(
    path_or_fileobj=tmp_path,
    path_in_repo=json_filename,
    repo_id=args.hf_repo,
    repo_type="dataset",
  )
  print(f"Updated {json_filename}")
 if __name__ == "__main__":
  main()
@@ -381,20 +381,20 @@ wheels = [
 [[package]]
 name = "deepmerge"
-version = "3.0"
+version = "2.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b7/6c/9f4577a36d5f463a3a3f8322bd65d33e1a1a6b6ba1d692a5ebc3cba19015/deepmerge-3.0.tar.gz", hash = "sha256:14ed69f063de64b7743985c732ccff5d6c34ff4560946e7fbfd99086b853b9ce", size = 22279, upload-time = "2026-08-17T05:50:53.161Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2a/78/6e9e20106224083cfb817d2d3c26e80e72258d617b616721a169b87081e0/deepmerge-2.1.0.tar.gz", hash = "sha256:07ca7a7b8935df596c512fa8161877c0487ac61f691c07766e7d71d2b23bdd2f", size = 21449, upload-time = "2026-06-22T05:46:07.669Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a8/d7/7f19bedd30b90b72865aeec3a29127bed6dee6c9ef0324bb5b4d424bb0e3/deepmerge-3.0-py3-none-any.whl", hash = "sha256:c8541c3e186dc88d19a5513ad3a0b2d0b22beaa780969fc0c13b995a64265365", size = 14855, upload-time = "2026-08-17T05:50:52.218Z" },
+    { url = "https://files.pythonhosted.org/packages/51/25/2a75b47cb057b1e164c604fb81ab690a6cdb5e2260ce651194eae90f64a3/deepmerge-2.1.0-py3-none-any.whl", hash = "sha256:8f148339a91d680a75ecb74ade235d9e759a93df373a0b04e9d31c8666cfeb75", size = 14345, upload-time = "2026-06-22T05:46:06.742Z" },
 ]
 [[package]]
 name = "filelock"
-version = "3.32.3"
+version = "3.32.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7d/64/a02e6765de08964ed371eca577870593245afc9dfac16d037de7c10d18e6/filelock-3.32.3.tar.gz", hash = "sha256:0ffa185a3540854c95caa7fa76b76cb219d907415e2c5dc9af25fd970563487f", size = 218135, upload-time = "2026-08-13T16:00:05.577Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/57/3ba6e6cb097f85b855b00163d169f35365f44277df044dcf96d55b8f62a3/filelock-3.32.2.tar.gz", hash = "sha256:c33351e1f49cae33414acbc6d56784e6ecee82514ec90795da1161fc4836b5b8", size = 217172, upload-time = "2026-07-29T22:46:04.895Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a7/8e/50f46a9c0ce8d2861a394c1347caae037ea0431d2f67d7feb151cbc4649a/filelock-3.32.3-py3-none-any.whl", hash = "sha256:7f0ca4bcc0e181c60dbbd8aa9ab5b120ebb99e4e064e83636340056f833a1f09", size = 98901, upload-time = "2026-08-13T16:00:03.974Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/e8/72f8cef9fdfeffe06213fe8508039396ee48daa0e3259457ed766173bfd6/filelock-3.32.2-py3-none-any.whl", hash = "sha256:87dd94cf281e586d135fa51132b8e3d9a598b316e90377a288663c9321036c82", size = 98830, upload-time = "2026-07-29T22:46:03.52Z" },
 ]
 [[package]]
@@ -478,7 +478,7 @@ wheels = [
 [[package]]
 name = "huggingface-hub"
-version = "1.28.0"
+version = "1.27.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "click" },
@@ -491,18 +491,18 @@ dependencies = [
    { name = "tqdm" },
    { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c6/ae/222a91937ebee7f62c0ca8f5ee0afd97577caf24c0abb927d1f5c7e9f6d2/huggingface_hub-1.28.0.tar.gz", hash = "sha256:46a2e950c09234de54093d587d1675382f0d08dbd600d9fb599b5932f5b2c6cb", size = 959609, upload-time = "2026-08-18T12:27:15.101Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3e/9b/ddf3d02a8681f1b9ce52fda03d755dad6b74c4f8172304c4c8d2975450f9/huggingface_hub-1.27.0.tar.gz", hash = "sha256:c1fed40ea82a6b41b477f5243546549b792ae0a93abcea608cff66089bf8f8df", size = 942668, upload-time = "2026-08-07T12:48:05.161Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/51/0e/eafef18f1a75e125e68395db21131db0cf868a128ecd2fce69b4df6c584b/huggingface_hub-1.28.0-py3-none-any.whl", hash = "sha256:58a8bacb03072edfc38067065e9dc24bbb34805410fcd36a1632de0b329660bb", size = 793202, upload-time = "2026-08-18T12:27:12.719Z" },
+    { url = "https://files.pythonhosted.org/packages/de/d8/95b735e183957c1f26d94c52977f09d466d55119cbbc1558ea4975e4c216/huggingface_hub-1.27.0-py3-none-any.whl", hash = "sha256:7df6827c2f956c60fbaa64646e979e566db76f619dd0a9729dfb8c5a3eb4f68d", size = 784926, upload-time = "2026-08-07T12:48:02.905Z" },
 ]
 [[package]]
 name = "idna"
-version = "3.19"
+version = "3.18"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5f/f7/abb373e5757eaec4b922b92f97ec8d6d7e057cf06778247604fbc4e7c3f3/idna-3.19.tar.gz", hash = "sha256:5e0811a4383b21dc5838069f801c4fb62113b7447663d2530d2bd6e77b49bf15", size = 215237, upload-time = "2026-08-18T05:14:24.27Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" },
 ]
 [[package]]
@@ -847,7 +847,7 @@ requires-dist = [
    { name = "rednose", marker = "extra == 'submodules'", editable = "rednose_repo" },
    { name = "requests" },
    { name = "ruff", marker = "extra == 'testing'" },
-    { name = "scons", specifier = "==4.10.1" },
+    { name = "scons" },
    { name = "sentry-sdk" },
    { name = "setproctitle" },
    { name = "sounddevice" },
@@ -971,11 +971,11 @@ wheels = [
 [[package]]
 name = "pygments"
-version = "2.21.0"
+version = "2.20.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
 ]
 [[package]]
@@ -1136,11 +1136,11 @@ wheels = [
 [[package]]
 name = "scons"
-version = "4.10.1"
+version = "4.11.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7d/c9/2f430bb39e4eccba32ce8008df4a3206df651276422204e177a09e12b30b/scons-4.10.1.tar.gz", hash = "sha256:99c0e94a42a2c1182fa6859b0be697953db07ba936ecc9817ae0d218ced20b15", size = 3258403, upload-time = "2025-11-16T22:43:39.258Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/dd/82/3c4e089ac8df2eaee8a7f14e489b2a76f94f4c1d8defa4e46c8ad15cae86/scons-4.11.0.tar.gz", hash = "sha256:5ba48f9e2eb6b9178cabdc9893792418e6970c84f43f4b027e4468e20616a89c", size = 3269126, upload-time = "2026-08-11T04:29:45.62Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ce/bf/931fb9fbb87234c32b8b1b1c15fba23472a10777c12043336675633809a7/scons-4.10.1-py3-none-any.whl", hash = "sha256:bd9d1c52f908d874eba92a8c0c0a8dcf2ed9f3b88ab956d0fce1da479c4e7126", size = 4136069, upload-time = "2025-11-16T22:43:35.933Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/ac/a4445bbbd58a5fa6a5c8b3b0458ffbee04e4acaff87677058eab9c6af682/scons-4.11.0-py3-none-any.whl", hash = "sha256:2edc077aaeafc43377ba46ce1fa3e7b40edea59c62db9ef7e39e07dc88b754fa", size = 4123742, upload-time = "2026-08-11T04:29:42.881Z" },
 ]
 [[package]]
@@ -1194,18 +1194,18 @@ wheels = [
 [[package]]
 name = "sounddevice"
-version = "0.5.6"
+version = "0.5.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "cffi" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ec/db/0c890e2d9aab9ba284021efc02e1d3aebfecab1b611762d7434602209bcf/sounddevice-0.5.6.tar.gz", hash = "sha256:8ec9fbfde2e32f020b167e348f3ab3bac6625a5f15af524d790108ac7147a410", size = 1120094, upload-time = "2026-08-17T07:55:05.048Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2a/f9/2592608737553638fca98e21e54bfec40bf577bb98a61b2770c912aab25e/sounddevice-0.5.5.tar.gz", hash = "sha256:22487b65198cb5bf2208755105b524f78ad173e5ab6b445bdab1c989f6698df3", size = 143191, upload-time = "2026-01-23T18:36:43.529Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/72/1f/62eef605172bddc1017508469a12f75bc7c4194ece35c734f822795f53b1/sounddevice-0.5.6-py3-none-any.whl", hash = "sha256:de099612311ad81e55d31ccbd83f43ea6bf4d87b48f9b6ea55a1fbcde0eee4e0", size = 32793, upload-time = "2026-08-17T07:54:57.507Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0a/478e441fd049002cf308520c0d62dd8333e7c6cc8d997f0dda07b9fbcc46/sounddevice-0.5.5-py3-none-any.whl", hash = "sha256:30ff99f6c107f49d25ad16a45cacd8d91c25a1bcdd3e81a206b921a3a6405b1f", size = 32807, upload-time = "2026-01-23T18:36:35.649Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/84/85e719d49cf98b2f406d9ac9c338892286c4448eb42ef0b2625ccf159616/sounddevice-0.5.6-py3-none-macosx_10_6_x86_64.macosx_10_6_universal2.whl", hash = "sha256:e3aef00ad8b1d1740eb66d9a7671eab88a4d2b8fa4ab33498d742e63b65c309c", size = 1009647, upload-time = "2026-08-17T07:54:58.814Z" },
+    { url = "https://files.pythonhosted.org/packages/56/f9/c037c35f6d0b6bc3bc7bfb314f1d6f1f9a341328ef47cd63fc4f850a7b27/sounddevice-0.5.5-py3-none-macosx_10_6_x86_64.macosx_10_6_universal2.whl", hash = "sha256:05eb9fd6c54c38d67741441c19164c0dae8ce80453af2d8c4ad2e7823d15b722", size = 108557, upload-time = "2026-01-23T18:36:37.41Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/6f/6292145099f72a153a710245f46ae43e5fb6c77bec1b6086cb76c12dc280/sounddevice-0.5.6-py3-none-win32.whl", hash = "sha256:b36b807eb02abd257198bf84b2af05e4fea199a9d2f0019014169c7136d45e9c", size = 1009627, upload-time = "2026-08-17T07:55:00.401Z" },
+    { url = "https://files.pythonhosted.org/packages/88/a1/d19dd9889cd4bce2e233c4fac007cd8daaf5b9fe6e6a5d432cf17be0b807/sounddevice-0.5.5-py3-none-win32.whl", hash = "sha256:1234cc9b4c9df97b6cbe748146ae0ec64dd7d6e44739e8e42eaa5b595313a103", size = 317765, upload-time = "2026-01-23T18:36:39.047Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/3e/cbc593c31a5f0d817b3fe97e64aa8461bd0f55cb07b67ce1b776296ae336/sounddevice-0.5.6-py3-none-win_amd64.whl", hash = "sha256:7f4162f514f007b0bf25a3ccfed3f1705bc2ec311888a90232729eec4f57a4f4", size = 1009630, upload-time = "2026-08-17T07:55:02.088Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/0e/002ed7c4c1c2ab69031f78989d3b789fee3a7fba9e586eb2b81688bf4961/sounddevice-0.5.5-py3-none-win_amd64.whl", hash = "sha256:cfc6b2c49fb7f555591c78cb8ecf48d6a637fd5b6e1db5fec6ed9365d64b3519", size = 365324, upload-time = "2026-01-23T18:36:40.496Z" },
-    { url = "https://files.pythonhosted.org/packages/60/a4/b0c21c9f215a6fd9606b8f8748c21212dc098e5d5a2d93068c50edcf19b4/sounddevice-0.5.6-py3-none-win_arm64.whl", hash = "sha256:c8ae19173e5f27f8c12d4b5eee2dbfe542cee125d591e663e0fb4dfb75246d45", size = 1009630, upload-time = "2026-08-17T07:55:03.689Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/39/a61d4b83a7746b70d23d9173be688c0c6bfc7173772344b7442c2c155497/sounddevice-0.5.5-py3-none-win_arm64.whl", hash = "sha256:3861901ddd8230d2e0e8ae62ac320cdd4c688d81df89da036dcb812f757bb3e6", size = 317115, upload-time = "2026-01-23T18:36:42.235Z" },
 ]
 [[package]]
@@ -1285,6 +1285,7 @@ requires-dist = [
    { name = "pylint", marker = "extra == 'linting'" },
    { name = "pytest", marker = "extra == 'testing-minimal'" },
    { name = "pytest-split", marker = "extra == 'testing-minimal'" },
    { name = "pytest-timeout", marker = "extra == 'testing-minimal'" },
    { name = "pytest-xdist", marker = "extra == 'testing-minimal'" },
    { name = "ruff", marker = "extra == 'linting'", specifier = "==0.14.10" },
    { name = "safetensors", marker = "extra == 'testing-unit'" },
@@ -1293,7 +1294,6 @@ requires-dist = [
    { name = "tiktoken", marker = "extra == 'testing'" },
    { name = "tinygrad", extras = ["testing-minimal"], marker = "extra == 'testing-unit'" },
    { name = "tinygrad", extras = ["testing-unit"], marker = "extra == 'testing'" },
    { name = "tinymesa", marker = "extra == 'mesa'", specifier = "==25.2.7.2" },
    { name = "torch", marker = "extra == 'testing-minimal'", specifier = "==2.9.1" },
    { name = "tqdm", marker = "extra == 'testing-unit'" },
    { name = "transformers", marker = "extra == 'testing'" },
@@ -1301,7 +1301,7 @@ requires-dist = [
    { name = "typing-extensions", marker = "extra == 'linting'" },
    { name = "z3-solver", marker = "extra == 'testing-minimal'", specifier = "<4.15.4" },
 ]
-provides-extras = ["linting", "testing-minimal", "testing-unit", "testing", "docs", "mesa"]
+provides-extras = ["linting", "testing-minimal", "testing-unit", "testing", "docs"]
 [[package]]
 name = "tomli"
@@ -1335,27 +1335,27 @@ wheels = [
 [[package]]
 name = "ty"
-version = "0.0.73"
+version = "0.0.72"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e5/90/c4e1bb4cead3b644c3e258a27f9b05c7dc5eb0ec96a4f5282194edae9e0d/ty-0.0.73.tar.gz", hash = "sha256:823d4ce0d237bfc7eb6bcee70842f2c0706113813a16951077840743712f4b74", size = 6712739, upload-time = "2026-08-19T03:12:43.381Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d5/df/656e684bafb13c1d146e7d5b5f3e7978ca177232acc84998ff36427e9462/ty-0.0.72.tar.gz", hash = "sha256:ec2b8066b618df18cab4cb8e992f8da45d360332acb23fa34df7fa29cd1b9d3a", size = 6654939, upload-time = "2026-08-14T21:35:42.612Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e4/0f/f5e1801e55cc631f2db193276675b30561b963a2403da832bffb5d100267/ty-0.0.73-py3-none-linux_armv6l.whl", hash = "sha256:90a946082bf9bc446b5e72973d9f4ff1222a240b2ca4c9e6eed61eb913e30810", size = 12715452, upload-time = "2026-08-19T03:12:06.673Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/3b/f51461239a4e66565d4b362f97a3b55fe7fdba2e944068341f87c62f6743/ty-0.0.72-py3-none-linux_armv6l.whl", hash = "sha256:fda86db153ffd85ee52000cf175d6a3f1c0223772cf7c5b6f726200bf92c7b44", size = 12621989, upload-time = "2026-08-14T21:35:01.676Z" },
-    { url = "https://files.pythonhosted.org/packages/54/32/515dd05074c213b433524ab97eb003b0132ae7e358e0d75633ba7a314ed8/ty-0.0.73-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b7d6b5c6a6db7ea95fbbc16af514ef44a27a29a2fe1dc798900790364d170209", size = 12301870, upload-time = "2026-08-19T03:12:08.924Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/fb/79ddf683affc679ca856f3510b5640ec3a88a842ba5f654f5d4bc78f1786/ty-0.0.72-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ceb944c612529b9023acfdc9cf4c0dcbb722549f9d17d46baecd1141baf01d7f", size = 12233910, upload-time = "2026-08-14T21:35:04.334Z" },
-    { url = "https://files.pythonhosted.org/packages/50/4d/085b4889f0d4bbe4af8b96242d4a1cb209fff95967cfa239ea141983719b/ty-0.0.73-py3-none-macosx_11_0_arm64.whl", hash = "sha256:dd6f657f463e01372d8688f235be164750c8db722c97da27fa4903aa8d40b203", size = 12111741, upload-time = "2026-08-19T03:12:11.067Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/45/10562a0d84802158db8fa4ec46de54aa9fdcecdeeaabbfe3639ae7042b66/ty-0.0.72-py3-none-macosx_11_0_arm64.whl", hash = "sha256:108d76218333d6c092e5f1cebf8e9b06f25738613a0236a28e2dd47c936ee52c", size = 12084108, upload-time = "2026-08-14T21:35:06.686Z" },
-    { url = "https://files.pythonhosted.org/packages/95/f6/d6ec277cadfecf03ad4c18551b67c4c6eb7807a0560d801db14be99d7a89/ty-0.0.73-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc2de468e33fd44c9ff1c43473a7316f4289480f5cba8995a67b6d22aee39ca9", size = 12196124, upload-time = "2026-08-19T03:12:13.14Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/dc/1fe1aef8d697e3509face271a5331700c7aa1d1e44a4b622707bdfa41d4b/ty-0.0.72-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f3943f186f741a2499a31053872169250c9264a9a49684920e48d8fcf4ef4f5", size = 12132640, upload-time = "2026-08-14T21:35:09.305Z" },
-    { url = "https://files.pythonhosted.org/packages/75/b7/ce78d8707563af9cae9bbd25328bfbc4931035085bd20089adf0c418f70e/ty-0.0.73-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2942fa0ef795a66034cdc8d75a72f453442f3b58ff2f69b4da05b7b954765b55", size = 12488557, upload-time = "2026-08-19T03:12:15.252Z" },
+    { url = "https://files.pythonhosted.org/packages/14/46/41ceb265e96969487311a2014bd0e53abb4fbc1395efb2ebe411fcb4db62/ty-0.0.72-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cf283c07dc3cc52ca48a3ad8ab100fb5aec3aebbd03ef6a12d5f910b8e596fc5", size = 12402489, upload-time = "2026-08-14T21:35:11.555Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/e8/329b9851b23502758c5c98e8cc875ea2a1b4c9674b4ca3a86da56a5063d3/ty-0.0.73-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e0f1ef14f642e18ac4e7a616a2796dcf7a5d82e28cd17f9796494acc7c4aabb", size = 13215606, upload-time = "2026-08-19T03:12:17.225Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/45/30bf43cb4fd505c5c2dd30fda27dde5f05208686cd21217adec77c954204/ty-0.0.72-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:95f3b6462c38f9f115d10cee21f47fedf715fcf2040daf36eef210359300bc7c", size = 13130835, upload-time = "2026-08-14T21:35:13.746Z" },
-    { url = "https://files.pythonhosted.org/packages/36/38/67fedfd2cb77516ef0066b1642f487dba0eb3006493cf3475b15f5b8b228/ty-0.0.73-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:16981e15fdceedb37d0aff76c5ac25914595dfee2675af95335550064251ad22", size = 13665497, upload-time = "2026-08-19T03:12:19.286Z" },
+    { url = "https://files.pythonhosted.org/packages/31/2f/03bba754d2613f640df168335c41f83f41db150bb515839c60d80e3a7880/ty-0.0.72-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:30caf658feb8ffb250d9e9e47107657a78f5f3425c227df1664d8df2ebe38880", size = 13590392, upload-time = "2026-08-14T21:35:16.839Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/b3/154f4dd48ec5eebc186ab4b822c6e62f982fc5ddfd262d6e3903c2acba44/ty-0.0.73-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:644b2bec8a2e2e4957a942ae81d6cff5571c489bb5a8675e4d3886de537a694d", size = 13351231, upload-time = "2026-08-19T03:12:21.353Z" },
+    { url = "https://files.pythonhosted.org/packages/04/c7/03c67f00e63005ec41585653dc3096064570b1e6273742baae2798cd242f/ty-0.0.72-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:27bdc012ddfbeec8948e4a6036c0dc39ac7cf2c8ec7c7d48dc7d2fd56d57b399", size = 13309629, upload-time = "2026-08-14T21:35:19.169Z" },
-    { url = "https://files.pythonhosted.org/packages/35/5f/d462496903fbe453fb76363f8478be929c8e6ff21e6928c57dcd7e5fa21f/ty-0.0.73-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:338d565be3186f50ff8e9d10483685549c2d23f0754485d5ede3b54f4319188a", size = 12782586, upload-time = "2026-08-19T03:12:23.667Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/df/102d3b264eb7f2a58dd11952f229bb5150bb5668d176a6154976a6675981/ty-0.0.72-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:802c5970a77d7739e6f499921fbb6984fb7ad8a31d95e1ff42fd46f3642e4f3b", size = 12734028, upload-time = "2026-08-14T21:35:22.099Z" },
-    { url = "https://files.pythonhosted.org/packages/87/52/ec6d24b74abe3ec324204c1c71e6d0c6c76a17ffc15fd51d603b0a302abe/ty-0.0.73-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:11c7b6d839309d2c102cb3a4c03d817176bbfab5b2fccc95a75ec5c9597421c9", size = 13247134, upload-time = "2026-08-19T03:12:25.956Z" },
+    { url = "https://files.pythonhosted.org/packages/61/85/d0737c8c54d0ba67366ddfb9f31d88edf0b02299e65923e6945ae60ebcb5/ty-0.0.72-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:47dce65114fdc615c68ca0edb393b433df0956447e4267df0e264137a789598d", size = 13174832, upload-time = "2026-08-14T21:35:24.71Z" },
-    { url = "https://files.pythonhosted.org/packages/26/20/cc74650fec56a54786c6d7c89e09576fcad3092be34cf21715d39a406a9b/ty-0.0.73-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:488572db7ff97fb50ea36a76250f2d617c9727d143da6c7bf0623276eb0fc507", size = 12309344, upload-time = "2026-08-19T03:12:28.122Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/31/497f5a96c36d9b586ab6afe0574986835c6fd5b835a89773d2bec4711b49/ty-0.0.72-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:325144fa07e2675d0faa337fcc864213c272a499eb0cfe5bde2fdc62282d27bc", size = 12215005, upload-time = "2026-08-14T21:35:26.892Z" },
-    { url = "https://files.pythonhosted.org/packages/89/bd/4b0a9087f4315d7fbadf77a3ce44c816cc9ffabed1ced06cc5be81fbc414/ty-0.0.73-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:1b958ebceefbbf594e59eb8d3d55bbd033ce634026fcba3e4bc3179e78e45bb7", size = 12502319, upload-time = "2026-08-19T03:12:30.128Z" },
+    { url = "https://files.pythonhosted.org/packages/df/7d/46e65b17b4966c7cd0140f134380d33d8e84fe6efccd761533ce793dc502/ty-0.0.72-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:a5c9f15d0f58e43707d8848274be1821a0ef408eccb8aa7dda28a4a9eddf7640", size = 12421298, upload-time = "2026-08-14T21:35:29.301Z" },
-    { url = "https://files.pythonhosted.org/packages/11/80/0a925074911fe111912ea29d9eed309bcc183f43d2fb3eef07db056a0beb/ty-0.0.73-py3-none-musllinux_1_2_i686.whl", hash = "sha256:91a32993b3c34e42c3f323ad6c0399cb596bd1c27e9b7f20db7cd64c1067b68e", size = 12753688, upload-time = "2026-08-19T03:12:32.433Z" },
+    { url = "https://files.pythonhosted.org/packages/08/2a/12ada4ec17700b3cb1d4fd3bc3e5b1852df9e6885288429318cade87b3c1/ty-0.0.72-py3-none-musllinux_1_2_i686.whl", hash = "sha256:8ee508d64b381871529cc22c412b41071bf5e908b7aa5d66a38f3f6b2573a806", size = 12669242, upload-time = "2026-08-14T21:35:31.444Z" },
-    { url = "https://files.pythonhosted.org/packages/24/6b/aeccaf89efbc2e112bd415340a22e2669ec998aa397242503e747b712ca4/ty-0.0.73-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:bab8a19fbf51f479bddb2a12c5fabfe52f918a5590362321ed5d89b44eb62c15", size = 13069050, upload-time = "2026-08-19T03:12:35.398Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/1a/4692536880790fb550ed6d44a6096778dc71bb112f2c6d615cebb01a57e5/ty-0.0.72-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3699e2ec7921d44da79d6b089f7bf239b2cc53c4e45a5a38430adc34ee9e9a55", size = 12988199, upload-time = "2026-08-14T21:35:33.749Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/3e/eae485fd86c1585943fd4e1746b0757b2da01e2c43136ebe8c686fe1c7f1/ty-0.0.73-py3-none-win32.whl", hash = "sha256:03347a612f0fa020b19bfd8dbd521db6ecc75d377a3e4d4f6e6c2e62871da4cc", size = 12053187, upload-time = "2026-08-19T03:12:37.565Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/0d/f5e5a50322e9c45865e7b7a428ba6cd6527387cf0f2472492ac3cf746243/ty-0.0.72-py3-none-win32.whl", hash = "sha256:f25f72a67bd36cd247707c4784e52fad0b6b4f42a1b7dd14804110fa95c486ed", size = 11939708, upload-time = "2026-08-14T21:35:36.006Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/01/9b8b983786e3ce34924e372e8b76b92b508273ab65c589fc7e88cc03ee17/ty-0.0.73-py3-none-win_amd64.whl", hash = "sha256:cedd05122ded0b5dcc55431a370e974b747f99c41c290a3d2ab8c1867f197519", size = 12693838, upload-time = "2026-08-19T03:12:39.483Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/4e/8af3534b2e4214e6184a5a59c34101e94a68d578f081f97b995866bab1bf/ty-0.0.72-py3-none-win_amd64.whl", hash = "sha256:cdeee869341717e1736cea2e2d7856738c6957c320f584ed2f68c8f90100d2f5", size = 12643876, upload-time = "2026-08-14T21:35:38.141Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/88/25333bbfea6a5dc064371d2002d3d4807db90b84d5448f9106b2712b0fbc/ty-0.0.73-py3-none-win_arm64.whl", hash = "sha256:e47068f8369dea5d641a26a2ad0a947a320b02ff87099b07e95de0323245a4dc", size = 12443573, upload-time = "2026-08-19T03:12:41.449Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/ea/a2606e654c7276bd08586391a2525b0af3f3bf60228a8c57b2d248f273f9/ty-0.0.72-py3-none-win_arm64.whl", hash = "sha256:1bd3ac3ed4424a6d6990a85dc388556aea012bd752de21349a84b685951de0d8", size = 12394857, upload-time = "2026-08-14T21:35:40.277Z" },
 ]
 [[package]]
@@ -1387,7 +1387,7 @@ wheels = [
 [[package]]
 name = "zensical"
-version = "0.0.56"
+version = "0.0.54"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "click" },
@@ -1399,20 +1399,20 @@ dependencies = [
    { name = "pyyaml" },
    { name = "tomli" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f8/7d/18bb725a659352e9af0940a3d879c5edcff5d86fec3ac15ce500d484d9d3/zensical-0.0.56.tar.gz", hash = "sha256:c359163800d1c3a8c39af48f4e2869fcfc2b4fc00d28652bd2a5b0330c36530c", size = 3997416, upload-time = "2026-08-18T15:46:47.283Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/75/7e/343a78c0c9da1954d2f0a4d47ca778baac48bb18c6b9c0c6260e7974976e/zensical-0.0.54.tar.gz", hash = "sha256:4de205dbb323d0a443e2ebf3fef77e93e3c1493c34a58d205e7f3631dd7745af", size = 3992024, upload-time = "2026-08-13T16:04:49.297Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/4b/6810aec6e670451f39639039b570a43d90bc1d4a3b93cf13316ccf6bad11/zensical-0.0.56-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:5135ea3aa5d1358503fc1903e866c191873b138028bc1ab170abac3a4b537ffe", size = 12874712, upload-time = "2026-08-18T15:46:18.378Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cf/13e887c303fd5c786c09f83362382a42d10292fca633a95067de6a6591a3/zensical-0.0.54-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:f7177a3b6647e4ee47864ab02e5141f9e923dd57b9fa96e5dc5da4228daff505", size = 12893082, upload-time = "2026-08-13T16:04:17.337Z" },
-    { url = "https://files.pythonhosted.org/packages/97/98/23445d8ed708088dd6d9d51674f8836b77c53aab280360d7aa7a206bea8e/zensical-0.0.56-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:a22ae2329ba755c6e58e1fe5967ca429d580d346a73cf467ad5185377e2cf809", size = 12764552, upload-time = "2026-08-18T15:46:20.746Z" },
+    { url = "https://files.pythonhosted.org/packages/82/ee/7fe1418fa31bc120cf9eb0fbce9e021c40752206ce993a7bc652c011f890/zensical-0.0.54-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:7b23c3b0c720885891b220c3e562074d93eb940314823d91875c6246976bd9b2", size = 12778626, upload-time = "2026-08-13T16:04:19.906Z" },
-    { url = "https://files.pythonhosted.org/packages/14/bd/ab89450728b0a55e6a52a86060b38a362a52a1b9f02eda7fef68b729eb2e/zensical-0.0.56-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:03c70ef328e31cce0e31739acdd6679e9272bc7a3016ca5eafaa16dcfda460c9", size = 13212920, upload-time = "2026-08-18T15:46:22.977Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b8/0420115270c1a22a2d4a1598f89dadc4e933eb7aa85539b72f3532acc5b6/zensical-0.0.54-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c012eb0ec20fda5794e90b4906b7401c77b712e2acc7f9f65026935368539da", size = 13225462, upload-time = "2026-08-13T16:04:22.663Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/5a/969fd9a461204392a9266a544c185fbb223714b306534661dcbb7d290be7/zensical-0.0.56-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1ffc50153a50292078357a5052e7a6b3e20a818523792ffcbeace70418b761eb", size = 13146652, upload-time = "2026-08-18T15:46:25.773Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/48/0dfdd3e00fb3b807de702383ef5f4e9cf0d2791fee0e8a56f39bd590f16b/zensical-0.0.54-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f0e851d26ba4f7397db3b3532e534c0572a9826bbd451ee0a00e649c030dcb38", size = 13158184, upload-time = "2026-08-13T16:04:24.958Z" },
-    { url = "https://files.pythonhosted.org/packages/22/b3/28a7c8dea8fe2edbba75a664efbde797b5922651ea92ffc480947ab22197/zensical-0.0.56-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88bba0e339d36647ce638a42b4ba96f2521b59ea54be74c314340be7e401f94b", size = 13530946, upload-time = "2026-08-18T15:46:28.19Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/2c/f1fb1f5387108b206f985cdb394bbdc730557cc339e63067ded9b3565263/zensical-0.0.54-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a48583da6f485e2373845d4332882c9e9d504302dbd2731c589543584df5b087", size = 13536772, upload-time = "2026-08-13T16:04:27.373Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/a6/d55a18c6e041b788af1d19e4d8c61ee9b8a7de5b9cc79ffa7bc9565e3a28/zensical-0.0.56-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b7a37f6ac38ac218e3e0dd311b58c468603963e38ee23f2e25672dcd6e9c17b", size = 13178741, upload-time = "2026-08-18T15:46:30.378Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/97/3224b3dd5d76cebddf9725ae871a5a6a8f2de177be59d802232d00073d8b/zensical-0.0.54-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da7781a906623fb7bc278cc874ec6f80691c8753b90fbdf90a451abb046ae204", size = 13191901, upload-time = "2026-08-13T16:04:30.295Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/4f/a07da2f761cfd6a27faf9e8d5a9475c396a9a0ca37424a0b67cab7ae4d2c/zensical-0.0.56-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:5f6d850bce3184422b37b9d98ef4d123047a47446844793251cabc04bd55f8f0", size = 13389836, upload-time = "2026-08-18T15:46:32.847Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/00/b1f55530c8df4331e1f209ec605816a578142f124b5f8078a9d984514d63/zensical-0.0.54-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:75aff1c01f6104dd0e79d08c87bd595da13db3e1f6da55fc9933ebff3e94fdd5", size = 13402956, upload-time = "2026-08-13T16:04:32.899Z" },
-    { url = "https://files.pythonhosted.org/packages/34/aa/697ef9846b0e2071de4d03b0472e2658380ea9271bd01235f4ffaeef1978/zensical-0.0.56-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:d18944a4a111050b8f571e73d4e2475d7ce62ce78b64f09bcf33bb11cc346e1c", size = 13419551, upload-time = "2026-08-18T15:46:35.112Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/6e/58df496c2742600df3a2f273ba52b8ced1ce357340b825af9f1bb0f2042e/zensical-0.0.54-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:1469c5d551a0ea2d0fcf922046a263d2afcff5f03ce3bb443e286970d04ff9f2", size = 13431462, upload-time = "2026-08-13T16:04:35.518Z" },
-    { url = "https://files.pythonhosted.org/packages/97/6b/20e1b2443951d5182b3fc2ee54c200ea00c09bd8901a479be4147c94361b/zensical-0.0.56-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:3937029ec5091d577c2a05ebccd38fde97fab28662d165ead66d566689b2a6df", size = 13579878, upload-time = "2026-08-18T15:46:37.381Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/85/70ae775db7865be2434bc39e9b4ff1c7988978d796a7ff9d49294e7410c7/zensical-0.0.54-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:31c354f98b3374b9bcab65278a278dbec66125c997f7f1a5ee9501f413b87b9c", size = 13587289, upload-time = "2026-08-13T16:04:37.954Z" },
-    { url = "https://files.pythonhosted.org/packages/53/c7/9c3b400b8a7d78cc169b7a78d4f74a90f9114209034a604f04051f48037c/zensical-0.0.56-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:346a1cdbad157633d185f79039a97c8b4f8c2b40be7d7efd56d72622f40247b0", size = 13526142, upload-time = "2026-08-18T15:46:39.949Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ca/05e6b3e04323810bbf4da9240b8b710740fac82ec01659b14c86e44aa88e/zensical-0.0.54-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:85ef75654e7845aa65f1392af771771566f33faac452a2aed004ba367454f812", size = 13534594, upload-time = "2026-08-13T16:04:41.006Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/f6/7a6f2a513054071e44a504d7157684f00ac5e5e5f741eadc78ab6c80642c/zensical-0.0.56-cp310-abi3-win32.whl", hash = "sha256:a06681046f74b5bdc506d22af8fcef505b2450e45538c7f01a5e028f4e50c6f7", size = 12433218, upload-time = "2026-08-18T15:46:42.329Z" },
+    { url = "https://files.pythonhosted.org/packages/14/70/be34910c13632f85911f505bd9a4d1bb53d46c8498d20ebb18570bbe4b7b/zensical-0.0.54-cp310-abi3-win32.whl", hash = "sha256:b56c80a8cd234666afb917fb1ed8467104f6857b1acabd66f60ef1b8a0daa66f", size = 12448180, upload-time = "2026-08-13T16:04:43.486Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ed/5b497c75fb1fd5845f3ec2f0b11b5e01f18f14c297041cd2f20d30d8b6a4/zensical-0.0.56-cp310-abi3-win_amd64.whl", hash = "sha256:c557985f12d042c15dcb7d577543d81ceee9281f96d591d265310b673437a325", size = 12702823, upload-time = "2026-08-18T15:46:44.836Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/c6/a965265946555023dc0e159a41038502190882669d177dfa59b1dd3d580b/zensical-0.0.54-cp310-abi3-win_amd64.whl", hash = "sha256:f5a602986c4123a349cfd075c8d494096a2a2db74422169d65f8092872e48dfa", size = 12712264, upload-time = "2026-08-13T16:04:46.155Z" },
 ]
 [[package]]
Author	SHA1	Message	Date
royjr	6252bc37b2	Update opendbc_repo	2026-08-18 01:01:24 -04:00
royjr	d1f3acf9d4	Merge branch 'master' into hens	2026-08-17 17:13:35 -04:00
royjr	6eb64fe64f	Update opendbc_repo	2026-08-17 17:09:57 -04:00
royjr	e0e2db4179	Update opendbc_repo	2026-08-17 09:41:13 -04:00
royjr	8d5f74b84a	Update opendbc_repo	2026-08-16 15:30:31 -04:00
`@@ -1,2 +1 @@`
	`DEFAULT_MODEL = "CD210"`	`DEFAULT_MODEL = "CD210"`
	`DEFAULT_BIG_MODEL = "Lebowski"`