IQ.Pilot Release Commit @ 8d3c939

artifacts/iqpilot_hephaestusd_private/manifest.json

@@ -1,8 +1,8 @@
 {
   "python/_iqclosure/_vendored.json": {
     "mode": 420,
-    "sha256": "7129a872d199127747c6b251d90633857f0e179a8079063d060eeafbdced03ab",
+    "sha256": "4971aeda24749e9b8554757d9655115369b1764789afc80d8b4639dba812cba6",
-    "size": 1773
+    "size": 1950
   },
   "python/_iqclosure/iqpilot/__init__.py": {
     "mode": 420,
@@ -154,6 +154,21 @@
     "sha256": "056c744bbd9f1fe1053555d9b1fc1257d53093d69ddc94be3f05d840eb70781c",
     "size": 3590
   },
+  "python/_iqclosure/iqpilot/selfdrive/iqmodeld/egpu_helpers.py": {
+    "mode": 420,
+    "sha256": "0b8f118dc45ad0c3809855800960b47c893ee121ea75d94e8569dcce46d58ce5",
+    "size": 7312
+  },
+  "python/_iqclosure/iqpilot/selfdrive/iqmodeld/egpu_model.py": {
+    "mode": 420,
+    "sha256": "eb3ebc7065a863d51d5bb4359d68f26fc2f1929e1d7e044377f15cf5bac7f77d",
+    "size": 367
+  },
+  "python/_iqclosure/iqpilot/selfdrive/iqmodeld/model_bundle_downloader.py": {
+    "mode": 420,
+    "sha256": "27aade5852507baf84ed460b9446d0de4df58a4a535b82c301113040b7ba472a",
+    "size": 7305
+  },
   "python/_iqclosure/iqpilot/selfdrive/iqmodeld/models/__init__.py": {
     "mode": 420,
     "sha256": "5865243a95ca4557d2a960302124a9898545cc3a8387e88ef569308e3d0f7077",
@@ -191,8 +206,8 @@
   },
   "python/_iqclosure/iqpilot/selfdrive/selfdrived/events.py": {
     "mode": 420,
-    "sha256": "5da7fc165b88cca63457f1aa4d62cef38b2585039e1b77184fbd5ff4b2fcc244",
+    "sha256": "5e37693eeced1e3ba81f03234b7b0dad33b7564826d232d288998be5fae7efd6",
-    "size": 36716
+    "size": 37038
   },
   "python/_iqclosure/iqpilot/selfdrive/ui/__init__.py": {
     "mode": 420,
@@ -274,6 +289,11 @@
     "sha256": "b57ba4262e6a6a79f2db15c27356acf3e54f579a7edd13b483b2e16d140aca6d",
     "size": 678
   },
+  "python/_iqclosure/iqpilot/system/hardware/usb.py": {
+    "mode": 420,
+    "sha256": "7c2cd7c6d5a859fb8454059da1b36e3b5ce4639aca6fea296b4f91096b46c1ba",
+    "size": 7257
+  },
   "python/_iqclosure/iqpilot/system/loggerd/__init__.py": {
     "mode": 420,
     "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
@@ -296,8 +316,8 @@
   },
   "python/_iqclosure/iqpilot/system/manager/process_config.py": {
     "mode": 420,
-    "sha256": "71594d16c0c104ede7bad3145d19d6af2d89d6c4aa4e9b5e6fdedd941ce35e41",
+    "sha256": "1676d1350461c917f2ac8412d68b85a4181e05075755823d34d530866f37ce62",
-    "size": 11679
+    "size": 13361
   },
   "python/_iqclosure/iqpilot/system/micd.py": {
     "mode": 420,
@@ -356,27 +376,27 @@
   },
   "python/iqpilot_private/konn3kt/backups/archive_codec.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "ac62a6876710b148e793f3bab5e6a52d22e83468992fa05dbaa7d29e846ac399",
+    "sha256": "569652717895a42a6efd58fded1fdf6aa9c26badad96cf6c9a0a103a7972488d",
     "size": 135552
   },
   "python/iqpilot_private/konn3kt/backups/backup_keys.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "02107df593150737b365238580006470af5f394c29a04516d07fcea6c0c7969f",
+    "sha256": "fc2abcec7142e56b3c8c83414a49eaaec3922e8d56d49c9494ec5fa2c467c018",
     "size": 67664
   },
   "python/iqpilot_private/konn3kt/backups/backup_orchestrator.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "8fd8fa511d44cf667faad7c5dd92bd68ba7f98457d1e65b57115c9cc920fb316",
+    "sha256": "2d6763b947b92912313645d3e98a1ed31a6bfaba7f6c73269fa594e12fa2b525",
     "size": 204640
   },
   "python/iqpilot_private/konn3kt/backups/cbc_vault.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "e9a8759405e96ace952c49004303d189fb2be1a777b56956d9a90fa32e325f19",
+    "sha256": "484c77fb10d314ac117f7a3914ed2f84c2b7afe2b466846f953aa41bf690d1e2",
     "size": 69768
   },
   "python/iqpilot_private/konn3kt/backups/imahelper.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "d495b424ec0066020e1694a22cfca59e4998d4b11de4823fd8aee4add91a2407",
+    "sha256": "85d79a68bd1fc98dc44131d765c55b3c06a7fc72b8901b3034c6ad54b56471dc",
     "size": 203088
   },
   "python/iqpilot_private/konn3kt/flockd/__init__.py": {
@@ -386,12 +406,12 @@
   },
   "python/iqpilot_private/konn3kt/flockd/flockd.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "466054f522dd6eb7e32f85bfd2d014cab5534662deb5b7b4d2842668f34bde6e",
+    "sha256": "3b70968cfe8bb9cc6faafaca46b9505a3a7c53062577f4e4d570bea7a6a84b21",
     "size": 202184
   },
   "python/iqpilot_private/konn3kt/flockd/signatures.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "9b96c82bf946c8e4166d41487902a23750dec210d684ae153d86e7922d64b7bf",
+    "sha256": "45e697fc70a02b9f2ba939c5c7136958bef704e907e05d0c835ca585eab878fb",
     "size": 68080
   },
   "python/iqpilot_private/konn3kt/hephaestus/__init__.py": {
@@ -401,67 +421,67 @@
   },
   "python/iqpilot_private/konn3kt/hephaestus/_vendor/localapi_runtime.zip": {
     "mode": 420,
-    "sha256": "7a9fe9bc8d6141e80e8e4c2befb5860ee287d820a62893729098114628d00357",
+    "sha256": "db892948057af888ff4587704b3f4ca70b714743a91c0f26d2ec85ccbff309b1",
-    "size": 2100238
+    "size": 1379342
   },
   "python/iqpilot_private/konn3kt/hephaestus/ble_auth.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "d7befce62715f669cbd763bac96e33eae8289ebe8085e2a842e7daa8bb42aeec",
+    "sha256": "7bbe4d5161fbb3cbe20f9ee9e52cb3c06b11254cbeaed1d3c64f8ac3bbf7ffc8",
     "size": 268080
   },
   "python/iqpilot_private/konn3kt/hephaestus/ble_gatt.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "134fa9773cd5b502b6c791bad720f8c1b22ef71571543d366feb27fd2ce11b21",
+    "sha256": "a6da1a1242c2817474d4d16ce156cf875f1ae18622c883af335fe8f344f8b083",
     "size": 406176
   },
   "python/iqpilot_private/konn3kt/hephaestus/ble_rpc_dispatch.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "3b34c918c56bd534d661470c44f0aa1149126f68f013d8d0b631e6fcbf6b7fb3",
+    "sha256": "27741c9bec5652feb9da487489aa7c2cca2821887bc2fb36c28f9a79c05c52a7",
     "size": 68048
   },
   "python/iqpilot_private/konn3kt/hephaestus/ble_transportd.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "c5e5b50579d97356e67db887588ffc2b5fa2225dc59a6c473bcfb0bd9c4fa482",
+    "sha256": "6df244ee0a6fd26e4e9071c1907410485c8e2b5023fbd67831affadd943d301d",
     "size": 335776
   },
   "python/iqpilot_private/konn3kt/hephaestus/bt_gamepad.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "3b6704277d4c5a8713bfc45673c548e30a3d2111dc2b39bbba05ad98a072b4f8",
+    "sha256": "0e9a3c8c59635fa516ab41c786f2f2cf162d3a9995cf00e7da46ca8c7b60c7b8",
     "size": 272112
   },
   "python/iqpilot_private/konn3kt/hephaestus/cloud_routes.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "914e0027aa9926ed8433e40ec9b31a09826ccf145f243f1c228174ef618d69ef",
+    "sha256": "140b254df8377104f3cb61e821e82d0a6885f63a61197dbad00a55c9c94641d6",
     "size": 134408
   },
   "python/iqpilot_private/konn3kt/hephaestus/hephaestusd.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "2ea4610ac0d27268d2764beb86d3f0e363325de591f02bb1139b6ce5ccefdc8e",
+    "sha256": "2324a4c85cd1b3489d7e87cb5c178c885b90fd0e1ad8a15e619dec05d264e4cf",
-    "size": 3847768
+    "size": 3915272
   },
   "python/iqpilot_private/konn3kt/hephaestus/kwp2000.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "172ff41c5d3728f6186fd705c56313bd8910bd271d76d38ebbe9f94f1110d88d",
+    "sha256": "53b21e9789a609d1498653441629f99fbfa8051fe7f9e1da6cf7c24dbb20f509",
     "size": 136472
   },
   "python/iqpilot_private/konn3kt/hephaestus/manage_hephaestusd.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "b3b96b633a4e5ced01b382cb423d2d44e5acd2ed08bc36b376c74ef0db5ef763",
+    "sha256": "cea0fed8dbb76eb47c466c34491c8feb3847598b0235103a8c3f7897d28caa15",
     "size": 68208
   },
   "python/iqpilot_private/konn3kt/hephaestus/motd.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "b49c0e72b91db359e9c97ef91362e2a708228361b90e028a4cf029495aae65a5",
+    "sha256": "a60bd145da3d8dba8f55710eb6b36c2583ee485245e2a0d5d6b2230659157231",
     "size": 67840
   },
   "python/iqpilot_private/konn3kt/hephaestus/tp20.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "0d9389cd00d0bcf85ece329b3e7ff0a106fea9772cf6663d995c059eabd680ae",
+    "sha256": "45d4c4cd8751b0d91efc90938c74148f29eec869a4523ef80dc7e0d471687e1a",
     "size": 135664
   },
   "python/iqpilot_private/konn3kt/hephaestus/vw_pq_flasher.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "650079ec882ae4aac58c2251c57617a47fe29f2848097a703dd4e4dd11cd4df1",
+    "sha256": "05445a115170b7ebe9355db42d2e44d4d6e323c4ddad10cd8d3c2ea975523793",
     "size": 269600
   },
   "python/iqpilot_private/konn3kt/uploaderd/__init__.py": {
@@ -471,7 +491,7 @@
   },
   "python/iqpilot_private/konn3kt/uploaderd/iquploaderd.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "fdd33b9c9bbe5b6c699461f627c1d5fb327cb2f1494a83f09e0ecfd1d6eb8ddb",
+    "sha256": "6fd0eb12cec35a9d0d8ac7b7e6005daccb5bb7fcc4cb53dd1bfd4bfbcde0a923",
     "size": 336280
   },
   "runtime": {
@@ -515,25 +535,25 @@
     }
   },
   "signatures": {
-    "python/iqpilot_private/konn3kt/backups/archive_codec.cpython-312-aarch64-linux-gnu.so": "OZaZmVdETSWhIHiKL/tiS8BJH9nIhZvOSdwokaWwz8A4DAXHDc6ZxPVvNthpt9tWeD3gdLVA1l3NoDxOL+vaAQ==",
+    "python/iqpilot_private/konn3kt/backups/archive_codec.cpython-312-aarch64-linux-gnu.so": "VxFp08PRJrvMSP23LRZa7qFujDFaUvn6tG4RlO7iJSDj8i+1wLZAcDiPGJTHZdY6YeExXgP6jSLtQy1BcbZ5Dg==",
-    "python/iqpilot_private/konn3kt/backups/backup_keys.cpython-312-aarch64-linux-gnu.so": "fOnIVo0lkVPJccWVr+i3LLVzhlIkAQ/jUM8JRV78Cyyzy7mLepnN38qQ/Y/zLIMNgYowM5Uh3lQtXhpi73HRCw==",
+    "python/iqpilot_private/konn3kt/backups/backup_keys.cpython-312-aarch64-linux-gnu.so": "331zmBEB54CVkMicucclvnYGOhUpzEPhIS6Tnl3lURFjcwjjuc+r4uwgjvLDvfwaBCWTpwel0NNGC03aIyaGAA==",
-    "python/iqpilot_private/konn3kt/backups/backup_orchestrator.cpython-312-aarch64-linux-gnu.so": "KBZ0V3Saibcb3sbD9LIMTYibszxoEV+pprWLZTf8FeWRrIh6s8aFLWSPALrv3AsdP9OQ4Uu6qH4gPY7+7BUADw==",
+    "python/iqpilot_private/konn3kt/backups/backup_orchestrator.cpython-312-aarch64-linux-gnu.so": "pHLBdX6X8gNM4sI3+NAFAUB5zB82F46GBpzzzWVwiy/pNDPa/60yJh0228Lo8/Z+79iOwr2rqpT+GtZIGaUHBw==",
-    "python/iqpilot_private/konn3kt/backups/cbc_vault.cpython-312-aarch64-linux-gnu.so": "gqMC+b4o9TzEZaIJLTZeQcjBZO0dePgGtEl754YpxiYTwJKNsu8wDgip960+dRs4TH30RNppSnsKTzByEHFfDQ==",
+    "python/iqpilot_private/konn3kt/backups/cbc_vault.cpython-312-aarch64-linux-gnu.so": "l3u8IUF/uaSXW4IimexnNX191B0nxLuu+PxdHQcjkSK+hOs0PJY8QVYE1oeY1CTy8mK0YTQP8sv6hp4RCVb7DA==",
-    "python/iqpilot_private/konn3kt/backups/imahelper.cpython-312-aarch64-linux-gnu.so": "zMoW2sGwo+O9QurXu/kI1rBuy88//+heDjhrtmloEk7m6BUGGCVaYo18RTyERN5lhpjGGArC4uo+qQ0XqWlODA==",
+    "python/iqpilot_private/konn3kt/backups/imahelper.cpython-312-aarch64-linux-gnu.so": "kt7IQeKSbCNwia1YG2fHdJAO5DH+D+wNrJVTxGeSi+/c3qxOY9NgdXdRA9RROQcN7Zks95sNEcVXhR6I5ck4CQ==",
-    "python/iqpilot_private/konn3kt/flockd/flockd.cpython-312-aarch64-linux-gnu.so": "j+x6R2Kc3lmR3Vbzsfue/kYuK5n1pNdEUQm8DpgZK66xDSsMTxBd/hK+ucfiutfFXchOitBvNegqBjXD+qa3AA==",
+    "python/iqpilot_private/konn3kt/flockd/flockd.cpython-312-aarch64-linux-gnu.so": "jeejVBJoO2+wtw/AYlbTGzPKvn+SLphtKhm9xuEkLTv8EmB5OkmM3AMqrH3G9czCRNBBSn2zjn4sxWimtH0fCQ==",
-    "python/iqpilot_private/konn3kt/flockd/signatures.cpython-312-aarch64-linux-gnu.so": "orpZvvoluLpjZ+92jmyrUbyqD7EOv2WlEBsEaMAFOCZiWxXrQxnHgUs/Van6gBmDMyT8zKTYuqsMovupBmQkDQ==",
+    "python/iqpilot_private/konn3kt/flockd/signatures.cpython-312-aarch64-linux-gnu.so": "85xhiHsSocrlo2tm2m4tI/9wSjMMEzXYjJctL/SNk/MdHE1vSl7e85RGPp1r2xMBsibKi5vvJBaB66dDJikYAA==",
-    "python/iqpilot_private/konn3kt/hephaestus/ble_auth.cpython-312-aarch64-linux-gnu.so": "tbeuIL+jaDy4IJya/gJHNWGvU8xA2JcCyLRmQdopF68DCVwhzBnpF+9l2cPTPQ4+c+j/itwGwkwlkfMYDrVWDw==",
+    "python/iqpilot_private/konn3kt/hephaestus/ble_auth.cpython-312-aarch64-linux-gnu.so": "Arh8D4rzhmm8tIgJhOxDoOSGxZtrkkGFgWSkUPyFRxGv14cMoEoQzMEdU9UErkW4jO2U8vj93nieELi7SMNZDQ==",
-    "python/iqpilot_private/konn3kt/hephaestus/ble_gatt.cpython-312-aarch64-linux-gnu.so": "HdkKaV0vEn/qnNPiMoKQ9BmUJOn/fFs8WKBYtT2VtAxP/UNOnHzVidOCEthgFBmcDGia2iJpAUzJJtaVW2plBg==",
+    "python/iqpilot_private/konn3kt/hephaestus/ble_gatt.cpython-312-aarch64-linux-gnu.so": "5JDxFY5itf0gGWDYKQbgpkBqE2Esf33v2i2cPDzQtDF/jpA+2C3Lev1rzmM2pN9y/fpCsW4urOmKB5IPRDh0Cg==",
-    "python/iqpilot_private/konn3kt/hephaestus/ble_rpc_dispatch.cpython-312-aarch64-linux-gnu.so": "khgAZ6q6XZA4DyrNn+GeWl/pbVExjxfiiYgVDVb91TcfExQ0NKOHVFDjEOw+4sWDzjwJgqVOrq6ctFtZ4P+HCw==",
+    "python/iqpilot_private/konn3kt/hephaestus/ble_rpc_dispatch.cpython-312-aarch64-linux-gnu.so": "T5D7W6WtK6K42GT/VkkD3/1AWp9xV9Ya5rgE6V+GX4+4sV5PgaFmEf68BlDr/Iwf7PKTEHKKM7eQ3gswOYNEAg==",
-    "python/iqpilot_private/konn3kt/hephaestus/ble_transportd.cpython-312-aarch64-linux-gnu.so": "6ncETsGmDllGix8F7eEECALhCYjhzzBVz1ZtNIDs1l3Ydy2XJ8L8FigNJ/bed9SBb20gtGwYXMXRmiu/hZZfDA==",
+    "python/iqpilot_private/konn3kt/hephaestus/ble_transportd.cpython-312-aarch64-linux-gnu.so": "w/1Xq9W4NVDyS24frgWfl58AbVPWEuq8k5CrC3uwyg0mLGAnr+UXqFzo9/E9xh9XJKbQdCfMdmo0OsSENpNgDA==",
-    "python/iqpilot_private/konn3kt/hephaestus/bt_gamepad.cpython-312-aarch64-linux-gnu.so": "3CNA1ZxBEwKX1/XftG3bGEYjN/+j6Hts1JKM0gfgd9qW1J90XCF1U4sYUvutBXyITBAFoGwPG813d/juwCGkBg==",
+    "python/iqpilot_private/konn3kt/hephaestus/bt_gamepad.cpython-312-aarch64-linux-gnu.so": "ifpWpiuKSApIA3Q2q3p+Odw6d127qQfI64cJmr49ReS5ujyzKZqJMGo1vkgm1MsPf/CaBB5PLDA49dJxau1hCw==",
-    "python/iqpilot_private/konn3kt/hephaestus/cloud_routes.cpython-312-aarch64-linux-gnu.so": "2VuGKUTtPfuwSxnLs5/EQ4QteD+6wgxDpzUiIkrxIbdeQ5RNeTWdq1oju6bPctUXZ97SJgm2q26rZhchF13PDg==",
+    "python/iqpilot_private/konn3kt/hephaestus/cloud_routes.cpython-312-aarch64-linux-gnu.so": "HPAYWBMZJ8+mfyYR3lzg9jnkH+K5JEY/aYRCMTNlHPO7Wy1e2SLd8e5sqhc0AdOnVembXt06pdRNXrr5myMcDA==",
-    "python/iqpilot_private/konn3kt/hephaestus/hephaestusd.cpython-312-aarch64-linux-gnu.so": "7QUTUZNrIxuFyMR5Ksp8LZvUsziXqLrXN2XAcTeY5jOSl0eu0wwk0Vn0KUA4/C+zBJWF7Azok3m2oIPV+vQiBQ==",
+    "python/iqpilot_private/konn3kt/hephaestus/hephaestusd.cpython-312-aarch64-linux-gnu.so": "6v9Zrjtw0bA5PLqZxZz03N1gwVoGHDzPLvolDWYnUziPwQ3ANhsjJ7puzun4r8s/Y2dyeZe5tjB3ht2YZBsOAQ==",
-    "python/iqpilot_private/konn3kt/hephaestus/kwp2000.cpython-312-aarch64-linux-gnu.so": "4/CrUNcQQM+QRtZeRoUWHh0dlq2tFVYESqXn9ByRNG5jcwvCaTMhA3qbHnK7LnNcLqZf6nKPlKJG8gNZrnW3CA==",
+    "python/iqpilot_private/konn3kt/hephaestus/kwp2000.cpython-312-aarch64-linux-gnu.so": "8LUrOg0CgdEaX04HvEAZrSWdovj/M/uhr54bN3XSWbE4qDeKnlsxDD430hHH/Bz17u+eSXzFPBrk33s7SXuyDg==",
-    "python/iqpilot_private/konn3kt/hephaestus/manage_hephaestusd.cpython-312-aarch64-linux-gnu.so": "6j0Fl7SPymEo9Bhj8Rg2+56pkjZVY7yFPFjz1Mv5PnkZZUzCvmqbqArrxfKY8tmt17Zfn+Uq0XUx/A4ns868Aw==",
+    "python/iqpilot_private/konn3kt/hephaestus/manage_hephaestusd.cpython-312-aarch64-linux-gnu.so": "TxU/vX6RG/aYvZnJc7plxaHcBiE7zzEmZGlcrRlojwIdUVR9MXwngKLkEBCDdgcXK99xS7JyeXuOxv7bJGwjCg==",
-    "python/iqpilot_private/konn3kt/hephaestus/motd.cpython-312-aarch64-linux-gnu.so": "8/td493hepBmhe7AGfTiZ0DyGy7G1R2aQM8S5kOH8/7lxP1yOzPJNp0Q4IUdiO7PAv4K/Qs3mZXRqIb9m6muAQ==",
+    "python/iqpilot_private/konn3kt/hephaestus/motd.cpython-312-aarch64-linux-gnu.so": "VVwuzRtbygLWD0MFhPsRZLNm10Bep4Kde+PQbpHNmpdxXBNYN09cHnxGval7UBmpsgnOIcORBSNK0M2RkfZiBw==",
-    "python/iqpilot_private/konn3kt/hephaestus/tp20.cpython-312-aarch64-linux-gnu.so": "YL4VfWwVM4LA30Ug/D5da0dpL2CrtS9k1iZGcHzxn0UZXg7gvn/CwofgPrAgqxKOuvwy8OAN4dseKCgvVl7tBw==",
+    "python/iqpilot_private/konn3kt/hephaestus/tp20.cpython-312-aarch64-linux-gnu.so": "OVFsjEKAZNu/dx0Y6aTklTNL+kB+VgwdRFQEaBPkU4Aa3+w192FNSl7QgZYjGymBYk8t4TVkoEJAeIaQAOLBCQ==",
-    "python/iqpilot_private/konn3kt/hephaestus/vw_pq_flasher.cpython-312-aarch64-linux-gnu.so": "9ae5f6k/QFWnu/NcLHR4Jdp9teHEreFVqMstcgCS2krd2WDrA4RyenCMpAW5DssCVgK/SSYZ5R/mt784LtX5Dg==",
+    "python/iqpilot_private/konn3kt/hephaestus/vw_pq_flasher.cpython-312-aarch64-linux-gnu.so": "qQkWfrSS3J2CrMpWJ3YDvlg+QZJSLiFp+K6UJvEDOCpd2b9Vdu1jWrUzSVJ+jngsKnzyiwA28j15r5YW290pDA==",
-    "python/iqpilot_private/konn3kt/uploaderd/iquploaderd.cpython-312-aarch64-linux-gnu.so": "FEavK888fANFifz5HwjkSnzyUicwrDoVMor1xg7dIDlflvBGeE+q+N45+EJNYuT+Gtu7z5NeBh3QWx8S9KHTDw=="
+    "python/iqpilot_private/konn3kt/uploaderd/iquploaderd.cpython-312-aarch64-linux-gnu.so": "2OPtA7wcd78pbfj532oQKn07r4w+gVXXYq5SzH9Ely3etJJgtAMNGWF6kEY/St5UKHrXz0Ijkb243eyzNNVsBQ=="
   }
 }

artifacts/iqpilot_hephaestusd_private/manifest.json.sig

@@ -1 +1 @@
-7unLWRQJMpEA37ml8a0VSDmIhihtSdBcl8LG9zT7eXqtHofgwK7hTGUGVWvGro/g7STaxm2yDGLe9maVHRpcAg==
+1iB1q4SvZisVqE7ivgPA8wvxTvn7nSsXY5ZvPonciaVEx2/aLqhaXV9wA9sj3a+y1dp9J2Cg4AbrQqgyw+gvAg==

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/_vendored.json

@@ -22,6 +22,9 @@
   "iqpilot.konn3kt.service_health",
   "iqpilot.selfdrive.car.vehicle_catalog",
   "iqpilot.selfdrive.iqmodeld.config",
+  "iqpilot.selfdrive.iqmodeld.egpu_helpers",
+  "iqpilot.selfdrive.iqmodeld.egpu_model",
+  "iqpilot.selfdrive.iqmodeld.model_bundle_downloader",
   "iqpilot.selfdrive.iqmodeld.models",
   "iqpilot.selfdrive.iqmodeld.models.fetcher",
   "iqpilot.selfdrive.iqmodeld.models.helpers",
@@ -40,6 +43,7 @@
   "iqpilot.system.hardware.tici.iwlist",
   "iqpilot.system.hardware.tici.lpa",
   "iqpilot.system.hardware.tici.pins",
+  "iqpilot.system.hardware.usb",
   "iqpilot.system.loggerd.xattr_cache",
   "iqpilot.system.manager.process",
   "iqpilot.system.manager.process_config",

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/iqmodeld/egpu_helpers.py

@@ -0,0 +1,209 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos/
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+
+from iqpilot.common.swaglog import cloudlog
+import urllib.request
+from pathlib import Path
+
+from iqpilot.system.hardware.usb import egpu_dock_ready
+
+USB_SYSFS_ROOT = "/sys/bus/usb/devices"
+FIRMWARE_MIRROR = os.getenv("IQ_EGPU_FIRMWARE_MIRROR", "/data/firmware/tinygrad")
+TINYGRAD_CACHE = "/data/.cache"
+
+COMMA_LFS_BATCH_URL = "https://gitlab.com/commaai/openpilot-lfs.git/info/lfs/objects/batch"
+
+DOWNLOAD_CHUNK = 4 * 1024 * 1024
+
+
+def usbgpu_present(sysfs_root: str = USB_SYSFS_ROOT) -> bool:
+  return egpu_dock_ready(Path(sysfs_root))
+
+
+def egpu_present_consented(params, sysfs_root: str = USB_SYSFS_ROOT) -> bool:
+  try:
+    if params is not None and params.get_bool("IQEgpuDisabled"):
+      return False
+  except Exception:
+    pass
+  return usbgpu_present(sysfs_root)
+
+
+def egpu_selected(params, sysfs_root: str = USB_SYSFS_ROOT) -> bool:
+  try:
+    if params is not None and params.get_bool("IQEgpuDisabled"):
+      return False
+    if params is not None and params.get_bool("IQEgpuEnabled"):
+      return True
+  except Exception:
+    pass
+  return usbgpu_present(sysfs_root)
+
+
+def resolve_backend(emac_enabled: bool, egpu_enabled: bool, egpu_present: bool = False) -> str | None:
+  if egpu_present:
+    return "egpu"
+  if emac_enabled:
+    return "emac"
+  if egpu_enabled:
+    return "egpu"
+  return None
+
+
+def egpu_pkl_path(meta: dict) -> str:
+  from iqpilot.system.hardware.hw import Paths
+  return os.path.join(Paths.model_root(), f"egpu_{meta['key']}_{meta['sha256'][:8]}_amd_tinygrad.pkl")
+
+
+def egpu_policy_pkl_path(meta: dict) -> str:
+  from iqpilot.system.hardware.hw import Paths
+  return os.path.join(Paths.model_root(), f"egpu_{meta['key']}_{meta['sha256'][:8]}_amd_policy.pkl")
+
+
+def egpu_oob_pkl_path(meta: dict) -> str:
+  from iqpilot.system.hardware.hw import Paths
+  return os.path.join(Paths.model_root(), f"egpu_{meta['key']}_{meta['sha256'][:8]}_amd_policy_oob.pkl")
+
+
+def onnx_cache_path(meta: dict) -> str:
+  from iqpilot.system.hardware.hw import Paths
+  return os.path.join(Paths.model_root(), f"{meta['model_name']}_{meta['sha256'][:8]}.onnx")
+
+
+def _sha256_file(path: str) -> str:
+  digest = hashlib.sha256()
+  with open(path, "rb") as f:
+    while chunk := f.read(DOWNLOAD_CHUNK):
+      digest.update(chunk)
+  return digest.hexdigest()
+
+
+def quarantine_artifact(path: str, why: str) -> None:
+  try:
+    if os.path.isfile(path):
+      os.replace(path, path + ".unusable")
+  except OSError:
+    try:
+      os.remove(path)
+    except OSError:
+      pass
+
+
+def local_onnx(meta: dict) -> str | None:
+  path = onnx_cache_path(meta)
+  if not os.path.isfile(path):
+    return None
+  size = int(meta.get("download", {}).get("size", 0))
+  if size and os.path.getsize(path) != size:
+    quarantine_artifact(path, "onnx size mismatch")
+    return None
+  if _sha256_file(path) != meta["sha256"]:
+    quarantine_artifact(path, "onnx sha256 mismatch")
+    return None
+  return path
+
+
+def resolve_download_url(download_url: str, sha256: str, size: int, timeout: float = 30.0) -> str:
+  if download_url.startswith("commalfs:"):
+    oid = download_url.split(":", 1)[1]
+    body = json.dumps({"operation": "download", "transfers": ["basic"],
+                       "objects": [{"oid": oid, "size": size}]}).encode()
+    req = urllib.request.Request(COMMA_LFS_BATCH_URL, data=body, headers={
+      "Accept": "application/vnd.git-lfs+json", "Content-Type": "application/vnd.git-lfs+json"})
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+      d = json.load(r)
+    return d["objects"][0]["actions"]["download"]["href"]
+  return download_url
+
+
+def download_onnx(meta: dict, progress_cb=None) -> str:
+  from iqpilot.selfdrive.iqmodeld.egpu_model import download_descriptor
+  download_url, size = download_descriptor(meta)
+  if not download_url:
+    raise RuntimeError(f"model {meta['key']} has no download source; stage the onnx at {onnx_cache_path(meta)}")
+
+  path = onnx_cache_path(meta)
+  os.makedirs(os.path.dirname(path), exist_ok=True)
+  try:
+    from iqpilot.selfdrive.iqmodeld.model_bundle_downloader import download_hf_file
+    return download_hf_file(f"onnx/{meta['sha256']}.onnx", path, meta["sha256"], int(size or 0), progress_cb=progress_cb)
+  except Exception as e:
+    cloudlog.warning(f"onnx {meta['key']} unavailable from HF ({e}); falling back to {download_url.split(':', 1)[0]}")
+  url = resolve_download_url(download_url, meta["sha256"], size)
+  tmp = path + ".part"
+  digest = hashlib.sha256()
+  got = 0
+  with urllib.request.urlopen(url, timeout=60) as r, open(tmp, "wb") as f:
+    while chunk := r.read(DOWNLOAD_CHUNK):
+      f.write(chunk)
+      digest.update(chunk)
+      got += len(chunk)
+      if progress_cb is not None and size:
+        progress_cb(got / size)
+  if size and got != size:
+    os.remove(tmp)
+    raise RuntimeError(f"onnx download truncated: {got}/{size} bytes")
+  if digest.hexdigest() != meta["sha256"]:
+    os.remove(tmp)
+    raise RuntimeError(f"onnx sha256 mismatch for {meta['key']}")
+  os.replace(tmp, path)
+  return path
+
+
+def download_precompiled(meta: dict, progress_cb=None, policy: bool = False, oob: bool = False) -> str | None:
+  field = "egpu_oob_artifact" if oob else "egpu_policy_artifact" if policy else "egpu_artifact"
+  art = meta.get(field)
+  if not art or not (art.get("objects") or art.get("hf_path")):
+    return None
+  from iqpilot.selfdrive.iqmodeld.model_bundle_downloader import download_hf_file, download_lfs_bundle
+  dest = egpu_oob_pkl_path(meta) if oob else egpu_policy_pkl_path(meta) if policy else egpu_pkl_path(meta)
+  if art.get("hf_path"):
+    try:
+      return download_hf_file(art["hf_path"], dest, art["sha256"], int(art.get("size", 0)), progress_cb=progress_cb)
+    except Exception as e:
+      cloudlog.warning(f"precompiled {meta['key']} unavailable from HF ({e}); trying LFS")
+      if not art.get("objects"):
+        raise
+  return download_lfs_bundle(art["objects"], dest, art["sha256"], int(art.get("size", 0)), progress_cb=progress_cb)
+
+
+def patch_tinygrad_fetch_fw() -> None:
+  import pathlib
+
+  import zstandard
+  from tinygrad import helpers
+  if getattr(helpers.fetch_fw, "_iq_patched", False):
+    return
+  _orig = helpers.fetch_fw
+
+  def fetch_fw(path, name, sha256):
+    mirror = pathlib.Path(FIRMWARE_MIRROR) / path / name
+    if mirror.is_file():
+      blob = mirror.read_bytes()
+      if hashlib.sha256(blob).hexdigest() == sha256:
+        return blob
+    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
+    blob = _orig(path, name, sha256)
+    # The dock's GPU firmware otherwise lives only in tinygrad's per-user download cache, which is
+    # a network fetch the first time a new HOME sees it; onroad the car is usually offline.
+    try:
+      mirror.parent.mkdir(parents=True, exist_ok=True)
+      tmp = mirror.with_suffix(mirror.suffix + ".part")
+      tmp.write_bytes(blob)
+      os.replace(tmp, mirror)
+    except OSError:
+      pass
+    return blob
+
+  fetch_fw._iq_patched = True
+  helpers.fetch_fw = fetch_fw

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/iqmodeld/egpu_model.py

@@ -0,0 +1,9 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos/
+"""
+from iqpilot._proprietary_loader import ProprietaryModuleMissing, load_private_module
+
+try:
+  load_private_module(__name__, "iqpilot_private.models.egpu_model")
+except ProprietaryModuleMissing:
+  from iqpilot.models_private_src.egpu_model import *

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/iqmodeld/model_bundle_downloader.py

@@ -0,0 +1,211 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos/
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+
+MODELS_BASE_URLS = (
+  "https://git.konn3kt.com/teal/IQModels/raw/branch/main",
+  "https://gitlvb.teallvbs.xyz/teal/IQModels/raw/branch/main",
+)
+CHUNK = 4 * 1024 * 1024
+HTTP_TIMEOUT_S = 60.0
+STREAM_RETRIES = 6
+
+
+def _requests_auth():
+  import importlib
+  for mod in ("iqpilot_private.models.git_auth", "iqpilot.models_private_src.git_auth",
+              "iqpilot.selfdrive.iqmodeld.models.git_auth"):
+    try:
+      return importlib.import_module(mod).get_requests_auth()
+    except Exception:
+      continue
+  return None
+
+
+def _hf():
+  import importlib
+  for mod in ("iqpilot_private.models.git_auth", "iqpilot.selfdrive.iqmodeld.models.git_auth"):
+    try:
+      m = importlib.import_module(mod)
+      return m.get_hf_headers(), m.hf_resolve_url
+    except Exception:
+      continue
+  return None, None
+
+
+def download_hf_file(hf_path: str, dst: str, sha256: str, size: int, progress_cb=None) -> str:
+  import requests
+  headers, resolve = _hf()
+  if resolve is None:
+    raise RuntimeError("no HF credentials available")
+  url = resolve(hf_path)
+  os.makedirs(os.path.dirname(dst), exist_ok=True)
+  tmp = dst + ".hfpart"
+  last_error: Exception | None = None
+  for _attempt in range(STREAM_RETRIES):
+    try:
+      have = os.path.getsize(tmp) if os.path.isfile(tmp) else 0
+      if size and have > size:
+        os.remove(tmp)
+        have = 0
+      if not size or have < size:
+        req_headers = dict(headers)
+        if have:
+          req_headers["Range"] = f"bytes={have}-"
+        with requests.get(url, headers=req_headers, stream=True, timeout=HTTP_TIMEOUT_S, allow_redirects=True) as r:
+          r.raise_for_status()
+          if have and r.status_code != 206:
+            have = 0
+          with open(tmp, "ab" if have else "wb") as f:
+            got = have
+            for chunk in r.iter_content(CHUNK):
+              f.write(chunk)
+              got += len(chunk)
+              if progress_cb is not None and size:
+                progress_cb(min(1.0, got / size))
+      digest = hashlib.sha256()
+      with open(tmp, "rb") as f:
+        for chunk in iter(lambda: f.read(CHUNK), b""):
+          digest.update(chunk)
+      if size and os.path.getsize(tmp) != size:
+        raise RuntimeError(f"size mismatch: {os.path.getsize(tmp)}/{size} bytes")
+      if sha256 and digest.hexdigest() != sha256:
+        os.remove(tmp)
+        raise RuntimeError("sha256 mismatch")
+      os.replace(tmp, dst)
+      return dst
+    except Exception as e:
+      last_error = e
+  raise RuntimeError(f"HF download failed: {last_error}")
+
+
+def _lfs_endpoint(base_url: str) -> str:
+  return base_url.split("/raw/", 1)[0] + ".git/info/lfs"
+
+
+def _resolve_oid(session, base_url: str, oid: str, size: int, auth):
+  import requests
+  batch = session.post(f"{_lfs_endpoint(base_url)}/objects/batch",
+                       data=json.dumps({"operation": "download", "transfers": ["basic"],
+                                        "objects": [{"oid": oid, "size": size}]}),
+                       headers={"Content-Type": "application/vnd.git-lfs+json",
+                                "Accept": "application/vnd.git-lfs+json"},
+                       auth=auth, timeout=HTTP_TIMEOUT_S)
+  batch.raise_for_status()
+  entry = batch.json()["objects"][0]
+  if "actions" not in entry:
+    raise requests.RequestException(f"LFS object unavailable: {entry.get('error', oid)}")
+  action = entry["actions"]["download"]
+  return action["href"], action.get("header", {})
+
+
+def _part_path(dst: str, oid: str) -> str:
+  return os.path.join(dst + ".parts", oid)
+
+
+def _part_complete(path: str, oid: str, size: int) -> bool:
+  if not os.path.isfile(path) or os.path.getsize(path) != size:
+    return False
+  digest = hashlib.sha256()
+  with open(path, "rb") as f:
+    for chunk in iter(lambda: f.read(CHUNK), b""):
+      digest.update(chunk)
+  return digest.hexdigest() == oid
+
+
+def _fetch_part(session, base_url: str, obj: dict, path: str, auth, progress) -> None:
+  size = int(obj["size"])
+  have = os.path.getsize(path) if os.path.isfile(path) else 0
+  if have > size:
+    os.remove(path)
+    have = 0
+  href, headers = _resolve_oid(session, base_url, obj["oid"], size, auth)
+  obj_auth = None if headers.get("Authorization") else auth
+  # LFS parts are content-addressed (oid == sha256), so a half-written part can be resumed with a
+  # Range request and verified afterwards instead of being thrown away on every restart.
+  if have:
+    headers = {**headers, "Range": f"bytes={have}-"}
+  with session.get(href, headers=headers, stream=True, timeout=HTTP_TIMEOUT_S, auth=obj_auth) as r:
+    r.raise_for_status()
+    if have and r.status_code != 206:
+      have = 0
+    with open(path, "ab" if have else "wb") as f:
+      for chunk in r.iter_content(CHUNK):
+        f.write(chunk)
+        progress(len(chunk))
+
+
+def download_lfs_bundle(objects: list, dst: str, sha256: str, size: int, progress_cb=None) -> str:
+  import requests
+  auth = _requests_auth()
+  session = requests.Session()
+  os.makedirs(dst + ".parts", exist_ok=True)
+  total = int(size) or sum(int(o["size"]) for o in objects)
+  done_bytes = sum(int(o["size"]) for o in objects if _part_complete(_part_path(dst, o["oid"]), o["oid"], int(o["size"])))
+  got = [done_bytes]
+
+  def progress(n: int) -> None:
+    got[0] += n
+    if progress_cb is not None and total:
+      progress_cb(min(1.0, got[0] / total))
+
+  last_error: Exception | None = None
+  for base_url in MODELS_BASE_URLS:
+    for _attempt in range(STREAM_RETRIES):
+      try:
+        for obj in objects:
+          path = _part_path(dst, obj["oid"])
+          if _part_complete(path, obj["oid"], int(obj["size"])):
+            continue
+          got[0] = done_bytes
+          _fetch_part(session, base_url, obj, path, auth, progress)
+          if not _part_complete(path, obj["oid"], int(obj["size"])):
+            if os.path.getsize(path) >= int(obj["size"]):
+              os.remove(path)
+            raise RuntimeError(f"part {obj['oid'][:12]} incomplete or failed verification")
+          done_bytes += int(obj["size"])
+          got[0] = done_bytes
+        break
+      except Exception as e:
+        last_error = e
+    else:
+      continue
+    break
+  else:
+    raise RuntimeError(f"model bundle download failed: {last_error}")
+
+  tmp = dst + ".part"
+  digest = hashlib.sha256()
+  with open(tmp, "wb") as out:
+    for obj in objects:
+      with open(_part_path(dst, obj["oid"]), "rb") as f:
+        for chunk in iter(lambda: f.read(CHUNK), b""):
+          out.write(chunk)
+          digest.update(chunk)
+  if total and os.path.getsize(tmp) != total:
+    os.remove(tmp)
+    raise RuntimeError(f"size mismatch: {os.path.getsize(tmp) if os.path.exists(tmp) else 0}/{total} bytes")
+  if sha256 and digest.hexdigest() != sha256:
+    os.remove(tmp)
+    for obj in objects:
+      try:
+        os.remove(_part_path(dst, obj["oid"]))
+      except OSError:
+        pass
+    raise RuntimeError("sha256 mismatch")
+  os.replace(tmp, dst)
+  for obj in objects:
+    try:
+      os.remove(_part_path(dst, obj["oid"]))
+    except OSError:
+      pass
+  try:
+    os.rmdir(dst + ".parts")
+  except OSError:
+    pass
+  return dst

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/selfdrived/events.py

@@ -253,6 +253,15 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = {
                                        "Ensure road ahead is clear"),
   },
 
+  EventName.bigModelLoading: {
+    ET.NO_ENTRY: NoEntryAlert("Big Model Loading"),
+  },
+
+  EventName.bigModelFailed: {
+    ET.SOFT_DISABLE: soft_disable_alert("Big Model Failed"),
+    ET.PERMANENT: NormalPermanentAlert("Big Model Failed ", "Restart the car to retry,\nsmall model is still available", duration=20.),
+  },
+
   EventName.lateralManeuver: {
     ET.WARNING: longitudinal_maneuver_alert,
     ET.PERMANENT: NormalPermanentAlert("Lateral Maneuver Mode"),
@@ -366,7 +375,7 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = {
       "Pay Attention",
       "",
       AlertStatus.normal, AlertSize.small,
-      Priority.LOW, VisualAlert.none, AudibleAlert.none, .1),
+      Priority.MID, VisualAlert.none, AudibleAlert.none, .1),
   },
 
   EventName.promptDriverDistracted: {
@@ -892,7 +901,7 @@ if HARDWARE.get_device_type() == 'mici':
         "Pay Attention",
         "",
         AlertStatus.normal, AlertSize.small,
-        Priority.LOW, VisualAlert.none, AudibleAlert.none, 2),
+        Priority.MID, VisualAlert.none, AudibleAlert.none, 2),
     },
     EventName.promptDriverDistracted: {
       ET.PERMANENT: Alert(

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/hardware/usb.py

@@ -0,0 +1,184 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos/
+
+USB bus snapshot for deviceState: every enumerated device with its negotiated
+speed and its controller's link-error count. Landing this in every rlog makes
+cable/hub/link regressions diagnosable from a recorded route instead of only
+live.
+
+Link errors come from `portli` on the ssusb controller (IQ.OS 4.9.1+); on older
+builds the file is absent and the counts read 0.
+
+The USB eGPU dock is identified by VID/PID only. comma's internal codename for
+it is deliberately not used here: IQ.Pilot runs these models on several
+backends (eGPU dock, eMac), so the naming stays about the role, not the vendor.
+"""
+from pathlib import Path
+
+# comma's USB eGPU dock, both shipped USB IDs. The ROM ids are the same board
+# sitting in its bootloader (ASMedia) before vendor firmware is flashed — it
+# enumerates but cannot serve a GPU in that state.
+EGPU_DOCK_USB_IDS = ((0xADD1, 0x0001), (0x3801, 0x0001))
+EGPU_DOCK_ROM_USB_IDS = ((0x174C, 0x2464), (0x174C, 0x2463))
+# must equal image_product() of the bundled firmware; test_egpu_dock_flash pins them together
+EGPU_DOCK_FW_PRODUCT = "custom ed4e39b7-CLEAN"
+
+
+def is_egpu_usb_device(vendor_id: int, product_id: int, include_bootloader: bool = False) -> bool:
+  ids = EGPU_DOCK_USB_IDS + EGPU_DOCK_ROM_USB_IDS if include_bootloader else EGPU_DOCK_USB_IDS
+  return (vendor_id, product_id) in ids
+USB_DEVICES_PATH = Path("/sys/bus/usb/devices")
+UDC_PATH = Path("/sys/class/udc")
+TYPEC_CC_ORIENTATION_PATH = Path("/sys/class/power_supply/usb/typec_cc_orientation")
+USB3_LANES = {1: "a", 2: "b"}  # 0 = unattached
+SOC_PLATFORM_PATH = Path("/sys/devices/platform/soc")
+CONTROLLER_SUFFIX = ".ssusb"
+LINK_ERRORS_FILE = "portli"
+
+
+def read(path: Path) -> str | None:
+  # a controller in peripheral mode fails portli's show(); that surfaces as TypeError, not OSError
+  try:
+    return path.read_text().strip()
+  except Exception:
+    return None
+
+
+def read_int(path: Path, base: int = 10) -> int:
+  try:
+    return int(path.read_text(), base)
+  except Exception:
+    return 0
+
+
+def read_hex_counter(path: Path) -> int:
+  """sysfs counter printed as '0x0000002a' (portli), tolerating a bare hex value."""
+  raw = read(path)
+  if raw is None:
+    return 0
+  try:
+    return int(raw, 0) if raw.lower().startswith("0x") else int(raw, 16)
+  except ValueError:
+    return 0
+
+
+def get_usb_topology(root: Path = USB_DEVICES_PATH) -> set[str]:
+  """Names of everything on the bus; a cheap way to detect hotplug without
+  re-reading every attribute."""
+  try:
+    return {p.name for p in root.iterdir()}
+  except Exception:
+    return set()
+
+
+def usb_devices(root: Path = USB_DEVICES_PATH) -> list[Path]:
+  try:
+    return sorted((d for d in root.glob("*") if (d / "idVendor").exists()), key=lambda p: p.name)
+  except Exception:
+    return []
+
+
+def controller(device: Path) -> Path | None:
+  """The SuperSpeed controller a device hangs off (…/a800000.ssusb)."""
+  try:
+    return next((p for p in device.resolve().parents if p.name.endswith(CONTROLLER_SUFFIX)), None)
+  except Exception:
+    return None
+
+
+def usb_controllers(soc: Path = SOC_PLATFORM_PATH) -> list[Path]:
+  try:
+    return sorted(soc.glob(f"*{CONTROLLER_SUFFIX}"))
+  except Exception:
+    return []
+
+
+def link_controller(udc_root: Path = UDC_PATH) -> str:
+  """Name of the Type-C port's controller, derived from the UDC rather than
+  hardcoded: the gadget exposes `<addr>.dwc3`, whose address prefix is the
+  `<addr>.ssusb` controller behind the same connector. comma pins the 3X value
+  directly, which would be wrong on any other board."""
+  try:
+    udc = next(iter(sorted(p.name for p in udc_root.iterdir())), "")
+  except Exception:
+    return ""
+  return f"{udc.split('.')[0]}{CONTROLLER_SUFFIX}" if udc else ""
+
+
+def usb3_lane(orientation: int | None = None) -> str:
+  """Which SuperSpeed lane the Type-C connector landed on. Unattached reads 0,
+  which is 'unknown' rather than a lane."""
+  if orientation is None:
+    orientation = read_int(TYPEC_CC_ORIENTATION_PATH)
+  return USB3_LANES.get(orientation, "unknown")
+
+
+def link_errors(ctrl: Path | None) -> int:
+  return read_hex_counter(ctrl / LINK_ERRORS_FILE) if ctrl is not None else 0
+
+
+def get_link_error_count(soc: Path = SOC_PLATFORM_PATH) -> int:
+  """Cumulative SS port link errors, read off the controller rather than a
+  device: in peripheral mode (eMac gadget link) the peer never enumerates on
+  our side, so there is no device row to carry the count."""
+  return sum(link_errors(c) for c in usb_controllers(soc))
+
+
+def egpu_dock_present(root: Path = USB_DEVICES_PATH) -> bool:
+  """A dock in ROM/bootloader state is deliberately NOT counted as present: it
+  enumerates but cannot serve a GPU until vendor firmware is flashed."""
+  return any((read_int(d / "idVendor", 16), read_int(d / "idProduct", 16)) in EGPU_DOCK_USB_IDS
+             for d in usb_devices(root))
+
+
+def egpu_dock_ready(root: Path = USB_DEVICES_PATH) -> bool:
+  """Present AND running the exact firmware we ship. A dock on any other
+  firmware enumerates fine but has not been validated with this stack, so the
+  runtime refuses it; the flasher still sees it via egpu_dock_present."""
+  return any((read_int(d / "idVendor", 16), read_int(d / "idProduct", 16)) in EGPU_DOCK_USB_IDS
+             and (read(d / "product") or "").strip() == EGPU_DOCK_FW_PRODUCT
+             for d in usb_devices(root))
+
+
+def get_usb_state(root: Path = USB_DEVICES_PATH, udc_root: Path = UDC_PATH) -> list[dict]:
+  devices = []
+  lane, link_ctrl = usb3_lane(), link_controller(udc_root)
+  for device in usb_devices(root):
+    ctrl = controller(device)
+    devices.append({
+      "usb3Lane": lane if ctrl is not None and ctrl.name == link_ctrl else "unknown",
+      "busnum": read_int(device / "busnum"),
+      "devnum": read_int(device / "devnum"),
+      "vendorId": read_int(device / "idVendor", 16),
+      "productId": read_int(device / "idProduct", 16),
+      "speedMbps": read_int(device / "speed"),
+      "manufacturer": read(device / "manufacturer") or "",
+      "product": read(device / "product") or "",
+      # 16-bit field upstream, so mask rather than let a wrapped counter overflow it
+      "linkErrorCount": link_errors(ctrl) & 0xFFFF,
+    })
+  return devices
+
+
+def set_usb_state(device_state, devices: list[dict], link_error_count: int = 0,
+                  lane: str | None = None) -> None:
+  entries = device_state.usbState.init('devices', len(devices))
+
+  dock_present = False
+  for entry, device in zip(entries, devices, strict=True):
+    entry.busnum = device["busnum"]
+    entry.devnum = device["devnum"]
+    entry.vendorId = device["vendorId"]
+    entry.productId = device["productId"]
+    entry.speedMbps = device["speedMbps"]
+    entry.manufacturer = device["manufacturer"]
+    entry.product = device["product"]
+    entry.linkErrorCount = device.get("linkErrorCount", 0) & 0xFFFF
+    entry.usb3Lane = device.get("usb3Lane", "unknown")
+
+    if (entry.vendorId, entry.productId) in EGPU_DOCK_USB_IDS:
+      dock_present = True
+
+  device_state.usbState.linkErrorCount = link_error_count
+  device_state.usbState.usb3Lane = lane if lane is not None else usb3_lane()
+  device_state.egpuDockPresent = dock_present

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/manager/process_config.py

@@ -8,6 +8,7 @@ from iqpilot.system.hardware import HARDWARE, PC, TICI
 from iqpilot.system.hardware.hw import Paths
 from iqpilot.system.manager.process import PythonProcess, NativeProcess, BundleProcess
 
+from iqpilot.selfdrive.iqmodeld.egpu_helpers import egpu_selected, resolve_backend, usbgpu_present
 from iqpilot.selfdrive.iqmodeld.models.helpers import get_active_model_runner
 from iqpilot.konn3kt.service_health import hephaestus_ready
 
@@ -124,6 +125,22 @@ def is_tinygrad_model(started, params, CP: car.CarParams) -> bool:
   """Check if the active model runner is tinygrad."""
   return bool(get_active_model_runner(params, not started) == custom.IQModelManager.Runner.tinygrad)
 
+def _egpu_present(params) -> bool:
+  if params.get_bool("IQEgpuDisabled"):
+    return False
+  return usbgpu_present()
+
+
+def emac_enabled(started, params, CP: car.CarParams) -> bool:
+  return resolve_backend(params.get_bool("IQEmacEnabled"), egpu_selected(params), _egpu_present(params)) == "emac"
+
+def egpu_enabled(started, params, CP: car.CarParams) -> bool:
+  return (resolve_backend(params.get_bool("IQEmacEnabled"), egpu_selected(params), _egpu_present(params)) == "egpu"
+          and _egpu_present(params))
+
+def big_model_enabled(started, params, CP: car.CarParams) -> bool:
+  return params.get_bool("IQEmacEnabled") or egpu_selected(params)
+
 def hephaestus_ready_shim(started, params, CP: car.CarParams) -> bool:
   return hephaestus_ready(params)
 
@@ -196,6 +213,17 @@ procs += [
   # Models
   BundleProcess("models_manager", "iqpilot_model_selector_private", "iqpilot_private.models.manager", and_(only_offroad, not_low_power)),
   NativeProcess("iqmodeld", "iqpilot/selfdrive/iqmodeld", ["./iqmodeld"], and_(only_onroad, is_tinygrad_model), restart_if_crash=True),
+  # big-model backends: iqmodeld self-demotes to the small channel worker when
+  # either backend is enabled; the selector publishes, and exactly one big
+  # worker (Mac or eGPU, eMac wins) feeds the BIG channel
+  PythonProcess("modeld_selector", "iqpilot.selfdrive.iqmodeld.modeld_selector",
+                and_(only_onroad, and_(is_tinygrad_model, big_model_enabled)), restart_if_crash=True),
+  BundleProcess("maciqmodeld", "iqpilot_emac_private", "iqpilot_private.emac.maciqmodeld",
+                and_(only_onroad, and_(is_tinygrad_model, emac_enabled)), restart_if_crash=True),
+  PythonProcess("iqegpumodeld", "iqpilot.selfdrive.iqmodeld.iqegpumodeld",
+                and_(only_onroad, and_(is_tinygrad_model, egpu_enabled)), restart_if_crash=True),
+  PythonProcess("egpu_prefetch", "iqpilot.selfdrive.iqmodeld.egpu_prefetch",
+                and_(only_offroad, and_(is_tinygrad_model, egpu_enabled)), restart_if_crash=True),
 
   BundleProcess("backup_manager_k3", "iqpilot_hephaestusd_private", "iqpilot_private.konn3kt.backups.backup_orchestrator",
                 and_(only_offroad, hephaestus_ready_shim, not_low_power)),

artifacts/iqpilot_navd_private/.source_sha

@@ -1 +1 @@
-7ef341203873309cd6087fbd6a0d355183f21472
+3184657cdc4d4fc1c69a924491f8a52466f10ec2

artifacts/iqpilot_navd_private/manifest.json

@@ -186,7 +186,7 @@
   },
   "python/iqpilot_private/navd/__init__.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "ab83e566caaae8db57a64209742a9243ccfb332daab10577eef1dd11ff2f062e",
+    "sha256": "9459a9e4551e5fd87cd98457a4cebcdd6f4763fc2ce03e13202011659289f8d3",
     "size": 67616
   },
   "python/iqpilot_private/navd/__init__.py": {
@@ -196,107 +196,107 @@
   },
   "python/iqpilot_private/navd/alpr_matcher.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "4252e7d3de4db89dd6bff89b4c59fae3fb009b3f150b8bf2f04e912e5030b591",
+    "sha256": "ea3451196fa13a2a8e2f9be7abff1b084308c856c52f001260f8340cc22e220f",
     "size": 269936
   },
   "python/iqpilot_private/navd/amap_client.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "75a0f2dfc9b6b21298f97be0d43079e873333faaaeb904a251247cf9b1958469",
+    "sha256": "96398bb3c989d670b641582e15bcd3ebc73f43f20b081dfaecd3d26fa81dc873",
     "size": 202040
   },
   "python/iqpilot_private/navd/event_builder.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "30ffec950cdaa4aaf49c7e7c1d2a150c98b13941a31067969ec6beffb4b4cc6e",
+    "sha256": "bdd6cc139cdac78d3b6bf93e7930764bbd0538f24799b939fedd1e32f25c5266",
     "size": 136960
   },
   "python/iqpilot_private/navd/helpers.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "2a2b1be142b042cf85d008b7bc7605a5fc89e8c80f9303ffd8e7f503092cadbf",
+    "sha256": "2df3400081a717f6ed6a819d3f5789ceda0707f89a6f6851dd77bd827b4721c6",
     "size": 135960
   },
   "python/iqpilot_private/navd/incident_feed.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "387b407e49fe9eb3debf58de1e80d26e878a55af8d7d386c69fe690fabdfc278",
+    "sha256": "fe29e5f6eb290d17c7fab03e55db700772d9b6abc77e34954d952175a9a8dd45",
     "size": 135528
   },
   "python/iqpilot_private/navd/iqmapd.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "4ae88149ae54971836bb0e539d3e6d8c400045d32b2524396ffb2e9bf3cd377e",
+    "sha256": "f6104209fc944accc4bca9d76598c14ea7bb32b5c06c6675c69ed71abbc18692",
     "size": 135632
   },
   "python/iqpilot_private/navd/long_decel.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "4eaa7376674fd8ed11661fe9587b8756cb0816dd7dcf9ee02a7122f4e16c4208",
+    "sha256": "b9a69dc97ff120e5efc5a41b0e24d14d9b57a4e83faf4a2fb9c414cc5feae407",
     "size": 69752
   },
   "python/iqpilot_private/navd/mapbox_client.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "bf259ccce678c8450d3a8646d641e3c1cee841ce62106964ddd8f0af76590922",
+    "sha256": "c6e2f1e77e0ef71ddb7ae6178e3a22990b11b224b4b62e5db767e0f78d854402",
     "size": 68144
   },
   "python/iqpilot_private/navd/nav_cameras.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "0af88978fcc2f04be1d9378eb0702f78d31321d845bf2f5b92efead4a6246b41",
+    "sha256": "fcabb4944766db54e4ef13849886339b352f9604b620b93e7b09bbddc5172a58",
     "size": 203056
   },
   "python/iqpilot_private/navd/nav_turn_signals.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "6dab10706556491be6b2481f805ee4d016f04d9faaddd8943d384851d14352b7",
+    "sha256": "f95c6ae94b726d5c6634a0867e60cb433fcf41a07270512ee02ae422f580fb2a",
     "size": 135560
   },
   "python/iqpilot_private/navd/navd.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "4bc9df93ca01b1623ae080ba468916c1ac1d22eb30d0b922bc97cc8d8f4177de",
+    "sha256": "4b04550554f61540c72d7657d172e699f17535faaf29b8223f6640eb71a9c0dc",
     "size": 797328
   },
   "python/iqpilot_private/navd/navincidentd.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "213cd32635b223ca3c39ccb5b65b2bbfe050b5401ff8e1285a4fd2f288107df5",
+    "sha256": "9a51d7c696a819e5ba47ba552bd1e7d21c28cdcb91fc9e0c22eb4b8d7c6d37e8",
     "size": 135344
   },
   "python/iqpilot_private/navd/navrenderd.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "87c4fae3eda6107363d54a32d200b6237ce02aa67db429895f68935476424bd0",
+    "sha256": "fd120500f581eb408700c1c43dc6789b0391041b7a1b4341ee9352e5edeb1cf1",
     "size": 135584
   },
   "python/iqpilot_private/navd/osm_cameras.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "236ff9dcb24f0599f8feab2fcfbf76754816ae3a8c4d9c7692d86c3579c6feca",
+    "sha256": "89ca86442a4cad9c79046c6a7d5a96dd65c352829b6234e41d131997e27ef28b",
     "size": 202384
   },
   "python/iqpilot_private/navd/reroute.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "5ef4fad4e686b94b258a4592733451358e0838f9cfe3fa0b2012cc87e4f550da",
+    "sha256": "8850331bcad9b7d708cb5cabff7c80364ed75b4dd000f1f3cca0098fb02bc5a7",
     "size": 136216
   },
   "python/iqpilot_private/navd/road_incidents.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "9833ba14d5565cfd9be9442a090d90134eb18dd26e2664aaf403cd8fc4e55906",
+    "sha256": "9faab3cc244eeba8dfae46b6ec57f4e8d9d03ca0c465b5ce2da836f1988aa0f6",
     "size": 203136
   },
   "python/iqpilot_private/navd/route_manager.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "6dc7c0b3600eaaf4429f960c68df3b2f9f50b44c515f3b8395541fe367cdcafc",
+    "sha256": "92e599dc73871b128be19c80057f983423023d7e2e3f9589ee8fe3c308ef2297",
     "size": 877864
   },
   "python/iqpilot_private/navd/runtime_common.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "df427f9ecd65f070a14b058b1ce3b12a6ff95cee0df4fb0ecbb7d281f6f85f48",
+    "sha256": "e24efc1da92e76a996549c22d8c56708e8713193be36c6365868de29be9a0276",
     "size": 135760
   },
   "python/iqpilot_private/navd/traffic.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "d1bcf0d4bdf3cf3d1877185b1ffb282ae2f837c181be16f5b2562db40033c5ad",
+    "sha256": "b97fae21d32dee6f240b79e3090c94f06e0328b8bf511b869667e56a23836901",
     "size": 69720
   },
   "python/iqpilot_private/navd/turn_desire.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "aebe5ee4db658d6383afbf5e2298820f66fb3a3deadf557a7d1557a24bf3189a",
+    "sha256": "822c67671b249a96bb5de1a83bd7c047ffb780bd252c62791a25a0ea7c2101fc",
     "size": 69768
   },
   "python/iqpilot_private/navd/web_server.cpython-312-aarch64-linux-gnu.so": {
     "mode": 493,
-    "sha256": "ea7ad6c47b9597cb620a21a9328c4086acf1e688df3f7e9215e0b80204c7c36c",
+    "sha256": "2c1c671d8d933d6896387894fe62b213b99b9d75085b54c61806e2bb7d381d7b",
     "size": 201400
   },
   "runtime": {
@@ -336,27 +336,27 @@
     }
   },
   "signatures": {
-    "python/iqpilot_private/navd/__init__.cpython-312-aarch64-linux-gnu.so": "oPML6Wc2Gz1fcV9/pvBqum19QGaDdU6dgx4XxyW+riBWG0SCYhQN49tYqIlCYG0sFhmNTxk+t7PooiDR6IFGDA==",
+    "python/iqpilot_private/navd/__init__.cpython-312-aarch64-linux-gnu.so": "lg9M4QXLrh1ynX/Hev+0FAPnbN9mDoqv8diic0U+aYqjLMgkW+wHcB4r78J8oTrpDC+vF1wWztWj3cQOx98NCw==",
-    "python/iqpilot_private/navd/alpr_matcher.cpython-312-aarch64-linux-gnu.so": "ny5TsakqUUusA8CHaRAHr2u8I36TJMEUYUlIj6QVyLL2+lSdx4EILBp4CPxlCbKD0GXHmtz7e3cUXjQ8ZeEwAg==",
+    "python/iqpilot_private/navd/alpr_matcher.cpython-312-aarch64-linux-gnu.so": "DGacFfOsQ9paqF8ytUgX572A/wPOZi7rJefAl9vydnAFbQv5NL+c9ot5YDGI1s4mXs/SHPbn0WtTOOU2aS/hDQ==",
-    "python/iqpilot_private/navd/amap_client.cpython-312-aarch64-linux-gnu.so": "NphgdvZnPhZGkKWHxb9MGuZBfNMIiZPAFZ52c554F0894KWrInZNVgejQO7j+uz2QnS3ZQdR/PlFmI1kdDi+Aw==",
+    "python/iqpilot_private/navd/amap_client.cpython-312-aarch64-linux-gnu.so": "r0vM+nE7A00o362Oj745OQzat76z889uBd/niFp18Qds4P1Wpvynd1ctrbOlo9H1yESeC09NuP/Qw4k1pvt1Cg==",
-    "python/iqpilot_private/navd/event_builder.cpython-312-aarch64-linux-gnu.so": "adGUan4KdFX6rUvqTlURR6ZRPiW5H3ssuIR66TRmNbTUetkU6dmNNl4YhEslaKSz1cYQHyEpHwdU2P+DjwKDCg==",
+    "python/iqpilot_private/navd/event_builder.cpython-312-aarch64-linux-gnu.so": "JkfNSqU9uM4oZqxteomIbPo6abywxUzzdBx5B2myJNtUjGW5bHEii2D2DAUKuO+gd7x+6+IwgPwSOJJyN+QYBQ==",
-    "python/iqpilot_private/navd/helpers.cpython-312-aarch64-linux-gnu.so": "NXYguIzqCJ0R2KFlweClB4KVYpLmWhVo125EtvYFqKYEQrPQFc9gPv5z9ximd4uJkeTDSJbDBEtgESscs2tyAA==",
+    "python/iqpilot_private/navd/helpers.cpython-312-aarch64-linux-gnu.so": "/CNm/bxjvo/IgjjDTde0p8c1Gl6I54dSwiSS0sEVUcrTRP3Y31S0dh8dnBqn1VTH3PIGlUDBF7EmTavXUOAfDg==",
-    "python/iqpilot_private/navd/incident_feed.cpython-312-aarch64-linux-gnu.so": "ng6Y0DD3j+U/Y6LLH5yK5Z5di/FtAnze+nU6EOlE/5v8a0ITw0TDKe90OeiUUWV+vH580sec0DwzNuFyxKodAA==",
+    "python/iqpilot_private/navd/incident_feed.cpython-312-aarch64-linux-gnu.so": "3IB5k4NEsFoKHckxlqoOZVXBAyVhYkVWRCvRdBnH4H+8udEuW5EpRXHv0rxtqBAs82ozbpOcZ7QjtfFgQPbXCQ==",
-    "python/iqpilot_private/navd/iqmapd.cpython-312-aarch64-linux-gnu.so": "HihBFDE4shygX42LHhQK3+FBqEtwDhpdkgavEzIi4o9G1IoDHJw3x1waUYq4f53pVORmHdigRlhCHAzCu0QBCA==",
+    "python/iqpilot_private/navd/iqmapd.cpython-312-aarch64-linux-gnu.so": "Dp4PpzIqDJ5ySg1lIi0b5V49g7U2aOx1T+SeKGGKhOaEcCLnUEAd2EilrXt2luq8Xj+nnHWbMrZUho0KV7MfBQ==",
-    "python/iqpilot_private/navd/long_decel.cpython-312-aarch64-linux-gnu.so": "XTu5FBSn9wzzUbyFpYqtEI6T8xFyIaY4JheqW2laPKx+opAhY8OGyniRdc8WQm28/YkYh7alFHcbmkE0ZRMOAw==",
+    "python/iqpilot_private/navd/long_decel.cpython-312-aarch64-linux-gnu.so": "z87MDJLWKyqWqsXzTnoxjNfjkPxi6W0wsUt+Cafw5QWHMB6jGkJ1ZedYeS83qqdaxZGR3OaBdKohMSi9JKQHDA==",
-    "python/iqpilot_private/navd/mapbox_client.cpython-312-aarch64-linux-gnu.so": "KOXmWcb8Pv+Y8h2hbAVu86CfKvwM2STRljCkiaLFayPa+s7ItISkwwLeaj94EQpg7QW0MGKGXBznZJRHBtM9DA==",
+    "python/iqpilot_private/navd/mapbox_client.cpython-312-aarch64-linux-gnu.so": "FtOYM9RJA3LudYiGW9h4+EO94TqJVV4/hhEb9DOIL3hrbJYMWCctCTfo70UmgL+v8+8MSCyHgL3KBqPsW58gCg==",
-    "python/iqpilot_private/navd/nav_cameras.cpython-312-aarch64-linux-gnu.so": "2XWDcUR+oJH0invIRcOfERVwwUhC8ATks+gYWHMw8FlTKjSqbLhzY3TyWB2c1MIpF311c968R0wc4ZmCmmdSDw==",
+    "python/iqpilot_private/navd/nav_cameras.cpython-312-aarch64-linux-gnu.so": "XfkYcx/mj7TT57RjfAdlleSW5kgdGkLYt0h+SpJV+UdQeb+NTVHYa3+PgglT1KP8WjO5Tbyr6i5V4pq4ZwbhCQ==",
-    "python/iqpilot_private/navd/nav_turn_signals.cpython-312-aarch64-linux-gnu.so": "uR1wgK2h8ouVr+Po1brESGiDhbpxBEBqFGq9Ek+woiaceJO9njiTKSOBSldp3653sGIPuZ4++7yRMmzCd7GDCw==",
+    "python/iqpilot_private/navd/nav_turn_signals.cpython-312-aarch64-linux-gnu.so": "GGhf7FRjRzg9uLp4ClSosUUXJk+ocH4NETh8wetaqTkXev1smeJCd2OWbTqgWmlGRfjLqsnXzpv+bxBIKishAw==",
-    "python/iqpilot_private/navd/navd.cpython-312-aarch64-linux-gnu.so": "zMtyBW+eW3Phtljgoq8dEHThhyeenDq9IPkRCPiWzdZoSysKWmOz0cDnhuLihgaJJDcOz4msp5aggqzHsKlRCQ==",
+    "python/iqpilot_private/navd/navd.cpython-312-aarch64-linux-gnu.so": "YwIAOpt1komu3aFiqx1uhCJFpFZ/tCub2RNrJMyh8RS7SI0ySxmiQ9MXMyuXt5Gxnt9ReGmxVSKo7x3UDsuCCg==",
-    "python/iqpilot_private/navd/navincidentd.cpython-312-aarch64-linux-gnu.so": "J3ZnYTzWLxwDUrmwh+d2rKmtMM/t6eGfSYQQoihLltX5LfXZHRUjnk/CMbr619iJWw2srmX/HT2LWyjh+h7vBw==",
+    "python/iqpilot_private/navd/navincidentd.cpython-312-aarch64-linux-gnu.so": "2agJVQwkglB5XE1acDWp+u/ZzwP0qJcEklPATDv4jez1KkftYqQb47J1/iGSxOtwh9NuXe//MNg+EEmwSlzvAQ==",
-    "python/iqpilot_private/navd/navrenderd.cpython-312-aarch64-linux-gnu.so": "E340TW5CssaeUeA/xioykmrvsVJUZDVe5mUpUrdCUyG6qVta/V+6ZxvM+n9FEjUuqHO5w0U1Gog7SMU6QguEDA==",
+    "python/iqpilot_private/navd/navrenderd.cpython-312-aarch64-linux-gnu.so": "G2ccii+ezg3lFQcNXI15EMVXWpszZlJJ4dy+nylF0OLEWWKRGFofb+vq4fYfwrJXmbn4nK9F+286nt4Q81WQAQ==",
-    "python/iqpilot_private/navd/osm_cameras.cpython-312-aarch64-linux-gnu.so": "l3iGDUFF+LGssB6mrgoOoB/P4M4FeoDQmmZgYzjoQArM0DjXN51yHC1oAuVUikMC1QqI8JEz+pT/t3K/lthDDA==",
+    "python/iqpilot_private/navd/osm_cameras.cpython-312-aarch64-linux-gnu.so": "+zTVSWeyZBkJFOC95QdK0LGd0EzLBZVB/GbKd3RiMsiQw83oAwNomLWs3SbsUhRBCZyGF56n2TQXEZQWjknaCg==",
-    "python/iqpilot_private/navd/reroute.cpython-312-aarch64-linux-gnu.so": "dR976C5dqTNV2z2I9RXcfxT/SSwg+IRaIcXrJM6/uL2rjyTW4E0avjJwgIH7GAYyOKfdRdWaBhoeIpfpDu18Aw==",
+    "python/iqpilot_private/navd/reroute.cpython-312-aarch64-linux-gnu.so": "V+CQv3lqojsqJ/1gJJCuaR94ncCkRX4fT0iD+mxvJNmTLBGvw90hKl9v6IgtUvCOhqnHo2nJf30iH07C8R7iBA==",
-    "python/iqpilot_private/navd/road_incidents.cpython-312-aarch64-linux-gnu.so": "n5h8gG43Se5sGYqwc+OAmu2JF2mWKZ6yHz+Zm62qwYuImz/3KMC8dP4tXWrCsZNeOYhIWhQ8/rtrUA2+99GDBg==",
+    "python/iqpilot_private/navd/road_incidents.cpython-312-aarch64-linux-gnu.so": "y5v5qBwMoKEvcYxjEy5tOwEB2BXaCAKIaKEBQKUuUfZpEZw7IpvPDGZbD5P5f1j05EJBde6jV9XbPB1mHIiHCg==",
-    "python/iqpilot_private/navd/route_manager.cpython-312-aarch64-linux-gnu.so": "pnE75vxRBGvNdNGna3EETR5/XIVm6++qFo+RiwII/Cfr/qLy2htTdGRv7sVz419HR65NbrK1XNOhnomgaeKvCg==",
+    "python/iqpilot_private/navd/route_manager.cpython-312-aarch64-linux-gnu.so": "BIpSZfiTIaOZucyCX3pGiAtNAtRIg8WNQyfaMqnMEy52Ttowb1NheURl/qn11wqKaKeQN5+wgDmTwIkx3Eu6CQ==",
-    "python/iqpilot_private/navd/runtime_common.cpython-312-aarch64-linux-gnu.so": "wbXLXRjX9hsV1fhYcHhqii6+ejytkL8cBWROmUjc4S0zJCMj5+h+egXl8Pdg7R2X0ylFM6Ifxa3xvyT6CwMuDA==",
+    "python/iqpilot_private/navd/runtime_common.cpython-312-aarch64-linux-gnu.so": "pyRMyI5u6/IG5LKIgCuZf4rcquMN19P8M2rcmr+yjnfO50o8SRT18+iklNXj0VY96LKMyQx/ejV7y7Jgt+qnDw==",
-    "python/iqpilot_private/navd/traffic.cpython-312-aarch64-linux-gnu.so": "DztyZU20SV8yBmCxA8RVRQQgUyOsKYPpvFaXlOOI7qrlWEJUFedw1CPhh+OEfPtqETHtAD/RbYtNTJvJxdOEBA==",
+    "python/iqpilot_private/navd/traffic.cpython-312-aarch64-linux-gnu.so": "MVSL4IXTQ8SFa6zDY5Y/QWN5yhcFBx6LaujCzLJQfALs0bYb7jyy7XVbxlyQshpOy4n151YggEBhuNSCGHSaCA==",
-    "python/iqpilot_private/navd/turn_desire.cpython-312-aarch64-linux-gnu.so": "Zuif6kcPBjB3x+fN9BSrYv0RVMplHLGtV5grV0j8iNLOvO9vgKveAxSQYm+Mds1qjLOheL6ElhOPrlHH93ZlCg==",
+    "python/iqpilot_private/navd/turn_desire.cpython-312-aarch64-linux-gnu.so": "A6QTQvEit2o797TrW2PuahnLODdACAAIahBw3UWtOTKHhD+vQaXke0yvxBcgVxgaBJLfpIz8SjKaZuEeIPphDg==",
-    "python/iqpilot_private/navd/web_server.cpython-312-aarch64-linux-gnu.so": "9uBrvcgtzx/3Y4GUaFW2M3DD6got1o+ZtQRjPUC3FZtWLRO4nl4U/6iBRuNXnSOw5Hv2M5P4OZawSo6stK/MAQ=="
+    "python/iqpilot_private/navd/web_server.cpython-312-aarch64-linux-gnu.so": "Qe32cW7+K4rQR6eRvi9vM8BZta5mPsK/xo9/dF4IZnfPYTP0bHzBFXZjsO4LVntwY/bUwMagp4fnRgXxwhNFCw=="
   }
 }

artifacts/iqpilot_navd_private/manifest.json.sig

@@ -1 +1 @@
-WJGvk92Vi3ftfwgoTBFWBFrdBiRyw1rJNRMjFcAsqEAcbBlA3tZWbUNmqLqiJamhrGc7pWX/1j2jEB0dImvZBg==
+Fhs5w4K9yXGTe1Y9xpYpVEnHRHUsq4pJ0opKgllTGam0njHeskbHsYQmlj3n94vPeCJhQw52x9Bd1S2/R37WAg==

iqpilot/common/params_keys.h

@@ -393,6 +393,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"OsmDownloadedDate", {PERSISTENT, STRING, "0.0"}},
     {"OSMDownloadLocations", {PERSISTENT, JSON}},
     {"AthenaNavigationRoute", {CLEAR_ON_MANAGER_START, JSON}},
+    {"Konn3ktNavigationSession", {CLEAR_ON_MANAGER_START, JSON}},
     {"NavigationActive", {CLEAR_ON_MANAGER_START, BOOL, "0"}},
     {"NavigationDestination", {CLEAR_ON_MANAGER_START, JSON}},
     {"NavigationEnabled", {PERSISTENT, BOOL, "0"}},

launch_chffrplus.sh

@@ -265,6 +265,9 @@ function launch {
   if [ ! -f $DIR/prebuilt ]; then
     if pkill -f /tmp/installer 2>/dev/null; then sleep 1; fi
     "$DIR/.venv/bin/python3" ./build.py
+    for service_name in hephaestusd ble-transportd flockd; do
+      sudo systemctl restart --no-block "${service_name}.service"
+    done
   fi
 
   "$DIR/.venv/bin/python3" ./manager.py