fuck. i AM blind. or dumb. or both.

i might be blind
wtf. ghostwriter
2026-07-26 05:12:19 +08:00 · 2026-07-25 16:49:07 -04:00 · 2026-07-25 16:47:01 -04:00 · 2026-07-25 16:34:01 -04:00 · 2026-07-25 16:28:47 -04:00 · 2026-07-25 16:12:52 -04:00
265 changed files with 5044 additions and 4374 deletions
@@ -12,11 +12,11 @@ on:
        required: false
        type: string
      recompiled_dir:
-        description: 'Existing recompiled directory number (e.g. 3 for recompiled3)'
+        description: 'Existing recompiled directory number (e.g. 1 for recompiled1)'
        required: true
        type: string
      json_version:
-        description: 'driving_models version number to update (e.g. 5 for driving_models_v5.json)'
+        description: 'driving_models version number to update (e.g. 18 for driving_models_v18.json)'
        required: true
        type: string
      artifact_suffix:
@@ -63,12 +63,11 @@ on:
        default: 'None'
        options:
          - None
-          - Simple Plan Models
-          - Space Lab Models
-          - TR Models
-          - DTR Models
+          - Master Models
+          - Release Models
+          - 2025 World Models
+          - 2026 World Models
          - Custom Merge Models
-          - FOF series models
          - Other
      custom_model_folder:
        description: 'Custom model folder name (if "Other" selected)'
@@ -65,8 +65,21 @@ jobs:
          echo '    pushurl = ${{ env.LFS_PUSH_URL }}' >> .lfsconfig
          echo '    locksverify = false' >> .lfsconfig

+      - name: Configure LFS transfer settings
+        run: |
+          git config lfs.activitytimeout 300
+          git config lfs.transfer.maxretries 5
+          git config lfs.concurrenttransfers 4
+
      - name: Push LFS
        id: sync-and-commit
        run: |
          git lfs ls-files -l
-          git lfs push --all origin
+          for attempt in 1 2 3; do
+            echo "Push attempt $attempt..."
+            git lfs push --all origin && exit 0
+            echo "Attempt $attempt failed, retrying in 30s..."
+            sleep 30
+          done
+          echo "All push attempts failed"
+          exit 1
@@ -93,6 +93,14 @@ jobs:
            const { owner, repo } = context.repo;
            const upstream = `${owner}/${repo}`;

+            const closed = context.payload.pull_request;
+            if (closed) {
+              if (closed.head.repo?.full_name === upstream) {
+                await github.rest.git.deleteRef({ owner, repo, ref: `heads/${closed.head.ref}` }).catch(console.log);
+              }
+              return;
+            }
+
            for await (const response of github.paginate.iterator(github.rest.pulls.list, {
              owner,
              repo,
@@ -30,6 +30,11 @@ on:
        required: false
        type: string
        default: ''
+      target_hardware:
+        description: 'Hardware target to compile for (qcom or usbgpu)'
+        required: false
+        type: string
+        default: 'qcom'
  workflow_dispatch:
    inputs:
      upstream_branch:
@@ -46,6 +51,14 @@ on:
        required: false
        type: boolean
        default: true
+      target_hardware:
+        description: 'Hardware target to compile for'
+        required: true
+        type: choice
+        options:
+          - qcom
+          - usbgpu
+        default: 'qcom'


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

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

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

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

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

-      - name: Validate Model Outputs
-        run: |
-          source /etc/profile
-          export UV_PROJECT_ENVIRONMENT=${HOME}/venv
-          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
-          python3 "${{ github.workspace }}/release/ci/model_generator.py" \
-            --validate-only \
-            --model-dir "${{ env.MODELS_DIR }}"
-
      - name: Prepare Output
        run: |
          sudo rm -rf ${{ env.OUTPUT_DIR }}
@@ -166,6 +166,11 @@ env = Environment(
  tools=["default", "cython", "compilation_db", "rednose_filter"],
  toolpath=["#site_scons/site_tools", "#rednose_repo/site_scons/site_tools"],
 )
+# SCons' Darwin linker tool doesn't define the variables used to expand RPATH.
+if arch == "Darwin":
+  env["RPATHPREFIX"] = "-Wl,-rpath,"
+  env["RPATHSUFFIX"] = ""
+  env["_RPATH"] = "${_concat(RPATHPREFIX, RPATH, RPATHSUFFIX, __env__)}"
 if arch != "larch64":
  env['_LIBFLAGS'] = _libflags

@@ -16,7 +16,7 @@ export VECLIB_MAXIMUM_THREADS=1
 export QCOM_PRIORITY=12

 if [ -z "$AGNOS_VERSION" ]; then
-  export AGNOS_VERSION="18.4"
+  export AGNOS_VERSION="18.5"
 fi

 export STAGING_ROOT="/data/safe_staging"
@@ -137,10 +137,16 @@ struct ModelManagerSP @0xaedffd8f31e7b55d {
    eta @2 :UInt32;
  }

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

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

@@ -812,6 +812,7 @@ struct SelfdriveState {
    promptDistracted @8;

    preAlert @9;
+    complete @10;
  }

  enum OpenpilotState @0xdbe58b96d2d1ac61 {
@@ -2160,7 +2161,8 @@ struct DriverMonitoringStateDEPRECATED @0xb83cda094a1da284 {

 struct DriverMonitoringState {
  lockout @0 :Bool;
-  lockoutRecoveryPercent @11 :Int8;
+  lockoutCount @15 :Int8;
+  lockoutMinutesRemaining @11 :Int8;
  alert3Count @12 :Int8;
  noResponseCount @13 :Int8;
  noResponseForceDecel @14 :Bool;
@@ -7,12 +7,43 @@ import os
 import capnp
 import time

-from typing import Optional, List, Union, Dict
+from typing import Union

 from openpilot.cereal import log
 from openpilot.cereal.services import SERVICE_LIST
 from openpilot.common.utils import MovingAverage

+__all__ = (
+  "NO_TRAVERSAL_LIMIT",
+  "Context",
+  "FrequencyTracker",
+  "IpcError",
+  "MultiplePublishersError",
+  "Poller",
+  "PubMaster",
+  "PubSocket",
+  "SocketEventHandle",
+  "SubMaster",
+  "SubSocket",
+  "delete_fake_prefix",
+  "drain_sock",
+  "drain_sock_raw",
+  "fake_event_handle",
+  "get_fake_prefix",
+  "log_from_bytes",
+  "new_message",
+  "pub_sock",
+  "recv_one",
+  "recv_one_or_none",
+  "recv_one_retry",
+  "recv_sock",
+  "reset_context",
+  "set_fake_prefix",
+  "sub_sock",
+  "toggle_fake_events",
+  "wait_for_one_event",
+)
+
 NO_TRAVERSAL_LIMIT = 2**64-1


@@ -22,8 +53,8 @@ def pub_sock(endpoint: str) -> PubSocket:
  return msgq.pub_sock(endpoint, segment_size)


-def sub_sock(endpoint: str, poller: Optional[Poller] = None, addr: str = "127.0.0.1",
-             conflate: bool = False, timeout: Optional[int] = None) -> SubSocket:
+def sub_sock(endpoint: str, poller: Poller | None = None, addr: str = "127.0.0.1",
+             conflate: bool = False, timeout: int | None = None) -> SubSocket:
  service = SERVICE_LIST.get(endpoint)
  segment_size = service.queue_size if service else 0
  return msgq.sub_sock(endpoint, poller=poller, addr=addr, conflate=conflate,
@@ -39,7 +70,7 @@ def log_from_bytes(dat: bytes, struct: capnp.lib.capnp._StructModule = log.Event
    return msg


-def new_message(service: Optional[str], size: Optional[int] = None, **kwargs) -> capnp.lib.capnp._DynamicStructBuilder:
+def new_message(service: str | None, size: int | None = None, **kwargs) -> capnp.lib.capnp._DynamicStructBuilder:
  args = {
    'valid': False,
    'logMonoTime': int(time.monotonic() * 1e9),
@@ -54,14 +85,14 @@ def new_message(service: Optional[str], size: Optional[int] = None, **kwargs) ->
  return dat


-def drain_sock(sock: SubSocket, wait_for_one: bool = False) -> List[capnp.lib.capnp._DynamicStructReader]:
+def drain_sock(sock: SubSocket, wait_for_one: bool = False) -> list[capnp.lib.capnp._DynamicStructReader]:
  """Receive all message currently available on the queue"""
  msgs = drain_sock_raw(sock, wait_for_one=wait_for_one)
  return [log_from_bytes(m) for m in msgs]


 # TODO: print when we drop packets?
-def recv_sock(sock: SubSocket, wait: bool = False) -> Optional[capnp.lib.capnp._DynamicStructReader]:
+def recv_sock(sock: SubSocket, wait: bool = False) -> capnp.lib.capnp._DynamicStructReader | None:
  """Same as drain sock, but only returns latest message. Consider using conflate instead."""
  dat = None

@@ -82,14 +113,14 @@ def recv_sock(sock: SubSocket, wait: bool = False) -> Optional[capnp.lib.capnp._
  return dat


-def recv_one(sock: SubSocket) -> Optional[capnp.lib.capnp._DynamicStructReader]:
+def recv_one(sock: SubSocket) -> capnp.lib.capnp._DynamicStructReader | None:
  dat = sock.receive()
  if dat is not None:
    dat = log_from_bytes(dat)
  return dat


-def recv_one_or_none(sock: SubSocket) -> Optional[capnp.lib.capnp._DynamicStructReader]:
+def recv_one_or_none(sock: SubSocket) -> capnp.lib.capnp._DynamicStructReader | None:
  dat = sock.receive(non_blocking=True)
  if dat is not None:
    dat = log_from_bytes(dat)
@@ -148,27 +179,27 @@ class FrequencyTracker:


 class SubMaster:
-  def __init__(self, services: List[str], poll: Optional[str] = None,
-               ignore_alive: Optional[List[str]] = None, ignore_avg_freq: Optional[List[str]] = None,
-               ignore_valid: Optional[List[str]] = None, addr: str = "127.0.0.1", frequency: Optional[float] = None):
+  def __init__(self, services: list[str], poll: str | None = None,
+               ignore_alive: list[str] | None = None, ignore_avg_freq: list[str] | None = None,
+               ignore_valid: list[str] | None = None, addr: str = "127.0.0.1", frequency: float | None = None):
    self.frame = -1
    self.services = services
-    self.seen = {s: False for s in services}
-    self.updated = {s: False for s in services}
-    self.recv_time = {s: 0. for s in services}
-    self.recv_frame = {s: 0 for s in services}
+    self.seen = dict.fromkeys(services, False)
+    self.updated = dict.fromkeys(services, False)
+    self.recv_time = dict.fromkeys(services, 0.0)
+    self.recv_frame = dict.fromkeys(services, 0)
    self.sock = {}
    self.data = {}
-    self.logMonoTime = {s: 0 for s in services}
+    self.logMonoTime = dict.fromkeys(services, 0)

    # zero-frequency / on-demand services are always alive and presumed valid; all others must pass checks
    on_demand = {s: SERVICE_LIST[s].frequency <= 1e-5 for s in services}
-    self.static_freq_services = set(s for s in services if not on_demand[s])
+    self.static_freq_services = {s for s in services if not on_demand[s]}
    self.alive = {s: on_demand[s] for s in services}
    self.freq_ok = {s: on_demand[s] for s in services}
    self.valid = {s: on_demand[s] for s in services}

-    self.freq_tracker: Dict[str, FrequencyTracker] = {}
+    self.freq_tracker: dict[str, FrequencyTracker] = {}
    self.poller = Poller()
    polled_services = set([poll, ] if poll is not None else services)
    self.non_polled_services = set(services) - polled_services
@@ -211,7 +242,7 @@ class SubMaster:
      msgs.append(recv_one_or_none(self.sock[s]))
    self.update_msgs(time.monotonic(), msgs)

-  def update_msgs(self, cur_time: float, msgs: List[capnp.lib.capnp._DynamicStructReader]) -> None:
+  def update_msgs(self, cur_time: float, msgs: list[capnp.lib.capnp._DynamicStructReader]) -> None:
    self.frame += 1
    self.updated = dict.fromkeys(self.services, False)
    for msg in msgs:
@@ -234,21 +265,21 @@ class SubMaster:
      self.alive[s] = (cur_time - self.recv_time[s]) < (10. / SERVICE_LIST[s].frequency) or (self.seen[s] and self.simulation)
      self.freq_ok[s] = self.freq_tracker[s].valid or self.simulation

-  def all_alive(self, service_list: Optional[List[str]] = None) -> bool:
+  def all_alive(self, service_list: list[str] | None = None) -> bool:
    return all(self.alive[s] for s in (service_list or self.services) if s not in self.ignore_alive)

-  def all_freq_ok(self, service_list: Optional[List[str]] = None) -> bool:
+  def all_freq_ok(self, service_list: list[str] | None = None) -> bool:
    return all(self.freq_ok[s] for s in (service_list or self.services) if self._check_avg_freq(s))

-  def all_valid(self, service_list: Optional[List[str]] = None) -> bool:
+  def all_valid(self, service_list: list[str] | None = None) -> bool:
    return all(self.valid[s] for s in (service_list or self.services) if s not in self.ignore_valid)

-  def all_checks(self, service_list: Optional[List[str]] = None) -> bool:
+  def all_checks(self, service_list: list[str] | None = None) -> bool:
    return self.all_alive(service_list) and self.all_freq_ok(service_list) and self.all_valid(service_list)


 class PubMaster:
-  def __init__(self, services: List[str]):
+  def __init__(self, services: list[str]):
    self.sock = {}
    for s in services:
      self.sock[s] = pub_sock(s)
@@ -1,4 +1,3 @@
-import os
 import capnp
 import multiprocessing
 import numbers
@@ -6,7 +5,6 @@ import random
 import threading
 import time
 from openpilot.common.parameterized import parameterized
-import pytest

 from openpilot.cereal import log
 from opendbc.car.structs import car
@@ -24,10 +22,6 @@ def random_socks(num_socks=10):
 def random_bytes(length=1000):
  return bytes([random.randrange(0xFF) for _ in range(length)])

-def zmq_sleep(t=1):
-  if "ZMQ" in os.environ:
-    time.sleep(t)
-

 # TODO: this should take any capnp struct and returrn a msg with random populated data
 def random_carstate():
@@ -53,16 +47,6 @@ def delayed_send(delay, sock, dat):


 class TestMessaging:
-  def setUp(self):
-    # TODO: ZMQ tests are too slow; all sleeps will need to be
-    # replaced with logic to block on the necessary condition
-    if "ZMQ" in os.environ:
-      pytest.skip()
-
-    # ZMQ pub socket takes too long to die
-    # sleep to prevent multiple publishers error between tests
-    zmq_sleep()
-
  @parameterized.expand(events)
  def test_new_message(self, evt):
    try:
@@ -89,7 +73,6 @@ class TestMessaging:
    sock = "carState"
    pub_sock = messaging.pub_sock(sock)
    sub_sock = messaging.sub_sock(sock, timeout=1000)
-    zmq_sleep()

    # no wait and no msgs in queue
    msgs = func(sub_sock)
@@ -110,7 +93,6 @@ class TestMessaging:
    sock = "carState"
    pub_sock = messaging.pub_sock(sock)
    sub_sock = messaging.sub_sock(sock, timeout=100)
-    zmq_sleep()

    # no wait and no msg in queue, socket should timeout
    recvd = messaging.recv_sock(sub_sock)
@@ -129,7 +111,6 @@ class TestMessaging:
    sock = "carState"
    pub_sock = messaging.pub_sock(sock)
    sub_sock = messaging.sub_sock(sock, timeout=1000)
-    zmq_sleep()

    # no msg in queue, socket should timeout
    recvd = messaging.recv_one(sub_sock)
@@ -142,12 +123,10 @@ class TestMessaging:
    assert isinstance(recvd, capnp._DynamicStructReader)
    assert_carstate(msg.carState, recvd.carState)

-  @pytest.mark.xfail(condition="ZMQ" in os.environ, reason='ZMQ detected')
  def test_recv_one_or_none(self):
    sock = "carState"
    pub_sock = messaging.pub_sock(sock)
    sub_sock = messaging.sub_sock(sock)
-    zmq_sleep()

    # no msg in queue, socket shouldn't block
    recvd = messaging.recv_one_or_none(sub_sock)
@@ -165,16 +144,13 @@ class TestMessaging:
    sock_timeout = 0.1
    pub_sock = messaging.pub_sock(sock)
    sub_sock = messaging.sub_sock(sock, timeout=round(sock_timeout*1000))
-    zmq_sleep()

-    # this test doesn't work with ZMQ since multiprocessing interrupts it
-    if "ZMQ" not in os.environ:
-      # wait 5 socket timeouts and make sure it's still retrying
-      p = multiprocessing.Process(target=messaging.recv_one_retry, args=(sub_sock,))
-      p.start()
-      time.sleep(sock_timeout*5)
-      assert p.is_alive()
-      p.terminate()
+    # wait 5 socket timeouts and make sure it's still retrying
+    p = multiprocessing.Process(target=messaging.recv_one_retry, args=(sub_sock,))
+    p.start()
+    time.sleep(sock_timeout*5)
+    assert p.is_alive()
+    p.terminate()

    # wait 5 socket timeouts before sending
    msg = random_carstate()
@@ -1,21 +1,16 @@
 import random
 import time
-from typing import Sized, cast
+from typing import cast
+from collections.abc import Sized

 import openpilot.cereal.messaging as messaging
 from openpilot.cereal.messaging.tests.test_messaging import events, random_sock, random_socks, \
-                                                  random_bytes, random_carstate, assert_carstate, \
-                                                  zmq_sleep
+                                                  random_bytes, random_carstate, assert_carstate
 from openpilot.cereal.services import SERVICE_LIST


 class TestSubMaster:

-  def setup_method(self):
-    # ZMQ pub socket takes too long to die
-    # sleep to prevent multiple publishers error between tests
-    zmq_sleep(3)
-
  def test_init(self):
    sm = messaging.SubMaster(events)
    for p in [sm.updated, sm.recv_time, sm.recv_frame, sm.alive,
@@ -42,7 +37,6 @@ class TestSubMaster:
    sock = "carState"
    pub_sock = messaging.pub_sock(sock)
    sm = messaging.SubMaster([sock,])
-    zmq_sleep()

    msg = random_carstate()
    pub_sock.send(msg.to_bytes())
@@ -54,7 +48,6 @@ class TestSubMaster:
    sock = "carState"
    pub_sock = messaging.pub_sock(sock)
    sm = messaging.SubMaster([sock,])
-    zmq_sleep()

    for i in range(10):
      msg = messaging.new_message(sock)
@@ -91,21 +84,13 @@ class TestSubMaster:

      for service, (max_freq, min_freq) in checks.items():
        if max_freq is not None:
+          assert min_freq is not None
          assert sm._check_avg_freq(service)
          assert sm.freq_tracker[service].max_freq == max_freq*1.2
          assert sm.freq_tracker[service].min_freq == min_freq*0.8
        else:
          assert not sm._check_avg_freq(service)

-  def test_alive(self):
-    pass
-
-  def test_ignore_alive(self):
-    pass
-
-  def test_valid(self):
-    pass
-
  # SubMaster should always conflate
  def test_conflate(self):
    sock = "carState"
@@ -124,11 +109,6 @@ class TestSubMaster:

 class TestPubMaster:

-  def setup_method(self):
-    # ZMQ pub socket takes too long to die
-    # sleep to prevent multiple publishers error between tests
-    zmq_sleep(3)
-
  def test_init(self):
    messaging.PubMaster(events)

@@ -136,7 +116,6 @@ class TestPubMaster:
    socks = random_socks()
    pm = messaging.PubMaster(socks)
    sub_socks = {s: messaging.sub_sock(s, conflate=True, timeout=1000) for s in socks}
-    zmq_sleep()

    # PubMaster accepts either a capnp msg builder or bytes
    for capnp in [True, False]:
@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
 from enum import IntEnum
-from typing import Optional


 # TODO: this should be automatically determined using the capnp schema
@@ -11,7 +10,7 @@ class QueueSize(IntEnum):


 class Service:
-  def __init__(self, should_log: bool, frequency: float, decimation: Optional[int] = None,
+  def __init__(self, should_log: bool, frequency: float, decimation: int | None = None,
               queue_size: QueueSize = QueueSize.SMALL):
    self.should_log = should_log
    self.frequency = frequency
@@ -125,8 +124,7 @@ def build_header():
  for k, v in SERVICE_LIST.items():
    should_log = "true" if v.should_log else "false"
    decimation = -1 if v.decimation is None else v.decimation
-    h += '  { "%s", {"%s", %s, %f, %d, %d}},\n' % \
-         (k, k, should_log, v.frequency, decimation, v.queue_size)
+    h += f'  {{ "{k}", {{"{k}", {should_log}, {v.frequency:f}, {decimation:d}, {v.queue_size:d}}}}},\n'
  h += "};\n"

  h += "#endif\n"
@@ -38,6 +38,7 @@ class BaseApi:
    }
    if payload_extra is not None:
      payload.update(payload_extra)
+    assert self.private_key is not None
    token = jwt.encode(payload, self.private_key, algorithm=self.jwt_algorithm)
    if isinstance(token, bytes):
      token = token.decode('utf8')
@@ -42,25 +42,26 @@ def get_existing_chunks(path):
 class ChunkStream(io.RawIOBase):
  def __init__(self, paths):
    self._paths = iter(paths)
-    self._buf = memoryview(b'')
+    self._f = None

  def readable(self):
    return True

  def readinto(self, b):
    n = 0
+    view = memoryview(b)
    while n < len(b):
-      if not self._buf:
+      if self._f is None:
        p = next(self._paths, None)
        if p is None:
          break
-        with open(p, 'rb') as f:
-          self._buf = memoryview(f.read())
+        self._f = open(p, 'rb')
+      count = self._f.readinto(view[n:])
+      if not count:
+        self._f.close()
+        self._f = None
        continue
-      take = min(len(b) - n, len(self._buf))
-      b[n:n + take] = self._buf[:take]
-      self._buf = self._buf[take:]
-      n += take
+      n += count
    return n

 def open_file_chunked(path):
@@ -56,28 +56,28 @@
  },
  {
    "name": "boot",
-    "url": "https://commadist.azureedge.net/agnosupdate/boot-8806802b195a5b1396a3ae8dd92a8b7711dc522f6aceafd820e871bae5c8a6d8.img.xz",
-    "hash": "8806802b195a5b1396a3ae8dd92a8b7711dc522f6aceafd820e871bae5c8a6d8",
-    "hash_raw": "8806802b195a5b1396a3ae8dd92a8b7711dc522f6aceafd820e871bae5c8a6d8",
+    "url": "https://commadist.azureedge.net/agnosupdate/boot-19ff57b68e219e4503fcaca716967098d5d0a1de8af833f04dbf13b99aeb4d39.img.xz",
+    "hash": "19ff57b68e219e4503fcaca716967098d5d0a1de8af833f04dbf13b99aeb4d39",
+    "hash_raw": "19ff57b68e219e4503fcaca716967098d5d0a1de8af833f04dbf13b99aeb4d39",
    "size": 17487872,
    "sparse": false,
    "full_check": true,
    "has_ab": true,
-    "ondevice_hash": "edca8bee1531e66953d107eeceeed2dc7b3ca46417e49d55508f94e58bf95db8"
+    "ondevice_hash": "ddfe93cc6a8531af92ee331d9bbaeae2f1d933bdb38e579769dc9fe7998eb626"
  },
  {
    "name": "system",
-    "url": "https://commadist.azureedge.net/agnosupdate/system-ef0d879302cb29e72110e9c8d3f947c830fd7d37c8192744fc9dbea1af78501f.img.xz",
-    "hash": "78acfe16a7b62a3a91fc7a81f40a693e4468cec1c69df7d0b1e550aacc646113",
-    "hash_raw": "ef0d879302cb29e72110e9c8d3f947c830fd7d37c8192744fc9dbea1af78501f",
+    "url": "https://commadist.azureedge.net/agnosupdate/system-a396dd98ffd49614fb198d1b022a0c7a6d0a1e563c20ce11b0a975105ab50724.img.xz",
+    "hash": "4dc41c2c072f5f5d5cd484cd6173049cd96acfb9a67bc20049775585fe881539",
+    "hash_raw": "a396dd98ffd49614fb198d1b022a0c7a6d0a1e563c20ce11b0a975105ab50724",
    "size": 4718592000,
    "sparse": true,
    "full_check": false,
    "has_ab": true,
-    "ondevice_hash": "743142c5a898f27b2a1029cca42c8a5d5d1fc0096414422b850fe84c8d0b8342",
+    "ondevice_hash": "cf1229630b7a2b8497705bca4ba947dbf0c217418ff4febff571aa4f4a878134",
    "alt": {
-      "hash": "ef0d879302cb29e72110e9c8d3f947c830fd7d37c8192744fc9dbea1af78501f",
-      "url": "https://commadist.azureedge.net/agnosupdate/system-ef0d879302cb29e72110e9c8d3f947c830fd7d37c8192744fc9dbea1af78501f.img",
+      "hash": "a396dd98ffd49614fb198d1b022a0c7a6d0a1e563c20ce11b0a975105ab50724",
+      "url": "https://commadist.azureedge.net/agnosupdate/system-a396dd98ffd49614fb198d1b022a0c7a6d0a1e563c20ce11b0a975105ab50724.img",
      "size": 4718592000
    }
  }
@@ -19,7 +19,7 @@ class StreamingDecompressor:
  def __init__(self, url: str) -> None:
    self.buf = b""

-    self.req = requests.get(url, stream=True, headers={'Accept-Encoding': None}, timeout=60)
+    self.req = requests.get(url, stream=True, headers={'Accept-Encoding': 'identity'}, timeout=60)
    self.it = self.req.iter_content(chunk_size=1024 * 1024)
    self.decompressor = lzma.LZMADecompressor(format=lzma.FORMAT_AUTO)
    self.eof = False
@@ -339,7 +339,7 @@ class Tici(HardwareBase):

    # Ensure fan gpio is enabled so fan runs until shutdown, also turned on at boot by the ABL
    gpio_init(GPIO.SOM_ST_IO, True)
-    gpio_set(GPIO.SOM_ST_IO, 1)
+    gpio_set(GPIO.SOM_ST_IO, True)

    # *** IRQ config ***

@@ -389,21 +389,21 @@ class Tici(HardwareBase):
    gpio_init(GPIO.STM_RST_N, True)
    gpio_init(GPIO.STM_BOOT0, True)

-    gpio_set(GPIO.STM_RST_N, 1)
-    gpio_set(GPIO.STM_BOOT0, 0)
+    gpio_set(GPIO.STM_RST_N, True)
+    gpio_set(GPIO.STM_BOOT0, False)
    time.sleep(0.01)
-    gpio_set(GPIO.STM_RST_N, 0)
+    gpio_set(GPIO.STM_RST_N, False)

  def recover_internal_panda(self):
    gpio_init(GPIO.STM_RST_N, True)
    gpio_init(GPIO.STM_BOOT0, True)

-    gpio_set(GPIO.STM_RST_N, 1)
-    gpio_set(GPIO.STM_BOOT0, 1)
+    gpio_set(GPIO.STM_RST_N, True)
+    gpio_set(GPIO.STM_BOOT0, True)
    time.sleep(0.01)
-    gpio_set(GPIO.STM_RST_N, 0)
+    gpio_set(GPIO.STM_RST_N, False)
    time.sleep(0.01)
-    gpio_set(GPIO.STM_BOOT0, 0)
+    gpio_set(GPIO.STM_BOOT0, False)

  def booted(self):
    # this normally boots within 8s, but on rare occasions takes 30+s
@@ -52,7 +52,7 @@ PPPD_CMD = [
  "novj", "novjccomp", "ipcp-accept-local", "ipcp-accept-remote", "nomagic",
  "user", '""', "password", '""',
 ]
-INITIAL_STATE = {
+INITIAL_STATE: dict[str, object] = {
  "seconds_since_boot": 0,
  "state": "INITIALIZING",
  "connected": False, "ip_address": "",
@@ -37,6 +37,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"DoShutdown", {CLEAR_ON_MANAGER_START, BOOL}},
    {"DoUninstall", {CLEAR_ON_MANAGER_START, BOOL}},
    {"DriverTooDistracted", {CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_ON, BOOL}},
+    {"DriverLockoutCount", {CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_ON, INT, "0"}},
    {"AlphaLongitudinalEnabled", {PERSISTENT | DEVELOPMENT_ONLY | BACKUP, BOOL}},
    {"ExperimentalMode", {PERSISTENT | BACKUP, BOOL}},
    {"ExperimentalModeConfirmed", {PERSISTENT | BACKUP, BOOL}},
@@ -1,11 +1,13 @@
 import numpy as np
-from numbers import Number
+from collections.abc import Sequence
+
+Gain = int | float | tuple[Sequence[float], Sequence[float]] | list[list[float]]

 class PIDController:
-  def __init__(self, k_p, k_i, k_d=0., pos_limit=1e308, neg_limit=-1e308, rate=100):
-    self._k_p: list[list[float]] = [[0], [k_p]] if isinstance(k_p, Number) else k_p
-    self._k_i: list[list[float]] = [[0], [k_i]] if isinstance(k_i, Number) else k_i
-    self._k_d: list[list[float]] = [[0], [k_d]] if isinstance(k_d, Number) else k_d
+  def __init__(self, k_p: Gain, k_i: Gain, k_d: Gain = 0., pos_limit=1e308, neg_limit=-1e308, rate=100):
+    self._k_p = ([0], [k_p]) if isinstance(k_p, (int, float)) else k_p
+    self._k_i = ([0], [k_i]) if isinstance(k_i, (int, float)) else k_i
+    self._k_d = ([0], [k_d]) if isinstance(k_d, (int, float)) else k_d

    self.set_limits(pos_limit, neg_limit)

@@ -27,7 +27,7 @@ class SwaglogRotatingFileHandler(BaseRotatingHandler):
    self.log_files = self.get_existing_logfiles()
    log_indexes = [f.split(".")[-1] for f in self.log_files]
    self.last_file_idx = max([int(i) for i in log_indexes if i.isdigit()] or [-1])
-    self.last_rollover = None
+    self.last_rollover = 0.0
    self.doRollover()

  def _open(self):
@@ -39,7 +39,7 @@ class SwaglogRotatingFileHandler(BaseRotatingHandler):
    return stream

  def get_existing_logfiles(self):
-    log_files = list()
+    log_files = []
    base_dir = os.path.dirname(self.base_filename)
    for fn in os.listdir(base_dir):
      fp = os.path.join(base_dir, fn)
@@ -112,14 +112,14 @@ class TestParams:
  def test_params_default_value(self):
    self.params.remove("LanguageSetting")
    self.params.remove("LongitudinalPersonality")
-    self.params.remove("LiveParameters")
+    self.params.remove("LiveParametersV2")

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

  def test_params_get_type(self):
    # json
@@ -52,7 +52,7 @@ _ar_ox_config = DeviceCameraConfig(CameraConfig(1928, 1208, 2648.0), _ar_ox_fish
 _os_config = DeviceCameraConfig(CameraConfig(2688 // 2, 1520 // 2, 1522.0 * 3 / 4), _os_fisheye, _os_fisheye)
 _neo_config = DeviceCameraConfig(CameraConfig(1164, 874, 910.0), CameraConfig(816, 612, 650.0), _NoneCameraConfig())

-DEVICE_CAMERAS = {
+DEVICE_CAMERAS: dict[tuple[str, str], DeviceCameraConfig] = {
  # A "device camera" is defined by a device type and sensor

  # sensor type was never set on eon/neo/two
@@ -176,4 +176,3 @@ def img_from_device(pt_device):

  pt_img = pt_view/pt_view[:, 2:3]
  return pt_img.reshape(input_shape)[:, :2]
-
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3027da9834adf9c71177bc3086f8de3018ce22e4725b694d635723c5b3c860cd
+size 97120
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca29ff46fbd6d00cc02596de8c9abfbf1cacdc6a7b2f98b27a74d24c790da004
+size 52374
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:42bd04a57b527c787a0555503e02a203f7d672c12d448769a3f41f17befbf013
-size 48044
+oid sha256:6f47633b5082b911e79dd13fc2d1f4c2a9d44d2fe0860f3d390ffc4e3d772f7d
+size 97120
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:538271820d618046009bb456e930598f2736dd1a6174c11925ec3912581b05c1
+size 52374
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:634fad6590295ef2e73d5f7e5aecbb5dd245a0f7692f1e300c2ebac95aabb8e3
+size 73026
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b1e177499d9439367179cc57a6301b6162393972e3a136cc35c5fdac026bf10a
-size 48044
+oid sha256:a380fe0a022856b302841a0dd19b71eab318c6b08ec851f128942758a7f1631a
+size 97120
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2c0af7f5fe57bb36ab96fae868e20feca763541c97a61b3a3a84a0e7fcb81163
-size 83350
+oid sha256:cc9e67cfaba77e8e4f4049f0add9238660e4cf8f886c6915600d8f47a30c98db
+size 97120
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ad19268e4aaaeac8dd21f6b26c16a121e7b3f50bba867748e7226727643ae682
-size 144642
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:412ef25d2fb103c1ebd55c667313a5921493305fb4e1f4e1dafc08d3b95d86ab
-size 73026
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4af81cbf1d96a42cc351878b015298aee82874b46baaf1a615ca91ec36c0ced6
-size 83228
+oid sha256:081d64ca28a84a59ff5e6aea4732865b8687585938b8a287bc7e6a49d0646508
+size 97120
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bb440f424c989c06e203bfba0b32d39aede8f6c78a9b335e5e778460202b601
+size 73026
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5a390831afca3bfc6ea3c2739b872ebf866e70df8ae30653f8587e5cd3993959
-size 68306
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:67e636d072703e6b1233a12344c0a6304fd43d64dbb31c66b71c2c8870a339c1
-size 153764
@@ -3,7 +3,7 @@ import copy
 import os
 import pytest
 import random
-import unittest # noqa: TID251
+import unittest
 from collections import defaultdict, Counter
 import hypothesis.strategies as st
 from hypothesis import Phase, given, settings
@@ -22,6 +22,7 @@ from openpilot.selfdrive.pandad import can_capnp_to_list
 from openpilot.selfdrive.test.helpers import read_segment_list
 from openpilot.common.hardware.hw import DEFAULT_DOWNLOAD_CACHE_ROOT
 from openpilot.tools.lib.logreader import LogReader, LogsUnavailable, openpilotci_source, internal_source, comma_api_source
+from openpilot.tools.lib.file_sources import Source
 from openpilot.tools.lib.route import SegmentName

 SafetyModel = car.CarParams.SafetyModel
@@ -131,7 +132,7 @@ class TestCarModelBase(unittest.TestCase):
      segment_range = f"{cls.test_route.route}/{seg}"

      try:
-        sources = [internal_source] if len(INTERNAL_SEG_LIST) else [openpilotci_source, comma_api_source]
+        sources: list[Source] = [internal_source] if len(INTERNAL_SEG_LIST) else [openpilotci_source, comma_api_source]
        lr = LogReader(segment_range, sources=sources, sort_by_time=True)
        return cls.get_testing_data_from_logreader(lr)
      except (LogsUnavailable, AssertionError):
@@ -257,7 +258,7 @@ class TestCarModelBase(unittest.TestCase):

      # Don't check relay malfunction on disabled routes (relay closed),
      # or before fingerprinting is done (elm327 and noOutput)
-      if self.openpilot_enabled and t / 1e4 > self.car_safety_mode_frame:
+      if self.car_safety_mode_frame is not None and t / 1e4 > self.car_safety_mode_frame:
        self.assertFalse(self.safety.get_relay_malfunction())
      else:
        self.safety.set_relay_malfunction(False)
@@ -451,7 +452,7 @@ class TestCarModelBase(unittest.TestCase):
      # TODO: remove this exception once this mismatch is resolved
      brake_pressed = CS.brakePressed
      if CS.brakePressed and not self.safety.get_brake_pressed_prev():
-        if self.CP.carFingerprint in (HONDA.HONDA_PILOT, HONDA.HONDA_RIDGELINE) and CS.brakeDEPRECATED > 0.05:
+        if self.CP.carFingerprint in (HONDA.HONDA_PILOT, HONDA.HONDA_RIDGELINE) and CS.deprecated.brake > 0.05:
          brake_pressed = False
      checks['brakePressed'] += brake_pressed != self.safety.get_brake_pressed_prev()
      checks['regenBraking'] += CS.regenBraking != self.safety.get_regen_braking_prev()
@@ -15,6 +15,9 @@ MAX_LATERAL_JERK = 5.0  # m/s^3
 MAX_LATERAL_ACCEL_NO_ROLL = 3.0  # m/s^2


+def should_stop(v_ego: float, a_target: float) -> bool:
+  return bool(v_ego < 0.25 and a_target < 0.1)
+
 def clamp(val, min_val, max_val):
  clamped_val = float(np.clip(val, min_val, max_val))
  return clamped_val, clamped_val != val
@@ -40,7 +43,7 @@ def clip_curvature(v_ego, prev_curvature, new_curvature, roll) -> tuple[float, b
  return float(new_curvature), limited_accel or limited_max_curv


-def get_accel_from_plan(speeds, accels, t_idxs, action_t=DT_MDL, vEgoStopping=0.3):
+def get_accel_from_plan(speeds, accels, t_idxs, action_t=DT_MDL):
  if len(speeds) == len(t_idxs):
    v_now = speeds[0]
    a_now = accels[0]
@@ -53,8 +56,7 @@ def get_accel_from_plan(speeds, accels, t_idxs, action_t=DT_MDL, vEgoStopping=0.
    v_now = 0.0
    v_target = 0.0
    a_target = 0.0
-  should_stop = (v_now < vEgoStopping and a_target < 0.1)
-  return a_target, should_stop
+  return a_target, should_stop(v_now, a_target)

 def curv_from_psis(psi_target, psi_rate, vego, action_t):
  vego = np.clip(vego, MIN_SPEED, np.inf)
@@ -14,7 +14,7 @@ class LatControl(ABC):
    self.steer_max = 1.0

  @abstractmethod
-  def update(self, active: bool, CS, VM, params, steer_limited_by_safety: bool, desired_curvature: float, calibrated_pose: Pose,
+  def update(self, active: bool, CS, VM, params, steer_limited_by_safety: bool, desired_curvature: float, calibrated_pose: Pose | None,
             curvature_limited: bool, lat_delay: float):
    pass

@@ -10,7 +10,7 @@ CONTROL_N_T_IDX = ModelConstants.T_IDXS[:CONTROL_N]
 LongCtrlState = car.CarControl.Actuators.LongControlState


-def long_control_state_trans(CP, CP_SP, active, long_control_state, v_ego,
+def long_control_state_trans(CP_SP, active, long_control_state,
                             should_stop, brake_pressed, cruise_standstill):
  # Gas Interceptor
  cruise_standstill = cruise_standstill and not CP_SP.enableGasInterceptor
@@ -26,22 +26,17 @@ def long_control_state_trans(CP, CP_SP, active, long_control_state, v_ego,
    if long_control_state == LongCtrlState.off:
      if not starting_condition:
        long_control_state = LongCtrlState.stopping
-      elif CP.startingState:
-        long_control_state = LongCtrlState.starting
      else:
        long_control_state = LongCtrlState.pid

    elif long_control_state == LongCtrlState.stopping:
-      if starting_condition and CP.startingState:
-        long_control_state = LongCtrlState.starting
-      elif starting_condition:
+      if starting_condition:
        long_control_state = LongCtrlState.pid

-    elif long_control_state in [LongCtrlState.starting, LongCtrlState.pid]:
+    elif long_control_state == LongCtrlState.pid:
      if should_stop:
        long_control_state = LongCtrlState.stopping
-      elif v_ego > CP.vEgoStarting:
-        long_control_state = LongCtrlState.pid
+
  return long_control_state

 class LongControl:
@@ -62,7 +57,7 @@ class LongControl:
    self.pid.neg_limit = accel_limits[0]
    self.pid.pos_limit = accel_limits[1]

-    self.long_control_state = long_control_state_trans(self.CP, self.CP_SP, active, self.long_control_state, CS.vEgo,
+    self.long_control_state = long_control_state_trans(self.CP_SP, active, self.long_control_state,
                                                       should_stop, CS.brakePressed,
                                                       CS.cruiseState.standstill)
    if self.long_control_state == LongCtrlState.off:
@@ -73,11 +68,8 @@ class LongControl:
      output_accel = self.last_output_accel
      if output_accel > self.CP.stopAccel:
        output_accel = min(output_accel, 0.0)
-        output_accel -= self.CP.stoppingDecelRate * DT_CTRL
-      self.reset()
-
-    elif self.long_control_state == LongCtrlState.starting:
-      output_accel = self.CP.startAccel
+        # TODO: can we just go straight to stopAccel?
+        output_accel -= 1.0 * DT_CTRL  # m/s^2/s while trying to stop
      self.reset()

    else:  # LongCtrlState.pid
@@ -137,7 +137,7 @@ class LongitudinalPlanner(LongitudinalPlannerSP):

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

@@ -158,7 +158,7 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
  def publish(self, sm, pm):
    plan_send = messaging.new_message('longitudinalPlan')

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

    longitudinalPlan = plan_send.longitudinalPlan
    longitudinalPlan.modelMonoTime = sm.logMonoTime['modelV2']
@@ -23,13 +23,14 @@ def main():
  cloudlog.info("plannerd got CarParamsSP")

  gps_location_service = get_gps_location_service(params)
+  ignore_services = ["liveMapDataSP", gps_location_service]

  ldw = LaneDepartureWarning()
  longitudinal_planner = LongitudinalPlanner(CP, CP_SP)
  pm = messaging.PubMaster(['longitudinalPlan', 'driverAssistance', 'longitudinalPlanSP'])
  sm = messaging.SubMaster(['carControl', 'carState', 'controlsState', 'liveParameters', 'radarState', 'modelV2', 'selfdriveState',
                            'liveMapDataSP', 'carStateSP', gps_location_service],
-                           poll='carState')
+                           poll='carState', ignore_alive=ignore_services, ignore_avg_freq=ignore_services, ignore_valid=ignore_services)

  while True:
    sm.update()
@@ -40,7 +41,7 @@ def main():

      ldw.update(sm.frame, sm['modelV2'], sm['carState'], sm['carControl'])
      msg = messaging.new_message('driverAssistance')
-      msg.valid = sm.all_checks()
+      msg.valid = sm.all_checks(['carState', 'carControl', 'modelV2', 'liveParameters'])
      msg.driverAssistance.leftLaneDeparture = ldw.left
      msg.driverAssistance.rightLaneDeparture = ldw.right
      pm.send('driverAssistance', msg)
@@ -1,60 +1,43 @@
 from openpilot.cereal import custom
-from opendbc.car.structs import car
 from openpilot.selfdrive.controls.lib.longcontrol import LongCtrlState, long_control_state_trans


-
-
 class TestLongControlStateTransition:

  def test_stay_stopped(self):
-    CP = car.CarParams.new_message()
    CP_SP = custom.CarParamsSP.new_message()
    active = True
    current_state = LongCtrlState.stopping
-    next_state = long_control_state_trans(CP, CP_SP, active, current_state, v_ego=0.1,
+    next_state = long_control_state_trans(CP_SP, active, current_state,
                             should_stop=True, brake_pressed=False, cruise_standstill=False)
    assert next_state == LongCtrlState.stopping
-    next_state = long_control_state_trans(CP, CP_SP, active, current_state, v_ego=0.1,
+    next_state = long_control_state_trans(CP_SP, active, current_state,
                             should_stop=False, brake_pressed=True, cruise_standstill=False)
    assert next_state == LongCtrlState.stopping
-    next_state = long_control_state_trans(CP, CP_SP, active, current_state, v_ego=0.1,
+    next_state = long_control_state_trans(CP_SP, active, current_state,
                             should_stop=False, brake_pressed=False, cruise_standstill=True)
    assert next_state == LongCtrlState.stopping
-    next_state = long_control_state_trans(CP, CP_SP, active, current_state, v_ego=1.0,
+    next_state = long_control_state_trans(CP_SP, active, current_state,
                             should_stop=False, brake_pressed=False, cruise_standstill=False)
    assert next_state == LongCtrlState.pid
    active = False
-    next_state = long_control_state_trans(CP, CP_SP, active, current_state, v_ego=1.0,
+    next_state = long_control_state_trans(CP_SP, active, current_state,
                             should_stop=False, brake_pressed=False, cruise_standstill=False)
    assert next_state == LongCtrlState.off

 def test_engage():
-  CP = car.CarParams.new_message()
  CP_SP = custom.CarParamsSP.new_message()
  active = True
  current_state = LongCtrlState.off
-  next_state = long_control_state_trans(CP, CP_SP, active, current_state, v_ego=0.1,
+  next_state = long_control_state_trans(CP_SP, active, current_state,
                             should_stop=True, brake_pressed=False, cruise_standstill=False)
  assert next_state == LongCtrlState.stopping
-  next_state = long_control_state_trans(CP, CP_SP, active, current_state, v_ego=0.1,
+  next_state = long_control_state_trans(CP_SP, active, current_state,
                             should_stop=False, brake_pressed=True, cruise_standstill=False)
  assert next_state == LongCtrlState.stopping
-  next_state = long_control_state_trans(CP, CP_SP, active, current_state, v_ego=0.1,
+  next_state = long_control_state_trans(CP_SP, active, current_state,
                             should_stop=False, brake_pressed=False, cruise_standstill=True)
  assert next_state == LongCtrlState.stopping
-  next_state = long_control_state_trans(CP, CP_SP, active, current_state, v_ego=0.1,
-                             should_stop=False, brake_pressed=False, cruise_standstill=False)
-  assert next_state == LongCtrlState.pid
-
-def test_starting():
-  CP = car.CarParams.new_message(startingState=True, vEgoStarting=0.5)
-  CP_SP = custom.CarParamsSP.new_message()
-  active = True
-  current_state = LongCtrlState.starting
-  next_state = long_control_state_trans(CP, CP_SP, active, current_state, v_ego=0.1,
-                             should_stop=False, brake_pressed=False, cruise_standstill=False)
-  assert next_state == LongCtrlState.starting
-  next_state = long_control_state_trans(CP, CP_SP, active, current_state, v_ego=1.0,
+  next_state = long_control_state_trans(CP_SP, active, current_state,
                             should_stop=False, brake_pressed=False, cruise_standstill=False)
  assert next_state == LongCtrlState.pid
@@ -7,8 +7,6 @@ from opendbc.car.lateral import get_friction, FRICTION_THRESHOLD
 from openpilot.common.realtime import DT_MDL
 from openpilot.selfdrive.locationd.torqued import TorqueEstimator, MIN_BUCKET_POINTS, POINTS_PER_BUCKET, STEER_BUCKET_BOUNDS

-np.random.seed(0)
-
 LA_ERR_STD = 1.0
 INPUT_NOISE_STD = 0.08
 V_EGO = 30.0
@@ -58,16 +56,17 @@ def simulate_straight_road_msgs(est):
    for which, msg in (('carControl', carControl), ('carOutput', carOutput), ('carState', carState), ('livePose', livePose)):
      est.handle_log(t, which, msg)

-def test_estimated_offset():
-  steer_torques, lat_accels = generate_inputs(TORQUE_TUNE_BIASED, la_err_std=LA_ERR_STD, input_noise_std=INPUT_NOISE_STD)
-  est = get_warmed_up_estimator(steer_torques, lat_accels)
-  msg = est.get_msg()
-  # TODO add lataccelfactor and friction check when we have more accurate estimates
-  assert abs(msg.liveTorqueParameters.latAccelOffsetRaw - TORQUE_TUNE_BIASED.latAccelOffset) < 0.1
+class TestTorquedLatAccelOffset:
+  def test_estimated_offset(self):
+    steer_torques, lat_accels = generate_inputs(TORQUE_TUNE_BIASED, la_err_std=LA_ERR_STD, input_noise_std=INPUT_NOISE_STD)
+    est = get_warmed_up_estimator(steer_torques, lat_accels)
+    msg = est.get_msg()
+    # TODO add lataccelfactor and friction check when we have more accurate estimates
+    assert abs(msg.liveTorqueParameters.latAccelOffsetRaw - TORQUE_TUNE_BIASED.latAccelOffset) < 0.1

-def test_straight_road_roll_bias():
-  steer_torques, lat_accels = generate_inputs(TORQUE_TUNE, la_err_std=LA_ERR_STD, input_noise_std=INPUT_NOISE_STD)
-  est = get_warmed_up_estimator(steer_torques, lat_accels)
-  simulate_straight_road_msgs(est)
-  msg = est.get_msg()
-  assert (msg.liveTorqueParameters.latAccelOffsetRaw < -0.05) and np.isfinite(msg.liveTorqueParameters.latAccelOffsetRaw)
+  def test_straight_road_roll_bias(self):
+    steer_torques, lat_accels = generate_inputs(TORQUE_TUNE, la_err_std=LA_ERR_STD, input_noise_std=INPUT_NOISE_STD)
+    est = get_warmed_up_estimator(steer_torques, lat_accels)
+    simulate_straight_road_msgs(est)
+    msg = est.get_msg()
+    assert (msg.liveTorqueParameters.latAccelOffsetRaw < -0.05) and np.isfinite(msg.liveTorqueParameters.latAccelOffsetRaw)
@@ -1,4 +1,5 @@
 import numpy as np
+from collections.abc import Sequence
 from typing import Any
 from functools import cache

@@ -68,7 +69,8 @@ class NPQueue:


 class PointBuckets:
-  def __init__(self, x_bounds: list[tuple[float, float]], min_points: list[float], min_points_total: int, points_per_bucket: int, rowsize: int) -> None:
+  def __init__(self, x_bounds: list[tuple[float, float]], min_points: Sequence[float], min_points_total: int, points_per_bucket: int, rowsize: int) -> None:
+    self._rng = np.random.default_rng()
    self.x_bounds = x_bounds
    self.buckets = {bounds: NPQueue(maxlen=points_per_bucket, rowsize=rowsize) for bounds in x_bounds}
    self.buckets_min_points = dict(zip(x_bounds, min_points, strict=True))
@@ -98,9 +100,9 @@ class PointBuckets:
    points = np.vstack([x.arr for x in self.buckets.values()])
    if num_points is None:
      return points
-    return points[np.random.choice(np.arange(len(points)), min(len(points), num_points), replace=False)]
+    return points[self._rng.choice(np.arange(len(points)), min(len(points), num_points), replace=False)]

-  def load_points(self, points: list[list[float]]) -> None:
+  def load_points(self, points: Sequence[Sequence[float]]) -> None:
    for point in points:
      self.add_point(*point)

@@ -66,7 +66,7 @@ class LocationEstimator:
    self.observations = {kind: np.zeros(3, dtype=np.float32) for kind in obs_kinds}
    self.observation_errors = {kind: np.zeros(3, dtype=np.float32) for kind in obs_kinds}

-  def reset(self, t: float, x_initial: np.ndarray = PoseKalman.initial_x, P_initial: np.ndarray = PoseKalman.initial_P):
+  def reset(self, t: float | None, x_initial: np.ndarray = PoseKalman.initial_x, P_initial: np.ndarray = PoseKalman.initial_P):
    self.kf.init_state(x_initial, covs=P_initial, filter_time=t)

  def _validate_sensor_source(self, source: log.SensorEventData.SensorSource):
@@ -200,25 +200,6 @@ def check_valid_with_hysteresis(current_valid: bool, val: float, threshold: floa
  return current_valid


-# TODO: Remove this function after few releases (added in 0.9.9)
-def migrate_cached_vehicle_params_if_needed(params: Params):
-  last_parameters_data_old = params.get("LiveParameters")
-  last_parameters_data = params.get("LiveParametersV2")
-  if last_parameters_data_old is None or last_parameters_data is not None:
-    return
-
-  try:
-    last_parameters_msg = messaging.new_message('liveParameters')
-    last_parameters_msg.liveParameters.valid = True
-    last_parameters_msg.liveParameters.steerRatio = last_parameters_data_old['steerRatio']
-    last_parameters_msg.liveParameters.stiffnessFactor = last_parameters_data_old['stiffnessFactor']
-    last_parameters_msg.liveParameters.angleOffsetAverageDeg = last_parameters_data_old['angleOffsetAverageDeg']
-    params.put("LiveParametersV2", last_parameters_msg.to_bytes(), block=True)
-  except Exception as e:
-    cloudlog.error(f"Failed to perform parameter migration: {e}")
-    params.remove("LiveParameters")
-
-
 def retrieve_initial_vehicle_params(params: Params, CP: car.CarParams, replay: bool, debug: bool):
  last_parameters_data = params.get("LiveParametersV2")
  last_carparams_data = params.get("CarParamsPrevRoute")
@@ -273,8 +254,6 @@ def main():
  params = Params()
  CP = messaging.log_from_bytes(params.get("CarParams", block=True), car.CarParams)

-  migrate_cached_vehicle_params_if_needed(params)
-
  steer_ratio, stiffness_factor, angle_offset_deg, pInitial = retrieve_initial_vehicle_params(params, CP, REPLAY, DEBUG)
  learner = VehicleParamsLearner(CP, steer_ratio, stiffness_factor, np.radians(angle_offset_deg), pInitial)

@@ -81,6 +81,7 @@ class TestLagd:
        assert retrieve_initial_lag(params, CP) is None

  def test_ncc(self):
+    rng = np.random.default_rng()
    lag_frames = random.randint(1, 19)

    desired_sig = np.sin(np.arange(0.0, 10.0, 0.1))
@@ -91,15 +92,15 @@ class TestLagd:
    assert np.argmax(corr) == lag_frames

    # add some noise
-    desired_sig += np.random.normal(0, 0.05, len(desired_sig))
-    actual_sig += np.random.normal(0, 0.05, len(actual_sig))
+    desired_sig += rng.normal(0, 0.05, len(desired_sig))
+    actual_sig += rng.normal(0, 0.05, len(actual_sig))
    corr = masked_normalized_cross_correlation(desired_sig, actual_sig, mask, 200)[len(desired_sig) - 1:len(desired_sig) + 20]
    assert np.argmax(corr)  in range(lag_frames - MAX_ERR_FRAMES, lag_frames + MAX_ERR_FRAMES + 1)

    # mask out 40% of the values, and make them noise
-    mask = np.random.choice([True, False], size=len(desired_sig), p=[0.6, 0.4])
-    desired_sig[~mask] = np.random.normal(0, 1, size=np.sum(~mask))
-    actual_sig[~mask] = np.random.normal(0, 1, size=np.sum(~mask))
+    mask = rng.choice([True, False], size=len(desired_sig), p=[0.6, 0.4])
+    desired_sig[~mask] = rng.normal(0, 1, size=np.sum(~mask))
+    actual_sig[~mask] = rng.normal(0, 1, size=np.sum(~mask))
    corr = masked_normalized_cross_correlation(desired_sig, actual_sig, mask, 200)[len(desired_sig) - 1:len(desired_sig) + 20]
    assert np.argmax(corr) in range(lag_frames - MAX_ERR_FRAMES, lag_frames + MAX_ERR_FRAMES + 1)

@@ -37,9 +37,9 @@ def get_select_fields_data(logs):
  def sig_smooth(signal):
    return masked_symmetric_moving_average(signal, np.ones_like(signal), 5, 1.0)
  def get_nested_keys(msg, keys):
-    val = None
+    val = msg
    for key in keys:
-      val = getattr(msg if val is None else val, key) if isinstance(key, str) else val[key]
+      val = getattr(val, key) if isinstance(key, str) else val[key]
    return val
  lp = [x.livePose for x in logs if x.which() == 'livePose']
  data = defaultdict(list)
@@ -2,7 +2,7 @@ import random
 import numpy as np

 from openpilot.cereal import messaging
-from openpilot.selfdrive.locationd.paramsd import retrieve_initial_vehicle_params, migrate_cached_vehicle_params_if_needed
+from openpilot.selfdrive.locationd.paramsd import retrieve_initial_vehicle_params
 from openpilot.selfdrive.locationd.models.car_kf import CarKalman
 from openpilot.selfdrive.locationd.test.test_locationd_scenarios import TEST_ROUTE
 from openpilot.selfdrive.test.process_replay.migration import migrate, migrate_carParams
@@ -30,38 +30,9 @@ class TestParamsd:
    params.put("LiveParametersV2", msg.to_bytes(), block=True)
    params.put("CarParamsPrevRoute", CP.as_builder().to_bytes(), block=True)

-    migrate_cached_vehicle_params_if_needed(params) # this is not tested here but should not mess anything up or throw an error
    sr, sf, offset, p_init = retrieve_initial_vehicle_params(params, CP, replay=True, debug=True)
    np.testing.assert_allclose(sr, msg.liveParameters.steerRatio)
    np.testing.assert_allclose(sf, msg.liveParameters.stiffnessFactor)
    np.testing.assert_allclose(offset, msg.liveParameters.angleOffsetAverageDeg)
    np.testing.assert_equal(p_init.shape, CarKalman.P_initial.shape)
    np.testing.assert_allclose(np.diagonal(p_init), msg.liveParameters.debugFilterState.std)
-
-  # TODO Remove this test after the support for old format is removed
-  def test_read_saved_params_old_format(self):
-    params = Params()
-
-    lr = migrate(LogReader(TEST_ROUTE), [migrate_carParams])
-    CP = next(m for m in lr if m.which() == "carParams").carParams
-
-    msg = get_random_live_parameters(CP)
-    params.put("LiveParameters", msg.liveParameters.to_dict(), block=True)
-    params.put("CarParamsPrevRoute", CP.as_builder().to_bytes(), block=True)
-    params.remove("LiveParametersV2")
-
-    migrate_cached_vehicle_params_if_needed(params)
-    sr, sf, offset, _ = retrieve_initial_vehicle_params(params, CP, replay=True, debug=True)
-    np.testing.assert_allclose(sr, msg.liveParameters.steerRatio)
-    np.testing.assert_allclose(sf, msg.liveParameters.stiffnessFactor)
-    np.testing.assert_allclose(offset, msg.liveParameters.angleOffsetAverageDeg)
-    assert params.get("LiveParametersV2") is not None
-
-  def test_read_saved_params_corrupted_old_format(self):
-    params = Params()
-    params.put("LiveParameters", {}, block=True)
-    params.remove("LiveParametersV2")
-
-    migrate_cached_vehicle_params_if_needed(params)
-    assert params.get("LiveParameters") is None
-    assert params.get("LiveParametersV2") is None
@@ -2,24 +2,25 @@ from opendbc.car.structs import car
 from openpilot.selfdrive.locationd.torqued import TorqueEstimator


-def test_cal_percent():
-  est = TorqueEstimator(car.CarParams())
-  msg = est.get_msg()
-  assert msg.liveTorqueParameters.calPerc == 0
+class TestTorqued:
+  def test_cal_percent(self):
+    est = TorqueEstimator(car.CarParams())
+    msg = est.get_msg()
+    assert msg.liveTorqueParameters.calPerc == 0

-  for (low, high), min_pts in zip(est.filtered_points.buckets.keys(),
-                                  est.filtered_points.buckets_min_points.values(), strict=True):
-    for _ in range(int(min_pts)):
-      est.filtered_points.add_point((low + high) / 2.0, 0.0)
+    for (low, high), min_pts in zip(est.filtered_points.buckets.keys(),
+                                    est.filtered_points.buckets_min_points.values(), strict=True):
+      for _ in range(int(min_pts)):
+        est.filtered_points.add_point((low + high) / 2.0, 0.0)

-  # enough bucket points, but not enough total points
-  msg = est.get_msg()
-  assert msg.liveTorqueParameters.calPerc == (len(est.filtered_points) / est.min_points_total * 100 + 100) / 2
+    # enough bucket points, but not enough total points
+    msg = est.get_msg()
+    assert msg.liveTorqueParameters.calPerc == (len(est.filtered_points) / est.min_points_total * 100 + 100) / 2

-  # add enough points to bucket with most capacity
-  key = list(est.filtered_points.buckets)[0]
-  for _ in range(est.min_points_total - len(est.filtered_points)):
-    est.filtered_points.add_point((key[0] + key[1]) / 2.0, 0.0)
+    # add enough points to bucket with most capacity
+    key = list(est.filtered_points.buckets)[0]
+    for _ in range(est.min_points_total - len(est.filtered_points)):
+      est.filtered_points.add_point((key[0] + key[1]) / 2.0, 0.0)

-  msg = est.get_msg()
-  assert msg.liveTorqueParameters.calPerc == 100
+    msg = est.get_msg()
+    assert msg.liveTorqueParameters.calPerc == 100
@@ -62,14 +62,14 @@ class TorqueEstimator(ParameterEstimator, TorqueEstimatorExt):
    self.lag = 0.0
    self.track_all_points = track_all_points  # for offline analysis, without max lateral accel or max steer torque filters
    if decimated:
-      self.min_bucket_points = MIN_BUCKET_POINTS / 10
+      self.min_bucket_points: list[float] = (MIN_BUCKET_POINTS / 10).tolist()
      self.min_points_total = MIN_POINTS_TOTAL_QLOG
      self.fit_points = FIT_POINTS_TOTAL_QLOG
      self.factor_sanity = FACTOR_SANITY_QLOG
      self.friction_sanity = FRICTION_SANITY_QLOG

    else:
-      self.min_bucket_points = MIN_BUCKET_POINTS
+      self.min_bucket_points = MIN_BUCKET_POINTS.tolist()
      self.min_points_total = MIN_POINTS_TOTAL
      self.fit_points = FIT_POINTS_TOTAL
      self.factor_sanity = FACTOR_SANITY
@@ -120,9 +120,10 @@ class TorqueEstimator(ParameterEstimator, TorqueEstimatorExt):
              'latAccelOffset': cache_ltp.latAccelOffsetFiltered,
              'frictionCoefficient': cache_ltp.frictionCoefficientFiltered
            }
-          initial_params['points'] = cache_ltp.points
+          cached_points: list[list[float]] = [list(point) for point in cache_ltp.points]
+          initial_params['points'] = cached_points
          self.decay = cache_ltp.decay
-          self.filtered_points.load_points(initial_params['points'])
+          self.filtered_points.load_points(cached_points)
          cloudlog.info("restored torque params from cache")
      except Exception:
        cloudlog.exception("failed to restore cached torque params")
@@ -13,6 +13,7 @@ from collections import namedtuple
 import numpy as np

 from openpilot.selfdrive.modeld.helpers import dump_oob, load_oob
+from openpilot.selfdrive.modeld.usbgpu_link import wait_usbgpu_link

 def _patch_tinygrad_fetch_fw():
  import hashlib
@@ -242,7 +243,7 @@ def compile_jit(jit, make_random_inputs, input_keys, make_queues):
  SEED = 42
  def random_inputs_run(fn, seed, test_val=None, test_buffers=None, expect_match=True):
    input_queues, npy = make_queues(Device.DEFAULT)
-    np.random.seed(seed)
+    rng = np.random.default_rng(seed)
    Tensor.manual_seed(seed)

    testing = test_val is not None or test_buffers is not None
@@ -250,7 +251,7 @@ def compile_jit(jit, make_random_inputs, input_keys, make_queues):

    for i in range(n_runs):
      for v in npy.values():
-        v[:] = np.random.randn(*v.shape).astype(v.dtype)
+        v[:] = rng.standard_normal(v.shape).astype(v.dtype)
      Device.default.synchronize()
      random_inputs = make_random_inputs()
      st = time.perf_counter()
@@ -311,6 +312,9 @@ if __name__ == "__main__":
  p.add_argument('--frame-skip', type=int, required=True)
  args = p.parse_args()

+  if 'USB+AMD' in os.environ.get('DEV', ''):
+    wait_usbgpu_link()
+
  model_path = read_file_chunked_to_disk(args.onnx)
  model_w, model_h = args.model_size

@@ -25,6 +25,7 @@ from openpilot.selfdrive.modeld.fill_model_msg import fill_model_msg, fill_drivi
 from openpilot.common.file_chunker import open_file_chunked, get_manifest_path
 from openpilot.selfdrive.modeld.constants import ModelConstants, Plan
 from openpilot.selfdrive.modeld.helpers import usbgpu_present, modeld_pkl_path, get_tg_input_devices, load_oob
+from openpilot.selfdrive.modeld.usbgpu_link import wait_usbgpu_link

 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld_v2.modeld_base import ModelStateBase
@@ -94,7 +95,7 @@ class ModelState(ModelStateBase):
    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)
    self.full_frames: dict[str, Tensor] = {}
-    self._blob_cache: dict[int, Tensor] = {}
+    self._blob_cache: dict[tuple[str, int], Tensor] = {}
    self.parser = Parser()
    self.frame_buf_params = {k: get_nv12_info(cam_w, cam_h) for k in ('img', 'big_img')}
    self.run_policy = jits['run_policy']
@@ -173,6 +174,8 @@ def main(demo=False):
  if use_extra_client:
    cloudlog.warning(f"connected extra cam with buffer size: {vipc_client_extra.buffer_len} ({vipc_client_extra.width} x {vipc_client_extra.height})")

+  if USBGPU:
+    wait_usbgpu_link()
  st = time.monotonic()
  cloudlog.warning("loading model")
  model = ModelState(vipc_client_main.width, vipc_client_main.height, USBGPU)
@@ -41,7 +41,7 @@ class Parser:
    raw = outs[name]
    outs[name] = sigmoid(raw)

-  def parse_mdn(self, name, outs, in_N=0, out_N=1, out_shape=None):
+  def parse_mdn(self, name, outs, in_N=0, out_N=1, out_shape=()):
    if self.check_missing(outs, name):
      return
    raw = outs[name]
@@ -0,0 +1,34 @@
+import time
+from pathlib import Path
+
+from openpilot.common.swaglog import cloudlog
+from openpilot.common.hardware.usb import CHESTNUT_VENDOR_ID, CHESTNUT_PRODUCT_ID, usb_devices, controller, read_int
+
+STABLE_SECONDS = 2.0
+STABLE_THRESHOLD = 5.0  # link errors per second
+
+
+def _chestnut_portli() -> Path | None:
+  for device in usb_devices():
+    if read_int(device / "idVendor", 16) == CHESTNUT_VENDOR_ID and \
+       read_int(device / "idProduct", 16) == CHESTNUT_PRODUCT_ID:
+      ctrl = controller(device)
+      if ctrl is not None and (ctrl / "portli").exists():
+        return ctrl / "portli"
+  return None
+
+
+def wait_usbgpu_link(timeout: float = 30.0) -> None:
+  portli = _chestnut_portli()
+  if portli is None:
+    return
+
+  t0 = time.monotonic()
+  while time.monotonic() - t0 < timeout:
+    start = read_int(portli, 0)
+    time.sleep(STABLE_SECONDS)
+    rate = (read_int(portli, 0) - start) / STABLE_SECONDS
+    if rate <= STABLE_THRESHOLD:
+      return
+    cloudlog.warning(f"usbgpu link not stable: {rate:.0f} errors/s")
+  cloudlog.error("usbgpu link never stabilized")
@@ -41,7 +41,7 @@ class DRIVER_MONITOR_SETTINGS:
    # lockout specs
    self._MAX_ALERT_3 = 2
    self._MAX_NO_RESPONSE = 1
-    self._LOCKOUT_TIME = int(1800 / DT_DMON)
+    self._LOCKOUT_TIMES = [int(60 * n_min / DT_DMON) for n_min in [1, 5, 15, 30]]

    self._TIMEOUT_RECOVERY_FACTOR_MAX = 5.
    self._TIMEOUT_RECOVERY_FACTOR_MIN = 1.25
@@ -152,7 +152,10 @@ class DriverMonitoring:
    self.cnt_since_alert_3 = 0
    self.no_response_timeout = int(self.settings._NO_RESPONSE_TIMEOUT / DT_DMON)
    self.no_response_cnt = 0
-    self.lockout_time = 0
+    self.lockout_active = Params().get_bool("DriverTooDistracted")
+    self.lockout_count = Params().get("DriverLockoutCount") or 0
+    self.lockout_duration = self.settings._LOCKOUT_TIMES[min(max(self.lockout_count - 1, 0), len(self.settings._LOCKOUT_TIMES) - 1)]
+    self.lockout_time_elapsed = 0
    self.step_change = 0.
    self.active_policy = MonitoringPolicy.vision
    self.driver_interacting = False
@@ -163,7 +166,6 @@ class DriverMonitoring:
    self.threshold_alert_2 = 0.
    self.dcam_uncertain_cnt = 0
    self.dcam_reset_cnt = 0
-    self.too_distracted = Params().get_bool("DriverTooDistracted")

    self._reset_awareness()
    self._set_policy(MonitoringPolicy.vision)
@@ -310,16 +312,20 @@ class DriverMonitoring:
    self.driver_interacting = driver_engaged

    if self.alert_3_cnt >= self.settings._MAX_ALERT_3 or self.no_response_cnt >= self.settings._MAX_NO_RESPONSE:
-      self.too_distracted = True
+      if not self.lockout_active:
+        self.lockout_count += 1
+        self.lockout_duration = self.settings._LOCKOUT_TIMES[min(self.lockout_count - 1, len(self.settings._LOCKOUT_TIMES) - 1)]
+        Params().put("DriverLockoutCount", self.lockout_count)
+      self.lockout_active = True

-    if self.too_distracted:
-      self.lockout_time += 1
-      if self.lockout_time > self.settings._LOCKOUT_TIME:
-        self.too_distracted = False
+    if self.lockout_active:
+      self.lockout_time_elapsed += 1
+      if self.lockout_time_elapsed > self.lockout_duration:
+        self.lockout_active = False
        self.alert_3_cnt = 0
        self.cnt_since_alert_3 = 0
        self.no_response_cnt = 0
-        self.lockout_time = 0
+        self.lockout_time_elapsed = 0

    always_on_valid = self.always_on and not wrong_gear
    if (self.driver_interacting and self.awareness > 0 and self.active_policy == MonitoringPolicy.wheeltouch) or \
@@ -379,8 +385,10 @@ class DriverMonitoring:
    dat = messaging.new_message('driverMonitoringState', valid=valid)
    dm = dat.driverMonitoringState

-    dm.lockout = self.too_distracted
-    dm.lockoutRecoveryPercent = to_percent(self.lockout_time / self.settings._LOCKOUT_TIME)
+    dm.lockout = self.lockout_active
+    dm.lockoutCount = self.lockout_count
+    if self.lockout_active:
+      dm.lockoutMinutesRemaining = max(1, round((self.lockout_duration - self.lockout_time_elapsed) * DT_DMON / 60.))
    dm.alert3Count = self.alert_3_cnt
    dm.noResponseCount = self.no_response_cnt
    dm.noResponseForceDecel = self.alert_level == AlertLevel.three and self.cnt_since_alert_3 >= self.no_response_timeout
@@ -86,21 +86,17 @@ class TestMonitoring:
  # engaged, distracted past red and beyond the no-response window -> unavailability response + lockout
  def test_distracted_lockout(self):
    alert_lvls, d_status = self._run_seq(always_distracted, always_false, always_true, always_false)
-    s = d_status.settings
    assert alert_lvls[int(DISTRACTED_SECONDS_TO_RED / DT_DMON)] == 3
-    assert d_status.alert_3_cnt == 1
-    assert d_status.no_response_cnt == s._MAX_NO_RESPONSE
-    assert d_status.too_distracted
-    assert d_status.lockout_time > 0
+    assert d_status.lockout_active
+    assert d_status.lockout_time_elapsed > 0
+    assert d_status.lockout_count >= 1

  # no face -> wheeltouch red, sustained past the no-response timeout -> unavailability response + lockout
  def test_invisible_lockout(self):
    _, d_status = self._run_seq(always_no_face, always_false, always_true, always_false)
-    s = d_status.settings
    assert d_status.active_policy == log.DriverMonitoringState.MonitoringPolicy.wheeltouch
-    assert d_status.alert_3_cnt == 1
-    assert d_status.no_response_cnt == s._MAX_NO_RESPONSE
-    assert d_status.too_distracted
+    assert d_status.lockout_active
+    assert d_status.lockout_count >= 1

  # engaged, no face detected the whole time, no action
  def test_fully_invisible_driver(self):
@@ -275,7 +271,7 @@ def test_run_step_engagement(selfdrive_enabled, lat_active, steering, gas,
    captured['op_engaged'] = op_engaged
    return orig(driver_engaged, op_engaged, lowspeed, wrong_gear)

-  dm._update_events = spy
+  object.__setattr__(dm, '_update_events', spy)
  dm.run_step(sm, demo=False)
  assert captured['op_engaged'] == expected_op_engaged
  assert captured['driver_engaged'] == expected_driver_engaged
@@ -60,7 +60,7 @@ class TestPandad:

  def test_in_reset(self):
    gpio_init(GPIO.STM_RST_N, True)
-    gpio_set(GPIO.STM_RST_N, 1)
+    gpio_set(GPIO.STM_RST_N, True)
    assert not Panda.list()
    self._run_test()

@@ -38,10 +38,10 @@ class TestBoarddSpi:

    total_recv_count = 0
    total_sent_count = 0
-    sent_msgs = {bus: list() for bus in range(3)}
+    sent_msgs = {bus: [] for bus in range(3)}

    st = time.monotonic()
-    ts = {s: list() for s in socks.keys()}
+    ts = {s: [] for s in socks.keys()}
    for _ in range(int(os.getenv("TEST_TIME", "20"))):
      # send some CAN messages
      if not JUNGLE_SPAM:
@@ -7,9 +7,8 @@ from opendbc.car.structs import car
 import openpilot.cereal.messaging as messaging
 from openpilot.common.constants import CV
 from openpilot.common.git import get_short_branch
-from openpilot.common.realtime import DT_CTRL, DT_DMON
+from openpilot.common.realtime import DT_CTRL
 from openpilot.selfdrive.locationd.calibrationd import MIN_SPEED_FILTER
-from openpilot.selfdrive.monitoring.policy import DRIVER_MONITOR_SETTINGS
 from openpilot.system.micd import SAMPLE_RATE, SAMPLE_BUFFER
 from openpilot.selfdrive.ui.feedback.feedbackd import FEEDBACK_MAX_DURATION
 from openpilot.common.hardware import HARDWARE
@@ -25,7 +24,6 @@ VisualAlert = car.CarControl.HUDControl.VisualAlert
 AudibleAlert = log.SelfdriveState.AudibleAlert
 EventName = log.OnroadEvent.EventName

-DMON_LOCKOUT_TIME = DRIVER_MONITOR_SETTINGS()._LOCKOUT_TIME

 # get event name from enum
 EVENT_NAME = {v: k for k, v in EventName.schema.enumerants.items()}
@@ -101,7 +99,7 @@ def calibration_incomplete_alert(CP: car.CarParams, CS: car.CarState, sm: messag

 def too_distracted_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
  if sm['driverMonitoringState'].lockout:
-    mins_left = max(1, round((100 - sm['driverMonitoringState'].lockoutRecoveryPercent) / 100 * DMON_LOCKOUT_TIME * DT_DMON / 60.))
+    mins_left = sm['driverMonitoringState'].lockoutMinutesRemaining
    return NoEntryAlert("Too Distracted", f"{mins_left} minute{'s' if mins_left != 1 else ''} Left", priority=Priority.HIGH)
  return NoEntryAlert("Pay Attention to Engage", priority=Priority.HIGH)

@@ -13,11 +13,11 @@ ALL_STATES = tuple(State.schema.enumerants.values())
 ENABLE_EVENT_TYPES = (ET.ENABLE, ET.PRE_ENABLE, ET.OVERRIDE_LATERAL, ET.OVERRIDE_LONGITUDINAL)


-def make_event(event_types):
-  event = {}
+def make_event(event_types: list[str | None]):
+  EVENTS[0] = {}
  for ev in event_types:
-    event[ev] = NormalPermanentAlert("alert")
-  EVENTS[0] = event
+    if ev is not None:
+      EVENTS[0][ev] = NormalPermanentAlert("alert")
  return 0


@@ -7,7 +7,7 @@ from openpilot.common.utils import tabulate

 DEMO_ROUTE = "5beb9b58bd12b691/0000010a--a51155e496"
 MB = 1024 * 1024
-TABULATE_OPTS = dict(tablefmt="simple_grid", stralign="center", numalign="center")
+TABULATE_OPTS = {"tablefmt": "simple_grid", "stralign": "center", "numalign": "center"}


 def _get_procs():
@@ -297,7 +297,7 @@ def migrate_carOutput(msgs):
    co = messaging.new_message('carOutput')
    co.valid = msg.valid
    co.logMonoTime = msg.logMonoTime
-    co.carOutput.actuatorsOutput = msg.carControl.actuatorsOutputDEPRECATED
+    co.carOutput.actuatorsOutput = msg.carControl.deprecated.actuatorsOutput
    add_ops.append(as_reader(co))
  return [], add_ops, []

@@ -323,10 +323,10 @@ def migrate_pandaStates(msgs):
    safety_param = safety_param_migration[fingerprint].value
  elif len(CP.safetyConfigs):
    safety_param = CP.safetyConfigs[0].safetyParam
-    if CP.safetyConfigs[0].safetyParamDEPRECATED != 0:
-      safety_param = CP.safetyConfigs[0].safetyParamDEPRECATED
+    if CP.safetyConfigs[0].deprecated.safetyParam != 0:
+      safety_param = CP.safetyConfigs[0].deprecated.safetyParam
  else:
-    safety_param = CP.safetyParamDEPRECATED
+    safety_param = CP.deprecated.safetyParam

  ops = []
  for index, msg in msgs:
@@ -216,8 +216,7 @@ class ProcessContainer:

  def _start_process(self):
    if self.capture is not None:
-      self.process.launcher = LauncherWithCapture(self.capture, self.process.launcher)
-    self.process.prepare()
+      self.process.launcher = LauncherWithCapture(self.capture, self.process.launcher)  # ty: ignore[invalid-assignment]  # intentional wrapper
    self.process.start()

  def start(
@@ -635,10 +634,10 @@ def replay_process(
  fingerprint: str | None = None, return_all_logs: bool = False, custom_params: dict[str, Any] | None = None,
  captured_output_store: dict[str, dict[str, str]] | None = None, disable_progress: bool = False
 ) -> list[capnp._DynamicStructReader]:
-  if isinstance(cfg, Iterable):
-    cfgs = list(cfg)
-  else:
+  if isinstance(cfg, ProcessConfig):
    cfgs = [cfg]
+  else:
+    cfgs = list(cfg)

  all_msgs = migrate_all(lr,
                         manager_states=True,
@@ -204,7 +204,10 @@ class FaceAnimator:
      frames_back = round(rewind_elapsed / self._animation.frame_duration)
      frame_index = self._rewind_from - frames_back
      if frame_index <= 0:
-        return self._switch_to_next(now)
+        if self._next is None:
+          self._rewinding = False
+          return self._animation.frames[0]
+        return self._switch_to_next(now, self._next)
      return self._animation.frames[frame_index]

    # Play starting frames first (once)
@@ -223,7 +226,7 @@ class FaceAnimator:

    if self._next is not None:
      if frame_index == 0 and (len(self._animation.frames) == 1 or self._seen_nonzero):
-        return self._switch_to_next(now)
+        return self._switch_to_next(now, self._next)
      # No natural return to frame 0 — start rewinding
      if self._animation.mode in (AnimationMode.ONCE_FORWARD, AnimationMode.REPEAT_FORWARD):
        self._rewinding = True
@@ -232,8 +235,8 @@ class FaceAnimator:

    return self._animation.frames[frame_index]

-  def _switch_to_next(self, now: float) -> list[tuple[int, int]]:
-    self._animation = self._next
+  def _switch_to_next(self, now: float, animation: Animation) -> list[tuple[int, int]]:
+    self._animation = animation
    self._next = None
    self._rewinding = False
    self._seen_nonzero = False
@@ -34,7 +34,11 @@ class MainLayout(Widget):
    # Initialize layouts
    self._home_layout = HomeLayout()
    self._home_body_layout = BodyLayout()
-    self._layouts = {MainState.HOME: self._home_layout, MainState.SETTINGS: SettingsLayout(), MainState.ONROAD: AugmentedRoadView()}
+    self._layouts: dict[MainState, Widget] = {
+      MainState.HOME: self._home_layout,
+      MainState.SETTINGS: SettingsLayout(),
+      MainState.ONROAD: AugmentedRoadView(),
+    }

    self._sidebar_rect = rl.Rectangle(0, 0, 0, 0)
    self._content_rect = rl.Rectangle(0, 0, 0, 0)
@@ -105,7 +105,6 @@ class DeviceLayout(Widget):

      self._params.remove("CalibrationParams")
      self._params.remove("LiveTorqueParameters")
-      self._params.remove("LiveParameters")
      self._params.remove("LiveParametersV2")
      self._params.remove("LiveDelay")
      self._params.put_bool("OnroadCycleRequested", True, block=True)
@@ -1,5 +1,5 @@
 import pyray as rl
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import IntEnum
 from collections.abc import Callable
 from openpilot.selfdrive.ui.layouts.settings.developer import DeveloperLayout
@@ -43,7 +43,7 @@ class PanelType(IntEnum):
 class PanelInfo:
  name: str
  instance: Widget
-  button_rect: rl.Rectangle = rl.Rectangle(0, 0, 0, 0)
+  button_rect: rl.Rectangle = field(default_factory=lambda: rl.Rectangle(0, 0, 0, 0))


 class SettingsLayout(Widget):
@@ -68,7 +68,7 @@ class Sidebar(Widget, SidebarSP):
  def __init__(self):
    Widget.__init__(self)
    SidebarSP.__init__(self)
-    self._net_type = NETWORK_TYPES.get(NetworkType.none)
+    self._net_type = NETWORK_TYPES[NetworkType.none]
    self._net_strength = 0

    self._temp_status = MetricData(tr_noop("TEMP"), tr_noop("GOOD"), Colors.GOOD)
@@ -251,7 +251,7 @@ class MiciHomeLayout(Widget):
    self._egpu_icon.set_visible(ui_state.usbgpu and ui_state.usbgpu_compiled)
    self._egpu_icon_gray.set_visible(ui_state.usbgpu and not ui_state.usbgpu_compiled)
    self._mic_icon.set_visible(ui_state.recording_audio)
-    self._body_icon.set_visible(ui_state.is_body)
+    self._body_icon.set_visible(bool(ui_state.is_body))

    footer_rect = rl.Rectangle(self.rect.x + HOME_PADDING, self.rect.y + self.rect.height - 48, self.rect.width - HOME_PADDING, 48)
    self._status_bar_layout.render(footer_rect)
@@ -148,4 +148,4 @@ class MiciMainLayout(Scroller):

  def _on_body_changed(self):
    self._car_onroad_layout.set_visible(not ui_state.is_body)
-    self._body_onroad_layout.set_visible(ui_state.is_body)
+    self._body_onroad_layout.set_visible(bool(ui_state.is_body))
@@ -250,12 +250,12 @@ class MiciOffroadAlerts(Scroller):
                              {alert_data.key: self.params.get(alert_data.key) for alert_data in self.sorted_alerts})
      time.sleep(REFRESH_INTERVAL)

-  def _refresh(self) -> int:
+  def _refresh(self, pending_params: dict) -> int:
    """Refresh alerts from params and return active count."""
    active_count = 0

    # Handle UpdateAvailable alert specially
-    update_available = self._pending_params["UpdateAvailable"]
+    update_available = pending_params["UpdateAvailable"]
    update_alert_data = next((alert_data for alert_data in self.sorted_alerts if alert_data.key == "UpdateAvailable"), None)

    if update_alert_data:
@@ -263,7 +263,7 @@ class MiciOffroadAlerts(Scroller):
        version_string = ""

        # Get new version description and parse version and date
-        new_desc = self._pending_params["UpdaterNewDescription"] or ""
+        new_desc = pending_params["UpdaterNewDescription"] or ""
        if new_desc:
          # format: "version / branch / commit / date"
          parts = new_desc.split(" / ")
@@ -284,7 +284,7 @@ class MiciOffroadAlerts(Scroller):
        continue  # Skip, already handled above

      text = ""
-      alert_json = self._pending_params[alert_data.key]
+      alert_json = pending_params[alert_data.key]

      if alert_json:
        text = alert_json.get("text", "").replace("%1", alert_json.get("extra", ""))
@@ -311,8 +311,9 @@ class MiciOffroadAlerts(Scroller):
  def _update_state(self):
    """Periodically refresh alerts."""
    # Refresh alerts when thread updates params
-    if self._pending_params is not None:
-      self._refresh()
+    pending_params = self._pending_params
+    if pending_params is not None:
+      self._refresh(pending_params)
      self._pending_params = None

  def _render(self, rect: rl.Rectangle):
@@ -16,7 +16,7 @@ from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.widgets import Widget
 from openpilot.selfdrive.ui.ui_state import device, ui_state
 from openpilot.system.ui.widgets.label import UnifiedLabel
-from openpilot.system.ui.widgets.html_render import HtmlModal, HtmlRenderer
+from openpilot.system.ui.widgets.html_render import HtmlRenderer
 from openpilot.system.athena.registration import UNREGISTERED_DONGLE_ID


@@ -160,7 +160,7 @@ class DeviceLayoutMici(NavScroller):
  def __init__(self):
    super().__init__()

-    self._fcc_dialog: HtmlModal | None = None
+    self._fcc_dialog: MiciFccModal | None = None

    def power_off_callback():
      ui_state.params.put_bool("DoShutdown", True, block=True)
@@ -172,7 +172,6 @@ class DeviceLayoutMici(NavScroller):
      params = ui_state.params
      params.remove("CalibrationParams")
      params.remove("LiveTorqueParameters")
-      params.remove("LiveParameters")
      params.remove("LiveParametersV2")
      params.remove("LiveDelay")
      params.put_bool("OnroadCycleRequested", True, block=True)
@@ -219,7 +219,7 @@ class CameraView(Widget):
      [0.0, 0.0, 1.0]
    ])

-  def _render(self, rect: rl.Rectangle):
+  def _render(self, rect: rl.Rectangle, /):
    if self._switching:
      self._handle_switch()

@@ -47,8 +47,8 @@ class ModelPoints:

@dataclass
 class LeadVehicle:
-  glow: list[float] = field(default_factory=list)
-  chevron: list[float] = field(default_factory=list)
+  glow: list[tuple[float, float]] = field(default_factory=list)
+  chevron: list[tuple[float, float]] = field(default_factory=list)
  fill_alpha: int = 0


@@ -41,80 +41,81 @@ def get_child_widgets(widget) -> list:
  return children


-@pytest.mark.skip(reason="segfaults")
-def test_dialogs_do_not_leak():
-  import pyray as rl
-  rl.set_config_flags(rl.ConfigFlags.FLAG_WINDOW_HIDDEN)
-  from openpilot.system.ui.lib.application import gui_app
+class TestWidgetLeaks:
+  @pytest.mark.skip(reason="segfaults")
+  def test_dialogs_do_not_leak(self):
+    import pyray as rl
+    rl.set_config_flags(rl.ConfigFlags.FLAG_WINDOW_HIDDEN)
+    from openpilot.system.ui.lib.application import gui_app

-  # mici dialogs
-  from openpilot.selfdrive.ui.mici.layouts.onboarding import TrainingGuide as MiciTrainingGuide, OnboardingWindow as MiciOnboardingWindow
-  from openpilot.selfdrive.ui.mici.onroad.driver_camera_dialog import DriverCameraDialog as MiciDriverCameraDialog
-  from openpilot.selfdrive.ui.mici.widgets.pairing_dialog import PairingDialog as MiciPairingDialog
-  from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog, BigConfirmationDialog, BigInputDialog
-  from openpilot.selfdrive.ui.mici.layouts.settings.device import MiciFccModal
+    # mici dialogs
+    from openpilot.selfdrive.ui.mici.layouts.onboarding import TrainingGuide as MiciTrainingGuide, OnboardingWindow as MiciOnboardingWindow
+    from openpilot.selfdrive.ui.mici.onroad.driver_camera_dialog import DriverCameraDialog as MiciDriverCameraDialog
+    from openpilot.selfdrive.ui.mici.widgets.pairing_dialog import PairingDialog as MiciPairingDialog
+    from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog, BigConfirmationDialog, BigInputDialog
+    from openpilot.selfdrive.ui.mici.layouts.settings.device import MiciFccModal

-  # tici dialogs
-  from openpilot.selfdrive.ui.onroad.driver_camera_dialog import DriverCameraDialog as TiciDriverCameraDialog
-  from openpilot.selfdrive.ui.layouts.onboarding import OnboardingWindow as TiciOnboardingWindow
-  from openpilot.selfdrive.ui.widgets.pairing_dialog import PairingDialog as TiciPairingDialog
-  from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
-  from openpilot.system.ui.widgets.option_dialog import MultiOptionDialog
-  from openpilot.system.ui.widgets.html_render import HtmlModal
-  from openpilot.system.ui.widgets.keyboard import Keyboard
+    # tici dialogs
+    from openpilot.selfdrive.ui.onroad.driver_camera_dialog import DriverCameraDialog as TiciDriverCameraDialog
+    from openpilot.selfdrive.ui.layouts.onboarding import OnboardingWindow as TiciOnboardingWindow
+    from openpilot.selfdrive.ui.widgets.pairing_dialog import PairingDialog as TiciPairingDialog
+    from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
+    from openpilot.system.ui.widgets.option_dialog import MultiOptionDialog
+    from openpilot.system.ui.widgets.html_render import HtmlModal
+    from openpilot.system.ui.widgets.keyboard import Keyboard

-  gui_app.init_window("ref-test")
+    gui_app.init_window("ref-test")

-  leaked_widgets = set()
+    leaked_widgets = set()

-  for ctor in (
-    # mici
-    MiciDriverCameraDialog, MiciPairingDialog,
-    lambda: MiciTrainingGuide(lambda: None),
-    lambda: MiciOnboardingWindow(lambda: None),
-    lambda: BigDialog("test", "test"),
-    lambda: BigConfirmationDialog("test", gui_app.texture("icons_mici/settings/network/new/trash.png", 54, 64), lambda: None),
-    lambda: BigInputDialog("test"),
-    lambda: MiciFccModal(text="test"),
-    # tici
-    TiciDriverCameraDialog, TiciOnboardingWindow, TiciPairingDialog, Keyboard,
-    lambda: ConfirmDialog("test", "ok"),
-    lambda: MultiOptionDialog("test", ["a", "b"]),
-    lambda: HtmlModal(text="test"),
-  ):
-    widget = ctor()
-    all_refs = [weakref.ref(w) for w in get_child_widgets(widget) + [widget]]
+    for ctor in (
+      # mici
+      MiciDriverCameraDialog, MiciPairingDialog,
+      lambda: MiciTrainingGuide(lambda: None),
+      lambda: MiciOnboardingWindow(lambda: None),
+      lambda: BigDialog("test", "test"),
+      lambda: BigConfirmationDialog("test", gui_app.texture("icons_mici/settings/network/new/trash.png", 54, 64), lambda: None),
+      lambda: BigInputDialog("test"),
+      lambda: MiciFccModal(text="test"),
+      # tici
+      TiciDriverCameraDialog, TiciOnboardingWindow, TiciPairingDialog, Keyboard,
+      lambda: ConfirmDialog("test", "ok"),
+      lambda: MultiOptionDialog("test", ["a", "b"]),
+      lambda: HtmlModal(text="test"),
+    ):
+      widget = ctor()
+      all_refs = [weakref.ref(w) for w in get_child_widgets(widget) + [widget]]

-    del widget
+      del widget

-    for ref in all_refs:
-      if ref() is not None:
-        obj = ref()
-        name = f"{type(obj).__module__}.{type(obj).__qualname__}"
-        leaked_widgets.add(name)
+      for ref in all_refs:
+        if ref() is not None:
+          obj = ref()
+          name = f"{type(obj).__module__}.{type(obj).__qualname__}"
+          leaked_widgets.add(name)

-        print(f"\n===  Widget {name} alive after del")
-        print("  Referrers:")
-        for r in gc.get_referrers(obj):
-          if r is obj:
-            continue
+          print(f"\n===  Widget {name} alive after del")
+          print("  Referrers:")
+          for r in gc.get_referrers(obj):
+            if r is obj:
+              continue

-          if hasattr(r, '__self__') and r.__self__ is not obj:
-            print(f"    bound method: {type(r.__self__).__qualname__}.{r.__name__}")
-          elif hasattr(r, '__func__'):
-            print(f"    method: {r.__name__}")
-          else:
-            print(f"    {type(r).__module__}.{type(r).__qualname__}")
-        del obj
+            if hasattr(r, '__self__') and r.__self__ is not obj:
+              print(f"    bound method: {type(r.__self__).__qualname__}.{r.__name__}")
+            elif hasattr(r, '__func__'):
+              print(f"    method: {r.__name__}")
+            else:
+              print(f"    {type(r).__module__}.{type(r).__qualname__}")
+          del obj

-  gui_app.close()
+    gui_app.close()

-  unexpected = leaked_widgets - KNOWN_LEAKS
-  assert not unexpected, f"New leaked widgets: {unexpected}"
+    unexpected = leaked_widgets - KNOWN_LEAKS
+    assert not unexpected, f"New leaked widgets: {unexpected}"

-  fixed = KNOWN_LEAKS - leaked_widgets
-  assert not fixed, f"These leaks are fixed, remove from KNOWN_LEAKS: {fixed}"
+    fixed = KNOWN_LEAKS - leaked_widgets
+    assert not fixed, f"These leaks are fixed, remove from KNOWN_LEAKS: {fixed}"


 if __name__ == "__main__":
-  test_dialogs_do_not_leak()
+  TestWidgetLeaks().test_dialogs_do_not_leak()
@@ -375,6 +375,7 @@ class GreyBigButton(BigButton):
 class BigMultiParamToggle(BigMultiToggle):
  def __init__(self, text: str, param: str, options: list[str], toggle_callback: Callable | None = None,
               select_callback: Callable | None = None):
+    assert Params is not None
    super().__init__(text, options, toggle_callback, select_callback)
    self._param = param

@@ -392,6 +393,7 @@ class BigMultiParamToggle(BigMultiToggle):

 class BigParamControl(BigToggle):
  def __init__(self, text: str, param: str, toggle_callback: Callable | None = None):
+    assert Params is not None
    super().__init__(text, "", toggle_callback=toggle_callback)
    self.param = param
    self.params = Params()
@@ -409,6 +411,7 @@ class BigParamControl(BigToggle):
 class BigCircleParamControl(BigCircleToggle):
  def __init__(self, icon: rl.Texture, param: str, toggle_callback: Callable | None = None,
               icon_offset: tuple[int, int] = (0, 0)):
+    assert Params is not None
    super().__init__(icon, toggle_callback, icon_offset=icon_offset)
    self._param = param
    self.params = Params()
@@ -39,8 +39,8 @@ class ModelPoints:

@dataclass
 class LeadVehicle:
-  glow: list[float] = field(default_factory=list)
-  chevron: list[float] = field(default_factory=list)
+  glow: list[tuple[float, float]] = field(default_factory=list)
+  chevron: list[tuple[float, float]] = field(default_factory=list)
  fill_alpha: int = 0


@@ -24,7 +24,7 @@ ALERT_RAMP_TIME = 4 # seconds to ramp to max volume for warningImmediate
 SELFDRIVE_STATE_TIMEOUT = 5 # 5 seconds
 FILTER_DT = 1. / (micd.SAMPLE_RATE / micd.FFT_SAMPLES)

-AMBIENT_DB = 24 # DB where MIN_VOLUME is applied
+AMBIENT_DB = 26 # DB where MIN_VOLUME is applied
 DB_SCALE = 30 # AMBIENT_DB + DB_SCALE is where MAX_VOLUME is applied

 VOLUME_BASE = 20
@@ -48,14 +48,15 @@ sound_list: dict[int, tuple[str, int | None, float]] = {
  AudibleAlert.disengage: ("disengage.wav", 1, MAX_VOLUME),
  AudibleAlert.refuse: ("refuse.wav", 1, MAX_VOLUME),

-  AudibleAlert.prompt: ("prompt.wav", 1, MAX_VOLUME),
-  AudibleAlert.promptRepeat: ("prompt.wav", None, MAX_VOLUME),
-  AudibleAlert.promptDistracted: ("prompt_distracted.wav", None, MAX_VOLUME),
+  AudibleAlert.prompt: ("warning.wav", 1, MAX_VOLUME),
+  AudibleAlert.promptRepeat: ("warning.wav", None, MAX_VOLUME),
+  AudibleAlert.promptDistracted: ("dm_warning.wav", None, MAX_VOLUME),

  AudibleAlert.preAlert: ("pre_alert.wav", 1, MAX_VOLUME),
+  AudibleAlert.complete: ("complete.wav", 1, MAX_VOLUME),

-  AudibleAlert.warningSoft: ("warning_soft.wav", None, MAX_VOLUME),
-  AudibleAlert.warningImmediate: ("warning_immediate.wav", None, MAX_VOLUME),
+  AudibleAlert.warningSoft: ("critical.wav", None, MAX_VOLUME),
+  AudibleAlert.warningImmediate: ("dm_critical.wav", None, MAX_VOLUME),

  **sound_list_sp,
 }
@@ -89,6 +90,7 @@ class Soundd(QuietMode):
    self.ramp_start_time = 0.

    self.selfdrive_timeout_alert = False
+    self.pending_stop = False

    self.spl_filter_weighted = FirstOrderFilter(0, 2.5, FILTER_DT, initialized=False)

@@ -127,6 +129,10 @@ class Soundd(QuietMode):
        self.current_sound_frame += frames_to_write
        current_sound_frame = self.current_sound_frame % len(sound_data)
        loops = self.current_sound_frame // len(sound_data)
+        if self.pending_stop and current_sound_frame == 0:
+          self.current_alert = AudibleAlert.none
+          self.pending_stop = False
+          break

    return ret * self.current_volume

@@ -137,6 +143,15 @@ class Soundd(QuietMode):

  def update_alert(self, new_alert):
    current_alert_played_once = self.current_alert == AudibleAlert.none or self.current_sound_frame >= len(self.loaded_sounds[self.current_alert])
+    # let looping sounds finish the current loop instead of cutting off mid tone
+    if new_alert == AudibleAlert.none and self.current_alert != AudibleAlert.none and sound_list[self.current_alert][1] is None:
+      if current_alert_played_once:
+        self.pending_stop = True
+      else:
+        self.current_alert = AudibleAlert.none
+        self.current_sound_frame = 0
+      return
+    self.pending_stop = False
    if self.current_alert != new_alert and (new_alert != AudibleAlert.none or current_alert_played_once):
      if new_alert == AudibleAlert.warningImmediate:
        self.ramp_start_volume = self.current_volume
@@ -43,7 +43,7 @@ class ModelsLayout(Widget):
    self._initialize_items()

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

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

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

+    self.camera_offset = option_item_sp(tr("Adjust Camera Offset"), "CameraOffset", -35, 35,
+                                        tr("Virtually shift camera's perspective to move model's center to Left(+ values) or Right (- values)"),
+                                        1, None, True, "", style.BUTTON_ACTION_WIDTH, None, True,
+                                        lambda v: f"{v / 100:.2f} m")
+
    self.items = [self.current_model_item, self.cancel_download_item, self.supercombo_label, self.vision_label,
-                  self.policy_label, self.off_policy_label, self.on_policy_label, self.refresh_item, self.clear_cache_item, self.lane_turn_desire_toggle,
-                  self.lane_turn_value_control, self.lagd_toggle, self.delay_control]
+                  self.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):
    desc = tr("Enable this for the car to learn and adapt its steering response time. Disable to use a fixed steering response time. " +
@@ -232,14 +237,16 @@ class ModelsLayout(Widget):
    advanced_controls: bool = ui_state.params.get_bool("ShowAdvancedControls")
    turn_desire: bool = ui_state.params.get_bool("LaneTurnDesire")
    live_delay: bool = ui_state.params.get_bool("LagdToggle")
+    camera_offset: bool = ui_state.params.get("ModelManager_ActiveBundle") is not None

    self.lane_turn_desire_toggle.action_item.set_state(turn_desire)
    self.lane_turn_value_control.set_visible(turn_desire and advanced_controls)
    self.lagd_toggle.action_item.set_state(live_delay)
    self.delay_control.set_visible(not live_delay and advanced_controls)
    new_step = int(round(100 / CV.MPH_TO_KPH)) if ui_state.is_metric else 100
-    if self.lane_turn_value_control.action_item.value_change_step != new_step:
+    if self.lane_turn_value_control.action_item is not None and self.lane_turn_value_control.action_item.value_change_step != new_step:
      self.lane_turn_value_control.action_item.value_change_step = new_step
+    self.camera_offset.set_visible(camera_offset)

    self._update_lagd_description(live_delay)
    self.model_manager = ui_state.sm["modelManagerSP"]
@@ -38,8 +38,8 @@ class NetworkUISP(NetworkUI):
      self.scan_button.set_text(tr("Scan"))
      self.scan_button.set_enabled(True)

-  def _render(self, rect: rl.Rectangle):
-    super()._render(rect)
+  def _render(self, _):
+    super()._render(_)

    if self._current_panel == PanelType.WIFI:
      self.scan_button.set_position(self._rect.x, self._rect.y + 20)
@@ -37,7 +37,7 @@ from openpilot.system.ui.widgets.scroller_tici import Scroller
 OP.PANEL_COLOR = rl.Color(10, 10, 10, 255)
 ICON_SIZE = 70

-OP.PanelType = IntEnum(
+OP.PanelType = IntEnum(  # type: ignore[assignment] # ty: ignore[invalid-assignment]
  "PanelType",
  [es.name for es in OP.PanelType] + [
    "SUNNYLINK",
@@ -180,20 +180,18 @@ class SettingsLayoutSP(OP.SettingsLayout):
      self._sidebar_scroller.render(nav_rect)
      return

-  def _handle_mouse_release(self, mouse_pos: MousePos) -> bool:
+  def _handle_mouse_release(self, mouse_pos: MousePos) -> None:
    # Check close button
    if rl.check_collision_point_rec(mouse_pos, self._close_btn_rect):
      if self._close_callback:
        self._close_callback()
-      return True
+      return

    # Check navigation buttons
    for panel_type, panel_info in self._panels.items():
      if rl.check_collision_point_rec(mouse_pos, panel_info.button_rect) and self._sidebar_scroller.scroll_panel.is_touch_valid():
        self.set_current_panel(panel_type)
-        return True
-
-    return False
+        return

  def show_event(self):
    super().show_event()
@@ -138,7 +138,7 @@ class ModelsLayoutMici(NavScroller):
    self._show_selection_view(btns, self._show_folders)

  def _reset_main_view(self):
-    self._scroller._items = self.main_items
+    self._scroller._items = self.main_items  # type: ignore[assignment] # ty: ignore[invalid-assignment]
    self.set_back_callback(self.original_back_callback)
    self._scroller.scroll_panel.set_offset(0)
    self._scroller.scroll_to(0)
@@ -16,6 +16,9 @@ class SunnylinkConsentPage(NavScroller):
  def __init__(self, on_accept: Callable | None = None, on_decline: Callable | None = None):
    super().__init__()

+    assert on_accept is not None and callable(on_accept)
+    assert on_decline is not None and callable(on_decline)
+
    self._accept_button = BigConfirmationCircleButton("enable\nsunnylink", gui_app.texture("icons_mici/setup/driver_monitoring/dm_check.png", 64, 64),
                                                      on_accept,  exit_on_confirm=False)

@@ -198,7 +198,7 @@ class SpeedLimitRenderer(Widget, SpeedLimitAlertRenderer):
        self._draw_ahead_info(sign_rect)

  def _draw_sign_main(self, rect, alpha=1.0):
-    speed_limit_warning_enabled = ui_state.speed_limit_mode >= SpeedLimitMode.warning
+    speed_limit_warning_enabled = ui_state.speed_limit_mode is not None and ui_state.speed_limit_mode >= SpeedLimitMode.warning
    has_limit = self.speed_limit_valid or self.speed_limit_last_valid
    is_overspeed = has_limit and round(self.speed_limit_final_last) < round(self.speed)

@@ -224,8 +224,7 @@ class UIStateSP:


 class DeviceSP:
-  @staticmethod
-  def _set_awake(on: bool, _ui_state):
+  def _set_awake(self, on: bool, _ui_state=None):
    if _ui_state.boot_offroad_mode == 1 and not on:
      _ui_state.params.put_bool("OffroadMode", True)

@@ -357,7 +357,7 @@ def build_mici_script(pm: PubMaster, main_layout, script: Script) -> None:
    params = Params()
    main_layout._alerts_layout._pending_params = ({"UpdaterNewDescription": params.get("UpdaterNewDescription")} |
                                                  {alert_data.key: params.get(alert_data.key) for alert_data in main_layout._alerts_layout.sorted_alerts})
-    main_layout._alerts_layout._refresh()
+    main_layout._alerts_layout._update_state()

  swipe_right(width, wait_after=WAIT_SHORT)  # open alerts
  script.setup(setup_offroad_alerts_and_refresh)  # show alerts
@@ -49,7 +49,7 @@ def patch_submaster(message_chunks):
        sm.recv_frame[service] = sm.frame
        sm.valid[service] = True
    sm.frame += 1
-  ui_state.sm.update = mock_update
+  ui_state.sm.update = mock_update  # ty: ignore[invalid-assignment]  # profiling hook


 if __name__ == "__main__":
@@ -92,7 +92,7 @@ if __name__ == "__main__":
  vipc.create_buffers(VisionStreamType.VISION_STREAM_ROAD, 5, W, H)
  vipc.start_listener()
  yuv_buffer_size = W * H + (W // 2) * (H // 2) * 2
-  yuv_data = np.random.randint(0, 256, yuv_buffer_size, dtype=np.uint8).tobytes()
+  yuv_data = np.random.default_rng().integers(0, 256, yuv_buffer_size, dtype=np.uint8).tobytes()
  with cProfile.Profile() as pr:
    for _ in gui_app.render():
      if ui_state.sm.frame >= len(message_chunks):
@@ -2,7 +2,8 @@ import time
 from openpilot.selfdrive.test.helpers import with_processes


-@with_processes(["ui"])
-def test_raylib_ui():
-  """Test initialization of the UI widgets is successful."""
-  time.sleep(1)
+class TestRaylibUi:
+  @with_processes(["ui"])
+  def test_raylib_ui(self):
+    """Test initialization of the UI widgets is successful."""
+    time.sleep(1)
@@ -46,61 +46,59 @@ def load_po_text(po_path: Path) -> str:
  return po_path.read_text(encoding='utf-8')


-@pytest.mark.parametrize("language_code", sorted(TRANSLATION_LANGUAGES.values()))
-def test_translation_file_exists(language_code: str):
-  po_path = PO_DIR / f"app_{language_code}.po"
-  assert po_path.exists(), f"missing translation file: {po_path}"
+class TestTranslations:
+  @pytest.mark.parametrize("language_code", sorted(TRANSLATION_LANGUAGES.values()))
+  def test_translation_file_exists(self, language_code: str):
+    po_path = PO_DIR / f"app_{language_code}.po"
+    assert po_path.exists(), f"missing translation file: {po_path}"

+  @pytest.mark.parametrize("po_path", sorted(PO_DIR.glob("app_*.po")), ids=lambda p: p.name)
+  def test_translation_placeholders_are_preserved(self, po_path: Path):
+    _, entries = parse_po(po_path)
+    language = po_path.stem.removeprefix("app_")

-@pytest.mark.parametrize("po_path", sorted(PO_DIR.glob("app_*.po")), ids=lambda p: p.name)
-def test_translation_placeholders_are_preserved(po_path: Path):
-  _, entries = parse_po(po_path)
-  language = po_path.stem.removeprefix("app_")
+    for entry in entries:
+      source_placeholders = extract_placeholders(entry.msgid)

-  for entry in entries:
-    source_placeholders = extract_placeholders(entry.msgid)
+      if entry.is_plural:
+        plural_placeholders = extract_placeholders(entry.msgid_plural)
+        message = (
+          f"{language}: source plural placeholders do not match singular for "
+          + f"{entry.msgid!r}: {source_placeholders} vs {plural_placeholders}"
+        )
+        assert plural_placeholders == source_placeholders, message

-    if entry.is_plural:
-      plural_placeholders = extract_placeholders(entry.msgid_plural)
-      message = (
-        f"{language}: source plural placeholders do not match singular for "
-        + f"{entry.msgid!r}: {source_placeholders} vs {plural_placeholders}"
-      )
-      assert plural_placeholders == source_placeholders, message
+        for idx, msgstr in sorted(entry.msgstr_plural.items()):
+          if not msgstr:
+            continue

-      for idx, msgstr in sorted(entry.msgstr_plural.items()):
-        if not msgstr:
+          translated_placeholders = extract_placeholders(msgstr)
+          message = (
+            f"{language}: plural form {idx} changes placeholders for {entry.msgid!r}: "
+            + f"expected {source_placeholders}, got {translated_placeholders}"
+          )
+          assert translated_placeholders == source_placeholders, message
+      else:
+        if not entry.msgstr:
          continue

-        translated_placeholders = extract_placeholders(msgstr)
+        translated_placeholders = extract_placeholders(entry.msgstr)
        message = (
-          f"{language}: plural form {idx} changes placeholders for {entry.msgid!r}: "
+          f"{language}: translation changes placeholders for {entry.msgid!r}: "
          + f"expected {source_placeholders}, got {translated_placeholders}"
        )
        assert translated_placeholders == source_placeholders, message
-    else:
-      if not entry.msgstr:
-        continue

-      translated_placeholders = extract_placeholders(entry.msgstr)
-      message = (
-        f"{language}: translation changes placeholders for {entry.msgid!r}: "
-        + f"expected {source_placeholders}, got {translated_placeholders}"
+  @pytest.mark.parametrize("po_path", sorted(PO_DIR.glob("app_*.po")), ids=lambda p: p.name)
+  def test_translation_refs_do_not_include_line_numbers(self, po_path: Path):
+    for line in load_po_text(po_path).splitlines():
+      assert not LINE_NUMBER_REF_RE.match(line), (
+        f"{po_path.name}: line-number source reference found: {line}"
      )
-      assert translated_placeholders == source_placeholders, message

-
-@pytest.mark.parametrize("po_path", sorted(PO_DIR.glob("app_*.po")), ids=lambda p: p.name)
-def test_translation_refs_do_not_include_line_numbers(po_path: Path):
-  for line in load_po_text(po_path).splitlines():
-    assert not LINE_NUMBER_REF_RE.match(line), (
-      f"{po_path.name}: line-number source reference found: {line}"
+  @pytest.mark.parametrize("po_path", sorted(PO_DIR.glob("app_*.po")), ids=lambda p: p.name)
+  def test_translation_entities_are_valid(self, po_path: Path):
+    matches = BAD_ENTITY_RE.findall(load_po_text(po_path))
+    assert not matches, (
+      f"{po_path.name}: found '@...;' entity typo(s): {', '.join(sorted(set(matches)))}"
    )
-
-
-@pytest.mark.parametrize("po_path", sorted(PO_DIR.glob("app_*.po")), ids=lambda p: p.name)
-def test_translation_entities_are_valid(po_path: Path):
-  matches = BAD_ENTITY_RE.findall(load_po_text(po_path))
-  assert not matches, (
-    f"{po_path.name}: found '@...;' entity typo(s): {', '.join(sorted(set(matches)))}"
-  )
@@ -67,22 +67,22 @@ def parse_po(path: str | Path) -> tuple[POEntry | None, list[POEntry]]:
  cur_field: str | None = None
  plural_idx = 0

-  def finish():
-    nonlocal cur, header
-    if cur is None:
+  def finish(entry: POEntry | None):
+    nonlocal header
+    if entry is None:
      return
-    if cur.msgid == "" and cur.msgstr:
-      header = cur
-    elif cur.msgid != "" or cur.is_plural:
-      entries.append(cur)
-    cur = None
+    if entry.msgid == "" and entry.msgstr:
+      header = entry
+    elif entry.msgid != "" or entry.is_plural:
+      entries.append(entry)

  for raw in lines:
    line = raw.rstrip('\n')
    stripped = line.strip()

    if not stripped:
-      finish()
+      finish(cur)
+      cur = None
      cur_field = None
      continue

@@ -123,6 +123,8 @@ def parse_po(path: str | Path) -> tuple[POEntry | None, list[POEntry]]:
      continue

    if stripped.startswith('msgstr '):
+      if cur is None:
+        cur = POEntry()
      cur.msgstr = _parse_quoted(stripped[len('msgstr '):])
      cur_field = 'msgstr'
      continue
@@ -138,7 +140,7 @@ def parse_po(path: str | Path) -> tuple[POEntry | None, list[POEntry]]:
      elif cur_field == 'msgstr_plural':
        cur.msgstr_plural[plural_idx] += val

-  finish()
+  finish(cur)
  return header, entries


@@ -12,9 +12,9 @@ POT_FILE = os.path.join(str(TRANSLATIONS_DIR), "app.pot")
 def update_translations():
  files = []
  for root, _, filenames in chain(os.walk(SYSTEM_UI_DIR),
-                                  os.walk(os.path.join(UI_DIR, "widgets")),
-                                  os.walk(os.path.join(UI_DIR, "layouts")),
-                                  os.walk(os.path.join(UI_DIR, "onroad"))):
+                                  os.walk(os.path.join(str(UI_DIR), "widgets")),
+                                  os.walk(os.path.join(str(UI_DIR), "layouts")),
+                                  os.walk(os.path.join(str(UI_DIR), "onroad"))):
    for filename in filenames:
      if filename.endswith(".py"):
        files.append(os.path.relpath(os.path.join(root, filename), BASEDIR))
@@ -25,7 +25,7 @@ def update_translations():

  # Generate/update translation files for each language
  for name in multilang.languages.values():
-    po_file = os.path.join(TRANSLATIONS_DIR, f"app_{name}.po")
+    po_file = os.path.join(str(TRANSLATIONS_DIR), f"app_{name}.po")
    if os.path.exists(po_file):
      merge_po(po_file, POT_FILE)
    else:
@@ -314,9 +314,9 @@ class Device(DeviceSP):
      brightness = 0

    if brightness != self._last_brightness:
-      self._brightness_target = brightness
+      self._brightness_target = int(brightness)
      self._brightness_event.set()
-      self._last_brightness = brightness
+      self._last_brightness = int(brightness)

  def _update_wakefulness(self):
    # Handle interactive timeout
@@ -337,9 +337,9 @@ class Device(DeviceSP):

    self._set_awake(ui_state.ignition or not interaction_timeout or PC)

-  def _set_awake(self, on: bool):
+  def _set_awake(self, on: bool, _ui_state=None):
    if on != self._awake:
-      DeviceSP._set_awake(on, ui_state)
+      super()._set_awake(on, _ui_state or ui_state)
      self._awake = on
      cloudlog.debug(f"setting display power {int(on)}")
      HARDWARE.set_display_power(on)
@@ -1 +1 @@
-#define SUNNYPILOT_VERSION "2026.002.000"
+#define SUNNYPILOT_VERSION "2026.003.000"
@@ -29,7 +29,7 @@ def make_event(event_types):
  event = {}
  for ev in event_types:
    event[ev] = NormalPermanentAlert("alert")
-  EVENTS_SP[0] = event
+  EVENTS_SP[0] = event  # type: ignore[assignment] # ty: ignore[invalid-assignment]
  return 0


@@ -128,7 +128,7 @@ def main_thread():
    cloudlog.exception(f"mapd: failed to make {Paths.mapd_root()}")

  while True:
-    show_alert = get_files_for_cleanup() and params.get_bool("OsmLocal")
+    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.")

    update_osm_db()
@@ -10,471 +10,291 @@ import argparse
 import os
 import pickle
 import time
-from functools import partial
 from collections import defaultdict
-
+from functools import partial
 import numpy as np
-from tinygrad.tensor import Tensor
+os.environ['GMMU'] = '0'
+
+def _patch_tinygrad_fetch_fw():
+  import hashlib
+  import pathlib
+  import zstandard
+  from tinygrad import helpers
+  _orig_fetch_fw = helpers.fetch_fw
+  def fetch_fw(path, name, sha256):
+    p = pathlib.Path(f"/lib/firmware/{path}/{name}.zst")
+    if p.is_file():
+      blob = zstandard.ZstdDecompressor().stream_reader(p.read_bytes()).read()
+      if hashlib.sha256(blob).hexdigest() == sha256:
+        return blob
+    return _orig_fetch_fw(path, name, sha256)
+  helpers.fetch_fw = fetch_fw
+_patch_tinygrad_fetch_fw()
+
+from openpilot.selfdrive.modeld.compile_modeld import NV12Frame, make_frame_prepare, sample_desire, sample_skip, shift_and_sample
+from tinygrad import dtypes
 from tinygrad.device import Device
 from tinygrad.engine.jit import TinyJit
-
-from openpilot.selfdrive.modeld.compile_modeld import (
-  NV12Frame, make_frame_prepare,
-  shift_and_sample, sample_skip, sample_desire,
-)
+from tinygrad.tensor import Tensor

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


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


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


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


-def make_run_split_policy(vision_runner, policy_runner, nv12: NV12Frame, model_w, model_h,
-                          vision_features_slice, frame_skip, desire_key, extra_policy_keys,
-                          vision_road_key, vision_wide_key, prepare_only=False):
-  frame_prepare = make_frame_prepare(nv12, model_w, model_h)
-  sample_skip_fn = partial(sample_skip, frame_skip=frame_skip)
-  sample_desire_fn = partial(sample_desire, frame_skip=frame_skip)
-
-  def run_policy(img_q, big_img_q, feat_q, desire_q, desire, traffic_convention, tfm, big_tfm, frame, big_frame, **extra):
-    npy_tensors = [tfm.to(Device.DEFAULT), big_tfm.to(Device.DEFAULT),
-                   desire.to(Device.DEFAULT), traffic_convention.to(Device.DEFAULT)]
-    extra_device = {k: extra[k].to(Device.DEFAULT) for k in extra_policy_keys}
-    Tensor.realize(*npy_tensors, *extra_device.values())
-    tfm, big_tfm, desire, traffic_convention = npy_tensors
-
-    img = shift_and_sample(img_q, frame_prepare(frame, tfm).unsqueeze(0), sample_skip_fn)
-    big_img = shift_and_sample(big_img_q, frame_prepare(big_frame, big_tfm).unsqueeze(0), sample_skip_fn)
-
-    if prepare_only:
-      return img, big_img
-
-    vision_out = next(iter(vision_runner({vision_road_key: img, vision_wide_key: big_img}).values())).cast('float32')
-
-    new_feat = vision_out[:, vision_features_slice].reshape(1, -1).unsqueeze(0)
-    feat_buf = shift_and_sample(feat_q, new_feat, sample_skip_fn)
-    desire_buf = shift_and_sample(desire_q, desire.reshape(1, 1, -1), sample_desire_fn)
-
-    inputs = {'features_buffer': feat_buf, desire_key: desire_buf, 'traffic_convention': traffic_convention, **extra_device}
-    policy_out = next(iter(policy_runner(inputs).values())).cast('float32')
-
-    return vision_out, policy_out
-  return run_policy
-
-
-def compile_split_policy(nv12: NV12Frame, model_w, model_h, prepare_only, frame_skip,
-                         vision_runner, policy_runner, vision_metadata, policy_metadata):
-  print(f"Compiling combined policy JIT for {nv12.width}x{nv12.height} (prepare_only={prepare_only})...")
-
-  vision_features_slice = vision_metadata['output_slices']['hidden_state']
-  vision_input_shapes = vision_metadata['input_shapes']
-  policy_input_shapes = policy_metadata['input_shapes']
-  desire_key = _detect_desire_key(policy_input_shapes)
-  extra_policy_keys = [k for k in policy_input_shapes if k not in ('features_buffer', desire_key, 'traffic_convention')]
-  vision_road_key, vision_wide_key = _detect_vision_keys(vision_input_shapes)
-
-  _run = make_run_split_policy(vision_runner, policy_runner, nv12, model_w, model_h,
-                               vision_features_slice, frame_skip, desire_key, extra_policy_keys,
-                               vision_road_key, vision_wide_key, prepare_only)
-  run_policy_jit = TinyJit(_run, prune=True)
-
-  SEED = 42
-
-  def random_inputs_run_fn(fn, seed, test_val=None, test_buffers=None, expect_match=True):
-    input_queues, npy = make_split_input_queues(vision_input_shapes, policy_input_shapes, frame_skip, Device.DEFAULT)
-    np.random.seed(seed)
-    Tensor.manual_seed(seed)
-
-    testing = test_val is not None or test_buffers is not None
-    n_runs = 1 if testing else 3
-
-    for i in range(n_runs):
-      frame = Tensor.randint(nv12.size, low=0, high=256, dtype='uint8').realize()
-      big_frame = Tensor.randint(nv12.size, low=0, high=256, dtype='uint8').realize()
-      for v in npy.values():
-        v[:] = np.random.randn(*v.shape).astype(v.dtype)
-      Device.default.synchronize()
-      st = time.perf_counter()
-      outs = fn(**input_queues, frame=frame, big_frame=big_frame)
-      mt = time.perf_counter()
-      Device.default.synchronize()
-      et = time.perf_counter()
-      print(f"  [{i+1}/{n_runs}] enqueue {(mt-st)*1e3:6.2f} ms -- total {(et-st)*1e3:6.2f} ms")
-
-      if i == 0:
-        val = [np.copy(v.numpy()) for v in outs]
-        buffers = [np.copy(v.numpy().copy()) for v in input_queues.values()]
-
-    if test_val is not None:
-      match = all(np.array_equal(a, b) for a, b in zip(val, test_val, strict=True))
-      assert match == expect_match, f"outputs {'differ from' if expect_match else 'match'} baseline (seed={seed})"
-    if test_buffers is not None:
-      match = all(np.array_equal(a, b) for a, b in zip(buffers, test_buffers, strict=True))
-      assert match == expect_match, f"buffers {'differ from' if expect_match else 'match'} baseline (seed={seed})"
-    return fn, val, buffers
-
-  print('capture + replay')
-  run_policy_jit, test_val, test_buffers = random_inputs_run_fn(run_policy_jit, SEED)
-
-  print('pickle round trip')
-  run_policy_jit = pickle.loads(pickle.dumps(run_policy_jit))
-  random_inputs_run_fn(run_policy_jit, SEED, test_val, test_buffers, expect_match=True)
-  random_inputs_run_fn(run_policy_jit, SEED+1, test_val, test_buffers, expect_match=False)
-  return run_policy_jit
-
-
-def derive_frame_skip(vision_input_shapes, policy_input_shapes):
-  fb = policy_input_shapes.get('features_buffer')
-  if fb is None:
-    return 1
-  fb_history = fb[1]
-  if fb_history >= 99:
-    return 1
-  return 4
-
-
-def make_supercombo_input_queues(input_shapes, frame_skip, device):
-  img_shape = input_shapes.get('img', input_shapes.get('input_imgs'))
-  if img_shape is None:
-    raise ValueError("No img input found in model shapes")
+def generate_queues_and_npy(input_shapes: dict, frame_skip: int, device: str = Device.DEFAULT) -> tuple[dict, dict]:
+  road_key, _ = _detect_vision_keys(input_shapes)
+  if not road_key:
+    raise ValueError("Vision road key missing from input shapes.")

+  img_shape = input_shapes[road_key]
  n_frames = img_shape[1] // 6
  img_buf_shape = (frame_skip * (n_frames - 1) + 1, 6, img_shape[2], img_shape[3])

-  numpy_keys = {}
-  queue_keys = {}
+  desire_key = _detect_desire_key(input_shapes)
+  if not desire_key:
+    raise ValueError("Desire key missing from input shapes.")
+
+  desire_shape = input_shapes[desire_key]
+  features_buffer = input_shapes.get('features_buffer')
+
+  npy_arrays = {
+    'desire': np.zeros(desire_shape[2], dtype=np.float32),
+    'tfm': np.zeros((3, 3), dtype=np.float32),
+    'big_tfm': np.zeros((3, 3), dtype=np.float32)
+  }

  for key, shape in input_shapes.items():
-    if 'img' in key:
-      continue
-    if len(shape) == 3 and shape[1] > 1:
-      if key.startswith('desire'):
-        numpy_keys[key] = np.zeros(shape[2], dtype=np.float32)
-        queue_keys[f'{key}_q'] = Tensor(
-          np.zeros((frame_skip * shape[1], shape[0], shape[2]), dtype=np.float32),
-          device=device).contiguous().realize()
-      elif key == 'features_buffer':
-        queue_keys['feat_q'] = Tensor(
-          np.zeros((frame_skip * (shape[1] - 1) + 1, shape[0], shape[2]), dtype=np.float32),
-          device=device).contiguous().realize()
-      else:
-        numpy_keys[key] = np.zeros(shape, dtype=np.float32)
-    elif len(shape) == 2:
-      numpy_keys[key] = np.zeros(shape, dtype=np.float32)
+    if key not in npy_arrays and 'img' not in key and key not in ('features_buffer', desire_key):
+      npy_arrays[key] = np.zeros(shape, dtype=np.float32)

-  if 'traffic_convention' not in numpy_keys:
-    tc_shape = input_shapes.get('traffic_convention', (1, 2))
-    numpy_keys['traffic_convention'] = np.zeros(tc_shape, dtype=np.float32)
-
-  numpy_keys['tfm'] = np.zeros((3, 3), dtype=np.float32)
-  numpy_keys['big_tfm'] = np.zeros((3, 3), dtype=np.float32)
-
-  input_queues = {
+  queues = {
    'img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
    'big_img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
-    **queue_keys,
-    **{k: Tensor(v, device='NPY').realize() for k, v in numpy_keys.items()},
+    'desire_q': Tensor(np.zeros((frame_skip * desire_shape[1], desire_shape[0], desire_shape[2]),
+                  dtype=np.float32), device=device).contiguous().realize()
  }
-  return input_queues, numpy_keys
+
+  if features_buffer:
+    queues['feat_q'] = Tensor(np.zeros((frame_skip * (features_buffer[1] - 1) + 1, features_buffer[0], features_buffer[2]),
+                       dtype=np.float32), device=device).contiguous().realize()
+
+  queues.update({key: Tensor(value, device='NPY').realize() for key, value in npy_arrays.items()})
+  return queues, npy_arrays


-def make_run_supercombo(model_runner, nv12: NV12Frame, model_w, model_h,
-                        features_slice, frame_skip, input_shapes, prepare_only=False):
-  frame_prepare = make_frame_prepare(nv12, model_w, model_h)
+def make_split_input_queues(vision_input_shapes: dict, policy_input_shapes: dict, frame_skip: int, device: str = Device.DEFAULT) -> tuple[dict, dict]:
+  return generate_queues_and_npy({**vision_input_shapes, **policy_input_shapes}, frame_skip, device)
+
+
+def make_supercombo_input_queues(input_shapes: dict, frame_skip: int, device: str = Device.DEFAULT) -> tuple[dict, dict]:
+  return generate_queues_and_npy(input_shapes, frame_skip, device)
+
+
+def create_jit_runner(vision_runner, policy_runners: list, nv12: NV12Frame, model_size: tuple[int, int],
+            features_slice: slice, frame_skip: int, input_shapes: dict, prepare_only: bool):
+  frame_prepare = make_frame_prepare(nv12, *model_size)
  sample_skip_fn = partial(sample_skip, frame_skip=frame_skip)
  sample_desire_fn = partial(sample_desire, frame_skip=frame_skip)

  desire_key = _detect_desire_key(input_shapes)
-  if desire_key is None:
-    raise ValueError(f"No desire* key found in input_shapes: {list(input_shapes.keys())}")
-  road_img_key, wide_img_key = _detect_vision_keys(input_shapes)
-  extra_policy_keys = [k for k in input_shapes
-                       if k not in (desire_key, 'features_buffer', 'traffic_convention')
-                       and 'img' not in k]
+  road_key, wide_key = _detect_vision_keys(input_shapes)

-  def run_supercombo(img_q, big_img_q, feat_q, desire_q,
-                     frame, big_frame, **kwargs):
-    desire = kwargs.get(desire_key)
+  if not desire_key or not road_key or not wide_key:
+    raise ValueError("Missing required vision or desire keys in input shapes.")
+
+  extra_keys = [key for key in input_shapes if key not in (desire_key, 'features_buffer', 'traffic_convention') and 'img' not in key]
+
+  def runner(img_q, big_img_q, feat_q, frame, big_frame, tfm, big_tfm, **kwargs):
+    desire_q = kwargs['desire_q']
+    desire = kwargs['desire']
    traffic_convention = kwargs.get('traffic_convention')
-    tfm = kwargs['tfm']
-    big_tfm = kwargs['big_tfm']

-    tfm = tfm.to(Device.DEFAULT)
-    big_tfm = big_tfm.to(Device.DEFAULT)
-    desire = desire.to(Device.DEFAULT)
-    traffic_convention = traffic_convention.to(Device.DEFAULT)
-    Tensor.realize(tfm, big_tfm, desire, traffic_convention)
+    npys = [tfm.to(Device.DEFAULT), big_tfm.to(Device.DEFAULT), desire.to(Device.DEFAULT)]
+    if traffic_convention is not None:
+      npys.append(traffic_convention.to(Device.DEFAULT))

-    img = shift_and_sample(img_q, frame_prepare(frame, tfm).unsqueeze(0), sample_skip_fn)
-    big_img = shift_and_sample(big_img_q, frame_prepare(big_frame, big_tfm).unsqueeze(0), sample_skip_fn)
+    extra_tensors = {key: kwargs[key].to(Device.DEFAULT) for key in extra_keys if key in kwargs}
+    Tensor.realize(*npys, *extra_tensors.values())
+
+    tfm_dev, big_tfm_dev, desire_dev = npys[:3]
+    traffic_conv_dev = npys[3] if traffic_convention is not None else None
+
+    img = shift_and_sample(img_q, frame_prepare(frame, tfm_dev).unsqueeze(0), sample_skip_fn)
+    big_img = shift_and_sample(big_img_q, frame_prepare(big_frame, big_tfm_dev).unsqueeze(0), sample_skip_fn)

    if prepare_only:
      return img, big_img

-    desire_buf = shift_and_sample(desire_q, desire.reshape(1, 1, -1), sample_desire_fn)
-    feat_buf = sample_skip_fn(feat_q)
+    desire_buf = shift_and_sample(desire_q, desire_dev.reshape(1, 1, -1), sample_desire_fn)
+    inputs = {desire_key: desire_buf, **extra_tensors}

-    inputs = {road_img_key: img, wide_img_key: big_img,
-              desire_key: desire_buf, 'features_buffer': feat_buf,
-              'traffic_convention': traffic_convention}
-    for k in extra_policy_keys:
-      if k in kwargs:
-        inputs[k] = kwargs[k].to(Device.DEFAULT)
+    if traffic_conv_dev is not None:
+      inputs['traffic_convention'] = traffic_conv_dev

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

-    new_feat = model_out[:, features_slice].reshape(1, -1).unsqueeze(0)
-    shift_and_sample(feat_q, new_feat, sample_skip_fn)
-
-    return model_out
-
-  return run_supercombo
+  return runner


-def make_run_vision_multi_policy(vision_runner, policy_runners, nv12: NV12Frame, model_w, model_h,
-                                 vision_features_slice, frame_skip, desire_key, extra_policy_keys,
-                                 vision_road_key, vision_wide_key, prepare_only=False):
-  frame_prepare = make_frame_prepare(nv12, model_w, model_h)
-  sample_skip_fn = partial(sample_skip, frame_skip=frame_skip)
-  sample_desire_fn = partial(sample_desire, frame_skip=frame_skip)
+def compile_and_warmup(nv12: NV12Frame, model_size: tuple[int, int], prepare_only: bool, frame_skip: int, vision_runner, policy_runners: list, metadata: dict):
+  print(f"Compiling combined JIT for {nv12.width}x{nv12.height} (prepare_only={prepare_only})...")

-  def run_multi_policy(img_q, big_img_q, feat_q, desire_q, desire,
-                       traffic_convention, tfm, big_tfm, frame, big_frame, **extra):
-    npy_tensors = [tfm.to(Device.DEFAULT), big_tfm.to(Device.DEFAULT),
-                   desire.to(Device.DEFAULT), traffic_convention.to(Device.DEFAULT)]
-    extra_device = {k: extra[k].to(Device.DEFAULT) for k in extra_policy_keys}
-    Tensor.realize(*npy_tensors, *extra_device.values())
-    tfm, big_tfm, desire, traffic_convention = npy_tensors
+  all_shapes = {key: value for meta in metadata.values() for key, value in meta['input_shapes'].items()}

-    img = shift_and_sample(img_q, frame_prepare(frame, tfm).unsqueeze(0), sample_skip_fn)
-    big_img = shift_and_sample(big_img_q, frame_prepare(big_frame, big_tfm).unsqueeze(0), sample_skip_fn)
+  feat_meta = metadata.get('vision') or metadata.get('model') or metadata.get('policy')
+  if not feat_meta:
+    raise ValueError("Could not find vision, model, or policy metadata.")

-    if prepare_only:
-      return img, big_img
+  features_slice = feat_meta['output_slices']['hidden_state']
+  WARP_DEV = 'CPU' if "USBGPU" in os.environ else Device.DEFAULT

-    vision_out = next(iter(vision_runner({vision_road_key: img, vision_wide_key: big_img}).values())).cast('float32')
+  run_func = create_jit_runner(vision_runner, policy_runners, nv12, model_size, features_slice, frame_skip, all_shapes, prepare_only)
+  run_jit = TinyJit(run_func, prune=True)
+  queues, npy_arrays = generate_queues_and_npy(all_shapes, frame_skip, Device.DEFAULT)

-    new_feat = vision_out[:, vision_features_slice].reshape(1, -1).unsqueeze(0)
-    feat_buf = shift_and_sample(feat_q, new_feat, sample_skip_fn)
-    desire_buf = shift_and_sample(desire_q, desire.reshape(1, 1, -1), sample_desire_fn)
-
-    inputs = {'features_buffer': feat_buf, desire_key: desire_buf, 'traffic_convention': traffic_convention, **extra_device}
-
-    policy_outputs = []
-    for runner in policy_runners:
-      policy_out = next(iter(runner(inputs).values())).cast('float32')
-      policy_outputs.append(policy_out)
-
-    return (vision_out, *policy_outputs)
-
-  return run_multi_policy
-
-
-def _warmup_and_serialize(run_jit, input_queues, npy, nv12):
  for i in range(3):
    np.random.seed(42 + i)
-    frame = Tensor.randint(nv12.size, low=0, high=256, dtype='uint8').realize()
-    big_frame = Tensor.randint(nv12.size, low=0, high=256, dtype='uint8').realize()
-    for v in npy.values():
-      v[:] = np.random.randn(*v.shape).astype(v.dtype)
+    frame = Tensor.randint(nv12.size, low=0, high=256, dtype=dtypes.uint8, device=WARP_DEV).realize()
+    big_frame = Tensor.randint(nv12.size, low=0, high=256, dtype=dtypes.uint8, device=WARP_DEV).realize()
+    for arr in npy_arrays.values():
+      arr[:] = np.random.randn(*arr.shape).astype(arr.dtype)
+
    Device.default.synchronize()
-    st = time.perf_counter()
-    run_jit(**input_queues, frame=frame, big_frame=big_frame)
-    mt = time.perf_counter()
+    start_time = time.perf_counter()
+    run_jit(**queues, frame=frame, big_frame=big_frame)
+    mid_time = time.perf_counter()
    Device.default.synchronize()
-    et = time.perf_counter()
-    print(f"  [{i + 1}/3] enqueue {(mt - st) * 1e3:6.2f} ms -- total {(et - st) * 1e3:6.2f} ms")
-  return pickle.loads(pickle.dumps(run_jit))
+    print(f"  [{i + 1}/3] enqueue {(mid_time - start_time) * 1e3:6.2f} ms -- total {(time.perf_counter() - start_time) * 1e3:6.2f} ms")
+
+  return pickle.loads(pickle.dumps(run_jit)) if not prepare_only else run_jit


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


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


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


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

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

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

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

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

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

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

-    first_policy_key = policy_onnxes[0][0]
-    frame_skip = args.frame_skip if args.frame_skip is not None else derive_frame_skip(out['metadata']['vision']['input_shapes'],
-                                                                                       out['metadata'][first_policy_key]['input_shapes'])
+  with open(args.output, "wb") as file:
+    pickle.dump(output_data, file)

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

  from openpilot.common.file_chunker import chunk_file, get_chunk_targets
  chunk_targets = get_chunk_targets(args.output, pkl_size)
  chunk_file(args.output, chunk_targets)
-  num_chunks = len(chunk_targets) - 1
-  print(f"Chunked into {num_chunks} file(s)")
+  print(f"Chunked into {len(chunk_targets) - 1} file(s)")
@@ -7,6 +7,7 @@ See the LICENSE.md file in the root directory for more details.
 """

 import os
+os.environ['GMMU'] = '0'
 from openpilot.common.hardware import TICI
 os.environ['DEV'] = 'QCOM' if TICI else 'CPU'
 USBGPU = "USBGPU" in os.environ
@@ -110,6 +111,8 @@ class ModelState(ModelStateBase):
    jits = pickle.load(open_file_chunked(pkl_path))

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

    metadata = jits['metadata']
    if 'model' in metadata:
@@ -121,7 +124,7 @@ class ModelState(ModelStateBase):
      self._vision_input_names = [k for k in model_metadata['input_shapes'] if 'img' in k]
      from openpilot.sunnypilot.modeld_v2.compile_modeld import make_supercombo_input_queues
      frame_skip = derive_frame_skip({}, model_metadata['input_shapes'])
-      self.input_queues, self.numpy_inputs = make_supercombo_input_queues(model_metadata['input_shapes'], frame_skip, device=self.DEV)
+      self.input_queues, self.numpy_inputs = make_supercombo_input_queues(model_metadata['input_shapes'], frame_skip, device=self.QUEUE_DEV)
    else:
      vision_metadata = metadata['vision']
      policy_keys = [k for k in metadata if k != 'vision']
@@ -139,7 +142,11 @@ class ModelState(ModelStateBase):
      policy_input_shapes = first_policy_metadata['input_shapes']
      self._vision_input_names = [k for k in vision_input_shapes if 'img' in k]
      frame_skip = derive_frame_skip(vision_input_shapes, policy_input_shapes)
-      self.input_queues, self.numpy_inputs = make_split_input_queues(vision_input_shapes, policy_input_shapes, frame_skip, device=self.DEV)
+      self.input_queues, self.numpy_inputs = make_split_input_queues(vision_input_shapes, policy_input_shapes, frame_skip, device=self.QUEUE_DEV)
+
+    self._desire_key = next(key for key in self.numpy_inputs if key.startswith('desire'))
+    self._road_key = next(key for key in self._vision_input_names if 'big' not in key)
+    self._wide_key = next(key for key in self._vision_input_names if 'big' in key)

    from openpilot.sunnypilot.modeld_v2.parse_model_outputs_split import Parser as SplitParser
    from openpilot.sunnypilot.modeld_v2.parse_model_outputs import Parser as CombinedParser
@@ -161,12 +168,11 @@ class ModelState(ModelStateBase):

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


  @property
@@ -179,7 +185,7 @@ class ModelState(ModelStateBase):

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

  def run(self, bufs: dict[str, VisionBuf], transforms: dict[str, np.ndarray],
                inputs: dict[str, np.ndarray], prepare_only: bool) -> dict[str, np.ndarray] | None:
@@ -190,19 +196,19 @@ class ModelState(ModelStateBase):
      yuv_size = self.frame_buf_params[key][3]
      cache_key = (key, ptr)
      if cache_key not in self._blob_cache:
-        self._blob_cache[cache_key] = Tensor.from_blob(ptr, (yuv_size,), dtype='uint8', device=self.DEV)
+        self._blob_cache[cache_key] = Tensor.from_blob(ptr, (yuv_size,), dtype='uint8', device=self.WARP_DEV)
      self.full_frames[key] = self._blob_cache[cache_key]

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

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

@@ -225,8 +231,12 @@ class ModelState(ModelStateBase):
        policy_output = raw_outputs[i + 1].numpy().flatten()
        policy_sliced = {k: policy_output[np.newaxis, v] for k, v in policy_slices.items()}
        parsed = self.parser.parse_policy_outputs(policy_sliced)
-        if 'off' in self._policy_keys[i] and self._has_on_policy:
+        if ('off' in self._policy_keys[i]
+          and self._has_on_policy
+          and any('plan' in self._policy_slices_list[j] for j, k in enumerate(self._policy_keys) if 'on' in k.lower())):
+
          parsed.pop('plan', None)
+
        outputs.update(parsed)

      if 'planplus' in outputs and 'plan' in outputs:
@@ -241,13 +251,20 @@ class ModelState(ModelStateBase):

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

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

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

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

-      action = model.get_action_from_model(model_output, prev_action, lat_delay + DT_MDL, long_delay + DT_MDL, v_ego)
+      action = model.get_action_from_model(model_output, prev_action, lat_action_t, long_action_t, v_ego)
      prev_action = action
      fill_model_msg(drivingdata_send, modelv2_send, model_output, action,
                     publish_state, meta_main.frame_id, meta_extra.frame_id, frame_id,
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nayan	98254867a9	fuck. i AM blind. or dumb. or both.	2026-07-25 16:49:07 -04:00
Nayan	bee1cdd45d	i might be blind	2026-07-25 16:47:01 -04:00
nayan	91e40b80d8	wtf. ghostwriter	2026-07-25 16:34:01 -04:00
nayan	110568a9d1	it's a supercombo	2026-07-25 16:28:47 -04:00
nayan	bb1b9a27d8	Merge remote-tracking branch 'origin/master' into deep-rl # Conflicts: # openpilot/sunnypilot/modeld_v2/compile_modeld.py # openpilot/sunnypilot/modeld_v2/modeld.py # openpilot/sunnypilot/modeld_v2/tests/test_combined_pkl_loader.py # openpilot/sunnypilot/modeld_v2/tests/test_warp.py # openpilot/sunnypilot/modeld_v2/warp.py # openpilot/sunnypilot/models/manager.py # openpilot/sunnypilot/models/runners/helpers.py # openpilot/sunnypilot/models/runners/model_runner.py # openpilot/sunnypilot/models/runners/tinygrad/model_types.py # openpilot/sunnypilot/models/runners/tinygrad/tinygrad_runner.py # sunnypilot/models/helpers.py	2026-07-25 16:12:52 -04:00
nayan	76b21c72cf	i don't know what i'm doing	2026-07-25 16:08:15 -04:00
Eitan	fd22de1c9a	SCC-M: fix operator precedence in quadratic roots (#1816 ) * controls/scc: fix operator precedence in map controller quadratic roots * not async --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2026-07-25 09:37:18 -04:00
Christopher Haucke	ee3583df33	[tizi/tici] ui: Camera offset controls (#1813 ) * Camera offset controls * final --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2026-07-25 09:15:05 -04:00
Jason Wen	7801bdf0cc	Reapply "mapd: ignore in plannerd health check (#1880 )" This reverts commit `9163d1cb74`.	2026-07-25 01:36:05 -04:00
Jason Wen	0265ae5f76	Revert "plannerd: check all services for validity (#38341 )" This reverts commit `a9ffebe96e`.	2026-07-25 01:27:25 -04:00
Jason Wen	9163d1cb74	Revert "mapd: ignore in plannerd health check (#1880 )" This reverts commit `2c334ede44`.	2026-07-25 01:27:11 -04:00
Jason Wen	a0cc313fdc	version: bump to 2026.003.000	2026-07-24 11:36:33 -04:00
Jason Wen	93bb596a2e	Sync: `commaai/openpilot:master` → `sunnypilot/sunnypilot:master` (#1883 )	2026-07-24 11:18:35 -04:00
Jason Wen	41b14fa595	Merge commaai/openpilot `fdd1df79` into sync-20260721	2026-07-24 11:07:06 -04:00
Adeeb Shihadeh	fdd1df79fb	longitudinal: remove per-car stopping tunes (#38394 ) * remove per-car longitudinal stopping tunes * bump opendbc * lil more * lil more * lil more * lil more * revert modeld for now	2026-07-20 19:52:23 -07:00
Adeeb Shihadeh	031b1ad0a3	longcontrol: remove starting state (#38340 )	2026-07-20 16:30:42 -07:00
Daniel Koepping	b1f2e638de	fix branch cleanup burning GH API requests (#38392 ) * ci: stop branch cleanup from burning API rate limit * simpler	2026-07-20 16:00:20 -07:00
Daniel Koepping	c20263d985	speedup chunk reading (#38389 ) read chunk directly into caller buffer	2026-07-20 14:46:33 -07:00
Daniel Koepping	5472e69e35	New sounds (#38154 ) * new sounds * soundd: fix sound cutoff * update sounds * add max warning_immediate variant * mici: play sounds button in developer settings * rename sounds * add complete sound * update sounds * raise soundfloor by 5% * update sounds * play unused sounds * update sounds * bump opendbc * Revert "play unused sounds" This reverts commit 47e538da2200e700804714576baa5f8c0f28cdb3. * Revert "mici: play sounds button in developer settings" This reverts commit 149141bb8a21bec7a04dc8f231d0b6b9120cc7c2. * remove unused sounds * raise soundfloor by 5% * opendbc * add space	2026-07-20 14:31:55 -07:00
Jason Wen	2c334ede44	mapd: ignore in plannerd health check (#1880 ) * mapd: ignore in plannerd health check * more	2026-07-20 15:05:19 -04:00
Daniel Koepping	78909dac73	soundd: add complete sound (#38390 )	2026-07-20 10:50:18 -07:00
Daniel Koepping	24a9b6dae5	profile usb gpu link stability (#38368 ) * profile usb gpu link before using * ci	2026-07-20 10:36:09 -07:00
Adeeb Shihadeh	d9596fa998	gc old athena and uploader migration code	2026-07-19 14:55:42 -07:00
Adeeb Shihadeh	e124d6df9b	more dead code gc	2026-07-19 14:52:04 -07:00
Adeeb Shihadeh	3dbf02f803	cereal: gc dead ZMQ branches in tests	2026-07-19 14:45:26 -07:00
Adeeb Shihadeh	fef29ad225	start porting tests to unittest style (#38384 )	2026-07-19 14:33:26 -07:00
Adeeb Shihadeh	157c7080ce	bump opendbc (#38370 )	2026-07-19 12:21:04 -07:00
Adeeb Shihadeh	caa9e770cc	manager: remove preimport stage (#38381 )	2026-07-19 12:20:25 -07:00
Adeeb Shihadeh	24893ebadb	rm pre-commit-hooks (#38382 ) * rm pre-commit-hooks * rm test for the tests * lil more	2026-07-19 12:10:48 -07:00
Adeeb Shihadeh	39e12c8bb1	rm cffi, it's a raylib transitive dep	2026-07-19 11:14:40 -07:00
Adeeb Shihadeh	f0d93eb32d	more ty, part 2 (#38379 )	2026-07-19 11:02:00 -07:00
Adeeb Shihadeh	19ecc37de8	more ty (#38378 ) * enable no matching overload * enable call non callable * enable unsupported-operator * enable not subscriptable * refactor pass	2026-07-19 09:45:46 -07:00
Adeeb Shihadeh	ecac2d386b	these go in tools	2026-07-19 09:02:02 -07:00
Adeeb Shihadeh	e475d10adc	more ruff (#38377 ) * lil more ruff * no exclusions! * rm nb exception * and generated * not used * c408 * random * all * unittest is fine	2026-07-19 08:51:16 -07:00
Adeeb Shihadeh	7d74c3c99b	rm setuptools (#38376 ) * rm setuptools * lock	2026-07-19 08:25:31 -07:00
Adeeb Shihadeh	cefcf10ec3	rm jinja2	2026-07-19 08:15:01 -07:00
Adeeb Shihadeh	1c07e00759	rm xattr (#38373 ) * rm xattr * doesn't add new coverage	2026-07-18 13:55:47 -07:00
Adeeb Shihadeh	f0841b827a	remove av (#38366 )	2026-07-18 09:04:41 -07:00
Adeeb Shihadeh	3f49e2d33c	jp: add thumbnail source (#38363 )	2026-07-18 09:02:08 -07:00
Adeeb Shihadeh	3f93b00120	webrtc: remove av (#38369 )	2026-07-18 08:52:02 -07:00
stef	c21b0821da	fix(ui): label alignment and text with icon (#38365 ) fix align bottom and text positioning with icon	2026-07-17 16:23:44 -07:00
Adeeb Shihadeh	b9f25f8a43	webrtcd: move to libdatachannel (#38228 ) * try libdatachannel * fix uv lock * fix uv lock * remove datachannel abstraction and just use libdatachannel * clean * fix livestream bitrate controller * fix sample * fix import breaking ci * clean up and add catches * bump tele * move to teleop master * fix linter * . * remove libdatachannel explicit reference from pyproject.toml * add PyJWT crypto and catch in registration * spelling * add crypto back to lock --------- Co-authored-by: stefpi <19478336+stefpi@users.noreply.github.com>	2026-07-17 15:28:39 -07:00
ZwX1616	c8786d930d	DM: reasonable lockout ramp up (#38358 )	2026-07-17 15:27:20 -07:00
Adeeb Shihadeh	3a55f31dc5	agnos 18.5 (#38302 )	2026-07-17 15:24:34 -07:00
Adeeb Shihadeh	a04c045cd7	cabana: de-Qt, part 3 (#38360 )	2026-07-17 09:31:16 -07:00
rkdune	9aa5c3d2c6	expose submodule dependencies as an extra	2026-07-16 18:16:08 -07:00
Adeeb Shihadeh	5d23a78c77	cabana: de-Qt, part 2 (#38359 )	2026-07-16 14:35:45 -07:00
Adeeb Shihadeh	06a73f538e	cabana: de-Qt, part 1 (#38357 ) * cabana: de-Qt, part 1 * lil more	2026-07-16 13:45:57 -07:00
Shane Smiskol	60716edc37	Fix thumbnail creation (#38354 ) it's not a stream	2026-07-15 22:51:41 -07:00
Adeeb Shihadeh	61608db786	jp: fix linking on macOS (#38353 ) * jp: fix linking on macOS * mv to root	2026-07-15 21:39:47 -07:00
discountchubbs	70424bd661	oopsie	2026-06-12 04:08:47 -07:00
discountchubbs	d215eab1d4	deeeeep	2026-06-12 03:49:03 -07:00
discountchubbs	91316c8cb5	simplify	2026-06-12 03:38:33 -07:00
discountchubbs	fa284be7e6	bye metadata	2026-06-12 03:12:13 -07:00
discountchubbs	6e7d9e5e52	done done done	2026-06-07 11:37:30 -07:00
James Vecellio-Grant	a4a7c2335d	Merge branch 'compile-modeld-defluff' into deep-rl	2026-06-07 19:54:47 +02:00
James Vecellio-Grant	ae573c7c3f	Update compile_modeld.py	2026-06-07 10:52:39 -07:00
discountchubbs	7d7b6ee306	i could	2026-06-07 10:32:55 -07:00
discountchubbs	6a4c59c3e0	needed	2026-06-07 10:22:07 -07:00
discountchubbs	fb5cb7a1cc	i could lie say	2026-06-07 10:06:02 -07:00
discountchubbs	049dfd2eaa	Update compile_modeld.py	2026-06-07 09:47:40 -07:00
discountchubbs	be20848487	Update compile_modeld.py	2026-06-07 04:17:14 -07:00
discountchubbs	cdd232b606	Merge branch 'deep-rl' of github.com:sunnypilot/sunnypilot into deep-rl	2026-06-07 04:06:16 -07:00
discountchubbs	b21c70b1ba	Update compile_modeld.py	2026-06-07 04:05:54 -07:00
James Vecellio-Grant	67e5bd3c1e	Merge branch 'compile-modeld-defluff' into deep-rl	2026-06-07 12:58:59 +02:00
discountchubbs	74692d0b5f	summary	2026-06-07 03:56:09 -07:00
discountchubbs	dd35c27981	Update compile_modeld.py	2026-06-07 03:44:27 -07:00
discountchubbs	159140e64e	Update compile_modeld.py	2026-06-07 03:41:09 -07:00
James Vecellio-Grant	f1ab6c8dfb	Update compile_modeld.py	2026-06-07 12:21:49 +02:00
James Vecellio-Grant	e1fe30fd3e	Update compile_modeld.py	2026-06-07 12:19:36 +02:00
James Vecellio-Grant	fba521dcff	Update fetcher.py	2026-06-07 12:06:02 +02:00
discountchubbs	a8ef55bfaa	gpu stuffs	2026-06-07 02:14:25 -07:00
discountchubbs	a232f54e2d	CREAM AND SUGAR	2026-06-07 01:45:42 -07:00
discountchubbs	2697008aa7	redundant	2026-06-06 10:09:07 -07:00
discountchubbs	ad5abd242a	modeld_v2: refactor compile_modeld	2026-06-06 09:58:48 -07:00
discountchubbs	6c1e0f370b	god use full attribute names please	2026-06-06 09:25:50 -07:00
discountchubbs	1083f5bf21	dumb	2026-06-06 09:16:36 -07:00
discountchubbs	dc5116c718	numpy	2026-06-06 09:15:51 -07:00
discountchubbs	8611e08dc6	fix string	2026-06-06 09:03:36 -07:00
discountchubbs	dc0f73c63b	modeld_v2: safe model validation	2026-06-06 08:54:36 -07:00