Merge branch 'pioarduino' into crowpanel-p4

Co-authored-by: Copilot <copilot@github.com>

.devcontainer/devcontainer.json

@@ -8,7 +8,7 @@
   "features": {
     "ghcr.io/devcontainers/features/python:1": {
       "installTools": true,
-      "version": "3.14"
+      "version": "3.13"
     }
   },
   "customizations": {

.github/copilot-instructions.md

@@ -135,95 +135,6 @@ On top of authorization, any remote admin message that **mutates** state (not a
 - **Channel 0 PSK change** → every peer must re-learn the channel hash; cached NodeInfo becomes temporarily unreachable until the next broadcast.
 - **`security.private_key` blanked via admin** → regenerates both halves (unless in Ham mode) and propagates the new public key via NodeInfo.
 
-## NodeDB Layout (v25)
-
-`DEVICESTATE_CUR_VER = 25`, `DEVICESTATE_MIN_VER = 24`. The on-device NodeDB was split in v25 into a slim header table plus four optional satellite stores. Older v24 saves auto-migrate at boot. Old training-data instincts (`node->user.long_name`, `node->position.latitude_i`, `node->is_favorite`, `node->device_metrics.battery_level`) are wrong now — the fields aren't there. Read this section before touching anything that walks `nodeDB->meshNodes`.
-
-### Slim `NodeInfoLite`
-
-`UserLite` is flattened onto `NodeInfoLite` (no nested sub-message); `position` and `device_metrics` are removed entirely (tags reserved). MAC address is dropped. Long names are capped at 25 chars (`max_size:25` in `deviceonly.options`); `hw_model` and `role` are `int_size:8`. Encoded size dropped from ~166 B → ~105 B per node.
-
-Booleans are bit-packed into `NodeInfoLite.bitfield`. **Do not read or write the bits directly** — use the inline helpers in `src/mesh/NodeDB.h`:
-
-```cpp
-nodeInfoLiteHasUser(n)                  // bit 5 — user fields populated
-nodeInfoLiteIsFavorite(n)               // bit 3
-nodeInfoLiteIsIgnored(n)                // bit 4
-nodeInfoLiteIsMuted(n)                  // bit 1
-nodeInfoLiteIsLicensed(n)               // bit 6 — Ham mode peer
-nodeInfoLiteIsKeyManuallyVerified(n)    // bit 0
-nodeInfoLiteHasIsUnmessagable(n)        // bit 8 — "is_unmessagable was sent"
-nodeInfoLiteIsUnmessagable(n)           // bit 7
-// via_mqtt is bit 2 (mask exposed; predicate uses the mask directly)
-
-nodeInfoLiteSetBit(n, NODEINFO_BITFIELD_IS_FAVORITE_MASK, true);  // setter
-```
-
-### Satellite stores
-
-Four `std::unordered_map<NodeNum, …>` members on `NodeDB`, each gated by its own build flag:
-
-| Map               | Value type                      | Build flag                         |
-| ----------------- | ------------------------------- | ---------------------------------- |
-| `nodePositions`   | `meshtastic_PositionLite`       | `MESHTASTIC_EXCLUDE_POSITIONDB`    |
-| `nodeTelemetry`   | `meshtastic_DeviceMetrics`      | `MESHTASTIC_EXCLUDE_TELEMETRYDB`   |
-| `nodeEnvironment` | `meshtastic_EnvironmentMetrics` | `MESHTASTIC_EXCLUDE_ENVIRONMENTDB` |
-| `nodeStatus`      | `meshtastic_StatusMessage`      | `MESHTASTIC_EXCLUDE_STATUSDB`      |
-
-Defaults are ON (i.e., maps **excluded**) for STM32WL only — see `src/mesh/mesh-pb-constants.h`. On every other arch all four maps are present. When excluded, the map member is absent and the corresponding accessors return `false`.
-
-All four maps are guarded by **`mutable concurrency::Lock satelliteMutex`** — concurrent access from receive threads, the phone API state machine, and the renderer is the rule, not the exception.
-
-### Accessor convention
-
-**Never hand out pointers into the maps.** Use the copy-out accessors on `NodeDB`:
-
-```cpp
-bool copyNodePosition(NodeNum, meshtastic_PositionLite &out)       const;
-bool copyNodeTelemetry(NodeNum, meshtastic_DeviceMetrics &out)     const;
-bool copyNodeEnvironment(NodeNum, meshtastic_EnvironmentMetrics &out) const;
-bool copyNodeStatus(NodeNum, meshtastic_StatusMessage &out)        const;
-```
-
-Each takes the lock, copies the value if present, returns `false` if the entry is absent or the DB is excluded. Pass-by-out-param is deliberate — pointer-style accessors would invite UAF and lock-leak bugs across the renderer. The "has any X" convenience predicates (`hasValidPosition` etc.) are implemented in terms of these.
-
-Writers go through `setNodeStatus`, `updatePosition`, `updateTelemetry` (which dispatches on `which_variant` for device vs environment metrics) — these own the lock and the eviction hooks.
-
-### Eviction
-
-Every code path that drops a node from the header table must also evict the satellites. The single chokepoint is `eraseNodeSatellites(NodeNum)`; it's already called from `getOrCreateMeshNode`'s oldest-boring eviction, `removeNodeByNum`, both branches of `resetNodes`, `cleanupMeshDB`, `addFromContact`'s ignored-branch, and `AdminModule`'s `set_ignored_node`. Add new eviction sites here, not by calling `.erase()` directly.
-
-### Gradient sync (opt-in via special nonces)
-
-`client_capabilities` is **not** a thing in this branch. Phone clients opt into the new sync flow by sending one of two values in the `ToRadio.want_config_id`:
-
-- `SPECIAL_NONCE_GRADIENT_SYNC` (69422) — full config + thin NodeInfo + replay phases.
-- `SPECIAL_NONCE_GRADIENT_ONLY_NODES` (69423) — skip config segments, NodeInfo + replay only.
-
-`PhoneAPI::clientWantsGradientSync()` is the single switch. When true, `STATE_SEND_OTHER_NODEINFOS` is followed by:
-
-```text
-STATE_REPLAY_POSITIONS → STATE_REPLAY_TELEMETRY → STATE_REPLAY_ENVIRONMENT → STATE_REPLAY_STATUS
-```
-
-Each replay phase walks the corresponding satellite map and emits synthetic `MeshPacket`s on the matching portnum (`POSITION_APP`, `TELEMETRY_APP` for both device + environment variants, `STATUS_MESSAGE_APP`). Legacy clients (no special nonce) get the bundled-NodeInfo path with position/device_metrics joined back in by `ConvertToNodeInfo(lite, pos*, dm*)` — wire bytes are byte-identical to pre-v25 for them.
-
-`ConvertToNodeInfoThin(lite)` is the gradient-sync emitter (no position/telemetry).
-
-### v24 → v25 migration
-
-The legacy migration code lives in **`src/mesh/NodeDBLegacyMigration.cpp`**, not in `NodeDB.cpp`. It owns the `meshtastic_NodeDatabase_Legacy` callback and `NodeDB::migrateLegacyNodeDatabase()`. The legacy proto descriptor is `protobufs/meshtastic/deviceonly_legacy.proto` (only included by the migration TU). The boot path peeks the file's leading version tag, runs the migration if `version < 25`, then re-saves in v25 layout. The legacy descriptor is scheduled for removal once `DEVICESTATE_MIN_VER` is bumped.
-
-### Read-site rules of thumb
-
-- Never `node->position.X` / `node->device_metrics.X` — those fields no longer exist. Pull from the satellite map via `copyNodePosition` / `copyNodeTelemetry`.
-- Never `node->user.long_name` — `long_name`, `short_name`, `public_key`, `hw_model`, `role`, `macaddr` (gone), `is_licensed`, `is_unmessagable` are flat on `NodeInfoLite`.
-- Never `node->is_favorite` / `node->is_ignored` / `node->via_mqtt` / `node->is_key_manually_verified` — use the bitfield helpers.
-- Never assume `nodeDB->getMeshNode(num)->position.time` — call `copyNodePosition` and check the return.
-- Don't lock `satelliteMutex` yourself in renderer code; the copy-out accessors already do.
-
-Unit tests for the conversion layer live in `test/test_type_conversions/test_main.cpp` (Unity) — bitfield round-trips, `long_name` truncation, thin-vs-full conversions. Add cases there when extending the schema.
-
 ## Project Structure
 
 ```

.vscode/extensions.json

@@ -1,10 +1,10 @@
 {
-    // See http://go.microsoft.com/fwlink/?LinkId=827846
-    // for the documentation about the extensions.json format
     "recommendations": [
-        "platformio.platformio-ide"
+        "Jason2866.esp-decoder",
+        "pioarduino.pioarduino-ide"
     ],
     "unwantedRecommendations": [
-        "ms-vscode.cpptools-extension-pack"
+        "ms-vscode.cpptools-extension-pack",
+        "platformio.platformio-ide"
     ]
 }

bin/build-esp32.sh

@@ -38,4 +38,4 @@ cp bin/device-install.* $OUTDIR/
 cp bin/device-update.* $OUTDIR/
 
 echo "Copying manifest"
-cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json || true
+cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json

bin/org.meshtastic.meshtasticd.metainfo.xml

@@ -87,9 +87,6 @@
   </screenshots>
 
   <releases>
-    <release version="2.7.24" date="2026-05-08">
-      <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.24</url>
-    </release>
     <release version="2.7.23" date="2026-04-14">
       <url type="details">https://github.com/meshtastic/firmware/releases?q=tag%3Av2.7.23</url>
     </release>

bin/platformio-custom.py

@@ -293,9 +293,12 @@ if ("HAS_TFT", 1) in env.get("CPPDEFINES", []):
 board_arch = infer_architecture(env.BoardConfig())
 should_skip_manifest = board_arch is None
 
-# For host/native envs, avoid depending on 'buildprog' (some targets don't define it)
-mtjson_deps = [] if should_skip_manifest else ["buildprog"]
-if not should_skip_manifest and platform.name == "espressif32":
+# Most platforms can generate the manifest as part of the default 'buildprog' target.
+# Typically this passes success/failure properly.
+mtjson_deps = ["buildprog"]
+if platform.name == "espressif32":
+    # On ESP32, we need to explicitly depend upon the binary to prevent fake-success upon failure.
+    mtjson_deps = ["$BUILD_DIR/${PROGNAME}.bin"]
     # Build littlefs image as part of mtjson target
     # Equivalent to `pio run -t buildfs`
     target_lfs = env.DataToBin(
@@ -309,7 +312,8 @@ if should_skip_manifest:
 
     env.AddCustomTarget(
         name="mtjson",
-        dependencies=mtjson_deps,
+        # For host/native envs, avoid depending on 'buildprog' (some targets don't define it)
+        dependencies=[],
         actions=[skip_manifest],
         title="Meshtastic Manifest (skipped)",
         description="mtjson generation is skipped for native environments",

boards/CDEBYTE_EoRa-S3.json

@@ -7,7 +7,7 @@
     "extra_flags": [
       "-D CDEBYTE_EORA_S3",
       "-D ARDUINO_USB_CDC_ON_BOOT=1",
-      "-D ARDUINO_USB_MODE=0",
+      "-D ARDUINO_USB_MODE=1",
       "-D ARDUINO_RUNNING_CORE=1",
       "-D ARDUINO_EVENT_RUNNING_CORE=1",
       "-D BOARD_HAS_PSRAM"

boards/bpi_picow_esp32_s3.json

@@ -6,7 +6,7 @@
     "core": "esp32",
     "extra_flags": [
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1",
       "-DBOARD_HAS_PSRAM"

boards/crowpanel-p4.json

@@ -0,0 +1,32 @@
+{
+  "build": {
+    "core": "esp32",
+    "extra_flags": ["-DBOARD_HAS_PSRAM"],
+    "f_cpu": "360000000L",
+    "f_flash": "80000000L",
+    "f_psram": "200000000L",
+    "flash_mode": "qio",
+    "hwids": [["0x1A86", "0x7522"]],
+    "mcu": "esp32p4",
+    "chip_variant": "esp32p4",
+    "variant": "esp32p4"
+  },
+  "arduino": {
+    "partitions": "default_16MB.csv"
+  },
+  "connectivity": ["bluetooth", "openthread"],
+  "debug": {
+    "openocd_target": "esp32p4.cfg"
+  },
+  "frameworks": ["arduino", "espidf"],
+  "name": "CrowPanel Advanced ESP32-P4 HMI AI Display",
+  "upload": {
+    "flash_size": "16MB",
+    "maximum_ram_size": 512000,
+    "maximum_size": 16777216,
+    "require_upload_port": true,
+    "speed": 1500000
+  },
+  "url": "https://www.elecrow.com/crowpanel-advanced-5inch-esp32-p4-hmi-ai-display-800x480-ips-touch-screen-with-wifi-6.html",
+  "vendor": "Elecrow"
+}

boards/hackaday-communicator.json

@@ -8,7 +8,7 @@
     "extra_flags": [
       "-DBOARD_HAS_PSRAM",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/heltec_vision_master_e213.json

@@ -9,7 +9,7 @@
     "extra_flags": [
       "-DBOARD_HAS_PSRAM",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/heltec_vision_master_e290.json

@@ -9,7 +9,7 @@
     "extra_flags": [
       "-DBOARD_HAS_PSRAM",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/heltec_vision_master_t190.json

@@ -9,7 +9,7 @@
     "extra_flags": [
       "-DBOARD_HAS_PSRAM",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/heltec_wireless_tracker.json

@@ -8,7 +8,7 @@
     "extra_flags": [
       "-DHELTEC_WIRELESS_TRACKER",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/heltec_wireless_tracker_v2.json

@@ -7,7 +7,7 @@
     "core": "esp32",
     "extra_flags": [
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/seeed-xiao-s3.json

@@ -8,7 +8,7 @@
     "extra_flags": [
       "-DBOARD_HAS_PSRAM",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=0"
     ],

boards/t-beam-1w.json

@@ -9,7 +9,7 @@
       "-DBOARD_HAS_PSRAM",
       "-DLILYGO_TBEAM_1W",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/t-deck.json

@@ -8,7 +8,7 @@
     "extra_flags": [
       "-DBOARD_HAS_PSRAM",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/tbeam-s3-core.json

@@ -8,7 +8,7 @@
       "-DBOARD_HAS_PSRAM",
       "-DLILYGO_TBEAM_S3_CORE",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

boards/tlora-t3s3-v1.json

@@ -7,7 +7,7 @@
     "extra_flags": [
       "-DLILYGO_T3S3_V1",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1",
       "-DBOARD_HAS_PSRAM"

boards/unphone.json

@@ -10,7 +10,7 @@
       "-DBOARD_HAS_PSRAM",
       "-DUNPHONE_SPIN=9",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=0",
+      "-DARDUINO_USB_MODE=1",
       "-DARDUINO_RUNNING_CORE=1",
       "-DARDUINO_EVENT_RUNNING_CORE=1"
     ],

debian/changelog

@@ -1,9 +1,3 @@
-meshtasticd (2.7.24.0) unstable; urgency=medium
-
-  * Version 2.7.24
-
- -- GitHub Actions <github-actions[bot]@users.noreply.github.com>  Fri, 08 May 2026 10:44:12 +0000
-
 meshtasticd (2.7.23.0) unstable; urgency=medium
 
   * Version 2.7.23

default_16MB.csv

@@ -0,0 +1,7 @@
+# Name,   Type, SubType, Offset,  Size, Flags
+nvs,      data, nvs,     0x9000,  0x5000,
+otadata,  data, ota,     0xe000,  0x2000,
+app0,     app,  ota_0,   0x10000, 0x640000,
+app1,     app,  ota_1,   0x650000,0x640000,
+spiffs,   data, spiffs,  0xc90000,0x360000,
+coredump, data, coredump,0xFF0000,0x10000,

default_8MB.csv

@@ -0,0 +1,7 @@
+# Name,   Type, SubType, Offset,  Size, Flags
+nvs,      data, nvs,     0x9000,  0x5000,
+otadata,  data, ota,     0xe000,  0x2000,
+app0,     app,  ota_0,   0x10000, 0x330000,
+app1,     app,  ota_1,   0x340000,0x330000,
+spiffs,   data, spiffs,  0x670000,0x180000,
+coredump, data, coredump,0x7F0000,0x10000,

extra_scripts/esp32_extra.py

@@ -70,17 +70,6 @@ def esp32_create_combined_bin(source, target, env):
 
 env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", esp32_create_combined_bin)
 
-esp32_kind = env.GetProjectOption("custom_esp32_kind")
-if esp32_kind == "esp32":
-    # Free up some IRAM by removing auxiliary SPI flash chip drivers.
-    # Wrapped stub symbols are defined in src/platform/esp32/iram-quirk.c.
-    env.Append(
-        LINKFLAGS=[
-            "-Wl,--wrap=esp_flash_chip_gd",
-            "-Wl,--wrap=esp_flash_chip_issi",
-            "-Wl,--wrap=esp_flash_chip_winbond",
-        ]
-    )
-else:
-    # For newer ESP32 targets, using newlib nano works better.
-    env.Append(LINKFLAGS=["--specs=nano.specs", "-u", "_printf_float"])
+# Enable Newlib Nano formatting to save space
+# ...but allow printf float support (compromise)
+env.Append(LINKFLAGS=["--specs=nano.specs", "-u", "_printf_float"])

extra_scripts/ld_response_file.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# trunk-ignore-all(ruff/F821)
+# trunk-ignore-all(flake8/F821): For SConstruct imports
+
+# force linker response file instead of command line arguments
+
+Import("env")
+
+
+def wrap_with_tempfile(command_key):
+    command = env.get(command_key)
+    if not command or not isinstance(command, str):
+        return
+    if "TEMPFILE(" in command:
+        return
+    env.Replace(**{command_key: "${TEMPFILE('%s')}" % command})
+
+
+# Force SCons to spill long commands into response files on this target.
+env.Replace(MAXLINELENGTH=8192)
+
+for key in ("LINKCOM", "CXXLINKCOM", "SHLINKCOM", "SHCXXLINKCOM"):
+    wrap_with_tempfile(key)

platformio.ini

@@ -2,7 +2,7 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-default_envs = tbeam
+default_envs = heltec-v3
 
 extra_configs =
 	variants/*/*.ini

src/BluetoothCommon.cpp

@@ -14,4 +14,28 @@ const uint8_t FROMNUM_UUID_16[16u] = {0x53, 0x44, 0xe3, 0x47, 0x75, 0xaa, 0x70,
 const uint8_t LEGACY_LOGRADIO_UUID_16[16u] = {0xe2, 0xf2, 0x1e, 0xbe, 0xc5, 0x15, 0xcf, 0xaa,
                                               0x6b, 0x43, 0xfa, 0x78, 0x38, 0xd2, 0x6f, 0x6c};
 const uint8_t LOGRADIO_UUID_16[16u] = {0x47, 0x95, 0xDF, 0x8C, 0xDE, 0xE9, 0x44, 0x99,
-                                       0x23, 0x44, 0xE6, 0x06, 0x49, 0x6E, 0x3D, 0x5A};
+                                       0x23, 0x44, 0xE6, 0x06, 0x49, 0x6E, 0x3D, 0x5A};
+
+void BluetoothApi::setup() {}
+void BluetoothApi::shutdown() {}
+void BluetoothApi::deinit() {}
+void BluetoothApi::clearBonds() {}
+bool BluetoothApi::isActive()
+{
+    return false;
+}
+bool BluetoothApi::isConnected()
+{
+    return false;
+}
+void BluetoothApi::sendLog(const uint8_t *logMessage, size_t length)
+{
+    (void)logMessage;
+    (void)length;
+}
+
+void updateBatteryLevel(uint8_t level) __attribute__((weak));
+void updateBatteryLevel(uint8_t level)
+{
+    (void)level;
+}

src/BluetoothCommon.h

@@ -24,9 +24,14 @@ void updateBatteryLevel(uint8_t level);
 class BluetoothApi
 {
   public:
+    virtual ~BluetoothApi() = default;
+
     virtual void setup();
     virtual void shutdown();
+    virtual void deinit();
     virtual void clearBonds();
+    virtual bool isActive();
     virtual bool isConnected();
     virtual int getRssi() = 0;
+    virtual void sendLog(const uint8_t *logMessage, size_t length);
 };

src/DebugConfiguration.cpp

@@ -26,8 +26,6 @@ SOFTWARE.*/
 
 #include "DebugConfiguration.h"
 
-#include <memory>
-
 #ifdef ARCH_PORTDUINO
 #include "platform/portduino/PortduinoGlue.h"
 #endif
@@ -121,22 +119,27 @@ bool Syslog::vlogf(uint16_t pri, const char *fmt, va_list args)
 
 bool Syslog::vlogf(uint16_t pri, const char *appName, const char *fmt, va_list args)
 {
-    // First measure the formatted length using a copy of args; passing args directly
-    // to vsnprintf consumes it, and reusing a consumed va_list is undefined behavior.
-    va_list args_measure;
-    va_copy(args_measure, args);
-    int needed = vsnprintf(nullptr, 0, fmt, args_measure);
-    va_end(args_measure);
+    char *message;
+    size_t initialLen;
+    size_t len;
+    bool result;
 
-    if (needed < 0)
-        return false; // encoding error
+    initialLen = strlen(fmt);
 
-    auto message = std::unique_ptr<char[]>(new char[static_cast<size_t>(needed) + 1]);
-    int written = vsnprintf(message.get(), static_cast<size_t>(needed) + 1, fmt, args);
-    if (written < 0)
-        return false;
+    message = new char[initialLen + 1];
 
-    return this->_sendLog(pri, appName, message.get());
+    len = vsnprintf(message, initialLen + 1, fmt, args);
+    if (len > initialLen) {
+        delete[] message;
+        message = new char[len + 1];
+
+        vsnprintf(message, len + 1, fmt, args);
+    }
+
+    result = this->_sendLog(pri, appName, message);
+
+    delete[] message;
+    return result;
 }
 
 inline bool Syslog::_sendLog(uint16_t pri, const char *appName, const char *message)

src/DebugConfiguration.h

@@ -151,9 +151,8 @@ extern "C" void logLegacy(const char *level, const char *fmt, ...);
 #include <RAK13800_W5100S.h>
 #endif // HAS_ETHERNET
 
-#if HAS_ETHERNET && defined(USE_WS5500)
-#include <ETHClass2.h>
-#define ETH ETH2
+#if HAS_ETHERNET && defined(ARCH_ESP32)
+#include <ETH.h>
 #endif // HAS_ETHERNET
 
 #if HAS_WIFI

src/FSCommon.cpp

@@ -277,7 +277,7 @@ void fsInit()
  */
 void setupSDCard()
 {
-#if defined(HAS_SDCARD) && !defined(SDCARD_USE_SOFT_SPI)
+#if defined(HAS_SDCARD) && !defined(SDCARD_USE_SOFT_SPI) && !defined(HAS_SD_MMC)
     concurrency::LockGuard g(spiLock);
     SDHandler.begin(SPI_SCK, SPI_MISO, SPI_MOSI);
     if (!SD.begin(SDCARD_CS, SDHandler, SD_SPI_FREQUENCY)) {

src/GPSStatus.h

@@ -53,7 +53,8 @@ class GPSStatus : public Status
     int32_t getLatitude() const
     {
         if (config.position.fixed_position) {
-            return localPosition.latitude_i;
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+            return node->position.latitude_i;
         } else {
             return p.latitude_i;
         }
@@ -62,7 +63,8 @@ class GPSStatus : public Status
     int32_t getLongitude() const
     {
         if (config.position.fixed_position) {
-            return localPosition.longitude_i;
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+            return node->position.longitude_i;
         } else {
             return p.longitude_i;
         }
@@ -71,7 +73,8 @@ class GPSStatus : public Status
     int32_t getAltitude() const
     {
         if (config.position.fixed_position) {
-            return localPosition.altitude;
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
+            return node->position.altitude;
         } else {
             return p.altitude;
         }

src/MessageStore.cpp

@@ -6,6 +6,7 @@
 #include "SPILock.h"
 #include "SafeFile.h"
 #include "gps/RTC.h"
+#include "graphics/draw/MessageRenderer.h"
 #include <cstring> // memcpy
 
 #ifndef MESSAGE_TEXT_POOL_SIZE
@@ -180,8 +181,13 @@ const StoredMessage &MessageStore::addFromPacket(const meshtastic_MeshPacket &pa
 
     bool isDM = (sm.dest != 0 && sm.dest != NODENUM_BROADCAST);
 
-    sm.type = isDM ? MessageType::DM_TO_US : MessageType::BROADCAST;
-    sm.ackStatus = (packet.from == 0) ? AckStatus::NONE : AckStatus::ACKED;
+    if (packet.from == 0) {
+        sm.type = isDM ? MessageType::DM_TO_US : MessageType::BROADCAST;
+        sm.ackStatus = AckStatus::NONE;
+    } else {
+        sm.type = isDM ? MessageType::DM_TO_US : MessageType::BROADCAST;
+        sm.ackStatus = AckStatus::ACKED;
+    }
 
     addLiveMessage(sm);
 
@@ -366,25 +372,26 @@ void MessageStore::clearAllMessages()
 #endif
 }
 
-// Internal helpers for targeted erasure.
-template <typename Predicate> static bool eraseFirstMatch(std::deque<StoredMessage> &deque, Predicate pred)
+// Internal helper: erase first or last message matching a predicate
+template <typename Predicate> static void eraseIf(std::deque<StoredMessage> &deque, Predicate pred, bool fromBack = false)
 {
-    for (auto it = deque.begin(); it != deque.end(); ++it) {
-        if (pred(*it)) {
-            deque.erase(it);
-            return true;
+    if (fromBack) {
+        // Iterate from the back and erase all matches from the end
+        for (auto it = deque.rbegin(); it != deque.rend();) {
+            if (pred(*it)) {
+                it = std::deque<StoredMessage>::reverse_iterator(deque.erase(std::next(it).base()));
+            } else {
+                ++it;
+            }
         }
-    }
-    return false;
-}
-
-template <typename Predicate> static void eraseAllMatches(std::deque<StoredMessage> &deque, Predicate pred)
-{
-    for (auto it = deque.begin(); it != deque.end();) {
-        if (pred(*it)) {
-            it = deque.erase(it);
-        } else {
-            ++it;
+    } else {
+        // Manual forward search to erase all matches
+        for (auto it = deque.begin(); it != deque.end();) {
+            if (pred(*it)) {
+                it = deque.erase(it);
+            } else {
+                ++it;
+            }
         }
     }
 }
@@ -392,9 +399,7 @@ template <typename Predicate> static void eraseAllMatches(std::deque<StoredMessa
 // Delete oldest message (RAM + persisted queue)
 void MessageStore::deleteOldestMessage()
 {
-    if (!liveMessages.empty()) {
-        liveMessages.pop_front();
-    }
+    eraseIf(liveMessages, [](StoredMessage &) { return true; });
     saveToFlash();
 }
 
@@ -402,14 +407,14 @@ void MessageStore::deleteOldestMessage()
 void MessageStore::deleteOldestMessageInChannel(uint8_t channel)
 {
     auto pred = [channel](const StoredMessage &m) { return m.type == MessageType::BROADCAST && m.channelIndex == channel; };
-    eraseFirstMatch(liveMessages, pred);
+    eraseIf(liveMessages, pred);
     saveToFlash();
 }
 
 void MessageStore::deleteAllMessagesInChannel(uint8_t channel)
 {
     auto pred = [channel](const StoredMessage &m) { return m.type == MessageType::BROADCAST && m.channelIndex == channel; };
-    eraseAllMatches(liveMessages, pred);
+    eraseIf(liveMessages, pred, false /* delete ALL, not just first */);
     saveToFlash();
 }
 
@@ -422,7 +427,7 @@ void MessageStore::deleteAllMessagesWithPeer(uint32_t peer)
         uint32_t other = (m.sender == local) ? m.dest : m.sender;
         return other == peer;
     };
-    eraseAllMatches(liveMessages, pred);
+    eraseIf(liveMessages, pred, false);
     saveToFlash();
 }
 
@@ -435,7 +440,7 @@ void MessageStore::deleteOldestMessageWithPeer(uint32_t peer)
         uint32_t other = (m.sender == nodeDB->getNodeNum()) ? m.dest : m.sender;
         return other == peer;
     };
-    eraseFirstMatch(liveMessages, pred);
+    eraseIf(liveMessages, pred);
     saveToFlash();
 }
 

src/MessageStore.h

@@ -124,6 +124,9 @@ class MessageStore
     // Allocate text into pool (used by sender-side code)
     static uint16_t storeText(const char *src, size_t len);
 
+    // Used when loading from flash to rebuild the text pool
+    static uint16_t rebuildTextFromFlash(const char *src, size_t len);
+
   private:
     std::deque<StoredMessage> liveMessages; // Single in-RAM message buffer (also used for persistence)
     std::string filename;                   // Flash filename for persistence

src/Power.cpp

@@ -24,6 +24,13 @@
 #include "meshUtils.h"
 #include "power/PowerHAL.h"
 #include "sleep.h"
+#ifdef ARCH_ESP32
+// #include <driver/adc.h>
+#include <esp_adc/adc_cali.h>
+#include <esp_adc/adc_cali_scheme.h>
+#include <esp_adc/adc_oneshot.h>
+#include <esp_err.h>
+#endif
 
 #if defined(ARCH_PORTDUINO)
 #include "api/WiFiServerAPI.h"
@@ -63,9 +70,8 @@
 #include <WiFi.h>
 #endif
 
-#if HAS_ETHERNET && defined(USE_WS5500)
-#include <ETHClass2.h>
-#define ETH ETH2
+#if HAS_ETHERNET && defined(ARCH_ESP32)
+#include <ETH.h>
 #endif // HAS_ETHERNET
 
 #endif
@@ -77,21 +83,86 @@
 #if defined(BATTERY_PIN) && defined(ARCH_ESP32)
 
 #ifndef BAT_MEASURE_ADC_UNIT // ADC1 is default
-static const adc1_channel_t adc_channel = ADC_CHANNEL;
+static const adc_channel_t adc_channel = ADC_CHANNEL;
 static const adc_unit_t unit = ADC_UNIT_1;
-#else // ADC2
-static const adc2_channel_t adc_channel = ADC_CHANNEL;
+#else  // ADC2
+static const adc_channel_t adc_channel = ADC_CHANNEL;
 static const adc_unit_t unit = ADC_UNIT_2;
-RTC_NOINIT_ATTR uint64_t RTC_reg_b;
-
 #endif // BAT_MEASURE_ADC_UNIT
 
-esp_adc_cal_characteristics_t *adc_characs = (esp_adc_cal_characteristics_t *)calloc(1, sizeof(esp_adc_cal_characteristics_t));
+static adc_oneshot_unit_handle_t adc_handle = nullptr;
+static adc_cali_handle_t adc_cali_handle = nullptr;
+static bool adc_calibrated = false;
 #ifndef ADC_ATTENUATION
 static const adc_atten_t atten = ADC_ATTEN_DB_12;
 #else
 static const adc_atten_t atten = ADC_ATTENUATION;
 #endif
+#ifdef ADC_BITWIDTH
+static const adc_bitwidth_t adc_width = ADC_BITWIDTH;
+#else
+static const adc_bitwidth_t adc_width = ADC_BITWIDTH_DEFAULT;
+#endif
+
+static int adcBitWidthToBits(adc_bitwidth_t width)
+{
+    switch (width) {
+    case ADC_BITWIDTH_9:
+        return 9;
+    case ADC_BITWIDTH_10:
+        return 10;
+    case ADC_BITWIDTH_11:
+        return 11;
+    case ADC_BITWIDTH_12:
+        return 12;
+#ifdef ADC_BITWIDTH_13
+    case ADC_BITWIDTH_13:
+        return 13;
+#endif
+    default:
+        return 12;
+    }
+}
+
+static bool initAdcCalibration()
+{
+#if ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED
+    adc_cali_curve_fitting_config_t cali_config = {
+        .unit_id = unit,
+        .atten = atten,
+        .bitwidth = adc_width,
+    };
+    esp_err_t ret = adc_cali_create_scheme_curve_fitting(&cali_config, &adc_cali_handle);
+    if (ret == ESP_OK) {
+        LOG_INFO("ADC calibration: curve fitting enabled");
+        return true;
+    }
+    if (ret != ESP_ERR_NOT_SUPPORTED) {
+        LOG_WARN("ADC calibration: curve fitting failed: %s", esp_err_to_name(ret));
+    }
+#endif
+
+#if ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED
+    adc_cali_line_fitting_config_t cali_config = {
+        .unit_id = unit,
+        .atten = atten,
+        .bitwidth = adc_width,
+        .default_vref = DEFAULT_VREF,
+    };
+    esp_err_t ret = adc_cali_create_scheme_line_fitting(&cali_config, &adc_cali_handle);
+    if (ret == ESP_OK) {
+        LOG_INFO("ADC calibration: line fitting enabled");
+        return true;
+    }
+    if (ret != ESP_ERR_NOT_SUPPORTED) {
+        LOG_WARN("ADC calibration: line fitting failed: %s", esp_err_to_name(ret));
+    }
+#endif
+
+    LOG_INFO("ADC calibration not supported; using approximate scaling");
+    return false;
+}
+
 #endif // BATTERY_PIN && ARCH_ESP32
 
 #ifdef EXT_PWR_DETECT
@@ -367,8 +438,20 @@ class AnalogBatteryLevel : public HasBatteryLevel
             scaled *= operativeAdcMultiplier;
 #elif defined(ARCH_ESP32) // ADC block for espressif platforms
             raw = espAdcRead();
-            scaled = esp_adc_cal_raw_to_voltage(raw, adc_characs);
-            scaled *= operativeAdcMultiplier;
+            int voltage_mv = 0;
+            if (adc_calibrated && adc_cali_handle) {
+                if (adc_cali_raw_to_voltage(adc_cali_handle, raw, &voltage_mv) != ESP_OK) {
+                    LOG_WARN("ADC calibration read failed; using raw value");
+                    voltage_mv = 0;
+                }
+            }
+            if (voltage_mv == 0) {
+                // Fallback approximate conversion without calibration
+                const int bits = adcBitWidthToBits(adc_width);
+                const float max_code = powf(2.0f, bits) - 1.0f;
+                voltage_mv = (int)((raw / max_code) * DEFAULT_VREF);
+            }
+            scaled = voltage_mv * operativeAdcMultiplier;
 #else                     // block for all other platforms
 #ifdef ARCH_NRF52
             concurrency::LockGuard saadcGuard(concurrency::nrf52SaadcLock);
@@ -410,51 +493,22 @@ class AnalogBatteryLevel : public HasBatteryLevel
         uint32_t raw = 0;
         uint8_t raw_c = 0; // raw reading counter
 
-#ifndef BAT_MEASURE_ADC_UNIT // ADC1
+        if (!adc_handle) {
+            LOG_ERROR("ADC oneshot handle not initialized");
+            return 0;
+        }
+
         for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
-            int val_ = adc1_get_raw(adc_channel);
-            if (val_ >= 0) { // save only valid readings
-                raw += val_;
+            int val = 0;
+            esp_err_t err = adc_oneshot_read(adc_handle, adc_channel, &val);
+            if (err == ESP_OK) {
+                raw += val;
                 raw_c++;
-            }
-            // delayMicroseconds(100);
-        }
-#else                            // ADC2
-#ifdef CONFIG_IDF_TARGET_ESP32S3 // ESP32S3
-        // ADC2 wifi bug workaround not required, breaks compile
-        // On ESP32S3, ADC2 can take turns with Wifi (?)
-
-        int32_t adc_buf;
-        esp_err_t read_result;
-
-        // Multiple samples
-        for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
-            adc_buf = 0;
-            read_result = -1;
-
-            read_result = adc2_get_raw(adc_channel, ADC_WIDTH_BIT_12, &adc_buf);
-            if (read_result == ESP_OK) {
-                raw += adc_buf;
-                raw_c++; // Count valid samples
             } else {
-                LOG_DEBUG("An attempt to sample ADC2 failed");
+                LOG_DEBUG("ADC read failed: %s", esp_err_to_name(err));
             }
         }
 
-#else  // Other ESP32
-        int32_t adc_buf = 0;
-        for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
-            // ADC2 wifi bug workaround, see
-            // https://github.com/espressif/arduino-esp32/issues/102
-            WRITE_PERI_REG(SENS_SAR_READ_CTRL2_REG, RTC_reg_b);
-            SET_PERI_REG_MASK(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_DATA_INV);
-            adc2_get_raw(adc_channel, ADC_WIDTH_BIT_12, &adc_buf);
-            raw += adc_buf;
-            raw_c++;
-        }
-#endif // BAT_MEASURE_ADC_UNIT
-
-#endif // End BAT_MEASURE_ADC_UNIT
         return (raw / (raw_c < 1 ? 1 : raw_c));
     }
 #endif
@@ -666,42 +720,31 @@ bool Power::analogInit()
 #ifdef ARCH_STM32WL
     analogReadResolution(BATTERY_SENSE_RESOLUTION_BITS);
 #elif defined(ARCH_ESP32) // ESP32 needs special analog stuff
+    adc_oneshot_unit_init_cfg_t init_config = {
+        .unit_id = unit,
+    };
 
-#ifndef ADC_WIDTH // max resolution by default
-    static const adc_bits_width_t width = ADC_WIDTH_BIT_12;
-#else
-    static const adc_bits_width_t width = ADC_WIDTH;
-#endif
-#ifndef BAT_MEASURE_ADC_UNIT // ADC1
-    adc1_config_width(width);
-    adc1_config_channel_atten(adc_channel, atten);
-#else                        // ADC2
-    adc2_config_channel_atten(adc_channel, atten);
-#ifndef CONFIG_IDF_TARGET_ESP32S3
-    // ADC2 wifi bug workaround
-    // Not required with ESP32S3, breaks compile
-    RTC_reg_b = READ_PERI_REG(SENS_SAR_READ_CTRL2_REG);
-#endif
-#endif
-    // calibrate ADC
-    esp_adc_cal_value_t val_type = esp_adc_cal_characterize(unit, atten, width, DEFAULT_VREF, adc_characs);
-    // show ADC characterization base
-    if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP) {
-        LOG_INFO("ADC config based on Two Point values stored in eFuse");
-    } else if (val_type == ESP_ADC_CAL_VAL_EFUSE_VREF) {
-        LOG_INFO("ADC config based on reference voltage stored in eFuse");
+    if (!adc_handle) {
+        esp_err_t err = adc_oneshot_new_unit(&init_config, &adc_handle);
+        if (err != ESP_OK) {
+            LOG_ERROR("ADC oneshot init failed: %s", esp_err_to_name(err));
+            return false;
+        }
     }
-#ifdef CONFIG_IDF_TARGET_ESP32S3
-    // ESP32S3
-    else if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP_FIT) {
-        LOG_INFO("ADC config based on Two Point values and fitting curve "
-                 "coefficients stored in eFuse");
+
+    adc_oneshot_chan_cfg_t chan_cfg = {
+        .atten = atten,
+        .bitwidth = adc_width,
+    };
+
+    esp_err_t err = adc_oneshot_config_channel(adc_handle, adc_channel, &chan_cfg);
+    if (err != ESP_OK) {
+        LOG_ERROR("ADC channel config failed: %s", esp_err_to_name(err));
+        return false;
     }
-#endif
-    else {
-        LOG_INFO("ADC config based on default reference voltage");
-    }
-#endif // ARCH_ESP32
+
+    adc_calibrated = initAdcCalibration();
+#endif                    // ARCH_ESP32
 
     // NRF52 ADC init moved to powerHAL_init in nrf52 platform
 

src/RedirectablePrint.cpp

@@ -222,7 +222,7 @@ void RedirectablePrint::log_to_ble(const char *logLevel, const char *format, va_
     if (config.security.debug_log_api_enabled && !pauseBluetoothLogging) {
         bool isBleConnected = false;
 #ifdef ARCH_ESP32
-        isBleConnected = nimbleBluetooth && nimbleBluetooth->isActive() && nimbleBluetooth->isConnected();
+        isBleConnected = bluetoothApi && bluetoothApi->isActive() && bluetoothApi->isConnected();
 #elif defined(ARCH_NRF52)
         isBleConnected = nrf52Bluetooth != nullptr && nrf52Bluetooth->isConnected();
 #endif
@@ -238,7 +238,7 @@ void RedirectablePrint::log_to_ble(const char *logLevel, const char *format, va_
             auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[meshtastic_LogRecord_size]);
             size_t size = pb_encode_to_bytes(buffer.get(), meshtastic_LogRecord_size, meshtastic_LogRecord_fields, &logRecord);
 #ifdef ARCH_ESP32
-            nimbleBluetooth->sendLog(buffer.get(), size);
+            bluetoothApi->sendLog(buffer.get(), size);
 #elif defined(ARCH_NRF52)
             nrf52Bluetooth->sendLog(buffer.get(), size);
 #endif

src/bluetooth/HostedBluetooth.cpp

@@ -0,0 +1,762 @@
+#include "configuration.h"
+
+#if defined(CONFIG_IDF_TARGET_ESP32P4) && defined(CONFIG_ESP_HOSTED_ENABLED) && !MESHTASTIC_EXCLUDE_BLUETOOTH
+#include "BluetoothStatus.h"
+#include "PowerFSM.h"
+#include "bluetooth/HostedBluetooth.h"
+#include "concurrency/OSThread.h"
+#include "esp32-hal-hosted.h"
+#include "esp_err.h"
+#include "esp_event.h"
+#include "esp_hosted.h"
+#include "esp_hosted_event.h"
+#include "main.h"
+#include "mesh/PhoneAPI.h"
+#include "mesh/mesh-pb-constants.h"
+#include <BLEAdvertising.h>
+#include <BLEDevice.h>
+#include <BLESecurity.h>
+#include <BLEServer.h>
+#include <BLEUtils.h>
+#include <array>
+#include <atomic>
+#include <climits>
+#include <cstring>
+#include <driver/gpio.h>
+#include <mutex>
+
+#include "host/ble_gap.h"
+#include "host/ble_store.h"
+
+namespace
+{
+/*
+ * Maintainer note: HostedBluetooth intentionally stays close to NimbleBluetooth
+ * but is not a strict drop-in equivalent.
+ *
+ * Intentional differences from NimbleBluetooth include:
+ * - ESP-Hosted transport lifecycle handling (event callbacks + CP reset GPIO control).
+ * - Data-length update behavior (Hosted currently requests ble_gap_set_data_len on connect).
+ * - No Battery Service exposure here.
+ *
+ * If you modify common BLE flow in one class, review and likely mirror in both:
+ * - PhoneAPI queueing/synchronization between BLE callbacks and runOnce().
+ * - Security/pairing config and passkey UX/status updates.
+ * - Mesh GATT characteristics, permissions, and advertising setup.
+ * - Connection parameter tuning and reconnect/disconnect cleanup paths.
+ */
+constexpr uint16_t kPreferredBleMtu = 517;
+constexpr uint16_t kPreferredBleTxOctets = 251;
+constexpr uint16_t kPreferredBleTxTimeUs = (kPreferredBleTxOctets + 14) * 8;
+constexpr size_t kBluetoothToPhoneQueueSize = 3;
+constexpr size_t kBluetoothFromPhoneQueueSize = 3;
+
+BLECharacteristic *fromNumCharacteristic = nullptr;
+BLECharacteristic *logRadioCharacteristic = nullptr;
+BLEServer *bleServer = nullptr;
+
+static bool passkeyShowing = false;
+std::atomic<uint16_t> hostedConnHandle{BLE_HS_CONN_HANDLE_NONE};
+
+void clearPairingDisplay()
+{
+    if (!passkeyShowing) {
+        return;
+    }
+
+    passkeyShowing = false;
+#if HAS_SCREEN
+    if (screen) {
+        screen->endAlert();
+    }
+#endif
+}
+
+class HostedBluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
+{
+  public:
+    HostedBluetoothPhoneAPI() : concurrency::OSThread("HostedBluetooth") { api_type = TYPE_BLE; }
+
+    std::mutex fromPhoneMutex;
+    std::atomic<size_t> fromPhoneQueueSize{0};
+    std::array<BLEValue, kBluetoothFromPhoneQueueSize> fromPhoneQueue{};
+
+    std::mutex toPhoneMutex;
+    std::atomic<size_t> toPhoneQueueSize{0};
+    std::array<std::array<uint8_t, meshtastic_FromRadio_size>, kBluetoothToPhoneQueueSize> toPhoneQueue{};
+    std::array<size_t, kBluetoothToPhoneQueueSize> toPhoneQueueByteSizes{};
+    std::atomic<bool> onReadCallbackIsWaitingForData{false};
+
+  protected:
+    int32_t runOnce() override
+    {
+        while (fromPhoneQueueSize > 0 || onReadCallbackIsWaitingForData) {
+            runOnceHandleFromPhoneQueue();
+            runOnceHandleToPhoneQueue();
+        }
+        return INT32_MAX;
+    }
+
+    void onNowHasData(uint32_t fromRadioNum) override
+    {
+        PhoneAPI::onNowHasData(fromRadioNum);
+
+        if (!fromNumCharacteristic || !bleServer || bleServer->getConnectedCount() == 0) {
+            return;
+        }
+
+        uint8_t val[4];
+        put_le32(val, fromRadioNum);
+        fromNumCharacteristic->setValue(val, sizeof(val));
+        fromNumCharacteristic->notify();
+    }
+
+    bool checkIsConnected() override { return bleServer && bleServer->getConnectedCount() > 0; }
+
+  private:
+    void runOnceHandleToPhoneQueue()
+    {
+        if (!onReadCallbackIsWaitingForData) {
+            return;
+        }
+
+        uint8_t fromRadioBytes[meshtastic_FromRadio_size] = {0};
+        size_t numBytes = getFromRadio(fromRadioBytes);
+
+        if (numBytes > 0 && toPhoneQueueSize < kBluetoothToPhoneQueueSize) {
+            std::lock_guard<std::mutex> guard(toPhoneMutex);
+            const size_t storeAtIndex = toPhoneQueueSize.load();
+            memcpy(toPhoneQueue[storeAtIndex].data(), fromRadioBytes, numBytes);
+            toPhoneQueueByteSizes[storeAtIndex] = numBytes;
+            toPhoneQueueSize++;
+        }
+
+        onReadCallbackIsWaitingForData = false;
+    }
+
+    void runOnceHandleFromPhoneQueue()
+    {
+        if (fromPhoneQueueSize == 0) {
+            return;
+        }
+
+        BLEValue val;
+        {
+            std::lock_guard<std::mutex> guard(fromPhoneMutex);
+            val = fromPhoneQueue[0];
+            for (size_t i = 1; i < fromPhoneQueueSize; ++i) {
+                fromPhoneQueue[i - 1] = fromPhoneQueue[i];
+            }
+            fromPhoneQueueSize--;
+        }
+
+        handleToRadio(val.getData(), val.getLength());
+    }
+};
+
+static HostedBluetoothPhoneAPI *bluetoothPhoneAPI = nullptr;
+uint8_t lastToRadio[MAX_TO_FROM_RADIO_SIZE] = {0};
+
+class HostedBluetoothToRadioCallback : public BLECharacteristicCallbacks
+{
+  public:
+    void onWrite(BLECharacteristic *pCharacteristic) override
+    {
+        if (!bluetoothPhoneAPI) {
+            return;
+        }
+
+        BLEValue val;
+        val.setValue(pCharacteristic->getData(), pCharacteristic->getLength());
+
+        if (memcmp(lastToRadio, val.getData(), val.getLength()) == 0) {
+            return;
+        }
+
+        if (bluetoothPhoneAPI->fromPhoneQueueSize >= kBluetoothFromPhoneQueueSize) {
+            LOG_WARN("Hosted BLE onWrite drop: queue full (%u bytes)", val.getLength());
+            return;
+        }
+
+        memcpy(lastToRadio, val.getData(), val.getLength());
+
+        {
+            std::lock_guard<std::mutex> guard(bluetoothPhoneAPI->fromPhoneMutex);
+            bluetoothPhoneAPI->fromPhoneQueue.at(bluetoothPhoneAPI->fromPhoneQueueSize) = val;
+            bluetoothPhoneAPI->fromPhoneQueueSize++;
+        }
+
+        bluetoothPhoneAPI->setIntervalFromNow(0);
+        concurrency::mainDelay.interrupt();
+    }
+};
+
+class HostedBluetoothFromRadioCallback : public BLECharacteristicCallbacks
+{
+  public:
+    void onRead(BLECharacteristic *pCharacteristic) override
+    {
+        if (!bluetoothPhoneAPI) {
+            return;
+        }
+
+        if (bluetoothPhoneAPI->toPhoneQueueSize == 0) {
+            bluetoothPhoneAPI->onReadCallbackIsWaitingForData = true;
+            bluetoothPhoneAPI->setIntervalFromNow(0);
+            concurrency::mainDelay.interrupt();
+
+            int tries = 0;
+            while (bluetoothPhoneAPI->onReadCallbackIsWaitingForData && tries < 4000) {
+                delay(tries < 20 ? 1 : 5);
+                tries++;
+                if (tries == 4000) {
+                    LOG_WARN("BLE onRead: timeout waiting for data after %d tries, giving up and returning 0-size response",
+                             tries);
+                }
+            }
+        }
+
+        uint8_t fromRadioBytes[meshtastic_FromRadio_size] = {0};
+        size_t numBytes = 0;
+
+        {
+            std::lock_guard<std::mutex> guard(bluetoothPhoneAPI->toPhoneMutex);
+            size_t pending = bluetoothPhoneAPI->toPhoneQueueSize.load();
+            if (pending > 0) {
+                numBytes = bluetoothPhoneAPI->toPhoneQueueByteSizes[0];
+                memcpy(fromRadioBytes, bluetoothPhoneAPI->toPhoneQueue[0].data(), numBytes);
+
+                for (size_t i = 1; i < pending; ++i) {
+                    memcpy(bluetoothPhoneAPI->toPhoneQueue[i - 1].data(), bluetoothPhoneAPI->toPhoneQueue[i].data(),
+                           bluetoothPhoneAPI->toPhoneQueueByteSizes[i]);
+                    bluetoothPhoneAPI->toPhoneQueueByteSizes[i - 1] = bluetoothPhoneAPI->toPhoneQueueByteSizes[i];
+                }
+
+                bluetoothPhoneAPI->toPhoneQueueSize--;
+            }
+        }
+
+        pCharacteristic->setValue(fromRadioBytes, numBytes);
+    }
+};
+
+class HostedBluetoothServerCallback : public BLEServerCallbacks
+{
+  public:
+    explicit HostedBluetoothServerCallback(HostedBluetooth *owner) : owner(owner) {}
+
+  private:
+    HostedBluetooth *owner;
+
+    void onConnect(BLEServer *pServer, struct ble_gap_conn_desc *desc) override
+    {
+        BLEAddress peerAddr(desc->peer_id_addr);
+        LOG_INFO("Hosted BLE incoming connection %s", peerAddr.toString().c_str());
+        owner->setConnected(true);
+        hostedConnHandle = desc->conn_handle;
+
+        const int dataLenResult = ble_gap_set_data_len(desc->conn_handle, kPreferredBleTxOctets, kPreferredBleTxTimeUs);
+        if (dataLenResult != 0) {
+            LOG_WARN("Hosted BLE failed to raise data length rc=%d", dataLenResult);
+        }
+
+        pServer->updateConnParams(desc->conn_handle, 6, 12, 0, 200);
+    }
+
+    void onDisconnect(BLEServer *pServer, struct ble_gap_conn_desc *desc) override
+    {
+        (void)pServer;
+        (void)desc;
+        LOG_INFO("Hosted BLE disconnected");
+        owner->setConnected(false);
+        meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::DISCONNECTED);
+        bluetoothStatus->updateStatus(&newStatus);
+        clearPairingDisplay();
+        hostedConnHandle = BLE_HS_CONN_HANDLE_NONE;
+        memset(lastToRadio, 0, sizeof(lastToRadio));
+
+        if (bluetoothPhoneAPI) {
+            bluetoothPhoneAPI->close();
+            {
+                std::lock_guard<std::mutex> guard(bluetoothPhoneAPI->fromPhoneMutex);
+                bluetoothPhoneAPI->fromPhoneQueueSize = 0;
+            }
+            {
+                std::lock_guard<std::mutex> guard(bluetoothPhoneAPI->toPhoneMutex);
+                bluetoothPhoneAPI->toPhoneQueueSize = 0;
+            }
+            bluetoothPhoneAPI->onReadCallbackIsWaitingForData = false;
+        }
+
+        owner->startAdvertising();
+    }
+};
+
+class HostedBluetoothSecurityCallback : public BLESecurityCallbacks
+{
+  public:
+    void onPassKeyNotify(uint32_t passkey) override
+    {
+        LOG_INFO("*** Enter passkey %06u on the peer side ***", passkey);
+        powerFSM.trigger(EVENT_BLUETOOTH_PAIR);
+
+        meshtastic::BluetoothStatus newStatus(std::to_string(passkey));
+        bluetoothStatus->updateStatus(&newStatus);
+
+#if HAS_SCREEN
+        if (screen) {
+            screen->startAlert([passkey](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
+                char btPIN[16] = "888888";
+                snprintf(btPIN, sizeof(btPIN), "%06u", passkey);
+                int x_offset = display->width() / 2;
+                int y_offset = display->height() <= 80 ? 0 : 12;
+                display->setTextAlignment(TEXT_ALIGN_CENTER);
+                display->setFont(FONT_MEDIUM);
+                display->drawString(x_offset + x, y_offset + y, "Bluetooth");
+#if !defined(M5STACK_UNITC6L)
+                display->setFont(FONT_SMALL);
+                y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_MEDIUM - 4 : y_offset + FONT_HEIGHT_MEDIUM + 5;
+                display->drawString(x_offset + x, y_offset + y, "Enter this code");
+#endif
+                display->setFont(FONT_LARGE);
+                char pin[8];
+                snprintf(pin, sizeof(pin), "%.3s %.3s", btPIN, btPIN + 3);
+                y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_SMALL - 5 : y_offset + FONT_HEIGHT_SMALL + 5;
+                display->drawString(x_offset + x, y_offset + y, pin);
+
+                display->setFont(FONT_SMALL);
+                char deviceName[64];
+                snprintf(deviceName, sizeof(deviceName), "Name: %s", getDeviceName());
+                y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_LARGE - 6 : y_offset + FONT_HEIGHT_LARGE + 5;
+                display->drawString(x_offset + x, y_offset + y, deviceName);
+            });
+        }
+#endif
+
+        passkeyShowing = true;
+    }
+
+    void onAuthenticationComplete(ble_gap_conn_desc *desc) override
+    {
+        (void)desc;
+        LOG_INFO("Hosted BLE authentication complete");
+
+        meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::CONNECTED);
+        bluetoothStatus->updateStatus(&newStatus);
+        clearPairingDisplay();
+    }
+};
+
+HostedBluetoothToRadioCallback *toRadioCallbacks = nullptr;
+HostedBluetoothFromRadioCallback *fromRadioCallbacks = nullptr;
+HostedBluetoothSecurityCallback *securityCallbacks = nullptr;
+
+gpio_num_t getSlaveResetGpio()
+{
+#if defined(CONFIG_ESP_HOSTED_GPIO_SLAVE_RESET_SLAVE)
+    return static_cast<gpio_num_t>(CONFIG_ESP_HOSTED_GPIO_SLAVE_RESET_SLAVE);
+#elif defined(CONFIG_ESP_HOSTED_SDIO_GPIO_RESET_SLAVE)
+    return static_cast<gpio_num_t>(CONFIG_ESP_HOSTED_SDIO_GPIO_RESET_SLAVE);
+#else
+    return GPIO_NUM_NC;
+#endif
+}
+
+void setSlaveResetLine(bool assertReset)
+{
+    const gpio_num_t gpioNum = getSlaveResetGpio();
+    if (gpioNum == GPIO_NUM_NC || gpioNum < 0) {
+        return;
+    }
+
+    if (gpio_reset_pin(gpioNum) != ESP_OK) {
+        return;
+    }
+    if (gpio_set_direction(gpioNum, GPIO_MODE_OUTPUT) != ESP_OK) {
+        return;
+    }
+
+    const int activeLevel =
+#if defined(CONFIG_ESP_HOSTED_SDIO_RESET_ACTIVE_HIGH)
+        1;
+#else
+        0;
+#endif
+    const int inactiveLevel = activeLevel ? 0 : 1;
+
+    gpio_set_level(gpioNum, assertReset ? activeLevel : inactiveLevel);
+    LOG_DEBUG("[HostedBluetooth] setSlaveResetLine: GPIO[%d] -> %d (assertReset=%d, activeLevel=%d)", gpioNum,
+              assertReset ? activeLevel : inactiveLevel, assertReset, activeLevel);
+}
+
+void hostedEventHandler(void *arg, esp_event_base_t eventBase, int32_t eventId, void *eventData)
+{
+    (void)eventData;
+
+    auto *self = static_cast<HostedBluetooth *>(arg);
+    if (!self || eventBase != ESP_HOSTED_EVENT) {
+        return;
+    }
+
+    switch (eventId) {
+    case ESP_HOSTED_EVENT_TRANSPORT_UP:
+        LOG_INFO("ESP-Hosted transport is up");
+        self->setConnected(true);
+        break;
+    case ESP_HOSTED_EVENT_TRANSPORT_DOWN:
+        LOG_WARN("ESP-Hosted transport is down");
+        [[fallthrough]];
+    case ESP_HOSTED_EVENT_TRANSPORT_FAILURE:
+        if (eventId == ESP_HOSTED_EVENT_TRANSPORT_FAILURE) {
+            LOG_ERROR("ESP-Hosted transport failure");
+        }
+        self->setConnected(false);
+        break;
+    case ESP_HOSTED_EVENT_CP_INIT:
+    case ESP_HOSTED_EVENT_CP_HEARTBEAT:
+    default:
+        break;
+    }
+}
+} // namespace
+
+HostedBluetooth::HostedBluetooth() {}
+
+HostedBluetooth::~HostedBluetooth()
+{
+    deinit();
+}
+
+bool HostedBluetooth::registerCallbacks()
+{
+    if (callbacksRegistered) {
+        return true;
+    }
+
+    // Defensive cleanup in case setup() is called again after an incomplete/early previous init.
+    // esp_event_handler_unregister can safely fail if the handler wasn't present.
+    esp_event_handler_unregister(ESP_HOSTED_EVENT, ESP_EVENT_ANY_ID, hostedEventHandler);
+
+    esp_err_t err = esp_event_handler_register(ESP_HOSTED_EVENT, ESP_EVENT_ANY_ID, hostedEventHandler, this);
+    if (err != ESP_OK && err != ESP_ERR_INVALID_STATE) {
+        LOG_ERROR("Failed to register hosted event handler: %s", esp_err_to_name(err));
+        return false;
+    }
+    if (err == ESP_ERR_INVALID_STATE) {
+        LOG_WARN("Hosted event handler already registered, continuing");
+    }
+
+    callbacksRegistered = true;
+    return true;
+}
+
+void HostedBluetooth::unregisterCallbacks()
+{
+    if (!callbacksRegistered) {
+        return;
+    }
+
+    esp_event_handler_unregister(ESP_HOSTED_EVENT, ESP_EVENT_ANY_ID, hostedEventHandler);
+
+    callbacksRegistered = false;
+}
+
+void HostedBluetooth::setup()
+{
+    if (active) {
+        return;
+    }
+
+    // Ensure co-processor is released from reset before bringing transport back up.
+    setSlaveResetLine(false);
+    LOG_DEBUG("[HostedBluetooth] setup(): Released co-processor from reset");
+
+    if (!registerCallbacks()) {
+        return;
+    }
+
+    active = setupGatt();
+    firstRssiLogged.store(false);
+    if (active) {
+        LOG_INFO("ESP-Hosted Bluetooth ready");
+    } else {
+        LOG_ERROR("Hosted BLE setup failed in hosted mode");
+        deinit();
+    }
+}
+
+void HostedBluetooth::shutdown()
+{
+    deinit();
+}
+
+void HostedBluetooth::deinit()
+{
+    if (!active && !callbacksRegistered) {
+        return;
+    }
+
+    shutdownGatt();
+    if (BLEDevice::getInitialized()) {
+        BLEDevice::deinit(false);
+    } else {
+        hostedDeinitBLE();
+    }
+
+    // Hold co-processor in reset when hosted transport is disabled to reduce idle draw.
+    setSlaveResetLine(true);
+
+    unregisterCallbacks();
+
+    connected.store(false);
+    active = false;
+    rssi.store(0);
+    firstRssiLogged.store(false);
+}
+
+void HostedBluetooth::clearBonds()
+{
+    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_PEER_SEC, nullptr);
+    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_CCCD, nullptr);
+}
+
+bool HostedBluetooth::isActive()
+{
+    return active;
+}
+
+bool HostedBluetooth::isConnected()
+{
+    if (!connected.load()) {
+        return false;
+    }
+    return bleServer && bleServer->getConnectedCount() > 0;
+}
+
+int HostedBluetooth::getRssi()
+{
+    if (!bleServer || !isConnected()) {
+        return 0;
+    }
+
+    uint16_t connHandle = hostedConnHandle.load();
+    if (connHandle == BLE_HS_CONN_HANDLE_NONE) {
+        const auto peers = bleServer->getPeerDevices(true);
+        if (!peers.empty()) {
+            connHandle = peers.begin()->first;
+            hostedConnHandle = connHandle;
+        }
+    }
+    if (connHandle == BLE_HS_CONN_HANDLE_NONE) {
+        return 0;
+    }
+
+    int8_t currentRssi = 0;
+    const int rc = ble_gap_conn_rssi(connHandle, &currentRssi);
+    if (rc == 0) {
+        setRssi(currentRssi);
+        return currentRssi;
+    }
+
+    return rssi.load();
+}
+
+void HostedBluetooth::sendLog(const uint8_t *logMessage, size_t length)
+{
+    if (!logRadioCharacteristic || !isConnected() || length > 512) {
+        return;
+    }
+
+    logRadioCharacteristic->setValue(logMessage, length);
+    logRadioCharacteristic->notify();
+}
+
+void HostedBluetooth::setConnected(bool value)
+{
+    connected.store(value);
+}
+
+void HostedBluetooth::setRssi(int value)
+{
+    rssi.store(value);
+    maybeLogFirstRssi(value);
+}
+
+void HostedBluetooth::maybeLogFirstRssi(int value)
+{
+    bool expected = false;
+    if (firstRssiLogged.compare_exchange_strong(expected, true)) {
+        LOG_INFO("ESP-Hosted first RSSI update: %d dBm", value);
+    }
+}
+
+bool HostedBluetooth::setupGatt()
+{
+    memset(lastToRadio, 0, sizeof(lastToRadio));
+    hostedConnHandle = BLE_HS_CONN_HANDLE_NONE;
+
+    if (!BLEDevice::init(getDeviceName())) {
+        LOG_ERROR("Hosted BLE init failed");
+        return false;
+    }
+#ifdef ESP_PWR_LVL_P9
+    BLEDevice::setPower(ESP_PWR_LVL_P9);
+#endif
+
+    BLESecurity *security = new BLESecurity();
+    security->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
+    security->setRespEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
+    if (config.bluetooth.mode != meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
+        security->setCapability(ESP_IO_CAP_OUT);
+        if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN) {
+            LOG_INFO("Hosted BLE using random passkey");
+            security->setPassKey(false);
+        } else {
+            LOG_INFO("Hosted BLE using fixed passkey");
+            security->setPassKey(true, config.bluetooth.fixed_pin);
+        }
+        // Enable authorization requirements:
+        // - bonding: true (for persistent storage of the keys)
+        // - MITM: true (enables Man-In-The-Middle protection for password prompts)
+        // - secure connection: true (enables secure connection for encryption)
+        security->setAuthenticationMode(true, true, true);
+    } else {
+        security->setCapability(ESP_IO_CAP_NONE);
+        security->setAuthenticationMode(true, false, false);
+    }
+
+    if (!securityCallbacks) {
+        securityCallbacks = new HostedBluetoothSecurityCallback();
+    }
+    BLEDevice::setSecurityCallbacks(securityCallbacks);
+
+    const int mtuResult = BLEDevice::setMTU(kPreferredBleMtu);
+    if (mtuResult == 0) {
+        LOG_INFO("Hosted BLE MTU request set to %u", kPreferredBleMtu);
+    } else {
+        LOG_WARN("Hosted BLE unable to request MTU %u, rc=%d", kPreferredBleMtu, mtuResult);
+    }
+
+    bleServer = BLEDevice::createServer();
+    if (!bleServer) {
+        LOG_ERROR("Hosted BLE createServer failed");
+        return false;
+    }
+
+    const int nameRc = ble_svc_gap_device_name_set(BLEDevice::getDeviceName().c_str());
+    if (nameRc != 0) {
+        LOG_WARN("Hosted BLE device_name_set rc=%d %s", nameRc, BLEUtils::returnCodeToString(nameRc));
+    }
+
+    bleServer->setCallbacks(new HostedBluetoothServerCallback(this));
+
+    BLEService *meshService = bleServer->createService(MESH_SERVICE_UUID);
+    if (!meshService) {
+        LOG_ERROR("Hosted BLE mesh service creation failed");
+        return false;
+    }
+
+    BLECharacteristic *toRadioCharacteristic = nullptr;
+    BLECharacteristic *fromRadioCharacteristic = nullptr;
+    if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
+        toRadioCharacteristic = meshService->createCharacteristic(TORADIO_UUID, BLECharacteristic::PROPERTY_WRITE);
+        fromRadioCharacteristic = meshService->createCharacteristic(FROMRADIO_UUID, BLECharacteristic::PROPERTY_READ);
+        fromNumCharacteristic = meshService->createCharacteristic(FROMNUM_UUID, BLECharacteristic::PROPERTY_NOTIFY |
+                                                                                    BLECharacteristic::PROPERTY_READ);
+        logRadioCharacteristic = meshService->createCharacteristic(LOGRADIO_UUID, BLECharacteristic::PROPERTY_NOTIFY |
+                                                                                      BLECharacteristic::PROPERTY_READ);
+    } else {
+        toRadioCharacteristic = meshService->createCharacteristic(TORADIO_UUID, BLECharacteristic::PROPERTY_WRITE |
+                                                                                    BLECharacteristic::PROPERTY_WRITE_AUTHEN |
+                                                                                    BLECharacteristic::PROPERTY_WRITE_ENC);
+        fromRadioCharacteristic = meshService->createCharacteristic(FROMRADIO_UUID, BLECharacteristic::PROPERTY_READ |
+                                                                                        BLECharacteristic::PROPERTY_READ_AUTHEN |
+                                                                                        BLECharacteristic::PROPERTY_READ_ENC);
+        fromNumCharacteristic = meshService->createCharacteristic(
+            FROMNUM_UUID, BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_READ |
+                              BLECharacteristic::PROPERTY_READ_AUTHEN | BLECharacteristic::PROPERTY_READ_ENC);
+        logRadioCharacteristic = meshService->createCharacteristic(
+            LOGRADIO_UUID, BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_READ |
+                               BLECharacteristic::PROPERTY_READ_AUTHEN | BLECharacteristic::PROPERTY_READ_ENC);
+    }
+
+    if (!toRadioCharacteristic || !fromRadioCharacteristic || !fromNumCharacteristic || !logRadioCharacteristic) {
+        LOG_ERROR("Hosted BLE characteristic creation failed");
+        return false;
+    }
+
+    if (!bluetoothPhoneAPI) {
+        bluetoothPhoneAPI = new HostedBluetoothPhoneAPI();
+    }
+
+    if (!toRadioCallbacks) {
+        toRadioCallbacks = new HostedBluetoothToRadioCallback();
+    }
+    if (!fromRadioCallbacks) {
+        fromRadioCallbacks = new HostedBluetoothFromRadioCallback();
+    }
+
+    toRadioCharacteristic->setCallbacks(toRadioCallbacks);
+    fromRadioCharacteristic->setCallbacks(fromRadioCallbacks);
+    meshService->start();
+
+    startAdvertising();
+    return true;
+}
+
+void HostedBluetooth::shutdownGatt()
+{
+    if (bluetoothPhoneAPI) {
+        bluetoothPhoneAPI->close();
+        delete bluetoothPhoneAPI;
+        bluetoothPhoneAPI = nullptr;
+    }
+
+    delete toRadioCallbacks;
+    toRadioCallbacks = nullptr;
+
+    delete fromRadioCallbacks;
+    fromRadioCallbacks = nullptr;
+
+    delete securityCallbacks;
+    securityCallbacks = nullptr;
+
+    if (bleServer) {
+        BLEAdvertising *advertising = BLEDevice::getAdvertising();
+        if (advertising) {
+            advertising->stop();
+        }
+    }
+
+    fromNumCharacteristic = nullptr;
+    logRadioCharacteristic = nullptr;
+    bleServer = nullptr;
+    hostedConnHandle = BLE_HS_CONN_HANDLE_NONE;
+}
+
+void HostedBluetooth::startAdvertising()
+{
+    BLEAdvertising *advertising = BLEDevice::getAdvertising();
+    if (!advertising) {
+        LOG_ERROR("Hosted BLE getAdvertising failed");
+        return;
+    }
+
+    advertising->stop();
+    advertising->reset();
+    advertising->addServiceUUID(MESH_SERVICE_UUID);
+
+    BLEAdvertisementData scan;
+    scan.setName(getDeviceName());
+    advertising->setScanResponseData(scan);
+    advertising->setMinPreferred(0x06);
+    advertising->setMaxPreferred(0x12);
+
+    if (!advertising->start(0)) {
+        LOG_ERROR("Hosted BLE failed to start advertising");
+    } else {
+        LOG_INFO("Hosted BLE advertising started");
+    }
+}
+
+#endif

src/bluetooth/HostedBluetooth.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "BluetoothCommon.h"
+#include <atomic>
+
+/**
+ * Placeholder backend for ESP32-P4 + ESP-Hosted BLE transport.
+ *
+ * This intentionally mirrors the NimbleBluetooth surface used by the firmware,
+ * so the caller side can stay stable while we implement esp-hosted internals.
+ */
+class HostedBluetooth : public BluetoothApi
+{
+  public:
+    HostedBluetooth();
+    ~HostedBluetooth() override;
+
+    void setup() override;
+    void shutdown() override;
+    void deinit() override;
+    void clearBonds() override;
+    bool isActive() override;
+    bool isConnected() override;
+    int getRssi() override;
+    void sendLog(const uint8_t *logMessage, size_t length) override;
+    void startAdvertising();
+
+    void setConnected(bool value);
+    void setRssi(int value);
+
+  private:
+    bool setupGatt();
+    void shutdownGatt();
+    void maybeLogFirstRssi(int value);
+    bool registerCallbacks();
+    void unregisterCallbacks();
+
+    bool active = false;
+    std::atomic<bool> connected{false};
+    std::atomic<int> rssi{0};
+    std::atomic<bool> firstRssiLogged{false};
+    bool callbacksRegistered = false;
+};

src/concurrency/Lock.cpp

@@ -14,11 +14,6 @@ Lock::Lock() : handle(xSemaphoreCreateBinary())
     }
 }
 
-Lock::~Lock()
-{
-    vSemaphoreDelete(handle);
-}
-
 void Lock::lock()
 {
     if (xSemaphoreTake(handle, portMAX_DELAY) == false) {
@@ -35,8 +30,6 @@ void Lock::unlock()
 #else
 Lock::Lock() {}
 
-Lock::~Lock() {}
-
 void Lock::lock() {}
 
 void Lock::unlock() {}

src/concurrency/Lock.h

@@ -12,7 +12,6 @@ class Lock
 {
   public:
     Lock();
-    ~Lock();
 
     Lock(const Lock &) = delete;
     Lock &operator=(const Lock &) = delete;

src/detect/LoRaRadioType.h

@@ -11,8 +11,7 @@ enum LoRaRadioType {
     SX1280_RADIO,
     LR1110_RADIO,
     LR1120_RADIO,
-    LR1121_RADIO,
-    LR2021_RADIO
+    LR1121_RADIO
 };
 
 extern LoRaRadioType radioType;

src/gps/GPS.cpp

@@ -1025,13 +1025,10 @@ void GPS::up()
     setPowerState(GPS_ACTIVE);
 }
 
-// We've finished a GPS search cycle (lock or timeout). Enter a low power state, potentially.
+// We've got a GPS lock. Enter a low power state, potentially.
 void GPS::down()
 {
-    if (hasValidLocation)
-        scheduling.informGotLock();
-    else
-        scheduling.informSearchFailed();
+    scheduling.informGotLock();
     uint32_t predictedSearchDuration = scheduling.predictedSearchDurationMs();
     uint32_t sleepTime = scheduling.msUntilNextSearch();
     uint32_t updateInterval = Default::getConfiguredOrDefaultMs(config.position.gps_update_interval);
@@ -1556,12 +1553,7 @@ std::unique_ptr<GPS> GPS::createGps()
         _en_gpio = PIN_GPS_EN;
 #endif
 #ifdef ARCH_PORTDUINO
-    if (portduino_config.has_gps) {
-        // These need to set as flags so later checks will pass on native and GPS will work.
-        // They are not used for any hardware access.
-        _rx_gpio = 1;
-        _tx_gpio = 1;
-    } else
+    if (!portduino_config.has_gps)
         return nullptr;
 #endif
     if (!_rx_gpio || !_serial_gps) // Configured to have no GPS at all

src/gps/GPSUpdateScheduling.cpp

@@ -15,19 +15,6 @@ void GPSUpdateScheduling::informGotLock()
     searchEndedMs = millis();
     LOG_DEBUG("Took %us to get lock", (searchEndedMs - searchStartedMs) / 1000);
     updateLockTimePrediction();
-    consecutiveFailures = 0; // Drop back to fast cadence as soon as we acquire any fix
-}
-
-// Search finished without obtaining a fix. We still need to mark the end time so
-// the next sleep is timed correctly, but we must not feed the timeout duration
-// into predictedMsToGetLock — doing so poisons msUntilNextSearch() and causes
-// down() to fall into GPS_IDLE, leaving the chip awake on subsequent indoor cycles.
-void GPSUpdateScheduling::informSearchFailed()
-{
-    searchEndedMs = millis();
-    consecutiveFailures++;
-    LOG_DEBUG("GPS search ended without fix after %us (consecutive failures: %u)", (searchEndedMs - searchStartedMs) / 1000,
-              consecutiveFailures);
 }
 
 // Clear old lock-time prediction data.
@@ -38,7 +25,6 @@ void GPSUpdateScheduling::reset()
     searchEndedMs = 0;
     searchCount = 0;
     predictedMsToGetLock = 0;
-    consecutiveFailures = 0;
 }
 
 // How many milliseconds before we should next search for GPS position
@@ -50,20 +36,6 @@ uint32_t GPSUpdateScheduling::msUntilNextSearch()
     // Target interval (seconds), between GPS updates
     uint32_t updateInterval = Default::getConfiguredOrDefaultMs(config.position.gps_update_interval, default_gps_update_interval);
 
-    // After a failed search, back off: indoors / no-sky environments will keep failing,
-    // so wake at most once per broadcast interval rather than once per gps_update_interval.
-    // Capped at 1 hour so a user-configured very-long broadcast interval still retries
-    // periodically (in case conditions change). Reset on any successful lock.
-    if (consecutiveFailures > 0) {
-        constexpr uint32_t failureRetryCapMs = 60UL * 60UL * 1000UL; // 1 hour cap
-        uint32_t failureSleepMs =
-            Default::getConfiguredOrDefaultMs(config.position.position_broadcast_secs, default_broadcast_interval_secs);
-        if (failureSleepMs > failureRetryCapMs)
-            failureSleepMs = failureRetryCapMs;
-        if (updateInterval < failureSleepMs)
-            updateInterval = failureSleepMs;
-    }
-
     // Check how long until we should start searching, to hopefully hit our target interval
     uint32_t dueAtMs = searchEndedMs + updateInterval;
     uint32_t compensatedStart = dueAtMs - predictedMsToGetLock;
@@ -99,18 +71,14 @@ bool GPSUpdateScheduling::isUpdateDue()
 bool GPSUpdateScheduling::searchedTooLong()
 {
     constexpr uint32_t oneMinuteMs = 60UL * 1000UL;
-    constexpr uint32_t maxSearchClampMs = 15UL * oneMinuteMs;   // Hard cap: 15 minutes is always too long
-    constexpr uint32_t postFailureSearchMs = 5UL * oneMinuteMs; // Tighter dwell once we know the environment is hostile
+    constexpr uint32_t maxSearchClampMs = 15UL * oneMinuteMs; // Hard cap: 15 minutes is always too long
     uint32_t elapsed = elapsedSearchMs();
 
     // Anything over 15 minutes is too long, regardless of the broadcast interval.
+    // TODO: Make a smarter algorithm that backs off the search dwell time when not getting a lock.
     if (elapsed > maxSearchClampMs)
         return true;
 
-    // After a prior failed search, shorten the dwell
-    if (consecutiveFailures > 0 && elapsed > postFailureSearchMs)
-        return true;
-
     uint32_t minimumOrConfiguredSecs =
         Default::getConfiguredOrMinimumValue(config.position.position_broadcast_secs, default_broadcast_interval_secs);
     uint32_t maxSearchMs = Default::getConfiguredOrDefaultMs(minimumOrConfiguredSecs, default_broadcast_interval_secs);

src/gps/GPSUpdateScheduling.h

@@ -8,8 +8,7 @@ class GPSUpdateScheduling
   public:
     // Marks the time of these events, for calculation use
     void informSearching();
-    void informGotLock();      // Predicted lock-time is recalculated here
-    void informSearchFailed(); // Search ended without a fix; prediction is left untouched
+    void informGotLock(); // Predicted lock-time is recalculated here
 
     void reset();           // Reset the prediction - after GPS::disable() / GPS::enable()
     bool isUpdateDue();     // Is it time to begin searching for a GPS position?
@@ -25,7 +24,6 @@ class GPSUpdateScheduling
     uint32_t searchEndedMs = 0;
     uint32_t searchCount = 0;
     uint32_t predictedMsToGetLock = 0;
-    uint32_t consecutiveFailures = 0; // Count of search cycles that ended without a fix; reset on lock
 
     const float weighting = 0.2; // Controls exponential smoothing of lock-times prediction. 20% weighting of "latest lock-time".
 };

src/graphics/Screen.cpp

@@ -65,6 +65,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "mesh/Default.h"
 #include "mesh/generated/meshtastic/deviceonly.pb.h"
 #include "modules/ExternalNotificationModule.h"
+#include "modules/TextMessageModule.h"
 #include "modules/WaypointModule.h"
 #include "sleep.h"
 #include "target_specific.h"
@@ -1284,7 +1285,7 @@ void Screen::setFrames(FrameFocus focus)
 
         for (size_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
             const meshtastic_NodeInfoLite *n = nodeDB->getMeshNodeByIndex(i);
-            if (n && n->num != nodeDB->getNodeNum() && nodeInfoLiteIsFavorite(n)) {
+            if (n && n->num != nodeDB->getNodeNum() && n->is_favorite) {
                 favoriteFrames.push_back(graphics::UIRenderer::drawFavoriteNode);
             }
         }
@@ -1642,6 +1643,138 @@ int Screen::handleStatusUpdate(const meshtastic::Status *arg)
     return 0;
 }
 
+// Handles when message is received; will jump to text message frame.
+int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
+{
+    if (showingNormalScreen) {
+        if (packet->from == 0) {
+            // Outgoing message (likely sent from phone)
+            devicestate.has_rx_text_message = false;
+            memset(&devicestate.rx_text_message, 0, sizeof(devicestate.rx_text_message));
+            hiddenFrames.textMessage = true;
+            hasUnreadMessage = false; // Clear unread state when user replies
+
+            setFrames(FOCUS_PRESERVE); // Stay on same frame, silently update frame list
+        } else {
+            // Incoming message
+            devicestate.has_rx_text_message = true; // Needed to include the message frame
+            hasUnreadMessage = true;                // Enables mail icon in the header
+            setFrames(FOCUS_PRESERVE);              // Refresh frame list without switching view (no-op during text_input)
+
+            // Only wake/force display if the configuration allows it
+            if (shouldWakeOnReceivedMessage()) {
+                setOn(true);    // Wake up the screen first
+                forceDisplay(); // Forces screen redraw
+            }
+            // === Prepare banner/popup content ===
+            const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(packet->from);
+            const meshtastic_Channel channel =
+                channels.getByIndex(packet->channel ? packet->channel : channels.getPrimaryIndex());
+            const char *longName = (node && node->has_user) ? node->user.long_name : nullptr;
+
+            const char *msgRaw = reinterpret_cast<const char *>(packet->decoded.payload.bytes);
+
+            char banner[256];
+
+            bool isAlert = false;
+
+            if (moduleConfig.external_notification.alert_bell || moduleConfig.external_notification.alert_bell_vibra ||
+                moduleConfig.external_notification.alert_bell_buzzer)
+                // Check for bell character to determine if this message is an alert
+                for (size_t i = 0; i < packet->decoded.payload.size && i < 100; i++) {
+                    if (msgRaw[i] == ASCII_BELL) {
+                        isAlert = true;
+                        break;
+                    }
+                }
+
+            // Unlike generic messages, alerts (when enabled via the ext notif module) ignore any
+            // 'mute' preferences set to any specific node or channel.
+            // If on-screen keyboard is active, show a transient popup over keyboard instead of interrupting it
+            if (NotificationRenderer::current_notification_type == notificationTypeEnum::text_input) {
+                // Wake and force redraw so popup is visible immediately
+                if (shouldWakeOnReceivedMessage()) {
+                    setOn(true);
+                    forceDisplay();
+                }
+
+                // Build popup: title = message source name, content = message text (sanitized)
+                // Title
+                char titleBuf[64] = {0};
+                if (longName && longName[0]) {
+                    // Sanitize sender name
+                    std::string t = sanitizeString(longName);
+                    strncpy(titleBuf, t.c_str(), sizeof(titleBuf) - 1);
+                } else {
+                    strncpy(titleBuf, "Message", sizeof(titleBuf) - 1);
+                }
+
+                // Content: payload bytes may not be null-terminated, remove ASCII_BELL and sanitize
+                char content[256] = {0};
+                {
+                    std::string raw;
+                    raw.reserve(packet->decoded.payload.size);
+                    for (size_t i = 0; i < packet->decoded.payload.size; ++i) {
+                        char c = msgRaw[i];
+                        if (c == ASCII_BELL)
+                            continue; // strip bell
+                        raw.push_back(c);
+                    }
+                    std::string sanitized = sanitizeString(raw);
+                    strncpy(content, sanitized.c_str(), sizeof(content) - 1);
+                }
+
+                NotificationRenderer::showKeyboardMessagePopupWithTitle(titleBuf, content, 3000);
+
+// Maintain existing buzzer behavior on M5 if applicable
+#if defined(M5STACK_UNITC6L)
+                if (config.device.buzzer_mode != meshtastic_Config_DeviceConfig_BuzzerMode_DIRECT_MSG_ONLY ||
+                    (isAlert && moduleConfig.external_notification.alert_bell_buzzer) ||
+                    (!isBroadcast(packet->to) && isToUs(packet))) {
+                    playLongBeep();
+                }
+#endif
+            } else {
+                // No keyboard active: use regular banner flow, respecting mute settings
+                if (isAlert) {
+                    if (longName && longName[0]) {
+                        snprintf(banner, sizeof(banner), "Alert Received from\n%s", longName);
+                    } else {
+                        strcpy(banner, "Alert Received");
+                    }
+                    screen->showSimpleBanner(banner, 3000);
+                } else if (!channel.settings.has_module_settings || !channel.settings.module_settings.is_muted) {
+                    if (longName && longName[0]) {
+                        if (currentResolution == ScreenResolution::UltraLow) {
+                            strcpy(banner, "New Message");
+                        } else {
+                            snprintf(banner, sizeof(banner), "New Message from\n%s", longName);
+                        }
+                    } else {
+                        strcpy(banner, "New Message");
+                    }
+#if defined(M5STACK_UNITC6L)
+                    screen->setOn(true);
+                    screen->showSimpleBanner(banner, 1500);
+                    if (config.device.buzzer_mode != meshtastic_Config_DeviceConfig_BuzzerMode_DIRECT_MSG_ONLY ||
+                        (isAlert && moduleConfig.external_notification.alert_bell_buzzer) ||
+                        (!isBroadcast(packet->to) && isToUs(packet))) {
+                        // Beep if not in DIRECT_MSG_ONLY mode or if in DIRECT_MSG_ONLY mode and either
+                        // - packet contains an alert and alert bell buzzer is enabled
+                        // - packet is a non-broadcast that is addressed to this node
+                        playLongBeep();
+                    }
+#else
+                    screen->showSimpleBanner(banner, 3000);
+#endif
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
 // Triggered by MeshModules
 int Screen::handleUIFrameEvent(const UIFrameEvent *event)
 {

src/graphics/Screen.h

@@ -609,6 +609,7 @@ class Screen : public concurrency::OSThread
 
     // Handle observer events
     int handleStatusUpdate(const meshtastic::Status *arg);
+    int handleTextMessage(const meshtastic_MeshPacket *packet);
     int handleUIFrameEvent(const UIFrameEvent *arg);
     int handleInputEvent(const InputEvent *arg);
     int handleAdminMessage(AdminModule_ObserverData *arg);

src/graphics/draw/MenuHandler.cpp

@@ -57,70 +57,6 @@ BannerOverlayOptions createStaticBannerOptions(const char *message, const MenuOp
     return bannerOptions;
 }
 
-const StoredMessage *getNewestMessageForActiveThread()
-{
-    const auto &messages = messageStore.getMessages();
-    if (messages.empty()) {
-        return nullptr;
-    }
-
-    const auto mode = graphics::MessageRenderer::getThreadMode();
-    const int channel = graphics::MessageRenderer::getThreadChannel();
-    const uint32_t peer = graphics::MessageRenderer::getThreadPeer();
-    const uint32_t localNode = nodeDB->getNodeNum();
-
-    if (mode == graphics::MessageRenderer::ThreadMode::ALL) {
-        return &messages.back();
-    }
-
-    for (auto it = messages.rbegin(); it != messages.rend(); ++it) {
-        const StoredMessage &m = *it;
-
-        if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL) {
-            if (m.type == MessageType::BROADCAST && static_cast<int>(m.channelIndex) == channel) {
-                return &m;
-            }
-            continue;
-        }
-
-        if (mode == graphics::MessageRenderer::ThreadMode::DIRECT) {
-            if (m.type != MessageType::DM_TO_US) {
-                continue;
-            }
-            const uint32_t other = (m.sender == localNode) ? m.dest : m.sender;
-            if (other == peer) {
-                return &m;
-            }
-        }
-    }
-
-    return nullptr;
-}
-
-void launchReplyForMessage(const StoredMessage &message, bool freetext)
-{
-    if (message.type == MessageType::BROADCAST || message.dest == NODENUM_BROADCAST) {
-        if (freetext) {
-            cannedMessageModule->LaunchFreetextWithDestination(NODENUM_BROADCAST, message.channelIndex);
-        } else {
-            cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST, message.channelIndex);
-        }
-        return;
-    }
-
-    const uint32_t localNode = nodeDB->getNodeNum();
-    const uint32_t peer = (message.sender == localNode) ? message.dest : message.sender;
-    if (peer == 0 || peer == NODENUM_BROADCAST) {
-        return;
-    }
-
-    if (freetext) {
-        cannedMessageModule->LaunchFreetextWithDestination(peer);
-    } else {
-        cannedMessageModule->LaunchWithDestination(peer);
-    }
-}
-
 } // namespace
 
 menuHandler::screenMenus menuHandler::menuQueue = MenuNone;
@@ -658,12 +594,9 @@ void menuHandler::messageResponseMenu()
 
 #ifdef HAS_I2S
         } else if (selected == Aloud) {
-            if (const StoredMessage *latest = getNewestMessageForActiveThread()) {
-                const char *msg = MessageStore::getText(*latest);
-                if (msg && msg[0]) {
-                    audioThread->readAloud(msg);
-                }
-            }
+            const meshtastic_MeshPacket &mp = devicestate.rx_text_message;
+            const char *msg = reinterpret_cast<const char *>(mp.decoded.payload.bytes);
+            audioThread->readAloud(msg);
 #endif
         }
     };
@@ -723,12 +656,20 @@ void menuHandler::replyMenu()
 
         // Preset reply
         if (selected == ReplyPreset) {
+
             if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL) {
                 cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST, ch);
+
             } else if (mode == graphics::MessageRenderer::ThreadMode::DIRECT) {
                 cannedMessageModule->LaunchWithDestination(peer);
-            } else if (const StoredMessage *latest = getNewestMessageForActiveThread()) {
-                launchReplyForMessage(*latest, false);
+
+            } else {
+                // Fallback for last received message
+                if (devicestate.rx_text_message.to == NODENUM_BROADCAST) {
+                    cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST, devicestate.rx_text_message.channel);
+                } else {
+                    cannedMessageModule->LaunchWithDestination(devicestate.rx_text_message.from);
+                }
             }
 
             return;
@@ -736,12 +677,20 @@ void menuHandler::replyMenu()
 
         // Freetext reply
         if (selected == ReplyFreetext) {
+
             if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL) {
                 cannedMessageModule->LaunchFreetextWithDestination(NODENUM_BROADCAST, ch);
+
             } else if (mode == graphics::MessageRenderer::ThreadMode::DIRECT) {
                 cannedMessageModule->LaunchFreetextWithDestination(peer);
-            } else if (const StoredMessage *latest = getNewestMessageForActiveThread()) {
-                launchReplyForMessage(*latest, true);
+
+            } else {
+                // Fallback for last received message
+                if (devicestate.rx_text_message.to == NODENUM_BROADCAST) {
+                    cannedMessageModule->LaunchFreetextWithDestination(NODENUM_BROADCAST, devicestate.rx_text_message.channel);
+                } else {
+                    cannedMessageModule->LaunchFreetextWithDestination(devicestate.rx_text_message.from);
+                }
             }
 
             return;
@@ -896,10 +845,10 @@ void menuHandler::messageViewModeMenu()
     // Encode peers
     for (size_t i = 0; i < uniquePeers.size(); ++i) {
         uint32_t peer = uniquePeers[i];
-        const auto *node = nodeDB->getMeshNode(peer);
+        auto node = nodeDB->getMeshNode(peer);
         std::string name;
-        if (nodeInfoLiteHasUser(node))
-            name = sanitizeString(node->long_name).substr(0, 15);
+        if (node && node->has_user)
+            name = sanitizeString(node->user.long_name).substr(0, 15);
         else {
             char buf[20];
             snprintf(buf, sizeof(buf), "Node %08X", peer);
@@ -1406,14 +1355,14 @@ void menuHandler::manageNodeMenu()
     static int optionsEnumArray[enumEnd] = {Back};
     int options = 1;
 
-    if (nodeInfoLiteIsFavorite(node)) {
+    if (node->is_favorite) {
         optionsArray[options] = "Unfavorite";
     } else {
         optionsArray[options] = "Favorite";
     }
     optionsEnumArray[options++] = Favorite;
 
-    bool isMuted = nodeInfoLiteIsMuted(node);
+    bool isMuted = (node->bitfield & NODEINFO_BITFIELD_IS_MUTED_MASK) != 0;
     if (isMuted) {
         optionsArray[options] = "Unmute Notifications";
     } else {
@@ -1427,7 +1376,7 @@ void menuHandler::manageNodeMenu()
     optionsArray[options] = "Key Verification";
     optionsEnumArray[options++] = KeyVerification;
 
-    if (nodeInfoLiteIsIgnored(node)) {
+    if (node->is_ignored) {
         optionsArray[options] = "Unignore Node";
     } else {
         optionsArray[options] = "Ignore Node";
@@ -1437,8 +1386,8 @@ void menuHandler::manageNodeMenu()
     BannerOverlayOptions bannerOptions;
 
     std::string title = "";
-    if (nodeInfoLiteHasUser(node) && node->long_name[0]) {
-        title += sanitizeString(node->long_name).substr(0, 15);
+    if (node->has_user && node->user.long_name && node->user.long_name[0]) {
+        title += sanitizeString(node->user.long_name).substr(0, 15);
     } else {
         char buf[20];
         snprintf(buf, sizeof(buf), "%08X", (unsigned int)node->num);
@@ -1460,7 +1409,7 @@ void menuHandler::manageNodeMenu()
             if (!n) {
                 return;
             }
-            if (nodeInfoLiteIsFavorite(n)) {
+            if (n->is_favorite) {
                 LOG_INFO("Removing node %08X from favorites", menuHandler::pickedNodeNum);
                 nodeDB->set_favorite(false, menuHandler::pickedNodeNum);
             } else {
@@ -1477,9 +1426,13 @@ void menuHandler::manageNodeMenu()
                 return;
             }
 
-            const bool wasMuted = nodeInfoLiteIsMuted(n);
-            nodeInfoLiteSetBit(n, NODEINFO_BITFIELD_IS_MUTED_MASK, !wasMuted);
-            LOG_INFO(wasMuted ? "Unmuted node %08X" : "Muted node %08X", menuHandler::pickedNodeNum);
+            if (n->bitfield & NODEINFO_BITFIELD_IS_MUTED_MASK) {
+                n->bitfield &= ~NODEINFO_BITFIELD_IS_MUTED_MASK;
+                LOG_INFO("Unmuted node %08X", menuHandler::pickedNodeNum);
+            } else {
+                n->bitfield |= NODEINFO_BITFIELD_IS_MUTED_MASK;
+                LOG_INFO("Muted node %08X", menuHandler::pickedNodeNum);
+            }
             nodeDB->notifyObservers(true);
             nodeDB->saveToDisk();
             screen->setFrames(graphics::Screen::FOCUS_PRESERVE);
@@ -1508,11 +1461,11 @@ void menuHandler::manageNodeMenu()
                 return;
             }
 
-            if (nodeInfoLiteIsIgnored(n)) {
-                nodeInfoLiteSetBit(n, NODEINFO_BITFIELD_IS_IGNORED_MASK, false);
+            if (n->is_ignored) {
+                n->is_ignored = false;
                 LOG_INFO("Unignoring node %08X", menuHandler::pickedNodeNum);
             } else {
-                nodeInfoLiteSetBit(n, NODEINFO_BITFIELD_IS_IGNORED_MASK, true);
+                n->is_ignored = true;
                 LOG_INFO("Ignoring node %08X", menuHandler::pickedNodeNum);
             }
             nodeDB->notifyObservers(true);
@@ -2126,9 +2079,9 @@ void menuHandler::removeFavoriteMenu()
     static const char *optionsArray[] = {"Back", "Yes"};
     BannerOverlayOptions bannerOptions;
     std::string message = "Unfavorite This Node?\n";
-    const auto *node = nodeDB->getMeshNode(graphics::UIRenderer::currentFavoriteNodeNum);
-    if (nodeInfoLiteHasUser(node)) {
-        message += sanitizeString(node->long_name).substr(0, 15);
+    auto node = nodeDB->getMeshNode(graphics::UIRenderer::currentFavoriteNodeNum);
+    if (node && node->has_user) {
+        message += sanitizeString(node->user.long_name).substr(0, 15);
     }
     bannerOptions.message = message.c_str();
     bannerOptions.optionsArrayPtr = optionsArray;

src/graphics/draw/MessageRenderer.cpp

@@ -462,8 +462,8 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     }
     case ThreadMode::DIRECT: {
         meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(currentPeer);
-        if (nodeInfoLiteHasUser(node) && node->short_name[0]) {
-            snprintf(titleStr, sizeof(titleStr), "@%s", node->short_name);
+        if (node && node->has_user && node->user.short_name[0]) {
+            snprintf(titleStr, sizeof(titleStr), "@%s", node->user.short_name);
         } else {
             snprintf(titleStr, sizeof(titleStr), "@%08x", currentPeer);
         }
@@ -585,11 +585,11 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
         meshtastic_NodeInfoLite *node_recipient = nodeDB->getMeshNode(m.dest);
 
         char senderName[64] = "";
-        if (nodeInfoLiteHasUser(node)) {
-            if (node->long_name[0]) {
-                strncpy(senderName, node->long_name, sizeof(senderName) - 1);
-            } else if (node->short_name[0]) {
-                strncpy(senderName, node->short_name, sizeof(senderName) - 1);
+        if (node && node->has_user) {
+            if (node->user.long_name[0]) {
+                strncpy(senderName, node->user.long_name, sizeof(senderName) - 1);
+            } else if (node->user.short_name[0]) {
+                strncpy(senderName, node->user.short_name, sizeof(senderName) - 1);
             }
             senderName[sizeof(senderName) - 1] = '\0';
         }
@@ -599,17 +599,18 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
 
         // If this is *our own* message, override senderName to who the recipient was
         bool mine = (m.sender == nodeDB->getNodeNum());
-        if (mine && nodeInfoLiteHasUser(node_recipient)) {
-            if (node_recipient->long_name[0]) {
-                strncpy(senderName, node_recipient->long_name, sizeof(senderName) - 1);
+        if (mine && node_recipient && node_recipient->has_user) {
+            if (node_recipient->user.long_name[0]) {
+                strncpy(senderName, node_recipient->user.long_name, sizeof(senderName) - 1);
                 senderName[sizeof(senderName) - 1] = '\0';
-            } else if (node_recipient->short_name[0]) {
-                strncpy(senderName, node_recipient->short_name, sizeof(senderName) - 1);
+            } else if (node_recipient->user.short_name[0]) {
+                strncpy(senderName, node_recipient->user.short_name, sizeof(senderName) - 1);
                 senderName[sizeof(senderName) - 1] = '\0';
             }
         }
         // If recipient info is missing/empty, prefer a recipient identifier for outbound messages.
-        if (mine && (!nodeInfoLiteHasUser(node_recipient) || (!node_recipient->long_name[0] && !node_recipient->short_name[0]))) {
+        if (mine && (!node_recipient || !node_recipient->has_user ||
+                     (!node_recipient->user.long_name[0] && !node_recipient->user.short_name[0]))) {
             snprintf(senderName, sizeof(senderName), "(%08x)", m.dest);
         }
 
@@ -1072,12 +1073,12 @@ void handleNewMessage(OLEDDisplay *display, const StoredMessage &sm, const mesht
         // Banner logic
         const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(packet.from);
         char longName[64] = "?";
-        if (nodeInfoLiteHasUser(node)) {
-            if (node->long_name[0]) {
-                strncpy(longName, node->long_name, sizeof(longName) - 1);
+        if (node && node->has_user) {
+            if (node->user.long_name[0]) {
+                strncpy(longName, node->user.long_name, sizeof(longName) - 1);
                 longName[sizeof(longName) - 1] = '\0';
-            } else if (node->short_name[0]) {
-                strncpy(longName, node->short_name, sizeof(longName) - 1);
+            } else if (node->user.short_name[0]) {
+                strncpy(longName, node->user.short_name, sizeof(longName) - 1);
                 longName[sizeof(longName) - 1] = '\0';
             }
         }

src/graphics/draw/NodeListRenderer.cpp

@@ -98,23 +98,29 @@ std::string getSafeNodeName(OLEDDisplay *display, meshtastic_NodeInfoLite *node,
     // 1) Choose target candidate (long vs short) only if present
     const char *raw = nullptr;
 
-#if !MESHTASTIC_EXCLUDE_STATUS && !MESHTASTIC_EXCLUDE_STATUSDB
+#if !MESHTASTIC_EXCLUDE_STATUS
     // If long-name mode is enabled, and we have a recent status for this node,
-    // prefer "(short_name) statusText" as the raw candidate. Pull straight out
-    // of NodeDB's per-NodeNum cache instead of scanning a FIFO.
+    // prefer "(short_name) statusText" as the raw candidate.
     std::string composedFromStatus;
-    if (config.display.use_long_node_name && nodeInfoLiteHasUser(node) && nodeDB) {
-        meshtastic_StatusMessage cachedStatus;
-        if (nodeDB->copyNodeStatus(node->num, cachedStatus) && cachedStatus.status[0]) {
-            const char *shortName = node->short_name;
-            const size_t statusLen = std::strlen(cachedStatus.status);
-            composedFromStatus.reserve(4 + (shortName ? std::strlen(shortName) : 0) + 1 + statusLen);
+    if (config.display.use_long_node_name && node && node->has_user && statusMessageModule) {
+        const auto &recent = statusMessageModule->getRecentReceived();
+        const StatusMessageModule::RecentStatus *found = nullptr;
+        for (auto it = recent.rbegin(); it != recent.rend(); ++it) {
+            if (it->fromNodeId == node->num && !it->statusText.empty()) {
+                found = &(*it);
+                break;
+            }
+        }
+
+        if (found) {
+            const char *shortName = node->user.short_name;
+            composedFromStatus.reserve(4 + (shortName ? std::strlen(shortName) : 0) + 1 + found->statusText.size());
             composedFromStatus += "(";
             if (shortName && *shortName) {
                 composedFromStatus += shortName;
             }
             composedFromStatus += ") ";
-            composedFromStatus += cachedStatus.status;
+            composedFromStatus += found->statusText;
 
             raw = composedFromStatus.c_str(); // safe for now; we'll sanitize immediately into std::string
         }
@@ -123,8 +129,8 @@ std::string getSafeNodeName(OLEDDisplay *display, meshtastic_NodeInfoLite *node,
 
     // If we didn't compose from status, use normal long/short selection
     if (!raw) {
-        if (nodeInfoLiteHasUser(node)) {
-            raw = config.display.use_long_node_name ? node->long_name : node->short_name;
+        if (node && node->has_user) {
+            raw = config.display.use_long_node_name ? node->user.long_name : node->user.short_name;
         }
     }
 
@@ -212,7 +218,7 @@ void drawScrollbar(OLEDDisplay *display, int visibleNodeRows, int totalEntries,
 static inline void applyFavoriteNodeNameColor(OLEDDisplay *display, const meshtastic_NodeInfoLite *node, const char *nodeName,
                                               int16_t nameX, int16_t y, int nameMaxWidth)
 {
-    if (!display || !node || !nodeInfoLiteIsFavorite(node) || !isTFTColoringEnabled() || !nodeName) {
+    if (!display || !node || !node->is_favorite || !isTFTColoringEnabled() || !nodeName) {
         return;
     }
 
@@ -253,7 +259,7 @@ void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int
 #if GRAPHICS_TFT_COLORING_ENABLED
     applyFavoriteNodeNameColor(display, node, nodeName, nameX, y, nameMaxWidth);
 #endif
-    bool isMuted = nodeInfoLiteIsMuted(node);
+    bool isMuted = (node->bitfield & NODEINFO_BITFIELD_IS_MUTED_MASK) != 0;
 
     char timeStr[10];
     uint32_t seconds = sinceLastSeen(node);
@@ -273,14 +279,14 @@ void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
     UIRenderer::drawStringWithEmotes(display, nameX, y, nodeName, FONT_HEIGHT_SMALL, 1, false);
-    if (nodeInfoLiteIsFavorite(node)) {
+    if (node->is_favorite) {
         if (currentResolution == ScreenResolution::High) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
             display->drawXbm(x, y + 5, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint);
         }
     }
-    if (nodeInfoLiteIsIgnored(node) || isMuted) {
+    if (node->is_ignored || isMuted) {
         if (currentResolution == ScreenResolution::High) {
             display->drawLine(x + 8, y + 8, (isLeftCol ? 0 : x - 4) + nameMaxWidth - 17, y + 8);
         } else {
@@ -315,20 +321,20 @@ void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int
 #if GRAPHICS_TFT_COLORING_ENABLED
     applyFavoriteNodeNameColor(display, node, nodeName, nameX, y, nameMaxWidth);
 #endif
-    bool isMuted = nodeInfoLiteIsMuted(node);
+    bool isMuted = (node->bitfield & NODEINFO_BITFIELD_IS_MUTED_MASK) != 0;
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
 
     UIRenderer::drawStringWithEmotes(display, nameX, y, nodeName, FONT_HEIGHT_SMALL, 1, false);
-    if (nodeInfoLiteIsFavorite(node)) {
+    if (node->is_favorite) {
         if (currentResolution == ScreenResolution::High) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
             display->drawXbm(x, y + 5, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint);
         }
     }
-    if (nodeInfoLiteIsIgnored(node) || isMuted) {
+    if (node->is_ignored || isMuted) {
         if (currentResolution == ScreenResolution::High) {
             display->drawLine(x + 8, y + 8, (isLeftCol ? 0 : x - 4) + nameMaxWidth - 17, y + 8);
         } else {
@@ -395,19 +401,15 @@ void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
 #if GRAPHICS_TFT_COLORING_ENABLED
     applyFavoriteNodeNameColor(display, node, nodeName, nameX, y, nameMaxWidth);
 #endif
-    bool isMuted = nodeInfoLiteIsMuted(node);
+    bool isMuted = (node->bitfield & NODEINFO_BITFIELD_IS_MUTED_MASK) != 0;
     char distStr[10] = "";
 
-    const meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    meshtastic_PositionLite ourPos;
-    meshtastic_PositionLite theirPos;
-    const bool haveOurPos = ourNode && nodeDB->copyNodePosition(ourNode->num, ourPos);
-    const bool haveTheirPos = nodeDB->copyNodePosition(node->num, theirPos);
-    if (nodeDB->hasValidPosition(ourNode) && nodeDB->hasValidPosition(node) && haveOurPos && haveTheirPos) {
-        double lat1 = ourPos.latitude_i * 1e-7;
-        double lon1 = ourPos.longitude_i * 1e-7;
-        double lat2 = theirPos.latitude_i * 1e-7;
-        double lon2 = theirPos.longitude_i * 1e-7;
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    if (nodeDB->hasValidPosition(ourNode) && nodeDB->hasValidPosition(node)) {
+        double lat1 = ourNode->position.latitude_i * 1e-7;
+        double lon1 = ourNode->position.longitude_i * 1e-7;
+        double lat2 = node->position.latitude_i * 1e-7;
+        double lon2 = node->position.longitude_i * 1e-7;
 
         double earthRadiusKm = 6371.0;
         double dLat = (lat2 - lat1) * DEG_TO_RAD;
@@ -453,14 +455,14 @@ void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
     UIRenderer::drawStringWithEmotes(display, nameX, y, nodeName, FONT_HEIGHT_SMALL, 1, false);
-    if (nodeInfoLiteIsFavorite(node)) {
+    if (node->is_favorite) {
         if (currentResolution == ScreenResolution::High) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
             display->drawXbm(x, y + 5, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint);
         }
     }
-    if (nodeInfoLiteIsIgnored(node) || isMuted) {
+    if (node->is_ignored || isMuted) {
         if (currentResolution == ScreenResolution::High) {
             display->drawLine(x + 8, y + 8, (isLeftCol ? 0 : x - 4) + nameMaxWidth - 17, y + 8);
         } else {
@@ -507,19 +509,19 @@ void drawEntryCompass(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
 #if GRAPHICS_TFT_COLORING_ENABLED
     applyFavoriteNodeNameColor(display, node, nodeName, nameX, y, nameMaxWidth);
 #endif
-    bool isMuted = nodeInfoLiteIsMuted(node);
+    bool isMuted = (node->bitfield & NODEINFO_BITFIELD_IS_MUTED_MASK) != 0;
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
     UIRenderer::drawStringWithEmotes(display, nameX, y, nodeName, FONT_HEIGHT_SMALL, 1, false);
-    if (nodeInfoLiteIsFavorite(node)) {
+    if (node->is_favorite) {
         if (currentResolution == ScreenResolution::High) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
             display->drawXbm(x, y + 5, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint);
         }
     }
-    if (nodeInfoLiteIsIgnored(node) || isMuted) {
+    if (node->is_ignored || isMuted) {
         if (currentResolution == ScreenResolution::High) {
             display->drawLine(x + 8, y + 8, (isLeftCol ? 0 : x - 4) + nameMaxWidth - 17, y + 8);
         } else {
@@ -540,11 +542,8 @@ void drawCompassArrow(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
     int centerX = x + columnWidth - arrowXOffset;
     int centerY = y + FONT_HEIGHT_SMALL / 2;
 
-    meshtastic_PositionLite nodePos;
-    if (!nodeDB->copyNodePosition(node->num, nodePos))
-        return;
-    double nodeLat = nodePos.latitude_i * 1e-7;
-    double nodeLon = nodePos.longitude_i * 1e-7;
+    double nodeLat = node->position.latitude_i * 1e-7;
+    double nodeLon = node->position.longitude_i * 1e-7;
     float bearing = GeoCoord::bearing(userLat, userLon, nodeLat, nodeLon);
     float relativeBearing = CompassRenderer::adjustBearingForCompassMode(bearing, myHeadingRadian);
     float relativeBearingDeg = CompassRenderer::radiansToDegrees360(relativeBearing);
@@ -653,7 +652,7 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
             continue;
         if (n->num == nodeDB->getNodeNum())
             continue;
-        if (locationScreen && !nodeDB->hasNodePosition(n->num))
+        if (locationScreen && !n->has_position)
             continue;
 
         drawList.push_back(n->num);
@@ -884,15 +883,14 @@ void drawDistanceScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
 void drawNodeListWithCompasses(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     float headingRadian = 0.0f;
-    const auto *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    meshtastic_PositionLite ourSelfPos;
-    if (!ourNode || !nodeDB->hasValidPosition(ourNode) || !nodeDB->copyNodePosition(ourNode->num, ourSelfPos)) {
+    auto ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    if (!ourNode || !nodeDB->hasValidPosition(ourNode)) {
         drawNodeListScreen(display, state, x, y, "Bearings", drawEntryCompass, drawCompassUnknown, headingRadian, 0.0, 0.0);
         return;
     }
 
-    double lat = DegD(ourSelfPos.latitude_i);
-    double lon = DegD(ourSelfPos.longitude_i);
+    double lat = DegD(ourNode->position.latitude_i);
+    double lon = DegD(ourNode->position.longitude_i);
 
 #if defined(M5STACK_UNITC6L)
     display->clear();

src/graphics/draw/NotificationRenderer.cpp

@@ -317,12 +317,12 @@ void NotificationRenderer::drawNodePicker(OLEDDisplay *display, OLEDDisplayUiSta
     for (int i = firstOptionToShow; i < alertBannerOptions && linesShown < visibleTotalLines; i++, linesShown++) {
         char tempName[48] = {0};
         meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i + 1);
-        if (nodeInfoLiteHasUser(node)) {
+        if (node && node->has_user) {
             const char *rawName = nullptr;
-            if (node->long_name[0]) {
-                rawName = node->long_name;
-            } else if (node->short_name[0]) {
-                rawName = node->short_name;
+            if (node->user.long_name[0]) {
+                rawName = node->user.long_name;
+            } else if (node->user.short_name[0]) {
+                rawName = node->user.short_name;
             }
             if (rawName) {
                 const int arrowWidth = (currentResolution == ScreenResolution::High)

src/graphics/draw/UIRenderer.cpp

@@ -464,11 +464,11 @@ static bool computeBottomCompassPlacement(OLEDDisplay *display, int16_t xOffset,
     return true;
 }
 
-static void drawTruncatedStatusLine(OLEDDisplay *display, int16_t x, int16_t y, const char *statusText)
+static void drawTruncatedStatusLine(OLEDDisplay *display, int16_t x, int16_t y, const std::string &statusText)
 {
     // Fixed-buffer truncate helper replaces iterative std::string chopping to keep code size down.
     char rawStatus[96];
-    snprintf(rawStatus, sizeof(rawStatus), " Status: %s", statusText ? statusText : "");
+    snprintf(rawStatus, sizeof(rawStatus), " Status: %s", statusText.c_str());
 
     char clippedStatus[96];
     UIRenderer::truncateStringWithEmotes(display, rawStatus, clippedStatus, sizeof(clippedStatus), display->getWidth());
@@ -495,7 +495,7 @@ void graphics::UIRenderer::rebuildFavoritedNodes()
         meshtastic_NodeInfoLite *n = nodeDB->getMeshNodeByIndex(i);
         if (!n || n->num == nodeDB->getNodeNum())
             continue;
-        if (nodeInfoLiteIsFavorite(n))
+        if (n->is_favorite)
             favoritedNodes.push_back(n);
     }
 
@@ -750,7 +750,7 @@ void UIRenderer::drawFavoriteNode(OLEDDisplay *display, OLEDDisplayUiState *stat
         return;
 
     meshtastic_NodeInfoLite *node = favoritedNodes[nodeIndex];
-    if (!node || node->num == nodeDB->getNodeNum() || !nodeInfoLiteIsFavorite(node))
+    if (!node || node->num == nodeDB->getNodeNum() || !node->is_favorite)
         return;
     display->clear();
 #if defined(M5STACK_UNITC6L)
@@ -763,7 +763,7 @@ void UIRenderer::drawFavoriteNode(OLEDDisplay *display, OLEDDisplayUiState *stat
 #endif
     currentFavoriteNodeNum = node->num;
     // === Create the shortName and title string ===
-    const char *shortName = (nodeInfoLiteHasUser(node) && node->short_name[0]) ? node->short_name : "Node";
+    const char *shortName = (node->has_user && node->user.short_name[0]) ? node->user.short_name : "Node";
     char titlestr[40];
     snprintf(titlestr, sizeof(titlestr), "*%s*", shortName);
 
@@ -781,9 +781,9 @@ void UIRenderer::drawFavoriteNode(OLEDDisplay *display, OLEDDisplayUiState *stat
     // === 1. Long Name (always try to show first) ===
     const char *username;
     if (currentResolution == ScreenResolution::UltraLow) {
-        username = (nodeInfoLiteHasUser(node) && node->long_name[0]) ? node->short_name : nullptr;
+        username = (node->has_user && node->user.long_name[0]) ? node->user.short_name : nullptr;
     } else {
-        username = (nodeInfoLiteHasUser(node) && node->long_name[0]) ? node->long_name : nullptr;
+        username = (node->has_user && node->user.long_name[0]) ? node->user.long_name : nullptr;
     }
 
     // Print node's long name (e.g. "Backpack Node")
@@ -796,14 +796,23 @@ void UIRenderer::drawFavoriteNode(OLEDDisplay *display, OLEDDisplayUiState *stat
         UIRenderer::drawStringWithEmotes(display, x, getTextPositions(display)[line++], username, FONT_HEIGHT_SMALL, 1, false);
     }
 
-#if !MESHTASTIC_EXCLUDE_STATUS && !MESHTASTIC_EXCLUDE_STATUSDB
+#if !MESHTASTIC_EXCLUDE_STATUS
     // === Optional: Last received StatusMessage line for this node ===
-    // Display it directly under the username line (if we have one). The cache
-    // lives on NodeDB now, keyed by NodeNum, so this is an O(1) lookup.
-    if (nodeDB) {
-        meshtastic_StatusMessage cachedStatus;
-        if (nodeDB->copyNodeStatus(node->num, cachedStatus) && cachedStatus.status[0]) {
-            drawTruncatedStatusLine(display, x, getTextPositions(display)[line++], cachedStatus.status);
+    // Display it directly under the username line (if we have one).
+    if (statusMessageModule) {
+        const auto &recent = statusMessageModule->getRecentReceived();
+        const StatusMessageModule::RecentStatus *found = nullptr;
+
+        // Search newest-to-oldest
+        for (auto it = recent.rbegin(); it != recent.rend(); ++it) {
+            if (it->fromNodeId == node->num && !it->statusText.empty()) {
+                found = &(*it);
+                break;
+            }
+        }
+
+        if (found) {
+            drawTruncatedStatusLine(display, x, getTextPositions(display)[line++], found->statusText);
         }
     }
 #endif
@@ -962,30 +971,25 @@ void UIRenderer::drawFavoriteNode(OLEDDisplay *display, OLEDDisplayUiState *stat
 #if !defined(M5STACK_UNITC6L)
     // === 4. Uptime (only show if metric is present) ===
     char uptimeStr[32] = "";
-    meshtastic_DeviceMetrics nodeMetrics;
-    const bool haveNodeMetrics = nodeDB->copyNodeTelemetry(node->num, nodeMetrics);
-    if (haveNodeMetrics && nodeMetrics.has_uptime_seconds) {
+    if (node->has_device_metrics && node->device_metrics.has_uptime_seconds) {
         char upPrefix[12]; // enough for leftSideSpacing + "Up:"
         snprintf(upPrefix, sizeof(upPrefix), "%sUp:", leftSideSpacing);
-        getUptimeStr(nodeMetrics.uptime_seconds * 1000, upPrefix, uptimeStr, sizeof(uptimeStr));
+        getUptimeStr(node->device_metrics.uptime_seconds * 1000, upPrefix, uptimeStr, sizeof(uptimeStr));
     }
     if (uptimeStr[0]) {
         display->drawString(x, getTextPositions(display)[line++], uptimeStr);
     }
 
     // === 5. Distance (only if both nodes have GPS position) ===
-    const meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
     char distStr[24] = ""; // Make buffer big enough for any string
     bool haveDistance = false;
 
-    meshtastic_PositionLite nodePos;
-    meshtastic_PositionLite ourPos;
-    const bool haveNodePos = nodeDB->copyNodePosition(node->num, nodePos);
-    const bool haveOurPos = ourNode && nodeDB->copyNodePosition(ourNode->num, ourPos);
-    if (nodeDB->hasValidPosition(ourNode) && nodeDB->hasValidPosition(node) && haveNodePos && haveOurPos) {
+    if (nodeDB->hasValidPosition(ourNode) && nodeDB->hasValidPosition(node)) {
         // Use shared meter conversion, then format display units with lightweight integer rounding.
-        const float distanceMeters = GeoCoord::latLongToMeter(DegD(nodePos.latitude_i), DegD(nodePos.longitude_i),
-                                                              DegD(ourPos.latitude_i), DegD(ourPos.longitude_i));
+        const float distanceMeters =
+            GeoCoord::latLongToMeter(DegD(node->position.latitude_i), DegD(node->position.longitude_i),
+                                     DegD(ourNode->position.latitude_i), DegD(ourNode->position.longitude_i));
         if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) {
             const int feet = static_cast<int>((distanceMeters * METERS_TO_FEET) + 0.5f);
             if (feet > 0 && feet < 1000) {
@@ -1020,19 +1024,19 @@ void UIRenderer::drawFavoriteNode(OLEDDisplay *display, OLEDDisplayUiState *stat
     char batLine[32] = "";
     bool haveBatLine = false;
 
-    if (haveNodeMetrics) {
-        bool hasPct = nodeMetrics.has_battery_level;
-        bool hasVolt = nodeMetrics.has_voltage && nodeMetrics.voltage > 0.001f;
+    if (node->has_device_metrics) {
+        bool hasPct = node->device_metrics.has_battery_level;
+        bool hasVolt = node->device_metrics.has_voltage && node->device_metrics.voltage > 0.001f;
 
         int pct = 0;
         float volt = 0.0f;
 
         if (hasPct) {
-            pct = (int)nodeMetrics.battery_level;
+            pct = (int)node->device_metrics.battery_level;
         }
 
         if (hasVolt) {
-            volt = nodeMetrics.voltage;
+            volt = node->device_metrics.voltage;
         }
 
         if (hasPct && pct > 0 && pct <= 100) {
@@ -1072,11 +1076,11 @@ void UIRenderer::drawFavoriteNode(OLEDDisplay *display, OLEDDisplayUiState *stat
     const bool hasNodePositionFix = nodeDB->hasValidPosition(node);
     const char *statusLine1 = nullptr;
     const char *statusLine2 = nullptr;
-    if (hasOwnPositionFix && hasNodePositionFix && haveOurPos && haveNodePos) {
-        const auto &op = ourPos;
+    if (hasOwnPositionFix && hasNodePositionFix) {
+        const auto &op = ourNode->position;
         showCompass = CompassRenderer::getHeadingRadians(DegD(op.latitude_i), DegD(op.longitude_i), myHeading);
         if (showCompass) {
-            const auto &p = nodePos;
+            const auto &p = node->position;
             bearing = GeoCoord::bearing(DegD(op.latitude_i), DegD(op.longitude_i), DegD(p.latitude_i), DegD(p.longitude_i));
             bearing = CompassRenderer::adjustBearingForCompassMode(bearing, myHeading);
         } else {
@@ -1126,7 +1130,7 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
     int line = 1;
-    const meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
 
     // === Header ===
     if (currentResolution == ScreenResolution::UltraLow) {
@@ -1266,7 +1270,7 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     int textWidth = 0;
     int nameX = 0;
     int yOffset = (currentResolution == ScreenResolution::High) ? 0 : 5;
-    const char *longName = (nodeInfoLiteHasUser(ourNode) && ourNode->long_name[0]) ? ourNode->long_name : "";
+    const char *longName = (ourNode && ourNode->has_user && ourNode->user.long_name[0]) ? ourNode->user.long_name : "";
     const char *shortName = owner.short_name ? owner.short_name : "";
     char combinedName[96];
     if (longName[0] && shortName[0]) {
@@ -1593,7 +1597,7 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
     geoCoord.updateCoords(int32_t(gpsStatus->getLatitude()), int32_t(gpsStatus->getLongitude()),
                           int32_t(gpsStatus->getAltitude()));
 
-    const meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
     const bool hasOwnPositionFix = (ourNode && nodeDB->hasValidPosition(ourNode));
     const bool hasLiveGpsFix =
         (gpsStatus && gpsStatus->getHasLock() && (gpsStatus->getLatitude() != 0 || gpsStatus->getLongitude() != 0));
@@ -1609,11 +1613,9 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
             headingLat = DegD(gpsStatus->getLatitude());
             headingLon = DegD(gpsStatus->getLongitude());
         } else if (hasOwnPositionFix) {
-            meshtastic_PositionLite ownPos;
-            if (nodeDB->copyNodePosition(ourNode->num, ownPos)) {
-                headingLat = DegD(ownPos.latitude_i);
-                headingLon = DegD(ownPos.longitude_i);
-            }
+            const auto &op = ourNode->position;
+            headingLat = DegD(op.latitude_i);
+            headingLon = DegD(op.longitude_i);
         }
         validHeading = CompassRenderer::getHeadingRadians(headingLat, headingLon, heading);
     }

src/graphics/niche/InkHUD/Applet.cpp

@@ -362,8 +362,8 @@ std::string InkHUD::Applet::parseShortName(meshtastic_NodeInfoLite *node)
     assert(node);
 
     // Use the true shortname if known, and doesn't contain any unprintable characters (emoji, etc.)
-    if (nodeInfoLiteHasUser(node)) {
-        std::string parsed = parse(node->short_name);
+    if (node->has_user) {
+        std::string parsed = parse(node->user.short_name);
         if (isPrintable(parsed))
             return parsed;
     }

src/graphics/niche/InkHUD/Applets/Bases/Map/MapApplet.cpp

@@ -136,10 +136,9 @@ void InkHUD::MapApplet::onRender(bool full)
     printAt(vertBarX + (bottomLabelW / 2) + 1, bottomLabelY + (bottomLabelH / 2), vertBottomLabel, CENTER, MIDDLE);
 
     // Draw our node LAST with full white fill + outline
-    const meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    meshtastic_PositionLite ourSelfPos;
-    if (ourNode && nodeDB->hasValidPosition(ourNode) && nodeDB->copyNodePosition(ourNode->num, ourSelfPos)) {
-        Marker self = calculateMarker(ourSelfPos.latitude_i * 1e-7, ourSelfPos.longitude_i * 1e-7, false, 0);
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    if (ourNode && nodeDB->hasValidPosition(ourNode)) {
+        Marker self = calculateMarker(ourNode->position.latitude_i * 1e-7, ourNode->position.longitude_i * 1e-7, false, 0);
 
         int16_t centerX = X(0.5) + (self.eastMeters * metersToPx);
         int16_t centerY = Y(0.5) - (self.northMeters * metersToPx);
@@ -169,11 +168,10 @@ void InkHUD::MapApplet::onRender(bool full)
 void InkHUD::MapApplet::getMapCenter(float *lat, float *lng)
 {
     // If we have a valid position for our own node, use that as the anchor
-    const meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    meshtastic_PositionLite ourSelfPos;
-    if (ourNode && nodeDB->hasValidPosition(ourNode) && nodeDB->copyNodePosition(ourNode->num, ourSelfPos)) {
-        *lat = ourSelfPos.latitude_i * 1e-7;
-        *lng = ourSelfPos.longitude_i * 1e-7;
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    if (ourNode && nodeDB->hasValidPosition(ourNode)) {
+        *lat = ourNode->position.latitude_i * 1e-7;
+        *lng = ourNode->position.longitude_i * 1e-7;
     } else {
         // Find mean lat long coords
         // ============================
@@ -203,13 +201,9 @@ void InkHUD::MapApplet::getMapCenter(float *lat, float *lng)
             if (!shouldDrawNode(node))
                 continue;
 
-            meshtastic_PositionLite pos;
-            if (!nodeDB->copyNodePosition(node->num, pos))
-                continue;
-
             // Latitude and Longitude of node, in radians
-            float latRad = pos.latitude_i * (1e-7) * DEG_TO_RAD;
-            float lngRad = pos.longitude_i * (1e-7) * DEG_TO_RAD;
+            float latRad = node->position.latitude_i * (1e-7) * DEG_TO_RAD;
+            float lngRad = node->position.longitude_i * (1e-7) * DEG_TO_RAD;
 
             // Convert to cartesian points, with center of earth at 0, 0, 0
             // Exact distance from center is irrelevant, as we're only interested in the vector
@@ -306,17 +300,13 @@ void InkHUD::MapApplet::getMapCenter(float *lat, float *lng)
         if (!shouldDrawNode(node))
             continue;
 
-        meshtastic_PositionLite pos;
-        if (!nodeDB->copyNodePosition(node->num, pos))
-            continue;
-
         // Check for a new top or bottom latitude
-        float latNode = pos.latitude_i * 1e-7;
+        float latNode = node->position.latitude_i * 1e-7;
         northernmost = max(northernmost, latNode);
         southernmost = min(southernmost, latNode);
 
         // Longitude is trickier
-        float lngNode = pos.longitude_i * 1e-7;
+        float lngNode = node->position.longitude_i * 1e-7;
         float degEastward = fmod(((lngNode - lngCenter) + 360), 360);      // Degrees traveled east from lngCenter to reach node
         float degWestward = abs(fmod(((lngNode - lngCenter) - 360), 360)); // Degrees traveled west from lngCenter to reach node
         if (degEastward < degWestward)
@@ -382,13 +372,10 @@ void InkHUD::MapApplet::drawLabeledMarker(meshtastic_NodeInfoLite *node)
 {
     // Find x and y position based on node's position in nodeDB
     assert(nodeDB->hasValidPosition(node));
-    meshtastic_PositionLite pos;
-    const bool hasPos = nodeDB->copyNodePosition(node->num, pos);
-    assert(hasPos);
-    Marker m = calculateMarker(pos.latitude_i * 1e-7,  // Lat, converted from Meshtastic's internal int32 style
-                               pos.longitude_i * 1e-7, // Long, converted from Meshtastic's internal int32 style
-                               node->has_hops_away,    // Is the hopsAway number valid
-                               node->hops_away         // Hops away
+    Marker m = calculateMarker(node->position.latitude_i * 1e-7,  // Lat, converted from Meshtastic's internal int32 style
+                               node->position.longitude_i * 1e-7, // Long, converted from Meshtastic's internal int32 style
+                               node->has_hops_away,               // Is the hopsAway number valid
+                               node->hops_away                    // Hops away
     );
 
     // Convert to pixel coords
@@ -529,16 +516,13 @@ void InkHUD::MapApplet::calculateAllMarkers()
         if (node->num == nodeDB->getNodeNum())
             continue;
 
-        meshtastic_PositionLite pos;
-        if (!nodeDB->copyNodePosition(node->num, pos))
-            continue;
-
         // Calculate marker and store it
-        markers.push_back(calculateMarker(pos.latitude_i * 1e-7,  // Lat, converted from Meshtastic's internal int32 style
-                                          pos.longitude_i * 1e-7, // Long, converted from Meshtastic's internal int32 style
-                                          node->has_hops_away,    // Is the hopsAway number valid
-                                          node->hops_away         // Hops away
-                                          ));
+        markers.push_back(
+            calculateMarker(node->position.latitude_i * 1e-7,  // Lat, converted from Meshtastic's internal int32 style
+                            node->position.longitude_i * 1e-7, // Long, converted from Meshtastic's internal int32 style
+                            node->has_hops_away,               // Is the hopsAway number valid
+                            node->hops_away                    // Hops away
+                            ));
     }
 }
 

src/graphics/niche/InkHUD/Applets/Bases/NodeList/NodeListApplet.cpp

@@ -50,23 +50,21 @@ ProcessMessage InkHUD::NodeListApplet::handleReceived(const meshtastic_MeshPacke
     c.signal = getSignalStrength(mp.rx_snr, mp.rx_rssi);
 
     // Assemble info: from nodeDB (needed to detect changes)
-    const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(c.nodeNum);
-    const meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(c.nodeNum);
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
     if (node) {
         if (node->has_hops_away)
             c.hopsAway = node->hops_away;
 
         if (nodeDB->hasValidPosition(node) && nodeDB->hasValidPosition(ourNode)) {
-            meshtastic_PositionLite ourPos;
-            meshtastic_PositionLite theirPos;
-            if (nodeDB->copyNodePosition(ourNode->num, ourPos) && nodeDB->copyNodePosition(node->num, theirPos)) {
-                float ourLat = ourPos.latitude_i * 1e-7;
-                float ourLong = ourPos.longitude_i * 1e-7;
-                float theirLat = theirPos.latitude_i * 1e-7;
-                float theirLong = theirPos.longitude_i * 1e-7;
+            // Get lat and long as float
+            // Meshtastic stores these as integers internally
+            float ourLat = ourNode->position.latitude_i * 1e-7;
+            float ourLong = ourNode->position.longitude_i * 1e-7;
+            float theirLat = node->position.latitude_i * 1e-7;
+            float theirLong = node->position.longitude_i * 1e-7;
 
-                c.distanceMeters = (int32_t)GeoCoord::latLongToMeter(theirLat, theirLong, ourLat, ourLong);
-            }
+            c.distanceMeters = (int32_t)GeoCoord::latLongToMeter(theirLat, theirLong, ourLat, ourLong);
         }
     }
 
@@ -181,8 +179,8 @@ void InkHUD::NodeListApplet::onRender(bool full)
         // -- Longname --
         // Parse special chars in long name
         // Use node id if unknown
-        if (nodeInfoLiteHasUser(node))
-            longName = parse(node->long_name); // Found in nodeDB
+        if (node && node->has_user)
+            longName = parse(node->user.long_name); // Found in nodeDB
         else {
             // Not found in nodeDB, show a hex nodeid instead
             longName = hexifyNodeNum(nodeNum);

src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.cpp

@@ -2090,7 +2090,7 @@ void InkHUD::MenuApplet::populateRecipientPage()
 
     // Count favorites
     for (uint32_t i = 0; i < nodeCount; i++) {
-        if (nodeInfoLiteIsFavorite(nodeDB->getMeshNodeByIndex(i)))
+        if (nodeDB->getMeshNodeByIndex(i)->is_favorite)
             favoriteCount++;
     }
 
@@ -2098,10 +2098,10 @@ void InkHUD::MenuApplet::populateRecipientPage()
     // Don't want some monstrous list that takes 100 clicks to reach exit
     if (favoriteCount < 20) {
         for (uint32_t i = 0; i < nodeCount; i++) {
-            const meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
+            meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
 
             // Skip node if not a favorite
-            if (!nodeInfoLiteIsFavorite(node))
+            if (!node->is_favorite)
                 continue;
 
             CannedMessages::RecipientItem r;
@@ -2111,8 +2111,8 @@ void InkHUD::MenuApplet::populateRecipientPage()
 
             // Set a label for the menu item
             r.label = "DM: ";
-            if (nodeInfoLiteHasUser(node))
-                r.label += parse(node->long_name);
+            if (node->has_user)
+                r.label += parse(node->user.long_name);
             else
                 r.label += hexifyNodeNum(node->num); // Unsure if it's possible to favorite a node without NodeInfo?
 

src/graphics/niche/InkHUD/Applets/System/Notification/NotificationApplet.cpp

@@ -241,7 +241,7 @@ std::string InkHUD::NotificationApplet::getNotificationText(uint16_t widthAvaila
         text += msgIsBroadcast ? "From:" : "DM: ";
 
         // Sender id
-        if (nodeInfoLiteHasUser(node))
+        if (node && node->has_user)
             text += parseShortName(node);
         else
             text += hexifyNodeNum(message->sender);
@@ -255,7 +255,7 @@ std::string InkHUD::NotificationApplet::getNotificationText(uint16_t widthAvaila
             text += msgIsBroadcast ? "Msg from " : "DM from ";
 
             // Sender id
-            if (nodeInfoLiteHasUser(node))
+            if (node && node->has_user)
                 text += parseShortName(node);
             else
                 text += hexifyNodeNum(message->sender);

src/graphics/niche/InkHUD/Applets/User/AllMessage/AllMessageApplet.cpp

@@ -70,10 +70,10 @@ void InkHUD::AllMessageApplet::onRender(bool full)
     // - short name and long name, if available, or
     // - node id
     meshtastic_NodeInfoLite *sender = nodeDB->getMeshNode(message->sender);
-    if (nodeInfoLiteHasUser(sender)) {
+    if (sender && sender->has_user) {
         header += parseShortName(sender); // May be last-four of node if unprintable (emoji, etc)
         header += " (";
-        header += parse(sender->long_name);
+        header += parse(sender->user.long_name);
         header += ")";
     } else
         header += hexifyNodeNum(message->sender);

src/graphics/niche/InkHUD/Applets/User/AllMessage/AllMessageApplet.h

@@ -5,8 +5,9 @@
 Shows the latest incoming text message, as well as sender.
 Both broadcast and direct messages will be shown here, from all channels.
 
+This module doesn't doesn't use the devicestate.rx_text_message,' as this is overwritten to contain outgoing messages
 This module doesn't collect its own text message. Instead, the WindowManager stores the most recent incoming text message.
-This is available to any interested modules (SingleMessageApplet, NotificationApplet etc.) via InkHUD::latestMessage
+This is available to any interested modules (SingeMessageApplet, NotificationApplet etc.) via InkHUD::latestMessage
 
 We do still receive notifications from the text message module though,
 to know when a new message has arrived, and trigger the update.
@@ -45,4 +46,4 @@ class AllMessageApplet : public Applet
 
 } // namespace NicheGraphics::InkHUD
 
-#endif
+#endif

src/graphics/niche/InkHUD/Applets/User/DM/DMApplet.cpp

@@ -66,10 +66,10 @@ void InkHUD::DMApplet::onRender(bool full)
     // - shortname and long name, if available, or
     // - node id
     meshtastic_NodeInfoLite *sender = nodeDB->getMeshNode(latestMessage->dm.sender);
-    if (nodeInfoLiteHasUser(sender)) {
+    if (sender && sender->has_user) {
         header += parseShortName(sender); // May be last-four of node if unprintable (emoji, etc)
         header += " (";
-        header += parse(sender->long_name);
+        header += parse(sender->user.long_name);
         header += ")";
     } else
         header += hexifyNodeNum(latestMessage->dm.sender);

src/graphics/niche/InkHUD/Applets/User/DM/DMApplet.h

@@ -3,10 +3,11 @@
 /*
 
 Shows the latest incoming *Direct Message* (DM), as well as sender.
-This complements the threaded message applets
+This compliments the threaded message applets
 
+This module doesn't doesn't use the devicestate.rx_text_message,' as this is overwritten to contain outgoing messages
 This module doesn't collect its own text message. Instead, the WindowManager stores the most recent incoming text message.
-This is available to any interested modules (SingleMessageApplet, NotificationApplet etc.) via InkHUD::latestMessage
+This is available to any interested modules (SingeMessageApplet, NotificationApplet etc.) via InkHUD::latestMessage
 
 We do still receive notifications from the text message module though,
 to know when a new message has arrived, and trigger the update.
@@ -45,4 +46,4 @@ class DMApplet : public Applet
 
 } // namespace NicheGraphics::InkHUD
 
-#endif
+#endif

src/graphics/niche/InkHUD/Applets/User/FavoritesMap/FavoritesMapApplet.cpp

@@ -8,7 +8,7 @@ using namespace NicheGraphics;
 bool InkHUD::FavoritesMapApplet::shouldDrawNode(meshtastic_NodeInfoLite *node)
 {
     // Keep our own node available as map anchor/center; all others must be favorited.
-    return node && (node->num == nodeDB->getNodeNum() || nodeInfoLiteIsFavorite(node));
+    return node && (node->num == nodeDB->getNodeNum() || node->is_favorite);
 }
 
 void InkHUD::FavoritesMapApplet::onRender(bool full)
@@ -25,7 +25,7 @@ void InkHUD::FavoritesMapApplet::onRender(bool full)
 
     // Draw our latest "node of interest" as a special marker.
     meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(lastFrom);
-    if (node && nodeInfoLiteIsFavorite(node) && nodeDB->hasValidPosition(node) && enoughMarkers())
+    if (node && node->is_favorite && nodeDB->hasValidPosition(node) && enoughMarkers())
         drawLabeledMarker(node);
 }
 
@@ -74,7 +74,7 @@ ProcessMessage InkHUD::FavoritesMapApplet::handleReceived(const meshtastic_MeshP
     } else {
         // For non-local packets, this applet only reacts to favorited nodes.
         const meshtastic_NodeInfoLite *sender = nodeDB->getMeshNode(mp.from);
-        if (!nodeInfoLiteIsFavorite(sender))
+        if (!sender || !sender->is_favorite)
             return ProcessMessage::CONTINUE;
 
         // Check if this position is from someone different than our previous position packet.

src/graphics/niche/InkHUD/Applets/User/Heard/HeardApplet.cpp

@@ -80,8 +80,8 @@ void InkHUD::HeardApplet::populateFromNodeDB()
         ordered.resize(maxCards());
 
     // Create card info for these (stale) node observations
-    const meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
-    for (const meshtastic_NodeInfoLite *node : ordered) {
+    meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
+    for (meshtastic_NodeInfoLite *node : ordered) {
         CardInfo c;
         c.nodeNum = node->num;
 
@@ -89,16 +89,14 @@ void InkHUD::HeardApplet::populateFromNodeDB()
             c.hopsAway = node->hops_away;
 
         if (nodeDB->hasValidPosition(node) && nodeDB->hasValidPosition(ourNode)) {
-            meshtastic_PositionLite ourPos;
-            meshtastic_PositionLite theirPos;
-            if (nodeDB->copyNodePosition(ourNode->num, ourPos) && nodeDB->copyNodePosition(node->num, theirPos)) {
-                float ourLat = ourPos.latitude_i * 1e-7;
-                float ourLong = ourPos.longitude_i * 1e-7;
-                float theirLat = theirPos.latitude_i * 1e-7;
-                float theirLong = theirPos.longitude_i * 1e-7;
+            // Get lat and long as float
+            // Meshtastic stores these as integers internally
+            float ourLat = ourNode->position.latitude_i * 1e-7;
+            float ourLong = ourNode->position.longitude_i * 1e-7;
+            float theirLat = node->position.latitude_i * 1e-7;
+            float theirLong = node->position.longitude_i * 1e-7;
 
-                c.distanceMeters = (int32_t)GeoCoord::latLongToMeter(theirLat, theirLong, ourLat, ourLong);
-            }
+            c.distanceMeters = (int32_t)GeoCoord::latLongToMeter(theirLat, theirLong, ourLat, ourLong);
         }
 
         // Insert into the card collection (member of base class)
@@ -124,4 +122,4 @@ std::string InkHUD::HeardApplet::getHeaderText()
     return text;
 }
 
-#endif
+#endif

src/graphics/niche/InkHUD/Events.cpp

@@ -525,7 +525,7 @@ int InkHUD::Events::beforeReboot(void *unused)
 // Callback when a new text message is received
 // Caches the most recently received message, for use by applets
 // Rx does not trigger a save to flash, however the data *will* be saved alongside other during shutdown, etc.
-// Note: this is intentionally separate from device-state message fields.
+// Note: this is different from devicestate.rx_text_message, which may contain an *outgoing* message
 int InkHUD::Events::onReceiveTextMessage(const meshtastic_MeshPacket *packet)
 {
     // Short circuit: don't store outgoing messages

src/graphics/niche/InkHUD/MessageStore.cpp

@@ -53,10 +53,11 @@ void InkHUD::MessageStore::saveToFlash()
         f.write(reinterpret_cast<const uint8_t *>(&m.timestamp), sizeof(m.timestamp));       // Write timestamp. 4 bytes
         f.write(reinterpret_cast<const uint8_t *>(&m.sender), sizeof(m.sender));             // Write sender NodeId. 4 Bytes
         f.write(reinterpret_cast<const uint8_t *>(&m.channelIndex), sizeof(m.channelIndex)); // Write channel index. 1 Byte
-        f.write(reinterpret_cast<const uint8_t *>(m.text.c_str()), min(MAX_MESSAGE_SIZE, m.text.size())); // Write message text
-        f.write('\0');                                                                                    // Append null term
-        LOG_DEBUG("Wrote message %u, length %u, text \"%s\"", static_cast<uint32_t>(i), min(MAX_MESSAGE_SIZE, m.text.size()),
-                  m.text.c_str());
+        f.write(reinterpret_cast<const uint8_t *>(m.text.c_str()),
+                min((size_t)MAX_MESSAGE_SIZE, m.text.size())); // Write message text
+        f.write('\0');                                         // Append null term
+        LOG_DEBUG("Wrote message %u, length %u, text \"%s\"", static_cast<uint32_t>(i),
+                  min((size_t)MAX_MESSAGE_SIZE, m.text.size()), m.text.c_str());
     }
 
     // Release firmware's SPI lock, because SafeFile::close needs it

src/graphics/niche/InkHUD/Persistence.h

@@ -121,7 +121,8 @@ class Persistence
 
     // Most recently received text message
     // Value is updated by InkHUD::WindowManager, as a courtesy to applets
-    // InkHUD keeps its own latest-message cache for applets.
+    // Note: different from devicestate.rx_text_message,
+    // which may contain an *outgoing message* to broadcast
     struct LatestMessage {
         MessageStore::Message broadcast; // Most recent message received broadcast
         MessageStore::Message dm;        // Most recent received DM

src/graphics/niche/InkHUD/docs/README.md

@@ -464,7 +464,7 @@ Most recently received text message
 
 Collected here, so various user applets don't all have to store their own copy of this info.
 
-We keep this separate latest-message cache for this purpose, because:
+We are unable to use `devicestate.rx_text_message` for this purpose, because:
 
 - it is cleared by an outgoing text message
 - we want to store both a recent broadcast and a recent DM

src/input/ExpressLRSFiveWay.h

@@ -13,6 +13,8 @@
 
 #ifdef INPUTBROKER_EXPRESSLRSFIVEWAY_TYPE
 
+// REVISIT esp_adc_cal.h
+// "legacy adc calibration driver is deprecated, please migrate to use esp_adc/adc_cali.h and esp_adc/adc_cali_scheme.h"
 #include <esp_adc_cal.h>
 #include <soc/adc_channel.h>
 

src/input/RotaryEncoderImpl.cpp

@@ -13,6 +13,7 @@ RotaryEncoderImpl *rotaryEncoderImpl;
 
 RotaryEncoderImpl::RotaryEncoderImpl()
 {
+    rotary = nullptr;
 #ifdef ARCH_ESP32
     isFirstInit = true;
 #endif
@@ -22,6 +23,11 @@ RotaryEncoderImpl::~RotaryEncoderImpl()
 {
     LOG_DEBUG("RotaryEncoderImpl destructor");
     detachRotaryEncoderInterrupts();
+
+    if (rotary != nullptr) {
+        delete rotary;
+        rotary = nullptr;
+    }
 }
 
 bool RotaryEncoderImpl::init()
@@ -37,9 +43,8 @@ bool RotaryEncoderImpl::init()
     eventPressed = static_cast<input_broker_event>(moduleConfig.canned_message.inputbroker_event_press);
 
     if (rotary == nullptr) {
-        rotary.reset(new RotaryEncoder(moduleConfig.canned_message.inputbroker_pin_a,
-                                       moduleConfig.canned_message.inputbroker_pin_b,
-                                       moduleConfig.canned_message.inputbroker_pin_press));
+        rotary = new RotaryEncoder(moduleConfig.canned_message.inputbroker_pin_a, moduleConfig.canned_message.inputbroker_pin_b,
+                                   moduleConfig.canned_message.inputbroker_pin_press);
     }
 
     attachRotaryEncoderInterrupts();

src/input/RotaryEncoderImpl.h

@@ -5,7 +5,6 @@
 #include "InputBroker.h"
 #include "concurrency/OSThread.h"
 #include "mesh/NodeDB.h"
-#include <memory>
 
 class RotaryEncoder;
 
@@ -29,7 +28,7 @@ class RotaryEncoderImpl final : public InputPollable
     input_broker_event eventCcw = INPUT_BROKER_NONE;
     input_broker_event eventPressed = INPUT_BROKER_NONE;
 
-    std::unique_ptr<RotaryEncoder> rotary;
+    RotaryEncoder *rotary;
 
   private:
 #ifdef ARCH_ESP32

src/input/TLoraPagerKeyboard.cpp

@@ -68,7 +68,7 @@ TLoraPagerKeyboard::TLoraPagerKeyboard()
     : TCA8418KeyboardBase(_TCA8418_ROWS, _TCA8418_COLS), modifierFlag(0), last_modifier_time(0), last_key(UINT8_MAX),
       next_key(UINT8_MAX), last_tap(0L), char_idx(0), tap_interval(0)
 {
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
     ledcAttach(KB_BL_PIN, LEDC_BACKLIGHT_FREQ, LEDC_BACKLIGHT_BIT_WIDTH);
 #else
     ledcSetup(LEDC_BACKLIGHT_CHANNEL, LEDC_BACKLIGHT_FREQ, LEDC_BACKLIGHT_BIT_WIDTH);
@@ -108,7 +108,7 @@ void TLoraPagerKeyboard::setBacklight(bool on)
     uint32_t _brightness = 0;
     if (on)
         _brightness = brightness;
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
     ledcWrite(KB_BL_PIN, _brightness);
 #else
     ledcWrite(LEDC_BACKLIGHT_CHANNEL, _brightness);

src/main.cpp

@@ -49,8 +49,7 @@
 #include "mesh/http/WebServer.h"
 #endif
 #if !MESHTASTIC_EXCLUDE_BLUETOOTH
-#include "nimble/NimbleBluetooth.h"
-NimbleBluetooth *nimbleBluetooth = nullptr;
+BluetoothApi *bluetoothApi = nullptr;
 #endif
 #endif
 
@@ -731,15 +730,8 @@ void setup()
 #elif defined(USE_SH1107_128_64)
     screen_model = meshtastic_Config_DisplayConfig_OledType_OLED_SH1107; // keep dimension of 128x64
 #else
-    if (config.display.oled != meshtastic_Config_DisplayConfig_OledType_OLED_AUTO) {
+    if (config.display.oled != meshtastic_Config_DisplayConfig_OledType_OLED_AUTO)
         screen_model = config.display.oled;
-
-        // Fix: update geometry for SH1107 128x128 selected via menu
-        if (screen_model == meshtastic_Config_DisplayConfig_OledType_OLED_SH1107_128_128) {
-            screen_geometry = GEOMETRY_128_128;
-            screen_model = meshtastic_Config_DisplayConfig_OledType_OLED_SH1107; // normalize
-        }
-    }
 #endif
 #endif
 

src/main.h

@@ -12,8 +12,8 @@
 #include <SPI.h>
 #include <map>
 #if defined(ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32S2)
-#include "nimble/NimbleBluetooth.h"
-extern NimbleBluetooth *nimbleBluetooth;
+#include "BluetoothCommon.h"
+extern BluetoothApi *bluetoothApi;
 #endif
 #ifdef ARCH_NRF52
 #include "NRF52Bluetooth.h"

src/mesh/CryptoEngine.cpp

@@ -112,7 +112,7 @@ bool CryptoEngine::ensurePkiKeys(meshtastic_Config_SecurityConfig &security, mes
  * @param bytes Buffer containing plaintext input.
  * @param bytesOut Output buffer to be populated with encrypted ciphertext.
  */
-bool CryptoEngine::encryptCurve25519(uint32_t toNode, uint32_t fromNode, meshtastic_NodeInfoLite_public_key_t remotePublic,
+bool CryptoEngine::encryptCurve25519(uint32_t toNode, uint32_t fromNode, meshtastic_UserLite_public_key_t remotePublic,
                                      uint64_t packetNum, size_t numBytes, const uint8_t *bytes, uint8_t *bytesOut)
 {
     uint8_t *auth;
@@ -152,7 +152,7 @@ bool CryptoEngine::encryptCurve25519(uint32_t toNode, uint32_t fromNode, meshtas
  * @param bytes Buffer containing ciphertext input.
  * @param bytesOut Output buffer to be populated with decrypted plaintext.
  */
-bool CryptoEngine::decryptCurve25519(uint32_t fromNode, meshtastic_NodeInfoLite_public_key_t remotePublic, uint64_t packetNum,
+bool CryptoEngine::decryptCurve25519(uint32_t fromNode, meshtastic_UserLite_public_key_t remotePublic, uint64_t packetNum,
                                      size_t numBytes, const uint8_t *bytes, uint8_t *bytesOut)
 {
     const uint8_t *auth = bytes + numBytes - 12; // set to last 8 bytes of text?

src/mesh/CryptoEngine.h

@@ -40,12 +40,9 @@ class CryptoEngine
 
 #endif
     void setDHPrivateKey(uint8_t *_private_key);
-    // The remotePublic key parameter takes the public_key bytes container from
-    // a stored node header. NodeInfoLite is the on-device storage type since
-    // the slim refactor flattened UserLite into it.
-    virtual bool encryptCurve25519(uint32_t toNode, uint32_t fromNode, meshtastic_NodeInfoLite_public_key_t remotePublic,
+    virtual bool encryptCurve25519(uint32_t toNode, uint32_t fromNode, meshtastic_UserLite_public_key_t remotePublic,
                                    uint64_t packetNum, size_t numBytes, const uint8_t *bytes, uint8_t *bytesOut);
-    virtual bool decryptCurve25519(uint32_t fromNode, meshtastic_NodeInfoLite_public_key_t remotePublic, uint64_t packetNum,
+    virtual bool decryptCurve25519(uint32_t fromNode, meshtastic_UserLite_public_key_t remotePublic, uint64_t packetNum,
                                    size_t numBytes, const uint8_t *bytes, uint8_t *bytesOut);
     virtual bool setDHPublicKey(uint8_t *publicKey);
     virtual void hash(uint8_t *bytes, size_t numBytes);

src/mesh/InterfacesTemplates.cpp

@@ -1,9 +1,5 @@
-#include "configuration.h"
-
 #include "LR11x0Interface.cpp"
 #include "LR11x0Interface.h"
-#include "LR20x0Interface.cpp"
-#include "LR20x0Interface.h"
 #include "SX126xInterface.cpp"
 #include "SX126xInterface.h"
 #include "SX128xInterface.cpp"
@@ -25,9 +21,6 @@ template class LR11x0Interface<LR1110>;
 template class LR11x0Interface<LR1120>;
 template class LR11x0Interface<LR1121>;
 #endif
-#if defined(USE_LR2021) && RADIOLIB_EXCLUDE_LR2021 != 1
-template class LR20x0Interface<LR2021>;
-#endif
 #ifdef ARCH_STM32WL
 template class SX126xInterface<STM32WLx>;
 #endif

src/mesh/LR11x0Interface.cpp

@@ -57,19 +57,16 @@ template <typename T> bool LR11x0Interface<T>::init()
 #if ARCH_PORTDUINO
     float tcxoVoltage = (float)portduino_config.dio3_tcxo_voltage / 1000;
 // FIXME: correct logic to default to not using TCXO if no voltage is specified for LR11x0_DIO3_TCXO_VOLTAGE
-#elif defined(LR11X0_DIO3_TCXO_VOLTAGE)
-    float tcxoVoltage = LR11X0_DIO3_TCXO_VOLTAGE;
-    LOG_DEBUG("LR11X0_DIO3_TCXO_VOLTAGE defined, using DIO3 as TCXO reference voltage at %f V", LR11X0_DIO3_TCXO_VOLTAGE);
-    // (DIO3 is not free to be used as an IRQ)
-#elif defined(TCXO_OPTIONAL)
-    float tcxoVoltage = 1.6f; // TCXO_OPTIONAL: try default 1.6 V first, fall back to XTAL on failure
-    LOG_DEBUG("TCXO_OPTIONAL: no LR11X0_DIO3_TCXO_VOLTAGE defined, trying default TCXO Vref 1.6 V first");
-#else
+#elif !defined(LR11X0_DIO3_TCXO_VOLTAGE)
     float tcxoVoltage =
         0; // "TCXO reference voltage to be set on DIO3. Defaults to 1.6 V, set to 0 to skip." per
            // https://github.com/jgromes/RadioLib/blob/690a050ebb46e6097c5d00c371e961c1caa3b52e/src/modules/LR11x0/LR11x0.h#L471C26-L471C104
     // (DIO3 is free to be used as an IRQ)
     LOG_DEBUG("LR11X0_DIO3_TCXO_VOLTAGE not defined, not using DIO3 as TCXO reference voltage");
+#else
+    float tcxoVoltage = LR11X0_DIO3_TCXO_VOLTAGE;
+    LOG_DEBUG("LR11X0_DIO3_TCXO_VOLTAGE defined, using DIO3 as TCXO reference voltage at %f V", LR11X0_DIO3_TCXO_VOLTAGE);
+    // (DIO3 is not free to be used as an IRQ)
 #endif
 
     RadioLibInterface::init();
@@ -104,17 +101,6 @@ template <typename T> bool LR11x0Interface<T>::init()
         res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage);
     }
 
-#if defined(TCXO_OPTIONAL)
-    // If init failed for any reason other than chip not found, retry without TCXO (XTAL mode)
-    if (res != RADIOLIB_ERR_NONE && res != RADIOLIB_ERR_CHIP_NOT_FOUND && tcxoVoltage > 0) {
-        LOG_WARN("LR11x0 init failed with TCXO Vref %f V (err %d), retrying without TCXO", tcxoVoltage, res);
-        tcxoVoltage = 0;
-        res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage);
-        if (res == RADIOLIB_ERR_NONE)
-            LOG_INFO("LR11x0 init success without TCXO (XTAL mode)");
-    }
-#endif
-
     // \todo Display actual typename of the adapter, not just `LR11x0`
     LOG_INFO("LR11x0 init result %d", res);
     if (res == RADIOLIB_ERR_CHIP_NOT_FOUND || res == RADIOLIB_ERR_SPI_CMD_FAILED)
@@ -212,7 +198,7 @@ template <typename T> bool LR11x0Interface<T>::reconfigure()
 
     startReceive(); // restart receiving
 
-    return true;
+    return RADIOLIB_ERR_NONE;
 }
 
 template <typename T> void LR11x0Interface<T>::disableInterrupt()

src/mesh/LR2021Interface.cpp

@@ -1,18 +0,0 @@
-#include "configuration.h"
-
-#if defined(USE_LR2021) && RADIOLIB_EXCLUDE_LR2021 != 1
-
-#include "LR2021Interface.h"
-#include "error.h"
-
-LR2021Interface::LR2021Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
-                                 RADIOLIB_PIN_TYPE busy)
-    : LR20x0Interface(hal, cs, irq, rst, busy)
-{
-}
-
-bool LR2021Interface::wideLora()
-{
-    return true;
-}
-#endif

src/mesh/LR2021Interface.h

@@ -1,15 +0,0 @@
-#pragma once
-#if RADIOLIB_EXCLUDE_LR2021 != 1
-#include "LR20x0Interface.h"
-
-/**
- * Our adapter for LR2021 radios
- */
-class LR2021Interface : public LR20x0Interface<LR2021>
-{
-  public:
-    LR2021Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
-                    RADIOLIB_PIN_TYPE busy);
-    bool wideLora() override;
-};
-#endif

src/mesh/LR20x0Interface.cpp

@@ -1,399 +0,0 @@
-#include "configuration.h"
-
-#if defined(USE_LR2021) && RADIOLIB_EXCLUDE_LR2021 != 1
-#include "LR20x0Interface.h"
-#include "error.h"
-#include "mesh/NodeDB.h"
-
-// Keep LR20x0 naming while RadioLib exposes LR2021 symbols.
-#ifndef LR20x0
-#define LR20x0 LR2021
-#endif
-
-#ifdef LR2021_DIO_AS_RF_SWITCH
-#include "rfswitch.h"
-#elif ARCH_PORTDUINO
-#include "PortduinoGlue.h"
-#define lr20x0_rfswitch_dio_pins portduino_config.rfswitch_dio_pins
-#define lr20x0_rfswitch_table portduino_config.rfswitch_table
-#else
-static const uint32_t lr20x0_rfswitch_dio_pins[] = {RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC};
-static const Module::RfSwitchMode_t lr20x0_rfswitch_table[] = {
-    {LR20x0::MODE_STBY, {}},  {LR20x0::MODE_RX, {}},    {LR20x0::MODE_TX, {}},
-    {LR20x0::MODE_RX_HF, {}}, {LR20x0::MODE_TX_HF, {}}, END_OF_MODE_TABLE,
-};
-#endif
-
-// Particular boards might define a different max power based on what their hardware can do, default to max power output if not
-// specified (may be dangerous if using external PA and LR20x0 power config forgotten)
-#if ARCH_PORTDUINO
-#define LR2021_MAX_POWER portduino_config.lr2021_max_power
-#endif
-#ifndef LR2021_MAX_POWER
-#define LR2021_MAX_POWER 22
-#endif
-
-// the 2.4G part maxes at 12dBm
-
-#if ARCH_PORTDUINO
-#define LR2021_MAX_POWER_HF portduino_config.lr2021_max_power_hf
-#endif
-#ifndef LR2021_MAX_POWER_HF
-#define LR2021_MAX_POWER_HF 12
-#endif
-
-template <typename T>
-LR20x0Interface<T>::LR20x0Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
-                                    RADIOLIB_PIN_TYPE busy)
-    : RadioLibInterface(hal, cs, irq, rst, busy, &lora), lora(&module)
-{
-    LOG_WARN("LR20x0Interface(cs=%d, irq=%d, rst=%d, busy=%d)", cs, irq, rst, busy);
-}
-
-/// Initialise the Driver transport hardware and software.
-/// Make sure the Driver is properly configured before calling init().
-/// \return true if initialisation succeeded.
-template <typename T> bool LR20x0Interface<T>::init()
-{
-#ifdef LR2021_POWER_EN
-    pinMode(LR2021_POWER_EN, OUTPUT);
-    digitalWrite(LR2021_POWER_EN, HIGH);
-#endif
-
-#if ARCH_PORTDUINO
-    float tcxoVoltage = (float)portduino_config.dio3_tcxo_voltage / 1000;
-// FIXME: correct logic to default to not using TCXO if no voltage is specified for LR20x0_DIO3_TCXO_VOLTAGE
-#elif defined(LR2021_DIO3_TCXO_VOLTAGE)
-    float tcxoVoltage = LR2021_DIO3_TCXO_VOLTAGE;
-    LOG_DEBUG("LR2021_DIO3_TCXO_VOLTAGE defined, using DIO3 as TCXO reference voltage at %f V", LR2021_DIO3_TCXO_VOLTAGE);
-    // (DIO3 is not free to be used as an IRQ)
-#elif defined(TCXO_OPTIONAL)
-    float tcxoVoltage = 1.6f; // TCXO_OPTIONAL: try default 1.6 V first, fall back to XTAL on failure
-    LOG_DEBUG("TCXO_OPTIONAL: no LR2021_DIO3_TCXO_VOLTAGE defined, trying default TCXO Vref 1.6 V first");
-#else
-    float tcxoVoltage =
-        0; // "TCXO reference voltage to be set on DIO3. Defaults to 1.6 V, set to 0 to skip." per
-           // https://github.com/jgromes/RadioLib/blob/690a050ebb46e6097c5d00c371e961c1caa3b52e/src/modules/LR11x0/LR11x0.h#L471C26-L471C104
-    // (DIO3 is free to be used as an IRQ)
-    LOG_DEBUG("LR2021_DIO3_TCXO_VOLTAGE not defined, not using DIO3 as TCXO reference voltage");
-#endif
-
-    RadioLibInterface::init();
-
-#ifdef LR2021_IRQ_DIO_NUM
-    lora.irqDioNum = LR2021_IRQ_DIO_NUM;
-    LOG_DEBUG("Set irqDioNum %d", lora.irqDioNum);
-#elif defined(IRQ_DIO_NUM)
-    lora.irqDioNum = IRQ_DIO_NUM;
-    LOG_DEBUG("Set irqDioNum %d", lora.irqDioNum);
-#else
-    LOG_DEBUG("Use default irqDioNum %d", lora.irqDioNum);
-#endif
-
-    if (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_LORA_24) { // clamp if wide freq range
-        limitPower(LR2021_MAX_POWER_HF);
-    } else {
-        limitPower(LR2021_MAX_POWER); // default clamp for non-wide freq range
-    }
-
-#ifdef LR2021_RF_SWITCH_SUBGHZ
-    pinMode(LR2021_RF_SWITCH_SUBGHZ, OUTPUT);
-    digitalWrite(LR2021_RF_SWITCH_SUBGHZ, getFreq() < 1e9 ? HIGH : LOW);
-    LOG_DEBUG("Set RF0 switch to %s", getFreq() < 1e9 ? "SubGHz" : "2.4GHz");
-#endif
-
-#ifdef LR2021_RF_SWITCH_2_4GHZ
-    pinMode(LR2021_RF_SWITCH_2_4GHZ, OUTPUT);
-    digitalWrite(LR2021_RF_SWITCH_2_4GHZ, getFreq() < 1e9 ? LOW : HIGH);
-    LOG_DEBUG("Set RF1 switch to %s", getFreq() < 1e9 ? "SubGHz" : "2.4GHz");
-#endif
-
-    // Allow extra time for TCXO to stabilize after power-on
-    delay(10);
-
-    int res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage);
-
-    // Retry if we get SPI command failed - some units need extra TCXO stabilization time
-    if (res == RADIOLIB_ERR_SPI_CMD_FAILED) {
-        LOG_WARN("LR20x0 init failed with %d (SPI_CMD_FAILED), retrying after delay...", res);
-        delay(100);
-        res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage);
-    }
-
-#if defined(TCXO_OPTIONAL)
-    // If init failed for any reason other than chip not found, retry without TCXO (XTAL mode)
-    if (res != RADIOLIB_ERR_NONE && res != RADIOLIB_ERR_CHIP_NOT_FOUND && tcxoVoltage > 0) {
-        LOG_WARN("LR20x0 init failed with TCXO Vref %f V (err %d), retrying without TCXO", tcxoVoltage, res);
-        tcxoVoltage = 0;
-        res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage);
-        if (res == RADIOLIB_ERR_NONE)
-            LOG_INFO("LR20x0 init success without TCXO (XTAL mode)");
-    }
-#endif
-
-    // \todo Display actual typename of the adapter, not just `LR20x0`
-    LOG_INFO("LR20x0 init result %d", res);
-    if (res == RADIOLIB_ERR_CHIP_NOT_FOUND || res == RADIOLIB_ERR_SPI_CMD_FAILED)
-        return false;
-
-        // Some basic info about the module's explicit firmware version - no other info available
-        // Currently requires radiolib godmode
-
-#if RADIOLIB_GODMODE
-    uint8_t fwMajor = 0;
-    uint8_t fwMinor = 0;
-    int versionRes = lora.getVersion(&fwMajor, &fwMinor);
-    if (versionRes == RADIOLIB_ERR_NONE)
-        LOG_DEBUG("LR20x0 FW %d.%d", fwMajor, fwMinor);
-#endif
-
-    LOG_INFO("Frequency set to %f", getFreq());
-    LOG_INFO("Bandwidth set to %f", bw);
-    LOG_INFO("Power output set to %d", power);
-
-    if (res == RADIOLIB_ERR_NONE)
-        res = lora.setCRC(2);
-
-        // Standard DCDC ramp timing from RadioLib workarounds (register 0x00F20024)
-        // Currently requires radiolib godmode
-#if RADIOLIB_GODMODE
-    if (res == RADIOLIB_ERR_NONE) {
-        uint8_t rampTimes[4] = {15, 15, 15, 15}; // Standard case for all conditions
-        res = lora.setRegMode(RADIOLIB_LR2021_REG_MODE_SIMO_NORMAL, rampTimes);
-        if (res != RADIOLIB_ERR_NONE)
-            LOG_WARN("LR2021 setRegMode failed: %d", res);
-    }
-#endif
-
-#ifdef LR2021_DIO_AS_RF_SWITCH
-    bool dioAsRfSwitch = true;
-#elif defined(ARCH_PORTDUINO)
-    bool dioAsRfSwitch = portduino_config.has_rfswitch_table;
-#else
-    bool dioAsRfSwitch = false;
-#endif
-
-    if (dioAsRfSwitch) {
-        lora.setRfSwitchTable(lr20x0_rfswitch_dio_pins, lr20x0_rfswitch_table);
-        LOG_DEBUG("Set DIO RF switch");
-    }
-
-    if (res == RADIOLIB_ERR_NONE) {
-        if (config.lora.sx126x_rx_boosted_gain) { // the name is unfortunate but historically accurate
-            res = lora.setRxBoostedGainMode(true);
-            LOG_INFO("Set RX gain to boosted mode; result: %d", res);
-        } else {
-            res = lora.setRxBoostedGainMode(false);
-            LOG_INFO("Set RX gain to power saving mode (boosted mode off); result: %d", res);
-        }
-    }
-
-    if (res == RADIOLIB_ERR_NONE)
-        startReceive(); // start receiving
-
-    return res == RADIOLIB_ERR_NONE;
-}
-
-template <typename T> bool LR20x0Interface<T>::reconfigure()
-{
-    RadioLibInterface::reconfigure();
-
-    // set mode to standby
-    setStandby();
-
-    // configure publicly accessible settings
-    int err = lora.setSpreadingFactor(sf);
-    if (err != RADIOLIB_ERR_NONE)
-        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
-
-    err = lora.setBandwidth(bw); // different form than LR11xx
-    if (err != RADIOLIB_ERR_NONE)
-        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
-
-    err = lora.setCodingRate(cr, cr != 7); // use long interleaving except if CR is 4/7 which doesn't support it
-    if (err != RADIOLIB_ERR_NONE)
-        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
-
-    err = lora.setSyncWord(syncWord);
-    assert(err == RADIOLIB_ERR_NONE);
-
-    if (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_LORA_24) { // clamp if wide freq range
-        limitPower(LR2021_MAX_POWER_HF);
-    } else {
-        limitPower(LR2021_MAX_POWER); // default clamp for non-wide freq range
-    }
-
-    err = lora.setPreambleLength(preambleLength);
-    assert(err == RADIOLIB_ERR_NONE);
-
-    err = lora.setFrequency(getFreq());
-    if (err != RADIOLIB_ERR_NONE)
-        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
-
-    err = lora.setOutputPower(power);
-    assert(err == RADIOLIB_ERR_NONE);
-
-    // Apply RX gain mode — valid in STDBY, matches resetAGC() pattern
-    err = lora.setRxBoostedGainMode(config.lora.sx126x_rx_boosted_gain);
-    if (err != RADIOLIB_ERR_NONE)
-        LOG_WARN("LR20x0 setRxBoostedGainMode %s%d", radioLibErr, err);
-
-    startReceive(); // restart receiving
-
-    return true;
-}
-
-template <typename T> void LR20x0Interface<T>::disableInterrupt()
-{
-    lora.clearIrqAction();
-}
-
-template <typename T> void LR20x0Interface<T>::setStandby()
-{
-    checkNotification(); // handle any pending interrupts before we force standby
-
-    int err = lora.standby();
-
-    if (err != RADIOLIB_ERR_NONE) {
-        LOG_DEBUG("LR20x0 standby failed with error %d", err);
-    }
-
-    assert(err == RADIOLIB_ERR_NONE);
-
-    isReceiving = false; // If we were receiving, not any more
-    activeReceiveStart = 0;
-    disableInterrupt();
-    completeSending(); // If we were sending, not anymore
-    RadioLibInterface::setStandby();
-}
-
-/**
- * Add SNR data to received messages
- */
-template <typename T> void LR20x0Interface<T>::addReceiveMetadata(meshtastic_MeshPacket *mp)
-{
-    // LOG_DEBUG("PacketStatus %x", lora.getPacketStatus());
-    mp->rx_snr = lora.getSNR();
-    mp->rx_rssi = lround(lora.getRSSI());
-    // LOG_DEBUG("Corrected frequency offset: %f", lora.getFrequencyError()); // not implemented for LR20x0, but noop for LR11x0
-    // too(!)
-}
-
-/** We override to turn on transmitter power as needed.
- */
-template <typename T> void LR20x0Interface<T>::configHardwareForSend()
-{
-    RadioLibInterface::configHardwareForSend();
-}
-
-// For power draw measurements, helpful to force radio to stay sleeping
-// #define SLEEP_ONLY
-
-template <typename T> void LR20x0Interface<T>::startReceive()
-{
-#ifdef SLEEP_ONLY
-    sleep();
-#else
-
-    setStandby();
-
-    lora.setPreambleLength(preambleLength); // Solve RX ack fail after direct message sent.  Not sure why this is needed.
-
-    // We use a 16 bit preamble so this should save some power by letting radio sit in standby mostly.
-    int err =
-        lora.startReceive(RADIOLIB_LR2021_RX_TIMEOUT_INF, MESHTASTIC_RADIOLIB_IRQ_RX_FLAGS, RADIOLIB_IRQ_RX_DEFAULT_MASK, 0);
-    if (err)
-        LOG_ERROR("StartReceive error: %d", err);
-    assert(err == RADIOLIB_ERR_NONE);
-
-    RadioLibInterface::startReceive();
-
-    // Must be done AFTER starting receive, because startReceive clears (possibly stale) interrupt pending register bits
-    enableInterrupt(isrRxLevel0);
-    checkRxDoneIrqFlag();
-#endif
-}
-
-/** Is the channel currently active? */
-template <typename T> bool LR20x0Interface<T>::isChannelActive()
-{
-    // check if we can detect a LoRa preamble on the current channel
-    ChannelScanConfig_t cfg = {.cad = {.symNum = NUM_SYM_CAD,
-                                       .detPeak = RADIOLIB_LR2021_CAD_PARAM_DEFAULT,
-                                       .detMin = RADIOLIB_LR2021_CAD_PARAM_DEFAULT,
-                                       .exitMode = RADIOLIB_LR2021_CAD_PARAM_DEFAULT,
-                                       .timeout = 0,
-                                       .irqFlags = RADIOLIB_IRQ_CAD_DEFAULT_FLAGS,
-                                       .irqMask = RADIOLIB_IRQ_CAD_DEFAULT_MASK}};
-    int16_t result;
-
-    setStandby();
-    result = lora.scanChannel(cfg);
-    if (result == RADIOLIB_LORA_DETECTED)
-        return true;
-
-    assert(result != RADIOLIB_ERR_WRONG_MODEM);
-
-    return false;
-}
-
-/** Could we send right now (i.e. either not actively receiving or transmitting)? */
-template <typename T> bool LR20x0Interface<T>::isActivelyReceiving()
-{
-    // The IRQ status will be cleared when we start our read operation. Check if we've started a header, but haven't yet
-    // received and handled the interrupt for reading the packet/handling errors.
-    return receiveDetected(lora.getIrqStatus(), RADIOLIB_LR2021_IRQ_LORA_HEADER_VALID, RADIOLIB_LR2021_IRQ_PREAMBLE_DETECTED);
-}
-
-#ifdef LR20X0_AGC_RESET
-template <typename T> void LR20x0Interface<T>::resetAGC()
-{
-    // Safety: don't reset mid-packet
-    if (sendingPacket != NULL || (isReceiving && isActivelyReceiving()))
-        return;
-
-    LOG_DEBUG("LR20x0 AGC reset: warm sleep + Calibrate(0x3F)");
-
-    // 1. Warm sleep — powers down the analog frontend, resetting AGC state
-    lora.sleep(true, 0);
-
-    // 2. Wake to RC standby for stable calibration
-    lora.standby(RADIOLIB_LR20X0_STANDBY_RC, true);
-
-    // 3. Calibrate all blocks (PLL, ADC, image, RC oscillators)
-    //    calibrate() is protected on LR20x0, so use raw SPI (same as internal implementation)
-    uint8_t calData = RADIOLIB_LR20X0_CALIBRATE_ALL;
-    module.SPIwriteStream(RADIOLIB_LR20X0_CMD_CALIBRATE, &calData, 1, true, true);
-
-    // 4. Re-calibrate image rejection for actual operating frequency
-    //    Calibrate(0x3F) defaults to 902-928 MHz which is wrong for other regions.
-    lora.calibrateImageRejection(getFreq() - 4.0f, getFreq() + 4.0f);
-
-    // 5. Re-apply RX boosted gain mode
-    lora.setRxBoostedGainMode(config.lora.sx126x_rx_boosted_gain);
-
-    // 6. Resume receiving
-    startReceive();
-}
-#endif
-
-template <typename T> bool LR20x0Interface<T>::sleep()
-{
-    // \todo Display actual typename of the adapter, not just `LR20x0`
-    LOG_DEBUG("LR20x0 entering sleep mode");
-    setStandby(); // Stop any pending operations
-
-    // turn off TCXO if it was powered
-    lora.setTCXO(0);
-
-    // put chipset into sleep mode (we've already disabled interrupts by now)
-    bool keepConfig = false;
-    lora.sleep(keepConfig, 0); // Note: we do not keep the config, full reinit will be needed
-
-#ifdef LR2021_POWER_EN
-    digitalWrite(LR2021_POWER_EN, LOW);
-#endif
-
-    return true;
-}
-#endif

src/mesh/LR20x0Interface.h

@@ -1,75 +0,0 @@
-#pragma once
-#if RADIOLIB_EXCLUDE_LR2021 != 1
-#include "RadioLibInterface.h"
-
-/**
- * \brief Adapter for LR20x0 radio family. Implements common logic for child classes.
- * \tparam T RadioLib module type for LR20x0, e.g. LR2021.
- */
-template <class T> class LR20x0Interface : public RadioLibInterface
-{
-  public:
-    LR20x0Interface(LockingArduinoHal *hal, RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst,
-                    RADIOLIB_PIN_TYPE busy);
-
-    /// Initialise the Driver transport hardware and software.
-    /// Make sure the Driver is properly configured before calling init().
-    /// \return true if initialisation succeeded.
-    virtual bool init() override;
-
-    /// Apply any radio provisioning changes
-    /// Make sure the Driver is properly configured before calling init().
-    /// \return true if initialisation succeeded.
-    virtual bool reconfigure() override;
-
-    /// Prepare hardware for sleep.  Call this _only_ for deep sleep, not needed for light sleep.
-    virtual bool sleep() override;
-
-    bool isIRQPending() override { return lora.getIrqFlags() != 0; }
-
-#ifdef LR20X0_AGC_RESET
-    void resetAGC() override;
-#endif
-
-  protected:
-    /**
-     * Specific module instance
-     */
-    T lora;
-
-    /**
-     * Glue functions called from ISR land
-     */
-    virtual void disableInterrupt() override;
-
-    /**
-     * Enable a particular ISR callback glue function
-     */
-    virtual void enableInterrupt(void (*callback)()) { lora.setIrqAction(callback); }
-
-    /** can we detect a LoRa preamble on the current channel? */
-    virtual bool isChannelActive() override;
-
-    /** are we actively receiving a packet (only called during receiving state) */
-    virtual bool isActivelyReceiving() override;
-
-    /**
-     * Start waiting to receive a message
-     */
-    virtual void startReceive() override;
-
-    /**
-     *  We override to turn on transmitter power as needed.
-     */
-    virtual void configHardwareForSend() override;
-
-    /**
-     * Add SNR data to received messages
-     */
-    virtual void addReceiveMetadata(meshtastic_MeshPacket *mp) override;
-
-    virtual void setStandby() override;
-
-    uint32_t getPacketTime(uint32_t pl, bool received) override { return computePacketTime(lora, pl, received); }
-};
-#endif

src/mesh/MeshService.cpp

@@ -94,9 +94,8 @@ int MeshService::handleFromRadio(const meshtastic_MeshPacket *mp)
         mp->decoded.portnum == meshtastic_PortNum_TELEMETRY_APP && mp->decoded.request_id > 0) {
         LOG_DEBUG("Received telemetry response. Skip sending our NodeInfo");
         //  ignore our request for its NodeInfo
-    } else if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag &&
-               !nodeInfoLiteHasUser(nodeDB->getMeshNode(mp->from)) && nodeInfoModule && !isPreferredRebroadcaster &&
-               !nodeDB->isFull()) {
+    } else if (mp->which_payload_variant == meshtastic_MeshPacket_decoded_tag && !nodeDB->getMeshNode(mp->from)->has_user &&
+               nodeInfoModule && !isPreferredRebroadcaster && !nodeDB->isFull()) {
         if (airTime->isTxAllowedChannelUtil(true)) {
             const int8_t hopsUsed = getHopsAway(*mp, config.lora.hop_limit);
             if (hopsUsed > (int32_t)(config.lora.hop_limit + 2)) {
@@ -393,16 +392,19 @@ meshtastic_NodeInfoLite *MeshService::refreshLocalMeshNode()
     meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(nodeDB->getNodeNum());
     assert(node);
 
+    // We might not have a position yet for our local node, in that case, at least try to send the time
+    if (!node->has_position) {
+        memset(&node->position, 0, sizeof(node->position));
+        node->has_position = true;
+    }
+
+    meshtastic_PositionLite &position = node->position;
+
     // Update our local node info with our time (even if we don't decide to update anyone else)
     node->last_heard =
         getValidTime(RTCQualityFromNet); // This nodedb timestamp might be stale, so update it if our clock is kinda valid
 
-#if !MESHTASTIC_EXCLUDE_POSITIONDB
-    // Make sure our own NodeNum has a slot in the position map so subsequent
-    // updates (and the bundled NodeInfo emission to the phone) have somewhere
-    // to read from. Insert a default-zero entry on first call.
-    nodeDB->touchNodePositionTime(node->num, getValidTime(RTCQualityFromNet));
-#endif
+    position.time = getValidTime(RTCQualityFromNet);
 
     if (powerStatus->getHasBattery() == 1) {
         updateBatteryLevel(powerStatus->getBatteryChargePercent());
@@ -430,9 +432,7 @@ int MeshService::onGPSChanged(const meshtastic::GPSStatus *newStatus)
     // Used fixed position if configured regardless of GPS lock
     if (config.position.fixed_position) {
         LOG_WARN("Use fixed position");
-        meshtastic_PositionLite fixedSlot;
-        if (nodeDB->copyNodePosition(node->num, fixedSlot))
-            pos = TypeConversions::ConvertToPosition(fixedSlot);
+        pos = TypeConversions::ConvertToPosition(node->position);
     }
 
     // Add a fresh timestamp

src/mesh/NodeDB.cpp

@@ -22,7 +22,6 @@
 #include "error.h"
 #include "main.h"
 #include "mesh-pb-constants.h"
-#include "mesh/generated/meshtastic/deviceonly_legacy.pb.h"
 #include "meshUtils.h"
 #include "modules/NeighborInfoModule.h"
 #include <ErriezCRC32.h>
@@ -152,103 +151,24 @@ uint32_t get_st7789_id(uint8_t cs, uint8_t sck, uint8_t mosi, uint8_t dc, uint8_
 
 #endif
 
-bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field)
+bool meshtastic_NodeDatabase_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_iter_t *field)
 {
-    const auto *iter = reinterpret_cast<const pb_field_iter_t *>(field);
-    switch (iter->tag) {
-    case meshtastic_NodeDatabase_nodes_tag: {
-        if (ostream) {
-            const auto *vec = static_cast<const std::vector<meshtastic_NodeInfoLite> *>(iter->pData);
-            for (auto item : *vec) {
-                if (!pb_encode_tag_for_field(ostream, iter))
-                    return false;
-                if (!pb_encode_submessage(ostream, meshtastic_NodeInfoLite_fields, &item))
-                    return false;
-            }
+    if (ostream) {
+        std::vector<meshtastic_NodeInfoLite> const *vec = (std::vector<meshtastic_NodeInfoLite> *)field->pData;
+        for (auto item : *vec) {
+            if (!pb_encode_tag_for_field(ostream, field))
+                return false;
+            pb_encode_submessage(ostream, meshtastic_NodeInfoLite_fields, &item);
         }
-        if (istream) {
-            meshtastic_NodeInfoLite node;
-            auto *vec = static_cast<std::vector<meshtastic_NodeInfoLite> *>(iter->pData);
-            if (istream->bytes_left && pb_decode(istream, meshtastic_NodeInfoLite_fields, &node))
-                vec->push_back(node);
-        }
-        return true;
     }
-    case meshtastic_NodeDatabase_positions_tag: {
-        if (ostream) {
-            const auto *vec = static_cast<const std::vector<meshtastic_NodePositionEntry> *>(iter->pData);
-            for (auto item : *vec) {
-                if (!pb_encode_tag_for_field(ostream, iter))
-                    return false;
-                if (!pb_encode_submessage(ostream, meshtastic_NodePositionEntry_fields, &item))
-                    return false;
-            }
-        }
-        if (istream) {
-            meshtastic_NodePositionEntry entry;
-            auto *vec = static_cast<std::vector<meshtastic_NodePositionEntry> *>(iter->pData);
-            if (istream->bytes_left && pb_decode(istream, meshtastic_NodePositionEntry_fields, &entry))
-                vec->push_back(entry);
-        }
-        return true;
-    }
-    case meshtastic_NodeDatabase_telemetry_tag: {
-        if (ostream) {
-            const auto *vec = static_cast<const std::vector<meshtastic_NodeTelemetryEntry> *>(iter->pData);
-            for (auto item : *vec) {
-                if (!pb_encode_tag_for_field(ostream, iter))
-                    return false;
-                if (!pb_encode_submessage(ostream, meshtastic_NodeTelemetryEntry_fields, &item))
-                    return false;
-            }
-        }
-        if (istream) {
-            meshtastic_NodeTelemetryEntry entry;
-            auto *vec = static_cast<std::vector<meshtastic_NodeTelemetryEntry> *>(iter->pData);
-            if (istream->bytes_left && pb_decode(istream, meshtastic_NodeTelemetryEntry_fields, &entry))
-                vec->push_back(entry);
-        }
-        return true;
-    }
-    case meshtastic_NodeDatabase_status_tag: {
-        if (ostream) {
-            const auto *vec = static_cast<const std::vector<meshtastic_NodeStatusEntry> *>(iter->pData);
-            for (auto item : *vec) {
-                if (!pb_encode_tag_for_field(ostream, iter))
-                    return false;
-                if (!pb_encode_submessage(ostream, meshtastic_NodeStatusEntry_fields, &item))
-                    return false;
-            }
-        }
-        if (istream) {
-            meshtastic_NodeStatusEntry entry;
-            auto *vec = static_cast<std::vector<meshtastic_NodeStatusEntry> *>(iter->pData);
-            if (istream->bytes_left && pb_decode(istream, meshtastic_NodeStatusEntry_fields, &entry))
-                vec->push_back(entry);
-        }
-        return true;
-    }
-    case meshtastic_NodeDatabase_environment_tag: {
-        if (ostream) {
-            const auto *vec = static_cast<const std::vector<meshtastic_NodeEnvironmentEntry> *>(iter->pData);
-            for (auto item : *vec) {
-                if (!pb_encode_tag_for_field(ostream, iter))
-                    return false;
-                if (!pb_encode_submessage(ostream, meshtastic_NodeEnvironmentEntry_fields, &item))
-                    return false;
-            }
-        }
-        if (istream) {
-            meshtastic_NodeEnvironmentEntry entry;
-            auto *vec = static_cast<std::vector<meshtastic_NodeEnvironmentEntry> *>(iter->pData);
-            if (istream->bytes_left && pb_decode(istream, meshtastic_NodeEnvironmentEntry_fields, &entry))
-                vec->push_back(entry);
-        }
-        return true;
-    }
-    default:
-        return true;
+    if (istream) {
+        meshtastic_NodeInfoLite node; // this gets good data
+        std::vector<meshtastic_NodeInfoLite> *vec = (std::vector<meshtastic_NodeInfoLite> *)field->pData;
+
+        if (istream->bytes_left && pb_decode(istream, meshtastic_NodeInfoLite_fields, &node))
+            vec->push_back(node);
     }
+    return true;
 }
 
 /** The current change # for radio settings.  Starts at 0 on boot and any time the radio settings
@@ -378,7 +298,8 @@ NodeDB::NodeDB()
 #endif
     // Include our owner in the node db under our nodenum
     meshtastic_NodeInfoLite *info = getOrCreateMeshNode(getNodeNum());
-    TypeConversions::CopyUserToNodeInfoLite(info, owner);
+    info->user = TypeConversions::ConvertToUserLite(owner);
+    info->has_user = true;
 
     // If node database has not been saved for the first time, save it now
 #ifdef FSCom
@@ -521,12 +442,8 @@ NodeDB::NodeDB()
 #if defined(USERPREFS_FIXED_GPS_LAT) && defined(USERPREFS_FIXED_GPS_LON)
         fixedGPS.location_source = meshtastic_Position_LocSource_LOC_MANUAL;
         config.has_position = true;
-#if !MESHTASTIC_EXCLUDE_POSITIONDB
-        {
-            concurrency::LockGuard guard(&satelliteMutex);
-            nodePositions[info->num] = TypeConversions::ConvertToPositionLite(fixedGPS);
-        }
-#endif
+        info->has_position = true;
+        info->position = TypeConversions::ConvertToPositionLite(fixedGPS);
         nodeDB->setLocalPosition(fixedGPS);
         config.position.fixed_position = true;
 #endif
@@ -562,29 +479,6 @@ bool isBroadcast(uint32_t dest)
     return dest == NODENUM_BROADCAST || dest == NODENUM_BROADCAST_NO_LORA;
 }
 
-namespace
-{
-template <typename Map, typename Value> bool copySatelliteEntry(const Map &map, NodeNum n, Value &out)
-{
-    auto it = map.find(n);
-    if (it == map.end())
-        return false;
-    out = it->second;
-    return true;
-}
-
-template <typename Map> std::vector<NodeNum> snapshotSatelliteNodeNums(const Map &map, NodeNum exclude)
-{
-    std::vector<NodeNum> result;
-    result.reserve(map.size());
-    for (const auto &kv : map) {
-        if (kv.first != exclude)
-            result.push_back(kv.first);
-    }
-    return result;
-}
-} // namespace
-
 void NodeDB::resetRadioConfig(bool is_fresh_install)
 {
     if (is_fresh_install) {
@@ -654,19 +548,6 @@ void NodeDB::installDefaultNodeDatabase()
     nodeDatabase.nodes = std::vector<meshtastic_NodeInfoLite>(MAX_NUM_NODES);
     numMeshNodes = 0;
     meshNodes = &nodeDatabase.nodes;
-    concurrency::LockGuard satelliteGuard(&satelliteMutex);
-#if !MESHTASTIC_EXCLUDE_POSITIONDB
-    nodePositions.clear();
-#endif
-#if !MESHTASTIC_EXCLUDE_TELEMETRYDB
-    nodeTelemetry.clear();
-#endif
-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTDB
-    nodeEnvironment.clear();
-#endif
-#if !MESHTASTIC_EXCLUDE_STATUSDB
-    nodeStatus.clear();
-#endif
 }
 
 void NodeDB::installDefaultConfig(bool preserveKey = false)
@@ -1138,14 +1019,12 @@ void NodeDB::resetNodes(bool keepFavorites)
 {
     if (!config.position.fixed_position)
         clearLocalPosition();
-    NodeNum ourNum = getNodeNum();
     numMeshNodes = 1;
     if (keepFavorites) {
         LOG_INFO("Clearing node database - preserving favorites");
         for (size_t i = 0; i < meshNodes->size(); i++) {
             meshtastic_NodeInfoLite &node = meshNodes->at(i);
-            if (i > 0 && !nodeInfoLiteIsFavorite(&node)) {
-                eraseNodeSatellites(node.num);
+            if (i > 0 && !node.is_favorite) {
                 node = meshtastic_NodeInfoLite();
             } else {
                 numMeshNodes += 1;
@@ -1153,14 +1032,9 @@ void NodeDB::resetNodes(bool keepFavorites)
         };
     } else {
         LOG_INFO("Clearing node database - removing favorites");
-        for (size_t i = 1; i < meshNodes->size(); i++) {
-            const NodeNum gone = meshNodes->at(i).num;
-            if (gone)
-                eraseNodeSatellites(gone);
-        }
         std::fill(nodeDatabase.nodes.begin() + 1, nodeDatabase.nodes.end(), meshtastic_NodeInfoLite());
     }
-    (void)ourNum;
+    devicestate.has_rx_text_message = false;
     devicestate.has_rx_waypoint = false;
     saveNodeDatabaseToDisk();
     saveDeviceStateToDisk();
@@ -1180,173 +1054,36 @@ void NodeDB::removeNodeByNum(NodeNum nodeNum)
     numMeshNodes -= removed;
     std::fill(nodeDatabase.nodes.begin() + numMeshNodes, nodeDatabase.nodes.begin() + numMeshNodes + 1,
               meshtastic_NodeInfoLite());
-    if (removed)
-        eraseNodeSatellites(nodeNum);
     LOG_DEBUG("NodeDB::removeNodeByNum purged %d entries. Save changes", removed);
     saveNodeDatabaseToDisk();
 }
 
 void NodeDB::clearLocalPosition()
 {
-#if !MESHTASTIC_EXCLUDE_POSITIONDB
-    concurrency::LockGuard guard(&satelliteMutex);
-    nodePositions.erase(getNodeNum());
-#endif
+    meshtastic_NodeInfoLite *node = getMeshNode(nodeDB->getNodeNum());
+    node->position.latitude_i = 0;
+    node->position.longitude_i = 0;
+    node->position.altitude = 0;
+    node->position.time = 0;
     setLocalPosition(meshtastic_Position_init_default);
     localPositionUpdatedSinceBoot = false;
 }
 
-bool NodeDB::copyNodePosition(NodeNum n, meshtastic_PositionLite &out) const
-{
-#if MESHTASTIC_EXCLUDE_POSITIONDB
-    (void)n;
-    (void)out;
-    return false;
-#else
-    concurrency::LockGuard guard(&satelliteMutex);
-    return copySatelliteEntry(nodePositions, n, out);
-#endif
-}
-
-bool NodeDB::copyNodeTelemetry(NodeNum n, meshtastic_DeviceMetrics &out) const
-{
-#if MESHTASTIC_EXCLUDE_TELEMETRYDB
-    (void)n;
-    (void)out;
-    return false;
-#else
-    concurrency::LockGuard guard(&satelliteMutex);
-    return copySatelliteEntry(nodeTelemetry, n, out);
-#endif
-}
-
-bool NodeDB::copyNodeEnvironment(NodeNum n, meshtastic_EnvironmentMetrics &out) const
-{
-#if MESHTASTIC_EXCLUDE_ENVIRONMENTDB
-    (void)n;
-    (void)out;
-    return false;
-#else
-    concurrency::LockGuard guard(&satelliteMutex);
-    return copySatelliteEntry(nodeEnvironment, n, out);
-#endif
-}
-
-bool NodeDB::copyNodeStatus(NodeNum n, meshtastic_StatusMessage &out) const
-{
-#if MESHTASTIC_EXCLUDE_STATUSDB
-    (void)n;
-    (void)out;
-    return false;
-#else
-    concurrency::LockGuard guard(&satelliteMutex);
-    return copySatelliteEntry(nodeStatus, n, out);
-#endif
-}
-
-std::vector<NodeNum> NodeDB::snapshotPositionNodeNums(NodeNum exclude) const
-{
-#if MESHTASTIC_EXCLUDE_POSITIONDB
-    (void)exclude;
-    return {};
-#else
-    concurrency::LockGuard guard(&satelliteMutex);
-    return snapshotSatelliteNodeNums(nodePositions, exclude);
-#endif
-}
-
-std::vector<NodeNum> NodeDB::snapshotTelemetryNodeNums(NodeNum exclude) const
-{
-#if MESHTASTIC_EXCLUDE_TELEMETRYDB
-    (void)exclude;
-    return {};
-#else
-    concurrency::LockGuard guard(&satelliteMutex);
-    return snapshotSatelliteNodeNums(nodeTelemetry, exclude);
-#endif
-}
-
-std::vector<NodeNum> NodeDB::snapshotEnvironmentNodeNums(NodeNum exclude) const
-{
-#if MESHTASTIC_EXCLUDE_ENVIRONMENTDB
-    (void)exclude;
-    return {};
-#else
-    concurrency::LockGuard guard(&satelliteMutex);
-    return snapshotSatelliteNodeNums(nodeEnvironment, exclude);
-#endif
-}
-
-std::vector<NodeNum> NodeDB::snapshotStatusNodeNums(NodeNum exclude) const
-{
-#if MESHTASTIC_EXCLUDE_STATUSDB
-    (void)exclude;
-    return {};
-#else
-    concurrency::LockGuard guard(&satelliteMutex);
-    return snapshotSatelliteNodeNums(nodeStatus, exclude);
-#endif
-}
-
-void NodeDB::setNodeStatus(NodeNum n, const meshtastic_StatusMessage &status)
-{
-#if MESHTASTIC_EXCLUDE_STATUSDB
-    (void)n;
-    (void)status;
-#else
-    concurrency::LockGuard guard(&satelliteMutex);
-    nodeStatus[n] = status;
-#endif
-}
-
-void NodeDB::touchNodePositionTime(NodeNum n, uint32_t time)
-{
-#if MESHTASTIC_EXCLUDE_POSITIONDB
-    (void)n;
-    (void)time;
-#else
-    concurrency::LockGuard guard(&satelliteMutex);
-    nodePositions[n].time = time;
-#endif
-}
-
-void NodeDB::eraseNodeSatellites(NodeNum n)
-{
-    concurrency::LockGuard guard(&satelliteMutex);
-#if !MESHTASTIC_EXCLUDE_POSITIONDB
-    nodePositions.erase(n);
-#endif
-#if !MESHTASTIC_EXCLUDE_TELEMETRYDB
-    nodeTelemetry.erase(n);
-#endif
-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTDB
-    nodeEnvironment.erase(n);
-#endif
-#if !MESHTASTIC_EXCLUDE_STATUSDB
-    nodeStatus.erase(n);
-#endif
-}
-
 void NodeDB::cleanupMeshDB()
 {
     int newPos = 0, removed = 0;
     for (int i = 0; i < numMeshNodes; i++) {
-        meshtastic_NodeInfoLite &n = meshNodes->at(i);
-        if (nodeInfoLiteHasUser(&n)) {
-            if (n.public_key.size > 0) {
-                if (memfll(n.public_key.bytes, 0, n.public_key.size)) {
-                    n.public_key.size = 0;
+        if (meshNodes->at(i).has_user) {
+            if (meshNodes->at(i).user.public_key.size > 0) {
+                if (memfll(meshNodes->at(i).user.public_key.bytes, 0, meshNodes->at(i).user.public_key.size)) {
+                    meshNodes->at(i).user.public_key.size = 0;
                 }
             }
             if (newPos != i)
-                meshNodes->at(newPos++) = n;
+                meshNodes->at(newPos++) = meshNodes->at(i);
             else
                 newPos++;
         } else {
-            // No user info - drop this node and its satellites
-            const NodeNum gone = n.num;
-            if (gone)
-                eraseNodeSatellites(gone);
             removed++;
         }
     }
@@ -1367,6 +1104,7 @@ void NodeDB::installDefaultDeviceState()
     devicestate.version = DEVICESTATE_CUR_VER;
     devicestate.receive_queue_count = 0; // Not yet implemented FIXME
     devicestate.has_rx_waypoint = false;
+    devicestate.has_rx_text_message = false;
 
     generatePacketId(); // FIXME - ugly way to init current_packet_id;
 
@@ -1403,22 +1141,14 @@ void NodeDB::pickNewNodeNum()
         nodeNum = (ourMacAddr[2] << 24) | (ourMacAddr[3] << 16) | (ourMacAddr[4] << 8) | ourMacAddr[5];
     }
 
-    // Identity check via public key (or "empty slot?" when no keys yet);
-    // macaddr no longer lives on the slim header.
-    auto isOurOwnEntry = [&](const meshtastic_NodeInfoLite *n) -> bool {
-        if (!n)
-            return false;
-        if (owner.public_key.size == 32 && n->public_key.size == 32)
-            return memcmp(n->public_key.bytes, owner.public_key.bytes, 32) == 0;
-        return !nodeInfoLiteHasUser(n);
-    };
-
     meshtastic_NodeInfoLite *found;
-    while (((found = getMeshNode(nodeNum)) && !isOurOwnEntry(found)) ||
+    while (((found = getMeshNode(nodeNum)) && memcmp(found->user.macaddr, ourMacAddr, sizeof(ourMacAddr)) != 0) ||
            (nodeNum == NODENUM_BROADCAST || nodeNum < NUM_RESERVED)) {
         NodeNum candidate = random(NUM_RESERVED, LONG_MAX); // try a new random choice
         if (found)
-            LOG_WARN("NOTE! Our desired nodenum 0x%x is invalid or in use, picking 0x%x", nodeNum, candidate);
+            LOG_WARN("NOTE! Our desired nodenum 0x%x is invalid or in use, by MAC ending in 0x%02x%02x vs our 0x%02x%02x, so "
+                     "trying for 0x%x",
+                     nodeNum, found->user.macaddr[4], found->user.macaddr[5], ourMacAddr[4], ourMacAddr[5], candidate);
         nodeNum = candidate;
     }
     LOG_DEBUG("Use nodenum 0x%x ", nodeNum);
@@ -1439,8 +1169,7 @@ LoadFileResult NodeDB::loadProto(const char *filename, size_t protoSize, size_t
     if (f) {
         LOG_INFO("Load %s", filename);
         pb_istream_t stream = {&readcb, &f, protoSize};
-        if (fields != &meshtastic_NodeDatabase_msg &&
-            fields != &meshtastic_NodeDatabase_Legacy_msg) // both NodeDatabase descriptors contain std::vector members
+        if (fields != &meshtastic_NodeDatabase_msg) // contains a vector object
             memset(dest_struct, 0, objSize);
         if (!pb_decode(&stream, fields, dest_struct)) {
             LOG_ERROR("Error: can't decode protobuf %s", PB_GET_ERROR(&stream));
@@ -1513,57 +1242,9 @@ void NodeDB::loadFromDisk()
     if (nodeDatabase.version < DEVICESTATE_MIN_VER) {
         LOG_WARN("NodeDatabase %d is old, discard", nodeDatabase.version);
         installDefaultNodeDatabase();
-    } else if (nodeDatabase.version < DEVICESTATE_CUR_VER) {
-        if (migrateLegacyNodeDatabase())
-            saveNodeDatabaseToDisk();
-        else
-            installDefaultNodeDatabase();
     } else {
         meshNodes = &nodeDatabase.nodes;
         numMeshNodes = nodeDatabase.nodes.size();
-        // Hydrate the satellite maps; the on-disk vectors stay empty in steady
-        // state and are repopulated only at save time.
-        concurrency::LockGuard guard(&satelliteMutex);
-#if !MESHTASTIC_EXCLUDE_POSITIONDB
-        nodePositions.clear();
-        nodePositions.reserve(nodeDatabase.positions.size());
-        for (const auto &entry : nodeDatabase.positions) {
-            if (entry.has_position)
-                nodePositions[entry.num] = entry.position;
-        }
-        nodeDatabase.positions.clear();
-        nodeDatabase.positions.shrink_to_fit();
-#endif
-#if !MESHTASTIC_EXCLUDE_TELEMETRYDB
-        nodeTelemetry.clear();
-        nodeTelemetry.reserve(nodeDatabase.telemetry.size());
-        for (const auto &entry : nodeDatabase.telemetry) {
-            if (entry.has_device_metrics)
-                nodeTelemetry[entry.num] = entry.device_metrics;
-        }
-        nodeDatabase.telemetry.clear();
-        nodeDatabase.telemetry.shrink_to_fit();
-#endif
-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTDB
-        nodeEnvironment.clear();
-        nodeEnvironment.reserve(nodeDatabase.environment.size());
-        for (const auto &entry : nodeDatabase.environment) {
-            if (entry.has_environment_metrics)
-                nodeEnvironment[entry.num] = entry.environment_metrics;
-        }
-        nodeDatabase.environment.clear();
-        nodeDatabase.environment.shrink_to_fit();
-#endif
-#if !MESHTASTIC_EXCLUDE_STATUSDB
-        nodeStatus.clear();
-        nodeStatus.reserve(nodeDatabase.status.size());
-        for (const auto &entry : nodeDatabase.status) {
-            if (entry.has_status)
-                nodeStatus[entry.num] = entry.status;
-        }
-        nodeDatabase.status.clear();
-        nodeDatabase.status.shrink_to_fit();
-#endif
         LOG_INFO("Loaded saved nodedatabase version %d, with nodes count: %d", nodeDatabase.version, nodeDatabase.nodes.size());
     }
 
@@ -1591,16 +1272,16 @@ void NodeDB::loadFromDisk()
 
         // Attempt recovery of owner fields from our own NodeDB entry if available.
         meshtastic_NodeInfoLite *us = getMeshNode(getNodeNum());
-        if (nodeInfoLiteHasUser(us)) {
+        if (us && us->has_user) {
             LOG_WARN("Restoring owner fields (long_name/short_name/is_licensed/is_unmessagable) from NodeDB for our node 0x%08x",
                      us->num);
-            memcpy(owner.long_name, us->long_name, sizeof(owner.long_name));
+            memcpy(owner.long_name, us->user.long_name, sizeof(owner.long_name));
             owner.long_name[sizeof(owner.long_name) - 1] = '\0';
-            memcpy(owner.short_name, us->short_name, sizeof(owner.short_name));
+            memcpy(owner.short_name, us->user.short_name, sizeof(owner.short_name));
             owner.short_name[sizeof(owner.short_name) - 1] = '\0';
-            owner.is_licensed = nodeInfoLiteIsLicensed(us);
-            owner.has_is_unmessagable = nodeInfoLiteHasIsUnmessagable(us);
-            owner.is_unmessagable = nodeInfoLiteIsUnmessagable(us);
+            owner.is_licensed = us->user.is_licensed;
+            owner.has_is_unmessagable = us->user.has_is_unmessagable;
+            owner.is_unmessagable = us->user.is_unmessagable;
 
             // Save the recovered owner to device state on disk
             saveToDisk(SEGMENT_DEVICESTATE);
@@ -1847,75 +1528,9 @@ bool NodeDB::saveNodeDatabaseToDisk()
     FSCom.mkdir("/prefs");
     spiLock->unlock();
 #endif
-    // Project the maps into the on-disk vectors just before encoding; cleared
-    // again on the way out so we don't carry duplicate state.
-    concurrency::LockGuard guard(&satelliteMutex);
-#if !MESHTASTIC_EXCLUDE_POSITIONDB
-    nodeDatabase.positions.clear();
-    nodeDatabase.positions.reserve(nodePositions.size());
-    for (const auto &kv : nodePositions) {
-        meshtastic_NodePositionEntry entry = meshtastic_NodePositionEntry_init_default;
-        entry.num = kv.first;
-        entry.has_position = true;
-        entry.position = kv.second;
-        nodeDatabase.positions.push_back(entry);
-    }
-#else
-    nodeDatabase.positions.clear();
-#endif
-#if !MESHTASTIC_EXCLUDE_TELEMETRYDB
-    nodeDatabase.telemetry.clear();
-    nodeDatabase.telemetry.reserve(nodeTelemetry.size());
-    for (const auto &kv : nodeTelemetry) {
-        meshtastic_NodeTelemetryEntry entry = meshtastic_NodeTelemetryEntry_init_default;
-        entry.num = kv.first;
-        entry.has_device_metrics = true;
-        entry.device_metrics = kv.second;
-        nodeDatabase.telemetry.push_back(entry);
-    }
-#else
-    nodeDatabase.telemetry.clear();
-#endif
-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTDB
-    nodeDatabase.environment.clear();
-    nodeDatabase.environment.reserve(nodeEnvironment.size());
-    for (const auto &kv : nodeEnvironment) {
-        meshtastic_NodeEnvironmentEntry entry = meshtastic_NodeEnvironmentEntry_init_default;
-        entry.num = kv.first;
-        entry.has_environment_metrics = true;
-        entry.environment_metrics = kv.second;
-        nodeDatabase.environment.push_back(entry);
-    }
-#else
-    nodeDatabase.environment.clear();
-#endif
-#if !MESHTASTIC_EXCLUDE_STATUSDB
-    nodeDatabase.status.clear();
-    nodeDatabase.status.reserve(nodeStatus.size());
-    for (const auto &kv : nodeStatus) {
-        meshtastic_NodeStatusEntry entry = meshtastic_NodeStatusEntry_init_default;
-        entry.num = kv.first;
-        entry.has_status = true;
-        entry.status = kv.second;
-        nodeDatabase.status.push_back(entry);
-    }
-#else
-    nodeDatabase.status.clear();
-#endif
-
     size_t nodeDatabaseSize;
     pb_get_encoded_size(&nodeDatabaseSize, meshtastic_NodeDatabase_fields, &nodeDatabase);
-    bool ok = saveProto(nodeDatabaseFileName, nodeDatabaseSize, &meshtastic_NodeDatabase_msg, &nodeDatabase, false);
-
-    nodeDatabase.positions.clear();
-    nodeDatabase.positions.shrink_to_fit();
-    nodeDatabase.telemetry.clear();
-    nodeDatabase.telemetry.shrink_to_fit();
-    nodeDatabase.environment.clear();
-    nodeDatabase.environment.shrink_to_fit();
-    nodeDatabase.status.clear();
-    nodeDatabase.status.shrink_to_fit();
-    return ok;
+    return saveProto(nodeDatabaseFileName, nodeDatabaseSize, &meshtastic_NodeDatabase_msg, &nodeDatabase, false);
 }
 
 bool NodeDB::saveToDiskNoRetry(int saveWhat)
@@ -2084,7 +1699,7 @@ size_t NodeDB::getNumOnlineMeshNodes(bool localOnly)
 
     // FIXME this implementation is kinda expensive
     for (int i = 0; i < numMeshNodes; i++) {
-        if (localOnly && nodeInfoLiteViaMqtt(&meshNodes->at(i)))
+        if (localOnly && meshNodes->at(i).via_mqtt)
             continue;
         if (sinceLastSeen(&meshNodes->at(i)) < NUM_ONLINE_SECS)
             numseen++;
@@ -2121,94 +1736,62 @@ void NodeDB::updatePosition(uint32_t nodeId, const meshtastic_Position &p, RxSou
         return;
     }
 
-#if MESHTASTIC_EXCLUDE_POSITIONDB
-    // Build flag opted out: header still tracks last_heard via updateFrom; we
-    // simply don't cache the position payload anywhere on this device.
     if (src == RX_SRC_LOCAL) {
-        LOG_INFO("updatePosition LOCAL (PositionDB excluded) time=%u lat=%d lon=%d alt=%d", p.time, p.latitude_i, p.longitude_i,
+        // Local packet, fully authoritative
+        LOG_INFO("updatePosition LOCAL pos@%x time=%u lat=%d lon=%d alt=%d", p.timestamp, p.time, p.latitude_i, p.longitude_i,
                  p.altitude);
+
         setLocalPosition(p);
+        info->position = TypeConversions::ConvertToPositionLite(p);
+    } else if ((p.time > 0) && !p.latitude_i && !p.longitude_i && !p.timestamp && !p.location_source) {
+        // FIXME SPECIAL TIME SETTING PACKET FROM EUD TO RADIO
+        // (stop-gap fix for issue #900)
+        LOG_DEBUG("updatePosition SPECIAL time setting time=%u", p.time);
+        info->position.time = p.time;
+    } else {
+        // Be careful to only update fields that have been set by the REMOTE sender
+        // A lot of position reports don't have time populated.  In that case, be careful to not blow away the time we
+        // recorded based on the packet rxTime
+        //
+        // FIXME perhaps handle RX_SRC_USER separately?
+        LOG_INFO("updatePosition REMOTE node=0x%x time=%u lat=%d lon=%d", nodeId, p.time, p.latitude_i, p.longitude_i);
+
+        // First, back up fields that we want to protect from overwrite
+        uint32_t tmp_time = info->position.time;
+
+        // Next, update atomically
+        info->position = TypeConversions::ConvertToPositionLite(p);
+
+        // Last, restore any fields that may have been overwritten
+        if (!info->position.time)
+            info->position.time = tmp_time;
     }
-    (void)nodeId;
-    updateGUIforNode = info;
-    notifyObservers(true);
-#else
-    {
-        concurrency::LockGuard guard(&satelliteMutex);
-        meshtastic_PositionLite &slot = nodePositions[nodeId]; // creates default-zero entry if missing
-
-        if (src == RX_SRC_LOCAL) {
-            // Local packet, fully authoritative
-            LOG_INFO("updatePosition LOCAL pos@%x time=%u lat=%d lon=%d alt=%d", p.timestamp, p.time, p.latitude_i, p.longitude_i,
-                     p.altitude);
-
-            setLocalPosition(p);
-            slot = TypeConversions::ConvertToPositionLite(p);
-        } else if ((p.time > 0) && !p.latitude_i && !p.longitude_i && !p.timestamp && !p.location_source) {
-            // FIXME SPECIAL TIME SETTING PACKET FROM EUD TO RADIO
-            // (stop-gap fix for issue #900)
-            LOG_DEBUG("updatePosition SPECIAL time setting time=%u", p.time);
-            slot.time = p.time;
-        } else {
-            // Be careful to only update fields that have been set by the REMOTE sender
-            // A lot of position reports don't have time populated.  In that case, be careful to not blow away the time we
-            // recorded based on the packet rxTime
-            //
-            // FIXME perhaps handle RX_SRC_USER separately?
-            LOG_INFO("updatePosition REMOTE node=0x%x time=%u lat=%d lon=%d", nodeId, p.time, p.latitude_i, p.longitude_i);
-
-            // First, back up fields that we want to protect from overwrite
-            uint32_t tmp_time = slot.time;
-
-            // Next, update atomically
-            slot = TypeConversions::ConvertToPositionLite(p);
-
-            // Last, restore any fields that may have been overwritten
-            if (!slot.time)
-                slot.time = tmp_time;
-        }
-    }
+    info->has_position = true;
     updateGUIforNode = info;
     notifyObservers(true); // Force an update whether or not our node counts have changed
-#endif
 }
 
-/** Update telemetry info for this node based on received metrics. Stores
- *  device_metrics and environment_metrics into their respective satellite
- *  maps; other variants (air_quality, power, local_stats, health) are
- *  intentionally not retained per-node.
+/** Update telemetry info for this node based on received metrics
+ *  We only care about device telemetry here
  */
 void NodeDB::updateTelemetry(uint32_t nodeId, const meshtastic_Telemetry &t, RxSource src)
 {
     meshtastic_NodeInfoLite *info = getOrCreateMeshNode(nodeId);
-    if (!info)
+    // Environment metrics should never go to NodeDb but we'll safegaurd anyway
+    if (!info || t.which_variant != meshtastic_Telemetry_device_metrics_tag) {
         return;
-
-    if (t.which_variant == meshtastic_Telemetry_device_metrics_tag) {
-        if (src == RX_SRC_LOCAL) {
-            LOG_DEBUG("updateTelemetry LOCAL device");
-        } else {
-            LOG_DEBUG("updateTelemetry REMOTE device node=0x%x", nodeId);
-        }
-#if !MESHTASTIC_EXCLUDE_TELEMETRYDB
-        concurrency::LockGuard guard(&satelliteMutex);
-        nodeTelemetry[nodeId] = t.variant.device_metrics;
-#endif
-    } else if (t.which_variant == meshtastic_Telemetry_environment_metrics_tag) {
-        if (src == RX_SRC_LOCAL) {
-            LOG_DEBUG("updateTelemetry LOCAL env");
-        } else {
-            LOG_DEBUG("updateTelemetry REMOTE env node=0x%x", nodeId);
-        }
-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTDB
-        concurrency::LockGuard guard(&satelliteMutex);
-        nodeEnvironment[nodeId] = t.variant.environment_metrics;
-#endif
-    } else {
-        return; // air_quality / power / local_stats / health: not stored per-node
     }
+
+    if (src == RX_SRC_LOCAL) {
+        // Local packet, fully authoritative
+        LOG_DEBUG("updateTelemetry LOCAL");
+    } else {
+        LOG_DEBUG("updateTelemetry REMOTE node=0x%x ", nodeId);
+    }
+    info->device_metrics = t.variant.device_metrics;
+    info->has_device_metrics = true;
     updateGUIforNode = info;
-    notifyObservers(true);
+    notifyObservers(true); // Force an update whether or not our node counts have changed
 }
 
 /**
@@ -2223,22 +1806,24 @@ void NodeDB::addFromContact(meshtastic_SharedContact contact)
     // If the local node has this node marked as manually verified
     // and the client does not, do not allow the client to update the
     // saved public key.
-    if (nodeInfoLiteIsKeyManuallyVerified(info) && !contact.manually_verified) {
-        if (contact.user.public_key.size != info->public_key.size ||
-            memcmp(contact.user.public_key.bytes, info->public_key.bytes, info->public_key.size) != 0) {
+    if ((info->bitfield & NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK) && !contact.manually_verified) {
+        if (contact.user.public_key.size != info->user.public_key.size ||
+            memcmp(contact.user.public_key.bytes, info->user.public_key.bytes, info->user.public_key.size) != 0) {
             return;
         }
     }
     info->num = contact.node_num;
-    TypeConversions::CopyUserToNodeInfoLite(info, contact.user);
+    info->has_user = true;
+    info->user = TypeConversions::ConvertToUserLite(contact.user);
     if (contact.should_ignore) {
         // If should_ignore is set,
         // we need to clear the public key and other cruft, in addition to setting the node as ignored
-        nodeInfoLiteSetBit(info, NODEINFO_BITFIELD_IS_IGNORED_MASK, true);
-        nodeInfoLiteSetBit(info, NODEINFO_BITFIELD_IS_FAVORITE_MASK, false);
-        eraseNodeSatellites(contact.node_num);
-        info->public_key.size = 0;
-        memset(info->public_key.bytes, 0, sizeof(info->public_key.bytes));
+        info->is_ignored = true;
+        info->is_favorite = false;
+        info->has_device_metrics = false;
+        info->has_position = false;
+        info->user.public_key.size = 0;
+        memset(info->user.public_key.bytes, 0, sizeof(info->user.public_key.bytes));
     } else {
         /* Clients are sending add_contact before every text message DM (because clients may hold a larger node database with
          * public keys than the radio holds). However, we don't want to update last_heard just because we sent someone a DM!
@@ -2257,12 +1842,12 @@ void NodeDB::addFromContact(meshtastic_SharedContact contact)
         } else {
             // Normal case: set is_favorite to prevent expiration.
             // last_heard will remain as-is (or remain 0 if this entry wasn't in the nodeDB).
-            nodeInfoLiteSetBit(info, NODEINFO_BITFIELD_IS_FAVORITE_MASK, true);
+            info->is_favorite = true;
         }
 
         // As the clients will begin sending the contact with DMs, we want to strictly check if the node is manually verified
         if (contact.manually_verified) {
-            nodeInfoLiteSetBit(info, NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK, true);
+            info->bitfield |= NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK;
         }
         // Mark the node's key as manually verified to indicate trustworthiness.
         updateGUIforNode = info;
@@ -2296,15 +1881,15 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde
                 meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
                 cn->level = meshtastic_LogRecord_Level_WARNING;
                 cn->time = getValidTime(RTCQualityFromNet);
-                snprintf(cn->message, sizeof(cn->message), warning, p.long_name);
+                sprintf(cn->message, warning, p.long_name);
                 service->sendClientNotification(cn);
             }
             return false;
         }
     }
-    if (info->public_key.size == 32) { // if we have a key for this user already, don't overwrite with a new one
+    if (info->user.public_key.size == 32) { // if we have a key for this user already, don't overwrite with a new one
         // if the key doesn't match, don't update nodeDB at all.
-        if (p.public_key.size != 32 || (memcmp(p.public_key.bytes, info->public_key.bytes, 32) != 0)) {
+        if (p.public_key.size != 32 || (memcmp(p.public_key.bytes, info->user.public_key.bytes, 32) != 0)) {
             LOG_WARN("Public Key mismatch, dropping NodeInfo");
             return false;
         }
@@ -2317,22 +1902,19 @@ bool NodeDB::updateUser(uint32_t nodeId, meshtastic_User &p, uint8_t channelInde
     // Always ensure user.id is derived from nodeId, regardless of what was received
     snprintf(p.id, sizeof(p.id), "!%08x", nodeId);
 
-    meshtastic_NodeInfoLite before = *info;
-    TypeConversions::CopyUserToNodeInfoLite(info, p);
-    bool changed =
-        (memcmp(before.long_name, info->long_name, sizeof(info->long_name)) != 0) ||
-        (memcmp(before.short_name, info->short_name, sizeof(info->short_name)) != 0) || (before.hw_model != info->hw_model) ||
-        (before.role != info->role) || (before.public_key.size != info->public_key.size) ||
-        (info->public_key.size > 0 && memcmp(before.public_key.bytes, info->public_key.bytes, info->public_key.size) != 0) ||
-        (before.bitfield != info->bitfield) || (info->channel != channelIndex);
+    // Both of info->user and p start as filled with zero so I think this is okay
+    auto lite = TypeConversions::ConvertToUserLite(p);
+    bool changed = memcmp(&info->user, &lite, sizeof(info->user)) || (info->channel != channelIndex);
 
-    if (info->public_key.size == 32) {
-        printBytes("Saved Pubkey: ", info->public_key.bytes, 32);
+    info->user = lite;
+    if (info->user.public_key.size == 32) {
+        printBytes("Saved Pubkey: ", info->user.public_key.bytes, 32);
     }
     if (nodeId != getNodeNum())
         info->channel = channelIndex; // Set channel we need to use to reach this node (but don't set our own channel)
-    LOG_DEBUG("Update changed=%d user %s/%s, id=0x%08x, channel=%d", changed, info->long_name, info->short_name, nodeId,
+    LOG_DEBUG("Update changed=%d user %s/%s, id=0x%08x, channel=%d", changed, info->user.long_name, info->user.short_name, nodeId,
               info->channel);
+    info->has_user = true;
 
     if (changed) {
         updateGUIforNode = info;
@@ -2374,8 +1956,7 @@ void NodeDB::updateFrom(const meshtastic_MeshPacket &mp)
         if (mp.rx_snr)
             info->snr = mp.rx_snr; // keep the most recent SNR we received for this node.
 
-        nodeInfoLiteSetBit(info, NODEINFO_BITFIELD_VIA_MQTT_MASK,
-                           mp.via_mqtt); // Store if we received this packet via MQTT
+        info->via_mqtt = mp.via_mqtt; // Store if we received this packet via MQTT
 
         // If hopStart was set and there wasn't someone messing with the limit in the middle, add hopsAway
         const int8_t hopsAway = getHopsAway(mp);
@@ -2390,8 +1971,8 @@ void NodeDB::updateFrom(const meshtastic_MeshPacket &mp)
 void NodeDB::set_favorite(bool is_favorite, uint32_t nodeId)
 {
     meshtastic_NodeInfoLite *lite = getMeshNode(nodeId);
-    if (lite && nodeInfoLiteIsFavorite(lite) != is_favorite) {
-        nodeInfoLiteSetBit(lite, NODEINFO_BITFIELD_IS_FAVORITE_MASK, is_favorite);
+    if (lite && lite->is_favorite != is_favorite) {
+        lite->is_favorite = is_favorite;
         sortMeshDB();
         saveNodeDatabaseToDisk();
     }
@@ -2405,10 +1986,10 @@ bool NodeDB::isFavorite(uint32_t nodeId)
     if (nodeId == NODENUM_BROADCAST)
         return false;
 
-    const meshtastic_NodeInfoLite *lite = getMeshNode(nodeId);
+    meshtastic_NodeInfoLite *lite = getMeshNode(nodeId);
 
     if (lite) {
-        return nodeInfoLiteIsFavorite(lite);
+        return lite->is_favorite;
     }
     return false;
 }
@@ -2433,14 +2014,14 @@ bool NodeDB::isFromOrToFavoritedNode(const meshtastic_MeshPacket &p)
         lite = &meshNodes->at(i);
 
         if (lite->num == p.from) {
-            if (nodeInfoLiteIsFavorite(lite))
+            if (lite->is_favorite)
                 return true;
 
             seenFrom = true;
         }
 
         if (lite->num == p.to) {
-            if (nodeInfoLiteIsFavorite(lite))
+            if (lite->is_favorite)
                 return true;
 
             seenTo = true;
@@ -2476,10 +2057,10 @@ void NodeDB::sortMeshDB()
                     // TODO: Look for at(i-1) also matching own node num, and throw the DB in the trash
                     std::swap(meshNodes->at(i), meshNodes->at(i - 1));
                     changed = true;
-                } else if (nodeInfoLiteIsFavorite(&meshNodes->at(i)) && !nodeInfoLiteIsFavorite(&meshNodes->at(i - 1))) {
+                } else if (meshNodes->at(i).is_favorite && !meshNodes->at(i - 1).is_favorite) {
                     std::swap(meshNodes->at(i), meshNodes->at(i - 1));
                     changed = true;
-                } else if (!nodeInfoLiteIsFavorite(&meshNodes->at(i)) && nodeInfoLiteIsFavorite(&meshNodes->at(i - 1))) {
+                } else if (!meshNodes->at(i).is_favorite && meshNodes->at(i - 1).is_favorite) {
                     // noop
                 } else if (meshNodes->at(i).last_heard > meshNodes->at(i - 1).last_heard) {
                     std::swap(meshNodes->at(i), meshNodes->at(i - 1));
@@ -2539,18 +2120,17 @@ meshtastic_NodeInfoLite *NodeDB::getOrCreateMeshNode(NodeNum n)
             int oldestIndex = -1;
             int oldestBoringIndex = -1;
             for (int i = 1; i < numMeshNodes; i++) {
-                const meshtastic_NodeInfoLite *cand = &meshNodes->at(i);
-                const bool isFavoriteNode = nodeInfoLiteIsFavorite(cand);
-                const bool isIgnored = nodeInfoLiteIsIgnored(cand);
-                const bool isVerified = nodeInfoLiteIsKeyManuallyVerified(cand);
                 // Simply the oldest non-favorite, non-ignored, non-verified node
-                if (!isFavoriteNode && !isIgnored && !isVerified && cand->last_heard < oldest) {
-                    oldest = cand->last_heard;
+                if (!meshNodes->at(i).is_favorite && !meshNodes->at(i).is_ignored &&
+                    !(meshNodes->at(i).bitfield & NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK) &&
+                    meshNodes->at(i).last_heard < oldest) {
+                    oldest = meshNodes->at(i).last_heard;
                     oldestIndex = i;
                 }
                 // The oldest "boring" node
-                if (!isFavoriteNode && !isIgnored && cand->public_key.size == 0 && cand->last_heard < oldestBoring) {
-                    oldestBoring = cand->last_heard;
+                if (!meshNodes->at(i).is_favorite && !meshNodes->at(i).is_ignored && meshNodes->at(i).user.public_key.size == 0 &&
+                    meshNodes->at(i).last_heard < oldestBoring) {
+                    oldestBoring = meshNodes->at(i).last_heard;
                     oldestBoringIndex = i;
                 }
             }
@@ -2560,7 +2140,6 @@ meshtastic_NodeInfoLite *NodeDB::getOrCreateMeshNode(NodeNum n)
             }
 
             if (oldestIndex != -1) {
-                eraseNodeSatellites(meshNodes->at(oldestIndex).num);
                 // Shove the remaining nodes down the chain
                 for (int i = oldestIndex; i < numMeshNodes - 1; i++) {
                     meshNodes->at(i) = meshNodes->at(i + 1);
@@ -2584,23 +2163,18 @@ meshtastic_NodeInfoLite *NodeDB::getOrCreateMeshNode(NodeNum n)
 /// valid lat/lon
 bool NodeDB::hasValidPosition(const meshtastic_NodeInfoLite *n)
 {
-    if (!n)
-        return false;
-    if (n->num == getNodeNum()) {
-        return localPosition.latitude_i != 0 || localPosition.longitude_i != 0;
-    }
-    meshtastic_PositionLite pos;
-    return copyNodePosition(n->num, pos) && (pos.latitude_i != 0 || pos.longitude_i != 0);
+    return n->has_position && (n->position.latitude_i != 0 || n->position.longitude_i != 0);
 }
 
 /// If we have a node / user and they report is_licensed = true
 /// we consider them licensed
 UserLicenseStatus NodeDB::getLicenseStatus(uint32_t nodeNum)
 {
-    const meshtastic_NodeInfoLite *info = getMeshNode(nodeNum);
-    if (!nodeInfoLiteHasUser(info))
+    meshtastic_NodeInfoLite *info = getMeshNode(nodeNum);
+    if (!info || !info->has_user) {
         return UserLicenseStatus::NotKnown;
-    return nodeInfoLiteIsLicensed(info) ? UserLicenseStatus::Licensed : UserLicenseStatus::NotLicensed;
+    }
+    return info->user.is_licensed ? UserLicenseStatus::Licensed : UserLicenseStatus::NotLicensed;
 }
 
 #if !defined(MESHTASTIC_EXCLUDE_PKI)

src/mesh/NodeDB.h

@@ -6,12 +6,10 @@
 #include <assert.h>
 #include <pb_encode.h>
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 #include "MeshTypes.h"
 #include "NodeStatus.h"
-#include "concurrency/Lock.h"
 #include "configuration.h"
 #include "mesh-pb-constants.h"
 #include "mesh/generated/meshtastic/mesh.pb.h" // For CriticalErrorCode
@@ -84,9 +82,7 @@ DeviceState versions used to be defined in the .proto file but really only this
 #define SEGMENT_CHANNELS 8
 #define SEGMENT_NODEDATABASE 16
 
-#define DEVICESTATE_CUR_VER 25
-// Lowest on-disk version we still know how to load. v24 saves are migrated
-// at boot via the parallel deviceonly_legacy descriptor and re-saved as v25.
+#define DEVICESTATE_CUR_VER 24
 #define DEVICESTATE_MIN_VER 24
 
 extern meshtastic_DeviceState devicestate;
@@ -170,21 +166,6 @@ class NodeDB
     Observable<const meshtastic::NodeStatus *> newStatus;
     pb_size_t numMeshNodes;
 
-    // Satellite per-NodeNum maps for data we used to inline into NodeInfoLite,
-    // gated by MESHTASTIC_EXCLUDE_*DB so STM32WL can omit them.
-#if !MESHTASTIC_EXCLUDE_POSITIONDB
-    std::unordered_map<NodeNum, meshtastic_PositionLite> nodePositions;
-#endif
-#if !MESHTASTIC_EXCLUDE_TELEMETRYDB
-    std::unordered_map<NodeNum, meshtastic_DeviceMetrics> nodeTelemetry;
-#endif
-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTDB
-    std::unordered_map<NodeNum, meshtastic_EnvironmentMetrics> nodeEnvironment;
-#endif
-#if !MESHTASTIC_EXCLUDE_STATUSDB
-    std::unordered_map<NodeNum, meshtastic_StatusMessage> nodeStatus;
-#endif
-
     bool keyIsLowEntropy = false;
     bool hasWarned = false;
 
@@ -296,43 +277,6 @@ class NodeDB
     virtual meshtastic_NodeInfoLite *getMeshNode(NodeNum n);
     size_t getNumMeshNodes() { return numMeshNodes; }
 
-    // Thread-safe satellite-map accessors. Return false if absent or the
-    // corresponding DB is compiled out.
-    bool copyNodePosition(NodeNum n, meshtastic_PositionLite &out) const;
-    bool copyNodeTelemetry(NodeNum n, meshtastic_DeviceMetrics &out) const;
-    bool copyNodeEnvironment(NodeNum n, meshtastic_EnvironmentMetrics &out) const;
-    bool copyNodeStatus(NodeNum n, meshtastic_StatusMessage &out) const;
-    std::vector<NodeNum> snapshotPositionNodeNums(NodeNum exclude) const;
-    std::vector<NodeNum> snapshotTelemetryNodeNums(NodeNum exclude) const;
-    std::vector<NodeNum> snapshotEnvironmentNodeNums(NodeNum exclude) const;
-    std::vector<NodeNum> snapshotStatusNodeNums(NodeNum exclude) const;
-
-    void setNodeStatus(NodeNum n, const meshtastic_StatusMessage &status);
-    void touchNodePositionTime(NodeNum n, uint32_t time);
-
-    bool hasNodePosition(NodeNum n) const
-    {
-        meshtastic_PositionLite scratch;
-        return copyNodePosition(n, scratch);
-    }
-    bool hasNodeTelemetry(NodeNum n) const
-    {
-        meshtastic_DeviceMetrics scratch;
-        return copyNodeTelemetry(n, scratch);
-    }
-    bool hasNodeEnvironment(NodeNum n) const
-    {
-        meshtastic_EnvironmentMetrics scratch;
-        return copyNodeEnvironment(n, scratch);
-    }
-    bool hasNodeStatus(NodeNum n) const
-    {
-        meshtastic_StatusMessage scratch;
-        return copyNodeStatus(n, scratch);
-    }
-
-    void eraseNodeSatellites(NodeNum n);
-
     UserLicenseStatus getLicenseStatus(uint32_t nodeNum);
 
     size_t getMaxNodesAllocatedSize()
@@ -341,11 +285,7 @@ class NodeDB
         emptyNodeDatabase.version = DEVICESTATE_CUR_VER;
         size_t nodeDatabaseSize;
         pb_get_encoded_size(&nodeDatabaseSize, meshtastic_NodeDatabase_fields, &emptyNodeDatabase);
-        // Always include satellite slots so backups from higher-cap peers
-        // decode without truncation, even when our build excludes the DBs.
-        return nodeDatabaseSize + (MAX_NUM_NODES * meshtastic_NodeInfoLite_size) +
-               (MAX_NUM_NODES * meshtastic_NodePositionEntry_size) + (MAX_NUM_NODES * meshtastic_NodeTelemetryEntry_size) +
-               (MAX_NUM_NODES * meshtastic_NodeEnvironmentEntry_size) + (MAX_NUM_NODES * meshtastic_NodeStatusEntry_size);
+        return nodeDatabaseSize + (MAX_NUM_NODES * meshtastic_NodeInfoLite_size);
     }
 
     // returns true if the maximum number of nodes is reached or we are running low on memory
@@ -389,7 +329,6 @@ class NodeDB
     }
 
   private:
-    mutable concurrency::Lock satelliteMutex;
     bool duplicateWarned = false;
     bool localPositionUpdatedSinceBoot = false;
     uint32_t lastNodeDbSave = 0;    // when we last saved our db to flash
@@ -424,11 +363,6 @@ class NodeDB
     bool saveDeviceStateToDisk();
     bool saveNodeDatabaseToDisk();
     void sortMeshDB();
-
-    // Defined in NodeDBLegacyMigration.cpp. Decodes /prefs/nodes.proto via
-    // the legacy descriptor and copies entries into the v25 layout. Caller
-    // is responsible for save / install-default on the result.
-    bool migrateLegacyNodeDatabase();
 };
 
 extern NodeDB *nodeDB;
@@ -463,74 +397,10 @@ extern meshtastic_CriticalErrorCode error_code;
  * A numeric error address (nonzero if available)
  */
 extern uint32_t error_address;
-// Bit assignments for meshtastic_NodeInfoLite.bitfield.
 #define NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_SHIFT 0
-#define NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK (1u << NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_SHIFT)
+#define NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK (1 << NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_SHIFT)
 #define NODEINFO_BITFIELD_IS_MUTED_SHIFT 1
-#define NODEINFO_BITFIELD_IS_MUTED_MASK (1u << NODEINFO_BITFIELD_IS_MUTED_SHIFT)
-#define NODEINFO_BITFIELD_VIA_MQTT_SHIFT 2
-#define NODEINFO_BITFIELD_VIA_MQTT_MASK (1u << NODEINFO_BITFIELD_VIA_MQTT_SHIFT)
-#define NODEINFO_BITFIELD_IS_FAVORITE_SHIFT 3
-#define NODEINFO_BITFIELD_IS_FAVORITE_MASK (1u << NODEINFO_BITFIELD_IS_FAVORITE_SHIFT)
-#define NODEINFO_BITFIELD_IS_IGNORED_SHIFT 4
-#define NODEINFO_BITFIELD_IS_IGNORED_MASK (1u << NODEINFO_BITFIELD_IS_IGNORED_SHIFT)
-#define NODEINFO_BITFIELD_HAS_USER_SHIFT 5
-#define NODEINFO_BITFIELD_HAS_USER_MASK (1u << NODEINFO_BITFIELD_HAS_USER_SHIFT)
-#define NODEINFO_BITFIELD_IS_LICENSED_SHIFT 6
-#define NODEINFO_BITFIELD_IS_LICENSED_MASK (1u << NODEINFO_BITFIELD_IS_LICENSED_SHIFT)
-#define NODEINFO_BITFIELD_IS_UNMESSAGABLE_SHIFT 7
-#define NODEINFO_BITFIELD_IS_UNMESSAGABLE_MASK (1u << NODEINFO_BITFIELD_IS_UNMESSAGABLE_SHIFT)
-#define NODEINFO_BITFIELD_HAS_IS_UNMESSAGABLE_SHIFT 8
-#define NODEINFO_BITFIELD_HAS_IS_UNMESSAGABLE_MASK (1u << NODEINFO_BITFIELD_HAS_IS_UNMESSAGABLE_SHIFT)
-// Bits 9..31 reserved for future single-bit flags.
-
-// Convenience accessors so call sites read like the old struct fields.
-inline bool nodeInfoLiteHasUser(const meshtastic_NodeInfoLite *n)
-{
-    return n && (n->bitfield & NODEINFO_BITFIELD_HAS_USER_MASK);
-}
-inline bool nodeInfoLiteViaMqtt(const meshtastic_NodeInfoLite *n)
-{
-    return n && (n->bitfield & NODEINFO_BITFIELD_VIA_MQTT_MASK);
-}
-inline bool nodeInfoLiteIsFavorite(const meshtastic_NodeInfoLite *n)
-{
-    return n && (n->bitfield & NODEINFO_BITFIELD_IS_FAVORITE_MASK);
-}
-inline bool nodeInfoLiteIsIgnored(const meshtastic_NodeInfoLite *n)
-{
-    return n && (n->bitfield & NODEINFO_BITFIELD_IS_IGNORED_MASK);
-}
-inline bool nodeInfoLiteIsLicensed(const meshtastic_NodeInfoLite *n)
-{
-    return n && (n->bitfield & NODEINFO_BITFIELD_IS_LICENSED_MASK);
-}
-inline bool nodeInfoLiteHasIsUnmessagable(const meshtastic_NodeInfoLite *n)
-{
-    return n && (n->bitfield & NODEINFO_BITFIELD_HAS_IS_UNMESSAGABLE_MASK);
-}
-inline bool nodeInfoLiteIsUnmessagable(const meshtastic_NodeInfoLite *n)
-{
-    return n && (n->bitfield & NODEINFO_BITFIELD_IS_UNMESSAGABLE_MASK);
-}
-inline bool nodeInfoLiteIsMuted(const meshtastic_NodeInfoLite *n)
-{
-    return n && (n->bitfield & NODEINFO_BITFIELD_IS_MUTED_MASK);
-}
-inline bool nodeInfoLiteIsKeyManuallyVerified(const meshtastic_NodeInfoLite *n)
-{
-    return n && (n->bitfield & NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK);
-}
-
-inline void nodeInfoLiteSetBit(meshtastic_NodeInfoLite *n, uint32_t mask, bool value)
-{
-    if (!n)
-        return;
-    if (value)
-        n->bitfield |= mask;
-    else
-        n->bitfield &= ~mask;
-}
+#define NODEINFO_BITFIELD_IS_MUTED_MASK (1 << NODEINFO_BITFIELD_IS_MUTED_SHIFT)
 
 #define Module_Config_size                                                                                                       \
     (ModuleConfig_CannedMessageConfig_size + ModuleConfig_ExternalNotificationConfig_size + ModuleConfig_MQTTConfig_size +       \

src/mesh/NodeDBLegacyMigration.cpp

@@ -1,129 +0,0 @@
-// Migration from the legacy (pre-v25) NodeDatabase shape to the slim header +
-// satellite maps layout. Lives in its own translation unit so the bulk
-// fixed-shape decode + field-by-field copy doesn't clutter NodeDB.cpp.
-//
-// Caller (NodeDB::loadFromDisk) decides what to do with the result:
-//   - true  -> persist via saveNodeDatabaseToDisk()
-//   - false -> reset via installDefaultNodeDatabase()
-//
-// This file (and the deviceonly_legacy proto) can be removed once
-// DEVICESTATE_MIN_VER advances past 24.
-
-#include "NodeDB.h"
-#include "concurrency/LockGuard.h"
-#include "configuration.h"
-#include "mesh-pb-constants.h"
-#include "mesh/generated/meshtastic/deviceonly_legacy.pb.h"
-
-#include <algorithm>
-#include <cstring>
-#include <pb_decode.h>
-#include <pb_encode.h>
-
-bool meshtastic_NodeDatabase_Legacy_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field)
-{
-    const auto *iter = reinterpret_cast<const pb_field_iter_t *>(field);
-    if (ostream) {
-        const auto *vec = static_cast<const std::vector<meshtastic_NodeInfoLite_Legacy> *>(iter->pData);
-        for (auto item : *vec) {
-            if (!pb_encode_tag_for_field(ostream, iter))
-                return false;
-            if (!pb_encode_submessage(ostream, meshtastic_NodeInfoLite_Legacy_fields, &item))
-                return false;
-        }
-    }
-    if (istream) {
-        meshtastic_NodeInfoLite_Legacy node;
-        auto *vec = static_cast<std::vector<meshtastic_NodeInfoLite_Legacy> *>(iter->pData);
-        if (istream->bytes_left && pb_decode(istream, meshtastic_NodeInfoLite_Legacy_fields, &node))
-            vec->push_back(node);
-    }
-    return true;
-}
-
-bool NodeDB::migrateLegacyNodeDatabase()
-{
-    LOG_WARN("NodeDatabase v%u: migrating to v%u", nodeDatabase.version, DEVICESTATE_CUR_VER);
-
-    // _init_zero brace-inits the embedded std::vector via its explicit
-    // (size_type, allocator) ctor, so default-construct instead.
-    meshtastic_NodeDatabase_Legacy legacyDb{};
-    legacyDb.version = 0;
-    meshtastic_NodeDatabase_Legacy legacyEmpty{};
-    legacyEmpty.version = DEVICESTATE_CUR_VER;
-    size_t legacyEmptyEncoded = 0;
-    pb_get_encoded_size(&legacyEmptyEncoded, meshtastic_NodeDatabase_Legacy_fields, &legacyEmpty);
-    const size_t legacyBufSize = legacyEmptyEncoded + (MAX_NUM_NODES * meshtastic_NodeInfoLite_Legacy_size);
-    auto legacyState = loadProto(nodeDatabaseFileName, legacyBufSize, sizeof(meshtastic_NodeDatabase_Legacy),
-                                 &meshtastic_NodeDatabase_Legacy_msg, &legacyDb);
-    if (legacyState != LoadFileResult::LOAD_SUCCESS) {
-        LOG_ERROR("Failed to load NodeDatabase via legacy descriptor; installing default");
-        return false;
-    }
-
-    nodeDatabase.nodes.clear();
-    const size_t maxToMigrate = std::min<size_t>(legacyDb.nodes.size(), MAX_NUM_NODES);
-    nodeDatabase.nodes.reserve(maxToMigrate);
-    size_t posCount = 0, telCount = 0;
-    {
-        concurrency::LockGuard guard(&satelliteMutex);
-        for (size_t i = 0; i < maxToMigrate; ++i) {
-            const auto &legacy = legacyDb.nodes[i];
-            meshtastic_NodeInfoLite slim = meshtastic_NodeInfoLite_init_default;
-            slim.num = legacy.num;
-            slim.snr = legacy.snr;
-            slim.last_heard = legacy.last_heard;
-            slim.channel = legacy.channel;
-            slim.has_hops_away = legacy.has_hops_away;
-            slim.hops_away = legacy.hops_away;
-            slim.next_hop = legacy.next_hop;
-            slim.bitfield = legacy.bitfield;
-            if (legacy.via_mqtt)
-                slim.bitfield |= NODEINFO_BITFIELD_VIA_MQTT_MASK;
-            if (legacy.is_favorite)
-                slim.bitfield |= NODEINFO_BITFIELD_IS_FAVORITE_MASK;
-            if (legacy.is_ignored)
-                slim.bitfield |= NODEINFO_BITFIELD_IS_IGNORED_MASK;
-            if (legacy.has_user) {
-                slim.bitfield |= NODEINFO_BITFIELD_HAS_USER_MASK;
-                strncpy(slim.long_name, legacy.user.long_name, sizeof(slim.long_name));
-                slim.long_name[sizeof(slim.long_name) - 1] = '\0';
-                strncpy(slim.short_name, legacy.user.short_name, sizeof(slim.short_name));
-                slim.short_name[sizeof(slim.short_name) - 1] = '\0';
-                slim.hw_model = legacy.user.hw_model;
-                slim.role = legacy.user.role;
-                if (legacy.user.is_licensed)
-                    slim.bitfield |= NODEINFO_BITFIELD_IS_LICENSED_MASK;
-                slim.public_key.size = legacy.user.public_key.size;
-                memcpy(slim.public_key.bytes, legacy.user.public_key.bytes, sizeof(slim.public_key.bytes));
-                if (legacy.user.has_is_unmessagable) {
-                    slim.bitfield |= NODEINFO_BITFIELD_HAS_IS_UNMESSAGABLE_MASK;
-                    if (legacy.user.is_unmessagable)
-                        slim.bitfield |= NODEINFO_BITFIELD_IS_UNMESSAGABLE_MASK;
-                }
-                // macaddr deprecated since 1.2.11 - dropped from slim header.
-            }
-            nodeDatabase.nodes.push_back(slim);
-#if !MESHTASTIC_EXCLUDE_POSITIONDB
-            if (legacy.has_position)
-                nodePositions[legacy.num] = legacy.position;
-#endif
-#if !MESHTASTIC_EXCLUDE_TELEMETRYDB
-            if (legacy.has_device_metrics)
-                nodeTelemetry[legacy.num] = legacy.device_metrics;
-#endif
-        }
-#if !MESHTASTIC_EXCLUDE_POSITIONDB
-        posCount = nodePositions.size();
-#endif
-#if !MESHTASTIC_EXCLUDE_TELEMETRYDB
-        telCount = nodeTelemetry.size();
-#endif
-    }
-    nodeDatabase.version = DEVICESTATE_CUR_VER;
-    meshNodes = &nodeDatabase.nodes;
-    numMeshNodes = nodeDatabase.nodes.size();
-    LOG_INFO("Migrated %u nodes from legacy -> v%u (positions: %u, telemetry: %u)", (unsigned)numMeshNodes, DEVICESTATE_CUR_VER,
-             (unsigned)posCount, (unsigned)telCount);
-    return true;
-}

src/mesh/PacketHistory.cpp

@@ -17,7 +17,7 @@
 #define VERBOSE_PACKET_HISTORY 0     // Set to 1 for verbose logging, 2 for heavy debugging
 #define PACKET_HISTORY_TRACE_AGING 1 // Set to 1 to enable logging of the age of re/used history slots
 
-PacketHistory::PacketHistory(uint32_t size) : recentPacketsCapacity(0) // Initialize members
+PacketHistory::PacketHistory(uint32_t size) : recentPacketsCapacity(0), recentPackets(NULL) // Initialize members
 {
     if (size < 4 || size > PACKETHISTORY_MAX) { // Copilot suggested - makes sense
         LOG_WARN("Packet History - Invalid size %d, using default %d", size, PACKETHISTORY_MAX);
@@ -34,7 +34,7 @@ PacketHistory::PacketHistory(uint32_t size) : recentPacketsCapacity(0) // Initia
 
     // Allocate memory for the recent packets array
     recentPacketsCapacity = size;
-    recentPackets.reset(new PacketRecord[recentPacketsCapacity]);
+    recentPackets = new PacketRecord[recentPacketsCapacity];
     if (!recentPackets) { // No logging here, console/log probably uninitialized yet.
         LOG_ERROR("Packet History - Memory allocation failed for size=%d entries / %d Bytes", size,
                   sizeof(PacketRecord) * recentPacketsCapacity);
@@ -43,20 +43,33 @@ PacketHistory::PacketHistory(uint32_t size) : recentPacketsCapacity(0) // Initia
     }
 
     // Initialize the recent packets array to zero
-    memset(recentPackets.get(), 0, sizeof(PacketRecord) * recentPacketsCapacity);
+    memset(recentPackets, 0, sizeof(PacketRecord) * recentPacketsCapacity);
 
 #if !MESHTASTIC_EXCLUDE_PKT_HISTORY_HASH
     // Allocate hash index with load factor <= 0.5 for short probe chains
     hashCapacity = nextPowerOf2(recentPacketsCapacity * 2);
     hashMask = hashCapacity - 1;
-    hashIndex.reset(new uint16_t[hashCapacity]);
+    hashIndex = new uint16_t[hashCapacity];
     if (!hashIndex) {
         LOG_ERROR("Packet History - Hash index allocation failed for %d entries", hashCapacity);
         hashCapacity = 0;
         hashMask = 0;
         return;
     }
-    memset(hashIndex.get(), 0xFF, sizeof(uint16_t) * hashCapacity); // Fill with HASH_EMPTY (0xFFFF)
+    memset(hashIndex, 0xFF, sizeof(uint16_t) * hashCapacity); // Fill with HASH_EMPTY (0xFFFF)
+#endif
+}
+
+PacketHistory::~PacketHistory()
+{
+    recentPacketsCapacity = 0;
+    delete[] recentPackets;
+    recentPackets = NULL;
+#if !MESHTASTIC_EXCLUDE_PKT_HISTORY_HASH
+    delete[] hashIndex;
+    hashIndex = NULL;
+    hashCapacity = 0;
+    hashMask = 0;
 #endif
 }
 
@@ -272,7 +285,7 @@ void PacketHistory::hashRebuild()
 {
     if (!hashIndex)
         return;
-    memset(hashIndex.get(), 0xFF, sizeof(uint16_t) * hashCapacity);
+    memset(hashIndex, 0xFF, sizeof(uint16_t) * hashCapacity);
     for (uint32_t i = 0; i < recentPacketsCapacity; i++) {
         if (recentPackets[i].rxTimeMsec != 0)
             hashInsert(recentPackets[i].sender, recentPackets[i].id, (uint16_t)i);
@@ -319,8 +332,7 @@ PacketHistory::PacketRecord *PacketHistory::find(NodeNum sender, PacketId id)
 #endif
 
     // Linear scan (sole path when hash excluded, fallback when hash allocation failed)
-    PacketRecord *base = recentPackets.get();
-    for (PacketRecord *it = base; it < (base + recentPacketsCapacity); ++it) {
+    for (PacketRecord *it = recentPackets; it < (recentPackets + recentPacketsCapacity); ++it) {
         if (it->id == id && it->sender == sender) {
             return it;
         }
@@ -334,38 +346,39 @@ void PacketHistory::insert(const PacketRecord &r)
 {
     uint32_t now_millis = millis(); // Should not jump with time changes
     uint32_t OldtrxTimeMsec = 0;
-    PacketRecord *base = recentPackets.get();
     PacketRecord *tu = NULL; // Will insert here.
     PacketRecord *it = NULL;
 
     // Find a free, matching or oldest used slot in the recentPackets array
-    for (it = base; it < (base + recentPacketsCapacity); ++it) {
+    for (it = recentPackets; it < (recentPackets + recentPacketsCapacity); ++it) {
         if (it->id == 0 && it->sender == 0 /*&& rxTimeMsec == 0*/) { // Record is empty
             tu = it;                                                 // Remember the free slot
 #if VERBOSE_PACKET_HISTORY >= 2
-            LOG_DEBUG("Packet History - insert: Free slot@ %d/%d", tu - base, recentPacketsCapacity);
+            LOG_DEBUG("Packet History - insert: Free slot@ %d/%d", tu - recentPackets, recentPacketsCapacity);
 #endif
             // We have that, Exit the loop
-            it = (base + recentPacketsCapacity);
+            it = (recentPackets + recentPacketsCapacity);
         } else if (it->id == r.id && it->sender == r.sender) { // Record matches the packet we want to insert
             tu = it;                                           // Remember the matching slot
             OldtrxTimeMsec = now_millis - it->rxTimeMsec;      // ..and save current entry's age
 #if VERBOSE_PACKET_HISTORY >= 2
-            LOG_DEBUG("Packet History - insert: Matched slot@ %d/%d age=%d", tu - base, recentPacketsCapacity, OldtrxTimeMsec);
+            LOG_DEBUG("Packet History - insert: Matched slot@ %d/%d age=%d", tu - recentPackets, recentPacketsCapacity,
+                      OldtrxTimeMsec);
 #endif
             // We have that, Exit the loop
-            it = (base + recentPacketsCapacity);
+            it = (recentPackets + recentPacketsCapacity);
         } else {
             if (it->rxTimeMsec == 0) {
                 LOG_WARN(
                     "Packet History - insert: Found packet s=%08x id=%08x with rxTimeMsec = 0, slot %d/%d. Should never happen!",
-                    it->sender, it->id, it - base, recentPacketsCapacity);
+                    it->sender, it->id, it - recentPackets, recentPacketsCapacity);
             }
             if ((now_millis - it->rxTimeMsec) > OldtrxTimeMsec) { // 49.7 days rollover friendly
                 OldtrxTimeMsec = now_millis - it->rxTimeMsec;
                 tu = it; // remember the oldest packet
 #if VERBOSE_PACKET_HISTORY >= 2
-                LOG_DEBUG("Packet History - insert: Older slot@ %d/%d age=%d", tu - base, recentPacketsCapacity, OldtrxTimeMsec);
+                LOG_DEBUG("Packet History - insert: Older slot@ %d/%d age=%d", tu - recentPackets, recentPacketsCapacity,
+                          OldtrxTimeMsec);
 #endif
             }
             // keep looking for oldest till entire array is checked
@@ -380,11 +393,13 @@ void PacketHistory::insert(const PacketRecord &r)
 
 #if VERBOSE_PACKET_HISTORY
     if (tu->id == 0 && tu->sender == 0) {
-        LOG_DEBUG("Packet History - insert: slot@ %d/%d is NEW", tu - base, recentPacketsCapacity);
+        LOG_DEBUG("Packet History - insert: slot@ %d/%d is NEW", tu - recentPackets, recentPacketsCapacity);
     } else if (tu->id == r.id && tu->sender == r.sender) {
-        LOG_DEBUG("Packet History - insert: slot@ %d/%d MATCHED, age=%d", tu - base, recentPacketsCapacity, OldtrxTimeMsec);
+        LOG_DEBUG("Packet History - insert: slot@ %d/%d MATCHED, age=%d", tu - recentPackets, recentPacketsCapacity,
+                  OldtrxTimeMsec);
     } else {
-        LOG_DEBUG("Packet History - insert: slot@ %d/%d REUSE OLDEST, age=%d", tu - base, recentPacketsCapacity, OldtrxTimeMsec);
+        LOG_DEBUG("Packet History - insert: slot@ %d/%d REUSE OLDEST, age=%d", tu - recentPackets, recentPacketsCapacity,
+                  OldtrxTimeMsec);
     }
 #endif
 
@@ -417,9 +432,9 @@ void PacketHistory::insert(const PacketRecord &r)
 #endif
 
 #if VERBOSE_PACKET_HISTORY
-    LOG_DEBUG("Packet History - insert: Store slot@ %d/%d s=%08x id=%08x nh=%02x rby=%02x %02x %02x rxT=%d BEFORE", tu - base,
-              recentPacketsCapacity, tu->sender, tu->id, tu->next_hop, tu->relayed_by[0], tu->relayed_by[1], tu->relayed_by[2],
-              tu->rxTimeMsec);
+    LOG_DEBUG("Packet History - insert: Store slot@ %d/%d s=%08x id=%08x nh=%02x rby=%02x %02x %02x rxT=%d BEFORE",
+              tu - recentPackets, recentPacketsCapacity, tu->sender, tu->id, tu->next_hop, tu->relayed_by[0], tu->relayed_by[1],
+              tu->relayed_by[2], tu->rxTimeMsec);
 #endif
 
     if (r.rxTimeMsec == 0) {
@@ -439,16 +454,16 @@ void PacketHistory::insert(const PacketRecord &r)
     *tu = r; // store the packet
 
     if (!isMatchingSlot) {
-        hashInsert(r.sender, r.id, (uint16_t)(tu - base));
+        hashInsert(r.sender, r.id, (uint16_t)(tu - recentPackets));
     }
 #else
     *tu = r; // store the packet
 #endif
 
 #if VERBOSE_PACKET_HISTORY
-    LOG_DEBUG("Packet History - insert: Store slot@ %d/%d s=%08x id=%08x nh=%02x rby=%02x %02x %02x rxT=%d AFTER", tu - base,
-              recentPacketsCapacity, tu->sender, tu->id, tu->next_hop, tu->relayed_by[0], tu->relayed_by[1], tu->relayed_by[2],
-              tu->rxTimeMsec);
+    LOG_DEBUG("Packet History - insert: Store slot@ %d/%d s=%08x id=%08x nh=%02x rby=%02x %02x %02x rxT=%d AFTER",
+              tu - recentPackets, recentPacketsCapacity, tu->sender, tu->id, tu->next_hop, tu->relayed_by[0], tu->relayed_by[1],
+              tu->relayed_by[2], tu->rxTimeMsec);
 #endif
 }
 

src/mesh/PacketHistory.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "NodeDB.h"
-#include <memory>
 
 // Number of relayers we keep track of. Use 6 to be efficient with memory alignment of PacketRecord to 20 bytes
 #define NUM_RELAYERS 6
@@ -27,7 +26,7 @@ class PacketHistory
 
     uint32_t recentPacketsCapacity =
         0; // Can be set in constructor, no need to recompile. Used to allocate memory for mx_recentPackets.
-    std::unique_ptr<PacketRecord[]> recentPackets; // Simple and fixed in size. Debloat.
+    PacketRecord *recentPackets = NULL; // Simple and fixed in size. Debloat.
 
 #if !MESHTASTIC_EXCLUDE_PKT_HISTORY_HASH
     // Open-addressing hash table for O(1) lookup in find(), replacing the O(N) linear scan.
@@ -35,7 +34,7 @@ class PacketHistory
     // The load factor invariant holds permanently: hashCapacity = 2 * nextPowerOf2(recentPacketsCapacity),
     // and at most recentPacketsCapacity entries can ever be live (one per recentPackets[] slot).
     static constexpr uint16_t HASH_EMPTY = 0xFFFF;
-    std::unique_ptr<uint16_t[]> hashIndex;
+    uint16_t *hashIndex = NULL;
     uint32_t hashCapacity = 0; // Always a power of 2
     uint32_t hashMask = 0;     // hashCapacity - 1, for fast modular indexing
 
@@ -65,8 +64,11 @@ class PacketHistory
     uint8_t getOurTxHopLimit(const PacketRecord &r);
     void setOurTxHopLimit(PacketRecord &r, uint8_t hopLimit);
 
+    PacketHistory(const PacketHistory &);            // non construction-copyable
+    PacketHistory &operator=(const PacketHistory &); // non copyable
   public:
     explicit PacketHistory(uint32_t size = -1); // Constructor with size parameter, default is PACKETHISTORY_MAX
+    ~PacketHistory();
 
     /**
      * Update recentBroadcasts and return true if we have already seen this packet
@@ -98,5 +100,5 @@ class PacketHistory
     void removeRelayer(const uint8_t relayer, const uint32_t id, const NodeNum sender);
 
     // To check if the PacketHistory was initialized correctly by constructor
-    bool initOk(void) { return recentPackets != nullptr && recentPacketsCapacity != 0; }
+    bool initOk(void) { return recentPackets != NULL && recentPacketsCapacity != 0; }
 };

src/mesh/PhoneAPI.cpp

@@ -62,7 +62,7 @@ void PhoneAPI::handleStartConfig()
     onConfigStart();
 
     // even if we were already connected - restart our state machine
-    if (config_nonce == SPECIAL_NONCE_ONLY_NODES || config_nonce == SPECIAL_NONCE_GRADIENT_ONLY_NODES) {
+    if (config_nonce == SPECIAL_NONCE_ONLY_NODES) {
         // If client only wants node info, jump directly to sending nodes
         state = STATE_SEND_OWN_NODEINFO;
         LOG_INFO("Client only wants node info, skipping other config");
@@ -81,15 +81,6 @@ void PhoneAPI::handleStartConfig()
         concurrency::LockGuard guard(&nodeInfoMutex);
         nodeInfoForPhone = {};
         nodeInfoQueue.clear();
-        replayQueue.clear();
-        replayPositionOrder.clear();
-        replayTelemetryOrder.clear();
-        replayEnvironmentOrder.clear();
-        replayStatusOrder.clear();
-        replayPositionIndex = 0;
-        replayTelemetryIndex = 0;
-        replayEnvironmentIndex = 0;
-        replayStatusIndex = 0;
     }
     resetReadIndex();
 }
@@ -129,15 +120,6 @@ void PhoneAPI::close()
             concurrency::LockGuard guard(&nodeInfoMutex);
             nodeInfoForPhone = {};
             nodeInfoQueue.clear();
-            replayQueue.clear();
-            replayPositionOrder.clear();
-            replayTelemetryOrder.clear();
-            replayEnvironmentOrder.clear();
-            replayStatusOrder.clear();
-            replayPositionIndex = 0;
-            replayTelemetryIndex = 0;
-            replayEnvironmentIndex = 0;
-            replayStatusIndex = 0;
         }
         packetForPhone = NULL;
         filesManifest.clear();
@@ -320,7 +302,7 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
                 nodeInfoForPhone.num = 0;
             }
         }
-        if (config_nonce == SPECIAL_NONCE_ONLY_NODES || config_nonce == SPECIAL_NONCE_GRADIENT_ONLY_NODES) {
+        if (config_nonce == SPECIAL_NONCE_ONLY_NODES) {
             // If client only wants node info, jump directly to sending nodes
             state = STATE_SEND_OTHER_NODEINFOS;
             onNowHasData(0);
@@ -547,124 +529,8 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
             LOG_DEBUG("Done sending %d of %d nodeinfos millis=%u", readIndex, nodeDB->getNumMeshNodes(), millis());
             concurrency::LockGuard guard(&nodeInfoMutex);
             nodeInfoQueue.clear();
-            // Replay states no-op for legacy clients / excluded DBs.
-            state = STATE_REPLAY_POSITIONS;
-            return getFromRadio(buf);
-        }
-        break;
-    }
-
-    case STATE_REPLAY_POSITIONS: {
-        if (replayPositionOrder.empty() && replayPositionIndex == 0)
-            beginReplayPositions();
-        prefetchReplayPositions();
-
-        meshtastic_MeshPacket pkt = {};
-        bool havePkt = false;
-        {
-            concurrency::LockGuard guard(&nodeInfoMutex);
-            if (!replayQueue.empty()) {
-                pkt = replayQueue.front();
-                replayQueue.pop_front();
-                havePkt = true;
-            }
-        }
-
-        if (havePkt) {
-            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_packet_tag;
-            fromRadioScratch.packet = pkt;
-        } else {
-            LOG_DEBUG("Done replaying positions count=%u millis=%u", (unsigned)replayPositionIndex, millis());
-            state = STATE_REPLAY_TELEMETRY;
-            return getFromRadio(buf);
-        }
-        break;
-    }
-
-    case STATE_REPLAY_TELEMETRY: {
-        if (replayTelemetryOrder.empty() && replayTelemetryIndex == 0)
-            beginReplayTelemetry();
-        prefetchReplayTelemetry();
-
-        meshtastic_MeshPacket pkt = {};
-        bool havePkt = false;
-        {
-            concurrency::LockGuard guard(&nodeInfoMutex);
-            if (!replayQueue.empty()) {
-                pkt = replayQueue.front();
-                replayQueue.pop_front();
-                havePkt = true;
-            }
-        }
-
-        if (havePkt) {
-            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_packet_tag;
-            fromRadioScratch.packet = pkt;
-        } else {
-            LOG_DEBUG("Done replaying telemetry count=%u millis=%u", (unsigned)replayTelemetryIndex, millis());
-            state = STATE_REPLAY_ENVIRONMENT;
-            return getFromRadio(buf);
-        }
-        break;
-    }
-
-    case STATE_REPLAY_ENVIRONMENT: {
-        if (replayEnvironmentOrder.empty() && replayEnvironmentIndex == 0)
-            beginReplayEnvironment();
-        prefetchReplayEnvironment();
-
-        meshtastic_MeshPacket pkt = {};
-        bool havePkt = false;
-        {
-            concurrency::LockGuard guard(&nodeInfoMutex);
-            if (!replayQueue.empty()) {
-                pkt = replayQueue.front();
-                replayQueue.pop_front();
-                havePkt = true;
-            }
-        }
-
-        if (havePkt) {
-            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_packet_tag;
-            fromRadioScratch.packet = pkt;
-        } else {
-            LOG_DEBUG("Done replaying environment count=%u millis=%u", (unsigned)replayEnvironmentIndex, millis());
-            state = STATE_REPLAY_STATUS;
-            return getFromRadio(buf);
-        }
-        break;
-    }
-
-    case STATE_REPLAY_STATUS: {
-        if (replayStatusOrder.empty() && replayStatusIndex == 0)
-            beginReplayStatus();
-        prefetchReplayStatus();
-
-        meshtastic_MeshPacket pkt = {};
-        bool havePkt = false;
-        {
-            concurrency::LockGuard guard(&nodeInfoMutex);
-            if (!replayQueue.empty()) {
-                pkt = replayQueue.front();
-                replayQueue.pop_front();
-                havePkt = true;
-            }
-        }
-
-        if (havePkt) {
-            fromRadioScratch.which_payload_variant = meshtastic_FromRadio_packet_tag;
-            fromRadioScratch.packet = pkt;
-        } else {
-            LOG_DEBUG("Done replaying status count=%u millis=%u", (unsigned)replayStatusIndex, millis());
-            replayPositionOrder.clear();
-            replayPositionOrder.shrink_to_fit();
-            replayTelemetryOrder.clear();
-            replayTelemetryOrder.shrink_to_fit();
-            replayEnvironmentOrder.clear();
-            replayEnvironmentOrder.shrink_to_fit();
-            replayStatusOrder.clear();
-            replayStatusOrder.shrink_to_fit();
             state = STATE_SEND_FILEMANIFEST;
+            // Go ahead and send that ID right now
             return getFromRadio(buf);
         }
         break;
@@ -672,9 +538,9 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
 
     case STATE_SEND_FILEMANIFEST: {
         LOG_DEBUG("FromRadio=STATE_SEND_FILEMANIFEST");
-        // ONLY_NODES variants skip the manifest.
-        if (config_state == filesManifest.size() || config_nonce == SPECIAL_NONCE_ONLY_NODES ||
-            config_nonce == SPECIAL_NONCE_GRADIENT_ONLY_NODES) {
+        // last element
+        if (config_state == filesManifest.size() ||
+            config_nonce == SPECIAL_NONCE_ONLY_NODES) { // also handles an empty filesManifest
             config_state = 0;
             filesManifest.clear();
             // Skip to complete packet
@@ -787,7 +653,6 @@ void PhoneAPI::prefetchNodeInfos()
 {
     bool added = false;
     bool wasEmpty = false;
-    const bool gradient = clientWantsGradientSync();
     // Keep the queue topped up so BLE reads stay responsive even if DB fetches take a moment.
     {
         concurrency::LockGuard guard(&nodeInfoMutex);
@@ -797,8 +662,7 @@ void PhoneAPI::prefetchNodeInfos()
             if (!nextNode)
                 break;
 
-            auto info =
-                gradient ? TypeConversions::ConvertToNodeInfoThin(nextNode) : TypeConversions::ConvertToNodeInfo(nextNode);
+            auto info = TypeConversions::ConvertToNodeInfo(nextNode);
             bool isUs = info.num == nodeDB->getNodeNum();
             info.hops_away = isUs ? 0 : info.hops_away;
             info.last_heard = isUs ? getValidTime(RTCQualityFromNet) : info.last_heard;
@@ -818,257 +682,6 @@ void PhoneAPI::prefetchNodeInfos()
         onNowHasData(0);
 }
 
-meshtastic_MeshPacket PhoneAPI::makeReplayPositionPacket(NodeNum num, const meshtastic_PositionLite &pos)
-{
-    meshtastic_MeshPacket pkt = meshtastic_MeshPacket_init_default;
-    pkt.from = num;
-    pkt.to = nodeDB->getNodeNum();
-    pkt.id = generatePacketId();
-    pkt.rx_time = pos.time;
-    pkt.which_payload_variant = meshtastic_MeshPacket_decoded_tag;
-    pkt.decoded.portnum = meshtastic_PortNum_POSITION_APP;
-    meshtastic_Position fullPos = TypeConversions::ConvertToPosition(pos);
-    size_t len =
-        pb_encode_to_bytes(pkt.decoded.payload.bytes, sizeof(pkt.decoded.payload.bytes), &meshtastic_Position_msg, &fullPos);
-    pkt.decoded.payload.size = (pb_size_t)len;
-    return pkt;
-}
-
-meshtastic_MeshPacket PhoneAPI::makeReplayTelemetryPacket(NodeNum num, const meshtastic_DeviceMetrics &metrics)
-{
-    meshtastic_MeshPacket pkt = meshtastic_MeshPacket_init_default;
-    pkt.from = num;
-    pkt.to = nodeDB->getNodeNum();
-    pkt.id = generatePacketId();
-    // No native timestamp on telemetry packets here; use last_heard.
-    const meshtastic_NodeInfoLite *header = nodeDB->getMeshNode(num);
-    pkt.rx_time = header ? header->last_heard : 0;
-    pkt.which_payload_variant = meshtastic_MeshPacket_decoded_tag;
-    pkt.decoded.portnum = meshtastic_PortNum_TELEMETRY_APP;
-    meshtastic_Telemetry fullTel = meshtastic_Telemetry_init_default;
-    fullTel.time = pkt.rx_time;
-    fullTel.which_variant = meshtastic_Telemetry_device_metrics_tag;
-    fullTel.variant.device_metrics = metrics;
-    size_t len =
-        pb_encode_to_bytes(pkt.decoded.payload.bytes, sizeof(pkt.decoded.payload.bytes), &meshtastic_Telemetry_msg, &fullTel);
-    pkt.decoded.payload.size = (pb_size_t)len;
-    return pkt;
-}
-
-void PhoneAPI::beginReplayPositions()
-{
-#if MESHTASTIC_EXCLUDE_POSITIONDB
-    // Build excluded entirely - leave the order list empty so the state arm
-    // immediately drains and advances.
-    replayPositionOrder.clear();
-    replayPositionIndex = 0;
-#else
-    if (!clientWantsGradientSync()) {
-        replayPositionOrder.clear();
-        replayPositionIndex = 0;
-        return;
-    }
-    // Snapshot the keyset at phase start so concurrent inserts/erases on the
-    // map don't invalidate iteration. Skip our own node - the phone already
-    // got our position bundled in STATE_SEND_OWN_NODEINFO.
-    replayPositionOrder = nodeDB->snapshotPositionNodeNums(nodeDB->getNodeNum());
-    replayPositionIndex = 0;
-    LOG_INFO("Begin position replay: %u entries millis=%u", (unsigned)replayPositionOrder.size(), millis());
-#endif
-}
-
-void PhoneAPI::prefetchReplayPositions()
-{
-#if MESHTASTIC_EXCLUDE_POSITIONDB
-    return;
-#else
-    if (!clientWantsGradientSync())
-        return;
-    bool added = false;
-    bool wasEmpty = false;
-    {
-        concurrency::LockGuard guard(&nodeInfoMutex);
-        wasEmpty = replayQueue.empty();
-        while (replayQueue.size() < kReplayPrefetchDepth && replayPositionIndex < replayPositionOrder.size()) {
-            NodeNum num = replayPositionOrder[replayPositionIndex++];
-            meshtastic_PositionLite pos;
-            if (!nodeDB->copyNodePosition(num, pos))
-                continue; // entry was evicted between snapshot and now
-            replayQueue.push_back(makeReplayPositionPacket(num, pos));
-            added = true;
-        }
-    }
-    if (added && wasEmpty)
-        onNowHasData(0);
-#endif
-}
-
-void PhoneAPI::beginReplayTelemetry()
-{
-#if MESHTASTIC_EXCLUDE_TELEMETRYDB
-    replayTelemetryOrder.clear();
-    replayTelemetryIndex = 0;
-#else
-    if (!clientWantsGradientSync()) {
-        replayTelemetryOrder.clear();
-        replayTelemetryIndex = 0;
-        return;
-    }
-    replayTelemetryOrder = nodeDB->snapshotTelemetryNodeNums(nodeDB->getNodeNum());
-    replayTelemetryIndex = 0;
-    LOG_INFO("Begin telemetry replay: %u entries millis=%u", (unsigned)replayTelemetryOrder.size(), millis());
-#endif
-}
-
-void PhoneAPI::prefetchReplayTelemetry()
-{
-#if MESHTASTIC_EXCLUDE_TELEMETRYDB
-    return;
-#else
-    if (!clientWantsGradientSync())
-        return;
-    bool added = false;
-    bool wasEmpty = false;
-    {
-        concurrency::LockGuard guard(&nodeInfoMutex);
-        wasEmpty = replayQueue.empty();
-        while (replayQueue.size() < kReplayPrefetchDepth && replayTelemetryIndex < replayTelemetryOrder.size()) {
-            NodeNum num = replayTelemetryOrder[replayTelemetryIndex++];
-            meshtastic_DeviceMetrics dm;
-            if (!nodeDB->copyNodeTelemetry(num, dm))
-                continue;
-            replayQueue.push_back(makeReplayTelemetryPacket(num, dm));
-            added = true;
-        }
-    }
-    if (added && wasEmpty)
-        onNowHasData(0);
-#endif
-}
-
-meshtastic_MeshPacket PhoneAPI::makeReplayEnvironmentPacket(uint32_t num, const meshtastic_EnvironmentMetrics &env)
-{
-    meshtastic_MeshPacket pkt = meshtastic_MeshPacket_init_default;
-    pkt.from = num;
-    pkt.to = nodeDB->getNodeNum();
-    pkt.id = generatePacketId();
-    const meshtastic_NodeInfoLite *header = nodeDB->getMeshNode(num);
-    pkt.rx_time = header ? header->last_heard : 0;
-    pkt.which_payload_variant = meshtastic_MeshPacket_decoded_tag;
-    pkt.decoded.portnum = meshtastic_PortNum_TELEMETRY_APP;
-    meshtastic_Telemetry fullTel = meshtastic_Telemetry_init_default;
-    fullTel.time = pkt.rx_time;
-    fullTel.which_variant = meshtastic_Telemetry_environment_metrics_tag;
-    fullTel.variant.environment_metrics = env;
-    size_t len =
-        pb_encode_to_bytes(pkt.decoded.payload.bytes, sizeof(pkt.decoded.payload.bytes), &meshtastic_Telemetry_msg, &fullTel);
-    pkt.decoded.payload.size = (pb_size_t)len;
-    return pkt;
-}
-
-void PhoneAPI::beginReplayEnvironment()
-{
-#if MESHTASTIC_EXCLUDE_ENVIRONMENTDB
-    replayEnvironmentOrder.clear();
-    replayEnvironmentIndex = 0;
-#else
-    if (!clientWantsGradientSync()) {
-        replayEnvironmentOrder.clear();
-        replayEnvironmentIndex = 0;
-        return;
-    }
-    replayEnvironmentOrder = nodeDB->snapshotEnvironmentNodeNums(nodeDB->getNodeNum());
-    replayEnvironmentIndex = 0;
-    LOG_INFO("Begin environment replay: %u entries millis=%u", (unsigned)replayEnvironmentOrder.size(), millis());
-#endif
-}
-
-void PhoneAPI::prefetchReplayEnvironment()
-{
-#if MESHTASTIC_EXCLUDE_ENVIRONMENTDB
-    return;
-#else
-    if (!clientWantsGradientSync())
-        return;
-    bool added = false;
-    bool wasEmpty = false;
-    {
-        concurrency::LockGuard guard(&nodeInfoMutex);
-        wasEmpty = replayQueue.empty();
-        while (replayQueue.size() < kReplayPrefetchDepth && replayEnvironmentIndex < replayEnvironmentOrder.size()) {
-            NodeNum num = replayEnvironmentOrder[replayEnvironmentIndex++];
-            meshtastic_EnvironmentMetrics env;
-            if (!nodeDB->copyNodeEnvironment(num, env))
-                continue;
-            replayQueue.push_back(makeReplayEnvironmentPacket(num, env));
-            added = true;
-        }
-    }
-    if (added && wasEmpty)
-        onNowHasData(0);
-#endif
-}
-
-meshtastic_MeshPacket PhoneAPI::makeReplayStatusPacket(uint32_t num, const meshtastic_StatusMessage &status)
-{
-    meshtastic_MeshPacket pkt = meshtastic_MeshPacket_init_default;
-    pkt.from = num;
-    pkt.to = nodeDB->getNodeNum();
-    pkt.id = generatePacketId();
-    // StatusMessage has no native timestamp; use last_heard.
-    const meshtastic_NodeInfoLite *header = nodeDB->getMeshNode(num);
-    pkt.rx_time = header ? header->last_heard : 0;
-    pkt.which_payload_variant = meshtastic_MeshPacket_decoded_tag;
-    pkt.decoded.portnum = meshtastic_PortNum_NODE_STATUS_APP;
-    size_t len =
-        pb_encode_to_bytes(pkt.decoded.payload.bytes, sizeof(pkt.decoded.payload.bytes), &meshtastic_StatusMessage_msg, &status);
-    pkt.decoded.payload.size = (pb_size_t)len;
-    return pkt;
-}
-
-void PhoneAPI::beginReplayStatus()
-{
-#if MESHTASTIC_EXCLUDE_STATUSDB
-    replayStatusOrder.clear();
-    replayStatusIndex = 0;
-#else
-    if (!clientWantsGradientSync()) {
-        replayStatusOrder.clear();
-        replayStatusIndex = 0;
-        return;
-    }
-    replayStatusOrder = nodeDB->snapshotStatusNodeNums(nodeDB->getNodeNum());
-    replayStatusIndex = 0;
-    LOG_INFO("Begin status replay: %u entries millis=%u", (unsigned)replayStatusOrder.size(), millis());
-#endif
-}
-
-void PhoneAPI::prefetchReplayStatus()
-{
-#if MESHTASTIC_EXCLUDE_STATUSDB
-    return;
-#else
-    if (!clientWantsGradientSync())
-        return;
-    bool added = false;
-    bool wasEmpty = false;
-    {
-        concurrency::LockGuard guard(&nodeInfoMutex);
-        wasEmpty = replayQueue.empty();
-        while (replayQueue.size() < kReplayPrefetchDepth && replayStatusIndex < replayStatusOrder.size()) {
-            NodeNum num = replayStatusOrder[replayStatusIndex++];
-            meshtastic_StatusMessage status;
-            if (!nodeDB->copyNodeStatus(num, status) || status.status[0] == '\0')
-                continue;
-            replayQueue.push_back(makeReplayStatusPacket(num, status));
-            added = true;
-        }
-    }
-    if (added && wasEmpty)
-        onNowHasData(0);
-#endif
-}
-
 void PhoneAPI::releaseMqttClientProxyPhonePacket()
 {
     if (mqttClientProxyMessageForPhone) {
@@ -1115,31 +728,6 @@ bool PhoneAPI::available()
     PREFETCH_NODEINFO:
         prefetchNodeInfos();
         return true;
-    case STATE_REPLAY_POSITIONS: {
-        // Prime the iterator if we haven't yet, then top up the queue.
-        if (replayPositionOrder.empty() && replayPositionIndex == 0)
-            beginReplayPositions();
-        prefetchReplayPositions();
-        return true; // Always advance state machine; arm itself transitions when drained
-    }
-    case STATE_REPLAY_TELEMETRY: {
-        if (replayTelemetryOrder.empty() && replayTelemetryIndex == 0)
-            beginReplayTelemetry();
-        prefetchReplayTelemetry();
-        return true;
-    }
-    case STATE_REPLAY_ENVIRONMENT: {
-        if (replayEnvironmentOrder.empty() && replayEnvironmentIndex == 0)
-            beginReplayEnvironment();
-        prefetchReplayEnvironment();
-        return true;
-    }
-    case STATE_REPLAY_STATUS: {
-        if (replayStatusOrder.empty() && replayStatusIndex == 0)
-            beginReplayStatus();
-        prefetchReplayStatus();
-        return true;
-    }
     case STATE_SEND_PACKETS: {
         if (!queueStatusPacketForPhone)
             queueStatusPacketForPhone = service->getQueueStatusForPhone();

src/mesh/PhoneAPI.h

@@ -4,16 +4,12 @@
 #include "concurrency/Lock.h"
 #include "mesh-pb-constants.h"
 #include "meshtastic/portnums.pb.h"
-#include <cstdint>
 #include <deque>
 #include <iterator>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
-// NodeNum stored as raw uint32_t below; including MeshTypes.h here breaks the
-// LOG_WARN include order via Arduino.h/MemoryPool.h.
-
 // Make sure that we never let our packets grow too large for one BLE packet
 #define MAX_TO_FROM_RADIO_SIZE 512
 
@@ -26,9 +22,6 @@
 
 #define SPECIAL_NONCE_ONLY_CONFIG 69420
 #define SPECIAL_NONCE_ONLY_NODES 69421 // ( ͡° ͜ʖ ͡°)
-// Gradient sync: phone sends one of these to opt into thin-header + replay.
-#define SPECIAL_NONCE_GRADIENT_SYNC 69422
-#define SPECIAL_NONCE_GRADIENT_ONLY_NODES 69423
 
 /**
  * Provides our protobuf based API which phone/PC clients can use to talk to our device
@@ -52,13 +45,7 @@ class PhoneAPI
         STATE_SEND_CONFIG,          // Replacement for the old Radioconfig
         STATE_SEND_MODULECONFIG,    // Send Module specific config
         STATE_SEND_OTHER_NODEINFOS, // states progress in this order as the device sends to to the client
-        // Drain satellite DBs as synthetic POSITION_APP / TELEMETRY_APP /
-        // NODE_STATUS_APP packets when the phone opted into gradient sync.
-        STATE_REPLAY_POSITIONS,
-        STATE_REPLAY_TELEMETRY,
-        STATE_REPLAY_ENVIRONMENT,
-        STATE_REPLAY_STATUS,
-        STATE_SEND_FILEMANIFEST, // Send file manifest
+        STATE_SEND_FILEMANIFEST,    // Send file manifest
         STATE_SEND_COMPLETE_ID,
         STATE_SEND_PACKETS // send packets or debug strings
     };
@@ -101,20 +88,6 @@ class PhoneAPI
     // Protect nodeInfoForPhone + nodeInfoQueue because NimBLE callbacks run in a separate FreeRTOS task.
     concurrency::Lock nodeInfoMutex;
 
-    // Synthetic-packet replay queue (paced via prefetch).
-    std::deque<meshtastic_MeshPacket> replayQueue;
-    static constexpr size_t kReplayPrefetchDepth = 4;
-    // NodeNum snapshots taken at each replay phase start so concurrent
-    // satellite-map mutations don't invalidate iteration.
-    std::vector<uint32_t> replayPositionOrder;
-    std::vector<uint32_t> replayTelemetryOrder;
-    std::vector<uint32_t> replayEnvironmentOrder;
-    std::vector<uint32_t> replayStatusOrder;
-    size_t replayPositionIndex = 0;
-    size_t replayTelemetryIndex = 0;
-    size_t replayEnvironmentIndex = 0;
-    size_t replayStatusIndex = 0;
-
     meshtastic_ToRadio toRadioScratch = {
         0}; // this is a static scratch object, any data must be copied elsewhere before returning
 
@@ -164,10 +137,6 @@ class PhoneAPI
 
     bool isConnected() { return state != STATE_SEND_NOTHING; }
     bool isSendingPackets() { return state == STATE_SEND_PACKETS; }
-    bool clientWantsGradientSync() const
-    {
-        return config_nonce == SPECIAL_NONCE_GRADIENT_SYNC || config_nonce == SPECIAL_NONCE_GRADIENT_ONLY_NODES;
-    }
 
   protected:
     /// Our fromradio packet while it is being assembled
@@ -216,18 +185,6 @@ class PhoneAPI
     void releaseQueueStatusPhonePacket();
 
     void prefetchNodeInfos();
-    void beginReplayPositions();
-    void prefetchReplayPositions();
-    void beginReplayTelemetry();
-    void prefetchReplayTelemetry();
-    void beginReplayEnvironment();
-    void prefetchReplayEnvironment();
-    void beginReplayStatus();
-    void prefetchReplayStatus();
-    meshtastic_MeshPacket makeReplayPositionPacket(uint32_t num, const meshtastic_PositionLite &pos);
-    meshtastic_MeshPacket makeReplayTelemetryPacket(uint32_t num, const meshtastic_DeviceMetrics &metrics);
-    meshtastic_MeshPacket makeReplayEnvironmentPacket(uint32_t num, const meshtastic_EnvironmentMetrics &env);
-    meshtastic_MeshPacket makeReplayStatusPacket(uint32_t num, const meshtastic_StatusMessage &status);
 
     void releaseMqttClientProxyPhonePacket();
 

src/mesh/ProtobufModule.h

@@ -58,7 +58,7 @@ template <class T> class ProtobufModule : protected SinglePortModule
     const char *getSenderShortName(const meshtastic_MeshPacket &mp)
     {
         auto node = nodeDB->getMeshNode(getFrom(&mp));
-        const char *sender = (node && nodeInfoLiteHasUser(node) && node->short_name[0]) ? node->short_name : "???";
+        const char *sender = (node) ? node->user.short_name : "???";
         return sender;
     }
 
@@ -121,4 +121,4 @@ template <class T> class ProtobufModule : protected SinglePortModule
             return alterReceivedProtobuf(mp, decoded);
         }
     }
-};
+};

src/mesh/RF95Interface.cpp

@@ -252,7 +252,7 @@ bool RF95Interface::reconfigure()
 
     startReceive(); // restart receiving
 
-    return true;
+    return RADIOLIB_ERR_NONE;
 }
 
 /**

src/mesh/RadioInterface.cpp

@@ -5,7 +5,6 @@
 #include "LR1110Interface.h"
 #include "LR1120Interface.h"
 #include "LR1121Interface.h"
-#include "LR2021Interface.h"
 #include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
@@ -479,20 +478,6 @@ std::unique_ptr<RadioInterface> initLoRa()
     }
 #endif
 
-#if defined(USE_LR2021) && RADIOLIB_EXCLUDE_LR2021 != 1
-    if (!rIf) {
-        rIf = std::unique_ptr<LR2021Interface>(
-            new LR2021Interface(loraHal, LR2021_SPI_NSS_PIN, LR2021_IRQ_PIN, LR2021_NRESET_PIN, LR2021_BUSY_PIN));
-        if (!rIf->init()) {
-            LOG_WARN("No LR2021 radio");
-            rIf = nullptr;
-        } else {
-            LOG_INFO("LR2021 init success");
-            radioType = LR2021_RADIO;
-        }
-    }
-#endif
-
 #if defined(USE_SX1280) && RADIOLIB_EXCLUDE_SX128X != 1
     if (!rIf) {
         rIf = std::unique_ptr<SX1280Interface>(new SX1280Interface(loraHal, SX128X_CS, SX128X_DIO1, SX128X_RESET, SX128X_BUSY));

src/mesh/ReliableRouter.cpp

@@ -115,7 +115,7 @@ void ReliableRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtas
                         sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, p->channel, 0);
                     }
                 } else if (p->which_payload_variant == meshtastic_MeshPacket_encrypted_tag && p->channel == 0 &&
-                           (nodeDB->getMeshNode(p->from) == nullptr || nodeDB->getMeshNode(p->from)->public_key.size == 0)) {
+                           (nodeDB->getMeshNode(p->from) == nullptr || nodeDB->getMeshNode(p->from)->user.public_key.size == 0)) {
                     LOG_INFO("PKI packet from unknown node, send PKI_UNKNOWN_PUBKEY");
                     sendAckNak(meshtastic_Routing_Error_PKI_UNKNOWN_PUBKEY, getFrom(p), p->id, channels.getPrimaryIndex(),
                                routingModule->getHopLimitForResponse(*p));

src/mesh/Router.cpp

@@ -120,17 +120,17 @@ bool Router::shouldDecrementHopLimit(const meshtastic_MeshPacket *p)
         if (!node)
             continue;
 
-        // Check 1: is_favorite (cheapest - single bit test)
-        if (!nodeInfoLiteIsFavorite(node))
+        // Check 1: is_favorite (cheapest - single bool)
+        if (!node->is_favorite)
             continue;
 
-        // Check 2: has_user (cheap - single bit test)
-        if (!nodeInfoLiteHasUser(node))
+        // Check 2: has_user (cheap - single bool)
+        if (!node->has_user)
             continue;
 
         // Check 3: role check (moderate cost - multiple comparisons)
-        if (!IS_ONE_OF(node->role, meshtastic_Config_DeviceConfig_Role_ROUTER, meshtastic_Config_DeviceConfig_Role_ROUTER_LATE,
-                       meshtastic_Config_DeviceConfig_Role_CLIENT_BASE)) {
+        if (!IS_ONE_OF(node->user.role, meshtastic_Config_DeviceConfig_Role_ROUTER,
+                       meshtastic_Config_DeviceConfig_Role_ROUTER_LATE, meshtastic_Config_DeviceConfig_Role_CLIENT_BASE)) {
             continue;
         }
 
@@ -329,7 +329,7 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
             cn->reply_id = p->id;
             cn->level = meshtastic_LogRecord_Level_WARNING;
             cn->time = getValidTime(RTCQualityFromNet);
-            snprintf(cn->message, sizeof(cn->message), "Duty cycle limit exceeded. You can send again in %d mins", silentMinutes);
+            sprintf(cn->message, "Duty cycle limit exceeded. You can send again in %d mins", silentMinutes);
             service->sendClientNotification(cn);
 
             meshtastic_Routing_Error err = meshtastic_Routing_Error_DUTY_CYCLE_LIMIT;
@@ -433,7 +433,7 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
     concurrency::LockGuard g(cryptLock);
 
     if (config.device.rebroadcast_mode == meshtastic_Config_DeviceConfig_RebroadcastMode_KNOWN_ONLY &&
-        !nodeInfoLiteHasUser(nodeDB->getMeshNode(p->from))) {
+        (nodeDB->getMeshNode(p->from) == NULL || !nodeDB->getMeshNode(p->from)->has_user)) {
         LOG_DEBUG("Node 0x%x not in nodeDB-> Rebroadcast mode KNOWN_ONLY will ignore packet", p->from);
         return DecodeState::DECODE_FAILURE;
     }
@@ -451,11 +451,11 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
 #if !(MESHTASTIC_EXCLUDE_PKI)
     // Attempt PKI decryption first
     if (p->channel == 0 && isToUs(p) && p->to > 0 && !isBroadcast(p->to) && nodeDB->getMeshNode(p->from) != nullptr &&
-        nodeDB->getMeshNode(p->from)->public_key.size > 0 && nodeDB->getMeshNode(p->to) != nullptr &&
-        nodeDB->getMeshNode(p->to)->public_key.size > 0 && rawSize > MESHTASTIC_PKC_OVERHEAD) {
+        nodeDB->getMeshNode(p->from)->user.public_key.size > 0 && nodeDB->getMeshNode(p->to)->user.public_key.size > 0 &&
+        rawSize > MESHTASTIC_PKC_OVERHEAD) {
         LOG_DEBUG("Attempt PKI decryption");
 
-        if (crypto->decryptCurve25519(p->from, nodeDB->getMeshNode(p->from)->public_key, p->id, rawSize, p->encrypted.bytes,
+        if (crypto->decryptCurve25519(p->from, nodeDB->getMeshNode(p->from)->user.public_key, p->id, rawSize, p->encrypted.bytes,
                                       bytes)) {
             LOG_INFO("PKI Decryption worked!");
 
@@ -467,7 +467,7 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
                 decrypted = true;
                 LOG_INFO("Packet decrypted using PKI!");
                 p->pki_encrypted = true;
-                memcpy(&p->public_key.bytes, nodeDB->getMeshNode(p->from)->public_key.bytes, 32);
+                memcpy(&p->public_key.bytes, nodeDB->getMeshNode(p->from)->user.public_key.bytes, 32);
                 p->public_key.size = 32;
                 p->decoded = decodedtmp;
                 p->which_payload_variant = meshtastic_MeshPacket_decoded_tag; // change type to decoded
@@ -665,18 +665,18 @@ meshtastic_Routing_Error perhapsEncode(meshtastic_MeshPacket *p)
             if (numbytes + MESHTASTIC_HEADER_LENGTH + MESHTASTIC_PKC_OVERHEAD > MAX_LORA_PAYLOAD_LEN)
                 return meshtastic_Routing_Error_TOO_LARGE;
             // Check for a known public key for the destination
-            if (node == nullptr || node->public_key.size != 32) {
+            if (node == nullptr || node->user.public_key.size != 32) {
                 LOG_WARN("Unknown public key for destination node 0x%08x (portnum %d), refusing to send legacy DM", p->to,
                          p->decoded.portnum);
                 return meshtastic_Routing_Error_PKI_SEND_FAIL_PUBLIC_KEY;
             }
             if (p->pki_encrypted && !memfll(p->public_key.bytes, 0, 32) &&
-                memcmp(p->public_key.bytes, node->public_key.bytes, 32) != 0) {
+                memcmp(p->public_key.bytes, node->user.public_key.bytes, 32) != 0) {
                 LOG_WARN("Client public key differs from requested: 0x%02x, stored key begins 0x%02x", *p->public_key.bytes,
-                         *node->public_key.bytes);
+                         *node->user.public_key.bytes);
                 return meshtastic_Routing_Error_PKI_FAILED;
             }
-            crypto->encryptCurve25519(p->to, getFrom(p), node->public_key, p->id, numbytes, bytes, p->encrypted.bytes);
+            crypto->encryptCurve25519(p->to, getFrom(p), node->user.public_key, p->id, numbytes, bytes, p->encrypted.bytes);
             numbytes += MESHTASTIC_PKC_OVERHEAD;
             p->channel = 0;
             p->pki_encrypted = true;
@@ -860,7 +860,7 @@ void Router::perhapsHandleReceived(meshtastic_MeshPacket *p)
     }
 
     meshtastic_NodeInfoLite const *node = nodeDB->getMeshNode(p->from);
-    if (nodeInfoLiteIsIgnored(node)) {
+    if (node != NULL && node->is_ignored) {
         LOG_DEBUG("Ignore msg, 0x%x is ignored", p->from);
         packetPool.release(p);
         return;

src/mesh/SX126xInterface.cpp

@@ -262,7 +262,7 @@ template <typename T> bool SX126xInterface<T>::reconfigure()
 
     startReceive(); // restart receiving
 
-    return true;
+    return RADIOLIB_ERR_NONE;
 }
 
 template <typename T> void SX126xInterface<T>::disableInterrupt()

src/mesh/SX128xInterface.cpp

@@ -153,7 +153,7 @@ template <typename T> bool SX128xInterface<T>::reconfigure()
 
     startReceive(); // restart receiving
 
-    return true;
+    return RADIOLIB_ERR_NONE;
 }
 
 template <typename T> void SX128xInterface<T>::disableInterrupt()

src/mesh/TypeConversions.cpp

@@ -3,9 +3,7 @@
 #include "mesh/generated/meshtastic/mesh.pb.h"
 #include "meshUtils.h"
 
-meshtastic_NodeInfo TypeConversions::ConvertToNodeInfo(const meshtastic_NodeInfoLite *lite,
-                                                       const meshtastic_PositionLite *position,
-                                                       const meshtastic_DeviceMetrics *deviceMetrics)
+meshtastic_NodeInfo TypeConversions::ConvertToNodeInfo(const meshtastic_NodeInfoLite *lite)
 {
     meshtastic_NodeInfo info = meshtastic_NodeInfo_init_default;
 
@@ -13,56 +11,42 @@ meshtastic_NodeInfo TypeConversions::ConvertToNodeInfo(const meshtastic_NodeInfo
     info.snr = lite->snr;
     info.last_heard = lite->last_heard;
     info.channel = lite->channel;
-    info.via_mqtt = nodeInfoLiteViaMqtt(lite);
-    info.is_favorite = nodeInfoLiteIsFavorite(lite);
-    info.is_ignored = nodeInfoLiteIsIgnored(lite);
-    info.is_key_manually_verified = nodeInfoLiteIsKeyManuallyVerified(lite);
-    info.is_muted = nodeInfoLiteIsMuted(lite);
+    info.via_mqtt = lite->via_mqtt;
+    info.is_favorite = lite->is_favorite;
+    info.is_ignored = lite->is_ignored;
+    info.is_key_manually_verified = lite->bitfield & NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK;
+    info.is_muted = lite->bitfield & NODEINFO_BITFIELD_IS_MUTED_MASK;
 
     if (lite->has_hops_away) {
         info.has_hops_away = true;
         info.hops_away = lite->hops_away;
     }
 
-    if (position) {
+    if (lite->has_position) {
         info.has_position = true;
-        if (position->latitude_i != 0)
+        if (lite->position.latitude_i != 0)
             info.position.has_latitude_i = true;
-        info.position.latitude_i = position->latitude_i;
-        if (position->longitude_i != 0)
+        info.position.latitude_i = lite->position.latitude_i;
+        if (lite->position.longitude_i != 0)
             info.position.has_longitude_i = true;
-        info.position.longitude_i = position->longitude_i;
-        if (position->altitude != 0)
+        info.position.longitude_i = lite->position.longitude_i;
+        if (lite->position.altitude != 0)
             info.position.has_altitude = true;
-        info.position.altitude = position->altitude;
-        info.position.location_source = position->location_source;
-        info.position.time = position->time;
+        info.position.altitude = lite->position.altitude;
+        info.position.location_source = lite->position.location_source;
+        info.position.time = lite->position.time;
     }
-    if (nodeInfoLiteHasUser(lite)) {
+    if (lite->has_user) {
         info.has_user = true;
-        info.user = ConvertToUser(lite);
+        info.user = ConvertToUser(lite->num, lite->user);
     }
-    if (deviceMetrics) {
+    if (lite->has_device_metrics) {
         info.has_device_metrics = true;
-        info.device_metrics = *deviceMetrics;
+        info.device_metrics = lite->device_metrics;
     }
     return info;
 }
 
-meshtastic_NodeInfo TypeConversions::ConvertToNodeInfo(const meshtastic_NodeInfoLite *lite)
-{
-    meshtastic_PositionLite posScratch;
-    meshtastic_DeviceMetrics dmScratch;
-    const meshtastic_PositionLite *pos = (nodeDB && nodeDB->copyNodePosition(lite->num, posScratch)) ? &posScratch : nullptr;
-    const meshtastic_DeviceMetrics *dm = (nodeDB && nodeDB->copyNodeTelemetry(lite->num, dmScratch)) ? &dmScratch : nullptr;
-    return ConvertToNodeInfo(lite, pos, dm);
-}
-
-meshtastic_NodeInfo TypeConversions::ConvertToNodeInfoThin(const meshtastic_NodeInfoLite *lite)
-{
-    return ConvertToNodeInfo(lite, nullptr, nullptr);
-}
-
 meshtastic_PositionLite TypeConversions::ConvertToPositionLite(meshtastic_Position position)
 {
     meshtastic_PositionLite lite = meshtastic_PositionLite_init_default;
@@ -93,50 +77,46 @@ meshtastic_Position TypeConversions::ConvertToPosition(meshtastic_PositionLite l
     return position;
 }
 
-void TypeConversions::CopyUserToNodeInfoLite(meshtastic_NodeInfoLite *lite, const meshtastic_User &user)
+meshtastic_UserLite TypeConversions::ConvertToUserLite(meshtastic_User user)
 {
-    if (!lite)
-        return;
+    meshtastic_UserLite lite = meshtastic_UserLite_init_default;
 
-    strncpy(lite->long_name, user.long_name, sizeof(lite->long_name));
-    lite->long_name[sizeof(lite->long_name) - 1] = '\0';
-    sanitizeUtf8(lite->long_name, sizeof(lite->long_name));
-    strncpy(lite->short_name, user.short_name, sizeof(lite->short_name));
-    lite->short_name[sizeof(lite->short_name) - 1] = '\0';
-    sanitizeUtf8(lite->short_name, sizeof(lite->short_name));
-    lite->hw_model = user.hw_model;
-    lite->role = user.role;
-    memcpy(lite->public_key.bytes, user.public_key.bytes, sizeof(lite->public_key.bytes));
-    lite->public_key.size = user.public_key.size;
-
-    nodeInfoLiteSetBit(lite, NODEINFO_BITFIELD_IS_LICENSED_MASK, user.is_licensed);
-    nodeInfoLiteSetBit(lite, NODEINFO_BITFIELD_HAS_IS_UNMESSAGABLE_MASK, user.has_is_unmessagable);
-    nodeInfoLiteSetBit(lite, NODEINFO_BITFIELD_IS_UNMESSAGABLE_MASK, user.has_is_unmessagable && user.is_unmessagable);
-    nodeInfoLiteSetBit(lite, NODEINFO_BITFIELD_HAS_USER_MASK, true);
+    strncpy(lite.long_name, user.long_name, sizeof(lite.long_name));
+    lite.long_name[sizeof(lite.long_name) - 1] = '\0';
+    sanitizeUtf8(lite.long_name, sizeof(lite.long_name));
+    strncpy(lite.short_name, user.short_name, sizeof(lite.short_name));
+    lite.short_name[sizeof(lite.short_name) - 1] = '\0';
+    sanitizeUtf8(lite.short_name, sizeof(lite.short_name));
+    lite.hw_model = user.hw_model;
+    lite.role = user.role;
+    lite.is_licensed = user.is_licensed;
+    memcpy(lite.macaddr, user.macaddr, sizeof(lite.macaddr));
+    memcpy(lite.public_key.bytes, user.public_key.bytes, sizeof(lite.public_key.bytes));
+    lite.public_key.size = user.public_key.size;
+    lite.has_is_unmessagable = user.has_is_unmessagable;
+    lite.is_unmessagable = user.is_unmessagable;
+    return lite;
 }
 
-meshtastic_User TypeConversions::ConvertToUser(const meshtastic_NodeInfoLite *lite)
+meshtastic_User TypeConversions::ConvertToUser(uint32_t nodeNum, meshtastic_UserLite lite)
 {
     meshtastic_User user = meshtastic_User_init_default;
-    if (!lite)
-        return user;
 
-    snprintf(user.id, sizeof(user.id), "!%08x", lite->num);
-    strncpy(user.long_name, lite->long_name, sizeof(user.long_name));
+    snprintf(user.id, sizeof(user.id), "!%08x", nodeNum);
+    strncpy(user.long_name, lite.long_name, sizeof(user.long_name));
     user.long_name[sizeof(user.long_name) - 1] = '\0';
     sanitizeUtf8(user.long_name, sizeof(user.long_name));
-    strncpy(user.short_name, lite->short_name, sizeof(user.short_name));
+    strncpy(user.short_name, lite.short_name, sizeof(user.short_name));
     user.short_name[sizeof(user.short_name) - 1] = '\0';
     sanitizeUtf8(user.short_name, sizeof(user.short_name));
-    user.hw_model = lite->hw_model;
-    user.role = lite->role;
-    user.is_licensed = nodeInfoLiteIsLicensed(lite);
-    memcpy(user.public_key.bytes, lite->public_key.bytes, sizeof(user.public_key.bytes));
-    user.public_key.size = lite->public_key.size;
-    user.has_is_unmessagable = nodeInfoLiteHasIsUnmessagable(lite);
-    user.is_unmessagable = nodeInfoLiteIsUnmessagable(lite);
-    // macaddr is gone from the slim header; zero-fill for old clients that read it.
-    memset(user.macaddr, 0, sizeof(user.macaddr));
+    user.hw_model = lite.hw_model;
+    user.role = lite.role;
+    user.is_licensed = lite.is_licensed;
+    memcpy(user.macaddr, lite.macaddr, sizeof(user.macaddr));
+    memcpy(user.public_key.bytes, lite.public_key.bytes, sizeof(user.public_key.bytes));
+    user.public_key.size = lite.public_key.size;
+    user.has_is_unmessagable = lite.has_is_unmessagable;
+    user.is_unmessagable = lite.is_unmessagable;
 
     return user;
-}
+}

src/mesh/TypeConversions.h

@@ -7,16 +7,9 @@
 class TypeConversions
 {
   public:
-    // Either pointer may be null; the corresponding has_* fields stay unset.
-    static meshtastic_NodeInfo ConvertToNodeInfo(const meshtastic_NodeInfoLite *lite, const meshtastic_PositionLite *position,
-                                                 const meshtastic_DeviceMetrics *deviceMetrics);
     static meshtastic_NodeInfo ConvertToNodeInfo(const meshtastic_NodeInfoLite *lite);
-    // Identity + link-state only; satellite payloads are replayed afterward.
-    static meshtastic_NodeInfo ConvertToNodeInfoThin(const meshtastic_NodeInfoLite *lite);
-
     static meshtastic_PositionLite ConvertToPositionLite(meshtastic_Position position);
     static meshtastic_Position ConvertToPosition(meshtastic_PositionLite lite);
-
-    static void CopyUserToNodeInfoLite(meshtastic_NodeInfoLite *lite, const meshtastic_User &user);
-    static meshtastic_User ConvertToUser(const meshtastic_NodeInfoLite *lite);
+    static meshtastic_UserLite ConvertToUserLite(meshtastic_User user);
+    static meshtastic_User ConvertToUser(uint32_t nodeNum, meshtastic_UserLite lite);
 };

src/mesh/api/WiFiServerAPI.h

@@ -3,9 +3,8 @@
 #include "ServerAPI.h"
 #include <WiFi.h>
 
-#if HAS_ETHERNET && defined(USE_WS5500)
-#include <ETHClass2.h>
-#define ETH ETH2
+#if HAS_ETHERNET && defined(ARCH_ESP32)
+#include <ETH.h>
 #endif // HAS_ETHERNET
 
 /**